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