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