Merge tag 'fixes-for-v3.8-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi...
[~shefty/rdma-dev.git] / drivers / usb / otg / mv_otg.c
1 /*
2  * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
3  * Author: Chao Xie <chao.xie@marvell.com>
4  *         Neil Zhang <zhangwm@marvell.com>
5  *
6  * This program is free software; you can redistribute  it and/or modify it
7  * under  the terms of  the GNU General  Public License as published by the
8  * Free Software Foundation;  either version 2 of the  License, or (at your
9  * option) any later version.
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/io.h>
16 #include <linux/uaccess.h>
17 #include <linux/device.h>
18 #include <linux/proc_fs.h>
19 #include <linux/clk.h>
20 #include <linux/workqueue.h>
21 #include <linux/platform_device.h>
22
23 #include <linux/usb.h>
24 #include <linux/usb/ch9.h>
25 #include <linux/usb/otg.h>
26 #include <linux/usb/gadget.h>
27 #include <linux/usb/hcd.h>
28 #include <linux/platform_data/mv_usb.h>
29
30 #include "mv_otg.h"
31
32 #define DRIVER_DESC     "Marvell USB OTG transceiver driver"
33 #define DRIVER_VERSION  "Jan 20, 2010"
34
35 MODULE_DESCRIPTION(DRIVER_DESC);
36 MODULE_VERSION(DRIVER_VERSION);
37 MODULE_LICENSE("GPL");
38
39 static const char driver_name[] = "mv-otg";
40
41 static char *state_string[] = {
42         "undefined",
43         "b_idle",
44         "b_srp_init",
45         "b_peripheral",
46         "b_wait_acon",
47         "b_host",
48         "a_idle",
49         "a_wait_vrise",
50         "a_wait_bcon",
51         "a_host",
52         "a_suspend",
53         "a_peripheral",
54         "a_wait_vfall",
55         "a_vbus_err"
56 };
57
58 static int mv_otg_set_vbus(struct usb_otg *otg, bool on)
59 {
60         struct mv_otg *mvotg = container_of(otg->phy, struct mv_otg, phy);
61         if (mvotg->pdata->set_vbus == NULL)
62                 return -ENODEV;
63
64         return mvotg->pdata->set_vbus(on);
65 }
66
67 static int mv_otg_set_host(struct usb_otg *otg,
68                            struct usb_bus *host)
69 {
70         otg->host = host;
71
72         return 0;
73 }
74
75 static int mv_otg_set_peripheral(struct usb_otg *otg,
76                                  struct usb_gadget *gadget)
77 {
78         otg->gadget = gadget;
79
80         return 0;
81 }
82
83 static void mv_otg_run_state_machine(struct mv_otg *mvotg,
84                                      unsigned long delay)
85 {
86         dev_dbg(&mvotg->pdev->dev, "transceiver is updated\n");
87         if (!mvotg->qwork)
88                 return;
89
90         queue_delayed_work(mvotg->qwork, &mvotg->work, delay);
91 }
92
93 static void mv_otg_timer_await_bcon(unsigned long data)
94 {
95         struct mv_otg *mvotg = (struct mv_otg *) data;
96
97         mvotg->otg_ctrl.a_wait_bcon_timeout = 1;
98
99         dev_info(&mvotg->pdev->dev, "B Device No Response!\n");
100
101         if (spin_trylock(&mvotg->wq_lock)) {
102                 mv_otg_run_state_machine(mvotg, 0);
103                 spin_unlock(&mvotg->wq_lock);
104         }
105 }
106
107 static int mv_otg_cancel_timer(struct mv_otg *mvotg, unsigned int id)
108 {
109         struct timer_list *timer;
110
111         if (id >= OTG_TIMER_NUM)
112                 return -EINVAL;
113
114         timer = &mvotg->otg_ctrl.timer[id];
115
116         if (timer_pending(timer))
117                 del_timer(timer);
118
119         return 0;
120 }
121
122 static int mv_otg_set_timer(struct mv_otg *mvotg, unsigned int id,
123                             unsigned long interval,
124                             void (*callback) (unsigned long))
125 {
126         struct timer_list *timer;
127
128         if (id >= OTG_TIMER_NUM)
129                 return -EINVAL;
130
131         timer = &mvotg->otg_ctrl.timer[id];
132         if (timer_pending(timer)) {
133                 dev_err(&mvotg->pdev->dev, "Timer%d is already running\n", id);
134                 return -EBUSY;
135         }
136
137         init_timer(timer);
138         timer->data = (unsigned long) mvotg;
139         timer->function = callback;
140         timer->expires = jiffies + interval;
141         add_timer(timer);
142
143         return 0;
144 }
145
146 static int mv_otg_reset(struct mv_otg *mvotg)
147 {
148         unsigned int loops;
149         u32 tmp;
150
151         /* Stop the controller */
152         tmp = readl(&mvotg->op_regs->usbcmd);
153         tmp &= ~USBCMD_RUN_STOP;
154         writel(tmp, &mvotg->op_regs->usbcmd);
155
156         /* Reset the controller to get default values */
157         writel(USBCMD_CTRL_RESET, &mvotg->op_regs->usbcmd);
158
159         loops = 500;
160         while (readl(&mvotg->op_regs->usbcmd) & USBCMD_CTRL_RESET) {
161                 if (loops == 0) {
162                         dev_err(&mvotg->pdev->dev,
163                                 "Wait for RESET completed TIMEOUT\n");
164                         return -ETIMEDOUT;
165                 }
166                 loops--;
167                 udelay(20);
168         }
169
170         writel(0x0, &mvotg->op_regs->usbintr);
171         tmp = readl(&mvotg->op_regs->usbsts);
172         writel(tmp, &mvotg->op_regs->usbsts);
173
174         return 0;
175 }
176
177 static void mv_otg_init_irq(struct mv_otg *mvotg)
178 {
179         u32 otgsc;
180
181         mvotg->irq_en = OTGSC_INTR_A_SESSION_VALID
182             | OTGSC_INTR_A_VBUS_VALID;
183         mvotg->irq_status = OTGSC_INTSTS_A_SESSION_VALID
184             | OTGSC_INTSTS_A_VBUS_VALID;
185
186         if (mvotg->pdata->vbus == NULL) {
187                 mvotg->irq_en |= OTGSC_INTR_B_SESSION_VALID
188                     | OTGSC_INTR_B_SESSION_END;
189                 mvotg->irq_status |= OTGSC_INTSTS_B_SESSION_VALID
190                     | OTGSC_INTSTS_B_SESSION_END;
191         }
192
193         if (mvotg->pdata->id == NULL) {
194                 mvotg->irq_en |= OTGSC_INTR_USB_ID;
195                 mvotg->irq_status |= OTGSC_INTSTS_USB_ID;
196         }
197
198         otgsc = readl(&mvotg->op_regs->otgsc);
199         otgsc |= mvotg->irq_en;
200         writel(otgsc, &mvotg->op_regs->otgsc);
201 }
202
203 static void mv_otg_start_host(struct mv_otg *mvotg, int on)
204 {
205 #ifdef CONFIG_USB
206         struct usb_otg *otg = mvotg->phy.otg;
207         struct usb_hcd *hcd;
208
209         if (!otg->host)
210                 return;
211
212         dev_info(&mvotg->pdev->dev, "%s host\n", on ? "start" : "stop");
213
214         hcd = bus_to_hcd(otg->host);
215
216         if (on)
217                 usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
218         else
219                 usb_remove_hcd(hcd);
220 #endif /* CONFIG_USB */
221 }
222
223 static void mv_otg_start_periphrals(struct mv_otg *mvotg, int on)
224 {
225         struct usb_otg *otg = mvotg->phy.otg;
226
227         if (!otg->gadget)
228                 return;
229
230         dev_info(mvotg->phy.dev, "gadget %s\n", on ? "on" : "off");
231
232         if (on)
233                 usb_gadget_vbus_connect(otg->gadget);
234         else
235                 usb_gadget_vbus_disconnect(otg->gadget);
236 }
237
238 static void otg_clock_enable(struct mv_otg *mvotg)
239 {
240         unsigned int i;
241
242         for (i = 0; i < mvotg->clknum; i++)
243                 clk_prepare_enable(mvotg->clk[i]);
244 }
245
246 static void otg_clock_disable(struct mv_otg *mvotg)
247 {
248         unsigned int i;
249
250         for (i = 0; i < mvotg->clknum; i++)
251                 clk_disable_unprepare(mvotg->clk[i]);
252 }
253
254 static int mv_otg_enable_internal(struct mv_otg *mvotg)
255 {
256         int retval = 0;
257
258         if (mvotg->active)
259                 return 0;
260
261         dev_dbg(&mvotg->pdev->dev, "otg enabled\n");
262
263         otg_clock_enable(mvotg);
264         if (mvotg->pdata->phy_init) {
265                 retval = mvotg->pdata->phy_init(mvotg->phy_regs);
266                 if (retval) {
267                         dev_err(&mvotg->pdev->dev,
268                                 "init phy error %d\n", retval);
269                         otg_clock_disable(mvotg);
270                         return retval;
271                 }
272         }
273         mvotg->active = 1;
274
275         return 0;
276
277 }
278
279 static int mv_otg_enable(struct mv_otg *mvotg)
280 {
281         if (mvotg->clock_gating)
282                 return mv_otg_enable_internal(mvotg);
283
284         return 0;
285 }
286
287 static void mv_otg_disable_internal(struct mv_otg *mvotg)
288 {
289         if (mvotg->active) {
290                 dev_dbg(&mvotg->pdev->dev, "otg disabled\n");
291                 if (mvotg->pdata->phy_deinit)
292                         mvotg->pdata->phy_deinit(mvotg->phy_regs);
293                 otg_clock_disable(mvotg);
294                 mvotg->active = 0;
295         }
296 }
297
298 static void mv_otg_disable(struct mv_otg *mvotg)
299 {
300         if (mvotg->clock_gating)
301                 mv_otg_disable_internal(mvotg);
302 }
303
304 static void mv_otg_update_inputs(struct mv_otg *mvotg)
305 {
306         struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl;
307         u32 otgsc;
308
309         otgsc = readl(&mvotg->op_regs->otgsc);
310
311         if (mvotg->pdata->vbus) {
312                 if (mvotg->pdata->vbus->poll() == VBUS_HIGH) {
313                         otg_ctrl->b_sess_vld = 1;
314                         otg_ctrl->b_sess_end = 0;
315                 } else {
316                         otg_ctrl->b_sess_vld = 0;
317                         otg_ctrl->b_sess_end = 1;
318                 }
319         } else {
320                 otg_ctrl->b_sess_vld = !!(otgsc & OTGSC_STS_B_SESSION_VALID);
321                 otg_ctrl->b_sess_end = !!(otgsc & OTGSC_STS_B_SESSION_END);
322         }
323
324         if (mvotg->pdata->id)
325                 otg_ctrl->id = !!mvotg->pdata->id->poll();
326         else
327                 otg_ctrl->id = !!(otgsc & OTGSC_STS_USB_ID);
328
329         if (mvotg->pdata->otg_force_a_bus_req && !otg_ctrl->id)
330                 otg_ctrl->a_bus_req = 1;
331
332         otg_ctrl->a_sess_vld = !!(otgsc & OTGSC_STS_A_SESSION_VALID);
333         otg_ctrl->a_vbus_vld = !!(otgsc & OTGSC_STS_A_VBUS_VALID);
334
335         dev_dbg(&mvotg->pdev->dev, "%s: ", __func__);
336         dev_dbg(&mvotg->pdev->dev, "id %d\n", otg_ctrl->id);
337         dev_dbg(&mvotg->pdev->dev, "b_sess_vld %d\n", otg_ctrl->b_sess_vld);
338         dev_dbg(&mvotg->pdev->dev, "b_sess_end %d\n", otg_ctrl->b_sess_end);
339         dev_dbg(&mvotg->pdev->dev, "a_vbus_vld %d\n", otg_ctrl->a_vbus_vld);
340         dev_dbg(&mvotg->pdev->dev, "a_sess_vld %d\n", otg_ctrl->a_sess_vld);
341 }
342
343 static void mv_otg_update_state(struct mv_otg *mvotg)
344 {
345         struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl;
346         struct usb_phy *phy = &mvotg->phy;
347         int old_state = phy->state;
348
349         switch (old_state) {
350         case OTG_STATE_UNDEFINED:
351                 phy->state = OTG_STATE_B_IDLE;
352                 /* FALL THROUGH */
353         case OTG_STATE_B_IDLE:
354                 if (otg_ctrl->id == 0)
355                         phy->state = OTG_STATE_A_IDLE;
356                 else if (otg_ctrl->b_sess_vld)
357                         phy->state = OTG_STATE_B_PERIPHERAL;
358                 break;
359         case OTG_STATE_B_PERIPHERAL:
360                 if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0)
361                         phy->state = OTG_STATE_B_IDLE;
362                 break;
363         case OTG_STATE_A_IDLE:
364                 if (otg_ctrl->id)
365                         phy->state = OTG_STATE_B_IDLE;
366                 else if (!(otg_ctrl->a_bus_drop) &&
367                          (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det))
368                         phy->state = OTG_STATE_A_WAIT_VRISE;
369                 break;
370         case OTG_STATE_A_WAIT_VRISE:
371                 if (otg_ctrl->a_vbus_vld)
372                         phy->state = OTG_STATE_A_WAIT_BCON;
373                 break;
374         case OTG_STATE_A_WAIT_BCON:
375                 if (otg_ctrl->id || otg_ctrl->a_bus_drop
376                     || otg_ctrl->a_wait_bcon_timeout) {
377                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
378                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
379                         phy->state = OTG_STATE_A_WAIT_VFALL;
380                         otg_ctrl->a_bus_req = 0;
381                 } else if (!otg_ctrl->a_vbus_vld) {
382                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
383                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
384                         phy->state = OTG_STATE_A_VBUS_ERR;
385                 } else if (otg_ctrl->b_conn) {
386                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
387                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
388                         phy->state = OTG_STATE_A_HOST;
389                 }
390                 break;
391         case OTG_STATE_A_HOST:
392                 if (otg_ctrl->id || !otg_ctrl->b_conn
393                     || otg_ctrl->a_bus_drop)
394                         phy->state = OTG_STATE_A_WAIT_BCON;
395                 else if (!otg_ctrl->a_vbus_vld)
396                         phy->state = OTG_STATE_A_VBUS_ERR;
397                 break;
398         case OTG_STATE_A_WAIT_VFALL:
399                 if (otg_ctrl->id
400                     || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld)
401                     || otg_ctrl->a_bus_req)
402                         phy->state = OTG_STATE_A_IDLE;
403                 break;
404         case OTG_STATE_A_VBUS_ERR:
405                 if (otg_ctrl->id || otg_ctrl->a_clr_err
406                     || otg_ctrl->a_bus_drop) {
407                         otg_ctrl->a_clr_err = 0;
408                         phy->state = OTG_STATE_A_WAIT_VFALL;
409                 }
410                 break;
411         default:
412                 break;
413         }
414 }
415
416 static void mv_otg_work(struct work_struct *work)
417 {
418         struct mv_otg *mvotg;
419         struct usb_phy *phy;
420         struct usb_otg *otg;
421         int old_state;
422
423         mvotg = container_of((struct delayed_work *)work, struct mv_otg, work);
424
425 run:
426         /* work queue is single thread, or we need spin_lock to protect */
427         phy = &mvotg->phy;
428         otg = phy->otg;
429         old_state = phy->state;
430
431         if (!mvotg->active)
432                 return;
433
434         mv_otg_update_inputs(mvotg);
435         mv_otg_update_state(mvotg);
436
437         if (old_state != phy->state) {
438                 dev_info(&mvotg->pdev->dev, "change from state %s to %s\n",
439                          state_string[old_state],
440                          state_string[phy->state]);
441
442                 switch (phy->state) {
443                 case OTG_STATE_B_IDLE:
444                         otg->default_a = 0;
445                         if (old_state == OTG_STATE_B_PERIPHERAL)
446                                 mv_otg_start_periphrals(mvotg, 0);
447                         mv_otg_reset(mvotg);
448                         mv_otg_disable(mvotg);
449                         break;
450                 case OTG_STATE_B_PERIPHERAL:
451                         mv_otg_enable(mvotg);
452                         mv_otg_start_periphrals(mvotg, 1);
453                         break;
454                 case OTG_STATE_A_IDLE:
455                         otg->default_a = 1;
456                         mv_otg_enable(mvotg);
457                         if (old_state == OTG_STATE_A_WAIT_VFALL)
458                                 mv_otg_start_host(mvotg, 0);
459                         mv_otg_reset(mvotg);
460                         break;
461                 case OTG_STATE_A_WAIT_VRISE:
462                         mv_otg_set_vbus(otg, 1);
463                         break;
464                 case OTG_STATE_A_WAIT_BCON:
465                         if (old_state != OTG_STATE_A_HOST)
466                                 mv_otg_start_host(mvotg, 1);
467                         mv_otg_set_timer(mvotg, A_WAIT_BCON_TIMER,
468                                          T_A_WAIT_BCON,
469                                          mv_otg_timer_await_bcon);
470                         /*
471                          * Now, we directly enter A_HOST. So set b_conn = 1
472                          * here. In fact, it need host driver to notify us.
473                          */
474                         mvotg->otg_ctrl.b_conn = 1;
475                         break;
476                 case OTG_STATE_A_HOST:
477                         break;
478                 case OTG_STATE_A_WAIT_VFALL:
479                         /*
480                          * Now, we has exited A_HOST. So set b_conn = 0
481                          * here. In fact, it need host driver to notify us.
482                          */
483                         mvotg->otg_ctrl.b_conn = 0;
484                         mv_otg_set_vbus(otg, 0);
485                         break;
486                 case OTG_STATE_A_VBUS_ERR:
487                         break;
488                 default:
489                         break;
490                 }
491                 goto run;
492         }
493 }
494
495 static irqreturn_t mv_otg_irq(int irq, void *dev)
496 {
497         struct mv_otg *mvotg = dev;
498         u32 otgsc;
499
500         otgsc = readl(&mvotg->op_regs->otgsc);
501         writel(otgsc, &mvotg->op_regs->otgsc);
502
503         /*
504          * if we have vbus, then the vbus detection for B-device
505          * will be done by mv_otg_inputs_irq().
506          */
507         if (mvotg->pdata->vbus)
508                 if ((otgsc & OTGSC_STS_USB_ID) &&
509                     !(otgsc & OTGSC_INTSTS_USB_ID))
510                         return IRQ_NONE;
511
512         if ((otgsc & mvotg->irq_status) == 0)
513                 return IRQ_NONE;
514
515         mv_otg_run_state_machine(mvotg, 0);
516
517         return IRQ_HANDLED;
518 }
519
520 static irqreturn_t mv_otg_inputs_irq(int irq, void *dev)
521 {
522         struct mv_otg *mvotg = dev;
523
524         /* The clock may disabled at this time */
525         if (!mvotg->active) {
526                 mv_otg_enable(mvotg);
527                 mv_otg_init_irq(mvotg);
528         }
529
530         mv_otg_run_state_machine(mvotg, 0);
531
532         return IRQ_HANDLED;
533 }
534
535 static ssize_t
536 get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
537 {
538         struct mv_otg *mvotg = dev_get_drvdata(dev);
539         return scnprintf(buf, PAGE_SIZE, "%d\n",
540                          mvotg->otg_ctrl.a_bus_req);
541 }
542
543 static ssize_t
544 set_a_bus_req(struct device *dev, struct device_attribute *attr,
545               const char *buf, size_t count)
546 {
547         struct mv_otg *mvotg = dev_get_drvdata(dev);
548
549         if (count > 2)
550                 return -1;
551
552         /* We will use this interface to change to A device */
553         if (mvotg->phy.state != OTG_STATE_B_IDLE
554             && mvotg->phy.state != OTG_STATE_A_IDLE)
555                 return -1;
556
557         /* The clock may disabled and we need to set irq for ID detected */
558         mv_otg_enable(mvotg);
559         mv_otg_init_irq(mvotg);
560
561         if (buf[0] == '1') {
562                 mvotg->otg_ctrl.a_bus_req = 1;
563                 mvotg->otg_ctrl.a_bus_drop = 0;
564                 dev_dbg(&mvotg->pdev->dev,
565                         "User request: a_bus_req = 1\n");
566
567                 if (spin_trylock(&mvotg->wq_lock)) {
568                         mv_otg_run_state_machine(mvotg, 0);
569                         spin_unlock(&mvotg->wq_lock);
570                 }
571         }
572
573         return count;
574 }
575
576 static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req,
577                    set_a_bus_req);
578
579 static ssize_t
580 set_a_clr_err(struct device *dev, struct device_attribute *attr,
581               const char *buf, size_t count)
582 {
583         struct mv_otg *mvotg = dev_get_drvdata(dev);
584         if (!mvotg->phy.otg->default_a)
585                 return -1;
586
587         if (count > 2)
588                 return -1;
589
590         if (buf[0] == '1') {
591                 mvotg->otg_ctrl.a_clr_err = 1;
592                 dev_dbg(&mvotg->pdev->dev,
593                         "User request: a_clr_err = 1\n");
594         }
595
596         if (spin_trylock(&mvotg->wq_lock)) {
597                 mv_otg_run_state_machine(mvotg, 0);
598                 spin_unlock(&mvotg->wq_lock);
599         }
600
601         return count;
602 }
603
604 static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
605
606 static ssize_t
607 get_a_bus_drop(struct device *dev, struct device_attribute *attr,
608                char *buf)
609 {
610         struct mv_otg *mvotg = dev_get_drvdata(dev);
611         return scnprintf(buf, PAGE_SIZE, "%d\n",
612                          mvotg->otg_ctrl.a_bus_drop);
613 }
614
615 static ssize_t
616 set_a_bus_drop(struct device *dev, struct device_attribute *attr,
617                const char *buf, size_t count)
618 {
619         struct mv_otg *mvotg = dev_get_drvdata(dev);
620         if (!mvotg->phy.otg->default_a)
621                 return -1;
622
623         if (count > 2)
624                 return -1;
625
626         if (buf[0] == '0') {
627                 mvotg->otg_ctrl.a_bus_drop = 0;
628                 dev_dbg(&mvotg->pdev->dev,
629                         "User request: a_bus_drop = 0\n");
630         } else if (buf[0] == '1') {
631                 mvotg->otg_ctrl.a_bus_drop = 1;
632                 mvotg->otg_ctrl.a_bus_req = 0;
633                 dev_dbg(&mvotg->pdev->dev,
634                         "User request: a_bus_drop = 1\n");
635                 dev_dbg(&mvotg->pdev->dev,
636                         "User request: and a_bus_req = 0\n");
637         }
638
639         if (spin_trylock(&mvotg->wq_lock)) {
640                 mv_otg_run_state_machine(mvotg, 0);
641                 spin_unlock(&mvotg->wq_lock);
642         }
643
644         return count;
645 }
646
647 static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR,
648                    get_a_bus_drop, set_a_bus_drop);
649
650 static struct attribute *inputs_attrs[] = {
651         &dev_attr_a_bus_req.attr,
652         &dev_attr_a_clr_err.attr,
653         &dev_attr_a_bus_drop.attr,
654         NULL,
655 };
656
657 static struct attribute_group inputs_attr_group = {
658         .name = "inputs",
659         .attrs = inputs_attrs,
660 };
661
662 int mv_otg_remove(struct platform_device *pdev)
663 {
664         struct mv_otg *mvotg = platform_get_drvdata(pdev);
665         int clk_i;
666
667         sysfs_remove_group(&mvotg->pdev->dev.kobj, &inputs_attr_group);
668
669         if (mvotg->irq)
670                 free_irq(mvotg->irq, mvotg);
671
672         if (mvotg->pdata->vbus)
673                 free_irq(mvotg->pdata->vbus->irq, mvotg);
674         if (mvotg->pdata->id)
675                 free_irq(mvotg->pdata->id->irq, mvotg);
676
677         if (mvotg->qwork) {
678                 flush_workqueue(mvotg->qwork);
679                 destroy_workqueue(mvotg->qwork);
680         }
681
682         mv_otg_disable(mvotg);
683
684         if (mvotg->cap_regs)
685                 iounmap(mvotg->cap_regs);
686
687         if (mvotg->phy_regs)
688                 iounmap(mvotg->phy_regs);
689
690         for (clk_i = 0; clk_i <= mvotg->clknum; clk_i++)
691                 clk_put(mvotg->clk[clk_i]);
692
693         usb_remove_phy(&mvotg->phy);
694         platform_set_drvdata(pdev, NULL);
695
696         kfree(mvotg->phy.otg);
697         kfree(mvotg);
698
699         return 0;
700 }
701
702 static int mv_otg_probe(struct platform_device *pdev)
703 {
704         struct mv_usb_platform_data *pdata = pdev->dev.platform_data;
705         struct mv_otg *mvotg;
706         struct usb_otg *otg;
707         struct resource *r;
708         int retval = 0, clk_i, i;
709         size_t size;
710
711         if (pdata == NULL) {
712                 dev_err(&pdev->dev, "failed to get platform data\n");
713                 return -ENODEV;
714         }
715
716         size = sizeof(*mvotg) + sizeof(struct clk *) * pdata->clknum;
717         mvotg = kzalloc(size, GFP_KERNEL);
718         if (!mvotg) {
719                 dev_err(&pdev->dev, "failed to allocate memory!\n");
720                 return -ENOMEM;
721         }
722
723         otg = kzalloc(sizeof *otg, GFP_KERNEL);
724         if (!otg) {
725                 kfree(mvotg);
726                 return -ENOMEM;
727         }
728
729         platform_set_drvdata(pdev, mvotg);
730
731         mvotg->pdev = pdev;
732         mvotg->pdata = pdata;
733
734         mvotg->clknum = pdata->clknum;
735         for (clk_i = 0; clk_i < mvotg->clknum; clk_i++) {
736                 mvotg->clk[clk_i] = clk_get(&pdev->dev, pdata->clkname[clk_i]);
737                 if (IS_ERR(mvotg->clk[clk_i])) {
738                         retval = PTR_ERR(mvotg->clk[clk_i]);
739                         goto err_put_clk;
740                 }
741         }
742
743         mvotg->qwork = create_singlethread_workqueue("mv_otg_queue");
744         if (!mvotg->qwork) {
745                 dev_dbg(&pdev->dev, "cannot create workqueue for OTG\n");
746                 retval = -ENOMEM;
747                 goto err_put_clk;
748         }
749
750         INIT_DELAYED_WORK(&mvotg->work, mv_otg_work);
751
752         /* OTG common part */
753         mvotg->pdev = pdev;
754         mvotg->phy.dev = &pdev->dev;
755         mvotg->phy.otg = otg;
756         mvotg->phy.label = driver_name;
757         mvotg->phy.state = OTG_STATE_UNDEFINED;
758
759         otg->phy = &mvotg->phy;
760         otg->set_host = mv_otg_set_host;
761         otg->set_peripheral = mv_otg_set_peripheral;
762         otg->set_vbus = mv_otg_set_vbus;
763
764         for (i = 0; i < OTG_TIMER_NUM; i++)
765                 init_timer(&mvotg->otg_ctrl.timer[i]);
766
767         r = platform_get_resource_byname(mvotg->pdev,
768                                          IORESOURCE_MEM, "phyregs");
769         if (r == NULL) {
770                 dev_err(&pdev->dev, "no phy I/O memory resource defined\n");
771                 retval = -ENODEV;
772                 goto err_destroy_workqueue;
773         }
774
775         mvotg->phy_regs = ioremap(r->start, resource_size(r));
776         if (mvotg->phy_regs == NULL) {
777                 dev_err(&pdev->dev, "failed to map phy I/O memory\n");
778                 retval = -EFAULT;
779                 goto err_destroy_workqueue;
780         }
781
782         r = platform_get_resource_byname(mvotg->pdev,
783                                          IORESOURCE_MEM, "capregs");
784         if (r == NULL) {
785                 dev_err(&pdev->dev, "no I/O memory resource defined\n");
786                 retval = -ENODEV;
787                 goto err_unmap_phyreg;
788         }
789
790         mvotg->cap_regs = ioremap(r->start, resource_size(r));
791         if (mvotg->cap_regs == NULL) {
792                 dev_err(&pdev->dev, "failed to map I/O memory\n");
793                 retval = -EFAULT;
794                 goto err_unmap_phyreg;
795         }
796
797         /* we will acces controller register, so enable the udc controller */
798         retval = mv_otg_enable_internal(mvotg);
799         if (retval) {
800                 dev_err(&pdev->dev, "mv otg enable error %d\n", retval);
801                 goto err_unmap_capreg;
802         }
803
804         mvotg->op_regs =
805                 (struct mv_otg_regs __iomem *) ((unsigned long) mvotg->cap_regs
806                         + (readl(mvotg->cap_regs) & CAPLENGTH_MASK));
807
808         if (pdata->id) {
809                 retval = request_threaded_irq(pdata->id->irq, NULL,
810                                               mv_otg_inputs_irq,
811                                               IRQF_ONESHOT, "id", mvotg);
812                 if (retval) {
813                         dev_info(&pdev->dev,
814                                  "Failed to request irq for ID\n");
815                         pdata->id = NULL;
816                 }
817         }
818
819         if (pdata->vbus) {
820                 mvotg->clock_gating = 1;
821                 retval = request_threaded_irq(pdata->vbus->irq, NULL,
822                                               mv_otg_inputs_irq,
823                                               IRQF_ONESHOT, "vbus", mvotg);
824                 if (retval) {
825                         dev_info(&pdev->dev,
826                                  "Failed to request irq for VBUS, "
827                                  "disable clock gating\n");
828                         mvotg->clock_gating = 0;
829                         pdata->vbus = NULL;
830                 }
831         }
832
833         if (pdata->disable_otg_clock_gating)
834                 mvotg->clock_gating = 0;
835
836         mv_otg_reset(mvotg);
837         mv_otg_init_irq(mvotg);
838
839         r = platform_get_resource(mvotg->pdev, IORESOURCE_IRQ, 0);
840         if (r == NULL) {
841                 dev_err(&pdev->dev, "no IRQ resource defined\n");
842                 retval = -ENODEV;
843                 goto err_disable_clk;
844         }
845
846         mvotg->irq = r->start;
847         if (request_irq(mvotg->irq, mv_otg_irq, IRQF_SHARED,
848                         driver_name, mvotg)) {
849                 dev_err(&pdev->dev, "Request irq %d for OTG failed\n",
850                         mvotg->irq);
851                 mvotg->irq = 0;
852                 retval = -ENODEV;
853                 goto err_disable_clk;
854         }
855
856         retval = usb_add_phy(&mvotg->phy, USB_PHY_TYPE_USB2);
857         if (retval < 0) {
858                 dev_err(&pdev->dev, "can't register transceiver, %d\n",
859                         retval);
860                 goto err_free_irq;
861         }
862
863         retval = sysfs_create_group(&pdev->dev.kobj, &inputs_attr_group);
864         if (retval < 0) {
865                 dev_dbg(&pdev->dev,
866                         "Can't register sysfs attr group: %d\n", retval);
867                 goto err_set_transceiver;
868         }
869
870         spin_lock_init(&mvotg->wq_lock);
871         if (spin_trylock(&mvotg->wq_lock)) {
872                 mv_otg_run_state_machine(mvotg, 2 * HZ);
873                 spin_unlock(&mvotg->wq_lock);
874         }
875
876         dev_info(&pdev->dev,
877                  "successful probe OTG device %s clock gating.\n",
878                  mvotg->clock_gating ? "with" : "without");
879
880         return 0;
881
882 err_set_transceiver:
883         usb_remove_phy(&mvotg->phy);
884 err_free_irq:
885         free_irq(mvotg->irq, mvotg);
886 err_disable_clk:
887         if (pdata->vbus)
888                 free_irq(pdata->vbus->irq, mvotg);
889         if (pdata->id)
890                 free_irq(pdata->id->irq, mvotg);
891         mv_otg_disable_internal(mvotg);
892 err_unmap_capreg:
893         iounmap(mvotg->cap_regs);
894 err_unmap_phyreg:
895         iounmap(mvotg->phy_regs);
896 err_destroy_workqueue:
897         flush_workqueue(mvotg->qwork);
898         destroy_workqueue(mvotg->qwork);
899 err_put_clk:
900         for (clk_i--; clk_i >= 0; clk_i--)
901                 clk_put(mvotg->clk[clk_i]);
902
903         platform_set_drvdata(pdev, NULL);
904         kfree(otg);
905         kfree(mvotg);
906
907         return retval;
908 }
909
910 #ifdef CONFIG_PM
911 static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state)
912 {
913         struct mv_otg *mvotg = platform_get_drvdata(pdev);
914
915         if (mvotg->phy.state != OTG_STATE_B_IDLE) {
916                 dev_info(&pdev->dev,
917                          "OTG state is not B_IDLE, it is %d!\n",
918                          mvotg->phy.state);
919                 return -EAGAIN;
920         }
921
922         if (!mvotg->clock_gating)
923                 mv_otg_disable_internal(mvotg);
924
925         return 0;
926 }
927
928 static int mv_otg_resume(struct platform_device *pdev)
929 {
930         struct mv_otg *mvotg = platform_get_drvdata(pdev);
931         u32 otgsc;
932
933         if (!mvotg->clock_gating) {
934                 mv_otg_enable_internal(mvotg);
935
936                 otgsc = readl(&mvotg->op_regs->otgsc);
937                 otgsc |= mvotg->irq_en;
938                 writel(otgsc, &mvotg->op_regs->otgsc);
939
940                 if (spin_trylock(&mvotg->wq_lock)) {
941                         mv_otg_run_state_machine(mvotg, 0);
942                         spin_unlock(&mvotg->wq_lock);
943                 }
944         }
945         return 0;
946 }
947 #endif
948
949 static struct platform_driver mv_otg_driver = {
950         .probe = mv_otg_probe,
951         .remove = __exit_p(mv_otg_remove),
952         .driver = {
953                    .owner = THIS_MODULE,
954                    .name = driver_name,
955                    },
956 #ifdef CONFIG_PM
957         .suspend = mv_otg_suspend,
958         .resume = mv_otg_resume,
959 #endif
960 };
961 module_platform_driver(mv_otg_driver);