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