This source file includes following definitions.
- assert_out_naking
- stop_out_naking
- type_string
- buf_state_string
- dma_mode_string
- net2272_enable
- net2272_ep_reset
- net2272_disable
- net2272_alloc_request
- net2272_free_request
- net2272_done
- net2272_write_packet
- net2272_write_fifo
- net2272_out_flush
- net2272_read_packet
- net2272_read_fifo
- net2272_pio_advance
- net2272_request_dma
- net2272_start_dma
- net2272_kick_dma
- net2272_cancel_dma
- net2272_queue
- net2272_dequeue_all
- net2272_dequeue
- net2272_set_halt_and_wedge
- net2272_set_halt
- net2272_set_wedge
- net2272_fifo_status
- net2272_fifo_flush
- net2272_get_frame
- net2272_wakeup
- net2272_set_selfpowered
- net2272_pullup
- registers_show
- net2272_set_fifo_mode
- net2272_usb_reset
- net2272_usb_reinit
- net2272_ep0_start
- net2272_start
- stop_activity
- net2272_stop
- net2272_handle_dma
- net2272_handle_ep
- net2272_get_ep_by_addr
- net2272_set_test_mode
- net2272_handle_stat0_irqs
- net2272_handle_stat1_irqs
- net2272_irq
- net2272_present
- net2272_gadget_release
- net2272_remove
- net2272_probe_init
- net2272_probe_fin
- net2272_rdk1_probe
- net2272_rdk2_probe
- net2272_pci_probe
- net2272_rdk1_remove
- net2272_rdk2_remove
- net2272_pci_remove
- net2272_pci_register
- net2272_pci_unregister
- net2272_pci_register
- net2272_pci_unregister
- net2272_plat_probe
- net2272_plat_remove
- net2272_init
- net2272_cleanup
1
2
3
4
5
6
7
8
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/errno.h>
12 #include <linux/gpio.h>
13 #include <linux/init.h>
14 #include <linux/interrupt.h>
15 #include <linux/io.h>
16 #include <linux/ioport.h>
17 #include <linux/kernel.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
21 #include <linux/pci.h>
22 #include <linux/platform_device.h>
23 #include <linux/prefetch.h>
24 #include <linux/sched.h>
25 #include <linux/slab.h>
26 #include <linux/timer.h>
27 #include <linux/usb.h>
28 #include <linux/usb/ch9.h>
29 #include <linux/usb/gadget.h>
30
31 #include <asm/byteorder.h>
32 #include <asm/unaligned.h>
33
34 #include "net2272.h"
35
36 #define DRIVER_DESC "PLX NET2272 USB Peripheral Controller"
37
38 static const char driver_name[] = "net2272";
39 static const char driver_vers[] = "2006 October 17/mainline";
40 static const char driver_desc[] = DRIVER_DESC;
41
42 static const char ep0name[] = "ep0";
43 static const char * const ep_name[] = {
44 ep0name,
45 "ep-a", "ep-b", "ep-c",
46 };
47
48 #ifdef CONFIG_USB_NET2272_DMA
49
50
51
52
53
54
55
56
57 static bool use_dma = 0;
58 module_param(use_dma, bool, 0644);
59
60
61
62
63
64
65
66
67
68
69
70
71 static ushort dma_ep = 1;
72 module_param(dma_ep, ushort, 0644);
73
74
75
76
77
78
79
80 static ushort dma_mode = 2;
81 module_param(dma_mode, ushort, 0644);
82 #else
83 #define use_dma 0
84 #define dma_ep 1
85 #define dma_mode 2
86 #endif
87
88
89
90
91
92
93
94
95 static ushort fifo_mode = 0;
96 module_param(fifo_mode, ushort, 0644);
97
98
99
100
101
102
103
104 static ushort enable_suspend = 0;
105 module_param(enable_suspend, ushort, 0644);
106
107 static void assert_out_naking(struct net2272_ep *ep, const char *where)
108 {
109 u8 tmp;
110
111 #ifndef DEBUG
112 return;
113 #endif
114
115 tmp = net2272_ep_read(ep, EP_STAT0);
116 if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
117 dev_dbg(ep->dev->dev, "%s %s %02x !NAK\n",
118 ep->ep.name, where, tmp);
119 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
120 }
121 }
122 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep, __func__)
123
124 static void stop_out_naking(struct net2272_ep *ep)
125 {
126 u8 tmp = net2272_ep_read(ep, EP_STAT0);
127
128 if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
129 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
130 }
131
132 #define PIPEDIR(bAddress) (usb_pipein(bAddress) ? "in" : "out")
133
134 static char *type_string(u8 bmAttributes)
135 {
136 switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) {
137 case USB_ENDPOINT_XFER_BULK: return "bulk";
138 case USB_ENDPOINT_XFER_ISOC: return "iso";
139 case USB_ENDPOINT_XFER_INT: return "intr";
140 default: return "control";
141 }
142 }
143
144 static char *buf_state_string(unsigned state)
145 {
146 switch (state) {
147 case BUFF_FREE: return "free";
148 case BUFF_VALID: return "valid";
149 case BUFF_LCL: return "local";
150 case BUFF_USB: return "usb";
151 default: return "unknown";
152 }
153 }
154
155 static char *dma_mode_string(void)
156 {
157 if (!use_dma)
158 return "PIO";
159 switch (dma_mode) {
160 case 0: return "SLOW DREQ";
161 case 1: return "FAST DREQ";
162 case 2: return "BURST";
163 default: return "invalid";
164 }
165 }
166
167 static void net2272_dequeue_all(struct net2272_ep *);
168 static int net2272_kick_dma(struct net2272_ep *, struct net2272_request *);
169 static int net2272_fifo_status(struct usb_ep *);
170
171 static const struct usb_ep_ops net2272_ep_ops;
172
173
174
175 static int
176 net2272_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
177 {
178 struct net2272 *dev;
179 struct net2272_ep *ep;
180 u32 max;
181 u8 tmp;
182 unsigned long flags;
183
184 ep = container_of(_ep, struct net2272_ep, ep);
185 if (!_ep || !desc || ep->desc || _ep->name == ep0name
186 || desc->bDescriptorType != USB_DT_ENDPOINT)
187 return -EINVAL;
188 dev = ep->dev;
189 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
190 return -ESHUTDOWN;
191
192 max = usb_endpoint_maxp(desc);
193
194 spin_lock_irqsave(&dev->lock, flags);
195 _ep->maxpacket = max;
196 ep->desc = desc;
197
198
199 ep->stopped = 0;
200 ep->wedged = 0;
201
202
203 net2272_ep_write(ep, EP_MAXPKT0, max & 0xff);
204 net2272_ep_write(ep, EP_MAXPKT1, (max & 0xff00) >> 8);
205
206
207 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
208 tmp = usb_endpoint_type(desc);
209 if (usb_endpoint_xfer_bulk(desc)) {
210
211 if ((dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
212 (dev->gadget.speed == USB_SPEED_FULL && max > 64)) {
213 spin_unlock_irqrestore(&dev->lock, flags);
214 return -ERANGE;
215 }
216 }
217 ep->is_iso = usb_endpoint_xfer_isoc(desc) ? 1 : 0;
218 tmp <<= ENDPOINT_TYPE;
219 tmp |= ((desc->bEndpointAddress & 0x0f) << ENDPOINT_NUMBER);
220 tmp |= usb_endpoint_dir_in(desc) << ENDPOINT_DIRECTION;
221 tmp |= (1 << ENDPOINT_ENABLE);
222
223
224 ep->is_in = usb_endpoint_dir_in(desc);
225 if (!ep->is_in)
226 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
227
228 net2272_ep_write(ep, EP_CFG, tmp);
229
230
231 tmp = (1 << ep->num) | net2272_read(dev, IRQENB0);
232 net2272_write(dev, IRQENB0, tmp);
233
234 tmp = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
235 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
236 | net2272_ep_read(ep, EP_IRQENB);
237 net2272_ep_write(ep, EP_IRQENB, tmp);
238
239 tmp = desc->bEndpointAddress;
240 dev_dbg(dev->dev, "enabled %s (ep%d%s-%s) max %04x cfg %02x\n",
241 _ep->name, tmp & 0x0f, PIPEDIR(tmp),
242 type_string(desc->bmAttributes), max,
243 net2272_ep_read(ep, EP_CFG));
244
245 spin_unlock_irqrestore(&dev->lock, flags);
246 return 0;
247 }
248
249 static void net2272_ep_reset(struct net2272_ep *ep)
250 {
251 u8 tmp;
252
253 ep->desc = NULL;
254 INIT_LIST_HEAD(&ep->queue);
255
256 usb_ep_set_maxpacket_limit(&ep->ep, ~0);
257 ep->ep.ops = &net2272_ep_ops;
258
259
260 net2272_ep_write(ep, EP_IRQENB, 0);
261
262
263
264
265 tmp = (1 << NAK_OUT_PACKETS_MODE) | (1 << ALT_NAK_OUT_PACKETS);
266 net2272_ep_write(ep, EP_RSPSET, tmp);
267
268 tmp = (1 << INTERRUPT_MODE) | (1 << HIDE_STATUS_PHASE);
269 if (ep->num != 0)
270 tmp |= (1 << ENDPOINT_TOGGLE) | (1 << ENDPOINT_HALT);
271
272 net2272_ep_write(ep, EP_RSPCLR, tmp);
273
274
275 net2272_ep_write(ep, EP_STAT0,
276 (1 << DATA_IN_TOKEN_INTERRUPT)
277 | (1 << DATA_OUT_TOKEN_INTERRUPT)
278 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
279 | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
280 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
281
282 net2272_ep_write(ep, EP_STAT1,
283 (1 << TIMEOUT)
284 | (1 << USB_OUT_ACK_SENT)
285 | (1 << USB_OUT_NAK_SENT)
286 | (1 << USB_IN_ACK_RCVD)
287 | (1 << USB_IN_NAK_SENT)
288 | (1 << USB_STALL_SENT)
289 | (1 << LOCAL_OUT_ZLP)
290 | (1 << BUFFER_FLUSH));
291
292
293 }
294
295 static int net2272_disable(struct usb_ep *_ep)
296 {
297 struct net2272_ep *ep;
298 unsigned long flags;
299
300 ep = container_of(_ep, struct net2272_ep, ep);
301 if (!_ep || !ep->desc || _ep->name == ep0name)
302 return -EINVAL;
303
304 spin_lock_irqsave(&ep->dev->lock, flags);
305 net2272_dequeue_all(ep);
306 net2272_ep_reset(ep);
307
308 dev_vdbg(ep->dev->dev, "disabled %s\n", _ep->name);
309
310 spin_unlock_irqrestore(&ep->dev->lock, flags);
311 return 0;
312 }
313
314
315
316 static struct usb_request *
317 net2272_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
318 {
319 struct net2272_request *req;
320
321 if (!_ep)
322 return NULL;
323
324 req = kzalloc(sizeof(*req), gfp_flags);
325 if (!req)
326 return NULL;
327
328 INIT_LIST_HEAD(&req->queue);
329
330 return &req->req;
331 }
332
333 static void
334 net2272_free_request(struct usb_ep *_ep, struct usb_request *_req)
335 {
336 struct net2272_request *req;
337
338 if (!_ep || !_req)
339 return;
340
341 req = container_of(_req, struct net2272_request, req);
342 WARN_ON(!list_empty(&req->queue));
343 kfree(req);
344 }
345
346 static void
347 net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
348 {
349 struct net2272 *dev;
350 unsigned stopped = ep->stopped;
351
352 if (ep->num == 0) {
353 if (ep->dev->protocol_stall) {
354 ep->stopped = 1;
355 set_halt(ep);
356 }
357 allow_status(ep);
358 }
359
360 list_del_init(&req->queue);
361
362 if (req->req.status == -EINPROGRESS)
363 req->req.status = status;
364 else
365 status = req->req.status;
366
367 dev = ep->dev;
368 if (use_dma && ep->dma)
369 usb_gadget_unmap_request(&dev->gadget, &req->req,
370 ep->is_in);
371
372 if (status && status != -ESHUTDOWN)
373 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
374 ep->ep.name, &req->req, status,
375 req->req.actual, req->req.length, req->req.buf);
376
377
378 ep->stopped = 1;
379 spin_unlock(&dev->lock);
380 usb_gadget_giveback_request(&ep->ep, &req->req);
381 spin_lock(&dev->lock);
382 ep->stopped = stopped;
383 }
384
385 static int
386 net2272_write_packet(struct net2272_ep *ep, u8 *buf,
387 struct net2272_request *req, unsigned max)
388 {
389 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
390 u16 *bufp;
391 unsigned length, count;
392 u8 tmp;
393
394 length = min(req->req.length - req->req.actual, max);
395 req->req.actual += length;
396
397 dev_vdbg(ep->dev->dev, "write packet %s req %p max %u len %u avail %u\n",
398 ep->ep.name, req, max, length,
399 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
400
401 count = length;
402 bufp = (u16 *)buf;
403
404 while (likely(count >= 2)) {
405
406 writew(*bufp++, ep_data);
407 count -= 2;
408 }
409 buf = (u8 *)bufp;
410
411
412 if (unlikely(count)) {
413 tmp = net2272_read(ep->dev, LOCCTL);
414 net2272_write(ep->dev, LOCCTL, tmp & ~(1 << DATA_WIDTH));
415 writeb(*buf, ep_data);
416 net2272_write(ep->dev, LOCCTL, tmp);
417 }
418 return length;
419 }
420
421
422 static int
423 net2272_write_fifo(struct net2272_ep *ep, struct net2272_request *req)
424 {
425 u8 *buf;
426 unsigned count, max;
427 int status;
428
429 dev_vdbg(ep->dev->dev, "write_fifo %s actual %d len %d\n",
430 ep->ep.name, req->req.actual, req->req.length);
431
432
433
434
435
436 top:
437
438
439
440
441
442 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
443 while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_FULL))) {
444 buf = req->req.buf + req->req.actual;
445 prefetch(buf);
446
447
448 net2272_ep_read(ep, EP_STAT0);
449
450 max = (net2272_ep_read(ep, EP_AVAIL1) << 8) |
451 (net2272_ep_read(ep, EP_AVAIL0));
452
453 if (max < ep->ep.maxpacket)
454 max = (net2272_ep_read(ep, EP_AVAIL1) << 8)
455 | (net2272_ep_read(ep, EP_AVAIL0));
456
457 count = net2272_write_packet(ep, buf, req, max);
458
459 if (req->req.length == req->req.actual) {
460
461 if (count < ep->ep.maxpacket)
462 set_fifo_bytecount(ep, 0);
463 net2272_done(ep, req, 0);
464
465 if (!list_empty(&ep->queue)) {
466 req = list_entry(ep->queue.next,
467 struct net2272_request,
468 queue);
469 status = net2272_kick_dma(ep, req);
470
471 if (status < 0)
472 if ((net2272_ep_read(ep, EP_STAT0)
473 & (1 << BUFFER_EMPTY)))
474 goto top;
475 }
476 return 1;
477 }
478 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
479 }
480 return 0;
481 }
482
483 static void
484 net2272_out_flush(struct net2272_ep *ep)
485 {
486 ASSERT_OUT_NAKING(ep);
487
488 net2272_ep_write(ep, EP_STAT0, (1 << DATA_OUT_TOKEN_INTERRUPT)
489 | (1 << DATA_PACKET_RECEIVED_INTERRUPT));
490 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
491 }
492
493 static int
494 net2272_read_packet(struct net2272_ep *ep, u8 *buf,
495 struct net2272_request *req, unsigned avail)
496 {
497 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
498 unsigned is_short;
499 u16 *bufp;
500
501 req->req.actual += avail;
502
503 dev_vdbg(ep->dev->dev, "read packet %s req %p len %u avail %u\n",
504 ep->ep.name, req, avail,
505 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
506
507 is_short = (avail < ep->ep.maxpacket);
508
509 if (unlikely(avail == 0)) {
510
511 (void)readw(ep_data);
512 return is_short;
513 }
514
515
516 if (unlikely(avail % 2))
517 avail++;
518 bufp = (u16 *)buf;
519
520 do {
521 *bufp++ = readw(ep_data);
522 avail -= 2;
523 } while (avail);
524
525
526
527
528
529 if (net2272_ep_read(ep, EP_STAT0) & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT))
530 net2272_ep_read(ep, EP_STAT0);
531
532 return is_short;
533 }
534
535 static int
536 net2272_read_fifo(struct net2272_ep *ep, struct net2272_request *req)
537 {
538 u8 *buf;
539 unsigned is_short;
540 int count;
541 int tmp;
542 int cleanup = 0;
543 int status = -1;
544
545 dev_vdbg(ep->dev->dev, "read_fifo %s actual %d len %d\n",
546 ep->ep.name, req->req.actual, req->req.length);
547
548 top:
549 do {
550 buf = req->req.buf + req->req.actual;
551 prefetchw(buf);
552
553 count = (net2272_ep_read(ep, EP_AVAIL1) << 8)
554 | net2272_ep_read(ep, EP_AVAIL0);
555
556 net2272_ep_write(ep, EP_STAT0,
557 (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT) |
558 (1 << DATA_PACKET_RECEIVED_INTERRUPT));
559
560 tmp = req->req.length - req->req.actual;
561
562 if (count > tmp) {
563 if ((tmp % ep->ep.maxpacket) != 0) {
564 dev_err(ep->dev->dev,
565 "%s out fifo %d bytes, expected %d\n",
566 ep->ep.name, count, tmp);
567 cleanup = 1;
568 }
569 count = (tmp > 0) ? tmp : 0;
570 }
571
572 is_short = net2272_read_packet(ep, buf, req, count);
573
574
575 if (unlikely(cleanup || is_short ||
576 req->req.actual == req->req.length)) {
577
578 if (cleanup) {
579 net2272_out_flush(ep);
580 net2272_done(ep, req, -EOVERFLOW);
581 } else
582 net2272_done(ep, req, 0);
583
584
585
586
587
588 if (unlikely(ep->num == 0)) {
589 net2272_ep_write(ep, EP_TRANSFER2, 0);
590 net2272_ep_write(ep, EP_TRANSFER1, 0);
591 net2272_ep_write(ep, EP_TRANSFER0, 0);
592 }
593
594 if (!list_empty(&ep->queue)) {
595 req = list_entry(ep->queue.next,
596 struct net2272_request, queue);
597 status = net2272_kick_dma(ep, req);
598 if ((status < 0) &&
599 !(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)))
600 goto top;
601 }
602 return 1;
603 }
604 } while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)));
605
606 return 0;
607 }
608
609 static void
610 net2272_pio_advance(struct net2272_ep *ep)
611 {
612 struct net2272_request *req;
613
614 if (unlikely(list_empty(&ep->queue)))
615 return;
616
617 req = list_entry(ep->queue.next, struct net2272_request, queue);
618 (ep->is_in ? net2272_write_fifo : net2272_read_fifo)(ep, req);
619 }
620
621
622 static int
623 net2272_request_dma(struct net2272 *dev, unsigned ep, u32 buf,
624 unsigned len, unsigned dir)
625 {
626 dev_vdbg(dev->dev, "request_dma ep %d buf %08x len %d dir %d\n",
627 ep, buf, len, dir);
628
629
630 if (dev->dma_busy)
631 return -EBUSY;
632
633
634
635
636 if ((dir == 1) && (len > 0x1000000))
637 return -EINVAL;
638
639 dev->dma_busy = 1;
640
641
642 #ifdef CONFIG_USB_PCI
643
644 switch (dev->dev_id) {
645 case PCI_DEVICE_ID_RDK1:
646
647 writel((1 << LOCAL_BUS_WIDTH) |
648 (1 << TA_READY_INPUT_ENABLE) |
649 (0 << LOCAL_BURST_ENABLE) |
650 (1 << DONE_INTERRUPT_ENABLE) |
651 (1 << LOCAL_ADDRESSING_MODE) |
652 (1 << DEMAND_MODE) |
653 (1 << DMA_EOT_ENABLE) |
654 (1 << FAST_SLOW_TERMINATE_MODE_SELECT) |
655 (1 << DMA_CHANNEL_INTERRUPT_SELECT),
656 dev->rdk1.plx9054_base_addr + DMAMODE0);
657
658 writel(0x100000, dev->rdk1.plx9054_base_addr + DMALADR0);
659 writel(buf, dev->rdk1.plx9054_base_addr + DMAPADR0);
660 writel(len, dev->rdk1.plx9054_base_addr + DMASIZ0);
661 writel((dir << DIRECTION_OF_TRANSFER) |
662 (1 << INTERRUPT_AFTER_TERMINAL_COUNT),
663 dev->rdk1.plx9054_base_addr + DMADPR0);
664 writel((1 << LOCAL_DMA_CHANNEL_0_INTERRUPT_ENABLE) |
665 readl(dev->rdk1.plx9054_base_addr + INTCSR),
666 dev->rdk1.plx9054_base_addr + INTCSR);
667
668 break;
669 }
670 #endif
671
672 net2272_write(dev, DMAREQ,
673 (0 << DMA_BUFFER_VALID) |
674 (1 << DMA_REQUEST_ENABLE) |
675 (1 << DMA_CONTROL_DACK) |
676 (dev->dma_eot_polarity << EOT_POLARITY) |
677 (dev->dma_dack_polarity << DACK_POLARITY) |
678 (dev->dma_dreq_polarity << DREQ_POLARITY) |
679 ((ep >> 1) << DMA_ENDPOINT_SELECT));
680
681 (void) net2272_read(dev, SCRATCH);
682
683 return 0;
684 }
685
686 static void
687 net2272_start_dma(struct net2272 *dev)
688 {
689
690 #ifdef CONFIG_USB_PCI
691 switch (dev->dev_id) {
692 case PCI_DEVICE_ID_RDK1:
693 writeb((1 << CHANNEL_ENABLE) | (1 << CHANNEL_START),
694 dev->rdk1.plx9054_base_addr + DMACSR0);
695 break;
696 }
697 #endif
698 }
699
700
701 static int
702 net2272_kick_dma(struct net2272_ep *ep, struct net2272_request *req)
703 {
704 unsigned size;
705 u8 tmp;
706
707 if (!use_dma || (ep->num < 1) || (ep->num > 2) || !ep->dma)
708 return -EINVAL;
709
710
711
712
713 if (req->req.length & 1)
714 return -EINVAL;
715
716 dev_vdbg(ep->dev->dev, "kick_dma %s req %p dma %08llx\n",
717 ep->ep.name, req, (unsigned long long) req->req.dma);
718
719 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
720
721
722 if (ep->dev->dma_busy)
723 return -EBUSY;
724
725
726
727
728 size = req->req.length;
729 size &= ~1;
730
731
732 if (ep->is_in) {
733
734 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 0))
735
736 return -EBUSY;
737 req->req.actual += size;
738
739
740 } else {
741 tmp = net2272_ep_read(ep, EP_STAT0);
742
743
744 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 1))
745
746 return -EBUSY;
747
748 if (!(tmp & (1 << BUFFER_EMPTY)))
749 ep->not_empty = 1;
750 else
751 ep->not_empty = 0;
752
753
754
755 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
756
757
758
759
760 if (tmp & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) {
761
762
763 net2272_write(ep->dev, DMAREQ,
764 (0 << DMA_BUFFER_VALID) |
765 (0 << DMA_REQUEST_ENABLE) |
766 (1 << DMA_CONTROL_DACK) |
767 (ep->dev->dma_eot_polarity << EOT_POLARITY) |
768 (ep->dev->dma_dack_polarity << DACK_POLARITY) |
769 (ep->dev->dma_dreq_polarity << DREQ_POLARITY) |
770 ((ep->num >> 1) << DMA_ENDPOINT_SELECT));
771
772 return -EBUSY;
773 }
774 }
775
776
777 net2272_ep_write(ep, EP_IRQENB, 0);
778
779 net2272_start_dma(ep->dev);
780
781 return 0;
782 }
783
784 static void net2272_cancel_dma(struct net2272 *dev)
785 {
786 #ifdef CONFIG_USB_PCI
787 switch (dev->dev_id) {
788 case PCI_DEVICE_ID_RDK1:
789 writeb(0, dev->rdk1.plx9054_base_addr + DMACSR0);
790 writeb(1 << CHANNEL_ABORT, dev->rdk1.plx9054_base_addr + DMACSR0);
791 while (!(readb(dev->rdk1.plx9054_base_addr + DMACSR0) &
792 (1 << CHANNEL_DONE)))
793 continue;
794
795
796 writeb(1 << CHANNEL_CLEAR_INTERRUPT,
797 dev->rdk1.plx9054_base_addr + DMACSR0);
798 break;
799 }
800 #endif
801
802 dev->dma_busy = 0;
803 }
804
805
806
807 static int
808 net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
809 {
810 struct net2272_request *req;
811 struct net2272_ep *ep;
812 struct net2272 *dev;
813 unsigned long flags;
814 int status = -1;
815 u8 s;
816
817 req = container_of(_req, struct net2272_request, req);
818 if (!_req || !_req->complete || !_req->buf
819 || !list_empty(&req->queue))
820 return -EINVAL;
821 ep = container_of(_ep, struct net2272_ep, ep);
822 if (!_ep || (!ep->desc && ep->num != 0))
823 return -EINVAL;
824 dev = ep->dev;
825 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
826 return -ESHUTDOWN;
827
828
829 if (use_dma && ep->dma) {
830 status = usb_gadget_map_request(&dev->gadget, _req,
831 ep->is_in);
832 if (status)
833 return status;
834 }
835
836 dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
837 _ep->name, _req, _req->length, _req->buf,
838 (unsigned long long) _req->dma, _req->zero ? "zero" : "!zero");
839
840 spin_lock_irqsave(&dev->lock, flags);
841
842 _req->status = -EINPROGRESS;
843 _req->actual = 0;
844
845
846 if (list_empty(&ep->queue) && !ep->stopped) {
847
848 if (ep->num == 0 && _req->length == 0) {
849 net2272_done(ep, req, 0);
850 dev_vdbg(dev->dev, "%s status ack\n", ep->ep.name);
851 goto done;
852 }
853
854
855 s = net2272_ep_read(ep, EP_STAT0);
856 if (s & (1 << BUFFER_EMPTY)) {
857
858 if ((s & (1 << NAK_OUT_PACKETS)) &&
859 net2272_ep_read(ep, EP_STAT1) & (1 << LOCAL_OUT_ZLP)) {
860 dev_dbg(dev->dev, "WARNING: returning ZLP short packet termination!\n");
861
862
863
864
865 status = net2272_read_fifo(ep, req);
866
867 net2272_ep_write(ep, EP_STAT0, (1 << NAK_OUT_PACKETS));
868 goto done;
869 }
870 }
871
872
873 status = net2272_kick_dma(ep, req);
874
875 if (status < 0) {
876
877
878
879 status = 0;
880
881 if (ep->is_in)
882 status = net2272_write_fifo(ep, req);
883 else {
884 s = net2272_ep_read(ep, EP_STAT0);
885 if ((s & (1 << BUFFER_EMPTY)) == 0)
886 status = net2272_read_fifo(ep, req);
887 }
888
889 if (unlikely(status != 0)) {
890 if (status > 0)
891 status = 0;
892 req = NULL;
893 }
894 }
895 }
896 if (likely(req))
897 list_add_tail(&req->queue, &ep->queue);
898
899 if (likely(!list_empty(&ep->queue)))
900 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
901 done:
902 spin_unlock_irqrestore(&dev->lock, flags);
903
904 return 0;
905 }
906
907
908 static void
909 net2272_dequeue_all(struct net2272_ep *ep)
910 {
911 struct net2272_request *req;
912
913
914 ep->stopped = 1;
915
916 while (!list_empty(&ep->queue)) {
917 req = list_entry(ep->queue.next,
918 struct net2272_request,
919 queue);
920 net2272_done(ep, req, -ESHUTDOWN);
921 }
922 }
923
924
925 static int
926 net2272_dequeue(struct usb_ep *_ep, struct usb_request *_req)
927 {
928 struct net2272_ep *ep;
929 struct net2272_request *req;
930 unsigned long flags;
931 int stopped;
932
933 ep = container_of(_ep, struct net2272_ep, ep);
934 if (!_ep || (!ep->desc && ep->num != 0) || !_req)
935 return -EINVAL;
936
937 spin_lock_irqsave(&ep->dev->lock, flags);
938 stopped = ep->stopped;
939 ep->stopped = 1;
940
941
942 list_for_each_entry(req, &ep->queue, queue) {
943 if (&req->req == _req)
944 break;
945 }
946 if (&req->req != _req) {
947 ep->stopped = stopped;
948 spin_unlock_irqrestore(&ep->dev->lock, flags);
949 return -EINVAL;
950 }
951
952
953 if (ep->queue.next == &req->queue) {
954 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name);
955 net2272_done(ep, req, -ECONNRESET);
956 }
957 req = NULL;
958 ep->stopped = stopped;
959
960 spin_unlock_irqrestore(&ep->dev->lock, flags);
961 return 0;
962 }
963
964
965
966 static int
967 net2272_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
968 {
969 struct net2272_ep *ep;
970 unsigned long flags;
971 int ret = 0;
972
973 ep = container_of(_ep, struct net2272_ep, ep);
974 if (!_ep || (!ep->desc && ep->num != 0))
975 return -EINVAL;
976 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
977 return -ESHUTDOWN;
978 if (ep->desc && usb_endpoint_xfer_isoc(ep->desc))
979 return -EINVAL;
980
981 spin_lock_irqsave(&ep->dev->lock, flags);
982 if (!list_empty(&ep->queue))
983 ret = -EAGAIN;
984 else if (ep->is_in && value && net2272_fifo_status(_ep) != 0)
985 ret = -EAGAIN;
986 else {
987 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name,
988 value ? "set" : "clear",
989 wedged ? "wedge" : "halt");
990
991 if (value) {
992 if (ep->num == 0)
993 ep->dev->protocol_stall = 1;
994 else
995 set_halt(ep);
996 if (wedged)
997 ep->wedged = 1;
998 } else {
999 clear_halt(ep);
1000 ep->wedged = 0;
1001 }
1002 }
1003 spin_unlock_irqrestore(&ep->dev->lock, flags);
1004
1005 return ret;
1006 }
1007
1008 static int
1009 net2272_set_halt(struct usb_ep *_ep, int value)
1010 {
1011 return net2272_set_halt_and_wedge(_ep, value, 0);
1012 }
1013
1014 static int
1015 net2272_set_wedge(struct usb_ep *_ep)
1016 {
1017 if (!_ep || _ep->name == ep0name)
1018 return -EINVAL;
1019 return net2272_set_halt_and_wedge(_ep, 1, 1);
1020 }
1021
1022 static int
1023 net2272_fifo_status(struct usb_ep *_ep)
1024 {
1025 struct net2272_ep *ep;
1026 u16 avail;
1027
1028 ep = container_of(_ep, struct net2272_ep, ep);
1029 if (!_ep || (!ep->desc && ep->num != 0))
1030 return -ENODEV;
1031 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1032 return -ESHUTDOWN;
1033
1034 avail = net2272_ep_read(ep, EP_AVAIL1) << 8;
1035 avail |= net2272_ep_read(ep, EP_AVAIL0);
1036 if (avail > ep->fifo_size)
1037 return -EOVERFLOW;
1038 if (ep->is_in)
1039 avail = ep->fifo_size - avail;
1040 return avail;
1041 }
1042
1043 static void
1044 net2272_fifo_flush(struct usb_ep *_ep)
1045 {
1046 struct net2272_ep *ep;
1047
1048 ep = container_of(_ep, struct net2272_ep, ep);
1049 if (!_ep || (!ep->desc && ep->num != 0))
1050 return;
1051 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1052 return;
1053
1054 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
1055 }
1056
1057 static const struct usb_ep_ops net2272_ep_ops = {
1058 .enable = net2272_enable,
1059 .disable = net2272_disable,
1060
1061 .alloc_request = net2272_alloc_request,
1062 .free_request = net2272_free_request,
1063
1064 .queue = net2272_queue,
1065 .dequeue = net2272_dequeue,
1066
1067 .set_halt = net2272_set_halt,
1068 .set_wedge = net2272_set_wedge,
1069 .fifo_status = net2272_fifo_status,
1070 .fifo_flush = net2272_fifo_flush,
1071 };
1072
1073
1074
1075 static int
1076 net2272_get_frame(struct usb_gadget *_gadget)
1077 {
1078 struct net2272 *dev;
1079 unsigned long flags;
1080 u16 ret;
1081
1082 if (!_gadget)
1083 return -ENODEV;
1084 dev = container_of(_gadget, struct net2272, gadget);
1085 spin_lock_irqsave(&dev->lock, flags);
1086
1087 ret = net2272_read(dev, FRAME1) << 8;
1088 ret |= net2272_read(dev, FRAME0);
1089
1090 spin_unlock_irqrestore(&dev->lock, flags);
1091 return ret;
1092 }
1093
1094 static int
1095 net2272_wakeup(struct usb_gadget *_gadget)
1096 {
1097 struct net2272 *dev;
1098 u8 tmp;
1099 unsigned long flags;
1100
1101 if (!_gadget)
1102 return 0;
1103 dev = container_of(_gadget, struct net2272, gadget);
1104
1105 spin_lock_irqsave(&dev->lock, flags);
1106 tmp = net2272_read(dev, USBCTL0);
1107 if (tmp & (1 << IO_WAKEUP_ENABLE))
1108 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME));
1109
1110 spin_unlock_irqrestore(&dev->lock, flags);
1111
1112 return 0;
1113 }
1114
1115 static int
1116 net2272_set_selfpowered(struct usb_gadget *_gadget, int value)
1117 {
1118 if (!_gadget)
1119 return -ENODEV;
1120
1121 _gadget->is_selfpowered = (value != 0);
1122
1123 return 0;
1124 }
1125
1126 static int
1127 net2272_pullup(struct usb_gadget *_gadget, int is_on)
1128 {
1129 struct net2272 *dev;
1130 u8 tmp;
1131 unsigned long flags;
1132
1133 if (!_gadget)
1134 return -ENODEV;
1135 dev = container_of(_gadget, struct net2272, gadget);
1136
1137 spin_lock_irqsave(&dev->lock, flags);
1138 tmp = net2272_read(dev, USBCTL0);
1139 dev->softconnect = (is_on != 0);
1140 if (is_on)
1141 tmp |= (1 << USB_DETECT_ENABLE);
1142 else
1143 tmp &= ~(1 << USB_DETECT_ENABLE);
1144 net2272_write(dev, USBCTL0, tmp);
1145 spin_unlock_irqrestore(&dev->lock, flags);
1146
1147 return 0;
1148 }
1149
1150 static int net2272_start(struct usb_gadget *_gadget,
1151 struct usb_gadget_driver *driver);
1152 static int net2272_stop(struct usb_gadget *_gadget);
1153
1154 static const struct usb_gadget_ops net2272_ops = {
1155 .get_frame = net2272_get_frame,
1156 .wakeup = net2272_wakeup,
1157 .set_selfpowered = net2272_set_selfpowered,
1158 .pullup = net2272_pullup,
1159 .udc_start = net2272_start,
1160 .udc_stop = net2272_stop,
1161 };
1162
1163
1164
1165 static ssize_t
1166 registers_show(struct device *_dev, struct device_attribute *attr, char *buf)
1167 {
1168 struct net2272 *dev;
1169 char *next;
1170 unsigned size, t;
1171 unsigned long flags;
1172 u8 t1, t2;
1173 int i;
1174 const char *s;
1175
1176 dev = dev_get_drvdata(_dev);
1177 next = buf;
1178 size = PAGE_SIZE;
1179 spin_lock_irqsave(&dev->lock, flags);
1180
1181
1182 t = scnprintf(next, size, "%s version %s,"
1183 "chiprev %02x, locctl %02x\n"
1184 "irqenb0 %02x irqenb1 %02x "
1185 "irqstat0 %02x irqstat1 %02x\n",
1186 driver_name, driver_vers, dev->chiprev,
1187 net2272_read(dev, LOCCTL),
1188 net2272_read(dev, IRQENB0),
1189 net2272_read(dev, IRQENB1),
1190 net2272_read(dev, IRQSTAT0),
1191 net2272_read(dev, IRQSTAT1));
1192 size -= t;
1193 next += t;
1194
1195
1196 t1 = net2272_read(dev, DMAREQ);
1197 t = scnprintf(next, size, "\ndmareq %02x: %s %s%s%s%s\n",
1198 t1, ep_name[(t1 & 0x01) + 1],
1199 t1 & (1 << DMA_CONTROL_DACK) ? "dack " : "",
1200 t1 & (1 << DMA_REQUEST_ENABLE) ? "reqenb " : "",
1201 t1 & (1 << DMA_REQUEST) ? "req " : "",
1202 t1 & (1 << DMA_BUFFER_VALID) ? "valid " : "");
1203 size -= t;
1204 next += t;
1205
1206
1207 t1 = net2272_read(dev, USBCTL1);
1208 if (t1 & (1 << VBUS_PIN)) {
1209 if (t1 & (1 << USB_HIGH_SPEED))
1210 s = "high speed";
1211 else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1212 s = "powered";
1213 else
1214 s = "full speed";
1215 } else
1216 s = "not attached";
1217 t = scnprintf(next, size,
1218 "usbctl0 %02x usbctl1 %02x addr 0x%02x (%s)\n",
1219 net2272_read(dev, USBCTL0), t1,
1220 net2272_read(dev, OURADDR), s);
1221 size -= t;
1222 next += t;
1223
1224
1225 for (i = 0; i < 4; ++i) {
1226 struct net2272_ep *ep;
1227
1228 ep = &dev->ep[i];
1229 if (i && !ep->desc)
1230 continue;
1231
1232 t1 = net2272_ep_read(ep, EP_CFG);
1233 t2 = net2272_ep_read(ep, EP_RSPSET);
1234 t = scnprintf(next, size,
1235 "\n%s\tcfg %02x rsp (%02x) %s%s%s%s%s%s%s%s"
1236 "irqenb %02x\n",
1237 ep->ep.name, t1, t2,
1238 (t2 & (1 << ALT_NAK_OUT_PACKETS)) ? "NAK " : "",
1239 (t2 & (1 << HIDE_STATUS_PHASE)) ? "hide " : "",
1240 (t2 & (1 << AUTOVALIDATE)) ? "auto " : "",
1241 (t2 & (1 << INTERRUPT_MODE)) ? "interrupt " : "",
1242 (t2 & (1 << CONTROL_STATUS_PHASE_HANDSHAKE)) ? "status " : "",
1243 (t2 & (1 << NAK_OUT_PACKETS_MODE)) ? "NAKmode " : "",
1244 (t2 & (1 << ENDPOINT_TOGGLE)) ? "DATA1 " : "DATA0 ",
1245 (t2 & (1 << ENDPOINT_HALT)) ? "HALT " : "",
1246 net2272_ep_read(ep, EP_IRQENB));
1247 size -= t;
1248 next += t;
1249
1250 t = scnprintf(next, size,
1251 "\tstat0 %02x stat1 %02x avail %04x "
1252 "(ep%d%s-%s)%s\n",
1253 net2272_ep_read(ep, EP_STAT0),
1254 net2272_ep_read(ep, EP_STAT1),
1255 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0),
1256 t1 & 0x0f,
1257 ep->is_in ? "in" : "out",
1258 type_string(t1 >> 5),
1259 ep->stopped ? "*" : "");
1260 size -= t;
1261 next += t;
1262
1263 t = scnprintf(next, size,
1264 "\tep_transfer %06x\n",
1265 ((net2272_ep_read(ep, EP_TRANSFER2) & 0xff) << 16) |
1266 ((net2272_ep_read(ep, EP_TRANSFER1) & 0xff) << 8) |
1267 ((net2272_ep_read(ep, EP_TRANSFER0) & 0xff)));
1268 size -= t;
1269 next += t;
1270
1271 t1 = net2272_ep_read(ep, EP_BUFF_STATES) & 0x03;
1272 t2 = (net2272_ep_read(ep, EP_BUFF_STATES) >> 2) & 0x03;
1273 t = scnprintf(next, size,
1274 "\tbuf-a %s buf-b %s\n",
1275 buf_state_string(t1),
1276 buf_state_string(t2));
1277 size -= t;
1278 next += t;
1279 }
1280
1281 spin_unlock_irqrestore(&dev->lock, flags);
1282
1283 return PAGE_SIZE - size;
1284 }
1285 static DEVICE_ATTR_RO(registers);
1286
1287
1288
1289 static void
1290 net2272_set_fifo_mode(struct net2272 *dev, int mode)
1291 {
1292 u8 tmp;
1293
1294 tmp = net2272_read(dev, LOCCTL) & 0x3f;
1295 tmp |= (mode << 6);
1296 net2272_write(dev, LOCCTL, tmp);
1297
1298 INIT_LIST_HEAD(&dev->gadget.ep_list);
1299
1300
1301 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1302
1303 switch (mode) {
1304 case 0:
1305 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1306 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512;
1307 break;
1308 case 1:
1309 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1310 dev->ep[1].fifo_size = 1024;
1311 dev->ep[2].fifo_size = 512;
1312 break;
1313 case 2:
1314 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1315 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1316 break;
1317 case 3:
1318 dev->ep[1].fifo_size = 1024;
1319 break;
1320 }
1321
1322
1323 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1324 dev->ep[3].fifo_size = 512;
1325 }
1326
1327
1328
1329 static void
1330 net2272_usb_reset(struct net2272 *dev)
1331 {
1332 dev->gadget.speed = USB_SPEED_UNKNOWN;
1333
1334 net2272_cancel_dma(dev);
1335
1336 net2272_write(dev, IRQENB0, 0);
1337 net2272_write(dev, IRQENB1, 0);
1338
1339
1340 net2272_write(dev, IRQSTAT0, 0xff);
1341 net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT));
1342
1343 net2272_write(dev, DMAREQ,
1344 (0 << DMA_BUFFER_VALID) |
1345 (0 << DMA_REQUEST_ENABLE) |
1346 (1 << DMA_CONTROL_DACK) |
1347 (dev->dma_eot_polarity << EOT_POLARITY) |
1348 (dev->dma_dack_polarity << DACK_POLARITY) |
1349 (dev->dma_dreq_polarity << DREQ_POLARITY) |
1350 ((dma_ep >> 1) << DMA_ENDPOINT_SELECT));
1351
1352 net2272_cancel_dma(dev);
1353 net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0);
1354
1355
1356
1357
1358
1359 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH));
1360 net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE));
1361 }
1362
1363 static void
1364 net2272_usb_reinit(struct net2272 *dev)
1365 {
1366 int i;
1367
1368
1369 for (i = 0; i < 4; ++i) {
1370 struct net2272_ep *ep = &dev->ep[i];
1371
1372 ep->ep.name = ep_name[i];
1373 ep->dev = dev;
1374 ep->num = i;
1375 ep->not_empty = 0;
1376
1377 if (use_dma && ep->num == dma_ep)
1378 ep->dma = 1;
1379
1380 if (i > 0 && i <= 3)
1381 ep->fifo_size = 512;
1382 else
1383 ep->fifo_size = 64;
1384 net2272_ep_reset(ep);
1385
1386 if (i == 0) {
1387 ep->ep.caps.type_control = true;
1388 } else {
1389 ep->ep.caps.type_iso = true;
1390 ep->ep.caps.type_bulk = true;
1391 ep->ep.caps.type_int = true;
1392 }
1393
1394 ep->ep.caps.dir_in = true;
1395 ep->ep.caps.dir_out = true;
1396 }
1397 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
1398
1399 dev->gadget.ep0 = &dev->ep[0].ep;
1400 dev->ep[0].stopped = 0;
1401 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
1402 }
1403
1404 static void
1405 net2272_ep0_start(struct net2272 *dev)
1406 {
1407 struct net2272_ep *ep0 = &dev->ep[0];
1408
1409 net2272_ep_write(ep0, EP_RSPSET,
1410 (1 << NAK_OUT_PACKETS_MODE) |
1411 (1 << ALT_NAK_OUT_PACKETS));
1412 net2272_ep_write(ep0, EP_RSPCLR,
1413 (1 << HIDE_STATUS_PHASE) |
1414 (1 << CONTROL_STATUS_PHASE_HANDSHAKE));
1415 net2272_write(dev, USBCTL0,
1416 (dev->softconnect << USB_DETECT_ENABLE) |
1417 (1 << USB_ROOT_PORT_WAKEUP_ENABLE) |
1418 (1 << IO_WAKEUP_ENABLE));
1419 net2272_write(dev, IRQENB0,
1420 (1 << SETUP_PACKET_INTERRUPT_ENABLE) |
1421 (1 << ENDPOINT_0_INTERRUPT_ENABLE) |
1422 (1 << DMA_DONE_INTERRUPT_ENABLE));
1423 net2272_write(dev, IRQENB1,
1424 (1 << VBUS_INTERRUPT_ENABLE) |
1425 (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE) |
1426 (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE));
1427 }
1428
1429
1430
1431
1432
1433
1434
1435 static int net2272_start(struct usb_gadget *_gadget,
1436 struct usb_gadget_driver *driver)
1437 {
1438 struct net2272 *dev;
1439 unsigned i;
1440
1441 if (!driver || !driver->setup ||
1442 driver->max_speed != USB_SPEED_HIGH)
1443 return -EINVAL;
1444
1445 dev = container_of(_gadget, struct net2272, gadget);
1446
1447 for (i = 0; i < 4; ++i)
1448 dev->ep[i].irqs = 0;
1449
1450 dev->softconnect = 1;
1451 driver->driver.bus = NULL;
1452 dev->driver = driver;
1453
1454
1455
1456
1457 net2272_ep0_start(dev);
1458
1459 return 0;
1460 }
1461
1462 static void
1463 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1464 {
1465 int i;
1466
1467
1468 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1469 driver = NULL;
1470
1471
1472
1473
1474 net2272_usb_reset(dev);
1475 for (i = 0; i < 4; ++i)
1476 net2272_dequeue_all(&dev->ep[i]);
1477
1478
1479 if (driver) {
1480 spin_unlock(&dev->lock);
1481 driver->disconnect(&dev->gadget);
1482 spin_lock(&dev->lock);
1483 }
1484
1485 net2272_usb_reinit(dev);
1486 }
1487
1488 static int net2272_stop(struct usb_gadget *_gadget)
1489 {
1490 struct net2272 *dev;
1491 unsigned long flags;
1492
1493 dev = container_of(_gadget, struct net2272, gadget);
1494
1495 spin_lock_irqsave(&dev->lock, flags);
1496 stop_activity(dev, NULL);
1497 spin_unlock_irqrestore(&dev->lock, flags);
1498
1499 dev->driver = NULL;
1500
1501 return 0;
1502 }
1503
1504
1505
1506 static void
1507 net2272_handle_dma(struct net2272_ep *ep)
1508 {
1509 struct net2272_request *req;
1510 unsigned len;
1511 int status;
1512
1513 if (!list_empty(&ep->queue))
1514 req = list_entry(ep->queue.next,
1515 struct net2272_request, queue);
1516 else
1517 req = NULL;
1518
1519 dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req);
1520
1521
1522 net2272_write(ep->dev, DMAREQ,
1523 (0 << DMA_BUFFER_VALID)
1524 | (0 << DMA_REQUEST_ENABLE)
1525 | (1 << DMA_CONTROL_DACK)
1526 | (ep->dev->dma_eot_polarity << EOT_POLARITY)
1527 | (ep->dev->dma_dack_polarity << DACK_POLARITY)
1528 | (ep->dev->dma_dreq_polarity << DREQ_POLARITY)
1529 | (ep->dma << DMA_ENDPOINT_SELECT));
1530
1531 ep->dev->dma_busy = 0;
1532
1533 net2272_ep_write(ep, EP_IRQENB,
1534 (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1535 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1536 | net2272_ep_read(ep, EP_IRQENB));
1537
1538
1539 if (ep->is_in) {
1540
1541 if ((req->req.length % ep->ep.maxpacket != 0) ||
1542 req->req.zero)
1543 set_fifo_bytecount(ep, 0);
1544
1545 net2272_done(ep, req, 0);
1546 if (!list_empty(&ep->queue)) {
1547 req = list_entry(ep->queue.next,
1548 struct net2272_request, queue);
1549 status = net2272_kick_dma(ep, req);
1550 if (status < 0)
1551 net2272_pio_advance(ep);
1552 }
1553
1554
1555 } else {
1556
1557 if (net2272_read(ep->dev, IRQSTAT0) &
1558 (1 << DMA_DONE_INTERRUPT)) {
1559
1560 net2272_cancel_dma(ep->dev);
1561 }
1562
1563
1564
1565
1566
1567
1568 len = (net2272_ep_read(ep, EP_TRANSFER2) << 16)
1569 | (net2272_ep_read(ep, EP_TRANSFER1) << 8)
1570 | (net2272_ep_read(ep, EP_TRANSFER0));
1571
1572 if (ep->not_empty)
1573 len += 4;
1574
1575 req->req.actual += len;
1576
1577
1578 net2272_pio_advance(ep);
1579 }
1580 }
1581
1582
1583
1584 static void
1585 net2272_handle_ep(struct net2272_ep *ep)
1586 {
1587 struct net2272_request *req;
1588 u8 stat0, stat1;
1589
1590 if (!list_empty(&ep->queue))
1591 req = list_entry(ep->queue.next,
1592 struct net2272_request, queue);
1593 else
1594 req = NULL;
1595
1596
1597 stat0 = net2272_ep_read(ep, EP_STAT0);
1598 stat1 = net2272_ep_read(ep, EP_STAT1);
1599 ep->irqs++;
1600
1601 dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n",
1602 ep->ep.name, stat0, stat1, req ? &req->req : NULL);
1603
1604 net2272_ep_write(ep, EP_STAT0, stat0 &
1605 ~((1 << NAK_OUT_PACKETS)
1606 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)));
1607 net2272_ep_write(ep, EP_STAT1, stat1);
1608
1609
1610
1611
1612
1613 if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT)))
1614 net2272_pio_advance(ep);
1615
1616 else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))
1617 net2272_pio_advance(ep);
1618 }
1619
1620 static struct net2272_ep *
1621 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex)
1622 {
1623 struct net2272_ep *ep;
1624
1625 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
1626 return &dev->ep[0];
1627
1628 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1629 u8 bEndpointAddress;
1630
1631 if (!ep->desc)
1632 continue;
1633 bEndpointAddress = ep->desc->bEndpointAddress;
1634 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
1635 continue;
1636 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
1637 return ep;
1638 }
1639 return NULL;
1640 }
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651 static const u8 net2272_test_packet[] = {
1652 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1653 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1654 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1655 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1656 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1657 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E
1658 };
1659
1660 static void
1661 net2272_set_test_mode(struct net2272 *dev, int mode)
1662 {
1663 int i;
1664
1665
1666
1667
1668 net2272_write(dev, IRQENB0, 0x00);
1669 net2272_write(dev, IRQENB1, 0x00);
1670
1671
1672 net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED);
1673
1674 net2272_write(dev, PAGESEL, 0);
1675 net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT);
1676 net2272_write(dev, EP_RSPCLR,
1677 (1 << CONTROL_STATUS_PHASE_HANDSHAKE)
1678 | (1 << HIDE_STATUS_PHASE));
1679 net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION);
1680 net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH);
1681
1682
1683 while (!(net2272_read(dev, EP_STAT0) &
1684 (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)))
1685 ;
1686
1687
1688 net2272_write(dev, USBTEST, mode);
1689
1690
1691 if (mode == TEST_PACKET) {
1692
1693 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) &
1694 ~(1 << DATA_WIDTH));
1695
1696 for (i = 0; i < sizeof(net2272_test_packet); ++i)
1697 net2272_write(dev, EP_DATA, net2272_test_packet[i]);
1698
1699
1700 net2272_write(dev, EP_TRANSFER0, 0);
1701 }
1702 }
1703
1704 static void
1705 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat)
1706 {
1707 struct net2272_ep *ep;
1708 u8 num, scratch;
1709
1710
1711 if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) {
1712 union {
1713 u8 raw[8];
1714 struct usb_ctrlrequest r;
1715 } u;
1716 int tmp = 0;
1717 struct net2272_request *req;
1718
1719 if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
1720 if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED))
1721 dev->gadget.speed = USB_SPEED_HIGH;
1722 else
1723 dev->gadget.speed = USB_SPEED_FULL;
1724 dev_dbg(dev->dev, "%s\n",
1725 usb_speed_string(dev->gadget.speed));
1726 }
1727
1728 ep = &dev->ep[0];
1729 ep->irqs++;
1730
1731
1732 stat &= ~(1 << ENDPOINT_0_INTERRUPT);
1733 while (!list_empty(&ep->queue)) {
1734 req = list_entry(ep->queue.next,
1735 struct net2272_request, queue);
1736 net2272_done(ep, req,
1737 (req->req.actual == req->req.length) ? 0 : -EPROTO);
1738 }
1739 ep->stopped = 0;
1740 dev->protocol_stall = 0;
1741 net2272_ep_write(ep, EP_STAT0,
1742 (1 << DATA_IN_TOKEN_INTERRUPT)
1743 | (1 << DATA_OUT_TOKEN_INTERRUPT)
1744 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
1745 | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
1746 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
1747 net2272_ep_write(ep, EP_STAT1,
1748 (1 << TIMEOUT)
1749 | (1 << USB_OUT_ACK_SENT)
1750 | (1 << USB_OUT_NAK_SENT)
1751 | (1 << USB_IN_ACK_RCVD)
1752 | (1 << USB_IN_NAK_SENT)
1753 | (1 << USB_STALL_SENT)
1754 | (1 << LOCAL_OUT_ZLP));
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765 net2272_write(dev, PAGESEL, 0);
1766 net2272_write(dev, EP_TRANSFER2, 0xff);
1767 net2272_write(dev, EP_TRANSFER1, 0xff);
1768 net2272_write(dev, EP_TRANSFER0, 0xff);
1769
1770 u.raw[0] = net2272_read(dev, SETUP0);
1771 u.raw[1] = net2272_read(dev, SETUP1);
1772 u.raw[2] = net2272_read(dev, SETUP2);
1773 u.raw[3] = net2272_read(dev, SETUP3);
1774 u.raw[4] = net2272_read(dev, SETUP4);
1775 u.raw[5] = net2272_read(dev, SETUP5);
1776 u.raw[6] = net2272_read(dev, SETUP6);
1777 u.raw[7] = net2272_read(dev, SETUP7);
1778
1779
1780
1781
1782 le16_to_cpus(&u.r.wValue);
1783 le16_to_cpus(&u.r.wIndex);
1784 le16_to_cpus(&u.r.wLength);
1785
1786
1787 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT);
1788 stat ^= (1 << SETUP_PACKET_INTERRUPT);
1789
1790
1791
1792
1793 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
1794 if (ep->is_in) {
1795 scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1796 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1797 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1798 stop_out_naking(ep);
1799 } else
1800 scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1801 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1802 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1803 net2272_ep_write(ep, EP_IRQENB, scratch);
1804
1805 if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
1806 goto delegate;
1807 switch (u.r.bRequest) {
1808 case USB_REQ_GET_STATUS: {
1809 struct net2272_ep *e;
1810 u16 status = 0;
1811
1812 switch (u.r.bRequestType & USB_RECIP_MASK) {
1813 case USB_RECIP_ENDPOINT:
1814 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1815 if (!e || u.r.wLength > 2)
1816 goto do_stall;
1817 if (net2272_ep_read(e, EP_RSPSET) & (1 << ENDPOINT_HALT))
1818 status = cpu_to_le16(1);
1819 else
1820 status = cpu_to_le16(0);
1821
1822
1823 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1824 writew(status, net2272_reg_addr(dev, EP_DATA));
1825 set_fifo_bytecount(&dev->ep[0], 0);
1826 allow_status(ep);
1827 dev_vdbg(dev->dev, "%s stat %02x\n",
1828 ep->ep.name, status);
1829 goto next_endpoints;
1830 case USB_RECIP_DEVICE:
1831 if (u.r.wLength > 2)
1832 goto do_stall;
1833 if (dev->gadget.is_selfpowered)
1834 status = (1 << USB_DEVICE_SELF_POWERED);
1835
1836
1837 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1838 writew(status, net2272_reg_addr(dev, EP_DATA));
1839 set_fifo_bytecount(&dev->ep[0], 0);
1840 allow_status(ep);
1841 dev_vdbg(dev->dev, "device stat %02x\n", status);
1842 goto next_endpoints;
1843 case USB_RECIP_INTERFACE:
1844 if (u.r.wLength > 2)
1845 goto do_stall;
1846
1847
1848 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1849 writew(status, net2272_reg_addr(dev, EP_DATA));
1850 set_fifo_bytecount(&dev->ep[0], 0);
1851 allow_status(ep);
1852 dev_vdbg(dev->dev, "interface status %02x\n", status);
1853 goto next_endpoints;
1854 }
1855
1856 break;
1857 }
1858 case USB_REQ_CLEAR_FEATURE: {
1859 struct net2272_ep *e;
1860
1861 if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1862 goto delegate;
1863 if (u.r.wValue != USB_ENDPOINT_HALT ||
1864 u.r.wLength != 0)
1865 goto do_stall;
1866 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1867 if (!e)
1868 goto do_stall;
1869 if (e->wedged) {
1870 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n",
1871 ep->ep.name);
1872 } else {
1873 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name);
1874 clear_halt(e);
1875 }
1876 allow_status(ep);
1877 goto next_endpoints;
1878 }
1879 case USB_REQ_SET_FEATURE: {
1880 struct net2272_ep *e;
1881
1882 if (u.r.bRequestType == USB_RECIP_DEVICE) {
1883 if (u.r.wIndex != NORMAL_OPERATION)
1884 net2272_set_test_mode(dev, (u.r.wIndex >> 8));
1885 allow_status(ep);
1886 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex);
1887 goto next_endpoints;
1888 } else if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1889 goto delegate;
1890 if (u.r.wValue != USB_ENDPOINT_HALT ||
1891 u.r.wLength != 0)
1892 goto do_stall;
1893 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1894 if (!e)
1895 goto do_stall;
1896 set_halt(e);
1897 allow_status(ep);
1898 dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name);
1899 goto next_endpoints;
1900 }
1901 case USB_REQ_SET_ADDRESS: {
1902 net2272_write(dev, OURADDR, u.r.wValue & 0xff);
1903 allow_status(ep);
1904 break;
1905 }
1906 default:
1907 delegate:
1908 dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x "
1909 "ep_cfg %08x\n",
1910 u.r.bRequestType, u.r.bRequest,
1911 u.r.wValue, u.r.wIndex,
1912 net2272_ep_read(ep, EP_CFG));
1913 spin_unlock(&dev->lock);
1914 tmp = dev->driver->setup(&dev->gadget, &u.r);
1915 spin_lock(&dev->lock);
1916 }
1917
1918
1919 if (tmp < 0) {
1920 do_stall:
1921 dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n",
1922 u.r.bRequestType, u.r.bRequest, tmp);
1923 dev->protocol_stall = 1;
1924 }
1925
1926 } else if (stat & (1 << DMA_DONE_INTERRUPT)) {
1927 net2272_cancel_dma(dev);
1928 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT);
1929 stat &= ~(1 << DMA_DONE_INTERRUPT);
1930 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT))
1931 ? 2 : 1;
1932
1933 ep = &dev->ep[num];
1934 net2272_handle_dma(ep);
1935 }
1936
1937 next_endpoints:
1938
1939 scratch = stat & 0x0f;
1940 stat &= ~0x0f;
1941 for (num = 0; scratch; num++) {
1942 u8 t;
1943
1944
1945 t = 1 << num;
1946 if ((scratch & t) == 0)
1947 continue;
1948 scratch ^= t;
1949
1950 ep = &dev->ep[num];
1951 net2272_handle_ep(ep);
1952 }
1953
1954
1955 stat &= ~(1 << SOF_INTERRUPT);
1956
1957 if (stat)
1958 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat);
1959 }
1960
1961 static void
1962 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1963 {
1964 u8 tmp, mask;
1965
1966
1967 tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT);
1968 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED);
1969
1970 if (stat & tmp) {
1971 bool reset = false;
1972 bool disconnect = false;
1973
1974
1975
1976
1977
1978 net2272_write(dev, IRQSTAT1, tmp);
1979 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1980 if ((stat & (1 << VBUS_INTERRUPT)) &&
1981 (net2272_read(dev, USBCTL1) &
1982 (1 << VBUS_PIN)) == 0) {
1983 disconnect = true;
1984 dev_dbg(dev->dev, "disconnect %s\n",
1985 dev->driver->driver.name);
1986 } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) &&
1987 (net2272_read(dev, USBCTL1) & mask)
1988 == 0) {
1989 reset = true;
1990 dev_dbg(dev->dev, "reset %s\n",
1991 dev->driver->driver.name);
1992 }
1993
1994 if (disconnect || reset) {
1995 stop_activity(dev, dev->driver);
1996 net2272_ep0_start(dev);
1997 spin_unlock(&dev->lock);
1998 if (reset)
1999 usb_gadget_udc_reset
2000 (&dev->gadget, dev->driver);
2001 else
2002 (dev->driver->disconnect)
2003 (&dev->gadget);
2004 spin_lock(&dev->lock);
2005 return;
2006 }
2007 }
2008 stat &= ~tmp;
2009
2010 if (!stat)
2011 return;
2012 }
2013
2014 tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
2015 if (stat & tmp) {
2016 net2272_write(dev, IRQSTAT1, tmp);
2017 if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
2018 if (dev->driver->suspend)
2019 dev->driver->suspend(&dev->gadget);
2020 if (!enable_suspend) {
2021 stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
2022 dev_dbg(dev->dev, "Suspend disabled, ignoring\n");
2023 }
2024 } else {
2025 if (dev->driver->resume)
2026 dev->driver->resume(&dev->gadget);
2027 }
2028 stat &= ~tmp;
2029 }
2030
2031
2032 if (stat)
2033 net2272_write(dev, IRQSTAT1, stat);
2034
2035
2036 stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
2037 | (1 << SUSPEND_REQUEST_INTERRUPT)
2038 | (1 << RESUME_INTERRUPT));
2039 if (!stat)
2040 return;
2041 else
2042 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat);
2043 }
2044
2045 static irqreturn_t net2272_irq(int irq, void *_dev)
2046 {
2047 struct net2272 *dev = _dev;
2048 #if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2)
2049 u32 intcsr;
2050 #endif
2051 #if defined(PLX_PCI_RDK)
2052 u8 dmareq;
2053 #endif
2054 spin_lock(&dev->lock);
2055 #if defined(PLX_PCI_RDK)
2056 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2057
2058 if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) {
2059 writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE),
2060 dev->rdk1.plx9054_base_addr + INTCSR);
2061 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2062 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2063 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2064 writel(intcsr | (1 << PCI_INTERRUPT_ENABLE),
2065 dev->rdk1.plx9054_base_addr + INTCSR);
2066 }
2067 if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) {
2068 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2069 dev->rdk1.plx9054_base_addr + DMACSR0);
2070
2071 dmareq = net2272_read(dev, DMAREQ);
2072 if (dmareq & 0x01)
2073 net2272_handle_dma(&dev->ep[2]);
2074 else
2075 net2272_handle_dma(&dev->ep[1]);
2076 }
2077 #endif
2078 #if defined(PLX_PCI_RDK2)
2079
2080 intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT);
2081 if (!(intcsr & (1 << NET2272_PCI_IRQ))) {
2082 spin_unlock(&dev->lock);
2083 return IRQ_NONE;
2084 }
2085
2086 #endif
2087
2088 #if !defined(PLX_PCI_RDK)
2089 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2090 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2091 #endif
2092 spin_unlock(&dev->lock);
2093
2094 return IRQ_HANDLED;
2095 }
2096
2097 static int net2272_present(struct net2272 *dev)
2098 {
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108 unsigned int ii;
2109 u8 val, refval;
2110
2111
2112 refval = net2272_read(dev, SCRATCH);
2113 for (ii = 0; ii < 0x100; ii += 7) {
2114 net2272_write(dev, SCRATCH, ii);
2115 val = net2272_read(dev, SCRATCH);
2116 if (val != ii) {
2117 dev_dbg(dev->dev,
2118 "%s: write/read SCRATCH register test failed: "
2119 "wrote:0x%2.2x, read:0x%2.2x\n",
2120 __func__, ii, val);
2121 return -EINVAL;
2122 }
2123 }
2124
2125 net2272_write(dev, SCRATCH, refval);
2126
2127
2128 refval = net2272_read(dev, CHIPREV_2272);
2129 for (ii = 0; ii < 0x100; ii += 7) {
2130 net2272_write(dev, CHIPREV_2272, ii);
2131 val = net2272_read(dev, CHIPREV_2272);
2132 if (val != refval) {
2133 dev_dbg(dev->dev,
2134 "%s: write/read CHIPREV register test failed: "
2135 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n",
2136 __func__, ii, val, refval);
2137 return -EINVAL;
2138 }
2139 }
2140
2141
2142
2143
2144
2145
2146
2147
2148 val = net2272_read(dev, CHIPREV_LEGACY);
2149 if (val != NET2270_LEGACY_REV) {
2150
2151
2152
2153
2154 dev_dbg(dev->dev,
2155 "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n"
2156 " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n",
2157 __func__, NET2270_LEGACY_REV, val);
2158 return -EINVAL;
2159 }
2160
2161
2162
2163
2164
2165
2166 val = net2272_read(dev, CHIPREV_2272);
2167 switch (val) {
2168 case CHIPREV_NET2272_R1:
2169
2170
2171
2172
2173 dev_dbg(dev->dev,
2174 "%s: Rev 1 detected: newer silicon recommended for DMA support\n",
2175 __func__);
2176 break;
2177 case CHIPREV_NET2272_R1A:
2178 break;
2179 default:
2180
2181 dev_dbg(dev->dev,
2182 "%s: unexpected silicon revision register value: "
2183 " CHIPREV_2272: 0x%2.2x\n",
2184 __func__, val);
2185
2186
2187
2188
2189
2190 }
2191
2192
2193 return 0;
2194 }
2195
2196 static void
2197 net2272_gadget_release(struct device *_dev)
2198 {
2199 struct net2272 *dev = dev_get_drvdata(_dev);
2200 kfree(dev);
2201 }
2202
2203
2204
2205 static void
2206 net2272_remove(struct net2272 *dev)
2207 {
2208 usb_del_gadget_udc(&dev->gadget);
2209 free_irq(dev->irq, dev);
2210 iounmap(dev->base_addr);
2211 device_remove_file(dev->dev, &dev_attr_registers);
2212
2213 dev_info(dev->dev, "unbind\n");
2214 }
2215
2216 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq)
2217 {
2218 struct net2272 *ret;
2219
2220 if (!irq) {
2221 dev_dbg(dev, "No IRQ!\n");
2222 return ERR_PTR(-ENODEV);
2223 }
2224
2225
2226 ret = kzalloc(sizeof(*ret), GFP_KERNEL);
2227 if (!ret)
2228 return ERR_PTR(-ENOMEM);
2229
2230 spin_lock_init(&ret->lock);
2231 ret->irq = irq;
2232 ret->dev = dev;
2233 ret->gadget.ops = &net2272_ops;
2234 ret->gadget.max_speed = USB_SPEED_HIGH;
2235
2236
2237 ret->gadget.name = driver_name;
2238
2239 return ret;
2240 }
2241
2242 static int
2243 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2244 {
2245 int ret;
2246
2247
2248 if (net2272_present(dev)) {
2249 dev_warn(dev->dev, "2272 not found!\n");
2250 ret = -ENODEV;
2251 goto err;
2252 }
2253
2254 net2272_usb_reset(dev);
2255 net2272_usb_reinit(dev);
2256
2257 ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2258 if (ret) {
2259 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2260 goto err;
2261 }
2262
2263 dev->chiprev = net2272_read(dev, CHIPREV_2272);
2264
2265
2266 dev_info(dev->dev, "%s\n", driver_desc);
2267 dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2268 dev->irq, dev->base_addr, dev->chiprev,
2269 dma_mode_string());
2270 dev_info(dev->dev, "version: %s\n", driver_vers);
2271
2272 ret = device_create_file(dev->dev, &dev_attr_registers);
2273 if (ret)
2274 goto err_irq;
2275
2276 ret = usb_add_gadget_udc_release(dev->dev, &dev->gadget,
2277 net2272_gadget_release);
2278 if (ret)
2279 goto err_add_udc;
2280
2281 return 0;
2282
2283 err_add_udc:
2284 device_remove_file(dev->dev, &dev_attr_registers);
2285 err_irq:
2286 free_irq(dev->irq, dev);
2287 err:
2288 return ret;
2289 }
2290
2291 #ifdef CONFIG_USB_PCI
2292
2293
2294
2295
2296
2297
2298 static int
2299 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2300 {
2301 unsigned long resource, len, tmp;
2302 void __iomem *mem_mapped_addr[4];
2303 int ret, i;
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313 for (i = 0; i < 4; ++i) {
2314 if (i == 1)
2315 continue;
2316
2317 resource = pci_resource_start(pdev, i);
2318 len = pci_resource_len(pdev, i);
2319
2320 if (!request_mem_region(resource, len, driver_name)) {
2321 dev_dbg(dev->dev, "controller already in use\n");
2322 ret = -EBUSY;
2323 goto err;
2324 }
2325
2326 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2327 if (mem_mapped_addr[i] == NULL) {
2328 release_mem_region(resource, len);
2329 dev_dbg(dev->dev, "can't map memory\n");
2330 ret = -EFAULT;
2331 goto err;
2332 }
2333 }
2334
2335 dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2336 dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2337 dev->base_addr = mem_mapped_addr[3];
2338
2339
2340 tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2341 writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2342 dev->rdk1.plx9054_base_addr + LBRD1);
2343
2344
2345 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2346 (1 << PCI_INTERRUPT_ENABLE) |
2347 (1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2348 dev->rdk1.plx9054_base_addr + INTCSR);
2349
2350 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2351 dev->rdk1.plx9054_base_addr + DMACSR0);
2352
2353
2354 writeb((1 << EPLD_DMA_ENABLE) |
2355 (1 << DMA_CTL_DACK) |
2356 (1 << DMA_TIMEOUT_ENABLE) |
2357 (1 << USER) |
2358 (0 << MPX_MODE) |
2359 (1 << BUSWIDTH) |
2360 (1 << NET2272_RESET),
2361 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2362
2363 mb();
2364 writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2365 ~(1 << NET2272_RESET),
2366 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2367 udelay(200);
2368
2369 return 0;
2370
2371 err:
2372 while (--i >= 0) {
2373 iounmap(mem_mapped_addr[i]);
2374 release_mem_region(pci_resource_start(pdev, i),
2375 pci_resource_len(pdev, i));
2376 }
2377
2378 return ret;
2379 }
2380
2381 static int
2382 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2383 {
2384 unsigned long resource, len;
2385 void __iomem *mem_mapped_addr[2];
2386 int ret, i;
2387
2388
2389
2390
2391
2392
2393
2394 for (i = 0; i < 2; ++i) {
2395 resource = pci_resource_start(pdev, i);
2396 len = pci_resource_len(pdev, i);
2397
2398 if (!request_mem_region(resource, len, driver_name)) {
2399 dev_dbg(dev->dev, "controller already in use\n");
2400 ret = -EBUSY;
2401 goto err;
2402 }
2403
2404 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2405 if (mem_mapped_addr[i] == NULL) {
2406 release_mem_region(resource, len);
2407 dev_dbg(dev->dev, "can't map memory\n");
2408 ret = -EFAULT;
2409 goto err;
2410 }
2411 }
2412
2413 dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2414 dev->base_addr = mem_mapped_addr[1];
2415
2416 mb();
2417
2418 writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2419 udelay(200);
2420 writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2421
2422 dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2423 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2424
2425 writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2426
2427 return 0;
2428
2429 err:
2430 while (--i >= 0) {
2431 iounmap(mem_mapped_addr[i]);
2432 release_mem_region(pci_resource_start(pdev, i),
2433 pci_resource_len(pdev, i));
2434 }
2435
2436 return ret;
2437 }
2438
2439 static int
2440 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2441 {
2442 struct net2272 *dev;
2443 int ret;
2444
2445 dev = net2272_probe_init(&pdev->dev, pdev->irq);
2446 if (IS_ERR(dev))
2447 return PTR_ERR(dev);
2448 dev->dev_id = pdev->device;
2449
2450 if (pci_enable_device(pdev) < 0) {
2451 ret = -ENODEV;
2452 goto err_free;
2453 }
2454
2455 pci_set_master(pdev);
2456
2457 switch (pdev->device) {
2458 case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2459 case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2460 default: BUG();
2461 }
2462 if (ret)
2463 goto err_pci;
2464
2465 ret = net2272_probe_fin(dev, 0);
2466 if (ret)
2467 goto err_pci;
2468
2469 pci_set_drvdata(pdev, dev);
2470
2471 return 0;
2472
2473 err_pci:
2474 pci_disable_device(pdev);
2475 err_free:
2476 kfree(dev);
2477
2478 return ret;
2479 }
2480
2481 static void
2482 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2483 {
2484 int i;
2485
2486
2487 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2488 ~(1 << PCI_INTERRUPT_ENABLE),
2489 dev->rdk1.plx9054_base_addr + INTCSR);
2490
2491
2492 iounmap(dev->rdk1.plx9054_base_addr);
2493 iounmap(dev->rdk1.epld_base_addr);
2494
2495 for (i = 0; i < 4; ++i) {
2496 if (i == 1)
2497 continue;
2498 release_mem_region(pci_resource_start(pdev, i),
2499 pci_resource_len(pdev, i));
2500 }
2501 }
2502
2503 static void
2504 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2505 {
2506 int i;
2507
2508
2509
2510
2511
2512
2513
2514
2515 iounmap(dev->rdk2.fpga_base_addr);
2516
2517 for (i = 0; i < 2; ++i)
2518 release_mem_region(pci_resource_start(pdev, i),
2519 pci_resource_len(pdev, i));
2520 }
2521
2522 static void
2523 net2272_pci_remove(struct pci_dev *pdev)
2524 {
2525 struct net2272 *dev = pci_get_drvdata(pdev);
2526
2527 net2272_remove(dev);
2528
2529 switch (pdev->device) {
2530 case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2531 case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2532 default: BUG();
2533 }
2534
2535 pci_disable_device(pdev);
2536
2537 kfree(dev);
2538 }
2539
2540
2541 static struct pci_device_id pci_ids[] = {
2542 {
2543 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2544 .class_mask = 0,
2545 .vendor = PCI_VENDOR_ID_PLX,
2546 .device = PCI_DEVICE_ID_RDK1,
2547 .subvendor = PCI_ANY_ID,
2548 .subdevice = PCI_ANY_ID,
2549 },
2550 {
2551 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2552 .class_mask = 0,
2553 .vendor = PCI_VENDOR_ID_PLX,
2554 .device = PCI_DEVICE_ID_RDK2,
2555 .subvendor = PCI_ANY_ID,
2556 .subdevice = PCI_ANY_ID,
2557 },
2558 { }
2559 };
2560 MODULE_DEVICE_TABLE(pci, pci_ids);
2561
2562 static struct pci_driver net2272_pci_driver = {
2563 .name = driver_name,
2564 .id_table = pci_ids,
2565
2566 .probe = net2272_pci_probe,
2567 .remove = net2272_pci_remove,
2568 };
2569
2570 static int net2272_pci_register(void)
2571 {
2572 return pci_register_driver(&net2272_pci_driver);
2573 }
2574
2575 static void net2272_pci_unregister(void)
2576 {
2577 pci_unregister_driver(&net2272_pci_driver);
2578 }
2579
2580 #else
2581 static inline int net2272_pci_register(void) { return 0; }
2582 static inline void net2272_pci_unregister(void) { }
2583 #endif
2584
2585
2586
2587 static int
2588 net2272_plat_probe(struct platform_device *pdev)
2589 {
2590 struct net2272 *dev;
2591 int ret;
2592 unsigned int irqflags;
2593 resource_size_t base, len;
2594 struct resource *iomem, *iomem_bus, *irq_res;
2595
2596 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2597 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2598 iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2599 if (!irq_res || !iomem) {
2600 dev_err(&pdev->dev, "must provide irq/base addr");
2601 return -EINVAL;
2602 }
2603
2604 dev = net2272_probe_init(&pdev->dev, irq_res->start);
2605 if (IS_ERR(dev))
2606 return PTR_ERR(dev);
2607
2608 irqflags = 0;
2609 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2610 irqflags |= IRQF_TRIGGER_RISING;
2611 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2612 irqflags |= IRQF_TRIGGER_FALLING;
2613 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2614 irqflags |= IRQF_TRIGGER_HIGH;
2615 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2616 irqflags |= IRQF_TRIGGER_LOW;
2617
2618 base = iomem->start;
2619 len = resource_size(iomem);
2620 if (iomem_bus)
2621 dev->base_shift = iomem_bus->start;
2622
2623 if (!request_mem_region(base, len, driver_name)) {
2624 dev_dbg(dev->dev, "get request memory region!\n");
2625 ret = -EBUSY;
2626 goto err;
2627 }
2628 dev->base_addr = ioremap_nocache(base, len);
2629 if (!dev->base_addr) {
2630 dev_dbg(dev->dev, "can't map memory\n");
2631 ret = -EFAULT;
2632 goto err_req;
2633 }
2634
2635 ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW);
2636 if (ret)
2637 goto err_io;
2638
2639 platform_set_drvdata(pdev, dev);
2640 dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2641 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2642
2643 return 0;
2644
2645 err_io:
2646 iounmap(dev->base_addr);
2647 err_req:
2648 release_mem_region(base, len);
2649 err:
2650 kfree(dev);
2651
2652 return ret;
2653 }
2654
2655 static int
2656 net2272_plat_remove(struct platform_device *pdev)
2657 {
2658 struct net2272 *dev = platform_get_drvdata(pdev);
2659
2660 net2272_remove(dev);
2661
2662 release_mem_region(pdev->resource[0].start,
2663 resource_size(&pdev->resource[0]));
2664
2665 kfree(dev);
2666
2667 return 0;
2668 }
2669
2670 static struct platform_driver net2272_plat_driver = {
2671 .probe = net2272_plat_probe,
2672 .remove = net2272_plat_remove,
2673 .driver = {
2674 .name = driver_name,
2675 },
2676
2677 };
2678 MODULE_ALIAS("platform:net2272");
2679
2680 static int __init net2272_init(void)
2681 {
2682 int ret;
2683
2684 ret = net2272_pci_register();
2685 if (ret)
2686 return ret;
2687 ret = platform_driver_register(&net2272_plat_driver);
2688 if (ret)
2689 goto err_pci;
2690 return ret;
2691
2692 err_pci:
2693 net2272_pci_unregister();
2694 return ret;
2695 }
2696 module_init(net2272_init);
2697
2698 static void __exit net2272_cleanup(void)
2699 {
2700 net2272_pci_unregister();
2701 platform_driver_unregister(&net2272_plat_driver);
2702 }
2703 module_exit(net2272_cleanup);
2704
2705 MODULE_DESCRIPTION(DRIVER_DESC);
2706 MODULE_AUTHOR("PLX Technology, Inc.");
2707 MODULE_LICENSE("GPL");