2 * Intel Langwell USB Device Controller driver
3 * Copyright (C) 2008-2009, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
12 /* #undef VERBOSE_DEBUG */
14 #include <linux/module.h>
15 #include <linux/pci.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/kernel.h>
18 #include <linux/delay.h>
19 #include <linux/ioport.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/timer.h>
25 #include <linux/list.h>
26 #include <linux/interrupt.h>
27 #include <linux/moduleparam.h>
28 #include <linux/device.h>
29 #include <linux/usb/ch9.h>
30 #include <linux/usb/gadget.h>
31 #include <linux/usb/otg.h>
34 #include <linux/irq.h>
35 #include <asm/system.h>
36 #include <asm/unaligned.h>
38 #include "langwell_udc.h"
41 #define DRIVER_DESC "Intel Langwell USB Device Controller driver"
42 #define DRIVER_VERSION "16 May 2009"
44 static const char driver_name[] = "langwell_udc";
45 static const char driver_desc[] = DRIVER_DESC;
48 /* for endpoint 0 operations */
49 static const struct usb_endpoint_descriptor
51 .bLength = USB_DT_ENDPOINT_SIZE,
52 .bDescriptorType = USB_DT_ENDPOINT,
53 .bEndpointAddress = 0,
54 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
55 .wMaxPacketSize = EP0_MAX_PKT_SIZE,
59 /*-------------------------------------------------------------------------*/
63 static inline void print_all_registers(struct langwell_udc *dev)
67 /* Capability Registers */
68 dev_dbg(&dev->pdev->dev,
69 "Capability Registers (offset: 0x%04x, length: 0x%08x)\n",
70 CAP_REG_OFFSET, (u32)sizeof(struct langwell_cap_regs));
71 dev_dbg(&dev->pdev->dev, "caplength=0x%02x\n",
72 readb(&dev->cap_regs->caplength));
73 dev_dbg(&dev->pdev->dev, "hciversion=0x%04x\n",
74 readw(&dev->cap_regs->hciversion));
75 dev_dbg(&dev->pdev->dev, "hcsparams=0x%08x\n",
76 readl(&dev->cap_regs->hcsparams));
77 dev_dbg(&dev->pdev->dev, "hccparams=0x%08x\n",
78 readl(&dev->cap_regs->hccparams));
79 dev_dbg(&dev->pdev->dev, "dciversion=0x%04x\n",
80 readw(&dev->cap_regs->dciversion));
81 dev_dbg(&dev->pdev->dev, "dccparams=0x%08x\n",
82 readl(&dev->cap_regs->dccparams));
84 /* Operational Registers */
85 dev_dbg(&dev->pdev->dev,
86 "Operational Registers (offset: 0x%04x, length: 0x%08x)\n",
87 OP_REG_OFFSET, (u32)sizeof(struct langwell_op_regs));
88 dev_dbg(&dev->pdev->dev, "extsts=0x%08x\n",
89 readl(&dev->op_regs->extsts));
90 dev_dbg(&dev->pdev->dev, "extintr=0x%08x\n",
91 readl(&dev->op_regs->extintr));
92 dev_dbg(&dev->pdev->dev, "usbcmd=0x%08x\n",
93 readl(&dev->op_regs->usbcmd));
94 dev_dbg(&dev->pdev->dev, "usbsts=0x%08x\n",
95 readl(&dev->op_regs->usbsts));
96 dev_dbg(&dev->pdev->dev, "usbintr=0x%08x\n",
97 readl(&dev->op_regs->usbintr));
98 dev_dbg(&dev->pdev->dev, "frindex=0x%08x\n",
99 readl(&dev->op_regs->frindex));
100 dev_dbg(&dev->pdev->dev, "ctrldssegment=0x%08x\n",
101 readl(&dev->op_regs->ctrldssegment));
102 dev_dbg(&dev->pdev->dev, "deviceaddr=0x%08x\n",
103 readl(&dev->op_regs->deviceaddr));
104 dev_dbg(&dev->pdev->dev, "endpointlistaddr=0x%08x\n",
105 readl(&dev->op_regs->endpointlistaddr));
106 dev_dbg(&dev->pdev->dev, "ttctrl=0x%08x\n",
107 readl(&dev->op_regs->ttctrl));
108 dev_dbg(&dev->pdev->dev, "burstsize=0x%08x\n",
109 readl(&dev->op_regs->burstsize));
110 dev_dbg(&dev->pdev->dev, "txfilltuning=0x%08x\n",
111 readl(&dev->op_regs->txfilltuning));
112 dev_dbg(&dev->pdev->dev, "txttfilltuning=0x%08x\n",
113 readl(&dev->op_regs->txttfilltuning));
114 dev_dbg(&dev->pdev->dev, "ic_usb=0x%08x\n",
115 readl(&dev->op_regs->ic_usb));
116 dev_dbg(&dev->pdev->dev, "ulpi_viewport=0x%08x\n",
117 readl(&dev->op_regs->ulpi_viewport));
118 dev_dbg(&dev->pdev->dev, "configflag=0x%08x\n",
119 readl(&dev->op_regs->configflag));
120 dev_dbg(&dev->pdev->dev, "portsc1=0x%08x\n",
121 readl(&dev->op_regs->portsc1));
122 dev_dbg(&dev->pdev->dev, "devlc=0x%08x\n",
123 readl(&dev->op_regs->devlc));
124 dev_dbg(&dev->pdev->dev, "otgsc=0x%08x\n",
125 readl(&dev->op_regs->otgsc));
126 dev_dbg(&dev->pdev->dev, "usbmode=0x%08x\n",
127 readl(&dev->op_regs->usbmode));
128 dev_dbg(&dev->pdev->dev, "endptnak=0x%08x\n",
129 readl(&dev->op_regs->endptnak));
130 dev_dbg(&dev->pdev->dev, "endptnaken=0x%08x\n",
131 readl(&dev->op_regs->endptnaken));
132 dev_dbg(&dev->pdev->dev, "endptsetupstat=0x%08x\n",
133 readl(&dev->op_regs->endptsetupstat));
134 dev_dbg(&dev->pdev->dev, "endptprime=0x%08x\n",
135 readl(&dev->op_regs->endptprime));
136 dev_dbg(&dev->pdev->dev, "endptflush=0x%08x\n",
137 readl(&dev->op_regs->endptflush));
138 dev_dbg(&dev->pdev->dev, "endptstat=0x%08x\n",
139 readl(&dev->op_regs->endptstat));
140 dev_dbg(&dev->pdev->dev, "endptcomplete=0x%08x\n",
141 readl(&dev->op_regs->endptcomplete));
143 for (i = 0; i < dev->ep_max / 2; i++) {
144 dev_dbg(&dev->pdev->dev, "endptctrl[%d]=0x%08x\n",
145 i, readl(&dev->op_regs->endptctrl[i]));
150 #define print_all_registers(dev) do { } while (0)
152 #endif /* VERBOSE_DEBUG */
155 /*-------------------------------------------------------------------------*/
157 #define is_in(ep) (((ep)->ep_num == 0) ? ((ep)->dev->ep0_dir == \
158 USB_DIR_IN) : (usb_endpoint_dir_in((ep)->desc)))
160 #define DIR_STRING(ep) (is_in(ep) ? "in" : "out")
163 static char *type_string(const struct usb_endpoint_descriptor *desc)
165 switch (usb_endpoint_type(desc)) {
166 case USB_ENDPOINT_XFER_BULK:
168 case USB_ENDPOINT_XFER_ISOC:
170 case USB_ENDPOINT_XFER_INT:
178 /* configure endpoint control registers */
179 static void ep_reset(struct langwell_ep *ep, unsigned char ep_num,
180 unsigned char is_in, unsigned char ep_type)
182 struct langwell_udc *dev;
186 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
188 endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
189 if (is_in) { /* TX */
191 endptctrl |= EPCTRL_TXR;
192 endptctrl |= EPCTRL_TXE;
193 endptctrl |= ep_type << EPCTRL_TXT_SHIFT;
196 endptctrl |= EPCTRL_RXR;
197 endptctrl |= EPCTRL_RXE;
198 endptctrl |= ep_type << EPCTRL_RXT_SHIFT;
201 writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
203 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
207 /* reset ep0 dQH and endptctrl */
208 static void ep0_reset(struct langwell_udc *dev)
210 struct langwell_ep *ep;
213 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
216 for (i = 0; i < 2; i++) {
221 ep->dqh = &dev->ep_dqh[i];
223 /* configure ep0 endpoint capabilities in dQH */
224 ep->dqh->dqh_ios = 1;
225 ep->dqh->dqh_mpl = EP0_MAX_PKT_SIZE;
227 /* enable ep0-in HW zero length termination select */
229 ep->dqh->dqh_zlt = 0;
230 ep->dqh->dqh_mult = 0;
232 ep->dqh->dtd_next = DTD_TERM;
234 /* configure ep0 control registers */
235 ep_reset(&dev->ep[0], 0, i, USB_ENDPOINT_XFER_CONTROL);
238 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
242 /*-------------------------------------------------------------------------*/
244 /* endpoints operations */
246 /* configure endpoint, making it usable */
247 static int langwell_ep_enable(struct usb_ep *_ep,
248 const struct usb_endpoint_descriptor *desc)
250 struct langwell_udc *dev;
251 struct langwell_ep *ep;
255 unsigned char zlt, ios = 0, mult = 0;
257 ep = container_of(_ep, struct langwell_ep, ep);
259 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
261 if (!_ep || !desc || ep->desc
262 || desc->bDescriptorType != USB_DT_ENDPOINT)
265 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
268 max = usb_endpoint_maxp(desc);
271 * disable HW zero length termination select
272 * driver handles zero length packet through req->req.zero
277 * sanity check type, direction, address, and then
278 * initialize the endpoint capabilities fields in dQH
280 switch (usb_endpoint_type(desc)) {
281 case USB_ENDPOINT_XFER_CONTROL:
284 case USB_ENDPOINT_XFER_BULK:
285 if ((dev->gadget.speed == USB_SPEED_HIGH
287 || (dev->gadget.speed == USB_SPEED_FULL
292 case USB_ENDPOINT_XFER_INT:
293 if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
296 switch (dev->gadget.speed) {
309 case USB_ENDPOINT_XFER_ISOC:
310 if (strstr(ep->ep.name, "-bulk")
311 || strstr(ep->ep.name, "-int"))
314 switch (dev->gadget.speed) {
326 * calculate transactions needed for high bandwidth iso
328 mult = (unsigned char)(1 + ((max >> 11) & 0x03));
329 max = max & 0x8ff; /* bit 0~10 */
330 /* 3 transactions at most */
338 spin_lock_irqsave(&dev->lock, flags);
340 ep->ep.maxpacket = max;
343 ep->ep_num = usb_endpoint_num(desc);
346 ep->ep_type = usb_endpoint_type(desc);
348 /* configure endpoint control registers */
349 ep_reset(ep, ep->ep_num, is_in(ep), ep->ep_type);
351 /* configure endpoint capabilities in dQH */
352 i = ep->ep_num * 2 + is_in(ep);
353 ep->dqh = &dev->ep_dqh[i];
354 ep->dqh->dqh_ios = ios;
355 ep->dqh->dqh_mpl = cpu_to_le16(max);
356 ep->dqh->dqh_zlt = zlt;
357 ep->dqh->dqh_mult = mult;
358 ep->dqh->dtd_next = DTD_TERM;
360 dev_dbg(&dev->pdev->dev, "enabled %s (ep%d%s-%s), max %04x\n",
367 spin_unlock_irqrestore(&dev->lock, flags);
369 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
374 /*-------------------------------------------------------------------------*/
376 /* retire a request */
377 static void done(struct langwell_ep *ep, struct langwell_request *req,
380 struct langwell_udc *dev = ep->dev;
381 unsigned stopped = ep->stopped;
382 struct langwell_dtd *curr_dtd, *next_dtd;
385 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
387 /* remove the req from ep->queue */
388 list_del_init(&req->queue);
390 if (req->req.status == -EINPROGRESS)
391 req->req.status = status;
393 status = req->req.status;
395 /* free dTD for the request */
396 next_dtd = req->head;
397 for (i = 0; i < req->dtd_count; i++) {
399 if (i != req->dtd_count - 1)
400 next_dtd = curr_dtd->next_dtd_virt;
401 dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma);
404 usb_gadget_unmap_request(&dev->gadget, &req->req, is_in(ep));
406 if (status != -ESHUTDOWN)
407 dev_dbg(&dev->pdev->dev,
408 "complete %s, req %p, stat %d, len %u/%u\n",
409 ep->ep.name, &req->req, status,
410 req->req.actual, req->req.length);
412 /* don't modify queue heads during completion callback */
415 spin_unlock(&dev->lock);
416 /* complete routine from gadget driver */
417 if (req->req.complete)
418 req->req.complete(&ep->ep, &req->req);
420 spin_lock(&dev->lock);
421 ep->stopped = stopped;
423 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
427 static void langwell_ep_fifo_flush(struct usb_ep *_ep);
429 /* delete all endpoint requests, called with spinlock held */
430 static void nuke(struct langwell_ep *ep, int status)
432 /* called with spinlock held */
435 /* endpoint fifo flush */
436 if (&ep->ep && ep->desc)
437 langwell_ep_fifo_flush(&ep->ep);
439 while (!list_empty(&ep->queue)) {
440 struct langwell_request *req = NULL;
441 req = list_entry(ep->queue.next, struct langwell_request,
443 done(ep, req, status);
448 /*-------------------------------------------------------------------------*/
450 /* endpoint is no longer usable */
451 static int langwell_ep_disable(struct usb_ep *_ep)
453 struct langwell_ep *ep;
455 struct langwell_udc *dev;
459 ep = container_of(_ep, struct langwell_ep, ep);
461 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
463 if (!_ep || !ep->desc)
466 spin_lock_irqsave(&dev->lock, flags);
468 /* disable endpoint control register */
470 endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
472 endptctrl &= ~EPCTRL_TXE;
474 endptctrl &= ~EPCTRL_RXE;
475 writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
477 /* nuke all pending requests (does flush) */
478 nuke(ep, -ESHUTDOWN);
484 spin_unlock_irqrestore(&dev->lock, flags);
486 dev_dbg(&dev->pdev->dev, "disabled %s\n", _ep->name);
487 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
493 /* allocate a request object to use with this endpoint */
494 static struct usb_request *langwell_alloc_request(struct usb_ep *_ep,
497 struct langwell_ep *ep;
498 struct langwell_udc *dev;
499 struct langwell_request *req = NULL;
504 ep = container_of(_ep, struct langwell_ep, ep);
506 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
508 req = kzalloc(sizeof(*req), gfp_flags);
512 req->req.dma = DMA_ADDR_INVALID;
513 INIT_LIST_HEAD(&req->queue);
515 dev_vdbg(&dev->pdev->dev, "alloc request for %s\n", _ep->name);
516 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
521 /* free a request object */
522 static void langwell_free_request(struct usb_ep *_ep,
523 struct usb_request *_req)
525 struct langwell_ep *ep;
526 struct langwell_udc *dev;
527 struct langwell_request *req = NULL;
529 ep = container_of(_ep, struct langwell_ep, ep);
531 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
536 req = container_of(_req, struct langwell_request, req);
537 WARN_ON(!list_empty(&req->queue));
542 dev_vdbg(&dev->pdev->dev, "free request for %s\n", _ep->name);
543 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
547 /*-------------------------------------------------------------------------*/
549 /* queue dTD and PRIME endpoint */
550 static int queue_dtd(struct langwell_ep *ep, struct langwell_request *req)
552 u32 bit_mask, usbcmd, endptstat, dtd_dma;
555 struct langwell_dqh *dqh;
556 struct langwell_udc *dev;
559 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
561 i = ep->ep_num * 2 + is_in(ep);
562 dqh = &dev->ep_dqh[i];
565 dev_vdbg(&dev->pdev->dev, "%s\n", ep->name);
568 dev_vdbg(&dev->pdev->dev, "%s-%s\n", ep->name, DIR_STRING(ep));
570 dev_vdbg(&dev->pdev->dev, "ep_dqh[%d] addr: 0x%p\n",
571 i, &(dev->ep_dqh[i]));
573 bit_mask = is_in(ep) ?
574 (1 << (ep->ep_num + 16)) : (1 << (ep->ep_num));
576 dev_vdbg(&dev->pdev->dev, "bit_mask = 0x%08x\n", bit_mask);
578 /* check if the pipe is empty */
579 if (!(list_empty(&ep->queue))) {
580 /* add dTD to the end of linked list */
581 struct langwell_request *lastreq;
582 lastreq = list_entry(ep->queue.prev,
583 struct langwell_request, queue);
585 lastreq->tail->dtd_next =
586 cpu_to_le32(req->head->dtd_dma & DTD_NEXT_MASK);
588 /* read prime bit, if 1 goto out */
589 if (readl(&dev->op_regs->endptprime) & bit_mask)
593 /* set ATDTW bit in USBCMD */
594 usbcmd = readl(&dev->op_regs->usbcmd);
595 writel(usbcmd | CMD_ATDTW, &dev->op_regs->usbcmd);
597 /* read correct status bit */
598 endptstat = readl(&dev->op_regs->endptstat) & bit_mask;
600 } while (!(readl(&dev->op_regs->usbcmd) & CMD_ATDTW));
602 /* write ATDTW bit to 0 */
603 usbcmd = readl(&dev->op_regs->usbcmd);
604 writel(usbcmd & ~CMD_ATDTW, &dev->op_regs->usbcmd);
610 /* write dQH next pointer and terminate bit to 0 */
611 dtd_dma = req->head->dtd_dma & DTD_NEXT_MASK;
612 dqh->dtd_next = cpu_to_le32(dtd_dma);
614 /* clear active and halt bit */
615 dtd_status = (u8) ~(DTD_STS_ACTIVE | DTD_STS_HALTED);
616 dqh->dtd_status &= dtd_status;
617 dev_vdbg(&dev->pdev->dev, "dqh->dtd_status = 0x%x\n", dqh->dtd_status);
619 /* ensure that updates to the dQH will occur before priming */
622 /* write 1 to endptprime register to PRIME endpoint */
623 bit_mask = is_in(ep) ? (1 << (ep->ep_num + 16)) : (1 << ep->ep_num);
624 dev_vdbg(&dev->pdev->dev, "endprime bit_mask = 0x%08x\n", bit_mask);
625 writel(bit_mask, &dev->op_regs->endptprime);
627 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
632 /* fill in the dTD structure to build a transfer descriptor */
633 static struct langwell_dtd *build_dtd(struct langwell_request *req,
634 unsigned *length, dma_addr_t *dma, int *is_last)
637 struct langwell_dtd *dtd;
638 struct langwell_udc *dev;
642 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
644 /* the maximum transfer length, up to 16k bytes */
645 *length = min(req->req.length - req->req.actual,
646 (unsigned)DTD_MAX_TRANSFER_LENGTH);
648 /* create dTD dma_pool resource */
649 dtd = dma_pool_alloc(dev->dtd_pool, GFP_KERNEL, dma);
654 /* initialize buffer page pointers */
655 buf_ptr = (u32)(req->req.dma + req->req.actual);
656 for (i = 0; i < 5; i++)
657 dtd->dtd_buf[i] = cpu_to_le32(buf_ptr + i * PAGE_SIZE);
659 req->req.actual += *length;
661 /* fill in total bytes with transfer size */
662 dtd->dtd_total = cpu_to_le16(*length);
663 dev_vdbg(&dev->pdev->dev, "dtd->dtd_total = %d\n", dtd->dtd_total);
665 /* set is_last flag if req->req.zero is set or not */
667 if (*length == 0 || (*length % req->ep->ep.maxpacket) != 0)
671 } else if (req->req.length == req->req.actual) {
677 dev_vdbg(&dev->pdev->dev, "multi-dtd request!\n");
679 /* set interrupt on complete bit for the last dTD */
680 if (*is_last && !req->req.no_interrupt)
683 /* set multiplier override 0 for non-ISO and non-TX endpoint */
686 /* set the active bit of status field to 1 */
687 dtd->dtd_status = DTD_STS_ACTIVE;
688 dev_vdbg(&dev->pdev->dev, "dtd->dtd_status = 0x%02x\n",
691 dev_vdbg(&dev->pdev->dev, "length = %d, dma addr= 0x%08x\n",
693 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
698 /* generate dTD linked list for a request */
699 static int req_to_dtd(struct langwell_request *req)
702 int is_last, is_first = 1;
703 struct langwell_dtd *dtd, *last_dtd = NULL;
704 struct langwell_udc *dev;
708 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
710 dtd = build_dtd(req, &count, &dma, &is_last);
718 last_dtd->dtd_next = cpu_to_le32(dma);
719 last_dtd->next_dtd_virt = dtd;
725 /* set terminate bit to 1 for the last dTD */
726 dtd->dtd_next = DTD_TERM;
730 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
734 /*-------------------------------------------------------------------------*/
736 /* queue (submits) an I/O requests to an endpoint */
737 static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
740 struct langwell_request *req;
741 struct langwell_ep *ep;
742 struct langwell_udc *dev;
747 /* always require a cpu-view buffer */
748 req = container_of(_req, struct langwell_request, req);
749 ep = container_of(_ep, struct langwell_ep, ep);
751 if (!_req || !_req->complete || !_req->buf
752 || !list_empty(&req->queue)) {
756 if (unlikely(!_ep || !ep->desc))
761 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
763 if (usb_endpoint_xfer_isoc(ep->desc)) {
764 if (req->req.length > ep->ep.maxpacket)
769 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
772 /* set up dma mapping */
773 ret = usb_gadget_map_request(&dev->gadget, &req->req, is_in(ep));
777 dev_dbg(&dev->pdev->dev,
778 "%s queue req %p, len %u, buf %p, dma 0x%08x\n",
780 _req, _req->length, _req->buf, (int)_req->dma);
782 _req->status = -EINPROGRESS;
786 spin_lock_irqsave(&dev->lock, flags);
788 /* build and put dTDs to endpoint queue */
789 if (!req_to_dtd(req)) {
792 spin_unlock_irqrestore(&dev->lock, flags);
796 /* update ep0 state */
798 dev->ep0_state = DATA_STATE_XMIT;
800 if (likely(req != NULL)) {
801 list_add_tail(&req->queue, &ep->queue);
802 dev_vdbg(&dev->pdev->dev, "list_add_tail()\n");
805 spin_unlock_irqrestore(&dev->lock, flags);
807 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
812 /* dequeue (cancels, unlinks) an I/O request from an endpoint */
813 static int langwell_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
815 struct langwell_ep *ep;
816 struct langwell_udc *dev;
817 struct langwell_request *req;
819 int stopped, ep_num, retval = 0;
822 ep = container_of(_ep, struct langwell_ep, ep);
824 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
826 if (!_ep || !ep->desc || !_req)
832 spin_lock_irqsave(&dev->lock, flags);
833 stopped = ep->stopped;
835 /* quiesce dma while we patch the queue */
839 /* disable endpoint control register */
840 endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
842 endptctrl &= ~EPCTRL_TXE;
844 endptctrl &= ~EPCTRL_RXE;
845 writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
847 /* make sure it's still queued on this endpoint */
848 list_for_each_entry(req, &ep->queue, queue) {
849 if (&req->req == _req)
853 if (&req->req != _req) {
858 /* queue head may be partially complete. */
859 if (ep->queue.next == &req->queue) {
860 dev_dbg(&dev->pdev->dev, "unlink (%s) dma\n", _ep->name);
861 _req->status = -ECONNRESET;
862 langwell_ep_fifo_flush(&ep->ep);
864 /* not the last request in endpoint queue */
865 if (likely(ep->queue.next == &req->queue)) {
866 struct langwell_dqh *dqh;
867 struct langwell_request *next_req;
870 next_req = list_entry(req->queue.next,
871 struct langwell_request, queue);
873 /* point the dQH to the first dTD of next request */
874 writel((u32) next_req->head, &dqh->dqh_current);
877 struct langwell_request *prev_req;
879 prev_req = list_entry(req->queue.prev,
880 struct langwell_request, queue);
881 writel(readl(&req->tail->dtd_next),
882 &prev_req->tail->dtd_next);
885 done(ep, req, -ECONNRESET);
888 /* enable endpoint again */
889 endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
891 endptctrl |= EPCTRL_TXE;
893 endptctrl |= EPCTRL_RXE;
894 writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
896 ep->stopped = stopped;
897 spin_unlock_irqrestore(&dev->lock, flags);
899 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
904 /*-------------------------------------------------------------------------*/
906 /* endpoint set/clear halt */
907 static void ep_set_halt(struct langwell_ep *ep, int value)
911 struct langwell_udc *dev = ep->dev;
912 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
915 endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
917 /* value: 1 - set halt, 0 - clear halt */
919 /* set the stall bit */
921 endptctrl |= EPCTRL_TXS;
923 endptctrl |= EPCTRL_RXS;
925 /* clear the stall bit and reset data toggle */
927 endptctrl &= ~EPCTRL_TXS;
928 endptctrl |= EPCTRL_TXR;
930 endptctrl &= ~EPCTRL_RXS;
931 endptctrl |= EPCTRL_RXR;
935 writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
937 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
941 /* set the endpoint halt feature */
942 static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
944 struct langwell_ep *ep;
945 struct langwell_udc *dev;
949 ep = container_of(_ep, struct langwell_ep, ep);
952 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
954 if (!_ep || !ep->desc)
957 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
960 if (usb_endpoint_xfer_isoc(ep->desc))
963 spin_lock_irqsave(&dev->lock, flags);
966 * attempt to halt IN ep will fail if any transfer requests
969 if (!list_empty(&ep->queue) && is_in(ep) && value) {
970 /* IN endpoint FIFO holds bytes */
971 dev_dbg(&dev->pdev->dev, "%s FIFO holds bytes\n", _ep->name);
976 /* endpoint set/clear halt */
978 ep_set_halt(ep, value);
979 } else { /* endpoint 0 */
980 dev->ep0_state = WAIT_FOR_SETUP;
981 dev->ep0_dir = USB_DIR_OUT;
984 spin_unlock_irqrestore(&dev->lock, flags);
985 dev_dbg(&dev->pdev->dev, "%s %s halt\n",
986 _ep->name, value ? "set" : "clear");
987 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
992 /* set the halt feature and ignores clear requests */
993 static int langwell_ep_set_wedge(struct usb_ep *_ep)
995 struct langwell_ep *ep;
996 struct langwell_udc *dev;
998 ep = container_of(_ep, struct langwell_ep, ep);
1001 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1003 if (!_ep || !ep->desc)
1006 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1007 return usb_ep_set_halt(_ep);
1011 /* flush contents of a fifo */
1012 static void langwell_ep_fifo_flush(struct usb_ep *_ep)
1014 struct langwell_ep *ep;
1015 struct langwell_udc *dev;
1017 unsigned long timeout;
1019 ep = container_of(_ep, struct langwell_ep, ep);
1022 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1024 if (!_ep || !ep->desc) {
1025 dev_vdbg(&dev->pdev->dev, "ep or ep->desc is NULL\n");
1026 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1030 dev_vdbg(&dev->pdev->dev, "%s-%s fifo flush\n",
1031 _ep->name, DIR_STRING(ep));
1033 /* flush endpoint buffer */
1034 if (ep->ep_num == 0)
1035 flush_bit = (1 << 16) | 1;
1037 flush_bit = 1 << (ep->ep_num + 16); /* TX */
1039 flush_bit = 1 << ep->ep_num; /* RX */
1041 /* wait until flush complete */
1042 timeout = jiffies + FLUSH_TIMEOUT;
1044 writel(flush_bit, &dev->op_regs->endptflush);
1045 while (readl(&dev->op_regs->endptflush)) {
1046 if (time_after(jiffies, timeout)) {
1047 dev_err(&dev->pdev->dev, "ep flush timeout\n");
1052 } while (readl(&dev->op_regs->endptstat) & flush_bit);
1054 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1058 /* endpoints operations structure */
1059 static const struct usb_ep_ops langwell_ep_ops = {
1061 /* configure endpoint, making it usable */
1062 .enable = langwell_ep_enable,
1064 /* endpoint is no longer usable */
1065 .disable = langwell_ep_disable,
1067 /* allocate a request object to use with this endpoint */
1068 .alloc_request = langwell_alloc_request,
1070 /* free a request object */
1071 .free_request = langwell_free_request,
1073 /* queue (submits) an I/O requests to an endpoint */
1074 .queue = langwell_ep_queue,
1076 /* dequeue (cancels, unlinks) an I/O request from an endpoint */
1077 .dequeue = langwell_ep_dequeue,
1079 /* set the endpoint halt feature */
1080 .set_halt = langwell_ep_set_halt,
1082 /* set the halt feature and ignores clear requests */
1083 .set_wedge = langwell_ep_set_wedge,
1085 /* flush contents of a fifo */
1086 .fifo_flush = langwell_ep_fifo_flush,
1090 /*-------------------------------------------------------------------------*/
1092 /* device controller usb_gadget_ops structure */
1094 /* returns the current frame number */
1095 static int langwell_get_frame(struct usb_gadget *_gadget)
1097 struct langwell_udc *dev;
1103 dev = container_of(_gadget, struct langwell_udc, gadget);
1104 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1106 retval = readl(&dev->op_regs->frindex) & FRINDEX_MASK;
1108 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1113 /* enter or exit PHY low power state */
1114 static void langwell_phy_low_power(struct langwell_udc *dev, bool flag)
1118 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1120 devlc = readl(&dev->op_regs->devlc);
1121 dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
1128 /* FIXME: workaround for Langwell A1/A2/A3 sighting */
1129 devlc_byte2 = (devlc >> 16) & 0xff;
1130 writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
1132 devlc = readl(&dev->op_regs->devlc);
1133 dev_vdbg(&dev->pdev->dev,
1134 "%s PHY low power suspend, devlc = 0x%08x\n",
1135 flag ? "enter" : "exit", devlc);
1139 /* tries to wake up the host connected to this gadget */
1140 static int langwell_wakeup(struct usb_gadget *_gadget)
1142 struct langwell_udc *dev;
1144 unsigned long flags;
1149 dev = container_of(_gadget, struct langwell_udc, gadget);
1150 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1152 /* remote wakeup feature not enabled by host */
1153 if (!dev->remote_wakeup) {
1154 dev_info(&dev->pdev->dev, "remote wakeup is disabled\n");
1158 spin_lock_irqsave(&dev->lock, flags);
1160 portsc1 = readl(&dev->op_regs->portsc1);
1161 if (!(portsc1 & PORTS_SUSP)) {
1162 spin_unlock_irqrestore(&dev->lock, flags);
1166 /* LPM L1 to L0 or legacy remote wakeup */
1167 if (dev->lpm && dev->lpm_state == LPM_L1)
1168 dev_info(&dev->pdev->dev, "LPM L1 to L0 remote wakeup\n");
1170 dev_info(&dev->pdev->dev, "device remote wakeup\n");
1172 /* exit PHY low power suspend */
1173 if (dev->pdev->device != 0x0829)
1174 langwell_phy_low_power(dev, 0);
1176 /* force port resume */
1177 portsc1 |= PORTS_FPR;
1178 writel(portsc1, &dev->op_regs->portsc1);
1180 spin_unlock_irqrestore(&dev->lock, flags);
1182 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1187 /* notify controller that VBUS is powered or not */
1188 static int langwell_vbus_session(struct usb_gadget *_gadget, int is_active)
1190 struct langwell_udc *dev;
1191 unsigned long flags;
1197 dev = container_of(_gadget, struct langwell_udc, gadget);
1198 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1200 spin_lock_irqsave(&dev->lock, flags);
1201 dev_vdbg(&dev->pdev->dev, "VBUS status: %s\n",
1202 is_active ? "on" : "off");
1204 dev->vbus_active = (is_active != 0);
1205 if (dev->driver && dev->softconnected && dev->vbus_active) {
1206 usbcmd = readl(&dev->op_regs->usbcmd);
1207 usbcmd |= CMD_RUNSTOP;
1208 writel(usbcmd, &dev->op_regs->usbcmd);
1210 usbcmd = readl(&dev->op_regs->usbcmd);
1211 usbcmd &= ~CMD_RUNSTOP;
1212 writel(usbcmd, &dev->op_regs->usbcmd);
1215 spin_unlock_irqrestore(&dev->lock, flags);
1217 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1222 /* constrain controller's VBUS power usage */
1223 static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
1225 struct langwell_udc *dev;
1230 dev = container_of(_gadget, struct langwell_udc, gadget);
1231 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1233 if (dev->transceiver) {
1234 dev_vdbg(&dev->pdev->dev, "usb_phy_set_power\n");
1235 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1236 return usb_phy_set_power(dev->transceiver, mA);
1239 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1244 /* D+ pullup, software-controlled connect/disconnect to USB host */
1245 static int langwell_pullup(struct usb_gadget *_gadget, int is_on)
1247 struct langwell_udc *dev;
1249 unsigned long flags;
1254 dev = container_of(_gadget, struct langwell_udc, gadget);
1256 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1258 spin_lock_irqsave(&dev->lock, flags);
1259 dev->softconnected = (is_on != 0);
1261 if (dev->driver && dev->softconnected && dev->vbus_active) {
1262 usbcmd = readl(&dev->op_regs->usbcmd);
1263 usbcmd |= CMD_RUNSTOP;
1264 writel(usbcmd, &dev->op_regs->usbcmd);
1266 usbcmd = readl(&dev->op_regs->usbcmd);
1267 usbcmd &= ~CMD_RUNSTOP;
1268 writel(usbcmd, &dev->op_regs->usbcmd);
1270 spin_unlock_irqrestore(&dev->lock, flags);
1272 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1276 static int langwell_start(struct usb_gadget *g,
1277 struct usb_gadget_driver *driver);
1279 static int langwell_stop(struct usb_gadget *g,
1280 struct usb_gadget_driver *driver);
1282 /* device controller usb_gadget_ops structure */
1283 static const struct usb_gadget_ops langwell_ops = {
1285 /* returns the current frame number */
1286 .get_frame = langwell_get_frame,
1288 /* tries to wake up the host connected to this gadget */
1289 .wakeup = langwell_wakeup,
1291 /* set the device selfpowered feature, always selfpowered */
1292 /* .set_selfpowered = langwell_set_selfpowered, */
1294 /* notify controller that VBUS is powered or not */
1295 .vbus_session = langwell_vbus_session,
1297 /* constrain controller's VBUS power usage */
1298 .vbus_draw = langwell_vbus_draw,
1300 /* D+ pullup, software-controlled connect/disconnect to USB host */
1301 .pullup = langwell_pullup,
1303 .udc_start = langwell_start,
1304 .udc_stop = langwell_stop,
1308 /*-------------------------------------------------------------------------*/
1310 /* device controller operations */
1312 /* reset device controller */
1313 static int langwell_udc_reset(struct langwell_udc *dev)
1315 u32 usbcmd, usbmode, devlc, endpointlistaddr;
1316 u8 devlc_byte0, devlc_byte2;
1317 unsigned long timeout;
1322 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1324 /* set controller to stop state */
1325 usbcmd = readl(&dev->op_regs->usbcmd);
1326 usbcmd &= ~CMD_RUNSTOP;
1327 writel(usbcmd, &dev->op_regs->usbcmd);
1329 /* reset device controller */
1330 usbcmd = readl(&dev->op_regs->usbcmd);
1332 writel(usbcmd, &dev->op_regs->usbcmd);
1334 /* wait for reset to complete */
1335 timeout = jiffies + RESET_TIMEOUT;
1336 while (readl(&dev->op_regs->usbcmd) & CMD_RST) {
1337 if (time_after(jiffies, timeout)) {
1338 dev_err(&dev->pdev->dev, "device reset timeout\n");
1344 /* set controller to device mode */
1345 usbmode = readl(&dev->op_regs->usbmode);
1346 usbmode |= MODE_DEVICE;
1348 /* turn setup lockout off, require setup tripwire in usbcmd */
1349 usbmode |= MODE_SLOM;
1351 writel(usbmode, &dev->op_regs->usbmode);
1352 usbmode = readl(&dev->op_regs->usbmode);
1353 dev_vdbg(&dev->pdev->dev, "usbmode=0x%08x\n", usbmode);
1355 /* Write-Clear setup status */
1356 writel(0, &dev->op_regs->usbsts);
1358 /* if support USB LPM, ACK all LPM token */
1360 devlc = readl(&dev->op_regs->devlc);
1361 dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
1362 /* FIXME: workaround for Langwell A1/A2/A3 sighting */
1363 devlc &= ~LPM_STL; /* don't STALL LPM token */
1364 devlc &= ~LPM_NYT_ACK; /* ACK LPM token */
1365 devlc_byte0 = devlc & 0xff;
1366 devlc_byte2 = (devlc >> 16) & 0xff;
1367 writeb(devlc_byte0, (u8 *)&dev->op_regs->devlc);
1368 writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
1369 devlc = readl(&dev->op_regs->devlc);
1370 dev_vdbg(&dev->pdev->dev,
1371 "ACK LPM token, devlc = 0x%08x\n", devlc);
1374 /* fill endpointlistaddr register */
1375 endpointlistaddr = dev->ep_dqh_dma;
1376 endpointlistaddr &= ENDPOINTLISTADDR_MASK;
1377 writel(endpointlistaddr, &dev->op_regs->endpointlistaddr);
1379 dev_vdbg(&dev->pdev->dev,
1380 "dQH base (vir: %p, phy: 0x%08x), endpointlistaddr=0x%08x\n",
1381 dev->ep_dqh, endpointlistaddr,
1382 readl(&dev->op_regs->endpointlistaddr));
1383 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1388 /* reinitialize device controller endpoints */
1389 static int eps_reinit(struct langwell_udc *dev)
1391 struct langwell_ep *ep;
1395 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1397 /* initialize ep0 */
1400 strncpy(ep->name, "ep0", sizeof(ep->name));
1401 ep->ep.name = ep->name;
1402 ep->ep.ops = &langwell_ep_ops;
1404 ep->ep.maxpacket = EP0_MAX_PKT_SIZE;
1406 ep->desc = &langwell_ep0_desc;
1407 INIT_LIST_HEAD(&ep->queue);
1409 ep->ep_type = USB_ENDPOINT_XFER_CONTROL;
1411 /* initialize other endpoints */
1412 for (i = 2; i < dev->ep_max; i++) {
1415 snprintf(name, sizeof(name), "ep%din", i / 2);
1417 snprintf(name, sizeof(name), "ep%dout", i / 2);
1419 strncpy(ep->name, name, sizeof(ep->name));
1420 ep->ep.name = ep->name;
1422 ep->ep.ops = &langwell_ep_ops;
1424 ep->ep.maxpacket = (unsigned short) ~0;
1427 INIT_LIST_HEAD(&ep->queue);
1428 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
1431 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1436 /* enable interrupt and set controller to run state */
1437 static void langwell_udc_start(struct langwell_udc *dev)
1439 u32 usbintr, usbcmd;
1440 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1442 /* enable interrupts */
1443 usbintr = INTR_ULPIE /* ULPI */
1444 | INTR_SLE /* suspend */
1445 /* | INTR_SRE SOF received */
1446 | INTR_URE /* USB reset */
1447 | INTR_AAE /* async advance */
1448 | INTR_SEE /* system error */
1449 | INTR_FRE /* frame list rollover */
1450 | INTR_PCE /* port change detect */
1451 | INTR_UEE /* USB error interrupt */
1452 | INTR_UE; /* USB interrupt */
1453 writel(usbintr, &dev->op_regs->usbintr);
1455 /* clear stopped bit */
1458 /* set controller to run */
1459 usbcmd = readl(&dev->op_regs->usbcmd);
1460 usbcmd |= CMD_RUNSTOP;
1461 writel(usbcmd, &dev->op_regs->usbcmd);
1463 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1467 /* disable interrupt and set controller to stop state */
1468 static void langwell_udc_stop(struct langwell_udc *dev)
1472 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1474 /* disable all interrupts */
1475 writel(0, &dev->op_regs->usbintr);
1477 /* set stopped bit */
1480 /* set controller to stop state */
1481 usbcmd = readl(&dev->op_regs->usbcmd);
1482 usbcmd &= ~CMD_RUNSTOP;
1483 writel(usbcmd, &dev->op_regs->usbcmd);
1485 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1489 /* stop all USB activities */
1490 static void stop_activity(struct langwell_udc *dev)
1492 struct langwell_ep *ep;
1493 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1495 nuke(&dev->ep[0], -ESHUTDOWN);
1497 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1498 nuke(ep, -ESHUTDOWN);
1501 /* report disconnect; the driver is already quiesced */
1503 spin_unlock(&dev->lock);
1504 dev->driver->disconnect(&dev->gadget);
1505 spin_lock(&dev->lock);
1508 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1512 /*-------------------------------------------------------------------------*/
1514 /* device "function" sysfs attribute file */
1515 static ssize_t show_function(struct device *_dev,
1516 struct device_attribute *attr, char *buf)
1518 struct langwell_udc *dev = dev_get_drvdata(_dev);
1520 if (!dev->driver || !dev->driver->function
1521 || strlen(dev->driver->function) > PAGE_SIZE)
1524 return scnprintf(buf, PAGE_SIZE, "%s\n", dev->driver->function);
1526 static DEVICE_ATTR(function, S_IRUGO, show_function, NULL);
1529 static inline enum usb_device_speed lpm_device_speed(u32 reg)
1531 switch (LPM_PSPD(reg)) {
1532 case LPM_SPEED_HIGH:
1533 return USB_SPEED_HIGH;
1534 case LPM_SPEED_FULL:
1535 return USB_SPEED_FULL;
1537 return USB_SPEED_LOW;
1539 return USB_SPEED_UNKNOWN;
1543 /* device "langwell_udc" sysfs attribute file */
1544 static ssize_t show_langwell_udc(struct device *_dev,
1545 struct device_attribute *attr, char *buf)
1547 struct langwell_udc *dev = dev_get_drvdata(_dev);
1548 struct langwell_request *req;
1549 struct langwell_ep *ep = NULL;
1554 unsigned long flags;
1559 spin_lock_irqsave(&dev->lock, flags);
1561 /* driver basic information */
1562 t = scnprintf(next, size,
1565 "Gadget driver: %s\n\n",
1566 driver_name, DRIVER_VERSION,
1567 dev->driver ? dev->driver->driver.name : "(none)");
1571 /* device registers */
1572 tmp_reg = readl(&dev->op_regs->usbcmd);
1573 t = scnprintf(next, size,
1577 (tmp_reg & CMD_SUTW) ? 1 : 0,
1578 (tmp_reg & CMD_RUNSTOP) ? "Run" : "Stop");
1582 tmp_reg = readl(&dev->op_regs->usbsts);
1583 t = scnprintf(next, size,
1585 "Device Suspend: %d\n"
1586 "Reset Received: %d\n"
1587 "System Error: %s\n"
1588 "USB Error Interrupt: %s\n\n",
1589 (tmp_reg & STS_SLI) ? 1 : 0,
1590 (tmp_reg & STS_URI) ? 1 : 0,
1591 (tmp_reg & STS_SEI) ? "Error" : "No error",
1592 (tmp_reg & STS_UEI) ? "Error detected" : "No error");
1596 tmp_reg = readl(&dev->op_regs->usbintr);
1597 t = scnprintf(next, size,
1598 "USB Intrrupt Enable Reg:\n"
1599 "Sleep Enable: %d\n"
1600 "SOF Received Enable: %d\n"
1601 "Reset Enable: %d\n"
1602 "System Error Enable: %d\n"
1603 "Port Change Dectected Enable: %d\n"
1604 "USB Error Intr Enable: %d\n"
1605 "USB Intr Enable: %d\n\n",
1606 (tmp_reg & INTR_SLE) ? 1 : 0,
1607 (tmp_reg & INTR_SRE) ? 1 : 0,
1608 (tmp_reg & INTR_URE) ? 1 : 0,
1609 (tmp_reg & INTR_SEE) ? 1 : 0,
1610 (tmp_reg & INTR_PCE) ? 1 : 0,
1611 (tmp_reg & INTR_UEE) ? 1 : 0,
1612 (tmp_reg & INTR_UE) ? 1 : 0);
1616 tmp_reg = readl(&dev->op_regs->frindex);
1617 t = scnprintf(next, size,
1618 "USB Frame Index Reg:\n"
1619 "Frame Number is 0x%08x\n\n",
1620 (tmp_reg & FRINDEX_MASK));
1624 tmp_reg = readl(&dev->op_regs->deviceaddr);
1625 t = scnprintf(next, size,
1626 "USB Device Address Reg:\n"
1627 "Device Addr is 0x%x\n\n",
1632 tmp_reg = readl(&dev->op_regs->endpointlistaddr);
1633 t = scnprintf(next, size,
1634 "USB Endpoint List Address Reg:\n"
1635 "Endpoint List Pointer is 0x%x\n\n",
1640 tmp_reg = readl(&dev->op_regs->portsc1);
1641 t = scnprintf(next, size,
1642 "USB Port Status & Control Reg:\n"
1644 "Port Suspend Mode: %s\n"
1645 "Over-current Change: %s\n"
1646 "Port Enable/Disable Change: %s\n"
1647 "Port Enabled/Disabled: %s\n"
1648 "Current Connect Status: %s\n"
1649 "LPM Suspend Status: %s\n\n",
1650 (tmp_reg & PORTS_PR) ? "Reset" : "Not Reset",
1651 (tmp_reg & PORTS_SUSP) ? "Suspend " : "Not Suspend",
1652 (tmp_reg & PORTS_OCC) ? "Detected" : "No",
1653 (tmp_reg & PORTS_PEC) ? "Changed" : "Not Changed",
1654 (tmp_reg & PORTS_PE) ? "Enable" : "Not Correct",
1655 (tmp_reg & PORTS_CCS) ? "Attached" : "Not Attached",
1656 (tmp_reg & PORTS_SLP) ? "LPM L1" : "LPM L0");
1660 tmp_reg = readl(&dev->op_regs->devlc);
1661 t = scnprintf(next, size,
1662 "Device LPM Control Reg:\n"
1663 "Parallel Transceiver : %d\n"
1664 "Serial Transceiver : %d\n"
1666 "Port Force Full Speed Connenct: %s\n"
1667 "PHY Low Power Suspend Clock: %s\n"
1668 "BmAttributes: %d\n\n",
1670 (tmp_reg & LPM_STS) ? 1 : 0,
1671 usb_speed_string(lpm_device_speed(tmp_reg)),
1672 (tmp_reg & LPM_PFSC) ? "Force Full Speed" : "Not Force",
1673 (tmp_reg & LPM_PHCD) ? "Disabled" : "Enabled",
1678 tmp_reg = readl(&dev->op_regs->usbmode);
1679 t = scnprintf(next, size,
1681 "Controller Mode is : %s\n\n", ({
1683 switch (MODE_CM(tmp_reg)) {
1687 s = "Device Controller"; break;
1689 s = "Host Controller"; break;
1698 tmp_reg = readl(&dev->op_regs->endptsetupstat);
1699 t = scnprintf(next, size,
1700 "Endpoint Setup Status Reg:\n"
1701 "SETUP on ep 0x%04x\n\n",
1702 tmp_reg & SETUPSTAT_MASK);
1706 for (i = 0; i < dev->ep_max / 2; i++) {
1707 tmp_reg = readl(&dev->op_regs->endptctrl[i]);
1708 t = scnprintf(next, size, "EP Ctrl Reg [%d]: 0x%08x\n",
1713 tmp_reg = readl(&dev->op_regs->endptprime);
1714 t = scnprintf(next, size, "EP Prime Reg: 0x%08x\n\n", tmp_reg);
1718 /* langwell_udc, langwell_ep, langwell_request structure information */
1720 t = scnprintf(next, size, "%s MaxPacketSize: 0x%x, ep_num: %d\n",
1721 ep->ep.name, ep->ep.maxpacket, ep->ep_num);
1725 if (list_empty(&ep->queue)) {
1726 t = scnprintf(next, size, "its req queue is empty\n\n");
1730 list_for_each_entry(req, &ep->queue, queue) {
1731 t = scnprintf(next, size,
1732 "req %p actual 0x%x length 0x%x buf %p\n",
1733 &req->req, req->req.actual,
1734 req->req.length, req->req.buf);
1739 /* other gadget->eplist ep */
1740 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1742 t = scnprintf(next, size,
1743 "\n%s MaxPacketSize: 0x%x, "
1745 ep->ep.name, ep->ep.maxpacket,
1750 if (list_empty(&ep->queue)) {
1751 t = scnprintf(next, size,
1752 "its req queue is empty\n\n");
1756 list_for_each_entry(req, &ep->queue, queue) {
1757 t = scnprintf(next, size,
1758 "req %p actual 0x%x length "
1760 &req->req, req->req.actual,
1761 req->req.length, req->req.buf);
1769 spin_unlock_irqrestore(&dev->lock, flags);
1770 return PAGE_SIZE - size;
1772 static DEVICE_ATTR(langwell_udc, S_IRUGO, show_langwell_udc, NULL);
1775 /* device "remote_wakeup" sysfs attribute file */
1776 static ssize_t store_remote_wakeup(struct device *_dev,
1777 struct device_attribute *attr, const char *buf, size_t count)
1779 struct langwell_udc *dev = dev_get_drvdata(_dev);
1780 unsigned long flags;
1786 if (count > 0 && buf[count-1] == '\n')
1787 ((char *) buf)[count-1] = 0;
1792 /* force remote wakeup enabled in case gadget driver doesn't support */
1793 spin_lock_irqsave(&dev->lock, flags);
1794 dev->remote_wakeup = 1;
1795 dev->dev_status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1796 spin_unlock_irqrestore(&dev->lock, flags);
1798 langwell_wakeup(&dev->gadget);
1802 static DEVICE_ATTR(remote_wakeup, S_IWUSR, NULL, store_remote_wakeup);
1805 /*-------------------------------------------------------------------------*/
1808 * when a driver is successfully registered, it will receive
1809 * control requests including set_configuration(), which enables
1810 * non-control requests. then usb traffic follows until a
1811 * disconnect is reported. then a host may connect again, or
1812 * the driver might get unbound.
1815 static int langwell_start(struct usb_gadget *g,
1816 struct usb_gadget_driver *driver)
1818 struct langwell_udc *dev = gadget_to_langwell(g);
1819 unsigned long flags;
1822 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1824 spin_lock_irqsave(&dev->lock, flags);
1826 /* hook up the driver ... */
1827 driver->driver.bus = NULL;
1828 dev->driver = driver;
1829 dev->gadget.dev.driver = &driver->driver;
1831 spin_unlock_irqrestore(&dev->lock, flags);
1833 retval = device_create_file(&dev->pdev->dev, &dev_attr_function);
1837 dev->usb_state = USB_STATE_ATTACHED;
1838 dev->ep0_state = WAIT_FOR_SETUP;
1839 dev->ep0_dir = USB_DIR_OUT;
1841 /* enable interrupt and set controller to run state */
1843 langwell_udc_start(dev);
1845 dev_vdbg(&dev->pdev->dev,
1846 "After langwell_udc_start(), print all registers:\n");
1847 print_all_registers(dev);
1849 dev_info(&dev->pdev->dev, "register driver: %s\n",
1850 driver->driver.name);
1851 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1856 dev->gadget.dev.driver = NULL;
1859 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1864 /* unregister gadget driver */
1865 static int langwell_stop(struct usb_gadget *g,
1866 struct usb_gadget_driver *driver)
1868 struct langwell_udc *dev = gadget_to_langwell(g);
1869 unsigned long flags;
1871 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1873 /* exit PHY low power suspend */
1874 if (dev->pdev->device != 0x0829)
1875 langwell_phy_low_power(dev, 0);
1877 /* unbind OTG transceiver */
1878 if (dev->transceiver)
1879 (void)otg_set_peripheral(dev->transceiver->otg, 0);
1881 /* disable interrupt and set controller to stop state */
1882 langwell_udc_stop(dev);
1884 dev->usb_state = USB_STATE_ATTACHED;
1885 dev->ep0_state = WAIT_FOR_SETUP;
1886 dev->ep0_dir = USB_DIR_OUT;
1888 spin_lock_irqsave(&dev->lock, flags);
1890 /* stop all usb activities */
1891 dev->gadget.speed = USB_SPEED_UNKNOWN;
1892 dev->gadget.dev.driver = NULL;
1895 spin_unlock_irqrestore(&dev->lock, flags);
1897 device_remove_file(&dev->pdev->dev, &dev_attr_function);
1899 dev_info(&dev->pdev->dev, "unregistered driver '%s'\n",
1900 driver->driver.name);
1901 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1906 /*-------------------------------------------------------------------------*/
1909 * setup tripwire is used as a semaphore to ensure that the setup data
1910 * payload is extracted from a dQH without being corrupted
1912 static void setup_tripwire(struct langwell_udc *dev)
1916 unsigned long timeout;
1917 struct langwell_dqh *dqh;
1919 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1922 dqh = &dev->ep_dqh[EP_DIR_OUT];
1924 /* Write-Clear endptsetupstat */
1925 endptsetupstat = readl(&dev->op_regs->endptsetupstat);
1926 writel(endptsetupstat, &dev->op_regs->endptsetupstat);
1928 /* wait until endptsetupstat is cleared */
1929 timeout = jiffies + SETUPSTAT_TIMEOUT;
1930 while (readl(&dev->op_regs->endptsetupstat)) {
1931 if (time_after(jiffies, timeout)) {
1932 dev_err(&dev->pdev->dev, "setup_tripwire timeout\n");
1938 /* while a hazard exists when setup packet arrives */
1940 /* set setup tripwire bit */
1941 usbcmd = readl(&dev->op_regs->usbcmd);
1942 writel(usbcmd | CMD_SUTW, &dev->op_regs->usbcmd);
1944 /* copy the setup packet to local buffer */
1945 memcpy(&dev->local_setup_buff, &dqh->dqh_setup, 8);
1946 } while (!(readl(&dev->op_regs->usbcmd) & CMD_SUTW));
1948 /* Write-Clear setup tripwire bit */
1949 usbcmd = readl(&dev->op_regs->usbcmd);
1950 writel(usbcmd & ~CMD_SUTW, &dev->op_regs->usbcmd);
1952 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1956 /* protocol ep0 stall, will automatically be cleared on new transaction */
1957 static void ep0_stall(struct langwell_udc *dev)
1961 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1963 /* set TX and RX to stall */
1964 endptctrl = readl(&dev->op_regs->endptctrl[0]);
1965 endptctrl |= EPCTRL_TXS | EPCTRL_RXS;
1966 writel(endptctrl, &dev->op_regs->endptctrl[0]);
1968 /* update ep0 state */
1969 dev->ep0_state = WAIT_FOR_SETUP;
1970 dev->ep0_dir = USB_DIR_OUT;
1972 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1976 /* PRIME a status phase for ep0 */
1977 static int prime_status_phase(struct langwell_udc *dev, int dir)
1979 struct langwell_request *req;
1980 struct langwell_ep *ep;
1983 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1985 if (dir == EP_DIR_IN)
1986 dev->ep0_dir = USB_DIR_IN;
1988 dev->ep0_dir = USB_DIR_OUT;
1991 dev->ep0_state = WAIT_FOR_OUT_STATUS;
1993 req = dev->status_req;
1996 req->req.length = 0;
1997 req->req.status = -EINPROGRESS;
1998 req->req.actual = 0;
1999 req->req.complete = NULL;
2002 if (!req_to_dtd(req))
2003 status = queue_dtd(ep, req);
2008 dev_err(&dev->pdev->dev, "can't queue ep0 status request\n");
2010 list_add_tail(&req->queue, &ep->queue);
2012 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2017 /* SET_ADDRESS request routine */
2018 static void set_address(struct langwell_udc *dev, u16 value,
2019 u16 index, u16 length)
2021 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2023 /* save the new address to device struct */
2024 dev->dev_addr = (u8) value;
2025 dev_vdbg(&dev->pdev->dev, "dev->dev_addr = %d\n", dev->dev_addr);
2027 /* update usb state */
2028 dev->usb_state = USB_STATE_ADDRESS;
2031 if (prime_status_phase(dev, EP_DIR_IN))
2034 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2038 /* return endpoint by windex */
2039 static struct langwell_ep *get_ep_by_windex(struct langwell_udc *dev,
2042 struct langwell_ep *ep;
2043 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2045 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
2048 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
2049 u8 bEndpointAddress;
2053 bEndpointAddress = ep->desc->bEndpointAddress;
2054 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
2057 if ((wIndex & USB_ENDPOINT_NUMBER_MASK)
2058 == (bEndpointAddress & USB_ENDPOINT_NUMBER_MASK))
2062 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2067 /* return whether endpoint is stalled, 0: not stalled; 1: stalled */
2068 static int ep_is_stall(struct langwell_ep *ep)
2070 struct langwell_udc *dev = ep->dev;
2074 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2076 endptctrl = readl(&dev->op_regs->endptctrl[ep->ep_num]);
2078 retval = endptctrl & EPCTRL_TXS ? 1 : 0;
2080 retval = endptctrl & EPCTRL_RXS ? 1 : 0;
2082 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2087 /* GET_STATUS request routine */
2088 static void get_status(struct langwell_udc *dev, u8 request_type, u16 value,
2089 u16 index, u16 length)
2091 struct langwell_request *req;
2092 struct langwell_ep *ep;
2093 u16 status_data = 0; /* 16 bits cpu view status data */
2096 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2100 if ((request_type & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
2101 /* get device status */
2102 status_data = dev->dev_status;
2103 } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_INTERFACE) {
2104 /* get interface status */
2106 } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_ENDPOINT) {
2107 /* get endpoint status */
2108 struct langwell_ep *epn;
2109 epn = get_ep_by_windex(dev, index);
2110 /* stall if endpoint doesn't exist */
2114 status_data = ep_is_stall(epn) << USB_ENDPOINT_HALT;
2117 dev_dbg(&dev->pdev->dev, "get status data: 0x%04x\n", status_data);
2119 dev->ep0_dir = USB_DIR_IN;
2121 /* borrow the per device status_req */
2122 req = dev->status_req;
2124 /* fill in the reqest structure */
2125 *((u16 *) req->req.buf) = cpu_to_le16(status_data);
2127 req->req.length = 2;
2128 req->req.status = -EINPROGRESS;
2129 req->req.actual = 0;
2130 req->req.complete = NULL;
2133 /* prime the data phase */
2134 if (!req_to_dtd(req))
2135 status = queue_dtd(ep, req);
2140 dev_err(&dev->pdev->dev,
2141 "response error on GET_STATUS request\n");
2145 list_add_tail(&req->queue, &ep->queue);
2146 dev->ep0_state = DATA_STATE_XMIT;
2148 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2152 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2156 /* setup packet interrupt handler */
2157 static void handle_setup_packet(struct langwell_udc *dev,
2158 struct usb_ctrlrequest *setup)
2160 u16 wValue = le16_to_cpu(setup->wValue);
2161 u16 wIndex = le16_to_cpu(setup->wIndex);
2162 u16 wLength = le16_to_cpu(setup->wLength);
2165 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2167 /* ep0 fifo flush */
2168 nuke(&dev->ep[0], -ESHUTDOWN);
2170 dev_dbg(&dev->pdev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
2171 setup->bRequestType, setup->bRequest,
2172 wValue, wIndex, wLength);
2174 /* RNDIS gadget delegate */
2175 if ((setup->bRequestType == 0x21) && (setup->bRequest == 0x00)) {
2176 /* USB_CDC_SEND_ENCAPSULATED_COMMAND */
2180 /* USB_CDC_GET_ENCAPSULATED_RESPONSE */
2181 if ((setup->bRequestType == 0xa1) && (setup->bRequest == 0x01)) {
2182 /* USB_CDC_GET_ENCAPSULATED_RESPONSE */
2186 /* We process some stardard setup requests here */
2187 switch (setup->bRequest) {
2188 case USB_REQ_GET_STATUS:
2189 dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_GET_STATUS\n");
2190 /* get status, DATA and STATUS phase */
2191 if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK))
2192 != (USB_DIR_IN | USB_TYPE_STANDARD))
2194 get_status(dev, setup->bRequestType, wValue, wIndex, wLength);
2197 case USB_REQ_SET_ADDRESS:
2198 dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_SET_ADDRESS\n");
2200 if (setup->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD
2201 | USB_RECIP_DEVICE))
2203 set_address(dev, wValue, wIndex, wLength);
2206 case USB_REQ_CLEAR_FEATURE:
2207 case USB_REQ_SET_FEATURE:
2210 int rc = -EOPNOTSUPP;
2211 if (setup->bRequest == USB_REQ_SET_FEATURE)
2212 dev_dbg(&dev->pdev->dev,
2213 "SETUP: USB_REQ_SET_FEATURE\n");
2214 else if (setup->bRequest == USB_REQ_CLEAR_FEATURE)
2215 dev_dbg(&dev->pdev->dev,
2216 "SETUP: USB_REQ_CLEAR_FEATURE\n");
2218 if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK))
2219 == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) {
2220 struct langwell_ep *epn;
2221 epn = get_ep_by_windex(dev, wIndex);
2222 /* stall if endpoint doesn't exist */
2228 if (wValue != 0 || wLength != 0
2229 || epn->ep_num > dev->ep_max)
2232 spin_unlock(&dev->lock);
2233 rc = langwell_ep_set_halt(&epn->ep,
2234 (setup->bRequest == USB_REQ_SET_FEATURE)
2236 spin_lock(&dev->lock);
2238 } else if ((setup->bRequestType & (USB_RECIP_MASK
2239 | USB_TYPE_MASK)) == (USB_RECIP_DEVICE
2240 | USB_TYPE_STANDARD)) {
2243 case USB_DEVICE_REMOTE_WAKEUP:
2244 if (setup->bRequest == USB_REQ_SET_FEATURE) {
2245 dev->remote_wakeup = 1;
2246 dev->dev_status |= (1 << wValue);
2248 dev->remote_wakeup = 0;
2249 dev->dev_status &= ~(1 << wValue);
2252 case USB_DEVICE_TEST_MODE:
2253 dev_dbg(&dev->pdev->dev, "SETUP: TEST MODE\n");
2254 if ((wIndex & 0xff) ||
2255 (dev->gadget.speed != USB_SPEED_HIGH))
2258 switch (wIndex >> 8) {
2264 if (prime_status_phase(dev, EP_DIR_IN))
2266 portsc1 = readl(&dev->op_regs->portsc1);
2267 portsc1 |= (wIndex & 0xf00) << 8;
2268 writel(portsc1, &dev->op_regs->portsc1);
2279 if (!gadget_is_otg(&dev->gadget))
2281 else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE)
2282 dev->gadget.b_hnp_enable = 1;
2283 else if (setup->bRequest == USB_DEVICE_A_HNP_SUPPORT)
2284 dev->gadget.a_hnp_support = 1;
2285 else if (setup->bRequest ==
2286 USB_DEVICE_A_ALT_HNP_SUPPORT)
2287 dev->gadget.a_alt_hnp_support = 1;
2294 if (prime_status_phase(dev, EP_DIR_IN))
2300 case USB_REQ_GET_DESCRIPTOR:
2301 dev_dbg(&dev->pdev->dev,
2302 "SETUP: USB_REQ_GET_DESCRIPTOR\n");
2305 case USB_REQ_SET_DESCRIPTOR:
2306 dev_dbg(&dev->pdev->dev,
2307 "SETUP: USB_REQ_SET_DESCRIPTOR unsupported\n");
2310 case USB_REQ_GET_CONFIGURATION:
2311 dev_dbg(&dev->pdev->dev,
2312 "SETUP: USB_REQ_GET_CONFIGURATION\n");
2315 case USB_REQ_SET_CONFIGURATION:
2316 dev_dbg(&dev->pdev->dev,
2317 "SETUP: USB_REQ_SET_CONFIGURATION\n");
2320 case USB_REQ_GET_INTERFACE:
2321 dev_dbg(&dev->pdev->dev,
2322 "SETUP: USB_REQ_GET_INTERFACE\n");
2325 case USB_REQ_SET_INTERFACE:
2326 dev_dbg(&dev->pdev->dev,
2327 "SETUP: USB_REQ_SET_INTERFACE\n");
2330 case USB_REQ_SYNCH_FRAME:
2331 dev_dbg(&dev->pdev->dev,
2332 "SETUP: USB_REQ_SYNCH_FRAME unsupported\n");
2336 /* delegate USB standard requests to the gadget driver */
2339 /* USB requests handled by gadget */
2341 /* DATA phase from gadget, STATUS phase from udc */
2342 dev->ep0_dir = (setup->bRequestType & USB_DIR_IN)
2343 ? USB_DIR_IN : USB_DIR_OUT;
2344 dev_vdbg(&dev->pdev->dev,
2345 "dev->ep0_dir = 0x%x, wLength = %d\n",
2346 dev->ep0_dir, wLength);
2347 spin_unlock(&dev->lock);
2348 if (dev->driver->setup(&dev->gadget,
2349 &dev->local_setup_buff) < 0)
2351 spin_lock(&dev->lock);
2352 dev->ep0_state = (setup->bRequestType & USB_DIR_IN)
2353 ? DATA_STATE_XMIT : DATA_STATE_RECV;
2355 /* no DATA phase, IN STATUS phase from gadget */
2356 dev->ep0_dir = USB_DIR_IN;
2357 dev_vdbg(&dev->pdev->dev,
2358 "dev->ep0_dir = 0x%x, wLength = %d\n",
2359 dev->ep0_dir, wLength);
2360 spin_unlock(&dev->lock);
2361 if (dev->driver->setup(&dev->gadget,
2362 &dev->local_setup_buff) < 0)
2364 spin_lock(&dev->lock);
2365 dev->ep0_state = WAIT_FOR_OUT_STATUS;
2370 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2374 /* transfer completion, process endpoint request and free the completed dTDs
2377 static int process_ep_req(struct langwell_udc *dev, int index,
2378 struct langwell_request *curr_req)
2380 struct langwell_dtd *curr_dtd;
2381 struct langwell_dqh *curr_dqh;
2382 int td_complete, actual, remaining_length;
2387 curr_dqh = &dev->ep_dqh[index];
2390 curr_dtd = curr_req->head;
2392 actual = curr_req->req.length;
2394 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2396 for (i = 0; i < curr_req->dtd_count; i++) {
2398 /* command execution states by dTD */
2399 dtd_status = curr_dtd->dtd_status;
2402 remaining_length = le16_to_cpu(curr_dtd->dtd_total);
2403 actual -= remaining_length;
2406 /* transfers completed successfully */
2407 if (!remaining_length) {
2409 dev_vdbg(&dev->pdev->dev,
2410 "dTD transmitted successfully\n");
2413 dev_vdbg(&dev->pdev->dev,
2414 "TX dTD remains data\n");
2424 /* transfers completed with errors */
2425 if (dtd_status & DTD_STS_ACTIVE) {
2426 dev_dbg(&dev->pdev->dev,
2427 "dTD status ACTIVE dQH[%d]\n", index);
2430 } else if (dtd_status & DTD_STS_HALTED) {
2431 dev_err(&dev->pdev->dev,
2432 "dTD error %08x dQH[%d]\n",
2434 /* clear the errors and halt condition */
2435 curr_dqh->dtd_status = 0;
2438 } else if (dtd_status & DTD_STS_DBE) {
2439 dev_dbg(&dev->pdev->dev,
2440 "data buffer (overflow) error\n");
2443 } else if (dtd_status & DTD_STS_TRE) {
2444 dev_dbg(&dev->pdev->dev,
2445 "transaction(ISO) error\n");
2449 dev_err(&dev->pdev->dev,
2450 "unknown error (0x%x)!\n",
2454 if (i != curr_req->dtd_count - 1)
2455 curr_dtd = (struct langwell_dtd *)
2456 curr_dtd->next_dtd_virt;
2462 curr_req->req.actual = actual;
2464 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2469 /* complete DATA or STATUS phase of ep0 prime status phase if needed */
2470 static void ep0_req_complete(struct langwell_udc *dev,
2471 struct langwell_ep *ep0, struct langwell_request *req)
2474 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2476 if (dev->usb_state == USB_STATE_ADDRESS) {
2477 /* set the new address */
2478 new_addr = (u32)dev->dev_addr;
2479 writel(new_addr << USBADR_SHIFT, &dev->op_regs->deviceaddr);
2481 new_addr = USBADR(readl(&dev->op_regs->deviceaddr));
2482 dev_vdbg(&dev->pdev->dev, "new_addr = %d\n", new_addr);
2487 switch (dev->ep0_state) {
2488 case DATA_STATE_XMIT:
2489 /* receive status phase */
2490 if (prime_status_phase(dev, EP_DIR_OUT))
2493 case DATA_STATE_RECV:
2494 /* send status phase */
2495 if (prime_status_phase(dev, EP_DIR_IN))
2498 case WAIT_FOR_OUT_STATUS:
2499 dev->ep0_state = WAIT_FOR_SETUP;
2501 case WAIT_FOR_SETUP:
2502 dev_err(&dev->pdev->dev, "unexpect ep0 packets\n");
2509 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2513 /* USB transfer completion interrupt */
2514 static void handle_trans_complete(struct langwell_udc *dev)
2517 int i, ep_num, dir, bit_mask, status;
2518 struct langwell_ep *epn;
2519 struct langwell_request *curr_req, *temp_req;
2521 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2523 complete_bits = readl(&dev->op_regs->endptcomplete);
2524 dev_vdbg(&dev->pdev->dev, "endptcomplete register: 0x%08x\n",
2527 /* Write-Clear the bits in endptcomplete register */
2528 writel(complete_bits, &dev->op_regs->endptcomplete);
2530 if (!complete_bits) {
2531 dev_dbg(&dev->pdev->dev, "complete_bits = 0\n");
2535 for (i = 0; i < dev->ep_max; i++) {
2539 bit_mask = 1 << (ep_num + 16 * dir);
2541 if (!(complete_bits & bit_mask))
2550 if (epn->name == NULL) {
2551 dev_warn(&dev->pdev->dev, "invalid endpoint\n");
2556 /* ep0 in and out */
2557 dev_dbg(&dev->pdev->dev, "%s-%s transfer completed\n",
2559 is_in(epn) ? "in" : "out");
2561 dev_dbg(&dev->pdev->dev, "%s transfer completed\n",
2564 /* process the req queue until an uncomplete request */
2565 list_for_each_entry_safe(curr_req, temp_req,
2566 &epn->queue, queue) {
2567 status = process_ep_req(dev, i, curr_req);
2568 dev_vdbg(&dev->pdev->dev, "%s req status: %d\n",
2574 /* write back status to req */
2575 curr_req->req.status = status;
2577 /* ep0 request completion */
2579 ep0_req_complete(dev, epn, curr_req);
2582 done(epn, curr_req, status);
2587 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2590 /* port change detect interrupt handler */
2591 static void handle_port_change(struct langwell_udc *dev)
2595 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2600 portsc1 = readl(&dev->op_regs->portsc1);
2601 devlc = readl(&dev->op_regs->devlc);
2602 dev_vdbg(&dev->pdev->dev, "portsc1 = 0x%08x, devlc = 0x%08x\n",
2605 /* bus reset is finished */
2606 if (!(portsc1 & PORTS_PR)) {
2608 dev->gadget.speed = lpm_device_speed(devlc);
2609 dev_vdbg(&dev->pdev->dev, "dev->gadget.speed = %d\n",
2614 if (dev->lpm && dev->lpm_state == LPM_L0)
2615 if (portsc1 & PORTS_SUSP && portsc1 & PORTS_SLP) {
2616 dev_info(&dev->pdev->dev, "LPM L0 to L1\n");
2617 dev->lpm_state = LPM_L1;
2620 /* LPM L1 to L0, force resume or remote wakeup finished */
2621 if (dev->lpm && dev->lpm_state == LPM_L1)
2622 if (!(portsc1 & PORTS_SUSP)) {
2623 dev_info(&dev->pdev->dev, "LPM L1 to L0\n");
2624 dev->lpm_state = LPM_L0;
2627 /* update USB state */
2628 if (!dev->resume_state)
2629 dev->usb_state = USB_STATE_DEFAULT;
2631 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2635 /* USB reset interrupt handler */
2636 static void handle_usb_reset(struct langwell_udc *dev)
2641 unsigned long timeout;
2643 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2645 /* Write-Clear the device address */
2646 deviceaddr = readl(&dev->op_regs->deviceaddr);
2647 writel(deviceaddr & ~USBADR_MASK, &dev->op_regs->deviceaddr);
2651 /* clear usb state */
2652 dev->resume_state = 0;
2654 /* LPM L1 to L0, reset */
2656 dev->lpm_state = LPM_L0;
2658 dev->ep0_dir = USB_DIR_OUT;
2659 dev->ep0_state = WAIT_FOR_SETUP;
2661 /* remote wakeup reset to 0 when the device is reset */
2662 dev->remote_wakeup = 0;
2663 dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
2664 dev->gadget.b_hnp_enable = 0;
2665 dev->gadget.a_hnp_support = 0;
2666 dev->gadget.a_alt_hnp_support = 0;
2668 /* Write-Clear all the setup token semaphores */
2669 endptsetupstat = readl(&dev->op_regs->endptsetupstat);
2670 writel(endptsetupstat, &dev->op_regs->endptsetupstat);
2672 /* Write-Clear all the endpoint complete status bits */
2673 endptcomplete = readl(&dev->op_regs->endptcomplete);
2674 writel(endptcomplete, &dev->op_regs->endptcomplete);
2676 /* wait until all endptprime bits cleared */
2677 timeout = jiffies + PRIME_TIMEOUT;
2678 while (readl(&dev->op_regs->endptprime)) {
2679 if (time_after(jiffies, timeout)) {
2680 dev_err(&dev->pdev->dev, "USB reset timeout\n");
2686 /* write 1s to endptflush register to clear any primed buffers */
2687 writel((u32) ~0, &dev->op_regs->endptflush);
2689 if (readl(&dev->op_regs->portsc1) & PORTS_PR) {
2690 dev_vdbg(&dev->pdev->dev, "USB bus reset\n");
2691 /* bus is reseting */
2694 /* reset all the queues, stop all USB activities */
2696 dev->usb_state = USB_STATE_DEFAULT;
2698 dev_vdbg(&dev->pdev->dev, "device controller reset\n");
2699 /* controller reset */
2700 langwell_udc_reset(dev);
2702 /* reset all the queues, stop all USB activities */
2705 /* reset ep0 dQH and endptctrl */
2708 /* enable interrupt and set controller to run state */
2709 langwell_udc_start(dev);
2711 dev->usb_state = USB_STATE_ATTACHED;
2714 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2718 /* USB bus suspend/resume interrupt */
2719 static void handle_bus_suspend(struct langwell_udc *dev)
2721 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2723 dev->resume_state = dev->usb_state;
2724 dev->usb_state = USB_STATE_SUSPENDED;
2726 /* report suspend to the driver */
2728 if (dev->driver->suspend) {
2729 spin_unlock(&dev->lock);
2730 dev->driver->suspend(&dev->gadget);
2731 spin_lock(&dev->lock);
2732 dev_dbg(&dev->pdev->dev, "suspend %s\n",
2733 dev->driver->driver.name);
2737 /* enter PHY low power suspend */
2738 if (dev->pdev->device != 0x0829)
2739 langwell_phy_low_power(dev, 0);
2741 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2745 static void handle_bus_resume(struct langwell_udc *dev)
2747 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2749 dev->usb_state = dev->resume_state;
2750 dev->resume_state = 0;
2752 /* exit PHY low power suspend */
2753 if (dev->pdev->device != 0x0829)
2754 langwell_phy_low_power(dev, 0);
2756 /* report resume to the driver */
2758 if (dev->driver->resume) {
2759 spin_unlock(&dev->lock);
2760 dev->driver->resume(&dev->gadget);
2761 spin_lock(&dev->lock);
2762 dev_dbg(&dev->pdev->dev, "resume %s\n",
2763 dev->driver->driver.name);
2767 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2771 /* USB device controller interrupt handler */
2772 static irqreturn_t langwell_irq(int irq, void *_dev)
2774 struct langwell_udc *dev = _dev;
2780 dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2783 dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
2784 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2788 spin_lock(&dev->lock);
2791 usbsts = readl(&dev->op_regs->usbsts);
2793 /* USB interrupt enable */
2794 usbintr = readl(&dev->op_regs->usbintr);
2796 irq_sts = usbsts & usbintr;
2797 dev_vdbg(&dev->pdev->dev,
2798 "usbsts = 0x%08x, usbintr = 0x%08x, irq_sts = 0x%08x\n",
2799 usbsts, usbintr, irq_sts);
2802 dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
2803 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2804 spin_unlock(&dev->lock);
2808 /* Write-Clear interrupt status bits */
2809 writel(irq_sts, &dev->op_regs->usbsts);
2811 /* resume from suspend */
2812 portsc1 = readl(&dev->op_regs->portsc1);
2813 if (dev->usb_state == USB_STATE_SUSPENDED)
2814 if (!(portsc1 & PORTS_SUSP))
2815 handle_bus_resume(dev);
2818 if (irq_sts & STS_UI) {
2819 dev_vdbg(&dev->pdev->dev, "USB interrupt\n");
2821 /* setup packet received from ep0 */
2822 if (readl(&dev->op_regs->endptsetupstat)
2823 & EP0SETUPSTAT_MASK) {
2824 dev_vdbg(&dev->pdev->dev,
2825 "USB SETUP packet received interrupt\n");
2826 /* setup tripwire semaphone */
2827 setup_tripwire(dev);
2828 handle_setup_packet(dev, &dev->local_setup_buff);
2831 /* USB transfer completion */
2832 if (readl(&dev->op_regs->endptcomplete)) {
2833 dev_vdbg(&dev->pdev->dev,
2834 "USB transfer completion interrupt\n");
2835 handle_trans_complete(dev);
2839 /* SOF received interrupt (for ISO transfer) */
2840 if (irq_sts & STS_SRI) {
2842 /* dev_vdbg(&dev->pdev->dev, "SOF received interrupt\n"); */
2845 /* port change detect interrupt */
2846 if (irq_sts & STS_PCI) {
2847 dev_vdbg(&dev->pdev->dev, "port change detect interrupt\n");
2848 handle_port_change(dev);
2851 /* suspend interrupt */
2852 if (irq_sts & STS_SLI) {
2853 dev_vdbg(&dev->pdev->dev, "suspend interrupt\n");
2854 handle_bus_suspend(dev);
2857 /* USB reset interrupt */
2858 if (irq_sts & STS_URI) {
2859 dev_vdbg(&dev->pdev->dev, "USB reset interrupt\n");
2860 handle_usb_reset(dev);
2863 /* USB error or system error interrupt */
2864 if (irq_sts & (STS_UEI | STS_SEI)) {
2866 dev_warn(&dev->pdev->dev, "error IRQ, irq_sts: %x\n", irq_sts);
2869 spin_unlock(&dev->lock);
2871 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2876 /*-------------------------------------------------------------------------*/
2878 /* release device structure */
2879 static void gadget_release(struct device *_dev)
2881 struct langwell_udc *dev = dev_get_drvdata(_dev);
2883 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2885 complete(dev->done);
2887 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2892 /* enable SRAM caching if SRAM detected */
2893 static void sram_init(struct langwell_udc *dev)
2895 struct pci_dev *pdev = dev->pdev;
2897 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2899 dev->sram_addr = pci_resource_start(pdev, 1);
2900 dev->sram_size = pci_resource_len(pdev, 1);
2901 dev_info(&dev->pdev->dev, "Found private SRAM at %x size:%x\n",
2902 dev->sram_addr, dev->sram_size);
2905 if (pci_request_region(pdev, 1, kobject_name(&pdev->dev.kobj))) {
2906 dev_warn(&dev->pdev->dev, "SRAM request failed\n");
2908 } else if (!dma_declare_coherent_memory(&pdev->dev, dev->sram_addr,
2909 dev->sram_addr, dev->sram_size, DMA_MEMORY_MAP)) {
2910 dev_warn(&dev->pdev->dev, "SRAM DMA declare failed\n");
2911 pci_release_region(pdev, 1);
2915 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2919 /* release SRAM caching */
2920 static void sram_deinit(struct langwell_udc *dev)
2922 struct pci_dev *pdev = dev->pdev;
2924 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2926 dma_release_declared_memory(&pdev->dev);
2927 pci_release_region(pdev, 1);
2931 dev_info(&dev->pdev->dev, "release SRAM caching\n");
2932 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2936 /* tear down the binding between this driver and the pci device */
2937 static void langwell_udc_remove(struct pci_dev *pdev)
2939 struct langwell_udc *dev = pci_get_drvdata(pdev);
2941 DECLARE_COMPLETION(done);
2943 BUG_ON(dev->driver);
2944 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2948 /* free dTD dma_pool and dQH */
2950 dma_pool_destroy(dev->dtd_pool);
2953 dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
2954 dev->ep_dqh, dev->ep_dqh_dma);
2956 /* release SRAM caching */
2957 if (dev->has_sram && dev->got_sram)
2960 if (dev->status_req) {
2961 kfree(dev->status_req->req.buf);
2962 kfree(dev->status_req);
2967 /* disable IRQ handler */
2969 free_irq(pdev->irq, dev);
2972 iounmap(dev->cap_regs);
2975 release_mem_region(pci_resource_start(pdev, 0),
2976 pci_resource_len(pdev, 0));
2979 pci_disable_device(pdev);
2981 dev->cap_regs = NULL;
2983 dev_info(&dev->pdev->dev, "unbind\n");
2984 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2986 device_unregister(&dev->gadget.dev);
2987 device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
2988 device_remove_file(&pdev->dev, &dev_attr_remote_wakeup);
2990 pci_set_drvdata(pdev, NULL);
2992 /* free dev, wait for the release() finished */
2993 wait_for_completion(&done);
2998 * wrap this driver around the specified device, but
2999 * don't respond over USB until a gadget driver binds to us.
3001 static int langwell_udc_probe(struct pci_dev *pdev,
3002 const struct pci_device_id *id)
3004 struct langwell_udc *dev;
3005 unsigned long resource, len;
3006 void __iomem *base = NULL;
3010 /* alloc, and start init */
3011 dev = kzalloc(sizeof *dev, GFP_KERNEL);
3017 /* initialize device spinlock */
3018 spin_lock_init(&dev->lock);
3021 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3023 pci_set_drvdata(pdev, dev);
3025 /* now all the pci goodies ... */
3026 if (pci_enable_device(pdev) < 0) {
3032 /* control register: BAR 0 */
3033 resource = pci_resource_start(pdev, 0);
3034 len = pci_resource_len(pdev, 0);
3035 if (!request_mem_region(resource, len, driver_name)) {
3036 dev_err(&dev->pdev->dev, "controller already in use\n");
3042 base = ioremap_nocache(resource, len);
3044 dev_err(&dev->pdev->dev, "can't map memory\n");
3049 dev->cap_regs = (struct langwell_cap_regs __iomem *) base;
3050 dev_vdbg(&dev->pdev->dev, "dev->cap_regs: %p\n", dev->cap_regs);
3051 dev->op_regs = (struct langwell_op_regs __iomem *)
3052 (base + OP_REG_OFFSET);
3053 dev_vdbg(&dev->pdev->dev, "dev->op_regs: %p\n", dev->op_regs);
3055 /* irq setup after old hardware is cleaned up */
3057 dev_err(&dev->pdev->dev, "No IRQ. Check PCI setup!\n");
3064 dev_vdbg(&dev->pdev->dev, "dev->has_sram: %d\n", dev->has_sram);
3066 /* enable SRAM caching if detected */
3067 if (dev->has_sram && !dev->got_sram)
3070 dev_info(&dev->pdev->dev,
3071 "irq %d, io mem: 0x%08lx, len: 0x%08lx, pci mem 0x%p\n",
3072 pdev->irq, resource, len, base);
3073 /* enables bus-mastering for device dev */
3074 pci_set_master(pdev);
3076 if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
3077 driver_name, dev) != 0) {
3078 dev_err(&dev->pdev->dev,
3079 "request interrupt %d failed\n", pdev->irq);
3085 /* set stopped bit */
3088 /* capabilities and endpoint number */
3089 dev->lpm = (readl(&dev->cap_regs->hccparams) & HCC_LEN) ? 1 : 0;
3090 dev->dciversion = readw(&dev->cap_regs->dciversion);
3091 dev->devcap = (readl(&dev->cap_regs->dccparams) & DEVCAP) ? 1 : 0;
3092 dev_vdbg(&dev->pdev->dev, "dev->lpm: %d\n", dev->lpm);
3093 dev_vdbg(&dev->pdev->dev, "dev->dciversion: 0x%04x\n",
3095 dev_vdbg(&dev->pdev->dev, "dccparams: 0x%08x\n",
3096 readl(&dev->cap_regs->dccparams));
3097 dev_vdbg(&dev->pdev->dev, "dev->devcap: %d\n", dev->devcap);
3099 dev_err(&dev->pdev->dev, "can't support device mode\n");
3104 /* a pair of endpoints (out/in) for each address */
3105 dev->ep_max = DEN(readl(&dev->cap_regs->dccparams)) * 2;
3106 dev_vdbg(&dev->pdev->dev, "dev->ep_max: %d\n", dev->ep_max);
3108 /* allocate endpoints memory */
3109 dev->ep = kzalloc(sizeof(struct langwell_ep) * dev->ep_max,
3112 dev_err(&dev->pdev->dev, "allocate endpoints memory failed\n");
3117 /* allocate device dQH memory */
3118 size = dev->ep_max * sizeof(struct langwell_dqh);
3119 dev_vdbg(&dev->pdev->dev, "orig size = %zd\n", size);
3120 if (size < DQH_ALIGNMENT)
3121 size = DQH_ALIGNMENT;
3122 else if ((size % DQH_ALIGNMENT) != 0) {
3123 size += DQH_ALIGNMENT + 1;
3124 size &= ~(DQH_ALIGNMENT - 1);
3126 dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
3127 &dev->ep_dqh_dma, GFP_KERNEL);
3129 dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
3133 dev->ep_dqh_size = size;
3134 dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %zd\n", dev->ep_dqh_size);
3136 /* initialize ep0 status request structure */
3137 dev->status_req = kzalloc(sizeof(struct langwell_request), GFP_KERNEL);
3138 if (!dev->status_req) {
3139 dev_err(&dev->pdev->dev,
3140 "allocate status_req memory failed\n");
3144 INIT_LIST_HEAD(&dev->status_req->queue);
3146 /* allocate a small amount of memory to get valid address */
3147 dev->status_req->req.buf = kmalloc(8, GFP_KERNEL);
3148 dev->status_req->req.dma = virt_to_phys(dev->status_req->req.buf);
3150 dev->resume_state = USB_STATE_NOTATTACHED;
3151 dev->usb_state = USB_STATE_POWERED;
3152 dev->ep0_dir = USB_DIR_OUT;
3154 /* remote wakeup reset to 0 when the device is reset */
3155 dev->remote_wakeup = 0;
3156 dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
3158 /* reset device controller */
3159 langwell_udc_reset(dev);
3161 /* initialize gadget structure */
3162 dev->gadget.ops = &langwell_ops; /* usb_gadget_ops */
3163 dev->gadget.ep0 = &dev->ep[0].ep; /* gadget ep0 */
3164 INIT_LIST_HEAD(&dev->gadget.ep_list); /* ep_list */
3165 dev->gadget.speed = USB_SPEED_UNKNOWN; /* speed */
3166 dev->gadget.max_speed = USB_SPEED_HIGH; /* support dual speed */
3168 /* the "gadget" abstracts/virtualizes the controller */
3169 dev_set_name(&dev->gadget.dev, "gadget");
3170 dev->gadget.dev.parent = &pdev->dev;
3171 dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
3172 dev->gadget.dev.release = gadget_release;
3173 dev->gadget.name = driver_name; /* gadget name */
3175 /* controller endpoints reinit */
3178 /* reset ep0 dQH and endptctrl */
3181 /* create dTD dma_pool resource */
3182 dev->dtd_pool = dma_pool_create("langwell_dtd",
3184 sizeof(struct langwell_dtd),
3188 if (!dev->dtd_pool) {
3194 dev_info(&dev->pdev->dev, "%s\n", driver_desc);
3195 dev_info(&dev->pdev->dev, "irq %d, pci mem %p\n", pdev->irq, base);
3196 dev_info(&dev->pdev->dev, "Driver version: " DRIVER_VERSION "\n");
3197 dev_info(&dev->pdev->dev, "Support (max) %d endpoints\n", dev->ep_max);
3198 dev_info(&dev->pdev->dev, "Device interface version: 0x%04x\n",
3200 dev_info(&dev->pdev->dev, "Controller mode: %s\n",
3201 dev->devcap ? "Device" : "Host");
3202 dev_info(&dev->pdev->dev, "Support USB LPM: %s\n",
3203 dev->lpm ? "Yes" : "No");
3205 dev_vdbg(&dev->pdev->dev,
3206 "After langwell_udc_probe(), print all registers:\n");
3207 print_all_registers(dev);
3209 retval = device_register(&dev->gadget.dev);
3213 retval = usb_add_gadget_udc(&pdev->dev, &dev->gadget);
3217 retval = device_create_file(&pdev->dev, &dev_attr_langwell_udc);
3221 retval = device_create_file(&pdev->dev, &dev_attr_remote_wakeup);
3225 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3229 device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
3232 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3233 langwell_udc_remove(pdev);
3240 /* device controller suspend */
3241 static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state)
3243 struct langwell_udc *dev = pci_get_drvdata(pdev);
3245 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3247 usb_del_gadget_udc(&dev->gadget);
3248 /* disable interrupt and set controller to stop state */
3249 langwell_udc_stop(dev);
3251 /* disable IRQ handler */
3253 free_irq(pdev->irq, dev);
3256 /* save PCI state */
3257 pci_save_state(pdev);
3259 spin_lock_irq(&dev->lock);
3260 /* stop all usb activities */
3262 spin_unlock_irq(&dev->lock);
3264 /* free dTD dma_pool and dQH */
3266 dma_pool_destroy(dev->dtd_pool);
3269 dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
3270 dev->ep_dqh, dev->ep_dqh_dma);
3272 /* release SRAM caching */
3273 if (dev->has_sram && dev->got_sram)
3276 /* set device power state */
3277 pci_set_power_state(pdev, PCI_D3hot);
3279 /* enter PHY low power suspend */
3280 if (dev->pdev->device != 0x0829)
3281 langwell_phy_low_power(dev, 1);
3283 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3288 /* device controller resume */
3289 static int langwell_udc_resume(struct pci_dev *pdev)
3291 struct langwell_udc *dev = pci_get_drvdata(pdev);
3294 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3296 /* exit PHY low power suspend */
3297 if (dev->pdev->device != 0x0829)
3298 langwell_phy_low_power(dev, 0);
3300 /* set device D0 power state */
3301 pci_set_power_state(pdev, PCI_D0);
3303 /* enable SRAM caching if detected */
3304 if (dev->has_sram && !dev->got_sram)
3307 /* allocate device dQH memory */
3308 size = dev->ep_max * sizeof(struct langwell_dqh);
3309 dev_vdbg(&dev->pdev->dev, "orig size = %zd\n", size);
3310 if (size < DQH_ALIGNMENT)
3311 size = DQH_ALIGNMENT;
3312 else if ((size % DQH_ALIGNMENT) != 0) {
3313 size += DQH_ALIGNMENT + 1;
3314 size &= ~(DQH_ALIGNMENT - 1);
3316 dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
3317 &dev->ep_dqh_dma, GFP_KERNEL);
3319 dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
3322 dev->ep_dqh_size = size;
3323 dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %zd\n", dev->ep_dqh_size);
3325 /* create dTD dma_pool resource */
3326 dev->dtd_pool = dma_pool_create("langwell_dtd",
3328 sizeof(struct langwell_dtd),
3335 /* restore PCI state */
3336 pci_restore_state(pdev);
3338 /* enable IRQ handler */
3339 if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
3340 driver_name, dev) != 0) {
3341 dev_err(&dev->pdev->dev, "request interrupt %d failed\n",
3347 /* reset and start controller to run state */
3349 /* reset device controller */
3350 langwell_udc_reset(dev);
3352 /* reset ep0 dQH and endptctrl */
3355 /* start device if gadget is loaded */
3357 langwell_udc_start(dev);
3360 /* reset USB status */
3361 dev->usb_state = USB_STATE_ATTACHED;
3362 dev->ep0_state = WAIT_FOR_SETUP;
3363 dev->ep0_dir = USB_DIR_OUT;
3365 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3370 /* pci driver shutdown */
3371 static void langwell_udc_shutdown(struct pci_dev *pdev)
3373 struct langwell_udc *dev = pci_get_drvdata(pdev);
3376 dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3378 /* reset controller mode to IDLE */
3379 usbmode = readl(&dev->op_regs->usbmode);
3380 dev_dbg(&dev->pdev->dev, "usbmode = 0x%08x\n", usbmode);
3381 usbmode &= (~3 | MODE_IDLE);
3382 writel(usbmode, &dev->op_regs->usbmode);
3384 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3387 /*-------------------------------------------------------------------------*/
3389 static const struct pci_device_id pci_ids[] = { {
3390 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
3394 .subvendor = PCI_ANY_ID,
3395 .subdevice = PCI_ANY_ID,
3396 }, { /* end: all zeroes */ }
3399 MODULE_DEVICE_TABLE(pci, pci_ids);
3402 static struct pci_driver langwell_pci_driver = {
3403 .name = (char *) driver_name,
3404 .id_table = pci_ids,
3406 .probe = langwell_udc_probe,
3407 .remove = langwell_udc_remove,
3409 /* device controller suspend/resume */
3410 .suspend = langwell_udc_suspend,
3411 .resume = langwell_udc_resume,
3413 .shutdown = langwell_udc_shutdown,
3417 static int __init init(void)
3419 return pci_register_driver(&langwell_pci_driver);
3424 static void __exit cleanup(void)
3426 pci_unregister_driver(&langwell_pci_driver);
3428 module_exit(cleanup);
3431 MODULE_DESCRIPTION(DRIVER_DESC);
3432 MODULE_AUTHOR("Xiaochen Shen <xiaochen.shen@intel.com>");
3433 MODULE_VERSION(DRIVER_VERSION);
3434 MODULE_LICENSE("GPL");