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, value: 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, value: 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(epd: 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, value: max & 0xff);
203	net2272_ep_write(ep, EP_MAXPKT1, value: (max & 0xff00) >> 8);
204
205	/* set type, direction, address; reset fifo counters */
206	net2272_ep_write(ep, EP_STAT1, value: 1 << BUFFER_FLUSH);
207	tmp = usb_endpoint_type(epd: desc);
208	if (usb_endpoint_xfer_bulk(epd: 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(lock: &dev->lock, flags);
213	return -ERANGE;
214	}
215	}
216	ep->is_iso = usb_endpoint_xfer_isoc(epd: desc) ? 1 : 0;
217	tmp <<= ENDPOINT_TYPE;
218	tmp |= ((desc->bEndpointAddress & 0x0f) << ENDPOINT_NUMBER);
219	tmp |= usb_endpoint_dir_in(epd: 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(epd: desc);
224	if (!ep->is_in)
225	net2272_ep_write(ep, EP_RSPSET, value: 1 << ALT_NAK_OUT_PACKETS);
226
227	net2272_ep_write(ep, EP_CFG, value: tmp);
228
229	/* enable irqs */
230	tmp = (1 << ep->num) | net2272_read(dev, IRQENB0);
231	net2272_write(dev, IRQENB0, value: 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, value: 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(lock: &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(list: &ep->queue);
254
255	usb_ep_set_maxpacket_limit(ep: &ep->ep, maxpacket_limit: ~0);
256	ep->ep.ops = &net2272_ep_ops;
257
258	/* disable irqs, endpoint */
259	net2272_ep_write(ep, EP_IRQENB, value: 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, value: 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, value: tmp);
272
273	/* scrub most status bits, and flush any fifo state */
274	net2272_ep_write(ep, EP_STAT0,
275	value: (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	value: (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(lock: &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(size: sizeof(*req), flags: gfp_flags);
324	if (!req)
325	return NULL;
326
327	INIT_LIST_HEAD(list: &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(objp: 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(entry: &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(gadget: &dev->gadget, req: &req->req,
369	is_in: 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(lock: &dev->lock);
379	usb_gadget_giveback_request(ep: &ep->ep, req: &req->req);
380	spin_lock(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(dev: 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(val: *bufp++, addr: 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(dev: ep->dev, LOCCTL);
413	net2272_write(dev: ep->dev, LOCCTL, value: tmp & ~(1 << DATA_WIDTH));
414	writeb(val: *buf, addr: ep_data);
415	net2272_write(dev: ep->dev, LOCCTL, value: 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, value: (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, count: 0);
462	net2272_done(ep, req, status: 0);
463
464	if (!list_empty(head: &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, value: (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, value: (1 << DATA_OUT_TOKEN_INTERRUPT)
488	| (1 << DATA_PACKET_RECEIVED_INTERRUPT));
489	net2272_ep_write(ep, EP_STAT1, value: 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(dev: 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(addr: 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(addr: 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(x: 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	value: (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, avail: 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, status: -EOVERFLOW);
579	} else
580	net2272_done(ep, req, status: 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, value: 0);
588	net2272_ep_write(ep, EP_TRANSFER1, value: 0);
589	net2272_ep_write(ep, EP_TRANSFER0, value: 0);
590	}
591
592	if (!list_empty(head: &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(val: (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	addr: dev->rdk1.plx9054_base_addr + DMAMODE0);
657
658	writel(val: 0x100000, addr: dev->rdk1.plx9054_base_addr + DMALADR0);
659	writel(val: buf, addr: dev->rdk1.plx9054_base_addr + DMAPADR0);
660	writel(val: len, addr: dev->rdk1.plx9054_base_addr + DMASIZ0);
661	writel(val: (dir << DIRECTION_OF_TRANSFER) |
662	(1 << INTERRUPT_AFTER_TERMINAL_COUNT),
663	addr: dev->rdk1.plx9054_base_addr + DMADPR0);
664	writel(val: (1 << LOCAL_DMA_CHANNEL_0_INTERRUPT_ENABLE) |
665	readl(addr: dev->rdk1.plx9054_base_addr + INTCSR),
666	addr: dev->rdk1.plx9054_base_addr + INTCSR);
667
668	break;
669	}
670	#endif
671
672	net2272_write(dev, DMAREQ,
673	value: (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(val: (1 << CHANNEL_ENABLE) | (1 << CHANNEL_START),
694	addr: 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, value: 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(dev: ep->dev, ep: ep->num, buf: req->req.dma, len: size, dir: 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(dev: ep->dev, ep: ep->num, buf: req->req.dma, len: size, dir: 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, value: 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(dev: ep->dev, DMAREQ,
764	value: (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, value: 0);
778
779	net2272_start_dma(dev: 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(val: 0, addr: dev->rdk1.plx9054_base_addr + DMACSR0);
790	writeb(val: 1 << CHANNEL_ABORT, addr: dev->rdk1.plx9054_base_addr + DMACSR0);
791	while (!(readb(addr: 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(val: 1 << CHANNEL_CLEAR_INTERRUPT,
797	addr: 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(head: &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(gadget: &dev->gadget, req: _req,
831	is_in: 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(head: &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, status: 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, value: (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(new: &req->queue, head: &ep->queue);
898
899	if (likely(!list_empty(&ep->queue)))
900	net2272_ep_write(ep, EP_RSPCLR, value: 1 << ALT_NAK_OUT_PACKETS);
901	done:
902	spin_unlock_irqrestore(lock: &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(head: &ep->queue)) {
917	req = list_entry(ep->queue.next,
918	struct net2272_request,
919	queue);
920	net2272_done(ep, req, status: -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(lock: &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, status: -ECONNRESET);
958	}
959	ep->stopped = stopped;
960
961	spin_unlock_irqrestore(lock: &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(epd: ep->desc))
980	return -EINVAL;
981
982	spin_lock_irqsave(&ep->dev->lock, flags);
983	if (!list_empty(head: &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(lock: &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, wedged: 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, value: 1, wedged: 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, value: 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(lock: &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, value: (1 << GENERATE_RESUME));
1110
1111	spin_unlock_irqrestore(lock: &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, value: tmp);
1146	spin_unlock_irqrestore(lock: &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: _dev);
1180	next = buf;
1181	size = PAGE_SIZE;
1182	spin_lock_irqsave(&dev->lock, flags);
1183
1184	/* Main Control Registers */
1185	t = scnprintf(buf: next, size, fmt: "%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(buf: next, size, fmt: "\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(buf: next, size,
1221	fmt: "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(buf: next, size,
1238	fmt: "\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(buf: next, size,
1254	fmt: "\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(bmAttributes: t1 >> 5),
1262	ep->stopped ? "*" : "");
1263	size -= t;
1264	next += t;
1265
1266	t = scnprintf(buf: next, size,
1267	fmt: "\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(buf: next, size,
1277	fmt: "\tbuf-a %s buf-b %s\n",
1278	buf_state_string(state: t1),
1279	buf_state_string(state: t2));
1280	size -= t;
1281	next += t;
1282	}
1283
1284	spin_unlock_irqrestore(lock: &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, value: tmp);
1300
1301	INIT_LIST_HEAD(list: &dev->gadget.ep_list);
1302
1303	/* always ep-a, ep-c ... maybe not ep-b */
1304	list_add_tail(new: &dev->ep[1].ep.ep_list, head: &dev->gadget.ep_list);
1305
1306	switch (mode) {
1307	case 0:
1308	list_add_tail(new: &dev->ep[2].ep.ep_list, head: &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(new: &dev->ep[2].ep.ep_list, head: &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(new: &dev->ep[2].ep.ep_list, head: &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(new: &dev->ep[3].ep.ep_list, head: &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, value: 0);
1340	net2272_write(dev, IRQENB1, value: 0);
1341
1342	/* clear irq state */
1343	net2272_write(dev, IRQSTAT0, value: 0xff);
1344	net2272_write(dev, IRQSTAT1, value: ~(1 << SUSPEND_REQUEST_INTERRUPT));
1345
1346	net2272_write(dev, DMAREQ,
1347	value: (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, mode: (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, value: net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH));
1363	net2272_write(dev, LOCCTL1, value: (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(ep: &dev->ep[0].ep, maxpacket_limit: 64);
1401
1402	dev->gadget.ep0 = &dev->ep[0].ep;
1403	dev->ep[0].stopped = 0;
1404	INIT_LIST_HEAD(list: &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(ep: ep0, EP_RSPSET,
1413	value: (1 << NAK_OUT_PACKETS_MODE) |
1414	(1 << ALT_NAK_OUT_PACKETS));
1415	net2272_ep_write(ep: ep0, EP_RSPCLR,
1416	value: (1 << HIDE_STATUS_PHASE) |
1417	(1 << CONTROL_STATUS_PHASE_HANDSHAKE));
1418	net2272_write(dev, USBCTL0,
1419	value: (dev->softconnect << USB_DETECT_ENABLE) |
1420	(1 << USB_ROOT_PORT_WAKEUP_ENABLE) |
1421	(1 << IO_WAKEUP_ENABLE));
1422	net2272_write(dev, IRQENB0,
1423	value: (1 << SETUP_PACKET_INTERRUPT_ENABLE) |
1424	(1 << ENDPOINT_0_INTERRUPT_ENABLE) |
1425	(1 << DMA_DONE_INTERRUPT_ENABLE));
1426	net2272_write(dev, IRQENB1,
1427	value: (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	dev->driver = driver;
1455
1456	/* ... then enable host detection and ep0; and we're ready
1457	* for set_configuration as well as eventual disconnect.
1458	*/
1459	net2272_ep0_start(dev);
1460
1461	return 0;
1462	}
1463
1464	static void
1465	stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1466	{
1467	int i;
1468
1469	/* don't disconnect if it's not connected */
1470	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1471	driver = NULL;
1472
1473	/* stop hardware; prevent new request submissions;
1474	* and kill any outstanding requests.
1475	*/
1476	net2272_usb_reset(dev);
1477	for (i = 0; i < 4; ++i)
1478	net2272_dequeue_all(ep: &dev->ep[i]);
1479
1480	/* report disconnect; the driver is already quiesced */
1481	if (dev->async_callbacks && driver) {
1482	spin_unlock(lock: &dev->lock);
1483	driver->disconnect(&dev->gadget);
1484	spin_lock(lock: &dev->lock);
1485	}
1486
1487	net2272_usb_reinit(dev);
1488	}
1489
1490	static int net2272_stop(struct usb_gadget *_gadget)
1491	{
1492	struct net2272 *dev;
1493	unsigned long flags;
1494
1495	dev = container_of(_gadget, struct net2272, gadget);
1496
1497	spin_lock_irqsave(&dev->lock, flags);
1498	stop_activity(dev, NULL);
1499	spin_unlock_irqrestore(lock: &dev->lock, flags);
1500
1501	dev->driver = NULL;
1502
1503	return 0;
1504	}
1505
1506	static void net2272_async_callbacks(struct usb_gadget *_gadget, bool enable)
1507	{
1508	struct net2272 *dev = container_of(_gadget, struct net2272, gadget);
1509
1510	spin_lock_irq(lock: &dev->lock);
1511	dev->async_callbacks = enable;
1512	spin_unlock_irq(lock: &dev->lock);
1513	}
1514
1515	/*---------------------------------------------------------------------------*/
1516	/* handle ep-a/ep-b dma completions */
1517	static void
1518	net2272_handle_dma(struct net2272_ep *ep)
1519	{
1520	struct net2272_request *req;
1521	unsigned len;
1522	int status;
1523
1524	if (!list_empty(head: &ep->queue))
1525	req = list_entry(ep->queue.next,
1526	struct net2272_request, queue);
1527	else
1528	req = NULL;
1529
1530	dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req);
1531
1532	/* Ensure DREQ is de-asserted */
1533	net2272_write(dev: ep->dev, DMAREQ,
1534	value: (0 << DMA_BUFFER_VALID)
1535	| (0 << DMA_REQUEST_ENABLE)
1536	| (1 << DMA_CONTROL_DACK)
1537	| (ep->dev->dma_eot_polarity << EOT_POLARITY)
1538	| (ep->dev->dma_dack_polarity << DACK_POLARITY)
1539	| (ep->dev->dma_dreq_polarity << DREQ_POLARITY)
1540	| (ep->dma << DMA_ENDPOINT_SELECT));
1541
1542	ep->dev->dma_busy = 0;
1543
1544	net2272_ep_write(ep, EP_IRQENB,
1545	value: (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1546	| (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1547	| net2272_ep_read(ep, EP_IRQENB));
1548
1549	/* device-to-host transfer completed */
1550	if (ep->is_in) {
1551	/* validate a short packet or zlp if necessary */
1552	if ((req->req.length % ep->ep.maxpacket != 0) ||
1553	req->req.zero)
1554	set_fifo_bytecount(ep, count: 0);
1555
1556	net2272_done(ep, req, status: 0);
1557	if (!list_empty(head: &ep->queue)) {
1558	req = list_entry(ep->queue.next,
1559	struct net2272_request, queue);
1560	status = net2272_kick_dma(ep, req);
1561	if (status < 0)
1562	net2272_pio_advance(ep);
1563	}
1564
1565	/* host-to-device transfer completed */
1566	} else {
1567	/* terminated with a short packet? */
1568	if (net2272_read(dev: ep->dev, IRQSTAT0) &
1569	(1 << DMA_DONE_INTERRUPT)) {
1570	/* abort system dma */
1571	net2272_cancel_dma(dev: ep->dev);
1572	}
1573
1574	/* EP_TRANSFER will contain the number of bytes
1575	* actually received.
1576	* NOTE: There is no overflow detection on EP_TRANSFER:
1577	* We can't deal with transfers larger than 2^24 bytes!
1578	*/
1579	len = (net2272_ep_read(ep, EP_TRANSFER2) << 16)
1580	| (net2272_ep_read(ep, EP_TRANSFER1) << 8)
1581	| (net2272_ep_read(ep, EP_TRANSFER0));
1582
1583	if (ep->not_empty)
1584	len += 4;
1585
1586	req->req.actual += len;
1587
1588	/* get any remaining data */
1589	net2272_pio_advance(ep);
1590	}
1591	}
1592
1593	/*---------------------------------------------------------------------------*/
1594
1595	static void
1596	net2272_handle_ep(struct net2272_ep *ep)
1597	{
1598	struct net2272_request *req;
1599	u8 stat0, stat1;
1600
1601	if (!list_empty(head: &ep->queue))
1602	req = list_entry(ep->queue.next,
1603	struct net2272_request, queue);
1604	else
1605	req = NULL;
1606
1607	/* ack all, and handle what we care about */
1608	stat0 = net2272_ep_read(ep, EP_STAT0);
1609	stat1 = net2272_ep_read(ep, EP_STAT1);
1610	ep->irqs++;
1611
1612	dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n",
1613	ep->ep.name, stat0, stat1, req ? &req->req : NULL);
1614
1615	net2272_ep_write(ep, EP_STAT0, value: stat0 &
1616	~((1 << NAK_OUT_PACKETS)
1617	| (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)));
1618	net2272_ep_write(ep, EP_STAT1, value: stat1);
1619
1620	/* data packet(s) received (in the fifo, OUT)
1621	* direction must be validated, otherwise control read status phase
1622	* could be interpreted as a valid packet
1623	*/
1624	if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT)))
1625	net2272_pio_advance(ep);
1626	/* data packet(s) transmitted (IN) */
1627	else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))
1628	net2272_pio_advance(ep);
1629	}
1630
1631	static struct net2272_ep *
1632	net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex)
1633	{
1634	struct net2272_ep *ep;
1635
1636	if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
1637	return &dev->ep[0];
1638
1639	list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1640	u8 bEndpointAddress;
1641
1642	if (!ep->desc)
1643	continue;
1644	bEndpointAddress = ep->desc->bEndpointAddress;
1645	if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
1646	continue;
1647	if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
1648	return ep;
1649	}
1650	return NULL;
1651	}
1652
1653	/*
1654	* USB Test Packet:
1655	* JKJKJKJK * 9
1656	* JJKKJJKK * 8
1657	* JJJJKKKK * 8
1658	* JJJJJJJKKKKKKK * 8
1659	* JJJJJJJK * 8
1660	* {JKKKKKKK * 10}, JK
1661	*/
1662	static const u8 net2272_test_packet[] = {
1663	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1664	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1665	0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1666	0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1667	0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1668	0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E
1669	};
1670
1671	static void
1672	net2272_set_test_mode(struct net2272 *dev, int mode)
1673	{
1674	int i;
1675
1676	/* Disable all net2272 interrupts:
1677	* Nothing but a power cycle should stop the test.
1678	*/
1679	net2272_write(dev, IRQENB0, value: 0x00);
1680	net2272_write(dev, IRQENB1, value: 0x00);
1681
1682	/* Force tranceiver to high-speed */
1683	net2272_write(dev, XCVRDIAG, value: 1 << FORCE_HIGH_SPEED);
1684
1685	net2272_write(dev, PAGESEL, value: 0);
1686	net2272_write(dev, EP_STAT0, value: 1 << DATA_PACKET_TRANSMITTED_INTERRUPT);
1687	net2272_write(dev, EP_RSPCLR,
1688	value: (1 << CONTROL_STATUS_PHASE_HANDSHAKE)
1689	| (1 << HIDE_STATUS_PHASE));
1690	net2272_write(dev, EP_CFG, value: 1 << ENDPOINT_DIRECTION);
1691	net2272_write(dev, EP_STAT1, value: 1 << BUFFER_FLUSH);
1692
1693	/* wait for status phase to complete */
1694	while (!(net2272_read(dev, EP_STAT0) &
1695	(1 << DATA_PACKET_TRANSMITTED_INTERRUPT)))
1696	;
1697
1698	/* Enable test mode */
1699	net2272_write(dev, USBTEST, value: mode);
1700
1701	/* load test packet */
1702	if (mode == USB_TEST_PACKET) {
1703	/* switch to 8 bit mode */
1704	net2272_write(dev, LOCCTL, value: net2272_read(dev, LOCCTL) &
1705	~(1 << DATA_WIDTH));
1706
1707	for (i = 0; i < sizeof(net2272_test_packet); ++i)
1708	net2272_write(dev, EP_DATA, value: net2272_test_packet[i]);
1709
1710	/* Validate test packet */
1711	net2272_write(dev, EP_TRANSFER0, value: 0);
1712	}
1713	}
1714
1715	static void
1716	net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat)
1717	{
1718	struct net2272_ep *ep;
1719	u8 num, scratch;
1720
1721	/* starting a control request? */
1722	if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) {
1723	union {
1724	u8 raw[8];
1725	struct usb_ctrlrequest r;
1726	} u;
1727	int tmp = 0;
1728	struct net2272_request *req;
1729
1730	if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
1731	if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED))
1732	dev->gadget.speed = USB_SPEED_HIGH;
1733	else
1734	dev->gadget.speed = USB_SPEED_FULL;
1735	dev_dbg(dev->dev, "%s\n",
1736	usb_speed_string(dev->gadget.speed));
1737	}
1738
1739	ep = &dev->ep[0];
1740	ep->irqs++;
1741
1742	/* make sure any leftover interrupt state is cleared */
1743	stat &= ~(1 << ENDPOINT_0_INTERRUPT);
1744	while (!list_empty(head: &ep->queue)) {
1745	req = list_entry(ep->queue.next,
1746	struct net2272_request, queue);
1747	net2272_done(ep, req,
1748	status: (req->req.actual == req->req.length) ? 0 : -EPROTO);
1749	}
1750	ep->stopped = 0;
1751	dev->protocol_stall = 0;
1752	net2272_ep_write(ep, EP_STAT0,
1753	value: (1 << DATA_IN_TOKEN_INTERRUPT)
1754	| (1 << DATA_OUT_TOKEN_INTERRUPT)
1755	| (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
1756	| (1 << DATA_PACKET_RECEIVED_INTERRUPT)
1757	| (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
1758	net2272_ep_write(ep, EP_STAT1,
1759	value: (1 << TIMEOUT)
1760	| (1 << USB_OUT_ACK_SENT)
1761	| (1 << USB_OUT_NAK_SENT)
1762	| (1 << USB_IN_ACK_RCVD)
1763	| (1 << USB_IN_NAK_SENT)
1764	| (1 << USB_STALL_SENT)
1765	| (1 << LOCAL_OUT_ZLP));
1766
1767	/*
1768	* Ensure Control Read pre-validation setting is beyond maximum size
1769	* - Control Writes can leave non-zero values in EP_TRANSFER. If
1770	* an EP0 transfer following the Control Write is a Control Read,
1771	* the NET2272 sees the non-zero EP_TRANSFER as an unexpected
1772	* pre-validation count.
1773	* - Setting EP_TRANSFER beyond the maximum EP0 transfer size ensures
1774	* the pre-validation count cannot cause an unexpected validatation
1775	*/
1776	net2272_write(dev, PAGESEL, value: 0);
1777	net2272_write(dev, EP_TRANSFER2, value: 0xff);
1778	net2272_write(dev, EP_TRANSFER1, value: 0xff);
1779	net2272_write(dev, EP_TRANSFER0, value: 0xff);
1780
1781	u.raw[0] = net2272_read(dev, SETUP0);
1782	u.raw[1] = net2272_read(dev, SETUP1);
1783	u.raw[2] = net2272_read(dev, SETUP2);
1784	u.raw[3] = net2272_read(dev, SETUP3);
1785	u.raw[4] = net2272_read(dev, SETUP4);
1786	u.raw[5] = net2272_read(dev, SETUP5);
1787	u.raw[6] = net2272_read(dev, SETUP6);
1788	u.raw[7] = net2272_read(dev, SETUP7);
1789	/*
1790	* If you have a big endian cpu make sure le16_to_cpus
1791	* performs the proper byte swapping here...
1792	*/
1793	le16_to_cpus(&u.r.wValue);
1794	le16_to_cpus(&u.r.wIndex);
1795	le16_to_cpus(&u.r.wLength);
1796
1797	/* ack the irq */
1798	net2272_write(dev, IRQSTAT0, value: 1 << SETUP_PACKET_INTERRUPT);
1799	stat ^= (1 << SETUP_PACKET_INTERRUPT);
1800
1801	/* watch control traffic at the token level, and force
1802	* synchronization before letting the status phase happen.
1803	*/
1804	ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
1805	if (ep->is_in) {
1806	scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1807	| (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1808	| (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1809	stop_out_naking(ep);
1810	} else
1811	scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1812	| (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1813	| (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1814	net2272_ep_write(ep, EP_IRQENB, value: scratch);
1815
1816	if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
1817	goto delegate;
1818	switch (u.r.bRequest) {
1819	case USB_REQ_GET_STATUS: {
1820	struct net2272_ep *e;
1821	u16 status = 0;
1822
1823	switch (u.r.bRequestType & USB_RECIP_MASK) {
1824	case USB_RECIP_ENDPOINT:
1825	e = net2272_get_ep_by_addr(dev, wIndex: u.r.wIndex);
1826	if (!e || u.r.wLength > 2)
1827	goto do_stall;
1828	if (net2272_ep_read(ep: e, EP_RSPSET) & (1 << ENDPOINT_HALT))
1829	status = cpu_to_le16(1);
1830	else
1831	status = cpu_to_le16(0);
1832
1833	/* don't bother with a request object! */
1834	net2272_ep_write(ep: &dev->ep[0], EP_IRQENB, value: 0);
1835	writew(val: status, addr: net2272_reg_addr(dev, EP_DATA));
1836	set_fifo_bytecount(ep: &dev->ep[0], count: 0);
1837	allow_status(ep);
1838	dev_vdbg(dev->dev, "%s stat %02x\n",
1839	ep->ep.name, status);
1840	goto next_endpoints;
1841	case USB_RECIP_DEVICE:
1842	if (u.r.wLength > 2)
1843	goto do_stall;
1844	if (dev->gadget.is_selfpowered)
1845	status = (1 << USB_DEVICE_SELF_POWERED);
1846
1847	/* don't bother with a request object! */
1848	net2272_ep_write(ep: &dev->ep[0], EP_IRQENB, value: 0);
1849	writew(val: status, addr: net2272_reg_addr(dev, EP_DATA));
1850	set_fifo_bytecount(ep: &dev->ep[0], count: 0);
1851	allow_status(ep);
1852	dev_vdbg(dev->dev, "device stat %02x\n", status);
1853	goto next_endpoints;
1854	case USB_RECIP_INTERFACE:
1855	if (u.r.wLength > 2)
1856	goto do_stall;
1857
1858	/* don't bother with a request object! */
1859	net2272_ep_write(ep: &dev->ep[0], EP_IRQENB, value: 0);
1860	writew(val: status, addr: net2272_reg_addr(dev, EP_DATA));
1861	set_fifo_bytecount(ep: &dev->ep[0], count: 0);
1862	allow_status(ep);
1863	dev_vdbg(dev->dev, "interface status %02x\n", status);
1864	goto next_endpoints;
1865	}
1866
1867	break;
1868	}
1869	case USB_REQ_CLEAR_FEATURE: {
1870	struct net2272_ep *e;
1871
1872	if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1873	goto delegate;
1874	if (u.r.wValue != USB_ENDPOINT_HALT ||
1875	u.r.wLength != 0)
1876	goto do_stall;
1877	e = net2272_get_ep_by_addr(dev, wIndex: u.r.wIndex);
1878	if (!e)
1879	goto do_stall;
1880	if (e->wedged) {
1881	dev_vdbg(dev->dev, "%s wedged, halt not cleared\n",
1882	ep->ep.name);
1883	} else {
1884	dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name);
1885	clear_halt(ep: e);
1886	}
1887	allow_status(ep);
1888	goto next_endpoints;
1889	}
1890	case USB_REQ_SET_FEATURE: {
1891	struct net2272_ep *e;
1892
1893	if (u.r.bRequestType == USB_RECIP_DEVICE) {
1894	if (u.r.wIndex != NORMAL_OPERATION)
1895	net2272_set_test_mode(dev, mode: (u.r.wIndex >> 8));
1896	allow_status(ep);
1897	dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex);
1898	goto next_endpoints;
1899	} else if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1900	goto delegate;
1901	if (u.r.wValue != USB_ENDPOINT_HALT ||
1902	u.r.wLength != 0)
1903	goto do_stall;
1904	e = net2272_get_ep_by_addr(dev, wIndex: u.r.wIndex);
1905	if (!e)
1906	goto do_stall;
1907	set_halt(e);
1908	allow_status(ep);
1909	dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name);
1910	goto next_endpoints;
1911	}
1912	case USB_REQ_SET_ADDRESS: {
1913	net2272_write(dev, OURADDR, value: u.r.wValue & 0xff);
1914	allow_status(ep);
1915	break;
1916	}
1917	default:
1918	delegate:
1919	dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x "
1920	"ep_cfg %08x\n",
1921	u.r.bRequestType, u.r.bRequest,
1922	u.r.wValue, u.r.wIndex,
1923	net2272_ep_read(ep, EP_CFG));
1924	if (dev->async_callbacks) {
1925	spin_unlock(lock: &dev->lock);
1926	tmp = dev->driver->setup(&dev->gadget, &u.r);
1927	spin_lock(lock: &dev->lock);
1928	}
1929	}
1930
1931	/* stall ep0 on error */
1932	if (tmp < 0) {
1933	do_stall:
1934	dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n",
1935	u.r.bRequestType, u.r.bRequest, tmp);
1936	dev->protocol_stall = 1;
1937	}
1938	/* endpoint dma irq? */
1939	} else if (stat & (1 << DMA_DONE_INTERRUPT)) {
1940	net2272_cancel_dma(dev);
1941	net2272_write(dev, IRQSTAT0, value: 1 << DMA_DONE_INTERRUPT);
1942	stat &= ~(1 << DMA_DONE_INTERRUPT);
1943	num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT))
1944	? 2 : 1;
1945
1946	ep = &dev->ep[num];
1947	net2272_handle_dma(ep);
1948	}
1949
1950	next_endpoints:
1951	/* endpoint data irq? */
1952	scratch = stat & 0x0f;
1953	stat &= ~0x0f;
1954	for (num = 0; scratch; num++) {
1955	u8 t;
1956
1957	/* does this endpoint's FIFO and queue need tending? */
1958	t = 1 << num;
1959	if ((scratch & t) == 0)
1960	continue;
1961	scratch ^= t;
1962
1963	ep = &dev->ep[num];
1964	net2272_handle_ep(ep);
1965	}
1966
1967	/* some interrupts we can just ignore */
1968	stat &= ~(1 << SOF_INTERRUPT);
1969
1970	if (stat)
1971	dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat);
1972	}
1973
1974	static void
1975	net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1976	{
1977	u8 tmp, mask;
1978
1979	/* after disconnect there's nothing else to do! */
1980	tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT);
1981	mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED);
1982
1983	if (stat & tmp) {
1984	bool reset = false;
1985	bool disconnect = false;
1986
1987	/*
1988	* Ignore disconnects and resets if the speed hasn't been set.
1989	* VBUS can bounce and there's always an initial reset.
1990	*/
1991	net2272_write(dev, IRQSTAT1, value: tmp);
1992	if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1993	if ((stat & (1 << VBUS_INTERRUPT)) &&
1994	(net2272_read(dev, USBCTL1) &
1995	(1 << VBUS_PIN)) == 0) {
1996	disconnect = true;
1997	dev_dbg(dev->dev, "disconnect %s\n",
1998	dev->driver->driver.name);
1999	} else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) &&
2000	(net2272_read(dev, USBCTL1) & mask)
2001	== 0) {
2002	reset = true;
2003	dev_dbg(dev->dev, "reset %s\n",
2004	dev->driver->driver.name);
2005	}
2006
2007	if (disconnect || reset) {
2008	stop_activity(dev, driver: dev->driver);
2009	net2272_ep0_start(dev);
2010	if (dev->async_callbacks) {
2011	spin_unlock(lock: &dev->lock);
2012	if (reset)
2013	usb_gadget_udc_reset(gadget: &dev->gadget, driver: dev->driver);
2014	else
2015	(dev->driver->disconnect)(&dev->gadget);
2016	spin_lock(lock: &dev->lock);
2017	}
2018	return;
2019	}
2020	}
2021	stat &= ~tmp;
2022
2023	if (!stat)
2024	return;
2025	}
2026
2027	tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
2028	if (stat & tmp) {
2029	net2272_write(dev, IRQSTAT1, value: tmp);
2030	if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
2031	if (dev->async_callbacks && dev->driver->suspend)
2032	dev->driver->suspend(&dev->gadget);
2033	if (!enable_suspend) {
2034	stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
2035	dev_dbg(dev->dev, "Suspend disabled, ignoring\n");
2036	}
2037	} else {
2038	if (dev->async_callbacks && dev->driver->resume)
2039	dev->driver->resume(&dev->gadget);
2040	}
2041	stat &= ~tmp;
2042	}
2043
2044	/* clear any other status/irqs */
2045	if (stat)
2046	net2272_write(dev, IRQSTAT1, value: stat);
2047
2048	/* some status we can just ignore */
2049	stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
2050	| (1 << SUSPEND_REQUEST_INTERRUPT)
2051	| (1 << RESUME_INTERRUPT));
2052	if (!stat)
2053	return;
2054	else
2055	dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat);
2056	}
2057
2058	static irqreturn_t net2272_irq(int irq, void *_dev)
2059	{
2060	struct net2272 *dev = _dev;
2061	#if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2)
2062	u32 intcsr;
2063	#endif
2064	#if defined(PLX_PCI_RDK)
2065	u8 dmareq;
2066	#endif
2067	spin_lock(lock: &dev->lock);
2068	#if defined(PLX_PCI_RDK)
2069	intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2070
2071	if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) {
2072	writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE),
2073	dev->rdk1.plx9054_base_addr + INTCSR);
2074	net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2075	net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2076	intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2077	writel(intcsr | (1 << PCI_INTERRUPT_ENABLE),
2078	dev->rdk1.plx9054_base_addr + INTCSR);
2079	}
2080	if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) {
2081	writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2082	dev->rdk1.plx9054_base_addr + DMACSR0);
2083
2084	dmareq = net2272_read(dev, DMAREQ);
2085	if (dmareq & 0x01)
2086	net2272_handle_dma(&dev->ep[2]);
2087	else
2088	net2272_handle_dma(&dev->ep[1]);
2089	}
2090	#endif
2091	#if defined(PLX_PCI_RDK2)
2092	/* see if PCI int for us by checking irqstat */
2093	intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT);
2094	if (!(intcsr & (1 << NET2272_PCI_IRQ))) {
2095	spin_unlock(&dev->lock);
2096	return IRQ_NONE;
2097	}
2098	/* check dma interrupts */
2099	#endif
2100	/* Platform/devcice interrupt handler */
2101	#if !defined(PLX_PCI_RDK)
2102	net2272_handle_stat1_irqs(dev, stat: net2272_read(dev, IRQSTAT1));
2103	net2272_handle_stat0_irqs(dev, stat: net2272_read(dev, IRQSTAT0));
2104	#endif
2105	spin_unlock(lock: &dev->lock);
2106
2107	return IRQ_HANDLED;
2108	}
2109
2110	static int net2272_present(struct net2272 *dev)
2111	{
2112	/*
2113	* Quick test to see if CPU can communicate properly with the NET2272.
2114	* Verifies connection using writes and reads to write/read and
2115	* read-only registers.
2116	*
2117	* This routine is strongly recommended especially during early bring-up
2118	* of new hardware, however for designs that do not apply Power On System
2119	* Tests (POST) it may discarded (or perhaps minimized).
2120	*/
2121	unsigned int ii;
2122	u8 val, refval;
2123
2124	/* Verify NET2272 write/read SCRATCH register can write and read */
2125	refval = net2272_read(dev, SCRATCH);
2126	for (ii = 0; ii < 0x100; ii += 7) {
2127	net2272_write(dev, SCRATCH, value: ii);
2128	val = net2272_read(dev, SCRATCH);
2129	if (val != ii) {
2130	dev_dbg(dev->dev,
2131	"%s: write/read SCRATCH register test failed: "
2132	"wrote:0x%2.2x, read:0x%2.2x\n",
2133	__func__, ii, val);
2134	return -EINVAL;
2135	}
2136	}
2137	/* To be nice, we write the original SCRATCH value back: */
2138	net2272_write(dev, SCRATCH, value: refval);
2139
2140	/* Verify NET2272 CHIPREV register is read-only: */
2141	refval = net2272_read(dev, CHIPREV_2272);
2142	for (ii = 0; ii < 0x100; ii += 7) {
2143	net2272_write(dev, CHIPREV_2272, value: ii);
2144	val = net2272_read(dev, CHIPREV_2272);
2145	if (val != refval) {
2146	dev_dbg(dev->dev,
2147	"%s: write/read CHIPREV register test failed: "
2148	"wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n",
2149	__func__, ii, val, refval);
2150	return -EINVAL;
2151	}
2152	}
2153
2154	/*
2155	* Verify NET2272's "NET2270 legacy revision" register
2156	* - NET2272 has two revision registers. The NET2270 legacy revision
2157	* register should read the same value, regardless of the NET2272
2158	* silicon revision. The legacy register applies to NET2270
2159	* firmware being applied to the NET2272.
2160	*/
2161	val = net2272_read(dev, CHIPREV_LEGACY);
2162	if (val != NET2270_LEGACY_REV) {
2163	/*
2164	* Unexpected legacy revision value
2165	* - Perhaps the chip is a NET2270?
2166	*/
2167	dev_dbg(dev->dev,
2168	"%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n"
2169	" - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n",
2170	__func__, NET2270_LEGACY_REV, val);
2171	return -EINVAL;
2172	}
2173
2174	/*
2175	* Verify NET2272 silicon revision
2176	* - This revision register is appropriate for the silicon version
2177	* of the NET2272
2178	*/
2179	val = net2272_read(dev, CHIPREV_2272);
2180	switch (val) {
2181	case CHIPREV_NET2272_R1:
2182	/*
2183	* NET2272 Rev 1 has DMA related errata:
2184	* - Newer silicon (Rev 1A or better) required
2185	*/
2186	dev_dbg(dev->dev,
2187	"%s: Rev 1 detected: newer silicon recommended for DMA support\n",
2188	__func__);
2189	break;
2190	case CHIPREV_NET2272_R1A:
2191	break;
2192	default:
2193	/* NET2272 silicon version *may* not work with this firmware */
2194	dev_dbg(dev->dev,
2195	"%s: unexpected silicon revision register value: "
2196	" CHIPREV_2272: 0x%2.2x\n",
2197	__func__, val);
2198	/*
2199	* Return Success, even though the chip rev is not an expected value
2200	* - Older, pre-built firmware can attempt to operate on newer silicon
2201	* - Often, new silicon is perfectly compatible
2202	*/
2203	}
2204
2205	/* Success: NET2272 checks out OK */
2206	return 0;
2207	}
2208
2209	static void
2210	net2272_gadget_release(struct device *_dev)
2211	{
2212	struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev);
2213
2214	kfree(objp: dev);
2215	}
2216
2217	/*---------------------------------------------------------------------------*/
2218
2219	static void
2220	net2272_remove(struct net2272 *dev)
2221	{
2222	if (dev->added)
2223	usb_del_gadget(gadget: &dev->gadget);
2224	free_irq(dev->irq, dev);
2225	iounmap(addr: dev->base_addr);
2226	device_remove_file(dev: dev->dev, attr: &dev_attr_registers);
2227
2228	dev_info(dev->dev, "unbind\n");
2229	}
2230
2231	static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq)
2232	{
2233	struct net2272 *ret;
2234
2235	if (!irq) {
2236	dev_dbg(dev, "No IRQ!\n");
2237	return ERR_PTR(error: -ENODEV);
2238	}
2239
2240	/* alloc, and start init */
2241	ret = kzalloc(size: sizeof(*ret), GFP_KERNEL);
2242	if (!ret)
2243	return ERR_PTR(error: -ENOMEM);
2244
2245	spin_lock_init(&ret->lock);
2246	ret->irq = irq;
2247	ret->dev = dev;
2248	ret->gadget.ops = &net2272_ops;
2249	ret->gadget.max_speed = USB_SPEED_HIGH;
2250
2251	/* the "gadget" abstracts/virtualizes the controller */
2252	ret->gadget.name = driver_name;
2253	usb_initialize_gadget(parent: dev, gadget: &ret->gadget, release: net2272_gadget_release);
2254
2255	return ret;
2256	}
2257
2258	static int
2259	net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2260	{
2261	int ret;
2262
2263	/* See if there... */
2264	if (net2272_present(dev)) {
2265	dev_warn(dev->dev, "2272 not found!\n");
2266	ret = -ENODEV;
2267	goto err;
2268	}
2269
2270	net2272_usb_reset(dev);
2271	net2272_usb_reinit(dev);
2272
2273	ret = request_irq(irq: dev->irq, handler: net2272_irq, flags: irqflags, name: driver_name, dev);
2274	if (ret) {
2275	dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2276	goto err;
2277	}
2278
2279	dev->chiprev = net2272_read(dev, CHIPREV_2272);
2280
2281	/* done */
2282	dev_info(dev->dev, "%s\n", driver_desc);
2283	dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2284	dev->irq, dev->base_addr, dev->chiprev,
2285	dma_mode_string());
2286	dev_info(dev->dev, "version: %s\n", driver_vers);
2287
2288	ret = device_create_file(device: dev->dev, entry: &dev_attr_registers);
2289	if (ret)
2290	goto err_irq;
2291
2292	ret = usb_add_gadget(gadget: &dev->gadget);
2293	if (ret)
2294	goto err_add_udc;
2295	dev->added = 1;
2296
2297	return 0;
2298
2299	err_add_udc:
2300	device_remove_file(dev: dev->dev, attr: &dev_attr_registers);
2301	err_irq:
2302	free_irq(dev->irq, dev);
2303	err:
2304	return ret;
2305	}
2306
2307	#ifdef CONFIG_USB_PCI
2308
2309	/*
2310	* wrap this driver around the specified device, but
2311	* don't respond over USB until a gadget driver binds to us
2312	*/
2313
2314	static int
2315	net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2316	{
2317	unsigned long resource, len, tmp;
2318	void __iomem *mem_mapped_addr[4];
2319	int ret, i;
2320
2321	/*
2322	* BAR 0 holds PLX 9054 config registers
2323	* BAR 1 is i/o memory; unused here
2324	* BAR 2 holds EPLD config registers
2325	* BAR 3 holds NET2272 registers
2326	*/
2327
2328	/* Find and map all address spaces */
2329	for (i = 0; i < 4; ++i) {
2330	if (i == 1)
2331	continue; /* BAR1 unused */
2332
2333	resource = pci_resource_start(pdev, i);
2334	len = pci_resource_len(pdev, i);
2335
2336	if (!request_mem_region(resource, len, driver_name)) {
2337	dev_dbg(dev->dev, "controller already in use\n");
2338	ret = -EBUSY;
2339	goto err;
2340	}
2341
2342	mem_mapped_addr[i] = ioremap(offset: resource, size: len);
2343	if (mem_mapped_addr[i] == NULL) {
2344	release_mem_region(resource, len);
2345	dev_dbg(dev->dev, "can't map memory\n");
2346	ret = -EFAULT;
2347	goto err;
2348	}
2349	}
2350
2351	dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2352	dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2353	dev->base_addr = mem_mapped_addr[3];
2354
2355	/* Set PLX 9054 bus width (16 bits) */
2356	tmp = readl(addr: dev->rdk1.plx9054_base_addr + LBRD1);
2357	writel(val: (tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2358	addr: dev->rdk1.plx9054_base_addr + LBRD1);
2359
2360	/* Enable PLX 9054 Interrupts */
2361	writel(readl(addr: dev->rdk1.plx9054_base_addr + INTCSR) |
2362	(1 << PCI_INTERRUPT_ENABLE) |
2363	(1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2364	addr: dev->rdk1.plx9054_base_addr + INTCSR);
2365
2366	writeb(val: (1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2367	addr: dev->rdk1.plx9054_base_addr + DMACSR0);
2368
2369	/* reset */
2370	writeb(val: (1 << EPLD_DMA_ENABLE) |
2371	(1 << DMA_CTL_DACK) |
2372	(1 << DMA_TIMEOUT_ENABLE) |
2373	(1 << USER) |
2374	(0 << MPX_MODE) |
2375	(1 << BUSWIDTH) |
2376	(1 << NET2272_RESET),
2377	addr: dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2378
2379	mb();
2380	writeb(readb(addr: dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2381	~(1 << NET2272_RESET),
2382	addr: dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2383	udelay(200);
2384
2385	return 0;
2386
2387	err:
2388	while (--i >= 0) {
2389	if (i == 1)
2390	continue; /* BAR1 unused */
2391	iounmap(addr: mem_mapped_addr[i]);
2392	release_mem_region(pci_resource_start(pdev, i),
2393	pci_resource_len(pdev, i));
2394	}
2395
2396	return ret;
2397	}
2398
2399	static int
2400	net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2401	{
2402	unsigned long resource, len;
2403	void __iomem *mem_mapped_addr[2];
2404	int ret, i;
2405
2406	/*
2407	* BAR 0 holds FGPA config registers
2408	* BAR 1 holds NET2272 registers
2409	*/
2410
2411	/* Find and map all address spaces, bar2-3 unused in rdk 2 */
2412	for (i = 0; i < 2; ++i) {
2413	resource = pci_resource_start(pdev, i);
2414	len = pci_resource_len(pdev, i);
2415
2416	if (!request_mem_region(resource, len, driver_name)) {
2417	dev_dbg(dev->dev, "controller already in use\n");
2418	ret = -EBUSY;
2419	goto err;
2420	}
2421
2422	mem_mapped_addr[i] = ioremap(offset: resource, size: len);
2423	if (mem_mapped_addr[i] == NULL) {
2424	release_mem_region(resource, len);
2425	dev_dbg(dev->dev, "can't map memory\n");
2426	ret = -EFAULT;
2427	goto err;
2428	}
2429	}
2430
2431	dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2432	dev->base_addr = mem_mapped_addr[1];
2433
2434	mb();
2435	/* Set 2272 bus width (16 bits) and reset */
2436	writel(val: (1 << CHIP_RESET), addr: dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2437	udelay(200);
2438	writel(val: (1 << BUS_WIDTH), addr: dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2439	/* Print fpga version number */
2440	dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2441	readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2442	/* Enable FPGA Interrupts */
2443	writel(val: (1 << NET2272_PCI_IRQ), addr: dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2444
2445	return 0;
2446
2447	err:
2448	while (--i >= 0) {
2449	iounmap(addr: mem_mapped_addr[i]);
2450	release_mem_region(pci_resource_start(pdev, i),
2451	pci_resource_len(pdev, i));
2452	}
2453
2454	return ret;
2455	}
2456
2457	static int
2458	net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2459	{
2460	struct net2272 *dev;
2461	int ret;
2462
2463	dev = net2272_probe_init(dev: &pdev->dev, irq: pdev->irq);
2464	if (IS_ERR(ptr: dev))
2465	return PTR_ERR(ptr: dev);
2466	dev->dev_id = pdev->device;
2467
2468	if (pci_enable_device(dev: pdev) < 0) {
2469	ret = -ENODEV;
2470	goto err_put;
2471	}
2472
2473	pci_set_master(dev: pdev);
2474
2475	switch (pdev->device) {
2476	case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2477	case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2478	default: BUG();
2479	}
2480	if (ret)
2481	goto err_pci;
2482
2483	ret = net2272_probe_fin(dev, irqflags: 0);
2484	if (ret)
2485	goto err_pci;
2486
2487	pci_set_drvdata(pdev, data: dev);
2488
2489	return 0;
2490
2491	err_pci:
2492	pci_disable_device(dev: pdev);
2493	err_put:
2494	usb_put_gadget(gadget: &dev->gadget);
2495
2496	return ret;
2497	}
2498
2499	static void
2500	net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2501	{
2502	int i;
2503
2504	/* disable PLX 9054 interrupts */
2505	writel(readl(addr: dev->rdk1.plx9054_base_addr + INTCSR) &
2506	~(1 << PCI_INTERRUPT_ENABLE),
2507	addr: dev->rdk1.plx9054_base_addr + INTCSR);
2508
2509	/* clean up resources allocated during probe() */
2510	iounmap(addr: dev->rdk1.plx9054_base_addr);
2511	iounmap(addr: dev->rdk1.epld_base_addr);
2512
2513	for (i = 0; i < 4; ++i) {
2514	if (i == 1)
2515	continue; /* BAR1 unused */
2516	release_mem_region(pci_resource_start(pdev, i),
2517	pci_resource_len(pdev, i));
2518	}
2519	}
2520
2521	static void
2522	net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2523	{
2524	int i;
2525
2526	/* disable fpga interrupts
2527	writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2528	~(1 << PCI_INTERRUPT_ENABLE),
2529	dev->rdk1.plx9054_base_addr + INTCSR);
2530	*/
2531
2532	/* clean up resources allocated during probe() */
2533	iounmap(addr: dev->rdk2.fpga_base_addr);
2534
2535	for (i = 0; i < 2; ++i)
2536	release_mem_region(pci_resource_start(pdev, i),
2537	pci_resource_len(pdev, i));
2538	}
2539
2540	static void
2541	net2272_pci_remove(struct pci_dev *pdev)
2542	{
2543	struct net2272 *dev = pci_get_drvdata(pdev);
2544
2545	net2272_remove(dev);
2546
2547	switch (pdev->device) {
2548	case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2549	case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2550	default: BUG();
2551	}
2552
2553	pci_disable_device(dev: pdev);
2554
2555	usb_put_gadget(gadget: &dev->gadget);
2556	}
2557
2558	/* Table of matching PCI IDs */
2559	static struct pci_device_id pci_ids[] = {
2560	{ /* RDK 1 card */
2561	.class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2562	.class_mask = 0,
2563	.vendor = PCI_VENDOR_ID_PLX,
2564	.device = PCI_DEVICE_ID_RDK1,
2565	.subvendor = PCI_ANY_ID,
2566	.subdevice = PCI_ANY_ID,
2567	},
2568	{ /* RDK 2 card */
2569	.class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2570	.class_mask = 0,
2571	.vendor = PCI_VENDOR_ID_PLX,
2572	.device = PCI_DEVICE_ID_RDK2,
2573	.subvendor = PCI_ANY_ID,
2574	.subdevice = PCI_ANY_ID,
2575	},
2576	{ }
2577	};
2578	MODULE_DEVICE_TABLE(pci, pci_ids);
2579
2580	static struct pci_driver net2272_pci_driver = {
2581	.name = driver_name,
2582	.id_table = pci_ids,
2583
2584	.probe = net2272_pci_probe,
2585	.remove = net2272_pci_remove,
2586	};
2587
2588	static int net2272_pci_register(void)
2589	{
2590	return pci_register_driver(&net2272_pci_driver);
2591	}
2592
2593	static void net2272_pci_unregister(void)
2594	{
2595	pci_unregister_driver(dev: &net2272_pci_driver);
2596	}
2597
2598	#else
2599	static inline int net2272_pci_register(void) { return 0; }
2600	static inline void net2272_pci_unregister(void) { }
2601	#endif
2602
2603	/*---------------------------------------------------------------------------*/
2604
2605	static int
2606	net2272_plat_probe(struct platform_device *pdev)
2607	{
2608	struct net2272 *dev;
2609	int ret;
2610	unsigned int irqflags;
2611	resource_size_t base, len;
2612	struct resource *iomem, *iomem_bus, *irq_res;
2613
2614	irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2615	iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2616	iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2617	if (!irq_res || !iomem) {
2618	dev_err(&pdev->dev, "must provide irq/base addr");
2619	return -EINVAL;
2620	}
2621
2622	dev = net2272_probe_init(dev: &pdev->dev, irq: irq_res->start);
2623	if (IS_ERR(ptr: dev))
2624	return PTR_ERR(ptr: dev);
2625
2626	irqflags = 0;
2627	if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2628	irqflags |= IRQF_TRIGGER_RISING;
2629	if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2630	irqflags |= IRQF_TRIGGER_FALLING;
2631	if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2632	irqflags |= IRQF_TRIGGER_HIGH;
2633	if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2634	irqflags |= IRQF_TRIGGER_LOW;
2635
2636	base = iomem->start;
2637	len = resource_size(res: iomem);
2638	if (iomem_bus)
2639	dev->base_shift = iomem_bus->start;
2640
2641	if (!request_mem_region(base, len, driver_name)) {
2642	dev_dbg(dev->dev, "get request memory region!\n");
2643	ret = -EBUSY;
2644	goto err;
2645	}
2646	dev->base_addr = ioremap(offset: base, size: len);
2647	if (!dev->base_addr) {
2648	dev_dbg(dev->dev, "can't map memory\n");
2649	ret = -EFAULT;
2650	goto err_req;
2651	}
2652
2653	ret = net2272_probe_fin(dev, irqflags);
2654	if (ret)
2655	goto err_io;
2656
2657	platform_set_drvdata(pdev, data: dev);
2658	dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2659	(net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2660
2661	return 0;
2662
2663	err_io:
2664	iounmap(addr: dev->base_addr);
2665	err_req:
2666	release_mem_region(base, len);
2667	err:
2668	usb_put_gadget(gadget: &dev->gadget);
2669
2670	return ret;
2671	}
2672
2673	static void
2674	net2272_plat_remove(struct platform_device *pdev)
2675	{
2676	struct net2272 *dev = platform_get_drvdata(pdev);
2677
2678	net2272_remove(dev);
2679
2680	release_mem_region(pdev->resource[0].start,
2681	resource_size(&pdev->resource[0]));
2682
2683	usb_put_gadget(gadget: &dev->gadget);
2684	}
2685
2686	static struct platform_driver net2272_plat_driver = {
2687	.probe = net2272_plat_probe,
2688	.remove_new = net2272_plat_remove,
2689	.driver = {
2690	.name = driver_name,
2691	},
2692	/* FIXME .suspend, .resume */
2693	};
2694	MODULE_ALIAS("platform:net2272");
2695
2696	static int __init net2272_init(void)
2697	{
2698	int ret;
2699
2700	ret = net2272_pci_register();
2701	if (ret)
2702	return ret;
2703	ret = platform_driver_register(&net2272_plat_driver);
2704	if (ret)
2705	goto err_pci;
2706	return ret;
2707
2708	err_pci:
2709	net2272_pci_unregister();
2710	return ret;
2711	}
2712	module_init(net2272_init);
2713
2714	static void __exit net2272_cleanup(void)
2715	{
2716	net2272_pci_unregister();
2717	platform_driver_unregister(&net2272_plat_driver);
2718	}
2719	module_exit(net2272_cleanup);
2720
2721	MODULE_DESCRIPTION(DRIVER_DESC);
2722	MODULE_AUTHOR("PLX Technology, Inc.");
2723	MODULE_LICENSE("GPL");
2724