Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/usb/gadget/pch_udc.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us