1 // SPDX-License-Identifier: GPL-2.0+
3 * Driver for PLX NET2272 USB device controller
5 * Copyright (C) 2005-2006 PLX Technology, Inc.
6 * Copyright (C) 2006-2011 Analog Devices, Inc.
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/errno.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
15 #include <linux/ioport.h>
16 #include <linux/kernel.h>
17 #include <linux/list.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/pci.h>
21 #include <linux/platform_device.h>
22 #include <linux/prefetch.h>
23 #include <linux/sched.h>
24 #include <linux/slab.h>
25 #include <linux/timer.h>
26 #include <linux/usb.h>
27 #include <linux/usb/ch9.h>
28 #include <linux/usb/gadget.h>
30 #include <asm/byteorder.h>
31 #include <asm/unaligned.h>
35 #define DRIVER_DESC "PLX NET2272 USB Peripheral Controller"
37 static const char driver_name[] = "net2272";
38 static const char driver_vers[] = "2006 October 17/mainline";
39 static const char driver_desc[] = DRIVER_DESC;
41 static const char ep0name[] = "ep0";
42 static const char * const ep_name[] = {
44 "ep-a", "ep-b", "ep-c",
47 #ifdef CONFIG_USB_NET2272_DMA
49 * use_dma: the NET2272 can use an external DMA controller.
50 * Note that since there is no generic DMA api, some functions,
51 * notably request_dma, start_dma, and cancel_dma will need to be
52 * modified for your platform's particular dma controller.
54 * If use_dma is disabled, pio will be used instead.
56 static bool use_dma = false;
57 module_param(use_dma, bool, 0644);
60 * dma_ep: selects the endpoint for use with dma (1=ep-a, 2=ep-b)
61 * The NET2272 can only use dma for a single endpoint at a time.
62 * At some point this could be modified to allow either endpoint
63 * to take control of dma as it becomes available.
65 * Note that DMA should not be used on OUT endpoints unless it can
66 * be guaranteed that no short packets will arrive on an IN endpoint
67 * while the DMA operation is pending. Otherwise the OUT DMA will
68 * terminate prematurely (See NET2272 Errata 630-0213-0101)
70 static ushort dma_ep = 1;
71 module_param(dma_ep, ushort, 0644);
74 * dma_mode: net2272 dma mode setting (see LOCCTL1 definition):
75 * mode 0 == Slow DREQ mode
76 * mode 1 == Fast DREQ mode
77 * mode 2 == Burst mode
79 static ushort dma_mode = 2;
80 module_param(dma_mode, ushort, 0644);
88 * fifo_mode: net2272 buffer configuration:
89 * mode 0 == ep-{a,b,c} 512db each
90 * mode 1 == ep-a 1k, ep-{b,c} 512db
91 * mode 2 == ep-a 1k, ep-b 1k, ep-c 512db
92 * mode 3 == ep-a 1k, ep-b disabled, ep-c 512db
94 static ushort fifo_mode;
95 module_param(fifo_mode, ushort, 0644);
98 * enable_suspend: When enabled, the driver will respond to
99 * USB suspend requests by powering down the NET2272. Otherwise,
100 * USB suspend requests will be ignored. This is acceptable for
101 * self-powered devices. For bus powered devices set this to 1.
103 static ushort enable_suspend;
104 module_param(enable_suspend, ushort, 0644);
106 static void assert_out_naking(struct net2272_ep *ep, const char *where)
114 tmp = net2272_ep_read(ep, EP_STAT0);
115 if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
116 dev_dbg(ep->dev->dev, "%s %s %02x !NAK\n",
117 ep->ep.name, where, tmp);
118 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
121 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep, __func__)
123 static void stop_out_naking(struct net2272_ep *ep)
125 u8 tmp = net2272_ep_read(ep, EP_STAT0);
127 if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
128 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
131 #define PIPEDIR(bAddress) (usb_pipein(bAddress) ? "in" : "out")
133 static char *type_string(u8 bmAttributes)
135 switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) {
136 case USB_ENDPOINT_XFER_BULK: return "bulk";
137 case USB_ENDPOINT_XFER_ISOC: return "iso";
138 case USB_ENDPOINT_XFER_INT: return "intr";
139 default: return "control";
143 static char *buf_state_string(unsigned state)
146 case BUFF_FREE: return "free";
147 case BUFF_VALID: return "valid";
148 case BUFF_LCL: return "local";
149 case BUFF_USB: return "usb";
150 default: return "unknown";
154 static char *dma_mode_string(void)
159 case 0: return "SLOW DREQ";
160 case 1: return "FAST DREQ";
161 case 2: return "BURST";
162 default: return "invalid";
166 static void net2272_dequeue_all(struct net2272_ep *);
167 static int net2272_kick_dma(struct net2272_ep *, struct net2272_request *);
168 static int net2272_fifo_status(struct usb_ep *);
170 static const struct usb_ep_ops net2272_ep_ops;
172 /*---------------------------------------------------------------------------*/
175 net2272_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
178 struct net2272_ep *ep;
183 ep = container_of(_ep, struct net2272_ep, ep);
184 if (!_ep || !desc || ep->desc || _ep->name == ep0name
185 || desc->bDescriptorType != USB_DT_ENDPOINT)
188 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
191 max = usb_endpoint_maxp(desc);
193 spin_lock_irqsave(&dev->lock, flags);
194 _ep->maxpacket = max;
197 /* net2272_ep_reset() has already been called */
201 /* set speed-dependent max packet */
202 net2272_ep_write(ep, EP_MAXPKT0, max & 0xff);
203 net2272_ep_write(ep, EP_MAXPKT1, (max & 0xff00) >> 8);
205 /* set type, direction, address; reset fifo counters */
206 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
207 tmp = usb_endpoint_type(desc);
208 if (usb_endpoint_xfer_bulk(desc)) {
209 /* catch some particularly blatant driver bugs */
210 if ((dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
211 (dev->gadget.speed == USB_SPEED_FULL && max > 64)) {
212 spin_unlock_irqrestore(&dev->lock, flags);
216 ep->is_iso = usb_endpoint_xfer_isoc(desc) ? 1 : 0;
217 tmp <<= ENDPOINT_TYPE;
218 tmp |= ((desc->bEndpointAddress & 0x0f) << ENDPOINT_NUMBER);
219 tmp |= usb_endpoint_dir_in(desc) << ENDPOINT_DIRECTION;
220 tmp |= (1 << ENDPOINT_ENABLE);
222 /* for OUT transfers, block the rx fifo until a read is posted */
223 ep->is_in = usb_endpoint_dir_in(desc);
225 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
227 net2272_ep_write(ep, EP_CFG, tmp);
230 tmp = (1 << ep->num) | net2272_read(dev, IRQENB0);
231 net2272_write(dev, IRQENB0, tmp);
233 tmp = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
234 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
235 | net2272_ep_read(ep, EP_IRQENB);
236 net2272_ep_write(ep, EP_IRQENB, tmp);
238 tmp = desc->bEndpointAddress;
239 dev_dbg(dev->dev, "enabled %s (ep%d%s-%s) max %04x cfg %02x\n",
240 _ep->name, tmp & 0x0f, PIPEDIR(tmp),
241 type_string(desc->bmAttributes), max,
242 net2272_ep_read(ep, EP_CFG));
244 spin_unlock_irqrestore(&dev->lock, flags);
248 static void net2272_ep_reset(struct net2272_ep *ep)
253 INIT_LIST_HEAD(&ep->queue);
255 usb_ep_set_maxpacket_limit(&ep->ep, ~0);
256 ep->ep.ops = &net2272_ep_ops;
258 /* disable irqs, endpoint */
259 net2272_ep_write(ep, EP_IRQENB, 0);
261 /* init to our chosen defaults, notably so that we NAK OUT
262 * packets until the driver queues a read.
264 tmp = (1 << NAK_OUT_PACKETS_MODE) | (1 << ALT_NAK_OUT_PACKETS);
265 net2272_ep_write(ep, EP_RSPSET, tmp);
267 tmp = (1 << INTERRUPT_MODE) | (1 << HIDE_STATUS_PHASE);
269 tmp |= (1 << ENDPOINT_TOGGLE) | (1 << ENDPOINT_HALT);
271 net2272_ep_write(ep, EP_RSPCLR, tmp);
273 /* scrub most status bits, and flush any fifo state */
274 net2272_ep_write(ep, EP_STAT0,
275 (1 << DATA_IN_TOKEN_INTERRUPT)
276 | (1 << DATA_OUT_TOKEN_INTERRUPT)
277 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
278 | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
279 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
281 net2272_ep_write(ep, EP_STAT1,
283 | (1 << USB_OUT_ACK_SENT)
284 | (1 << USB_OUT_NAK_SENT)
285 | (1 << USB_IN_ACK_RCVD)
286 | (1 << USB_IN_NAK_SENT)
287 | (1 << USB_STALL_SENT)
288 | (1 << LOCAL_OUT_ZLP)
289 | (1 << BUFFER_FLUSH));
291 /* fifo size is handled separately */
294 static int net2272_disable(struct usb_ep *_ep)
296 struct net2272_ep *ep;
299 ep = container_of(_ep, struct net2272_ep, ep);
300 if (!_ep || !ep->desc || _ep->name == ep0name)
303 spin_lock_irqsave(&ep->dev->lock, flags);
304 net2272_dequeue_all(ep);
305 net2272_ep_reset(ep);
307 dev_vdbg(ep->dev->dev, "disabled %s\n", _ep->name);
309 spin_unlock_irqrestore(&ep->dev->lock, flags);
313 /*---------------------------------------------------------------------------*/
315 static struct usb_request *
316 net2272_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
318 struct net2272_request *req;
323 req = kzalloc(sizeof(*req), gfp_flags);
327 INIT_LIST_HEAD(&req->queue);
333 net2272_free_request(struct usb_ep *_ep, struct usb_request *_req)
335 struct net2272_request *req;
340 req = container_of(_req, struct net2272_request, req);
341 WARN_ON(!list_empty(&req->queue));
346 net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
349 unsigned stopped = ep->stopped;
352 if (ep->dev->protocol_stall) {
359 list_del_init(&req->queue);
361 if (req->req.status == -EINPROGRESS)
362 req->req.status = status;
364 status = req->req.status;
367 if (use_dma && ep->dma)
368 usb_gadget_unmap_request(&dev->gadget, &req->req,
371 if (status && status != -ESHUTDOWN)
372 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
373 ep->ep.name, &req->req, status,
374 req->req.actual, req->req.length, req->req.buf);
376 /* don't modify queue heads during completion callback */
378 spin_unlock(&dev->lock);
379 usb_gadget_giveback_request(&ep->ep, &req->req);
380 spin_lock(&dev->lock);
381 ep->stopped = stopped;
385 net2272_write_packet(struct net2272_ep *ep, u8 *buf,
386 struct net2272_request *req, unsigned max)
388 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
390 unsigned length, count;
393 length = min(req->req.length - req->req.actual, max);
394 req->req.actual += length;
396 dev_vdbg(ep->dev->dev, "write packet %s req %p max %u len %u avail %u\n",
397 ep->ep.name, req, max, length,
398 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
403 while (likely(count >= 2)) {
404 /* no byte-swap required; chip endian set during init */
405 writew(*bufp++, ep_data);
410 /* write final byte by placing the NET2272 into 8-bit mode */
411 if (unlikely(count)) {
412 tmp = net2272_read(ep->dev, LOCCTL);
413 net2272_write(ep->dev, LOCCTL, tmp & ~(1 << DATA_WIDTH));
414 writeb(*buf, ep_data);
415 net2272_write(ep->dev, LOCCTL, tmp);
420 /* returns: 0: still running, 1: completed, negative: errno */
422 net2272_write_fifo(struct net2272_ep *ep, struct net2272_request *req)
428 dev_vdbg(ep->dev->dev, "write_fifo %s actual %d len %d\n",
429 ep->ep.name, req->req.actual, req->req.length);
432 * Keep loading the endpoint until the final packet is loaded,
433 * or the endpoint buffer is full.
437 * Clear interrupt status
438 * - Packet Transmitted interrupt will become set again when the
439 * host successfully takes another packet
441 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
442 while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_FULL))) {
443 buf = req->req.buf + req->req.actual;
447 net2272_ep_read(ep, EP_STAT0);
449 max = (net2272_ep_read(ep, EP_AVAIL1) << 8) |
450 (net2272_ep_read(ep, EP_AVAIL0));
452 if (max < ep->ep.maxpacket)
453 max = (net2272_ep_read(ep, EP_AVAIL1) << 8)
454 | (net2272_ep_read(ep, EP_AVAIL0));
456 count = net2272_write_packet(ep, buf, req, max);
457 /* see if we are done */
458 if (req->req.length == req->req.actual) {
459 /* validate short or zlp packet */
460 if (count < ep->ep.maxpacket)
461 set_fifo_bytecount(ep, 0);
462 net2272_done(ep, req, 0);
464 if (!list_empty(&ep->queue)) {
465 req = list_entry(ep->queue.next,
466 struct net2272_request,
468 status = net2272_kick_dma(ep, req);
471 if ((net2272_ep_read(ep, EP_STAT0)
472 & (1 << BUFFER_EMPTY)))
477 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
483 net2272_out_flush(struct net2272_ep *ep)
485 ASSERT_OUT_NAKING(ep);
487 net2272_ep_write(ep, EP_STAT0, (1 << DATA_OUT_TOKEN_INTERRUPT)
488 | (1 << DATA_PACKET_RECEIVED_INTERRUPT));
489 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
493 net2272_read_packet(struct net2272_ep *ep, u8 *buf,
494 struct net2272_request *req, unsigned avail)
496 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
500 req->req.actual += avail;
502 dev_vdbg(ep->dev->dev, "read packet %s req %p len %u avail %u\n",
503 ep->ep.name, req, avail,
504 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
506 is_short = (avail < ep->ep.maxpacket);
508 if (unlikely(avail == 0)) {
509 /* remove any zlp from the buffer */
510 (void)readw(ep_data);
514 /* Ensure we get the final byte */
515 if (unlikely(avail % 2))
520 *bufp++ = readw(ep_data);
525 * To avoid false endpoint available race condition must read
526 * ep stat0 twice in the case of a short transfer
528 if (net2272_ep_read(ep, EP_STAT0) & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT))
529 net2272_ep_read(ep, EP_STAT0);
535 net2272_read_fifo(struct net2272_ep *ep, struct net2272_request *req)
543 dev_vdbg(ep->dev->dev, "read_fifo %s actual %d len %d\n",
544 ep->ep.name, req->req.actual, req->req.length);
548 buf = req->req.buf + req->req.actual;
551 count = (net2272_ep_read(ep, EP_AVAIL1) << 8)
552 | net2272_ep_read(ep, EP_AVAIL0);
554 net2272_ep_write(ep, EP_STAT0,
555 (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT) |
556 (1 << DATA_PACKET_RECEIVED_INTERRUPT));
558 tmp = req->req.length - req->req.actual;
561 if ((tmp % ep->ep.maxpacket) != 0) {
562 dev_err(ep->dev->dev,
563 "%s out fifo %d bytes, expected %d\n",
564 ep->ep.name, count, tmp);
567 count = (tmp > 0) ? tmp : 0;
570 is_short = net2272_read_packet(ep, buf, req, count);
573 if (unlikely(cleanup || is_short ||
574 req->req.actual == req->req.length)) {
577 net2272_out_flush(ep);
578 net2272_done(ep, req, -EOVERFLOW);
580 net2272_done(ep, req, 0);
582 /* re-initialize endpoint transfer registers
583 * otherwise they may result in erroneous pre-validation
584 * for subsequent control reads
586 if (unlikely(ep->num == 0)) {
587 net2272_ep_write(ep, EP_TRANSFER2, 0);
588 net2272_ep_write(ep, EP_TRANSFER1, 0);
589 net2272_ep_write(ep, EP_TRANSFER0, 0);
592 if (!list_empty(&ep->queue)) {
595 req = list_entry(ep->queue.next,
596 struct net2272_request, queue);
597 status = net2272_kick_dma(ep, req);
599 !(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)))
604 } while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)));
610 net2272_pio_advance(struct net2272_ep *ep)
612 struct net2272_request *req;
614 if (unlikely(list_empty(&ep->queue)))
617 req = list_entry(ep->queue.next, struct net2272_request, queue);
618 (ep->is_in ? net2272_write_fifo : net2272_read_fifo)(ep, req);
621 /* returns 0 on success, else negative errno */
623 net2272_request_dma(struct net2272 *dev, unsigned ep, u32 buf,
624 unsigned len, unsigned dir)
626 dev_vdbg(dev->dev, "request_dma ep %d buf %08x len %d dir %d\n",
629 /* The NET2272 only supports a single dma channel */
633 * EP_TRANSFER (used to determine the number of bytes received
634 * in an OUT transfer) is 24 bits wide; don't ask for more than that.
636 if ((dir == 1) && (len > 0x1000000))
641 /* initialize platform's dma */
642 #ifdef CONFIG_USB_PCI
643 /* NET2272 addr, buffer addr, length, etc. */
644 switch (dev->dev_id) {
645 case PCI_DEVICE_ID_RDK1:
646 /* Setup PLX 9054 DMA mode */
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) |
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);
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);
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));
681 (void) net2272_read(dev, SCRATCH);
687 net2272_start_dma(struct net2272 *dev)
689 /* start platform's dma controller */
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);
700 /* returns 0 on success, else negative errno */
702 net2272_kick_dma(struct net2272_ep *ep, struct net2272_request *req)
707 if (!use_dma || (ep->num < 1) || (ep->num > 2) || !ep->dma)
710 /* don't use dma for odd-length transfers
711 * otherwise, we'd need to deal with the last byte with pio
713 if (req->req.length & 1)
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);
719 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
721 /* The NET2272 can only use DMA on one endpoint at a time */
722 if (ep->dev->dma_busy)
725 /* Make sure we only DMA an even number of bytes (we'll use
726 * pio to complete the transfer)
728 size = req->req.length;
731 /* device-to-host transfer */
733 /* initialize platform's dma controller */
734 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 0))
735 /* unable to obtain DMA channel; return error and use pio mode */
737 req->req.actual += size;
739 /* host-to-device transfer */
741 tmp = net2272_ep_read(ep, EP_STAT0);
743 /* initialize platform's dma controller */
744 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 1))
745 /* unable to obtain DMA channel; return error and use pio mode */
748 if (!(tmp & (1 << BUFFER_EMPTY)))
754 /* allow the endpoint's buffer to fill */
755 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
757 /* this transfer completed and data's already in the fifo
758 * return error so pio gets used.
760 if (tmp & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) {
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));
776 /* Don't use per-packet interrupts: use dma interrupts only */
777 net2272_ep_write(ep, EP_IRQENB, 0);
779 net2272_start_dma(ep->dev);
784 static void net2272_cancel_dma(struct net2272 *dev)
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; /* wait for dma to stabalize */
795 /* dma abort generates an interrupt */
796 writeb(1 << CHANNEL_CLEAR_INTERRUPT,
797 dev->rdk1.plx9054_base_addr + DMACSR0);
805 /*---------------------------------------------------------------------------*/
808 net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
810 struct net2272_request *req;
811 struct net2272_ep *ep;
817 req = container_of(_req, struct net2272_request, req);
818 if (!_req || !_req->complete || !_req->buf
819 || !list_empty(&req->queue))
821 ep = container_of(_ep, struct net2272_ep, ep);
822 if (!_ep || (!ep->desc && ep->num != 0))
825 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
828 /* set up dma mapping in case the caller didn't */
829 if (use_dma && ep->dma) {
830 status = usb_gadget_map_request(&dev->gadget, _req,
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");
840 spin_lock_irqsave(&dev->lock, flags);
842 _req->status = -EINPROGRESS;
845 /* kickstart this i/o queue? */
846 if (list_empty(&ep->queue) && !ep->stopped) {
847 /* maybe there's no control data, just status ack */
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);
854 /* Return zlp, don't let it block subsequent packets */
855 s = net2272_ep_read(ep, EP_STAT0);
856 if (s & (1 << BUFFER_EMPTY)) {
857 /* Buffer is empty check for a blocking zlp, handle it */
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");
862 * Request is going to terminate with a short packet ...
863 * hope the client is ready for it!
865 status = net2272_read_fifo(ep, req);
866 /* clear short packet naking */
867 net2272_ep_write(ep, EP_STAT0, (1 << NAK_OUT_PACKETS));
873 status = net2272_kick_dma(ep, req);
876 /* dma failed (most likely in use by another endpoint)
882 status = net2272_write_fifo(ep, req);
884 s = net2272_ep_read(ep, EP_STAT0);
885 if ((s & (1 << BUFFER_EMPTY)) == 0)
886 status = net2272_read_fifo(ep, req);
889 if (unlikely(status != 0)) {
897 list_add_tail(&req->queue, &ep->queue);
899 if (likely(!list_empty(&ep->queue)))
900 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
902 spin_unlock_irqrestore(&dev->lock, flags);
907 /* dequeue ALL requests */
909 net2272_dequeue_all(struct net2272_ep *ep)
911 struct net2272_request *req;
913 /* called with spinlock held */
916 while (!list_empty(&ep->queue)) {
917 req = list_entry(ep->queue.next,
918 struct net2272_request,
920 net2272_done(ep, req, -ESHUTDOWN);
924 /* dequeue JUST ONE request */
926 net2272_dequeue(struct usb_ep *_ep, struct usb_request *_req)
928 struct net2272_ep *ep;
929 struct net2272_request *req = NULL, *iter;
933 ep = container_of(_ep, struct net2272_ep, ep);
934 if (!_ep || (!ep->desc && ep->num != 0) || !_req)
937 spin_lock_irqsave(&ep->dev->lock, flags);
938 stopped = ep->stopped;
941 /* make sure it's still queued on this endpoint */
942 list_for_each_entry(iter, &ep->queue, queue) {
943 if (&iter->req != _req)
949 ep->stopped = stopped;
950 spin_unlock_irqrestore(&ep->dev->lock, flags);
954 /* queue head may be partially complete */
955 if (ep->queue.next == &req->queue) {
956 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name);
957 net2272_done(ep, req, -ECONNRESET);
959 ep->stopped = stopped;
961 spin_unlock_irqrestore(&ep->dev->lock, flags);
965 /*---------------------------------------------------------------------------*/
968 net2272_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
970 struct net2272_ep *ep;
974 ep = container_of(_ep, struct net2272_ep, ep);
975 if (!_ep || (!ep->desc && ep->num != 0))
977 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
979 if (ep->desc /* not ep0 */ && usb_endpoint_xfer_isoc(ep->desc))
982 spin_lock_irqsave(&ep->dev->lock, flags);
983 if (!list_empty(&ep->queue))
985 else if (ep->is_in && value && net2272_fifo_status(_ep) != 0)
988 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name,
989 value ? "set" : "clear",
990 wedged ? "wedge" : "halt");
994 ep->dev->protocol_stall = 1;
1004 spin_unlock_irqrestore(&ep->dev->lock, flags);
1010 net2272_set_halt(struct usb_ep *_ep, int value)
1012 return net2272_set_halt_and_wedge(_ep, value, 0);
1016 net2272_set_wedge(struct usb_ep *_ep)
1018 if (!_ep || _ep->name == ep0name)
1020 return net2272_set_halt_and_wedge(_ep, 1, 1);
1024 net2272_fifo_status(struct usb_ep *_ep)
1026 struct net2272_ep *ep;
1029 ep = container_of(_ep, struct net2272_ep, ep);
1030 if (!_ep || (!ep->desc && ep->num != 0))
1032 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1035 avail = net2272_ep_read(ep, EP_AVAIL1) << 8;
1036 avail |= net2272_ep_read(ep, EP_AVAIL0);
1037 if (avail > ep->fifo_size)
1040 avail = ep->fifo_size - avail;
1045 net2272_fifo_flush(struct usb_ep *_ep)
1047 struct net2272_ep *ep;
1049 ep = container_of(_ep, struct net2272_ep, ep);
1050 if (!_ep || (!ep->desc && ep->num != 0))
1052 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1055 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
1058 static const struct usb_ep_ops net2272_ep_ops = {
1059 .enable = net2272_enable,
1060 .disable = net2272_disable,
1062 .alloc_request = net2272_alloc_request,
1063 .free_request = net2272_free_request,
1065 .queue = net2272_queue,
1066 .dequeue = net2272_dequeue,
1068 .set_halt = net2272_set_halt,
1069 .set_wedge = net2272_set_wedge,
1070 .fifo_status = net2272_fifo_status,
1071 .fifo_flush = net2272_fifo_flush,
1074 /*---------------------------------------------------------------------------*/
1077 net2272_get_frame(struct usb_gadget *_gadget)
1079 struct net2272 *dev;
1080 unsigned long flags;
1085 dev = container_of(_gadget, struct net2272, gadget);
1086 spin_lock_irqsave(&dev->lock, flags);
1088 ret = net2272_read(dev, FRAME1) << 8;
1089 ret |= net2272_read(dev, FRAME0);
1091 spin_unlock_irqrestore(&dev->lock, flags);
1096 net2272_wakeup(struct usb_gadget *_gadget)
1098 struct net2272 *dev;
1100 unsigned long flags;
1104 dev = container_of(_gadget, struct net2272, gadget);
1106 spin_lock_irqsave(&dev->lock, flags);
1107 tmp = net2272_read(dev, USBCTL0);
1108 if (tmp & (1 << IO_WAKEUP_ENABLE))
1109 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME));
1111 spin_unlock_irqrestore(&dev->lock, flags);
1117 net2272_set_selfpowered(struct usb_gadget *_gadget, int value)
1122 _gadget->is_selfpowered = (value != 0);
1128 net2272_pullup(struct usb_gadget *_gadget, int is_on)
1130 struct net2272 *dev;
1132 unsigned long flags;
1136 dev = container_of(_gadget, struct net2272, gadget);
1138 spin_lock_irqsave(&dev->lock, flags);
1139 tmp = net2272_read(dev, USBCTL0);
1140 dev->softconnect = (is_on != 0);
1142 tmp |= (1 << USB_DETECT_ENABLE);
1144 tmp &= ~(1 << USB_DETECT_ENABLE);
1145 net2272_write(dev, USBCTL0, tmp);
1146 spin_unlock_irqrestore(&dev->lock, flags);
1151 static int net2272_start(struct usb_gadget *_gadget,
1152 struct usb_gadget_driver *driver);
1153 static int net2272_stop(struct usb_gadget *_gadget);
1154 static void net2272_async_callbacks(struct usb_gadget *_gadget, bool enable);
1156 static const struct usb_gadget_ops net2272_ops = {
1157 .get_frame = net2272_get_frame,
1158 .wakeup = net2272_wakeup,
1159 .set_selfpowered = net2272_set_selfpowered,
1160 .pullup = net2272_pullup,
1161 .udc_start = net2272_start,
1162 .udc_stop = net2272_stop,
1163 .udc_async_callbacks = net2272_async_callbacks,
1166 /*---------------------------------------------------------------------------*/
1169 registers_show(struct device *_dev, struct device_attribute *attr, char *buf)
1171 struct net2272 *dev;
1174 unsigned long flags;
1179 dev = dev_get_drvdata(_dev);
1182 spin_lock_irqsave(&dev->lock, flags);
1184 /* Main Control Registers */
1185 t = scnprintf(next, size, "%s version %s,"
1186 "chiprev %02x, locctl %02x\n"
1187 "irqenb0 %02x irqenb1 %02x "
1188 "irqstat0 %02x irqstat1 %02x\n",
1189 driver_name, driver_vers, dev->chiprev,
1190 net2272_read(dev, LOCCTL),
1191 net2272_read(dev, IRQENB0),
1192 net2272_read(dev, IRQENB1),
1193 net2272_read(dev, IRQSTAT0),
1194 net2272_read(dev, IRQSTAT1));
1199 t1 = net2272_read(dev, DMAREQ);
1200 t = scnprintf(next, size, "\ndmareq %02x: %s %s%s%s%s\n",
1201 t1, ep_name[(t1 & 0x01) + 1],
1202 t1 & (1 << DMA_CONTROL_DACK) ? "dack " : "",
1203 t1 & (1 << DMA_REQUEST_ENABLE) ? "reqenb " : "",
1204 t1 & (1 << DMA_REQUEST) ? "req " : "",
1205 t1 & (1 << DMA_BUFFER_VALID) ? "valid " : "");
1209 /* USB Control Registers */
1210 t1 = net2272_read(dev, USBCTL1);
1211 if (t1 & (1 << VBUS_PIN)) {
1212 if (t1 & (1 << USB_HIGH_SPEED))
1214 else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1220 t = scnprintf(next, size,
1221 "usbctl0 %02x usbctl1 %02x addr 0x%02x (%s)\n",
1222 net2272_read(dev, USBCTL0), t1,
1223 net2272_read(dev, OURADDR), s);
1227 /* Endpoint Registers */
1228 for (i = 0; i < 4; ++i) {
1229 struct net2272_ep *ep;
1235 t1 = net2272_ep_read(ep, EP_CFG);
1236 t2 = net2272_ep_read(ep, EP_RSPSET);
1237 t = scnprintf(next, size,
1238 "\n%s\tcfg %02x rsp (%02x) %s%s%s%s%s%s%s%s"
1240 ep->ep.name, t1, t2,
1241 (t2 & (1 << ALT_NAK_OUT_PACKETS)) ? "NAK " : "",
1242 (t2 & (1 << HIDE_STATUS_PHASE)) ? "hide " : "",
1243 (t2 & (1 << AUTOVALIDATE)) ? "auto " : "",
1244 (t2 & (1 << INTERRUPT_MODE)) ? "interrupt " : "",
1245 (t2 & (1 << CONTROL_STATUS_PHASE_HANDSHAKE)) ? "status " : "",
1246 (t2 & (1 << NAK_OUT_PACKETS_MODE)) ? "NAKmode " : "",
1247 (t2 & (1 << ENDPOINT_TOGGLE)) ? "DATA1 " : "DATA0 ",
1248 (t2 & (1 << ENDPOINT_HALT)) ? "HALT " : "",
1249 net2272_ep_read(ep, EP_IRQENB));
1253 t = scnprintf(next, size,
1254 "\tstat0 %02x stat1 %02x avail %04x "
1256 net2272_ep_read(ep, EP_STAT0),
1257 net2272_ep_read(ep, EP_STAT1),
1258 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0),
1260 ep->is_in ? "in" : "out",
1261 type_string(t1 >> 5),
1262 ep->stopped ? "*" : "");
1266 t = scnprintf(next, size,
1267 "\tep_transfer %06x\n",
1268 ((net2272_ep_read(ep, EP_TRANSFER2) & 0xff) << 16) |
1269 ((net2272_ep_read(ep, EP_TRANSFER1) & 0xff) << 8) |
1270 ((net2272_ep_read(ep, EP_TRANSFER0) & 0xff)));
1274 t1 = net2272_ep_read(ep, EP_BUFF_STATES) & 0x03;
1275 t2 = (net2272_ep_read(ep, EP_BUFF_STATES) >> 2) & 0x03;
1276 t = scnprintf(next, size,
1277 "\tbuf-a %s buf-b %s\n",
1278 buf_state_string(t1),
1279 buf_state_string(t2));
1284 spin_unlock_irqrestore(&dev->lock, flags);
1286 return PAGE_SIZE - size;
1288 static DEVICE_ATTR_RO(registers);
1290 /*---------------------------------------------------------------------------*/
1293 net2272_set_fifo_mode(struct net2272 *dev, int mode)
1297 tmp = net2272_read(dev, LOCCTL) & 0x3f;
1299 net2272_write(dev, LOCCTL, tmp);
1301 INIT_LIST_HEAD(&dev->gadget.ep_list);
1303 /* always ep-a, ep-c ... maybe not ep-b */
1304 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1308 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1309 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512;
1312 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1313 dev->ep[1].fifo_size = 1024;
1314 dev->ep[2].fifo_size = 512;
1317 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1318 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1321 dev->ep[1].fifo_size = 1024;
1325 /* ep-c is always 2 512 byte buffers */
1326 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1327 dev->ep[3].fifo_size = 512;
1330 /*---------------------------------------------------------------------------*/
1333 net2272_usb_reset(struct net2272 *dev)
1335 dev->gadget.speed = USB_SPEED_UNKNOWN;
1337 net2272_cancel_dma(dev);
1339 net2272_write(dev, IRQENB0, 0);
1340 net2272_write(dev, IRQENB1, 0);
1342 /* clear irq state */
1343 net2272_write(dev, IRQSTAT0, 0xff);
1344 net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT));
1346 net2272_write(dev, DMAREQ,
1347 (0 << DMA_BUFFER_VALID) |
1348 (0 << DMA_REQUEST_ENABLE) |
1349 (1 << DMA_CONTROL_DACK) |
1350 (dev->dma_eot_polarity << EOT_POLARITY) |
1351 (dev->dma_dack_polarity << DACK_POLARITY) |
1352 (dev->dma_dreq_polarity << DREQ_POLARITY) |
1353 ((dma_ep >> 1) << DMA_ENDPOINT_SELECT));
1355 net2272_cancel_dma(dev);
1356 net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0);
1358 /* Set the NET2272 ep fifo data width to 16-bit mode and for correct byte swapping
1359 * note that the higher level gadget drivers are expected to convert data to little endian.
1360 * Enable byte swap for your local bus/cpu if needed by setting BYTE_SWAP in LOCCTL here
1362 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH));
1363 net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE));
1367 net2272_usb_reinit(struct net2272 *dev)
1371 /* basic endpoint init */
1372 for (i = 0; i < 4; ++i) {
1373 struct net2272_ep *ep = &dev->ep[i];
1375 ep->ep.name = ep_name[i];
1380 if (use_dma && ep->num == dma_ep)
1383 if (i > 0 && i <= 3)
1384 ep->fifo_size = 512;
1387 net2272_ep_reset(ep);
1390 ep->ep.caps.type_control = true;
1392 ep->ep.caps.type_iso = true;
1393 ep->ep.caps.type_bulk = true;
1394 ep->ep.caps.type_int = true;
1397 ep->ep.caps.dir_in = true;
1398 ep->ep.caps.dir_out = true;
1400 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
1402 dev->gadget.ep0 = &dev->ep[0].ep;
1403 dev->ep[0].stopped = 0;
1404 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
1408 net2272_ep0_start(struct net2272 *dev)
1410 struct net2272_ep *ep0 = &dev->ep[0];
1412 net2272_ep_write(ep0, EP_RSPSET,
1413 (1 << NAK_OUT_PACKETS_MODE) |
1414 (1 << ALT_NAK_OUT_PACKETS));
1415 net2272_ep_write(ep0, EP_RSPCLR,
1416 (1 << HIDE_STATUS_PHASE) |
1417 (1 << CONTROL_STATUS_PHASE_HANDSHAKE));
1418 net2272_write(dev, USBCTL0,
1419 (dev->softconnect << USB_DETECT_ENABLE) |
1420 (1 << USB_ROOT_PORT_WAKEUP_ENABLE) |
1421 (1 << IO_WAKEUP_ENABLE));
1422 net2272_write(dev, IRQENB0,
1423 (1 << SETUP_PACKET_INTERRUPT_ENABLE) |
1424 (1 << ENDPOINT_0_INTERRUPT_ENABLE) |
1425 (1 << DMA_DONE_INTERRUPT_ENABLE));
1426 net2272_write(dev, IRQENB1,
1427 (1 << VBUS_INTERRUPT_ENABLE) |
1428 (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE) |
1429 (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE));
1432 /* when a driver is successfully registered, it will receive
1433 * control requests including set_configuration(), which enables
1434 * non-control requests. then usb traffic follows until a
1435 * disconnect is reported. then a host may connect again, or
1436 * the driver might get unbound.
1438 static int net2272_start(struct usb_gadget *_gadget,
1439 struct usb_gadget_driver *driver)
1441 struct net2272 *dev;
1444 if (!driver || !driver->setup ||
1445 driver->max_speed != USB_SPEED_HIGH)
1448 dev = container_of(_gadget, struct net2272, gadget);
1450 for (i = 0; i < 4; ++i)
1451 dev->ep[i].irqs = 0;
1452 /* hook up the driver ... */
1453 dev->softconnect = 1;
1454 dev->driver = driver;
1456 /* ... then enable host detection and ep0; and we're ready
1457 * for set_configuration as well as eventual disconnect.
1459 net2272_ep0_start(dev);
1465 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1469 /* don't disconnect if it's not connected */
1470 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1473 /* stop hardware; prevent new request submissions;
1474 * and kill any outstanding requests.
1476 net2272_usb_reset(dev);
1477 for (i = 0; i < 4; ++i)
1478 net2272_dequeue_all(&dev->ep[i]);
1480 /* report disconnect; the driver is already quiesced */
1481 if (dev->async_callbacks && driver) {
1482 spin_unlock(&dev->lock);
1483 driver->disconnect(&dev->gadget);
1484 spin_lock(&dev->lock);
1487 net2272_usb_reinit(dev);
1490 static int net2272_stop(struct usb_gadget *_gadget)
1492 struct net2272 *dev;
1493 unsigned long flags;
1495 dev = container_of(_gadget, struct net2272, gadget);
1497 spin_lock_irqsave(&dev->lock, flags);
1498 stop_activity(dev, NULL);
1499 spin_unlock_irqrestore(&dev->lock, flags);
1506 static void net2272_async_callbacks(struct usb_gadget *_gadget, bool enable)
1508 struct net2272 *dev = container_of(_gadget, struct net2272, gadget);
1510 spin_lock_irq(&dev->lock);
1511 dev->async_callbacks = enable;
1512 spin_unlock_irq(&dev->lock);
1515 /*---------------------------------------------------------------------------*/
1516 /* handle ep-a/ep-b dma completions */
1518 net2272_handle_dma(struct net2272_ep *ep)
1520 struct net2272_request *req;
1524 if (!list_empty(&ep->queue))
1525 req = list_entry(ep->queue.next,
1526 struct net2272_request, queue);
1530 dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req);
1532 /* Ensure DREQ is de-asserted */
1533 net2272_write(ep->dev, DMAREQ,
1534 (0 << DMA_BUFFER_VALID)
1535 | (0 << DMA_REQUEST_ENABLE)
1536 | (1 << DMA_CONTROL_DACK)
1537 | (ep->dev->dma_eot_polarity << EOT_POLARITY)
1538 | (ep->dev->dma_dack_polarity << DACK_POLARITY)
1539 | (ep->dev->dma_dreq_polarity << DREQ_POLARITY)
1540 | (ep->dma << DMA_ENDPOINT_SELECT));
1542 ep->dev->dma_busy = 0;
1544 net2272_ep_write(ep, EP_IRQENB,
1545 (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1546 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1547 | net2272_ep_read(ep, EP_IRQENB));
1549 /* device-to-host transfer completed */
1551 /* validate a short packet or zlp if necessary */
1552 if ((req->req.length % ep->ep.maxpacket != 0) ||
1554 set_fifo_bytecount(ep, 0);
1556 net2272_done(ep, req, 0);
1557 if (!list_empty(&ep->queue)) {
1558 req = list_entry(ep->queue.next,
1559 struct net2272_request, queue);
1560 status = net2272_kick_dma(ep, req);
1562 net2272_pio_advance(ep);
1565 /* host-to-device transfer completed */
1567 /* terminated with a short packet? */
1568 if (net2272_read(ep->dev, IRQSTAT0) &
1569 (1 << DMA_DONE_INTERRUPT)) {
1570 /* abort system dma */
1571 net2272_cancel_dma(ep->dev);
1574 /* EP_TRANSFER will contain the number of bytes
1575 * actually received.
1576 * NOTE: There is no overflow detection on EP_TRANSFER:
1577 * We can't deal with transfers larger than 2^24 bytes!
1579 len = (net2272_ep_read(ep, EP_TRANSFER2) << 16)
1580 | (net2272_ep_read(ep, EP_TRANSFER1) << 8)
1581 | (net2272_ep_read(ep, EP_TRANSFER0));
1586 req->req.actual += len;
1588 /* get any remaining data */
1589 net2272_pio_advance(ep);
1593 /*---------------------------------------------------------------------------*/
1596 net2272_handle_ep(struct net2272_ep *ep)
1598 struct net2272_request *req;
1601 if (!list_empty(&ep->queue))
1602 req = list_entry(ep->queue.next,
1603 struct net2272_request, queue);
1607 /* ack all, and handle what we care about */
1608 stat0 = net2272_ep_read(ep, EP_STAT0);
1609 stat1 = net2272_ep_read(ep, EP_STAT1);
1612 dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n",
1613 ep->ep.name, stat0, stat1, req ? &req->req : NULL);
1615 net2272_ep_write(ep, EP_STAT0, stat0 &
1616 ~((1 << NAK_OUT_PACKETS)
1617 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)));
1618 net2272_ep_write(ep, EP_STAT1, stat1);
1620 /* data packet(s) received (in the fifo, OUT)
1621 * direction must be validated, otherwise control read status phase
1622 * could be interpreted as a valid packet
1624 if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT)))
1625 net2272_pio_advance(ep);
1626 /* data packet(s) transmitted (IN) */
1627 else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))
1628 net2272_pio_advance(ep);
1631 static struct net2272_ep *
1632 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex)
1634 struct net2272_ep *ep;
1636 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
1639 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1640 u8 bEndpointAddress;
1644 bEndpointAddress = ep->desc->bEndpointAddress;
1645 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
1647 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
1658 * JJJJJJJKKKKKKK * 8
1660 * {JKKKKKKK * 10}, JK
1662 static const u8 net2272_test_packet[] = {
1663 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1664 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1665 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1666 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1667 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1668 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E
1672 net2272_set_test_mode(struct net2272 *dev, int mode)
1676 /* Disable all net2272 interrupts:
1677 * Nothing but a power cycle should stop the test.
1679 net2272_write(dev, IRQENB0, 0x00);
1680 net2272_write(dev, IRQENB1, 0x00);
1682 /* Force tranceiver to high-speed */
1683 net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED);
1685 net2272_write(dev, PAGESEL, 0);
1686 net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT);
1687 net2272_write(dev, EP_RSPCLR,
1688 (1 << CONTROL_STATUS_PHASE_HANDSHAKE)
1689 | (1 << HIDE_STATUS_PHASE));
1690 net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION);
1691 net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH);
1693 /* wait for status phase to complete */
1694 while (!(net2272_read(dev, EP_STAT0) &
1695 (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)))
1698 /* Enable test mode */
1699 net2272_write(dev, USBTEST, mode);
1701 /* load test packet */
1702 if (mode == USB_TEST_PACKET) {
1703 /* switch to 8 bit mode */
1704 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) &
1705 ~(1 << DATA_WIDTH));
1707 for (i = 0; i < sizeof(net2272_test_packet); ++i)
1708 net2272_write(dev, EP_DATA, net2272_test_packet[i]);
1710 /* Validate test packet */
1711 net2272_write(dev, EP_TRANSFER0, 0);
1716 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat)
1718 struct net2272_ep *ep;
1721 /* starting a control request? */
1722 if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) {
1725 struct usb_ctrlrequest r;
1728 struct net2272_request *req;
1730 if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
1731 if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED))
1732 dev->gadget.speed = USB_SPEED_HIGH;
1734 dev->gadget.speed = USB_SPEED_FULL;
1735 dev_dbg(dev->dev, "%s\n",
1736 usb_speed_string(dev->gadget.speed));
1742 /* make sure any leftover interrupt state is cleared */
1743 stat &= ~(1 << ENDPOINT_0_INTERRUPT);
1744 while (!list_empty(&ep->queue)) {
1745 req = list_entry(ep->queue.next,
1746 struct net2272_request, queue);
1747 net2272_done(ep, req,
1748 (req->req.actual == req->req.length) ? 0 : -EPROTO);
1751 dev->protocol_stall = 0;
1752 net2272_ep_write(ep, EP_STAT0,
1753 (1 << DATA_IN_TOKEN_INTERRUPT)
1754 | (1 << DATA_OUT_TOKEN_INTERRUPT)
1755 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
1756 | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
1757 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
1758 net2272_ep_write(ep, EP_STAT1,
1760 | (1 << USB_OUT_ACK_SENT)
1761 | (1 << USB_OUT_NAK_SENT)
1762 | (1 << USB_IN_ACK_RCVD)
1763 | (1 << USB_IN_NAK_SENT)
1764 | (1 << USB_STALL_SENT)
1765 | (1 << LOCAL_OUT_ZLP));
1768 * Ensure Control Read pre-validation setting is beyond maximum size
1769 * - Control Writes can leave non-zero values in EP_TRANSFER. If
1770 * an EP0 transfer following the Control Write is a Control Read,
1771 * the NET2272 sees the non-zero EP_TRANSFER as an unexpected
1772 * pre-validation count.
1773 * - Setting EP_TRANSFER beyond the maximum EP0 transfer size ensures
1774 * the pre-validation count cannot cause an unexpected validatation
1776 net2272_write(dev, PAGESEL, 0);
1777 net2272_write(dev, EP_TRANSFER2, 0xff);
1778 net2272_write(dev, EP_TRANSFER1, 0xff);
1779 net2272_write(dev, EP_TRANSFER0, 0xff);
1781 u.raw[0] = net2272_read(dev, SETUP0);
1782 u.raw[1] = net2272_read(dev, SETUP1);
1783 u.raw[2] = net2272_read(dev, SETUP2);
1784 u.raw[3] = net2272_read(dev, SETUP3);
1785 u.raw[4] = net2272_read(dev, SETUP4);
1786 u.raw[5] = net2272_read(dev, SETUP5);
1787 u.raw[6] = net2272_read(dev, SETUP6);
1788 u.raw[7] = net2272_read(dev, SETUP7);
1790 * If you have a big endian cpu make sure le16_to_cpus
1791 * performs the proper byte swapping here...
1793 le16_to_cpus(&u.r.wValue);
1794 le16_to_cpus(&u.r.wIndex);
1795 le16_to_cpus(&u.r.wLength);
1798 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT);
1799 stat ^= (1 << SETUP_PACKET_INTERRUPT);
1801 /* watch control traffic at the token level, and force
1802 * synchronization before letting the status phase happen.
1804 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
1806 scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1807 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1808 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1809 stop_out_naking(ep);
1811 scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1812 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1813 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1814 net2272_ep_write(ep, EP_IRQENB, scratch);
1816 if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
1818 switch (u.r.bRequest) {
1819 case USB_REQ_GET_STATUS: {
1820 struct net2272_ep *e;
1823 switch (u.r.bRequestType & USB_RECIP_MASK) {
1824 case USB_RECIP_ENDPOINT:
1825 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1826 if (!e || u.r.wLength > 2)
1828 if (net2272_ep_read(e, EP_RSPSET) & (1 << ENDPOINT_HALT))
1829 status = cpu_to_le16(1);
1831 status = cpu_to_le16(0);
1833 /* don't bother with a request object! */
1834 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1835 writew(status, net2272_reg_addr(dev, EP_DATA));
1836 set_fifo_bytecount(&dev->ep[0], 0);
1838 dev_vdbg(dev->dev, "%s stat %02x\n",
1839 ep->ep.name, status);
1840 goto next_endpoints;
1841 case USB_RECIP_DEVICE:
1842 if (u.r.wLength > 2)
1844 if (dev->gadget.is_selfpowered)
1845 status = (1 << USB_DEVICE_SELF_POWERED);
1847 /* don't bother with a request object! */
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);
1852 dev_vdbg(dev->dev, "device stat %02x\n", status);
1853 goto next_endpoints;
1854 case USB_RECIP_INTERFACE:
1855 if (u.r.wLength > 2)
1858 /* don't bother with a request object! */
1859 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1860 writew(status, net2272_reg_addr(dev, EP_DATA));
1861 set_fifo_bytecount(&dev->ep[0], 0);
1863 dev_vdbg(dev->dev, "interface status %02x\n", status);
1864 goto next_endpoints;
1869 case USB_REQ_CLEAR_FEATURE: {
1870 struct net2272_ep *e;
1872 if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1874 if (u.r.wValue != USB_ENDPOINT_HALT ||
1877 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1881 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n",
1884 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name);
1888 goto next_endpoints;
1890 case USB_REQ_SET_FEATURE: {
1891 struct net2272_ep *e;
1893 if (u.r.bRequestType == USB_RECIP_DEVICE) {
1894 if (u.r.wIndex != NORMAL_OPERATION)
1895 net2272_set_test_mode(dev, (u.r.wIndex >> 8));
1897 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex);
1898 goto next_endpoints;
1899 } else if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1901 if (u.r.wValue != USB_ENDPOINT_HALT ||
1904 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1909 dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name);
1910 goto next_endpoints;
1912 case USB_REQ_SET_ADDRESS: {
1913 net2272_write(dev, OURADDR, u.r.wValue & 0xff);
1919 dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x "
1921 u.r.bRequestType, u.r.bRequest,
1922 u.r.wValue, u.r.wIndex,
1923 net2272_ep_read(ep, EP_CFG));
1924 if (dev->async_callbacks) {
1925 spin_unlock(&dev->lock);
1926 tmp = dev->driver->setup(&dev->gadget, &u.r);
1927 spin_lock(&dev->lock);
1931 /* stall ep0 on error */
1934 dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n",
1935 u.r.bRequestType, u.r.bRequest, tmp);
1936 dev->protocol_stall = 1;
1938 /* endpoint dma irq? */
1939 } else if (stat & (1 << DMA_DONE_INTERRUPT)) {
1940 net2272_cancel_dma(dev);
1941 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT);
1942 stat &= ~(1 << DMA_DONE_INTERRUPT);
1943 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT))
1947 net2272_handle_dma(ep);
1951 /* endpoint data irq? */
1952 scratch = stat & 0x0f;
1954 for (num = 0; scratch; num++) {
1957 /* does this endpoint's FIFO and queue need tending? */
1959 if ((scratch & t) == 0)
1964 net2272_handle_ep(ep);
1967 /* some interrupts we can just ignore */
1968 stat &= ~(1 << SOF_INTERRUPT);
1971 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat);
1975 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1979 /* after disconnect there's nothing else to do! */
1980 tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT);
1981 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED);
1985 bool disconnect = false;
1988 * Ignore disconnects and resets if the speed hasn't been set.
1989 * VBUS can bounce and there's always an initial reset.
1991 net2272_write(dev, IRQSTAT1, tmp);
1992 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1993 if ((stat & (1 << VBUS_INTERRUPT)) &&
1994 (net2272_read(dev, USBCTL1) &
1995 (1 << VBUS_PIN)) == 0) {
1997 dev_dbg(dev->dev, "disconnect %s\n",
1998 dev->driver->driver.name);
1999 } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) &&
2000 (net2272_read(dev, USBCTL1) & mask)
2003 dev_dbg(dev->dev, "reset %s\n",
2004 dev->driver->driver.name);
2007 if (disconnect || reset) {
2008 stop_activity(dev, dev->driver);
2009 net2272_ep0_start(dev);
2010 if (dev->async_callbacks) {
2011 spin_unlock(&dev->lock);
2013 usb_gadget_udc_reset(&dev->gadget, dev->driver);
2015 (dev->driver->disconnect)(&dev->gadget);
2016 spin_lock(&dev->lock);
2027 tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
2029 net2272_write(dev, IRQSTAT1, tmp);
2030 if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
2031 if (dev->async_callbacks && dev->driver->suspend)
2032 dev->driver->suspend(&dev->gadget);
2033 if (!enable_suspend) {
2034 stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
2035 dev_dbg(dev->dev, "Suspend disabled, ignoring\n");
2038 if (dev->async_callbacks && dev->driver->resume)
2039 dev->driver->resume(&dev->gadget);
2044 /* clear any other status/irqs */
2046 net2272_write(dev, IRQSTAT1, stat);
2048 /* some status we can just ignore */
2049 stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
2050 | (1 << SUSPEND_REQUEST_INTERRUPT)
2051 | (1 << RESUME_INTERRUPT));
2055 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat);
2058 static irqreturn_t net2272_irq(int irq, void *_dev)
2060 struct net2272 *dev = _dev;
2061 #if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2)
2064 #if defined(PLX_PCI_RDK)
2067 spin_lock(&dev->lock);
2068 #if defined(PLX_PCI_RDK)
2069 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2071 if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) {
2072 writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE),
2073 dev->rdk1.plx9054_base_addr + INTCSR);
2074 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2075 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2076 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2077 writel(intcsr | (1 << PCI_INTERRUPT_ENABLE),
2078 dev->rdk1.plx9054_base_addr + INTCSR);
2080 if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) {
2081 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2082 dev->rdk1.plx9054_base_addr + DMACSR0);
2084 dmareq = net2272_read(dev, DMAREQ);
2086 net2272_handle_dma(&dev->ep[2]);
2088 net2272_handle_dma(&dev->ep[1]);
2091 #if defined(PLX_PCI_RDK2)
2092 /* see if PCI int for us by checking irqstat */
2093 intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT);
2094 if (!(intcsr & (1 << NET2272_PCI_IRQ))) {
2095 spin_unlock(&dev->lock);
2098 /* check dma interrupts */
2100 /* Platform/devcice interrupt handler */
2101 #if !defined(PLX_PCI_RDK)
2102 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2103 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2105 spin_unlock(&dev->lock);
2110 static int net2272_present(struct net2272 *dev)
2113 * Quick test to see if CPU can communicate properly with the NET2272.
2114 * Verifies connection using writes and reads to write/read and
2115 * read-only registers.
2117 * This routine is strongly recommended especially during early bring-up
2118 * of new hardware, however for designs that do not apply Power On System
2119 * Tests (POST) it may discarded (or perhaps minimized).
2124 /* Verify NET2272 write/read SCRATCH register can write and read */
2125 refval = net2272_read(dev, SCRATCH);
2126 for (ii = 0; ii < 0x100; ii += 7) {
2127 net2272_write(dev, SCRATCH, ii);
2128 val = net2272_read(dev, SCRATCH);
2131 "%s: write/read SCRATCH register test failed: "
2132 "wrote:0x%2.2x, read:0x%2.2x\n",
2137 /* To be nice, we write the original SCRATCH value back: */
2138 net2272_write(dev, SCRATCH, refval);
2140 /* Verify NET2272 CHIPREV register is read-only: */
2141 refval = net2272_read(dev, CHIPREV_2272);
2142 for (ii = 0; ii < 0x100; ii += 7) {
2143 net2272_write(dev, CHIPREV_2272, ii);
2144 val = net2272_read(dev, CHIPREV_2272);
2145 if (val != refval) {
2147 "%s: write/read CHIPREV register test failed: "
2148 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n",
2149 __func__, ii, val, refval);
2155 * Verify NET2272's "NET2270 legacy revision" register
2156 * - NET2272 has two revision registers. The NET2270 legacy revision
2157 * register should read the same value, regardless of the NET2272
2158 * silicon revision. The legacy register applies to NET2270
2159 * firmware being applied to the NET2272.
2161 val = net2272_read(dev, CHIPREV_LEGACY);
2162 if (val != NET2270_LEGACY_REV) {
2164 * Unexpected legacy revision value
2165 * - Perhaps the chip is a NET2270?
2168 "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n"
2169 " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n",
2170 __func__, NET2270_LEGACY_REV, val);
2175 * Verify NET2272 silicon revision
2176 * - This revision register is appropriate for the silicon version
2179 val = net2272_read(dev, CHIPREV_2272);
2181 case CHIPREV_NET2272_R1:
2183 * NET2272 Rev 1 has DMA related errata:
2184 * - Newer silicon (Rev 1A or better) required
2187 "%s: Rev 1 detected: newer silicon recommended for DMA support\n",
2190 case CHIPREV_NET2272_R1A:
2193 /* NET2272 silicon version *may* not work with this firmware */
2195 "%s: unexpected silicon revision register value: "
2196 " CHIPREV_2272: 0x%2.2x\n",
2199 * Return Success, even though the chip rev is not an expected value
2200 * - Older, pre-built firmware can attempt to operate on newer silicon
2201 * - Often, new silicon is perfectly compatible
2205 /* Success: NET2272 checks out OK */
2210 net2272_gadget_release(struct device *_dev)
2212 struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev);
2217 /*---------------------------------------------------------------------------*/
2220 net2272_remove(struct net2272 *dev)
2223 usb_del_gadget(&dev->gadget);
2224 free_irq(dev->irq, dev);
2225 iounmap(dev->base_addr);
2226 device_remove_file(dev->dev, &dev_attr_registers);
2228 dev_info(dev->dev, "unbind\n");
2231 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq)
2233 struct net2272 *ret;
2236 dev_dbg(dev, "No IRQ!\n");
2237 return ERR_PTR(-ENODEV);
2240 /* alloc, and start init */
2241 ret = kzalloc(sizeof(*ret), GFP_KERNEL);
2243 return ERR_PTR(-ENOMEM);
2245 spin_lock_init(&ret->lock);
2248 ret->gadget.ops = &net2272_ops;
2249 ret->gadget.max_speed = USB_SPEED_HIGH;
2251 /* the "gadget" abstracts/virtualizes the controller */
2252 ret->gadget.name = driver_name;
2253 usb_initialize_gadget(dev, &ret->gadget, net2272_gadget_release);
2259 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2263 /* See if there... */
2264 if (net2272_present(dev)) {
2265 dev_warn(dev->dev, "2272 not found!\n");
2270 net2272_usb_reset(dev);
2271 net2272_usb_reinit(dev);
2273 ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2275 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2279 dev->chiprev = net2272_read(dev, CHIPREV_2272);
2282 dev_info(dev->dev, "%s\n", driver_desc);
2283 dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2284 dev->irq, dev->base_addr, dev->chiprev,
2286 dev_info(dev->dev, "version: %s\n", driver_vers);
2288 ret = device_create_file(dev->dev, &dev_attr_registers);
2292 ret = usb_add_gadget(&dev->gadget);
2300 device_remove_file(dev->dev, &dev_attr_registers);
2302 free_irq(dev->irq, dev);
2307 #ifdef CONFIG_USB_PCI
2310 * wrap this driver around the specified device, but
2311 * don't respond over USB until a gadget driver binds to us
2315 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2317 unsigned long resource, len, tmp;
2318 void __iomem *mem_mapped_addr[4];
2322 * BAR 0 holds PLX 9054 config registers
2323 * BAR 1 is i/o memory; unused here
2324 * BAR 2 holds EPLD config registers
2325 * BAR 3 holds NET2272 registers
2328 /* Find and map all address spaces */
2329 for (i = 0; i < 4; ++i) {
2331 continue; /* BAR1 unused */
2333 resource = pci_resource_start(pdev, i);
2334 len = pci_resource_len(pdev, i);
2336 if (!request_mem_region(resource, len, driver_name)) {
2337 dev_dbg(dev->dev, "controller already in use\n");
2342 mem_mapped_addr[i] = ioremap(resource, len);
2343 if (mem_mapped_addr[i] == NULL) {
2344 release_mem_region(resource, len);
2345 dev_dbg(dev->dev, "can't map memory\n");
2351 dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2352 dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2353 dev->base_addr = mem_mapped_addr[3];
2355 /* Set PLX 9054 bus width (16 bits) */
2356 tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2357 writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2358 dev->rdk1.plx9054_base_addr + LBRD1);
2360 /* Enable PLX 9054 Interrupts */
2361 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2362 (1 << PCI_INTERRUPT_ENABLE) |
2363 (1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2364 dev->rdk1.plx9054_base_addr + INTCSR);
2366 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2367 dev->rdk1.plx9054_base_addr + DMACSR0);
2370 writeb((1 << EPLD_DMA_ENABLE) |
2371 (1 << DMA_CTL_DACK) |
2372 (1 << DMA_TIMEOUT_ENABLE) |
2376 (1 << NET2272_RESET),
2377 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2380 writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2381 ~(1 << NET2272_RESET),
2382 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2390 continue; /* BAR1 unused */
2391 iounmap(mem_mapped_addr[i]);
2392 release_mem_region(pci_resource_start(pdev, i),
2393 pci_resource_len(pdev, i));
2400 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2402 unsigned long resource, len;
2403 void __iomem *mem_mapped_addr[2];
2407 * BAR 0 holds FGPA config registers
2408 * BAR 1 holds NET2272 registers
2411 /* Find and map all address spaces, bar2-3 unused in rdk 2 */
2412 for (i = 0; i < 2; ++i) {
2413 resource = pci_resource_start(pdev, i);
2414 len = pci_resource_len(pdev, i);
2416 if (!request_mem_region(resource, len, driver_name)) {
2417 dev_dbg(dev->dev, "controller already in use\n");
2422 mem_mapped_addr[i] = ioremap(resource, len);
2423 if (mem_mapped_addr[i] == NULL) {
2424 release_mem_region(resource, len);
2425 dev_dbg(dev->dev, "can't map memory\n");
2431 dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2432 dev->base_addr = mem_mapped_addr[1];
2435 /* Set 2272 bus width (16 bits) and reset */
2436 writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2438 writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2439 /* Print fpga version number */
2440 dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2441 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2442 /* Enable FPGA Interrupts */
2443 writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2449 iounmap(mem_mapped_addr[i]);
2450 release_mem_region(pci_resource_start(pdev, i),
2451 pci_resource_len(pdev, i));
2458 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2460 struct net2272 *dev;
2463 dev = net2272_probe_init(&pdev->dev, pdev->irq);
2465 return PTR_ERR(dev);
2466 dev->dev_id = pdev->device;
2468 if (pci_enable_device(pdev) < 0) {
2473 pci_set_master(pdev);
2475 switch (pdev->device) {
2476 case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2477 case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2483 ret = net2272_probe_fin(dev, 0);
2487 pci_set_drvdata(pdev, dev);
2492 pci_disable_device(pdev);
2494 usb_put_gadget(&dev->gadget);
2500 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2504 /* disable PLX 9054 interrupts */
2505 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2506 ~(1 << PCI_INTERRUPT_ENABLE),
2507 dev->rdk1.plx9054_base_addr + INTCSR);
2509 /* clean up resources allocated during probe() */
2510 iounmap(dev->rdk1.plx9054_base_addr);
2511 iounmap(dev->rdk1.epld_base_addr);
2513 for (i = 0; i < 4; ++i) {
2515 continue; /* BAR1 unused */
2516 release_mem_region(pci_resource_start(pdev, i),
2517 pci_resource_len(pdev, i));
2522 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2526 /* disable fpga interrupts
2527 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2528 ~(1 << PCI_INTERRUPT_ENABLE),
2529 dev->rdk1.plx9054_base_addr + INTCSR);
2532 /* clean up resources allocated during probe() */
2533 iounmap(dev->rdk2.fpga_base_addr);
2535 for (i = 0; i < 2; ++i)
2536 release_mem_region(pci_resource_start(pdev, i),
2537 pci_resource_len(pdev, i));
2541 net2272_pci_remove(struct pci_dev *pdev)
2543 struct net2272 *dev = pci_get_drvdata(pdev);
2545 net2272_remove(dev);
2547 switch (pdev->device) {
2548 case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2549 case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2553 pci_disable_device(pdev);
2555 usb_put_gadget(&dev->gadget);
2558 /* Table of matching PCI IDs */
2559 static struct pci_device_id pci_ids[] = {
2561 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2563 .vendor = PCI_VENDOR_ID_PLX,
2564 .device = PCI_DEVICE_ID_RDK1,
2565 .subvendor = PCI_ANY_ID,
2566 .subdevice = PCI_ANY_ID,
2569 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2571 .vendor = PCI_VENDOR_ID_PLX,
2572 .device = PCI_DEVICE_ID_RDK2,
2573 .subvendor = PCI_ANY_ID,
2574 .subdevice = PCI_ANY_ID,
2578 MODULE_DEVICE_TABLE(pci, pci_ids);
2580 static struct pci_driver net2272_pci_driver = {
2581 .name = driver_name,
2582 .id_table = pci_ids,
2584 .probe = net2272_pci_probe,
2585 .remove = net2272_pci_remove,
2588 static int net2272_pci_register(void)
2590 return pci_register_driver(&net2272_pci_driver);
2593 static void net2272_pci_unregister(void)
2595 pci_unregister_driver(&net2272_pci_driver);
2599 static inline int net2272_pci_register(void) { return 0; }
2600 static inline void net2272_pci_unregister(void) { }
2603 /*---------------------------------------------------------------------------*/
2606 net2272_plat_probe(struct platform_device *pdev)
2608 struct net2272 *dev;
2610 unsigned int irqflags;
2611 resource_size_t base, len;
2612 struct resource *iomem, *iomem_bus, *irq_res;
2614 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2615 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2616 iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2617 if (!irq_res || !iomem) {
2618 dev_err(&pdev->dev, "must provide irq/base addr");
2622 dev = net2272_probe_init(&pdev->dev, irq_res->start);
2624 return PTR_ERR(dev);
2627 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2628 irqflags |= IRQF_TRIGGER_RISING;
2629 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2630 irqflags |= IRQF_TRIGGER_FALLING;
2631 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2632 irqflags |= IRQF_TRIGGER_HIGH;
2633 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2634 irqflags |= IRQF_TRIGGER_LOW;
2636 base = iomem->start;
2637 len = resource_size(iomem);
2639 dev->base_shift = iomem_bus->start;
2641 if (!request_mem_region(base, len, driver_name)) {
2642 dev_dbg(dev->dev, "get request memory region!\n");
2646 dev->base_addr = ioremap(base, len);
2647 if (!dev->base_addr) {
2648 dev_dbg(dev->dev, "can't map memory\n");
2653 ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW);
2657 platform_set_drvdata(pdev, dev);
2658 dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2659 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2664 iounmap(dev->base_addr);
2666 release_mem_region(base, len);
2668 usb_put_gadget(&dev->gadget);
2674 net2272_plat_remove(struct platform_device *pdev)
2676 struct net2272 *dev = platform_get_drvdata(pdev);
2678 net2272_remove(dev);
2680 release_mem_region(pdev->resource[0].start,
2681 resource_size(&pdev->resource[0]));
2683 usb_put_gadget(&dev->gadget);
2688 static struct platform_driver net2272_plat_driver = {
2689 .probe = net2272_plat_probe,
2690 .remove = net2272_plat_remove,
2692 .name = driver_name,
2694 /* FIXME .suspend, .resume */
2696 MODULE_ALIAS("platform:net2272");
2698 static int __init net2272_init(void)
2702 ret = net2272_pci_register();
2705 ret = platform_driver_register(&net2272_plat_driver);
2711 net2272_pci_unregister();
2714 module_init(net2272_init);
2716 static void __exit net2272_cleanup(void)
2718 net2272_pci_unregister();
2719 platform_driver_unregister(&net2272_plat_driver);
2721 module_exit(net2272_cleanup);
2723 MODULE_DESCRIPTION(DRIVER_DESC);
2724 MODULE_AUTHOR("PLX Technology, Inc.");
2725 MODULE_LICENSE("GPL");