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