Revert "Merge commit 'main-jb-2012.08.03-B4' into t114-0806"
[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 #include <linux/export.h>
34
35 #define USB_PHY_WAKEUP          0x408
36 #define  USB_ID_INT_EN          (1 << 0)
37 #define  USB_ID_INT_STATUS      (1 << 1)
38 #define  USB_ID_STATUS          (1 << 2)
39 #define  USB_ID_PIN_WAKEUP_EN   (1 << 6)
40 #define  USB_VBUS_WAKEUP_EN     (1 << 30)
41 #define  USB_VBUS_INT_EN        (1 << 8)
42 #define  USB_VBUS_INT_STATUS    (1 << 9)
43 #define  USB_VBUS_STATUS        (1 << 10)
44 #define  USB_INT_EN             (USB_VBUS_INT_EN | USB_ID_INT_EN | \
45                                                 USB_VBUS_WAKEUP_EN | USB_ID_PIN_WAKEUP_EN)
46
47 #ifdef DEBUG
48 #define DBG(stuff...)   pr_info("tegra-otg: " stuff)
49 #else
50 #define DBG(stuff...)   do {} while (0)
51 #endif
52
53 struct tegra_otg_data {
54         struct platform_device *pdev;
55         struct tegra_usb_otg_data *pdata;
56         struct usb_phy phy;
57         unsigned long int_status;
58         spinlock_t lock;
59         void __iomem *regs;
60         struct clk *clk;
61         int irq;
62         struct work_struct work;
63         unsigned int intr_reg_data;
64         bool clk_enabled;
65         bool interrupt_mode;
66         bool builtin_host;
67         bool suspended
68 };
69
70 static struct tegra_otg_data *tegra_clone;
71
72 static inline unsigned long otg_readl(struct tegra_otg_data *tegra,
73                                       unsigned int offset)
74 {
75         return readl(tegra->regs + offset);
76 }
77
78 static inline void otg_writel(struct tegra_otg_data *tegra, unsigned long val,
79                               unsigned int offset)
80 {
81         writel(val, tegra->regs + offset);
82 }
83
84 static const char *tegra_state_name(enum usb_otg_state state)
85 {
86         switch (state) {
87                 case OTG_STATE_A_HOST:
88                         return "HOST";
89                 case OTG_STATE_B_PERIPHERAL:
90                         return "PERIPHERAL";
91                 case OTG_STATE_A_SUSPEND:
92                         return "SUSPEND";
93                 case OTG_STATE_UNDEFINED:
94                         return "UNDEFINED";
95                 default:
96                         return "INVALID";
97         }
98 }
99
100 static unsigned long enable_interrupt(struct tegra_otg_data *tegra, bool en)
101 {
102         unsigned long val;
103
104         clk_enable(tegra->clk);
105         val = otg_readl(tegra, USB_PHY_WAKEUP);
106         if (en) {
107                 if (tegra->builtin_host)
108                         val |= USB_INT_EN;
109                 else
110                         val = USB_VBUS_INT_EN | USB_VBUS_WAKEUP_EN | USB_ID_PIN_WAKEUP_EN;
111         }
112         else
113                 val &= ~USB_INT_EN;
114         otg_writel(tegra, val, USB_PHY_WAKEUP);
115         /* Add delay to make sure register is updated */
116         udelay(1);
117         clk_disable(tegra->clk);
118
119         return val;
120 }
121
122 static void tegra_start_host(struct tegra_otg_data *tegra)
123 {
124         struct tegra_usb_otg_data *pdata = tegra->pdata;
125         struct platform_device *pdev, *ehci_device = pdata->ehci_device;
126         int val;
127
128         DBG("%s(%d) Begin\n", __func__, __LINE__);
129
130         if (tegra->pdev)
131                 return;
132
133         /* prepare device structure for registering host*/
134         pdev = platform_device_alloc(ehci_device->name, ehci_device->id);
135         if (!pdev)
136                 return ;
137
138         val = platform_device_add_resources(pdev, ehci_device->resource,
139                         ehci_device->num_resources);
140         if (val)
141                 goto error;
142
143         pdev->dev.dma_mask = ehci_device->dev.dma_mask;
144         pdev->dev.coherent_dma_mask = ehci_device->dev.coherent_dma_mask;
145
146         val = platform_device_add_data(pdev, pdata->ehci_pdata,
147                         sizeof(struct tegra_usb_platform_data));
148         if (val)
149                 goto error;
150
151         val = platform_device_add(pdev);
152         if (val) {
153                 pr_err("%s: platform_device_add failed\n", __func__);
154                 goto error;
155         }
156
157         tegra->pdev = pdev;
158
159         DBG("%s(%d) End\n", __func__, __LINE__);
160         return;
161
162 error:
163         BUG_ON("failed to add the host controller device\n");
164         platform_device_del(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                 platform_device_unregister(pdev);
177                 tegra->pdev = NULL;
178         }
179
180         DBG("%s(%d) End\n", __func__, __LINE__);
181 }
182
183
184 static void tegra_change_otg_state(struct tegra_otg_data *tegra,
185                                 enum usb_otg_state to)
186 {
187         struct usb_otg *otg = tegra->phy.otg;
188         enum usb_otg_state from = otg->phy->state;
189
190         if (!tegra->interrupt_mode){
191                 DBG("OTG: Vbus detection is disabled");
192                 return;
193         }
194
195         DBG("%s(%d) requested otg state %s-->%s\n", __func__,
196                 __LINE__, tegra_state_name(from), tegra_state_name(to));
197
198         if (to != OTG_STATE_UNDEFINED && from != to) {
199                 otg->phy->state = to;
200                 pr_info("otg state changed: %s --> %s\n", tegra_state_name(from), tegra_state_name(to));
201
202                 if (from == OTG_STATE_A_SUSPEND) {
203                         if (to == OTG_STATE_B_PERIPHERAL && otg->gadget)
204                                 usb_gadget_vbus_connect(otg->gadget);
205                         else if (to == OTG_STATE_A_HOST)
206                                 tegra_start_host(tegra);
207                 } else if (from == OTG_STATE_A_HOST && to == OTG_STATE_A_SUSPEND) {
208                                 tegra_stop_host(tegra);
209                 } else if (from == OTG_STATE_B_PERIPHERAL && otg->gadget && to == OTG_STATE_A_SUSPEND) {
210                                 usb_gadget_vbus_disconnect(otg->gadget);
211                 }
212         }
213 }
214
215 static void irq_work(struct work_struct *work)
216 {
217         struct tegra_otg_data *tegra =
218                 container_of(work, struct tegra_otg_data, work);
219         struct usb_otg *otg = tegra->phy.otg;
220         enum usb_otg_state from = otg->phy->state;
221         enum usb_otg_state to = OTG_STATE_UNDEFINED;
222         unsigned long flags;
223         unsigned long status;
224
225         spin_lock_irqsave(&tegra->lock, flags);
226         status = tegra->int_status;
227
228         /* Debug prints */
229         DBG("%s(%d) status = 0x%lx\n", __func__, __LINE__, status);
230         if ((status & USB_ID_INT_STATUS) &&
231                         (status & USB_VBUS_INT_STATUS))
232                 DBG("%s(%d) got vbus & id interrupt\n", __func__, __LINE__);
233         else {
234                 if (status & USB_ID_INT_STATUS)
235                         DBG("%s(%d) got id interrupt\n", __func__, __LINE__);
236                 if (status & USB_VBUS_INT_STATUS)
237                         DBG("%s(%d) got vbus interrupt\n", __func__, __LINE__);
238         }
239
240         if (!(status & USB_ID_STATUS) && (status & USB_ID_INT_EN))
241                 to = OTG_STATE_A_HOST;
242         else if (status & USB_VBUS_STATUS && from != OTG_STATE_A_HOST)
243                 to = OTG_STATE_B_PERIPHERAL;
244         else
245                 to = OTG_STATE_A_SUSPEND;
246
247         spin_unlock_irqrestore(&tegra->lock, flags);
248         tegra_change_otg_state(tegra, to);
249 }
250
251 static irqreturn_t tegra_otg_irq(int irq, void *data)
252 {
253         struct tegra_otg_data *tegra = data;
254         unsigned long flags;
255         unsigned long val;
256
257         spin_lock_irqsave(&tegra->lock, flags);
258         val = otg_readl(tegra, USB_PHY_WAKEUP);
259         DBG("%s(%d) interrupt val = 0x%lx\n", __func__, __LINE__, val);
260
261         if (val & (USB_VBUS_INT_EN | USB_ID_INT_EN)) {
262                 DBG("%s(%d) PHY_WAKEUP = 0x%lx\n", __func__, __LINE__, val);
263                 otg_writel(tegra, val, USB_PHY_WAKEUP);
264                 if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
265                         tegra->int_status = val;
266                         schedule_work(&tegra->work);
267                 }
268         }
269         spin_unlock_irqrestore(&tegra->lock, flags);
270
271         return IRQ_HANDLED;
272 }
273
274
275 static int tegra_otg_set_peripheral(struct usb_otg *otg,
276                                 struct usb_gadget *gadget)
277 {
278         struct tegra_otg_data *tegra;
279         unsigned long val;
280         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
281
282         tegra = (struct tegra_otg_data *)container_of(otg->phy, struct tegra_otg_data, phy);
283         otg->gadget = gadget;
284
285         val = enable_interrupt(tegra, true);
286
287         if ((val & USB_ID_STATUS) && (val & USB_VBUS_STATUS))
288                 val |= USB_VBUS_INT_STATUS;
289         else if (!(val & USB_ID_STATUS)) {
290                 if(!tegra->builtin_host)
291                         val &= ~USB_ID_INT_STATUS;
292                 else
293                         val |= USB_ID_INT_STATUS;
294         }
295         else
296                 val &= ~(USB_ID_INT_STATUS | USB_VBUS_INT_STATUS);
297
298         if ((val & USB_ID_INT_STATUS) || (val & USB_VBUS_INT_STATUS)) {
299                 tegra->int_status = val;
300                 schedule_work(&tegra->work);
301         }
302
303         DBG("%s(%d) END\n", __func__, __LINE__);
304         return 0;
305 }
306
307 static int tegra_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
308 {
309         struct tegra_otg_data *tegra = container_of(otg->phy, struct tegra_otg_data, phy);
310         unsigned long val;
311         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
312
313         otg->host = host;
314
315         clk_enable(tegra->clk);
316         val = otg_readl(tegra, USB_PHY_WAKEUP);
317         val &= ~(USB_VBUS_INT_STATUS | USB_ID_INT_STATUS);
318         val |= (USB_ID_INT_EN | USB_ID_PIN_WAKEUP_EN);
319         otg_writel(tegra, val, USB_PHY_WAKEUP);
320         clk_disable(tegra->clk);
321
322         DBG("%s(%d) END\n", __func__, __LINE__);
323         return 0;
324 }
325
326 static ssize_t show_host_en(struct device *dev, struct device_attribute *attr,
327                                 char *buf)
328 {
329         struct platform_device *pdev = to_platform_device(dev);
330         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
331
332         *buf = tegra->interrupt_mode ? '0': '1';
333         strcat(buf, "\n");
334         return strlen(buf);
335 }
336
337 static ssize_t store_host_en(struct device *dev, struct device_attribute *attr,
338                                 const char *buf, size_t count)
339 {
340         struct platform_device *pdev = to_platform_device(dev);
341         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
342         unsigned long host;
343
344         if (sscanf(buf, "%d", &host) != 1 || host < 0 || host > 1)
345                 return -EINVAL;
346
347         if (host) {
348                 enable_interrupt(tegra, false);
349                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
350                 tegra_change_otg_state(tegra, OTG_STATE_A_HOST);
351                 tegra->interrupt_mode = false;
352         } else {
353                 tegra->interrupt_mode = true;
354                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
355                 enable_interrupt(tegra, true);
356         }
357
358         return count;
359 }
360
361 static DEVICE_ATTR(enable_host, 0644, show_host_en, store_host_en);
362
363 static int tegra_otg_set_power(struct usb_phy *phy, unsigned mA)
364 {
365         return 0;
366 }
367
368 static int tegra_otg_set_suspend(struct usb_phy *phy, int suspend)
369 {
370         return 0;
371 }
372
373 static int tegra_otg_probe(struct platform_device *pdev)
374 {
375         struct tegra_otg_data *tegra;
376         struct resource *res;
377         struct tegra_usb_otg_data *pdata = dev_get_platdata(&pdev->dev);
378         int err;
379
380         tegra = devm_kzalloc(&pdev->dev, sizeof(struct tegra_otg_data), GFP_KERNEL);
381         if (!tegra)
382                 return -ENOMEM;
383
384         tegra->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg), GFP_KERNEL);
385         if (!tegra->phy.otg) {
386                 dev_err(&pdev->dev, "unable to allocate otg\n");
387                 return -ENOMEM;
388         }
389
390         spin_lock_init(&tegra->lock);
391
392         if (pdata) {
393                 tegra->builtin_host = !pdata->ehci_pdata->builtin_host_disabled;
394         }
395
396         platform_set_drvdata(pdev, tegra);
397         tegra_clone = tegra;
398         tegra->interrupt_mode = true;
399         tegra->suspended = false;
400
401         tegra->clk = clk_get(&pdev->dev, NULL);
402         if (IS_ERR(tegra->clk)) {
403                 dev_err(&pdev->dev, "Can't get otg clock\n");
404                 err = PTR_ERR(tegra->clk);
405                 goto err_clk;
406         }
407
408         err = clk_enable(tegra->clk);
409         if (err)
410                 goto err_clken;
411
412         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
413         if (!res) {
414                 dev_err(&pdev->dev, "Failed to get I/O memory\n");
415                 err = -ENXIO;
416                 goto err_io;
417         }
418         tegra->regs = ioremap(res->start, resource_size(res));
419         if (!tegra->regs) {
420                 err = -ENOMEM;
421                 goto err_io;
422         }
423
424         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
425         if (!res) {
426                 dev_err(&pdev->dev, "Failed to get IRQ\n");
427                 err = -ENXIO;
428                 goto err_irq;
429         }
430         tegra->irq = res->start;
431         err = devm_request_threaded_irq(&pdev->dev, tegra->irq, tegra_otg_irq,
432                                    NULL,
433                                    IRQF_SHARED | IRQF_TRIGGER_HIGH,
434                                    "tegra-otg", tegra);
435         if (err) {
436                 dev_err(&pdev->dev, "Failed to register IRQ\n");
437                 goto err_irq;
438         }
439
440         err = enable_irq_wake(tegra->irq);
441         if (err < 0) {
442                 dev_warn(&pdev->dev,
443                         "Couldn't enable USB otg mode wakeup, irq=%d, error=%d\n",
444                         tegra->irq, err);
445                 err = 0;
446         }
447
448         INIT_WORK(&tegra->work, irq_work);
449
450         tegra->phy.label = "tegra-otg";
451         tegra->phy.otg->set_host = tegra_otg_set_host;
452         tegra->phy.otg->set_peripheral = tegra_otg_set_peripheral;
453         tegra->phy.set_suspend = tegra_otg_set_suspend;
454         tegra->phy.set_power = tegra_otg_set_power;
455         tegra->phy.state = OTG_STATE_A_SUSPEND;
456         tegra->phy.otg->phy = &tegra->phy;
457
458         err = usb_set_transceiver(&tegra->phy);
459         if (err) {
460                 dev_err(&pdev->dev, "usb_set_transceiver failed\n");
461                 goto err_clk;
462         }
463
464         err = device_create_file(&pdev->dev, &dev_attr_enable_host);
465         if (err) {
466                 dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
467                 goto err_irq;
468         }
469
470         clk_disable(tegra->clk);
471
472         dev_info(&pdev->dev, "otg transceiver registered\n");
473         return 0;
474
475 err_irq:
476         usb_set_transceiver(NULL);
477         iounmap(tegra->regs);
478 err_io:
479         clk_disable(tegra->clk);
480 err_clken:
481         clk_put(tegra->clk);
482 err_clk:
483         return err;
484 }
485
486 static int __exit tegra_otg_remove(struct platform_device *pdev)
487 {
488         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
489
490         usb_set_transceiver(NULL);
491         iounmap(tegra->regs);
492         clk_disable(tegra->clk);
493         clk_put(tegra->clk);
494         platform_set_drvdata(pdev, NULL);
495
496         return 0;
497 }
498
499 #ifdef CONFIG_PM
500 static int tegra_otg_suspend(struct device *dev)
501 {
502         struct platform_device *pdev = to_platform_device(dev);
503         struct tegra_otg_data *tegra = platform_get_drvdata(pdev);
504         struct usb_phy *phy = &tegra->phy;
505         enum usb_otg_state from = phy->otg->phy->state;
506         unsigned int val;
507
508         DBG("%s(%d) BEGIN state : %s\n", __func__, __LINE__,
509                                 tegra_state_name(phy->otg->phy->state));
510
511         clk_enable(tegra->clk);
512         val = otg_readl(tegra, USB_PHY_WAKEUP);
513         val &= ~(USB_ID_INT_EN | USB_VBUS_INT_EN);
514         otg_writel(tegra, val, USB_PHY_WAKEUP);
515         clk_disable(tegra->clk);
516
517         /* suspend peripheral mode, host mode is taken care by host driver */
518         if (from == OTG_STATE_B_PERIPHERAL)
519                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
520
521         tegra->suspended = true;
522
523         DBG("%s(%d) END\n", __func__, __LINE__);
524
525         return 0;
526 }
527
528 static void tegra_otg_resume(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 usb_otg *otg = tegra->phy.otg;
533         int val;
534         unsigned long flags;
535
536         DBG("%s(%d) BEGIN\n", __func__, __LINE__);
537
538         if (!tegra->suspended)
539                 return;
540
541         /* Clear pending interrupts */
542         clk_enable(tegra->clk);
543         val = otg_readl(tegra, USB_PHY_WAKEUP);
544         otg_writel(tegra, val, USB_PHY_WAKEUP);
545         DBG("%s(%d) PHY WAKEUP register : 0x%x\n", __func__, __LINE__, val);
546         clk_disable(tegra->clk);
547
548         /* Handle if host cable is replaced with device during suspend state */
549         if (otg->phy->state == OTG_STATE_A_HOST && (val & USB_ID_STATUS))
550                 tegra_change_otg_state(tegra, OTG_STATE_A_SUSPEND);
551
552         /* Enable interrupt and call work to set to appropriate state */
553         spin_lock_irqsave(&tegra->lock, flags);
554         if (tegra->builtin_host)
555                 tegra->int_status = val | USB_INT_EN;
556         else
557                 tegra->int_status = val | USB_VBUS_INT_EN | USB_VBUS_WAKEUP_EN |
558                         USB_ID_PIN_WAKEUP_EN;
559
560         spin_unlock_irqrestore(&tegra->lock, flags);
561         irq_work(&tegra->work);
562
563         enable_interrupt(tegra, true);
564
565         tegra->suspended = false;
566
567         DBG("%s(%d) END\n", __func__, __LINE__);
568 }
569
570 static const struct dev_pm_ops tegra_otg_pm_ops = {
571         .complete = tegra_otg_resume,
572         .suspend = tegra_otg_suspend,
573 };
574 #endif
575
576 static struct platform_driver tegra_otg_driver = {
577         .driver = {
578                 .name  = "tegra-otg",
579 #ifdef CONFIG_PM
580                 .pm    = &tegra_otg_pm_ops,
581 #endif
582         },
583         .remove  = __exit_p(tegra_otg_remove),
584         .probe   = tegra_otg_probe,
585 };
586
587 static int __init tegra_otg_init(void)
588 {
589         return platform_driver_register(&tegra_otg_driver);
590 }
591 subsys_initcall(tegra_otg_init);
592
593 static void __exit tegra_otg_exit(void)
594 {
595         platform_driver_unregister(&tegra_otg_driver);
596 }
597 module_exit(tegra_otg_exit);