LXR linux/drivers/usb/gadget/net2280.h

   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                                                wedged : 1,
 113                                                is_in : 1,
 114                                                is_iso : 1,
 115                                                responded : 1;
 116};
 117
 118static inline void allow_status (struct net2280_ep *ep)
 119{
 120        /* ep0 only */
 121        writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
 122                | (1 << CLEAR_NAK_OUT_PACKETS)
 123                | (1 << CLEAR_NAK_OUT_PACKETS_MODE)
 124                , &ep->regs->ep_rsp);
 125        ep->stopped = 1;
 126}
 127
 128/* count (<= 4) bytes in the next fifo write will be valid */
 129static inline void set_fifo_bytecount (struct net2280_ep *ep, unsigned count)
 130{
 131        writeb (count, 2 + (u8 __iomem *) &ep->regs->ep_cfg);
 132}
 133
 134struct net2280_request {
 135        struct usb_request              req;
 136        struct net2280_dma              *td;
 137        dma_addr_t                      td_dma;
 138        struct list_head                queue;
 139        unsigned                        mapped : 1,
 140                                        valid : 1;
 141};
 142
 143struct net2280 {
 144        /* each pci device provides one gadget, several endpoints */
 145        struct usb_gadget               gadget;
 146        spinlock_t                      lock;
 147        struct net2280_ep               ep [7];
 148        struct usb_gadget_driver        *driver;
 149        unsigned                        enabled : 1,
 150                                        protocol_stall : 1,
 151                                        softconnect : 1,
 152                                        got_irq : 1,
 153                                        region : 1;
 154        u16                             chiprev;
 155
 156        /* pci state used to access those endpoints */
 157        struct pci_dev                  *pdev;
 158        struct net2280_regs             __iomem *regs;
 159        struct net2280_usb_regs         __iomem *usb;
 160        struct net2280_pci_regs         __iomem *pci;
 161        struct net2280_dma_regs         __iomem *dma;
 162        struct net2280_dep_regs         __iomem *dep;
 163        struct net2280_ep_regs          __iomem *epregs;
 164
 165        struct pci_pool                 *requests;
 166        // statistics...
 167};
 168
 169static inline void set_halt (struct net2280_ep *ep)
 170{
 171        /* ep0 and bulk/intr endpoints */
 172        writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
 173                    /* set NAK_OUT for erratum 0114 */
 174                | ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS)
 175                | (1 << SET_ENDPOINT_HALT)
 176                , &ep->regs->ep_rsp);
 177}
 178
 179static inline void clear_halt (struct net2280_ep *ep)
 180{
 181        /* ep0 and bulk/intr endpoints */
 182        writel (  (1 << CLEAR_ENDPOINT_HALT)
 183                | (1 << CLEAR_ENDPOINT_TOGGLE)
 184                    /* unless the gadget driver left a short packet in the
 185                     * fifo, this reverses the erratum 0114 workaround.
 186                     */
 187                | ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS)
 188                , &ep->regs->ep_rsp);
 189}
 190
 191#ifdef USE_RDK_LEDS
 192
 193static inline void net2280_led_init (struct net2280 *dev)
 194{
 195        /* LED3 (green) is on during USB activity. note erratum 0113. */
 196        writel ((1 << GPIO3_LED_SELECT)
 197                | (1 << GPIO3_OUTPUT_ENABLE)
 198                | (1 << GPIO2_OUTPUT_ENABLE)
 199                | (1 << GPIO1_OUTPUT_ENABLE)
 200                | (1 << GPIO0_OUTPUT_ENABLE)
 201                , &dev->regs->gpioctl);
 202}
 203
 204/* indicate speed with bi-color LED 0/1 */
 205static inline
 206void net2280_led_speed (struct net2280 *dev, enum usb_device_speed speed)
 207{
 208        u32     val = readl (&dev->regs->gpioctl);
 209        switch (speed) {
 210        case USB_SPEED_HIGH:            /* green */
 211                val &= ~(1 << GPIO0_DATA);
 212                val |= (1 << GPIO1_DATA);
 213                break;
 214        case USB_SPEED_FULL:            /* red */
 215                val &= ~(1 << GPIO1_DATA);
 216                val |= (1 << GPIO0_DATA);
 217                break;
 218        default:                        /* (off/black) */
 219                val &= ~((1 << GPIO1_DATA) | (1 << GPIO0_DATA));
 220                break;
 221        }
 222        writel (val, &dev->regs->gpioctl);
 223}
 224
 225/* indicate power with LED 2 */
 226static inline void net2280_led_active (struct net2280 *dev, int is_active)
 227{
 228        u32     val = readl (&dev->regs->gpioctl);
 229
 230        // FIXME this LED never seems to turn on.
 231        if (is_active)
 232                val |= GPIO2_DATA;
 233        else
 234                val &= ~GPIO2_DATA;
 235        writel (val, &dev->regs->gpioctl);
 236}
 237static inline void net2280_led_shutdown (struct net2280 *dev)
 238{
 239        /* turn off all four GPIO*_DATA bits */
 240        writel (readl (&dev->regs->gpioctl) & ~0x0f,
 241                        &dev->regs->gpioctl);
 242}
 243
 244#else
 245
 246#define net2280_led_init(dev)           do { } while (0)
 247#define net2280_led_speed(dev, speed)   do { } while (0)
 248#define net2280_led_shutdown(dev)       do { } while (0)
 249
 250#endif
 251
 252/*-------------------------------------------------------------------------*/
 253
 254#define xprintk(dev,level,fmt,args...) \
 255        printk(level "%s %s: " fmt , driver_name , \
 256                        pci_name(dev->pdev) , ## args)
 257
 258#ifdef DEBUG
 259#undef DEBUG
 260#define DEBUG(dev,fmt,args...) \
 261        xprintk(dev , KERN_DEBUG , fmt , ## args)
 262#else
 263#define DEBUG(dev,fmt,args...) \
 264        do { } while (0)
 265#endif /* DEBUG */
 266
 267#ifdef VERBOSE
 268#define VDEBUG DEBUG
 269#else
 270#define VDEBUG(dev,fmt,args...) \
 271        do { } while (0)
 272#endif  /* VERBOSE */
 273
 274#define ERROR(dev,fmt,args...) \
 275        xprintk(dev , KERN_ERR , fmt , ## args)
 276#define WARNING(dev,fmt,args...) \
 277        xprintk(dev , KERN_WARNING , fmt , ## args)
 278#define INFO(dev,fmt,args...) \
 279        xprintk(dev , KERN_INFO , fmt , ## args)
 280
 281/*-------------------------------------------------------------------------*/
 282
 283static inline void start_out_naking (struct net2280_ep *ep)
 284{
 285        /* NOTE:  hardware races lurk here, and PING protocol issues */
 286        writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
 287        /* synch with device */
 288        readl (&ep->regs->ep_rsp);
 289}
 290
 291#ifdef DEBUG
 292static inline void assert_out_naking (struct net2280_ep *ep, const char *where)
 293{
 294        u32     tmp = readl (&ep->regs->ep_stat);
 295
 296        if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
 297                DEBUG (ep->dev, "%s %s %08x !NAK\n",
 298                                ep->ep.name, where, tmp);
 299                writel ((1 << SET_NAK_OUT_PACKETS),
 300                        &ep->regs->ep_rsp);
 301        }
 302}
 303#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__func__)
 304#else
 305#define ASSERT_OUT_NAKING(ep) do {} while (0)
 306#endif
 307
 308static inline void stop_out_naking (struct net2280_ep *ep)
 309{
 310        u32     tmp;
 311
 312        tmp = readl (&ep->regs->ep_stat);
 313        if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
 314                writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
 315}
 316
 317#endif  /* __KERNEL__ */
 318