63fc543c94a94a7ff654ed26c949ff4a2d7e5604
[sitara-epos/sitara-epos-kernel.git] / drivers / usb / musb / ti81xx.c
1 /*
2  * Texas Instruments TI81XX "usb platform glue layer"
3  *
4  * Copyright (c) 2008, MontaVista Software, Inc. <source@mvista.com>
5  *
6  * Based on the DaVinci "glue layer" code.
7  * Copyright (C) 2005-2006 by Texas Instruments
8  *
9  * This file is part of the Inventra Controller Driver for Linux.
10  *
11  * The Inventra Controller Driver for Linux is free software; you
12  * can redistribute it and/or modify it under the terms of the GNU
13  * General Public License version 2 as published by the Free Software
14  * Foundation.
15  *
16  * The Inventra Controller Driver for Linux is distributed in
17  * the hope that it will be useful, but WITHOUT ANY WARRANTY;
18  * without even the implied warranty of MERCHANTABILITY or
19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
20  * License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with The Inventra Controller Driver for Linux ; if not,
24  * write to the Free Software Foundation, Inc., 59 Temple Place,
25  * Suite 330, Boston, MA  02111-1307  USA
26  *
27  */
29 #include <linux/init.h>
30 #include <linux/clk.h>
31 #include <linux/io.h>
32 #include <linux/usb/otg.h>
33 #include <linux/platform_device.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/module.h>
37 #include "cppi41.h"
38 #include "ti81xx.h"
40 #include "musb_core.h"
41 #include "cppi41_dma.h"
43 struct ti81xx_glue {
44         struct device *dev;
45         struct clk *ick;                /* common usbss interface clk */
46         struct clk *fck;                /* common usbss functional clk */
47         struct resource *mem_pa;        /* usbss memory resource */
48         void *mem_va;                   /* ioremapped virtual address */
49         struct platform_device *musb[2];/* child musb pdevs */
50         u8      irq;                    /* usbss irq */
51 };
52 static u64 musb_dmamask = DMA_BIT_MASK(32);
53 static void *usbss_virt_base;
54 static u8 usbss_init_done;
55 struct musb *gmusb[2];
57 u8 usbid_sw_ctrl;
58 #undef USB_TI81XX_DEBUG
60 #ifdef USB_TI81XX_DEBUG
61 #define dprintk(x, ...) printk(x, ## __VA_ARGS__)
62 #else
63 #define dprintk(x, ...)
64 #endif
66 #ifdef CONFIG_USB_TI_CPPI41_DMA
67 static irqreturn_t cppi41dma_Interrupt(int irq, void *hci);
68 static u8 cppi41_init_done;
69 static void *cppi41_dma_base;
70 #define CPPI41_ADDR(offs) ((void *)((u32)cppi41_dma_base + (offs - 0x2000)))
71 #endif
73 extern void omap_ctrl_writel(u32 val, u16 offset);
74 extern u32 omap_ctrl_readl(u16 offset);
76 static inline u32 usbss_read(u32 offset)
77 {
78         if (!usbss_init_done)
79                 return 0;
80         return __raw_readl(usbss_virt_base + offset);
81 }
83 static inline void usbss_write(u32 offset, u32 data)
84 {
85         if (!usbss_init_done)
86                 return ;
87         __raw_writel(data, usbss_virt_base + offset);
88 }
90 static void usbotg_ss_init(void)
91 {
92         if (!usbss_init_done) {
93                 /* reset the usbss for usb0/usb1 */
94                 usbss_write(USBSS_SYSCONFIG,
95                         usbss_read(USBSS_SYSCONFIG) | USB_SOFT_RESET_MASK);
97                 /* clear any USBSS interrupts */
98                 usbss_write(USBSS_IRQ_EOI, 0);
99                 usbss_write(USBSS_IRQ_STATUS, usbss_read(USBSS_IRQ_STATUS));
100                 usbss_init_done = 1;
101         }
103 static void usbotg_ss_uninit(void)
105         if (usbss_init_done) {
106                 usbss_init_done = 0;
107                 usbss_virt_base = 0;
108         }
110 void set_frame_threshold(struct musb *musb, u8 is_tx, u8 epnum, u8 value, u8 en_intr)
112         u32     base, reg_val, frame_intr = 0, frame_base = 0;
113         u32     offs = epnum/4*4;
114         u8      indx = (epnum % 4) * 8;
116         if (is_tx)
117                 base = musb->id ? USBSS_IRQ_FRAME_THRESHOLD_TX1 :
118                                 USBSS_IRQ_FRAME_THRESHOLD_TX0;
119         else
120                 base = musb->id ? USBSS_IRQ_FRAME_THRESHOLD_RX1 :
121                                 USBSS_IRQ_FRAME_THRESHOLD_RX0;
123         reg_val = usbss_read(base + offs);
124         reg_val &= ~(0xFF << indx);
125         reg_val |= (value << indx);
126         usbss_write(base + offs, reg_val);
128         if (en_intr) {
129                 frame_base = musb->id ? USBSS_IRQ_FRAME_ENABLE_1 :
130                         USBSS_IRQ_FRAME_ENABLE_0;
131                 frame_intr = musb->id ? usbss_read(USBSS_IRQ_FRAME_ENABLE_0) :
132                         usbss_read(USBSS_IRQ_FRAME_ENABLE_1);
133                 frame_intr |= is_tx ? (1 << epnum) : (1 << (16 + epnum));
134                 usbss_write(frame_base, frame_intr);
135                 dev_dbg(musb->controller, "%s: framebase=%x, frame_intr=%x\n",
136                         is_tx ? "tx" : "rx", frame_base, frame_intr);
137         }
140 void set_dma_threshold(struct musb *musb, u8 is_tx, u8 epnum, u8 value)
142         u32     base, reg_val;
143         u32     offs = epnum/4*4;
144         u8      indx = (epnum % 4) * 8;
146         if (musb->id == 0)
147                 base = is_tx ? USBSS_IRQ_DMA_THRESHOLD_TX0 :
148                                 USBSS_IRQ_DMA_THRESHOLD_RX0;
149         else
150                 base = is_tx ? USBSS_IRQ_DMA_THRESHOLD_TX1 :
151                                 USBSS_IRQ_DMA_THRESHOLD_RX1;
153         reg_val = usbss_read(base + offs);
154         reg_val &= ~(0xFF << indx);
155         reg_val |= (value << indx);
156         dev_dbg(musb->controller, "base=%x, offs=%x, indx=%d, reg_val = (%x)%x\n",
157                 base, offs, indx, reg_val, usbss_read(base + offs));
158         usbss_write(base + offs, reg_val);
161 /* ti81xx specific read/write functions */
162 u16 ti81xx_musb_readw(const void __iomem *addr, unsigned offset)
164         u32 tmp;
165         u16 val;
167         tmp = __raw_readl(addr + (offset & ~3));
169         switch (offset & 0x3) {
170         case 0:
171                 val = (tmp & 0xffff);
172                 break;
173         case 1:
174                 val = (tmp >> 8) & 0xffff;
175                 break;
176         case 2:
177         case 3:
178         default:
179                 val = (tmp >> 16) & 0xffff;
180                 break;
181         }
182         return val;
185 void ti81xx_musb_writew(void __iomem *addr, unsigned offset, u16 data)
187         __raw_writew(data, addr + offset);
190 u8 ti81xx_musb_readb(const void __iomem *addr, unsigned offset)
192         u32 tmp;
193         u8 val;
195         tmp = __raw_readl(addr + (offset & ~3));
197         switch (offset & 0x3) {
198         case 0:
199                 val = tmp & 0xff;
200                 break;
201         case 1:
202                 val = (tmp >> 8);
203                 break;
204         case 2:
205                 val = (tmp >> 16);
206                 break;
207         case 3:
208         default:
209                 val = (tmp >> 24);
210                 break;
211         }
212         return val;
214 void ti81xx_musb_writeb(void __iomem *addr, unsigned offset, u8 data)
216         __raw_writeb(data, addr + offset);
219 #ifdef CONFIG_USB_TI_CPPI41_DMA
220 /*
221  * CPPI 4.1 resources used for USB OTG controller module:
222  *
223  tx/rx completion queues for usb0 */
224 static u16 tx_comp_q[] = {93, 94, 95, 96, 97,
225                                 98, 99, 100, 101, 102,
226                                 103, 104, 105, 106, 107 };
228 static u16 rx_comp_q[] = {109, 110, 111, 112, 113,
229                                 114, 115, 116, 117, 118,
230                                 119, 120, 121, 122, 123 };
232 /* tx/rx completion queues for usb1 */
233 static u16 tx_comp_q1[] = {125, 126, 127, 128, 129,
234                                  130, 131, 132, 133, 134,
235                                  135, 136, 137, 138, 139 };
237 static u16 rx_comp_q1[] = {141, 142, 143, 144, 145,
238                                  146, 147, 148, 149, 150,
239                                  151, 152, 153, 154, 155 };
241 /* Fair scheduling */
242 u32 dma_sched_table[] = {
243         0x81018000, 0x83038202, 0x85058404, 0x87078606,
244         0x89098808, 0x8b0b8a0a, 0x8d0d8c0c, 0x8f0f8e0e,
245         0x91119010, 0x93139212, 0x95159414, 0x97179616,
246         0x99199818, 0x9b1b9a1a, 0x9d1d9c1c, 0x00009e1e,
247 };
249 /* cppi41 dma tx channel info */
250 static const struct cppi41_tx_ch tx_ch_info[] = {
251         [0] = {
252                 .port_num       = 1,
253                 .num_tx_queue   = 2,
254                 .tx_queue       = { {0, 32} , {0, 33} }
255         },
256         [1] = {
257                 .port_num       = 2,
258                 .num_tx_queue   = 2,
259                 .tx_queue       = { {0, 34} , {0, 35} }
260         },
261         [2] = {
262                 .port_num       = 3,
263                 .num_tx_queue   = 2,
264                 .tx_queue       = { {0, 36} , {0, 37} }
265         },
266         [3] = {
267                 .port_num       = 4,
268                 .num_tx_queue   = 2,
269                 .tx_queue       = { {0, 38} , {0, 39} }
270         },
271         [4] = {
272                 .port_num       = 5,
273                 .num_tx_queue   = 2,
274                 .tx_queue       = { {0, 40} , {0, 41} }
275         },
276         [5] = {
277                 .port_num       = 6,
278                 .num_tx_queue   = 2,
279                 .tx_queue       = { {0, 42} , {0, 43} }
280         },
281         [6] = {
282                 .port_num       = 7,
283                 .num_tx_queue   = 2,
284                 .tx_queue       = { {0, 44} , {0, 45} }
285         },
286         [7] = {
287                 .port_num       = 8,
288                 .num_tx_queue   = 2,
289                 .tx_queue       = { {0, 46} , {0, 47} }
290         },
291         [8] = {
292                 .port_num       = 9,
293                 .num_tx_queue   = 2,
294                 .tx_queue       = { {0, 48} , {0, 49} }
295         },
296         [9] = {
297                 .port_num       = 10,
298                 .num_tx_queue   = 2,
299                 .tx_queue       = { {0, 50} , {0, 51} }
300         },
301         [10] = {
302                 .port_num       = 11,
303                 .num_tx_queue   = 2,
304                 .tx_queue       = { {0, 52} , {0, 53} }
305         },
306         [11] = {
307                 .port_num       = 12,
308                 .num_tx_queue   = 2,
309                 .tx_queue       = { {0, 54} , {0, 55} }
310         },
311         [12] = {
312                 .port_num       = 13,
313                 .num_tx_queue   = 2,
314                 .tx_queue       = { {0, 56} , {0, 57} }
315         },
316         [13] = {
317                 .port_num       = 14,
318                 .num_tx_queue   = 2,
319                 .tx_queue       = { {0, 58} , {0, 59} }
320         },
321         [14] = {
322                 .port_num       = 15,
323                 .num_tx_queue   = 2,
324                 .tx_queue       = { {0, 60} , {0, 61} }
325         },
326         [15] = {
327                 .port_num       = 1,
328                 .num_tx_queue   = 2,
329                 .tx_queue       = { {0, 62} , {0, 63} }
330         },
331         [16] = {
332                 .port_num       = 2,
333                 .num_tx_queue   = 2,
334                 .tx_queue       = { {0, 64} , {0, 65} }
335         },
336         [17] = {
337                 .port_num       = 3,
338                 .num_tx_queue   = 2,
339                 .tx_queue       = { {0, 66} , {0, 67} }
340         },
341         [18] = {
342                 .port_num       = 4,
343                 .num_tx_queue   = 2,
344                 .tx_queue       = { {0, 68} , {0, 69} }
345         },
346         [19] = {
347                 .port_num       = 5,
348                 .num_tx_queue   = 2,
349                 .tx_queue       = { {0, 70} , {0, 71} }
350         },
351         [20] = {
352                 .port_num       = 6,
353                 .num_tx_queue   = 2,
354                 .tx_queue       = { {0, 72} , {0, 73} }
355         },
356         [21] = {
357                 .port_num       = 7,
358                 .num_tx_queue   = 2,
359                 .tx_queue       = { {0, 74} , {0, 75} }
360         },
361         [22] = {
362                 .port_num       = 8,
363                 .num_tx_queue   = 2,
364                 .tx_queue       = { {0, 76} , {0, 77} }
365         },
366         [23] = {
367                 .port_num       = 9,
368                 .num_tx_queue   = 2,
369                 .tx_queue       = { {0, 78} , {0, 79} }
370         },
371         [24] = {
372                 .port_num       = 10,
373                 .num_tx_queue   = 2,
374                 .tx_queue       = { {0, 80} , {0, 81} }
375         },
376         [25] = {
377                 .port_num       = 11,
378                 .num_tx_queue   = 2,
379                 .tx_queue       = { {0, 82} , {0, 83} }
380         },
381         [26] = {
382                 .port_num       = 12,
383                 .num_tx_queue   = 2,
384                 .tx_queue       = { {0, 84} , {0, 85} }
385         },
386         [27] = {
387                 .port_num       = 13,
388                 .num_tx_queue   = 2,
389                 .tx_queue       = { {0, 86} , {0, 87} }
390         },
391         [28] = {
392                 .port_num       = 14,
393                 .num_tx_queue   = 2,
394                 .tx_queue       = { {0, 88} , {0, 89} }
395         },
396         [29] = {
397                 .port_num       = 15,
398                 .num_tx_queue   = 2,
399                 .tx_queue       = { {0, 90} , {0, 91} }
400         }
401 };
403 /* Queues 0 to 66 are pre-assigned, others are spare */
404 static const u32 assigned_queues[] = {  0xffffffff, /* queue 0..31 */
405                                         0xffffffff, /* queue 32..63 */
406                                         0xffffffff, /* queue 64..95 */
407                                         0xffffffff, /* queue 96..127 */
408                                         0x0fffffff  /* queue 128..155 */
409                                         };
411 int __devinit cppi41_init(u8 id, u8 irq, int num_instances)
413         struct usb_cppi41_info *cppi_info = &usb_cppi41_info[id];
414         u16 numch, blknum, order;
415         u32 i;
417         /* init cppi info structure  */
418         cppi_info->dma_block = 0;
419         for (i = 0 ; i < USB_CPPI41_NUM_CH ; i++)
420                 cppi_info->ep_dma_ch[i] = i + (15 * id);
422         cppi_info->q_mgr = 0;
423         cppi_info->num_tx_comp_q = 15;
424         cppi_info->num_rx_comp_q = 15;
425         cppi_info->tx_comp_q = id ? tx_comp_q1 : tx_comp_q;
426         cppi_info->rx_comp_q = id ? rx_comp_q1 : rx_comp_q;
427         cppi_info->bd_intr_ctrl = 1;
429         if (cppi41_init_done)
430                 return 0;
432         blknum = cppi_info->dma_block;
434         /* Queue manager information */
435         cppi41_queue_mgr[0].num_queue = 159;
436         cppi41_queue_mgr[0].queue_types = CPPI41_FREE_DESC_BUF_QUEUE |
437                                                 CPPI41_UNASSIGNED_QUEUE;
438         cppi41_queue_mgr[0].base_fdbq_num = 0;
439         cppi41_queue_mgr[0].assigned = assigned_queues;
441         /* init DMA block */
442         cppi41_dma_block[0].num_tx_ch = 30;
443         cppi41_dma_block[0].num_rx_ch = 30;
444         cppi41_dma_block[0].tx_ch_info = tx_ch_info;
446         /* initilize cppi41 dma & Qmgr address */
447         cppi41_dma_base = ioremap(TI81XX_USB_CPPIDMA_BASE,
448                                         TI81XX_USB_CPPIDMA_LEN);
450         cppi41_queue_mgr[0].q_mgr_rgn_base = CPPI41_ADDR(QMGR_RGN_OFFS);
451         cppi41_queue_mgr[0].desc_mem_rgn_base = CPPI41_ADDR(QMRG_DESCRGN_OFFS);
452         cppi41_queue_mgr[0].q_mgmt_rgn_base = CPPI41_ADDR(QMGR_REG_OFFS);
453         cppi41_queue_mgr[0].q_stat_rgn_base = CPPI41_ADDR(QMGR_STAT_OFFS);
454         cppi41_dma_block[0].global_ctrl_base = CPPI41_ADDR(DMA_GLBCTRL_OFFS);
455         cppi41_dma_block[0].ch_ctrl_stat_base = CPPI41_ADDR(DMA_CHCTRL_OFFS);
456         cppi41_dma_block[0].sched_ctrl_base = CPPI41_ADDR(DMA_SCHED_OFFS);
457         cppi41_dma_block[0].sched_table_base = CPPI41_ADDR(DMA_SCHEDTBL_OFFS);
459         /* Initialize for Linking RAM region 0 alone */
460         cppi41_queue_mgr_init(cppi_info->q_mgr, 0, 0x3fff);
462         numch =  USB_CPPI41_NUM_CH * 2 * num_instances;
463         cppi41_dma_block[0].num_max_ch = numch;
465         order = get_count_order(numch);
467         /* TODO: check two teardown desc per channel (5 or 7 ?)*/
468         if (order < 5)
469                 order = 5;
471         cppi41_dma_block_init(blknum, cppi_info->q_mgr, order,
472                         dma_sched_table, numch);
474         /* attach to the IRQ */
475         if (request_irq(irq, cppi41dma_Interrupt, 0, "cppi41_dma", 0))
476                 printk(KERN_INFO "request_irq %d failed!\n", irq);
477         else
478                 printk(KERN_INFO "registerd cppi-dma Intr @ IRQ %d\n", irq);
480         cppi41_init_done = 1;
482         printk(KERN_INFO "Cppi41 Init Done Qmgr-base(%p) dma-base(%p)\n",
483                 cppi41_queue_mgr[0].q_mgr_rgn_base,
484                 cppi41_dma_block[0].global_ctrl_base);
486         /* enable all usbss the interrupts */
487         usbss_write(USBSS_IRQ_EOI, 0);
488         usbss_write(USBSS_IRQ_ENABLE_SET, USBSS_INTR_FLAGS);
489         usbss_write(USBSS_IRQ_DMA_ENABLE_0, 0xFFFeFFFe);
491         printk(KERN_INFO "Cppi41 Init Done\n");
493         return 0;
496 void cppi41_free(void)
498         u32 numch, blknum, order;
499         struct usb_cppi41_info *cppi_info = &usb_cppi41_info[0];
501         if (!cppi41_init_done)
502                 return ;
504         numch = cppi41_dma_block[0].num_max_ch;
505         order = get_count_order(numch);
506         blknum = cppi_info->dma_block;
508         cppi41_dma_block_uninit(blknum, cppi_info->q_mgr, order,
509                         dma_sched_table, numch);
510         cppi41_queue_mgr_uninit(cppi_info->q_mgr);
512         iounmap(cppi41_dma_base);
513         cppi41_dma_base = 0;
514         cppi41_init_done = 0;
517 int cppi41_disable_sched_rx(void)
519         cppi41_dma_sched_tbl_init(0, 0, dma_sched_table, 30);
520         return 0;
523 int cppi41_enable_sched_rx(void)
525         cppi41_dma_sched_tbl_init(0, 0, dma_sched_table, 30);
526         return 0;
528 #endif /* CONFIG_USB_TI_CPPI41_DMA */
530 /*
531  * Because we don't set CTRL.UINT, it's "important" to:
532  *      - not read/write INTRUSB/INTRUSBE (except during
533  *        initial setup, as a workaround);
534  *      - use INTSET/INTCLR instead.
535  */
537 /**
538  * ti81xx_musb_enable - enable interrupts
539  */
540 void ti81xx_musb_enable(struct musb *musb)
542         void __iomem *reg_base = musb->ctrl_base;
543         u32 epmask, coremask;
545         /* Workaround: setup IRQs through both register sets. */
546         epmask = ((musb->epmask & USB_TX_EP_MASK) << USB_INTR_TX_SHIFT) |
547                ((musb->epmask & USB_RX_EP_MASK) << USB_INTR_RX_SHIFT);
548         coremask = (0x01ff << USB_INTR_USB_SHIFT);
550         coremask &= ~MUSB_INTR_SOF;
552         musb_writel(reg_base, USB_EP_INTR_SET_REG, epmask);
553         musb_writel(reg_base, USB_CORE_INTR_SET_REG, coremask);
554         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
555         if (is_otg_enabled(musb))
556                 musb_writel(reg_base, USB_CORE_INTR_SET_REG,
557                             USB_INTR_DRVVBUS << USB_INTR_USB_SHIFT);
560 /**
561  * ti81xx_musb_disable - disable HDRC and flush interrupts
562  */
563 void ti81xx_musb_disable(struct musb *musb)
565         void __iomem *reg_base = musb->ctrl_base;
567         musb_writel(reg_base, USB_CORE_INTR_CLEAR_REG, USB_INTR_USB_MASK);
568         musb_writel(reg_base, USB_EP_INTR_CLEAR_REG,
569                          USB_TX_INTR_MASK | USB_RX_INTR_MASK);
570         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
571         musb_writel(reg_base, USB_IRQ_EOI, 0);
574 #define POLL_SECONDS    2
576 static struct timer_list otg_workaround;
578 static void otg_timer(unsigned long _musb)
580         struct musb             *musb = (void *)_musb;
581         void __iomem            *mregs = musb->mregs;
582         u8                      devctl;
583         unsigned long           flags;
585         /* We poll because DaVinci's won't expose several OTG-critical
586         * status change events (from the transceiver) otherwise.
587          */
588         devctl = musb_readb(mregs, MUSB_DEVCTL);
589         dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
590                         otg_state_string(musb->xceiv->state));
592         spin_lock_irqsave(&musb->lock, flags);
593         switch (musb->xceiv->state) {
594         case OTG_STATE_A_WAIT_BCON:
595                 devctl &= ~MUSB_DEVCTL_SESSION;
596                 musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
598                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
599                 if (devctl & MUSB_DEVCTL_BDEVICE) {
600                         musb->xceiv->state = OTG_STATE_B_IDLE;
601                         MUSB_DEV_MODE(musb);
602                 } else {
603                         musb->xceiv->state = OTG_STATE_A_IDLE;
604                         MUSB_HST_MODE(musb);
605                 }
606                 break;
607         case OTG_STATE_A_WAIT_VFALL:
608                 /*
609                  * Wait till VBUS falls below SessionEnd (~0.2 V); the 1.3
610                  * RTL seems to mis-handle session "start" otherwise (or in
611                  * our case "recover"), in routine "VBUS was valid by the time
612                  * VBUSERR got reported during enumeration" cases.
613                  */
614                 if (devctl & MUSB_DEVCTL_VBUS) {
615                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
616                         break;
617                 }
618                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
619                 musb_writel(musb->ctrl_base, USB_CORE_INTR_SET_REG,
620                             MUSB_INTR_VBUSERROR << USB_INTR_USB_SHIFT);
621                 break;
622         case OTG_STATE_B_IDLE:
623                 if (!is_peripheral_enabled(musb))
624                         break;
626                 /*
627                  * There's no ID-changed IRQ, so we have no good way to tell
628                  * when to switch to the A-Default state machine (by setting
629                  * the DEVCTL.SESSION flag).
630                  *
631                  * Workaround:  whenever we're in B_IDLE, try setting the
632                  * session flag every few seconds.  If it works, ID was
633                  * grounded and we're now in the A-Default state machine.
634                  *
635                  * NOTE: setting the session flag is _supposed_ to trigger
636                  * SRP but clearly it doesn't.
637                  */
638                 devctl = musb_readb(mregs, MUSB_DEVCTL);
639                 if (devctl & MUSB_DEVCTL_BDEVICE)
640                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
641                 else
642                         musb->xceiv->state = OTG_STATE_A_IDLE;
643                 break;
644         default:
645                 break;
646         }
647         spin_unlock_irqrestore(&musb->lock, flags);
650 void ti81xx_musb_try_idle(struct musb *musb, unsigned long timeout)
652         static unsigned long last_timer;
654         if (!is_otg_enabled(musb))
655                 return;
657         if (timeout == 0)
658                 timeout = jiffies + msecs_to_jiffies(3);
660         /* Never idle if active, or when VBUS timeout is not set as host */
661         if (musb->is_active || (musb->a_wait_bcon == 0 &&
662                                 musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
663                 dev_dbg(musb->controller, "%s active, deleting timer\n",
664                         otg_state_string(musb->xceiv->state));
665                 del_timer(&otg_workaround);
666                 last_timer = jiffies;
667                 return;
668         }
670         if (time_after(last_timer, timeout) && timer_pending(&otg_workaround)) {
671                 dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");
672                 return;
673         }
674         last_timer = timeout;
676         dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
677             otg_state_string(musb->xceiv->state),
678                 jiffies_to_msecs(timeout - jiffies));
679         mod_timer(&otg_workaround, timeout);
682 #ifdef CONFIG_USB_TI_CPPI41_DMA
683 static irqreturn_t cppi41dma_Interrupt(int irq, void *hci)
685         struct musb  *musb = hci;
686         u32 intr_status;
687         irqreturn_t ret = IRQ_NONE;
688         u32 q_cmpl_status_0, q_cmpl_status_1, q_cmpl_status_2;
689         u32 usb0_tx_intr, usb0_rx_intr;
690         u32 usb1_tx_intr, usb1_rx_intr;
691         void *q_mgr_base = cppi41_queue_mgr[0].q_mgr_rgn_base;
692         unsigned long flags;
694         musb = hci;
695         /*
696          * CPPI 4.1 interrupts share the same IRQ and the EOI register but
697          * don't get reflected in the interrupt source/mask registers.
698          */
699         /*
700          * Check for the interrupts from Tx/Rx completion queues; they
701          * are level-triggered and will stay asserted until the queues
702          * are emptied.  We're using the queue pending register 0 as a
703          * substitute for the interrupt status register and reading it
704          * directly for speed.
705          */
706         intr_status = usbss_read(USBSS_IRQ_STATUS);
708         if (intr_status)
709                 usbss_write(USBSS_IRQ_STATUS, intr_status);
710         else
711                 printk(KERN_DEBUG "spurious usbss intr\n");
713         q_cmpl_status_0 = musb_readl(q_mgr_base, CPPI41_QSTATUS_REG2);
714         q_cmpl_status_1 = musb_readl(q_mgr_base, CPPI41_QSTATUS_REG3);
715         q_cmpl_status_2 = musb_readl(q_mgr_base, CPPI41_QSTATUS_REG4);
717         /* USB0 tx/rx completion */
718         /* usb0 tx completion interrupt for ep1..15 */
719         usb0_tx_intr = (q_cmpl_status_0 >> 29) |
720                         ((q_cmpl_status_1 & 0xFFF) << 3);
721         usb0_rx_intr = ((q_cmpl_status_1 & 0x07FFe000) >> 13);
723         usb1_tx_intr = (q_cmpl_status_1 >> 29) |
724                         ((q_cmpl_status_2 & 0xFFF) << 3);
725         usb1_rx_intr = ((q_cmpl_status_2 & 0x0fffe000) >> 13);
727         /* get proper musb handle based usb0/usb1 ctrl-id */
729         dev_dbg(musb->controller, "CPPI 4.1 IRQ: Tx %x, Rx %x\n", usb0_tx_intr,
730                                 usb0_rx_intr);
731         if (gmusb[0] && (usb0_tx_intr || usb0_rx_intr)) {
732                 spin_lock_irqsave(&gmusb[0]->lock, flags);
733                 cppi41_completion(gmusb[0], usb0_rx_intr,
734                                         usb0_tx_intr);
735                 spin_unlock_irqrestore(&gmusb[0]->lock, flags);
736                 ret = IRQ_HANDLED;
737         }
739         dev_dbg(musb->controller, "CPPI 4.1 IRQ: Tx %x, Rx %x\n", usb1_tx_intr,
740                 usb1_rx_intr);
741         if (gmusb[1] && (usb1_rx_intr || usb1_tx_intr)) {
742                 spin_lock_irqsave(&gmusb[1]->lock, flags);
743                 cppi41_completion(gmusb[1], usb1_rx_intr,
744                         usb1_tx_intr);
745                 spin_unlock_irqrestore(&gmusb[1]->lock, flags);
746                 ret = IRQ_HANDLED;
747         }
748         usbss_write(USBSS_IRQ_EOI, 0);
750         return ret;
752 #endif
754 int musb_simulate_babble(struct musb *musb)
756         void __iomem *reg_base = musb->ctrl_base;
757         void __iomem *mbase = musb->mregs;
758         u8 reg;
760         /* during babble condition musb controller
761          * remove the session
762          */
763         reg = musb_readb(mbase, MUSB_DEVCTL);
764         reg &= ~MUSB_DEVCTL_SESSION;
765         musb_writeb(mbase, MUSB_DEVCTL, reg);
766         mdelay(100);
768         /* generate s/w babble interrupt */
769         musb_writel(reg_base, USB_IRQ_STATUS_RAW_1,
770                 MUSB_INTR_BABBLE);
771         return 0;
773 EXPORT_SYMBOL(musb_simulate_babble);
775 void musb_babble_workaround(struct musb *musb)
777         void __iomem *reg_base = musb->ctrl_base;
778         struct device *dev = musb->controller;
779         struct musb_hdrc_platform_data *plat = dev->platform_data;
780         struct omap_musb_board_data *data = plat->board_data;
782         /* Reset the controller */
783         musb_writel(reg_base, USB_CTRL_REG, USB_SOFT_RESET_MASK);
784         udelay(100);
786         /* Shutdown the on-chip PHY and its PLL. */
787         if (data->set_phy_power)
788                 data->set_phy_power(0);
789         udelay(100);
791         musb_platform_set_mode(musb, MUSB_HOST);
792         udelay(100);
794         /* enable the usbphy */
795         if (data->set_phy_power)
796                 data->set_phy_power(1);
797         mdelay(100);
799         /* save the usbotgss register contents */
800         musb_platform_enable(musb);
802         musb_start(musb);
805 static void evm_deferred_musb_restart(struct work_struct *work)
807         struct musb *musb =
808                 container_of(work, struct musb, work);
810         ERR("deferred musb restart musbid(%d)\n", musb->id);
811         musb_babble_workaround(musb);
814 static irqreturn_t ti81xx_interrupt(int irq, void *hci)
816         struct musb  *musb = hci;
817         void __iomem *reg_base = musb->ctrl_base;
818         unsigned long flags;
819         irqreturn_t ret = IRQ_NONE;
820         u32 pend1 = 0, pend2 = 0;
821         u32 epintr, usbintr;
822         u8  is_babble = 0;
824         spin_lock_irqsave(&musb->lock, flags);
826         /* Acknowledge and handle non-CPPI interrupts */
827         /* Get endpoint interrupts */
828         epintr = musb_readl(reg_base, USB_EP_INTR_STATUS_REG);
829         musb->int_rx = (epintr & USB_RX_INTR_MASK) >> USB_INTR_RX_SHIFT;
830         musb->int_tx = (epintr & USB_TX_INTR_MASK) >> USB_INTR_TX_SHIFT;
831         if (epintr)
832                 musb_writel(reg_base, USB_EP_INTR_STATUS_REG, epintr);
834         /* Get usb core interrupts */
835         usbintr = musb_readl(reg_base, USB_CORE_INTR_STATUS_REG);
836         if (!usbintr && !epintr) {
837                 dev_dbg(musb->controller, "sprious interrupt\n");
838                 goto eoi;
839         }
841         if (usbintr)
842                 musb_writel(reg_base, USB_CORE_INTR_STATUS_REG, usbintr);
843         musb->int_usb = (usbintr & USB_INTR_USB_MASK) >> USB_INTR_USB_SHIFT;
845         dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n", usbintr, epintr);
846         /*
847          * DRVVBUS IRQs are the only proxy we have (a very poor one!) for
848          * AM3517's missing ID change IRQ.  We need an ID change IRQ to
849          * switch appropriately between halves of the OTG state machine.
850          * Managing DEVCTL.SESSION per Mentor docs requires that we know its
851          * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
852          * Also, DRVVBUS pulses for SRP (but not at 5V) ...
853          */
854         if ((usbintr & MUSB_INTR_BABBLE) && is_otg_enabled(musb)
855                 && (musb->xceiv->state == OTG_STATE_A_HOST))
856                 is_babble = 1;
857         else if ((usbintr & MUSB_INTR_BABBLE) && !is_otg_enabled(musb)
858                 && is_host_enabled(musb))
859                         is_babble = 1;
861         if (is_babble) {
862                 if (musb->enable_babble_work)
863                         musb->int_usb |= MUSB_INTR_DISCONNECT;
865                 ERR("CAUTION: musb%d: Babble Interrupt Occured\n", musb->id);
866                 ERR("Please issue long reset to make usb functional !!\n");
867         }
869         if (usbintr & (USB_INTR_DRVVBUS << USB_INTR_USB_SHIFT)) {
870                 int drvvbus = musb_readl(reg_base, USB_STAT_REG);
871                 void __iomem *mregs = musb->mregs;
872                 u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
873                 int err;
875                 err = is_host_enabled(musb) && (musb->int_usb &
876                                                 MUSB_INTR_VBUSERROR);
877                 if (err) {
878                         /*
879                          * The Mentor core doesn't debounce VBUS as needed
880                          * to cope with device connect current spikes. This
881                          * means it's not uncommon for bus-powered devices
882                          * to get VBUS errors during enumeration.
883                          *
884                          * This is a workaround, but newer RTL from Mentor
885                          * seems to allow a better one: "re"-starting sessions
886                          * without waiting for VBUS to stop registering in
887                          * devctl.
888                          */
889                         musb->int_usb &= ~MUSB_INTR_VBUSERROR;
890                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
891                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
892                         WARNING("VBUS error workaround (delay coming)\n");
893                 } else if (is_host_enabled(musb) && drvvbus) {
894                         musb->is_active = 1;
895                         MUSB_HST_MODE(musb);
896                         musb->xceiv->default_a = 1;
897                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
898                         del_timer(&otg_workaround);
899                 } else {
900                         musb->is_active = 0;
901                         MUSB_DEV_MODE(musb);
902                         musb->xceiv->default_a = 0;
903                         musb->xceiv->state = OTG_STATE_B_IDLE;
904                 }
906                 /* NOTE: this must complete power-on within 100 ms. */
907                 dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
908                                 drvvbus ? "on" : "off",
909                                 otg_state_string(musb->xceiv->state),
910                                 err ? " ERROR" : "",
911                                 devctl);
912                 ret = IRQ_HANDLED;
913         }
915         if (musb->int_tx || musb->int_rx || musb->int_usb)
916                 ret |= musb_interrupt(musb);
918  eoi:
919         /* EOI needs to be written for the IRQ to be re-asserted. */
920         if (ret == IRQ_HANDLED || epintr || usbintr) {
921                 /* write EOI */
922                 musb_writel(reg_base, USB_IRQ_EOI, 1);
923         }
925         /* Poll for ID change */
926         if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
927                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
929         spin_unlock_irqrestore(&musb->lock, flags);
931         if (ret != IRQ_HANDLED) {
932                 if (epintr || usbintr)
933                         /*
934                          * We sometimes get unhandled IRQs in the peripheral
935                          * mode from EP0 and SOF...
936                          */
937                         dev_dbg(musb->controller, "Unhandled USB IRQ %08x-%08x\n",
938                                          epintr, usbintr);
939                 else if (printk_ratelimit())
940                         /*
941                          * We've seen series of spurious interrupts in the
942                          * peripheral mode after USB reset and then after some
943                          * time a real interrupt storm starting...
944                          */
945                         dev_dbg(musb->controller, "Spurious IRQ, CPPI 4.1 status %08x, %08x\n",
946                                          pend1, pend2);
947         }
949         if (is_babble) {
950                 if (!musb->enable_babble_work) {
951                         musb_writeb(musb->mregs, MUSB_DEVCTL,
952                                 musb_readb(musb->mregs, MUSB_DEVCTL) |
953                                 MUSB_DEVCTL_SESSION);
954                 } else {
955                         ERR("Babble: devtcl(%x)Restarting musb....\n",
956                                  musb_readb(musb->mregs, MUSB_DEVCTL));
957                         schedule_work(&musb->work);
958                 }
959         }
960         return ret;
962 int ti81xx_musb_set_mode(struct musb *musb, u8 musb_mode)
964         void __iomem *reg_base = musb->ctrl_base;
965         u32 regval;
967         /* TODO: implement this using CONF0 */
968         if (musb_mode == MUSB_HOST) {
969                 regval = musb_readl(reg_base, USB_MODE_REG);
971                 regval &= ~USBMODE_USBID_HIGH;
972                 if (usbid_sw_ctrl && cpu_is_ti816x())
973                         regval |= USBMODE_USBID_MUXSEL;
975                 musb_writel(reg_base, USB_MODE_REG, regval);
976                 musb_writel(musb->ctrl_base, USB_PHY_UTMI_REG, 0x02);
977                 dev_dbg(musb->controller, "host: value of mode reg=%x regval(%x)\n",
978                         musb_readl(reg_base, USB_MODE_REG), regval);
979         } else if (musb_mode == MUSB_PERIPHERAL) {
980                 /* TODO commmented writing 8 to USB_MODE_REG device
981                         mode is not working */
982                 regval = musb_readl(reg_base, USB_MODE_REG);
984                 regval |= USBMODE_USBID_HIGH;
985                 if (usbid_sw_ctrl && cpu_is_ti816x())
986                         regval |= USBMODE_USBID_MUXSEL;
988                 musb_writel(reg_base, USB_MODE_REG, regval);
989                 dev_dbg(musb->controller, "device: value of mode reg=%x regval(%x)\n",
990                         musb_readl(reg_base, USB_MODE_REG), regval);
991         } else if (musb_mode == MUSB_OTG) {
992                 musb_writel(musb->ctrl_base, USB_PHY_UTMI_REG, 0x02);
993         } else
994                 return -EIO;
996         return 0;
999 int ti81xx_musb_init(struct musb *musb)
1001         void __iomem *reg_base = musb->ctrl_base;
1002         struct device *dev = musb->controller;
1003         struct musb_hdrc_platform_data *plat = dev->platform_data;
1004         struct omap_musb_board_data *data = plat->board_data;
1005         u32 rev, status = 0;
1006         u8 mode;
1008         if (musb->id < 2)
1009                 gmusb[musb->id] = musb;
1011         usb_nop_xceiv_register(musb->id);
1013         musb->xceiv = otg_get_transceiver(musb->id);
1014         if (!musb->xceiv)
1015                 return -ENODEV;
1017         status = pm_runtime_get_sync(dev);
1018         if (status < 0) {
1019                 dev_err(dev, "pm_runtime_get_sync FAILED");
1020                 goto err1;
1021         }
1023         /* mentor is at offset of 0x400 in am3517/ti81xx */
1024         musb->mregs += USB_MENTOR_CORE_OFFSET;
1027         /* Returns zero if e.g. not clocked */
1028         rev = musb_readl(reg_base, USB_REVISION_REG);
1029         if (!rev)
1030                 return -ENODEV;
1032         if (is_host_enabled(musb))
1033                 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
1035         /* Reset the controller */
1036         musb_writel(reg_base, USB_CTRL_REG, USB_SOFT_RESET_MASK);
1038         /* wait till reset bit clears */
1039         while ((musb_readl(reg_base, USB_CTRL_REG) & 0x1))
1040                 cpu_relax();
1042         /* Start the on-chip PHY and its PLL. */
1043         if (data->set_phy_power)
1044                 data->set_phy_power(1);
1046         musb->a_wait_bcon = A_WAIT_BCON_TIMEOUT;
1047         musb->isr = ti81xx_interrupt;
1049         if (cpu_is_ti816x())
1050                 usbid_sw_ctrl = 1;
1052         if (is_otg_enabled(musb)) {
1053                 /* if usb-id contolled through software for ti816x then
1054                  * configure the usb0 in peripheral mode and usb1 in
1055                  * host mode
1056                 */
1057                 if (usbid_sw_ctrl && cpu_is_ti816x())
1058                         mode = musb->id ? MUSB_HOST : MUSB_PERIPHERAL;
1059                 else
1060                         mode = MUSB_OTG;
1061         } else
1062                 /* set musb controller to host mode */
1063                 mode = is_host_enabled(musb) ? MUSB_HOST : MUSB_PERIPHERAL;
1065         /* set musb controller to host mode */
1066         musb_platform_set_mode(musb, mode);
1068         /* enable babble workaround */
1069         INIT_WORK(&musb->work, evm_deferred_musb_restart);
1070         musb->enable_babble_work = 0;
1072         musb_writel(reg_base, USB_IRQ_EOI, 0);
1074         return 0;
1075 err1:
1076         pm_runtime_disable(dev);
1077         return status;
1080 /* TI81xx supports only 32bit read operation */
1081 void ti81xx_musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
1083         void __iomem *fifo = hw_ep->fifo;
1084         u32             val;
1085         int             i;
1087         /* Read for 32bit-aligned destination address */
1088         if (likely((0x03 & (unsigned long) dst) == 0) && len >= 4) {
1089                 readsl(fifo, dst, len >> 2);
1090                 dst += len & ~0x03;
1091                 len &= 0x03;
1092         }
1093         /*
1094          * Now read the remaining 1 to 3 byte or complete length if
1095          * unaligned address.
1096          */
1097         if (len > 4) {
1098                 for (i = 0; i < (len >> 2); i++) {
1099                         *(u32 *) dst = musb_readl(fifo, 0);
1100                         dst += 4;
1101                 }
1102                 len &= 0x03;
1103         }
1104         if (len > 0) {
1105                 val = musb_readl(fifo, 0);
1106                 memcpy(dst, &val, len);
1107         }
1110 int ti81xx_musb_exit(struct musb *musb)
1112         struct device *dev = musb->controller;
1113         struct musb_hdrc_platform_data *plat = dev->platform_data;
1114         struct omap_musb_board_data *data = plat->board_data;
1116         if (is_host_enabled(musb))
1117                 del_timer_sync(&otg_workaround);
1119         /* Shutdown the on-chip PHY and its PLL. */
1120         if (data->set_phy_power)
1121                 data->set_phy_power(0);
1123         otg_put_transceiver(musb->xceiv);
1124         usb_nop_xceiv_unregister(musb->id);
1126         return 0;
1129 static struct musb_platform_ops ti81xx_ops = {
1130         .fifo_mode      = 4,
1131         .flags          = MUSB_GLUE_EP_ADDR_FLAT_MAPPING | MUSB_GLUE_DMA_CPPI41,
1132         .init           = ti81xx_musb_init,
1133         .exit           = ti81xx_musb_exit,
1135         .enable         = ti81xx_musb_enable,
1136         .disable        = ti81xx_musb_disable,
1138         .try_idle       = ti81xx_musb_try_idle,
1139         .set_mode       = ti81xx_musb_set_mode,
1141         .read_fifo      = ti81xx_musb_read_fifo,
1142         .write_fifo     = musb_write_fifo,
1144         .dma_controller_create  = cppi41_dma_controller_create,
1145         .dma_controller_destroy = cppi41_dma_controller_destroy,
1146         .simulate_babble_intr   = musb_simulate_babble,
1147 };
1149 static void __devexit ti81xx_delete_musb_pdev(struct ti81xx_glue *glue, u8 id)
1151         platform_device_del(glue->musb[id]);
1152         platform_device_put(glue->musb[id]);
1155 static int __devinit ti81xx_create_musb_pdev(struct ti81xx_glue *glue, u8 id)
1157         struct device *dev = glue->dev;
1158         struct platform_device *pdev = to_platform_device(dev);
1159         struct musb_hdrc_platform_data  *pdata = dev->platform_data;
1160         struct platform_device  *musb;
1161         struct resource *res;
1162         struct resource resources[2];
1163         char res_name[10];
1164         int ret = 0;
1166         /* get memory resource */
1167         sprintf(res_name, "musb%d", id);
1168         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, res_name);
1169         if (!res) {
1170                 dev_err(dev, "%s get mem resource failed\n", res_name);
1171                 ret = -ENODEV;
1172                 goto err0;
1173         }
1174         res->parent = NULL;
1175         resources[0] = *res;
1177         /* get irq resource */
1178         sprintf(res_name, "musb%d-irq", id);
1179         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, res_name);
1180         if (!res) {
1181                 dev_err(dev, "%s get irq resource failed\n", res_name);
1182                 ret = -ENODEV;
1183                 goto err0;
1184         }
1185         res->parent = NULL;
1186         resources[1] = *res;
1188         /* allocate the child platform device */
1189         musb = platform_device_alloc("musb-hdrc", id);
1190         if (!musb) {
1191                 dev_err(dev, "failed to allocate musb device\n");
1192                 goto err0;
1193         }
1195         musb->id                        = id;
1196         musb->dev.parent                = dev;
1197         musb->dev.dma_mask              = &musb_dmamask;
1198         musb->dev.coherent_dma_mask     = musb_dmamask;
1200         glue->musb[id]                  = musb;
1202         pdata->platform_ops             = &ti81xx_ops;
1204         ret = platform_device_add_resources(musb, resources, 2);
1205         if (ret) {
1206                 dev_err(dev, "failed to add resources\n");
1207                 goto err1;
1208         }
1210         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
1211         if (ret) {
1212                 dev_err(dev, "failed to add platform_data\n");
1213                 goto err1;
1214         }
1216         ret = platform_device_add(musb);
1217         if (ret) {
1218                 dev_err(dev, "failed to register musb device\n");
1219                 goto err1;
1220         }
1222         return 0;
1224 err1:
1225         platform_device_put(musb);
1226 err0:
1227         return ret;
1230 static int __init ti81xx_probe(struct platform_device *pdev)
1232         struct ti81xx_glue *glue;
1233         struct device *dev = &pdev->dev;
1234         struct musb_hdrc_platform_data *plat = dev->platform_data;
1235         struct omap_musb_board_data *data = plat->board_data;
1236         int ret = 0, i;
1237         struct resource *res;
1239         /* allocate glue */
1240         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
1241         if (!glue) {
1242                 dev_err(&pdev->dev, "unable to allocate glue memory\n");
1243                 ret = -ENOMEM;
1244                 goto err0;
1245         }
1247         /* interface clock needs to be enabled for usbss register programming */
1248         glue->ick = clk_get(&pdev->dev, "usbotg_ick");
1249         if (IS_ERR(glue->ick)) {
1250                 dev_err(&pdev->dev, "unable to get usbss interface clock\n");
1251                 ret = PTR_ERR(glue->ick);
1252                 goto err1;
1253         }
1255         /* functional clock needs to be enabled for usbss register programming */
1256         glue->fck = clk_get(&pdev->dev, "usbotg_fck");
1257         if (IS_ERR(glue->fck)) {
1258                 dev_err(&pdev->dev, "unable to get usbss functional clock\n");
1259                 ret = PTR_ERR(glue->fck);
1260                 goto err2;
1261         }
1263         /* get memory resource */
1264         glue->mem_pa = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1265         if (!glue->mem_pa) {
1266                 dev_err(&pdev->dev, "failed to get usbss mem resourse\n");
1267                 ret = -ENODEV;
1268                 goto err3;
1269         }
1271         /* get memory resource */
1272         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usbss-irq");
1273         if (!res) {
1274                 dev_err(&pdev->dev, "failed to get usbss irq resourse\n");
1275                 ret = -ENODEV;
1276                 goto err3;
1277         }
1278         glue->irq = res->start;
1280         /* enable interface clock */
1281         ret = clk_enable(glue->ick);
1282         if (ret) {
1283                 dev_err(&pdev->dev, "failed to enable usbss interface clock\n");
1284                 goto err3;
1285         }
1287         /* enable functional clock */
1288         ret = clk_enable(glue->fck);
1289         if (ret) {
1290                 dev_err(&pdev->dev, "failed to enable usbss functional clock\n");
1291                 goto err4;
1292         }
1294         /* iomap for usbss mem space */
1295         glue->mem_va =
1296                 ioremap(glue->mem_pa->start, resource_size(glue->mem_pa));
1297         if (!glue->mem_va) {
1298                 dev_err(&pdev->dev, "usbss ioremap failed\n");
1299                 ret = -ENOMEM;
1300                 goto err5;
1301         }
1302         usbss_virt_base = glue->mem_va;
1304         glue->dev = &pdev->dev;
1305         platform_set_drvdata(pdev, glue);
1307         /* usb subsystem init */
1308         usbotg_ss_init();
1310         /* clear any USBSS interrupts */
1311         __raw_writel(0, glue->mem_va + USBSS_IRQ_EOI);
1312         __raw_writel(__raw_readl(glue->mem_va + USBSS_IRQ_STATUS),
1313                                         glue->mem_va + USBSS_IRQ_STATUS);
1315         /* create the child platform device for mulitple instances of musb */
1316         for (i = 0; i <= data->instances; ++i) {
1317 #ifdef CONFIG_USB_TI_CPPI41_DMA
1318                 /* initialize the cppi41dma init */
1319                 cppi41_init(i, glue->irq, data->instances+1);
1320 #endif
1321                 ret = ti81xx_create_musb_pdev(glue, i);
1322                 if (ret != 0)
1323                         goto err6;
1324         }
1326         return 0;
1328 err6:
1329         iounmap(glue->mem_va);
1330 err5:
1331         clk_disable(glue->fck);
1332 err4:
1333         clk_disable(glue->ick);
1334 err3:
1335         clk_put(glue->fck);
1336 err2:
1337         clk_put(glue->ick);
1338 err1:
1339         kfree(glue);
1340 err0:
1341         return ret;
1344 static int __exit ti81xx_remove(struct platform_device *pdev)
1346         struct ti81xx_glue *glue = platform_get_drvdata(pdev);
1347         struct device *dev = &pdev->dev;
1348         struct musb_hdrc_platform_data *plat = dev->platform_data;
1349         struct omap_musb_board_data *data = plat->board_data;
1350         int i;
1352         /* delete the child platform device for mulitple instances of musb */
1353         for (i = 0; i <= data->instances; ++i)
1354                 ti81xx_delete_musb_pdev(glue, i);
1356 #ifdef CONFIG_USB_TI_CPPI41_DMA
1357         cppi41_free();
1358 #endif
1359         /* iounmap */
1360         iounmap(glue->mem_va);
1361         usbotg_ss_uninit();
1363         /* disable common usbss functional clock */
1364         clk_disable(glue->fck);
1365         clk_put(glue->fck);
1366         /* disable common usbss interface clock */
1367         clk_disable(glue->ick);
1368         clk_put(glue->ick);
1369         kfree(glue);
1371         return 0;
1374 #ifdef CONFIG_PM
1375 static int ti81xx_suspend(struct device *dev)
1377         struct ti81xx_glue *glue = dev_get_drvdata(dev);
1378         struct musb_hdrc_platform_data *plat = dev->platform_data;
1379         struct omap_musb_board_data *data = plat->board_data;
1380         int i;
1382         /* Shutdown the on-chip PHY and its PLL. */
1383         for (i = 0; i <= data->instances; ++i) {
1384                 if (data->set_phy_power)
1385                         data->set_phy_power(i);
1386         }
1388         /* disable the common usbss functional clock */
1389         clk_disable(glue->fck);
1390         /* disable the common usbss interface clock */
1391         clk_disable(glue->ick);
1392         return 0;
1395 static int ti81xx_resume(struct device *dev)
1397         struct ti81xx_glue *glue = dev_get_drvdata(dev);
1398         struct musb_hdrc_platform_data *plat = dev->platform_data;
1399         struct omap_musb_board_data *data = plat->board_data;
1400         int ret, i;
1402         /* Start the on-chip PHY and its PLL. */
1403         for (i = 0; i <= data->instances; ++i) {
1404                 if (data->set_phy_power)
1405                         data->set_phy_power(i);
1406         }
1408         /* enable the common usbss interface clock */
1409         ret = clk_enable(glue->ick);
1410         if (ret) {
1411                 dev_err(dev, "failed to enable iclock\n");
1412                 return ret;
1413         }
1414         /* enable the common usbss functional clock */
1415         ret = clk_enable(glue->fck);
1416         if (ret) {
1417                 dev_err(dev, "failed to enable fclock\n");
1418                 return ret;
1419         }
1420         return 0;
1423 static const struct dev_pm_ops ti81xx_pm_ops = {
1424         .suspend        = ti81xx_suspend,
1425         .resume         = ti81xx_resume,
1426 };
1428 #define DEV_PM_OPS      (&ti81xx_pm_ops)
1429 #else
1430 #define DEV_PM_OPS      NULL
1431 #endif
1433 static struct platform_driver ti81xx_musb_driver = {
1434         .remove         = __exit_p(ti81xx_remove),
1435         .driver         = {
1436                 .name   = "musb-ti81xx",
1437                 .pm     = DEV_PM_OPS,
1438         },
1439 };
1441 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
1442 MODULE_DESCRIPTION("AM35x MUSB Glue Layer");
1443 MODULE_LICENSE("GPL v2");
1445 static int __init ti81xx_glue_init(void)
1447         return platform_driver_probe(&ti81xx_musb_driver, ti81xx_probe);
1449 subsys_initcall(ti81xx_glue_init);
1451 static void __exit ti81xx_glue_exit(void)
1453 #ifdef CONFIG_USB_TI_CPPI41_DMA
1454         /* free the usbss irq */
1455         free_irq(TI81XX_IRQ_USBSS, 0);
1456 #endif
1458         /* disable the interrupts */
1459         usbss_write(USBSS_IRQ_EOI, 0);
1460         usbss_write(USBSS_IRQ_ENABLE_SET, 0);
1461         usbss_write(USBSS_IRQ_DMA_ENABLE_0, 0);
1463         /* unregister platform driver */
1464         platform_driver_unregister(&ti81xx_musb_driver);
1466 module_exit(ti81xx_glue_exit);
1468 #ifdef CONFIG_PM
1469 void musb_platform_save_context(struct musb *musb,
1470                  struct musb_context_registers *musb_context)
1472         /* Save CPPI41 DMA related registers */
1475 void musb_platform_restore_context(struct musb *musb,
1476                  struct musb_context_registers *musb_context)
1478         /* Restore CPPI41 DMA related registers */
1480 #endif