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