508202bffb9ba94897880759db9b2f293f062906
[linux-2.6.34-lpc32xx.git] / drivers / usb / gadget / lpc32xx_udc.c
1 /*
2  * drivers/usb/gadget/lpc32xx_udc.c
3  *
4  * Author: Kevin Wells <kevin.wells@nxp.com>
5  *
6  * Copyright (C) 2009 NXP Semiconductors
7  * Copyright (C) 2006 Mike James , Philips Semiconductors
8  *
9  * Note: This driver is based on original work done by Mike James for
10  *       the LPC3180.
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  */
26
27 /*
28  * Notes
29  *
30  * ISO functionality is untested. It probably works, but may not be reliable.
31  */
32
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/platform_device.h>
36 #include <linux/delay.h>
37 #include <linux/ioport.h>
38 #include <linux/slab.h>
39 #include <linux/errno.h>
40 #include <linux/init.h>
41 #include <linux/list.h>
42 #include <linux/interrupt.h>
43 #include <linux/proc_fs.h>
44 #include <linux/clk.h>
45 #include <linux/usb/ch9.h>
46 #include <linux/usb/gadget.h>
47 #include <linux/i2c.h>
48 #include <linux/kthread.h>
49 #include <linux/freezer.h>
50 #include <linux/dma-mapping.h>
51 #include <linux/dmapool.h>
52
53 #include <asm/byteorder.h>
54 #include <mach/hardware.h>
55 #include <asm/io.h>
56 #include <asm/irq.h>
57 #include <asm/system.h>
58
59 #include <mach/platform.h>
60 #include <mach/irqs.h>
61 #include <mach/usbd.h>
62 #include <mach/board.h>
63 #include "lpc32xx_udc.h"
64 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
65 #include <linux/seq_file.h>
66 #endif
67
68 #define UDCA_BUFF_SIZE (128)
69
70 #define USB_CTRL        IO_ADDRESS(LPC32XX_CLK_PM_BASE + 0x64)
71 #define USB_CLOCK_MASK (AHB_M_CLOCK_ON| OTG_CLOCK_ON | DEV_CLOCK_ON | I2C_CLOCK_ON)
72
73 /* USB_CTRL bit defines */
74 #define USB_SLAVE_HCLK_EN       (1 << 24)
75 #define USB_HOST_NEED_CLK_EN    (1 << 21)
76 #define USB_DEV_NEED_CLK_EN     (1 << 22)
77
78 #define USB_OTG_CLK_CTRL        IO_ADDRESS(LPC32XX_USB_BASE + 0xFF4)
79 #define USB_OTG_CLK_STAT        IO_ADDRESS(LPC32XX_USB_BASE + 0xFF8)
80
81 /* USB_OTG_CLK_CTRL bit defines */
82 #define AHB_M_CLOCK_ON          (1 << 4)
83 #define OTG_CLOCK_ON            (1 << 3)
84 #define I2C_CLOCK_ON            (1 << 2)
85 #define DEV_CLOCK_ON            (1 << 1)
86 #define HOST_CLOCK_ON           (1 << 0)
87
88 #define USB_OTG_STAT_CONTROL    IO_ADDRESS(LPC32XX_USB_BASE + 0x110)
89
90 /* USB_OTG_STAT_CONTROL bit defines */
91 #define TRANSPARENT_I2C_EN      (1 << 7)
92 #define HOST_EN                 (1 << 0)
93
94 /* ISP1301 USB transceiver I2C registers */
95 #define ISP1301_MODE_CONTROL_1          0x04    /* u8 read, set, +1 clear */
96
97 #define MC1_SPEED_REG           (1 << 0)
98 #define MC1_SUSPEND_REG         (1 << 1)
99 #define MC1_DAT_SE0             (1 << 2)
100 #define MC1_TRANSPARENT         (1 << 3)
101 #define MC1_BDIS_ACON_EN        (1 << 4)
102 #define MC1_OE_INT_EN           (1 << 5)
103 #define MC1_UART_EN             (1 << 6)
104 #define MC1_MASK                0x7f
105
106 #define ISP1301_MODE_CONTROL_2          0x12    /* u8 read, set, +1 clear */
107
108 #define MC2_GLOBAL_PWR_DN       (1 << 0)
109 #define MC2_SPD_SUSP_CTRL       (1 << 1)
110 #define MC2_BI_DI               (1 << 2)
111 #define MC2_TRANSP_BDIR0        (1 << 3)
112 #define MC2_TRANSP_BDIR1        (1 << 4)
113 #define MC2_AUDIO_EN            (1 << 5)
114 #define MC2_PSW_EN              (1 << 6)
115 #define MC2_EN2V7               (1 << 7)
116
117 #define ISP1301_OTG_CONTROL_1           0x06    /* u8 read, set, +1 clear */
118 #define OTG1_DP_PULLUP          (1 << 0)
119 #define OTG1_DM_PULLUP          (1 << 1)
120 #define OTG1_DP_PULLDOWN        (1 << 2)
121 #define OTG1_DM_PULLDOWN        (1 << 3)
122 #define OTG1_ID_PULLDOWN        (1 << 4)
123 #define OTG1_VBUS_DRV           (1 << 5)
124 #define OTG1_VBUS_DISCHRG       (1 << 6)
125 #define OTG1_VBUS_CHRG          (1 << 7)
126 #define ISP1301_OTG_STATUS              0x10    /* u8 readonly */
127 #define OTG_B_SESS_END          (1 << 6)
128 #define OTG_B_SESS_VLD          (1 << 7)
129
130 #define INT_CR_INT              (1 << 7)
131 #define INT_BDIS_ACON           (1 << 6)
132 #define INT_ID_FLOAT            (1 << 5)
133 #define INT_DM_HI               (1 << 4)
134 #define INT_ID_GND              (1 << 3)
135 #define INT_DP_HI               (1 << 2)
136 #define INT_SESS_VLD            (1 << 1)
137 #define INT_VBUS_VLD            (1 << 0)
138
139 #define ISP1301_I2C_ADDR 0x2C
140
141 #define ISP1301_I2C_MODE_CONTROL_1 0x4
142 #define ISP1301_I2C_MODE_CONTROL_2 0x12
143 #define ISP1301_I2C_OTG_CONTROL_1 0x6
144 #define ISP1301_I2C_OTG_CONTROL_2 0x10
145 #define ISP1301_I2C_INTERRUPT_SOURCE 0x8
146 #define ISP1301_I2C_INTERRUPT_LATCH 0xA
147 #define ISP1301_I2C_INTERRUPT_FALLING 0xC
148 #define ISP1301_I2C_INTERRUPT_RISING 0xE
149 #define ISP1301_I2C_REG_CLEAR_ADDR 1
150
151 #define DRIVER_VERSION  "$Revision: 1.01 $"
152 static const char driver_name [] = "lpc32xx_udc";
153
154 static void udc_set_address(struct lpc32xx_udc *udc, u32 addr);
155 #if defined(UDC_ENABLE_DMA)
156 static int udc_ep_in_req_dma(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep);
157 static int udc_ep_out_req_dma(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep);
158 #else
159 static int udc_ep_in_req(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep);
160 static int udc_ep_out_req(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep);
161 #endif
162 static int udc_ep0_in_req(struct lpc32xx_udc *udc);
163 static int udc_ep0_out_req(struct lpc32xx_udc *udc);
164
165 /*
166  *
167  * proc interface support
168  *
169  */
170 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
171 static char *epnames[] = {"INT", "ISO", "BULK", "CTRL"};
172 static const char debug_filename[] = "driver/udc";
173
174 static void proc_ep_show(struct seq_file *s, struct lpc32xx_ep *ep)
175 {
176         struct lpc32xx_request *req;
177         unsigned long flags;
178
179         local_irq_save(flags);
180
181         seq_printf(s, "\n");
182         seq_printf(s, "%12s, maxpacket %4d %3s",
183                         ep->ep.name, ep->ep.maxpacket,
184                         ep->is_in ? "in" : "out");
185         seq_printf(s, " type %4s", epnames[ep->eptype]);
186         seq_printf(s, " ints: %12d", ep->totalints);
187         seq_printf(s, " stalls: %12d", ep->totalstalls);
188         seq_printf(s, " NAKs: %12d\n", ep->totalnaks);
189
190         if (list_empty (&ep->queue))
191                 seq_printf(s, "\t(queue empty)\n");
192         else {
193                 list_for_each_entry (req, &ep->queue, queue) {
194                         u32 length = req->req.actual;
195
196                         seq_printf(s, "\treq %p len %d/%d buf %p\n",
197                                         &req->req, length,
198                                         req->req.length, req->req.buf);
199                 }
200         }
201
202         local_irq_restore(flags);
203 }
204
205 static int proc_udc_show(struct seq_file *s, void *unused)
206 {
207         struct lpc32xx_udc *udc = s->private;
208         struct lpc32xx_ep *ep;
209
210         seq_printf(s, "%s: version %s\n", driver_name, DRIVER_VERSION);
211
212         seq_printf(s, "vbus %s, pullup %s, %s powered%s, gadget %s\n\n",
213                         udc->vbus ? "present" : "off",
214                         udc->enabled
215                         ? (udc->vbus ? "active" : "enabled")
216                         : "disabled",
217                         udc->selfpowered ? "self" : "VBUS",
218                         udc->suspended ? ", suspended" : "",
219                         udc->driver ? udc->driver->driver.name : "(none)");
220
221         if (udc->enabled && udc->vbus) {
222                 proc_ep_show(s, &udc->ep[0]);
223                 list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
224                         if (ep->desc) {
225                                 proc_ep_show(s, ep);
226                         }
227                 }
228         }
229
230         return 0;
231 }
232
233 static int proc_udc_open(struct inode *inode, struct file *file)
234 {
235         return single_open(file, proc_udc_show, PDE(inode)->data);
236 }
237
238 static const struct file_operations proc_ops = {
239         .owner          = THIS_MODULE,
240         .open           = proc_udc_open,
241         .read           = seq_read,
242         .llseek         = seq_lseek,
243         .release        = single_release,
244 };
245
246 static void create_debug_file(struct lpc32xx_udc *udc)
247 {
248         udc->pde = proc_create_data(debug_filename, 0, NULL, &proc_ops, udc);
249 }
250
251 static void remove_debug_file(struct lpc32xx_udc *udc)
252 {
253         if (udc->pde)
254                 remove_proc_entry(debug_filename, NULL);
255 }
256
257 #else
258 static inline void create_debug_file(struct lpc32xx_udc *udc) {}
259 static inline void remove_debug_file(struct lpc32xx_udc *udc) {}
260 #endif
261
262 /*
263  *
264  * ISP1301 transceiver support functions
265  *
266  */
267 struct i2c_driver isp1301_driver;
268 struct i2c_client *isp1301_i2c_client;
269 static int isp1301_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id);
270 static int isp1301_remove(struct i2c_client *client);
271
272 static const unsigned short normal_i2c[] =
273 { ISP1301_I2C_ADDR, ISP1301_I2C_ADDR + 1, I2C_CLIENT_END };
274
275 static const struct i2c_device_id isp1301_id[] = {
276         { "isp1301_pnx", 0 },
277         { }
278 };
279
280 struct i2c_driver isp1301_driver = {
281         .driver = {
282                 .name = "isp1301_pnx",
283         },
284         .probe = isp1301_probe, 
285         .remove = isp1301_remove,
286         .id_table = isp1301_id,
287 };
288
289 static int isp1301_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id)
290 {
291         return 0;
292 }
293
294 static int isp1301_remove(struct i2c_client *client)
295 {
296         return 0;
297 }
298
299 static void i2c_write(u8 buf, u8 subaddr)
300 {
301         char tmpbuf[2];
302
303         tmpbuf[0] = subaddr;    /*register number */
304         tmpbuf[1] = buf;        /*register data */
305         i2c_master_send(isp1301_i2c_client, &tmpbuf[0], 2);
306 }
307
308 static u16 i2c_read(u8 subaddr)
309 {
310         u8 data;
311
312         i2c_master_send(isp1301_i2c_client, &subaddr, 1);
313         i2c_master_recv(isp1301_i2c_client, (u8 *) &data, 1);
314
315         return data;
316 }
317
318 static u16 i2c_read16(u8 subaddr)
319 {
320         u16 data;
321
322         i2c_master_send(isp1301_i2c_client, &subaddr, 1);
323         i2c_master_recv(isp1301_i2c_client, (u8 *) &data, 2);
324
325         return data;
326 }
327
328 /* Primary initializion sequence for the ISP1301 transceiver */
329 static void isp1301_udc_configure(struct lpc32xx_udc *udc)
330 {
331         /* LPC32XX only supports DAT_SE0 USB mode */
332         /* This sequence is important */
333
334         /* Disable transparent UART mode first */
335         i2c_write(MC1_UART_EN, (ISP1301_I2C_MODE_CONTROL_1 |
336                                 ISP1301_I2C_REG_CLEAR_ADDR));
337
338         /* Set full speed and SE0 mode */
339         i2c_write(~0, (ISP1301_I2C_MODE_CONTROL_1 | ISP1301_I2C_REG_CLEAR_ADDR));
340         i2c_write((MC1_SPEED_REG | MC1_DAT_SE0), ISP1301_I2C_MODE_CONTROL_1);
341
342         /* The PSW_OE enable bit state is reversed in the ISP1301 User's guide! */
343         i2c_write(~0, (ISP1301_I2C_MODE_CONTROL_2 | ISP1301_I2C_REG_CLEAR_ADDR));
344         i2c_write((MC2_BI_DI | MC2_SPD_SUSP_CTRL), ISP1301_I2C_MODE_CONTROL_2);
345
346         /* Driver VBUS_DRV high or low depending on board setup */
347         if (udc->board->vbus_drv_pol != 0) {
348                 i2c_write(OTG1_VBUS_DRV, ISP1301_I2C_OTG_CONTROL_1);
349         }
350         else {
351                 i2c_write(OTG1_VBUS_DRV, (ISP1301_I2C_OTG_CONTROL_1 |
352                                         ISP1301_I2C_REG_CLEAR_ADDR));
353         }
354
355         /* Bi-derctional mode with suspend control */
356         /* Enable both pulldowns for now - the pullup will be enable when VBUS is detected */
357         i2c_write(~0, (ISP1301_I2C_OTG_CONTROL_1 | ISP1301_I2C_REG_CLEAR_ADDR));
358         i2c_write((0 | OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN),
359                         ISP1301_I2C_OTG_CONTROL_1);
360
361         /* Discharge VBUS (just in case) */
362         i2c_write(OTG1_VBUS_DISCHRG, ISP1301_I2C_OTG_CONTROL_1);
363         mdelay(1);
364         i2c_write(OTG1_VBUS_DISCHRG,
365                         (ISP1301_I2C_OTG_CONTROL_1 | ISP1301_I2C_REG_CLEAR_ADDR));
366
367         /* Clear and enable VBUS high edge interrupt */
368         i2c_write(~0, ISP1301_I2C_INTERRUPT_LATCH | ISP1301_I2C_REG_CLEAR_ADDR);
369         i2c_write(~0, ISP1301_I2C_INTERRUPT_FALLING | ISP1301_I2C_REG_CLEAR_ADDR);
370         i2c_write(INT_VBUS_VLD, ISP1301_I2C_INTERRUPT_FALLING);
371         i2c_write(~0, ISP1301_I2C_INTERRUPT_RISING | ISP1301_I2C_REG_CLEAR_ADDR);
372         i2c_write(INT_VBUS_VLD, ISP1301_I2C_INTERRUPT_RISING);
373
374         /* Enable usb_need_clk clock after transceiver is initialized */
375         __raw_writel((__raw_readl(USB_CTRL) | (1 << 22)), USB_CTRL);
376
377         dev_dbg(udc->dev, "ISP1301 Vendor ID  : 0x%04x\n", i2c_read16(0x00));
378         dev_dbg(udc->dev, "ISP1301 Product ID : 0x%04x\n", i2c_read16(0x02));
379         dev_dbg(udc->dev, "ISP1301 Version ID : 0x%04x\n", i2c_read16(0x14));
380 }
381
382 /* Enables or disables the USB device pullup via the ISP1301 transceiver */
383 static void isp1301_pullup_enable(int en_pullup)
384 {
385         if (en_pullup) {
386                 /* Enable pullup for bus signalling */
387                 i2c_write(OTG1_DP_PULLUP, ISP1301_I2C_OTG_CONTROL_1);
388         }
389         else {
390                 /* Enable pullup for bus signalling */
391                 i2c_write(OTG1_DP_PULLUP,
392                                 (ISP1301_I2C_OTG_CONTROL_1 | ISP1301_I2C_REG_CLEAR_ADDR));
393         }
394 }
395
396 #ifdef CONFIG_PM
397 /* Powers up or down the ISP1301 transceiver */
398 static void isp1301_set_powerstate(int enable) {
399         if (enable != 0) {
400                 /* Power up ISP1301 - this ISP1301 will automatically wakeup
401                    when VBUS is detected */
402                 i2c_write(MC2_GLOBAL_PWR_DN, 
403                                 (ISP1301_I2C_MODE_CONTROL_2 | ISP1301_I2C_REG_CLEAR_ADDR));
404         }
405         else {
406                 /* Power down ISP1301 */
407                 i2c_write(MC2_GLOBAL_PWR_DN, ISP1301_I2C_MODE_CONTROL_2);
408         }
409 }
410 #endif
411
412 /*
413  *
414  * USB protocol engine command/data read/write helper functions
415  *
416  */
417 /* Issues a single command to the USB device state machine */
418 static void udc_protocol_cmd_w(struct lpc32xx_udc *udc, u32 cmd) {
419         u32 pass = 0;
420         int to;
421
422         /* EP may lock on CLRI if this read isn't done */
423         volatile u32 tmp = __raw_readl(USBD_DEVINTST(udc->udp_baseaddr));
424         (void) tmp;
425
426         while (pass == 0) {
427                 __raw_writel(USBD_CCEMPTY, USBD_DEVINTCLR(udc->udp_baseaddr));
428
429                 /* Write command code */
430                 __raw_writel(cmd, USBD_CMDCODE(udc->udp_baseaddr));
431                 to = 10000;
432                 while (((__raw_readl(USBD_DEVINTST(udc->udp_baseaddr)) &
433                                                 USBD_CCEMPTY) == 0) && (to > 0)) {
434                         to--;
435                 }
436
437                 if (to > 0) pass = 1;
438         }
439 }
440
441 /* Issues 2 commands (or command and data) to the USB device state machine */
442 static inline void udc_protocol_cmd_data_w(struct lpc32xx_udc *udc, u32 cmd, u32 data) {
443         udc_protocol_cmd_w(udc, cmd);
444         udc_protocol_cmd_w(udc, data);
445 }
446
447 /* Issues a single command to the USB device state machine and reads
448    response data */
449 static u32 udc_protocol_cmd_r(struct lpc32xx_udc *udc, u32 cmd) {
450         /* Write a command and read data from the protocol engine */
451         u32 tmp;
452
453         __raw_writel((USBD_CDFULL | USBD_CCEMPTY),
454                         USBD_DEVINTCLR(udc->udp_baseaddr));
455
456         /* Write command code */
457         udc_protocol_cmd_w(udc, cmd);
458         while ((__raw_readl(USBD_DEVINTST(udc->udp_baseaddr)) &
459                                 USBD_CDFULL) == 0);
460
461         tmp = __raw_readl(USBD_CMDDATA(udc->udp_baseaddr));
462
463         return tmp;
464 }
465
466 /*
467  *
468  * USB device interrupt mask support functions
469  *
470  */
471 /* Enable one or more USB device interrupts */
472 static inline void uda_enable_devint(struct lpc32xx_udc *udc, u32 devmask) {
473         udc->enabled_devints |= devmask;
474         __raw_writel(udc->enabled_devints, USBD_DEVINTEN(udc->udp_baseaddr));
475 }
476
477 /* Disable one or more USB device interrupts */
478 static inline void uda_disable_devint(struct lpc32xx_udc *udc, u32 mask) {
479         udc->enabled_devints &= ~mask;
480         __raw_writel(udc->enabled_devints, USBD_DEVINTEN(udc->udp_baseaddr));
481 }
482
483 /* Clear one or more USB device interrupts */
484 static inline void uda_clear_devint(struct lpc32xx_udc *udc, u32 mask) {
485         __raw_writel(mask, USBD_DEVINTCLR(udc->udp_baseaddr));
486 }
487
488 /*
489  *
490  * Endpoint interrupt disable/enable functions
491  *
492  */
493 /* Enable one or more USB endpoint interrupts */
494 static void uda_enable_hwepint(struct lpc32xx_udc *udc, u32 hwep) {
495         udc->enabled_hwepints |= (1 << hwep);
496         __raw_writel(udc->enabled_hwepints, USBD_EPINTEN(udc->udp_baseaddr));
497 }
498
499 /* Disable one or more USB endpoint interrupts */
500 static void uda_disable_hwepint(struct lpc32xx_udc *udc, u32 hwep) {
501         udc->enabled_hwepints &= ~(1 << hwep);
502         __raw_writel(udc->enabled_hwepints, USBD_EPINTEN(udc->udp_baseaddr));
503 }
504
505 /* Clear one or more USB endpoint interrupts */
506 static inline void uda_clear_hwepint(struct lpc32xx_udc *udc, u32 hwep) {
507         __raw_writel((1 << hwep), USBD_EPINTCLR(udc->udp_baseaddr));
508 }
509
510 /* Enable DMA for the HW channel */
511 static inline void udc_ep_dma_enable(struct lpc32xx_udc *udc, u32 hwep) {
512         __raw_writel((1 << hwep), USBD_EPDMAEN(udc->udp_baseaddr));
513 }
514
515 /* Disable DMA for the HW channel */
516 static inline void udc_ep_dma_disable(struct lpc32xx_udc *udc, u32 hwep) {
517         __raw_writel((1 << hwep), USBD_EPDMADIS(udc->udp_baseaddr));
518 }
519
520 /*
521  *
522  * Endpoint realize/unrealize functions
523  *
524  */
525 /* Before an endpoint can be used, it needs to be realized
526    in the USB protocol engine - this realizes the endpoint.
527    The interrupt (FIFO or DMA) is not enabled with this function */
528 static void udc_realize_hwep(struct lpc32xx_udc *udc, u32 hwep,
529                 u32 maxpacket) {
530         __raw_writel(USBD_EP_RLZED, USBD_DEVINTCLR(udc->udp_baseaddr));
531         __raw_writel(hwep, USBD_EPIND(udc->udp_baseaddr));
532         udc->realized_eps |= (1 << hwep);
533         __raw_writel(udc->realized_eps, USBD_REEP(udc->udp_baseaddr));
534         __raw_writel(maxpacket, USBD_EPMAXPSIZE(udc->udp_baseaddr));
535
536         /* Wait until endpoint is realized in hardware */
537         while (!(__raw_readl(USBD_DEVINTST(udc->udp_baseaddr)) & USBD_EP_RLZED));
538         __raw_writel(USBD_EP_RLZED, USBD_DEVINTCLR(udc->udp_baseaddr));
539 }
540
541 /* Unrealize an EP */
542 static void udc_unrealize_hwep(struct lpc32xx_udc *udc, u32 hwep) {
543         udc->realized_eps &= ~(1 << hwep);
544         __raw_writel(udc->realized_eps, USBD_REEP(udc->udp_baseaddr));
545 }
546
547 /*
548  *
549  * Endpoint support functions
550  *
551  */
552 /* Select and clear endpoint interrupt */
553 static u32 udc_selep_clrint(struct lpc32xx_udc *udc, u32 hwep) {
554         udc_protocol_cmd_w(udc, CMD_SEL_EP_CLRI(hwep));
555         return udc_protocol_cmd_r(udc, DAT_SEL_EP_CLRI(hwep));
556 }
557
558 /* Disables the endpoint in the USB protocol engine */
559 static void udc_disable_hwep(struct lpc32xx_udc *udc, u32 hwep) {
560         udc_protocol_cmd_data_w(udc, CMD_SET_EP_STAT(hwep),
561                         DAT_WR_BYTE(EP_STAT_DA));
562 }
563
564 /* Stalls the endpoint - endpoint will return STALL */
565 static void udc_stall_hwep(struct lpc32xx_udc *udc, u32 hwep) {
566         udc_protocol_cmd_data_w(udc, CMD_SET_EP_STAT(hwep),
567                         DAT_WR_BYTE(EP_STAT_ST));
568 }
569
570 /* Clear stall or reset endpoint */
571 static void udc_clrstall_hwep(struct lpc32xx_udc *udc, u32 hwep) {
572         udc_protocol_cmd_data_w(udc, CMD_SET_EP_STAT(hwep),
573                         DAT_WR_BYTE(0));
574 }
575
576 /* Select an endpoint for endpoint status, clear, validate */
577 static void udc_select_hwep(struct lpc32xx_udc *udc, u32 hwep) {
578         udc_protocol_cmd_w(udc, CMD_SEL_EP(hwep));
579 }
580
581 /*
582  *
583  * Endpoint buffer management functions
584  *
585  */
586 /* Clear the current endpoint's buffer */
587 static void udc_clr_buffer_hwep(struct lpc32xx_udc *udc, u32 hwep) {
588         udc_select_hwep(udc, hwep);
589         udc_protocol_cmd_w(udc, CMD_CLR_BUF);
590 }
591
592 /* Validate the current endpoint's buffer */
593 static void udc_val_buffer_hwep(struct lpc32xx_udc *udc, u32 hwep) {
594         udc_select_hwep(udc, hwep);
595         udc_protocol_cmd_w(udc, CMD_VALID_BUF);
596 }
597
598 static inline u32 udc_clearep_getsts(struct lpc32xx_udc *udc, u32 hwep) {
599         /* Clear EP interrupt */
600         uda_clear_hwepint(udc, hwep);
601         return udc_selep_clrint(udc, hwep);
602 }
603
604 #if defined(UDC_ENABLE_DMA)
605 /*
606  *
607  * USB EP DMA support
608  *
609  */
610 /* Allocate a DMA Descriptor */
611 static struct lpc32xx_usbd_dd_gad *udc_dd_alloc(struct lpc32xx_udc *udc) {
612         dma_addr_t                      dma;
613         struct lpc32xx_usbd_dd_gad      *dd;
614
615         dd = (struct lpc32xx_usbd_dd_gad *) dma_pool_alloc(
616                         udc->dd_cache, (GFP_KERNEL | GFP_DMA), &dma);
617         if (dd) {
618                 dd->this_dma = dma;
619         }
620
621         return dd;
622 }
623
624 /* Free a DMA Descriptor */
625 static void udc_dd_free(struct lpc32xx_udc *udc, struct lpc32xx_usbd_dd_gad *dd)
626 {
627         dma_pool_free(udc->dd_cache, dd, dd->this_dma);
628 }
629 #endif
630
631 /*
632  *
633  * USB setup and shutdown functions
634  *
635  */
636 /* Enables or disables most of the USB system clocks when low power mode is
637    needed. Clocks are typically started on a connection event, and disabled
638    when a cable is disconnected */
639 #define OTGOFF_CLK_MASK (AHB_M_CLOCK_ON | I2C_CLOCK_ON)
640 static void udc_clk_set(struct lpc32xx_udc *udc, int enable)
641 {
642         if (enable != 0) {
643                 if (udc->clocked)
644                         return;
645
646                 udc->clocked = 1;
647
648                 /* 48MHz PLL up */
649                 clk_enable(udc->usb_pll_clk);
650
651                 /* Enable the USb device clock */
652                 __raw_writel(__raw_readl(USB_CTRL) | USB_DEV_NEED_CLK_EN, USB_CTRL);
653
654                 /* Set to enable all needed USB OTG clocks */
655                 __raw_writel(USB_CLOCK_MASK, USB_OTG_CLK_CTRL);
656
657                 while ((__raw_readl(USB_OTG_CLK_STAT) & USB_CLOCK_MASK) !=
658                                 USB_CLOCK_MASK);
659         }
660         else {
661                 if (!udc->clocked)
662                         return;
663
664                 udc->clocked = 0;
665                 udc->gadget.speed = USB_SPEED_UNKNOWN;
666
667                 /* Never disable the USB_HCLK during normal operation */
668
669                 /* 48MHz PLL dpwn */
670                 clk_disable(udc->usb_pll_clk);
671
672                 /* Enable the USb device clock */
673                 __raw_writel(__raw_readl(USB_CTRL) & ~USB_DEV_NEED_CLK_EN, USB_CTRL);
674
675                 /* Set to enable all needed USB OTG clocks */
676                 __raw_writel(OTGOFF_CLK_MASK, USB_OTG_CLK_CTRL);
677
678                 while ((__raw_readl(USB_OTG_CLK_STAT) & OTGOFF_CLK_MASK) !=
679                                 OTGOFF_CLK_MASK);
680         }
681 }
682
683 static void udc_disable(struct lpc32xx_udc *udc) {
684         u32 i;
685
686         /* Disable device */
687         udc_protocol_cmd_data_w(udc, CMD_CFG_DEV, DAT_WR_BYTE(0));
688         udc_protocol_cmd_data_w(udc, CMD_SET_DEV_STAT, DAT_WR_BYTE(0));
689
690         /* Disable all device interrupts (including EP0) */
691         uda_disable_devint(udc, 0x3FF);
692
693         /* Disable and reset all endpoint interrupts */
694         for (i = 0; i < 32; i++) {
695                 uda_disable_hwepint(udc, i);
696                 uda_clear_hwepint(udc, i);
697                 udc_disable_hwep(udc, i);
698                 udc_unrealize_hwep(udc, i);
699                 udc->udca_v_base [i] = 0;
700
701                 /* Disable and clear all interrupts and DMA */
702                 udc_ep_dma_disable(udc, i);
703                 __raw_writel((1 << i), USBD_EOTINTCLR(udc->udp_baseaddr));
704                 __raw_writel((1 << i), USBD_NDDRTINTCLR(udc->udp_baseaddr));
705                 __raw_writel((1 << i), USBD_SYSERRTINTCLR(udc->udp_baseaddr));
706                 __raw_writel((1 << i), USBD_DMARCLR(udc->udp_baseaddr));
707         }
708
709         /* Disable DMA interrupts */
710         __raw_writel(0, USBD_DMAINTEN(udc->udp_baseaddr));
711
712         __raw_writel(0, USBD_UDCAH(udc->udp_baseaddr));
713 }
714
715 static void udc_enable(struct lpc32xx_udc *udc)
716 {
717         u32 i;
718         struct lpc32xx_ep *ep = &udc->ep[0];
719
720         udc->gadget.speed = USB_SPEED_UNKNOWN;
721
722         /* Start with known state */
723         udc_disable(udc);
724
725         /* Enable device */
726         udc_protocol_cmd_data_w(udc, CMD_SET_DEV_STAT, DAT_WR_BYTE(DEV_CON));
727
728         /* EP interrupts on high priority, FRAME interrupt on low priority */
729         __raw_writel(USBD_EP_FAST, USBD_DEVINTPRI(udc->udp_baseaddr));
730         __raw_writel(0xFFFF, USBD_EPINTPRI(udc->udp_baseaddr));
731
732         /* Clear any pending device interrupts */
733         __raw_writel(0x3FF, USBD_DEVINTCLR(udc->udp_baseaddr));
734
735         /* Setup UDCA - not yet used (DMA) */
736         __raw_writel((u32) udc->udca_p_base, USBD_UDCAH(udc->udp_baseaddr));
737
738         /* Only enable EP0 in and out for now, EP0 only works in FIFO mode */
739         for (i = 0; i <= 1; i++) {
740                 udc_realize_hwep(udc, i, ep->ep.maxpacket);
741                 uda_enable_hwepint(udc, i);
742                 udc_select_hwep(udc, i);
743                 udc_clrstall_hwep(udc, i);
744                 udc_clr_buffer_hwep(udc, i);
745         }
746
747         /* Device interrupt setup */
748         uda_clear_devint(udc, (USBD_ERR_INT | USBD_DEV_STAT | USBD_EP_SLOW |
749                                 USBD_EP_FAST));
750         uda_enable_devint(udc, (USBD_ERR_INT | USBD_DEV_STAT | USBD_EP_SLOW |
751                                 USBD_EP_FAST));
752
753         /* Set device address to 0 - called twice to force a latch in the USB
754            engine without the need of a setup packet status closure */
755         udc_set_address(udc, 0);
756         udc_set_address(udc, 0);
757
758 #if defined(UDC_ENABLE_DMA)
759         /* Enable master DMA interrupts */
760         __raw_writel((USBD_SYS_ERR_INT | USBD_EOT_INT), USBD_DMAINTEN(udc->udp_baseaddr));
761 #endif
762
763         udc->dev_status = 0;
764 }
765
766 /*
767  *
768  * USB device board specific events handled via callbacks
769  *
770  */
771 /* Connection change event - notify board function of change */
772 static void uda_power_event(struct lpc32xx_udc *udc, u32 conn) {
773         /* Just notify of a connection change event (optional) */
774         if (udc->board->conn_chgb != NULL) {
775                 udc->board->conn_chgb(conn);
776         }
777 }
778
779 /* Suspend/resume event - notify board function of change */
780 static void uda_resm_susp_event(struct lpc32xx_udc *udc, u32 conn) {
781         /* Just notify of a Suspend/resume change event (optional) */
782         if (udc->board->susp_chgb != NULL) {
783                 udc->board->susp_chgb(conn);
784         }
785
786         if (conn)
787                 udc->suspended = 0;
788         else
789                 udc->suspended = 1;
790 }
791
792 /* Remote wakeup enable/disable - notify board function of change */
793 static void uda_remwkp_cgh(struct lpc32xx_udc *udc) {
794         if (udc->board->rmwk_chgb != NULL) {
795                 udc->board->rmwk_chgb(udc->dev_status &
796                                 (1 << USB_DEVICE_REMOTE_WAKEUP));
797         }
798 }
799
800 /* Reads data from FIFO, adjusts for alignment and data size */
801 static void udc_pop_fifo(struct lpc32xx_udc *udc, u8 *data, u32 bytes) {
802         int n, i, bl;
803         u16 *p16;
804         u32 *p32, tmp, cbytes;
805
806         /* Use optimal data transfer method based on source address and size */
807         switch (((u32) data) & 0x3) {
808                 case 0: /* 32-bit aligned */
809                         p32 = (u32 *) data;
810                         cbytes = (bytes & ~0x3);
811
812                         /* Copy 32-bit aligned data first */
813                         for (n = 0; n < cbytes; n += 4)
814                                 *p32++ = __raw_readl(USBD_RXDATA(udc->udp_baseaddr));
815
816                         /* Handle any remaining bytes */
817                         bl = bytes - cbytes;
818                         if (bl) {
819                                 tmp = __raw_readl(USBD_RXDATA(udc->udp_baseaddr));
820                                 for (n = 0; n < bl; n++)
821                                         data[cbytes + n] = ((tmp >> (n * 8)) & 0xFF);
822
823                         }
824                         break;
825
826                 case 1: /* 8-bit aligned */
827                 case 3:
828                         /* Each byte has to be handled independently */
829                         for (n = 0; n < bytes; n += 4) {
830                                 tmp = __raw_readl(USBD_RXDATA(udc->udp_baseaddr));
831
832                                 bl = bytes - n;
833                                 if (bl > 3)
834                                         bl = 3;
835
836                                 for (i = 0; i < bl; i++)
837                                         data[n + i] = (u8) ((tmp >> (n * 8)) & 0xFF);
838                         }
839                         break;
840
841                 case 2: /* 16-bit aligned */
842                         p16 = (u16 *) data;
843                         cbytes = (bytes & ~0x3);
844
845                         /* Copy 32-bit sized objects first with 16-bit alignment */             
846                         for (n = 0; n < cbytes; n += 4) {
847                                 tmp = __raw_readl(USBD_RXDATA(udc->udp_baseaddr));
848                                 *p16++ = (u16) (tmp & 0xFFFF);
849                                 *p16++ = (u16) ((tmp >> 16) & 0xFFFF);
850                         }
851
852                         /* Handle any remaining bytes */
853                         bl = bytes - cbytes;
854                         if (bl) {
855                                 tmp = __raw_readl(USBD_RXDATA(udc->udp_baseaddr));
856                                 for (n = 0; n < bl; n++)
857                                         data[cbytes + n] = ((tmp >> (n * 8)) & 0xFF);
858                         }
859                         break;
860         }
861 }
862
863 /* Read data from the FIFO for an endpoint. This function is for endpoints (such
864    as EP0) that don't use DMA. This function should only be called if a packet
865    is known to be ready to read for the endpopint. Note that the endpoint must
866    be selected in the protocol engine prior to this call. */
867 static u32 udc_read_hwep(struct lpc32xx_udc *udc, u32 hwep, u32 *data,
868                 int bytes) {
869         volatile u32 tmpv;
870         u32 tmp, hwrep = ((hwep & 0x1E) << 1) | CTRL_RD_EN;
871
872         /* Setup read of endpoint */
873         __raw_writel(hwrep, USBD_CTRL(udc->udp_baseaddr));
874         __raw_writel(hwrep, USBD_CTRL(udc->udp_baseaddr));
875
876         while (__raw_readl(USBD_CTRL(udc->udp_baseaddr)) != hwrep) {
877                 __raw_writel(hwrep, USBD_CTRL(udc->udp_baseaddr));
878         }
879
880         /* Wait until packet is ready */
881         tmpv = 0;
882         while ((tmpv & PKT_RDY) == 0) {
883                 tmpv = __raw_readl(USBD_RXPLEN(udc->udp_baseaddr));
884         }
885
886         /* Mask out count */
887         tmp = tmpv & PKT_LNGTH_MASK;
888         if (bytes < tmp) {
889                 tmp = (u32) bytes;
890         }
891
892         if ((tmp > 0) && (data != NULL)) {
893                 udc_pop_fifo(udc, (u8 *) data, tmp);
894         }
895
896         __raw_writel(((hwep & 0x1E) << 1), USBD_CTRL(udc->udp_baseaddr));
897         __raw_writel(((hwep & 0x1E) << 1), USBD_CTRL(udc->udp_baseaddr));
898
899         /* Clear the buffer */
900         udc_clr_buffer_hwep(udc, hwep);
901
902         return tmp;
903 }
904
905 /* Stuffs data into the FIFO, adjusts for alignment and data size */
906 static void udc_stuff_fifo(struct lpc32xx_udc *udc, u8 *data, u32 bytes) {
907         int n, i, bl;
908         u16 *p16;
909         u32 *p32, tmp, cbytes;
910
911         /* Use optimal data transfer method based on source address and size */
912         switch (((u32) data) & 0x3) {
913                 case 0: /* 32-bit aligned */
914                         p32 = (u32 *) data;
915                         cbytes = (bytes & ~0x3);
916
917                         /* Copy 32-bit aligned data first */
918                         for (n = 0; n < cbytes; n += 4)
919                                 __raw_writel(*p32++, USBD_TXDATA(udc->udp_baseaddr));
920
921                         /* Handle any remaining bytes */
922                         bl = bytes - cbytes;
923                         if (bl) {
924                                 tmp = 0;
925                                 for (n = 0; n < bl; n++)
926                                         tmp |= (u32) (data[cbytes + n] << (n * 8));
927
928                                 __raw_writel(tmp, USBD_TXDATA(udc->udp_baseaddr));
929                         }
930                         break;
931
932                 case 1: /* 8-bit aligned */
933                 case 3:
934                         /* Each byte has to be handled independently */
935                         for (n = 0; n < bytes; n += 4) {
936                                 bl = bytes - n;
937                                 if (bl > 4)
938                                         bl = 4;
939
940                                 tmp = 0;
941                                 for (i = 0; i < bl; i++)
942                                         tmp |= (u32) (data[n + i] << (i * 8));
943
944                                 __raw_writel(tmp, USBD_TXDATA(udc->udp_baseaddr));
945                         }
946                         break;
947
948                 case 2: /* 16-bit aligned */
949                         p16 = (u16 *) data;
950                         cbytes = (bytes & ~0x3);
951
952                         /* Copy 32-bit aligned data first */
953                         for (n = 0; n < cbytes; n += 4) {
954                                 tmp = (u32) (*p16++ & 0xFFFF);
955                                 tmp |= (u32) ((*p16++ & 0xFFFF) << 16);
956                                 __raw_writel(tmp, USBD_TXDATA(udc->udp_baseaddr));
957                         }
958
959                         /* Handle any remaining bytes */
960                         bl = bytes - cbytes;
961                         if (bl) {
962                                 tmp = 0;
963                                 for (n = 0; n < bl; n++)
964                                         tmp |= (u32) (data[cbytes + n] << (n * 8));
965
966                                 __raw_writel(tmp, USBD_TXDATA(udc->udp_baseaddr));
967                         }
968                         break;
969         }
970 }
971
972 /* Write data to the FIFO for an endpoint. This function is for endpoints (such
973    as EP0) that don't use DMA. Note that the endpoint must be selected in the
974    protocol engine prior to this call. */
975 static void udc_write_hwep(struct lpc32xx_udc *udc, u32 hwep,
976                 u32 *data, u32 bytes) {
977         u32 hwwep = ((hwep & 0x1E) << 1) | CTRL_WR_EN;
978
979         if ((bytes > 0) && (data == NULL)) {
980                 return;
981         }
982
983         /* Setup write of endpoint */
984         __raw_writel(hwwep, USBD_CTRL(udc->udp_baseaddr));
985         __raw_writel(hwwep, USBD_CTRL(udc->udp_baseaddr));
986         while (__raw_readl(USBD_CTRL(udc->udp_baseaddr)) != hwwep) {
987                 __raw_writel(hwwep, USBD_CTRL(udc->udp_baseaddr));
988         }
989
990         __raw_writel(bytes, USBD_TXPLEN(udc->udp_baseaddr));
991
992         /* Need at least 1 byte to rgigger TX, may not be needed */
993         if (bytes == 0) {
994                 __raw_writel(0, USBD_TXDATA(udc->udp_baseaddr));
995         }
996         else {
997                 udc_stuff_fifo(udc, (u8 *) data, bytes);
998         }
999
1000         __raw_writel(((hwep & 0x1E) << 1), USBD_CTRL(udc->udp_baseaddr));
1001         __raw_writel(((hwep & 0x1E) << 1), USBD_CTRL(udc->udp_baseaddr));
1002
1003         udc_val_buffer_hwep(udc, hwep);
1004 }
1005
1006 /*
1007  *
1008  * USB protocol high level support functions
1009  *
1010  */
1011 /* Set/reset USB device address */
1012 static void udc_set_address(struct lpc32xx_udc *udc, u32 addr) {
1013         /* Address will be latched at the end of the status phase, or
1014            latched immediately if function is called twice */
1015         udc_protocol_cmd_data_w(udc, CMD_SET_ADDR,
1016                         DAT_WR_BYTE(DEV_EN | addr));
1017 }
1018
1019 /* USB device reset - resets USB to a default state with just EP0
1020    enabled */
1021 static void uda_usb_reset(struct lpc32xx_udc *udc) {
1022         u32 i = 0;
1023         /* Re-init device controller and EP0 */
1024         udc_enable(udc);
1025         udc->gadget.speed = USB_SPEED_FULL;
1026         
1027         for (i = 1; i < NUM_ENDPOINTS; i++) {
1028                 struct lpc32xx_ep *ep = &udc->ep[i];
1029                 ep->req_pending = 0;
1030         }
1031 }
1032
1033 /* Send a ZLP on EP0 */
1034 static void udc_ep0_send_zlp(struct lpc32xx_udc *udc) {
1035         udc_write_hwep(udc, EP_IN, NULL, 0);
1036 }
1037
1038 /* Get current frame number */
1039 static u16 udc_get_current_frame(struct lpc32xx_udc *udc) {
1040         u16 flo, fhi;
1041
1042         udc_protocol_cmd_w(udc, CMD_RD_FRAME);
1043         flo = (u16) udc_protocol_cmd_r(udc, DAT_RD_FRAME);
1044         fhi = (u16) udc_protocol_cmd_r(udc, DAT_RD_FRAME);
1045
1046         return (fhi << 8) | flo;
1047 }
1048
1049 /* Set the device as configured - enables all endpoints */
1050 static inline void udc_set_device_configured(struct lpc32xx_udc *udc) {
1051         udc_protocol_cmd_data_w(udc, CMD_CFG_DEV, DAT_WR_BYTE(CONF_DVICE));
1052 }
1053
1054 /* Set the device as unconfigured - disables all endpoints */
1055 static inline void udc_set_device_unconfigured(struct lpc32xx_udc *udc) {
1056         udc_protocol_cmd_data_w(udc, CMD_CFG_DEV, DAT_WR_BYTE(0));
1057 }
1058
1059 /* reinit == restore inital software state */
1060 static void udc_reinit(struct lpc32xx_udc *udc)
1061 {
1062         u32 i;
1063
1064         INIT_LIST_HEAD(&udc->gadget.ep_list);
1065         INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
1066
1067         for (i = 0; i < NUM_ENDPOINTS; i++) {
1068                 struct lpc32xx_ep *ep = &udc->ep[i];
1069
1070                 if (i != 0) {
1071                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
1072                 }
1073                 ep->desc = NULL;
1074                 ep->ep.maxpacket = ep->maxpacket;
1075                 INIT_LIST_HEAD(&ep->queue);
1076                 ep->req_pending = 0;
1077         }
1078
1079         udc->ep0state = WAIT_FOR_SETUP;
1080 }
1081
1082 static void done(struct lpc32xx_ep *ep, struct lpc32xx_request *req, int status)
1083 {
1084         struct lpc32xx_udc *udc = ep->udc;
1085
1086         list_del_init(&req->queue);
1087         if (req->req.status == -EINPROGRESS) {
1088                 req->req.status = status;
1089         }
1090         else {
1091                 status = req->req.status;
1092         }
1093
1094 #if defined(UDC_ENABLE_DMA)
1095         if (ep->uses_dma) {
1096                 enum dma_data_direction direction;
1097
1098                 if (ep->is_in)
1099                         direction = DMA_TO_DEVICE;
1100                 else
1101                         direction = DMA_FROM_DEVICE;
1102
1103                 if (req->mapped) {
1104                         dma_unmap_single(ep->udc->gadget.dev.parent,
1105                                         req->req.dma, req->req.length, direction);
1106                         req->req.dma = 0;
1107                         req->mapped = 0;
1108                 }
1109                 else {
1110                         dma_sync_single_for_cpu(ep->udc->gadget.dev.parent,
1111                                         req->req.dma, req->req.length, direction);
1112                 }
1113
1114                 /* Free DDs */
1115                 udc_dd_free(udc, req->dd_desc_ptr);
1116         }
1117 #endif
1118
1119         if (status && status != -ESHUTDOWN) {
1120                 ep_dbg(ep, "%s done %p, status %d\n", ep->ep.name, req, status);
1121         }
1122
1123         spin_unlock(&udc->lock);
1124         req->req.complete(&ep->ep, &req->req);
1125         spin_lock(&udc->lock);
1126 }
1127
1128
1129 static void nuke(struct lpc32xx_ep *ep, int status)
1130 {
1131         struct lpc32xx_request *req;
1132
1133         while (!list_empty(&ep->queue)) {
1134                 req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1135                 done(ep, req, status);
1136         }
1137
1138         if (ep->desc) {
1139                 if (status == -ESHUTDOWN) {
1140                         uda_disable_hwepint(ep->udc, ep->hwep_num);
1141                         udc_disable_hwep(ep->udc, ep->hwep_num);
1142                 }
1143         }
1144 }
1145
1146 static void stop_activity(struct lpc32xx_udc *udc)
1147 {
1148         struct usb_gadget_driver *driver = udc->driver;
1149         int i;
1150
1151         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
1152                 driver = NULL;
1153
1154         udc->gadget.speed = USB_SPEED_UNKNOWN;
1155         udc->suspended = 0;
1156
1157         for (i = 0; i < NUM_ENDPOINTS; i++) {
1158                 struct lpc32xx_ep *ep = &udc->ep[i];
1159                 nuke(ep, -ESHUTDOWN);
1160         }
1161         if (driver) {
1162                 driver->disconnect(&udc->gadget);
1163                 /*
1164                  *  Wait for all the endpoints to disable,
1165                  *  before disabling clocks. Don't wait if 
1166                  *  endpoints are not enabled. 
1167                  */
1168                 if(atomic_read(&udc->enabled_ep_cnt))
1169                         wait_event_interruptible(udc->ep_disable_wait_queue,
1170                                         (atomic_read(&udc->enabled_ep_cnt) == 0));
1171         }
1172
1173         isp1301_pullup_enable(0);
1174         udc_disable(udc);
1175         udc_reinit(udc);
1176 }
1177
1178 /*
1179  * Activate or kill host pullup
1180  */
1181 static void pullup(struct lpc32xx_udc *udc, int is_on)
1182 {
1183         if(!udc->clocked)
1184                 return;
1185
1186         if (!udc->enabled || !udc->vbus)
1187                 is_on = 0;
1188
1189         if (is_on) {
1190                 udc_clk_set(udc, 1);
1191                 isp1301_pullup_enable(1);
1192         } else {
1193                 stop_activity(udc);
1194                 isp1301_pullup_enable(0);
1195                 udc_clk_set(udc, 0);
1196         }
1197 }
1198
1199 static int lpc32xx_ep_disable (struct usb_ep * _ep)
1200 {
1201         struct lpc32xx_ep *ep = container_of(_ep, struct lpc32xx_ep, ep);
1202         struct lpc32xx_udc *udc = ep->udc;
1203         unsigned long   flags;
1204
1205         if ((ep->hwep_num_base == 0) || (ep->hwep_num == 0)) {
1206                 return -EINVAL;
1207         }
1208
1209         local_irq_save(flags);
1210
1211         nuke(ep, -ESHUTDOWN);
1212
1213         /* restore the endpoint's pristine config */
1214         ep->desc = NULL;
1215
1216         /* Clear all DMA statuses for this EP */
1217         udc_ep_dma_disable(udc, ep->hwep_num);
1218         __raw_writel((1 << ep->hwep_num), USBD_EOTINTCLR(udc->udp_baseaddr));
1219         __raw_writel((1 << ep->hwep_num), USBD_NDDRTINTCLR(udc->udp_baseaddr));
1220         __raw_writel((1 << ep->hwep_num), USBD_SYSERRTINTCLR(udc->udp_baseaddr));
1221         __raw_writel((1 << ep->hwep_num), USBD_DMARCLR(udc->udp_baseaddr));
1222
1223         /* Remove the DD pointer in the UDCA */
1224         udc->udca_v_base[ep->hwep_num] = 0;
1225         ep->uses_dma = 0;
1226
1227         /* Disable and reset endpoint and interrupt */
1228         uda_clear_hwepint(udc, ep->hwep_num);
1229         udc_unrealize_hwep(udc, ep->hwep_num);
1230
1231         ep->hwep_num = 0;
1232
1233         local_irq_restore(flags);
1234
1235         atomic_dec(&udc->enabled_ep_cnt);
1236         wake_up(&udc->ep_disable_wait_queue);
1237
1238         return 0;
1239 }
1240
1241 static int lpc32xx_ep_enable(struct usb_ep *_ep,
1242                 const struct usb_endpoint_descriptor *desc)
1243 {
1244         struct lpc32xx_ep *ep = container_of(_ep, struct lpc32xx_ep, ep);
1245         struct lpc32xx_udc *udc = ep->udc;
1246         u16 maxpacket;
1247         u32 tmp;
1248         unsigned long flags;
1249
1250         /* Verify EP data */
1251         if ((!_ep) || (!ep) || (!desc) || (ep->desc) ||
1252                         (desc->bDescriptorType != USB_DT_ENDPOINT) ||
1253                         ((maxpacket = le16_to_cpu(desc->wMaxPacketSize)) == 0) ||
1254                         (maxpacket > ep->maxpacket)) {
1255                 dev_dbg(udc->dev, "bad ep or descriptor\n");
1256                 return -EINVAL;
1257         }
1258
1259         /* Don't touch EP0 */
1260         if (ep->hwep_num_base == 0) {
1261                 dev_dbg(udc->dev, "Can't re-enable EP0!!!\n");
1262                 return -EINVAL;
1263         }
1264
1265         /* Is driver ready? */
1266         if ((!udc->driver) || (udc->gadget.speed == USB_SPEED_UNKNOWN)) {
1267                 dev_dbg(udc->dev, "bogus device state\n");
1268                 return -ESHUTDOWN;
1269         }
1270
1271         tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
1272         switch (tmp) {
1273                 case USB_ENDPOINT_XFER_CONTROL:
1274                         return -EINVAL;
1275
1276                 case USB_ENDPOINT_XFER_INT:
1277                         if (maxpacket > ep->maxpacket) {
1278                                 dev_dbg(udc->dev, "Bad INT endpoint maxpacket %d\n", maxpacket);
1279                                 return -EINVAL;
1280                         }
1281                         break;
1282
1283                 case USB_ENDPOINT_XFER_BULK:
1284                         switch (maxpacket) {
1285                                 case 8:
1286                                 case 16:
1287                                 case 32:
1288                                 case 64:
1289                                         break;
1290
1291                                 default:
1292                                         dev_dbg(udc->dev, "Bad BULK endpoint maxpacket %d\n", maxpacket);
1293                                         return -EINVAL;
1294                         }
1295                         break;
1296
1297                 case USB_ENDPOINT_XFER_ISOC:
1298                         break;
1299         }
1300
1301         local_irq_save(flags);
1302
1303         /* Initialize endpoint to match the selected descriptor */
1304         ep->is_in = (desc->bEndpointAddress & USB_DIR_IN) != 0;
1305         ep->desc = desc;
1306         ep->ep.maxpacket = maxpacket;
1307
1308         /* Map hardware endpoint from base and direction */
1309         if (ep->is_in) {
1310                 /* IN endpoints are offset 1 from the OUT endpoint */
1311                 ep->hwep_num = ep->hwep_num_base + EP_IN;
1312         }
1313         else {
1314                 ep->hwep_num = ep->hwep_num_base;
1315         }
1316
1317         ep_dbg(ep, "EP enabled: %s, HW:%d, MP:%d IN:%d\n", ep->ep.name, ep->hwep_num,
1318                         maxpacket, (ep->is_in == 1));
1319
1320         /* Realize the endpoint, interrupt is enabled later when
1321            buffers are queued, IN EPs will NAK until buffers are ready */
1322         udc_realize_hwep(udc, ep->hwep_num, ep->ep.maxpacket);
1323         udc_clr_buffer_hwep(udc, ep->hwep_num);
1324         uda_disable_hwepint(udc, ep->hwep_num);
1325         udc_clrstall_hwep(udc, ep->hwep_num);
1326
1327         /* Clear all DMA statuses for this EP */
1328         udc_ep_dma_disable(udc, ep->hwep_num);
1329         __raw_writel((1 << ep->hwep_num), USBD_EOTINTCLR(udc->udp_baseaddr));
1330         __raw_writel((1 << ep->hwep_num), USBD_NDDRTINTCLR(udc->udp_baseaddr));
1331         __raw_writel((1 << ep->hwep_num), USBD_SYSERRTINTCLR(udc->udp_baseaddr));
1332         __raw_writel((1 << ep->hwep_num), USBD_DMARCLR(udc->udp_baseaddr));
1333
1334 #if defined(UDC_ENABLE_DMA)
1335         ep->uses_dma = 1;
1336 #endif
1337
1338         local_irq_restore(flags);
1339
1340         atomic_inc(&udc->enabled_ep_cnt);
1341         return 0;
1342 }
1343
1344 /* Allocate a USB request list */
1345 static struct usb_request *lpc32xx_ep_alloc_request(
1346                 struct usb_ep *_ep, gfp_t gfp_flags)
1347 {
1348         struct lpc32xx_request *req;
1349
1350         req = kzalloc(sizeof (struct lpc32xx_request), gfp_flags);
1351         if (!req)
1352                 return NULL;
1353
1354         INIT_LIST_HEAD(&req->queue);
1355         return &req->req;
1356 }
1357
1358 /* De-allocate a USB request list */
1359 static void lpc32xx_ep_free_request(struct usb_ep *_ep,
1360                 struct usb_request *_req)
1361 {
1362         struct lpc32xx_request *req;
1363
1364         req = container_of(_req, struct lpc32xx_request, req);
1365         BUG_ON(!list_empty(&req->queue));
1366         kfree(req);
1367 }
1368
1369 static int lpc32xx_ep_queue(struct usb_ep *_ep,
1370                 struct usb_request *_req, gfp_t gfp_flags)
1371 {
1372         struct lpc32xx_request *req;
1373         struct lpc32xx_ep *ep;
1374         struct lpc32xx_udc *udc;
1375         unsigned long flags;
1376         int status = 0;
1377
1378         req = container_of(_req, struct lpc32xx_request, req);
1379         ep = container_of(_ep, struct lpc32xx_ep, ep);
1380
1381         if (!_req || !_req->complete || !_req->buf || !list_empty(&req->queue)) {
1382                 return -EINVAL;
1383         }
1384
1385         udc = ep->udc;
1386
1387         if (!_ep || (!ep->desc && ep->hwep_num_base != 0)) {
1388                 dev_dbg(udc->dev, "invalid ep\n");
1389                 return -EINVAL;
1390         }
1391
1392
1393         if ((!udc) || (!udc->driver) || (udc->gadget.speed == USB_SPEED_UNKNOWN)) {
1394                 dev_dbg(udc->dev, "invalid device\n");
1395                 return -EINVAL;
1396         }
1397
1398 #if defined(UDC_ENABLE_DMA)
1399         if (ep->uses_dma) {
1400                 enum dma_data_direction direction;
1401                 struct lpc32xx_usbd_dd_gad *dd;
1402
1403                 /* Map DMA pointer */
1404                 if (ep->is_in)
1405                         direction = DMA_TO_DEVICE;
1406                 else
1407                         direction = DMA_FROM_DEVICE;
1408
1409                 if (req->req.dma == 0) {
1410                         req->req.dma = dma_map_single(
1411                                         ep->udc->gadget.dev.parent,
1412                                         req->req.buf, req->req.length, direction);
1413                         req->mapped = 1;
1414                 }
1415                 else {
1416                         dma_sync_single_for_device(
1417                                         ep->udc->gadget.dev.parent,
1418                                         req->req.dma, req->req.length, direction);
1419                         req->mapped = 0;
1420                 }
1421
1422                 /* For the request, build a list of DDs */
1423                 dd = udc_dd_alloc(udc);
1424                 if (!dd) {
1425                         /* Error allocating DD */
1426                         return -ENOMEM;
1427                 }
1428                 req->dd_desc_ptr = dd;
1429
1430                 /* Setup the DMA descriptor */
1431                 dd->dd_next_phy = dd->dd_next_v = NULL;
1432                 dd->dd_buffer_addr = (u32) req->req.dma;
1433                 dd->dd_status = 0;
1434
1435                 /* Special handling for ISO EPs */
1436                 if (ep->eptype == EP_ISO_TYPE) {
1437                         dd->dd_setup = DD_SETUP_ISO_EP |
1438                                 DD_SETUP_PACKETLEN(ep->ep.maxpacket) |
1439                                 DD_SETUP_DMALENBYTES(req->req.length);
1440                         dd->dd_iso_ps_mem_addr = (u32 *) ((u32) dd->this_dma + 20);
1441                         dd->iso_status[0] = req->req.length;
1442                 }
1443                 else {
1444                         dd->dd_setup = DD_SETUP_PACKETLEN(ep->ep.maxpacket) |
1445                                 DD_SETUP_DMALENBYTES(req->req.length);
1446                 }
1447         }
1448 #endif
1449
1450         ep_dbg(ep, "%s queue req %p len %d buf %p (in=%d) z=%d\n", _ep->name, _req, _req->length,
1451                         _req->buf, ep->is_in, _req->zero);
1452
1453         spin_lock_irqsave(&udc->lock, flags);
1454
1455         _req->status = -EINPROGRESS;
1456         _req->actual = 0;
1457         req->send_zlp = _req->zero;
1458
1459         /* Kickstart empty queues */
1460         if (list_empty(&ep->queue)) {
1461                 list_add_tail(&req->queue, &ep->queue);
1462
1463                 if (ep->hwep_num_base == 0) {
1464                         /* Handle expected data direction */
1465                         if (ep->is_in) {
1466                                 /* IN packet to host */
1467                                 udc->ep0state = DATA_IN;
1468                                 status = udc_ep0_in_req(udc);
1469                         }
1470                         else {
1471                                 /* OUT packet from host */
1472                                 udc->ep0state = DATA_OUT;
1473                                 status = udc_ep0_out_req(udc);
1474                         }
1475                 }
1476                 else if (ep->is_in) {
1477                         /* IN packet to host and kick off transfer */
1478                         if (!ep->req_pending) {
1479 #if defined(UDC_ENABLE_DMA)
1480                                 udc_ep_in_req_dma(udc, ep);
1481 #else
1482                                 uda_enable_hwepint(udc, ep->hwep_num);
1483                                 udc_ep_in_req(udc, ep);
1484 #endif
1485                         }
1486                 }
1487                 else {
1488                         /* OUT packet from host and kick off list */
1489                         if (!ep->req_pending) {
1490 #if defined(UDC_ENABLE_DMA)
1491                                 udc_ep_out_req_dma(udc, ep);
1492 #else
1493                                 uda_enable_hwepint(udc, ep->hwep_num);
1494                                 udc_ep_out_req(udc, ep);
1495 #endif
1496                         }
1497                 }
1498         }
1499         else
1500                 list_add_tail(&req->queue, &ep->queue);
1501
1502         spin_unlock_irqrestore(&udc->lock, flags);
1503
1504         return (status < 0) ? status : 0;
1505 }
1506
1507 static int lpc32xx_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1508 {
1509         struct lpc32xx_ep       *ep;
1510         struct lpc32xx_request  *req;
1511         unsigned long flags;
1512
1513         ep = container_of(_ep, struct lpc32xx_ep, ep);
1514         if (!_ep || ep->hwep_num_base == 0)
1515                 return -EINVAL;
1516
1517         spin_lock_irqsave(&ep->udc->lock, flags);
1518
1519         /* make sure it's actually queued on this endpoint */
1520         list_for_each_entry (req, &ep->queue, queue) {
1521                 if (&req->req == _req)
1522                         break;
1523         }
1524         if (&req->req != _req) {
1525                 spin_unlock_irqrestore(&ep->udc->lock, flags);
1526                 return -EINVAL;
1527         }
1528
1529         done(ep, req, -ECONNRESET);
1530         spin_unlock_irqrestore(&ep->udc->lock, flags);
1531
1532         return 0;
1533 }
1534
1535 static int lpc32xx_ep_set_halt(struct usb_ep *_ep, int value)
1536 {
1537         struct lpc32xx_ep *ep = container_of(_ep, struct lpc32xx_ep, ep);
1538         struct lpc32xx_udc *udc = ep->udc;
1539         unsigned long flags;
1540
1541         if ((!ep) || (ep->desc == NULL) || (ep->hwep_num <= 1))
1542                 return -EINVAL;
1543
1544         /* Don't halt an IN EP */
1545         if (ep->is_in)
1546                 return -EAGAIN;
1547
1548         spin_lock_irqsave(&udc->lock, flags);
1549
1550         if (value == 1) {
1551                 /* stall */
1552                 udc_protocol_cmd_data_w(udc, CMD_SET_EP_STAT(ep->hwep_num),
1553                                 DAT_WR_BYTE(EP_STAT_ST));
1554         }
1555         else {
1556                 /* End stall */
1557                 udc_protocol_cmd_data_w(udc, CMD_SET_EP_STAT(ep->hwep_num),
1558                                 DAT_WR_BYTE(0));
1559         }
1560
1561         spin_unlock_irqrestore(&udc->lock, flags);
1562
1563         return 0;
1564 }
1565
1566 static const struct usb_ep_ops lpc32xx_ep_ops = {
1567         .enable         = lpc32xx_ep_enable,
1568         .disable        = lpc32xx_ep_disable,
1569         .alloc_request  = lpc32xx_ep_alloc_request,
1570         .free_request   = lpc32xx_ep_free_request,
1571         .queue          = lpc32xx_ep_queue,
1572         .dequeue        = lpc32xx_ep_dequeue,
1573         .set_halt       = lpc32xx_ep_set_halt,
1574 };
1575
1576 #if defined(UDC_ENABLE_DMA)
1577 /* Setup up a IN request for DMA transfer - this consists of determining the
1578    list of DMA addresses for the transfer, allocating DMA Descriptors,
1579    installing the DD into the UDCA, and then enabling the DMA for that EP */
1580 static int udc_ep_in_req_dma(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep)
1581 {
1582         struct lpc32xx_request *req;
1583         u32 hwep = ep->hwep_num;
1584
1585         ep->req_pending = 1;
1586
1587         /* There will always be a request waiting here */
1588         req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1589
1590         /* Place the DD Descriptor into the UDCA */
1591         udc->udca_v_base[hwep] = (u32) req->dd_desc_ptr->this_dma;
1592         
1593         /* Enable DMA and interrupt for the HW EP */
1594         udc_ep_dma_enable(udc, hwep);
1595
1596         return 0;
1597 }
1598
1599 /* Setup up a OUT request for DMA transfer - this consists of determining the
1600    list of DMA addresses for the transfer, allocating DMA Descriptors,
1601    installing the DD into the UDCA, and then enabling the DMA for that EP */
1602 static int udc_ep_out_req_dma(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep)
1603 {
1604         struct lpc32xx_request *req;
1605         u32 hwep = ep->hwep_num;
1606
1607         ep->req_pending = 1;
1608
1609         /* There will always be a request waiting here */
1610         req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1611
1612         /* Place the DD Descriptor into the UDCA */
1613         udc->udca_v_base[hwep] = (u32) req->dd_desc_ptr->this_dma;
1614         
1615         /* Enable DMA and interrupt for the HW EP */
1616         udc_ep_dma_enable(udc, hwep);
1617
1618         return 0;
1619 }
1620
1621 /* Handle EP completion */
1622 void udc_handle_eps(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep) {
1623         u32 epstatus;
1624         struct lpc32xx_request *req;
1625
1626         uda_disable_hwepint(udc, ep->hwep_num);
1627
1628         if (ep->hwep_num <= 0)
1629                 return;
1630
1631         epstatus = udc_clearep_getsts(udc, ep->hwep_num);
1632
1633         req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1634         done(ep, req, 0);
1635
1636         /* Start another request if ready */
1637         if(!list_empty(&ep->queue)) {
1638                 if (ep->is_in) {
1639                         udc_ep_in_req_dma(udc, ep);
1640                 }
1641                 else {
1642                         udc_ep_out_req_dma(udc, ep);
1643                 }
1644         }
1645         else
1646                 ep->req_pending = 0;
1647 }
1648
1649 /* Send a ZLP on a non-0 IN EP */
1650 void udc_send_in_zlp(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep,
1651                 struct lpc32xx_usbd_dd_gad *dd) {
1652         /* Set up EP interrupt status */
1653         uda_enable_hwepint(udc, ep->hwep_num);
1654         udc_clearep_getsts(udc, ep->hwep_num);
1655
1656         /* Send ZLP */
1657         udc_write_hwep(udc, ep->hwep_num, NULL, 0);
1658 }
1659
1660 /* DMA end of transfer completion */
1661 static void udc_handle_dma_ep(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep) {
1662         u32 status;
1663         struct lpc32xx_request *req;
1664         struct lpc32xx_usbd_dd_gad *dd;
1665
1666 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1667         ep->totalints++;
1668 #endif
1669         req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1670         if (!req) {
1671                 ep_err(ep, "DMA interrupt on no req!\n");
1672                 return;
1673         }
1674         dd = req->dd_desc_ptr;
1675
1676         /* Wait for end of descriptor to retire */
1677         while (!(dd->dd_status & DD_STATUS_DD_RETIRED));
1678
1679         /* Disable DMA */
1680         udc_ep_dma_disable(udc, ep->hwep_num);
1681         __raw_writel((1 << ep->hwep_num), USBD_EOTINTCLR(udc->udp_baseaddr));
1682         __raw_writel((1 << ep->hwep_num), USBD_NDDRTINTCLR(udc->udp_baseaddr));
1683
1684         /* System error? */
1685         if (__raw_readl(USBD_SYSERRTINTST(udc->udp_baseaddr)) & (1 << ep->hwep_num)) {
1686                 __raw_writel((1 << ep->hwep_num), USBD_SYSERRTINTCLR(udc->udp_baseaddr));
1687                 ep_err(ep, "AHB critical error!\n");
1688                 ep->req_pending = 0;
1689
1690                 /* The error could of occurred on a packet of a multipacket transfer,
1691                    so recovering the transfer is not possible. Close the request with
1692                    an error */
1693                 done(ep, req, -ECONNABORTED);
1694
1695                 return;
1696         }
1697
1698         /* Handle the current DD's status */
1699         status = dd->dd_status;
1700         switch (status & DD_STATUS_STS_MASK) {
1701                 case DD_STATUS_STS_NS:
1702                         /* DD not serviced? This shouldn't happen! */
1703                         ep->req_pending = 0;
1704                         ep_err(ep, "DMA critical EP error: DD not serviced (0x%x)!\n", status);
1705                         done(ep, req, -ECONNABORTED);
1706                         return;
1707
1708                 case DD_STATUS_STS_BS:
1709                         /* Interrupt only fires on EOT - This shouldn't happen! */
1710                         ep->req_pending = 0;
1711                         ep_err(ep, "DMA critical EP error: EOT prior to service completion (0x%x)!\n", status);
1712                         done(ep, req, -ECONNABORTED);
1713                         return;
1714
1715                 case DD_STATUS_STS_NC:
1716                 case DD_STATUS_STS_DUR: /* Really just a short packet, not an underrun */
1717                         /* This is a good status and what we expect */
1718                         break;
1719
1720                 default:
1721                         /* Data overrun, system error, or unknown */
1722                         ep->req_pending = 0;
1723                         ep_err(ep, "DMA critical EP error: System error (0x%x)!\n", status);
1724                         done(ep, req, -ECONNABORTED);
1725                         return;
1726         }
1727
1728         /* Save transferred data size */
1729         req->req.actual += DD_STATUS_CURDMACNT(status);
1730
1731         /* Work around the wierd underrun packet issue */
1732         if ((!ep->is_in) && (!(req->req.actual % ep->maxpacket)) &&
1733                         ((req->req.length - req->req.actual) > 0)) {
1734                 ep_dbg(ep, "Short packet in unexpected situation!\n");
1735
1736                 // WTF is this? An underrun packet on OUT with no ZLP! Hardware issue? */
1737                 dd->dd_next_phy = dd->dd_next_v = NULL;
1738                 dd->dd_buffer_addr = (u32) req->req.dma;
1739                 dd->dd_buffer_addr += req->req.actual;
1740                 dd->dd_status = 0;
1741
1742                 /* Special handling for ISO EPs */
1743                 dd->dd_setup = DD_SETUP_PACKETLEN(ep->ep.maxpacket) |
1744                         DD_SETUP_DMALENBYTES(req->req.length - req->req.actual);
1745
1746                 /* Do the remainder of the req */
1747                 udc_ep_out_req_dma(udc, ep);
1748
1749                 return;
1750         }
1751
1752         /* ISO endpoints are handled differently */
1753         if (ep->eptype == EP_ISO_TYPE) {
1754                 if (!ep->is_in)
1755                         req->req.actual = dd->iso_status[0] & 0xFFFF;
1756         }
1757
1758         /* For an Bulk IN EP, the DMA engine will only send data as specified in the
1759            descriptor. If the total transfer size is a multiple of the max packet
1760            size, then the transfer was completed, but no ZLP was sent. The ZLP needs
1761            to be sent using the FIFO mechanism to terminate this transfer */
1762         if (req->send_zlp) {
1763                 udc_send_in_zlp(udc, ep, dd);
1764
1765                 /* Just exit */
1766                 return;
1767         }
1768
1769         /* Transfer request is complete */
1770         done(ep, req, 0);
1771
1772         udc_clearep_getsts(udc, ep->hwep_num);
1773         /* Start another request if ready */
1774         if(!list_empty((&ep->queue))) {
1775                 if (ep->is_in) {
1776                         udc_ep_in_req_dma(udc, ep);
1777                 }
1778                 else {
1779                         udc_ep_out_req_dma(udc, ep);
1780                 }
1781         }
1782         else 
1783                 ep->req_pending = 0;
1784 }
1785
1786 #else
1787 /* This function was called if a new request is ready to be placed into the SEND FIFO
1788    for transfer to the host, or when a previous transfer to the host has completed. */
1789 static int udc_ep_in_req(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep) {
1790         struct lpc32xx_request *req;
1791         u32 ts, epstatus, bufst;
1792         int is_last;
1793
1794         /* Select and clear EP interrupt */
1795         epstatus = udc_clearep_getsts(udc, ep->hwep_num);
1796
1797         if (epstatus & EP_SEL_ST) {
1798                 /* EP is stalled */
1799                 ep->totalstalls++;
1800                 return 0;
1801         }
1802
1803         if (epstatus & EP_SEL_EPN) {
1804                 /* NAK'd on other side */
1805                 ep->totalnaks++;
1806         }
1807
1808         bufst = (epstatus & EP_SEL_F);
1809
1810         /* Are any requests available? */
1811         if (list_empty(&ep->queue)) {
1812                 if (!bufst) {
1813                         /* No reqs and the hardware is idle, disable IRQ */
1814                         uda_disable_hwepint(udc, ep->hwep_num);
1815                 }
1816
1817                 return 0;
1818         }
1819
1820         /* If both buffers are currently full, just exit for now */
1821         if (bufst)
1822                 return 0;
1823
1824         /* A buffer is available in the hardware, so we can fill  it */
1825         req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1826
1827         /* Limit packet size to the size of the EP */
1828         ts = req->req.length - req->req.actual;
1829         if (ts > ep->ep.maxpacket)
1830                 ts = ep->ep.maxpacket;
1831
1832         /* Write data to the EP0 FIFO and start transfer */
1833         ep_dbg(ep, "SEND %s 0x%x(%d)\n", ep->ep.name, (u32)(req->req.buf + req->req.actual), ts);
1834         udc_write_hwep(udc, ep->hwep_num, (req->req.buf + req->req.actual), ts);
1835
1836         /* Increment data pointer */
1837         req->req.actual += ts;
1838
1839         if (ts < ep->ep.maxpacket)
1840                 is_last = 1;
1841         else if ((req->req.actual != req->req.length) || (req->send_zlp)) {
1842                 req->send_zlp = 0;
1843                 is_last = 0;
1844         }
1845         else
1846                 is_last = 1;
1847
1848         if (is_last) {
1849                 /* Transfer request is complete */
1850                 done(ep, req, 0);
1851                 return 1;
1852         }
1853
1854         /* Stay in data transfer state */
1855         return 0;
1856 }
1857
1858 static int udc_ep_out_req(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep) {
1859         struct lpc32xx_request *req;
1860         u32 tr, bufferspace, epstatus;
1861
1862         /* Clear EP interrupt */
1863         epstatus = udc_clearep_getsts(udc, ep->hwep_num);
1864
1865         if (epstatus & EP_SEL_ST) {
1866                 /* EP is stalled */
1867                 ep->totalstalls++;
1868         }
1869
1870         if (epstatus & EP_SEL_EPN) {
1871                 /* Sent NAK */
1872                 ep->totalnaks++;
1873         }
1874
1875         /* Are any requests available? */
1876         if (list_empty(&ep->queue)) {
1877                 uda_disable_hwepint(udc, ep->hwep_num);
1878
1879                 return 0;
1880         }
1881
1882         if (epstatus & EP_SEL_F) {
1883                 req = list_entry(ep->queue.next, struct lpc32xx_request, queue);
1884                 if (req->req.length == 0) {
1885                         ep_dbg(ep, "%s OUT zero buffer length!\n", ep->ep.name);
1886                         return 0;
1887                 }
1888
1889                 /* Limit transfer size to size of endpoint */
1890                 bufferspace = req->req.length - req->req.actual;
1891                 if (bufferspace > ep->ep.maxpacket)
1892                         bufferspace = ep->ep.maxpacket;
1893
1894                 /* Copy data to buffer from FIFO */
1895                 prefetchw(req->req.buf + req->req.actual);
1896                 tr = udc_read_hwep(udc, ep->hwep_num,
1897                                 (req->req.buf + req->req.actual), bufferspace);
1898
1899                 ep_dbg(ep, "RECV %s 0x%x(%d) %d %d\n", ep->ep.name, (u32)(req->req.buf + req->req.actual), tr,
1900                                 req->req.actual, req->req.length);
1901                 req->req.actual += tr;
1902
1903                 if ((tr < ep->ep.maxpacket) || (req->req.actual == req->req.length)) {
1904                         /* This is the last packet */
1905                         done(ep, req, 0);
1906
1907                         return 1;
1908                 }
1909         }
1910
1911         return 0;
1912 }
1913
1914 static void udc_handle_ep(struct lpc32xx_udc *udc, struct lpc32xx_ep *ep) {
1915         ep->totalints++;
1916
1917         if (!ep->desc) {
1918                 uda_disable_hwepint(udc, ep->hwep_num);
1919                 return;
1920         }
1921
1922         /* Nice and easy */
1923         if (ep->is_in) {
1924                 /* Handle IN request */
1925                 udc_ep_in_req(udc, ep);
1926         }
1927         else {
1928                 /* Handle OUT request */
1929                 udc_ep_out_req(udc, ep);
1930         }
1931 }
1932 #endif
1933
1934 /*
1935  *
1936  * Endpoint 0 functions
1937  * + *
1938  * + */
1939 static void udc_handle_dev(struct lpc32xx_udc *udc) {
1940         u32 tmp;
1941
1942         udc_protocol_cmd_w(udc, CMD_GET_DEV_STAT);
1943         tmp = udc_protocol_cmd_r(udc, DAT_GET_DEV_STAT);
1944
1945         if (tmp & DEV_RST) {
1946                 uda_usb_reset(udc);
1947         }
1948         else if (tmp & DEV_CON_CH) {
1949                 uda_power_event(udc, (tmp & DEV_CON));
1950         }
1951         else if (tmp & DEV_SUS_CH) {
1952                 if (tmp & DEV_SUS) {
1953                         if (udc->vbus == 0) {
1954                                 stop_activity(udc);
1955                         } else if ((udc->gadget.speed !=
1956                                                 USB_SPEED_UNKNOWN) && udc->driver &&
1957                                         udc->driver->suspend) {
1958                                 udc->driver->suspend(&udc->gadget);
1959                                 uda_resm_susp_event(udc, 1);
1960                         }
1961                 }
1962                 else {
1963                         if ((udc->gadget.speed != USB_SPEED_UNKNOWN) &&
1964                                         udc->driver && udc->driver->resume &&
1965                                         udc->vbus) {
1966                                 udc->driver->resume(&udc->gadget);
1967                                 uda_resm_susp_event(udc, 0);
1968                         }
1969                 }
1970         }
1971 }
1972
1973 /* IN endpoint 0 transfer */
1974 static int udc_ep0_in_req(struct lpc32xx_udc *udc) {
1975         struct lpc32xx_request *req;
1976         struct lpc32xx_ep *ep0 = &udc->ep [0];
1977         u32 tsend, ts = 0;
1978
1979         if (list_empty(&ep0->queue))
1980         {
1981                 /* Nothing to send */
1982                 return 0;
1983         }
1984         else {
1985                 req = list_entry(ep0->queue.next,
1986                                 struct lpc32xx_request, queue);
1987         }
1988
1989         tsend = ts = req->req.length - req->req.actual;
1990         if (ts == 0) {
1991                 /* Send a ZLP */
1992                 udc_ep0_send_zlp(udc);
1993                 done(ep0, req, 0);
1994                 return 1;
1995         }
1996         else if (ts > ep0->ep.maxpacket) {
1997                 /* Just send what we can */
1998                 ts = ep0->ep.maxpacket;
1999         }
2000
2001         /* Write data to the EP0 FIFO and start transfer */
2002         udc_write_hwep(udc, EP_IN, (req->req.buf + req->req.actual), ts);
2003
2004         /* Increment data pointer */
2005         req->req.actual += ts;
2006
2007         if (tsend >= ep0->ep.maxpacket) {
2008                 /* Stay in data transfer state */
2009                 return 0;
2010         }
2011
2012         /* Transfer request is complete */
2013         udc->ep0state = WAIT_FOR_SETUP;
2014         done(ep0, req, 0);
2015         return 1;
2016 }
2017
2018 /* OUT endpoint 0 transfer */
2019 static int udc_ep0_out_req(struct lpc32xx_udc *udc) {
2020         struct lpc32xx_request *req;
2021         struct lpc32xx_ep *ep0 = &udc->ep[0];
2022         u32 tr, bufferspace;
2023
2024         if (list_empty(&ep0->queue)) {
2025                 return 0;
2026         }
2027         else {
2028                 req = list_entry(ep0->queue.next, struct lpc32xx_request, queue);
2029         }
2030
2031         if (req) {
2032                 if (req->req.length == 0) {
2033                         /* Just dequeue request */
2034                         done(ep0, req, 0);
2035                         udc->ep0state = WAIT_FOR_SETUP;
2036                         return 1;
2037                 }
2038
2039                 /* Get data from FIFO */
2040                 bufferspace = req->req.length - req->req.actual;
2041                 if (bufferspace > ep0->ep.maxpacket) {
2042                         bufferspace = ep0->ep.maxpacket;
2043                 }
2044
2045                 /* Copy data to buffer */
2046                 prefetchw(req->req.buf + req->req.actual);
2047                 tr = udc_read_hwep(udc, EP_OUT,
2048                                 (req->req.buf + req->req.actual), bufferspace);
2049                 req->req.actual += bufferspace;
2050
2051                 if (tr < ep0->ep.maxpacket) {
2052                         /* This is the last packet */
2053                         done(ep0, req, 0);
2054                         udc->ep0state = WAIT_FOR_SETUP;
2055                         return 1;
2056                 }
2057         }
2058
2059         return 0;
2060 }
2061
2062 static int udc_get_status(struct lpc32xx_udc *udc, u16 reqtype, u16 wIndex) {
2063         struct lpc32xx_ep *ep;
2064         u32 ep0buff = 0, tmp;
2065
2066         switch (reqtype) {
2067                 case USB_RECIP_INTERFACE:
2068                         /* Not supported */
2069                         break;
2070
2071                 case USB_RECIP_DEVICE:
2072                         ep0buff = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
2073                         if (udc->dev_status & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
2074                                 ep0buff |= (1 << USB_DEVICE_REMOTE_WAKEUP);
2075                         }
2076                         break;
2077
2078                 case USB_RECIP_ENDPOINT:
2079                         tmp = wIndex & USB_ENDPOINT_NUMBER_MASK;
2080                         ep = &udc->ep[tmp];
2081                         if ((tmp == 0) || (tmp >= NUM_ENDPOINTS) || (tmp && !ep->desc)) {
2082                                 return -EOPNOTSUPP;
2083                         }
2084
2085                         if (wIndex & USB_DIR_IN) {
2086                                 if (!ep->is_in) {
2087                                         /* Somethings wrong */
2088                                         return -EOPNOTSUPP;
2089                                 }
2090                         } else if (ep->is_in)
2091                                 /* Not an IN endpoint */
2092                                 return -EOPNOTSUPP;
2093
2094                         /* Get status of the endpoint */
2095                         udc_protocol_cmd_w(udc, CMD_SEL_EP(ep->hwep_num));
2096                         tmp = udc_protocol_cmd_r(udc, DAT_SEL_EP(ep->hwep_num));
2097
2098                         if (tmp & EP_SEL_ST) {
2099                                 ep0buff = (1 << USB_ENDPOINT_HALT);
2100                         }
2101                         else {
2102                                 ep0buff = 0;
2103                         }
2104                         break;
2105
2106                 default:
2107                         break;
2108         }
2109
2110         /* Return data */
2111         udc_write_hwep(udc, EP_IN, &ep0buff, 2);
2112
2113         return 0;
2114 }
2115
2116 static void udc_handle_ep0_setup(struct lpc32xx_udc *udc) {
2117         struct lpc32xx_ep *ep, *ep0 = &udc->ep[0];
2118         struct usb_ctrlrequest ctrlpkt;
2119         int i, bytes;
2120         u16 wIndex, wValue, wLength, reqtype, req, tmp;
2121
2122         /* Nuke previous transfers */
2123         nuke(ep0, -EPROTO);
2124
2125         /* Get setup packet */
2126         bytes = udc_read_hwep(udc, EP_OUT, (u32 *) &ctrlpkt, 8);
2127         if (bytes != 8) {
2128                 ep_dbg(ep0, "Incorrectly sized setup packet (s/b 8, is %d!\n", bytes);
2129                 return;
2130         }
2131
2132         /* Native endianness */
2133         wIndex = le16_to_cpu(ctrlpkt.wIndex);
2134         wValue = le16_to_cpu(ctrlpkt.wValue);
2135         wLength = le16_to_cpu(ctrlpkt.wLength);
2136         reqtype = le16_to_cpu(ctrlpkt.bRequestType);
2137
2138         /* Set direction of EP0 */
2139         if (likely(reqtype & USB_DIR_IN)) {
2140                 ep0->is_in = 1;
2141         } else {
2142                 ep0->is_in = 0;
2143         }
2144
2145         /* Handle SETUP packet */
2146         req = le16_to_cpu(ctrlpkt.bRequest);
2147         switch (req) {
2148                 case USB_REQ_CLEAR_FEATURE:
2149                 case USB_REQ_SET_FEATURE:
2150                         switch (reqtype) {
2151                                 case (USB_TYPE_STANDARD | USB_RECIP_DEVICE):
2152                                         if (wValue != USB_DEVICE_REMOTE_WAKEUP) {
2153                                                 /* Nothing else handled */
2154                                                 goto stall;
2155                                         }
2156
2157                                         /* Tell board about event */
2158                                         if (req == USB_REQ_CLEAR_FEATURE)
2159                                                 udc->dev_status &= ~(1 << USB_DEVICE_REMOTE_WAKEUP);
2160                                         else
2161                                                 udc->dev_status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
2162                                         uda_remwkp_cgh(udc);
2163                                         goto zlp_send;
2164
2165                                 case (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT):
2166                                         tmp = wIndex & USB_ENDPOINT_NUMBER_MASK;
2167                                         if ((wValue != USB_ENDPOINT_HALT) || (tmp >= NUM_ENDPOINTS))
2168                                                 break;
2169
2170                                         /* Find hardware endpoint from logical endpoint */
2171                                         ep = &udc->ep[tmp];
2172                                         tmp = ep->hwep_num;
2173                                         if (tmp == 0)
2174                                                 break;
2175
2176                                         if (req == USB_REQ_CLEAR_FEATURE)
2177                                                 udc_stall_hwep(udc, tmp);
2178                                         else
2179                                                 udc_clrstall_hwep(udc, tmp);
2180
2181                                         goto zlp_send;
2182
2183                                 default:
2184                                         break;
2185                         }
2186
2187
2188                 case USB_REQ_SET_ADDRESS:
2189                         if (reqtype == (USB_TYPE_STANDARD | USB_RECIP_DEVICE)) {
2190                                 udc_set_address(udc, wValue);
2191                                 goto zlp_send;
2192                         }
2193                         break;
2194
2195                 case USB_REQ_GET_STATUS:
2196                         udc_get_status(udc, reqtype, wIndex);
2197                         return;
2198
2199                 default:
2200                         /* Let GadgetFs handle the descriptor instead */
2201                         break;
2202         }
2203
2204         if (likely(udc->driver)) {
2205                 /* device-2-host (IN) or no data setup command, process immediately */
2206                 spin_unlock(&udc->lock);
2207                 i = udc->driver->setup(&udc->gadget, &ctrlpkt);
2208                 spin_lock(&udc->lock);
2209                 if (req == USB_REQ_SET_CONFIGURATION) {
2210                         /* Configuration is set after endpoints are realized */
2211                         if (wValue) {
2212                                 /* Set configuration */
2213                                 udc_set_device_configured(udc);
2214
2215                                 /* NAK EP interrupts do not need to be enabled for this
2216                                    driver, but if you really want them for statistic
2217                                    purposes, uncomment the following lines */
2218                                 udc_protocol_cmd_data_w(udc, CMD_SET_MODE, DAT_WR_BYTE(AP_CLK |
2219 #if defined(UDC_ENABLE_DMA)
2220                                                         INAK_BI | INAK_II));
2221 #else
2222                                 INAK_BO | INAK_BI | INAK_IO | INAK_II));
2223 #endif
2224                         }
2225                         else {
2226                                 /* Clear configuration */
2227                                 udc_set_device_unconfigured(udc);
2228
2229                                 /* Disable NAK interrupts */
2230                                 udc_protocol_cmd_data_w(udc, CMD_SET_MODE, DAT_WR_BYTE(AP_CLK));
2231                         }
2232                 }
2233
2234                 if (i < 0) {
2235                         /* setup processing failed, force stall */
2236                         dev_err(udc->dev, "req %02x.%02x protocol STALL; stat %d\n",
2237                                         reqtype, req, i);
2238                         udc->ep0state = WAIT_FOR_SETUP;
2239                         goto stall;
2240                 }
2241         }
2242
2243         if (!ep0->is_in) {
2244                 /* ZLP IN packet on on data phase */
2245                 udc_ep0_send_zlp(udc);
2246         }
2247
2248         return;
2249
2250 stall:
2251         udc_stall_hwep(udc, EP_IN);
2252         return;
2253
2254 zlp_send:
2255         udc_ep0_send_zlp(udc);
2256         return;
2257 }
2258
2259 /* IN endpoint 0 transfer */
2260 static void udc_handle_ep0_in(struct lpc32xx_udc *udc) {
2261         struct lpc32xx_ep *ep0 = &udc->ep [0];
2262         u32 epstatus;
2263
2264         /* Clear EP interrupt */
2265         epstatus = udc_clearep_getsts(udc, EP_IN);
2266
2267 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2268         ep0->totalints++;
2269 #endif
2270
2271         /* Stalled? Clear stall and reset buffers */
2272         if (epstatus & EP_SEL_ST) {
2273                 udc_clrstall_hwep(udc, EP_IN);
2274                 nuke(ep0, -ECONNABORTED);
2275                 udc->ep0state = WAIT_FOR_SETUP;
2276                 return;
2277         }
2278
2279         /* Is a buffer available? */
2280         if (!(epstatus & EP_SEL_F)) {
2281                 /* Handle based on current state */
2282                 if (udc->ep0state == DATA_IN) {
2283                         udc_ep0_in_req(udc);
2284                 }
2285                 else {
2286                         /* Unknown state for EP0 oe end of DATA IN phase */
2287                         nuke(ep0, -ECONNABORTED);
2288                         udc->ep0state = WAIT_FOR_SETUP;
2289                 }
2290         }
2291 }
2292
2293 /* OUT endpoint 0 transfer */
2294 static void udc_handle_ep0_out(struct lpc32xx_udc *udc) {
2295         struct lpc32xx_ep *ep0 = &udc->ep[0];
2296         u32 epstatus;
2297
2298         /* Clear EP interrupt */
2299         epstatus = udc_clearep_getsts(udc, EP_OUT);
2300
2301 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2302         ep0->totalints++;
2303 #endif
2304
2305         /* Stalled? */
2306         if (epstatus & EP_SEL_ST) {
2307                 udc_clrstall_hwep(udc, EP_OUT);
2308                 nuke(ep0, -ECONNABORTED);
2309                 udc->ep0state = WAIT_FOR_SETUP;
2310                 return;
2311         }
2312
2313         /* A NAK may occur if a packet coudn't be received yet */
2314         if (epstatus & EP_SEL_EPN) {
2315                 return;
2316         }
2317         /* Setup packet incoming? */
2318         if (epstatus & EP_SEL_STP) {
2319                 nuke(ep0, 0);
2320                 udc->ep0state = WAIT_FOR_SETUP;
2321         }
2322
2323         /* Data available? */
2324         if (epstatus & EP_SEL_F) {
2325                 /* Handle based on current state */
2326                 switch (udc->ep0state) {
2327                         case WAIT_FOR_SETUP:
2328                                 udc_handle_ep0_setup(udc);
2329                                 break;
2330
2331                         case DATA_OUT:
2332                                 udc_ep0_out_req(udc);
2333                                 break;
2334
2335                         default:
2336                                 /* Unknown state for EP0 */
2337                                 nuke(ep0, -ECONNABORTED);
2338                                 udc->ep0state = WAIT_FOR_SETUP;
2339                 }
2340         }
2341 }
2342
2343 static int lpc32xx_get_frame(struct usb_gadget *gadget)
2344 {
2345         struct lpc32xx_udc *udc = to_udc(gadget);
2346
2347         if (!to_udc(gadget)->clocked)
2348                 return -EINVAL;
2349
2350         return (int) udc_get_current_frame(udc);
2351 }
2352
2353 static int lpc32xx_wakeup(struct usb_gadget *gadget)
2354 {
2355         return -ENOTSUPP;
2356 }
2357
2358 static int lpc32xx_set_selfpowered(struct usb_gadget *gadget, int is_on)
2359 {
2360         struct lpc32xx_udc *udc = to_udc(gadget);
2361
2362         /* Always self-powered */
2363         udc->selfpowered = (is_on != 0);
2364
2365         return 0;
2366         return -ENOTSUPP;
2367 }
2368
2369 /* vbus is here!  turn everything on that's ready */
2370 static int lpc32xx_vbus_session(struct usb_gadget *gadget, int is_active)
2371 {
2372         struct lpc32xx_udc *udc = to_udc(gadget);
2373
2374         /* Doesn't need lock */
2375         if (udc->driver)
2376                 pullup(udc, is_active);
2377         else
2378                 pullup(udc, 0);
2379
2380         return 0;
2381 }
2382
2383 static int lpc32xx_pullup(struct usb_gadget *gadget, int is_on)
2384 {
2385         struct lpc32xx_udc *udc = to_udc(gadget);
2386
2387         /* Doesn't need lock */
2388         pullup(udc, is_on);
2389
2390         return 0;
2391 }
2392
2393 static const struct usb_gadget_ops lpc32xx_udc_ops = {
2394         .get_frame              = lpc32xx_get_frame,
2395         .wakeup                 = lpc32xx_wakeup,
2396         .set_selfpowered        = lpc32xx_set_selfpowered,
2397         .vbus_session           = lpc32xx_vbus_session,
2398         .pullup                 = lpc32xx_pullup,
2399 };
2400
2401 static void nop_release(struct device *dev)
2402 {
2403         /* nothing to free */
2404 }
2405
2406 static struct lpc32xx_udc controller = {
2407         .gadget = {
2408                 .ops    = &lpc32xx_udc_ops,
2409                 .ep0    = &controller.ep[0].ep,
2410                 .name   = driver_name,
2411                 .dev    = {
2412                         .init_name = "gadget",
2413                         .release = nop_release,
2414                 }
2415         },
2416         .ep[0] = {
2417                 .ep = {
2418                         .name   = "ep0",
2419                         .ops    = &lpc32xx_ep_ops,
2420                 },
2421                 .udc            = &controller,
2422                 .maxpacket      = 64,
2423                 .hwep_num_base  = 0,
2424                 .hwep_num       = 0, /* Can be 0 or 1, has special handling */
2425                 .lep            = 0,
2426                 .eptype         = EP_CTL_TYPE,
2427         },
2428         .ep[1] = {
2429                 .ep = {
2430                         .name   = "ep1-int",
2431                         .ops    = &lpc32xx_ep_ops,
2432                 },
2433                 .udc            = &controller,
2434                 .maxpacket      = 64,
2435                 .hwep_num_base  = 2,
2436                 .hwep_num       = 0, /* 2 or 3, will be set later */
2437                 .lep            = 1,
2438                 .eptype         = EP_INT_TYPE,
2439         },
2440         .ep[2] = {
2441                 .ep = {
2442                         .name   = "ep2-bulk",
2443                         .ops    = &lpc32xx_ep_ops,
2444                 },
2445                 .udc            = &controller,
2446                 .maxpacket      = 64,
2447                 .hwep_num_base  = 4,
2448                 .hwep_num       = 0, /* 4 or 5, will be set later */
2449                 .doublebuff     = 1,
2450                 .lep            = 2,
2451                 .eptype         = EP_BLK_TYPE,
2452         },
2453         .ep[3] = {
2454                 .ep = {
2455                         .name   = "ep3-iso",
2456                         .ops    = &lpc32xx_ep_ops,
2457                 },
2458                 .udc            = &controller,
2459                 .maxpacket      = 1023,
2460                 .hwep_num_base  = 6,
2461                 .hwep_num       = 0, /* 6 or 7, will be set later */
2462                 .doublebuff     = 1,
2463                 .lep            = 3,
2464                 .eptype         = EP_ISO_TYPE,
2465         },
2466         .ep[4] = {
2467                 .ep = {
2468                         .name   = "ep4-int",
2469                         .ops    = &lpc32xx_ep_ops,
2470                 },
2471                 .udc            = &controller,
2472                 .maxpacket      = 64,
2473                 .hwep_num_base  = 8,
2474                 .hwep_num       = 0, /* 8 or 9, will be set later */
2475                 .lep            = 4,
2476                 .eptype         = EP_INT_TYPE,
2477         },
2478         .ep[5] = {
2479                 .ep = {
2480                         .name   = "ep5-bulk",
2481                         .ops    = &lpc32xx_ep_ops,
2482                 },
2483                 .udc            = &controller,
2484                 .maxpacket      = 64,
2485                 .hwep_num_base  = 10,
2486                 .hwep_num       = 0, /* 10 or 11, will be set later */
2487                 .doublebuff     = 1,
2488                 .lep            = 5,
2489                 .eptype         = EP_BLK_TYPE,
2490         },
2491         .ep[6] = {
2492                 .ep = {
2493                         .name   = "ep6-iso",
2494                         .ops    = &lpc32xx_ep_ops,
2495                 },
2496                 .udc            = &controller,
2497                 .maxpacket      = 1023,
2498                 .hwep_num_base  = 12,
2499                 .hwep_num       = 0, /* 12 or 13, will be set later */
2500                 .doublebuff     = 1,
2501                 .lep            = 6,
2502                 .eptype         = EP_ISO_TYPE,
2503         },
2504         .ep[7] = {
2505                 .ep = {
2506                         .name   = "ep7-int",
2507                         .ops    = &lpc32xx_ep_ops,
2508                 },
2509                 .udc            = &controller,
2510                 .maxpacket      = 64,
2511                 .hwep_num_base  = 14,
2512                 .hwep_num       = 0,
2513                 .lep            = 7,
2514                 .eptype         = EP_INT_TYPE,
2515         },
2516         .ep[8] = {
2517                 .ep = {
2518                         .name   = "ep8-bulk",
2519                         .ops    = &lpc32xx_ep_ops,
2520                 },
2521                 .udc            = &controller,
2522                 .maxpacket      = 64,
2523                 .hwep_num_base  = 16,
2524                 .hwep_num       = 0,
2525                 .doublebuff     = 1,
2526                 .lep            = 8,
2527                 .eptype         = EP_BLK_TYPE,
2528         },
2529         .ep[9] = {
2530                 .ep = {
2531                         .name   = "ep9-iso",
2532                         .ops    = &lpc32xx_ep_ops,
2533                 },
2534                 .udc            = &controller,
2535                 .maxpacket      = 1023,
2536                 .hwep_num_base  = 18,
2537                 .hwep_num       = 0,
2538                 .doublebuff     = 1,
2539                 .lep            = 9,
2540                 .eptype         = EP_ISO_TYPE,
2541         },
2542         .ep[10] = {
2543                 .ep = {
2544                         .name   = "ep10-int",
2545                         .ops    = &lpc32xx_ep_ops,
2546                 },
2547                 .udc            = &controller,
2548                 .maxpacket      = 64,
2549                 .hwep_num_base  = 20,
2550                 .hwep_num       = 0,
2551                 .lep            = 10,
2552                 .eptype         = EP_INT_TYPE,
2553         },
2554         .ep[11] = {
2555                 .ep = {
2556                         .name   = "ep11-bulk",
2557                         .ops    = &lpc32xx_ep_ops,
2558                 },
2559                 .udc            = &controller,
2560                 .maxpacket      = 64,
2561                 .hwep_num_base  = 22,
2562                 .hwep_num       = 0,
2563                 .doublebuff     = 1,
2564                 .lep            = 11,
2565                 .eptype         = EP_BLK_TYPE,
2566         },
2567         .ep[12] = {
2568                 .ep = {
2569                         .name   = "ep12-iso",
2570                         .ops    = &lpc32xx_ep_ops,
2571                 },
2572                 .udc            = &controller,
2573                 .maxpacket      = 1023,
2574                 .hwep_num_base  = 24,
2575                 .hwep_num       = 0,
2576                 .doublebuff     = 1,
2577                 .lep            = 12,
2578                 .eptype         = EP_ISO_TYPE,
2579         },
2580         .ep[13] = {
2581                 .ep = {
2582                         .name   = "ep13-int",
2583                         .ops    = &lpc32xx_ep_ops,
2584                 },
2585                 .udc            = &controller,
2586                 .maxpacket      = 64,
2587                 .hwep_num_base  = 26,
2588                 .hwep_num       = 0,
2589                 .lep            = 13,
2590                 .eptype         = EP_INT_TYPE,
2591         },
2592         .ep[14] = {
2593                 .ep = {
2594                         .name   = "ep14-bulk",
2595                         .ops    = &lpc32xx_ep_ops,
2596                 },
2597                 .udc            = &controller,
2598                 .maxpacket      = 64,
2599                 .hwep_num_base  = 28,
2600                 .hwep_num       = 0,
2601                 .doublebuff     = 1,
2602                 .lep            = 14,
2603                 .eptype         = EP_BLK_TYPE,
2604         },
2605         .ep[15] = {
2606                 .ep = {
2607                         .name   = "ep15-bulk",
2608                         .ops    = &lpc32xx_ep_ops,
2609                 },
2610                 .udc            = &controller,
2611                 .maxpacket      = 1023,
2612                 .hwep_num_base  = 30,
2613                 .hwep_num       = 0,
2614                 .doublebuff     = 1,
2615                 .lep            = 15,
2616                 .eptype         = EP_BLK_TYPE,
2617         },
2618 };
2619
2620 /* ISO and status interrupts */
2621 static irqreturn_t lpc32xx_usb_lp_irq(int irq, void *_udc) {
2622         u32 tmp, devstat;
2623         struct lpc32xx_udc *udc = _udc;
2624
2625         spin_lock(&udc->lock);
2626
2627         /* Read the device status register */
2628         devstat = __raw_readl(USBD_DEVINTST(udc->udp_baseaddr));
2629         devstat &= ~USBD_EP_FAST;
2630         __raw_writel(devstat, USBD_DEVINTCLR(udc->udp_baseaddr));
2631         devstat = devstat & udc->enabled_devints;
2632
2633         /* Device specific handling needed? */
2634         if (devstat & USBD_DEV_STAT) {
2635                 udc_handle_dev(udc);
2636         }
2637
2638         /* Start of frame? */
2639         if (devstat & FRAME_INT) {
2640                 /* The frame interrupt isn't really needed for ISO support,
2641                    as the driver will queue the necessary packets */
2642                 dev_dbg(udc->dev, "Device frame interrupt not supported\n");
2643         }
2644
2645         /* Error? */
2646         if (devstat & ERR_INT) {
2647                 /* All types of errors, from cable removal during transfer to
2648                    misc protocol and bit errors. These are mostly for just info,
2649                    as the USB hardware will work around these */
2650                 udc_protocol_cmd_w(udc, CMD_RD_ERR_STAT);
2651                 tmp = udc_protocol_cmd_r(udc, DAT_RD_ERR_STAT);
2652                 dev_err(udc->dev, "Device error (0x%x)!\n", tmp);
2653         }
2654
2655         spin_unlock(&udc->lock);
2656         return IRQ_HANDLED;
2657 }
2658
2659 /* EP interrupts */
2660 static irqreturn_t lpc32xx_usb_hp_irq(int irq, void *_udc)
2661 {
2662         u32 tmp;
2663         struct lpc32xx_udc *udc = _udc;
2664
2665         spin_lock(&udc->lock);
2666
2667         /* Read the device status register */
2668         tmp = __raw_readl(USBD_DEVINTST(udc->udp_baseaddr));
2669         __raw_writel(USBD_EP_FAST, USBD_DEVINTCLR(udc->udp_baseaddr));
2670
2671         /* Endpoints */
2672         tmp = __raw_readl(USBD_EPINTST(udc->udp_baseaddr));
2673
2674         /* Special handling for EP0 */
2675         if (tmp & (EP_MASK_SEL(0, EP_OUT) | EP_MASK_SEL(0, EP_IN))) {
2676                 /* Handle EP0 IN */
2677                 if (tmp & (EP_MASK_SEL(0, EP_IN)))
2678                         udc_handle_ep0_in(udc);
2679
2680                 /* Handle EP0 OUT */
2681                 if (tmp & (EP_MASK_SEL(0, EP_OUT)))
2682                         udc_handle_ep0_out(udc);
2683         }
2684
2685         /* All other EPs */
2686         if (tmp & ~(EP_MASK_SEL(0, EP_OUT) | EP_MASK_SEL(0, EP_IN))) {
2687                 int i;
2688
2689                 /* Handle other EP interrupts */
2690                 for (i = 1; i < NUM_ENDPOINTS; i++) {
2691                         if (tmp & (1 << udc->ep [i].hwep_num))
2692 #if defined(UDC_ENABLE_DMA)
2693                                 udc_handle_eps(udc, &udc->ep[i]);
2694 #else
2695                                 udc_handle_ep(udc, &udc->ep[i]);
2696 #endif
2697                 }
2698         }
2699
2700         spin_unlock(&udc->lock);
2701         return IRQ_HANDLED;
2702 }
2703
2704 static irqreturn_t lpc32xx_usb_devdma_irq(int irq, void *_udc)
2705 {
2706         struct lpc32xx_udc *udc = _udc;
2707
2708 #if defined(UDC_ENABLE_DMA)
2709         int i;
2710         u32 tmp;
2711
2712         spin_lock(&udc->lock);
2713
2714         /* Handle EP DMA EOT interrupts */
2715         tmp = __raw_readl(USBD_EOTINTST(udc->udp_baseaddr)) |
2716                 __raw_readl(USBD_NDDRTINTST(udc->udp_baseaddr)) |
2717                 __raw_readl(USBD_SYSERRTINTST(udc->udp_baseaddr));
2718         for (i = 1; i < NUM_ENDPOINTS; i++) {
2719                 if (tmp & (1 << udc->ep [i].hwep_num))
2720                         udc_handle_dma_ep(udc, &udc->ep[i]);
2721         }
2722
2723         spin_unlock(&udc->lock);
2724 #endif
2725
2726         return IRQ_HANDLED;
2727 }
2728
2729 /*
2730  *
2731  * VBUS detection, pullup handler, and Gadget cable state notification
2732  *
2733  */
2734 static int vbus_handler_thread(void *udc_)
2735 {
2736         struct lpc32xx_udc *udc = udc_;
2737         u8 value;
2738
2739         /* The main loop */
2740         while (!kthread_should_stop()) {
2741                 if (udc->enabled != 0) {
2742                         /* Get the VBUS status from the transceiver */
2743                         value = i2c_read(ISP1301_I2C_OTG_CONTROL_2);
2744
2745                         /* VBUS on or off? */
2746                         if (value & OTG_B_SESS_VLD) {
2747                                 udc->vbus = 1;
2748
2749                                 /* Enable USB clocks */
2750                                 udc_clk_set(udc, 1);
2751
2752                                 /* Setup the UDC and ep0 */
2753                                 udc_enable(udc);
2754                         }
2755                         else {
2756                                 /* Will force disconnect */
2757                                 udc->vbus = 0;
2758                         }
2759
2760                         /* VBUS changed? */
2761                         if (udc->last_vbus != udc->vbus) {
2762                                 lpc32xx_vbus_session(&udc->gadget, udc->vbus);
2763                                 udc->last_vbus = udc->vbus;
2764                         }
2765                 }
2766
2767                 /* sleep if nothing to send */
2768                 set_current_state(TASK_INTERRUPTIBLE);
2769                 schedule();
2770         }
2771
2772         udc->thread_task = NULL;
2773
2774         return 0;
2775 }
2776
2777 static irqreturn_t lpc32xx_usb_vbus_irq(int irq, void *_udc)
2778 {
2779         struct lpc32xx_udc *udc = _udc;
2780
2781         /* Discharge VBUS real quick */
2782         i2c_write(OTG1_VBUS_DISCHRG, ISP1301_I2C_OTG_CONTROL_1);
2783         
2784         /* Give VBUS some time (100mS) to discharge */
2785         msleep(100);
2786
2787         /* Disable VBUS discharge resistor */
2788         i2c_write(OTG1_VBUS_DISCHRG,
2789                         (ISP1301_I2C_OTG_CONTROL_1 | ISP1301_I2C_REG_CLEAR_ADDR));
2790         
2791         /* Clear interrupt */
2792         i2c_write(~0, ISP1301_I2C_INTERRUPT_LATCH | ISP1301_I2C_REG_CLEAR_ADDR);
2793         
2794         /* Kick off the VBUS handler thread */
2795         udc->thread_wakeup_needed = 1;
2796         wake_up_process(udc->thread_task);
2797
2798         return IRQ_HANDLED;
2799 }
2800
2801 int usb_gadget_register_driver (struct usb_gadget_driver *driver)
2802 {
2803         struct lpc32xx_udc *udc = &controller;
2804         int retval;
2805
2806         if (!driver || driver->speed < USB_SPEED_FULL ||
2807                         !driver->bind || !driver->setup) {
2808                 dev_err(udc->dev, "bad parameter.\n");
2809                 return -EINVAL;
2810         }
2811
2812         if (udc->driver) {
2813                 dev_err(udc->dev, "UDC already has a gadget driver\n");
2814                 return -EBUSY;
2815         }
2816
2817         udc->driver = driver;
2818         udc->gadget.dev.driver = &driver->driver;
2819         udc->enabled = 1;
2820         udc->selfpowered = 1;
2821         udc->vbus = 0;
2822
2823         retval = driver->bind(&udc->gadget);
2824         if (retval) {
2825                 dev_err(udc->dev, "driver->bind() returned %d\n", retval);
2826                 udc->enabled = 0;
2827                 udc->selfpowered = 0;
2828                 udc->driver = NULL;
2829                 udc->gadget.dev.driver = NULL;
2830                 return retval;
2831         }
2832
2833         dev_dbg(udc->dev, "bound to %s\n", driver->driver.name);
2834
2835         /* Force VBUS process once to check for cable insertion */
2836         udc->last_vbus = udc->vbus = 0;
2837         wake_up_process(udc->thread_task);
2838         enable_irq(udc->udp_irq[IRQ_USB_ATX]);
2839
2840         return 0;
2841 }
2842 EXPORT_SYMBOL (usb_gadget_register_driver);
2843
2844 int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
2845 {
2846         struct lpc32xx_udc *udc = &controller;
2847
2848         if (!driver || driver != udc->driver || !driver->unbind)
2849                 return -EINVAL;
2850
2851         disable_irq(udc->udp_irq[IRQ_USB_ATX]);
2852         local_irq_disable();
2853         udc->enabled = 0;
2854         pullup(udc, 0);
2855         local_irq_enable();
2856
2857         driver->unbind(&udc->gadget);
2858         udc->gadget.dev.driver = NULL;
2859         udc->driver = NULL;
2860
2861         dev_dbg(udc->dev, "unbound from %s\n", driver->driver.name);
2862         return 0;
2863 }
2864 EXPORT_SYMBOL (usb_gadget_unregister_driver);
2865
2866 /*-------------------------------------------------------------------------*/
2867
2868 static void lpc32xx_udc_shutdown(struct platform_device *dev)
2869 {
2870         /* Force disconnect on reboot */
2871         struct lpc32xx_udc *udc = &controller;
2872
2873         pullup(udc, 0);
2874 }
2875
2876 static int __init lpc32xx_udc_probe(struct platform_device *pdev)
2877 {
2878         struct device *dev = &pdev->dev;
2879         struct lpc32xx_udc *udc = &controller;
2880         int retval, i;
2881         struct resource *res;
2882         dma_addr_t dma_handle;
2883         struct i2c_adapter *i2c_adap;
2884         struct i2c_board_info i2c_info;
2885
2886         /* init software state */
2887         udc->gadget.dev.parent = dev;
2888         udc->pdev = pdev;
2889         udc->dev = &pdev->dev;
2890         udc->enabled = 0;
2891
2892         if (!dev->platform_data) {
2893                 dev_err(udc->dev, "missing platform_data\n");
2894                 return -ENODEV;
2895         }
2896
2897         udc->board = (struct lpc32xx_usbd_cfg *) dev->platform_data;
2898
2899         /*
2900          * Resources are mapped as follows:
2901          *  [0] = IORESOURCE_MEM, base address and size of USB space
2902          *  [1] = IORESOURCE_IRQ, USB device low priority interrupt number
2903          *  [2] = IORESOURCE_IRQ, USB device high priority interrupt number
2904          *  [3] = IORESOURCE_IRQ, USB device interrupt number
2905          *  [4] = IORESOURCE_IRQ, USB transciever interrupt number
2906          */
2907         if (pdev->num_resources != 5) {
2908                 dev_err(udc->dev, "invalid num_resources\n");
2909                 return -ENODEV;
2910         }
2911
2912         if (pdev->resource[0].flags != IORESOURCE_MEM) {
2913                 dev_err(udc->dev, "invalid resource type\n");
2914                 return -ENODEV;
2915         }
2916
2917         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2918         if (!res)
2919                 return -ENXIO;
2920
2921         spin_lock_init(&udc->lock);
2922
2923         /* Get IRQs */
2924         for (i = 0; i < 4; i++) {
2925                 if (pdev->resource[i + 1].flags != IORESOURCE_IRQ) {
2926                         dev_err(udc->dev, "invalid resource type\n");
2927                         return -ENODEV;
2928                 }
2929                 udc->udp_irq[i] = platform_get_irq(pdev, i);
2930         }
2931
2932         udc->io_p_start = res->start;
2933         udc->io_p_size = res->end - res->start + 1;
2934         if (!request_mem_region(udc->io_p_start, udc->io_p_size, driver_name)) {
2935                 dev_err(udc->dev, "someone's using UDC memory\n");
2936                 return -EBUSY;
2937         }
2938
2939         /* Enable AHB slave USB clock, needed for further USB clock control */
2940         __raw_writel(USB_SLAVE_HCLK_EN | (1 << 19), USB_CTRL);
2941
2942         /* Get required clocks */
2943         udc->usb_pll_clk = clk_get(&pdev->dev, "ck_pll5");
2944         if (IS_ERR(udc->usb_pll_clk)) {
2945                 dev_err(udc->dev, "failed to acquire USB PLL");
2946                 retval = PTR_ERR(udc->usb_pll_clk);
2947                 goto pll_get_fail;
2948         }
2949         udc->usb_slv_clk = clk_get(&pdev->dev, "ck_usbd");
2950         if (IS_ERR(udc->usb_slv_clk)) {
2951                 dev_err(udc->dev, "failed to acquire USB device clock");
2952                 retval = PTR_ERR(udc->usb_slv_clk);
2953                 goto usb_clk_get_fail;
2954         }
2955
2956         /* Setup PLL clock to 48MHz */
2957         retval = clk_enable(udc->usb_pll_clk);
2958         if (retval < 0) {
2959                 dev_err(udc->dev, "failed to start USB PLL");
2960                 goto pll_enable_fail;
2961         }
2962
2963         retval = clk_set_rate(udc->usb_pll_clk, 48000);
2964         if (retval < 0) {
2965                 dev_err(udc->dev, "failed to set USB clock rate");
2966                 goto pll_set_fail;
2967         }
2968
2969         __raw_writel(__raw_readl(USB_CTRL) | USB_DEV_NEED_CLK_EN, USB_CTRL);
2970
2971         /* Enable USB device clock */
2972         retval = clk_enable(udc->usb_slv_clk);
2973         if (retval < 0) {
2974                 dev_err(udc->dev, "failed to start USB device clock");
2975                 goto usb_clk_enable_fail;
2976         }
2977
2978         /* Set to enable all needed USB OTG clocks */
2979         __raw_writel(USB_CLOCK_MASK, USB_OTG_CLK_CTRL);
2980
2981         /* This is unsafe */
2982         while ((__raw_readl(USB_OTG_CLK_STAT) & USB_CLOCK_MASK) !=
2983                         USB_CLOCK_MASK);
2984
2985         /* All clocks are now on */
2986         udc->clocked = 1;
2987
2988         retval = i2c_add_driver(&isp1301_driver);
2989         if (retval < 0) {
2990                 dev_err(udc->dev, "Failed to add ISP1301 driver \n");
2991                 goto i2c_add_fail;
2992         }
2993         i2c_adap = i2c_get_adapter(2);
2994         memset(&i2c_info, 0, sizeof(struct i2c_board_info));
2995         isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
2996                         normal_i2c);
2997         i2c_put_adapter(i2c_adap);
2998         if (!isp1301_i2c_client) {
2999                 dev_err(udc->dev,"failed to connect I2C to ISP1301 USB Transceiver");
3000                 goto i2c_probe_fail;
3001         }
3002
3003         dev_info(udc->dev, "I2C device at address 0x%x", isp1301_i2c_client->addr);
3004
3005         isp1301_udc_configure(udc);
3006         /* Map register space */
3007         udc->udp_baseaddr = ioremap(udc->io_p_start, udc->io_p_size);
3008         if (!udc->udp_baseaddr) {
3009                 retval = -ENOMEM;
3010                 dev_err(udc->dev, "IO map failure");
3011                 goto io_map_fail;
3012         }
3013
3014         /* Allocate memory for the UDCA */
3015         udc->udca_v_base = dma_alloc_coherent(&pdev->dev, UDCA_BUFF_SIZE,
3016                         &dma_handle, (GFP_KERNEL | GFP_DMA));
3017         if (!udc->udca_v_base)
3018         {
3019                 dev_err(udc->dev, "error getting UDCA region");
3020                 retval = -ENOMEM;
3021                 goto dma_alloc_fail;
3022         }
3023         udc->udca_p_base = (void *) dma_handle;
3024         dev_dbg(udc->dev, "DMA buffer(0x%x bytes), P:0x%08x, V:0x%08x",
3025                         UDCA_BUFF_SIZE, (u32) udc->udca_p_base, (u32) udc->udca_v_base);
3026
3027         /* Setup the DD DMA memory pool */
3028         udc->dd_cache = dma_pool_create ("udc_dd", udc->dev,
3029                         sizeof (struct lpc32xx_usbd_dd_gad), sizeof (u32), 0);
3030         if (!udc->dd_cache) {
3031                 dev_err(udc->dev, "error getting DD DMA region");
3032                 retval = -ENOMEM;
3033                 goto dma2_alloc_fail;
3034         }
3035
3036         /* Clear USB peripheral and initialize gadget endpoints */
3037         udc_disable(udc);
3038         udc_reinit(udc);
3039
3040         retval = device_register(&udc->gadget.dev);
3041         if (retval < 0) {
3042                 dev_err(udc->dev, "Device registration failure");
3043                 goto dev_register_fail;
3044         }
3045
3046         /* Request IRQs - low and high priority USB device IRQs are routed to the
3047            same handler, while the DMA interrupt is routed elsewhere */
3048         retval = request_irq(udc->udp_irq[IRQ_USB_LP], lpc32xx_usb_lp_irq,
3049                         0, "udc_lp", udc);
3050         if (retval < 0) {
3051                 dev_err(udc->dev, "LP request irq %d failed", udc->udp_irq[IRQ_USB_LP]);
3052                 goto irq_lp_fail;
3053         }
3054         retval = request_irq(udc->udp_irq[IRQ_USB_HP], lpc32xx_usb_hp_irq,
3055                         0, "udc_hp", udc);
3056         if (retval < 0) {
3057                 dev_err(udc->dev, "HP request irq %d failed", udc->udp_irq[IRQ_USB_HP]);
3058                 goto irq_hp_fail;
3059         }
3060
3061         retval = request_irq(udc->udp_irq[IRQ_USB_DEVDMA], lpc32xx_usb_devdma_irq,
3062                         0, "udc_dma", udc);
3063         if (retval < 0) {
3064                 dev_err(udc->dev, "DEV request irq %d failed", udc->udp_irq[IRQ_USB_DEVDMA]);
3065                 goto irq_dev_fail;
3066         }
3067
3068         /* Create VBUS handler thread */
3069         udc->thread_wakeup_needed = 0;
3070         udc->thread_task = kthread_create(vbus_handler_thread, udc,
3071                         "vbus_handler_thread");
3072         if (IS_ERR(udc->thread_task)) {
3073                 retval = PTR_ERR(udc->thread_task);
3074                 dev_err(udc->dev, "VBUS handler thread failures");
3075                 goto vbus_thread_fail;
3076         }
3077
3078         /* The transceiver interrupt is used for VBUS detection and will
3079            kick off the VBUS handler thread */
3080         retval = request_threaded_irq(udc->udp_irq[IRQ_USB_ATX], NULL, lpc32xx_usb_vbus_irq,
3081                                  IRQF_ONESHOT, "udc_otg", udc);
3082         if (retval < 0) {
3083                 dev_err(udc->dev, "VBUS request irq %d failed\n", udc->udp_irq[IRQ_USB_ATX]);
3084                 goto irq_xcvr_fail;
3085         }
3086
3087         /* Initialize wait queue */
3088         init_waitqueue_head(&udc->ep_disable_wait_queue);
3089         atomic_set(&udc->enabled_ep_cnt,0);
3090
3091         /* Keep VBUS IRQ disabled until GadgetFS starts up */
3092         disable_irq(udc->udp_irq[IRQ_USB_ATX]);
3093
3094         dev_set_drvdata(dev, udc);
3095         device_init_wakeup(dev, 1);
3096         create_debug_file(udc);
3097
3098         /* Disable clocks for now */
3099         udc_clk_set(udc, 0);
3100
3101         dev_info(udc->dev, "%s version %s\n", driver_name, DRIVER_VERSION);
3102         return 0;
3103
3104 irq_xcvr_fail:
3105         kthread_stop(udc->thread_task);
3106 vbus_thread_fail:
3107         free_irq(udc->udp_irq[IRQ_USB_DEVDMA], udc);
3108 irq_dev_fail:
3109         free_irq(udc->udp_irq[IRQ_USB_HP], udc);
3110 irq_hp_fail:
3111         free_irq(udc->udp_irq[IRQ_USB_LP], udc);
3112 irq_lp_fail:
3113         device_unregister(&udc->gadget.dev);
3114 dev_register_fail:
3115         dma_pool_destroy(udc->dd_cache);
3116 dma2_alloc_fail:
3117         dma_free_coherent(&pdev->dev, UDCA_BUFF_SIZE,
3118                         udc->udca_v_base, (dma_addr_t) udc->udca_p_base);
3119 dma_alloc_fail:
3120         iounmap(udc->udp_baseaddr);
3121 io_map_fail:
3122         i2c_unregister_device(isp1301_i2c_client);
3123         isp1301_i2c_client = NULL;
3124 i2c_probe_fail:
3125         i2c_del_driver(&isp1301_driver);
3126 i2c_add_fail:
3127         clk_disable(udc->usb_slv_clk);
3128 usb_clk_enable_fail:
3129 pll_set_fail:
3130         clk_disable(udc->usb_pll_clk);
3131 pll_enable_fail:
3132         clk_put(udc->usb_slv_clk);
3133 usb_clk_get_fail:
3134         clk_put(udc->usb_pll_clk);
3135 pll_get_fail:
3136         release_mem_region(udc->io_p_start, udc->io_p_size);
3137         dev_err(udc->dev, "%s probe failed, %d\n", driver_name, retval);
3138
3139         return retval;
3140 }
3141
3142 static int __exit lpc32xx_udc_remove(struct platform_device *pdev)
3143 {
3144         struct lpc32xx_udc *udc = platform_get_drvdata(pdev);
3145
3146         if (udc->driver)
3147                 return -EBUSY;
3148
3149         udc_clk_set(udc, 1);
3150         udc_disable(udc);
3151         pullup(udc, 0);
3152
3153         free_irq(udc->udp_irq[IRQ_USB_ATX], udc);
3154
3155         device_init_wakeup(&pdev->dev, 0);
3156         remove_debug_file(udc);
3157
3158         dma_pool_destroy(udc->dd_cache);
3159         dma_free_coherent(&pdev->dev, UDCA_BUFF_SIZE,
3160                         udc->udca_v_base, (dma_addr_t) udc->udca_p_base);
3161         kthread_stop(udc->thread_task);
3162         free_irq(udc->udp_irq[IRQ_USB_DEVDMA], udc);
3163         free_irq(udc->udp_irq[IRQ_USB_HP], udc);
3164         free_irq(udc->udp_irq[IRQ_USB_LP], udc);
3165
3166         device_unregister(&udc->gadget.dev);
3167
3168         clk_disable(udc->usb_slv_clk);
3169         clk_put(udc->usb_slv_clk);
3170         clk_disable(udc->usb_pll_clk);
3171         clk_put(udc->usb_pll_clk);
3172         iounmap(udc->udp_baseaddr);
3173         i2c_unregister_device(isp1301_i2c_client);
3174         isp1301_i2c_client = NULL;
3175         i2c_del_driver(&isp1301_driver);
3176         release_mem_region(udc->io_p_start, udc->io_p_size);
3177
3178         return 0;
3179 }
3180
3181 #ifdef CONFIG_PM
3182 static int lpc32xx_udc_suspend(struct platform_device *pdev, pm_message_t mesg)
3183 {
3184         struct lpc32xx_udc *udc = platform_get_drvdata(pdev);
3185
3186         if (udc->clocked) {
3187                 /* Power down ISP */
3188                 isp1301_set_powerstate(0);
3189
3190                 /* Disable clocking */
3191                 udc_clk_set(udc, 0);
3192
3193                 /* Keep clock flag on, so we know to re-enable clocks
3194                    on resume */
3195                 udc->clocked = 1;
3196
3197                 /* Kill OTG and I2C clocks */
3198                 __raw_writel(0, USB_OTG_CLK_CTRL);
3199                 while ((__raw_readl(USB_OTG_CLK_STAT) & OTGOFF_CLK_MASK) !=
3200                                 OTGOFF_CLK_MASK);
3201
3202                 /* Kill global USB clock */
3203                 clk_disable(udc->usb_slv_clk);
3204         }
3205
3206         return 0;
3207 }
3208
3209 static int lpc32xx_udc_resume(struct platform_device *pdev)
3210 {
3211         struct lpc32xx_udc *udc = platform_get_drvdata(pdev);
3212
3213         if (udc->clocked) {
3214                 /* Enable global USB clock */
3215                 clk_enable(udc->usb_slv_clk);
3216
3217                 /* Enable clocking */
3218                 udc_clk_set(udc, 1);
3219
3220                 /* ISP back to normal power mode */
3221                 isp1301_set_powerstate(1);
3222         }
3223
3224         return 0;
3225 }
3226 #else
3227 #define lpc32xx_udc_suspend     NULL
3228 #define lpc32xx_udc_resume      NULL
3229 #endif
3230
3231 static struct platform_driver lpc32xx_udc_driver = {
3232         .probe          = lpc32xx_udc_probe,
3233         .remove         = __exit_p(lpc32xx_udc_remove),
3234         .shutdown       = lpc32xx_udc_shutdown,
3235         .suspend        = lpc32xx_udc_suspend,
3236         .resume         = lpc32xx_udc_resume,
3237         .driver         = {
3238                 .name   = (char *) driver_name,
3239                 .owner  = THIS_MODULE,
3240         },
3241 };
3242
3243 static int __init udc_init_module(void)
3244 {
3245         return platform_driver_register(&lpc32xx_udc_driver);
3246 }
3247 module_init(udc_init_module);
3248
3249 static void __exit udc_exit_module(void)
3250 {
3251         platform_driver_unregister(&lpc32xx_udc_driver);
3252 }
3253 module_exit(udc_exit_module);
3254
3255 MODULE_DESCRIPTION("LPC32XX udc driver");
3256 MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com");
3257 MODULE_LICENSE("GPL");
3258 MODULE_ALIAS("platform:lpc32xx_udc");
3259