drivers/usb/gadget/pch_udc.c

   1 /*
   2  * Copyright (C) 2010 OKI SEMICONDUCTOR CO., LTD.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  16  */
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/pci.h>
  21 #include <linux/delay.h>
  22 #include <linux/errno.h>
  23 #include <linux/list.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/usb/ch9.h>
  26 #include <linux/usb/gadget.h>
  27
  28 /* Address offset of Registers */
  29 #define UDC_EP_REG_SHIFT        0x20    /* Offset to next EP */
  30
  31 #define UDC_EPCTL_ADDR          0x00    /* Endpoint control */
  32 #define UDC_EPSTS_ADDR          0x04    /* Endpoint status */
  33 #define UDC_BUFIN_FRAMENUM_ADDR 0x08    /* buffer size in / frame number out */
  34 #define UDC_BUFOUT_MAXPKT_ADDR  0x0C    /* buffer size out / maxpkt in */
  35 #define UDC_SUBPTR_ADDR         0x10    /* setup buffer pointer */
  36 #define UDC_DESPTR_ADDR         0x14    /* Data descriptor pointer */
  37 #define UDC_CONFIRM_ADDR        0x18    /* Write/Read confirmation */
  38
  39 #define UDC_DEVCFG_ADDR         0x400   /* Device configuration */
  40 #define UDC_DEVCTL_ADDR         0x404   /* Device control */
  41 #define UDC_DEVSTS_ADDR         0x408   /* Device status */
  42 #define UDC_DEVIRQSTS_ADDR      0x40C   /* Device irq status */
  43 #define UDC_DEVIRQMSK_ADDR      0x410   /* Device irq mask */
  44 #define UDC_EPIRQSTS_ADDR       0x414   /* Endpoint irq status */
  45 #define UDC_EPIRQMSK_ADDR       0x418   /* Endpoint irq mask */
  46 #define UDC_DEVLPM_ADDR         0x41C   /* LPM control / status */
  47 #define UDC_CSR_BUSY_ADDR       0x4f0   /* UDC_CSR_BUSY Status register */
  48 #define UDC_SRST_ADDR           0x4fc   /* SOFT RESET register */
  49 #define UDC_CSR_ADDR            0x500   /* USB_DEVICE endpoint register */
  50
  51 /* Endpoint control register */
  52 /* Bit position */
  53 #define UDC_EPCTL_MRXFLUSH              (1 << 12)
  54 #define UDC_EPCTL_RRDY                  (1 << 9)
  55 #define UDC_EPCTL_CNAK                  (1 << 8)
  56 #define UDC_EPCTL_SNAK                  (1 << 7)
  57 #define UDC_EPCTL_NAK                   (1 << 6)
  58 #define UDC_EPCTL_P                     (1 << 3)
  59 #define UDC_EPCTL_F                     (1 << 1)
  60 #define UDC_EPCTL_S                     (1 << 0)
  61 #define UDC_EPCTL_ET_SHIFT              4
  62 /* Mask patern */
  63 #define UDC_EPCTL_ET_MASK               0x00000030
  64 /* Value for ET field */
  65 #define UDC_EPCTL_ET_CONTROL            0
  66 #define UDC_EPCTL_ET_ISO                1
  67 #define UDC_EPCTL_ET_BULK               2
  68 #define UDC_EPCTL_ET_INTERRUPT          3
  69
  70 /* Endpoint status register */
  71 /* Bit position */
  72 #define UDC_EPSTS_XFERDONE              (1 << 27)
  73 #define UDC_EPSTS_RSS                   (1 << 26)
  74 #define UDC_EPSTS_RCS                   (1 << 25)
  75 #define UDC_EPSTS_TXEMPTY               (1 << 24)
  76 #define UDC_EPSTS_TDC                   (1 << 10)
  77 #define UDC_EPSTS_HE                    (1 << 9)
  78 #define UDC_EPSTS_MRXFIFO_EMP           (1 << 8)
  79 #define UDC_EPSTS_BNA                   (1 << 7)
  80 #define UDC_EPSTS_IN                    (1 << 6)
  81 #define UDC_EPSTS_OUT_SHIFT             4
  82 /* Mask patern */
  83 #define UDC_EPSTS_OUT_MASK              0x00000030
  84 #define UDC_EPSTS_ALL_CLR_MASK          0x1F0006F0
  85 /* Value for OUT field */
  86 #define UDC_EPSTS_OUT_SETUP             2
  87 #define UDC_EPSTS_OUT_DATA              1
  88
  89 /* Device configuration register */
  90 /* Bit position */
  91 #define UDC_DEVCFG_CSR_PRG              (1 << 17)
  92 #define UDC_DEVCFG_SP                   (1 << 3)
  93 /* SPD Valee */
  94 #define UDC_DEVCFG_SPD_HS               0x0
  95 #define UDC_DEVCFG_SPD_FS               0x1
  96 #define UDC_DEVCFG_SPD_LS               0x2
  97
  98 /* Device control register */
  99 /* Bit position */
 100 #define UDC_DEVCTL_THLEN_SHIFT          24
 101 #define UDC_DEVCTL_BRLEN_SHIFT          16
 102 #define UDC_DEVCTL_CSR_DONE             (1 << 13)
 103 #define UDC_DEVCTL_SD                   (1 << 10)
 104 #define UDC_DEVCTL_MODE                 (1 << 9)
 105 #define UDC_DEVCTL_BREN                 (1 << 8)
 106 #define UDC_DEVCTL_THE                  (1 << 7)
 107 #define UDC_DEVCTL_DU                   (1 << 4)
 108 #define UDC_DEVCTL_TDE                  (1 << 3)
 109 #define UDC_DEVCTL_RDE                  (1 << 2)
 110 #define UDC_DEVCTL_RES                  (1 << 0)
 111
 112 /* Device status register */
 113 /* Bit position */
 114 #define UDC_DEVSTS_TS_SHIFT             18
 115 #define UDC_DEVSTS_ENUM_SPEED_SHIFT     13
 116 #define UDC_DEVSTS_ALT_SHIFT            8
 117 #define UDC_DEVSTS_INTF_SHIFT           4
 118 #define UDC_DEVSTS_CFG_SHIFT            0
 119 /* Mask patern */
 120 #define UDC_DEVSTS_TS_MASK              0xfffc0000
 121 #define UDC_DEVSTS_ENUM_SPEED_MASK      0x00006000
 122 #define UDC_DEVSTS_ALT_MASK             0x00000f00
 123 #define UDC_DEVSTS_INTF_MASK            0x000000f0
 124 #define UDC_DEVSTS_CFG_MASK             0x0000000f
 125 /* value for maximum speed for SPEED field */
 126 #define UDC_DEVSTS_ENUM_SPEED_FULL      1
 127 #define UDC_DEVSTS_ENUM_SPEED_HIGH      0
 128 #define UDC_DEVSTS_ENUM_SPEED_LOW       2
 129 #define UDC_DEVSTS_ENUM_SPEED_FULLX     3
 130
 131 /* Device irq register */
 132 /* Bit position */
 133 #define UDC_DEVINT_RWKP                 (1 << 7)
 134 #define UDC_DEVINT_ENUM                 (1 << 6)
 135 #define UDC_DEVINT_SOF                  (1 << 5)
 136 #define UDC_DEVINT_US                   (1 << 4)
 137 #define UDC_DEVINT_UR                   (1 << 3)
 138 #define UDC_DEVINT_ES                   (1 << 2)
 139 #define UDC_DEVINT_SI                   (1 << 1)
 140 #define UDC_DEVINT_SC                   (1 << 0)
 141 /* Mask patern */
 142 #define UDC_DEVINT_MSK                  0x7f
 143
 144 /* Endpoint irq register */
 145 /* Bit position */
 146 #define UDC_EPINT_IN_SHIFT              0
 147 #define UDC_EPINT_OUT_SHIFT             16
 148 #define UDC_EPINT_IN_EP0                (1 << 0)
 149 #define UDC_EPINT_OUT_EP0               (1 << 16)
 150 /* Mask patern */
 151 #define UDC_EPINT_MSK_DISABLE_ALL       0xffffffff
 152
 153 /* UDC_CSR_BUSY Status register */
 154 /* Bit position */
 155 #define UDC_CSR_BUSY                    (1 << 0)
 156
 157 /* SOFT RESET register */
 158 /* Bit position */
 159 #define UDC_PSRST                       (1 << 1)
 160 #define UDC_SRST                        (1 << 0)
 161
 162 /* USB_DEVICE endpoint register */
 163 /* Bit position */
 164 #define UDC_CSR_NE_NUM_SHIFT            0
 165 #define UDC_CSR_NE_DIR_SHIFT            4
 166 #define UDC_CSR_NE_TYPE_SHIFT           5
 167 #define UDC_CSR_NE_CFG_SHIFT            7
 168 #define UDC_CSR_NE_INTF_SHIFT           11
 169 #define UDC_CSR_NE_ALT_SHIFT            15
 170 #define UDC_CSR_NE_MAX_PKT_SHIFT        19
 171 /* Mask patern */
 172 #define UDC_CSR_NE_NUM_MASK             0x0000000f
 173 #define UDC_CSR_NE_DIR_MASK             0x00000010
 174 #define UDC_CSR_NE_TYPE_MASK            0x00000060
 175 #define UDC_CSR_NE_CFG_MASK             0x00000780
 176 #define UDC_CSR_NE_INTF_MASK            0x00007800
 177 #define UDC_CSR_NE_ALT_MASK             0x00078000
 178 #define UDC_CSR_NE_MAX_PKT_MASK         0x3ff80000
 179
 180 #define PCH_UDC_CSR(ep) (UDC_CSR_ADDR + ep*4)
 181 #define PCH_UDC_EPINT(in, num)\
 182                 (1 << (num + (in ? UDC_EPINT_IN_SHIFT : UDC_EPINT_OUT_SHIFT)))
 183
 184 /* Index of endpoint */
 185 #define UDC_EP0IN_IDX           0
 186 #define UDC_EP0OUT_IDX          1
 187 #define UDC_EPIN_IDX(ep)        (ep * 2)
 188 #define UDC_EPOUT_IDX(ep)       (ep * 2 + 1)
 189 #define PCH_UDC_EP0             0
 190 #define PCH_UDC_EP1             1
 191 #define PCH_UDC_EP2             2
 192 #define PCH_UDC_EP3             3
 193
 194 /* Number of endpoint */
 195 #define PCH_UDC_EP_NUM          32      /* Total number of EPs (16 IN,16 OUT) */
 196 #define PCH_UDC_USED_EP_NUM     4       /* EP number of EP's really used */
 197 /* Length Value */
 198 #define PCH_UDC_BRLEN           0x0F    /* Burst length */
 199 #define PCH_UDC_THLEN           0x1F    /* Threshold length */
 200 /* Value of EP Buffer Size */
 201 #define UDC_EP0IN_BUFF_SIZE     64
 202 #define UDC_EPIN_BUFF_SIZE      512
 203 #define UDC_EP0OUT_BUFF_SIZE    64
 204 #define UDC_EPOUT_BUFF_SIZE     512
 205 /* Value of EP maximum packet size */
 206 #define UDC_EP0IN_MAX_PKT_SIZE  64
 207 #define UDC_EP0OUT_MAX_PKT_SIZE 64
 208 #define UDC_BULK_MAX_PKT_SIZE   512
 209
 210 /* DMA */
 211 #define DMA_DIR_RX              1       /* DMA for data receive */
 212 #define DMA_DIR_TX              2       /* DMA for data transmit */
 213 #define DMA_ADDR_INVALID        (~(dma_addr_t)0)
 214 #define UDC_DMA_MAXPACKET       65536   /* maximum packet size for DMA */
 215
 216 /**
 217  * struct pch_udc_data_dma_desc - Structure to hold DMA descriptor information
 218  *                                for data
 219  * @status:             Status quadlet
 220  * @reserved:           Reserved
 221  * @dataptr:            Buffer descriptor
 222  * @next:               Next descriptor
 223  */
 224 struct pch_udc_data_dma_desc {
 225         u32 status;
 226         u32 reserved;
 227         u32 dataptr;
 228         u32 next;
 229 };
 230
 231 /**
 232  * struct pch_udc_stp_dma_desc - Structure to hold DMA descriptor information
 233  *                               for control data
 234  * @status:     Status
 235  * @reserved:   Reserved
 236  * @data12:     First setup word
 237  * @data34:     Second setup word
 238  */
 239 struct pch_udc_stp_dma_desc {
 240         u32 status;
 241         u32 reserved;
 242         struct usb_ctrlrequest request;
 243 } __attribute((packed));
 244
 245 /* DMA status definitions */
 246 /* Buffer status */
 247 #define PCH_UDC_BUFF_STS        0xC0000000
 248 #define PCH_UDC_BS_HST_RDY      0x00000000
 249 #define PCH_UDC_BS_DMA_BSY      0x40000000
 250 #define PCH_UDC_BS_DMA_DONE     0x80000000
 251 #define PCH_UDC_BS_HST_BSY      0xC0000000
 252 /*  Rx/Tx Status */
 253 #define PCH_UDC_RXTX_STS        0x30000000
 254 #define PCH_UDC_RTS_SUCC        0x00000000
 255 #define PCH_UDC_RTS_DESERR      0x10000000
 256 #define PCH_UDC_RTS_BUFERR      0x30000000
 257 /* Last Descriptor Indication */
 258 #define PCH_UDC_DMA_LAST        0x08000000
 259 /* Number of Rx/Tx Bytes Mask */
 260 #define PCH_UDC_RXTX_BYTES      0x0000ffff
 261
 262 /**
 263  * struct pch_udc_cfg_data - Structure to hold current configuration
 264  *                           and interface information
 265  * @cur_cfg:    current configuration in use
 266  * @cur_intf:   current interface in use
 267  * @cur_alt:    current alt interface in use
 268  */
 269 struct pch_udc_cfg_data {
 270         u16 cur_cfg;
 271         u16 cur_intf;
 272         u16 cur_alt;
 273 };
 274
 275 /**
 276  * struct pch_udc_ep - Structure holding a PCH USB device Endpoint information
 277  * @ep:                 embedded ep request
 278  * @td_stp_phys:        for setup request
 279  * @td_data_phys:       for data request
 280  * @td_stp:             for setup request
 281  * @td_data:            for data request
 282  * @dev:                reference to device struct
 283  * @offset_addr:        offset address of ep register
 284  * @desc:               for this ep
 285  * @queue:              queue for requests
 286  * @num:                endpoint number
 287  * @in:                 endpoint is IN
 288  * @halted:             endpoint halted?
 289  * @epsts:              Endpoint status
 290  */
 291 struct pch_udc_ep {
 292         struct usb_ep                   ep;
 293         dma_addr_t                      td_stp_phys;
 294         dma_addr_t                      td_data_phys;
 295         struct pch_udc_stp_dma_desc     *td_stp;
 296         struct pch_udc_data_dma_desc    *td_data;
 297         struct pch_udc_dev              *dev;
 298         unsigned long                   offset_addr;
 299         const struct usb_endpoint_descriptor    *desc;
 300         struct list_head                queue;
 301         unsigned                        num:5,
 302                                         in:1,
 303                                         halted:1;
 304         unsigned long                   epsts;
 305 };
 306
 307 /**
 308  * struct pch_udc_dev - Structure holding complete information
 309  *                      of the PCH USB device
 310  * @gadget:             gadget driver data
 311  * @driver:             reference to gadget driver bound
 312  * @pdev:               reference to the PCI device
 313  * @ep:                 array of endpoints
 314  * @lock:               protects all state
 315  * @active:             enabled the PCI device
 316  * @stall:              stall requested
 317  * @prot_stall:         protcol stall requested
 318  * @irq_registered:     irq registered with system
 319  * @mem_region:         device memory mapped
 320  * @registered:         driver regsitered with system
 321  * @suspended:          driver in suspended state
 322  * @connected:          gadget driver associated
 323  * @set_cfg_not_acked:  pending acknowledgement 4 setup
 324  * @waiting_zlp_ack:    pending acknowledgement 4 ZLP
 325  * @data_requests:      DMA pool for data requests
 326  * @stp_requests:       DMA pool for setup requests
 327  * @dma_addr:           DMA pool for received
 328  * @ep0out_buf:         Buffer for DMA
 329  * @setup_data:         Received setup data
 330  * @phys_addr:          of device memory
 331  * @base_addr:          for mapped device memory
 332  * @irq:                IRQ line for the device
 333  * @cfg_data:           current cfg, intf, and alt in use
 334  */
 335 struct pch_udc_dev {
 336         struct usb_gadget               gadget;
 337         struct usb_gadget_driver        *driver;
 338         struct pci_dev                  *pdev;
 339         struct pch_udc_ep               ep[PCH_UDC_EP_NUM];
 340         spinlock_t                      lock;
 341         unsigned        active:1,
 342                         stall:1,
 343                         prot_stall:1,
 344                         irq_registered:1,
 345                         mem_region:1,
 346                         registered:1,
 347                         suspended:1,
 348                         connected:1,
 349                         set_cfg_not_acked:1,
 350                         waiting_zlp_ack:1;
 351         struct pci_pool         *data_requests;
 352         struct pci_pool         *stp_requests;
 353         dma_addr_t                      dma_addr;
 354         unsigned long                   ep0out_buf[64];
 355         struct usb_ctrlrequest          setup_data;
 356         unsigned long                   phys_addr;
 357         void __iomem                    *base_addr;
 358         unsigned                        irq;
 359         struct pch_udc_cfg_data cfg_data;
 360 };
 361
 362 #define PCH_UDC_PCI_BAR                 1
 363 #define PCI_DEVICE_ID_INTEL_EG20T_UDC   0x8808
 364
 365 static const char       ep0_string[] = "ep0in";
 366 static DEFINE_SPINLOCK(udc_stall_spinlock);     /* stall spin lock */
 367 struct pch_udc_dev *pch_udc;            /* pointer to device object */
 368
 369 static int speed_fs;
 370 module_param_named(speed_fs, speed_fs, bool, S_IRUGO);
 371 MODULE_PARM_DESC(speed_fs, "true for Full speed operation");
 372
 373 /**
 374  * struct pch_udc_request - Structure holding a PCH USB device request packet
 375  * @req:                embedded ep request
 376  * @td_data_phys:       phys. address
 377  * @td_data:            first dma desc. of chain
 378  * @td_data_last:       last dma desc. of chain
 379  * @queue:              associated queue
 380  * @dma_going:          DMA in progress for request
 381  * @dma_mapped:         DMA memory mapped for request
 382  * @dma_done:           DMA completed for request
 383  * @chain_len:          chain length
 384  */
 385 struct pch_udc_request {
 386         struct usb_request              req;
 387         dma_addr_t                      td_data_phys;
 388         struct pch_udc_data_dma_desc    *td_data;
 389         struct pch_udc_data_dma_desc    *td_data_last;
 390         struct list_head                queue;
 391         unsigned                        dma_going:1,
 392                                         dma_mapped:1,
 393                                         dma_done:1;
 394         unsigned                        chain_len;
 395 };
 396
 397 static inline u32 pch_udc_readl(struct pch_udc_dev *dev, unsigned long reg)
 398 {
 399         return ioread32(dev->base_addr + reg);
 400 }
 401
 402 static inline void pch_udc_writel(struct pch_udc_dev *dev,
 403                                     unsigned long val, unsigned long reg)
 404 {
 405         iowrite32(val, dev->base_addr + reg);
 406 }
 407
 408 static inline void pch_udc_bit_set(struct pch_udc_dev *dev,
 409                                      unsigned long reg,
 410                                      unsigned long bitmask)
 411 {
 412         pch_udc_writel(dev, pch_udc_readl(dev, reg) | bitmask, reg);
 413 }
 414
 415 static inline void pch_udc_bit_clr(struct pch_udc_dev *dev,
 416                                      unsigned long reg,
 417                                      unsigned long bitmask)
 418 {
 419         pch_udc_writel(dev, pch_udc_readl(dev, reg) & ~(bitmask), reg);
 420 }
 421
 422 static inline u32 pch_udc_ep_readl(struct pch_udc_ep *ep, unsigned long reg)
 423 {
 424         return ioread32(ep->dev->base_addr + ep->offset_addr + reg);
 425 }
 426
 427 static inline void pch_udc_ep_writel(struct pch_udc_ep *ep,
 428                                     unsigned long val, unsigned long reg)
 429 {
 430         iowrite32(val, ep->dev->base_addr + ep->offset_addr + reg);
 431 }
 432
 433 static inline void pch_udc_ep_bit_set(struct pch_udc_ep *ep,
 434                                      unsigned long reg,
 435                                      unsigned long bitmask)
 436 {
 437         pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) | bitmask, reg);
 438 }
 439
 440 static inline void pch_udc_ep_bit_clr(struct pch_udc_ep *ep,
 441                                      unsigned long reg,
 442                                      unsigned long bitmask)
 443 {
 444         pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) & ~(bitmask), reg);
 445 }
 446
 447 /**
 448  * pch_udc_csr_busy() - Wait till idle.
 449  * @dev:        Reference to pch_udc_dev structure
 450  */
 451 static void pch_udc_csr_busy(struct pch_udc_dev *dev)
 452 {
 453         unsigned int count = 200;
 454
 455         /* Wait till idle */
 456         while ((pch_udc_readl(dev, UDC_CSR_BUSY_ADDR) & UDC_CSR_BUSY)
 457                 && --count)
 458                 cpu_relax();
 459         if (!count)
 460                 dev_err(&dev->pdev->dev, "%s: wait error\n", __func__);
 461 }
 462
 463 /**
 464  * pch_udc_write_csr() - Write the command and status registers.
 465  * @dev:        Reference to pch_udc_dev structure
 466  * @val:        value to be written to CSR register
 467  * @addr:       address of CSR register
 468  */
 469 static void pch_udc_write_csr(struct pch_udc_dev *dev, unsigned long val,
 470                                unsigned int ep)
 471 {
 472         unsigned long reg = PCH_UDC_CSR(ep);
 473
 474         pch_udc_csr_busy(dev);          /* Wait till idle */
 475         pch_udc_writel(dev, val, reg);
 476         pch_udc_csr_busy(dev);          /* Wait till idle */
 477 }
 478
 479 /**
 480  * pch_udc_read_csr() - Read the command and status registers.
 481  * @dev:        Reference to pch_udc_dev structure
 482  * @addr:       address of CSR register
 483  *
 484  * Return codes:        content of CSR register
 485  */
 486 static u32 pch_udc_read_csr(struct pch_udc_dev *dev, unsigned int ep)
 487 {
 488         unsigned long reg = PCH_UDC_CSR(ep);
 489
 490         pch_udc_csr_busy(dev);          /* Wait till idle */
 491         pch_udc_readl(dev, reg);        /* Dummy read */
 492         pch_udc_csr_busy(dev);          /* Wait till idle */
 493         return pch_udc_readl(dev, reg);
 494 }
 495
 496 /**
 497  * pch_udc_rmt_wakeup() - Initiate for remote wakeup
 498  * @dev:        Reference to pch_udc_dev structure
 499  */
 500 static inline void pch_udc_rmt_wakeup(struct pch_udc_dev *dev)
 501 {
 502         pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
 503         mdelay(1);
 504         pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
 505 }
 506
 507 /**
 508  * pch_udc_get_frame() - Get the current frame from device status register
 509  * @dev:        Reference to pch_udc_dev structure
 510  * Retern       current frame
 511  */
 512 static inline int pch_udc_get_frame(struct pch_udc_dev *dev)
 513 {
 514         u32 frame = pch_udc_readl(dev, UDC_DEVSTS_ADDR);
 515         return (frame & UDC_DEVSTS_TS_MASK) >> UDC_DEVSTS_TS_SHIFT;
 516 }
 517
 518 /**
 519  * pch_udc_clear_selfpowered() - Clear the self power control
 520  * @dev:        Reference to pch_udc_regs structure
 521  */
 522 static inline void pch_udc_clear_selfpowered(struct pch_udc_dev *dev)
 523 {
 524         pch_udc_bit_clr(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
 525 }
 526
 527 /**
 528  * pch_udc_set_selfpowered() - Set the self power control
 529  * @dev:        Reference to pch_udc_regs structure
 530  */
 531 static inline void pch_udc_set_selfpowered(struct pch_udc_dev *dev)
 532 {
 533         pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
 534 }
 535
 536 /**
 537  * pch_udc_set_disconnect() - Set the disconnect status.
 538  * @dev:        Reference to pch_udc_regs structure
 539  */
 540 static inline void pch_udc_set_disconnect(struct pch_udc_dev *dev)
 541 {
 542         pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
 543 }
 544
 545 /**
 546  * pch_udc_clear_disconnect() - Clear the disconnect status.
 547  * @dev:        Reference to pch_udc_regs structure
 548  */
 549 static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
 550 {
 551         /* Clear the disconnect */
 552         pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
 553         pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
 554         mdelay(1);
 555         /* Resume USB signalling */
 556         pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
 557 }
 558
 559 /**
 560  * pch_udc_vbus_session() - set or clearr the disconnect status.
 561  * @dev:        Reference to pch_udc_regs structure
 562  * @is_active:  Parameter specifying the action
 563  *                0:   indicating VBUS power is ending
 564  *                !0:  indicating VBUS power is starting
 565  */
 566 static inline void pch_udc_vbus_session(struct pch_udc_dev *dev,
 567                                           int is_active)
 568 {
 569         if (is_active)
 570                 pch_udc_clear_disconnect(dev);
 571         else
 572                 pch_udc_set_disconnect(dev);
 573 }
 574
 575 /**
 576  * pch_udc_ep_set_stall() - Set the stall of endpoint
 577  * @ep:         Reference to structure of type pch_udc_ep_regs
 578  */
 579 static void pch_udc_ep_set_stall(struct pch_udc_ep *ep)
 580 {
 581         if (ep->in) {
 582                 pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
 583                 pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
 584         } else {
 585                 pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
 586         }
 587 }
 588
 589 /**
 590  * pch_udc_ep_clear_stall() - Clear the stall of endpoint
 591  * @ep:         Reference to structure of type pch_udc_ep_regs
 592  */
 593 static inline void pch_udc_ep_clear_stall(struct pch_udc_ep *ep)
 594 {
 595         /* Clear the stall */
 596         pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
 597         /* Clear NAK by writing CNAK */
 598         pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
 599 }
 600
 601 /**
 602  * pch_udc_ep_set_trfr_type() - Set the transfer type of endpoint
 603  * @ep:         Reference to structure of type pch_udc_ep_regs
 604  * @type:       Type of endpoint
 605  */
 606 static inline void pch_udc_ep_set_trfr_type(struct pch_udc_ep *ep,
 607                                         u8 type)
 608 {
 609         pch_udc_ep_writel(ep, ((type << UDC_EPCTL_ET_SHIFT) &
 610                                 UDC_EPCTL_ET_MASK), UDC_EPCTL_ADDR);
 611 }
 612
 613 /**
 614  * pch_udc_ep_set_bufsz() - Set the maximum packet size for the endpoint
 615  * @ep:         Reference to structure of type pch_udc_ep_regs
 616  * @buf_size:   The buffer size
 617  */
 618 static void pch_udc_ep_set_bufsz(struct pch_udc_ep *ep,
 619                                                  u32 buf_size, u32 ep_in)
 620 {
 621         u32 data;
 622         if (ep_in) {
 623                 data = pch_udc_ep_readl(ep, UDC_BUFIN_FRAMENUM_ADDR);
 624                 data = (data & 0xffff0000) | (buf_size & 0xffff);
 625                 pch_udc_ep_writel(ep, data, UDC_BUFIN_FRAMENUM_ADDR);
 626         } else {
 627                 data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
 628                 data = (buf_size << 16) | (data & 0xffff);
 629                 pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
 630         }
 631 }
 632
 633 /**
 634  * pch_udc_ep_set_maxpkt() - Set the Max packet size for the endpoint
 635  * @ep:         Reference to structure of type pch_udc_ep_regs
 636  * @pkt_size:   The packet size
 637  */
 638 static void pch_udc_ep_set_maxpkt(struct pch_udc_ep *ep, u32 pkt_size)
 639 {
 640         u32 data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
 641         data = (data & 0xffff0000) | (pkt_size & 0xffff);
 642         pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
 643 }
 644
 645 /**
 646  * pch_udc_ep_set_subptr() - Set the Setup buffer pointer for the endpoint
 647  * @ep:         Reference to structure of type pch_udc_ep_regs
 648  * @addr:       Address of the register
 649  */
 650 static inline void pch_udc_ep_set_subptr(struct pch_udc_ep *ep, u32 addr)
 651 {
 652         pch_udc_ep_writel(ep, addr, UDC_SUBPTR_ADDR);
 653 }
 654
 655 /**
 656  * pch_udc_ep_set_ddptr() - Set the Data descriptor pointer for the endpoint
 657  * @ep:         Reference to structure of type pch_udc_ep_regs
 658  * @addr:       Address of the register
 659  */
 660 static inline void pch_udc_ep_set_ddptr(struct pch_udc_ep *ep, u32 addr)
 661 {
 662         pch_udc_ep_writel(ep, addr, UDC_DESPTR_ADDR);
 663 }
 664
 665 /**
 666  * pch_udc_ep_set_pd() - Set the poll demand bit for the endpoint
 667  * @ep:         Reference to structure of type pch_udc_ep_regs
 668  */
 669 static inline void pch_udc_ep_set_pd(struct pch_udc_ep *ep)
 670 {
 671         pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_P);
 672 }
 673
 674 /**
 675  * pch_udc_ep_set_rrdy() - Set the receive ready bit for the endpoint
 676  * @ep:         Reference to structure of type pch_udc_ep_regs
 677  */
 678 static inline void pch_udc_ep_set_rrdy(struct pch_udc_ep *ep)
 679 {
 680         pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
 681 }
 682
 683 /**
 684  * pch_udc_ep_clear_rrdy() - Clear the receive ready bit for the endpoint
 685  * @ep:         Reference to structure of type pch_udc_ep_regs
 686  */
 687 static inline void pch_udc_ep_clear_rrdy(struct pch_udc_ep *ep)
 688 {
 689         pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
 690 }
 691
 692 /**
 693  * pch_udc_set_dma() - Set the 'TDE' or RDE bit of device control
 694  *                      register depending on the direction specified
 695  * @dev:        Reference to structure of type pch_udc_regs
 696  * @dir:        whether Tx or Rx
 697  *                DMA_DIR_RX: Receive
 698  *                DMA_DIR_TX: Transmit
 699  */
 700 static inline void pch_udc_set_dma(struct pch_udc_dev *dev, int dir)
 701 {
 702         if (dir == DMA_DIR_RX)
 703                 pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
 704         else if (dir == DMA_DIR_TX)
 705                 pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
 706 }
 707
 708 /**
 709  * pch_udc_clear_dma() - Clear the 'TDE' or RDE bit of device control
 710  *                               register depending on the direction specified
 711  * @dev:        Reference to structure of type pch_udc_regs
 712  * @dir:        Whether Tx or Rx
 713  *                DMA_DIR_RX: Receive
 714  *                DMA_DIR_TX: Transmit
 715  */
 716 static inline void pch_udc_clear_dma(struct pch_udc_dev *dev, int dir)
 717 {
 718         if (dir == DMA_DIR_RX)
 719                 pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
 720         else if (dir == DMA_DIR_TX)
 721                 pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
 722 }
 723
 724 /**
 725  * pch_udc_set_csr_done() - Set the device control register
 726  *                              CSR done field (bit 13)
 727  * @dev:        reference to structure of type pch_udc_regs
 728  */
 729 static inline void pch_udc_set_csr_done(struct pch_udc_dev *dev)
 730 {
 731         pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_CSR_DONE);
 732 }
 733
 734 /**
 735  * pch_udc_disable_interrupts() - Disables the specified interrupts
 736  * @dev:        Reference to structure of type pch_udc_regs
 737  * @mask:       Mask to disable interrupts
 738  */
 739 static inline void pch_udc_disable_interrupts(struct pch_udc_dev *dev,
 740                                             u32 mask)
 741 {
 742         pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, mask);
 743 }
 744
 745 /**
 746  * pch_udc_enable_interrupts() - Enable the specified interrupts
 747  * @dev:        Reference to structure of type pch_udc_regs
 748  * @mask:       Mask to enable interrupts
 749  */
 750 static inline void pch_udc_enable_interrupts(struct pch_udc_dev *dev,
 751                                            u32 mask)
 752 {
 753         pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR, mask);
 754 }
 755
 756 /**
 757  * pch_udc_disable_ep_interrupts() - Disable endpoint interrupts
 758  * @dev:        Reference to structure of type pch_udc_regs
 759  * @mask:       Mask to disable interrupts
 760  */
 761 static inline void pch_udc_disable_ep_interrupts(struct pch_udc_dev *dev,
 762                                                 u32 mask)
 763 {
 764         pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, mask);
 765 }
 766
 767 /**
 768  * pch_udc_enable_ep_interrupts() - Enable endpoint interrupts
 769  * @dev:        Reference to structure of type pch_udc_regs
 770  * @mask:       Mask to enable interrupts
 771  */
 772 static inline void pch_udc_enable_ep_interrupts(struct pch_udc_dev *dev,
 773                                               u32 mask)
 774 {
 775         pch_udc_bit_clr(dev, UDC_EPIRQMSK_ADDR, mask);
 776 }
 777
 778 /**
 779  * pch_udc_read_device_interrupts() - Read the device interrupts
 780  * @dev:        Reference to structure of type pch_udc_regs
 781  * Retern       The device interrupts
 782  */
 783 static inline u32 pch_udc_read_device_interrupts(struct pch_udc_dev *dev)
 784 {
 785         return pch_udc_readl(dev, UDC_DEVIRQSTS_ADDR);
 786 }
 787
 788 /**
 789  * pch_udc_write_device_interrupts() - Write device interrupts
 790  * @dev:        Reference to structure of type pch_udc_regs
 791  * @val:        The value to be written to interrupt register
 792  */
 793 static inline void pch_udc_write_device_interrupts(struct pch_udc_dev *dev,
 794                                                      u32 val)
 795 {
 796         pch_udc_writel(dev, val, UDC_DEVIRQSTS_ADDR);
 797 }
 798
 799 /**
 800  * pch_udc_read_ep_interrupts() - Read the endpoint interrupts
 801  * @dev:        Reference to structure of type pch_udc_regs
 802  * Retern       The endpoint interrupt
 803  */
 804 static inline u32 pch_udc_read_ep_interrupts(struct pch_udc_dev *dev)
 805 {
 806         return pch_udc_readl(dev, UDC_EPIRQSTS_ADDR);
 807 }
 808
 809 /**
 810  * pch_udc_write_ep_interrupts() - Clear endpoint interupts
 811  * @dev:        Reference to structure of type pch_udc_regs
 812  * @val:        The value to be written to interrupt register
 813  */
 814 static inline void pch_udc_write_ep_interrupts(struct pch_udc_dev *dev,
 815                                              u32 val)
 816 {
 817         pch_udc_writel(dev, val, UDC_EPIRQSTS_ADDR);
 818 }
 819
 820 /**
 821  * pch_udc_read_device_status() - Read the device status
 822  * @dev:        Reference to structure of type pch_udc_regs
 823  * Retern       The device status
 824  */
 825 static inline u32 pch_udc_read_device_status(struct pch_udc_dev *dev)
 826 {
 827         return pch_udc_readl(dev, UDC_DEVSTS_ADDR);
 828 }
 829
 830 /**
 831  * pch_udc_read_ep_control() - Read the endpoint control
 832  * @ep:         Reference to structure of type pch_udc_ep_regs
 833  * Retern       The endpoint control register value
 834  */
 835 static inline u32 pch_udc_read_ep_control(struct pch_udc_ep *ep)
 836 {
 837         return pch_udc_ep_readl(ep, UDC_EPCTL_ADDR);
 838 }
 839
 840 /**
 841  * pch_udc_clear_ep_control() - Clear the endpoint control register
 842  * @ep:         Reference to structure of type pch_udc_ep_regs
 843  * Retern       The endpoint control register value
 844  */
 845 static inline void pch_udc_clear_ep_control(struct pch_udc_ep *ep)
 846 {
 847         return pch_udc_ep_writel(ep, 0, UDC_EPCTL_ADDR);
 848 }
 849
 850 /**
 851  * pch_udc_read_ep_status() - Read the endpoint status
 852  * @ep:         Reference to structure of type pch_udc_ep_regs
 853  * Retern       The endpoint status
 854  */
 855 static inline u32 pch_udc_read_ep_status(struct pch_udc_ep *ep)
 856 {
 857         return pch_udc_ep_readl(ep, UDC_EPSTS_ADDR);
 858 }
 859
 860 /**
 861  * pch_udc_clear_ep_status() - Clear the endpoint status
 862  * @ep:         Reference to structure of type pch_udc_ep_regs
 863  * @stat:       Endpoint status
 864  */
 865 static inline void pch_udc_clear_ep_status(struct pch_udc_ep *ep,
 866                                          u32 stat)
 867 {
 868         return pch_udc_ep_writel(ep, stat, UDC_EPSTS_ADDR);
 869 }
 870
 871 /**
 872  * pch_udc_ep_set_nak() - Set the bit 7 (SNAK field)
 873  *                              of the endpoint control register
 874  * @ep:         Reference to structure of type pch_udc_ep_regs
 875  */
 876 static inline void pch_udc_ep_set_nak(struct pch_udc_ep *ep)
 877 {
 878         pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_SNAK);
 879 }
 880
 881 /**
 882  * pch_udc_ep_clear_nak() - Set the bit 8 (CNAK field)
 883  *                              of the endpoint control register
 884  * @ep:         reference to structure of type pch_udc_ep_regs
 885  */
 886 static void pch_udc_ep_clear_nak(struct pch_udc_ep *ep)
 887 {
 888         unsigned int loopcnt = 0;
 889         struct pch_udc_dev *dev = ep->dev;
 890
 891         if (!(pch_udc_ep_readl(ep, UDC_EPCTL_ADDR) & UDC_EPCTL_NAK))
 892                 return;
 893         if (!ep->in) {
 894                 loopcnt = 10000;
 895                 while (!(pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP) &&
 896                         --loopcnt)
 897                         udelay(5);
 898                 if (!loopcnt)
 899                         dev_err(&dev->pdev->dev, "%s: RxFIFO not Empty\n",
 900                                 __func__);
 901         }
 902         loopcnt = 10000;
 903         while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_NAK) && --loopcnt) {
 904                 pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
 905                 udelay(5);
 906         }
 907         if (!loopcnt)
 908                 dev_err(&dev->pdev->dev, "%s: Clear NAK not set for ep%d%s\n",
 909                         __func__, ep->num, (ep->in ? "in" : "out"));
 910 }
 911
 912 /**
 913  * pch_udc_ep_fifo_flush() - Flush the endpoint fifo
 914  * @ep: reference to structure of type pch_udc_ep_regs
 915  * @dir:        direction of endpoint
 916  *                0:  endpoint is OUT
 917  *                !0: endpoint is IN
 918  */
 919 static void pch_udc_ep_fifo_flush(struct pch_udc_ep *ep, int dir)
 920 {
 921         unsigned int loopcnt = 0;
 922         struct pch_udc_dev *dev = ep->dev;
 923
 924         if (dir) {      /* IN ep */
 925                 pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
 926                 return;
 927         }
 928
 929         if (pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP)
 930                 return;
 931         pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_MRXFLUSH);
 932         /* Wait for RxFIFO Empty */
 933         loopcnt = 10000;
 934         while (!(pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP) &&
 935                 --loopcnt)
 936                 udelay(5);
 937         if (!loopcnt)
 938                 dev_err(&dev->pdev->dev, "RxFIFO not Empty\n");
 939         pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_MRXFLUSH);
 940 }
 941
 942 /**
 943  * pch_udc_ep_enable() - This api enables endpoint
 944  * @regs:       Reference to structure pch_udc_ep_regs
 945  * @desc:       endpoint descriptor
 946  */
 947 static void pch_udc_ep_enable(struct pch_udc_ep *ep,
 948                                struct pch_udc_cfg_data *cfg,
 949                                const struct usb_endpoint_descriptor *desc)
 950 {
 951         u32 val = 0;
 952         u32 buff_size = 0;
 953
 954         pch_udc_ep_set_trfr_type(ep, desc->bmAttributes);
 955         if (ep->in)
 956                 buff_size = UDC_EPIN_BUFF_SIZE;
 957         else
 958                 buff_size = UDC_EPOUT_BUFF_SIZE;
 959         pch_udc_ep_set_bufsz(ep, buff_size, ep->in);
 960         pch_udc_ep_set_maxpkt(ep, le16_to_cpu(desc->wMaxPacketSize));
 961         pch_udc_ep_set_nak(ep);
 962         pch_udc_ep_fifo_flush(ep, ep->in);
 963         /* Configure the endpoint */
 964         val = ep->num << UDC_CSR_NE_NUM_SHIFT | ep->in << UDC_CSR_NE_DIR_SHIFT |
 965               ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) <<
 966                 UDC_CSR_NE_TYPE_SHIFT) |
 967               (cfg->cur_cfg << UDC_CSR_NE_CFG_SHIFT) |
 968               (cfg->cur_intf << UDC_CSR_NE_INTF_SHIFT) |
 969               (cfg->cur_alt << UDC_CSR_NE_ALT_SHIFT) |
 970               le16_to_cpu(desc->wMaxPacketSize) << UDC_CSR_NE_MAX_PKT_SHIFT;
 971
 972         if (ep->in)
 973                 pch_udc_write_csr(ep->dev, val, UDC_EPIN_IDX(ep->num));
 974         else
 975                 pch_udc_write_csr(ep->dev, val, UDC_EPOUT_IDX(ep->num));
 976 }
 977
 978 /**
 979  * pch_udc_ep_disable() - This api disables endpoint
 980  * @regs:       Reference to structure pch_udc_ep_regs
 981  */
 982 static void pch_udc_ep_disable(struct pch_udc_ep *ep)
 983 {
 984         if (ep->in) {
 985                 /* flush the fifo */
 986                 pch_udc_ep_writel(ep, UDC_EPCTL_F, UDC_EPCTL_ADDR);
 987                 /* set NAK */
 988                 pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
 989                 pch_udc_ep_bit_set(ep, UDC_EPSTS_ADDR, UDC_EPSTS_IN);
 990         } else {
 991                 /* set NAK */
 992                 pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
 993         }
 994         /* reset desc pointer */
 995         pch_udc_ep_writel(ep, 0, UDC_DESPTR_ADDR);
 996 }
 997
 998 /**
 999  * pch_udc_wait_ep_stall() - Wait EP stall.
1000  * @dev:        Reference to pch_udc_dev structure
1001  */
1002 static void pch_udc_wait_ep_stall(struct pch_udc_ep *ep)
1003 {
1004         unsigned int count = 10000;
1005
1006         /* Wait till idle */
1007         while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_S) && --count)
1008                 udelay(5);
1009         if (!count)
1010                 dev_err(&ep->dev->pdev->dev, "%s: wait error\n", __func__);
1011 }
1012
1013 /**
1014  * pch_udc_init() - This API initializes usb device controller
1015  * @dev:        Rreference to pch_udc_regs structure
1016  */
1017 static void pch_udc_init(struct pch_udc_dev *dev)
1018 {
1019         if (NULL == dev) {
1020                 pr_err("%s: Invalid address\n", __func__);
1021                 return;
1022         }
1023         /* Soft Reset and Reset PHY */
1024         pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
1025         pch_udc_writel(dev, UDC_SRST | UDC_PSRST, UDC_SRST_ADDR);
1026         mdelay(1);
1027         pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
1028         pch_udc_writel(dev, 0x00, UDC_SRST_ADDR);
1029         mdelay(1);
1030         /* mask and clear all device interrupts */
1031         pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
1032         pch_udc_bit_set(dev, UDC_DEVIRQSTS_ADDR, UDC_DEVINT_MSK);
1033
1034         /* mask and clear all ep interrupts */
1035         pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
1036         pch_udc_bit_set(dev, UDC_EPIRQSTS_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
1037
1038         /* enable dynamic CSR programmingi, self powered and device speed */
1039         if (speed_fs)
1040                 pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
1041                                 UDC_DEVCFG_SP | UDC_DEVCFG_SPD_FS);
1042         else /* defaul high speed */
1043                 pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
1044                                 UDC_DEVCFG_SP | UDC_DEVCFG_SPD_HS);
1045         pch_udc_bit_set(dev, UDC_DEVCTL_ADDR,
1046                         (PCH_UDC_THLEN << UDC_DEVCTL_THLEN_SHIFT) |
1047                         (PCH_UDC_BRLEN << UDC_DEVCTL_BRLEN_SHIFT) |
1048                         UDC_DEVCTL_MODE | UDC_DEVCTL_BREN |
1049                         UDC_DEVCTL_THE);
1050 }
1051
1052 /**
1053  * pch_udc_exit() - This API exit usb device controller
1054  * @dev:        Reference to pch_udc_regs structure
1055  */
1056 static void pch_udc_exit(struct pch_udc_dev *dev)
1057 {
1058         /* mask all device interrupts */
1059         pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
1060         /* mask all ep interrupts */
1061         pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
1062         /* put device in disconnected state */
1063         pch_udc_set_disconnect(dev);
1064 }
1065
1066 /**
1067  * pch_udc_pcd_get_frame() - This API is invoked to get the current frame number
1068  * @gadget:     Reference to the gadget driver
1069  *
1070  * Return codes:
1071  *      0:              Success
1072  *      -EINVAL:        If the gadget passed is NULL
1073  */
1074 static int pch_udc_pcd_get_frame(struct usb_gadget *gadget)
1075 {
1076         struct pch_udc_dev      *dev;
1077
1078         if (!gadget)
1079                 return -EINVAL;
1080         dev = container_of(gadget, struct pch_udc_dev, gadget);
1081         return pch_udc_get_frame(dev);
1082 }
1083
1084 /**
1085  * pch_udc_pcd_wakeup() - This API is invoked to initiate a remote wakeup
1086  * @gadget:     Reference to the gadget driver
1087  *
1088  * Return codes:
1089  *      0:              Success
1090  *      -EINVAL:        If the gadget passed is NULL
1091  */
1092 static int pch_udc_pcd_wakeup(struct usb_gadget *gadget)
1093 {
1094         struct pch_udc_dev      *dev;
1095         unsigned long           flags;
1096
1097         if (!gadget)
1098                 return -EINVAL;
1099         dev = container_of(gadget, struct pch_udc_dev, gadget);
1100         spin_lock_irqsave(&dev->lock, flags);
1101         pch_udc_rmt_wakeup(dev);
1102         spin_unlock_irqrestore(&dev->lock, flags);
1103         return 0;
1104 }
1105
1106 /**
1107  * pch_udc_pcd_selfpowered() - This API is invoked to specify whether the device
1108  *                              is self powered or not
1109  * @gadget:     Reference to the gadget driver
1110  * @value:      Specifies self powered or not
1111  *
1112  * Return codes:
1113  *      0:              Success
1114  *      -EINVAL:        If the gadget passed is NULL
1115  */
1116 static int pch_udc_pcd_selfpowered(struct usb_gadget *gadget, int value)
1117 {
1118         struct pch_udc_dev      *dev;
1119
1120         if (!gadget)
1121                 return -EINVAL;
1122         dev = container_of(gadget, struct pch_udc_dev, gadget);
1123         if (value)
1124                 pch_udc_set_selfpowered(dev);
1125         else
1126                 pch_udc_clear_selfpowered(dev);
1127         return 0;
1128 }
1129
1130 /**
1131  * pch_udc_pcd_pullup() - This API is invoked to make the device
1132  *                              visible/invisible to the host
1133  * @gadget:     Reference to the gadget driver
1134  * @is_on:      Specifies whether the pull up is made active or inactive
1135  *
1136  * Return codes:
1137  *      0:              Success
1138  *      -EINVAL:        If the gadget passed is NULL
1139  */
1140 static int pch_udc_pcd_pullup(struct usb_gadget *gadget, int is_on)
1141 {
1142         struct pch_udc_dev      *dev;
1143
1144         if (!gadget)
1145                 return -EINVAL;
1146         dev = container_of(gadget, struct pch_udc_dev, gadget);
1147         pch_udc_vbus_session(dev, is_on);
1148         return 0;
1149 }
1150
1151 /**
1152  * pch_udc_pcd_vbus_session() - This API is used by a driver for an external
1153  *                              transceiver (or GPIO) that
1154  *                              detects a VBUS power session starting/ending
1155  * @gadget:     Reference to the gadget driver
1156  * @is_active:  specifies whether the session is starting or ending
1157  *
1158  * Return codes:
1159  *      0:              Success
1160  *      -EINVAL:        If the gadget passed is NULL
1161  */
1162 static int pch_udc_pcd_vbus_session(struct usb_gadget *gadget, int is_active)
1163 {
1164         struct pch_udc_dev      *dev;
1165
1166         if (!gadget)
1167                 return -EINVAL;
1168         dev = container_of(gadget, struct pch_udc_dev, gadget);
1169         pch_udc_vbus_session(dev, is_active);
1170         return 0;
1171 }
1172
1173 /**
1174  * pch_udc_pcd_vbus_draw() - This API is used by gadget drivers during
1175  *                              SET_CONFIGURATION calls to
1176  *                              specify how much power the device can consume
1177  * @gadget:     Reference to the gadget driver
1178  * @mA:         specifies the current limit in 2mA unit
1179  *
1180  * Return codes:
1181  *      -EINVAL:        If the gadget passed is NULL
1182  *      -EOPNOTSUPP:
1183  */
1184 static int pch_udc_pcd_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
1185 {
1186         return -EOPNOTSUPP;
1187 }
1188
1189 static const struct usb_gadget_ops pch_udc_ops = {
1190         .get_frame = pch_udc_pcd_get_frame,
1191         .wakeup = pch_udc_pcd_wakeup,
1192         .set_selfpowered = pch_udc_pcd_selfpowered,
1193         .pullup = pch_udc_pcd_pullup,
1194         .vbus_session = pch_udc_pcd_vbus_session,
1195         .vbus_draw = pch_udc_pcd_vbus_draw,
1196 };
1197
1198 /**
1199  * complete_req() - This API is invoked from the driver when processing
1200  *                      of a request is complete
1201  * @ep:         Reference to the endpoint structure
1202  * @req:        Reference to the request structure
1203  * @status:     Indicates the success/failure of completion
1204  */
1205 static void complete_req(struct pch_udc_ep *ep, struct pch_udc_request *req,
1206                                                                  int status)
1207 {
1208         struct pch_udc_dev      *dev;
1209         unsigned halted = ep->halted;
1210
1211         list_del_init(&req->queue);
1212
1213         /* set new status if pending */
1214         if (req->req.status == -EINPROGRESS)
1215                 req->req.status = status;
1216         else
1217                 status = req->req.status;
1218
1219         dev = ep->dev;
1220         if (req->dma_mapped) {
1221                 if (ep->in)
1222                         pci_unmap_single(dev->pdev, req->req.dma,
1223                                          req->req.length, PCI_DMA_TODEVICE);
1224                 else
1225                         pci_unmap_single(dev->pdev, req->req.dma,
1226                                          req->req.length, PCI_DMA_FROMDEVICE);
1227                 req->dma_mapped = 0;
1228                 req->req.dma = DMA_ADDR_INVALID;
1229         }
1230         ep->halted = 1;
1231         spin_unlock(&dev->lock);
1232         if (!ep->in)
1233                 pch_udc_ep_clear_rrdy(ep);
1234         req->req.complete(&ep->ep, &req->req);
1235         spin_lock(&dev->lock);
1236         ep->halted = halted;
1237 }
1238
1239 /**
1240  * empty_req_queue() - This API empties the request queue of an endpoint
1241  * @ep:         Reference to the endpoint structure
1242  */
1243 static void empty_req_queue(struct pch_udc_ep *ep)
1244 {
1245         struct pch_udc_request  *req;
1246
1247         ep->halted = 1;
1248         while (!list_empty(&ep->queue)) {
1249                 req = list_entry(ep->queue.next, struct pch_udc_request, queue);
1250                 complete_req(ep, req, -ESHUTDOWN);      /* Remove from list */
1251         }
1252 }
1253
1254 /**
1255  * pch_udc_free_dma_chain() - This function frees the DMA chain created
1256  *                              for the request
1257  * @dev         Reference to the driver structure
1258  * @req         Reference to the request to be freed
1259  *
1260  * Return codes:
1261  *      0: Success
1262  */
1263 static void pch_udc_free_dma_chain(struct pch_udc_dev *dev,
1264                                    struct pch_udc_request *req)
1265 {
1266         struct pch_udc_data_dma_desc *td = req->td_data;
1267         unsigned i = req->chain_len;
1268
1269         for (; i > 1; --i) {
1270                 dma_addr_t addr = (dma_addr_t)td->next;
1271                 /* do not free first desc., will be done by free for request */
1272                 td = phys_to_virt(addr);
1273                 pci_pool_free(dev->data_requests, td, addr);
1274         }
1275 }
1276
1277 /**
1278  * pch_udc_create_dma_chain() - This function creates or reinitializes
1279  *                              a DMA chain
1280  * @ep:         Reference to the endpoint structure
1281  * @req:        Reference to the request
1282  * @buf_len:    The buffer length
1283  * @gfp_flags:  Flags to be used while mapping the data buffer
1284  *
1285  * Return codes:
1286  *      0:              success,
1287  *      -ENOMEM:        pci_pool_alloc invocation fails
1288  */
1289 static int pch_udc_create_dma_chain(struct pch_udc_ep *ep,
1290                                     struct pch_udc_request *req,
1291                                     unsigned long buf_len,
1292                                     gfp_t gfp_flags)
1293 {
1294         struct pch_udc_data_dma_desc *td = req->td_data, *last;
1295         unsigned long bytes = req->req.length, i = 0;
1296         dma_addr_t dma_addr;
1297         unsigned len = 1;
1298
1299         if (req->chain_len > 1)
1300                 pch_udc_free_dma_chain(ep->dev, req);
1301
1302         for (; ; bytes -= buf_len, ++len) {
1303                 if (ep->in)
1304                         td->status = PCH_UDC_BS_HST_BSY | min(buf_len, bytes);
1305                 else
1306                         td->status = PCH_UDC_BS_HST_BSY;
1307
1308                 if (bytes <= buf_len)
1309                         break;
1310
1311                 last = td;
1312                 td = pci_pool_alloc(ep->dev->data_requests, gfp_flags,
1313                                     &dma_addr);
1314                 if (!td)
1315                         goto nomem;
1316
1317                 i += buf_len;
1318                 td->dataptr = req->req.dma + i;
1319                 last->next = dma_addr;
1320         }
1321
1322         req->td_data_last = td;
1323         td->status |= PCH_UDC_DMA_LAST;
1324         td->next = req->td_data_phys;
1325         req->chain_len = len;
1326         return 0;
1327
1328 nomem:
1329         if (len > 1) {
1330                 req->chain_len = len;
1331                 pch_udc_free_dma_chain(ep->dev, req);
1332         }
1333         req->chain_len = 1;
1334         return -ENOMEM;
1335 }
1336
1337 /**
1338  * prepare_dma() - This function creates and initializes the DMA chain
1339  *                      for the request
1340  * @ep:         Reference to the endpoint structure
1341  * @req:        Reference to the request
1342  * @gfp:        Flag to be used while mapping the data buffer
1343  *
1344  * Return codes:
1345  *      0:              Success
1346  *      Other 0:        linux error number on failure
1347  */
1348 static int prepare_dma(struct pch_udc_ep *ep, struct pch_udc_request *req,
1349                           gfp_t gfp)
1350 {
1351         int     retval;
1352
1353         req->td_data->dataptr = req->req.dma;
1354         req->td_data->status |= PCH_UDC_DMA_LAST;
1355         /* Allocate and create a DMA chain */
1356         retval = pch_udc_create_dma_chain(ep, req, ep->ep.maxpacket, gfp);
1357         if (retval) {
1358                 pr_err("%s: could not create DMA chain: %d\n",
1359                        __func__, retval);
1360                 return retval;
1361         }
1362         if (!ep->in)
1363                 return 0;
1364         if (req->req.length <= ep->ep.maxpacket)
1365                 req->td_data->status = PCH_UDC_DMA_LAST | PCH_UDC_BS_HST_BSY |
1366                                        req->req.length;
1367         /* if bytes < max packet then tx bytes must
1368          * be written in packet per buffer mode
1369          */
1370         if ((req->req.length < ep->ep.maxpacket) || !ep->num)
1371                 req->td_data->status = (req->td_data->status &
1372                                         ~PCH_UDC_RXTX_BYTES) | req->req.length;
1373         req->td_data->status = (req->td_data->status &
1374                                 ~PCH_UDC_BUFF_STS) | PCH_UDC_BS_HST_BSY;
1375         return 0;
1376 }
1377
1378 /**
1379  * process_zlp() - This function process zero length packets
1380  *                      from the gadget driver
1381  * @ep:         Reference to the endpoint structure
1382  * @req:        Reference to the request
1383  */
1384 static void process_zlp(struct pch_udc_ep *ep, struct pch_udc_request *req)
1385 {
1386         struct pch_udc_dev      *dev = ep->dev;
1387
1388         /* IN zlp's are handled by hardware */
1389         complete_req(ep, req, 0);
1390
1391         /* if set_config or set_intf is waiting for ack by zlp
1392          * then set CSR_DONE
1393          */
1394         if (dev->set_cfg_not_acked) {
1395                 pch_udc_set_csr_done(dev);
1396                 dev->set_cfg_not_acked = 0;
1397         }
1398         /* setup command is ACK'ed now by zlp */
1399         if (!dev->stall && dev->waiting_zlp_ack) {
1400                 pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
1401                 dev->waiting_zlp_ack = 0;
1402         }
1403 }
1404
1405 /**
1406  * pch_udc_start_rxrequest() - This function starts the receive requirement.
1407  * @ep:         Reference to the endpoint structure
1408  * @req:        Reference to the request structure
1409  */
1410 static void pch_udc_start_rxrequest(struct pch_udc_ep *ep,
1411                                          struct pch_udc_request *req)
1412 {
1413         struct pch_udc_data_dma_desc *td_data;
1414
1415         pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
1416         td_data = req->td_data;
1417         ep->td_data = req->td_data;
1418         /* Set the status bits for all descriptors */
1419         while (1) {
1420                 td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
1421                                     PCH_UDC_BS_HST_RDY;
1422                 if ((td_data->status & PCH_UDC_DMA_LAST) ==  PCH_UDC_DMA_LAST)
1423                         break;
1424                 td_data = phys_to_virt(td_data->next);
1425         }
1426         /* Write the descriptor pointer */
1427         pch_udc_ep_set_ddptr(ep, req->td_data_phys);
1428         req->dma_going = 1;
1429         pch_udc_enable_ep_interrupts(ep->dev, UDC_EPINT_OUT_EP0 << ep->num);
1430         pch_udc_set_dma(ep->dev, DMA_DIR_RX);
1431         pch_udc_ep_clear_nak(ep);
1432         pch_udc_ep_set_rrdy(ep);
1433 }
1434
1435 /**
1436  * pch_udc_pcd_ep_enable() - This API enables the endpoint. It is called
1437  *                              from gadget driver
1438  * @usbep:      Reference to the USB endpoint structure
1439  * @desc:       Reference to the USB endpoint descriptor structure
1440  *
1441  * Return codes:
1442  *      0:              Success
1443  *      -EINVAL:
1444  *      -ESHUTDOWN:
1445  */
1446 static int pch_udc_pcd_ep_enable(struct usb_ep *usbep,
1447                                     const struct usb_endpoint_descriptor *desc)
1448 {
1449         struct pch_udc_ep       *ep;
1450         struct pch_udc_dev      *dev;
1451         unsigned long           iflags;
1452
1453         if (!usbep || (usbep->name == ep0_string) || !desc ||
1454             (desc->bDescriptorType != USB_DT_ENDPOINT) || !desc->wMaxPacketSize)
1455                 return -EINVAL;
1456
1457         ep = container_of(usbep, struct pch_udc_ep, ep);
1458         dev = ep->dev;
1459         if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
1460                 return -ESHUTDOWN;
1461         spin_lock_irqsave(&dev->lock, iflags);
1462         ep->desc = desc;
1463         ep->halted = 0;
1464         pch_udc_ep_enable(ep, &ep->dev->cfg_data, desc);
1465         ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
1466         pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
1467         spin_unlock_irqrestore(&dev->lock, iflags);
1468         return 0;
1469 }
1470
1471 /**
1472  * pch_udc_pcd_ep_disable() - This API disables endpoint and is called
1473  *                              from gadget driver
1474  * @usbep       Reference to the USB endpoint structure
1475  *
1476  * Return codes:
1477  *      0:              Success
1478  *      -EINVAL:
1479  */
1480 static int pch_udc_pcd_ep_disable(struct usb_ep *usbep)
1481 {
1482         struct pch_udc_ep       *ep;
1483         struct pch_udc_dev      *dev;
1484         unsigned long   iflags;
1485
1486         if (!usbep)
1487                 return -EINVAL;
1488
1489         ep = container_of(usbep, struct pch_udc_ep, ep);
1490         dev = ep->dev;
1491         if ((usbep->name == ep0_string) || !ep->desc)
1492                 return -EINVAL;
1493
1494         spin_lock_irqsave(&ep->dev->lock, iflags);
1495         empty_req_queue(ep);
1496         ep->halted = 1;
1497         pch_udc_ep_disable(ep);
1498         pch_udc_disable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
1499         ep->desc = NULL;
1500         INIT_LIST_HEAD(&ep->queue);
1501         spin_unlock_irqrestore(&ep->dev->lock, iflags);
1502         return 0;
1503 }
1504
1505 /**
1506  * pch_udc_alloc_request() - This function allocates request structure.
1507  *                              It is called by gadget driver
1508  * @usbep:      Reference to the USB endpoint structure
1509  * @gfp:        Flag to be used while allocating memory
1510  *
1511  * Return codes:
1512  *      NULL:                   Failure
1513  *      Allocated address:      Success
1514  */
1515 static struct usb_request *pch_udc_alloc_request(struct usb_ep *usbep,
1516                                                   gfp_t gfp)
1517 {
1518         struct pch_udc_request          *req;
1519         struct pch_udc_ep               *ep;
1520         struct pch_udc_data_dma_desc    *dma_desc;
1521         struct pch_udc_dev              *dev;
1522
1523         if (!usbep)
1524                 return NULL;
1525         ep = container_of(usbep, struct pch_udc_ep, ep);
1526         dev = ep->dev;
1527         req = kzalloc(sizeof *req, gfp);
1528         if (!req)
1529                 return NULL;
1530         req->req.dma = DMA_ADDR_INVALID;
1531         INIT_LIST_HEAD(&req->queue);
1532         if (!ep->dev->dma_addr)
1533                 return &req->req;
1534         /* ep0 in requests are allocated from data pool here */
1535         dma_desc = pci_pool_alloc(ep->dev->data_requests, gfp,
1536                                   &req->td_data_phys);
1537         if (NULL == dma_desc) {
1538                 kfree(req);
1539                 return NULL;
1540         }
1541         /* prevent from using desc. - set HOST BUSY */
1542         dma_desc->status |= PCH_UDC_BS_HST_BSY;
1543         dma_desc->dataptr = __constant_cpu_to_le32(DMA_ADDR_INVALID);
1544         req->td_data = dma_desc;
1545         req->td_data_last = dma_desc;
1546         req->chain_len = 1;
1547         return &req->req;
1548 }
1549
1550 /**
1551  * pch_udc_free_request() - This function frees request structure.
1552  *                              It is called by gadget driver
1553  * @usbep:      Reference to the USB endpoint structure
1554  * @usbreq:     Reference to the USB request
1555  */
1556 static void pch_udc_free_request(struct usb_ep *usbep,
1557                                   struct usb_request *usbreq)
1558 {
1559         struct pch_udc_ep       *ep;
1560         struct pch_udc_request  *req;
1561         struct pch_udc_dev      *dev;
1562
1563         if (!usbep || !usbreq)
1564                 return;
1565         ep = container_of(usbep, struct pch_udc_ep, ep);
1566         req = container_of(usbreq, struct pch_udc_request, req);
1567         dev = ep->dev;
1568         if (!list_empty(&req->queue))
1569                 dev_err(&dev->pdev->dev, "%s: %s req=0x%p queue not empty\n",
1570                         __func__, usbep->name, req);
1571         if (req->td_data != NULL) {
1572                 if (req->chain_len > 1)
1573                         pch_udc_free_dma_chain(ep->dev, req);
1574                 pci_pool_free(ep->dev->data_requests, req->td_data,
1575                               req->td_data_phys);
1576         }
1577         kfree(req);
1578 }
1579
1580 /**
1581  * pch_udc_pcd_queue() - This function queues a request packet. It is called
1582  *                      by gadget driver
1583  * @usbep:      Reference to the USB endpoint structure
1584  * @usbreq:     Reference to the USB request
1585  * @gfp:        Flag to be used while mapping the data buffer
1586  *
1587  * Return codes:
1588  *      0:                      Success
1589  *      linux error number:     Failure
1590  */
1591 static int pch_udc_pcd_queue(struct usb_ep *usbep, struct usb_request *usbreq,
1592                                                                  gfp_t gfp)
1593 {
1594         int retval = 0;
1595         struct pch_udc_ep       *ep;
1596         struct pch_udc_dev      *dev;
1597         struct pch_udc_request  *req;
1598         unsigned long   iflags;
1599
1600         if (!usbep || !usbreq || !usbreq->complete || !usbreq->buf)
1601                 return -EINVAL;
1602         ep = container_of(usbep, struct pch_udc_ep, ep);
1603         dev = ep->dev;
1604         if (!ep->desc && ep->num)
1605                 return -EINVAL;
1606         req = container_of(usbreq, struct pch_udc_request, req);
1607         if (!list_empty(&req->queue))
1608                 return -EINVAL;
1609         if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
1610                 return -ESHUTDOWN;
1611         spin_lock_irqsave(&ep->dev->lock, iflags);
1612         /* map the buffer for dma */
1613         if (usbreq->length &&
1614             ((usbreq->dma == DMA_ADDR_INVALID) || !usbreq->dma)) {
1615                 if (ep->in)
1616                         usbreq->dma = pci_map_single(dev->pdev, usbreq->buf,
1617                                         usbreq->length, PCI_DMA_TODEVICE);
1618                 else
1619                         usbreq->dma = pci_map_single(dev->pdev, usbreq->buf,
1620                                         usbreq->length, PCI_DMA_FROMDEVICE);
1621                 req->dma_mapped = 1;
1622         }
1623         if (usbreq->length > 0) {
1624                 retval = prepare_dma(ep, req, gfp);
1625                 if (retval)
1626                         goto probe_end;
1627         }
1628         usbreq->actual = 0;
1629         usbreq->status = -EINPROGRESS;
1630         req->dma_done = 0;
1631         if (list_empty(&ep->queue) && !ep->halted) {
1632                 /* no pending transfer, so start this req */
1633                 if (!usbreq->length) {
1634                         process_zlp(ep, req);
1635                         retval = 0;
1636                         goto probe_end;
1637                 }
1638                 if (!ep->in) {
1639                         pch_udc_start_rxrequest(ep, req);
1640                 } else {
1641                         /*
1642                         * For IN trfr the descriptors will be programmed and
1643                         * P bit will be set when
1644                         * we get an IN token
1645                         */
1646                         pch_udc_wait_ep_stall(ep);
1647                         pch_udc_ep_clear_nak(ep);
1648                         pch_udc_enable_ep_interrupts(ep->dev, (1 << ep->num));
1649                         pch_udc_set_dma(dev, DMA_DIR_TX);
1650                 }
1651         }
1652         /* Now add this request to the ep's pending requests */
1653         if (req != NULL)
1654                 list_add_tail(&req->queue, &ep->queue);
1655
1656 probe_end:
1657         spin_unlock_irqrestore(&dev->lock, iflags);
1658         return retval;
1659 }
1660
1661 /**
1662  * pch_udc_pcd_dequeue() - This function de-queues a request packet.
1663  *                              It is called by gadget driver
1664  * @usbep:      Reference to the USB endpoint structure
1665  * @usbreq:     Reference to the USB request
1666  *
1667  * Return codes:
1668  *      0:                      Success
1669  *      linux error number:     Failure
1670  */
1671 static int pch_udc_pcd_dequeue(struct usb_ep *usbep,
1672                                 struct usb_request *usbreq)
1673 {
1674         struct pch_udc_ep       *ep;
1675         struct pch_udc_request  *req;
1676         struct pch_udc_dev      *dev;
1677         unsigned long           flags;
1678         int ret = -EINVAL;
1679
1680         ep = container_of(usbep, struct pch_udc_ep, ep);
1681         dev = ep->dev;
1682         if (!usbep || !usbreq || (!ep->desc && ep->num))
1683                 return ret;
1684         req = container_of(usbreq, struct pch_udc_request, req);
1685         spin_lock_irqsave(&ep->dev->lock, flags);
1686         /* make sure it's still queued on this endpoint */
1687         list_for_each_entry(req, &ep->queue, queue) {
1688                 if (&req->req == usbreq) {
1689                         pch_udc_ep_set_nak(ep);
1690                         if (!list_empty(&req->queue))
1691                                 complete_req(ep, req, -ECONNRESET);
1692                         ret = 0;
1693                         break;
1694                 }
1695         }
1696         spin_unlock_irqrestore(&ep->dev->lock, flags);
1697         return ret;
1698 }
1699
1700 /**
1701  * pch_udc_pcd_set_halt() - This function Sets or clear the endpoint halt
1702  *                          feature
1703  * @usbep:      Reference to the USB endpoint structure
1704  * @halt:       Specifies whether to set or clear the feature
1705  *
1706  * Return codes:
1707  *      0:                      Success
1708  *      linux error number:     Failure
1709  */
1710 static int pch_udc_pcd_set_halt(struct usb_ep *usbep, int halt)
1711 {
1712         struct pch_udc_ep       *ep;
1713         struct pch_udc_dev      *dev;
1714         unsigned long iflags;
1715         int ret;
1716
1717         if (!usbep)
1718                 return -EINVAL;
1719         ep = container_of(usbep, struct pch_udc_ep, ep);
1720         dev = ep->dev;
1721         if (!ep->desc && !ep->num)
1722                 return -EINVAL;
1723         if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
1724                 return -ESHUTDOWN;
1725         spin_lock_irqsave(&udc_stall_spinlock, iflags);
1726         if (list_empty(&ep->queue)) {
1727                 if (halt) {
1728                         if (ep->num == PCH_UDC_EP0)
1729                                 ep->dev->stall = 1;
1730                         pch_udc_ep_set_stall(ep);
1731                         pch_udc_enable_ep_interrupts(ep->dev,
1732                                                      PCH_UDC_EPINT(ep->in,
1733                                                                    ep->num));
1734                 } else {
1735                         pch_udc_ep_clear_stall(ep);
1736                 }
1737                 ret = 0;
1738         } else {
1739                 ret = -EAGAIN;
1740         }
1741         spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
1742         return ret;
1743 }
1744
1745 /**
1746  * pch_udc_pcd_set_wedge() - This function Sets or clear the endpoint
1747  *                              halt feature
1748  * @usbep:      Reference to the USB endpoint structure
1749  * @halt:       Specifies whether to set or clear the feature
1750  *
1751  * Return codes:
1752  *      0:                      Success
1753  *      linux error number:     Failure
1754  */
1755 static int pch_udc_pcd_set_wedge(struct usb_ep *usbep)
1756 {
1757         struct pch_udc_ep       *ep;
1758         struct pch_udc_dev      *dev;
1759         unsigned long iflags;
1760         int ret;
1761
1762         if (!usbep)
1763                 return -EINVAL;
1764         ep = container_of(usbep, struct pch_udc_ep, ep);
1765         dev = ep->dev;
1766         if (!ep->desc && !ep->num)
1767                 return -EINVAL;
1768         if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
1769                 return -ESHUTDOWN;
1770         spin_lock_irqsave(&udc_stall_spinlock, iflags);
1771         if (!list_empty(&ep->queue)) {
1772                 ret = -EAGAIN;
1773         } else {
1774                 if (ep->num == PCH_UDC_EP0)
1775                         ep->dev->stall = 1;
1776                 pch_udc_ep_set_stall(ep);
1777                 pch_udc_enable_ep_interrupts(ep->dev,
1778                                              PCH_UDC_EPINT(ep->in, ep->num));
1779                 ep->dev->prot_stall = 1;
1780                 ret = 0;
1781         }
1782         spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
1783         return ret;
1784 }
1785
1786 /**
1787  * pch_udc_pcd_fifo_flush() - This function Flush the FIFO of specified endpoint
1788  * @usbep:      Reference to the USB endpoint structure
1789  */
1790 static void pch_udc_pcd_fifo_flush(struct usb_ep *usbep)
1791 {
1792         struct pch_udc_ep  *ep;
1793
1794         if (!usbep)
1795                 return;
1796
1797         ep = container_of(usbep, struct pch_udc_ep, ep);
1798         if (ep->desc || !ep->num)
1799                 pch_udc_ep_fifo_flush(ep, ep->in);
1800 }
1801
1802 static const struct usb_ep_ops pch_udc_ep_ops = {
1803         .enable         = pch_udc_pcd_ep_enable,
1804         .disable        = pch_udc_pcd_ep_disable,
1805         .alloc_request  = pch_udc_alloc_request,
1806         .free_request   = pch_udc_free_request,
1807         .queue          = pch_udc_pcd_queue,
1808         .dequeue        = pch_udc_pcd_dequeue,
1809         .set_halt       = pch_udc_pcd_set_halt,
1810         .set_wedge      = pch_udc_pcd_set_wedge,
1811         .fifo_status    = NULL,
1812         .fifo_flush     = pch_udc_pcd_fifo_flush,
1813 };
1814
1815 /**
1816  * pch_udc_init_setup_buff() - This function initializes the SETUP buffer
1817  * @td_stp:     Reference to the SETP buffer structure
1818  */
1819 static void pch_udc_init_setup_buff(struct pch_udc_stp_dma_desc *td_stp)
1820 {
1821         static u32      pky_marker;
1822
1823         if (!td_stp)
1824                 return;
1825         td_stp->reserved = ++pky_marker;
1826         memset(&td_stp->request, 0xFF, sizeof td_stp->request);
1827         td_stp->status = PCH_UDC_BS_HST_RDY;
1828 }
1829
1830 /**
1831  * pch_udc_start_next_txrequest() - This function starts
1832  *                                      the next transmission requirement
1833  * @ep: Reference to the endpoint structure
1834  */
1835 static void pch_udc_start_next_txrequest(struct pch_udc_ep *ep)
1836 {
1837         struct pch_udc_request *req;
1838         struct pch_udc_data_dma_desc *td_data;
1839
1840         if (pch_udc_read_ep_control(ep) & UDC_EPCTL_P)
1841                 return;
1842
1843         if (list_empty(&ep->queue))
1844                 return;
1845
1846         /* next request */
1847         req = list_entry(ep->queue.next, struct pch_udc_request, queue);
1848         if (req->dma_going)
1849                 return;
1850         if (!req->td_data)
1851                 return;
1852         pch_udc_wait_ep_stall(ep);
1853         req->dma_going = 1;
1854         pch_udc_ep_set_ddptr(ep, 0);
1855         td_data = req->td_data;
1856         while (1) {
1857                 td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
1858                                    PCH_UDC_BS_HST_RDY;
1859                 if ((td_data->status & PCH_UDC_DMA_LAST) == PCH_UDC_DMA_LAST)
1860                         break;
1861                 td_data = phys_to_virt(td_data->next);
1862         }
1863         pch_udc_ep_set_ddptr(ep, req->td_data_phys);
1864         pch_udc_set_dma(ep->dev, DMA_DIR_TX);
1865         pch_udc_ep_set_pd(ep);
1866         pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
1867         pch_udc_ep_clear_nak(ep);
1868 }
1869
1870 /**
1871  * pch_udc_complete_transfer() - This function completes a transfer
1872  * @ep:         Reference to the endpoint structure
1873  */
1874 static void pch_udc_complete_transfer(struct pch_udc_ep *ep)
1875 {
1876         struct pch_udc_request *req;
1877         struct pch_udc_dev *dev = ep->dev;
1878
1879         if (list_empty(&ep->queue))
1880                 return;
1881         req = list_entry(ep->queue.next, struct pch_udc_request, queue);
1882         if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
1883             PCH_UDC_BS_DMA_DONE)
1884                 return;
1885         if ((req->td_data_last->status & PCH_UDC_RXTX_STS) !=
1886              PCH_UDC_RTS_SUCC) {
1887                 dev_err(&dev->pdev->dev, "Invalid RXTX status (0x%08x) "
1888                         "epstatus=0x%08x\n",
1889                        (req->td_data_last->status & PCH_UDC_RXTX_STS),
1890                        (int)(ep->epsts));
1891                 return;
1892         }
1893
1894         req->req.actual = req->req.length;
1895         req->td_data_last->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
1896         req->td_data->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
1897         complete_req(ep, req, 0);
1898         req->dma_going = 0;
1899         if (!list_empty(&ep->queue)) {
1900                 pch_udc_wait_ep_stall(ep);
1901                 pch_udc_ep_clear_nak(ep);
1902                 pch_udc_enable_ep_interrupts(ep->dev,
1903                                              PCH_UDC_EPINT(ep->in, ep->num));
1904         } else {
1905                 pch_udc_disable_ep_interrupts(ep->dev,
1906                                               PCH_UDC_EPINT(ep->in, ep->num));
1907         }
1908 }
1909
1910 /**
1911  * pch_udc_complete_receiver() - This function completes a receiver
1912  * @ep:         Reference to the endpoint structure
1913  */
1914 static void pch_udc_complete_receiver(struct pch_udc_ep *ep)
1915 {
1916         struct pch_udc_request *req;
1917         struct pch_udc_dev *dev = ep->dev;
1918         unsigned int count;
1919
1920         if (list_empty(&ep->queue))
1921                 return;
1922
1923         /* next request */
1924         req = list_entry(ep->queue.next, struct pch_udc_request, queue);
1925         if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
1926             PCH_UDC_BS_DMA_DONE)
1927                 return;
1928         pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
1929         if ((req->td_data_last->status & PCH_UDC_RXTX_STS) !=
1930             PCH_UDC_RTS_SUCC) {
1931                 dev_err(&dev->pdev->dev, "Invalid RXTX status (0x%08x) "
1932                         "epstatus=0x%08x\n",
1933                         (req->td_data_last->status & PCH_UDC_RXTX_STS),
1934                         (int)(ep->epsts));
1935                 return;
1936         }
1937         count = req->td_data_last->status & PCH_UDC_RXTX_BYTES;
1938
1939         /* on 64k packets the RXBYTES field is zero */
1940         if (!count && (req->req.length == UDC_DMA_MAXPACKET))
1941                 count = UDC_DMA_MAXPACKET;
1942         req->td_data->status |= PCH_UDC_DMA_LAST;
1943         req->td_data_last->status |= PCH_UDC_BS_HST_BSY;
1944
1945         req->dma_going = 0;
1946         req->req.actual = count;
1947         complete_req(ep, req, 0);
1948         /* If there is a new/failed requests try that now */
1949         if (!list_empty(&ep->queue)) {
1950                 req = list_entry(ep->queue.next, struct pch_udc_request, queue);
1951                 pch_udc_start_rxrequest(ep, req);
1952         }
1953 }
1954
1955 /**
1956  * pch_udc_svc_data_in() - This function process endpoint interrupts
1957  *                              for IN endpoints
1958  * @dev:        Reference to the device structure
1959  * @ep_num:     Endpoint that generated the interrupt
1960  */
1961 static void pch_udc_svc_data_in(struct pch_udc_dev *dev, int ep_num)
1962 {
1963         u32     epsts;
1964         struct pch_udc_ep       *ep;
1965
1966         ep = &dev->ep[2*ep_num];
1967         epsts = ep->epsts;
1968         ep->epsts = 0;
1969
1970         if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA  | UDC_EPSTS_HE |
1971                        UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
1972                        UDC_EPSTS_RSS | UDC_EPSTS_XFERDONE)))
1973                 return;
1974         if ((epsts & UDC_EPSTS_BNA))
1975                 return;
1976         if (epsts & UDC_EPSTS_HE)
1977                 return;
1978         if (epsts & UDC_EPSTS_RSS) {
1979                 pch_udc_ep_set_stall(ep);
1980                 pch_udc_enable_ep_interrupts(ep->dev,
1981                                              PCH_UDC_EPINT(ep->in, ep->num));
1982         }
1983         if (epsts & UDC_EPSTS_RCS)
1984                 if (!dev->prot_stall) {
1985                         pch_udc_ep_clear_stall(ep);
1986                 } else {
1987                         pch_udc_ep_set_stall(ep);
1988                         pch_udc_enable_ep_interrupts(ep->dev,
1989                                                 PCH_UDC_EPINT(ep->in, ep->num));
1990                 }
1991         if (epsts & UDC_EPSTS_TDC)
1992                 pch_udc_complete_transfer(ep);
1993         /* On IN interrupt, provide data if we have any */
1994         if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_RSS) &&
1995             !(epsts & UDC_EPSTS_TDC) && !(epsts & UDC_EPSTS_TXEMPTY))
1996                 pch_udc_start_next_txrequest(ep);
1997 }
1998
1999 /**
2000  * pch_udc_svc_data_out() - Handles interrupts from OUT endpoint
2001  * @dev:        Reference to the device structure
2002  * @ep_num:     Endpoint that generated the interrupt
2003  */
2004 static void pch_udc_svc_data_out(struct pch_udc_dev *dev, int ep_num)
2005 {
2006         u32                     epsts;
2007         struct pch_udc_ep               *ep;
2008         struct pch_udc_request          *req = NULL;
2009
2010         ep = &dev->ep[2*ep_num + 1];
2011         epsts = ep->epsts;
2012         ep->epsts = 0;
2013
2014         if ((epsts & UDC_EPSTS_BNA) && (!list_empty(&ep->queue))) {
2015                 /* next request */
2016                 req = list_entry(ep->queue.next, struct pch_udc_request,
2017                                  queue);
2018                 if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
2019                      PCH_UDC_BS_DMA_DONE) {
2020                         if (!req->dma_going)
2021                                 pch_udc_start_rxrequest(ep, req);
2022                         return;
2023                 }
2024         }
2025         if (epsts & UDC_EPSTS_HE)
2026                 return;
2027         if (epsts & UDC_EPSTS_RSS)
2028                 pch_udc_ep_set_stall(ep);
2029                 pch_udc_enable_ep_interrupts(ep->dev,
2030                                              PCH_UDC_EPINT(ep->in, ep->num));
2031         if (epsts & UDC_EPSTS_RCS)
2032                 if (!dev->prot_stall) {
2033                         pch_udc_ep_clear_stall(ep);
2034                 } else {
2035                         pch_udc_ep_set_stall(ep);
2036                         pch_udc_enable_ep_interrupts(ep->dev,
2037                                                 PCH_UDC_EPINT(ep->in, ep->num));
2038                 }
2039         if (((epsts & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
2040             UDC_EPSTS_OUT_DATA) {
2041                 if (ep->dev->prot_stall == 1) {
2042                         pch_udc_ep_set_stall(ep);
2043                         pch_udc_enable_ep_interrupts(ep->dev,
2044                                                 PCH_UDC_EPINT(ep->in, ep->num));
2045                 } else {
2046                         pch_udc_complete_receiver(ep);
2047                 }
2048         }
2049         if (list_empty(&ep->queue))
2050                 pch_udc_set_dma(dev, DMA_DIR_RX);
2051 }
2052
2053 /**
2054  * pch_udc_svc_control_in() - Handle Control IN endpoint interrupts
2055  * @dev:        Reference to the device structure
2056  */
2057 static void pch_udc_svc_control_in(struct pch_udc_dev *dev)
2058 {
2059         u32     epsts;
2060         struct pch_udc_ep       *ep;
2061
2062         ep = &dev->ep[UDC_EP0IN_IDX];
2063         epsts = ep->epsts;
2064         ep->epsts = 0;
2065
2066         if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA | UDC_EPSTS_HE |
2067                        UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
2068                        UDC_EPSTS_XFERDONE)))
2069                 return;
2070         if ((epsts & UDC_EPSTS_BNA))
2071                 return;
2072         if (epsts & UDC_EPSTS_HE)
2073                 return;
2074         if ((epsts & UDC_EPSTS_TDC) && (!dev->stall))
2075                 pch_udc_complete_transfer(ep);
2076         /* On IN interrupt, provide data if we have any */
2077         if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_TDC) &&
2078              !(epsts & UDC_EPSTS_TXEMPTY))
2079                 pch_udc_start_next_txrequest(ep);
2080 }
2081
2082 /**
2083  * pch_udc_svc_control_out() - Routine that handle Control
2084  *                                      OUT endpoint interrupts
2085  * @dev:        Reference to the device structure
2086  */
2087 static void pch_udc_svc_control_out(struct pch_udc_dev *dev)
2088 {
2089         u32     stat;
2090         int setup_supported;
2091         struct pch_udc_ep       *ep;
2092
2093         ep = &dev->ep[UDC_EP0OUT_IDX];
2094         stat = ep->epsts;
2095         ep->epsts = 0;
2096
2097         /* If setup data */
2098         if (((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
2099             UDC_EPSTS_OUT_SETUP) {
2100                 dev->stall = 0;
2101                 dev->ep[UDC_EP0IN_IDX].halted = 0;
2102                 dev->ep[UDC_EP0OUT_IDX].halted = 0;
2103                 /* In data not ready */
2104                 pch_udc_ep_set_nak(&(dev->ep[UDC_EP0IN_IDX]));
2105                 dev->setup_data = ep->td_stp->request;
2106                 pch_udc_init_setup_buff(ep->td_stp);
2107                 pch_udc_clear_dma(dev, DMA_DIR_TX);
2108                 pch_udc_ep_fifo_flush(&(dev->ep[UDC_EP0IN_IDX]),
2109                                       dev->ep[UDC_EP0IN_IDX].in);
2110                 if ((dev->setup_data.bRequestType & USB_DIR_IN))
2111                         dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
2112                 else /* OUT */
2113                         dev->gadget.ep0 = &ep->ep;
2114                 spin_unlock(&dev->lock);
2115                 /* If Mass storage Reset */
2116                 if ((dev->setup_data.bRequestType == 0x21) &&
2117                     (dev->setup_data.bRequest == 0xFF))
2118                         dev->prot_stall = 0;
2119                 /* call gadget with setup data received */
2120                 setup_supported = dev->driver->setup(&dev->gadget,
2121                                                      &dev->setup_data);
2122                 spin_lock(&dev->lock);
2123                 /* ep0 in returns data on IN phase */
2124                 if (setup_supported >= 0 && setup_supported <
2125                                             UDC_EP0IN_MAX_PKT_SIZE) {
2126                         pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
2127                         /* Gadget would have queued a request when
2128                          * we called the setup */
2129                         pch_udc_set_dma(dev, DMA_DIR_RX);
2130                         pch_udc_ep_clear_nak(ep);
2131                 } else if (setup_supported < 0) {
2132                         /* if unsupported request, then stall */
2133                         pch_udc_ep_set_stall(&(dev->ep[UDC_EP0IN_IDX]));
2134                         pch_udc_enable_ep_interrupts(ep->dev,
2135                                                 PCH_UDC_EPINT(ep->in, ep->num));
2136                         dev->stall = 0;
2137                         pch_udc_set_dma(dev, DMA_DIR_RX);
2138                 } else {
2139                         dev->waiting_zlp_ack = 1;
2140                 }
2141         } else if ((((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
2142                      UDC_EPSTS_OUT_DATA) && !dev->stall) {
2143                 if (list_empty(&ep->queue)) {
2144                         dev_err(&dev->pdev->dev, "%s: No request\n", __func__);
2145                         ep->td_data->status = (ep->td_data->status &
2146                                                ~PCH_UDC_BUFF_STS) |
2147                                                PCH_UDC_BS_HST_RDY;
2148                         pch_udc_set_dma(dev, DMA_DIR_RX);
2149                 } else {
2150                         /* control write */
2151                         pch_udc_svc_data_out(dev, UDC_EP0OUT_IDX);
2152                         /* re-program desc. pointer for possible ZLPs */
2153                         pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
2154                         pch_udc_set_dma(dev, DMA_DIR_RX);
2155                 }
2156         }
2157         pch_udc_ep_set_rrdy(ep);
2158 }
2159
2160
2161 /**
2162  * pch_udc_postsvc_epinters() - This function enables end point interrupts
2163  *                              and clears NAK status
2164  * @dev:        Reference to the device structure
2165  * @ep_num:     End point number
2166  */
2167 static void pch_udc_postsvc_epinters(struct pch_udc_dev *dev, int ep_num)
2168 {
2169         struct pch_udc_ep       *ep;
2170         struct pch_udc_request *req;
2171
2172         ep = &dev->ep[2*ep_num];
2173         if (!list_empty(&ep->queue)) {
2174                 req = list_entry(ep->queue.next, struct pch_udc_request, queue);
2175                 pch_udc_enable_ep_interrupts(ep->dev,
2176                                              PCH_UDC_EPINT(ep->in, ep->num));
2177                 pch_udc_ep_clear_nak(ep);
2178         }
2179 }
2180
2181 /**
2182  * pch_udc_read_all_epstatus() - This function read all endpoint status
2183  * @dev:        Reference to the device structure
2184  * @ep_intr:    Status of endpoint interrupt
2185  */
2186 static void pch_udc_read_all_epstatus(struct pch_udc_dev *dev, u32 ep_intr)
2187 {
2188         int i;
2189         struct pch_udc_ep       *ep;
2190
2191         for (i = 0; i < PCH_UDC_USED_EP_NUM; i++) {
2192                 /* IN */
2193                 if (ep_intr & (0x1 << i)) {
2194                         ep = &dev->ep[2*i];
2195                         ep->epsts = pch_udc_read_ep_status(ep);
2196                         pch_udc_clear_ep_status(ep, ep->epsts);
2197                 }
2198                 /* OUT */
2199                 if (ep_intr & (0x10000 << i)) {
2200                         ep = &dev->ep[2*i+1];
2201                         ep->epsts = pch_udc_read_ep_status(ep);
2202                         pch_udc_clear_ep_status(ep, ep->epsts);
2203                 }
2204         }
2205 }
2206
2207 /**
2208  * pch_udc_activate_control_ep() - This function enables the control endpoints
2209  *                                      for traffic after a reset
2210  * @dev:        Reference to the device structure
2211  */
2212 static void pch_udc_activate_control_ep(struct pch_udc_dev *dev)
2213 {
2214         struct pch_udc_ep       *ep;
2215         u32 val;
2216
2217         /* Setup the IN endpoint */
2218         ep = &dev->ep[UDC_EP0IN_IDX];
2219         pch_udc_clear_ep_control(ep);
2220         pch_udc_ep_fifo_flush(ep, ep->in);
2221         pch_udc_ep_set_bufsz(ep, UDC_EP0IN_BUFF_SIZE, ep->in);
2222         pch_udc_ep_set_maxpkt(ep, UDC_EP0IN_MAX_PKT_SIZE);
2223         /* Initialize the IN EP Descriptor */
2224         ep->td_data      = NULL;
2225         ep->td_stp       = NULL;
2226         ep->td_data_phys = 0;
2227         ep->td_stp_phys  = 0;
2228
2229         /* Setup the OUT endpoint */
2230         ep = &dev->ep[UDC_EP0OUT_IDX];
2231         pch_udc_clear_ep_control(ep);
2232         pch_udc_ep_fifo_flush(ep, ep->in);
2233         pch_udc_ep_set_bufsz(ep, UDC_EP0OUT_BUFF_SIZE, ep->in);
2234         pch_udc_ep_set_maxpkt(ep, UDC_EP0OUT_MAX_PKT_SIZE);
2235         val = UDC_EP0OUT_MAX_PKT_SIZE << UDC_CSR_NE_MAX_PKT_SHIFT;
2236         pch_udc_write_csr(ep->dev, val, UDC_EP0OUT_IDX);
2237
2238         /* Initialize the SETUP buffer */
2239         pch_udc_init_setup_buff(ep->td_stp);
2240         /* Write the pointer address of dma descriptor */
2241         pch_udc_ep_set_subptr(ep, ep->td_stp_phys);
2242         /* Write the pointer address of Setup descriptor */
2243         pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
2244
2245         /* Initialize the dma descriptor */
2246         ep->td_data->status  = PCH_UDC_DMA_LAST;
2247         ep->td_data->dataptr = dev->dma_addr;
2248         ep->td_data->next    = ep->td_data_phys;
2249
2250         pch_udc_ep_clear_nak(ep);
2251 }
2252
2253
2254 /**
2255  * pch_udc_svc_ur_interrupt() - This function handles a USB reset interrupt
2256  * @dev:        Reference to driver structure
2257  */
2258 static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
2259 {
2260         struct pch_udc_ep       *ep;
2261         int i;
2262
2263         pch_udc_clear_dma(dev, DMA_DIR_TX);
2264         pch_udc_clear_dma(dev, DMA_DIR_RX);
2265         /* Mask all endpoint interrupts */
2266         pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
2267         /* clear all endpoint interrupts */
2268         pch_udc_write_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
2269
2270         for (i = 0; i < PCH_UDC_EP_NUM; i++) {
2271                 ep = &dev->ep[i];
2272                 pch_udc_clear_ep_status(ep, UDC_EPSTS_ALL_CLR_MASK);
2273                 pch_udc_clear_ep_control(ep);
2274                 pch_udc_ep_set_ddptr(ep, 0);
2275                 pch_udc_write_csr(ep->dev, 0x00, i);
2276         }
2277         dev->stall = 0;
2278         dev->prot_stall = 0;
2279         dev->waiting_zlp_ack = 0;
2280         dev->set_cfg_not_acked = 0;
2281
2282         /* disable ep to empty req queue. Skip the control EP's */
2283         for (i = 0; i < (PCH_UDC_USED_EP_NUM*2); i++) {
2284                 ep = &dev->ep[i];
2285                 pch_udc_ep_set_nak(ep);
2286                 pch_udc_ep_fifo_flush(ep, ep->in);
2287                 /* Complete request queue */
2288                 empty_req_queue(ep);
2289         }
2290         if (dev->driver && dev->driver->disconnect)
2291                 dev->driver->disconnect(&dev->gadget);
2292 }
2293
2294 /**
2295  * pch_udc_svc_enum_interrupt() - This function handles a USB speed enumeration
2296  *                              done interrupt
2297  * @dev:        Reference to driver structure
2298  */
2299 static void pch_udc_svc_enum_interrupt(struct pch_udc_dev *dev)
2300 {
2301         u32 dev_stat, dev_speed;
2302         u32 speed = USB_SPEED_FULL;
2303
2304         dev_stat = pch_udc_read_device_status(dev);
2305         dev_speed = (dev_stat & UDC_DEVSTS_ENUM_SPEED_MASK) >>
2306                                                  UDC_DEVSTS_ENUM_SPEED_SHIFT;
2307         switch (dev_speed) {
2308         case UDC_DEVSTS_ENUM_SPEED_HIGH:
2309                 speed = USB_SPEED_HIGH;
2310                 break;
2311         case  UDC_DEVSTS_ENUM_SPEED_FULL:
2312                 speed = USB_SPEED_FULL;
2313                 break;
2314         case  UDC_DEVSTS_ENUM_SPEED_LOW:
2315                 speed = USB_SPEED_LOW;
2316                 break;
2317         default:
2318                 BUG();
2319         }
2320         dev->gadget.speed = speed;
2321         pch_udc_activate_control_ep(dev);
2322         pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 | UDC_EPINT_OUT_EP0);
2323         pch_udc_set_dma(dev, DMA_DIR_TX);
2324         pch_udc_set_dma(dev, DMA_DIR_RX);
2325         pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX]));
2326 }
2327
2328 /**
2329  * pch_udc_svc_intf_interrupt() - This function handles a set interface
2330  *                                interrupt
2331  * @dev:        Reference to driver structure
2332  */
2333 static void pch_udc_svc_intf_interrupt(struct pch_udc_dev *dev)
2334 {
2335         u32 reg, dev_stat = 0;
2336         int i, ret;
2337
2338         dev_stat = pch_udc_read_device_status(dev);
2339         dev->cfg_data.cur_intf = (dev_stat & UDC_DEVSTS_INTF_MASK) >>
2340                                                          UDC_DEVSTS_INTF_SHIFT;
2341         dev->cfg_data.cur_alt = (dev_stat & UDC_DEVSTS_ALT_MASK) >>
2342                                                          UDC_DEVSTS_ALT_SHIFT;
2343         dev->set_cfg_not_acked = 1;
2344         /* Construct the usb request for gadget driver and inform it */
2345         memset(&dev->setup_data, 0 , sizeof dev->setup_data);
2346         dev->setup_data.bRequest = USB_REQ_SET_INTERFACE;
2347         dev->setup_data.bRequestType = USB_RECIP_INTERFACE;
2348         dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_alt);
2349         dev->setup_data.wIndex = cpu_to_le16(dev->cfg_data.cur_intf);
2350         /* programm the Endpoint Cfg registers */
2351         /* Only one end point cfg register */
2352         reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
2353         reg = (reg & ~UDC_CSR_NE_INTF_MASK) |
2354               (dev->cfg_data.cur_intf << UDC_CSR_NE_INTF_SHIFT);
2355         reg = (reg & ~UDC_CSR_NE_ALT_MASK) |
2356               (dev->cfg_data.cur_alt << UDC_CSR_NE_ALT_SHIFT);
2357         pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
2358         for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
2359                 /* clear stall bits */
2360                 pch_udc_ep_clear_stall(&(dev->ep[i]));
2361                 dev->ep[i].halted = 0;
2362         }
2363         dev->stall = 0;
2364         spin_unlock(&dev->lock);
2365         ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
2366         spin_lock(&dev->lock);
2367 }
2368
2369 /**
2370  * pch_udc_svc_cfg_interrupt() - This function handles a set configuration
2371  *                              interrupt
2372  * @dev:        Reference to driver structure
2373  */
2374 static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
2375 {
2376         int i, ret;
2377         u32 reg, dev_stat = 0;
2378
2379         dev_stat = pch_udc_read_device_status(dev);
2380         dev->set_cfg_not_acked = 1;
2381         dev->cfg_data.cur_cfg = (dev_stat & UDC_DEVSTS_CFG_MASK) >>
2382                                 UDC_DEVSTS_CFG_SHIFT;
2383         /* make usb request for gadget driver */
2384         memset(&dev->setup_data, 0 , sizeof dev->setup_data);
2385         dev->setup_data.bRequest = USB_REQ_SET_CONFIGURATION;
2386         dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_cfg);
2387         /* program the NE registers */
2388         /* Only one end point cfg register */
2389         reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
2390         reg = (reg & ~UDC_CSR_NE_CFG_MASK) |
2391               (dev->cfg_data.cur_cfg << UDC_CSR_NE_CFG_SHIFT);
2392         pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
2393         for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
2394                 /* clear stall bits */
2395                 pch_udc_ep_clear_stall(&(dev->ep[i]));
2396                 dev->ep[i].halted = 0;
2397         }
2398         dev->stall = 0;
2399
2400         /* call gadget zero with setup data received */
2401         spin_unlock(&dev->lock);
2402         ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
2403         spin_lock(&dev->lock);
2404 }
2405
2406 /**
2407  * pch_udc_dev_isr() - This function services device interrupts
2408  *                      by invoking appropriate routines.
2409  * @dev:        Reference to the device structure
2410  * @dev_intr:   The Device interrupt status.
2411  */
2412 static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
2413 {
2414         /* USB Reset Interrupt */
2415         if (dev_intr & UDC_DEVINT_UR)
2416                 pch_udc_svc_ur_interrupt(dev);
2417         /* Enumeration Done Interrupt */
2418         if (dev_intr & UDC_DEVINT_ENUM)
2419                 pch_udc_svc_enum_interrupt(dev);
2420         /* Set Interface Interrupt */
2421         if (dev_intr & UDC_DEVINT_SI)
2422                 pch_udc_svc_intf_interrupt(dev);
2423         /* Set Config Interrupt */
2424         if (dev_intr & UDC_DEVINT_SC)
2425                 pch_udc_svc_cfg_interrupt(dev);
2426         /* USB Suspend interrupt */
2427         if (dev_intr & UDC_DEVINT_US)
2428                 dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n");
2429         /* Clear the SOF interrupt, if enabled */
2430         if (dev_intr & UDC_DEVINT_SOF)
2431                 dev_dbg(&dev->pdev->dev, "SOF\n");
2432         /* ES interrupt, IDLE > 3ms on the USB */
2433         if (dev_intr & UDC_DEVINT_ES)
2434                 dev_dbg(&dev->pdev->dev, "ES\n");
2435         /* RWKP interrupt */
2436         if (dev_intr & UDC_DEVINT_RWKP)
2437                 dev_dbg(&dev->pdev->dev, "RWKP\n");
2438 }
2439
2440 /**
2441  * pch_udc_isr() - This function handles interrupts from the PCH USB Device
2442  * @irq:        Interrupt request number
2443  * @dev:        Reference to the device structure
2444  */
2445 static irqreturn_t pch_udc_isr(int irq, void *pdev)
2446 {
2447         struct pch_udc_dev *dev = (struct pch_udc_dev *) pdev;
2448         u32 dev_intr, ep_intr;
2449         int i;
2450
2451         dev_intr = pch_udc_read_device_interrupts(dev);
2452         ep_intr = pch_udc_read_ep_interrupts(dev);
2453
2454         if (dev_intr)
2455                 /* Clear device interrupts */
2456                 pch_udc_write_device_interrupts(dev, dev_intr);
2457         if (ep_intr)
2458                 /* Clear ep interrupts */
2459                 pch_udc_write_ep_interrupts(dev, ep_intr);
2460         if (!dev_intr && !ep_intr)
2461                 return IRQ_NONE;
2462         spin_lock(&dev->lock);
2463         if (dev_intr)
2464                 pch_udc_dev_isr(dev, dev_intr);
2465         if (ep_intr) {
2466                 pch_udc_read_all_epstatus(dev, ep_intr);
2467                 /* Process Control In interrupts, if present */
2468                 if (ep_intr & UDC_EPINT_IN_EP0) {
2469                         pch_udc_svc_control_in(dev);
2470                         pch_udc_postsvc_epinters(dev, 0);
2471                 }
2472                 /* Process Control Out interrupts, if present */
2473                 if (ep_intr & UDC_EPINT_OUT_EP0)
2474                         pch_udc_svc_control_out(dev);
2475                 /* Process data in end point interrupts */
2476                 for (i = 1; i < PCH_UDC_USED_EP_NUM; i++) {
2477                         if (ep_intr & (1 <<  i)) {
2478                                 pch_udc_svc_data_in(dev, i);
2479                                 pch_udc_postsvc_epinters(dev, i);
2480                         }
2481                 }
2482                 /* Process data out end point interrupts */
2483                 for (i = UDC_EPINT_OUT_SHIFT + 1; i < (UDC_EPINT_OUT_SHIFT +
2484                                                  PCH_UDC_USED_EP_NUM); i++)
2485                         if (ep_intr & (1 <<  i))
2486                                 pch_udc_svc_data_out(dev, i -
2487                                                          UDC_EPINT_OUT_SHIFT);
2488         }
2489         spin_unlock(&dev->lock);
2490         return IRQ_HANDLED;
2491 }
2492
2493 /**
2494  * pch_udc_setup_ep0() - This function enables control endpoint for traffic
2495  * @dev:        Reference to the device structure
2496  */
2497 static void pch_udc_setup_ep0(struct pch_udc_dev *dev)
2498 {
2499         /* enable ep0 interrupts */
2500         pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 |
2501                                                 UDC_EPINT_OUT_EP0);
2502         /* enable device interrupts */
2503         pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US |
2504                                        UDC_DEVINT_ES | UDC_DEVINT_ENUM |
2505                                        UDC_DEVINT_SI | UDC_DEVINT_SC);
2506 }
2507
2508 /**
2509  * gadget_release() - Free the gadget driver private data
2510  * @pdev        reference to struct pci_dev
2511  */
2512 static void gadget_release(struct device *pdev)
2513 {
2514         struct pch_udc_dev *dev = dev_get_drvdata(pdev);
2515
2516         kfree(dev);
2517 }
2518
2519 /**
2520  * pch_udc_pcd_reinit() - This API initializes the endpoint structures
2521  * @dev:        Reference to the driver structure
2522  */
2523 static void pch_udc_pcd_reinit(struct pch_udc_dev *dev)
2524 {
2525         const char *const ep_string[] = {
2526                 ep0_string, "ep0out", "ep1in", "ep1out", "ep2in", "ep2out",
2527                 "ep3in", "ep3out", "ep4in", "ep4out", "ep5in", "ep5out",
2528                 "ep6in", "ep6out", "ep7in", "ep7out", "ep8in", "ep8out",
2529                 "ep9in", "ep9out", "ep10in", "ep10out", "ep11in", "ep11out",
2530                 "ep12in", "ep12out", "ep13in", "ep13out", "ep14in", "ep14out",
2531                 "ep15in", "ep15out",
2532         };
2533         int i;
2534
2535         dev->gadget.speed = USB_SPEED_UNKNOWN;
2536         INIT_LIST_HEAD(&dev->gadget.ep_list);
2537
2538         /* Initialize the endpoints structures */
2539         memset(dev->ep, 0, sizeof dev->ep);
2540         for (i = 0; i < PCH_UDC_EP_NUM; i++) {
2541                 struct pch_udc_ep *ep = &dev->ep[i];
2542                 ep->dev = dev;
2543                 ep->halted = 1;
2544                 ep->num = i / 2;
2545                 ep->in = ~i & 1;
2546                 ep->ep.name = ep_string[i];
2547                 ep->ep.ops = &pch_udc_ep_ops;
2548                 if (ep->in)
2549                         ep->offset_addr = ep->num * UDC_EP_REG_SHIFT;
2550                 else
2551                         ep->offset_addr = (UDC_EPINT_OUT_SHIFT + ep->num) *
2552                                           UDC_EP_REG_SHIFT;
2553                 /* need to set ep->ep.maxpacket and set Default Configuration?*/
2554                 ep->ep.maxpacket = UDC_BULK_MAX_PKT_SIZE;
2555                 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
2556                 INIT_LIST_HEAD(&ep->queue);
2557         }
2558         dev->ep[UDC_EP0IN_IDX].ep.maxpacket = UDC_EP0IN_MAX_PKT_SIZE;
2559         dev->ep[UDC_EP0OUT_IDX].ep.maxpacket = UDC_EP0OUT_MAX_PKT_SIZE;
2560
2561         dev->dma_addr = pci_map_single(dev->pdev, dev->ep0out_buf, 256,
2562                                   PCI_DMA_FROMDEVICE);
2563
2564         /* remove ep0 in and out from the list.  They have own pointer */
2565         list_del_init(&dev->ep[UDC_EP0IN_IDX].ep.ep_list);
2566         list_del_init(&dev->ep[UDC_EP0OUT_IDX].ep.ep_list);
2567
2568         dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
2569         INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
2570 }
2571
2572 /**
2573  * pch_udc_pcd_init() - This API initializes the driver structure
2574  * @dev:        Reference to the driver structure
2575  *
2576  * Return codes:
2577  *      0: Success
2578  */
2579 static int pch_udc_pcd_init(struct pch_udc_dev *dev)
2580 {
2581         pch_udc_init(dev);
2582         pch_udc_pcd_reinit(dev);
2583         return 0;
2584 }
2585
2586 /**
2587  * init_dma_pools() - create dma pools during initialization
2588  * @pdev:       reference to struct pci_dev
2589  */
2590 static int init_dma_pools(struct pch_udc_dev *dev)
2591 {
2592         struct pch_udc_stp_dma_desc     *td_stp;
2593         struct pch_udc_data_dma_desc    *td_data;
2594
2595         /* DMA setup */
2596         dev->data_requests = pci_pool_create("data_requests", dev->pdev,
2597                 sizeof(struct pch_udc_data_dma_desc), 0, 0);
2598         if (!dev->data_requests) {
2599                 dev_err(&dev->pdev->dev, "%s: can't get request data pool\n",
2600                         __func__);
2601                 return -ENOMEM;
2602         }
2603
2604         /* dma desc for setup data */
2605         dev->stp_requests = pci_pool_create("setup requests", dev->pdev,
2606                 sizeof(struct pch_udc_stp_dma_desc), 0, 0);
2607         if (!dev->stp_requests) {
2608                 dev_err(&dev->pdev->dev, "%s: can't get setup request pool\n",
2609                         __func__);
2610                 return -ENOMEM;
2611         }
2612         /* setup */
2613         td_stp = pci_pool_alloc(dev->stp_requests, GFP_KERNEL,
2614                                 &dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
2615         if (!td_stp) {
2616                 dev_err(&dev->pdev->dev,
2617                         "%s: can't allocate setup dma descriptor\n", __func__);
2618                 return -ENOMEM;
2619         }
2620         dev->ep[UDC_EP0OUT_IDX].td_stp = td_stp;
2621
2622         /* data: 0 packets !? */
2623         td_data = pci_pool_alloc(dev->data_requests, GFP_KERNEL,
2624                                 &dev->ep[UDC_EP0OUT_IDX].td_data_phys);
2625         if (!td_data) {
2626                 dev_err(&dev->pdev->dev,
2627                         "%s: can't allocate data dma descriptor\n", __func__);
2628                 return -ENOMEM;
2629         }
2630         dev->ep[UDC_EP0OUT_IDX].td_data = td_data;
2631         dev->ep[UDC_EP0IN_IDX].td_stp = NULL;
2632         dev->ep[UDC_EP0IN_IDX].td_stp_phys = 0;
2633         dev->ep[UDC_EP0IN_IDX].td_data = NULL;
2634         dev->ep[UDC_EP0IN_IDX].td_data_phys = 0;
2635         return 0;
2636 }
2637
2638 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
2639 {
2640         struct pch_udc_dev      *dev = pch_udc;
2641         int                     retval;
2642
2643         if (!driver || (driver->speed == USB_SPEED_UNKNOWN) || !driver->bind ||
2644             !driver->setup || !driver->unbind || !driver->disconnect) {
2645                 dev_err(&dev->pdev->dev,
2646                         "%s: invalid driver parameter\n", __func__);
2647                 return -EINVAL;
2648         }
2649
2650         if (!dev)
2651                 return -ENODEV;
2652
2653         if (dev->driver) {
2654                 dev_err(&dev->pdev->dev, "%s: already bound\n", __func__);
2655                 return -EBUSY;
2656         }
2657         driver->driver.bus = NULL;
2658         dev->driver = driver;
2659         dev->gadget.dev.driver = &driver->driver;
2660
2661         /* Invoke the bind routine of the gadget driver */
2662         retval = driver->bind(&dev->gadget);
2663
2664         if (retval) {
2665                 dev_err(&dev->pdev->dev, "%s: binding to %s returning %d\n",
2666                        __func__, driver->driver.name, retval);
2667                 dev->driver = NULL;
2668                 dev->gadget.dev.driver = NULL;
2669                 return retval;
2670         }
2671         /* get ready for ep0 traffic */
2672         pch_udc_setup_ep0(dev);
2673
2674         /* clear SD */
2675         pch_udc_clear_disconnect(dev);
2676
2677         dev->connected = 1;
2678         return 0;
2679 }
2680 EXPORT_SYMBOL(usb_gadget_register_driver);
2681
2682 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
2683 {
2684         struct pch_udc_dev      *dev = pch_udc;
2685
2686         if (!dev)
2687                 return -ENODEV;
2688
2689         if (!driver || (driver != dev->driver)) {
2690                 dev_err(&dev->pdev->dev,
2691                         "%s: invalid driver parameter\n", __func__);
2692                 return -EINVAL;
2693         }
2694
2695         pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
2696
2697         /* Assues that there are no pending requets with this driver */
2698         driver->unbind(&dev->gadget);
2699         dev->gadget.dev.driver = NULL;
2700         dev->driver = NULL;
2701         dev->connected = 0;
2702
2703         /* set SD */
2704         pch_udc_set_disconnect(dev);
2705         return 0;
2706 }
2707 EXPORT_SYMBOL(usb_gadget_unregister_driver);
2708
2709 static void pch_udc_shutdown(struct pci_dev *pdev)
2710 {
2711         struct pch_udc_dev *dev = pci_get_drvdata(pdev);
2712
2713         pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
2714         pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
2715
2716         /* disable the pullup so the host will think we're gone */
2717         pch_udc_set_disconnect(dev);
2718 }
2719
2720 static void pch_udc_remove(struct pci_dev *pdev)
2721 {
2722         struct pch_udc_dev      *dev = pci_get_drvdata(pdev);
2723
2724         /* gadget driver must not be registered */
2725         if (dev->driver)
2726                 dev_err(&pdev->dev,
2727                         "%s: gadget driver still bound!!!\n", __func__);
2728         /* dma pool cleanup */
2729         if (dev->data_requests)
2730                 pci_pool_destroy(dev->data_requests);
2731
2732         if (dev->stp_requests) {
2733                 /* cleanup DMA desc's for ep0in */
2734                 if (dev->ep[UDC_EP0OUT_IDX].td_stp) {
2735                         pci_pool_free(dev->stp_requests,
2736                                 dev->ep[UDC_EP0OUT_IDX].td_stp,
2737                                 dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
2738                 }
2739                 if (dev->ep[UDC_EP0OUT_IDX].td_data) {
2740                         pci_pool_free(dev->stp_requests,
2741                                 dev->ep[UDC_EP0OUT_IDX].td_data,
2742                                 dev->ep[UDC_EP0OUT_IDX].td_data_phys);
2743                 }
2744                 pci_pool_destroy(dev->stp_requests);
2745         }
2746
2747         pch_udc_exit(dev);
2748
2749         if (dev->irq_registered)
2750                 free_irq(pdev->irq, dev);
2751         if (dev->base_addr)
2752                 iounmap(dev->base_addr);
2753         if (dev->mem_region)
2754                 release_mem_region(dev->phys_addr,
2755                                    pci_resource_len(pdev, PCH_UDC_PCI_BAR));
2756         if (dev->active)
2757                 pci_disable_device(pdev);
2758         if (dev->registered)
2759                 device_unregister(&dev->gadget.dev);
2760         kfree(dev);
2761         pci_set_drvdata(pdev, NULL);
2762 }
2763
2764 #ifdef CONFIG_PM
2765 static int pch_udc_suspend(struct pci_dev *pdev, pm_message_t state)
2766 {
2767         struct pch_udc_dev *dev = pci_get_drvdata(pdev);
2768
2769         pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
2770         pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
2771
2772         pci_disable_device(pdev);
2773         pci_enable_wake(pdev, PCI_D3hot, 0);
2774
2775         if (pci_save_state(pdev)) {
2776                 dev_err(&pdev->dev,
2777                         "%s: could not save PCI config state\n", __func__);
2778                 return -ENOMEM;
2779         }
2780         pci_set_power_state(pdev, pci_choose_state(pdev, state));
2781         return 0;
2782 }
2783
2784 static int pch_udc_resume(struct pci_dev *pdev)
2785 {
2786         int ret;
2787
2788         pci_set_power_state(pdev, PCI_D0);
2789         ret = pci_restore_state(pdev);
2790         if (ret) {
2791                 dev_err(&pdev->dev, "%s: pci_restore_state failed\n", __func__);
2792                 return ret;
2793         }
2794         ret = pci_enable_device(pdev);
2795         if (ret) {
2796                 dev_err(&pdev->dev, "%s: pci_enable_device failed\n", __func__);
2797                 return ret;
2798         }
2799         pci_enable_wake(pdev, PCI_D3hot, 0);
2800         return 0;
2801 }
2802 #else
2803 #define pch_udc_suspend NULL
2804 #define pch_udc_resume  NULL
2805 #endif /* CONFIG_PM */
2806
2807 static int pch_udc_probe(struct pci_dev *pdev,
2808                           const struct pci_device_id *id)
2809 {
2810         unsigned long           resource;
2811         unsigned long           len;
2812         int                     retval;
2813         struct pch_udc_dev      *dev;
2814
2815         /* one udc only */
2816         if (pch_udc) {
2817                 pr_err("%s: already probed\n", __func__);
2818                 return -EBUSY;
2819         }
2820         /* init */
2821         dev = kzalloc(sizeof *dev, GFP_KERNEL);
2822         if (!dev) {
2823                 pr_err("%s: no memory for device structure\n", __func__);
2824                 return -ENOMEM;
2825         }
2826         /* pci setup */
2827         if (pci_enable_device(pdev) < 0) {
2828                 kfree(dev);
2829                 pr_err("%s: pci_enable_device failed\n", __func__);
2830                 return -ENODEV;
2831         }
2832         dev->active = 1;
2833         pci_set_drvdata(pdev, dev);
2834
2835         /* PCI resource allocation */
2836         resource = pci_resource_start(pdev, 1);
2837         len = pci_resource_len(pdev, 1);
2838
2839         if (!request_mem_region(resource, len, KBUILD_MODNAME)) {
2840                 dev_err(&pdev->dev, "%s: pci device used already\n", __func__);
2841                 retval = -EBUSY;
2842                 goto finished;
2843         }
2844         dev->phys_addr = resource;
2845         dev->mem_region = 1;
2846
2847         dev->base_addr = ioremap_nocache(resource, len);
2848         if (!dev->base_addr) {
2849                 pr_err("%s: device memory cannot be mapped\n", __func__);
2850                 retval = -ENOMEM;
2851                 goto finished;
2852         }
2853         if (!pdev->irq) {
2854                 dev_err(&pdev->dev, "%s: irq not set\n", __func__);
2855                 retval = -ENODEV;
2856                 goto finished;
2857         }
2858         pch_udc = dev;
2859         /* initialize the hardware */
2860         if (pch_udc_pcd_init(dev))
2861                 goto finished;
2862         if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME,
2863                         dev)) {
2864                 dev_err(&pdev->dev, "%s: request_irq(%d) fail\n", __func__,
2865                         pdev->irq);
2866                 retval = -ENODEV;
2867                 goto finished;
2868         }
2869         dev->irq = pdev->irq;
2870         dev->irq_registered = 1;
2871
2872         pci_set_master(pdev);
2873         pci_try_set_mwi(pdev);
2874
2875         /* device struct setup */
2876         spin_lock_init(&dev->lock);
2877         dev->pdev = pdev;
2878         dev->gadget.ops = &pch_udc_ops;
2879
2880         retval = init_dma_pools(dev);
2881         if (retval)
2882                 goto finished;
2883
2884         dev_set_name(&dev->gadget.dev, "gadget");
2885         dev->gadget.dev.parent = &pdev->dev;
2886         dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
2887         dev->gadget.dev.release = gadget_release;
2888         dev->gadget.name = KBUILD_MODNAME;
2889         dev->gadget.is_dualspeed = 1;
2890
2891         retval = device_register(&dev->gadget.dev);
2892         if (retval)
2893                 goto finished;
2894         dev->registered = 1;
2895
2896         /* Put the device in disconnected state till a driver is bound */
2897         pch_udc_set_disconnect(dev);
2898         return 0;
2899
2900 finished:
2901         pch_udc_remove(pdev);
2902         return retval;
2903 }
2904
2905 static const struct pci_device_id pch_udc_pcidev_id[] = {
2906         {
2907                 PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EG20T_UDC),
2908                 .class = (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
2909                 .class_mask = 0xffffffff,
2910         },
2911         { 0 },
2912 };
2913
2914 MODULE_DEVICE_TABLE(pci, pch_udc_pcidev_id);
2915
2916
2917 static struct pci_driver pch_udc_driver = {
2918         .name = KBUILD_MODNAME,
2919         .id_table =     pch_udc_pcidev_id,
2920         .probe =        pch_udc_probe,
2921         .remove =       pch_udc_remove,
2922         .suspend =      pch_udc_suspend,
2923         .resume =       pch_udc_resume,
2924         .shutdown =     pch_udc_shutdown,
2925 };
2926
2927 static int __init pch_udc_pci_init(void)
2928 {
2929         return pci_register_driver(&pch_udc_driver);
2930 }
2931 module_init(pch_udc_pci_init);
2932
2933 static void __exit pch_udc_pci_exit(void)
2934 {
2935         pci_unregister_driver(&pch_udc_driver);
2936 }
2937 module_exit(pch_udc_pci_exit);
2938
2939 MODULE_DESCRIPTION("Intel EG20T USB Device Controller");
2940 MODULE_AUTHOR("OKI SEMICONDUCTOR, <toshiharu-linux@dsn.okisemi.com>");
2941 MODULE_LICENSE("GPL");