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