2 * udc.c - ChipIdea UDC driver
4 * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/dmapool.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/err.h>
18 #include <linux/init.h>
19 #include <linux/platform_device.h>
20 #include <linux/module.h>
21 #include <linux/interrupt.h>
23 #include <linux/irq.h>
24 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/pm_runtime.h>
27 #include <linux/usb/ch9.h>
28 #include <linux/usb/gadget.h>
29 #include <linux/usb/otg.h>
30 #include <linux/usb/chipidea.h>
37 /* control endpoint description */
38 static const struct usb_endpoint_descriptor
39 ctrl_endpt_out_desc = {
40 .bLength = USB_DT_ENDPOINT_SIZE,
41 .bDescriptorType = USB_DT_ENDPOINT,
43 .bEndpointAddress = USB_DIR_OUT,
44 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
45 .wMaxPacketSize = cpu_to_le16(CTRL_PAYLOAD_MAX),
48 static const struct usb_endpoint_descriptor
49 ctrl_endpt_in_desc = {
50 .bLength = USB_DT_ENDPOINT_SIZE,
51 .bDescriptorType = USB_DT_ENDPOINT,
53 .bEndpointAddress = USB_DIR_IN,
54 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
55 .wMaxPacketSize = cpu_to_le16(CTRL_PAYLOAD_MAX),
59 * hw_ep_bit: calculates the bit number
60 * @num: endpoint number
61 * @dir: endpoint direction
63 * This function returns bit number
65 static inline int hw_ep_bit(int num, int dir)
67 return num + (dir ? 16 : 0);
70 static inline int ep_to_bit(struct ci13xxx *ci, int n)
72 int fill = 16 - ci->hw_ep_max / 2;
74 if (n >= ci->hw_ep_max / 2)
81 * hw_device_state: enables/disables interrupts (execute without interruption)
82 * @dma: 0 => disable, !0 => enable and set dma engine
84 * This function returns an error code
86 static int hw_device_state(struct ci13xxx *ci, u32 dma)
89 hw_write(ci, OP_ENDPTLISTADDR, ~0, dma);
90 /* interrupt, error, port change, reset, sleep/suspend */
91 hw_write(ci, OP_USBINTR, ~0,
92 USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
94 hw_write(ci, OP_USBINTR, ~0, 0);
100 * hw_ep_flush: flush endpoint fifo (execute without interruption)
101 * @num: endpoint number
102 * @dir: endpoint direction
104 * This function returns an error code
106 static int hw_ep_flush(struct ci13xxx *ci, int num, int dir)
108 int n = hw_ep_bit(num, dir);
111 /* flush any pending transfer */
112 hw_write(ci, OP_ENDPTFLUSH, BIT(n), BIT(n));
113 while (hw_read(ci, OP_ENDPTFLUSH, BIT(n)))
115 } while (hw_read(ci, OP_ENDPTSTAT, BIT(n)));
121 * hw_ep_disable: disables endpoint (execute without interruption)
122 * @num: endpoint number
123 * @dir: endpoint direction
125 * This function returns an error code
127 static int hw_ep_disable(struct ci13xxx *ci, int num, int dir)
129 hw_ep_flush(ci, num, dir);
130 hw_write(ci, OP_ENDPTCTRL + num,
131 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
136 * hw_ep_enable: enables endpoint (execute without interruption)
137 * @num: endpoint number
138 * @dir: endpoint direction
139 * @type: endpoint type
141 * This function returns an error code
143 static int hw_ep_enable(struct ci13xxx *ci, int num, int dir, int type)
148 mask = ENDPTCTRL_TXT; /* type */
149 data = type << ffs_nr(mask);
151 mask |= ENDPTCTRL_TXS; /* unstall */
152 mask |= ENDPTCTRL_TXR; /* reset data toggle */
153 data |= ENDPTCTRL_TXR;
154 mask |= ENDPTCTRL_TXE; /* enable */
155 data |= ENDPTCTRL_TXE;
157 mask = ENDPTCTRL_RXT; /* type */
158 data = type << ffs_nr(mask);
160 mask |= ENDPTCTRL_RXS; /* unstall */
161 mask |= ENDPTCTRL_RXR; /* reset data toggle */
162 data |= ENDPTCTRL_RXR;
163 mask |= ENDPTCTRL_RXE; /* enable */
164 data |= ENDPTCTRL_RXE;
166 hw_write(ci, OP_ENDPTCTRL + num, mask, data);
171 * hw_ep_get_halt: return endpoint halt status
172 * @num: endpoint number
173 * @dir: endpoint direction
175 * This function returns 1 if endpoint halted
177 static int hw_ep_get_halt(struct ci13xxx *ci, int num, int dir)
179 u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
181 return hw_read(ci, OP_ENDPTCTRL + num, mask) ? 1 : 0;
185 * hw_test_and_clear_setup_status: test & clear setup status (execute without
187 * @n: endpoint number
189 * This function returns setup status
191 static int hw_test_and_clear_setup_status(struct ci13xxx *ci, int n)
193 n = ep_to_bit(ci, n);
194 return hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(n));
198 * hw_ep_prime: primes endpoint (execute without interruption)
199 * @num: endpoint number
200 * @dir: endpoint direction
201 * @is_ctrl: true if control endpoint
203 * This function returns an error code
205 static int hw_ep_prime(struct ci13xxx *ci, int num, int dir, int is_ctrl)
207 int n = hw_ep_bit(num, dir);
209 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
212 hw_write(ci, OP_ENDPTPRIME, BIT(n), BIT(n));
214 while (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
216 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
219 /* status shoult be tested according with manual but it doesn't work */
224 * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
225 * without interruption)
226 * @num: endpoint number
227 * @dir: endpoint direction
228 * @value: true => stall, false => unstall
230 * This function returns an error code
232 static int hw_ep_set_halt(struct ci13xxx *ci, int num, int dir, int value)
234 if (value != 0 && value != 1)
238 enum ci13xxx_regs reg = OP_ENDPTCTRL + num;
239 u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
240 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
242 /* data toggle - reserved for EP0 but it's in ESS */
243 hw_write(ci, reg, mask_xs|mask_xr,
244 value ? mask_xs : mask_xr);
245 } while (value != hw_ep_get_halt(ci, num, dir));
251 * hw_is_port_high_speed: test if port is high speed
253 * This function returns true if high speed port
255 static int hw_port_is_high_speed(struct ci13xxx *ci)
257 return ci->hw_bank.lpm ? hw_read(ci, OP_DEVLC, DEVLC_PSPD) :
258 hw_read(ci, OP_PORTSC, PORTSC_HSP);
262 * hw_read_intr_enable: returns interrupt enable register
264 * This function returns register data
266 static u32 hw_read_intr_enable(struct ci13xxx *ci)
268 return hw_read(ci, OP_USBINTR, ~0);
272 * hw_read_intr_status: returns interrupt status register
274 * This function returns register data
276 static u32 hw_read_intr_status(struct ci13xxx *ci)
278 return hw_read(ci, OP_USBSTS, ~0);
282 * hw_test_and_clear_complete: test & clear complete status (execute without
284 * @n: endpoint number
286 * This function returns complete status
288 static int hw_test_and_clear_complete(struct ci13xxx *ci, int n)
290 n = ep_to_bit(ci, n);
291 return hw_test_and_clear(ci, OP_ENDPTCOMPLETE, BIT(n));
295 * hw_test_and_clear_intr_active: test & clear active interrupts (execute
296 * without interruption)
298 * This function returns active interrutps
300 static u32 hw_test_and_clear_intr_active(struct ci13xxx *ci)
302 u32 reg = hw_read_intr_status(ci) & hw_read_intr_enable(ci);
304 hw_write(ci, OP_USBSTS, ~0, reg);
309 * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
312 * This function returns guard value
314 static int hw_test_and_clear_setup_guard(struct ci13xxx *ci)
316 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, 0);
320 * hw_test_and_set_setup_guard: test & set setup guard (execute without
323 * This function returns guard value
325 static int hw_test_and_set_setup_guard(struct ci13xxx *ci)
327 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
331 * hw_usb_set_address: configures USB address (execute without interruption)
332 * @value: new USB address
334 * This function explicitly sets the address, without the "USBADRA" (advance)
335 * feature, which is not supported by older versions of the controller.
337 static void hw_usb_set_address(struct ci13xxx *ci, u8 value)
339 hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
340 value << ffs_nr(DEVICEADDR_USBADR));
344 * hw_usb_reset: restart device after a bus reset (execute without
347 * This function returns an error code
349 static int hw_usb_reset(struct ci13xxx *ci)
351 hw_usb_set_address(ci, 0);
353 /* ESS flushes only at end?!? */
354 hw_write(ci, OP_ENDPTFLUSH, ~0, ~0);
356 /* clear setup token semaphores */
357 hw_write(ci, OP_ENDPTSETUPSTAT, 0, 0);
359 /* clear complete status */
360 hw_write(ci, OP_ENDPTCOMPLETE, 0, 0);
362 /* wait until all bits cleared */
363 while (hw_read(ci, OP_ENDPTPRIME, ~0))
364 udelay(10); /* not RTOS friendly */
366 /* reset all endpoints ? */
368 /* reset internal status and wait for further instructions
369 no need to verify the port reset status (ESS does it) */
374 /******************************************************************************
376 *****************************************************************************/
378 * _usb_addr: calculates endpoint address from direction & number
381 static inline u8 _usb_addr(struct ci13xxx_ep *ep)
383 return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
387 * _hardware_queue: configures a request at hardware level
391 * This function returns an error code
393 static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
395 struct ci13xxx *ci = mEp->ci;
398 unsigned length = mReq->req.length;
400 /* don't queue twice */
401 if (mReq->req.status == -EALREADY)
404 mReq->req.status = -EALREADY;
406 if (mReq->req.zero && length && (length % mEp->ep.maxpacket == 0)) {
407 mReq->zptr = dma_pool_alloc(mEp->td_pool, GFP_ATOMIC,
409 if (mReq->zptr == NULL)
412 memset(mReq->zptr, 0, sizeof(*mReq->zptr));
413 mReq->zptr->next = TD_TERMINATE;
414 mReq->zptr->token = TD_STATUS_ACTIVE;
415 if (!mReq->req.no_interrupt)
416 mReq->zptr->token |= TD_IOC;
418 ret = usb_gadget_map_request(&ci->gadget, &mReq->req, mEp->dir);
424 * TODO - handle requests which spawns into several TDs
426 memset(mReq->ptr, 0, sizeof(*mReq->ptr));
427 mReq->ptr->token = length << ffs_nr(TD_TOTAL_BYTES);
428 mReq->ptr->token &= TD_TOTAL_BYTES;
429 mReq->ptr->token |= TD_STATUS_ACTIVE;
431 mReq->ptr->next = mReq->zdma;
433 mReq->ptr->next = TD_TERMINATE;
434 if (!mReq->req.no_interrupt)
435 mReq->ptr->token |= TD_IOC;
437 mReq->ptr->page[0] = mReq->req.dma;
438 for (i = 1; i < 5; i++)
440 (mReq->req.dma + i * CI13XXX_PAGE_SIZE) & ~TD_RESERVED_MASK;
442 if (!list_empty(&mEp->qh.queue)) {
443 struct ci13xxx_req *mReqPrev;
444 int n = hw_ep_bit(mEp->num, mEp->dir);
447 mReqPrev = list_entry(mEp->qh.queue.prev,
448 struct ci13xxx_req, queue);
450 mReqPrev->zptr->next = mReq->dma & TD_ADDR_MASK;
452 mReqPrev->ptr->next = mReq->dma & TD_ADDR_MASK;
454 if (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
457 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
458 tmp_stat = hw_read(ci, OP_ENDPTSTAT, BIT(n));
459 } while (!hw_read(ci, OP_USBCMD, USBCMD_ATDTW));
460 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, 0);
465 /* QH configuration */
466 mEp->qh.ptr->td.next = mReq->dma; /* TERMINATE = 0 */
467 mEp->qh.ptr->td.token &= ~TD_STATUS; /* clear status */
468 mEp->qh.ptr->cap |= QH_ZLT;
470 wmb(); /* synchronize before ep prime */
472 ret = hw_ep_prime(ci, mEp->num, mEp->dir,
473 mEp->type == USB_ENDPOINT_XFER_CONTROL);
479 * _hardware_dequeue: handles a request at hardware level
483 * This function returns an error code
485 static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
487 if (mReq->req.status != -EALREADY)
490 if ((TD_STATUS_ACTIVE & mReq->ptr->token) != 0)
494 if ((TD_STATUS_ACTIVE & mReq->zptr->token) != 0)
496 dma_pool_free(mEp->td_pool, mReq->zptr, mReq->zdma);
500 mReq->req.status = 0;
502 usb_gadget_unmap_request(&mEp->ci->gadget, &mReq->req, mEp->dir);
504 mReq->req.status = mReq->ptr->token & TD_STATUS;
505 if ((TD_STATUS_HALTED & mReq->req.status) != 0)
506 mReq->req.status = -1;
507 else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
508 mReq->req.status = -1;
509 else if ((TD_STATUS_TR_ERR & mReq->req.status) != 0)
510 mReq->req.status = -1;
512 mReq->req.actual = mReq->ptr->token & TD_TOTAL_BYTES;
513 mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
514 mReq->req.actual = mReq->req.length - mReq->req.actual;
515 mReq->req.actual = mReq->req.status ? 0 : mReq->req.actual;
517 return mReq->req.actual;
521 * _ep_nuke: dequeues all endpoint requests
524 * This function returns an error code
525 * Caller must hold lock
527 static int _ep_nuke(struct ci13xxx_ep *mEp)
528 __releases(mEp->lock)
529 __acquires(mEp->lock)
534 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
536 while (!list_empty(&mEp->qh.queue)) {
538 /* pop oldest request */
539 struct ci13xxx_req *mReq = \
540 list_entry(mEp->qh.queue.next,
541 struct ci13xxx_req, queue);
542 list_del_init(&mReq->queue);
543 mReq->req.status = -ESHUTDOWN;
545 if (mReq->req.complete != NULL) {
546 spin_unlock(mEp->lock);
547 mReq->req.complete(&mEp->ep, &mReq->req);
548 spin_lock(mEp->lock);
555 * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
558 * This function returns an error code
560 static int _gadget_stop_activity(struct usb_gadget *gadget)
563 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
566 spin_lock_irqsave(&ci->lock, flags);
567 ci->gadget.speed = USB_SPEED_UNKNOWN;
568 ci->remote_wakeup = 0;
570 spin_unlock_irqrestore(&ci->lock, flags);
572 /* flush all endpoints */
573 gadget_for_each_ep(ep, gadget) {
574 usb_ep_fifo_flush(ep);
576 usb_ep_fifo_flush(&ci->ep0out->ep);
577 usb_ep_fifo_flush(&ci->ep0in->ep);
580 ci->driver->disconnect(gadget);
582 /* make sure to disable all endpoints */
583 gadget_for_each_ep(ep, gadget) {
587 if (ci->status != NULL) {
588 usb_ep_free_request(&ci->ep0in->ep, ci->status);
595 /******************************************************************************
597 *****************************************************************************/
599 * isr_reset_handler: USB reset interrupt handler
602 * This function resets USB engine after a bus reset occurred
604 static void isr_reset_handler(struct ci13xxx *ci)
610 dbg_event(0xFF, "BUS RST", 0);
612 spin_unlock(&ci->lock);
613 retval = _gadget_stop_activity(&ci->gadget);
617 retval = hw_usb_reset(ci);
621 ci->status = usb_ep_alloc_request(&ci->ep0in->ep, GFP_ATOMIC);
622 if (ci->status == NULL)
626 spin_lock(&ci->lock);
629 dev_err(ci->dev, "error: %i\n", retval);
633 * isr_get_status_complete: get_status request complete function
635 * @req: request handled
637 * Caller must release lock
639 static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
641 if (ep == NULL || req == NULL)
645 usb_ep_free_request(ep, req);
649 * isr_get_status_response: get_status request response
651 * @setup: setup request packet
653 * This function returns an error code
655 static int isr_get_status_response(struct ci13xxx *ci,
656 struct usb_ctrlrequest *setup)
657 __releases(mEp->lock)
658 __acquires(mEp->lock)
660 struct ci13xxx_ep *mEp = ci->ep0in;
661 struct usb_request *req = NULL;
662 gfp_t gfp_flags = GFP_ATOMIC;
663 int dir, num, retval;
665 if (mEp == NULL || setup == NULL)
668 spin_unlock(mEp->lock);
669 req = usb_ep_alloc_request(&mEp->ep, gfp_flags);
670 spin_lock(mEp->lock);
674 req->complete = isr_get_status_complete;
676 req->buf = kzalloc(req->length, gfp_flags);
677 if (req->buf == NULL) {
682 if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
683 /* Assume that device is bus powered for now. */
684 *(u16 *)req->buf = ci->remote_wakeup << 1;
686 } else if ((setup->bRequestType & USB_RECIP_MASK) \
687 == USB_RECIP_ENDPOINT) {
688 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
690 num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
691 *(u16 *)req->buf = hw_ep_get_halt(ci, num, dir);
693 /* else do nothing; reserved for future use */
695 spin_unlock(mEp->lock);
696 retval = usb_ep_queue(&mEp->ep, req, gfp_flags);
697 spin_lock(mEp->lock);
706 spin_unlock(mEp->lock);
707 usb_ep_free_request(&mEp->ep, req);
708 spin_lock(mEp->lock);
713 * isr_setup_status_complete: setup_status request complete function
715 * @req: request handled
717 * Caller must release lock. Put the port in test mode if test mode
718 * feature is selected.
721 isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
723 struct ci13xxx *ci = req->context;
727 hw_usb_set_address(ci, ci->address);
731 spin_lock_irqsave(&ci->lock, flags);
733 hw_port_test_set(ci, ci->test_mode);
734 spin_unlock_irqrestore(&ci->lock, flags);
738 * isr_setup_status_phase: queues the status phase of a setup transation
741 * This function returns an error code
743 static int isr_setup_status_phase(struct ci13xxx *ci)
744 __releases(mEp->lock)
745 __acquires(mEp->lock)
748 struct ci13xxx_ep *mEp;
750 mEp = (ci->ep0_dir == TX) ? ci->ep0out : ci->ep0in;
751 ci->status->context = ci;
752 ci->status->complete = isr_setup_status_complete;
754 spin_unlock(mEp->lock);
755 retval = usb_ep_queue(&mEp->ep, ci->status, GFP_ATOMIC);
756 spin_lock(mEp->lock);
762 * isr_tr_complete_low: transaction complete low level handler
765 * This function returns an error code
766 * Caller must hold lock
768 static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
769 __releases(mEp->lock)
770 __acquires(mEp->lock)
772 struct ci13xxx_req *mReq, *mReqTemp;
773 struct ci13xxx_ep *mEpTemp = mEp;
774 int uninitialized_var(retval);
776 if (list_empty(&mEp->qh.queue))
779 list_for_each_entry_safe(mReq, mReqTemp, &mEp->qh.queue,
781 retval = _hardware_dequeue(mEp, mReq);
784 list_del_init(&mReq->queue);
785 dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
786 if (mReq->req.complete != NULL) {
787 spin_unlock(mEp->lock);
788 if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) &&
790 mEpTemp = mEp->ci->ep0in;
791 mReq->req.complete(&mEpTemp->ep, &mReq->req);
792 spin_lock(mEp->lock);
796 if (retval == -EBUSY)
799 dbg_event(_usb_addr(mEp), "DONE", retval);
805 * isr_tr_complete_handler: transaction complete interrupt handler
806 * @ci: UDC descriptor
808 * This function handles traffic events
810 static void isr_tr_complete_handler(struct ci13xxx *ci)
817 for (i = 0; i < ci->hw_ep_max; i++) {
818 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
819 int type, num, dir, err = -EINVAL;
820 struct usb_ctrlrequest req;
822 if (mEp->ep.desc == NULL)
823 continue; /* not configured */
825 if (hw_test_and_clear_complete(ci, i)) {
826 err = isr_tr_complete_low(mEp);
827 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
828 if (err > 0) /* needs status phase */
829 err = isr_setup_status_phase(ci);
831 dbg_event(_usb_addr(mEp),
833 spin_unlock(&ci->lock);
834 if (usb_ep_set_halt(&mEp->ep))
836 "error: ep_set_halt\n");
837 spin_lock(&ci->lock);
842 if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
843 !hw_test_and_clear_setup_status(ci, i))
847 dev_warn(ci->dev, "ctrl traffic at endpoint %d\n", i);
852 * Flush data and handshake transactions of previous
855 _ep_nuke(ci->ep0out);
858 /* read_setup_packet */
860 hw_test_and_set_setup_guard(ci);
861 memcpy(&req, &mEp->qh.ptr->setup, sizeof(req));
862 } while (!hw_test_and_clear_setup_guard(ci));
864 type = req.bRequestType;
866 ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
868 dbg_setup(_usb_addr(mEp), &req);
870 switch (req.bRequest) {
871 case USB_REQ_CLEAR_FEATURE:
872 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
873 le16_to_cpu(req.wValue) ==
875 if (req.wLength != 0)
877 num = le16_to_cpu(req.wIndex);
878 dir = num & USB_ENDPOINT_DIR_MASK;
879 num &= USB_ENDPOINT_NUMBER_MASK;
881 num += ci->hw_ep_max/2;
882 if (!ci->ci13xxx_ep[num].wedge) {
883 spin_unlock(&ci->lock);
884 err = usb_ep_clear_halt(
885 &ci->ci13xxx_ep[num].ep);
886 spin_lock(&ci->lock);
890 err = isr_setup_status_phase(ci);
891 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
892 le16_to_cpu(req.wValue) ==
893 USB_DEVICE_REMOTE_WAKEUP) {
894 if (req.wLength != 0)
896 ci->remote_wakeup = 0;
897 err = isr_setup_status_phase(ci);
902 case USB_REQ_GET_STATUS:
903 if (type != (USB_DIR_IN|USB_RECIP_DEVICE) &&
904 type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
905 type != (USB_DIR_IN|USB_RECIP_INTERFACE))
907 if (le16_to_cpu(req.wLength) != 2 ||
908 le16_to_cpu(req.wValue) != 0)
910 err = isr_get_status_response(ci, &req);
912 case USB_REQ_SET_ADDRESS:
913 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
915 if (le16_to_cpu(req.wLength) != 0 ||
916 le16_to_cpu(req.wIndex) != 0)
918 ci->address = (u8)le16_to_cpu(req.wValue);
920 err = isr_setup_status_phase(ci);
922 case USB_REQ_SET_FEATURE:
923 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
924 le16_to_cpu(req.wValue) ==
926 if (req.wLength != 0)
928 num = le16_to_cpu(req.wIndex);
929 dir = num & USB_ENDPOINT_DIR_MASK;
930 num &= USB_ENDPOINT_NUMBER_MASK;
932 num += ci->hw_ep_max/2;
934 spin_unlock(&ci->lock);
935 err = usb_ep_set_halt(&ci->ci13xxx_ep[num].ep);
936 spin_lock(&ci->lock);
938 isr_setup_status_phase(ci);
939 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
940 if (req.wLength != 0)
942 switch (le16_to_cpu(req.wValue)) {
943 case USB_DEVICE_REMOTE_WAKEUP:
944 ci->remote_wakeup = 1;
945 err = isr_setup_status_phase(ci);
947 case USB_DEVICE_TEST_MODE:
948 tmode = le16_to_cpu(req.wIndex) >> 8;
955 ci->test_mode = tmode;
956 err = isr_setup_status_phase(
971 if (req.wLength == 0) /* no data phase */
974 spin_unlock(&ci->lock);
975 err = ci->driver->setup(&ci->gadget, &req);
976 spin_lock(&ci->lock);
981 dbg_event(_usb_addr(mEp), "ERROR", err);
983 spin_unlock(&ci->lock);
984 if (usb_ep_set_halt(&mEp->ep))
985 dev_err(ci->dev, "error: ep_set_halt\n");
986 spin_lock(&ci->lock);
991 /******************************************************************************
993 *****************************************************************************/
995 * ep_enable: configure endpoint, making it usable
997 * Check usb_ep_enable() at "usb_gadget.h" for details
999 static int ep_enable(struct usb_ep *ep,
1000 const struct usb_endpoint_descriptor *desc)
1002 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1004 unsigned long flags;
1006 if (ep == NULL || desc == NULL)
1009 spin_lock_irqsave(mEp->lock, flags);
1011 /* only internal SW should enable ctrl endpts */
1013 mEp->ep.desc = desc;
1015 if (!list_empty(&mEp->qh.queue))
1016 dev_warn(mEp->ci->dev, "enabling a non-empty endpoint!\n");
1018 mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX;
1019 mEp->num = usb_endpoint_num(desc);
1020 mEp->type = usb_endpoint_type(desc);
1022 mEp->ep.maxpacket = usb_endpoint_maxp(desc);
1024 dbg_event(_usb_addr(mEp), "ENABLE", 0);
1026 mEp->qh.ptr->cap = 0;
1028 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1029 mEp->qh.ptr->cap |= QH_IOS;
1030 else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
1031 mEp->qh.ptr->cap &= ~QH_MULT;
1033 mEp->qh.ptr->cap &= ~QH_ZLT;
1036 (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
1037 mEp->qh.ptr->td.next |= TD_TERMINATE; /* needed? */
1040 * Enable endpoints in the HW other than ep0 as ep0
1044 retval |= hw_ep_enable(mEp->ci, mEp->num, mEp->dir, mEp->type);
1046 spin_unlock_irqrestore(mEp->lock, flags);
1051 * ep_disable: endpoint is no longer usable
1053 * Check usb_ep_disable() at "usb_gadget.h" for details
1055 static int ep_disable(struct usb_ep *ep)
1057 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1058 int direction, retval = 0;
1059 unsigned long flags;
1063 else if (mEp->ep.desc == NULL)
1066 spin_lock_irqsave(mEp->lock, flags);
1068 /* only internal SW should disable ctrl endpts */
1070 direction = mEp->dir;
1072 dbg_event(_usb_addr(mEp), "DISABLE", 0);
1074 retval |= _ep_nuke(mEp);
1075 retval |= hw_ep_disable(mEp->ci, mEp->num, mEp->dir);
1077 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1078 mEp->dir = (mEp->dir == TX) ? RX : TX;
1080 } while (mEp->dir != direction);
1082 mEp->ep.desc = NULL;
1084 spin_unlock_irqrestore(mEp->lock, flags);
1089 * ep_alloc_request: allocate a request object to use with this endpoint
1091 * Check usb_ep_alloc_request() at "usb_gadget.h" for details
1093 static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
1095 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1096 struct ci13xxx_req *mReq = NULL;
1101 mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
1103 INIT_LIST_HEAD(&mReq->queue);
1105 mReq->ptr = dma_pool_alloc(mEp->td_pool, gfp_flags,
1107 if (mReq->ptr == NULL) {
1113 dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
1115 return (mReq == NULL) ? NULL : &mReq->req;
1119 * ep_free_request: frees a request object
1121 * Check usb_ep_free_request() at "usb_gadget.h" for details
1123 static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
1125 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1126 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
1127 unsigned long flags;
1129 if (ep == NULL || req == NULL) {
1131 } else if (!list_empty(&mReq->queue)) {
1132 dev_err(mEp->ci->dev, "freeing queued request\n");
1136 spin_lock_irqsave(mEp->lock, flags);
1139 dma_pool_free(mEp->td_pool, mReq->ptr, mReq->dma);
1142 dbg_event(_usb_addr(mEp), "FREE", 0);
1144 spin_unlock_irqrestore(mEp->lock, flags);
1148 * ep_queue: queues (submits) an I/O request to an endpoint
1150 * Check usb_ep_queue()* at usb_gadget.h" for details
1152 static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1153 gfp_t __maybe_unused gfp_flags)
1155 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1156 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
1157 struct ci13xxx *ci = mEp->ci;
1159 unsigned long flags;
1161 if (ep == NULL || req == NULL || mEp->ep.desc == NULL)
1164 spin_lock_irqsave(mEp->lock, flags);
1166 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
1168 mEp = (ci->ep0_dir == RX) ?
1169 ci->ep0out : ci->ep0in;
1170 if (!list_empty(&mEp->qh.queue)) {
1172 retval = -EOVERFLOW;
1173 dev_warn(mEp->ci->dev, "endpoint ctrl %X nuked\n",
1178 /* first nuke then test link, e.g. previous status has not sent */
1179 if (!list_empty(&mReq->queue)) {
1181 dev_err(mEp->ci->dev, "request already in queue\n");
1185 if (req->length > 4 * CI13XXX_PAGE_SIZE) {
1186 req->length = 4 * CI13XXX_PAGE_SIZE;
1188 dev_warn(mEp->ci->dev, "request length truncated\n");
1191 dbg_queue(_usb_addr(mEp), req, retval);
1194 mReq->req.status = -EINPROGRESS;
1195 mReq->req.actual = 0;
1197 retval = _hardware_enqueue(mEp, mReq);
1199 if (retval == -EALREADY) {
1200 dbg_event(_usb_addr(mEp), "QUEUE", retval);
1204 list_add_tail(&mReq->queue, &mEp->qh.queue);
1207 spin_unlock_irqrestore(mEp->lock, flags);
1212 * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
1214 * Check usb_ep_dequeue() at "usb_gadget.h" for details
1216 static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
1218 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1219 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
1220 unsigned long flags;
1222 if (ep == NULL || req == NULL || mReq->req.status != -EALREADY ||
1223 mEp->ep.desc == NULL || list_empty(&mReq->queue) ||
1224 list_empty(&mEp->qh.queue))
1227 spin_lock_irqsave(mEp->lock, flags);
1229 dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
1231 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
1234 list_del_init(&mReq->queue);
1236 usb_gadget_unmap_request(&mEp->ci->gadget, req, mEp->dir);
1238 req->status = -ECONNRESET;
1240 if (mReq->req.complete != NULL) {
1241 spin_unlock(mEp->lock);
1242 mReq->req.complete(&mEp->ep, &mReq->req);
1243 spin_lock(mEp->lock);
1246 spin_unlock_irqrestore(mEp->lock, flags);
1251 * ep_set_halt: sets the endpoint halt feature
1253 * Check usb_ep_set_halt() at "usb_gadget.h" for details
1255 static int ep_set_halt(struct usb_ep *ep, int value)
1257 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1258 int direction, retval = 0;
1259 unsigned long flags;
1261 if (ep == NULL || mEp->ep.desc == NULL)
1264 spin_lock_irqsave(mEp->lock, flags);
1267 /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
1268 if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
1269 !list_empty(&mEp->qh.queue)) {
1270 spin_unlock_irqrestore(mEp->lock, flags);
1275 direction = mEp->dir;
1277 dbg_event(_usb_addr(mEp), "HALT", value);
1278 retval |= hw_ep_set_halt(mEp->ci, mEp->num, mEp->dir, value);
1283 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1284 mEp->dir = (mEp->dir == TX) ? RX : TX;
1286 } while (mEp->dir != direction);
1288 spin_unlock_irqrestore(mEp->lock, flags);
1293 * ep_set_wedge: sets the halt feature and ignores clear requests
1295 * Check usb_ep_set_wedge() at "usb_gadget.h" for details
1297 static int ep_set_wedge(struct usb_ep *ep)
1299 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1300 unsigned long flags;
1302 if (ep == NULL || mEp->ep.desc == NULL)
1305 spin_lock_irqsave(mEp->lock, flags);
1307 dbg_event(_usb_addr(mEp), "WEDGE", 0);
1310 spin_unlock_irqrestore(mEp->lock, flags);
1312 return usb_ep_set_halt(ep);
1316 * ep_fifo_flush: flushes contents of a fifo
1318 * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
1320 static void ep_fifo_flush(struct usb_ep *ep)
1322 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1323 unsigned long flags;
1326 dev_err(mEp->ci->dev, "%02X: -EINVAL\n", _usb_addr(mEp));
1330 spin_lock_irqsave(mEp->lock, flags);
1332 dbg_event(_usb_addr(mEp), "FFLUSH", 0);
1333 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
1335 spin_unlock_irqrestore(mEp->lock, flags);
1339 * Endpoint-specific part of the API to the USB controller hardware
1340 * Check "usb_gadget.h" for details
1342 static const struct usb_ep_ops usb_ep_ops = {
1343 .enable = ep_enable,
1344 .disable = ep_disable,
1345 .alloc_request = ep_alloc_request,
1346 .free_request = ep_free_request,
1348 .dequeue = ep_dequeue,
1349 .set_halt = ep_set_halt,
1350 .set_wedge = ep_set_wedge,
1351 .fifo_flush = ep_fifo_flush,
1354 /******************************************************************************
1356 *****************************************************************************/
1357 static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
1359 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1360 unsigned long flags;
1361 int gadget_ready = 0;
1363 if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS))
1366 spin_lock_irqsave(&ci->lock, flags);
1367 ci->vbus_active = is_active;
1370 spin_unlock_irqrestore(&ci->lock, flags);
1374 pm_runtime_get_sync(&_gadget->dev);
1375 hw_device_reset(ci, USBMODE_CM_DC);
1376 hw_device_state(ci, ci->ep0out->qh.dma);
1378 hw_device_state(ci, 0);
1379 if (ci->platdata->notify_event)
1380 ci->platdata->notify_event(ci,
1381 CI13XXX_CONTROLLER_STOPPED_EVENT);
1382 _gadget_stop_activity(&ci->gadget);
1383 pm_runtime_put_sync(&_gadget->dev);
1390 static int ci13xxx_wakeup(struct usb_gadget *_gadget)
1392 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1393 unsigned long flags;
1396 spin_lock_irqsave(&ci->lock, flags);
1397 if (!ci->remote_wakeup) {
1401 if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
1405 hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
1407 spin_unlock_irqrestore(&ci->lock, flags);
1411 static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
1413 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1415 if (ci->transceiver)
1416 return usb_phy_set_power(ci->transceiver, mA);
1420 /* Change Data+ pullup status
1421 * this func is used by usb_gadget_connect/disconnet
1423 static int ci13xxx_pullup(struct usb_gadget *_gadget, int is_on)
1425 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1428 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
1430 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
1435 static int ci13xxx_start(struct usb_gadget *gadget,
1436 struct usb_gadget_driver *driver);
1437 static int ci13xxx_stop(struct usb_gadget *gadget,
1438 struct usb_gadget_driver *driver);
1440 * Device operations part of the API to the USB controller hardware,
1441 * which don't involve endpoints (or i/o)
1442 * Check "usb_gadget.h" for details
1444 static const struct usb_gadget_ops usb_gadget_ops = {
1445 .vbus_session = ci13xxx_vbus_session,
1446 .wakeup = ci13xxx_wakeup,
1447 .pullup = ci13xxx_pullup,
1448 .vbus_draw = ci13xxx_vbus_draw,
1449 .udc_start = ci13xxx_start,
1450 .udc_stop = ci13xxx_stop,
1453 static int init_eps(struct ci13xxx *ci)
1455 int retval = 0, i, j;
1457 for (i = 0; i < ci->hw_ep_max/2; i++)
1458 for (j = RX; j <= TX; j++) {
1459 int k = i + j * ci->hw_ep_max/2;
1460 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[k];
1462 scnprintf(mEp->name, sizeof(mEp->name), "ep%i%s", i,
1463 (j == TX) ? "in" : "out");
1466 mEp->lock = &ci->lock;
1467 mEp->td_pool = ci->td_pool;
1469 mEp->ep.name = mEp->name;
1470 mEp->ep.ops = &usb_ep_ops;
1472 * for ep0: maxP defined in desc, for other
1473 * eps, maxP is set by epautoconfig() called
1476 mEp->ep.maxpacket = (unsigned short)~0;
1478 INIT_LIST_HEAD(&mEp->qh.queue);
1479 mEp->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
1481 if (mEp->qh.ptr == NULL)
1484 memset(mEp->qh.ptr, 0, sizeof(*mEp->qh.ptr));
1487 * set up shorthands for ep0 out and in endpoints,
1488 * don't add to gadget's ep_list
1496 mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
1500 list_add_tail(&mEp->ep.ep_list, &ci->gadget.ep_list);
1507 * ci13xxx_start: register a gadget driver
1508 * @gadget: our gadget
1509 * @driver: the driver being registered
1511 * Interrupts are enabled here.
1513 static int ci13xxx_start(struct usb_gadget *gadget,
1514 struct usb_gadget_driver *driver)
1516 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
1517 unsigned long flags;
1518 int retval = -ENOMEM;
1520 if (driver->disconnect == NULL)
1524 ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
1525 retval = usb_ep_enable(&ci->ep0out->ep);
1529 ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
1530 retval = usb_ep_enable(&ci->ep0in->ep);
1533 spin_lock_irqsave(&ci->lock, flags);
1535 ci->driver = driver;
1536 pm_runtime_get_sync(&ci->gadget.dev);
1537 if (ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) {
1538 if (ci->vbus_active) {
1539 if (ci->platdata->flags & CI13XXX_REGS_SHARED)
1540 hw_device_reset(ci, USBMODE_CM_DC);
1542 pm_runtime_put_sync(&ci->gadget.dev);
1547 retval = hw_device_state(ci, ci->ep0out->qh.dma);
1549 pm_runtime_put_sync(&ci->gadget.dev);
1552 spin_unlock_irqrestore(&ci->lock, flags);
1557 * ci13xxx_stop: unregister a gadget driver
1559 static int ci13xxx_stop(struct usb_gadget *gadget,
1560 struct usb_gadget_driver *driver)
1562 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
1563 unsigned long flags;
1565 spin_lock_irqsave(&ci->lock, flags);
1567 if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) ||
1569 hw_device_state(ci, 0);
1570 if (ci->platdata->notify_event)
1571 ci->platdata->notify_event(ci,
1572 CI13XXX_CONTROLLER_STOPPED_EVENT);
1574 spin_unlock_irqrestore(&ci->lock, flags);
1575 _gadget_stop_activity(&ci->gadget);
1576 spin_lock_irqsave(&ci->lock, flags);
1577 pm_runtime_put(&ci->gadget.dev);
1580 spin_unlock_irqrestore(&ci->lock, flags);
1585 /******************************************************************************
1587 *****************************************************************************/
1589 * udc_irq: ci interrupt handler
1591 * This function returns IRQ_HANDLED if the IRQ has been handled
1592 * It locks access to registers
1594 static irqreturn_t udc_irq(struct ci13xxx *ci)
1602 spin_lock(&ci->lock);
1604 if (ci->platdata->flags & CI13XXX_REGS_SHARED) {
1605 if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
1607 spin_unlock(&ci->lock);
1611 intr = hw_test_and_clear_intr_active(ci);
1612 dbg_interrupt(intr);
1615 /* order defines priority - do NOT change it */
1616 if (USBi_URI & intr)
1617 isr_reset_handler(ci);
1619 if (USBi_PCI & intr) {
1620 ci->gadget.speed = hw_port_is_high_speed(ci) ?
1621 USB_SPEED_HIGH : USB_SPEED_FULL;
1622 if (ci->suspended && ci->driver->resume) {
1623 spin_unlock(&ci->lock);
1624 ci->driver->resume(&ci->gadget);
1625 spin_lock(&ci->lock);
1631 isr_tr_complete_handler(ci);
1633 if (USBi_SLI & intr) {
1634 if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
1635 ci->driver->suspend) {
1637 spin_unlock(&ci->lock);
1638 ci->driver->suspend(&ci->gadget);
1639 spin_lock(&ci->lock);
1642 retval = IRQ_HANDLED;
1646 spin_unlock(&ci->lock);
1652 * udc_release: driver release function
1655 * Currently does nothing
1657 static void udc_release(struct device *dev)
1662 * udc_start: initialize gadget role
1663 * @ci: chipidea controller
1665 static int udc_start(struct ci13xxx *ci)
1667 struct device *dev = ci->dev;
1670 spin_lock_init(&ci->lock);
1672 ci->gadget.ops = &usb_gadget_ops;
1673 ci->gadget.speed = USB_SPEED_UNKNOWN;
1674 ci->gadget.max_speed = USB_SPEED_HIGH;
1675 ci->gadget.is_otg = 0;
1676 ci->gadget.name = ci->platdata->name;
1678 INIT_LIST_HEAD(&ci->gadget.ep_list);
1680 dev_set_name(&ci->gadget.dev, "gadget");
1681 ci->gadget.dev.dma_mask = dev->dma_mask;
1682 ci->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
1683 ci->gadget.dev.parent = dev;
1684 ci->gadget.dev.release = udc_release;
1686 /* alloc resources */
1687 ci->qh_pool = dma_pool_create("ci13xxx_qh", dev,
1688 sizeof(struct ci13xxx_qh),
1689 64, CI13XXX_PAGE_SIZE);
1690 if (ci->qh_pool == NULL)
1693 ci->td_pool = dma_pool_create("ci13xxx_td", dev,
1694 sizeof(struct ci13xxx_td),
1695 64, CI13XXX_PAGE_SIZE);
1696 if (ci->td_pool == NULL) {
1701 retval = init_eps(ci);
1705 ci->gadget.ep0 = &ci->ep0in->ep;
1708 ci->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
1710 if (ci->platdata->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
1711 if (ci->transceiver == NULL) {
1717 if (!(ci->platdata->flags & CI13XXX_REGS_SHARED)) {
1718 retval = hw_device_reset(ci, USBMODE_CM_DC);
1720 goto put_transceiver;
1723 retval = device_register(&ci->gadget.dev);
1725 put_device(&ci->gadget.dev);
1726 goto put_transceiver;
1729 retval = dbg_create_files(&ci->gadget.dev);
1733 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1734 retval = otg_set_peripheral(ci->transceiver->otg,
1740 retval = usb_add_gadget_udc(dev, &ci->gadget);
1744 pm_runtime_no_callbacks(&ci->gadget.dev);
1745 pm_runtime_enable(&ci->gadget.dev);
1750 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1751 otg_set_peripheral(ci->transceiver->otg, NULL);
1753 usb_put_phy(ci->transceiver);
1756 dev_err(dev, "error = %i\n", retval);
1758 dbg_remove_files(&ci->gadget.dev);
1760 device_unregister(&ci->gadget.dev);
1762 if (!IS_ERR_OR_NULL(ci->transceiver) && ci->global_phy)
1763 usb_put_phy(ci->transceiver);
1765 dma_pool_destroy(ci->td_pool);
1767 dma_pool_destroy(ci->qh_pool);
1772 * udc_remove: parent remove must call this to remove UDC
1774 * No interrupts active, the IRQ has been released
1776 static void udc_stop(struct ci13xxx *ci)
1783 usb_del_gadget_udc(&ci->gadget);
1785 for (i = 0; i < ci->hw_ep_max; i++) {
1786 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
1788 dma_pool_free(ci->qh_pool, mEp->qh.ptr, mEp->qh.dma);
1791 dma_pool_destroy(ci->td_pool);
1792 dma_pool_destroy(ci->qh_pool);
1794 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1795 otg_set_peripheral(ci->transceiver->otg, NULL);
1797 usb_put_phy(ci->transceiver);
1799 dbg_remove_files(&ci->gadget.dev);
1800 device_unregister(&ci->gadget.dev);
1801 /* my kobject is dynamic, I swear! */
1802 memset(&ci->gadget, 0, sizeof(ci->gadget));
1806 * ci_hdrc_gadget_init - initialize device related bits
1807 * ci: the controller
1809 * This function enables the gadget role, if the device is "device capable".
1811 int ci_hdrc_gadget_init(struct ci13xxx *ci)
1813 struct ci_role_driver *rdrv;
1815 if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DC))
1818 rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL);
1822 rdrv->start = udc_start;
1823 rdrv->stop = udc_stop;
1824 rdrv->irq = udc_irq;
1825 rdrv->name = "gadget";
1826 ci->roles[CI_ROLE_GADGET] = rdrv;