1/*
2 * NetChip 2280 high/full speed USB device controller.
3 * Unlike many such controllers, this one talks PCI.
4 */
5
6/*
7 * Copyright (C) 2002 NetChip Technology, Inc. (http://www.netchip.com)
8 * Copyright (C) 2003 David Brownell
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 */
24
25#include <linux/usb/net2280.h>
26
27/*-------------------------------------------------------------------------*/
28
29#ifdef	__KERNEL__
30
31/* indexed registers [11.10] are accessed indirectly
32 * caller must own the device lock.
33 */
34
35static inline u32
36get_idx_reg (struct net2280_regs __iomem *regs, u32 index)
37{
38	writel (index, &regs->idxaddr);
39	/* NOTE:  synchs device/cpu memory views */
40	return readl (&regs->idxdata);
41}
42
43static inline void
44set_idx_reg (struct net2280_regs __iomem *regs, u32 index, u32 value)
45{
46	writel (index, &regs->idxaddr);
47	writel (value, &regs->idxdata);
48	/* posted, may not be visible yet */
49}
50
51#endif	/* __KERNEL__ */
52
53
54#define REG_DIAG		0x0
55#define     RETRY_COUNTER                                       16
56#define     FORCE_PCI_SERR                                      11
57#define     FORCE_PCI_INTERRUPT                                 10
58#define     FORCE_USB_INTERRUPT                                 9
59#define     FORCE_CPU_INTERRUPT                                 8
60#define     ILLEGAL_BYTE_ENABLES                                5
61#define     FAST_TIMES                                          4
62#define     FORCE_RECEIVE_ERROR                                 2
63#define     FORCE_TRANSMIT_CRC_ERROR                            0
64#define REG_FRAME		0x02	/* from last sof */
65#define REG_CHIPREV		0x03	/* in bcd */
66#define	REG_HS_NAK_RATE		0x0a	/* NAK per N uframes */
67
68#define	CHIPREV_1	0x0100
69#define	CHIPREV_1A	0x0110
70
71#ifdef	__KERNEL__
72
73/* ep a-f highspeed and fullspeed maxpacket, addresses
74 * computed from ep->num
75 */
76#define REG_EP_MAXPKT(dev,num) (((num) + 1) * 0x10 + \
77		(((dev)->gadget.speed == USB_SPEED_HIGH) ? 0 : 1))
78
79/*-------------------------------------------------------------------------*/
80
81/* [8.3] for scatter/gather i/o
82 * use struct net2280_dma_regs bitfields
83 */
84struct net2280_dma {
85	__le32		dmacount;
86	__le32		dmaaddr;		/* the buffer */
87	__le32		dmadesc;		/* next dma descriptor */
88	__le32		_reserved;
89} __attribute__ ((aligned (16)));
90
91/*-------------------------------------------------------------------------*/
92
93/* DRIVER DATA STRUCTURES and UTILITIES */
94
95struct net2280_ep {
96	struct usb_ep				ep;
97	struct net2280_ep_regs			__iomem *regs;
98	struct net2280_dma_regs			__iomem *dma;
99	struct net2280_dma			*dummy;
100	dma_addr_t				td_dma;	/* of dummy */
101	struct net2280				*dev;
102	unsigned long				irqs;
103
104	/* analogous to a host-side qh */
105	struct list_head			queue;
106	const struct usb_endpoint_descriptor	*desc;
107	unsigned				num : 8,
108						fifo_size : 12,
109						in_fifo_validate : 1,
110						out_overflow : 1,
111						stopped : 1,
112						is_in : 1,
113						is_iso : 1,
114						responded : 1;
115};
116
117static inline void allow_status (struct net2280_ep *ep)
118{
119	/* ep0 only */
120	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
121		| (1 << CLEAR_NAK_OUT_PACKETS)
122		| (1 << CLEAR_NAK_OUT_PACKETS_MODE)
123		, &ep->regs->ep_rsp);
124	ep->stopped = 1;
125}
126
127/* count (<= 4) bytes in the next fifo write will be valid */
128static inline void set_fifo_bytecount (struct net2280_ep *ep, unsigned count)
129{
130	writeb (count, 2 + (u8 __iomem *) &ep->regs->ep_cfg);
131}
132
133struct net2280_request {
134	struct usb_request		req;
135	struct net2280_dma		*td;
136	dma_addr_t			td_dma;
137	struct list_head		queue;
138	unsigned			mapped : 1,
139					valid : 1;
140};
141
142struct net2280 {
143	/* each pci device provides one gadget, several endpoints */
144	struct usb_gadget		gadget;
145	spinlock_t			lock;
146	struct net2280_ep		ep [7];
147	struct usb_gadget_driver 	*driver;
148	unsigned			enabled : 1,
149					protocol_stall : 1,
150					softconnect : 1,
151					got_irq : 1,
152					region : 1;
153	u16				chiprev;
154
155	/* pci state used to access those endpoints */
156	struct pci_dev			*pdev;
157	struct net2280_regs		__iomem *regs;
158	struct net2280_usb_regs		__iomem *usb;
159	struct net2280_pci_regs		__iomem *pci;
160	struct net2280_dma_regs		__iomem *dma;
161	struct net2280_dep_regs		__iomem *dep;
162	struct net2280_ep_regs		__iomem *epregs;
163
164	struct pci_pool			*requests;
165	// statistics...
166};
167
168static inline void set_halt (struct net2280_ep *ep)
169{
170	/* ep0 and bulk/intr endpoints */
171	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
172		    /* set NAK_OUT for erratum 0114 */
173		| ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS)
174		| (1 << SET_ENDPOINT_HALT)
175		, &ep->regs->ep_rsp);
176}
177
178static inline void clear_halt (struct net2280_ep *ep)
179{
180	/* ep0 and bulk/intr endpoints */
181	writel (  (1 << CLEAR_ENDPOINT_HALT)
182		| (1 << CLEAR_ENDPOINT_TOGGLE)
183		| ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS)
184		, &ep->regs->ep_rsp);
185}
186
187#ifdef USE_RDK_LEDS
188
189static inline void net2280_led_init (struct net2280 *dev)
190{
191	/* LED3 (green) is on during USB activity. note erratum 0113. */
192	writel ((1 << GPIO3_LED_SELECT)
193		| (1 << GPIO3_OUTPUT_ENABLE)
194		| (1 << GPIO2_OUTPUT_ENABLE)
195		| (1 << GPIO1_OUTPUT_ENABLE)
196		| (1 << GPIO0_OUTPUT_ENABLE)
197		, &dev->regs->gpioctl);
198}
199
200/* indicate speed with bi-color LED 0/1 */
201static inline
202void net2280_led_speed (struct net2280 *dev, enum usb_device_speed speed)
203{
204	u32	val = readl (&dev->regs->gpioctl);
205	switch (speed) {
206	case USB_SPEED_HIGH:		/* green */
207		val &= ~(1 << GPIO0_DATA);
208		val |= (1 << GPIO1_DATA);
209		break;
210	case USB_SPEED_FULL:		/* red */
211		val &= ~(1 << GPIO1_DATA);
212		val |= (1 << GPIO0_DATA);
213		break;
214	default:			/* (off/black) */
215		val &= ~((1 << GPIO1_DATA) | (1 << GPIO0_DATA));
216		break;
217	}
218	writel (val, &dev->regs->gpioctl);
219}
220
221/* indicate power with LED 2 */
222static inline void net2280_led_active (struct net2280 *dev, int is_active)
223{
224	u32	val = readl (&dev->regs->gpioctl);
225
226	if (is_active)
227		val |= GPIO2_DATA;
228	else
229		val &= ~GPIO2_DATA;
230	writel (val, &dev->regs->gpioctl);
231}
232static inline void net2280_led_shutdown (struct net2280 *dev)
233{
234	/* turn off all four GPIO*_DATA bits */
235	writel (readl (&dev->regs->gpioctl) & ~0x0f,
236			&dev->regs->gpioctl);
237}
238
239#else
240
241#define net2280_led_init(dev)		do { } while (0)
242#define net2280_led_speed(dev, speed)	do { } while (0)
243#define net2280_led_shutdown(dev)	do { } while (0)
244
245#endif
246
247/*-------------------------------------------------------------------------*/
248
249#define xprintk(dev,level,fmt,args...) \
250	printk(level "%s %s: " fmt , driver_name , \
251			pci_name(dev->pdev) , ## args)
252
253#ifdef DEBUG
254#undef DEBUG
255#define DEBUG(dev,fmt,args...) \
256	xprintk(dev , KERN_DEBUG , fmt , ## args)
257#else
258#define DEBUG(dev,fmt,args...) \
259	do { } while (0)
260#endif /* DEBUG */
261
262#ifdef VERBOSE
263#define VDEBUG DEBUG
264#else
265#define VDEBUG(dev,fmt,args...) \
266	do { } while (0)
267#endif	/* VERBOSE */
268
269#define ERROR(dev,fmt,args...) \
270	xprintk(dev , KERN_ERR , fmt , ## args)
271#define WARN(dev,fmt,args...) \
272	xprintk(dev , KERN_WARNING , fmt , ## args)
273#define INFO(dev,fmt,args...) \
274	xprintk(dev , KERN_INFO , fmt , ## args)
275
276/*-------------------------------------------------------------------------*/
277
278static inline void start_out_naking (struct net2280_ep *ep)
279{
280	/* NOTE:  hardware races lurk here, and PING protocol issues */
281	writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
282	/* synch with device */
283	readl (&ep->regs->ep_rsp);
284}
285
286#ifdef DEBUG
287static inline void assert_out_naking (struct net2280_ep *ep, const char *where)
288{
289	u32	tmp = readl (&ep->regs->ep_stat);
290
291	if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
292		DEBUG (ep->dev, "%s %s %08x !NAK\n",
293				ep->ep.name, where, tmp);
294		writel ((1 << SET_NAK_OUT_PACKETS),
295			&ep->regs->ep_rsp);
296	}
297}
298#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__FUNCTION__)
299#else
300#define ASSERT_OUT_NAKING(ep) do {} while (0)
301#endif
302
303static inline void stop_out_naking (struct net2280_ep *ep)
304{
305	u32	tmp;
306
307	tmp = readl (&ep->regs->ep_stat);
308	if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
309		writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
310}
311
312#endif	/* __KERNEL__ */
313