drivers/usb/gadget/lpc32xx_udc.c

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