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 * Copyright (C) 2014 Ricardo Ribalda - Qtechnology/AS 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 */ 16 17 #include <linux/usb/net2280.h> 18 #include <linux/usb/usb338x.h> 19 20 /*-------------------------------------------------------------------------*/ 21 22 #ifdef __KERNEL__ 23 24 /* indexed registers [11.10] are accessed indirectly 25 * caller must own the device lock. 26 */ 27 28 static inline u32 get_idx_reg(struct net2280_regs __iomem *regs, u32 index) 29 { 30 writel(index, ®s->idxaddr); 31 /* NOTE: synchs device/cpu memory views */ 32 return readl(®s->idxdata); 33 } 34 35 static inline void 36 set_idx_reg(struct net2280_regs __iomem *regs, u32 index, u32 value) 37 { 38 writel(index, ®s->idxaddr); 39 writel(value, ®s->idxdata); 40 /* posted, may not be visible yet */ 41 } 42 43 #endif /* __KERNEL__ */ 44 45 #define PCI_VENDOR_ID_PLX_LEGACY 0x17cc 46 47 #define PLX_LEGACY BIT(0) 48 #define PLX_2280 BIT(1) 49 #define PLX_SUPERSPEED BIT(2) 50 51 #define REG_DIAG 0x0 52 #define RETRY_COUNTER 16 53 #define FORCE_PCI_SERR 11 54 #define FORCE_PCI_INTERRUPT 10 55 #define FORCE_USB_INTERRUPT 9 56 #define FORCE_CPU_INTERRUPT 8 57 #define ILLEGAL_BYTE_ENABLES 5 58 #define FAST_TIMES 4 59 #define FORCE_RECEIVE_ERROR 2 60 #define FORCE_TRANSMIT_CRC_ERROR 0 61 #define REG_FRAME 0x02 /* from last sof */ 62 #define REG_CHIPREV 0x03 /* in bcd */ 63 #define REG_HS_NAK_RATE 0x0a /* NAK per N uframes */ 64 65 #define CHIPREV_1 0x0100 66 #define CHIPREV_1A 0x0110 67 68 /* DEFECT 7374 */ 69 #define DEFECT_7374_NUMBEROF_MAX_WAIT_LOOPS 200 70 #define DEFECT_7374_PROCESSOR_WAIT_TIME 10 71 72 /* ep0 max packet size */ 73 #define EP0_SS_MAX_PACKET_SIZE 0x200 74 #define EP0_HS_MAX_PACKET_SIZE 0x40 75 #ifdef __KERNEL__ 76 77 /*-------------------------------------------------------------------------*/ 78 79 /* [8.3] for scatter/gather i/o 80 * use struct net2280_dma_regs bitfields 81 */ 82 struct net2280_dma { 83 __le32 dmacount; 84 __le32 dmaaddr; /* the buffer */ 85 __le32 dmadesc; /* next dma descriptor */ 86 __le32 _reserved; 87 } __aligned(16); 88 89 /*-------------------------------------------------------------------------*/ 90 91 /* DRIVER DATA STRUCTURES and UTILITIES */ 92 93 struct net2280_ep { 94 struct usb_ep ep; 95 struct net2280_ep_regs __iomem *cfg; 96 struct net2280_ep_regs __iomem *regs; 97 struct net2280_dma_regs __iomem *dma; 98 struct net2280_dma *dummy; 99 struct usb338x_fifo_regs __iomem *fiforegs; 100 dma_addr_t td_dma; /* of dummy */ 101 struct net2280 *dev; 102 unsigned long irqs; 103 unsigned is_halt:1, dma_started:1; 104 105 /* analogous to a host-side qh */ 106 struct list_head queue; 107 const struct usb_endpoint_descriptor *desc; 108 unsigned num : 8, 109 fifo_size : 12, 110 in_fifo_validate : 1, 111 out_overflow : 1, 112 stopped : 1, 113 wedged : 1, 114 is_in : 1, 115 is_iso : 1, 116 responded : 1; 117 }; 118 119 static inline void allow_status(struct net2280_ep *ep) 120 { 121 /* ep0 only */ 122 writel(BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE) | 123 BIT(CLEAR_NAK_OUT_PACKETS) | 124 BIT(CLEAR_NAK_OUT_PACKETS_MODE), 125 &ep->regs->ep_rsp); 126 ep->stopped = 1; 127 } 128 129 static void allow_status_338x(struct net2280_ep *ep) 130 { 131 /* 132 * Control Status Phase Handshake was set by the chip when the setup 133 * packet arrived. While set, the chip automatically NAKs the host's 134 * Status Phase tokens. 135 */ 136 writel(BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE), &ep->regs->ep_rsp); 137 138 ep->stopped = 1; 139 140 /* TD 9.9 Halt Endpoint test. TD 9.22 set feature test. */ 141 ep->responded = 0; 142 } 143 144 struct net2280_request { 145 struct usb_request req; 146 struct net2280_dma *td; 147 dma_addr_t td_dma; 148 struct list_head queue; 149 unsigned mapped : 1, 150 valid : 1; 151 }; 152 153 struct net2280 { 154 /* each pci device provides one gadget, several endpoints */ 155 struct usb_gadget gadget; 156 spinlock_t lock; 157 struct net2280_ep ep[9]; 158 struct usb_gadget_driver *driver; 159 unsigned enabled : 1, 160 protocol_stall : 1, 161 softconnect : 1, 162 got_irq : 1, 163 region:1, 164 u1_enable:1, 165 u2_enable:1, 166 ltm_enable:1, 167 wakeup_enable:1, 168 selfpowered:1, 169 addressed_state:1; 170 u16 chiprev; 171 int enhanced_mode; 172 int n_ep; 173 kernel_ulong_t quirks; 174 175 176 /* pci state used to access those endpoints */ 177 struct pci_dev *pdev; 178 struct net2280_regs __iomem *regs; 179 struct net2280_usb_regs __iomem *usb; 180 struct usb338x_usb_ext_regs __iomem *usb_ext; 181 struct net2280_pci_regs __iomem *pci; 182 struct net2280_dma_regs __iomem *dma; 183 struct net2280_dep_regs __iomem *dep; 184 struct net2280_ep_regs __iomem *epregs; 185 struct usb338x_fifo_regs __iomem *fiforegs; 186 struct usb338x_ll_regs __iomem *llregs; 187 struct usb338x_ll_lfps_regs __iomem *ll_lfps_regs; 188 struct usb338x_ll_tsn_regs __iomem *ll_tsn_regs; 189 struct usb338x_ll_chi_regs __iomem *ll_chicken_reg; 190 struct usb338x_pl_regs __iomem *plregs; 191 192 struct pci_pool *requests; 193 /* statistics...*/ 194 }; 195 196 static inline void set_halt(struct net2280_ep *ep) 197 { 198 /* ep0 and bulk/intr endpoints */ 199 writel(BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE) | 200 /* set NAK_OUT for erratum 0114 */ 201 ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS) | 202 BIT(SET_ENDPOINT_HALT), 203 &ep->regs->ep_rsp); 204 } 205 206 static inline void clear_halt(struct net2280_ep *ep) 207 { 208 /* ep0 and bulk/intr endpoints */ 209 writel(BIT(CLEAR_ENDPOINT_HALT) | 210 BIT(CLEAR_ENDPOINT_TOGGLE) | 211 /* 212 * unless the gadget driver left a short packet in the 213 * fifo, this reverses the erratum 0114 workaround. 214 */ 215 ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS), 216 &ep->regs->ep_rsp); 217 } 218 219 /* 220 * FSM value for Defect 7374 (U1U2 Test) is managed in 221 * chip's SCRATCH register: 222 */ 223 #define DEFECT7374_FSM_FIELD 28 224 225 /* Waiting for Control Read: 226 * - A transition to this state indicates a fresh USB connection, 227 * before the first Setup Packet. The connection speed is not 228 * known. Firmware is waiting for the first Control Read. 229 * - Starting state: This state can be thought of as the FSM's typical 230 * starting state. 231 * - Tip: Upon the first SS Control Read the FSM never 232 * returns to this state. 233 */ 234 #define DEFECT7374_FSM_WAITING_FOR_CONTROL_READ BIT(DEFECT7374_FSM_FIELD) 235 236 /* Non-SS Control Read: 237 * - A transition to this state indicates detection of the first HS 238 * or FS Control Read. 239 * - Tip: Upon the first SS Control Read the FSM never 240 * returns to this state. 241 */ 242 #define DEFECT7374_FSM_NON_SS_CONTROL_READ (2 << DEFECT7374_FSM_FIELD) 243 244 /* SS Control Read: 245 * - A transition to this state indicates detection of the 246 * first SS Control Read. 247 * - This state indicates workaround completion. Workarounds no longer 248 * need to be applied (as long as the chip remains powered up). 249 * - Tip: Once in this state the FSM state does not change (until 250 * the chip's power is lost and restored). 251 * - This can be thought of as the final state of the FSM; 252 * the FSM 'locks-up' in this state until the chip loses power. 253 */ 254 #define DEFECT7374_FSM_SS_CONTROL_READ (3 << DEFECT7374_FSM_FIELD) 255 256 #ifdef USE_RDK_LEDS 257 258 static inline void net2280_led_init(struct net2280 *dev) 259 { 260 /* LED3 (green) is on during USB activity. note erratum 0113. */ 261 writel(BIT(GPIO3_LED_SELECT) | 262 BIT(GPIO3_OUTPUT_ENABLE) | 263 BIT(GPIO2_OUTPUT_ENABLE) | 264 BIT(GPIO1_OUTPUT_ENABLE) | 265 BIT(GPIO0_OUTPUT_ENABLE), 266 &dev->regs->gpioctl); 267 } 268 269 /* indicate speed with bi-color LED 0/1 */ 270 static inline 271 void net2280_led_speed(struct net2280 *dev, enum usb_device_speed speed) 272 { 273 u32 val = readl(&dev->regs->gpioctl); 274 switch (speed) { 275 case USB_SPEED_SUPER: /* green + red */ 276 val |= BIT(GPIO0_DATA) | BIT(GPIO1_DATA); 277 break; 278 case USB_SPEED_HIGH: /* green */ 279 val &= ~BIT(GPIO0_DATA); 280 val |= BIT(GPIO1_DATA); 281 break; 282 case USB_SPEED_FULL: /* red */ 283 val &= ~BIT(GPIO1_DATA); 284 val |= BIT(GPIO0_DATA); 285 break; 286 default: /* (off/black) */ 287 val &= ~(BIT(GPIO1_DATA) | BIT(GPIO0_DATA)); 288 break; 289 } 290 writel(val, &dev->regs->gpioctl); 291 } 292 293 /* indicate power with LED 2 */ 294 static inline void net2280_led_active(struct net2280 *dev, int is_active) 295 { 296 u32 val = readl(&dev->regs->gpioctl); 297 298 /* FIXME this LED never seems to turn on.*/ 299 if (is_active) 300 val |= GPIO2_DATA; 301 else 302 val &= ~GPIO2_DATA; 303 writel(val, &dev->regs->gpioctl); 304 } 305 306 static inline void net2280_led_shutdown(struct net2280 *dev) 307 { 308 /* turn off all four GPIO*_DATA bits */ 309 writel(readl(&dev->regs->gpioctl) & ~0x0f, 310 &dev->regs->gpioctl); 311 } 312 313 #else 314 315 #define net2280_led_init(dev) do { } while (0) 316 #define net2280_led_speed(dev, speed) do { } while (0) 317 #define net2280_led_shutdown(dev) do { } while (0) 318 319 #endif 320 321 /*-------------------------------------------------------------------------*/ 322 323 #define ep_dbg(ndev, fmt, args...) \ 324 dev_dbg((&((ndev)->pdev->dev)), fmt, ##args) 325 326 #define ep_vdbg(ndev, fmt, args...) \ 327 dev_vdbg((&((ndev)->pdev->dev)), fmt, ##args) 328 329 #define ep_info(ndev, fmt, args...) \ 330 dev_info((&((ndev)->pdev->dev)), fmt, ##args) 331 332 #define ep_warn(ndev, fmt, args...) \ 333 dev_warn((&((ndev)->pdev->dev)), fmt, ##args) 334 335 #define ep_err(ndev, fmt, args...) \ 336 dev_err((&((ndev)->pdev->dev)), fmt, ##args) 337 338 /*-------------------------------------------------------------------------*/ 339 340 static inline void set_fifo_bytecount(struct net2280_ep *ep, unsigned count) 341 { 342 if (ep->dev->pdev->vendor == 0x17cc) 343 writeb(count, 2 + (u8 __iomem *) &ep->regs->ep_cfg); 344 else{ 345 u32 tmp = readl(&ep->cfg->ep_cfg) & 346 (~(0x07 << EP_FIFO_BYTE_COUNT)); 347 writel(tmp | (count << EP_FIFO_BYTE_COUNT), &ep->cfg->ep_cfg); 348 } 349 } 350 351 static inline void start_out_naking(struct net2280_ep *ep) 352 { 353 /* NOTE: hardware races lurk here, and PING protocol issues */ 354 writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp); 355 /* synch with device */ 356 readl(&ep->regs->ep_rsp); 357 } 358 359 #ifdef DEBUG 360 static inline void assert_out_naking(struct net2280_ep *ep, const char *where) 361 { 362 u32 tmp = readl(&ep->regs->ep_stat); 363 364 if ((tmp & BIT(NAK_OUT_PACKETS)) == 0) { 365 ep_dbg(ep->dev, "%s %s %08x !NAK\n", 366 ep->ep.name, where, tmp); 367 writel(BIT(SET_NAK_OUT_PACKETS), 368 &ep->regs->ep_rsp); 369 } 370 } 371 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep, __func__) 372 #else 373 #define ASSERT_OUT_NAKING(ep) do {} while (0) 374 #endif 375 376 static inline void stop_out_naking(struct net2280_ep *ep) 377 { 378 u32 tmp; 379 380 tmp = readl(&ep->regs->ep_stat); 381 if ((tmp & BIT(NAK_OUT_PACKETS)) != 0) 382 writel(BIT(CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp); 383 } 384 385 386 static inline void set_max_speed(struct net2280_ep *ep, u32 max) 387 { 388 u32 reg; 389 static const u32 ep_enhanced[9] = { 0x10, 0x60, 0x30, 0x80, 390 0x50, 0x20, 0x70, 0x40, 0x90 }; 391 392 if (ep->dev->enhanced_mode) 393 reg = ep_enhanced[ep->num]; 394 else{ 395 reg = (ep->num + 1) * 0x10; 396 if (ep->dev->gadget.speed != USB_SPEED_HIGH) 397 reg += 1; 398 } 399 400 set_idx_reg(ep->dev->regs, reg, max); 401 } 402 403 #endif /* __KERNEL__ */ 404