GNU Linux-libre 4.19.286-gnu1
[releases.git] / drivers / usb / isp1760 / isp1760-udc.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for the NXP ISP1761 device controller
4  *
5  * Copyright 2014 Ideas on Board Oy
6  *
7  * Contacts:
8  *      Laurent Pinchart <laurent.pinchart@ideasonboard.com>
9  */
10
11 #include <linux/interrupt.h>
12 #include <linux/io.h>
13 #include <linux/kernel.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/timer.h>
18 #include <linux/usb.h>
19
20 #include "isp1760-core.h"
21 #include "isp1760-regs.h"
22 #include "isp1760-udc.h"
23
24 #define ISP1760_VBUS_POLL_INTERVAL      msecs_to_jiffies(500)
25
26 struct isp1760_request {
27         struct usb_request req;
28         struct list_head queue;
29         struct isp1760_ep *ep;
30         unsigned int packet_size;
31 };
32
33 static inline struct isp1760_udc *gadget_to_udc(struct usb_gadget *gadget)
34 {
35         return container_of(gadget, struct isp1760_udc, gadget);
36 }
37
38 static inline struct isp1760_ep *ep_to_udc_ep(struct usb_ep *ep)
39 {
40         return container_of(ep, struct isp1760_ep, ep);
41 }
42
43 static inline struct isp1760_request *req_to_udc_req(struct usb_request *req)
44 {
45         return container_of(req, struct isp1760_request, req);
46 }
47
48 static inline u32 isp1760_udc_read(struct isp1760_udc *udc, u16 reg)
49 {
50         return isp1760_read32(udc->regs, reg);
51 }
52
53 static inline void isp1760_udc_write(struct isp1760_udc *udc, u16 reg, u32 val)
54 {
55         isp1760_write32(udc->regs, reg, val);
56 }
57
58 /* -----------------------------------------------------------------------------
59  * Endpoint Management
60  */
61
62 static struct isp1760_ep *isp1760_udc_find_ep(struct isp1760_udc *udc,
63                                               u16 index)
64 {
65         unsigned int i;
66
67         if (index == 0)
68                 return &udc->ep[0];
69
70         for (i = 1; i < ARRAY_SIZE(udc->ep); ++i) {
71                 if (udc->ep[i].addr == index)
72                         return udc->ep[i].desc ? &udc->ep[i] : NULL;
73         }
74
75         return NULL;
76 }
77
78 static void __isp1760_udc_select_ep(struct isp1760_ep *ep, int dir)
79 {
80         isp1760_udc_write(ep->udc, DC_EPINDEX,
81                           DC_ENDPIDX(ep->addr & USB_ENDPOINT_NUMBER_MASK) |
82                           (dir == USB_DIR_IN ? DC_EPDIR : 0));
83 }
84
85 /**
86  * isp1760_udc_select_ep - Select an endpoint for register access
87  * @ep: The endpoint
88  *
89  * The ISP1761 endpoint registers are banked. This function selects the target
90  * endpoint for banked register access. The selection remains valid until the
91  * next call to this function, the next direct access to the EPINDEX register
92  * or the next reset, whichever comes first.
93  *
94  * Called with the UDC spinlock held.
95  */
96 static void isp1760_udc_select_ep(struct isp1760_ep *ep)
97 {
98         __isp1760_udc_select_ep(ep, ep->addr & USB_ENDPOINT_DIR_MASK);
99 }
100
101 /* Called with the UDC spinlock held. */
102 static void isp1760_udc_ctrl_send_status(struct isp1760_ep *ep, int dir)
103 {
104         struct isp1760_udc *udc = ep->udc;
105
106         /*
107          * Proceed to the status stage. The status stage data packet flows in
108          * the direction opposite to the data stage data packets, we thus need
109          * to select the OUT/IN endpoint for IN/OUT transfers.
110          */
111         isp1760_udc_write(udc, DC_EPINDEX, DC_ENDPIDX(0) |
112                           (dir == USB_DIR_IN ? 0 : DC_EPDIR));
113         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STATUS);
114
115         /*
116          * The hardware will terminate the request automatically and go back to
117          * the setup stage without notifying us.
118          */
119         udc->ep0_state = ISP1760_CTRL_SETUP;
120 }
121
122 /* Called without the UDC spinlock held. */
123 static void isp1760_udc_request_complete(struct isp1760_ep *ep,
124                                          struct isp1760_request *req,
125                                          int status)
126 {
127         struct isp1760_udc *udc = ep->udc;
128         unsigned long flags;
129
130         dev_dbg(ep->udc->isp->dev, "completing request %p with status %d\n",
131                 req, status);
132
133         req->ep = NULL;
134         req->req.status = status;
135         req->req.complete(&ep->ep, &req->req);
136
137         spin_lock_irqsave(&udc->lock, flags);
138
139         /*
140          * When completing control OUT requests, move to the status stage after
141          * calling the request complete callback. This gives the gadget an
142          * opportunity to stall the control transfer if needed.
143          */
144         if (status == 0 && ep->addr == 0 && udc->ep0_dir == USB_DIR_OUT)
145                 isp1760_udc_ctrl_send_status(ep, USB_DIR_OUT);
146
147         spin_unlock_irqrestore(&udc->lock, flags);
148 }
149
150 static void isp1760_udc_ctrl_send_stall(struct isp1760_ep *ep)
151 {
152         struct isp1760_udc *udc = ep->udc;
153         unsigned long flags;
154
155         dev_dbg(ep->udc->isp->dev, "%s(ep%02x)\n", __func__, ep->addr);
156
157         spin_lock_irqsave(&udc->lock, flags);
158
159         /* Stall both the IN and OUT endpoints. */
160         __isp1760_udc_select_ep(ep, USB_DIR_OUT);
161         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STALL);
162         __isp1760_udc_select_ep(ep, USB_DIR_IN);
163         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STALL);
164
165         /* A protocol stall completes the control transaction. */
166         udc->ep0_state = ISP1760_CTRL_SETUP;
167
168         spin_unlock_irqrestore(&udc->lock, flags);
169 }
170
171 /* -----------------------------------------------------------------------------
172  * Data Endpoints
173  */
174
175 /* Called with the UDC spinlock held. */
176 static bool isp1760_udc_receive(struct isp1760_ep *ep,
177                                 struct isp1760_request *req)
178 {
179         struct isp1760_udc *udc = ep->udc;
180         unsigned int len;
181         u32 *buf;
182         int i;
183
184         isp1760_udc_select_ep(ep);
185         len = isp1760_udc_read(udc, DC_BUFLEN) & DC_DATACOUNT_MASK;
186
187         dev_dbg(udc->isp->dev, "%s: received %u bytes (%u/%u done)\n",
188                 __func__, len, req->req.actual, req->req.length);
189
190         len = min(len, req->req.length - req->req.actual);
191
192         if (!len) {
193                 /*
194                  * There's no data to be read from the FIFO, acknowledge the RX
195                  * interrupt by clearing the buffer.
196                  *
197                  * TODO: What if another packet arrives in the meantime ? The
198                  * datasheet doesn't clearly document how this should be
199                  * handled.
200                  */
201                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
202                 return false;
203         }
204
205         buf = req->req.buf + req->req.actual;
206
207         /*
208          * Make sure not to read more than one extra byte, otherwise data from
209          * the next packet might be removed from the FIFO.
210          */
211         for (i = len; i > 2; i -= 4, ++buf)
212                 *buf = le32_to_cpu(isp1760_udc_read(udc, DC_DATAPORT));
213         if (i > 0)
214                 *(u16 *)buf = le16_to_cpu(readw(udc->regs + DC_DATAPORT));
215
216         req->req.actual += len;
217
218         /*
219          * TODO: The short_not_ok flag isn't supported yet, but isn't used by
220          * any gadget driver either.
221          */
222
223         dev_dbg(udc->isp->dev,
224                 "%s: req %p actual/length %u/%u maxpacket %u packet size %u\n",
225                 __func__, req, req->req.actual, req->req.length, ep->maxpacket,
226                 len);
227
228         ep->rx_pending = false;
229
230         /*
231          * Complete the request if all data has been received or if a short
232          * packet has been received.
233          */
234         if (req->req.actual == req->req.length || len < ep->maxpacket) {
235                 list_del(&req->queue);
236                 return true;
237         }
238
239         return false;
240 }
241
242 static void isp1760_udc_transmit(struct isp1760_ep *ep,
243                                  struct isp1760_request *req)
244 {
245         struct isp1760_udc *udc = ep->udc;
246         u32 *buf = req->req.buf + req->req.actual;
247         int i;
248
249         req->packet_size = min(req->req.length - req->req.actual,
250                                ep->maxpacket);
251
252         dev_dbg(udc->isp->dev, "%s: transferring %u bytes (%u/%u done)\n",
253                 __func__, req->packet_size, req->req.actual,
254                 req->req.length);
255
256         __isp1760_udc_select_ep(ep, USB_DIR_IN);
257
258         if (req->packet_size)
259                 isp1760_udc_write(udc, DC_BUFLEN, req->packet_size);
260
261         /*
262          * Make sure not to write more than one extra byte, otherwise extra data
263          * will stay in the FIFO and will be transmitted during the next control
264          * request. The endpoint control CLBUF bit is supposed to allow flushing
265          * the FIFO for this kind of conditions, but doesn't seem to work.
266          */
267         for (i = req->packet_size; i > 2; i -= 4, ++buf)
268                 isp1760_udc_write(udc, DC_DATAPORT, cpu_to_le32(*buf));
269         if (i > 0)
270                 writew(cpu_to_le16(*(u16 *)buf), udc->regs + DC_DATAPORT);
271
272         if (ep->addr == 0)
273                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
274         if (!req->packet_size)
275                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_VENDP);
276 }
277
278 static void isp1760_ep_rx_ready(struct isp1760_ep *ep)
279 {
280         struct isp1760_udc *udc = ep->udc;
281         struct isp1760_request *req;
282         bool complete;
283
284         spin_lock(&udc->lock);
285
286         if (ep->addr == 0 && udc->ep0_state != ISP1760_CTRL_DATA_OUT) {
287                 spin_unlock(&udc->lock);
288                 dev_dbg(udc->isp->dev, "%s: invalid ep0 state %u\n", __func__,
289                         udc->ep0_state);
290                 return;
291         }
292
293         if (ep->addr != 0 && !ep->desc) {
294                 spin_unlock(&udc->lock);
295                 dev_dbg(udc->isp->dev, "%s: ep%02x is disabled\n", __func__,
296                         ep->addr);
297                 return;
298         }
299
300         if (list_empty(&ep->queue)) {
301                 ep->rx_pending = true;
302                 spin_unlock(&udc->lock);
303                 dev_dbg(udc->isp->dev, "%s: ep%02x (%p) has no request queued\n",
304                         __func__, ep->addr, ep);
305                 return;
306         }
307
308         req = list_first_entry(&ep->queue, struct isp1760_request,
309                                queue);
310         complete = isp1760_udc_receive(ep, req);
311
312         spin_unlock(&udc->lock);
313
314         if (complete)
315                 isp1760_udc_request_complete(ep, req, 0);
316 }
317
318 static void isp1760_ep_tx_complete(struct isp1760_ep *ep)
319 {
320         struct isp1760_udc *udc = ep->udc;
321         struct isp1760_request *complete = NULL;
322         struct isp1760_request *req;
323         bool need_zlp;
324
325         spin_lock(&udc->lock);
326
327         if (ep->addr == 0 && udc->ep0_state != ISP1760_CTRL_DATA_IN) {
328                 spin_unlock(&udc->lock);
329                 dev_dbg(udc->isp->dev, "TX IRQ: invalid endpoint state %u\n",
330                         udc->ep0_state);
331                 return;
332         }
333
334         if (list_empty(&ep->queue)) {
335                 /*
336                  * This can happen for the control endpoint when the reply to
337                  * the GET_STATUS IN control request is sent directly by the
338                  * setup IRQ handler. Just proceed to the status stage.
339                  */
340                 if (ep->addr == 0) {
341                         isp1760_udc_ctrl_send_status(ep, USB_DIR_IN);
342                         spin_unlock(&udc->lock);
343                         return;
344                 }
345
346                 spin_unlock(&udc->lock);
347                 dev_dbg(udc->isp->dev, "%s: ep%02x has no request queued\n",
348                         __func__, ep->addr);
349                 return;
350         }
351
352         req = list_first_entry(&ep->queue, struct isp1760_request,
353                                queue);
354         req->req.actual += req->packet_size;
355
356         need_zlp = req->req.actual == req->req.length &&
357                    !(req->req.length % ep->maxpacket) &&
358                    req->packet_size && req->req.zero;
359
360         dev_dbg(udc->isp->dev,
361                 "TX IRQ: req %p actual/length %u/%u maxpacket %u packet size %u zero %u need zlp %u\n",
362                  req, req->req.actual, req->req.length, ep->maxpacket,
363                  req->packet_size, req->req.zero, need_zlp);
364
365         /*
366          * Complete the request if all data has been sent and we don't need to
367          * transmit a zero length packet.
368          */
369         if (req->req.actual == req->req.length && !need_zlp) {
370                 complete = req;
371                 list_del(&req->queue);
372
373                 if (ep->addr == 0)
374                         isp1760_udc_ctrl_send_status(ep, USB_DIR_IN);
375
376                 if (!list_empty(&ep->queue))
377                         req = list_first_entry(&ep->queue,
378                                                struct isp1760_request, queue);
379                 else
380                         req = NULL;
381         }
382
383         /*
384          * Transmit the next packet or start the next request, if any.
385          *
386          * TODO: If the endpoint is stalled the next request shouldn't be
387          * started, but what about the next packet ?
388          */
389         if (req)
390                 isp1760_udc_transmit(ep, req);
391
392         spin_unlock(&udc->lock);
393
394         if (complete)
395                 isp1760_udc_request_complete(ep, complete, 0);
396 }
397
398 static int __isp1760_udc_set_halt(struct isp1760_ep *ep, bool halt)
399 {
400         struct isp1760_udc *udc = ep->udc;
401
402         dev_dbg(udc->isp->dev, "%s: %s halt on ep%02x\n", __func__,
403                 halt ? "set" : "clear", ep->addr);
404
405         if (ep->desc && usb_endpoint_xfer_isoc(ep->desc)) {
406                 dev_dbg(udc->isp->dev, "%s: ep%02x is isochronous\n", __func__,
407                         ep->addr);
408                 return -EINVAL;
409         }
410
411         isp1760_udc_select_ep(ep);
412         isp1760_udc_write(udc, DC_CTRLFUNC, halt ? DC_STALL : 0);
413
414         if (ep->addr == 0) {
415                 /* When halting the control endpoint, stall both IN and OUT. */
416                 __isp1760_udc_select_ep(ep, USB_DIR_IN);
417                 isp1760_udc_write(udc, DC_CTRLFUNC, halt ? DC_STALL : 0);
418         } else if (!halt) {
419                 /* Reset the data PID by cycling the endpoint enable bit. */
420                 u16 eptype = isp1760_udc_read(udc, DC_EPTYPE);
421
422                 isp1760_udc_write(udc, DC_EPTYPE, eptype & ~DC_EPENABLE);
423                 isp1760_udc_write(udc, DC_EPTYPE, eptype);
424
425                 /*
426                  * Disabling the endpoint emptied the transmit FIFO, fill it
427                  * again if a request is pending.
428                  *
429                  * TODO: Does the gadget framework require synchronizatino with
430                  * the TX IRQ handler ?
431                  */
432                 if ((ep->addr & USB_DIR_IN) && !list_empty(&ep->queue)) {
433                         struct isp1760_request *req;
434
435                         req = list_first_entry(&ep->queue,
436                                                struct isp1760_request, queue);
437                         isp1760_udc_transmit(ep, req);
438                 }
439         }
440
441         ep->halted = halt;
442
443         return 0;
444 }
445
446 /* -----------------------------------------------------------------------------
447  * Control Endpoint
448  */
449
450 static int isp1760_udc_get_status(struct isp1760_udc *udc,
451                                   const struct usb_ctrlrequest *req)
452 {
453         struct isp1760_ep *ep;
454         u16 status;
455
456         if (req->wLength != cpu_to_le16(2) || req->wValue != cpu_to_le16(0))
457                 return -EINVAL;
458
459         switch (req->bRequestType) {
460         case USB_DIR_IN | USB_RECIP_DEVICE:
461                 status = udc->devstatus;
462                 break;
463
464         case USB_DIR_IN | USB_RECIP_INTERFACE:
465                 status = 0;
466                 break;
467
468         case USB_DIR_IN | USB_RECIP_ENDPOINT:
469                 ep = isp1760_udc_find_ep(udc, le16_to_cpu(req->wIndex));
470                 if (!ep)
471                         return -EINVAL;
472
473                 status = 0;
474                 if (ep->halted)
475                         status |= 1 << USB_ENDPOINT_HALT;
476                 break;
477
478         default:
479                 return -EINVAL;
480         }
481
482         isp1760_udc_write(udc, DC_EPINDEX, DC_ENDPIDX(0) | DC_EPDIR);
483         isp1760_udc_write(udc, DC_BUFLEN, 2);
484
485         writew(cpu_to_le16(status), udc->regs + DC_DATAPORT);
486
487         isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
488
489         dev_dbg(udc->isp->dev, "%s: status 0x%04x\n", __func__, status);
490
491         return 0;
492 }
493
494 static int isp1760_udc_set_address(struct isp1760_udc *udc, u16 addr)
495 {
496         if (addr > 127) {
497                 dev_dbg(udc->isp->dev, "invalid device address %u\n", addr);
498                 return -EINVAL;
499         }
500
501         if (udc->gadget.state != USB_STATE_DEFAULT &&
502             udc->gadget.state != USB_STATE_ADDRESS) {
503                 dev_dbg(udc->isp->dev, "can't set address in state %u\n",
504                         udc->gadget.state);
505                 return -EINVAL;
506         }
507
508         usb_gadget_set_state(&udc->gadget, addr ? USB_STATE_ADDRESS :
509                              USB_STATE_DEFAULT);
510
511         isp1760_udc_write(udc, DC_ADDRESS, DC_DEVEN | addr);
512
513         spin_lock(&udc->lock);
514         isp1760_udc_ctrl_send_status(&udc->ep[0], USB_DIR_OUT);
515         spin_unlock(&udc->lock);
516
517         return 0;
518 }
519
520 static bool isp1760_ep0_setup_standard(struct isp1760_udc *udc,
521                                        struct usb_ctrlrequest *req)
522 {
523         bool stall;
524
525         switch (req->bRequest) {
526         case USB_REQ_GET_STATUS:
527                 return isp1760_udc_get_status(udc, req);
528
529         case USB_REQ_CLEAR_FEATURE:
530                 switch (req->bRequestType) {
531                 case USB_DIR_OUT | USB_RECIP_DEVICE: {
532                         /* TODO: Handle remote wakeup feature. */
533                         return true;
534                 }
535
536                 case USB_DIR_OUT | USB_RECIP_ENDPOINT: {
537                         u16 index = le16_to_cpu(req->wIndex);
538                         struct isp1760_ep *ep;
539
540                         if (req->wLength != cpu_to_le16(0) ||
541                             req->wValue != cpu_to_le16(USB_ENDPOINT_HALT))
542                                 return true;
543
544                         ep = isp1760_udc_find_ep(udc, index);
545                         if (!ep)
546                                 return true;
547
548                         spin_lock(&udc->lock);
549
550                         /*
551                          * If the endpoint is wedged only the gadget can clear
552                          * the halt feature. Pretend success in that case, but
553                          * keep the endpoint halted.
554                          */
555                         if (!ep->wedged)
556                                 stall = __isp1760_udc_set_halt(ep, false);
557                         else
558                                 stall = false;
559
560                         if (!stall)
561                                 isp1760_udc_ctrl_send_status(&udc->ep[0],
562                                                              USB_DIR_OUT);
563
564                         spin_unlock(&udc->lock);
565                         return stall;
566                 }
567
568                 default:
569                         return true;
570                 }
571                 break;
572
573         case USB_REQ_SET_FEATURE:
574                 switch (req->bRequestType) {
575                 case USB_DIR_OUT | USB_RECIP_DEVICE: {
576                         /* TODO: Handle remote wakeup and test mode features */
577                         return true;
578                 }
579
580                 case USB_DIR_OUT | USB_RECIP_ENDPOINT: {
581                         u16 index = le16_to_cpu(req->wIndex);
582                         struct isp1760_ep *ep;
583
584                         if (req->wLength != cpu_to_le16(0) ||
585                             req->wValue != cpu_to_le16(USB_ENDPOINT_HALT))
586                                 return true;
587
588                         ep = isp1760_udc_find_ep(udc, index);
589                         if (!ep)
590                                 return true;
591
592                         spin_lock(&udc->lock);
593
594                         stall = __isp1760_udc_set_halt(ep, true);
595                         if (!stall)
596                                 isp1760_udc_ctrl_send_status(&udc->ep[0],
597                                                              USB_DIR_OUT);
598
599                         spin_unlock(&udc->lock);
600                         return stall;
601                 }
602
603                 default:
604                         return true;
605                 }
606                 break;
607
608         case USB_REQ_SET_ADDRESS:
609                 if (req->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
610                         return true;
611
612                 return isp1760_udc_set_address(udc, le16_to_cpu(req->wValue));
613
614         case USB_REQ_SET_CONFIGURATION:
615                 if (req->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
616                         return true;
617
618                 if (udc->gadget.state != USB_STATE_ADDRESS &&
619                     udc->gadget.state != USB_STATE_CONFIGURED)
620                         return true;
621
622                 stall = udc->driver->setup(&udc->gadget, req) < 0;
623                 if (stall)
624                         return true;
625
626                 usb_gadget_set_state(&udc->gadget, req->wValue ?
627                                      USB_STATE_CONFIGURED : USB_STATE_ADDRESS);
628
629                 /*
630                  * SET_CONFIGURATION (and SET_INTERFACE) must reset the halt
631                  * feature on all endpoints. There is however no need to do so
632                  * explicitly here as the gadget driver will disable and
633                  * reenable endpoints, clearing the halt feature.
634                  */
635                 return false;
636
637         default:
638                 return udc->driver->setup(&udc->gadget, req) < 0;
639         }
640 }
641
642 static void isp1760_ep0_setup(struct isp1760_udc *udc)
643 {
644         union {
645                 struct usb_ctrlrequest r;
646                 u32 data[2];
647         } req;
648         unsigned int count;
649         bool stall = false;
650
651         spin_lock(&udc->lock);
652
653         isp1760_udc_write(udc, DC_EPINDEX, DC_EP0SETUP);
654
655         count = isp1760_udc_read(udc, DC_BUFLEN) & DC_DATACOUNT_MASK;
656         if (count != sizeof(req)) {
657                 spin_unlock(&udc->lock);
658
659                 dev_err(udc->isp->dev, "invalid length %u for setup packet\n",
660                         count);
661
662                 isp1760_udc_ctrl_send_stall(&udc->ep[0]);
663                 return;
664         }
665
666         req.data[0] = isp1760_udc_read(udc, DC_DATAPORT);
667         req.data[1] = isp1760_udc_read(udc, DC_DATAPORT);
668
669         if (udc->ep0_state != ISP1760_CTRL_SETUP) {
670                 spin_unlock(&udc->lock);
671                 dev_dbg(udc->isp->dev, "unexpected SETUP packet\n");
672                 return;
673         }
674
675         /* Move to the data stage. */
676         if (!req.r.wLength)
677                 udc->ep0_state = ISP1760_CTRL_STATUS;
678         else if (req.r.bRequestType & USB_DIR_IN)
679                 udc->ep0_state = ISP1760_CTRL_DATA_IN;
680         else
681                 udc->ep0_state = ISP1760_CTRL_DATA_OUT;
682
683         udc->ep0_dir = req.r.bRequestType & USB_DIR_IN;
684         udc->ep0_length = le16_to_cpu(req.r.wLength);
685
686         spin_unlock(&udc->lock);
687
688         dev_dbg(udc->isp->dev,
689                 "%s: bRequestType 0x%02x bRequest 0x%02x wValue 0x%04x wIndex 0x%04x wLength 0x%04x\n",
690                 __func__, req.r.bRequestType, req.r.bRequest,
691                 le16_to_cpu(req.r.wValue), le16_to_cpu(req.r.wIndex),
692                 le16_to_cpu(req.r.wLength));
693
694         if ((req.r.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
695                 stall = isp1760_ep0_setup_standard(udc, &req.r);
696         else
697                 stall = udc->driver->setup(&udc->gadget, &req.r) < 0;
698
699         if (stall)
700                 isp1760_udc_ctrl_send_stall(&udc->ep[0]);
701 }
702
703 /* -----------------------------------------------------------------------------
704  * Gadget Endpoint Operations
705  */
706
707 static int isp1760_ep_enable(struct usb_ep *ep,
708                              const struct usb_endpoint_descriptor *desc)
709 {
710         struct isp1760_ep *uep = ep_to_udc_ep(ep);
711         struct isp1760_udc *udc = uep->udc;
712         unsigned long flags;
713         unsigned int type;
714
715         dev_dbg(uep->udc->isp->dev, "%s\n", __func__);
716
717         /*
718          * Validate the descriptor. The control endpoint can't be enabled
719          * manually.
720          */
721         if (desc->bDescriptorType != USB_DT_ENDPOINT ||
722             desc->bEndpointAddress == 0 ||
723             desc->bEndpointAddress != uep->addr ||
724             le16_to_cpu(desc->wMaxPacketSize) > ep->maxpacket) {
725                 dev_dbg(udc->isp->dev,
726                         "%s: invalid descriptor type %u addr %02x ep addr %02x max packet size %u/%u\n",
727                         __func__, desc->bDescriptorType,
728                         desc->bEndpointAddress, uep->addr,
729                         le16_to_cpu(desc->wMaxPacketSize), ep->maxpacket);
730                 return -EINVAL;
731         }
732
733         switch (usb_endpoint_type(desc)) {
734         case USB_ENDPOINT_XFER_ISOC:
735                 type = DC_ENDPTYP_ISOC;
736                 break;
737         case USB_ENDPOINT_XFER_BULK:
738                 type = DC_ENDPTYP_BULK;
739                 break;
740         case USB_ENDPOINT_XFER_INT:
741                 type = DC_ENDPTYP_INTERRUPT;
742                 break;
743         case USB_ENDPOINT_XFER_CONTROL:
744         default:
745                 dev_dbg(udc->isp->dev, "%s: control endpoints unsupported\n",
746                         __func__);
747                 return -EINVAL;
748         }
749
750         spin_lock_irqsave(&udc->lock, flags);
751
752         uep->desc = desc;
753         uep->maxpacket = le16_to_cpu(desc->wMaxPacketSize);
754         uep->rx_pending = false;
755         uep->halted = false;
756         uep->wedged = false;
757
758         isp1760_udc_select_ep(uep);
759         isp1760_udc_write(udc, DC_EPMAXPKTSZ, uep->maxpacket);
760         isp1760_udc_write(udc, DC_BUFLEN, uep->maxpacket);
761         isp1760_udc_write(udc, DC_EPTYPE, DC_EPENABLE | type);
762
763         spin_unlock_irqrestore(&udc->lock, flags);
764
765         return 0;
766 }
767
768 static int isp1760_ep_disable(struct usb_ep *ep)
769 {
770         struct isp1760_ep *uep = ep_to_udc_ep(ep);
771         struct isp1760_udc *udc = uep->udc;
772         struct isp1760_request *req, *nreq;
773         LIST_HEAD(req_list);
774         unsigned long flags;
775
776         dev_dbg(udc->isp->dev, "%s\n", __func__);
777
778         spin_lock_irqsave(&udc->lock, flags);
779
780         if (!uep->desc) {
781                 dev_dbg(udc->isp->dev, "%s: endpoint not enabled\n", __func__);
782                 spin_unlock_irqrestore(&udc->lock, flags);
783                 return -EINVAL;
784         }
785
786         uep->desc = NULL;
787         uep->maxpacket = 0;
788
789         isp1760_udc_select_ep(uep);
790         isp1760_udc_write(udc, DC_EPTYPE, 0);
791
792         /* TODO Synchronize with the IRQ handler */
793
794         list_splice_init(&uep->queue, &req_list);
795
796         spin_unlock_irqrestore(&udc->lock, flags);
797
798         list_for_each_entry_safe(req, nreq, &req_list, queue) {
799                 list_del(&req->queue);
800                 isp1760_udc_request_complete(uep, req, -ESHUTDOWN);
801         }
802
803         return 0;
804 }
805
806 static struct usb_request *isp1760_ep_alloc_request(struct usb_ep *ep,
807                                                     gfp_t gfp_flags)
808 {
809         struct isp1760_request *req;
810
811         req = kzalloc(sizeof(*req), gfp_flags);
812         if (!req)
813                 return NULL;
814
815         return &req->req;
816 }
817
818 static void isp1760_ep_free_request(struct usb_ep *ep, struct usb_request *_req)
819 {
820         struct isp1760_request *req = req_to_udc_req(_req);
821
822         kfree(req);
823 }
824
825 static int isp1760_ep_queue(struct usb_ep *ep, struct usb_request *_req,
826                             gfp_t gfp_flags)
827 {
828         struct isp1760_request *req = req_to_udc_req(_req);
829         struct isp1760_ep *uep = ep_to_udc_ep(ep);
830         struct isp1760_udc *udc = uep->udc;
831         bool complete = false;
832         unsigned long flags;
833         int ret = 0;
834
835         _req->status = -EINPROGRESS;
836         _req->actual = 0;
837
838         spin_lock_irqsave(&udc->lock, flags);
839
840         dev_dbg(udc->isp->dev,
841                 "%s: req %p (%u bytes%s) ep %p(0x%02x)\n", __func__, _req,
842                 _req->length, _req->zero ? " (zlp)" : "", uep, uep->addr);
843
844         req->ep = uep;
845
846         if (uep->addr == 0) {
847                 if (_req->length != udc->ep0_length &&
848                     udc->ep0_state != ISP1760_CTRL_DATA_IN) {
849                         dev_dbg(udc->isp->dev,
850                                 "%s: invalid length %u for req %p\n",
851                                 __func__, _req->length, req);
852                         ret = -EINVAL;
853                         goto done;
854                 }
855
856                 switch (udc->ep0_state) {
857                 case ISP1760_CTRL_DATA_IN:
858                         dev_dbg(udc->isp->dev, "%s: transmitting req %p\n",
859                                 __func__, req);
860
861                         list_add_tail(&req->queue, &uep->queue);
862                         isp1760_udc_transmit(uep, req);
863                         break;
864
865                 case ISP1760_CTRL_DATA_OUT:
866                         list_add_tail(&req->queue, &uep->queue);
867                         __isp1760_udc_select_ep(uep, USB_DIR_OUT);
868                         isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
869                         break;
870
871                 case ISP1760_CTRL_STATUS:
872                         complete = true;
873                         break;
874
875                 default:
876                         dev_dbg(udc->isp->dev, "%s: invalid ep0 state\n",
877                                 __func__);
878                         ret = -EINVAL;
879                         break;
880                 }
881         } else if (uep->desc) {
882                 bool empty = list_empty(&uep->queue);
883
884                 list_add_tail(&req->queue, &uep->queue);
885                 if ((uep->addr & USB_DIR_IN) && !uep->halted && empty)
886                         isp1760_udc_transmit(uep, req);
887                 else if (!(uep->addr & USB_DIR_IN) && uep->rx_pending)
888                         complete = isp1760_udc_receive(uep, req);
889         } else {
890                 dev_dbg(udc->isp->dev,
891                         "%s: can't queue request to disabled ep%02x\n",
892                         __func__, uep->addr);
893                 ret = -ESHUTDOWN;
894         }
895
896 done:
897         if (ret < 0)
898                 req->ep = NULL;
899
900         spin_unlock_irqrestore(&udc->lock, flags);
901
902         if (complete)
903                 isp1760_udc_request_complete(uep, req, 0);
904
905         return ret;
906 }
907
908 static int isp1760_ep_dequeue(struct usb_ep *ep, struct usb_request *_req)
909 {
910         struct isp1760_request *req = req_to_udc_req(_req);
911         struct isp1760_ep *uep = ep_to_udc_ep(ep);
912         struct isp1760_udc *udc = uep->udc;
913         unsigned long flags;
914
915         dev_dbg(uep->udc->isp->dev, "%s(ep%02x)\n", __func__, uep->addr);
916
917         spin_lock_irqsave(&udc->lock, flags);
918
919         if (req->ep != uep)
920                 req = NULL;
921         else
922                 list_del(&req->queue);
923
924         spin_unlock_irqrestore(&udc->lock, flags);
925
926         if (!req)
927                 return -EINVAL;
928
929         isp1760_udc_request_complete(uep, req, -ECONNRESET);
930         return 0;
931 }
932
933 static int __isp1760_ep_set_halt(struct isp1760_ep *uep, bool stall, bool wedge)
934 {
935         struct isp1760_udc *udc = uep->udc;
936         int ret;
937
938         if (!uep->addr) {
939                 /*
940                  * Halting the control endpoint is only valid as a delayed error
941                  * response to a SETUP packet. Make sure EP0 is in the right
942                  * stage and that the gadget isn't trying to clear the halt
943                  * condition.
944                  */
945                 if (WARN_ON(udc->ep0_state == ISP1760_CTRL_SETUP || !stall ||
946                              wedge)) {
947                         return -EINVAL;
948                 }
949         }
950
951         if (uep->addr && !uep->desc) {
952                 dev_dbg(udc->isp->dev, "%s: ep%02x is disabled\n", __func__,
953                         uep->addr);
954                 return -EINVAL;
955         }
956
957         if (uep->addr & USB_DIR_IN) {
958                 /* Refuse to halt IN endpoints with active transfers. */
959                 if (!list_empty(&uep->queue)) {
960                         dev_dbg(udc->isp->dev,
961                                 "%s: ep%02x has request pending\n", __func__,
962                                 uep->addr);
963                         return -EAGAIN;
964                 }
965         }
966
967         ret = __isp1760_udc_set_halt(uep, stall);
968         if (ret < 0)
969                 return ret;
970
971         if (!uep->addr) {
972                 /*
973                  * Stalling EP0 completes the control transaction, move back to
974                  * the SETUP state.
975                  */
976                 udc->ep0_state = ISP1760_CTRL_SETUP;
977                 return 0;
978         }
979
980         if (wedge)
981                 uep->wedged = true;
982         else if (!stall)
983                 uep->wedged = false;
984
985         return 0;
986 }
987
988 static int isp1760_ep_set_halt(struct usb_ep *ep, int value)
989 {
990         struct isp1760_ep *uep = ep_to_udc_ep(ep);
991         unsigned long flags;
992         int ret;
993
994         dev_dbg(uep->udc->isp->dev, "%s: %s halt on ep%02x\n", __func__,
995                 value ? "set" : "clear", uep->addr);
996
997         spin_lock_irqsave(&uep->udc->lock, flags);
998         ret = __isp1760_ep_set_halt(uep, value, false);
999         spin_unlock_irqrestore(&uep->udc->lock, flags);
1000
1001         return ret;
1002 }
1003
1004 static int isp1760_ep_set_wedge(struct usb_ep *ep)
1005 {
1006         struct isp1760_ep *uep = ep_to_udc_ep(ep);
1007         unsigned long flags;
1008         int ret;
1009
1010         dev_dbg(uep->udc->isp->dev, "%s: set wedge on ep%02x)\n", __func__,
1011                 uep->addr);
1012
1013         spin_lock_irqsave(&uep->udc->lock, flags);
1014         ret = __isp1760_ep_set_halt(uep, true, true);
1015         spin_unlock_irqrestore(&uep->udc->lock, flags);
1016
1017         return ret;
1018 }
1019
1020 static void isp1760_ep_fifo_flush(struct usb_ep *ep)
1021 {
1022         struct isp1760_ep *uep = ep_to_udc_ep(ep);
1023         struct isp1760_udc *udc = uep->udc;
1024         unsigned long flags;
1025
1026         spin_lock_irqsave(&udc->lock, flags);
1027
1028         isp1760_udc_select_ep(uep);
1029
1030         /*
1031          * Set the CLBUF bit twice to flush both buffers in case double
1032          * buffering is enabled.
1033          */
1034         isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
1035         isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
1036
1037         spin_unlock_irqrestore(&udc->lock, flags);
1038 }
1039
1040 static const struct usb_ep_ops isp1760_ep_ops = {
1041         .enable = isp1760_ep_enable,
1042         .disable = isp1760_ep_disable,
1043         .alloc_request = isp1760_ep_alloc_request,
1044         .free_request = isp1760_ep_free_request,
1045         .queue = isp1760_ep_queue,
1046         .dequeue = isp1760_ep_dequeue,
1047         .set_halt = isp1760_ep_set_halt,
1048         .set_wedge = isp1760_ep_set_wedge,
1049         .fifo_flush = isp1760_ep_fifo_flush,
1050 };
1051
1052 /* -----------------------------------------------------------------------------
1053  * Device States
1054  */
1055
1056 /* Called with the UDC spinlock held. */
1057 static void isp1760_udc_connect(struct isp1760_udc *udc)
1058 {
1059         usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
1060         mod_timer(&udc->vbus_timer, jiffies + ISP1760_VBUS_POLL_INTERVAL);
1061 }
1062
1063 /* Called with the UDC spinlock held. */
1064 static void isp1760_udc_disconnect(struct isp1760_udc *udc)
1065 {
1066         if (udc->gadget.state < USB_STATE_POWERED)
1067                 return;
1068
1069         dev_dbg(udc->isp->dev, "Device disconnected in state %u\n",
1070                  udc->gadget.state);
1071
1072         udc->gadget.speed = USB_SPEED_UNKNOWN;
1073         usb_gadget_set_state(&udc->gadget, USB_STATE_ATTACHED);
1074
1075         if (udc->driver->disconnect)
1076                 udc->driver->disconnect(&udc->gadget);
1077
1078         del_timer(&udc->vbus_timer);
1079
1080         /* TODO Reset all endpoints ? */
1081 }
1082
1083 static void isp1760_udc_init_hw(struct isp1760_udc *udc)
1084 {
1085         /*
1086          * The device controller currently shares its interrupt with the host
1087          * controller, the DC_IRQ polarity and signaling mode are ignored. Set
1088          * the to active-low level-triggered.
1089          *
1090          * Configure the control, in and out pipes to generate interrupts on
1091          * ACK tokens only (and NYET for the out pipe). The default
1092          * configuration also generates an interrupt on the first NACK token.
1093          */
1094         isp1760_udc_write(udc, DC_INTCONF, DC_CDBGMOD_ACK | DC_DDBGMODIN_ACK |
1095                           DC_DDBGMODOUT_ACK_NYET);
1096
1097         isp1760_udc_write(udc, DC_INTENABLE, DC_IEPRXTX(7) | DC_IEPRXTX(6) |
1098                           DC_IEPRXTX(5) | DC_IEPRXTX(4) | DC_IEPRXTX(3) |
1099                           DC_IEPRXTX(2) | DC_IEPRXTX(1) | DC_IEPRXTX(0) |
1100                           DC_IEP0SETUP | DC_IEVBUS | DC_IERESM | DC_IESUSP |
1101                           DC_IEHS_STA | DC_IEBRST);
1102
1103         if (udc->connected)
1104                 isp1760_set_pullup(udc->isp, true);
1105
1106         isp1760_udc_write(udc, DC_ADDRESS, DC_DEVEN);
1107 }
1108
1109 static void isp1760_udc_reset(struct isp1760_udc *udc)
1110 {
1111         unsigned long flags;
1112
1113         spin_lock_irqsave(&udc->lock, flags);
1114
1115         /*
1116          * The bus reset has reset most registers to their default value,
1117          * reinitialize the UDC hardware.
1118          */
1119         isp1760_udc_init_hw(udc);
1120
1121         udc->ep0_state = ISP1760_CTRL_SETUP;
1122         udc->gadget.speed = USB_SPEED_FULL;
1123
1124         usb_gadget_udc_reset(&udc->gadget, udc->driver);
1125
1126         spin_unlock_irqrestore(&udc->lock, flags);
1127 }
1128
1129 static void isp1760_udc_suspend(struct isp1760_udc *udc)
1130 {
1131         if (udc->gadget.state < USB_STATE_DEFAULT)
1132                 return;
1133
1134         if (udc->driver->suspend)
1135                 udc->driver->suspend(&udc->gadget);
1136 }
1137
1138 static void isp1760_udc_resume(struct isp1760_udc *udc)
1139 {
1140         if (udc->gadget.state < USB_STATE_DEFAULT)
1141                 return;
1142
1143         if (udc->driver->resume)
1144                 udc->driver->resume(&udc->gadget);
1145 }
1146
1147 /* -----------------------------------------------------------------------------
1148  * Gadget Operations
1149  */
1150
1151 static int isp1760_udc_get_frame(struct usb_gadget *gadget)
1152 {
1153         struct isp1760_udc *udc = gadget_to_udc(gadget);
1154
1155         return isp1760_udc_read(udc, DC_FRAMENUM) & ((1 << 11) - 1);
1156 }
1157
1158 static int isp1760_udc_wakeup(struct usb_gadget *gadget)
1159 {
1160         struct isp1760_udc *udc = gadget_to_udc(gadget);
1161
1162         dev_dbg(udc->isp->dev, "%s\n", __func__);
1163         return -ENOTSUPP;
1164 }
1165
1166 static int isp1760_udc_set_selfpowered(struct usb_gadget *gadget,
1167                                        int is_selfpowered)
1168 {
1169         struct isp1760_udc *udc = gadget_to_udc(gadget);
1170
1171         if (is_selfpowered)
1172                 udc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
1173         else
1174                 udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
1175
1176         return 0;
1177 }
1178
1179 static int isp1760_udc_pullup(struct usb_gadget *gadget, int is_on)
1180 {
1181         struct isp1760_udc *udc = gadget_to_udc(gadget);
1182
1183         isp1760_set_pullup(udc->isp, is_on);
1184         udc->connected = is_on;
1185
1186         return 0;
1187 }
1188
1189 static int isp1760_udc_start(struct usb_gadget *gadget,
1190                              struct usb_gadget_driver *driver)
1191 {
1192         struct isp1760_udc *udc = gadget_to_udc(gadget);
1193         unsigned long flags;
1194
1195         /* The hardware doesn't support low speed. */
1196         if (driver->max_speed < USB_SPEED_FULL) {
1197                 dev_err(udc->isp->dev, "Invalid gadget driver\n");
1198                 return -EINVAL;
1199         }
1200
1201         spin_lock_irqsave(&udc->lock, flags);
1202
1203         if (udc->driver) {
1204                 dev_err(udc->isp->dev, "UDC already has a gadget driver\n");
1205                 spin_unlock_irqrestore(&udc->lock, flags);
1206                 return -EBUSY;
1207         }
1208
1209         udc->driver = driver;
1210
1211         spin_unlock_irqrestore(&udc->lock, flags);
1212
1213         dev_dbg(udc->isp->dev, "starting UDC with driver %s\n",
1214                 driver->function);
1215
1216         udc->devstatus = 0;
1217         udc->connected = true;
1218
1219         usb_gadget_set_state(&udc->gadget, USB_STATE_ATTACHED);
1220
1221         /* DMA isn't supported yet, don't enable the DMA clock. */
1222         isp1760_udc_write(udc, DC_MODE, DC_GLINTENA);
1223
1224         isp1760_udc_init_hw(udc);
1225
1226         dev_dbg(udc->isp->dev, "UDC started with driver %s\n",
1227                 driver->function);
1228
1229         return 0;
1230 }
1231
1232 static int isp1760_udc_stop(struct usb_gadget *gadget)
1233 {
1234         struct isp1760_udc *udc = gadget_to_udc(gadget);
1235         unsigned long flags;
1236
1237         dev_dbg(udc->isp->dev, "%s\n", __func__);
1238
1239         del_timer_sync(&udc->vbus_timer);
1240
1241         isp1760_udc_write(udc, DC_MODE, 0);
1242
1243         spin_lock_irqsave(&udc->lock, flags);
1244         udc->driver = NULL;
1245         spin_unlock_irqrestore(&udc->lock, flags);
1246
1247         return 0;
1248 }
1249
1250 static const struct usb_gadget_ops isp1760_udc_ops = {
1251         .get_frame = isp1760_udc_get_frame,
1252         .wakeup = isp1760_udc_wakeup,
1253         .set_selfpowered = isp1760_udc_set_selfpowered,
1254         .pullup = isp1760_udc_pullup,
1255         .udc_start = isp1760_udc_start,
1256         .udc_stop = isp1760_udc_stop,
1257 };
1258
1259 /* -----------------------------------------------------------------------------
1260  * Interrupt Handling
1261  */
1262
1263 static irqreturn_t isp1760_udc_irq(int irq, void *dev)
1264 {
1265         struct isp1760_udc *udc = dev;
1266         unsigned int i;
1267         u32 status;
1268
1269         status = isp1760_udc_read(udc, DC_INTERRUPT)
1270                & isp1760_udc_read(udc, DC_INTENABLE);
1271         isp1760_udc_write(udc, DC_INTERRUPT, status);
1272
1273         if (status & DC_IEVBUS) {
1274                 dev_dbg(udc->isp->dev, "%s(VBUS)\n", __func__);
1275                 /* The VBUS interrupt is only triggered when VBUS appears. */
1276                 spin_lock(&udc->lock);
1277                 isp1760_udc_connect(udc);
1278                 spin_unlock(&udc->lock);
1279         }
1280
1281         if (status & DC_IEBRST) {
1282                 dev_dbg(udc->isp->dev, "%s(BRST)\n", __func__);
1283
1284                 isp1760_udc_reset(udc);
1285         }
1286
1287         for (i = 0; i <= 7; ++i) {
1288                 struct isp1760_ep *ep = &udc->ep[i*2];
1289
1290                 if (status & DC_IEPTX(i)) {
1291                         dev_dbg(udc->isp->dev, "%s(EPTX%u)\n", __func__, i);
1292                         isp1760_ep_tx_complete(ep);
1293                 }
1294
1295                 if (status & DC_IEPRX(i)) {
1296                         dev_dbg(udc->isp->dev, "%s(EPRX%u)\n", __func__, i);
1297                         isp1760_ep_rx_ready(i ? ep - 1 : ep);
1298                 }
1299         }
1300
1301         if (status & DC_IEP0SETUP) {
1302                 dev_dbg(udc->isp->dev, "%s(EP0SETUP)\n", __func__);
1303
1304                 isp1760_ep0_setup(udc);
1305         }
1306
1307         if (status & DC_IERESM) {
1308                 dev_dbg(udc->isp->dev, "%s(RESM)\n", __func__);
1309                 isp1760_udc_resume(udc);
1310         }
1311
1312         if (status & DC_IESUSP) {
1313                 dev_dbg(udc->isp->dev, "%s(SUSP)\n", __func__);
1314
1315                 spin_lock(&udc->lock);
1316                 if (!(isp1760_udc_read(udc, DC_MODE) & DC_VBUSSTAT))
1317                         isp1760_udc_disconnect(udc);
1318                 else
1319                         isp1760_udc_suspend(udc);
1320                 spin_unlock(&udc->lock);
1321         }
1322
1323         if (status & DC_IEHS_STA) {
1324                 dev_dbg(udc->isp->dev, "%s(HS_STA)\n", __func__);
1325                 udc->gadget.speed = USB_SPEED_HIGH;
1326         }
1327
1328         return status ? IRQ_HANDLED : IRQ_NONE;
1329 }
1330
1331 static void isp1760_udc_vbus_poll(struct timer_list *t)
1332 {
1333         struct isp1760_udc *udc = from_timer(udc, t, vbus_timer);
1334         unsigned long flags;
1335
1336         spin_lock_irqsave(&udc->lock, flags);
1337
1338         if (!(isp1760_udc_read(udc, DC_MODE) & DC_VBUSSTAT))
1339                 isp1760_udc_disconnect(udc);
1340         else if (udc->gadget.state >= USB_STATE_POWERED)
1341                 mod_timer(&udc->vbus_timer,
1342                           jiffies + ISP1760_VBUS_POLL_INTERVAL);
1343
1344         spin_unlock_irqrestore(&udc->lock, flags);
1345 }
1346
1347 /* -----------------------------------------------------------------------------
1348  * Registration
1349  */
1350
1351 static void isp1760_udc_init_eps(struct isp1760_udc *udc)
1352 {
1353         unsigned int i;
1354
1355         INIT_LIST_HEAD(&udc->gadget.ep_list);
1356
1357         for (i = 0; i < ARRAY_SIZE(udc->ep); ++i) {
1358                 struct isp1760_ep *ep = &udc->ep[i];
1359                 unsigned int ep_num = (i + 1) / 2;
1360                 bool is_in = !(i & 1);
1361
1362                 ep->udc = udc;
1363
1364                 INIT_LIST_HEAD(&ep->queue);
1365
1366                 ep->addr = (ep_num && is_in ? USB_DIR_IN : USB_DIR_OUT)
1367                          | ep_num;
1368                 ep->desc = NULL;
1369
1370                 sprintf(ep->name, "ep%u%s", ep_num,
1371                         ep_num ? (is_in ? "in" : "out") : "");
1372
1373                 ep->ep.ops = &isp1760_ep_ops;
1374                 ep->ep.name = ep->name;
1375
1376                 /*
1377                  * Hardcode the maximum packet sizes for now, to 64 bytes for
1378                  * the control endpoint and 512 bytes for all other endpoints.
1379                  * This fits in the 8kB FIFO without double-buffering.
1380                  */
1381                 if (ep_num == 0) {
1382                         usb_ep_set_maxpacket_limit(&ep->ep, 64);
1383                         ep->ep.caps.type_control = true;
1384                         ep->ep.caps.dir_in = true;
1385                         ep->ep.caps.dir_out = true;
1386                         ep->maxpacket = 64;
1387                         udc->gadget.ep0 = &ep->ep;
1388                 } else {
1389                         usb_ep_set_maxpacket_limit(&ep->ep, 512);
1390                         ep->ep.caps.type_iso = true;
1391                         ep->ep.caps.type_bulk = true;
1392                         ep->ep.caps.type_int = true;
1393                         ep->maxpacket = 0;
1394                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
1395                 }
1396
1397                 if (is_in)
1398                         ep->ep.caps.dir_in = true;
1399                 else
1400                         ep->ep.caps.dir_out = true;
1401         }
1402 }
1403
1404 static int isp1760_udc_init(struct isp1760_udc *udc)
1405 {
1406         u16 scratch;
1407         u32 chipid;
1408
1409         /*
1410          * Check that the controller is present by writing to the scratch
1411          * register, modifying the bus pattern by reading from the chip ID
1412          * register, and reading the scratch register value back. The chip ID
1413          * and scratch register contents must match the expected values.
1414          */
1415         isp1760_udc_write(udc, DC_SCRATCH, 0xbabe);
1416         chipid = isp1760_udc_read(udc, DC_CHIPID);
1417         scratch = isp1760_udc_read(udc, DC_SCRATCH);
1418
1419         if (scratch != 0xbabe) {
1420                 dev_err(udc->isp->dev,
1421                         "udc: scratch test failed (0x%04x/0x%08x)\n",
1422                         scratch, chipid);
1423                 return -ENODEV;
1424         }
1425
1426         if (chipid != 0x00011582 && chipid != 0x00158210) {
1427                 dev_err(udc->isp->dev, "udc: invalid chip ID 0x%08x\n", chipid);
1428                 return -ENODEV;
1429         }
1430
1431         /* Reset the device controller. */
1432         isp1760_udc_write(udc, DC_MODE, DC_SFRESET);
1433         usleep_range(10000, 11000);
1434         isp1760_udc_write(udc, DC_MODE, 0);
1435         usleep_range(10000, 11000);
1436
1437         return 0;
1438 }
1439
1440 int isp1760_udc_register(struct isp1760_device *isp, int irq,
1441                          unsigned long irqflags)
1442 {
1443         struct isp1760_udc *udc = &isp->udc;
1444         int ret;
1445
1446         udc->irq = -1;
1447         udc->isp = isp;
1448         udc->regs = isp->regs;
1449
1450         spin_lock_init(&udc->lock);
1451         timer_setup(&udc->vbus_timer, isp1760_udc_vbus_poll, 0);
1452
1453         ret = isp1760_udc_init(udc);
1454         if (ret < 0)
1455                 return ret;
1456
1457         udc->irqname = kasprintf(GFP_KERNEL, "%s (udc)", dev_name(isp->dev));
1458         if (!udc->irqname)
1459                 return -ENOMEM;
1460
1461         ret = request_irq(irq, isp1760_udc_irq, IRQF_SHARED | irqflags,
1462                           udc->irqname, udc);
1463         if (ret < 0)
1464                 goto error;
1465
1466         udc->irq = irq;
1467
1468         /*
1469          * Initialize the gadget static fields and register its device. Gadget
1470          * fields that vary during the life time of the gadget are initialized
1471          * by the UDC core.
1472          */
1473         udc->gadget.ops = &isp1760_udc_ops;
1474         udc->gadget.speed = USB_SPEED_UNKNOWN;
1475         udc->gadget.max_speed = USB_SPEED_HIGH;
1476         udc->gadget.name = "isp1761_udc";
1477
1478         isp1760_udc_init_eps(udc);
1479
1480         ret = usb_add_gadget_udc(isp->dev, &udc->gadget);
1481         if (ret < 0)
1482                 goto error;
1483
1484         return 0;
1485
1486 error:
1487         if (udc->irq >= 0)
1488                 free_irq(udc->irq, udc);
1489         kfree(udc->irqname);
1490
1491         return ret;
1492 }
1493
1494 void isp1760_udc_unregister(struct isp1760_device *isp)
1495 {
1496         struct isp1760_udc *udc = &isp->udc;
1497
1498         if (!udc->isp)
1499                 return;
1500
1501         usb_del_gadget_udc(&udc->gadget);
1502
1503         free_irq(udc->irq, udc);
1504         kfree(udc->irqname);
1505 }