2 * Driver for the PLX NET2280 USB device controller.
3 * Specs and errata are available from <http://www.plxtech.com>.
5 * PLX Technology Inc. (formerly NetChip Technology) supported the
6 * development of this driver.
9 * CODE STATUS HIGHLIGHTS
11 * This driver should work well with most "gadget" drivers, including
12 * the File Storage, Serial, and Ethernet/RNDIS gadget drivers
13 * as well as Gadget Zero and Gadgetfs.
15 * DMA is enabled by default. Drivers using transfer queues might use
16 * DMA chaining to remove IRQ latencies between transfers. (Except when
17 * short OUT transfers happen.) Drivers can use the req->no_interrupt
18 * hint to completely eliminate some IRQs, if a later IRQ is guaranteed
19 * and DMA chaining is enabled.
21 * Note that almost all the errata workarounds here are only needed for
22 * rev1 chips. Rev1a silicon (0110) fixes almost all of them.
26 * Copyright (C) 2003 David Brownell
27 * Copyright (C) 2003-2005 PLX Technology, Inc.
29 * Modified Seth Levy 2005 PLX Technology, Inc. to provide compatibility
32 * This program is free software; you can redistribute it and/or modify
33 * it under the terms of the GNU General Public License as published by
34 * the Free Software Foundation; either version 2 of the License, or
35 * (at your option) any later version.
37 * This program is distributed in the hope that it will be useful,
38 * but WITHOUT ANY WARRANTY; without even the implied warranty of
39 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
40 * GNU General Public License for more details.
42 * You should have received a copy of the GNU General Public License
43 * along with this program; if not, write to the Free Software
44 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
47 #undef DEBUG /* messages on error and most fault paths */
48 #undef VERBOSE /* extra debug messages (success too) */
50 #include <linux/module.h>
51 #include <linux/pci.h>
52 #include <linux/dma-mapping.h>
53 #include <linux/kernel.h>
54 #include <linux/delay.h>
55 #include <linux/ioport.h>
56 #include <linux/sched.h>
57 #include <linux/slab.h>
58 #include <linux/smp_lock.h>
59 #include <linux/errno.h>
60 #include <linux/init.h>
61 #include <linux/timer.h>
62 #include <linux/list.h>
63 #include <linux/interrupt.h>
64 #include <linux/moduleparam.h>
65 #include <linux/device.h>
66 #include <linux/usb_ch9.h>
67 #include <linux/usb_gadget.h>
69 #include <asm/byteorder.h>
72 #include <asm/system.h>
73 #include <asm/unaligned.h>
76 #define DRIVER_DESC "PLX NET228x USB Peripheral Controller"
77 #define DRIVER_VERSION "2005 Sept 27"
79 #define DMA_ADDR_INVALID (~(dma_addr_t)0)
80 #define EP_DONTUSE 13 /* nonzero */
82 #define USE_RDK_LEDS /* GPIO pins control three LEDs */
85 static const char driver_name
[] = "net2280";
86 static const char driver_desc
[] = DRIVER_DESC
;
88 static const char ep0name
[] = "ep0";
89 static const char *const ep_name
[] = {
91 "ep-a", "ep-b", "ep-c", "ep-d",
95 /* use_dma -- general goodness, fewer interrupts, less cpu load (vs PIO)
96 * use_dma_chaining -- dma descriptor queueing gives even more irq reduction
98 * The net2280 DMA engines are not tightly integrated with their FIFOs;
99 * not all cases are (yet) handled well in this driver or the silicon.
100 * Some gadget drivers work better with the dma support here than others.
101 * These two parameters let you use PIO or more aggressive DMA.
103 static int use_dma
= 1;
104 static int use_dma_chaining
= 0;
106 /* "modprobe net2280 use_dma=n" etc */
107 module_param (use_dma
, bool, S_IRUGO
);
108 module_param (use_dma_chaining
, bool, S_IRUGO
);
111 /* mode 0 == ep-{a,b,c,d} 1K fifo each
112 * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
113 * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
115 static ushort fifo_mode
= 0;
117 /* "modprobe net2280 fifo_mode=1" etc */
118 module_param (fifo_mode
, ushort
, 0644);
120 /* enable_suspend -- When enabled, the driver will respond to
121 * USB suspend requests by powering down the NET2280. Otherwise,
122 * USB suspend requests will be ignored. This is acceptible for
123 * self-powered devices
125 static int enable_suspend
= 0;
127 /* "modprobe net2280 enable_suspend=1" etc */
128 module_param (enable_suspend
, bool, S_IRUGO
);
131 #define DIR_STRING(bAddress) (((bAddress) & USB_DIR_IN) ? "in" : "out")
133 #if defined(CONFIG_USB_GADGET_DEBUG_FILES) || defined (DEBUG)
134 static char *type_string (u8 bmAttributes
)
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";
147 #define valid_bit __constant_cpu_to_le32 (1 << VALID_BIT)
148 #define dma_done_ie __constant_cpu_to_le32 (1 << DMA_DONE_INTERRUPT_ENABLE)
150 /*-------------------------------------------------------------------------*/
153 net2280_enable (struct usb_ep
*_ep
, const struct usb_endpoint_descriptor
*desc
)
156 struct net2280_ep
*ep
;
160 ep
= container_of (_ep
, struct net2280_ep
, ep
);
161 if (!_ep
|| !desc
|| ep
->desc
|| _ep
->name
== ep0name
162 || desc
->bDescriptorType
!= USB_DT_ENDPOINT
)
165 if (!dev
->driver
|| dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
168 /* erratum 0119 workaround ties up an endpoint number */
169 if ((desc
->bEndpointAddress
& 0x0f) == EP_DONTUSE
)
172 /* sanity check ep-e/ep-f since their fifos are small */
173 max
= le16_to_cpu (desc
->wMaxPacketSize
) & 0x1fff;
174 if (ep
->num
> 4 && max
> 64)
177 spin_lock_irqsave (&dev
->lock
, flags
);
178 _ep
->maxpacket
= max
& 0x7ff;
181 /* ep_reset() has already been called */
183 ep
->out_overflow
= 0;
185 /* set speed-dependent max packet; may kick in high bandwidth */
186 set_idx_reg (dev
->regs
, REG_EP_MAXPKT (dev
, ep
->num
), max
);
188 /* FIFO lines can't go to different packets. PIO is ok, so
189 * use it instead of troublesome (non-bulk) multi-packet DMA.
191 if (ep
->dma
&& (max
% 4) != 0 && use_dma_chaining
) {
192 DEBUG (ep
->dev
, "%s, no dma for maxpacket %d\n",
193 ep
->ep
.name
, ep
->ep
.maxpacket
);
197 /* set type, direction, address; reset fifo counters */
198 writel ((1 << FIFO_FLUSH
), &ep
->regs
->ep_stat
);
199 tmp
= (desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
);
200 if (tmp
== USB_ENDPOINT_XFER_INT
) {
201 /* erratum 0105 workaround prevents hs NYET */
202 if (dev
->chiprev
== 0100
203 && dev
->gadget
.speed
== USB_SPEED_HIGH
204 && !(desc
->bEndpointAddress
& USB_DIR_IN
))
205 writel ((1 << CLEAR_NAK_OUT_PACKETS_MODE
),
207 } else if (tmp
== USB_ENDPOINT_XFER_BULK
) {
208 /* catch some particularly blatant driver bugs */
209 if ((dev
->gadget
.speed
== USB_SPEED_HIGH
211 || (dev
->gadget
.speed
== USB_SPEED_FULL
213 spin_unlock_irqrestore (&dev
->lock
, flags
);
217 ep
->is_iso
= (tmp
== USB_ENDPOINT_XFER_ISOC
) ? 1 : 0;
218 tmp
<<= ENDPOINT_TYPE
;
219 tmp
|= desc
->bEndpointAddress
;
220 tmp
|= (4 << ENDPOINT_BYTE_COUNT
); /* default full fifo lines */
221 tmp
|= 1 << ENDPOINT_ENABLE
;
224 /* for OUT transfers, block the rx fifo until a read is posted */
225 ep
->is_in
= (tmp
& USB_DIR_IN
) != 0;
227 writel ((1 << SET_NAK_OUT_PACKETS
), &ep
->regs
->ep_rsp
);
228 else if (dev
->pdev
->device
!= 0x2280) {
229 /* Added for 2282, Don't use nak packets on an in endpoint,
230 * this was ignored on 2280
232 writel ((1 << CLEAR_NAK_OUT_PACKETS
)
233 | (1 << CLEAR_NAK_OUT_PACKETS_MODE
), &ep
->regs
->ep_rsp
);
236 writel (tmp
, &ep
->regs
->ep_cfg
);
239 if (!ep
->dma
) { /* pio, per-packet */
240 tmp
= (1 << ep
->num
) | readl (&dev
->regs
->pciirqenb0
);
241 writel (tmp
, &dev
->regs
->pciirqenb0
);
243 tmp
= (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE
)
244 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE
);
245 if (dev
->pdev
->device
== 0x2280)
246 tmp
|= readl (&ep
->regs
->ep_irqenb
);
247 writel (tmp
, &ep
->regs
->ep_irqenb
);
248 } else { /* dma, per-request */
249 tmp
= (1 << (8 + ep
->num
)); /* completion */
250 tmp
|= readl (&dev
->regs
->pciirqenb1
);
251 writel (tmp
, &dev
->regs
->pciirqenb1
);
253 /* for short OUT transfers, dma completions can't
254 * advance the queue; do it pio-style, by hand.
255 * NOTE erratum 0112 workaround #2
257 if ((desc
->bEndpointAddress
& USB_DIR_IN
) == 0) {
258 tmp
= (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT_ENABLE
);
259 writel (tmp
, &ep
->regs
->ep_irqenb
);
261 tmp
= (1 << ep
->num
) | readl (&dev
->regs
->pciirqenb0
);
262 writel (tmp
, &dev
->regs
->pciirqenb0
);
266 tmp
= desc
->bEndpointAddress
;
267 DEBUG (dev
, "enabled %s (ep%d%s-%s) %s max %04x\n",
268 _ep
->name
, tmp
& 0x0f, DIR_STRING (tmp
),
269 type_string (desc
->bmAttributes
),
270 ep
->dma
? "dma" : "pio", max
);
272 /* pci writes may still be posted */
273 spin_unlock_irqrestore (&dev
->lock
, flags
);
277 static int handshake (u32 __iomem
*ptr
, u32 mask
, u32 done
, int usec
)
282 result
= readl (ptr
);
283 if (result
== ~(u32
)0) /* "device unplugged" */
294 static const struct usb_ep_ops net2280_ep_ops
;
296 static void ep_reset (struct net2280_regs __iomem
*regs
, struct net2280_ep
*ep
)
301 INIT_LIST_HEAD (&ep
->queue
);
303 ep
->ep
.maxpacket
= ~0;
304 ep
->ep
.ops
= &net2280_ep_ops
;
306 /* disable the dma, irqs, endpoint... */
308 writel (0, &ep
->dma
->dmactl
);
309 writel ( (1 << DMA_SCATTER_GATHER_DONE_INTERRUPT
)
310 | (1 << DMA_TRANSACTION_DONE_INTERRUPT
)
312 , &ep
->dma
->dmastat
);
314 tmp
= readl (®s
->pciirqenb0
);
315 tmp
&= ~(1 << ep
->num
);
316 writel (tmp
, ®s
->pciirqenb0
);
318 tmp
= readl (®s
->pciirqenb1
);
319 tmp
&= ~(1 << (8 + ep
->num
)); /* completion */
320 writel (tmp
, ®s
->pciirqenb1
);
322 writel (0, &ep
->regs
->ep_irqenb
);
324 /* init to our chosen defaults, notably so that we NAK OUT
325 * packets until the driver queues a read (+note erratum 0112)
327 if (!ep
->is_in
|| ep
->dev
->pdev
->device
== 0x2280) {
328 tmp
= (1 << SET_NAK_OUT_PACKETS_MODE
)
329 | (1 << SET_NAK_OUT_PACKETS
)
330 | (1 << CLEAR_EP_HIDE_STATUS_PHASE
)
331 | (1 << CLEAR_INTERRUPT_MODE
);
334 tmp
= (1 << CLEAR_NAK_OUT_PACKETS_MODE
)
335 | (1 << CLEAR_NAK_OUT_PACKETS
)
336 | (1 << CLEAR_EP_HIDE_STATUS_PHASE
)
337 | (1 << CLEAR_INTERRUPT_MODE
);
341 tmp
|= (1 << CLEAR_ENDPOINT_TOGGLE
)
342 | (1 << CLEAR_ENDPOINT_HALT
);
344 writel (tmp
, &ep
->regs
->ep_rsp
);
346 /* scrub most status bits, and flush any fifo state */
347 if (ep
->dev
->pdev
->device
== 0x2280)
348 tmp
= (1 << FIFO_OVERFLOW
)
349 | (1 << FIFO_UNDERFLOW
);
353 writel (tmp
| (1 << TIMEOUT
)
354 | (1 << USB_STALL_SENT
)
355 | (1 << USB_IN_NAK_SENT
)
356 | (1 << USB_IN_ACK_RCVD
)
357 | (1 << USB_OUT_PING_NAK_SENT
)
358 | (1 << USB_OUT_ACK_SENT
)
360 | (1 << SHORT_PACKET_OUT_DONE_INTERRUPT
)
361 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT
)
362 | (1 << DATA_PACKET_RECEIVED_INTERRUPT
)
363 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT
)
364 | (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
365 | (1 << DATA_IN_TOKEN_INTERRUPT
)
366 , &ep
->regs
->ep_stat
);
368 /* fifo size is handled separately */
371 static void nuke (struct net2280_ep
*);
373 static int net2280_disable (struct usb_ep
*_ep
)
375 struct net2280_ep
*ep
;
378 ep
= container_of (_ep
, struct net2280_ep
, ep
);
379 if (!_ep
|| !ep
->desc
|| _ep
->name
== ep0name
)
382 spin_lock_irqsave (&ep
->dev
->lock
, flags
);
384 ep_reset (ep
->dev
->regs
, ep
);
386 VDEBUG (ep
->dev
, "disabled %s %s\n",
387 ep
->dma
? "dma" : "pio", _ep
->name
);
389 /* synch memory views with the device */
390 (void) readl (&ep
->regs
->ep_cfg
);
392 if (use_dma
&& !ep
->dma
&& ep
->num
>= 1 && ep
->num
<= 4)
393 ep
->dma
= &ep
->dev
->dma
[ep
->num
- 1];
395 spin_unlock_irqrestore (&ep
->dev
->lock
, flags
);
399 /*-------------------------------------------------------------------------*/
401 static struct usb_request
*
402 net2280_alloc_request (struct usb_ep
*_ep
, gfp_t gfp_flags
)
404 struct net2280_ep
*ep
;
405 struct net2280_request
*req
;
409 ep
= container_of (_ep
, struct net2280_ep
, ep
);
411 req
= kzalloc(sizeof(*req
), gfp_flags
);
415 req
->req
.dma
= DMA_ADDR_INVALID
;
416 INIT_LIST_HEAD (&req
->queue
);
418 /* this dma descriptor may be swapped with the previous dummy */
420 struct net2280_dma
*td
;
422 td
= pci_pool_alloc (ep
->dev
->requests
, gfp_flags
,
428 td
->dmacount
= 0; /* not VALID */
429 td
->dmaaddr
= __constant_cpu_to_le32 (DMA_ADDR_INVALID
);
430 td
->dmadesc
= td
->dmaaddr
;
437 net2280_free_request (struct usb_ep
*_ep
, struct usb_request
*_req
)
439 struct net2280_ep
*ep
;
440 struct net2280_request
*req
;
442 ep
= container_of (_ep
, struct net2280_ep
, ep
);
446 req
= container_of (_req
, struct net2280_request
, req
);
447 WARN_ON (!list_empty (&req
->queue
));
449 pci_pool_free (ep
->dev
->requests
, req
->td
, req
->td_dma
);
453 /*-------------------------------------------------------------------------*/
456 * dma-coherent memory allocation (for dma-capable endpoints)
458 * NOTE: the dma_*_coherent() API calls suck. Most implementations are
459 * (a) page-oriented, so small buffers lose big; and (b) asymmetric with
460 * respect to calls with irqs disabled: alloc is safe, free is not.
461 * We currently work around (b), but not (a).
465 net2280_alloc_buffer (
473 struct net2280_ep
*ep
;
475 ep
= container_of (_ep
, struct net2280_ep
, ep
);
478 *dma
= DMA_ADDR_INVALID
;
481 retval
= dma_alloc_coherent(&ep
->dev
->pdev
->dev
,
482 bytes
, dma
, gfp_flags
);
484 retval
= kmalloc(bytes
, gfp_flags
);
488 static DEFINE_SPINLOCK(buflock
);
489 static LIST_HEAD(buffers
);
492 struct list_head list
;
498 static void do_free(unsigned long ignored
)
500 spin_lock_irq(&buflock
);
501 while (!list_empty(&buffers
)) {
502 struct free_record
*buf
;
504 buf
= list_entry(buffers
.next
, struct free_record
, list
);
505 list_del(&buf
->list
);
506 spin_unlock_irq(&buflock
);
508 dma_free_coherent(buf
->dev
, buf
->bytes
, buf
, buf
->dma
);
510 spin_lock_irq(&buflock
);
512 spin_unlock_irq(&buflock
);
515 static DECLARE_TASKLET(deferred_free
, do_free
, 0);
518 net2280_free_buffer (
524 /* free memory into the right allocator */
525 if (dma
!= DMA_ADDR_INVALID
) {
526 struct net2280_ep
*ep
;
527 struct free_record
*buf
= address
;
530 ep
= container_of(_ep
, struct net2280_ep
, ep
);
534 ep
= container_of (_ep
, struct net2280_ep
, ep
);
535 buf
->dev
= &ep
->dev
->pdev
->dev
;
539 spin_lock_irqsave(&buflock
, flags
);
540 list_add_tail(&buf
->list
, &buffers
);
541 tasklet_schedule(&deferred_free
);
542 spin_unlock_irqrestore(&buflock
, flags
);
547 /*-------------------------------------------------------------------------*/
549 /* load a packet into the fifo we use for usb IN transfers.
550 * works for all endpoints.
552 * NOTE: pio with ep-a..ep-d could stuff multiple packets into the fifo
553 * at a time, but this code is simpler because it knows it only writes
554 * one packet. ep-a..ep-d should use dma instead.
557 write_fifo (struct net2280_ep
*ep
, struct usb_request
*req
)
559 struct net2280_ep_regs __iomem
*regs
= ep
->regs
;
562 unsigned count
, total
;
564 /* INVARIANT: fifo is currently empty. (testable) */
567 buf
= req
->buf
+ req
->actual
;
569 total
= req
->length
- req
->actual
;
575 /* write just one packet at a time */
576 count
= ep
->ep
.maxpacket
;
577 if (count
> total
) /* min() cannot be used on a bitfield */
580 VDEBUG (ep
->dev
, "write %s fifo (IN) %d bytes%s req %p\n",
582 (count
!= ep
->ep
.maxpacket
) ? " (short)" : "",
585 /* NOTE be careful if you try to align these. fifo lines
586 * should normally be full (4 bytes) and successive partial
587 * lines are ok only in certain cases.
589 tmp
= get_unaligned ((u32
*)buf
);
591 writel (tmp
, ®s
->ep_data
);
596 /* last fifo entry is "short" unless we wrote a full packet.
597 * also explicitly validate last word in (periodic) transfers
598 * when maxpacket is not a multiple of 4 bytes.
600 if (count
|| total
< ep
->ep
.maxpacket
) {
601 tmp
= count
? get_unaligned ((u32
*)buf
) : count
;
603 set_fifo_bytecount (ep
, count
& 0x03);
604 writel (tmp
, ®s
->ep_data
);
607 /* pci writes may still be posted */
610 /* work around erratum 0106: PCI and USB race over the OUT fifo.
611 * caller guarantees chiprev 0100, out endpoint is NAKing, and
612 * there's no real data in the fifo.
614 * NOTE: also used in cases where that erratum doesn't apply:
615 * where the host wrote "too much" data to us.
617 static void out_flush (struct net2280_ep
*ep
)
622 ASSERT_OUT_NAKING (ep
);
624 statp
= &ep
->regs
->ep_stat
;
625 writel ( (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
626 | (1 << DATA_PACKET_RECEIVED_INTERRUPT
)
628 writel ((1 << FIFO_FLUSH
), statp
);
631 if (tmp
& (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
632 /* high speed did bulk NYET; fifo isn't filling */
633 && ep
->dev
->gadget
.speed
== USB_SPEED_FULL
) {
636 usec
= 50; /* 64 byte bulk/interrupt */
637 handshake (statp
, (1 << USB_OUT_PING_NAK_SENT
),
638 (1 << USB_OUT_PING_NAK_SENT
), usec
);
639 /* NAK done; now CLEAR_NAK_OUT_PACKETS is safe */
643 /* unload packet(s) from the fifo we use for usb OUT transfers.
644 * returns true iff the request completed, because of short packet
645 * or the request buffer having filled with full packets.
647 * for ep-a..ep-d this will read multiple packets out when they
648 * have been accepted.
651 read_fifo (struct net2280_ep
*ep
, struct net2280_request
*req
)
653 struct net2280_ep_regs __iomem
*regs
= ep
->regs
;
654 u8
*buf
= req
->req
.buf
+ req
->req
.actual
;
655 unsigned count
, tmp
, is_short
;
656 unsigned cleanup
= 0, prevent
= 0;
658 /* erratum 0106 ... packets coming in during fifo reads might
659 * be incompletely rejected. not all cases have workarounds.
661 if (ep
->dev
->chiprev
== 0x0100
662 && ep
->dev
->gadget
.speed
== USB_SPEED_FULL
) {
664 tmp
= readl (&ep
->regs
->ep_stat
);
665 if ((tmp
& (1 << NAK_OUT_PACKETS
)))
667 else if ((tmp
& (1 << FIFO_FULL
))) {
668 start_out_naking (ep
);
671 /* else: hope we don't see the problem */
674 /* never overflow the rx buffer. the fifo reads packets until
675 * it sees a short one; we might not be ready for them all.
678 count
= readl (®s
->ep_avail
);
679 if (unlikely (count
== 0)) {
681 tmp
= readl (&ep
->regs
->ep_stat
);
682 count
= readl (®s
->ep_avail
);
683 /* handled that data already? */
684 if (count
== 0 && (tmp
& (1 << NAK_OUT_PACKETS
)) == 0)
688 tmp
= req
->req
.length
- req
->req
.actual
;
690 /* as with DMA, data overflow gets flushed */
691 if ((tmp
% ep
->ep
.maxpacket
) != 0) {
693 "%s out fifo %d bytes, expected %d\n",
694 ep
->ep
.name
, count
, tmp
);
695 req
->req
.status
= -EOVERFLOW
;
697 /* NAK_OUT_PACKETS will be set, so flushing is safe;
698 * the next read will start with the next packet
700 } /* else it's a ZLP, no worries */
703 req
->req
.actual
+= count
;
705 is_short
= (count
== 0) || ((count
% ep
->ep
.maxpacket
) != 0);
707 VDEBUG (ep
->dev
, "read %s fifo (OUT) %d bytes%s%s%s req %p %d/%d\n",
708 ep
->ep
.name
, count
, is_short
? " (short)" : "",
709 cleanup
? " flush" : "", prevent
? " nak" : "",
710 req
, req
->req
.actual
, req
->req
.length
);
713 tmp
= readl (®s
->ep_data
);
715 put_unaligned (tmp
, (u32
*)buf
);
720 tmp
= readl (®s
->ep_data
);
721 /* LE conversion is implicit here: */
730 writel ((1 << CLEAR_NAK_OUT_PACKETS
), &ep
->regs
->ep_rsp
);
731 (void) readl (&ep
->regs
->ep_rsp
);
734 return is_short
|| ((req
->req
.actual
== req
->req
.length
)
738 /* fill out dma descriptor to match a given request */
740 fill_dma_desc (struct net2280_ep
*ep
, struct net2280_request
*req
, int valid
)
742 struct net2280_dma
*td
= req
->td
;
743 u32 dmacount
= req
->req
.length
;
745 /* don't let DMA continue after a short OUT packet,
746 * so overruns can't affect the next transfer.
747 * in case of overruns on max-size packets, we can't
748 * stop the fifo from filling but we can flush it.
751 dmacount
|= (1 << DMA_DIRECTION
);
752 if ((!ep
->is_in
&& (dmacount
% ep
->ep
.maxpacket
) != 0)
753 || ep
->dev
->pdev
->device
!= 0x2280)
754 dmacount
|= (1 << END_OF_CHAIN
);
758 dmacount
|= (1 << VALID_BIT
);
759 if (likely(!req
->req
.no_interrupt
|| !use_dma_chaining
))
760 dmacount
|= (1 << DMA_DONE_INTERRUPT_ENABLE
);
762 /* td->dmadesc = previously set by caller */
763 td
->dmaaddr
= cpu_to_le32 (req
->req
.dma
);
765 /* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
767 td
->dmacount
= cpu_to_le32p (&dmacount
);
770 static const u32 dmactl_default
=
771 (1 << DMA_SCATTER_GATHER_DONE_INTERRUPT
)
772 | (1 << DMA_CLEAR_COUNT_ENABLE
)
773 /* erratum 0116 workaround part 1 (use POLLING) */
774 | (POLL_100_USEC
<< DESCRIPTOR_POLLING_RATE
)
775 | (1 << DMA_VALID_BIT_POLLING_ENABLE
)
776 | (1 << DMA_VALID_BIT_ENABLE
)
777 | (1 << DMA_SCATTER_GATHER_ENABLE
)
778 /* erratum 0116 workaround part 2 (no AUTOSTART) */
781 static inline void spin_stop_dma (struct net2280_dma_regs __iomem
*dma
)
783 handshake (&dma
->dmactl
, (1 << DMA_ENABLE
), 0, 50);
786 static inline void stop_dma (struct net2280_dma_regs __iomem
*dma
)
788 writel (readl (&dma
->dmactl
) & ~(1 << DMA_ENABLE
), &dma
->dmactl
);
792 static void start_queue (struct net2280_ep
*ep
, u32 dmactl
, u32 td_dma
)
794 struct net2280_dma_regs __iomem
*dma
= ep
->dma
;
795 unsigned int tmp
= (1 << VALID_BIT
) | (ep
->is_in
<< DMA_DIRECTION
);
797 if (ep
->dev
->pdev
->device
!= 0x2280)
798 tmp
|= (1 << END_OF_CHAIN
);
800 writel (tmp
, &dma
->dmacount
);
801 writel (readl (&dma
->dmastat
), &dma
->dmastat
);
803 writel (td_dma
, &dma
->dmadesc
);
804 writel (dmactl
, &dma
->dmactl
);
806 /* erratum 0116 workaround part 3: pci arbiter away from net2280 */
807 (void) readl (&ep
->dev
->pci
->pcimstctl
);
809 writel ((1 << DMA_START
), &dma
->dmastat
);
812 stop_out_naking (ep
);
815 static void start_dma (struct net2280_ep
*ep
, struct net2280_request
*req
)
818 struct net2280_dma_regs __iomem
*dma
= ep
->dma
;
820 /* FIXME can't use DMA for ZLPs */
822 /* on this path we "know" there's no dma active (yet) */
823 WARN_ON (readl (&dma
->dmactl
) & (1 << DMA_ENABLE
));
824 writel (0, &ep
->dma
->dmactl
);
826 /* previous OUT packet might have been short */
827 if (!ep
->is_in
&& ((tmp
= readl (&ep
->regs
->ep_stat
))
828 & (1 << NAK_OUT_PACKETS
)) != 0) {
829 writel ((1 << SHORT_PACKET_TRANSFERRED_INTERRUPT
),
832 tmp
= readl (&ep
->regs
->ep_avail
);
834 writel (readl (&dma
->dmastat
), &dma
->dmastat
);
836 /* transfer all/some fifo data */
837 writel (req
->req
.dma
, &dma
->dmaaddr
);
838 tmp
= min (tmp
, req
->req
.length
);
840 /* dma irq, faking scatterlist status */
841 req
->td
->dmacount
= cpu_to_le32 (req
->req
.length
- tmp
);
842 writel ((1 << DMA_DONE_INTERRUPT_ENABLE
)
843 | tmp
, &dma
->dmacount
);
844 req
->td
->dmadesc
= 0;
847 writel ((1 << DMA_ENABLE
), &dma
->dmactl
);
848 writel ((1 << DMA_START
), &dma
->dmastat
);
853 tmp
= dmactl_default
;
855 /* force packet boundaries between dma requests, but prevent the
856 * controller from automagically writing a last "short" packet
857 * (zero length) unless the driver explicitly said to do that.
860 if (likely ((req
->req
.length
% ep
->ep
.maxpacket
) != 0
862 tmp
|= (1 << DMA_FIFO_VALIDATE
);
863 ep
->in_fifo_validate
= 1;
865 ep
->in_fifo_validate
= 0;
868 /* init req->td, pointing to the current dummy */
869 req
->td
->dmadesc
= cpu_to_le32 (ep
->td_dma
);
870 fill_dma_desc (ep
, req
, 1);
872 if (!use_dma_chaining
)
873 req
->td
->dmacount
|= __constant_cpu_to_le32 (1 << END_OF_CHAIN
);
875 start_queue (ep
, tmp
, req
->td_dma
);
879 queue_dma (struct net2280_ep
*ep
, struct net2280_request
*req
, int valid
)
881 struct net2280_dma
*end
;
884 /* swap new dummy for old, link; fill and maybe activate */
890 ep
->td_dma
= req
->td_dma
;
893 end
->dmadesc
= cpu_to_le32 (ep
->td_dma
);
895 fill_dma_desc (ep
, req
, valid
);
899 done (struct net2280_ep
*ep
, struct net2280_request
*req
, int status
)
902 unsigned stopped
= ep
->stopped
;
904 list_del_init (&req
->queue
);
906 if (req
->req
.status
== -EINPROGRESS
)
907 req
->req
.status
= status
;
909 status
= req
->req
.status
;
913 pci_unmap_single (dev
->pdev
, req
->req
.dma
, req
->req
.length
,
914 ep
->is_in
? PCI_DMA_TODEVICE
: PCI_DMA_FROMDEVICE
);
915 req
->req
.dma
= DMA_ADDR_INVALID
;
919 if (status
&& status
!= -ESHUTDOWN
)
920 VDEBUG (dev
, "complete %s req %p stat %d len %u/%u\n",
921 ep
->ep
.name
, &req
->req
, status
,
922 req
->req
.actual
, req
->req
.length
);
924 /* don't modify queue heads during completion callback */
926 spin_unlock (&dev
->lock
);
927 req
->req
.complete (&ep
->ep
, &req
->req
);
928 spin_lock (&dev
->lock
);
929 ep
->stopped
= stopped
;
932 /*-------------------------------------------------------------------------*/
935 net2280_queue (struct usb_ep
*_ep
, struct usb_request
*_req
, gfp_t gfp_flags
)
937 struct net2280_request
*req
;
938 struct net2280_ep
*ep
;
942 /* we always require a cpu-view buffer, so that we can
943 * always use pio (as fallback or whatever).
945 req
= container_of (_req
, struct net2280_request
, req
);
946 if (!_req
|| !_req
->complete
|| !_req
->buf
947 || !list_empty (&req
->queue
))
949 if (_req
->length
> (~0 & DMA_BYTE_COUNT_MASK
))
951 ep
= container_of (_ep
, struct net2280_ep
, ep
);
952 if (!_ep
|| (!ep
->desc
&& ep
->num
!= 0))
955 if (!dev
->driver
|| dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
958 /* FIXME implement PIO fallback for ZLPs with DMA */
959 if (ep
->dma
&& _req
->length
== 0)
962 /* set up dma mapping in case the caller didn't */
963 if (ep
->dma
&& _req
->dma
== DMA_ADDR_INVALID
) {
964 _req
->dma
= pci_map_single (dev
->pdev
, _req
->buf
, _req
->length
,
965 ep
->is_in
? PCI_DMA_TODEVICE
: PCI_DMA_FROMDEVICE
);
970 VDEBUG (dev
, "%s queue req %p, len %d buf %p\n",
971 _ep
->name
, _req
, _req
->length
, _req
->buf
);
974 spin_lock_irqsave (&dev
->lock
, flags
);
976 _req
->status
= -EINPROGRESS
;
979 /* kickstart this i/o queue? */
980 if (list_empty (&ep
->queue
) && !ep
->stopped
) {
981 /* use DMA if the endpoint supports it, else pio */
985 /* maybe there's no control data, just status ack */
986 if (ep
->num
== 0 && _req
->length
== 0) {
989 VDEBUG (dev
, "%s status ack\n", ep
->ep
.name
);
993 /* PIO ... stuff the fifo, or unblock it. */
995 write_fifo (ep
, _req
);
996 else if (list_empty (&ep
->queue
)) {
999 /* OUT FIFO might have packet(s) buffered */
1000 s
= readl (&ep
->regs
->ep_stat
);
1001 if ((s
& (1 << FIFO_EMPTY
)) == 0) {
1002 /* note: _req->short_not_ok is
1003 * ignored here since PIO _always_
1004 * stops queue advance here, and
1005 * _req->status doesn't change for
1006 * short reads (only _req->actual)
1008 if (read_fifo (ep
, req
)) {
1012 /* don't queue it */
1015 s
= readl (&ep
->regs
->ep_stat
);
1018 /* don't NAK, let the fifo fill */
1019 if (req
&& (s
& (1 << NAK_OUT_PACKETS
)))
1020 writel ((1 << CLEAR_NAK_OUT_PACKETS
),
1025 } else if (ep
->dma
) {
1031 /* preventing magic zlps is per-engine state, not
1032 * per-transfer; irq logic must recover hiccups.
1034 expect
= likely (req
->req
.zero
1035 || (req
->req
.length
% ep
->ep
.maxpacket
) != 0);
1036 if (expect
!= ep
->in_fifo_validate
)
1039 queue_dma (ep
, req
, valid
);
1041 } /* else the irq handler advances the queue. */
1045 list_add_tail (&req
->queue
, &ep
->queue
);
1047 spin_unlock_irqrestore (&dev
->lock
, flags
);
1049 /* pci writes may still be posted */
1055 struct net2280_ep
*ep
,
1056 struct net2280_request
*req
,
1061 req
->req
.actual
= req
->req
.length
- (DMA_BYTE_COUNT_MASK
& dmacount
);
1062 done (ep
, req
, status
);
1065 static void restart_dma (struct net2280_ep
*ep
);
1067 static void scan_dma_completions (struct net2280_ep
*ep
)
1069 /* only look at descriptors that were "naturally" retired,
1070 * so fifo and list head state won't matter
1072 while (!list_empty (&ep
->queue
)) {
1073 struct net2280_request
*req
;
1076 req
= list_entry (ep
->queue
.next
,
1077 struct net2280_request
, queue
);
1081 tmp
= le32_to_cpup (&req
->td
->dmacount
);
1082 if ((tmp
& (1 << VALID_BIT
)) != 0)
1085 /* SHORT_PACKET_TRANSFERRED_INTERRUPT handles "usb-short"
1086 * cases where DMA must be aborted; this code handles
1087 * all non-abort DMA completions.
1089 if (unlikely (req
->td
->dmadesc
== 0)) {
1091 tmp
= readl (&ep
->dma
->dmacount
);
1092 if (tmp
& DMA_BYTE_COUNT_MASK
)
1094 /* single transfer mode */
1095 dma_done (ep
, req
, tmp
, 0);
1097 } else if (!ep
->is_in
1098 && (req
->req
.length
% ep
->ep
.maxpacket
) != 0) {
1099 tmp
= readl (&ep
->regs
->ep_stat
);
1101 /* AVOID TROUBLE HERE by not issuing short reads from
1102 * your gadget driver. That helps avoids errata 0121,
1103 * 0122, and 0124; not all cases trigger the warning.
1105 if ((tmp
& (1 << NAK_OUT_PACKETS
)) == 0) {
1106 WARN (ep
->dev
, "%s lost packet sync!\n",
1108 req
->req
.status
= -EOVERFLOW
;
1109 } else if ((tmp
= readl (&ep
->regs
->ep_avail
)) != 0) {
1110 /* fifo gets flushed later */
1111 ep
->out_overflow
= 1;
1112 DEBUG (ep
->dev
, "%s dma, discard %d len %d\n",
1115 req
->req
.status
= -EOVERFLOW
;
1118 dma_done (ep
, req
, tmp
, 0);
1122 static void restart_dma (struct net2280_ep
*ep
)
1124 struct net2280_request
*req
;
1125 u32 dmactl
= dmactl_default
;
1129 req
= list_entry (ep
->queue
.next
, struct net2280_request
, queue
);
1131 if (!use_dma_chaining
) {
1132 start_dma (ep
, req
);
1136 /* the 2280 will be processing the queue unless queue hiccups after
1137 * the previous transfer:
1138 * IN: wanted automagic zlp, head doesn't (or vice versa)
1139 * DMA_FIFO_VALIDATE doesn't init from dma descriptors.
1140 * OUT: was "usb-short", we must restart.
1142 if (ep
->is_in
&& !req
->valid
) {
1143 struct net2280_request
*entry
, *prev
= NULL
;
1144 int reqmode
, done
= 0;
1146 DEBUG (ep
->dev
, "%s dma hiccup td %p\n", ep
->ep
.name
, req
->td
);
1147 ep
->in_fifo_validate
= likely (req
->req
.zero
1148 || (req
->req
.length
% ep
->ep
.maxpacket
) != 0);
1149 if (ep
->in_fifo_validate
)
1150 dmactl
|= (1 << DMA_FIFO_VALIDATE
);
1151 list_for_each_entry (entry
, &ep
->queue
, queue
) {
1156 dmacount
= entry
->td
->dmacount
;
1158 reqmode
= likely (entry
->req
.zero
1159 || (entry
->req
.length
1160 % ep
->ep
.maxpacket
) != 0);
1161 if (reqmode
== ep
->in_fifo_validate
) {
1163 dmacount
|= valid_bit
;
1164 entry
->td
->dmacount
= dmacount
;
1168 /* force a hiccup */
1169 prev
->td
->dmacount
|= dma_done_ie
;
1174 /* walk the rest of the queue so unlinks behave */
1176 dmacount
&= ~valid_bit
;
1177 entry
->td
->dmacount
= dmacount
;
1182 writel (0, &ep
->dma
->dmactl
);
1183 start_queue (ep
, dmactl
, req
->td_dma
);
1186 static void abort_dma (struct net2280_ep
*ep
)
1188 /* abort the current transfer */
1189 if (likely (!list_empty (&ep
->queue
))) {
1190 /* FIXME work around errata 0121, 0122, 0124 */
1191 writel ((1 << DMA_ABORT
), &ep
->dma
->dmastat
);
1192 spin_stop_dma (ep
->dma
);
1195 scan_dma_completions (ep
);
1198 /* dequeue ALL requests */
1199 static void nuke (struct net2280_ep
*ep
)
1201 struct net2280_request
*req
;
1203 /* called with spinlock held */
1207 while (!list_empty (&ep
->queue
)) {
1208 req
= list_entry (ep
->queue
.next
,
1209 struct net2280_request
,
1211 done (ep
, req
, -ESHUTDOWN
);
1215 /* dequeue JUST ONE request */
1216 static int net2280_dequeue (struct usb_ep
*_ep
, struct usb_request
*_req
)
1218 struct net2280_ep
*ep
;
1219 struct net2280_request
*req
;
1220 unsigned long flags
;
1224 ep
= container_of (_ep
, struct net2280_ep
, ep
);
1225 if (!_ep
|| (!ep
->desc
&& ep
->num
!= 0) || !_req
)
1228 spin_lock_irqsave (&ep
->dev
->lock
, flags
);
1229 stopped
= ep
->stopped
;
1231 /* quiesce dma while we patch the queue */
1235 dmactl
= readl (&ep
->dma
->dmactl
);
1236 /* WARNING erratum 0127 may kick in ... */
1238 scan_dma_completions (ep
);
1241 /* make sure it's still queued on this endpoint */
1242 list_for_each_entry (req
, &ep
->queue
, queue
) {
1243 if (&req
->req
== _req
)
1246 if (&req
->req
!= _req
) {
1247 spin_unlock_irqrestore (&ep
->dev
->lock
, flags
);
1251 /* queue head may be partially complete. */
1252 if (ep
->queue
.next
== &req
->queue
) {
1254 DEBUG (ep
->dev
, "unlink (%s) dma\n", _ep
->name
);
1255 _req
->status
= -ECONNRESET
;
1257 if (likely (ep
->queue
.next
== &req
->queue
)) {
1258 // NOTE: misreports single-transfer mode
1259 req
->td
->dmacount
= 0; /* invalidate */
1261 readl (&ep
->dma
->dmacount
),
1265 DEBUG (ep
->dev
, "unlink (%s) pio\n", _ep
->name
);
1266 done (ep
, req
, -ECONNRESET
);
1270 /* patch up hardware chaining data */
1271 } else if (ep
->dma
&& use_dma_chaining
) {
1272 if (req
->queue
.prev
== ep
->queue
.next
) {
1273 writel (le32_to_cpu (req
->td
->dmadesc
),
1275 if (req
->td
->dmacount
& dma_done_ie
)
1276 writel (readl (&ep
->dma
->dmacount
)
1277 | le32_to_cpu(dma_done_ie
),
1278 &ep
->dma
->dmacount
);
1280 struct net2280_request
*prev
;
1282 prev
= list_entry (req
->queue
.prev
,
1283 struct net2280_request
, queue
);
1284 prev
->td
->dmadesc
= req
->td
->dmadesc
;
1285 if (req
->td
->dmacount
& dma_done_ie
)
1286 prev
->td
->dmacount
|= dma_done_ie
;
1291 done (ep
, req
, -ECONNRESET
);
1292 ep
->stopped
= stopped
;
1295 /* turn off dma on inactive queues */
1296 if (list_empty (&ep
->queue
))
1298 else if (!ep
->stopped
) {
1299 /* resume current request, or start new one */
1301 writel (dmactl
, &ep
->dma
->dmactl
);
1303 start_dma (ep
, list_entry (ep
->queue
.next
,
1304 struct net2280_request
, queue
));
1308 spin_unlock_irqrestore (&ep
->dev
->lock
, flags
);
1312 /*-------------------------------------------------------------------------*/
1314 static int net2280_fifo_status (struct usb_ep
*_ep
);
1317 net2280_set_halt (struct usb_ep
*_ep
, int value
)
1319 struct net2280_ep
*ep
;
1320 unsigned long flags
;
1323 ep
= container_of (_ep
, struct net2280_ep
, ep
);
1324 if (!_ep
|| (!ep
->desc
&& ep
->num
!= 0))
1326 if (!ep
->dev
->driver
|| ep
->dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
1328 if (ep
->desc
/* not ep0 */ && (ep
->desc
->bmAttributes
& 0x03)
1329 == USB_ENDPOINT_XFER_ISOC
)
1332 spin_lock_irqsave (&ep
->dev
->lock
, flags
);
1333 if (!list_empty (&ep
->queue
))
1335 else if (ep
->is_in
&& value
&& net2280_fifo_status (_ep
) != 0)
1338 VDEBUG (ep
->dev
, "%s %s halt\n", _ep
->name
,
1339 value
? "set" : "clear");
1340 /* set/clear, then synch memory views with the device */
1343 ep
->dev
->protocol_stall
= 1;
1348 (void) readl (&ep
->regs
->ep_rsp
);
1350 spin_unlock_irqrestore (&ep
->dev
->lock
, flags
);
1356 net2280_fifo_status (struct usb_ep
*_ep
)
1358 struct net2280_ep
*ep
;
1361 ep
= container_of (_ep
, struct net2280_ep
, ep
);
1362 if (!_ep
|| (!ep
->desc
&& ep
->num
!= 0))
1364 if (!ep
->dev
->driver
|| ep
->dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
1367 avail
= readl (&ep
->regs
->ep_avail
) & ((1 << 12) - 1);
1368 if (avail
> ep
->fifo_size
)
1371 avail
= ep
->fifo_size
- avail
;
1376 net2280_fifo_flush (struct usb_ep
*_ep
)
1378 struct net2280_ep
*ep
;
1380 ep
= container_of (_ep
, struct net2280_ep
, ep
);
1381 if (!_ep
|| (!ep
->desc
&& ep
->num
!= 0))
1383 if (!ep
->dev
->driver
|| ep
->dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
1386 writel ((1 << FIFO_FLUSH
), &ep
->regs
->ep_stat
);
1387 (void) readl (&ep
->regs
->ep_rsp
);
1390 static const struct usb_ep_ops net2280_ep_ops
= {
1391 .enable
= net2280_enable
,
1392 .disable
= net2280_disable
,
1394 .alloc_request
= net2280_alloc_request
,
1395 .free_request
= net2280_free_request
,
1397 .alloc_buffer
= net2280_alloc_buffer
,
1398 .free_buffer
= net2280_free_buffer
,
1400 .queue
= net2280_queue
,
1401 .dequeue
= net2280_dequeue
,
1403 .set_halt
= net2280_set_halt
,
1404 .fifo_status
= net2280_fifo_status
,
1405 .fifo_flush
= net2280_fifo_flush
,
1408 /*-------------------------------------------------------------------------*/
1410 static int net2280_get_frame (struct usb_gadget
*_gadget
)
1412 struct net2280
*dev
;
1413 unsigned long flags
;
1418 dev
= container_of (_gadget
, struct net2280
, gadget
);
1419 spin_lock_irqsave (&dev
->lock
, flags
);
1420 retval
= get_idx_reg (dev
->regs
, REG_FRAME
) & 0x03ff;
1421 spin_unlock_irqrestore (&dev
->lock
, flags
);
1425 static int net2280_wakeup (struct usb_gadget
*_gadget
)
1427 struct net2280
*dev
;
1429 unsigned long flags
;
1433 dev
= container_of (_gadget
, struct net2280
, gadget
);
1435 spin_lock_irqsave (&dev
->lock
, flags
);
1436 tmp
= readl (&dev
->usb
->usbctl
);
1437 if (tmp
& (1 << DEVICE_REMOTE_WAKEUP_ENABLE
))
1438 writel (1 << GENERATE_RESUME
, &dev
->usb
->usbstat
);
1439 spin_unlock_irqrestore (&dev
->lock
, flags
);
1441 /* pci writes may still be posted */
1445 static int net2280_set_selfpowered (struct usb_gadget
*_gadget
, int value
)
1447 struct net2280
*dev
;
1449 unsigned long flags
;
1453 dev
= container_of (_gadget
, struct net2280
, gadget
);
1455 spin_lock_irqsave (&dev
->lock
, flags
);
1456 tmp
= readl (&dev
->usb
->usbctl
);
1458 tmp
|= (1 << SELF_POWERED_STATUS
);
1460 tmp
&= ~(1 << SELF_POWERED_STATUS
);
1461 writel (tmp
, &dev
->usb
->usbctl
);
1462 spin_unlock_irqrestore (&dev
->lock
, flags
);
1467 static int net2280_pullup(struct usb_gadget
*_gadget
, int is_on
)
1469 struct net2280
*dev
;
1471 unsigned long flags
;
1475 dev
= container_of (_gadget
, struct net2280
, gadget
);
1477 spin_lock_irqsave (&dev
->lock
, flags
);
1478 tmp
= readl (&dev
->usb
->usbctl
);
1479 dev
->softconnect
= (is_on
!= 0);
1481 tmp
|= (1 << USB_DETECT_ENABLE
);
1483 tmp
&= ~(1 << USB_DETECT_ENABLE
);
1484 writel (tmp
, &dev
->usb
->usbctl
);
1485 spin_unlock_irqrestore (&dev
->lock
, flags
);
1490 static const struct usb_gadget_ops net2280_ops
= {
1491 .get_frame
= net2280_get_frame
,
1492 .wakeup
= net2280_wakeup
,
1493 .set_selfpowered
= net2280_set_selfpowered
,
1494 .pullup
= net2280_pullup
,
1497 /*-------------------------------------------------------------------------*/
1499 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1501 /* FIXME move these into procfs, and use seq_file.
1502 * Sysfs _still_ doesn't behave for arbitrarily sized files,
1503 * and also doesn't help products using this with 2.4 kernels.
1506 /* "function" sysfs attribute */
1508 show_function (struct device
*_dev
, struct device_attribute
*attr
, char *buf
)
1510 struct net2280
*dev
= dev_get_drvdata (_dev
);
1513 || !dev
->driver
->function
1514 || strlen (dev
->driver
->function
) > PAGE_SIZE
)
1516 return scnprintf (buf
, PAGE_SIZE
, "%s\n", dev
->driver
->function
);
1518 static DEVICE_ATTR (function
, S_IRUGO
, show_function
, NULL
);
1521 show_registers (struct device
*_dev
, struct device_attribute
*attr
, char *buf
)
1523 struct net2280
*dev
;
1526 unsigned long flags
;
1531 dev
= dev_get_drvdata (_dev
);
1534 spin_lock_irqsave (&dev
->lock
, flags
);
1537 s
= dev
->driver
->driver
.name
;
1541 /* Main Control Registers */
1542 t
= scnprintf (next
, size
, "%s version " DRIVER_VERSION
1543 ", chiprev %04x, dma %s\n\n"
1544 "devinit %03x fifoctl %08x gadget '%s'\n"
1545 "pci irqenb0 %02x irqenb1 %08x "
1546 "irqstat0 %04x irqstat1 %08x\n",
1547 driver_name
, dev
->chiprev
,
1549 ? (use_dma_chaining
? "chaining" : "enabled")
1551 readl (&dev
->regs
->devinit
),
1552 readl (&dev
->regs
->fifoctl
),
1554 readl (&dev
->regs
->pciirqenb0
),
1555 readl (&dev
->regs
->pciirqenb1
),
1556 readl (&dev
->regs
->irqstat0
),
1557 readl (&dev
->regs
->irqstat1
));
1561 /* USB Control Registers */
1562 t1
= readl (&dev
->usb
->usbctl
);
1563 t2
= readl (&dev
->usb
->usbstat
);
1564 if (t1
& (1 << VBUS_PIN
)) {
1565 if (t2
& (1 << HIGH_SPEED
))
1567 else if (dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
1571 /* full speed bit (6) not working?? */
1574 t
= scnprintf (next
, size
,
1575 "stdrsp %08x usbctl %08x usbstat %08x "
1576 "addr 0x%02x (%s)\n",
1577 readl (&dev
->usb
->stdrsp
), t1
, t2
,
1578 readl (&dev
->usb
->ouraddr
), s
);
1582 /* PCI Master Control Registers */
1584 /* DMA Control Registers */
1586 /* Configurable EP Control Registers */
1587 for (i
= 0; i
< 7; i
++) {
1588 struct net2280_ep
*ep
;
1594 t1
= readl (&ep
->regs
->ep_cfg
);
1595 t2
= readl (&ep
->regs
->ep_rsp
) & 0xff;
1596 t
= scnprintf (next
, size
,
1597 "\n%s\tcfg %05x rsp (%02x) %s%s%s%s%s%s%s%s"
1599 ep
->ep
.name
, t1
, t2
,
1600 (t2
& (1 << CLEAR_NAK_OUT_PACKETS
))
1602 (t2
& (1 << CLEAR_EP_HIDE_STATUS_PHASE
))
1604 (t2
& (1 << CLEAR_EP_FORCE_CRC_ERROR
))
1606 (t2
& (1 << CLEAR_INTERRUPT_MODE
))
1607 ? "interrupt " : "",
1608 (t2
& (1<<CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE
))
1610 (t2
& (1 << CLEAR_NAK_OUT_PACKETS_MODE
))
1612 (t2
& (1 << CLEAR_ENDPOINT_TOGGLE
))
1613 ? "DATA1 " : "DATA0 ",
1614 (t2
& (1 << CLEAR_ENDPOINT_HALT
))
1616 readl (&ep
->regs
->ep_irqenb
));
1620 t
= scnprintf (next
, size
,
1621 "\tstat %08x avail %04x "
1623 readl (&ep
->regs
->ep_stat
),
1624 readl (&ep
->regs
->ep_avail
),
1625 t1
& 0x0f, DIR_STRING (t1
),
1626 type_string (t1
>> 8),
1627 ep
->stopped
? "*" : "");
1634 t
= scnprintf (next
, size
,
1635 " dma\tctl %08x stat %08x count %08x\n"
1636 "\taddr %08x desc %08x\n",
1637 readl (&ep
->dma
->dmactl
),
1638 readl (&ep
->dma
->dmastat
),
1639 readl (&ep
->dma
->dmacount
),
1640 readl (&ep
->dma
->dmaaddr
),
1641 readl (&ep
->dma
->dmadesc
));
1647 /* Indexed Registers */
1651 t
= scnprintf (next
, size
, "\nirqs: ");
1654 for (i
= 0; i
< 7; i
++) {
1655 struct net2280_ep
*ep
;
1660 t
= scnprintf (next
, size
, " %s/%lu", ep
->ep
.name
, ep
->irqs
);
1665 t
= scnprintf (next
, size
, "\n");
1669 spin_unlock_irqrestore (&dev
->lock
, flags
);
1671 return PAGE_SIZE
- size
;
1673 static DEVICE_ATTR (registers
, S_IRUGO
, show_registers
, NULL
);
1676 show_queues (struct device
*_dev
, struct device_attribute
*attr
, char *buf
)
1678 struct net2280
*dev
;
1681 unsigned long flags
;
1684 dev
= dev_get_drvdata (_dev
);
1687 spin_lock_irqsave (&dev
->lock
, flags
);
1689 for (i
= 0; i
< 7; i
++) {
1690 struct net2280_ep
*ep
= &dev
->ep
[i
];
1691 struct net2280_request
*req
;
1695 const struct usb_endpoint_descriptor
*d
;
1700 t
= d
->bEndpointAddress
;
1701 t
= scnprintf (next
, size
,
1702 "\n%s (ep%d%s-%s) max %04x %s fifo %d\n",
1703 ep
->ep
.name
, t
& USB_ENDPOINT_NUMBER_MASK
,
1704 (t
& USB_DIR_IN
) ? "in" : "out",
1706 switch (d
->bmAttributes
& 0x03) {
1707 case USB_ENDPOINT_XFER_BULK
:
1708 val
= "bulk"; break;
1709 case USB_ENDPOINT_XFER_INT
:
1710 val
= "intr"; break;
1714 le16_to_cpu (d
->wMaxPacketSize
) & 0x1fff,
1715 ep
->dma
? "dma" : "pio", ep
->fifo_size
1717 } else /* ep0 should only have one transfer queued */
1718 t
= scnprintf (next
, size
, "ep0 max 64 pio %s\n",
1719 ep
->is_in
? "in" : "out");
1720 if (t
<= 0 || t
> size
)
1725 if (list_empty (&ep
->queue
)) {
1726 t
= scnprintf (next
, size
, "\t(nothing queued)\n");
1727 if (t
<= 0 || t
> size
)
1733 list_for_each_entry (req
, &ep
->queue
, queue
) {
1734 if (ep
->dma
&& req
->td_dma
== readl (&ep
->dma
->dmadesc
))
1735 t
= scnprintf (next
, size
,
1736 "\treq %p len %d/%d "
1737 "buf %p (dmacount %08x)\n",
1738 &req
->req
, req
->req
.actual
,
1739 req
->req
.length
, req
->req
.buf
,
1740 readl (&ep
->dma
->dmacount
));
1742 t
= scnprintf (next
, size
,
1743 "\treq %p len %d/%d buf %p\n",
1744 &req
->req
, req
->req
.actual
,
1745 req
->req
.length
, req
->req
.buf
);
1746 if (t
<= 0 || t
> size
)
1752 struct net2280_dma
*td
;
1755 t
= scnprintf (next
, size
, "\t td %08x "
1756 " count %08x buf %08x desc %08x\n",
1758 le32_to_cpu (td
->dmacount
),
1759 le32_to_cpu (td
->dmaaddr
),
1760 le32_to_cpu (td
->dmadesc
));
1761 if (t
<= 0 || t
> size
)
1770 spin_unlock_irqrestore (&dev
->lock
, flags
);
1771 return PAGE_SIZE
- size
;
1773 static DEVICE_ATTR (queues
, S_IRUGO
, show_queues
, NULL
);
1778 #define device_create_file(a,b) (0)
1779 #define device_remove_file(a,b) do { } while (0)
1783 /*-------------------------------------------------------------------------*/
1785 /* another driver-specific mode might be a request type doing dma
1786 * to/from another device fifo instead of to/from memory.
1789 static void set_fifo_mode (struct net2280
*dev
, int mode
)
1791 /* keeping high bits preserves BAR2 */
1792 writel ((0xffff << PCI_BASE2_RANGE
) | mode
, &dev
->regs
->fifoctl
);
1794 /* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */
1795 INIT_LIST_HEAD (&dev
->gadget
.ep_list
);
1796 list_add_tail (&dev
->ep
[1].ep
.ep_list
, &dev
->gadget
.ep_list
);
1797 list_add_tail (&dev
->ep
[2].ep
.ep_list
, &dev
->gadget
.ep_list
);
1800 list_add_tail (&dev
->ep
[3].ep
.ep_list
, &dev
->gadget
.ep_list
);
1801 list_add_tail (&dev
->ep
[4].ep
.ep_list
, &dev
->gadget
.ep_list
);
1802 dev
->ep
[1].fifo_size
= dev
->ep
[2].fifo_size
= 1024;
1805 dev
->ep
[1].fifo_size
= dev
->ep
[2].fifo_size
= 2048;
1808 list_add_tail (&dev
->ep
[3].ep
.ep_list
, &dev
->gadget
.ep_list
);
1809 dev
->ep
[1].fifo_size
= 2048;
1810 dev
->ep
[2].fifo_size
= 1024;
1813 /* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
1814 list_add_tail (&dev
->ep
[5].ep
.ep_list
, &dev
->gadget
.ep_list
);
1815 list_add_tail (&dev
->ep
[6].ep
.ep_list
, &dev
->gadget
.ep_list
);
1818 /* just declare this in any driver that really need it */
1819 extern int net2280_set_fifo_mode (struct usb_gadget
*gadget
, int mode
);
1822 * net2280_set_fifo_mode - change allocation of fifo buffers
1823 * @gadget: access to the net2280 device that will be updated
1824 * @mode: 0 for default, four 1kB buffers (ep-a through ep-d);
1825 * 1 for two 2kB buffers (ep-a and ep-b only);
1826 * 2 for one 2kB buffer (ep-a) and two 1kB ones (ep-b, ep-c).
1828 * returns zero on success, else negative errno. when this succeeds,
1829 * the contents of gadget->ep_list may have changed.
1831 * you may only call this function when endpoints a-d are all disabled.
1832 * use it whenever extra hardware buffering can help performance, such
1833 * as before enabling "high bandwidth" interrupt endpoints that use
1834 * maxpacket bigger than 512 (when double buffering would otherwise
1837 int net2280_set_fifo_mode (struct usb_gadget
*gadget
, int mode
)
1840 struct net2280
*dev
;
1842 unsigned long flags
;
1846 dev
= container_of (gadget
, struct net2280
, gadget
);
1848 spin_lock_irqsave (&dev
->lock
, flags
);
1850 for (i
= 1; i
<= 4; i
++)
1851 if (dev
->ep
[i
].desc
) {
1855 if (mode
< 0 || mode
> 2)
1858 set_fifo_mode (dev
, mode
);
1859 spin_unlock_irqrestore (&dev
->lock
, flags
);
1863 DEBUG (dev
, "fifo: ep-a 2K, ep-b 2K\n");
1865 DEBUG (dev
, "fifo: ep-a 2K, ep-b 1K, ep-c 1K\n");
1866 /* else all are 1K */
1870 EXPORT_SYMBOL (net2280_set_fifo_mode
);
1872 /*-------------------------------------------------------------------------*/
1874 /* keeping it simple:
1875 * - one bus driver, initted first;
1876 * - one function driver, initted second
1878 * most of the work to support multiple net2280 controllers would
1879 * be to associate this gadget driver (yes?) with all of them, or
1880 * perhaps to bind specific drivers to specific devices.
1883 static struct net2280
*the_controller
;
1885 static void usb_reset (struct net2280
*dev
)
1889 dev
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1890 (void) readl (&dev
->usb
->usbctl
);
1892 net2280_led_init (dev
);
1894 /* disable automatic responses, and irqs */
1895 writel (0, &dev
->usb
->stdrsp
);
1896 writel (0, &dev
->regs
->pciirqenb0
);
1897 writel (0, &dev
->regs
->pciirqenb1
);
1899 /* clear old dma and irq state */
1900 for (tmp
= 0; tmp
< 4; tmp
++) {
1901 struct net2280_ep
*ep
= &dev
->ep
[tmp
+ 1];
1906 writel (~0, &dev
->regs
->irqstat0
),
1907 writel (~(1 << SUSPEND_REQUEST_INTERRUPT
), &dev
->regs
->irqstat1
),
1909 /* reset, and enable pci */
1910 tmp
= readl (&dev
->regs
->devinit
)
1912 | (1 << FIFO_SOFT_RESET
)
1913 | (1 << USB_SOFT_RESET
)
1914 | (1 << M8051_RESET
);
1915 writel (tmp
, &dev
->regs
->devinit
);
1917 /* standard fifo and endpoint allocations */
1918 set_fifo_mode (dev
, (fifo_mode
<= 2) ? fifo_mode
: 0);
1921 static void usb_reinit (struct net2280
*dev
)
1926 /* use_dma changes are ignored till next device re-init */
1929 /* basic endpoint init */
1930 for (tmp
= 0; tmp
< 7; tmp
++) {
1931 struct net2280_ep
*ep
= &dev
->ep
[tmp
];
1933 ep
->ep
.name
= ep_name
[tmp
];
1937 if (tmp
> 0 && tmp
<= 4) {
1938 ep
->fifo_size
= 1024;
1940 ep
->dma
= &dev
->dma
[tmp
- 1];
1943 ep
->regs
= &dev
->epregs
[tmp
];
1944 ep_reset (dev
->regs
, ep
);
1946 dev
->ep
[0].ep
.maxpacket
= 64;
1947 dev
->ep
[5].ep
.maxpacket
= 64;
1948 dev
->ep
[6].ep
.maxpacket
= 64;
1950 dev
->gadget
.ep0
= &dev
->ep
[0].ep
;
1951 dev
->ep
[0].stopped
= 0;
1952 INIT_LIST_HEAD (&dev
->gadget
.ep0
->ep_list
);
1954 /* we want to prevent lowlevel/insecure access from the USB host,
1955 * but erratum 0119 means this enable bit is ignored
1957 for (tmp
= 0; tmp
< 5; tmp
++)
1958 writel (EP_DONTUSE
, &dev
->dep
[tmp
].dep_cfg
);
1961 static void ep0_start (struct net2280
*dev
)
1963 writel ( (1 << CLEAR_EP_HIDE_STATUS_PHASE
)
1964 | (1 << CLEAR_NAK_OUT_PACKETS
)
1965 | (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE
)
1966 , &dev
->epregs
[0].ep_rsp
);
1969 * hardware optionally handles a bunch of standard requests
1970 * that the API hides from drivers anyway. have it do so.
1971 * endpoint status/features are handled in software, to
1972 * help pass tests for some dubious behavior.
1974 writel ( (1 << SET_TEST_MODE
)
1975 | (1 << SET_ADDRESS
)
1976 | (1 << DEVICE_SET_CLEAR_DEVICE_REMOTE_WAKEUP
)
1977 | (1 << GET_DEVICE_STATUS
)
1978 | (1 << GET_INTERFACE_STATUS
)
1979 , &dev
->usb
->stdrsp
);
1980 writel ( (1 << USB_ROOT_PORT_WAKEUP_ENABLE
)
1981 | (1 << SELF_POWERED_USB_DEVICE
)
1982 | (1 << REMOTE_WAKEUP_SUPPORT
)
1983 | (dev
->softconnect
<< USB_DETECT_ENABLE
)
1984 | (1 << SELF_POWERED_STATUS
)
1985 , &dev
->usb
->usbctl
);
1987 /* enable irqs so we can see ep0 and general operation */
1988 writel ( (1 << SETUP_PACKET_INTERRUPT_ENABLE
)
1989 | (1 << ENDPOINT_0_INTERRUPT_ENABLE
)
1990 , &dev
->regs
->pciirqenb0
);
1991 writel ( (1 << PCI_INTERRUPT_ENABLE
)
1992 | (1 << PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE
)
1993 | (1 << PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE
)
1994 | (1 << PCI_RETRY_ABORT_INTERRUPT_ENABLE
)
1995 | (1 << VBUS_INTERRUPT_ENABLE
)
1996 | (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE
)
1997 | (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE
)
1998 , &dev
->regs
->pciirqenb1
);
2000 /* don't leave any writes posted */
2001 (void) readl (&dev
->usb
->usbctl
);
2004 /* when a driver is successfully registered, it will receive
2005 * control requests including set_configuration(), which enables
2006 * non-control requests. then usb traffic follows until a
2007 * disconnect is reported. then a host may connect again, or
2008 * the driver might get unbound.
2010 int usb_gadget_register_driver (struct usb_gadget_driver
*driver
)
2012 struct net2280
*dev
= the_controller
;
2016 /* insist on high speed support from the driver, since
2017 * (dev->usb->xcvrdiag & FORCE_FULL_SPEED_MODE)
2018 * "must not be used in normal operation"
2021 || driver
->speed
!= USB_SPEED_HIGH
2031 for (i
= 0; i
< 7; i
++)
2032 dev
->ep
[i
].irqs
= 0;
2034 /* hook up the driver ... */
2035 dev
->softconnect
= 1;
2036 driver
->driver
.bus
= NULL
;
2037 dev
->driver
= driver
;
2038 dev
->gadget
.dev
.driver
= &driver
->driver
;
2039 retval
= driver
->bind (&dev
->gadget
);
2041 DEBUG (dev
, "bind to driver %s --> %d\n",
2042 driver
->driver
.name
, retval
);
2044 dev
->gadget
.dev
.driver
= NULL
;
2048 retval
= device_create_file (&dev
->pdev
->dev
, &dev_attr_function
);
2049 if (retval
) goto err_unbind
;
2050 retval
= device_create_file (&dev
->pdev
->dev
, &dev_attr_queues
);
2051 if (retval
) goto err_func
;
2053 /* ... then enable host detection and ep0; and we're ready
2054 * for set_configuration as well as eventual disconnect.
2056 net2280_led_active (dev
, 1);
2059 DEBUG (dev
, "%s ready, usbctl %08x stdrsp %08x\n",
2060 driver
->driver
.name
,
2061 readl (&dev
->usb
->usbctl
),
2062 readl (&dev
->usb
->stdrsp
));
2064 /* pci writes may still be posted */
2068 device_remove_file (&dev
->pdev
->dev
, &dev_attr_function
);
2070 driver
->unbind (&dev
->gadget
);
2071 dev
->gadget
.dev
.driver
= NULL
;
2075 EXPORT_SYMBOL (usb_gadget_register_driver
);
2078 stop_activity (struct net2280
*dev
, struct usb_gadget_driver
*driver
)
2082 /* don't disconnect if it's not connected */
2083 if (dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
2086 /* stop hardware; prevent new request submissions;
2087 * and kill any outstanding requests.
2090 for (i
= 0; i
< 7; i
++)
2091 nuke (&dev
->ep
[i
]);
2093 /* report disconnect; the driver is already quiesced */
2095 spin_unlock (&dev
->lock
);
2096 driver
->disconnect (&dev
->gadget
);
2097 spin_lock (&dev
->lock
);
2103 int usb_gadget_unregister_driver (struct usb_gadget_driver
*driver
)
2105 struct net2280
*dev
= the_controller
;
2106 unsigned long flags
;
2110 if (!driver
|| driver
!= dev
->driver
)
2113 spin_lock_irqsave (&dev
->lock
, flags
);
2114 stop_activity (dev
, driver
);
2115 spin_unlock_irqrestore (&dev
->lock
, flags
);
2117 net2280_pullup (&dev
->gadget
, 0);
2119 driver
->unbind (&dev
->gadget
);
2120 dev
->gadget
.dev
.driver
= NULL
;
2123 net2280_led_active (dev
, 0);
2124 device_remove_file (&dev
->pdev
->dev
, &dev_attr_function
);
2125 device_remove_file (&dev
->pdev
->dev
, &dev_attr_queues
);
2127 DEBUG (dev
, "unregistered driver '%s'\n", driver
->driver
.name
);
2130 EXPORT_SYMBOL (usb_gadget_unregister_driver
);
2133 /*-------------------------------------------------------------------------*/
2135 /* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq.
2136 * also works for dma-capable endpoints, in pio mode or just
2137 * to manually advance the queue after short OUT transfers.
2139 static void handle_ep_small (struct net2280_ep
*ep
)
2141 struct net2280_request
*req
;
2143 /* 0 error, 1 mid-data, 2 done */
2146 if (!list_empty (&ep
->queue
))
2147 req
= list_entry (ep
->queue
.next
,
2148 struct net2280_request
, queue
);
2152 /* ack all, and handle what we care about */
2153 t
= readl (&ep
->regs
->ep_stat
);
2156 VDEBUG (ep
->dev
, "%s ack ep_stat %08x, req %p\n",
2157 ep
->ep
.name
, t
, req
? &req
->req
: 0);
2159 if (!ep
->is_in
|| ep
->dev
->pdev
->device
== 0x2280)
2160 writel (t
& ~(1 << NAK_OUT_PACKETS
), &ep
->regs
->ep_stat
);
2162 /* Added for 2282 */
2163 writel (t
, &ep
->regs
->ep_stat
);
2165 /* for ep0, monitor token irqs to catch data stage length errors
2166 * and to synchronize on status.
2168 * also, to defer reporting of protocol stalls ... here's where
2169 * data or status first appears, handling stalls here should never
2170 * cause trouble on the host side..
2172 * control requests could be slightly faster without token synch for
2173 * status, but status can jam up that way.
2175 if (unlikely (ep
->num
== 0)) {
2177 /* status; stop NAKing */
2178 if (t
& (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)) {
2179 if (ep
->dev
->protocol_stall
) {
2186 /* reply to extra IN data tokens with a zlp */
2187 } else if (t
& (1 << DATA_IN_TOKEN_INTERRUPT
)) {
2188 if (ep
->dev
->protocol_stall
) {
2192 } else if (ep
->responded
&&
2193 !req
&& !ep
->stopped
)
2194 write_fifo (ep
, NULL
);
2197 /* status; stop NAKing */
2198 if (t
& (1 << DATA_IN_TOKEN_INTERRUPT
)) {
2199 if (ep
->dev
->protocol_stall
) {
2204 /* an extra OUT token is an error */
2205 } else if (((t
& (1 << DATA_OUT_PING_TOKEN_INTERRUPT
))
2207 && req
->req
.actual
== req
->req
.length
)
2208 || (ep
->responded
&& !req
)) {
2209 ep
->dev
->protocol_stall
= 1;
2213 done (ep
, req
, -EOVERFLOW
);
2219 if (unlikely (!req
))
2222 /* manual DMA queue advance after short OUT */
2223 if (likely (ep
->dma
!= 0)) {
2224 if (t
& (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT
)) {
2226 int stopped
= ep
->stopped
;
2228 /* TRANSFERRED works around OUT_DONE erratum 0112.
2229 * we expect (N <= maxpacket) bytes; host wrote M.
2230 * iff (M < N) we won't ever see a DMA interrupt.
2233 for (count
= 0; ; t
= readl (&ep
->regs
->ep_stat
)) {
2235 /* any preceding dma transfers must finish.
2236 * dma handles (M >= N), may empty the queue
2238 scan_dma_completions (ep
);
2239 if (unlikely (list_empty (&ep
->queue
)
2240 || ep
->out_overflow
)) {
2244 req
= list_entry (ep
->queue
.next
,
2245 struct net2280_request
, queue
);
2247 /* here either (M < N), a "real" short rx;
2248 * or (M == N) and the queue didn't empty
2250 if (likely (t
& (1 << FIFO_EMPTY
))) {
2251 count
= readl (&ep
->dma
->dmacount
);
2252 count
&= DMA_BYTE_COUNT_MASK
;
2253 if (readl (&ep
->dma
->dmadesc
)
2261 /* stop DMA, leave ep NAKing */
2262 writel ((1 << DMA_ABORT
), &ep
->dma
->dmastat
);
2263 spin_stop_dma (ep
->dma
);
2266 req
->td
->dmacount
= 0;
2267 t
= readl (&ep
->regs
->ep_avail
);
2268 dma_done (ep
, req
, count
,
2269 (ep
->out_overflow
|| t
)
2273 /* also flush to prevent erratum 0106 trouble */
2274 if (unlikely (ep
->out_overflow
2275 || (ep
->dev
->chiprev
== 0x0100
2276 && ep
->dev
->gadget
.speed
2277 == USB_SPEED_FULL
))) {
2279 ep
->out_overflow
= 0;
2282 /* (re)start dma if needed, stop NAKing */
2283 ep
->stopped
= stopped
;
2284 if (!list_empty (&ep
->queue
))
2287 DEBUG (ep
->dev
, "%s dma ep_stat %08x ??\n",
2291 /* data packet(s) received (in the fifo, OUT) */
2292 } else if (t
& (1 << DATA_PACKET_RECEIVED_INTERRUPT
)) {
2293 if (read_fifo (ep
, req
) && ep
->num
!= 0)
2296 /* data packet(s) transmitted (IN) */
2297 } else if (t
& (1 << DATA_PACKET_TRANSMITTED_INTERRUPT
)) {
2300 len
= req
->req
.length
- req
->req
.actual
;
2301 if (len
> ep
->ep
.maxpacket
)
2302 len
= ep
->ep
.maxpacket
;
2303 req
->req
.actual
+= len
;
2305 /* if we wrote it all, we're usually done */
2306 if (req
->req
.actual
== req
->req
.length
) {
2308 /* send zlps until the status stage */
2309 } else if (!req
->req
.zero
|| len
!= ep
->ep
.maxpacket
)
2313 /* there was nothing to do ... */
2314 } else if (mode
== 1)
2319 /* stream endpoints often resubmit/unlink in completion */
2322 /* maybe advance queue to next request */
2324 /* NOTE: net2280 could let gadget driver start the
2325 * status stage later. since not all controllers let
2326 * them control that, the api doesn't (yet) allow it.
2332 if (!list_empty (&ep
->queue
) && !ep
->stopped
)
2333 req
= list_entry (ep
->queue
.next
,
2334 struct net2280_request
, queue
);
2337 if (req
&& !ep
->is_in
)
2338 stop_out_naking (ep
);
2342 /* is there a buffer for the next packet?
2343 * for best streaming performance, make sure there is one.
2345 if (req
&& !ep
->stopped
) {
2347 /* load IN fifo with next packet (may be zlp) */
2348 if (t
& (1 << DATA_PACKET_TRANSMITTED_INTERRUPT
))
2349 write_fifo (ep
, &req
->req
);
2353 static struct net2280_ep
*
2354 get_ep_by_addr (struct net2280
*dev
, u16 wIndex
)
2356 struct net2280_ep
*ep
;
2358 if ((wIndex
& USB_ENDPOINT_NUMBER_MASK
) == 0)
2359 return &dev
->ep
[0];
2360 list_for_each_entry (ep
, &dev
->gadget
.ep_list
, ep
.ep_list
) {
2361 u8 bEndpointAddress
;
2365 bEndpointAddress
= ep
->desc
->bEndpointAddress
;
2366 if ((wIndex
^ bEndpointAddress
) & USB_DIR_IN
)
2368 if ((wIndex
& 0x0f) == (bEndpointAddress
& 0x0f))
2374 static void handle_stat0_irqs (struct net2280
*dev
, u32 stat
)
2376 struct net2280_ep
*ep
;
2379 /* most of these don't need individual acks */
2380 stat
&= ~(1 << INTA_ASSERTED
);
2383 // DEBUG (dev, "irqstat0 %04x\n", stat);
2385 /* starting a control request? */
2386 if (unlikely (stat
& (1 << SETUP_PACKET_INTERRUPT
))) {
2389 struct usb_ctrlrequest r
;
2392 struct net2280_request
*req
;
2394 if (dev
->gadget
.speed
== USB_SPEED_UNKNOWN
) {
2395 if (readl (&dev
->usb
->usbstat
) & (1 << HIGH_SPEED
))
2396 dev
->gadget
.speed
= USB_SPEED_HIGH
;
2398 dev
->gadget
.speed
= USB_SPEED_FULL
;
2399 net2280_led_speed (dev
, dev
->gadget
.speed
);
2400 DEBUG (dev
, "%s speed\n",
2401 (dev
->gadget
.speed
== USB_SPEED_HIGH
)
2408 /* make sure any leftover request state is cleared */
2409 stat
&= ~(1 << ENDPOINT_0_INTERRUPT
);
2410 while (!list_empty (&ep
->queue
)) {
2411 req
= list_entry (ep
->queue
.next
,
2412 struct net2280_request
, queue
);
2413 done (ep
, req
, (req
->req
.actual
== req
->req
.length
)
2417 dev
->protocol_stall
= 0;
2419 if (ep
->dev
->pdev
->device
== 0x2280)
2420 tmp
= (1 << FIFO_OVERFLOW
)
2421 | (1 << FIFO_UNDERFLOW
);
2425 writel (tmp
| (1 << TIMEOUT
)
2426 | (1 << USB_STALL_SENT
)
2427 | (1 << USB_IN_NAK_SENT
)
2428 | (1 << USB_IN_ACK_RCVD
)
2429 | (1 << USB_OUT_PING_NAK_SENT
)
2430 | (1 << USB_OUT_ACK_SENT
)
2431 | (1 << SHORT_PACKET_OUT_DONE_INTERRUPT
)
2432 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT
)
2433 | (1 << DATA_PACKET_RECEIVED_INTERRUPT
)
2434 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT
)
2435 | (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
2436 | (1 << DATA_IN_TOKEN_INTERRUPT
)
2437 , &ep
->regs
->ep_stat
);
2438 u
.raw
[0] = readl (&dev
->usb
->setup0123
);
2439 u
.raw
[1] = readl (&dev
->usb
->setup4567
);
2441 cpu_to_le32s (&u
.raw
[0]);
2442 cpu_to_le32s (&u
.raw
[1]);
2446 #define w_value le16_to_cpup (&u.r.wValue)
2447 #define w_index le16_to_cpup (&u.r.wIndex)
2448 #define w_length le16_to_cpup (&u.r.wLength)
2451 writel (1 << SETUP_PACKET_INTERRUPT
, &dev
->regs
->irqstat0
);
2452 stat
^= (1 << SETUP_PACKET_INTERRUPT
);
2454 /* watch control traffic at the token level, and force
2455 * synchronization before letting the status stage happen.
2456 * FIXME ignore tokens we'll NAK, until driver responds.
2457 * that'll mean a lot less irqs for some drivers.
2459 ep
->is_in
= (u
.r
.bRequestType
& USB_DIR_IN
) != 0;
2461 scratch
= (1 << DATA_PACKET_TRANSMITTED_INTERRUPT
)
2462 | (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
2463 | (1 << DATA_IN_TOKEN_INTERRUPT
);
2464 stop_out_naking (ep
);
2466 scratch
= (1 << DATA_PACKET_RECEIVED_INTERRUPT
)
2467 | (1 << DATA_OUT_PING_TOKEN_INTERRUPT
)
2468 | (1 << DATA_IN_TOKEN_INTERRUPT
);
2469 writel (scratch
, &dev
->epregs
[0].ep_irqenb
);
2471 /* we made the hardware handle most lowlevel requests;
2472 * everything else goes uplevel to the gadget code.
2475 switch (u
.r
.bRequest
) {
2476 case USB_REQ_GET_STATUS
: {
2477 struct net2280_ep
*e
;
2480 /* hw handles device and interface status */
2481 if (u
.r
.bRequestType
!= (USB_DIR_IN
|USB_RECIP_ENDPOINT
))
2483 if ((e
= get_ep_by_addr (dev
, w_index
)) == 0
2487 if (readl (&e
->regs
->ep_rsp
)
2488 & (1 << SET_ENDPOINT_HALT
))
2489 status
= __constant_cpu_to_le32 (1);
2491 status
= __constant_cpu_to_le32 (0);
2493 /* don't bother with a request object! */
2494 writel (0, &dev
->epregs
[0].ep_irqenb
);
2495 set_fifo_bytecount (ep
, w_length
);
2496 writel ((__force u32
)status
, &dev
->epregs
[0].ep_data
);
2498 VDEBUG (dev
, "%s stat %02x\n", ep
->ep
.name
, status
);
2499 goto next_endpoints
;
2502 case USB_REQ_CLEAR_FEATURE
: {
2503 struct net2280_ep
*e
;
2505 /* hw handles device features */
2506 if (u
.r
.bRequestType
!= USB_RECIP_ENDPOINT
)
2508 if (w_value
!= USB_ENDPOINT_HALT
2511 if ((e
= get_ep_by_addr (dev
, w_index
)) == 0)
2515 VDEBUG (dev
, "%s clear halt\n", ep
->ep
.name
);
2516 goto next_endpoints
;
2519 case USB_REQ_SET_FEATURE
: {
2520 struct net2280_ep
*e
;
2522 /* hw handles device features */
2523 if (u
.r
.bRequestType
!= USB_RECIP_ENDPOINT
)
2525 if (w_value
!= USB_ENDPOINT_HALT
2528 if ((e
= get_ep_by_addr (dev
, w_index
)) == 0)
2532 VDEBUG (dev
, "%s set halt\n", ep
->ep
.name
);
2533 goto next_endpoints
;
2538 VDEBUG (dev
, "setup %02x.%02x v%04x i%04x l%04x"
2540 u
.r
.bRequestType
, u
.r
.bRequest
,
2541 w_value
, w_index
, w_length
,
2542 readl (&ep
->regs
->ep_cfg
));
2544 spin_unlock (&dev
->lock
);
2545 tmp
= dev
->driver
->setup (&dev
->gadget
, &u
.r
);
2546 spin_lock (&dev
->lock
);
2549 /* stall ep0 on error */
2552 VDEBUG (dev
, "req %02x.%02x protocol STALL; stat %d\n",
2553 u
.r
.bRequestType
, u
.r
.bRequest
, tmp
);
2554 dev
->protocol_stall
= 1;
2557 /* some in/out token irq should follow; maybe stall then.
2558 * driver must queue a request (even zlp) or halt ep0
2559 * before the host times out.
2568 /* endpoint data irq ? */
2569 scratch
= stat
& 0x7f;
2571 for (num
= 0; scratch
; num
++) {
2574 /* do this endpoint's FIFO and queue need tending? */
2576 if ((scratch
& t
) == 0)
2580 ep
= &dev
->ep
[num
];
2581 handle_ep_small (ep
);
2585 DEBUG (dev
, "unhandled irqstat0 %08x\n", stat
);
2588 #define DMA_INTERRUPTS ( \
2589 (1 << DMA_D_INTERRUPT) \
2590 | (1 << DMA_C_INTERRUPT) \
2591 | (1 << DMA_B_INTERRUPT) \
2592 | (1 << DMA_A_INTERRUPT))
2593 #define PCI_ERROR_INTERRUPTS ( \
2594 (1 << PCI_MASTER_ABORT_RECEIVED_INTERRUPT) \
2595 | (1 << PCI_TARGET_ABORT_RECEIVED_INTERRUPT) \
2596 | (1 << PCI_RETRY_ABORT_INTERRUPT))
2598 static void handle_stat1_irqs (struct net2280
*dev
, u32 stat
)
2600 struct net2280_ep
*ep
;
2601 u32 tmp
, num
, mask
, scratch
;
2603 /* after disconnect there's nothing else to do! */
2604 tmp
= (1 << VBUS_INTERRUPT
) | (1 << ROOT_PORT_RESET_INTERRUPT
);
2605 mask
= (1 << HIGH_SPEED
) | (1 << FULL_SPEED
);
2607 /* VBUS disconnect is indicated by VBUS_PIN and VBUS_INTERRUPT set.
2608 * Root Port Reset is indicated by ROOT_PORT_RESET_INTERRRUPT set and
2609 * both HIGH_SPEED and FULL_SPEED clear (as ROOT_PORT_RESET_INTERRUPT
2610 * only indicates a change in the reset state).
2613 writel (tmp
, &dev
->regs
->irqstat1
);
2614 if ((((stat
& (1 << ROOT_PORT_RESET_INTERRUPT
))
2615 && ((readl (&dev
->usb
->usbstat
) & mask
)
2617 || ((readl (&dev
->usb
->usbctl
)
2618 & (1 << VBUS_PIN
)) == 0)
2619 ) && ( dev
->gadget
.speed
!= USB_SPEED_UNKNOWN
)) {
2620 DEBUG (dev
, "disconnect %s\n",
2621 dev
->driver
->driver
.name
);
2622 stop_activity (dev
, dev
->driver
);
2628 /* vBUS can bounce ... one of many reasons to ignore the
2629 * notion of hotplug events on bus connect/disconnect!
2635 /* NOTE: chip stays in PCI D0 state for now, but it could
2636 * enter D1 to save more power
2638 tmp
= (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT
);
2640 writel (tmp
, &dev
->regs
->irqstat1
);
2641 if (stat
& (1 << SUSPEND_REQUEST_INTERRUPT
)) {
2642 if (dev
->driver
->suspend
)
2643 dev
->driver
->suspend (&dev
->gadget
);
2644 if (!enable_suspend
)
2645 stat
&= ~(1 << SUSPEND_REQUEST_INTERRUPT
);
2647 if (dev
->driver
->resume
)
2648 dev
->driver
->resume (&dev
->gadget
);
2649 /* at high speed, note erratum 0133 */
2654 /* clear any other status/irqs */
2656 writel (stat
, &dev
->regs
->irqstat1
);
2658 /* some status we can just ignore */
2659 if (dev
->pdev
->device
== 0x2280)
2660 stat
&= ~((1 << CONTROL_STATUS_INTERRUPT
)
2661 | (1 << SUSPEND_REQUEST_INTERRUPT
)
2662 | (1 << RESUME_INTERRUPT
)
2663 | (1 << SOF_INTERRUPT
));
2665 stat
&= ~((1 << CONTROL_STATUS_INTERRUPT
)
2666 | (1 << RESUME_INTERRUPT
)
2667 | (1 << SOF_DOWN_INTERRUPT
)
2668 | (1 << SOF_INTERRUPT
));
2672 // DEBUG (dev, "irqstat1 %08x\n", stat);
2674 /* DMA status, for ep-{a,b,c,d} */
2675 scratch
= stat
& DMA_INTERRUPTS
;
2676 stat
&= ~DMA_INTERRUPTS
;
2678 for (num
= 0; scratch
; num
++) {
2679 struct net2280_dma_regs __iomem
*dma
;
2682 if ((tmp
& scratch
) == 0)
2686 ep
= &dev
->ep
[num
+ 1];
2692 /* clear ep's dma status */
2693 tmp
= readl (&dma
->dmastat
);
2694 writel (tmp
, &dma
->dmastat
);
2696 /* chaining should stop on abort, short OUT from fifo,
2697 * or (stat0 codepath) short OUT transfer.
2699 if (!use_dma_chaining
) {
2700 if ((tmp
& (1 << DMA_TRANSACTION_DONE_INTERRUPT
))
2702 DEBUG (ep
->dev
, "%s no xact done? %08x\n",
2709 /* OUT transfers terminate when the data from the
2710 * host is in our memory. Process whatever's done.
2711 * On this path, we know transfer's last packet wasn't
2712 * less than req->length. NAK_OUT_PACKETS may be set,
2713 * or the FIFO may already be holding new packets.
2715 * IN transfers can linger in the FIFO for a very
2716 * long time ... we ignore that for now, accounting
2717 * precisely (like PIO does) needs per-packet irqs
2719 scan_dma_completions (ep
);
2721 /* disable dma on inactive queues; else maybe restart */
2722 if (list_empty (&ep
->queue
)) {
2723 if (use_dma_chaining
)
2726 tmp
= readl (&dma
->dmactl
);
2727 if (!use_dma_chaining
2728 || (tmp
& (1 << DMA_ENABLE
)) == 0)
2730 else if (ep
->is_in
&& use_dma_chaining
) {
2731 struct net2280_request
*req
;
2734 /* the descriptor at the head of the chain
2735 * may still have VALID_BIT clear; that's
2736 * used to trigger changing DMA_FIFO_VALIDATE
2737 * (affects automagic zlp writes).
2739 req
= list_entry (ep
->queue
.next
,
2740 struct net2280_request
, queue
);
2741 dmacount
= req
->td
->dmacount
;
2742 dmacount
&= __constant_cpu_to_le32 (
2744 | DMA_BYTE_COUNT_MASK
);
2745 if (dmacount
&& (dmacount
& valid_bit
) == 0)
2752 /* NOTE: there are other PCI errors we might usefully notice.
2753 * if they appear very often, here's where to try recovering.
2755 if (stat
& PCI_ERROR_INTERRUPTS
) {
2756 ERROR (dev
, "pci dma error; stat %08x\n", stat
);
2757 stat
&= ~PCI_ERROR_INTERRUPTS
;
2758 /* these are fatal errors, but "maybe" they won't
2761 stop_activity (dev
, dev
->driver
);
2767 DEBUG (dev
, "unhandled irqstat1 %08x\n", stat
);
2770 static irqreturn_t
net2280_irq (int irq
, void *_dev
)
2772 struct net2280
*dev
= _dev
;
2774 /* shared interrupt, not ours */
2775 if (!(readl(&dev
->regs
->irqstat0
) & (1 << INTA_ASSERTED
)))
2778 spin_lock (&dev
->lock
);
2780 /* handle disconnect, dma, and more */
2781 handle_stat1_irqs (dev
, readl (&dev
->regs
->irqstat1
));
2783 /* control requests and PIO */
2784 handle_stat0_irqs (dev
, readl (&dev
->regs
->irqstat0
));
2786 spin_unlock (&dev
->lock
);
2791 /*-------------------------------------------------------------------------*/
2793 static void gadget_release (struct device
*_dev
)
2795 struct net2280
*dev
= dev_get_drvdata (_dev
);
2800 /* tear down the binding between this driver and the pci device */
2802 static void net2280_remove (struct pci_dev
*pdev
)
2804 struct net2280
*dev
= pci_get_drvdata (pdev
);
2806 /* start with the driver above us */
2808 /* should have been done already by driver model core */
2809 WARN (dev
, "pci remove, driver '%s' is still registered\n",
2810 dev
->driver
->driver
.name
);
2811 usb_gadget_unregister_driver (dev
->driver
);
2814 /* then clean up the resources we allocated during probe() */
2815 net2280_led_shutdown (dev
);
2816 if (dev
->requests
) {
2818 for (i
= 1; i
< 5; i
++) {
2819 if (!dev
->ep
[i
].dummy
)
2821 pci_pool_free (dev
->requests
, dev
->ep
[i
].dummy
,
2822 dev
->ep
[i
].td_dma
);
2824 pci_pool_destroy (dev
->requests
);
2827 free_irq (pdev
->irq
, dev
);
2829 iounmap (dev
->regs
);
2831 release_mem_region (pci_resource_start (pdev
, 0),
2832 pci_resource_len (pdev
, 0));
2834 pci_disable_device (pdev
);
2835 device_unregister (&dev
->gadget
.dev
);
2836 device_remove_file (&pdev
->dev
, &dev_attr_registers
);
2837 pci_set_drvdata (pdev
, NULL
);
2839 INFO (dev
, "unbind\n");
2841 the_controller
= NULL
;
2844 /* wrap this driver around the specified device, but
2845 * don't respond over USB until a gadget driver binds to us.
2848 static int net2280_probe (struct pci_dev
*pdev
, const struct pci_device_id
*id
)
2850 struct net2280
*dev
;
2851 unsigned long resource
, len
;
2852 void __iomem
*base
= NULL
;
2855 /* if you want to support more than one controller in a system,
2856 * usb_gadget_driver_{register,unregister}() must change.
2858 if (the_controller
) {
2859 dev_warn (&pdev
->dev
, "ignoring\n");
2863 /* alloc, and start init */
2864 dev
= kzalloc (sizeof *dev
, GFP_KERNEL
);
2870 pci_set_drvdata (pdev
, dev
);
2871 spin_lock_init (&dev
->lock
);
2873 dev
->gadget
.ops
= &net2280_ops
;
2874 dev
->gadget
.is_dualspeed
= 1;
2876 /* the "gadget" abstracts/virtualizes the controller */
2877 strcpy (dev
->gadget
.dev
.bus_id
, "gadget");
2878 dev
->gadget
.dev
.parent
= &pdev
->dev
;
2879 dev
->gadget
.dev
.dma_mask
= pdev
->dev
.dma_mask
;
2880 dev
->gadget
.dev
.release
= gadget_release
;
2881 dev
->gadget
.name
= driver_name
;
2883 /* now all the pci goodies ... */
2884 if (pci_enable_device (pdev
) < 0) {
2890 /* BAR 0 holds all the registers
2891 * BAR 1 is 8051 memory; unused here (note erratum 0103)
2892 * BAR 2 is fifo memory; unused here
2894 resource
= pci_resource_start (pdev
, 0);
2895 len
= pci_resource_len (pdev
, 0);
2896 if (!request_mem_region (resource
, len
, driver_name
)) {
2897 DEBUG (dev
, "controller already in use\n");
2903 /* FIXME provide firmware download interface to put
2904 * 8051 code into the chip, e.g. to turn on PCI PM.
2907 base
= ioremap_nocache (resource
, len
);
2909 DEBUG (dev
, "can't map memory\n");
2913 dev
->regs
= (struct net2280_regs __iomem
*) base
;
2914 dev
->usb
= (struct net2280_usb_regs __iomem
*) (base
+ 0x0080);
2915 dev
->pci
= (struct net2280_pci_regs __iomem
*) (base
+ 0x0100);
2916 dev
->dma
= (struct net2280_dma_regs __iomem
*) (base
+ 0x0180);
2917 dev
->dep
= (struct net2280_dep_regs __iomem
*) (base
+ 0x0200);
2918 dev
->epregs
= (struct net2280_ep_regs __iomem
*) (base
+ 0x0300);
2920 /* put into initial config, link up all endpoints */
2921 writel (0, &dev
->usb
->usbctl
);
2925 /* irq setup after old hardware is cleaned up */
2927 ERROR (dev
, "No IRQ. Check PCI setup!\n");
2932 if (request_irq (pdev
->irq
, net2280_irq
, IRQF_SHARED
, driver_name
, dev
)
2934 ERROR (dev
, "request interrupt %d failed\n", pdev
->irq
);
2941 /* NOTE: we know only the 32 LSBs of dma addresses may be nonzero */
2942 dev
->requests
= pci_pool_create ("requests", pdev
,
2943 sizeof (struct net2280_dma
),
2944 0 /* no alignment requirements */,
2945 0 /* or page-crossing issues */);
2946 if (!dev
->requests
) {
2947 DEBUG (dev
, "can't get request pool\n");
2951 for (i
= 1; i
< 5; i
++) {
2952 struct net2280_dma
*td
;
2954 td
= pci_pool_alloc (dev
->requests
, GFP_KERNEL
,
2955 &dev
->ep
[i
].td_dma
);
2957 DEBUG (dev
, "can't get dummy %d\n", i
);
2961 td
->dmacount
= 0; /* not VALID */
2962 td
->dmaaddr
= __constant_cpu_to_le32 (DMA_ADDR_INVALID
);
2963 td
->dmadesc
= td
->dmaaddr
;
2964 dev
->ep
[i
].dummy
= td
;
2967 /* enable lower-overhead pci memory bursts during DMA */
2968 writel ( (1 << DMA_MEMORY_WRITE_AND_INVALIDATE_ENABLE
)
2969 // 256 write retries may not be enough...
2970 // | (1 << PCI_RETRY_ABORT_ENABLE)
2971 | (1 << DMA_READ_MULTIPLE_ENABLE
)
2972 | (1 << DMA_READ_LINE_ENABLE
)
2973 , &dev
->pci
->pcimstctl
);
2974 /* erratum 0115 shouldn't appear: Linux inits PCI_LATENCY_TIMER */
2975 pci_set_master (pdev
);
2978 /* ... also flushes any posted pci writes */
2979 dev
->chiprev
= get_idx_reg (dev
->regs
, REG_CHIPREV
) & 0xffff;
2982 INFO (dev
, "%s\n", driver_desc
);
2983 INFO (dev
, "irq %d, pci mem %p, chip rev %04x\n",
2984 pdev
->irq
, base
, dev
->chiprev
);
2985 INFO (dev
, "version: " DRIVER_VERSION
"; dma %s\n",
2987 ? (use_dma_chaining
? "chaining" : "enabled")
2989 the_controller
= dev
;
2991 retval
= device_register (&dev
->gadget
.dev
);
2992 if (retval
) goto done
;
2993 retval
= device_create_file (&pdev
->dev
, &dev_attr_registers
);
2994 if (retval
) goto done
;
3000 net2280_remove (pdev
);
3004 /* make sure the board is quiescent; otherwise it will continue
3005 * generating IRQs across the upcoming reboot.
3008 static void net2280_shutdown (struct pci_dev
*pdev
)
3010 struct net2280
*dev
= pci_get_drvdata (pdev
);
3013 writel (0, &dev
->regs
->pciirqenb0
);
3014 writel (0, &dev
->regs
->pciirqenb1
);
3016 /* disable the pullup so the host will think we're gone */
3017 writel (0, &dev
->usb
->usbctl
);
3021 /*-------------------------------------------------------------------------*/
3023 static const struct pci_device_id pci_ids
[] = { {
3024 .class = ((PCI_CLASS_SERIAL_USB
<< 8) | 0xfe),
3028 .subvendor
= PCI_ANY_ID
,
3029 .subdevice
= PCI_ANY_ID
,
3031 .class = ((PCI_CLASS_SERIAL_USB
<< 8) | 0xfe),
3035 .subvendor
= PCI_ANY_ID
,
3036 .subdevice
= PCI_ANY_ID
,
3038 }, { /* end: all zeroes */ }
3040 MODULE_DEVICE_TABLE (pci
, pci_ids
);
3042 /* pci driver glue; this is a "new style" PCI driver module */
3043 static struct pci_driver net2280_pci_driver
= {
3044 .name
= (char *) driver_name
,
3045 .id_table
= pci_ids
,
3047 .probe
= net2280_probe
,
3048 .remove
= net2280_remove
,
3049 .shutdown
= net2280_shutdown
,
3051 /* FIXME add power management support */
3054 MODULE_DESCRIPTION (DRIVER_DESC
);
3055 MODULE_AUTHOR ("David Brownell");
3056 MODULE_LICENSE ("GPL");
3058 static int __init
init (void)
3061 use_dma_chaining
= 0;
3062 return pci_register_driver (&net2280_pci_driver
);
3066 static void __exit
cleanup (void)
3068 pci_unregister_driver (&net2280_pci_driver
);
3070 module_exit (cleanup
);