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