usb: otg: tegra: Notify USB events to otg core
[linux-2.6.git] / drivers / usb / otg / tegra-otg.c
1 /*
2  * drivers/usb/otg/tegra-otg.c
3  *
4  * OTG transceiver driver for Tegra UTMI phy
5  *
6  * Copyright (C) 2010-2012 NVIDIA CORPORATION. All rights reserved.
7  * Copyright (C) 2010 Google, Inc.
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by the
11  * Free Software Foundation; either version 2 of the License, or (at your
12  * option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
17  * more details.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
22  */
23
24 #include <linux/usb.h>
25 #include <linux/usb/otg.h>
26 #include <linux/usb/gadget.h>
27 #include <linux/platform_device.h>
28 #include <linux/platform_data/tegra_usb.h>
29 #include <linux/clk.h>
30 #include <linux/io.h>
31 #include <linux/delay.h>
32 #include <linux/err.h>
33
34 #define USB_PHY_WAKEUP          0x408
35 #define  USB_ID_INT_EN          (1 << 0)
36 #define  USB_ID_INT_STATUS      (1 << 1)
37 #define  USB_ID_STATUS          (1 << 2)
38 #define  USB_ID_PIN_WAKEUP_EN   (1 << 6)
39 #define  USB_VBUS_WAKEUP_EN     (1 << 30)
40 #define  USB_VBUS_INT_EN        (1 << 8)
41 #define  USB_VBUS_INT_STATUS    (1 << 9)
42 #define  USB_VBUS_STATUS        (1 << 10)
43 #define  USB_INT_EN             (USB_VBUS_INT_EN | USB_ID_INT_EN | \
44                                                 USB_VBUS_WAKEUP_EN | USB_ID_PIN_WAKEUP_EN)
45
46 #ifdef DEBUG
47 #define DBG(stuff...)   pr_info("tegra-otg: " stuff)
48 #else
49 #define DBG(stuff...)   do {} while (0)
50 #endif
51
52 struct tegra_otg_data {
53         struct otg_transceiver otg;
54         unsigned long int_status;
55         spinlock_t lock;
56         struct mutex irq_work_mutex;
57         void __iomem *regs;
58         struct clk *clk;
59         int irq;
60         struct platform_device *pdev;
61         struct work_struct work;
62         unsigned int intr_reg_data;
63         bool clk_enabled;
64         bool interrupt_mode;
65         bool builtin_host;
66         bool suspended;
67 };
68
69 static struct tegra_otg_data *tegra_clone;
70
71 static inline unsigned long otg_readl(struct tegra_otg_data *tegra,
72                                       unsigned int offset)
73 {
74         return readl(tegra->regs + offset);
75 }
76
77 static inline void otg_writel(struct tegra_otg_data *tegra, unsigned long val,
78                               unsigned int offset)
79 {
80         writel(val, tegra->regs + offset);
81 }
82
83 static const char *tegra_state_name(enum usb_otg_state state)
84 {
85         switch (state) {
86                 case OTG_STATE_A_HOST:
87                         return "HOST";
88                 case OTG_STATE_B_PERIPHERAL:
89                         return "PERIPHERAL";
90                 case OTG_STATE_A_SUSPEND:
91                         return "SUSPEND";
92                 case OTG_STATE_UNDEFINED:
93                         return "UNDEFINED";
94                 default:
95                         return "INVALID";
96         }
97 }
98
99 static unsigned long enable_interrupt(struct tegra_otg_data *tegra, bool en)
100 {
101         unsigned long val;
102
103         clk_enable(tegra->clk);
104         val = otg_readl(tegra, USB_PHY_WAKEUP);
105         if (en) {
106                 if (tegra->builtin_host)
107                         val |= USB_INT_EN;
108                 else
109                         val |= USB_VBUS_INT_EN | USB_VBUS_WAKEUP_EN | USB_ID_PIN_WAKEUP_EN;
110         }
111         else
112                 val &= ~USB_INT_EN;
113         otg_writel(tegra, val, USB_PHY_WAKEUP);
114         /* Add delay to make sure register is updated */
115         udelay(1);
116         clk_disable(tegra->clk);
117
118         return val;
119 }
120
121 static void tegra_start_host(struct tegra_otg_data *tegra)
122 {
123         struct tegra_usb_otg_data *pdata = tegra->otg.dev->platform_data;
124         struct platform_device *pdev, *ehci_device = pdata->ehci_device;
125         void *platform_data;
126         int val;
127         DBG("%s(%d) Begin\n", __func__, __LINE__);
128
129         if (tegra->pdev)
130                 return ;
131
132         /* prepare device structure for registering host*/
133         pdev = platform_device_alloc(ehci_device->name, ehci_device->id);
134         if (!pdev)
135                 return ;
136
137         val = platform_device_add_resources(pdev, ehci_device->resource,
138                                             ehci_device->num_resources);
139         if (val)
140                 goto error;
141
142         pdev->dev.dma_mask = ehci_device->dev.dma_mask;
143         pdev->dev.coherent_dma_mask = ehci_device->dev.coherent_dma_mask;
144
145         platform_data = kmalloc(sizeof(struct tegra_usb_platform_data), GFP_KERNEL);
146         if (!platform_data)
147                 goto error;
148
149         memcpy(platform_data, pdata->ehci_pdata,
150                                         sizeof(struct tegra_usb_platform_data));
151         pdev->dev.platform_data = platform_data;
152         val = platform_device_add(pdev);
153         if (val)
154                 goto error_add;
155
156         tegra->pdev = pdev;
157         DBG("%s(%d) End\n", __func__, __LINE__);
158         return ;
159
160 error_add:
161         kfree(platform_data);
162 error:
163         pr_err("%s: failed to add the host controller device\n", __func__);
164         platform_device_put(pdev);
165         tegra->pdev = NULL;
166 }
167
168 static void tegra_stop_host(struct tegra_otg_data *tegra)
169 {
170         struct platform_device *pdev = tegra->pdev;
171
172         DBG("%s(%d) Begin\n", __func__, __LINE__);
173
174         if (pdev) {
175                 /* unregister host from otg */
176                 kfree(pdev->dev.platform_data);
177                 pdev->dev.platform_data = NULL;
178                 platform_device_unregister(pdev);
179                 tegra->pdev = NULL;
180         }
181
182         DBG("%s(%d) End\n", __func__, __LINE__);
183 }
184
185 static void tegra_otg_notify_event(struct otg_transceiver *otg,
186                                         enum usb_xceiv_events event)
187 {
188         otg->last_event = event;
189         atomic_notifier_call_chain(&otg->notifier, event, NULL);
190 }
191
192 static void tegra_change_otg_state(struct tegra_otg_data *tegra,
193                                 enum usb_otg_state to)
194 {
195         struct otg_transceiver *otg = &tegra->otg;
196         enum usb_otg_state from = otg->state;
197
198         if(!tegra->interrupt_mode){
199                 DBG("OTG: Vbus detection is disabled");
200                 return;
201         }
202
203         DBG("%s(%d) requested otg state %s-->%s\n", __func__,
204                 __LINE__, tegra_state_name(from), tegra_state_name(to));
205
206         if (to != OTG_STATE_UNDEFINED && from != to) {
207                 otg->state = to;
208                 dev_info(tegra->otg.dev, "%s --> %s\n", tegra_state_name(from),
209                                               tegra_state_name(to));
210
211                 if (from == OTG_STATE_A_SUSPEND) {
212                         if (to == OTG_STATE_B_PERIPHERAL && otg->gadget) {
213                                 usb_gadget_vbus_connect(otg->gadget);
214                                 tegra_otg_notify_event(otg, USB_EVENT_VBUS);
215                         }
216                         else if (to == OTG_STATE_A_HOST) {
217                                 tegra_start_host(tegra);
218                                 tegra_otg_notify_event(otg, USB_EVENT_ID);
219                         }
220                 } else if (from == OTG_STATE_A_HOST) {
221                         if (to == OTG_STATE_A_SUSPEND) {
222                                 tegra_stop_host(tegra);
223                                 tegra_otg_notify_event(otg, USB_EVENT_NONE);
224                         }
225                 } else if (from == OTG_STATE_B_PERIPHERAL && otg->gadget) {
226                         if (to == OTG_STATE_A_SUSPEND) {
227                                 usb_gadget_vbus_disconnect(otg->gadget);
228                                 tegra_otg_notify_event(otg, USB_EVENT_NONE);
229                         }
230                 }
231         }
232 }
233
234 static void irq_work(struct work_struct *work)
235 {
236         struct tegra_otg_data *tegra =
237                 container_of(work, struct tegra_otg_data, work);
238         struct otg_transceiver *otg = &tegra->otg;
239         enum usb_otg_state from;
240         enum usb_otg_state to = OTG_STATE_UNDEFINED;
241         unsigned long flags;
242         unsigned long status;
243
244         mutex_lock(&tegra->irq_work_mutex);
245
246         spin_lock_irqsave(&tegra->lock, flags);
247         from = otg->state;
248         status = tegra->int_status;
249
250         /* Debug prints */
251         DBG("%s(%d) status = 0x%lx\n", __func__, __LINE__, status);
252         if ((status & USB_ID_INT_STATUS) &&
253                         (status & USB_VBUS_INT_STATUS))
254                 DBG("%s(%d) got vbus & id interrupt\n", __func__, __LINE__);
255         else {
256                 if (status & USB_ID_INT_STATUS)
257                         DBG("%s(%d) got id interrupt\n", __func__, __LINE__);
258                 if (status & USB_VBUS_INT_STATUS)
259                         DBG("%s(%d) got vbus interrupt\n", __func__, __LINE__);
260         }
261
262         if (!(status & USB_ID_STATUS) && (status & USB_ID_INT_EN))
263                 to = OTG_STATE_A_HOST;
264         else if (status & USB_VBUS_STATUS && from != OTG_STATE_A_HOST)
265                 to = OTG_STATE_B_PERIPHERAL;
266         else
267                 to = OTG_STATE_A_SUSPEND;
268
269         spin_unlock_irqrestore(&tegra->lock, flags);
270         tegra_change_otg_state(tegra, to);
271         mutex_unlock(&tegra->irq_work_mutex);
272 }
273
274 static irqreturn_t tegra_otg_irq(int irq, void *data)
275 {
276         struct tegra_otg_data *tegra = data;
277         unsigned long flags;
278         unsigned long val;
279
280         spin_lock_irqsave(&tegra->lock, flags);
281         val = otg_readl(tegra, USB_PHY_WAKEUP);
282         DBG("%s(%d) interrupt val = 0x%lx\n", __func__, __LINE__, val);
283
284         if (val & (USB_VBUS_INT_EN | USB_ID_INT_EN)) {
285                 DBG("%s(%d) PHY_WAKEUP = 0x%lx\n", __func__, __LINE__, val);
286                 otg_writel(tegra, val, USB_PHY_WAKEUP);
287                 if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
288                         tegra->int_status = val;
289                         schedule_work(&tegra->work);
290                 }
291         }
292         spin_unlock_irqrestore(&tegra->lock, flags);
293
294         return IRQ_HANDLED;
295 }
296
297
298 static int tegra_otg_set_peripheral(struct otg_transceiver *otg,
299                                 struct usb_gadget *gadget)
300 {
301         struct tegra_otg_data *tegra;
302         unsigned long val;
303         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
304
305         tegra = container_of(otg, struct tegra_otg_data, otg);
306         otg->gadget = gadget;
307
308         val = enable_interrupt(tegra, true);
309
310         if ((val & USB_ID_STATUS) && (val & USB_VBUS_STATUS))
311                 val |= USB_VBUS_INT_STATUS;
312         else if (!(val & USB_ID_STATUS)) {
313                 if(!tegra->builtin_host)
314                         val &= ~USB_ID_INT_STATUS;
315                 else
316                         val |= USB_ID_INT_STATUS;
317         }
318         else
319                 val &= ~(USB_ID_INT_STATUS | USB_VBUS_INT_STATUS);
320
321         if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
322                 tegra->int_status = val;
323                 schedule_work(&tegra->work);
324         }
325
326         DBG("%s(%d) END\n", __func__, __LINE__);
327         return 0;
328 }
329
330 static int tegra_otg_set_host(struct otg_transceiver *otg,
331                                 struct usb_bus *host)
332 {
333         struct tegra_otg_data *tegra;
334         unsigned long val;
335         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
336
337         tegra = container_of(otg, struct tegra_otg_data, otg);
338         otg->host = host;
339
340         clk_enable(tegra->clk);
341         val = otg_readl(tegra, USB_PHY_WAKEUP);
342         val &= ~(USB_VBUS_INT_STATUS | USB_ID_INT_STATUS);
343         val |= (USB_ID_INT_EN | USB_ID_PIN_WAKEUP_EN);
344         otg_writel(tegra, val, USB_PHY_WAKEUP);
345         clk_disable(tegra->clk);
346
347         DBG("%s(%d) END\n", __func__, __LINE__);
348         return 0;
349 }
350
351 static int tegra_otg_set_power(struct otg_transceiver *otg, unsigned mA)
352 {
353         return 0;
354 }
355
356 static int tegra_otg_set_suspend(struct otg_transceiver *otg, int suspend)
357 {
358         return 0;
359 }
360
361 static ssize_t show_host_en(struct device *dev, struct device_attribute *attr,
362                                 char *buf)
363 {
364         struct platform_device *pdev = to_platform_device(dev);
365         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
366
367         *buf = tegra->interrupt_mode ? '0': '1';
368         strcat(buf, "\n");
369         return strlen(buf);
370 }
371
372 static ssize_t store_host_en(struct device *dev, struct device_attribute *attr,
373                                 const char *buf, size_t count)
374 {
375         struct platform_device *pdev = to_platform_device(dev);
376         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
377         unsigned int host;
378
379         if (sscanf(buf, "%d", &host) != 1 || host < 0 || host > 1)
380                 return -EINVAL;
381
382         if (host) {
383                 enable_interrupt(tegra, false);
384                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
385                 tegra_change_otg_state(tegra, OTG_STATE_A_HOST);
386                 tegra->interrupt_mode = false;
387         } else {
388                 tegra->interrupt_mode = true;
389                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
390                 enable_interrupt(tegra, true);
391         }
392
393         return count;
394 }
395
396 static DEVICE_ATTR(enable_host, 0644, show_host_en, store_host_en);
397
398 static int tegra_otg_probe(struct platform_device *pdev)
399 {
400         struct tegra_otg_data *tegra;
401         struct resource *res;
402         struct tegra_usb_otg_data *pdata = dev_get_platdata(&pdev->dev);
403         int err;
404
405         tegra = kzalloc(sizeof(struct tegra_otg_data), GFP_KERNEL);
406         if (!tegra)
407                 return -ENOMEM;
408
409         tegra->otg.dev = &pdev->dev;
410         tegra->otg.label = "tegra-otg";
411         tegra->otg.state = OTG_STATE_UNDEFINED;
412         tegra->otg.set_host = tegra_otg_set_host;
413         tegra->otg.set_peripheral = tegra_otg_set_peripheral;
414         tegra->otg.set_suspend = tegra_otg_set_suspend;
415         tegra->otg.set_power = tegra_otg_set_power;
416         spin_lock_init(&tegra->lock);
417         mutex_init(&tegra->irq_work_mutex);
418
419         if (pdata) {
420                 tegra->builtin_host = !pdata->ehci_pdata->builtin_host_disabled;
421         }
422
423         platform_set_drvdata(pdev, tegra);
424         tegra_clone = tegra;
425         tegra->interrupt_mode = true;
426         tegra->suspended = false;
427
428         tegra->clk = clk_get(&pdev->dev, NULL);
429         if (IS_ERR(tegra->clk)) {
430                 dev_err(&pdev->dev, "Can't get otg clock\n");
431                 err = PTR_ERR(tegra->clk);
432                 goto err_clk;
433         }
434
435         err = clk_enable(tegra->clk);
436         if (err)
437                 goto err_clken;
438
439         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
440         if (!res) {
441                 dev_err(&pdev->dev, "Failed to get I/O memory\n");
442                 err = -ENXIO;
443                 goto err_io;
444         }
445         tegra->regs = ioremap(res->start, resource_size(res));
446         if (!tegra->regs) {
447                 err = -ENOMEM;
448                 goto err_io;
449         }
450
451         tegra->otg.state = OTG_STATE_A_SUSPEND;
452
453         err = otg_set_transceiver(&tegra->otg);
454         if (err) {
455                 dev_err(&pdev->dev, "can't register transceiver (%d)\n", err);
456                 goto err_otg;
457         }
458
459         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
460         if (!res) {
461                 dev_err(&pdev->dev, "Failed to get IRQ\n");
462                 err = -ENXIO;
463                 goto err_irq;
464         }
465         tegra->irq = res->start;
466         err = request_threaded_irq(tegra->irq, tegra_otg_irq,
467                                    NULL,
468                                    IRQF_SHARED | IRQF_TRIGGER_HIGH,
469                                    "tegra-otg", tegra);
470         if (err) {
471                 dev_err(&pdev->dev, "Failed to register IRQ\n");
472                 goto err_irq;
473         }
474
475         err = enable_irq_wake(tegra->irq);
476         if (err < 0) {
477                 dev_warn(&pdev->dev,
478                         "Couldn't enable USB otg mode wakeup, irq=%d, error=%d\n",
479                         tegra->irq, err);
480                 err = 0;
481         }
482
483         INIT_WORK(&tegra->work, irq_work);
484
485         dev_info(&pdev->dev, "otg transceiver registered\n");
486
487         err = device_create_file(&pdev->dev, &dev_attr_enable_host);
488         if (err) {
489                 dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
490                 goto err_irq;
491         }
492
493         clk_disable(tegra->clk);
494
495         return 0;
496
497 err_irq:
498         otg_set_transceiver(NULL);
499 err_otg:
500         iounmap(tegra->regs);
501 err_io:
502         clk_disable(tegra->clk);
503 err_clken:
504         clk_put(tegra->clk);
505 err_clk:
506         platform_set_drvdata(pdev, NULL);
507         kfree(tegra);
508         return err;
509 }
510
511 static int __exit tegra_otg_remove(struct platform_device *pdev)
512 {
513         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
514
515         free_irq(tegra->irq, tegra);
516         otg_set_transceiver(NULL);
517         iounmap(tegra->regs);
518         clk_disable(tegra->clk);
519         clk_put(tegra->clk);
520         platform_set_drvdata(pdev, NULL);
521         mutex_destroy(&tegra->irq_work_mutex);
522         kfree(tegra);
523
524         return 0;
525 }
526
527 #ifdef CONFIG_PM
528 static int tegra_otg_suspend(struct device *dev)
529 {
530         struct platform_device *pdev = to_platform_device(dev);
531         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
532         struct otg_transceiver *otg = &tegra->otg;
533         int val;
534
535         mutex_lock(&tegra->irq_work_mutex);
536         DBG("%s(%d) BEGIN state : %s\n", __func__, __LINE__,
537                                         tegra_state_name(otg->state));
538
539         clk_enable(tegra->clk);
540         val = otg_readl(tegra, USB_PHY_WAKEUP);
541         val &= ~(USB_ID_INT_EN | USB_VBUS_INT_EN);
542         otg_writel(tegra, val, USB_PHY_WAKEUP);
543         clk_disable(tegra->clk);
544
545         /* Suspend peripheral mode, host mode is taken care by host driver */
546         if (otg->state == OTG_STATE_B_PERIPHERAL)
547                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
548
549         tegra->suspended = true;
550
551         DBG("%s(%d) END\n", __func__, __LINE__);
552         mutex_unlock(&tegra->irq_work_mutex);
553         return 0;
554 }
555
556 static void tegra_otg_resume(struct device *dev)
557 {
558         struct platform_device *pdev = to_platform_device(dev);
559         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
560         int val;
561         unsigned long flags;
562         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
563
564         mutex_lock(&tegra->irq_work_mutex);
565         if (!tegra->suspended) {
566                 mutex_unlock(&tegra->irq_work_mutex);
567                 return;
568         }
569
570         /* Clear pending interrupts */
571         clk_enable(tegra->clk);
572         val = otg_readl(tegra, USB_PHY_WAKEUP);
573         otg_writel(tegra, val, USB_PHY_WAKEUP);
574         DBG("%s(%d) PHY WAKEUP register : 0x%x\n", __func__, __LINE__, val);
575         clk_disable(tegra->clk);
576
577         /* Enable interrupt and call work to set to appropriate state */
578         spin_lock_irqsave(&tegra->lock, flags);
579         if (tegra->builtin_host)
580                 tegra->int_status = val | USB_INT_EN;
581         else
582                 tegra->int_status = val | USB_VBUS_INT_EN | USB_VBUS_WAKEUP_EN |
583                         USB_ID_PIN_WAKEUP_EN;
584
585         spin_unlock_irqrestore(&tegra->lock, flags);
586         schedule_work(&tegra->work);
587         enable_interrupt(tegra, true);
588
589         tegra->suspended = false;
590
591         DBG("%s(%d) END\n", __func__, __LINE__);
592         mutex_unlock(&tegra->irq_work_mutex);
593 }
594
595 static const struct dev_pm_ops tegra_otg_pm_ops = {
596         .complete = tegra_otg_resume,
597         .suspend = tegra_otg_suspend,
598 };
599 #endif
600
601 static struct platform_driver tegra_otg_driver = {
602         .driver = {
603                 .name  = "tegra-otg",
604 #ifdef CONFIG_PM
605                 .pm    = &tegra_otg_pm_ops,
606 #endif
607         },
608         .remove  = __exit_p(tegra_otg_remove),
609         .probe   = tegra_otg_probe,
610 };
611
612 static int __init tegra_otg_init(void)
613 {
614         return platform_driver_register(&tegra_otg_driver);
615 }
616 subsys_initcall(tegra_otg_init);
617
618 static void __exit tegra_otg_exit(void)
619 {
620         platform_driver_unregister(&tegra_otg_driver);
621 }
622 module_exit(tegra_otg_exit);