usb: gadget: renesas_usbhs: disable pipe on top of interrupt
[deliverable/linux.git] / drivers / usb / renesas_usbhs / common.c
CommitLineData
f1407d5c
KM
1/*
2 * Renesas USB driver
3 *
4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
15 *
16 */
17#include <linux/io.h>
18#include <linux/module.h>
19#include <linux/pm_runtime.h>
20#include <linux/slab.h>
21#include <linux/sysfs.h>
22#include "./common.h"
23
233f519d
KM
24/*
25 * image of renesas_usbhs
26 *
27 * ex) gadget case
28
29 * mod.c
30 * mod_gadget.c
31 * mod_host.c pipe.c fifo.c
32 *
33 * +-------+ +-----------+
34 * | pipe0 |------>| fifo pio |
35 * +------------+ +-------+ +-----------+
36 * | mod_gadget |=====> | pipe1 |--+
37 * +------------+ +-------+ | +-----------+
38 * | pipe2 | | +-| fifo dma0 |
39 * +------------+ +-------+ | | +-----------+
40 * | mod_host | | pipe3 |<-|--+
41 * +------------+ +-------+ | +-----------+
42 * | .... | +--->| fifo dma1 |
43 * | .... | +-----------+
44 */
45
46
b002ff6e
KM
47#define USBHSF_RUNTIME_PWCTRL (1 << 0)
48
49/* status */
50#define usbhsc_flags_init(p) do {(p)->flags = 0; } while (0)
51#define usbhsc_flags_set(p, b) ((p)->flags |= (b))
52#define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
53#define usbhsc_flags_has(p, b) ((p)->flags & (b))
54
f1407d5c
KM
55/*
56 * platform call back
57 *
58 * renesas usb support platform callback function.
59 * Below macro call it.
60 * if platform doesn't have callback, it return 0 (no error)
61 */
62#define usbhs_platform_call(priv, func, args...)\
63 (!(priv) ? -ENODEV : \
64 !((priv)->pfunc->func) ? 0 : \
65 (priv)->pfunc->func(args))
66
67/*
68 * common functions
69 */
70u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
71{
72 return ioread16(priv->base + reg);
73}
74
75void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
76{
77 iowrite16(data, priv->base + reg);
78}
79
80void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
81{
82 u16 val = usbhs_read(priv, reg);
83
84 val &= ~mask;
85 val |= data & mask;
86
87 usbhs_write(priv, reg, val);
88}
89
206dcc2c
KM
90struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
91{
92 return dev_get_drvdata(&pdev->dev);
93}
94
f1407d5c
KM
95/*
96 * syscfg functions
97 */
98void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
99{
100 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
101}
102
103void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable)
104{
105 usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0);
106}
107
108void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable)
109{
110 usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0);
111}
112
113void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
114{
115 u16 mask = DCFM | DRPD | DPRPU;
116 u16 val = DCFM | DRPD;
117
118 /*
119 * if enable
120 *
121 * - select Host mode
122 * - D+ Line/D- Line Pull-down
123 */
124 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
125}
126
127void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
128{
129 u16 mask = DCFM | DRPD | DPRPU;
130 u16 val = DPRPU;
131
132 /*
133 * if enable
134 *
135 * - select Function mode
136 * - D+ Line Pull-up
137 */
138 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
139}
140
141/*
142 * frame functions
143 */
144int usbhs_frame_get_num(struct usbhs_priv *priv)
145{
146 return usbhs_read(priv, FRMNUM) & FRNM_MASK;
147}
148
ef8bedb9
KM
149/*
150 * usb request functions
151 */
152void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
153{
154 u16 val;
155
156 val = usbhs_read(priv, USBREQ);
157 req->bRequest = (val >> 8) & 0xFF;
158 req->bRequestType = (val >> 0) & 0xFF;
159
160 req->wValue = usbhs_read(priv, USBVAL);
161 req->wIndex = usbhs_read(priv, USBINDX);
162 req->wLength = usbhs_read(priv, USBLENG);
163}
164
165void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
166{
167 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType);
168 usbhs_write(priv, USBVAL, req->wValue);
169 usbhs_write(priv, USBINDX, req->wIndex);
170 usbhs_write(priv, USBLENG, req->wLength);
171
172 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ);
173}
174
258485d9
KM
175/*
176 * bus/vbus functions
177 */
178void usbhs_bus_send_sof_enable(struct usbhs_priv *priv)
179{
180 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT);
181}
182
183void usbhs_bus_send_reset(struct usbhs_priv *priv)
184{
185 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST);
186}
187
75587f52
KM
188int usbhs_bus_get_speed(struct usbhs_priv *priv)
189{
190 u16 dvstctr = usbhs_read(priv, DVSTCTR);
191
192 switch (RHST & dvstctr) {
193 case RHST_LOW_SPEED:
194 return USB_SPEED_LOW;
195 case RHST_FULL_SPEED:
196 return USB_SPEED_FULL;
197 case RHST_HIGH_SPEED:
198 return USB_SPEED_HIGH;
199 }
200
201 return USB_SPEED_UNKNOWN;
202}
203
258485d9
KM
204int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable)
205{
206 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
207
208 return usbhs_platform_call(priv, set_vbus, pdev, enable);
209}
210
211static void usbhsc_bus_init(struct usbhs_priv *priv)
212{
213 usbhs_write(priv, DVSTCTR, 0);
214
215 usbhs_vbus_ctrl(priv, 0);
216}
217
f1407d5c
KM
218/*
219 * local functions
220 */
11935de5 221static void usbhsc_set_buswait(struct usbhs_priv *priv)
f1407d5c
KM
222{
223 int wait = usbhs_get_dparam(priv, buswait_bwait);
f1407d5c 224
11935de5
KM
225 /* set bus wait if platform have */
226 if (wait)
227 usbhs_bset(priv, BUSWAIT, 0x000F, wait);
f1407d5c
KM
228}
229
230/*
231 * platform default param
232 */
233static u32 usbhsc_default_pipe_type[] = {
234 USB_ENDPOINT_XFER_CONTROL,
235 USB_ENDPOINT_XFER_ISOC,
236 USB_ENDPOINT_XFER_ISOC,
237 USB_ENDPOINT_XFER_BULK,
238 USB_ENDPOINT_XFER_BULK,
239 USB_ENDPOINT_XFER_BULK,
240 USB_ENDPOINT_XFER_INT,
241 USB_ENDPOINT_XFER_INT,
242 USB_ENDPOINT_XFER_INT,
243 USB_ENDPOINT_XFER_INT,
244};
245
246/*
6e267da8
KM
247 * power control
248 */
249static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
250{
251 struct device *dev = usbhs_priv_to_dev(priv);
252
253 if (enable) {
254 /* enable PM */
255 pm_runtime_get_sync(dev);
256
257 /* USB on */
258 usbhs_sys_clock_ctrl(priv, enable);
6e267da8
KM
259 } else {
260 /* USB off */
6e267da8
KM
261 usbhs_sys_clock_ctrl(priv, enable);
262
263 /* disable PM */
264 pm_runtime_put_sync(dev);
265 }
266}
267
268/*
ca8a282a 269 * hotplug
f1407d5c 270 */
ca8a282a 271static void usbhsc_hotplug(struct usbhs_priv *priv)
f1407d5c 272{
f1407d5c
KM
273 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
274 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
275 int id;
276 int enable;
277 int ret;
278
279 /*
280 * get vbus status from platform
281 */
282 enable = usbhs_platform_call(priv, get_vbus, pdev);
283
284 /*
285 * get id from platform
286 */
287 id = usbhs_platform_call(priv, get_id, pdev);
288
289 if (enable && !mod) {
290 ret = usbhs_mod_change(priv, id);
291 if (ret < 0)
292 return;
293
294 dev_dbg(&pdev->dev, "%s enable\n", __func__);
295
6e267da8 296 /* power on */
b002ff6e
KM
297 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
298 usbhsc_power_ctrl(priv, enable);
f1407d5c 299
258485d9
KM
300 /* bus init */
301 usbhsc_set_buswait(priv);
302 usbhsc_bus_init(priv);
303
f1407d5c
KM
304 /* module start */
305 usbhs_mod_call(priv, start, priv);
306
307 } else if (!enable && mod) {
308 dev_dbg(&pdev->dev, "%s disable\n", __func__);
309
310 /* module stop */
311 usbhs_mod_call(priv, stop, priv);
312
258485d9
KM
313 /* bus init */
314 usbhsc_bus_init(priv);
315
6e267da8 316 /* power off */
b002ff6e
KM
317 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
318 usbhsc_power_ctrl(priv, enable);
f1407d5c
KM
319
320 usbhs_mod_change(priv, -1);
321
322 /* reset phy for next connection */
323 usbhs_platform_call(priv, phy_reset, pdev);
324 }
325}
326
ca8a282a
KM
327/*
328 * notify hotplug
329 */
330static void usbhsc_notify_hotplug(struct work_struct *work)
331{
332 struct usbhs_priv *priv = container_of(work,
333 struct usbhs_priv,
334 notify_hotplug_work.work);
335 usbhsc_hotplug(priv);
336}
337
bc57381e 338int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
f1407d5c 339{
206dcc2c 340 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
bc57381e 341 int delay = usbhs_get_dparam(priv, detection_delay);
f1407d5c
KM
342
343 /*
344 * This functions will be called in interrupt.
345 * To make sure safety context,
346 * use workqueue for usbhs_notify_hotplug
347 */
bc57381e 348 schedule_delayed_work(&priv->notify_hotplug_work, delay);
f1407d5c
KM
349 return 0;
350}
351
352/*
353 * platform functions
354 */
355static int __devinit usbhs_probe(struct platform_device *pdev)
356{
357 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
358 struct renesas_usbhs_driver_callback *dfunc;
359 struct usbhs_priv *priv;
360 struct resource *res;
361 unsigned int irq;
362 int ret;
363
364 /* check platform information */
365 if (!info ||
b002ff6e 366 !info->platform_callback.get_id) {
f1407d5c
KM
367 dev_err(&pdev->dev, "no platform information\n");
368 return -EINVAL;
369 }
370
371 /* platform data */
372 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
373 irq = platform_get_irq(pdev, 0);
374 if (!res || (int)irq <= 0) {
375 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n");
376 return -ENODEV;
377 }
378
379 /* usb private data */
380 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
381 if (!priv) {
382 dev_err(&pdev->dev, "Could not allocate priv\n");
383 return -ENOMEM;
384 }
385
386 priv->base = ioremap_nocache(res->start, resource_size(res));
387 if (!priv->base) {
388 dev_err(&pdev->dev, "ioremap error.\n");
389 ret = -ENOMEM;
390 goto probe_end_kfree;
391 }
392
393 /*
394 * care platform info
395 */
396 priv->pfunc = &info->platform_callback;
397 priv->dparam = &info->driver_param;
398
399 /* set driver callback functions for platform */
400 dfunc = &info->driver_callback;
401 dfunc->notify_hotplug = usbhsc_drvcllbck_notify_hotplug;
402
403 /* set default param if platform doesn't have */
404 if (!priv->dparam->pipe_type) {
405 priv->dparam->pipe_type = usbhsc_default_pipe_type;
406 priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
407 }
e73a9891
KM
408 if (!priv->dparam->pio_dma_border)
409 priv->dparam->pio_dma_border = 64; /* 64byte */
f1407d5c 410
b002ff6e
KM
411 /* FIXME */
412 /* runtime power control ? */
413 if (priv->pfunc->get_vbus)
414 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
415
f1407d5c
KM
416 /*
417 * priv settings
418 */
419 priv->irq = irq;
420 priv->pdev = pdev;
bc57381e 421 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
f1407d5c
KM
422 spin_lock_init(usbhs_priv_to_lock(priv));
423
424 /* call pipe and module init */
425 ret = usbhs_pipe_probe(priv);
426 if (ret < 0)
97f93227 427 goto probe_end_iounmap;
f1407d5c 428
d3af90a5 429 ret = usbhs_fifo_probe(priv);
f1407d5c 430 if (ret < 0)
97f93227 431 goto probe_end_pipe_exit;
f1407d5c 432
d3af90a5
KM
433 ret = usbhs_mod_probe(priv);
434 if (ret < 0)
435 goto probe_end_fifo_exit;
436
f1407d5c
KM
437 /* dev_set_drvdata should be called after usbhs_mod_init */
438 dev_set_drvdata(&pdev->dev, priv);
439
440 /*
441 * deviece reset here because
442 * USB device might be used in boot loader.
443 */
444 usbhs_sys_clock_ctrl(priv, 0);
445
446 /*
447 * platform call
448 *
449 * USB phy setup might depend on CPU/Board.
450 * If platform has its callback functions,
451 * call it here.
452 */
453 ret = usbhs_platform_call(priv, hardware_init, pdev);
454 if (ret < 0) {
455 dev_err(&pdev->dev, "platform prove failed.\n");
97f93227 456 goto probe_end_mod_exit;
f1407d5c
KM
457 }
458
459 /* reset phy for connection */
460 usbhs_platform_call(priv, phy_reset, pdev);
461
b002ff6e
KM
462 /* power control */
463 pm_runtime_enable(&pdev->dev);
464 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
465 usbhsc_power_ctrl(priv, 1);
466 usbhs_mod_autonomy_mode(priv);
467 }
468
f1407d5c
KM
469 /*
470 * manual call notify_hotplug for cold plug
471 */
f1407d5c
KM
472 ret = usbhsc_drvcllbck_notify_hotplug(pdev);
473 if (ret < 0)
474 goto probe_end_call_remove;
475
476 dev_info(&pdev->dev, "probed\n");
477
478 return ret;
479
480probe_end_call_remove:
481 usbhs_platform_call(priv, hardware_exit, pdev);
f1407d5c
KM
482probe_end_mod_exit:
483 usbhs_mod_remove(priv);
d3af90a5
KM
484probe_end_fifo_exit:
485 usbhs_fifo_remove(priv);
97f93227
KM
486probe_end_pipe_exit:
487 usbhs_pipe_remove(priv);
f1407d5c
KM
488probe_end_iounmap:
489 iounmap(priv->base);
490probe_end_kfree:
491 kfree(priv);
492
493 dev_info(&pdev->dev, "probe failed\n");
494
495 return ret;
496}
497
498static int __devexit usbhs_remove(struct platform_device *pdev)
499{
206dcc2c 500 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
af32fe51
KM
501 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
502 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback;
f1407d5c
KM
503
504 dev_dbg(&pdev->dev, "usb remove\n");
505
af32fe51
KM
506 dfunc->notify_hotplug = NULL;
507
b002ff6e
KM
508 /* power off */
509 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
510 usbhsc_power_ctrl(priv, 0);
f1407d5c 511
b002ff6e 512 pm_runtime_disable(&pdev->dev);
f1407d5c
KM
513
514 usbhs_platform_call(priv, hardware_exit, pdev);
f1407d5c 515 usbhs_mod_remove(priv);
d3af90a5 516 usbhs_fifo_remove(priv);
97f93227 517 usbhs_pipe_remove(priv);
f1407d5c
KM
518 iounmap(priv->base);
519 kfree(priv);
520
521 return 0;
522}
523
ca8a282a
KM
524static int usbhsc_suspend(struct device *dev)
525{
526 struct usbhs_priv *priv = dev_get_drvdata(dev);
527 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
528
529 if (mod) {
530 usbhs_mod_call(priv, stop, priv);
531 usbhs_mod_change(priv, -1);
532 }
533
534 if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
535 usbhsc_power_ctrl(priv, 0);
536
537 return 0;
538}
539
540static int usbhsc_resume(struct device *dev)
541{
542 struct usbhs_priv *priv = dev_get_drvdata(dev);
543 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
544
545 usbhs_platform_call(priv, phy_reset, pdev);
546
547 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
548 usbhsc_power_ctrl(priv, 1);
549
550 usbhsc_hotplug(priv);
551
552 return 0;
553}
554
555static int usbhsc_runtime_nop(struct device *dev)
556{
557 /* Runtime PM callback shared between ->runtime_suspend()
558 * and ->runtime_resume(). Simply returns success.
559 *
560 * This driver re-initializes all registers after
561 * pm_runtime_get_sync() anyway so there is no need
562 * to save and restore registers here.
563 */
564 return 0;
565}
566
567static const struct dev_pm_ops usbhsc_pm_ops = {
568 .suspend = usbhsc_suspend,
569 .resume = usbhsc_resume,
570 .runtime_suspend = usbhsc_runtime_nop,
571 .runtime_resume = usbhsc_runtime_nop,
572};
573
f1407d5c
KM
574static struct platform_driver renesas_usbhs_driver = {
575 .driver = {
576 .name = "renesas_usbhs",
ca8a282a 577 .pm = &usbhsc_pm_ops,
f1407d5c
KM
578 },
579 .probe = usbhs_probe,
580 .remove = __devexit_p(usbhs_remove),
581};
582
583static int __init usbhs_init(void)
584{
585 return platform_driver_register(&renesas_usbhs_driver);
586}
587
588static void __exit usbhs_exit(void)
589{
590 platform_driver_unregister(&renesas_usbhs_driver);
591}
592
593module_init(usbhs_init);
594module_exit(usbhs_exit);
595
596MODULE_LICENSE("GPL");
597MODULE_DESCRIPTION("Renesas USB driver");
598MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
This page took 0.095133 seconds and 5 git commands to generate.