drivers/usb/gadget/net2280.h - kernel/msm-4.9 - Gitiles

 /*
  * NetChip 2280 high/full speed USB device controller.
  * Unlike many such controllers, this one talks PCI.
  */

 /*
  * Copyright (C) 2002 NetChip Technology, Inc. (http://www.netchip.com)
  * Copyright (C) 2003 David Brownell
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include <linux/usb/net2280.h>

 /*-------------------------------------------------------------------------*/

 #ifdef	__KERNEL__

 /* indexed registers [11.10] are accessed indirectly
  * caller must own the device lock.
  */

 static inline u32
 get_idx_reg (struct net2280_regs __iomem *regs, u32 index)
 {
 	writel (index, &regs->idxaddr);
 	/* NOTE:  synchs device/cpu memory views */
 	return readl (&regs->idxdata);
 }

 static inline void
 set_idx_reg (struct net2280_regs __iomem *regs, u32 index, u32 value)
 {
 	writel (index, &regs->idxaddr);
 	writel (value, &regs->idxdata);
 	/* posted, may not be visible yet */
 }

 #endif	/* __KERNEL__ */


 #define REG_DIAG		0x0
 #define     RETRY_COUNTER                                       16
 #define     FORCE_PCI_SERR                                      11
 #define     FORCE_PCI_INTERRUPT                                 10
 #define     FORCE_USB_INTERRUPT                                 9
 #define     FORCE_CPU_INTERRUPT                                 8
 #define     ILLEGAL_BYTE_ENABLES                                5
 #define     FAST_TIMES                                          4
 #define     FORCE_RECEIVE_ERROR                                 2
 #define     FORCE_TRANSMIT_CRC_ERROR                            0
 #define REG_FRAME		0x02	/* from last sof */
 #define REG_CHIPREV		0x03	/* in bcd */
 #define	REG_HS_NAK_RATE		0x0a	/* NAK per N uframes */

 #define	CHIPREV_1	0x0100
 #define	CHIPREV_1A	0x0110

 #ifdef	__KERNEL__

 /* ep a-f highspeed and fullspeed maxpacket, addresses
  * computed from ep->num
  */
 #define REG_EP_MAXPKT(dev,num) (((num) + 1) * 0x10 + \
 		(((dev)->gadget.speed == USB_SPEED_HIGH) ? 0 : 1))

 /*-------------------------------------------------------------------------*/

 /* [8.3] for scatter/gather i/o
  * use struct net2280_dma_regs bitfields
  */
 struct net2280_dma {
 	__le32		dmacount;
 	__le32		dmaaddr;		/* the buffer */
 	__le32		dmadesc;		/* next dma descriptor */
 	__le32		_reserved;
 } __attribute__ ((aligned (16)));

 /*-------------------------------------------------------------------------*/

 /* DRIVER DATA STRUCTURES and UTILITIES */

 struct net2280_ep {
 	struct usb_ep				ep;
 	struct net2280_ep_regs			__iomem *regs;
 	struct net2280_dma_regs			__iomem *dma;
 	struct net2280_dma			*dummy;
 	dma_addr_t				td_dma;	/* of dummy */
 	struct net2280				*dev;
 	unsigned long				irqs;

 	/* analogous to a host-side qh */
 	struct list_head			queue;
 	const struct usb_endpoint_descriptor	*desc;
 	unsigned				num : 8,
 						fifo_size : 12,
 						in_fifo_validate : 1,
 						out_overflow : 1,
 						stopped : 1,
 						wedged : 1,
 						is_in : 1,
 						is_iso : 1,
 						responded : 1;
 };

 static inline void allow_status (struct net2280_ep *ep)
 {
 	/* ep0 only */
 	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
 		| (1 << CLEAR_NAK_OUT_PACKETS)
 		| (1 << CLEAR_NAK_OUT_PACKETS_MODE)
 		, &ep->regs->ep_rsp);
 	ep->stopped = 1;
 }

 /* count (<= 4) bytes in the next fifo write will be valid */
 static inline void set_fifo_bytecount (struct net2280_ep *ep, unsigned count)
 {
 	writeb (count, 2 + (u8 __iomem *) &ep->regs->ep_cfg);
 }

 struct net2280_request {
 	struct usb_request		req;
 	struct net2280_dma		*td;
 	dma_addr_t			td_dma;
 	struct list_head		queue;
 	unsigned			mapped : 1,
 					valid : 1;
 };

 struct net2280 {
 	/* each pci device provides one gadget, several endpoints */
 	struct usb_gadget		gadget;
 	spinlock_t			lock;
 	struct net2280_ep		ep [7];
 	struct usb_gadget_driver 	*driver;
 	unsigned			enabled : 1,
 					protocol_stall : 1,
 					softconnect : 1,
 					got_irq : 1,
 					region : 1;
 	u16				chiprev;

 	/* pci state used to access those endpoints */
 	struct pci_dev			*pdev;
 	struct net2280_regs		__iomem *regs;
 	struct net2280_usb_regs		__iomem *usb;
 	struct net2280_pci_regs		__iomem *pci;
 	struct net2280_dma_regs		__iomem *dma;
 	struct net2280_dep_regs		__iomem *dep;
 	struct net2280_ep_regs		__iomem *epregs;

 	struct pci_pool			*requests;
 	// statistics...
 };

 static inline void set_halt (struct net2280_ep *ep)
 {
 	/* ep0 and bulk/intr endpoints */
 	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
 		    /* set NAK_OUT for erratum 0114 */
 		| ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS)
 		| (1 << SET_ENDPOINT_HALT)
 		, &ep->regs->ep_rsp);
 }

 static inline void clear_halt (struct net2280_ep *ep)
 {
 	/* ep0 and bulk/intr endpoints */
 	writel (  (1 << CLEAR_ENDPOINT_HALT)
 		| (1 << CLEAR_ENDPOINT_TOGGLE)
 		    /* unless the gadget driver left a short packet in the
 		     * fifo, this reverses the erratum 0114 workaround.
 		     */
 		| ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS)
 		, &ep->regs->ep_rsp);
 }

 #ifdef USE_RDK_LEDS

 static inline void net2280_led_init (struct net2280 *dev)
 {
 	/* LED3 (green) is on during USB activity. note erratum 0113. */
 	writel ((1 << GPIO3_LED_SELECT)
 		| (1 << GPIO3_OUTPUT_ENABLE)
 		| (1 << GPIO2_OUTPUT_ENABLE)
 		| (1 << GPIO1_OUTPUT_ENABLE)
 		| (1 << GPIO0_OUTPUT_ENABLE)
 		, &dev->regs->gpioctl);
 }

 /* indicate speed with bi-color LED 0/1 */
 static inline
 void net2280_led_speed (struct net2280 *dev, enum usb_device_speed speed)
 {
 	u32	val = readl (&dev->regs->gpioctl);
 	switch (speed) {
 	case USB_SPEED_HIGH:		/* green */
 		val &= ~(1 << GPIO0_DATA);
 		val |= (1 << GPIO1_DATA);
 		break;
 	case USB_SPEED_FULL:		/* red */
 		val &= ~(1 << GPIO1_DATA);
 		val |= (1 << GPIO0_DATA);
 		break;
 	default:			/* (off/black) */
 		val &= ~((1 << GPIO1_DATA) | (1 << GPIO0_DATA));
 		break;
 	}
 	writel (val, &dev->regs->gpioctl);
 }

 /* indicate power with LED 2 */
 static inline void net2280_led_active (struct net2280 *dev, int is_active)
 {
 	u32	val = readl (&dev->regs->gpioctl);

 	// FIXME this LED never seems to turn on.
 	if (is_active)
 		val |= GPIO2_DATA;
 	else
 		val &= ~GPIO2_DATA;
 	writel (val, &dev->regs->gpioctl);
 }
 static inline void net2280_led_shutdown (struct net2280 *dev)
 {
 	/* turn off all four GPIO*_DATA bits */
 	writel (readl (&dev->regs->gpioctl) & ~0x0f,
 			&dev->regs->gpioctl);
 }

 #else

 #define net2280_led_init(dev)		do { } while (0)
 #define net2280_led_speed(dev, speed)	do { } while (0)
 #define net2280_led_shutdown(dev)	do { } while (0)

 #endif

 /*-------------------------------------------------------------------------*/

 #define xprintk(dev,level,fmt,args...) \
 	printk(level "%s %s: " fmt , driver_name , \
 			pci_name(dev->pdev) , ## args)

 #ifdef DEBUG
 #undef DEBUG
 #define DEBUG(dev,fmt,args...) \
 	xprintk(dev , KERN_DEBUG , fmt , ## args)
 #else
 #define DEBUG(dev,fmt,args...) \
 	do { } while (0)
 #endif /* DEBUG */

 #ifdef VERBOSE
 #define VDEBUG DEBUG
 #else
 #define VDEBUG(dev,fmt,args...) \
 	do { } while (0)
 #endif	/* VERBOSE */

 #define ERROR(dev,fmt,args...) \
 	xprintk(dev , KERN_ERR , fmt , ## args)
 #define WARNING(dev,fmt,args...) \
 	xprintk(dev , KERN_WARNING , fmt , ## args)
 #define INFO(dev,fmt,args...) \
 	xprintk(dev , KERN_INFO , fmt , ## args)

 /*-------------------------------------------------------------------------*/

 static inline void start_out_naking (struct net2280_ep *ep)
 {
 	/* NOTE:  hardware races lurk here, and PING protocol issues */
 	writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
 	/* synch with device */
 	readl (&ep->regs->ep_rsp);
 }

 #ifdef DEBUG
 static inline void assert_out_naking (struct net2280_ep *ep, const char *where)
 {
 	u32	tmp = readl (&ep->regs->ep_stat);

 	if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
 		DEBUG (ep->dev, "%s %s %08x !NAK\n",
 				ep->ep.name, where, tmp);
 		writel ((1 << SET_NAK_OUT_PACKETS),
 			&ep->regs->ep_rsp);
 	}
 }
 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__func__)
 #else
 #define ASSERT_OUT_NAKING(ep) do {} while (0)
 #endif

 static inline void stop_out_naking (struct net2280_ep *ep)
 {
 	u32	tmp;

 	tmp = readl (&ep->regs->ep_stat);
 	if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
 		writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
 }

 #endif	/* __KERNEL__ */
	/*
	* NetChip 2280 high/full speed USB device controller.
	* Unlike many such controllers, this one talks PCI.
	*/

	/*
	* Copyright (C) 2002 NetChip Technology, Inc. (http://www.netchip.com)
	* Copyright (C) 2003 David Brownell
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <linux/usb/net2280.h>

	/-------------------------------------------------------------------------/

	#ifdef __KERNEL__

	/* indexed registers [11.10] are accessed indirectly
	* caller must own the device lock.
	*/

	static inline u32
	get_idx_reg (struct net2280_regs __iomem *regs, u32 index)
	{
	writel (index, &regs->idxaddr);
	/* NOTE: synchs device/cpu memory views */
	return readl (&regs->idxdata);
	}

	static inline void
	set_idx_reg (struct net2280_regs __iomem *regs, u32 index, u32 value)
	{
	writel (index, &regs->idxaddr);
	writel (value, &regs->idxdata);
	/* posted, may not be visible yet */
	}

	#endif /* __KERNEL__ */


	#define REG_DIAG 0x0
	#define RETRY_COUNTER 16
	#define FORCE_PCI_SERR 11
	#define FORCE_PCI_INTERRUPT 10
	#define FORCE_USB_INTERRUPT 9
	#define FORCE_CPU_INTERRUPT 8
	#define ILLEGAL_BYTE_ENABLES 5
	#define FAST_TIMES 4
	#define FORCE_RECEIVE_ERROR 2
	#define FORCE_TRANSMIT_CRC_ERROR 0
	#define REG_FRAME 0x02 /* from last sof */
	#define REG_CHIPREV 0x03 /* in bcd */
	#define REG_HS_NAK_RATE 0x0a /* NAK per N uframes */

	#define CHIPREV_1 0x0100
	#define CHIPREV_1A 0x0110

	#ifdef __KERNEL__

	/* ep a-f highspeed and fullspeed maxpacket, addresses
	* computed from ep->num
	*/
	#define REG_EP_MAXPKT(dev,num) (((num) + 1) * 0x10 + \
	(((dev)->gadget.speed == USB_SPEED_HIGH) ? 0 : 1))

	/-------------------------------------------------------------------------/

	/* [8.3] for scatter/gather i/o
	* use struct net2280_dma_regs bitfields
	*/
	struct net2280_dma {
	__le32 dmacount;
	__le32 dmaaddr; /* the buffer */
	__le32 dmadesc; /* next dma descriptor */
	__le32 _reserved;
	} __attribute__ ((aligned (16)));

	/-------------------------------------------------------------------------/

	/* DRIVER DATA STRUCTURES and UTILITIES */

	struct net2280_ep {
	struct usb_ep ep;
	struct net2280_ep_regs __iomem *regs;
	struct net2280_dma_regs __iomem *dma;
	struct net2280_dma *dummy;
	dma_addr_t td_dma; /* of dummy */
	struct net2280 *dev;
	unsigned long irqs;

	/* analogous to a host-side qh */
	struct list_head queue;
	const struct usb_endpoint_descriptor *desc;
	unsigned num : 8,
	fifo_size : 12,
	in_fifo_validate : 1,
	out_overflow : 1,
	stopped : 1,
	wedged : 1,
	is_in : 1,
	is_iso : 1,
	responded : 1;
	};

	static inline void allow_status (struct net2280_ep *ep)
	{
	/* ep0 only */
	writel ( (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
	\| (1 << CLEAR_NAK_OUT_PACKETS)
	\| (1 << CLEAR_NAK_OUT_PACKETS_MODE)
	, &ep->regs->ep_rsp);
	ep->stopped = 1;
	}

	/* count (<= 4) bytes in the next fifo write will be valid */
	static inline void set_fifo_bytecount (struct net2280_ep *ep, unsigned count)
	{
	writeb (count, 2 + (u8 __iomem *) &ep->regs->ep_cfg);
	}

	struct net2280_request {
	struct usb_request req;
	struct net2280_dma *td;
	dma_addr_t td_dma;
	struct list_head queue;
	unsigned mapped : 1,
	valid : 1;
	};

	struct net2280 {
	/* each pci device provides one gadget, several endpoints */
	struct usb_gadget gadget;
	spinlock_t lock;
	struct net2280_ep ep [7];
	struct usb_gadget_driver *driver;
	unsigned enabled : 1,
	protocol_stall : 1,
	softconnect : 1,
	got_irq : 1,
	region : 1;
	u16 chiprev;

	/* pci state used to access those endpoints */
	struct pci_dev *pdev;
	struct net2280_regs __iomem *regs;
	struct net2280_usb_regs __iomem *usb;
	struct net2280_pci_regs __iomem *pci;
	struct net2280_dma_regs __iomem *dma;
	struct net2280_dep_regs __iomem *dep;
	struct net2280_ep_regs __iomem *epregs;

	struct pci_pool *requests;
	// statistics...
	};

	static inline void set_halt (struct net2280_ep *ep)
	{
	/* ep0 and bulk/intr endpoints */
	writel ( (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
	/* set NAK_OUT for erratum 0114 */
	\| ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS)
	\| (1 << SET_ENDPOINT_HALT)
	, &ep->regs->ep_rsp);
	}

	static inline void clear_halt (struct net2280_ep *ep)
	{
	/* ep0 and bulk/intr endpoints */
	writel ( (1 << CLEAR_ENDPOINT_HALT)
	\| (1 << CLEAR_ENDPOINT_TOGGLE)
	/* unless the gadget driver left a short packet in the
	* fifo, this reverses the erratum 0114 workaround.
	*/
	\| ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS)
	, &ep->regs->ep_rsp);
	}

	#ifdef USE_RDK_LEDS

	static inline void net2280_led_init (struct net2280 *dev)
	{
	/* LED3 (green) is on during USB activity. note erratum 0113. */
	writel ((1 << GPIO3_LED_SELECT)
	\| (1 << GPIO3_OUTPUT_ENABLE)
	\| (1 << GPIO2_OUTPUT_ENABLE)
	\| (1 << GPIO1_OUTPUT_ENABLE)
	\| (1 << GPIO0_OUTPUT_ENABLE)
	, &dev->regs->gpioctl);
	}

	/* indicate speed with bi-color LED 0/1 */
	static inline
	void net2280_led_speed (struct net2280 *dev, enum usb_device_speed speed)
	{
	u32 val = readl (&dev->regs->gpioctl);
	switch (speed) {
	case USB_SPEED_HIGH: /* green */
	val &= ~(1 << GPIO0_DATA);
	val \|= (1 << GPIO1_DATA);
	break;
	case USB_SPEED_FULL: /* red */
	val &= ~(1 << GPIO1_DATA);
	val \|= (1 << GPIO0_DATA);
	break;
	default: /* (off/black) */
	val &= ~((1 << GPIO1_DATA) \| (1 << GPIO0_DATA));
	break;
	}
	writel (val, &dev->regs->gpioctl);
	}

	/* indicate power with LED 2 */
	static inline void net2280_led_active (struct net2280 *dev, int is_active)
	{
	u32 val = readl (&dev->regs->gpioctl);

	// FIXME this LED never seems to turn on.
	if (is_active)
	val \|= GPIO2_DATA;
	else
	val &= ~GPIO2_DATA;
	writel (val, &dev->regs->gpioctl);
	}
	static inline void net2280_led_shutdown (struct net2280 *dev)
	{
	/* turn off all four GPIO_DATA bits /
	writel (readl (&dev->regs->gpioctl) & ~0x0f,
	&dev->regs->gpioctl);
	}

	#else

	#define net2280_led_init(dev) do { } while (0)
	#define net2280_led_speed(dev, speed) do { } while (0)
	#define net2280_led_shutdown(dev) do { } while (0)

	#endif

	/-------------------------------------------------------------------------/

	#define xprintk(dev,level,fmt,args...) \
	printk(level "%s %s: " fmt , driver_name , \
	pci_name(dev->pdev) , ## args)

	#ifdef DEBUG
	#undef DEBUG
	#define DEBUG(dev,fmt,args...) \
	xprintk(dev , KERN_DEBUG , fmt , ## args)
	#else
	#define DEBUG(dev,fmt,args...) \
	do { } while (0)
	#endif /* DEBUG */

	#ifdef VERBOSE
	#define VDEBUG DEBUG
	#else
	#define VDEBUG(dev,fmt,args...) \
	do { } while (0)
	#endif /* VERBOSE */

	#define ERROR(dev,fmt,args...) \
	xprintk(dev , KERN_ERR , fmt , ## args)
	#define WARNING(dev,fmt,args...) \
	xprintk(dev , KERN_WARNING , fmt , ## args)
	#define INFO(dev,fmt,args...) \
	xprintk(dev , KERN_INFO , fmt , ## args)

	/-------------------------------------------------------------------------/

	static inline void start_out_naking (struct net2280_ep *ep)
	{
	/* NOTE: hardware races lurk here, and PING protocol issues */
	writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
	/* synch with device */
	readl (&ep->regs->ep_rsp);
	}

	#ifdef DEBUG
	static inline void assert_out_naking (struct net2280_ep ep, const char where)
	{
	u32 tmp = readl (&ep->regs->ep_stat);

	if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
	DEBUG (ep->dev, "%s %s %08x !NAK\n",
	ep->ep.name, where, tmp);
	writel ((1 << SET_NAK_OUT_PACKETS),
	&ep->regs->ep_rsp);
	}
	}
	#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__func__)
	#else
	#define ASSERT_OUT_NAKING(ep) do {} while (0)
	#endif

	static inline void stop_out_naking (struct net2280_ep *ep)
	{
	u32 tmp;

	tmp = readl (&ep->regs->ep_stat);
	if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
	writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
	}

	#endif /* __KERNEL__ */