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