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