source: src/linux/universal/linux-3.18/drivers/usb/chipidea/udc.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 45.3 KB
Line 
1/*
2 * udc.c - ChipIdea UDC driver
3 *
4 * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
5 *
6 * Author: David Lopo
7 *
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.
11 */
12
13#include <linux/delay.h>
14#include <linux/device.h>
15#include <linux/dmapool.h>
16#include <linux/err.h>
17#include <linux/irqreturn.h>
18#include <linux/kernel.h>
19#include <linux/slab.h>
20#include <linux/pm_runtime.h>
21#include <linux/usb/ch9.h>
22#include <linux/usb/gadget.h>
23#include <linux/usb/otg-fsm.h>
24#include <linux/usb/chipidea.h>
25
26#include "ci.h"
27#include "udc.h"
28#include "bits.h"
29#include "debug.h"
30#include "otg.h"
31#include "otg_fsm.h"
32
33/* control endpoint description */
34static const struct usb_endpoint_descriptor
35ctrl_endpt_out_desc = {
36        .bLength         = USB_DT_ENDPOINT_SIZE,
37        .bDescriptorType = USB_DT_ENDPOINT,
38
39        .bEndpointAddress = USB_DIR_OUT,
40        .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
41        .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
42};
43
44static const struct usb_endpoint_descriptor
45ctrl_endpt_in_desc = {
46        .bLength         = USB_DT_ENDPOINT_SIZE,
47        .bDescriptorType = USB_DT_ENDPOINT,
48
49        .bEndpointAddress = USB_DIR_IN,
50        .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
51        .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
52};
53
54/**
55 * hw_ep_bit: calculates the bit number
56 * @num: endpoint number
57 * @dir: endpoint direction
58 *
59 * This function returns bit number
60 */
61static inline int hw_ep_bit(int num, int dir)
62{
63        return num + (dir ? 16 : 0);
64}
65
66static inline int ep_to_bit(struct ci_hdrc *ci, int n)
67{
68        int fill = 16 - ci->hw_ep_max / 2;
69
70        if (n >= ci->hw_ep_max / 2)
71                n += fill;
72
73        return n;
74}
75
76/**
77 * hw_device_state: enables/disables interrupts (execute without interruption)
78 * @dma: 0 => disable, !0 => enable and set dma engine
79 *
80 * This function returns an error code
81 */
82static int hw_device_state(struct ci_hdrc *ci, u32 dma)
83{
84        if (dma) {
85                hw_write(ci, OP_ENDPTLISTADDR, ~0, dma);
86                /* interrupt, error, port change, reset, sleep/suspend */
87                hw_write(ci, OP_USBINTR, ~0,
88                             USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
89                hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
90        } else {
91                hw_write(ci, OP_USBINTR, ~0, 0);
92                hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
93        }
94        return 0;
95}
96
97/**
98 * hw_ep_flush: flush endpoint fifo (execute without interruption)
99 * @num: endpoint number
100 * @dir: endpoint direction
101 *
102 * This function returns an error code
103 */
104static int hw_ep_flush(struct ci_hdrc *ci, int num, int dir)
105{
106        int n = hw_ep_bit(num, dir);
107
108        do {
109                /* flush any pending transfer */
110                hw_write(ci, OP_ENDPTFLUSH, ~0, BIT(n));
111                while (hw_read(ci, OP_ENDPTFLUSH, BIT(n)))
112                        cpu_relax();
113        } while (hw_read(ci, OP_ENDPTSTAT, BIT(n)));
114
115        return 0;
116}
117
118/**
119 * hw_ep_disable: disables endpoint (execute without interruption)
120 * @num: endpoint number
121 * @dir: endpoint direction
122 *
123 * This function returns an error code
124 */
125static int hw_ep_disable(struct ci_hdrc *ci, int num, int dir)
126{
127        hw_ep_flush(ci, num, dir);
128        hw_write(ci, OP_ENDPTCTRL + num,
129                 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
130        return 0;
131}
132
133/**
134 * hw_ep_enable: enables endpoint (execute without interruption)
135 * @num:  endpoint number
136 * @dir:  endpoint direction
137 * @type: endpoint type
138 *
139 * This function returns an error code
140 */
141static int hw_ep_enable(struct ci_hdrc *ci, int num, int dir, int type)
142{
143        u32 mask, data;
144
145        if (dir) {
146                mask  = ENDPTCTRL_TXT;  /* type    */
147                data  = type << __ffs(mask);
148
149                mask |= ENDPTCTRL_TXS;  /* unstall */
150                mask |= ENDPTCTRL_TXR;  /* reset data toggle */
151                data |= ENDPTCTRL_TXR;
152                mask |= ENDPTCTRL_TXE;  /* enable  */
153                data |= ENDPTCTRL_TXE;
154        } else {
155                mask  = ENDPTCTRL_RXT;  /* type    */
156                data  = type << __ffs(mask);
157
158                mask |= ENDPTCTRL_RXS;  /* unstall */
159                mask |= ENDPTCTRL_RXR;  /* reset data toggle */
160                data |= ENDPTCTRL_RXR;
161                mask |= ENDPTCTRL_RXE;  /* enable  */
162                data |= ENDPTCTRL_RXE;
163        }
164        hw_write(ci, OP_ENDPTCTRL + num, mask, data);
165        return 0;
166}
167
168/**
169 * hw_ep_get_halt: return endpoint halt status
170 * @num: endpoint number
171 * @dir: endpoint direction
172 *
173 * This function returns 1 if endpoint halted
174 */
175static int hw_ep_get_halt(struct ci_hdrc *ci, int num, int dir)
176{
177        u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
178
179        return hw_read(ci, OP_ENDPTCTRL + num, mask) ? 1 : 0;
180}
181
182/**
183 * hw_ep_prime: primes endpoint (execute without interruption)
184 * @num:     endpoint number
185 * @dir:     endpoint direction
186 * @is_ctrl: true if control endpoint
187 *
188 * This function returns an error code
189 */
190static int hw_ep_prime(struct ci_hdrc *ci, int num, int dir, int is_ctrl)
191{
192        int n = hw_ep_bit(num, dir);
193
194        if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
195                return -EAGAIN;
196
197        hw_write(ci, OP_ENDPTPRIME, ~0, BIT(n));
198
199        while (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
200                cpu_relax();
201        if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
202                return -EAGAIN;
203
204        /* status shoult be tested according with manual but it doesn't work */
205        return 0;
206}
207
208/**
209 * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
210 *                 without interruption)
211 * @num:   endpoint number
212 * @dir:   endpoint direction
213 * @value: true => stall, false => unstall
214 *
215 * This function returns an error code
216 */
217static int hw_ep_set_halt(struct ci_hdrc *ci, int num, int dir, int value)
218{
219        if (value != 0 && value != 1)
220                return -EINVAL;
221
222        do {
223                enum ci_hw_regs reg = OP_ENDPTCTRL + num;
224                u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
225                u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
226
227                /* data toggle - reserved for EP0 but it's in ESS */
228                hw_write(ci, reg, mask_xs|mask_xr,
229                          value ? mask_xs : mask_xr);
230        } while (value != hw_ep_get_halt(ci, num, dir));
231
232        return 0;
233}
234
235/**
236 * hw_is_port_high_speed: test if port is high speed
237 *
238 * This function returns true if high speed port
239 */
240static int hw_port_is_high_speed(struct ci_hdrc *ci)
241{
242        return ci->hw_bank.lpm ? hw_read(ci, OP_DEVLC, DEVLC_PSPD) :
243                hw_read(ci, OP_PORTSC, PORTSC_HSP);
244}
245
246/**
247 * hw_test_and_clear_complete: test & clear complete status (execute without
248 *                             interruption)
249 * @n: endpoint number
250 *
251 * This function returns complete status
252 */
253static int hw_test_and_clear_complete(struct ci_hdrc *ci, int n)
254{
255        n = ep_to_bit(ci, n);
256        return hw_test_and_clear(ci, OP_ENDPTCOMPLETE, BIT(n));
257}
258
259/**
260 * hw_test_and_clear_intr_active: test & clear active interrupts (execute
261 *                                without interruption)
262 *
263 * This function returns active interrutps
264 */
265static u32 hw_test_and_clear_intr_active(struct ci_hdrc *ci)
266{
267        u32 reg = hw_read_intr_status(ci) & hw_read_intr_enable(ci);
268
269        hw_write(ci, OP_USBSTS, ~0, reg);
270        return reg;
271}
272
273/**
274 * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
275 *                                interruption)
276 *
277 * This function returns guard value
278 */
279static int hw_test_and_clear_setup_guard(struct ci_hdrc *ci)
280{
281        return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, 0);
282}
283
284/**
285 * hw_test_and_set_setup_guard: test & set setup guard (execute without
286 *                              interruption)
287 *
288 * This function returns guard value
289 */
290static int hw_test_and_set_setup_guard(struct ci_hdrc *ci)
291{
292        return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
293}
294
295/**
296 * hw_usb_set_address: configures USB address (execute without interruption)
297 * @value: new USB address
298 *
299 * This function explicitly sets the address, without the "USBADRA" (advance)
300 * feature, which is not supported by older versions of the controller.
301 */
302static void hw_usb_set_address(struct ci_hdrc *ci, u8 value)
303{
304        hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
305                 value << __ffs(DEVICEADDR_USBADR));
306}
307
308/**
309 * hw_usb_reset: restart device after a bus reset (execute without
310 *               interruption)
311 *
312 * This function returns an error code
313 */
314static int hw_usb_reset(struct ci_hdrc *ci)
315{
316        hw_usb_set_address(ci, 0);
317
318        /* ESS flushes only at end?!? */
319        hw_write(ci, OP_ENDPTFLUSH,    ~0, ~0);
320
321        /* clear setup token semaphores */
322        hw_write(ci, OP_ENDPTSETUPSTAT, 0,  0);
323
324        /* clear complete status */
325        hw_write(ci, OP_ENDPTCOMPLETE,  0,  0);
326
327        /* wait until all bits cleared */
328        while (hw_read(ci, OP_ENDPTPRIME, ~0))
329                udelay(10);             /* not RTOS friendly */
330
331        /* reset all endpoints ? */
332
333        /* reset internal status and wait for further instructions
334           no need to verify the port reset status (ESS does it) */
335
336        return 0;
337}
338
339/******************************************************************************
340 * UTIL block
341 *****************************************************************************/
342
343static int add_td_to_list(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq,
344                          unsigned length)
345{
346        int i;
347        u32 temp;
348        struct td_node *lastnode, *node = kzalloc(sizeof(struct td_node),
349                                                  GFP_ATOMIC);
350
351        if (node == NULL)
352                return -ENOMEM;
353
354        node->ptr = dma_pool_alloc(hwep->td_pool, GFP_ATOMIC,
355                                   &node->dma);
356        if (node->ptr == NULL) {
357                kfree(node);
358                return -ENOMEM;
359        }
360
361        memset(node->ptr, 0, sizeof(struct ci_hw_td));
362        node->ptr->token = cpu_to_le32(length << __ffs(TD_TOTAL_BYTES));
363        node->ptr->token &= cpu_to_le32(TD_TOTAL_BYTES);
364        node->ptr->token |= cpu_to_le32(TD_STATUS_ACTIVE);
365        if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == TX) {
366                u32 mul = hwreq->req.length / hwep->ep.maxpacket;
367
368                if (hwreq->req.length == 0
369                                || hwreq->req.length % hwep->ep.maxpacket)
370                        mul++;
371                node->ptr->token |= mul << __ffs(TD_MULTO);
372        }
373
374        temp = (u32) (hwreq->req.dma + hwreq->req.actual);
375        if (length) {
376                node->ptr->page[0] = cpu_to_le32(temp);
377                for (i = 1; i < TD_PAGE_COUNT; i++) {
378                        u32 page = temp + i * CI_HDRC_PAGE_SIZE;
379                        page &= ~TD_RESERVED_MASK;
380                        node->ptr->page[i] = cpu_to_le32(page);
381                }
382        }
383
384        hwreq->req.actual += length;
385
386        if (!list_empty(&hwreq->tds)) {
387                /* get the last entry */
388                lastnode = list_entry(hwreq->tds.prev,
389                                struct td_node, td);
390                lastnode->ptr->next = cpu_to_le32(node->dma);
391        }
392
393        INIT_LIST_HEAD(&node->td);
394        list_add_tail(&node->td, &hwreq->tds);
395
396        return 0;
397}
398
399/**
400 * _usb_addr: calculates endpoint address from direction & number
401 * @ep:  endpoint
402 */
403static inline u8 _usb_addr(struct ci_hw_ep *ep)
404{
405        return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
406}
407
408/**
409 * _hardware_queue: configures a request at hardware level
410 * @gadget: gadget
411 * @hwep:   endpoint
412 *
413 * This function returns an error code
414 */
415static int _hardware_enqueue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
416{
417        struct ci_hdrc *ci = hwep->ci;
418        int ret = 0;
419        unsigned rest = hwreq->req.length;
420        int pages = TD_PAGE_COUNT;
421        struct td_node *firstnode, *lastnode;
422
423        /* don't queue twice */
424        if (hwreq->req.status == -EALREADY)
425                return -EALREADY;
426
427        hwreq->req.status = -EALREADY;
428
429        ret = usb_gadget_map_request(&ci->gadget, &hwreq->req, hwep->dir);
430        if (ret)
431                return ret;
432
433        /*
434         * The first buffer could be not page aligned.
435         * In that case we have to span into one extra td.
436         */
437        if (hwreq->req.dma % PAGE_SIZE)
438                pages--;
439
440        if (rest == 0)
441                add_td_to_list(hwep, hwreq, 0);
442
443        while (rest > 0) {
444                unsigned count = min(hwreq->req.length - hwreq->req.actual,
445                                        (unsigned)(pages * CI_HDRC_PAGE_SIZE));
446                add_td_to_list(hwep, hwreq, count);
447                rest -= count;
448        }
449
450        if (hwreq->req.zero && hwreq->req.length
451            && (hwreq->req.length % hwep->ep.maxpacket == 0))
452                add_td_to_list(hwep, hwreq, 0);
453
454        firstnode = list_first_entry(&hwreq->tds, struct td_node, td);
455
456        lastnode = list_entry(hwreq->tds.prev,
457                struct td_node, td);
458
459        lastnode->ptr->next = cpu_to_le32(TD_TERMINATE);
460        if (!hwreq->req.no_interrupt)
461                lastnode->ptr->token |= cpu_to_le32(TD_IOC);
462        wmb();
463
464        hwreq->req.actual = 0;
465        if (!list_empty(&hwep->qh.queue)) {
466                struct ci_hw_req *hwreqprev;
467                int n = hw_ep_bit(hwep->num, hwep->dir);
468                int tmp_stat;
469                struct td_node *prevlastnode;
470                u32 next = firstnode->dma & TD_ADDR_MASK;
471
472                hwreqprev = list_entry(hwep->qh.queue.prev,
473                                struct ci_hw_req, queue);
474                prevlastnode = list_entry(hwreqprev->tds.prev,
475                                struct td_node, td);
476
477                prevlastnode->ptr->next = cpu_to_le32(next);
478                wmb();
479                if (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
480                        goto done;
481                do {
482                        hw_write(ci, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
483                        tmp_stat = hw_read(ci, OP_ENDPTSTAT, BIT(n));
484                } while (!hw_read(ci, OP_USBCMD, USBCMD_ATDTW));
485                hw_write(ci, OP_USBCMD, USBCMD_ATDTW, 0);
486                if (tmp_stat)
487                        goto done;
488        }
489
490        /*  QH configuration */
491        hwep->qh.ptr->td.next = cpu_to_le32(firstnode->dma);
492        hwep->qh.ptr->td.token &=
493                cpu_to_le32(~(TD_STATUS_HALTED|TD_STATUS_ACTIVE));
494
495        if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == RX) {
496                u32 mul = hwreq->req.length / hwep->ep.maxpacket;
497
498                if (hwreq->req.length == 0
499                                || hwreq->req.length % hwep->ep.maxpacket)
500                        mul++;
501                hwep->qh.ptr->cap |= mul << __ffs(QH_MULT);
502        }
503
504        wmb();   /* synchronize before ep prime */
505
506        ret = hw_ep_prime(ci, hwep->num, hwep->dir,
507                           hwep->type == USB_ENDPOINT_XFER_CONTROL);
508done:
509        return ret;
510}
511
512/*
513 * free_pending_td: remove a pending request for the endpoint
514 * @hwep: endpoint
515 */
516static void free_pending_td(struct ci_hw_ep *hwep)
517{
518        struct td_node *pending = hwep->pending_td;
519
520        dma_pool_free(hwep->td_pool, pending->ptr, pending->dma);
521        hwep->pending_td = NULL;
522        kfree(pending);
523}
524
525/**
526 * _hardware_dequeue: handles a request at hardware level
527 * @gadget: gadget
528 * @hwep:   endpoint
529 *
530 * This function returns an error code
531 */
532static int _hardware_dequeue(struct ci_hw_ep *hwep, struct ci_hw_req *hwreq)
533{
534        u32 tmptoken;
535        struct td_node *node, *tmpnode;
536        unsigned remaining_length;
537        unsigned actual = hwreq->req.length;
538
539        if (hwreq->req.status != -EALREADY)
540                return -EINVAL;
541
542        hwreq->req.status = 0;
543
544        list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
545                tmptoken = le32_to_cpu(node->ptr->token);
546                if ((TD_STATUS_ACTIVE & tmptoken) != 0) {
547                        hwreq->req.status = -EALREADY;
548                        return -EBUSY;
549                }
550
551                remaining_length = (tmptoken & TD_TOTAL_BYTES);
552                remaining_length >>= __ffs(TD_TOTAL_BYTES);
553                actual -= remaining_length;
554
555                hwreq->req.status = tmptoken & TD_STATUS;
556                if ((TD_STATUS_HALTED & hwreq->req.status)) {
557                        hwreq->req.status = -EPIPE;
558                        break;
559                } else if ((TD_STATUS_DT_ERR & hwreq->req.status)) {
560                        hwreq->req.status = -EPROTO;
561                        break;
562                } else if ((TD_STATUS_TR_ERR & hwreq->req.status)) {
563                        hwreq->req.status = -EILSEQ;
564                        break;
565                }
566
567                if (remaining_length) {
568                        if (hwep->dir) {
569                                hwreq->req.status = -EPROTO;
570                                break;
571                        }
572                }
573                /*
574                 * As the hardware could still address the freed td
575                 * which will run the udc unusable, the cleanup of the
576                 * td has to be delayed by one.
577                 */
578                if (hwep->pending_td)
579                        free_pending_td(hwep);
580
581                hwep->pending_td = node;
582                list_del_init(&node->td);
583        }
584
585        usb_gadget_unmap_request(&hwep->ci->gadget, &hwreq->req, hwep->dir);
586
587        hwreq->req.actual += actual;
588
589        if (hwreq->req.status)
590                return hwreq->req.status;
591
592        return hwreq->req.actual;
593}
594
595/**
596 * _ep_nuke: dequeues all endpoint requests
597 * @hwep: endpoint
598 *
599 * This function returns an error code
600 * Caller must hold lock
601 */
602static int _ep_nuke(struct ci_hw_ep *hwep)
603__releases(hwep->lock)
604__acquires(hwep->lock)
605{
606        struct td_node *node, *tmpnode;
607        if (hwep == NULL)
608                return -EINVAL;
609
610        hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
611
612        while (!list_empty(&hwep->qh.queue)) {
613
614                /* pop oldest request */
615                struct ci_hw_req *hwreq = list_entry(hwep->qh.queue.next,
616                                                     struct ci_hw_req, queue);
617
618                list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
619                        dma_pool_free(hwep->td_pool, node->ptr, node->dma);
620                        list_del_init(&node->td);
621                        node->ptr = NULL;
622                        kfree(node);
623                }
624
625                list_del_init(&hwreq->queue);
626                hwreq->req.status = -ESHUTDOWN;
627
628                if (hwreq->req.complete != NULL) {
629                        spin_unlock(hwep->lock);
630                        usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
631                        spin_lock(hwep->lock);
632                }
633        }
634
635        if (hwep->pending_td)
636                free_pending_td(hwep);
637
638        return 0;
639}
640
641static int _ep_set_halt(struct usb_ep *ep, int value, bool check_transfer)
642{
643        struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
644        int direction, retval = 0;
645        unsigned long flags;
646
647        if (ep == NULL || hwep->ep.desc == NULL)
648                return -EINVAL;
649
650        if (usb_endpoint_xfer_isoc(hwep->ep.desc))
651                return -EOPNOTSUPP;
652
653        spin_lock_irqsave(hwep->lock, flags);
654
655        if (value && hwep->dir == TX && check_transfer &&
656                !list_empty(&hwep->qh.queue) &&
657                        !usb_endpoint_xfer_control(hwep->ep.desc)) {
658                spin_unlock_irqrestore(hwep->lock, flags);
659                return -EAGAIN;
660        }
661
662        direction = hwep->dir;
663        do {
664                retval |= hw_ep_set_halt(hwep->ci, hwep->num, hwep->dir, value);
665
666                if (!value)
667                        hwep->wedge = 0;
668
669                if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
670                        hwep->dir = (hwep->dir == TX) ? RX : TX;
671
672        } while (hwep->dir != direction);
673
674        spin_unlock_irqrestore(hwep->lock, flags);
675        return retval;
676}
677
678
679/**
680 * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
681 * @gadget: gadget
682 *
683 * This function returns an error code
684 */
685static int _gadget_stop_activity(struct usb_gadget *gadget)
686{
687        struct usb_ep *ep;
688        struct ci_hdrc    *ci = container_of(gadget, struct ci_hdrc, gadget);
689        unsigned long flags;
690
691        spin_lock_irqsave(&ci->lock, flags);
692        ci->gadget.speed = USB_SPEED_UNKNOWN;
693        ci->remote_wakeup = 0;
694        ci->suspended = 0;
695        spin_unlock_irqrestore(&ci->lock, flags);
696
697        /* flush all endpoints */
698        gadget_for_each_ep(ep, gadget) {
699                usb_ep_fifo_flush(ep);
700        }
701        usb_ep_fifo_flush(&ci->ep0out->ep);
702        usb_ep_fifo_flush(&ci->ep0in->ep);
703
704        /* make sure to disable all endpoints */
705        gadget_for_each_ep(ep, gadget) {
706                usb_ep_disable(ep);
707        }
708
709        if (ci->status != NULL) {
710                usb_ep_free_request(&ci->ep0in->ep, ci->status);
711                ci->status = NULL;
712        }
713
714        return 0;
715}
716
717/******************************************************************************
718 * ISR block
719 *****************************************************************************/
720/**
721 * isr_reset_handler: USB reset interrupt handler
722 * @ci: UDC device
723 *
724 * This function resets USB engine after a bus reset occurred
725 */
726static void isr_reset_handler(struct ci_hdrc *ci)
727__releases(ci->lock)
728__acquires(ci->lock)
729{
730        int retval;
731
732        spin_unlock(&ci->lock);
733        if (ci->gadget.speed != USB_SPEED_UNKNOWN) {
734                if (ci->driver)
735                        ci->driver->disconnect(&ci->gadget);
736        }
737
738        retval = _gadget_stop_activity(&ci->gadget);
739        if (retval)
740                goto done;
741
742        retval = hw_usb_reset(ci);
743        if (retval)
744                goto done;
745
746        ci->status = usb_ep_alloc_request(&ci->ep0in->ep, GFP_ATOMIC);
747        if (ci->status == NULL)
748                retval = -ENOMEM;
749
750        usb_gadget_set_state(&ci->gadget, USB_STATE_DEFAULT);
751
752done:
753        spin_lock(&ci->lock);
754
755        if (retval)
756                dev_err(ci->dev, "error: %i\n", retval);
757}
758
759/**
760 * isr_get_status_complete: get_status request complete function
761 * @ep:  endpoint
762 * @req: request handled
763 *
764 * Caller must release lock
765 */
766static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
767{
768        if (ep == NULL || req == NULL)
769                return;
770
771        kfree(req->buf);
772        usb_ep_free_request(ep, req);
773}
774
775/**
776 * _ep_queue: queues (submits) an I/O request to an endpoint
777 *
778 * Caller must hold lock
779 */
780static int _ep_queue(struct usb_ep *ep, struct usb_request *req,
781                    gfp_t __maybe_unused gfp_flags)
782{
783        struct ci_hw_ep  *hwep  = container_of(ep,  struct ci_hw_ep, ep);
784        struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
785        struct ci_hdrc *ci = hwep->ci;
786        int retval = 0;
787
788        if (ep == NULL || req == NULL || hwep->ep.desc == NULL)
789                return -EINVAL;
790
791        if (hwep->type == USB_ENDPOINT_XFER_CONTROL) {
792                if (req->length)
793                        hwep = (ci->ep0_dir == RX) ?
794                               ci->ep0out : ci->ep0in;
795                if (!list_empty(&hwep->qh.queue)) {
796                        _ep_nuke(hwep);
797                        retval = -EOVERFLOW;
798                        dev_warn(hwep->ci->dev, "endpoint ctrl %X nuked\n",
799                                 _usb_addr(hwep));
800                }
801        }
802
803        if (usb_endpoint_xfer_isoc(hwep->ep.desc) &&
804            hwreq->req.length > (1 + hwep->ep.mult) * hwep->ep.maxpacket) {
805                dev_err(hwep->ci->dev, "request length too big for isochronous\n");
806                return -EMSGSIZE;
807        }
808
809        /* first nuke then test link, e.g. previous status has not sent */
810        if (!list_empty(&hwreq->queue)) {
811                dev_err(hwep->ci->dev, "request already in queue\n");
812                return -EBUSY;
813        }
814
815        /* push request */
816        hwreq->req.status = -EINPROGRESS;
817        hwreq->req.actual = 0;
818
819        retval = _hardware_enqueue(hwep, hwreq);
820
821        if (retval == -EALREADY)
822                retval = 0;
823        if (!retval)
824                list_add_tail(&hwreq->queue, &hwep->qh.queue);
825
826        return retval;
827}
828
829/**
830 * isr_get_status_response: get_status request response
831 * @ci: ci struct
832 * @setup: setup request packet
833 *
834 * This function returns an error code
835 */
836static int isr_get_status_response(struct ci_hdrc *ci,
837                                   struct usb_ctrlrequest *setup)
838__releases(hwep->lock)
839__acquires(hwep->lock)
840{
841        struct ci_hw_ep *hwep = ci->ep0in;
842        struct usb_request *req = NULL;
843        gfp_t gfp_flags = GFP_ATOMIC;
844        int dir, num, retval;
845
846        if (hwep == NULL || setup == NULL)
847                return -EINVAL;
848
849        spin_unlock(hwep->lock);
850        req = usb_ep_alloc_request(&hwep->ep, gfp_flags);
851        spin_lock(hwep->lock);
852        if (req == NULL)
853                return -ENOMEM;
854
855        req->complete = isr_get_status_complete;
856        req->length   = 2;
857        req->buf      = kzalloc(req->length, gfp_flags);
858        if (req->buf == NULL) {
859                retval = -ENOMEM;
860                goto err_free_req;
861        }
862
863        if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
864                /* Assume that device is bus powered for now. */
865                *(u16 *)req->buf = ci->remote_wakeup << 1;
866        } else if ((setup->bRequestType & USB_RECIP_MASK) \
867                   == USB_RECIP_ENDPOINT) {
868                dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
869                        TX : RX;
870                num =  le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
871                *(u16 *)req->buf = hw_ep_get_halt(ci, num, dir);
872        }
873        /* else do nothing; reserved for future use */
874
875        retval = _ep_queue(&hwep->ep, req, gfp_flags);
876        if (retval)
877                goto err_free_buf;
878
879        return 0;
880
881 err_free_buf:
882        kfree(req->buf);
883 err_free_req:
884        spin_unlock(hwep->lock);
885        usb_ep_free_request(&hwep->ep, req);
886        spin_lock(hwep->lock);
887        return retval;
888}
889
890/**
891 * isr_setup_status_complete: setup_status request complete function
892 * @ep:  endpoint
893 * @req: request handled
894 *
895 * Caller must release lock. Put the port in test mode if test mode
896 * feature is selected.
897 */
898static void
899isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
900{
901        struct ci_hdrc *ci = req->context;
902        unsigned long flags;
903
904        if (ci->setaddr) {
905                hw_usb_set_address(ci, ci->address);
906                ci->setaddr = false;
907                if (ci->address)
908                        usb_gadget_set_state(&ci->gadget, USB_STATE_ADDRESS);
909        }
910
911        spin_lock_irqsave(&ci->lock, flags);
912        if (ci->test_mode)
913                hw_port_test_set(ci, ci->test_mode);
914        spin_unlock_irqrestore(&ci->lock, flags);
915}
916
917/**
918 * isr_setup_status_phase: queues the status phase of a setup transation
919 * @ci: ci struct
920 *
921 * This function returns an error code
922 */
923static int isr_setup_status_phase(struct ci_hdrc *ci)
924{
925        int retval;
926        struct ci_hw_ep *hwep;
927
928        hwep = (ci->ep0_dir == TX) ? ci->ep0out : ci->ep0in;
929        ci->status->context = ci;
930        ci->status->complete = isr_setup_status_complete;
931
932        retval = _ep_queue(&hwep->ep, ci->status, GFP_ATOMIC);
933
934        return retval;
935}
936
937/**
938 * isr_tr_complete_low: transaction complete low level handler
939 * @hwep: endpoint
940 *
941 * This function returns an error code
942 * Caller must hold lock
943 */
944static int isr_tr_complete_low(struct ci_hw_ep *hwep)
945__releases(hwep->lock)
946__acquires(hwep->lock)
947{
948        struct ci_hw_req *hwreq, *hwreqtemp;
949        struct ci_hw_ep *hweptemp = hwep;
950        int retval = 0;
951
952        list_for_each_entry_safe(hwreq, hwreqtemp, &hwep->qh.queue,
953                        queue) {
954                retval = _hardware_dequeue(hwep, hwreq);
955                if (retval < 0)
956                        break;
957                list_del_init(&hwreq->queue);
958                if (hwreq->req.complete != NULL) {
959                        spin_unlock(hwep->lock);
960                        if ((hwep->type == USB_ENDPOINT_XFER_CONTROL) &&
961                                        hwreq->req.length)
962                                hweptemp = hwep->ci->ep0in;
963                        usb_gadget_giveback_request(&hweptemp->ep, &hwreq->req);
964                        spin_lock(hwep->lock);
965                }
966        }
967
968        if (retval == -EBUSY)
969                retval = 0;
970
971        return retval;
972}
973
974static int otg_a_alt_hnp_support(struct ci_hdrc *ci)
975{
976        dev_warn(&ci->gadget.dev,
977                "connect the device to an alternate port if you want HNP\n");
978        return isr_setup_status_phase(ci);
979}
980
981/**
982 * isr_setup_packet_handler: setup packet handler
983 * @ci: UDC descriptor
984 *
985 * This function handles setup packet
986 */
987static void isr_setup_packet_handler(struct ci_hdrc *ci)
988__releases(ci->lock)
989__acquires(ci->lock)
990{
991        struct ci_hw_ep *hwep = &ci->ci_hw_ep[0];
992        struct usb_ctrlrequest req;
993        int type, num, dir, err = -EINVAL;
994        u8 tmode = 0;
995
996        /*
997         * Flush data and handshake transactions of previous
998         * setup packet.
999         */
1000        _ep_nuke(ci->ep0out);
1001        _ep_nuke(ci->ep0in);
1002
1003        /* read_setup_packet */
1004        do {
1005                hw_test_and_set_setup_guard(ci);
1006                memcpy(&req, &hwep->qh.ptr->setup, sizeof(req));
1007        } while (!hw_test_and_clear_setup_guard(ci));
1008
1009        type = req.bRequestType;
1010
1011        ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
1012
1013        switch (req.bRequest) {
1014        case USB_REQ_CLEAR_FEATURE:
1015                if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1016                                le16_to_cpu(req.wValue) ==
1017                                USB_ENDPOINT_HALT) {
1018                        if (req.wLength != 0)
1019                                break;
1020                        num  = le16_to_cpu(req.wIndex);
1021                        dir = num & USB_ENDPOINT_DIR_MASK;
1022                        num &= USB_ENDPOINT_NUMBER_MASK;
1023                        if (dir) /* TX */
1024                                num += ci->hw_ep_max / 2;
1025                        if (!ci->ci_hw_ep[num].wedge) {
1026                                spin_unlock(&ci->lock);
1027                                err = usb_ep_clear_halt(
1028                                        &ci->ci_hw_ep[num].ep);
1029                                spin_lock(&ci->lock);
1030                                if (err)
1031                                        break;
1032                        }
1033                        err = isr_setup_status_phase(ci);
1034                } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
1035                                le16_to_cpu(req.wValue) ==
1036                                USB_DEVICE_REMOTE_WAKEUP) {
1037                        if (req.wLength != 0)
1038                                break;
1039                        ci->remote_wakeup = 0;
1040                        err = isr_setup_status_phase(ci);
1041                } else {
1042                        goto delegate;
1043                }
1044                break;
1045        case USB_REQ_GET_STATUS:
1046                if (type != (USB_DIR_IN|USB_RECIP_DEVICE)   &&
1047                    type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
1048                    type != (USB_DIR_IN|USB_RECIP_INTERFACE))
1049                        goto delegate;
1050                if (le16_to_cpu(req.wLength) != 2 ||
1051                    le16_to_cpu(req.wValue)  != 0)
1052                        break;
1053                err = isr_get_status_response(ci, &req);
1054                break;
1055        case USB_REQ_SET_ADDRESS:
1056                if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
1057                        goto delegate;
1058                if (le16_to_cpu(req.wLength) != 0 ||
1059                    le16_to_cpu(req.wIndex)  != 0)
1060                        break;
1061                ci->address = (u8)le16_to_cpu(req.wValue);
1062                ci->setaddr = true;
1063                err = isr_setup_status_phase(ci);
1064                break;
1065        case USB_REQ_SET_FEATURE:
1066                if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1067                                le16_to_cpu(req.wValue) ==
1068                                USB_ENDPOINT_HALT) {
1069                        if (req.wLength != 0)
1070                                break;
1071                        num  = le16_to_cpu(req.wIndex);
1072                        dir = num & USB_ENDPOINT_DIR_MASK;
1073                        num &= USB_ENDPOINT_NUMBER_MASK;
1074                        if (dir) /* TX */
1075                                num += ci->hw_ep_max / 2;
1076
1077                        spin_unlock(&ci->lock);
1078                        err = _ep_set_halt(&ci->ci_hw_ep[num].ep, 1, false);
1079                        spin_lock(&ci->lock);
1080                        if (!err)
1081                                isr_setup_status_phase(ci);
1082                } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
1083                        if (req.wLength != 0)
1084                                break;
1085                        switch (le16_to_cpu(req.wValue)) {
1086                        case USB_DEVICE_REMOTE_WAKEUP:
1087                                ci->remote_wakeup = 1;
1088                                err = isr_setup_status_phase(ci);
1089                                break;
1090                        case USB_DEVICE_TEST_MODE:
1091                                tmode = le16_to_cpu(req.wIndex) >> 8;
1092                                switch (tmode) {
1093                                case TEST_J:
1094                                case TEST_K:
1095                                case TEST_SE0_NAK:
1096                                case TEST_PACKET:
1097                                case TEST_FORCE_EN:
1098                                        ci->test_mode = tmode;
1099                                        err = isr_setup_status_phase(
1100                                                        ci);
1101                                        break;
1102                                default:
1103                                        break;
1104                                }
1105                                break;
1106                        case USB_DEVICE_B_HNP_ENABLE:
1107                                if (ci_otg_is_fsm_mode(ci)) {
1108                                        ci->gadget.b_hnp_enable = 1;
1109                                        err = isr_setup_status_phase(
1110                                                        ci);
1111                                }
1112                                break;
1113                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
1114                                if (ci_otg_is_fsm_mode(ci))
1115                                        err = otg_a_alt_hnp_support(ci);
1116                                break;
1117                        default:
1118                                goto delegate;
1119                        }
1120                } else {
1121                        goto delegate;
1122                }
1123                break;
1124        default:
1125delegate:
1126                if (req.wLength == 0)   /* no data phase */
1127                        ci->ep0_dir = TX;
1128
1129                spin_unlock(&ci->lock);
1130                err = ci->driver->setup(&ci->gadget, &req);
1131                spin_lock(&ci->lock);
1132                break;
1133        }
1134
1135        if (err < 0) {
1136                spin_unlock(&ci->lock);
1137                if (_ep_set_halt(&hwep->ep, 1, false))
1138                        dev_err(ci->dev, "error: _ep_set_halt\n");
1139                spin_lock(&ci->lock);
1140        }
1141}
1142
1143/**
1144 * isr_tr_complete_handler: transaction complete interrupt handler
1145 * @ci: UDC descriptor
1146 *
1147 * This function handles traffic events
1148 */
1149static void isr_tr_complete_handler(struct ci_hdrc *ci)
1150__releases(ci->lock)
1151__acquires(ci->lock)
1152{
1153        unsigned i;
1154        int err;
1155
1156        for (i = 0; i < ci->hw_ep_max; i++) {
1157                struct ci_hw_ep *hwep  = &ci->ci_hw_ep[i];
1158
1159                if (hwep->ep.desc == NULL)
1160                        continue;   /* not configured */
1161
1162                if (hw_test_and_clear_complete(ci, i)) {
1163                        err = isr_tr_complete_low(hwep);
1164                        if (hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1165                                if (err > 0)   /* needs status phase */
1166                                        err = isr_setup_status_phase(ci);
1167                                if (err < 0) {
1168                                        spin_unlock(&ci->lock);
1169                                        if (_ep_set_halt(&hwep->ep, 1, false))
1170                                                dev_err(ci->dev,
1171                                                "error: _ep_set_halt\n");
1172                                        spin_lock(&ci->lock);
1173                                }
1174                        }
1175                }
1176
1177                /* Only handle setup packet below */
1178                if (i == 0 &&
1179                        hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(0)))
1180                        isr_setup_packet_handler(ci);
1181        }
1182}
1183
1184/******************************************************************************
1185 * ENDPT block
1186 *****************************************************************************/
1187/**
1188 * ep_enable: configure endpoint, making it usable
1189 *
1190 * Check usb_ep_enable() at "usb_gadget.h" for details
1191 */
1192static int ep_enable(struct usb_ep *ep,
1193                     const struct usb_endpoint_descriptor *desc)
1194{
1195        struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1196        int retval = 0;
1197        unsigned long flags;
1198        u32 cap = 0;
1199
1200        if (ep == NULL || desc == NULL)
1201                return -EINVAL;
1202
1203        spin_lock_irqsave(hwep->lock, flags);
1204
1205        /* only internal SW should enable ctrl endpts */
1206
1207        hwep->ep.desc = desc;
1208
1209        if (!list_empty(&hwep->qh.queue))
1210                dev_warn(hwep->ci->dev, "enabling a non-empty endpoint!\n");
1211
1212        hwep->dir  = usb_endpoint_dir_in(desc) ? TX : RX;
1213        hwep->num  = usb_endpoint_num(desc);
1214        hwep->type = usb_endpoint_type(desc);
1215
1216        hwep->ep.maxpacket = usb_endpoint_maxp(desc) & 0x07ff;
1217        hwep->ep.mult = QH_ISO_MULT(usb_endpoint_maxp(desc));
1218
1219        if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1220                cap |= QH_IOS;
1221
1222        cap |= QH_ZLT;
1223        cap |= (hwep->ep.maxpacket << __ffs(QH_MAX_PKT)) & QH_MAX_PKT;
1224        /*
1225         * For ISO-TX, we set mult at QH as the largest value, and use
1226         * MultO at TD as real mult value.
1227         */
1228        if (hwep->type == USB_ENDPOINT_XFER_ISOC && hwep->dir == TX)
1229                cap |= 3 << __ffs(QH_MULT);
1230
1231        hwep->qh.ptr->cap = cpu_to_le32(cap);
1232
1233        hwep->qh.ptr->td.next |= cpu_to_le32(TD_TERMINATE);   /* needed? */
1234
1235        if (hwep->num != 0 && hwep->type == USB_ENDPOINT_XFER_CONTROL) {
1236                dev_err(hwep->ci->dev, "Set control xfer at non-ep0\n");
1237                retval = -EINVAL;
1238        }
1239
1240        /*
1241         * Enable endpoints in the HW other than ep0 as ep0
1242         * is always enabled
1243         */
1244        if (hwep->num)
1245                retval |= hw_ep_enable(hwep->ci, hwep->num, hwep->dir,
1246                                       hwep->type);
1247
1248        spin_unlock_irqrestore(hwep->lock, flags);
1249        return retval;
1250}
1251
1252/**
1253 * ep_disable: endpoint is no longer usable
1254 *
1255 * Check usb_ep_disable() at "usb_gadget.h" for details
1256 */
1257static int ep_disable(struct usb_ep *ep)
1258{
1259        struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1260        int direction, retval = 0;
1261        unsigned long flags;
1262
1263        if (ep == NULL)
1264                return -EINVAL;
1265        else if (hwep->ep.desc == NULL)
1266                return -EBUSY;
1267
1268        spin_lock_irqsave(hwep->lock, flags);
1269
1270        /* only internal SW should disable ctrl endpts */
1271
1272        direction = hwep->dir;
1273        do {
1274                retval |= _ep_nuke(hwep);
1275                retval |= hw_ep_disable(hwep->ci, hwep->num, hwep->dir);
1276
1277                if (hwep->type == USB_ENDPOINT_XFER_CONTROL)
1278                        hwep->dir = (hwep->dir == TX) ? RX : TX;
1279
1280        } while (hwep->dir != direction);
1281
1282        hwep->ep.desc = NULL;
1283
1284        spin_unlock_irqrestore(hwep->lock, flags);
1285        return retval;
1286}
1287
1288/**
1289 * ep_alloc_request: allocate a request object to use with this endpoint
1290 *
1291 * Check usb_ep_alloc_request() at "usb_gadget.h" for details
1292 */
1293static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
1294{
1295        struct ci_hw_req *hwreq = NULL;
1296
1297        if (ep == NULL)
1298                return NULL;
1299
1300        hwreq = kzalloc(sizeof(struct ci_hw_req), gfp_flags);
1301        if (hwreq != NULL) {
1302                INIT_LIST_HEAD(&hwreq->queue);
1303                INIT_LIST_HEAD(&hwreq->tds);
1304        }
1305
1306        return (hwreq == NULL) ? NULL : &hwreq->req;
1307}
1308
1309/**
1310 * ep_free_request: frees a request object
1311 *
1312 * Check usb_ep_free_request() at "usb_gadget.h" for details
1313 */
1314static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
1315{
1316        struct ci_hw_ep  *hwep  = container_of(ep,  struct ci_hw_ep, ep);
1317        struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1318        struct td_node *node, *tmpnode;
1319        unsigned long flags;
1320
1321        if (ep == NULL || req == NULL) {
1322                return;
1323        } else if (!list_empty(&hwreq->queue)) {
1324                dev_err(hwep->ci->dev, "freeing queued request\n");
1325                return;
1326        }
1327
1328        spin_lock_irqsave(hwep->lock, flags);
1329
1330        list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1331                dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1332                list_del_init(&node->td);
1333                node->ptr = NULL;
1334                kfree(node);
1335        }
1336
1337        kfree(hwreq);
1338
1339        spin_unlock_irqrestore(hwep->lock, flags);
1340}
1341
1342/**
1343 * ep_queue: queues (submits) an I/O request to an endpoint
1344 *
1345 * Check usb_ep_queue()* at usb_gadget.h" for details
1346 */
1347static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1348                    gfp_t __maybe_unused gfp_flags)
1349{
1350        struct ci_hw_ep  *hwep  = container_of(ep,  struct ci_hw_ep, ep);
1351        int retval = 0;
1352        unsigned long flags;
1353
1354        if (ep == NULL || req == NULL || hwep->ep.desc == NULL)
1355                return -EINVAL;
1356
1357        spin_lock_irqsave(hwep->lock, flags);
1358        retval = _ep_queue(ep, req, gfp_flags);
1359        spin_unlock_irqrestore(hwep->lock, flags);
1360        return retval;
1361}
1362
1363/**
1364 * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
1365 *
1366 * Check usb_ep_dequeue() at "usb_gadget.h" for details
1367 */
1368static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
1369{
1370        struct ci_hw_ep  *hwep  = container_of(ep,  struct ci_hw_ep, ep);
1371        struct ci_hw_req *hwreq = container_of(req, struct ci_hw_req, req);
1372        unsigned long flags;
1373        struct td_node *node, *tmpnode;
1374
1375        if (ep == NULL || req == NULL || hwreq->req.status != -EALREADY ||
1376                hwep->ep.desc == NULL || list_empty(&hwreq->queue) ||
1377                list_empty(&hwep->qh.queue))
1378                return -EINVAL;
1379
1380        spin_lock_irqsave(hwep->lock, flags);
1381
1382        hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1383
1384        list_for_each_entry_safe(node, tmpnode, &hwreq->tds, td) {
1385                dma_pool_free(hwep->td_pool, node->ptr, node->dma);
1386                list_del(&node->td);
1387                kfree(node);
1388        }
1389
1390        /* pop request */
1391        list_del_init(&hwreq->queue);
1392
1393        usb_gadget_unmap_request(&hwep->ci->gadget, req, hwep->dir);
1394
1395        req->status = -ECONNRESET;
1396
1397        if (hwreq->req.complete != NULL) {
1398                spin_unlock(hwep->lock);
1399                usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
1400                spin_lock(hwep->lock);
1401        }
1402
1403        spin_unlock_irqrestore(hwep->lock, flags);
1404        return 0;
1405}
1406
1407/**
1408 * ep_set_halt: sets the endpoint halt feature
1409 *
1410 * Check usb_ep_set_halt() at "usb_gadget.h" for details
1411 */
1412static int ep_set_halt(struct usb_ep *ep, int value)
1413{
1414        return _ep_set_halt(ep, value, true);
1415}
1416
1417/**
1418 * ep_set_wedge: sets the halt feature and ignores clear requests
1419 *
1420 * Check usb_ep_set_wedge() at "usb_gadget.h" for details
1421 */
1422static int ep_set_wedge(struct usb_ep *ep)
1423{
1424        struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1425        unsigned long flags;
1426
1427        if (ep == NULL || hwep->ep.desc == NULL)
1428                return -EINVAL;
1429
1430        spin_lock_irqsave(hwep->lock, flags);
1431        hwep->wedge = 1;
1432        spin_unlock_irqrestore(hwep->lock, flags);
1433
1434        return usb_ep_set_halt(ep);
1435}
1436
1437/**
1438 * ep_fifo_flush: flushes contents of a fifo
1439 *
1440 * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
1441 */
1442static void ep_fifo_flush(struct usb_ep *ep)
1443{
1444        struct ci_hw_ep *hwep = container_of(ep, struct ci_hw_ep, ep);
1445        unsigned long flags;
1446
1447        if (ep == NULL) {
1448                dev_err(hwep->ci->dev, "%02X: -EINVAL\n", _usb_addr(hwep));
1449                return;
1450        }
1451
1452        spin_lock_irqsave(hwep->lock, flags);
1453
1454        hw_ep_flush(hwep->ci, hwep->num, hwep->dir);
1455
1456        spin_unlock_irqrestore(hwep->lock, flags);
1457}
1458
1459/**
1460 * Endpoint-specific part of the API to the USB controller hardware
1461 * Check "usb_gadget.h" for details
1462 */
1463static const struct usb_ep_ops usb_ep_ops = {
1464        .enable        = ep_enable,
1465        .disable       = ep_disable,
1466        .alloc_request = ep_alloc_request,
1467        .free_request  = ep_free_request,
1468        .queue         = ep_queue,
1469        .dequeue       = ep_dequeue,
1470        .set_halt      = ep_set_halt,
1471        .set_wedge     = ep_set_wedge,
1472        .fifo_flush    = ep_fifo_flush,
1473};
1474
1475/******************************************************************************
1476 * GADGET block
1477 *****************************************************************************/
1478static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
1479{
1480        struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1481        unsigned long flags;
1482        int gadget_ready = 0;
1483
1484        spin_lock_irqsave(&ci->lock, flags);
1485        ci->vbus_active = is_active;
1486        if (ci->driver)
1487                gadget_ready = 1;
1488        spin_unlock_irqrestore(&ci->lock, flags);
1489
1490        if (gadget_ready) {
1491                if (is_active) {
1492                        pm_runtime_get_sync(&_gadget->dev);
1493                        hw_device_reset(ci, USBMODE_CM_DC);
1494                        hw_device_state(ci, ci->ep0out->qh.dma);
1495                        usb_gadget_set_state(_gadget, USB_STATE_POWERED);
1496                } else {
1497                        if (ci->driver)
1498                                ci->driver->disconnect(&ci->gadget);
1499                        hw_device_state(ci, 0);
1500                        if (ci->platdata->notify_event)
1501                                ci->platdata->notify_event(ci,
1502                                CI_HDRC_CONTROLLER_STOPPED_EVENT);
1503                        _gadget_stop_activity(&ci->gadget);
1504                        pm_runtime_put_sync(&_gadget->dev);
1505                        usb_gadget_set_state(_gadget, USB_STATE_NOTATTACHED);
1506                }
1507        }
1508
1509        return 0;
1510}
1511
1512static int ci_udc_wakeup(struct usb_gadget *_gadget)
1513{
1514        struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1515        unsigned long flags;
1516        int ret = 0;
1517
1518        spin_lock_irqsave(&ci->lock, flags);
1519        if (!ci->remote_wakeup) {
1520                ret = -EOPNOTSUPP;
1521                goto out;
1522        }
1523        if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
1524                ret = -EINVAL;
1525                goto out;
1526        }
1527        hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
1528out:
1529        spin_unlock_irqrestore(&ci->lock, flags);
1530        return ret;
1531}
1532
1533static int ci_udc_vbus_draw(struct usb_gadget *_gadget, unsigned ma)
1534{
1535        struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1536
1537        if (ci->transceiver)
1538                return usb_phy_set_power(ci->transceiver, ma);
1539        return -ENOTSUPP;
1540}
1541
1542/* Change Data+ pullup status
1543 * this func is used by usb_gadget_connect/disconnet
1544 */
1545static int ci_udc_pullup(struct usb_gadget *_gadget, int is_on)
1546{
1547        struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
1548
1549        if (!ci->vbus_active)
1550                return -EOPNOTSUPP;
1551
1552        if (is_on)
1553                hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
1554        else
1555                hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
1556
1557        return 0;
1558}
1559
1560static int ci_udc_start(struct usb_gadget *gadget,
1561                         struct usb_gadget_driver *driver);
1562static int ci_udc_stop(struct usb_gadget *gadget,
1563                        struct usb_gadget_driver *driver);
1564/**
1565 * Device operations part of the API to the USB controller hardware,
1566 * which don't involve endpoints (or i/o)
1567 * Check  "usb_gadget.h" for details
1568 */
1569static const struct usb_gadget_ops usb_gadget_ops = {
1570        .vbus_session   = ci_udc_vbus_session,
1571        .wakeup         = ci_udc_wakeup,
1572        .pullup         = ci_udc_pullup,
1573        .vbus_draw      = ci_udc_vbus_draw,
1574        .udc_start      = ci_udc_start,
1575        .udc_stop       = ci_udc_stop,
1576};
1577
1578static int init_eps(struct ci_hdrc *ci)
1579{
1580        int retval = 0, i, j;
1581
1582        for (i = 0; i < ci->hw_ep_max/2; i++)
1583                for (j = RX; j <= TX; j++) {
1584                        int k = i + j * ci->hw_ep_max/2;
1585                        struct ci_hw_ep *hwep = &ci->ci_hw_ep[k];
1586
1587                        scnprintf(hwep->name, sizeof(hwep->name), "ep%i%s", i,
1588                                        (j == TX)  ? "in" : "out");
1589
1590                        hwep->ci          = ci;
1591                        hwep->lock         = &ci->lock;
1592                        hwep->td_pool      = ci->td_pool;
1593
1594                        hwep->ep.name      = hwep->name;
1595                        hwep->ep.ops       = &usb_ep_ops;
1596                        /*
1597                         * for ep0: maxP defined in desc, for other
1598                         * eps, maxP is set by epautoconfig() called
1599                         * by gadget layer
1600                         */
1601                        usb_ep_set_maxpacket_limit(&hwep->ep, (unsigned short)~0);
1602
1603                        INIT_LIST_HEAD(&hwep->qh.queue);
1604                        hwep->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
1605                                                     &hwep->qh.dma);
1606                        if (hwep->qh.ptr == NULL)
1607                                retval = -ENOMEM;
1608                        else
1609                                memset(hwep->qh.ptr, 0, sizeof(*hwep->qh.ptr));
1610
1611                        /*
1612                         * set up shorthands for ep0 out and in endpoints,
1613                         * don't add to gadget's ep_list
1614                         */
1615                        if (i == 0) {
1616                                if (j == RX)
1617                                        ci->ep0out = hwep;
1618                                else
1619                                        ci->ep0in = hwep;
1620
1621                                usb_ep_set_maxpacket_limit(&hwep->ep, CTRL_PAYLOAD_MAX);
1622                                continue;
1623                        }
1624
1625                        list_add_tail(&hwep->ep.ep_list, &ci->gadget.ep_list);
1626                }
1627
1628        return retval;
1629}
1630
1631static void destroy_eps(struct ci_hdrc *ci)
1632{
1633        int i;
1634
1635        for (i = 0; i < ci->hw_ep_max; i++) {
1636                struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
1637
1638                if (hwep->pending_td)
1639                        free_pending_td(hwep);
1640                dma_pool_free(ci->qh_pool, hwep->qh.ptr, hwep->qh.dma);
1641        }
1642}
1643
1644/**
1645 * ci_udc_start: register a gadget driver
1646 * @gadget: our gadget
1647 * @driver: the driver being registered
1648 *
1649 * Interrupts are enabled here.
1650 */
1651static int ci_udc_start(struct usb_gadget *gadget,
1652                         struct usb_gadget_driver *driver)
1653{
1654        struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1655        unsigned long flags;
1656        int retval = -ENOMEM;
1657
1658        if (driver->disconnect == NULL)
1659                return -EINVAL;
1660
1661
1662        ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
1663        retval = usb_ep_enable(&ci->ep0out->ep);
1664        if (retval)
1665                return retval;
1666
1667        ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
1668        retval = usb_ep_enable(&ci->ep0in->ep);
1669        if (retval)
1670                return retval;
1671
1672        ci->driver = driver;
1673
1674        /* Start otg fsm for B-device */
1675        if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) {
1676                ci_hdrc_otg_fsm_start(ci);
1677                return retval;
1678        }
1679
1680        pm_runtime_get_sync(&ci->gadget.dev);
1681        if (ci->vbus_active) {
1682                spin_lock_irqsave(&ci->lock, flags);
1683                hw_device_reset(ci, USBMODE_CM_DC);
1684        } else {
1685                pm_runtime_put_sync(&ci->gadget.dev);
1686                return retval;
1687        }
1688
1689        retval = hw_device_state(ci, ci->ep0out->qh.dma);
1690        spin_unlock_irqrestore(&ci->lock, flags);
1691        if (retval)
1692                pm_runtime_put_sync(&ci->gadget.dev);
1693
1694        return retval;
1695}
1696
1697/**
1698 * ci_udc_stop: unregister a gadget driver
1699 */
1700static int ci_udc_stop(struct usb_gadget *gadget,
1701                        struct usb_gadget_driver *driver)
1702{
1703        struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
1704        unsigned long flags;
1705
1706        spin_lock_irqsave(&ci->lock, flags);
1707
1708        if (ci->vbus_active) {
1709                hw_device_state(ci, 0);
1710                if (ci->platdata->notify_event)
1711                        ci->platdata->notify_event(ci,
1712                        CI_HDRC_CONTROLLER_STOPPED_EVENT);
1713                spin_unlock_irqrestore(&ci->lock, flags);
1714                _gadget_stop_activity(&ci->gadget);
1715                spin_lock_irqsave(&ci->lock, flags);
1716                pm_runtime_put(&ci->gadget.dev);
1717        }
1718
1719        ci->driver = NULL;
1720        spin_unlock_irqrestore(&ci->lock, flags);
1721
1722        return 0;
1723}
1724
1725/******************************************************************************
1726 * BUS block
1727 *****************************************************************************/
1728/**
1729 * udc_irq: ci interrupt handler
1730 *
1731 * This function returns IRQ_HANDLED if the IRQ has been handled
1732 * It locks access to registers
1733 */
1734static irqreturn_t udc_irq(struct ci_hdrc *ci)
1735{
1736        irqreturn_t retval;
1737        u32 intr;
1738
1739        if (ci == NULL)
1740                return IRQ_HANDLED;
1741
1742        spin_lock(&ci->lock);
1743
1744        if (ci->platdata->flags & CI_HDRC_REGS_SHARED) {
1745                if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
1746                                USBMODE_CM_DC) {
1747                        spin_unlock(&ci->lock);
1748                        return IRQ_NONE;
1749                }
1750        }
1751        intr = hw_test_and_clear_intr_active(ci);
1752
1753        if (intr) {
1754                /* order defines priority - do NOT change it */
1755                if (USBi_URI & intr)
1756                        isr_reset_handler(ci);
1757
1758                if (USBi_PCI & intr) {
1759                        ci->gadget.speed = hw_port_is_high_speed(ci) ?
1760                                USB_SPEED_HIGH : USB_SPEED_FULL;
1761                        if (ci->suspended && ci->driver->resume) {
1762                                spin_unlock(&ci->lock);
1763                                ci->driver->resume(&ci->gadget);
1764                                spin_lock(&ci->lock);
1765                                ci->suspended = 0;
1766                        }
1767                }
1768
1769                if (USBi_UI  & intr)
1770                        isr_tr_complete_handler(ci);
1771
1772                if (USBi_SLI & intr) {
1773                        if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
1774                            ci->driver->suspend) {
1775                                ci->suspended = 1;
1776                                spin_unlock(&ci->lock);
1777                                ci->driver->suspend(&ci->gadget);
1778                                usb_gadget_set_state(&ci->gadget,
1779                                                USB_STATE_SUSPENDED);
1780                                spin_lock(&ci->lock);
1781                        }
1782                }
1783                retval = IRQ_HANDLED;
1784        } else {
1785                retval = IRQ_NONE;
1786        }
1787        spin_unlock(&ci->lock);
1788
1789        return retval;
1790}
1791
1792/**
1793 * udc_start: initialize gadget role
1794 * @ci: chipidea controller
1795 */
1796static int udc_start(struct ci_hdrc *ci)
1797{
1798        struct device *dev = ci->dev;
1799        int retval = 0;
1800
1801        ci->gadget.ops          = &usb_gadget_ops;
1802        ci->gadget.speed        = USB_SPEED_UNKNOWN;
1803        ci->gadget.max_speed    = USB_SPEED_HIGH;
1804        ci->gadget.is_otg       = ci->is_otg ? 1 : 0;
1805        ci->gadget.name         = ci->platdata->name;
1806
1807        INIT_LIST_HEAD(&ci->gadget.ep_list);
1808
1809        /* alloc resources */
1810        ci->qh_pool = dma_pool_create("ci_hw_qh", dev,
1811                                       sizeof(struct ci_hw_qh),
1812                                       64, CI_HDRC_PAGE_SIZE);
1813        if (ci->qh_pool == NULL)
1814                return -ENOMEM;
1815
1816        ci->td_pool = dma_pool_create("ci_hw_td", dev,
1817                                       sizeof(struct ci_hw_td),
1818                                       64, CI_HDRC_PAGE_SIZE);
1819        if (ci->td_pool == NULL) {
1820                retval = -ENOMEM;
1821                goto free_qh_pool;
1822        }
1823
1824        retval = init_eps(ci);
1825        if (retval)
1826                goto free_pools;
1827
1828        ci->gadget.ep0 = &ci->ep0in->ep;
1829
1830        retval = usb_add_gadget_udc(dev, &ci->gadget);
1831        if (retval)
1832                goto destroy_eps;
1833
1834        pm_runtime_no_callbacks(&ci->gadget.dev);
1835        pm_runtime_enable(&ci->gadget.dev);
1836
1837        return retval;
1838
1839destroy_eps:
1840        destroy_eps(ci);
1841free_pools:
1842        dma_pool_destroy(ci->td_pool);
1843free_qh_pool:
1844        dma_pool_destroy(ci->qh_pool);
1845        return retval;
1846}
1847
1848/**
1849 * ci_hdrc_gadget_destroy: parent remove must call this to remove UDC
1850 *
1851 * No interrupts active, the IRQ has been released
1852 */
1853void ci_hdrc_gadget_destroy(struct ci_hdrc *ci)
1854{
1855        if (!ci->roles[CI_ROLE_GADGET])
1856                return;
1857
1858        usb_del_gadget_udc(&ci->gadget);
1859
1860        destroy_eps(ci);
1861
1862        dma_pool_destroy(ci->td_pool);
1863        dma_pool_destroy(ci->qh_pool);
1864}
1865
1866static int udc_id_switch_for_device(struct ci_hdrc *ci)
1867{
1868        if (ci->is_otg)
1869                /* Clear and enable BSV irq */
1870                hw_write_otgsc(ci, OTGSC_BSVIS | OTGSC_BSVIE,
1871                                        OTGSC_BSVIS | OTGSC_BSVIE);
1872
1873        return 0;
1874}
1875
1876static void udc_id_switch_for_host(struct ci_hdrc *ci)
1877{
1878        /*
1879         * host doesn't care B_SESSION_VALID event
1880         * so clear and disbale BSV irq
1881         */
1882        if (ci->is_otg)
1883                hw_write_otgsc(ci, OTGSC_BSVIE | OTGSC_BSVIS, OTGSC_BSVIS);
1884}
1885
1886/**
1887 * ci_hdrc_gadget_init - initialize device related bits
1888 * ci: the controller
1889 *
1890 * This function initializes the gadget, if the device is "device capable".
1891 */
1892int ci_hdrc_gadget_init(struct ci_hdrc *ci)
1893{
1894        struct ci_role_driver *rdrv;
1895
1896        if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DC))
1897                return -ENXIO;
1898
1899        rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL);
1900        if (!rdrv)
1901                return -ENOMEM;
1902
1903        rdrv->start     = udc_id_switch_for_device;
1904        rdrv->stop      = udc_id_switch_for_host;
1905        rdrv->irq       = udc_irq;
1906        rdrv->name      = "gadget";
1907        ci->roles[CI_ROLE_GADGET] = rdrv;
1908
1909        return udc_start(ci);
1910}
Note: See TracBrowser for help on using the repository browser.