9d614cb78570bb27a36b6f3cd6b8b243f19ea577
[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
186 static void tegra_change_otg_state(struct tegra_otg_data *tegra,
187                                 enum usb_otg_state to)
188 {
189         struct otg_transceiver *otg = &tegra->otg;
190         enum usb_otg_state from = otg->state;
191
192         if(!tegra->interrupt_mode){
193                 DBG("OTG: Vbus detection is disabled");
194                 return;
195         }
196
197         DBG("%s(%d) requested otg state %s-->%s\n", __func__,
198                 __LINE__, tegra_state_name(from), tegra_state_name(to));
199
200         if (to != OTG_STATE_UNDEFINED && from != to) {
201                 otg->state = to;
202                 dev_info(tegra->otg.dev, "%s --> %s\n", tegra_state_name(from),
203                                               tegra_state_name(to));
204
205                 if (from == OTG_STATE_A_SUSPEND) {
206                         if (to == OTG_STATE_B_PERIPHERAL && otg->gadget)
207                                 usb_gadget_vbus_connect(otg->gadget);
208                         else if (to == OTG_STATE_A_HOST)
209                                 tegra_start_host(tegra);
210                 } else if (from == OTG_STATE_A_HOST) {
211                         if (to == OTG_STATE_A_SUSPEND)
212                                 tegra_stop_host(tegra);
213                 } else if (from == OTG_STATE_B_PERIPHERAL && otg->gadget) {
214                         if (to == OTG_STATE_A_SUSPEND)
215                                 usb_gadget_vbus_disconnect(otg->gadget);
216                 }
217         }
218 }
219
220 static void irq_work(struct work_struct *work)
221 {
222         struct tegra_otg_data *tegra =
223                 container_of(work, struct tegra_otg_data, work);
224         struct otg_transceiver *otg = &tegra->otg;
225         enum usb_otg_state from;
226         enum usb_otg_state to = OTG_STATE_UNDEFINED;
227         unsigned long flags;
228         unsigned long status;
229
230         mutex_lock(&tegra->irq_work_mutex);
231
232         spin_lock_irqsave(&tegra->lock, flags);
233         from = otg->state;
234         status = tegra->int_status;
235
236         /* Debug prints */
237         DBG("%s(%d) status = 0x%lx\n", __func__, __LINE__, status);
238         if ((status & USB_ID_INT_STATUS) &&
239                         (status & USB_VBUS_INT_STATUS))
240                 DBG("%s(%d) got vbus & id interrupt\n", __func__, __LINE__);
241         else {
242                 if (status & USB_ID_INT_STATUS)
243                         DBG("%s(%d) got id interrupt\n", __func__, __LINE__);
244                 if (status & USB_VBUS_INT_STATUS)
245                         DBG("%s(%d) got vbus interrupt\n", __func__, __LINE__);
246         }
247
248         if (!(status & USB_ID_STATUS) && (status & USB_ID_INT_EN))
249                 to = OTG_STATE_A_HOST;
250         else if (status & USB_VBUS_STATUS && from != OTG_STATE_A_HOST)
251                 to = OTG_STATE_B_PERIPHERAL;
252         else
253                 to = OTG_STATE_A_SUSPEND;
254
255         spin_unlock_irqrestore(&tegra->lock, flags);
256         tegra_change_otg_state(tegra, to);
257         mutex_unlock(&tegra->irq_work_mutex);
258 }
259
260 static irqreturn_t tegra_otg_irq(int irq, void *data)
261 {
262         struct tegra_otg_data *tegra = data;
263         unsigned long flags;
264         unsigned long val;
265
266         spin_lock_irqsave(&tegra->lock, flags);
267         val = otg_readl(tegra, USB_PHY_WAKEUP);
268         DBG("%s(%d) interrupt val = 0x%lx\n", __func__, __LINE__, val);
269
270         if (val & (USB_VBUS_INT_EN | USB_ID_INT_EN)) {
271                 DBG("%s(%d) PHY_WAKEUP = 0x%lx\n", __func__, __LINE__, val);
272                 otg_writel(tegra, val, USB_PHY_WAKEUP);
273                 if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
274                         tegra->int_status = val;
275                         schedule_work(&tegra->work);
276                 }
277         }
278         spin_unlock_irqrestore(&tegra->lock, flags);
279
280         return IRQ_HANDLED;
281 }
282
283
284 static int tegra_otg_set_peripheral(struct otg_transceiver *otg,
285                                 struct usb_gadget *gadget)
286 {
287         struct tegra_otg_data *tegra;
288         unsigned long val;
289         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
290
291         tegra = container_of(otg, struct tegra_otg_data, otg);
292         otg->gadget = gadget;
293
294         val = enable_interrupt(tegra, true);
295
296         if ((val & USB_ID_STATUS) && (val & USB_VBUS_STATUS))
297                 val |= USB_VBUS_INT_STATUS;
298         else if (!(val & USB_ID_STATUS)) {
299                 if(!tegra->builtin_host)
300                         val &= ~USB_ID_INT_STATUS;
301                 else
302                         val |= USB_ID_INT_STATUS;
303         }
304         else
305                 val &= ~(USB_ID_INT_STATUS | USB_VBUS_INT_STATUS);
306
307         if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
308                 tegra->int_status = val;
309                 schedule_work(&tegra->work);
310         }
311
312         DBG("%s(%d) END\n", __func__, __LINE__);
313         return 0;
314 }
315
316 static int tegra_otg_set_host(struct otg_transceiver *otg,
317                                 struct usb_bus *host)
318 {
319         struct tegra_otg_data *tegra;
320         unsigned long val;
321         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
322
323         tegra = container_of(otg, struct tegra_otg_data, otg);
324         otg->host = host;
325
326         clk_enable(tegra->clk);
327         val = otg_readl(tegra, USB_PHY_WAKEUP);
328         val &= ~(USB_VBUS_INT_STATUS | USB_ID_INT_STATUS);
329         val |= (USB_ID_INT_EN | USB_ID_PIN_WAKEUP_EN);
330         otg_writel(tegra, val, USB_PHY_WAKEUP);
331         clk_disable(tegra->clk);
332
333         DBG("%s(%d) END\n", __func__, __LINE__);
334         return 0;
335 }
336
337 static int tegra_otg_set_power(struct otg_transceiver *otg, unsigned mA)
338 {
339         return 0;
340 }
341
342 static int tegra_otg_set_suspend(struct otg_transceiver *otg, int suspend)
343 {
344         return 0;
345 }
346
347 static ssize_t show_host_en(struct device *dev, struct device_attribute *attr,
348                                 char *buf)
349 {
350         struct platform_device *pdev = to_platform_device(dev);
351         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
352
353         *buf = tegra->interrupt_mode ? '0': '1';
354         strcat(buf, "\n");
355         return strlen(buf);
356 }
357
358 static ssize_t store_host_en(struct device *dev, struct device_attribute *attr,
359                                 const char *buf, size_t count)
360 {
361         struct platform_device *pdev = to_platform_device(dev);
362         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
363         unsigned int host;
364
365         if (sscanf(buf, "%d", &host) != 1 || host < 0 || host > 1)
366                 return -EINVAL;
367
368         if (host) {
369                 enable_interrupt(tegra, false);
370                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
371                 tegra_change_otg_state(tegra, OTG_STATE_A_HOST);
372                 tegra->interrupt_mode = false;
373         } else {
374                 tegra->interrupt_mode = true;
375                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
376                 enable_interrupt(tegra, true);
377         }
378
379         return count;
380 }
381
382 static DEVICE_ATTR(enable_host, 0644, show_host_en, store_host_en);
383
384 static int tegra_otg_probe(struct platform_device *pdev)
385 {
386         struct tegra_otg_data *tegra;
387         struct resource *res;
388         struct tegra_usb_otg_data *pdata = dev_get_platdata(&pdev->dev);
389         int err;
390
391         tegra = kzalloc(sizeof(struct tegra_otg_data), GFP_KERNEL);
392         if (!tegra)
393                 return -ENOMEM;
394
395         tegra->otg.dev = &pdev->dev;
396         tegra->otg.label = "tegra-otg";
397         tegra->otg.state = OTG_STATE_UNDEFINED;
398         tegra->otg.set_host = tegra_otg_set_host;
399         tegra->otg.set_peripheral = tegra_otg_set_peripheral;
400         tegra->otg.set_suspend = tegra_otg_set_suspend;
401         tegra->otg.set_power = tegra_otg_set_power;
402         spin_lock_init(&tegra->lock);
403         mutex_init(&tegra->irq_work_mutex);
404
405         if (pdata) {
406                 tegra->builtin_host = !pdata->ehci_pdata->builtin_host_disabled;
407         }
408
409         platform_set_drvdata(pdev, tegra);
410         tegra_clone = tegra;
411         tegra->interrupt_mode = true;
412         tegra->suspended = false;
413
414         tegra->clk = clk_get(&pdev->dev, NULL);
415         if (IS_ERR(tegra->clk)) {
416                 dev_err(&pdev->dev, "Can't get otg clock\n");
417                 err = PTR_ERR(tegra->clk);
418                 goto err_clk;
419         }
420
421         err = clk_enable(tegra->clk);
422         if (err)
423                 goto err_clken;
424
425         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
426         if (!res) {
427                 dev_err(&pdev->dev, "Failed to get I/O memory\n");
428                 err = -ENXIO;
429                 goto err_io;
430         }
431         tegra->regs = ioremap(res->start, resource_size(res));
432         if (!tegra->regs) {
433                 err = -ENOMEM;
434                 goto err_io;
435         }
436
437         tegra->otg.state = OTG_STATE_A_SUSPEND;
438
439         err = otg_set_transceiver(&tegra->otg);
440         if (err) {
441                 dev_err(&pdev->dev, "can't register transceiver (%d)\n", err);
442                 goto err_otg;
443         }
444
445         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
446         if (!res) {
447                 dev_err(&pdev->dev, "Failed to get IRQ\n");
448                 err = -ENXIO;
449                 goto err_irq;
450         }
451         tegra->irq = res->start;
452         err = request_threaded_irq(tegra->irq, tegra_otg_irq,
453                                    NULL,
454                                    IRQF_SHARED | IRQF_TRIGGER_HIGH,
455                                    "tegra-otg", tegra);
456         if (err) {
457                 dev_err(&pdev->dev, "Failed to register IRQ\n");
458                 goto err_irq;
459         }
460
461         err = enable_irq_wake(tegra->irq);
462         if (err < 0) {
463                 dev_warn(&pdev->dev,
464                         "Couldn't enable USB otg mode wakeup, irq=%d, error=%d\n",
465                         tegra->irq, err);
466                 err = 0;
467         }
468
469         INIT_WORK(&tegra->work, irq_work);
470
471         dev_info(&pdev->dev, "otg transceiver registered\n");
472
473         err = device_create_file(&pdev->dev, &dev_attr_enable_host);
474         if (err) {
475                 dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
476                 goto err_irq;
477         }
478
479         clk_disable(tegra->clk);
480
481         return 0;
482
483 err_irq:
484         otg_set_transceiver(NULL);
485 err_otg:
486         iounmap(tegra->regs);
487 err_io:
488         clk_disable(tegra->clk);
489 err_clken:
490         clk_put(tegra->clk);
491 err_clk:
492         platform_set_drvdata(pdev, NULL);
493         kfree(tegra);
494         return err;
495 }
496
497 static int __exit tegra_otg_remove(struct platform_device *pdev)
498 {
499         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
500
501         free_irq(tegra->irq, tegra);
502         otg_set_transceiver(NULL);
503         iounmap(tegra->regs);
504         clk_disable(tegra->clk);
505         clk_put(tegra->clk);
506         platform_set_drvdata(pdev, NULL);
507         mutex_destroy(&tegra->irq_work_mutex);
508         kfree(tegra);
509
510         return 0;
511 }
512
513 #ifdef CONFIG_PM
514 static int tegra_otg_suspend(struct device *dev)
515 {
516         struct platform_device *pdev = to_platform_device(dev);
517         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
518         struct otg_transceiver *otg = &tegra->otg;
519         int val;
520
521         mutex_lock(&tegra->irq_work_mutex);
522         DBG("%s(%d) BEGIN state : %s\n", __func__, __LINE__,
523                                         tegra_state_name(otg->state));
524
525         clk_enable(tegra->clk);
526         val = otg_readl(tegra, USB_PHY_WAKEUP);
527         val &= ~(USB_ID_INT_EN | USB_VBUS_INT_EN);
528         otg_writel(tegra, val, USB_PHY_WAKEUP);
529         clk_disable(tegra->clk);
530
531         /* Suspend peripheral mode, host mode is taken care by host driver */
532         if (otg->state == OTG_STATE_B_PERIPHERAL)
533                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
534
535         tegra->suspended = true;
536
537         DBG("%s(%d) END\n", __func__, __LINE__);
538         mutex_unlock(&tegra->irq_work_mutex);
539         return 0;
540 }
541
542 static void tegra_otg_resume(struct device *dev)
543 {
544         struct platform_device *pdev = to_platform_device(dev);
545         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
546         int val;
547         unsigned long flags;
548         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
549
550         mutex_lock(&tegra->irq_work_mutex);
551         if (!tegra->suspended) {
552                 mutex_unlock(&tegra->irq_work_mutex);
553                 return;
554         }
555
556         /* Clear pending interrupts */
557         clk_enable(tegra->clk);
558         val = otg_readl(tegra, USB_PHY_WAKEUP);
559         otg_writel(tegra, val, USB_PHY_WAKEUP);
560         DBG("%s(%d) PHY WAKEUP register : 0x%x\n", __func__, __LINE__, val);
561         clk_disable(tegra->clk);
562
563         /* Enable interrupt and call work to set to appropriate state */
564         spin_lock_irqsave(&tegra->lock, flags);
565         if (tegra->builtin_host)
566                 tegra->int_status = val | USB_INT_EN;
567         else
568                 tegra->int_status = val | USB_VBUS_INT_EN | USB_VBUS_WAKEUP_EN |
569                         USB_ID_PIN_WAKEUP_EN;
570
571         spin_unlock_irqrestore(&tegra->lock, flags);
572         schedule_work(&tegra->work);
573         enable_interrupt(tegra, true);
574
575         tegra->suspended = false;
576
577         DBG("%s(%d) END\n", __func__, __LINE__);
578         mutex_unlock(&tegra->irq_work_mutex);
579 }
580
581 static const struct dev_pm_ops tegra_otg_pm_ops = {
582         .complete = tegra_otg_resume,
583         .suspend = tegra_otg_suspend,
584 };
585 #endif
586
587 static struct platform_driver tegra_otg_driver = {
588         .driver = {
589                 .name  = "tegra-otg",
590 #ifdef CONFIG_PM
591                 .pm    = &tegra_otg_pm_ops,
592 #endif
593         },
594         .remove  = __exit_p(tegra_otg_remove),
595         .probe   = tegra_otg_probe,
596 };
597
598 static int __init tegra_otg_init(void)
599 {
600         return platform_driver_register(&tegra_otg_driver);
601 }
602 subsys_initcall(tegra_otg_init);
603
604 static void __exit tegra_otg_exit(void)
605 {
606         platform_driver_unregister(&tegra_otg_driver);
607 }
608 module_exit(tegra_otg_exit);