1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/platform_device.h>
25
26#include "lh7a40x_udc.h"
27
28
29
30
31
32#ifndef DEBUG_EP0
33# define DEBUG_EP0(fmt,args...)
34#endif
35#ifndef DEBUG_SETUP
36# define DEBUG_SETUP(fmt,args...)
37#endif
38#ifndef DEBUG
39# define NO_STATES
40# define DEBUG(fmt,args...)
41#endif
42
43#define DRIVER_DESC "LH7A40x USB Device Controller"
44#define DRIVER_VERSION __DATE__
45
46#ifndef _BIT
47#define _BIT(x) (1<<(x))
48#endif
49
50struct lh7a40x_udc *the_controller;
51
52static const char driver_name[] = "lh7a40x_udc";
53static const char driver_desc[] = DRIVER_DESC;
54static const char ep0name[] = "ep0-control";
55
56
57
58
59
60#ifndef NO_STATES
61static char *state_names[] = {
62 "WAIT_FOR_SETUP",
63 "DATA_STATE_XMIT",
64 "DATA_STATE_NEED_ZLP",
65 "WAIT_FOR_OUT_STATUS",
66 "DATA_STATE_RECV"
67};
68#endif
69
70
71
72
73static int lh7a40x_ep_enable(struct usb_ep *ep,
74 const struct usb_endpoint_descriptor *);
75static int lh7a40x_ep_disable(struct usb_ep *ep);
76static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep, gfp_t);
77static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *);
78static int lh7a40x_queue(struct usb_ep *ep, struct usb_request *, gfp_t);
79static int lh7a40x_dequeue(struct usb_ep *ep, struct usb_request *);
80static int lh7a40x_set_halt(struct usb_ep *ep, int);
81static int lh7a40x_fifo_status(struct usb_ep *ep);
82static void lh7a40x_fifo_flush(struct usb_ep *ep);
83static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep);
84static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr);
85
86static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req,
87 int status);
88static void pio_irq_enable(int bEndpointAddress);
89static void pio_irq_disable(int bEndpointAddress);
90static void stop_activity(struct lh7a40x_udc *dev,
91 struct usb_gadget_driver *driver);
92static void flush(struct lh7a40x_ep *ep);
93static void udc_enable(struct lh7a40x_udc *dev);
94static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address);
95
96static struct usb_ep_ops lh7a40x_ep_ops = {
97 .enable = lh7a40x_ep_enable,
98 .disable = lh7a40x_ep_disable,
99
100 .alloc_request = lh7a40x_alloc_request,
101 .free_request = lh7a40x_free_request,
102
103 .queue = lh7a40x_queue,
104 .dequeue = lh7a40x_dequeue,
105
106 .set_halt = lh7a40x_set_halt,
107 .fifo_status = lh7a40x_fifo_status,
108 .fifo_flush = lh7a40x_fifo_flush,
109};
110
111
112
113static __inline__ int write_packet(struct lh7a40x_ep *ep,
114 struct lh7a40x_request *req, int max)
115{
116 u8 *buf;
117 int length, count;
118 volatile u32 *fifo = (volatile u32 *)ep->fifo;
119
120 buf = req->req.buf + req->req.actual;
121 prefetch(buf);
122
123 length = req->req.length - req->req.actual;
124 length = min(length, max);
125 req->req.actual += length;
126
127 DEBUG("Write %d (max %d), fifo %p\n", length, max, fifo);
128
129 count = length;
130 while (count--) {
131 *fifo = *buf++;
132 }
133
134 return length;
135}
136
137static __inline__ void usb_set_index(u32 ep)
138{
139 *(volatile u32 *)io_p2v(USB_INDEX) = ep;
140}
141
142static __inline__ u32 usb_read(u32 port)
143{
144 return *(volatile u32 *)io_p2v(port);
145}
146
147static __inline__ void usb_write(u32 val, u32 port)
148{
149 *(volatile u32 *)io_p2v(port) = val;
150}
151
152static __inline__ void usb_set(u32 val, u32 port)
153{
154 volatile u32 *ioport = (volatile u32 *)io_p2v(port);
155 u32 after = (*ioport) | val;
156 *ioport = after;
157}
158
159static __inline__ void usb_clear(u32 val, u32 port)
160{
161 volatile u32 *ioport = (volatile u32 *)io_p2v(port);
162 u32 after = (*ioport) & ~val;
163 *ioport = after;
164}
165
166
167
168#define GPIO_PORTC_DR (0x80000E08)
169#define GPIO_PORTC_DDR (0x80000E18)
170#define GPIO_PORTC_PDR (0x80000E70)
171
172
173#define get_portc_pdr(bit) ((usb_read(GPIO_PORTC_PDR) & _BIT(bit)) != 0)
174
175#define get_portc_ddr(bit) ((usb_read(GPIO_PORTC_DDR) & _BIT(bit)) != 0)
176
177#define set_portc_dr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DR) : usb_clear(_BIT(bit), GPIO_PORTC_DR))
178
179#define set_portc_ddr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DDR) : usb_clear(_BIT(bit), GPIO_PORTC_DDR))
180
181
182
183
184
185
186#define is_usb_connected() get_portc_pdr(2)
187
188#ifdef CONFIG_USB_GADGET_DEBUG_FILES
189
190static const char proc_node_name[] = "driver/udc";
191
192static int
193udc_proc_read(char *page, char **start, off_t off, int count,
194 int *eof, void *_dev)
195{
196 char *buf = page;
197 struct lh7a40x_udc *dev = _dev;
198 char *next = buf;
199 unsigned size = count;
200 unsigned long flags;
201 int t;
202
203 if (off != 0)
204 return 0;
205
206 local_irq_save(flags);
207
208
209 t = scnprintf(next, size,
210 DRIVER_DESC "\n"
211 "%s version: %s\n"
212 "Gadget driver: %s\n"
213 "Host: %s\n\n",
214 driver_name, DRIVER_VERSION,
215 dev->driver ? dev->driver->driver.name : "(none)",
216 is_usb_connected()? "full speed" : "disconnected");
217 size -= t;
218 next += t;
219
220 t = scnprintf(next, size,
221 "GPIO:\n"
222 " Port C bit 1: %d, dir %d\n"
223 " Port C bit 2: %d, dir %d\n\n",
224 get_portc_pdr(1), get_portc_ddr(1),
225 get_portc_pdr(2), get_portc_ddr(2)
226 );
227 size -= t;
228 next += t;
229
230 t = scnprintf(next, size,
231 "DCP pullup: %d\n\n",
232 (usb_read(USB_PM) & PM_USB_DCP) != 0);
233 size -= t;
234 next += t;
235
236 local_irq_restore(flags);
237 *eof = 1;
238 return count - size;
239}
240
241#define create_proc_files() create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev)
242#define remove_proc_files() remove_proc_entry(proc_node_name, NULL)
243
244#else
245
246#define create_proc_files() do {} while (0)
247#define remove_proc_files() do {} while (0)
248
249#endif
250
251
252
253
254static void udc_disable(struct lh7a40x_udc *dev)
255{
256 DEBUG("%s, %p\n", __func__, dev);
257
258 udc_set_address(dev, 0);
259
260
261 usb_write(0, USB_IN_INT_EN);
262 usb_write(0, USB_OUT_INT_EN);
263 usb_write(0, USB_INT_EN);
264
265
266 usb_write(0, USB_PM);
267
268#ifdef CONFIG_ARCH_LH7A404
269
270 set_portc_dr(1, 0);
271#endif
272
273
274
275
276 dev->ep0state = WAIT_FOR_SETUP;
277 dev->gadget.speed = USB_SPEED_UNKNOWN;
278 dev->usb_address = 0;
279}
280
281
282
283
284static void udc_reinit(struct lh7a40x_udc *dev)
285{
286 u32 i;
287
288 DEBUG("%s, %p\n", __func__, dev);
289
290
291 INIT_LIST_HEAD(&dev->gadget.ep_list);
292 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
293 dev->ep0state = WAIT_FOR_SETUP;
294
295
296 for (i = 0; i < UDC_MAX_ENDPOINTS; i++) {
297 struct lh7a40x_ep *ep = &dev->ep[i];
298
299 if (i != 0)
300 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
301
302 ep->desc = 0;
303 ep->stopped = 0;
304 INIT_LIST_HEAD(&ep->queue);
305 ep->pio_irqs = 0;
306 }
307
308
309}
310
311#define BYTES2MAXP(x) (x / 8)
312#define MAXP2BYTES(x) (x * 8)
313
314
315
316
317static void udc_enable(struct lh7a40x_udc *dev)
318{
319 int ep;
320
321 DEBUG("%s, %p\n", __func__, dev);
322
323 dev->gadget.speed = USB_SPEED_UNKNOWN;
324
325#ifdef CONFIG_ARCH_LH7A404
326
327 set_portc_ddr(1, 1);
328 set_portc_ddr(2, 1);
329
330
331 set_portc_dr(1, 0);
332#endif
333
334
335
336
337
338
339 usb_clear(PM_USB_ENABLE, USB_PM);
340
341
342 usb_set(USB_RESET_APB | USB_RESET_IO, USB_RESET);
343 mdelay(5);
344 usb_clear(USB_RESET_APB | USB_RESET_IO, USB_RESET);
345
346
347 for (ep = 0; ep < UDC_MAX_ENDPOINTS; ep++) {
348 struct lh7a40x_ep *ep_reg = &dev->ep[ep];
349 u32 csr;
350
351 usb_set_index(ep);
352
353 switch (ep_reg->ep_type) {
354 case ep_bulk_in:
355 case ep_interrupt:
356 usb_clear(USB_IN_CSR2_USB_DMA_EN | USB_IN_CSR2_AUTO_SET,
357 ep_reg->csr2);
358
359 case ep_control:
360 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)),
361 USB_IN_MAXP);
362 break;
363 case ep_bulk_out:
364 usb_clear(USB_OUT_CSR2_USB_DMA_EN |
365 USB_OUT_CSR2_AUTO_CLR, ep_reg->csr2);
366 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)),
367 USB_OUT_MAXP);
368 break;
369 }
370
371
372 csr = usb_read(ep_reg->csr1);
373 usb_write(csr, ep_reg->csr1);
374
375 flush(ep_reg);
376 }
377
378
379 usb_write(0, USB_IN_INT_EN);
380 usb_write(0, USB_OUT_INT_EN);
381 usb_write(0, USB_INT_EN);
382
383
384 usb_set(USB_IN_INT_EP0, USB_IN_INT_EN);
385 usb_set(USB_INT_RESET_INT | USB_INT_RESUME_INT, USB_INT_EN);
386
387
388
389
390
391 usb_set(PM_ENABLE_SUSPEND, USB_PM);
392
393
394 usb_set(PM_USB_ENABLE, USB_PM);
395
396#ifdef CONFIG_ARCH_LH7A404
397
398
399
400
401
402
403
404#endif
405}
406
407
408
409
410int usb_gadget_register_driver(struct usb_gadget_driver *driver)
411{
412 struct lh7a40x_udc *dev = the_controller;
413 int retval;
414
415 DEBUG("%s: %s\n", __func__, driver->driver.name);
416
417 if (!driver
418 || driver->speed != USB_SPEED_FULL
419 || !driver->bind
420 || !driver->disconnect
421 || !driver->setup)
422 return -EINVAL;
423 if (!dev)
424 return -ENODEV;
425 if (dev->driver)
426 return -EBUSY;
427
428
429 dev->driver = driver;
430 dev->gadget.dev.driver = &driver->driver;
431
432 device_add(&dev->gadget.dev);
433 retval = driver->bind(&dev->gadget);
434 if (retval) {
435 printk(KERN_WARNING "%s: bind to driver %s --> error %d\n",
436 dev->gadget.name, driver->driver.name, retval);
437 device_del(&dev->gadget.dev);
438
439 dev->driver = 0;
440 dev->gadget.dev.driver = 0;
441 return retval;
442 }
443
444
445
446
447
448 printk(KERN_WARNING "%s: registered gadget driver '%s'\n",
449 dev->gadget.name, driver->driver.name);
450
451 udc_enable(dev);
452
453 return 0;
454}
455
456EXPORT_SYMBOL(usb_gadget_register_driver);
457
458
459
460
461int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
462{
463 struct lh7a40x_udc *dev = the_controller;
464 unsigned long flags;
465
466 if (!dev)
467 return -ENODEV;
468 if (!driver || driver != dev->driver || !driver->unbind)
469 return -EINVAL;
470
471 spin_lock_irqsave(&dev->lock, flags);
472 dev->driver = 0;
473 stop_activity(dev, driver);
474 spin_unlock_irqrestore(&dev->lock, flags);
475
476 driver->unbind(&dev->gadget);
477 dev->gadget.dev.driver = NULL;
478 device_del(&dev->gadget.dev);
479
480 udc_disable(dev);
481
482 DEBUG("unregistered gadget driver '%s'\n", driver->driver.name);
483 return 0;
484}
485
486EXPORT_SYMBOL(usb_gadget_unregister_driver);
487
488
489
490
491
492
493
494static int write_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
495{
496 u32 max;
497 u32 csr;
498
499 max = le16_to_cpu(ep->desc->wMaxPacketSize);
500
501 csr = usb_read(ep->csr1);
502 DEBUG("CSR: %x %d\n", csr, csr & USB_IN_CSR1_FIFO_NOT_EMPTY);
503
504 if (!(csr & USB_IN_CSR1_FIFO_NOT_EMPTY)) {
505 unsigned count;
506 int is_last, is_short;
507
508 count = write_packet(ep, req, max);
509 usb_set(USB_IN_CSR1_IN_PKT_RDY, ep->csr1);
510
511
512 if (unlikely(count != max))
513 is_last = is_short = 1;
514 else {
515 if (likely(req->req.length != req->req.actual)
516 || req->req.zero)
517 is_last = 0;
518 else
519 is_last = 1;
520
521 is_short = unlikely(max < ep_maxpacket(ep));
522 }
523
524 DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __func__,
525 ep->ep.name, count,
526 is_last ? "/L" : "", is_short ? "/S" : "",
527 req->req.length - req->req.actual, req);
528
529
530 if (is_last) {
531 done(ep, req, 0);
532 if (list_empty(&ep->queue)) {
533 pio_irq_disable(ep_index(ep));
534 }
535 return 1;
536 }
537 } else {
538 DEBUG("Hmm.. %d ep FIFO is not empty!\n", ep_index(ep));
539 }
540
541 return 0;
542}
543
544
545
546
547
548static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
549{
550 u32 csr;
551 u8 *buf;
552 unsigned bufferspace, count, is_short;
553 volatile u32 *fifo = (volatile u32 *)ep->fifo;
554
555
556 csr = usb_read(ep->csr1);
557 if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) {
558 DEBUG("%s: Packet NOT ready!\n", __func__);
559 return -EINVAL;
560 }
561
562 buf = req->req.buf + req->req.actual;
563 prefetchw(buf);
564 bufferspace = req->req.length - req->req.actual;
565
566
567 count = usb_read(USB_OUT_FIFO_WC1);
568 req->req.actual += min(count, bufferspace);
569
570 is_short = (count < ep->ep.maxpacket);
571 DEBUG("read %s %02x, %d bytes%s req %p %d/%d\n",
572 ep->ep.name, csr, count,
573 is_short ? "/S" : "", req, req->req.actual, req->req.length);
574
575 while (likely(count-- != 0)) {
576 u8 byte = (u8) (*fifo & 0xff);
577
578 if (unlikely(bufferspace == 0)) {
579
580
581
582
583 if (req->req.status != -EOVERFLOW)
584 printk(KERN_WARNING "%s overflow %d\n",
585 ep->ep.name, count);
586 req->req.status = -EOVERFLOW;
587 } else {
588 *buf++ = byte;
589 bufferspace--;
590 }
591 }
592
593 usb_clear(USB_OUT_CSR1_OUT_PKT_RDY, ep->csr1);
594
595
596 if (is_short || req->req.actual == req->req.length) {
597 done(ep, req, 0);
598 usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
599
600 if (list_empty(&ep->queue))
601 pio_irq_disable(ep_index(ep));
602 return 1;
603 }
604
605
606 return 0;
607}
608
609
610
611
612
613static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status)
614{
615 unsigned int stopped = ep->stopped;
616 u32 index;
617
618 DEBUG("%s, %p\n", __func__, ep);
619 list_del_init(&req->queue);
620
621 if (likely(req->req.status == -EINPROGRESS))
622 req->req.status = status;
623 else
624 status = req->req.status;
625
626 if (status && status != -ESHUTDOWN)
627 DEBUG("complete %s req %p stat %d len %u/%u\n",
628 ep->ep.name, &req->req, status,
629 req->req.actual, req->req.length);
630
631
632 ep->stopped = 1;
633
634 index = usb_read(USB_INDEX);
635
636 spin_unlock(&ep->dev->lock);
637 req->req.complete(&ep->ep, &req->req);
638 spin_lock(&ep->dev->lock);
639
640
641 usb_set_index(index);
642 ep->stopped = stopped;
643}
644
645
646static void pio_irq_enable(int ep)
647{
648 DEBUG("%s: %d\n", __func__, ep);
649
650 switch (ep) {
651 case 1:
652 usb_set(USB_IN_INT_EP1, USB_IN_INT_EN);
653 break;
654 case 2:
655 usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN);
656 break;
657 case 3:
658 usb_set(USB_IN_INT_EP3, USB_IN_INT_EN);
659 break;
660 default:
661 DEBUG("Unknown endpoint: %d\n", ep);
662 break;
663 }
664}
665
666
667static void pio_irq_disable(int ep)
668{
669 DEBUG("%s: %d\n", __func__, ep);
670
671 switch (ep) {
672 case 1:
673 usb_clear(USB_IN_INT_EP1, USB_IN_INT_EN);
674 break;
675 case 2:
676 usb_clear(USB_OUT_INT_EP2, USB_OUT_INT_EN);
677 break;
678 case 3:
679 usb_clear(USB_IN_INT_EP3, USB_IN_INT_EN);
680 break;
681 default:
682 DEBUG("Unknown endpoint: %d\n", ep);
683 break;
684 }
685}
686
687
688
689
690void nuke(struct lh7a40x_ep *ep, int status)
691{
692 struct lh7a40x_request *req;
693
694 DEBUG("%s, %p\n", __func__, ep);
695
696
697 flush(ep);
698
699
700 while (!list_empty(&ep->queue)) {
701 req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
702 done(ep, req, status);
703 }
704
705
706 if (ep->desc)
707 pio_irq_disable(ep_index(ep));
708}
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736static void flush(struct lh7a40x_ep *ep)
737{
738 DEBUG("%s, %p\n", __func__, ep);
739
740 switch (ep->ep_type) {
741 case ep_control:
742
743 break;
744
745 case ep_bulk_in:
746 case ep_interrupt:
747
748 usb_set(USB_IN_CSR1_FIFO_FLUSH, ep->csr1);
749 break;
750
751 case ep_bulk_out:
752
753 usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
754 break;
755 }
756}
757
758
759
760
761static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
762{
763 u32 csr;
764 struct lh7a40x_ep *ep = &dev->ep[ep_idx];
765 struct lh7a40x_request *req;
766
767 usb_set_index(ep_idx);
768
769 csr = usb_read(ep->csr1);
770 DEBUG("%s: %d, csr %x\n", __func__, ep_idx, csr);
771
772 if (csr & USB_IN_CSR1_SENT_STALL) {
773 DEBUG("USB_IN_CSR1_SENT_STALL\n");
774 usb_set(USB_IN_CSR1_SENT_STALL ,
775 ep->csr1);
776 return;
777 }
778
779 if (!ep->desc) {
780 DEBUG("%s: NO EP DESC\n", __func__);
781 return;
782 }
783
784 if (list_empty(&ep->queue))
785 req = 0;
786 else
787 req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
788
789 DEBUG("req: %p\n", req);
790
791 if (!req)
792 return;
793
794 write_fifo(ep, req);
795}
796
797
798
799
800
801static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
802{
803 struct lh7a40x_ep *ep = &dev->ep[ep_idx];
804 struct lh7a40x_request *req;
805
806 DEBUG("%s: %d\n", __func__, ep_idx);
807
808 usb_set_index(ep_idx);
809
810 if (ep->desc) {
811 u32 csr;
812 csr = usb_read(ep->csr1);
813
814 while ((csr =
815 usb_read(ep->
816 csr1)) & (USB_OUT_CSR1_OUT_PKT_RDY |
817 USB_OUT_CSR1_SENT_STALL)) {
818 DEBUG("%s: %x\n", __func__, csr);
819
820 if (csr & USB_OUT_CSR1_SENT_STALL) {
821 DEBUG("%s: stall sent, flush fifo\n",
822 __func__);
823
824 flush(ep);
825 } else if (csr & USB_OUT_CSR1_OUT_PKT_RDY) {
826 if (list_empty(&ep->queue))
827 req = 0;
828 else
829 req =
830 list_entry(ep->queue.next,
831 struct lh7a40x_request,
832 queue);
833
834 if (!req) {
835 printk(KERN_WARNING
836 "%s: NULL REQ %d\n",
837 __func__, ep_idx);
838 flush(ep);
839 break;
840 } else {
841 read_fifo(ep, req);
842 }
843 }
844
845 }
846
847 } else {
848
849 printk(KERN_WARNING "%s: No descriptor?!?\n", __func__);
850 flush(ep);
851 }
852}
853
854static void stop_activity(struct lh7a40x_udc *dev,
855 struct usb_gadget_driver *driver)
856{
857 int i;
858
859
860 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
861 driver = 0;
862 dev->gadget.speed = USB_SPEED_UNKNOWN;
863
864
865 for (i = 0; i < UDC_MAX_ENDPOINTS; i++) {
866 struct lh7a40x_ep *ep = &dev->ep[i];
867 ep->stopped = 1;
868
869 usb_set_index(i);
870 nuke(ep, -ESHUTDOWN);
871 }
872
873
874 if (driver) {
875 spin_unlock(&dev->lock);
876 driver->disconnect(&dev->gadget);
877 spin_lock(&dev->lock);
878 }
879
880
881 udc_reinit(dev);
882}
883
884
885
886static void lh7a40x_reset_intr(struct lh7a40x_udc *dev)
887{
888#if 0
889
890
891 DEBUG("%s: %d\n", __func__, dev->usb_address);
892
893 if (!dev->usb_address) {
894
895
896
897 return;
898 }
899
900 usb_set(USB_RESET_IO, USB_RESET);
901
902
903 udc_set_address(dev, 0);
904
905
906 mdelay(5);
907
908
909 usb_clear(USB_RESET_IO, USB_RESET);
910
911
912 udc_enable(dev);
913
914#endif
915 dev->gadget.speed = USB_SPEED_FULL;
916}
917
918
919
920
921static irqreturn_t lh7a40x_udc_irq(int irq, void *_dev)
922{
923 struct lh7a40x_udc *dev = _dev;
924
925 DEBUG("\n\n");
926
927 spin_lock(&dev->lock);
928
929 for (;;) {
930 u32 intr_in = usb_read(USB_IN_INT);
931 u32 intr_out = usb_read(USB_OUT_INT);
932 u32 intr_int = usb_read(USB_INT);
933
934
935 u32 in_en = usb_read(USB_IN_INT_EN);
936 u32 out_en = usb_read(USB_OUT_INT_EN);
937
938 if (!intr_out && !intr_in && !intr_int)
939 break;
940
941 DEBUG("%s (on state %s)\n", __func__,
942 state_names[dev->ep0state]);
943 DEBUG("intr_out = %x\n", intr_out);
944 DEBUG("intr_in = %x\n", intr_in);
945 DEBUG("intr_int = %x\n", intr_int);
946
947 if (intr_in) {
948 usb_write(intr_in, USB_IN_INT);
949
950 if ((intr_in & USB_IN_INT_EP1)
951 && (in_en & USB_IN_INT_EP1)) {
952 DEBUG("USB_IN_INT_EP1\n");
953 lh7a40x_in_epn(dev, 1, intr_in);
954 }
955 if ((intr_in & USB_IN_INT_EP3)
956 && (in_en & USB_IN_INT_EP3)) {
957 DEBUG("USB_IN_INT_EP3\n");
958 lh7a40x_in_epn(dev, 3, intr_in);
959 }
960 if (intr_in & USB_IN_INT_EP0) {
961 DEBUG("USB_IN_INT_EP0 (control)\n");
962 lh7a40x_handle_ep0(dev, intr_in);
963 }
964 }
965
966 if (intr_out) {
967 usb_write(intr_out, USB_OUT_INT);
968
969 if ((intr_out & USB_OUT_INT_EP2)
970 && (out_en & USB_OUT_INT_EP2)) {
971 DEBUG("USB_OUT_INT_EP2\n");
972 lh7a40x_out_epn(dev, 2, intr_out);
973 }
974 }
975
976 if (intr_int) {
977 usb_write(intr_int, USB_INT);
978
979 if (intr_int & USB_INT_RESET_INT) {
980 lh7a40x_reset_intr(dev);
981 }
982
983 if (intr_int & USB_INT_RESUME_INT) {
984 DEBUG("USB resume\n");
985
986 if (dev->gadget.speed != USB_SPEED_UNKNOWN
987 && dev->driver
988 && dev->driver->resume
989 && is_usb_connected()) {
990 dev->driver->resume(&dev->gadget);
991 }
992 }
993
994 if (intr_int & USB_INT_SUSPEND_INT) {
995 DEBUG("USB suspend%s\n",
996 is_usb_connected()? "" : "+disconnect");
997 if (!is_usb_connected()) {
998 stop_activity(dev, dev->driver);
999 } else if (dev->gadget.speed !=
1000 USB_SPEED_UNKNOWN && dev->driver
1001 && dev->driver->suspend) {
1002 dev->driver->suspend(&dev->gadget);
1003 }
1004 }
1005
1006 }
1007 }
1008
1009 spin_unlock(&dev->lock);
1010
1011 return IRQ_HANDLED;
1012}
1013
1014static int lh7a40x_ep_enable(struct usb_ep *_ep,
1015 const struct usb_endpoint_descriptor *desc)
1016{
1017 struct lh7a40x_ep *ep;
1018 struct lh7a40x_udc *dev;
1019 unsigned long flags;
1020
1021 DEBUG("%s, %p\n", __func__, _ep);
1022
1023 ep = container_of(_ep, struct lh7a40x_ep, ep);
1024 if (!_ep || !desc || ep->desc || _ep->name == ep0name
1025 || desc->bDescriptorType != USB_DT_ENDPOINT
1026 || ep->bEndpointAddress != desc->bEndpointAddress
1027 || ep_maxpacket(ep) < le16_to_cpu(desc->wMaxPacketSize)) {
1028 DEBUG("%s, bad ep or descriptor\n", __func__);
1029 return -EINVAL;
1030 }
1031
1032
1033 if (ep->bmAttributes != desc->bmAttributes
1034 && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
1035 && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
1036 DEBUG("%s, %s type mismatch\n", __func__, _ep->name);
1037 return -EINVAL;
1038 }
1039
1040
1041 if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
1042 && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(ep))
1043 || !desc->wMaxPacketSize) {
1044 DEBUG("%s, bad %s maxpacket\n", __func__, _ep->name);
1045 return -ERANGE;
1046 }
1047
1048 dev = ep->dev;
1049 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
1050 DEBUG("%s, bogus device state\n", __func__);
1051 return -ESHUTDOWN;
1052 }
1053
1054 spin_lock_irqsave(&ep->dev->lock, flags);
1055
1056 ep->stopped = 0;
1057 ep->desc = desc;
1058 ep->pio_irqs = 0;
1059 ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
1060
1061 spin_unlock_irqrestore(&ep->dev->lock, flags);
1062
1063
1064 lh7a40x_set_halt(_ep, 0);
1065
1066 DEBUG("%s: enabled %s\n", __func__, _ep->name);
1067 return 0;
1068}
1069
1070
1071
1072
1073static int lh7a40x_ep_disable(struct usb_ep *_ep)
1074{
1075 struct lh7a40x_ep *ep;
1076 unsigned long flags;
1077
1078 DEBUG("%s, %p\n", __func__, _ep);
1079
1080 ep = container_of(_ep, struct lh7a40x_ep, ep);
1081 if (!_ep || !ep->desc) {
1082 DEBUG("%s, %s not enabled\n", __func__,
1083 _ep ? ep->ep.name : NULL);
1084 return -EINVAL;
1085 }
1086
1087 spin_lock_irqsave(&ep->dev->lock, flags);
1088
1089 usb_set_index(ep_index(ep));
1090
1091
1092 nuke(ep, -ESHUTDOWN);
1093
1094
1095 pio_irq_disable(ep_index(ep));
1096
1097 ep->desc = 0;
1098 ep->stopped = 1;
1099
1100 spin_unlock_irqrestore(&ep->dev->lock, flags);
1101
1102 DEBUG("%s: disabled %s\n", __func__, _ep->name);
1103 return 0;
1104}
1105
1106static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep,
1107 gfp_t gfp_flags)
1108{
1109 struct lh7a40x_request *req;
1110
1111 DEBUG("%s, %p\n", __func__, ep);
1112
1113 req = kzalloc(sizeof(*req), gfp_flags);
1114 if (!req)
1115 return 0;
1116
1117 INIT_LIST_HEAD(&req->queue);
1118
1119 return &req->req;
1120}
1121
1122static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *_req)
1123{
1124 struct lh7a40x_request *req;
1125
1126 DEBUG("%s, %p\n", __func__, ep);
1127
1128 req = container_of(_req, struct lh7a40x_request, req);
1129 WARN_ON(!list_empty(&req->queue));
1130 kfree(req);
1131}
1132
1133
1134
1135
1136
1137static int lh7a40x_queue(struct usb_ep *_ep, struct usb_request *_req,
1138 gfp_t gfp_flags)
1139{
1140 struct lh7a40x_request *req;
1141 struct lh7a40x_ep *ep;
1142 struct lh7a40x_udc *dev;
1143 unsigned long flags;
1144
1145 DEBUG("\n\n\n%s, %p\n", __func__, _ep);
1146
1147 req = container_of(_req, struct lh7a40x_request, req);
1148 if (unlikely
1149 (!_req || !_req->complete || !_req->buf
1150 || !list_empty(&req->queue))) {
1151 DEBUG("%s, bad params\n", __func__);
1152 return -EINVAL;
1153 }
1154
1155 ep = container_of(_ep, struct lh7a40x_ep, ep);
1156 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
1157 DEBUG("%s, bad ep\n", __func__);
1158 return -EINVAL;
1159 }
1160
1161 dev = ep->dev;
1162 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
1163 DEBUG("%s, bogus device state %p\n", __func__, dev->driver);
1164 return -ESHUTDOWN;
1165 }
1166
1167 DEBUG("%s queue req %p, len %d buf %p\n", _ep->name, _req, _req->length,
1168 _req->buf);
1169
1170 spin_lock_irqsave(&dev->lock, flags);
1171
1172 _req->status = -EINPROGRESS;
1173 _req->actual = 0;
1174
1175
1176 DEBUG("Add to %d Q %d %d\n", ep_index(ep), list_empty(&ep->queue),
1177 ep->stopped);
1178 if (list_empty(&ep->queue) && likely(!ep->stopped)) {
1179 u32 csr;
1180
1181 if (unlikely(ep_index(ep) == 0)) {
1182
1183 list_add_tail(&req->queue, &ep->queue);
1184 lh7a40x_ep0_kick(dev, ep);
1185 req = 0;
1186 } else if (ep_is_in(ep)) {
1187
1188 usb_set_index(ep_index(ep));
1189 csr = usb_read(ep->csr1);
1190 pio_irq_enable(ep_index(ep));
1191 if ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY) == 0) {
1192 if (write_fifo(ep, req) == 1)
1193 req = 0;
1194 }
1195 } else {
1196
1197 usb_set_index(ep_index(ep));
1198 csr = usb_read(ep->csr1);
1199 pio_irq_enable(ep_index(ep));
1200 if (!(csr & USB_OUT_CSR1_FIFO_FULL)) {
1201 if (read_fifo(ep, req) == 1)
1202 req = 0;
1203 }
1204 }
1205 }
1206
1207
1208 if (likely(req != 0))
1209 list_add_tail(&req->queue, &ep->queue);
1210
1211 spin_unlock_irqrestore(&dev->lock, flags);
1212
1213 return 0;
1214}
1215
1216
1217static int lh7a40x_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1218{
1219 struct lh7a40x_ep *ep;
1220 struct lh7a40x_request *req;
1221 unsigned long flags;
1222
1223 DEBUG("%s, %p\n", __func__, _ep);
1224
1225 ep = container_of(_ep, struct lh7a40x_ep, ep);
1226 if (!_ep || ep->ep.name == ep0name)
1227 return -EINVAL;
1228
1229 spin_lock_irqsave(&ep->dev->lock, flags);
1230
1231
1232 list_for_each_entry(req, &ep->queue, queue) {
1233 if (&req->req == _req)
1234 break;
1235 }
1236 if (&req->req != _req) {
1237 spin_unlock_irqrestore(&ep->dev->lock, flags);
1238 return -EINVAL;
1239 }
1240
1241 done(ep, req, -ECONNRESET);
1242
1243 spin_unlock_irqrestore(&ep->dev->lock, flags);
1244 return 0;
1245}
1246
1247
1248
1249
1250
1251static int lh7a40x_set_halt(struct usb_ep *_ep, int value)
1252{
1253 struct lh7a40x_ep *ep;
1254 unsigned long flags;
1255
1256 ep = container_of(_ep, struct lh7a40x_ep, ep);
1257 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
1258 DEBUG("%s, bad ep\n", __func__);
1259 return -EINVAL;
1260 }
1261
1262 usb_set_index(ep_index(ep));
1263
1264 DEBUG("%s, ep %d, val %d\n", __func__, ep_index(ep), value);
1265
1266 spin_lock_irqsave(&ep->dev->lock, flags);
1267
1268 if (ep_index(ep) == 0) {
1269
1270 usb_set(EP0_SEND_STALL, ep->csr1);
1271 } else if (ep_is_in(ep)) {
1272 u32 csr = usb_read(ep->csr1);
1273 if (value && ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY)
1274 || !list_empty(&ep->queue))) {
1275
1276
1277
1278
1279
1280 spin_unlock_irqrestore(&ep->dev->lock, flags);
1281 DEBUG
1282 ("Attempt to halt IN endpoint failed (returning -EAGAIN) %d %d\n",
1283 (csr & USB_IN_CSR1_FIFO_NOT_EMPTY),
1284 !list_empty(&ep->queue));
1285 return -EAGAIN;
1286 }
1287 flush(ep);
1288 if (value)
1289 usb_set(USB_IN_CSR1_SEND_STALL, ep->csr1);
1290 else {
1291 usb_clear(USB_IN_CSR1_SEND_STALL, ep->csr1);
1292 usb_set(USB_IN_CSR1_CLR_DATA_TOGGLE, ep->csr1);
1293 }
1294
1295 } else {
1296
1297 flush(ep);
1298 if (value)
1299 usb_set(USB_OUT_CSR1_SEND_STALL, ep->csr1);
1300 else {
1301 usb_clear(USB_OUT_CSR1_SEND_STALL, ep->csr1);
1302 usb_set(USB_OUT_CSR1_CLR_DATA_REG, ep->csr1);
1303 }
1304 }
1305
1306 if (value) {
1307 ep->stopped = 1;
1308 } else {
1309 ep->stopped = 0;
1310 }
1311
1312 spin_unlock_irqrestore(&ep->dev->lock, flags);
1313
1314 DEBUG("%s %s halted\n", _ep->name, value == 0 ? "NOT" : "IS");
1315
1316 return 0;
1317}
1318
1319
1320
1321
1322static int lh7a40x_fifo_status(struct usb_ep *_ep)
1323{
1324 u32 csr;
1325 int count = 0;
1326 struct lh7a40x_ep *ep;
1327
1328 ep = container_of(_ep, struct lh7a40x_ep, ep);
1329 if (!_ep) {
1330 DEBUG("%s, bad ep\n", __func__);
1331 return -ENODEV;
1332 }
1333
1334 DEBUG("%s, %d\n", __func__, ep_index(ep));
1335
1336
1337 if (ep_is_in(ep))
1338 return -EOPNOTSUPP;
1339
1340 usb_set_index(ep_index(ep));
1341
1342 csr = usb_read(ep->csr1);
1343 if (ep->dev->gadget.speed != USB_SPEED_UNKNOWN ||
1344 csr & USB_OUT_CSR1_OUT_PKT_RDY) {
1345 count = usb_read(USB_OUT_FIFO_WC1);
1346 }
1347
1348 return count;
1349}
1350
1351
1352
1353
1354static void lh7a40x_fifo_flush(struct usb_ep *_ep)
1355{
1356 struct lh7a40x_ep *ep;
1357
1358 ep = container_of(_ep, struct lh7a40x_ep, ep);
1359 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
1360 DEBUG("%s, bad ep\n", __func__);
1361 return;
1362 }
1363
1364 usb_set_index(ep_index(ep));
1365 flush(ep);
1366}
1367
1368
1369
1370
1371
1372
1373static int write_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
1374{
1375 u32 max;
1376 unsigned count;
1377 int is_last;
1378
1379 max = ep_maxpacket(ep);
1380
1381 DEBUG_EP0("%s\n", __func__);
1382
1383 count = write_packet(ep, req, max);
1384
1385
1386 if (unlikely(count != max))
1387 is_last = 1;
1388 else {
1389 if (likely(req->req.length != req->req.actual) || req->req.zero)
1390 is_last = 0;
1391 else
1392 is_last = 1;
1393 }
1394
1395 DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __func__,
1396 ep->ep.name, count,
1397 is_last ? "/L" : "", req->req.length - req->req.actual, req);
1398
1399
1400 if (is_last) {
1401 done(ep, req, 0);
1402 return 1;
1403 }
1404
1405 return 0;
1406}
1407
1408static __inline__ int lh7a40x_fifo_read(struct lh7a40x_ep *ep,
1409 unsigned char *cp, int max)
1410{
1411 int bytes;
1412 int count = usb_read(USB_OUT_FIFO_WC1);
1413 volatile u32 *fifo = (volatile u32 *)ep->fifo;
1414
1415 if (count > max)
1416 count = max;
1417 bytes = count;
1418 while (count--)
1419 *cp++ = *fifo & 0xFF;
1420 return bytes;
1421}
1422
1423static __inline__ void lh7a40x_fifo_write(struct lh7a40x_ep *ep,
1424 unsigned char *cp, int count)
1425{
1426 volatile u32 *fifo = (volatile u32 *)ep->fifo;
1427 DEBUG_EP0("fifo_write: %d %d\n", ep_index(ep), count);
1428 while (count--)
1429 *fifo = *cp++;
1430}
1431
1432static int read_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
1433{
1434 u32 csr;
1435 u8 *buf;
1436 unsigned bufferspace, count, is_short;
1437 volatile u32 *fifo = (volatile u32 *)ep->fifo;
1438
1439 DEBUG_EP0("%s\n", __func__);
1440
1441 csr = usb_read(USB_EP0_CSR);
1442 if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY))
1443 return 0;
1444
1445 buf = req->req.buf + req->req.actual;
1446 prefetchw(buf);
1447 bufferspace = req->req.length - req->req.actual;
1448
1449
1450 if (likely(csr & EP0_OUT_PKT_RDY)) {
1451 count = usb_read(USB_OUT_FIFO_WC1);
1452 req->req.actual += min(count, bufferspace);
1453 } else
1454 count = 0;
1455
1456 is_short = (count < ep->ep.maxpacket);
1457 DEBUG_EP0("read %s %02x, %d bytes%s req %p %d/%d\n",
1458 ep->ep.name, csr, count,
1459 is_short ? "/S" : "", req, req->req.actual, req->req.length);
1460
1461 while (likely(count-- != 0)) {
1462 u8 byte = (u8) (*fifo & 0xff);
1463
1464 if (unlikely(bufferspace == 0)) {
1465
1466
1467
1468
1469 if (req->req.status != -EOVERFLOW)
1470 DEBUG_EP0("%s overflow %d\n", ep->ep.name,
1471 count);
1472 req->req.status = -EOVERFLOW;
1473 } else {
1474 *buf++ = byte;
1475 bufferspace--;
1476 }
1477 }
1478
1479
1480 if (is_short || req->req.actual == req->req.length) {
1481 done(ep, req, 0);
1482 return 1;
1483 }
1484
1485
1486 return 0;
1487}
1488
1489
1490
1491
1492
1493
1494
1495static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address)
1496{
1497 DEBUG_EP0("%s: %d\n", __func__, address);
1498
1499 dev->usb_address = address;
1500 usb_set((address & USB_FA_FUNCTION_ADDR), USB_FA);
1501 usb_set(USB_FA_ADDR_UPDATE | (address & USB_FA_FUNCTION_ADDR), USB_FA);
1502
1503}
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513static void lh7a40x_ep0_out(struct lh7a40x_udc *dev, u32 csr)
1514{
1515 struct lh7a40x_request *req;
1516 struct lh7a40x_ep *ep = &dev->ep[0];
1517 int ret;
1518
1519 DEBUG_EP0("%s: %x\n", __func__, csr);
1520
1521 if (list_empty(&ep->queue))
1522 req = 0;
1523 else
1524 req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
1525
1526 if (req) {
1527
1528 if (req->req.length == 0) {
1529 DEBUG_EP0("ZERO LENGTH OUT!\n");
1530 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
1531 dev->ep0state = WAIT_FOR_SETUP;
1532 return;
1533 }
1534 ret = read_fifo_ep0(ep, req);
1535 if (ret) {
1536
1537 DEBUG_EP0("%s: finished, waiting for status\n",
1538 __func__);
1539
1540 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
1541 dev->ep0state = WAIT_FOR_SETUP;
1542 } else {
1543
1544 DEBUG_EP0("%s: not finished\n", __func__);
1545 usb_set(EP0_CLR_OUT, USB_EP0_CSR);
1546 }
1547 } else {
1548 DEBUG_EP0("NO REQ??!\n");
1549 }
1550}
1551
1552
1553
1554
1555static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr)
1556{
1557 struct lh7a40x_request *req;
1558 struct lh7a40x_ep *ep = &dev->ep[0];
1559 int ret, need_zlp = 0;
1560
1561 DEBUG_EP0("%s: %x\n", __func__, csr);
1562
1563 if (list_empty(&ep->queue))
1564 req = 0;
1565 else
1566 req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
1567
1568 if (!req) {
1569 DEBUG_EP0("%s: NULL REQ\n", __func__);
1570 return 0;
1571 }
1572
1573 if (req->req.length == 0) {
1574
1575 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
1576 dev->ep0state = WAIT_FOR_SETUP;
1577 return 1;
1578 }
1579
1580 if (req->req.length - req->req.actual == EP0_PACKETSIZE) {
1581
1582
1583 need_zlp = 1;
1584 }
1585
1586 ret = write_fifo_ep0(ep, req);
1587
1588 if (ret == 1 && !need_zlp) {
1589
1590 DEBUG_EP0("%s: finished, waiting for status\n", __func__);
1591
1592 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
1593 dev->ep0state = WAIT_FOR_SETUP;
1594 } else {
1595 DEBUG_EP0("%s: not finished\n", __func__);
1596 usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
1597 }
1598
1599 if (need_zlp) {
1600 DEBUG_EP0("%s: Need ZLP!\n", __func__);
1601 usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
1602 dev->ep0state = DATA_STATE_NEED_ZLP;
1603 }
1604
1605 return 1;
1606}
1607
1608static int lh7a40x_handle_get_status(struct lh7a40x_udc *dev,
1609 struct usb_ctrlrequest *ctrl)
1610{
1611 struct lh7a40x_ep *ep0 = &dev->ep[0];
1612 struct lh7a40x_ep *qep;
1613 int reqtype = (ctrl->bRequestType & USB_RECIP_MASK);
1614 u16 val = 0;
1615
1616 if (reqtype == USB_RECIP_INTERFACE) {
1617
1618
1619
1620
1621 DEBUG_SETUP("GET_STATUS: USB_RECIP_INTERFACE\n");
1622 } else if (reqtype == USB_RECIP_DEVICE) {
1623 DEBUG_SETUP("GET_STATUS: USB_RECIP_DEVICE\n");
1624 val |= (1 << 0);
1625
1626 } else if (reqtype == USB_RECIP_ENDPOINT) {
1627 int ep_num = (ctrl->wIndex & ~USB_DIR_IN);
1628
1629 DEBUG_SETUP
1630 ("GET_STATUS: USB_RECIP_ENDPOINT (%d), ctrl->wLength = %d\n",
1631 ep_num, ctrl->wLength);
1632
1633 if (ctrl->wLength > 2 || ep_num > 3)
1634 return -EOPNOTSUPP;
1635
1636 qep = &dev->ep[ep_num];
1637 if (ep_is_in(qep) != ((ctrl->wIndex & USB_DIR_IN) ? 1 : 0)
1638 && ep_index(qep) != 0) {
1639 return -EOPNOTSUPP;
1640 }
1641
1642 usb_set_index(ep_index(qep));
1643
1644
1645 switch (qep->ep_type) {
1646 case ep_control:
1647 val =
1648 (usb_read(qep->csr1) & EP0_SEND_STALL) ==
1649 EP0_SEND_STALL;
1650 break;
1651 case ep_bulk_in:
1652 case ep_interrupt:
1653 val =
1654 (usb_read(qep->csr1) & USB_IN_CSR1_SEND_STALL) ==
1655 USB_IN_CSR1_SEND_STALL;
1656 break;
1657 case ep_bulk_out:
1658 val =
1659 (usb_read(qep->csr1) & USB_OUT_CSR1_SEND_STALL) ==
1660 USB_OUT_CSR1_SEND_STALL;
1661 break;
1662 }
1663
1664
1665 usb_set_index(0);
1666
1667 DEBUG_SETUP("GET_STATUS, ep: %d (%x), val = %d\n", ep_num,
1668 ctrl->wIndex, val);
1669 } else {
1670 DEBUG_SETUP("Unknown REQ TYPE: %d\n", reqtype);
1671 return -EOPNOTSUPP;
1672 }
1673
1674
1675 usb_set((EP0_CLR_OUT), USB_EP0_CSR);
1676
1677 lh7a40x_fifo_write(ep0, (u8 *) & val, sizeof(val));
1678
1679 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
1680
1681 return 0;
1682}
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693static void lh7a40x_ep0_setup(struct lh7a40x_udc *dev, u32 csr)
1694{
1695 struct lh7a40x_ep *ep = &dev->ep[0];
1696 struct usb_ctrlrequest ctrl;
1697 int i, bytes, is_in;
1698
1699 DEBUG_SETUP("%s: %x\n", __func__, csr);
1700
1701
1702 nuke(ep, -EPROTO);
1703
1704
1705 bytes = lh7a40x_fifo_read(ep, (unsigned char *)&ctrl, 8);
1706
1707 DEBUG_SETUP("Read CTRL REQ %d bytes\n", bytes);
1708 DEBUG_SETUP("CTRL.bRequestType = %d (is_in %d)\n", ctrl.bRequestType,
1709 ctrl.bRequestType == USB_DIR_IN);
1710 DEBUG_SETUP("CTRL.bRequest = %d\n", ctrl.bRequest);
1711 DEBUG_SETUP("CTRL.wLength = %d\n", ctrl.wLength);
1712 DEBUG_SETUP("CTRL.wValue = %d (%d)\n", ctrl.wValue, ctrl.wValue >> 8);
1713 DEBUG_SETUP("CTRL.wIndex = %d\n", ctrl.wIndex);
1714
1715
1716 if (likely(ctrl.bRequestType & USB_DIR_IN)) {
1717 ep->bEndpointAddress |= USB_DIR_IN;
1718 is_in = 1;
1719 } else {
1720 ep->bEndpointAddress &= ~USB_DIR_IN;
1721 is_in = 0;
1722 }
1723
1724 dev->req_pending = 1;
1725
1726
1727 switch (ctrl.bRequest) {
1728 case USB_REQ_SET_ADDRESS:
1729 if (ctrl.bRequestType != (USB_TYPE_STANDARD | USB_RECIP_DEVICE))
1730 break;
1731
1732 DEBUG_SETUP("USB_REQ_SET_ADDRESS (%d)\n", ctrl.wValue);
1733 udc_set_address(dev, ctrl.wValue);
1734 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
1735 return;
1736
1737 case USB_REQ_GET_STATUS:{
1738 if (lh7a40x_handle_get_status(dev, &ctrl) == 0)
1739 return;
1740
1741 case USB_REQ_CLEAR_FEATURE:
1742 case USB_REQ_SET_FEATURE:
1743 if (ctrl.bRequestType == USB_RECIP_ENDPOINT) {
1744 struct lh7a40x_ep *qep;
1745 int ep_num = (ctrl.wIndex & 0x0f);
1746
1747
1748 if (ctrl.wValue != 0 || ctrl.wLength != 0
1749 || ep_num > 3 || ep_num < 1)
1750 break;
1751
1752 qep = &dev->ep[ep_num];
1753 spin_unlock(&dev->lock);
1754 if (ctrl.bRequest == USB_REQ_SET_FEATURE) {
1755 DEBUG_SETUP("SET_FEATURE (%d)\n",
1756 ep_num);
1757 lh7a40x_set_halt(&qep->ep, 1);
1758 } else {
1759 DEBUG_SETUP("CLR_FEATURE (%d)\n",
1760 ep_num);
1761 lh7a40x_set_halt(&qep->ep, 0);
1762 }
1763 spin_lock(&dev->lock);
1764 usb_set_index(0);
1765
1766
1767 usb_set((EP0_CLR_OUT | EP0_DATA_END),
1768 USB_EP0_CSR);
1769 return;
1770 }
1771 break;
1772 }
1773
1774 default:
1775 break;
1776 }
1777
1778 if (likely(dev->driver)) {
1779
1780 spin_unlock(&dev->lock);
1781 i = dev->driver->setup(&dev->gadget, &ctrl);
1782 spin_lock(&dev->lock);
1783
1784 if (i < 0) {
1785
1786 DEBUG_SETUP
1787 (" --> ERROR: gadget setup FAILED (stalling), setup returned %d\n",
1788 i);
1789 usb_set_index(0);
1790 usb_set((EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL),
1791 USB_EP0_CSR);
1792
1793
1794 dev->ep0state = WAIT_FOR_SETUP;
1795 }
1796 }
1797}
1798
1799
1800
1801
1802static void lh7a40x_ep0_in_zlp(struct lh7a40x_udc *dev, u32 csr)
1803{
1804 DEBUG_EP0("%s: %x\n", __func__, csr);
1805
1806
1807 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
1808 dev->ep0state = WAIT_FOR_SETUP;
1809}
1810
1811
1812
1813
1814static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
1815{
1816 struct lh7a40x_ep *ep = &dev->ep[0];
1817 u32 csr;
1818
1819
1820 usb_set_index(0);
1821 csr = usb_read(USB_EP0_CSR);
1822
1823 DEBUG_EP0("%s: csr = %x\n", __func__, csr);
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836 if (csr & EP0_SENT_STALL) {
1837 DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __func__, csr);
1838 usb_clear((EP0_SENT_STALL | EP0_SEND_STALL), USB_EP0_CSR);
1839 nuke(ep, -ECONNABORTED);
1840 dev->ep0state = WAIT_FOR_SETUP;
1841 return;
1842 }
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852 if (!(csr & (EP0_IN_PKT_RDY | EP0_OUT_PKT_RDY))) {
1853 DEBUG_EP0("%s: IN_PKT_RDY and OUT_PKT_RDY are clear\n",
1854 __func__);
1855
1856 switch (dev->ep0state) {
1857 case DATA_STATE_XMIT:
1858 DEBUG_EP0("continue with DATA_STATE_XMIT\n");
1859 lh7a40x_ep0_in(dev, csr);
1860 return;
1861 case DATA_STATE_NEED_ZLP:
1862 DEBUG_EP0("continue with DATA_STATE_NEED_ZLP\n");
1863 lh7a40x_ep0_in_zlp(dev, csr);
1864 return;
1865 default:
1866
1867 DEBUG_EP0("Odd state!! state = %s\n",
1868 state_names[dev->ep0state]);
1869 dev->ep0state = WAIT_FOR_SETUP;
1870
1871
1872 break;
1873 }
1874 }
1875
1876
1877
1878
1879
1880
1881 if (csr & EP0_SETUP_END) {
1882 DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __func__, csr);
1883
1884 usb_set(EP0_CLR_SETUP_END, USB_EP0_CSR);
1885
1886 nuke(ep, 0);
1887 dev->ep0state = WAIT_FOR_SETUP;
1888 }
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899 if (csr & EP0_OUT_PKT_RDY) {
1900
1901 DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __func__,
1902 csr);
1903
1904 switch (dev->ep0state) {
1905 case WAIT_FOR_SETUP:
1906 DEBUG_EP0("WAIT_FOR_SETUP\n");
1907 lh7a40x_ep0_setup(dev, csr);
1908 break;
1909
1910 case DATA_STATE_RECV:
1911 DEBUG_EP0("DATA_STATE_RECV\n");
1912 lh7a40x_ep0_out(dev, csr);
1913 break;
1914
1915 default:
1916
1917 DEBUG_EP0("strange state!! 2. send stall? state = %d\n",
1918 dev->ep0state);
1919 break;
1920 }
1921 }
1922}
1923
1924static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep)
1925{
1926 u32 csr;
1927
1928 usb_set_index(0);
1929 csr = usb_read(USB_EP0_CSR);
1930
1931 DEBUG_EP0("%s: %x\n", __func__, csr);
1932
1933
1934 usb_set(EP0_CLR_OUT, USB_EP0_CSR);
1935
1936 if (ep_is_in(ep)) {
1937 dev->ep0state = DATA_STATE_XMIT;
1938 lh7a40x_ep0_in(dev, csr);
1939 } else {
1940 dev->ep0state = DATA_STATE_RECV;
1941 lh7a40x_ep0_out(dev, csr);
1942 }
1943}
1944
1945
1946
1947
1948
1949
1950static int lh7a40x_udc_get_frame(struct usb_gadget *_gadget)
1951{
1952 u32 frame1 = usb_read(USB_FRM_NUM1);
1953 u32 frame2 = usb_read(USB_FRM_NUM2);
1954 DEBUG("%s, %p\n", __func__, _gadget);
1955 return ((frame2 & 0x07) << 8) | (frame1 & 0xff);
1956}
1957
1958static int lh7a40x_udc_wakeup(struct usb_gadget *_gadget)
1959{
1960
1961
1962
1963
1964 return -ENOTSUPP;
1965}
1966
1967static const struct usb_gadget_ops lh7a40x_udc_ops = {
1968 .get_frame = lh7a40x_udc_get_frame,
1969 .wakeup = lh7a40x_udc_wakeup,
1970
1971};
1972
1973static void nop_release(struct device *dev)
1974{
1975 DEBUG("%s %s\n", __func__, dev_name(dev));
1976}
1977
1978static struct lh7a40x_udc memory = {
1979 .usb_address = 0,
1980
1981 .gadget = {
1982 .ops = &lh7a40x_udc_ops,
1983 .ep0 = &memory.ep[0].ep,
1984 .name = driver_name,
1985 .dev = {
1986 .init_name = "gadget",
1987 .release = nop_release,
1988 },
1989 },
1990
1991
1992 .ep[0] = {
1993 .ep = {
1994 .name = ep0name,
1995 .ops = &lh7a40x_ep_ops,
1996 .maxpacket = EP0_PACKETSIZE,
1997 },
1998 .dev = &memory,
1999
2000 .bEndpointAddress = 0,
2001 .bmAttributes = 0,
2002
2003 .ep_type = ep_control,
2004 .fifo = io_p2v(USB_EP0_FIFO),
2005 .csr1 = USB_EP0_CSR,
2006 .csr2 = USB_EP0_CSR,
2007 },
2008
2009
2010 .ep[1] = {
2011 .ep = {
2012 .name = "ep1in-bulk",
2013 .ops = &lh7a40x_ep_ops,
2014 .maxpacket = 64,
2015 },
2016 .dev = &memory,
2017
2018 .bEndpointAddress = USB_DIR_IN | 1,
2019 .bmAttributes = USB_ENDPOINT_XFER_BULK,
2020
2021 .ep_type = ep_bulk_in,
2022 .fifo = io_p2v(USB_EP1_FIFO),
2023 .csr1 = USB_IN_CSR1,
2024 .csr2 = USB_IN_CSR2,
2025 },
2026
2027 .ep[2] = {
2028 .ep = {
2029 .name = "ep2out-bulk",
2030 .ops = &lh7a40x_ep_ops,
2031 .maxpacket = 64,
2032 },
2033 .dev = &memory,
2034
2035 .bEndpointAddress = 2,
2036 .bmAttributes = USB_ENDPOINT_XFER_BULK,
2037
2038 .ep_type = ep_bulk_out,
2039 .fifo = io_p2v(USB_EP2_FIFO),
2040 .csr1 = USB_OUT_CSR1,
2041 .csr2 = USB_OUT_CSR2,
2042 },
2043
2044 .ep[3] = {
2045 .ep = {
2046 .name = "ep3in-int",
2047 .ops = &lh7a40x_ep_ops,
2048 .maxpacket = 64,
2049 },
2050 .dev = &memory,
2051
2052 .bEndpointAddress = USB_DIR_IN | 3,
2053 .bmAttributes = USB_ENDPOINT_XFER_INT,
2054
2055 .ep_type = ep_interrupt,
2056 .fifo = io_p2v(USB_EP3_FIFO),
2057 .csr1 = USB_IN_CSR1,
2058 .csr2 = USB_IN_CSR2,
2059 },
2060};
2061
2062
2063
2064
2065static int lh7a40x_udc_probe(struct platform_device *pdev)
2066{
2067 struct lh7a40x_udc *dev = &memory;
2068 int retval;
2069
2070 DEBUG("%s: %p\n", __func__, pdev);
2071
2072 spin_lock_init(&dev->lock);
2073 dev->dev = &pdev->dev;
2074
2075 device_initialize(&dev->gadget.dev);
2076 dev->gadget.dev.parent = &pdev->dev;
2077
2078 the_controller = dev;
2079 platform_set_drvdata(pdev, dev);
2080
2081 udc_disable(dev);
2082 udc_reinit(dev);
2083
2084
2085 retval =
2086 request_irq(IRQ_USBINTR, lh7a40x_udc_irq, IRQF_DISABLED, driver_name,
2087 dev);
2088 if (retval != 0) {
2089 DEBUG(KERN_ERR "%s: can't get irq %i, err %d\n", driver_name,
2090 IRQ_USBINTR, retval);
2091 return -EBUSY;
2092 }
2093
2094 create_proc_files();
2095
2096 return retval;
2097}
2098
2099static int lh7a40x_udc_remove(struct platform_device *pdev)
2100{
2101 struct lh7a40x_udc *dev = platform_get_drvdata(pdev);
2102
2103 DEBUG("%s: %p\n", __func__, pdev);
2104
2105 if (dev->driver)
2106 return -EBUSY;
2107
2108 udc_disable(dev);
2109 remove_proc_files();
2110
2111 free_irq(IRQ_USBINTR, dev);
2112
2113 platform_set_drvdata(pdev, 0);
2114
2115 the_controller = 0;
2116
2117 return 0;
2118}
2119
2120
2121
2122static struct platform_driver udc_driver = {
2123 .probe = lh7a40x_udc_probe,
2124 .remove = lh7a40x_udc_remove,
2125
2126
2127
2128 .driver = {
2129 .name = (char *)driver_name,
2130 .owner = THIS_MODULE,
2131 },
2132};
2133
2134static int __init udc_init(void)
2135{
2136 DEBUG("%s: %s version %s\n", __func__, driver_name, DRIVER_VERSION);
2137 return platform_driver_register(&udc_driver);
2138}
2139
2140static void __exit udc_exit(void)
2141{
2142 platform_driver_unregister(&udc_driver);
2143}
2144
2145module_init(udc_init);
2146module_exit(udc_exit);
2147
2148MODULE_DESCRIPTION(DRIVER_DESC);
2149MODULE_AUTHOR("Mikko Lahteenmaki, Bo Henriksen");
2150MODULE_LICENSE("GPL");
2151MODULE_ALIAS("platform:lh7a40x_udc");
2152