1 // SPDX-License-Identifier: GPL-1.0+
2 /*
3 * Renesas USB driver
4 *
5 * Copyright (C) 2011 Renesas Solutions Corp.
6 * Copyright (C) 2019 Renesas Electronics Corporation
7 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
8 */
9 #include <linux/interrupt.h>
10
11 #include "common.h"
12 #include "mod.h"
13
14 /*
15 * autonomy
16 *
17 * these functions are used if platform doesn't have external phy.
18 * -> there is no "notify_hotplug" callback from platform
19 * -> call "notify_hotplug" by itself
20 * -> use own interrupt to connect/disconnect
21 * -> it mean module clock is always ON
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~
23 */
usbhsm_autonomy_get_vbus(struct platform_device * pdev)24 static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
25 {
26 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
27
28 return VBSTS & usbhs_read(priv, INTSTS0);
29 }
30
usbhsm_autonomy_irq_vbus(struct usbhs_priv * priv,struct usbhs_irq_state * irq_state)31 static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
32 struct usbhs_irq_state *irq_state)
33 {
34 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
35
36 usbhsc_schedule_notify_hotplug(pdev);
37
38 return 0;
39 }
40
usbhs_mod_autonomy_mode(struct usbhs_priv * priv)41 void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
42 {
43 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
44
45 info->irq_vbus = usbhsm_autonomy_irq_vbus;
46 info->get_vbus = usbhsm_autonomy_get_vbus;
47
48 usbhs_irq_callback_update(priv, NULL);
49 }
50
usbhs_mod_non_autonomy_mode(struct usbhs_priv * priv)51 void usbhs_mod_non_autonomy_mode(struct usbhs_priv *priv)
52 {
53 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
54
55 info->get_vbus = priv->pfunc->get_vbus;
56 }
57
58 /*
59 * host / gadget functions
60 *
61 * renesas_usbhs host/gadget can register itself by below functions.
62 * these functions are called when probe
63 *
64 */
usbhs_mod_register(struct usbhs_priv * priv,struct usbhs_mod * mod,int id)65 void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id)
66 {
67 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
68
69 info->mod[id] = mod;
70 mod->priv = priv;
71 }
72
usbhs_mod_get(struct usbhs_priv * priv,int id)73 struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id)
74 {
75 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
76 struct usbhs_mod *ret = NULL;
77
78 switch (id) {
79 case USBHS_HOST:
80 case USBHS_GADGET:
81 ret = info->mod[id];
82 break;
83 }
84
85 return ret;
86 }
87
usbhs_mod_is_host(struct usbhs_priv * priv)88 int usbhs_mod_is_host(struct usbhs_priv *priv)
89 {
90 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
91 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
92
93 if (!mod)
94 return -EINVAL;
95
96 return info->mod[USBHS_HOST] == mod;
97 }
98
usbhs_mod_get_current(struct usbhs_priv * priv)99 struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv)
100 {
101 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
102
103 return info->curt;
104 }
105
usbhs_mod_change(struct usbhs_priv * priv,int id)106 int usbhs_mod_change(struct usbhs_priv *priv, int id)
107 {
108 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
109 struct usbhs_mod *mod = NULL;
110 int ret = 0;
111
112 /* id < 0 mean no current */
113 switch (id) {
114 case USBHS_HOST:
115 case USBHS_GADGET:
116 mod = info->mod[id];
117 break;
118 default:
119 ret = -EINVAL;
120 }
121 info->curt = mod;
122
123 return ret;
124 }
125
126 static irqreturn_t usbhs_interrupt(int irq, void *data);
usbhs_mod_probe(struct usbhs_priv * priv)127 int usbhs_mod_probe(struct usbhs_priv *priv)
128 {
129 struct device *dev = usbhs_priv_to_dev(priv);
130 int ret;
131
132 /*
133 * install host/gadget driver
134 */
135 ret = usbhs_mod_host_probe(priv);
136 if (ret < 0)
137 return ret;
138
139 ret = usbhs_mod_gadget_probe(priv);
140 if (ret < 0)
141 goto mod_init_host_err;
142
143 /* irq settings */
144 ret = devm_request_irq(dev, priv->irq, usbhs_interrupt,
145 priv->irqflags, dev_name(dev), priv);
146 if (ret) {
147 dev_err(dev, "irq request err\n");
148 goto mod_init_gadget_err;
149 }
150
151 return ret;
152
153 mod_init_gadget_err:
154 usbhs_mod_gadget_remove(priv);
155 mod_init_host_err:
156 usbhs_mod_host_remove(priv);
157
158 return ret;
159 }
160
usbhs_mod_remove(struct usbhs_priv * priv)161 void usbhs_mod_remove(struct usbhs_priv *priv)
162 {
163 usbhs_mod_host_remove(priv);
164 usbhs_mod_gadget_remove(priv);
165 }
166
167 /*
168 * status functions
169 */
usbhs_status_get_device_state(struct usbhs_irq_state * irq_state)170 int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
171 {
172 return (int)irq_state->intsts0 & DVSQ_MASK;
173 }
174
usbhs_status_get_ctrl_stage(struct usbhs_irq_state * irq_state)175 int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
176 {
177 /*
178 * return value
179 *
180 * IDLE_SETUP_STAGE
181 * READ_DATA_STAGE
182 * READ_STATUS_STAGE
183 * WRITE_DATA_STAGE
184 * WRITE_STATUS_STAGE
185 * NODATA_STATUS_STAGE
186 * SEQUENCE_ERROR
187 */
188 return (int)irq_state->intsts0 & CTSQ_MASK;
189 }
190
usbhs_status_get_each_irq(struct usbhs_priv * priv,struct usbhs_irq_state * state)191 static int usbhs_status_get_each_irq(struct usbhs_priv *priv,
192 struct usbhs_irq_state *state)
193 {
194 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
195 u16 intenb0, intenb1;
196 unsigned long flags;
197
198 /******************** spin lock ********************/
199 usbhs_lock(priv, flags);
200 state->intsts0 = usbhs_read(priv, INTSTS0);
201 intenb0 = usbhs_read(priv, INTENB0);
202
203 if (usbhs_mod_is_host(priv)) {
204 state->intsts1 = usbhs_read(priv, INTSTS1);
205 intenb1 = usbhs_read(priv, INTENB1);
206 } else {
207 state->intsts1 = intenb1 = 0;
208 }
209
210 /* mask */
211 if (mod) {
212 state->brdysts = usbhs_read(priv, BRDYSTS);
213 state->nrdysts = usbhs_read(priv, NRDYSTS);
214 state->bempsts = usbhs_read(priv, BEMPSTS);
215
216 state->bempsts &= mod->irq_bempsts;
217 state->brdysts &= mod->irq_brdysts;
218 }
219 usbhs_unlock(priv, flags);
220 /******************** spin unlock ******************/
221
222 /*
223 * Check whether the irq enable registers and the irq status are set
224 * when IRQF_SHARED is set.
225 */
226 if (priv->irqflags & IRQF_SHARED) {
227 if (!(intenb0 & state->intsts0) &&
228 !(intenb1 & state->intsts1) &&
229 !(state->bempsts) &&
230 !(state->brdysts))
231 return -EIO;
232 }
233
234 return 0;
235 }
236
237 /*
238 * interrupt
239 */
240 #define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
241 #define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
usbhs_interrupt(int irq,void * data)242 static irqreturn_t usbhs_interrupt(int irq, void *data)
243 {
244 struct usbhs_priv *priv = data;
245 struct usbhs_irq_state irq_state;
246
247 if (usbhs_status_get_each_irq(priv, &irq_state) < 0)
248 return IRQ_NONE;
249
250 /*
251 * clear interrupt
252 *
253 * The hardware is _very_ picky to clear interrupt bit.
254 * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
255 *
256 * see
257 * "Operation"
258 * - "Control Transfer (DCP)"
259 * - Function :: VALID bit should 0
260 */
261 usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
262 if (usbhs_mod_is_host(priv))
263 usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);
264
265 /*
266 * The driver should not clear the xxxSTS after the line of
267 * "call irq callback functions" because each "if" statement is
268 * possible to call the callback function for avoiding any side effects.
269 */
270 if (irq_state.intsts0 & BRDY)
271 usbhs_write(priv, BRDYSTS, ~irq_state.brdysts);
272 usbhs_write(priv, NRDYSTS, ~irq_state.nrdysts);
273 if (irq_state.intsts0 & BEMP)
274 usbhs_write(priv, BEMPSTS, ~irq_state.bempsts);
275
276 /*
277 * call irq callback functions
278 * see also
279 * usbhs_irq_setting_update
280 */
281
282 /* INTSTS0 */
283 if (irq_state.intsts0 & VBINT)
284 usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);
285
286 if (irq_state.intsts0 & DVST)
287 usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);
288
289 if (irq_state.intsts0 & CTRT)
290 usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);
291
292 if (irq_state.intsts0 & BEMP)
293 usbhs_mod_call(priv, irq_empty, priv, &irq_state);
294
295 if (irq_state.intsts0 & BRDY)
296 usbhs_mod_call(priv, irq_ready, priv, &irq_state);
297
298 if (usbhs_mod_is_host(priv)) {
299 /* INTSTS1 */
300 if (irq_state.intsts1 & ATTCH)
301 usbhs_mod_call(priv, irq_attch, priv, &irq_state);
302
303 if (irq_state.intsts1 & DTCH)
304 usbhs_mod_call(priv, irq_dtch, priv, &irq_state);
305
306 if (irq_state.intsts1 & SIGN)
307 usbhs_mod_call(priv, irq_sign, priv, &irq_state);
308
309 if (irq_state.intsts1 & SACK)
310 usbhs_mod_call(priv, irq_sack, priv, &irq_state);
311 }
312 return IRQ_HANDLED;
313 }
314
usbhs_irq_callback_update(struct usbhs_priv * priv,struct usbhs_mod * mod)315 void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod)
316 {
317 u16 intenb0 = 0;
318 u16 intenb1 = 0;
319 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
320
321 /*
322 * BEMPENB/BRDYENB are picky.
323 * below method is required
324 *
325 * - clear INTSTS0
326 * - update BEMPENB/BRDYENB
327 * - update INTSTS0
328 */
329 usbhs_write(priv, INTENB0, 0);
330 if (usbhs_mod_is_host(priv))
331 usbhs_write(priv, INTENB1, 0);
332
333 usbhs_write(priv, BEMPENB, 0);
334 usbhs_write(priv, BRDYENB, 0);
335
336 /*
337 * see also
338 * usbhs_interrupt
339 */
340
341 if (info->irq_vbus)
342 intenb0 |= VBSE;
343
344 if (mod) {
345 /*
346 * INTSTS0
347 */
348 if (mod->irq_ctrl_stage)
349 intenb0 |= CTRE;
350
351 if (mod->irq_dev_state)
352 intenb0 |= DVSE;
353
354 if (mod->irq_empty && mod->irq_bempsts) {
355 usbhs_write(priv, BEMPENB, mod->irq_bempsts);
356 intenb0 |= BEMPE;
357 }
358
359 if (mod->irq_ready && mod->irq_brdysts) {
360 usbhs_write(priv, BRDYENB, mod->irq_brdysts);
361 intenb0 |= BRDYE;
362 }
363
364 if (usbhs_mod_is_host(priv)) {
365 /*
366 * INTSTS1
367 */
368 if (mod->irq_attch)
369 intenb1 |= ATTCHE;
370
371 if (mod->irq_dtch)
372 intenb1 |= DTCHE;
373
374 if (mod->irq_sign)
375 intenb1 |= SIGNE;
376
377 if (mod->irq_sack)
378 intenb1 |= SACKE;
379 }
380 }
381
382 if (intenb0)
383 usbhs_write(priv, INTENB0, intenb0);
384
385 if (usbhs_mod_is_host(priv) && intenb1)
386 usbhs_write(priv, INTENB1, intenb1);
387 }
388