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