1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * bcm63xx_udc.c -- BCM63xx UDC high/full speed USB device controller 4 * 5 * Copyright (C) 2012 Kevin Cernekee <cernekee@gmail.com> 6 * Copyright (C) 2012 Broadcom Corporation 7 */ 8 9 #include <linux/bitops.h> 10 #include <linux/bug.h> 11 #include <linux/clk.h> 12 #include <linux/compiler.h> 13 #include <linux/debugfs.h> 14 #include <linux/delay.h> 15 #include <linux/device.h> 16 #include <linux/dma-mapping.h> 17 #include <linux/errno.h> 18 #include <linux/interrupt.h> 19 #include <linux/ioport.h> 20 #include <linux/kernel.h> 21 #include <linux/list.h> 22 #include <linux/module.h> 23 #include <linux/moduleparam.h> 24 #include <linux/platform_device.h> 25 #include <linux/sched.h> 26 #include <linux/seq_file.h> 27 #include <linux/slab.h> 28 #include <linux/timer.h> 29 #include <linux/usb.h> 30 #include <linux/usb/ch9.h> 31 #include <linux/usb/gadget.h> 32 #include <linux/workqueue.h> 33 34 #include <bcm63xx_cpu.h> 35 #include <bcm63xx_iudma.h> 36 #include <bcm63xx_dev_usb_usbd.h> 37 #include <bcm63xx_io.h> 38 #include <bcm63xx_regs.h> 39 40 #define DRV_MODULE_NAME "bcm63xx_udc" 41 42 static const char bcm63xx_ep0name[] = "ep0"; 43 44 static const struct { 45 const char *name; 46 const struct usb_ep_caps caps; 47 } bcm63xx_ep_info[] = { 48 #define EP_INFO(_name, _caps) \ 49 { \ 50 .name = _name, \ 51 .caps = _caps, \ 52 } 53 54 EP_INFO(bcm63xx_ep0name, 55 USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)), 56 EP_INFO("ep1in-bulk", 57 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)), 58 EP_INFO("ep2out-bulk", 59 USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)), 60 EP_INFO("ep3in-int", 61 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)), 62 EP_INFO("ep4out-int", 63 USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_OUT)), 64 65 #undef EP_INFO 66 }; 67 68 static bool use_fullspeed; 69 module_param(use_fullspeed, bool, S_IRUGO); 70 MODULE_PARM_DESC(use_fullspeed, "true for fullspeed only"); 71 72 /* 73 * RX IRQ coalescing options: 74 * 75 * false (default) - one IRQ per DATAx packet. Slow but reliable. The 76 * driver is able to pass the "testusb" suite and recover from conditions like: 77 * 78 * 1) Device queues up a 2048-byte RX IUDMA transaction on an OUT bulk ep 79 * 2) Host sends 512 bytes of data 80 * 3) Host decides to reconfigure the device and sends SET_INTERFACE 81 * 4) Device shuts down the endpoint and cancels the RX transaction 82 * 83 * true - one IRQ per transfer, for transfers <= 2048B. Generates 84 * considerably fewer IRQs, but error recovery is less robust. Does not 85 * reliably pass "testusb". 86 * 87 * TX always uses coalescing, because we can cancel partially complete TX 88 * transfers by repeatedly flushing the FIFO. The hardware doesn't allow 89 * this on RX. 90 */ 91 static bool irq_coalesce; 92 module_param(irq_coalesce, bool, S_IRUGO); 93 MODULE_PARM_DESC(irq_coalesce, "take one IRQ per RX transfer"); 94 95 #define BCM63XX_NUM_EP 5 96 #define BCM63XX_NUM_IUDMA 6 97 #define BCM63XX_NUM_FIFO_PAIRS 3 98 99 #define IUDMA_RESET_TIMEOUT_US 10000 100 101 #define IUDMA_EP0_RXCHAN 0 102 #define IUDMA_EP0_TXCHAN 1 103 104 #define IUDMA_MAX_FRAGMENT 2048 105 #define BCM63XX_MAX_CTRL_PKT 64 106 107 #define BCMEP_CTRL 0x00 108 #define BCMEP_ISOC 0x01 109 #define BCMEP_BULK 0x02 110 #define BCMEP_INTR 0x03 111 112 #define BCMEP_OUT 0x00 113 #define BCMEP_IN 0x01 114 115 #define BCM63XX_SPD_FULL 1 116 #define BCM63XX_SPD_HIGH 0 117 118 #define IUDMA_DMAC_OFFSET 0x200 119 #define IUDMA_DMAS_OFFSET 0x400 120 121 enum bcm63xx_ep0_state { 122 EP0_REQUEUE, 123 EP0_IDLE, 124 EP0_IN_DATA_PHASE_SETUP, 125 EP0_IN_DATA_PHASE_COMPLETE, 126 EP0_OUT_DATA_PHASE_SETUP, 127 EP0_OUT_DATA_PHASE_COMPLETE, 128 EP0_OUT_STATUS_PHASE, 129 EP0_IN_FAKE_STATUS_PHASE, 130 EP0_SHUTDOWN, 131 }; 132 133 static const char __maybe_unused bcm63xx_ep0_state_names[][32] = { 134 "REQUEUE", 135 "IDLE", 136 "IN_DATA_PHASE_SETUP", 137 "IN_DATA_PHASE_COMPLETE", 138 "OUT_DATA_PHASE_SETUP", 139 "OUT_DATA_PHASE_COMPLETE", 140 "OUT_STATUS_PHASE", 141 "IN_FAKE_STATUS_PHASE", 142 "SHUTDOWN", 143 }; 144 145 /** 146 * struct iudma_ch_cfg - Static configuration for an IUDMA channel. 147 * @ep_num: USB endpoint number. 148 * @n_bds: Number of buffer descriptors in the ring. 149 * @ep_type: Endpoint type (control, bulk, interrupt). 150 * @dir: Direction (in, out). 151 * @n_fifo_slots: Number of FIFO entries to allocate for this channel. 152 * @max_pkt_hs: Maximum packet size in high speed mode. 153 * @max_pkt_fs: Maximum packet size in full speed mode. 154 */ 155 struct iudma_ch_cfg { 156 int ep_num; 157 int n_bds; 158 int ep_type; 159 int dir; 160 int n_fifo_slots; 161 int max_pkt_hs; 162 int max_pkt_fs; 163 }; 164 165 static const struct iudma_ch_cfg iudma_defaults[] = { 166 167 /* This controller was designed to support a CDC/RNDIS application. 168 It may be possible to reconfigure some of the endpoints, but 169 the hardware limitations (FIFO sizing and number of DMA channels) 170 may significantly impact flexibility and/or stability. Change 171 these values at your own risk. 172 173 ep_num ep_type n_fifo_slots max_pkt_fs 174 idx | n_bds | dir | max_pkt_hs | 175 | | | | | | | | */ 176 [0] = { -1, 4, BCMEP_CTRL, BCMEP_OUT, 32, 64, 64 }, 177 [1] = { 0, 4, BCMEP_CTRL, BCMEP_OUT, 32, 64, 64 }, 178 [2] = { 2, 16, BCMEP_BULK, BCMEP_OUT, 128, 512, 64 }, 179 [3] = { 1, 16, BCMEP_BULK, BCMEP_IN, 128, 512, 64 }, 180 [4] = { 4, 4, BCMEP_INTR, BCMEP_OUT, 32, 64, 64 }, 181 [5] = { 3, 4, BCMEP_INTR, BCMEP_IN, 32, 64, 64 }, 182 }; 183 184 struct bcm63xx_udc; 185 186 /** 187 * struct iudma_ch - Represents the current state of a single IUDMA channel. 188 * @ch_idx: IUDMA channel index (0 to BCM63XX_NUM_IUDMA-1). 189 * @ep_num: USB endpoint number. -1 for ep0 RX. 190 * @enabled: Whether bcm63xx_ep_enable() has been called. 191 * @max_pkt: "Chunk size" on the USB interface. Based on interface speed. 192 * @is_tx: true for TX, false for RX. 193 * @bep: Pointer to the associated endpoint. NULL for ep0 RX. 194 * @udc: Reference to the device controller. 195 * @read_bd: Next buffer descriptor to reap from the hardware. 196 * @write_bd: Next BD available for a new packet. 197 * @end_bd: Points to the final BD in the ring. 198 * @n_bds_used: Number of BD entries currently occupied. 199 * @bd_ring: Base pointer to the BD ring. 200 * @bd_ring_dma: Physical (DMA) address of bd_ring. 201 * @n_bds: Total number of BDs in the ring. 202 * 203 * ep0 has two IUDMA channels (IUDMA_EP0_RXCHAN and IUDMA_EP0_TXCHAN), as it is 204 * bidirectional. The "struct usb_ep" associated with ep0 is for TX (IN) 205 * only. 206 * 207 * Each bulk/intr endpoint has a single IUDMA channel and a single 208 * struct usb_ep. 209 */ 210 struct iudma_ch { 211 unsigned int ch_idx; 212 int ep_num; 213 bool enabled; 214 int max_pkt; 215 bool is_tx; 216 struct bcm63xx_ep *bep; 217 struct bcm63xx_udc *udc; 218 219 struct bcm_enet_desc *read_bd; 220 struct bcm_enet_desc *write_bd; 221 struct bcm_enet_desc *end_bd; 222 int n_bds_used; 223 224 struct bcm_enet_desc *bd_ring; 225 dma_addr_t bd_ring_dma; 226 unsigned int n_bds; 227 }; 228 229 /** 230 * struct bcm63xx_ep - Internal (driver) state of a single endpoint. 231 * @ep_num: USB endpoint number. 232 * @iudma: Pointer to IUDMA channel state. 233 * @ep: USB gadget layer representation of the EP. 234 * @udc: Reference to the device controller. 235 * @queue: Linked list of outstanding requests for this EP. 236 * @halted: 1 if the EP is stalled; 0 otherwise. 237 */ 238 struct bcm63xx_ep { 239 unsigned int ep_num; 240 struct iudma_ch *iudma; 241 struct usb_ep ep; 242 struct bcm63xx_udc *udc; 243 struct list_head queue; 244 unsigned halted:1; 245 }; 246 247 /** 248 * struct bcm63xx_req - Internal (driver) state of a single request. 249 * @queue: Links back to the EP's request list. 250 * @req: USB gadget layer representation of the request. 251 * @offset: Current byte offset into the data buffer (next byte to queue). 252 * @bd_bytes: Number of data bytes in outstanding BD entries. 253 * @iudma: IUDMA channel used for the request. 254 */ 255 struct bcm63xx_req { 256 struct list_head queue; /* ep's requests */ 257 struct usb_request req; 258 unsigned int offset; 259 unsigned int bd_bytes; 260 struct iudma_ch *iudma; 261 }; 262 263 /** 264 * struct bcm63xx_udc - Driver/hardware private context. 265 * @lock: Spinlock to mediate access to this struct, and (most) HW regs. 266 * @dev: Generic Linux device structure. 267 * @pd: Platform data (board/port info). 268 * @usbd_clk: Clock descriptor for the USB device block. 269 * @usbh_clk: Clock descriptor for the USB host block. 270 * @gadget: USB device. 271 * @driver: Driver for USB device. 272 * @usbd_regs: Base address of the USBD/USB20D block. 273 * @iudma_regs: Base address of the USBD's associated IUDMA block. 274 * @bep: Array of endpoints, including ep0. 275 * @iudma: Array of all IUDMA channels used by this controller. 276 * @cfg: USB configuration number, from SET_CONFIGURATION wValue. 277 * @iface: USB interface number, from SET_INTERFACE wIndex. 278 * @alt_iface: USB alt interface number, from SET_INTERFACE wValue. 279 * @ep0_ctrl_req: Request object for bcm63xx_udc-initiated ep0 transactions. 280 * @ep0_ctrl_buf: Data buffer for ep0_ctrl_req. 281 * @ep0state: Current state of the ep0 state machine. 282 * @ep0_wq: Workqueue struct used to wake up the ep0 state machine. 283 * @wedgemap: Bitmap of wedged endpoints. 284 * @ep0_req_reset: USB reset is pending. 285 * @ep0_req_set_cfg: Need to spoof a SET_CONFIGURATION packet. 286 * @ep0_req_set_iface: Need to spoof a SET_INTERFACE packet. 287 * @ep0_req_shutdown: Driver is shutting down; requesting ep0 to halt activity. 288 * @ep0_req_completed: ep0 request has completed; worker has not seen it yet. 289 * @ep0_reply: Pending reply from gadget driver. 290 * @ep0_request: Outstanding ep0 request. 291 */ 292 struct bcm63xx_udc { 293 spinlock_t lock; 294 295 struct device *dev; 296 struct bcm63xx_usbd_platform_data *pd; 297 struct clk *usbd_clk; 298 struct clk *usbh_clk; 299 300 struct usb_gadget gadget; 301 struct usb_gadget_driver *driver; 302 303 void __iomem *usbd_regs; 304 void __iomem *iudma_regs; 305 306 struct bcm63xx_ep bep[BCM63XX_NUM_EP]; 307 struct iudma_ch iudma[BCM63XX_NUM_IUDMA]; 308 309 int cfg; 310 int iface; 311 int alt_iface; 312 313 struct bcm63xx_req ep0_ctrl_req; 314 u8 *ep0_ctrl_buf; 315 316 int ep0state; 317 struct work_struct ep0_wq; 318 319 unsigned long wedgemap; 320 321 unsigned ep0_req_reset:1; 322 unsigned ep0_req_set_cfg:1; 323 unsigned ep0_req_set_iface:1; 324 unsigned ep0_req_shutdown:1; 325 326 unsigned ep0_req_completed:1; 327 struct usb_request *ep0_reply; 328 struct usb_request *ep0_request; 329 }; 330 331 static const struct usb_ep_ops bcm63xx_udc_ep_ops; 332 333 /*********************************************************************** 334 * Convenience functions 335 ***********************************************************************/ 336 337 static inline struct bcm63xx_udc *gadget_to_udc(struct usb_gadget *g) 338 { 339 return container_of(g, struct bcm63xx_udc, gadget); 340 } 341 342 static inline struct bcm63xx_ep *our_ep(struct usb_ep *ep) 343 { 344 return container_of(ep, struct bcm63xx_ep, ep); 345 } 346 347 static inline struct bcm63xx_req *our_req(struct usb_request *req) 348 { 349 return container_of(req, struct bcm63xx_req, req); 350 } 351 352 static inline u32 usbd_readl(struct bcm63xx_udc *udc, u32 off) 353 { 354 return bcm_readl(udc->usbd_regs + off); 355 } 356 357 static inline void usbd_writel(struct bcm63xx_udc *udc, u32 val, u32 off) 358 { 359 bcm_writel(val, udc->usbd_regs + off); 360 } 361 362 static inline u32 usb_dma_readl(struct bcm63xx_udc *udc, u32 off) 363 { 364 return bcm_readl(udc->iudma_regs + off); 365 } 366 367 static inline void usb_dma_writel(struct bcm63xx_udc *udc, u32 val, u32 off) 368 { 369 bcm_writel(val, udc->iudma_regs + off); 370 } 371 372 static inline u32 usb_dmac_readl(struct bcm63xx_udc *udc, u32 off, int chan) 373 { 374 return bcm_readl(udc->iudma_regs + IUDMA_DMAC_OFFSET + off + 375 (ENETDMA_CHAN_WIDTH * chan)); 376 } 377 378 static inline void usb_dmac_writel(struct bcm63xx_udc *udc, u32 val, u32 off, 379 int chan) 380 { 381 bcm_writel(val, udc->iudma_regs + IUDMA_DMAC_OFFSET + off + 382 (ENETDMA_CHAN_WIDTH * chan)); 383 } 384 385 static inline u32 usb_dmas_readl(struct bcm63xx_udc *udc, u32 off, int chan) 386 { 387 return bcm_readl(udc->iudma_regs + IUDMA_DMAS_OFFSET + off + 388 (ENETDMA_CHAN_WIDTH * chan)); 389 } 390 391 static inline void usb_dmas_writel(struct bcm63xx_udc *udc, u32 val, u32 off, 392 int chan) 393 { 394 bcm_writel(val, udc->iudma_regs + IUDMA_DMAS_OFFSET + off + 395 (ENETDMA_CHAN_WIDTH * chan)); 396 } 397 398 static inline void set_clocks(struct bcm63xx_udc *udc, bool is_enabled) 399 { 400 if (is_enabled) { 401 clk_enable(udc->usbh_clk); 402 clk_enable(udc->usbd_clk); 403 udelay(10); 404 } else { 405 clk_disable(udc->usbd_clk); 406 clk_disable(udc->usbh_clk); 407 } 408 } 409 410 /*********************************************************************** 411 * Low-level IUDMA / FIFO operations 412 ***********************************************************************/ 413 414 /** 415 * bcm63xx_ep_dma_select - Helper function to set up the init_sel signal. 416 * @udc: Reference to the device controller. 417 * @idx: Desired init_sel value. 418 * 419 * The "init_sel" signal is used as a selection index for both endpoints 420 * and IUDMA channels. Since these do not map 1:1, the use of this signal 421 * depends on the context. 422 */ 423 static void bcm63xx_ep_dma_select(struct bcm63xx_udc *udc, int idx) 424 { 425 u32 val = usbd_readl(udc, USBD_CONTROL_REG); 426 427 val &= ~USBD_CONTROL_INIT_SEL_MASK; 428 val |= idx << USBD_CONTROL_INIT_SEL_SHIFT; 429 usbd_writel(udc, val, USBD_CONTROL_REG); 430 } 431 432 /** 433 * bcm63xx_set_stall - Enable/disable stall on one endpoint. 434 * @udc: Reference to the device controller. 435 * @bep: Endpoint on which to operate. 436 * @is_stalled: true to enable stall, false to disable. 437 * 438 * See notes in bcm63xx_update_wedge() regarding automatic clearing of 439 * halt/stall conditions. 440 */ 441 static void bcm63xx_set_stall(struct bcm63xx_udc *udc, struct bcm63xx_ep *bep, 442 bool is_stalled) 443 { 444 u32 val; 445 446 val = USBD_STALL_UPDATE_MASK | 447 (is_stalled ? USBD_STALL_ENABLE_MASK : 0) | 448 (bep->ep_num << USBD_STALL_EPNUM_SHIFT); 449 usbd_writel(udc, val, USBD_STALL_REG); 450 } 451 452 /** 453 * bcm63xx_fifo_setup - (Re)initialize FIFO boundaries and settings. 454 * @udc: Reference to the device controller. 455 * 456 * These parameters depend on the USB link speed. Settings are 457 * per-IUDMA-channel-pair. 458 */ 459 static void bcm63xx_fifo_setup(struct bcm63xx_udc *udc) 460 { 461 int is_hs = udc->gadget.speed == USB_SPEED_HIGH; 462 u32 i, val, rx_fifo_slot, tx_fifo_slot; 463 464 /* set up FIFO boundaries and packet sizes; this is done in pairs */ 465 rx_fifo_slot = tx_fifo_slot = 0; 466 for (i = 0; i < BCM63XX_NUM_IUDMA; i += 2) { 467 const struct iudma_ch_cfg *rx_cfg = &iudma_defaults[i]; 468 const struct iudma_ch_cfg *tx_cfg = &iudma_defaults[i + 1]; 469 470 bcm63xx_ep_dma_select(udc, i >> 1); 471 472 val = (rx_fifo_slot << USBD_RXFIFO_CONFIG_START_SHIFT) | 473 ((rx_fifo_slot + rx_cfg->n_fifo_slots - 1) << 474 USBD_RXFIFO_CONFIG_END_SHIFT); 475 rx_fifo_slot += rx_cfg->n_fifo_slots; 476 usbd_writel(udc, val, USBD_RXFIFO_CONFIG_REG); 477 usbd_writel(udc, 478 is_hs ? rx_cfg->max_pkt_hs : rx_cfg->max_pkt_fs, 479 USBD_RXFIFO_EPSIZE_REG); 480 481 val = (tx_fifo_slot << USBD_TXFIFO_CONFIG_START_SHIFT) | 482 ((tx_fifo_slot + tx_cfg->n_fifo_slots - 1) << 483 USBD_TXFIFO_CONFIG_END_SHIFT); 484 tx_fifo_slot += tx_cfg->n_fifo_slots; 485 usbd_writel(udc, val, USBD_TXFIFO_CONFIG_REG); 486 usbd_writel(udc, 487 is_hs ? tx_cfg->max_pkt_hs : tx_cfg->max_pkt_fs, 488 USBD_TXFIFO_EPSIZE_REG); 489 490 usbd_readl(udc, USBD_TXFIFO_EPSIZE_REG); 491 } 492 } 493 494 /** 495 * bcm63xx_fifo_reset_ep - Flush a single endpoint's FIFO. 496 * @udc: Reference to the device controller. 497 * @ep_num: Endpoint number. 498 */ 499 static void bcm63xx_fifo_reset_ep(struct bcm63xx_udc *udc, int ep_num) 500 { 501 u32 val; 502 503 bcm63xx_ep_dma_select(udc, ep_num); 504 505 val = usbd_readl(udc, USBD_CONTROL_REG); 506 val |= USBD_CONTROL_FIFO_RESET_MASK; 507 usbd_writel(udc, val, USBD_CONTROL_REG); 508 usbd_readl(udc, USBD_CONTROL_REG); 509 } 510 511 /** 512 * bcm63xx_fifo_reset - Flush all hardware FIFOs. 513 * @udc: Reference to the device controller. 514 */ 515 static void bcm63xx_fifo_reset(struct bcm63xx_udc *udc) 516 { 517 int i; 518 519 for (i = 0; i < BCM63XX_NUM_FIFO_PAIRS; i++) 520 bcm63xx_fifo_reset_ep(udc, i); 521 } 522 523 /** 524 * bcm63xx_ep_init - Initial (one-time) endpoint initialization. 525 * @udc: Reference to the device controller. 526 */ 527 static void bcm63xx_ep_init(struct bcm63xx_udc *udc) 528 { 529 u32 i, val; 530 531 for (i = 0; i < BCM63XX_NUM_IUDMA; i++) { 532 const struct iudma_ch_cfg *cfg = &iudma_defaults[i]; 533 534 if (cfg->ep_num < 0) 535 continue; 536 537 bcm63xx_ep_dma_select(udc, cfg->ep_num); 538 val = (cfg->ep_type << USBD_EPNUM_TYPEMAP_TYPE_SHIFT) | 539 ((i >> 1) << USBD_EPNUM_TYPEMAP_DMA_CH_SHIFT); 540 usbd_writel(udc, val, USBD_EPNUM_TYPEMAP_REG); 541 } 542 } 543 544 /** 545 * bcm63xx_ep_setup - Configure per-endpoint settings. 546 * @udc: Reference to the device controller. 547 * 548 * This needs to be rerun if the speed/cfg/intf/altintf changes. 549 */ 550 static void bcm63xx_ep_setup(struct bcm63xx_udc *udc) 551 { 552 u32 val, i; 553 554 usbd_writel(udc, USBD_CSR_SETUPADDR_DEF, USBD_CSR_SETUPADDR_REG); 555 556 for (i = 0; i < BCM63XX_NUM_IUDMA; i++) { 557 const struct iudma_ch_cfg *cfg = &iudma_defaults[i]; 558 int max_pkt = udc->gadget.speed == USB_SPEED_HIGH ? 559 cfg->max_pkt_hs : cfg->max_pkt_fs; 560 int idx = cfg->ep_num; 561 562 udc->iudma[i].max_pkt = max_pkt; 563 564 if (idx < 0) 565 continue; 566 usb_ep_set_maxpacket_limit(&udc->bep[idx].ep, max_pkt); 567 568 val = (idx << USBD_CSR_EP_LOG_SHIFT) | 569 (cfg->dir << USBD_CSR_EP_DIR_SHIFT) | 570 (cfg->ep_type << USBD_CSR_EP_TYPE_SHIFT) | 571 (udc->cfg << USBD_CSR_EP_CFG_SHIFT) | 572 (udc->iface << USBD_CSR_EP_IFACE_SHIFT) | 573 (udc->alt_iface << USBD_CSR_EP_ALTIFACE_SHIFT) | 574 (max_pkt << USBD_CSR_EP_MAXPKT_SHIFT); 575 usbd_writel(udc, val, USBD_CSR_EP_REG(idx)); 576 } 577 } 578 579 /** 580 * iudma_write - Queue a single IUDMA transaction. 581 * @udc: Reference to the device controller. 582 * @iudma: IUDMA channel to use. 583 * @breq: Request containing the transaction data. 584 * 585 * For RX IUDMA, this will queue a single buffer descriptor, as RX IUDMA 586 * does not honor SOP/EOP so the handling of multiple buffers is ambiguous. 587 * So iudma_write() may be called several times to fulfill a single 588 * usb_request. 589 * 590 * For TX IUDMA, this can queue multiple buffer descriptors if needed. 591 */ 592 static void iudma_write(struct bcm63xx_udc *udc, struct iudma_ch *iudma, 593 struct bcm63xx_req *breq) 594 { 595 int first_bd = 1, last_bd = 0, extra_zero_pkt = 0; 596 unsigned int bytes_left = breq->req.length - breq->offset; 597 const int max_bd_bytes = !irq_coalesce && !iudma->is_tx ? 598 iudma->max_pkt : IUDMA_MAX_FRAGMENT; 599 600 iudma->n_bds_used = 0; 601 breq->bd_bytes = 0; 602 breq->iudma = iudma; 603 604 if ((bytes_left % iudma->max_pkt == 0) && bytes_left && breq->req.zero) 605 extra_zero_pkt = 1; 606 607 do { 608 struct bcm_enet_desc *d = iudma->write_bd; 609 u32 dmaflags = 0; 610 unsigned int n_bytes; 611 612 if (d == iudma->end_bd) { 613 dmaflags |= DMADESC_WRAP_MASK; 614 iudma->write_bd = iudma->bd_ring; 615 } else { 616 iudma->write_bd++; 617 } 618 iudma->n_bds_used++; 619 620 n_bytes = min_t(int, bytes_left, max_bd_bytes); 621 if (n_bytes) 622 dmaflags |= n_bytes << DMADESC_LENGTH_SHIFT; 623 else 624 dmaflags |= (1 << DMADESC_LENGTH_SHIFT) | 625 DMADESC_USB_ZERO_MASK; 626 627 dmaflags |= DMADESC_OWNER_MASK; 628 if (first_bd) { 629 dmaflags |= DMADESC_SOP_MASK; 630 first_bd = 0; 631 } 632 633 /* 634 * extra_zero_pkt forces one more iteration through the loop 635 * after all data is queued up, to send the zero packet 636 */ 637 if (extra_zero_pkt && !bytes_left) 638 extra_zero_pkt = 0; 639 640 if (!iudma->is_tx || iudma->n_bds_used == iudma->n_bds || 641 (n_bytes == bytes_left && !extra_zero_pkt)) { 642 last_bd = 1; 643 dmaflags |= DMADESC_EOP_MASK; 644 } 645 646 d->address = breq->req.dma + breq->offset; 647 mb(); 648 d->len_stat = dmaflags; 649 650 breq->offset += n_bytes; 651 breq->bd_bytes += n_bytes; 652 bytes_left -= n_bytes; 653 } while (!last_bd); 654 655 usb_dmac_writel(udc, ENETDMAC_CHANCFG_EN_MASK, 656 ENETDMAC_CHANCFG_REG, iudma->ch_idx); 657 } 658 659 /** 660 * iudma_read - Check for IUDMA buffer completion. 661 * @udc: Reference to the device controller. 662 * @iudma: IUDMA channel to use. 663 * 664 * This checks to see if ALL of the outstanding BDs on the DMA channel 665 * have been filled. If so, it returns the actual transfer length; 666 * otherwise it returns -EBUSY. 667 */ 668 static int iudma_read(struct bcm63xx_udc *udc, struct iudma_ch *iudma) 669 { 670 int i, actual_len = 0; 671 struct bcm_enet_desc *d = iudma->read_bd; 672 673 if (!iudma->n_bds_used) 674 return -EINVAL; 675 676 for (i = 0; i < iudma->n_bds_used; i++) { 677 u32 dmaflags; 678 679 dmaflags = d->len_stat; 680 681 if (dmaflags & DMADESC_OWNER_MASK) 682 return -EBUSY; 683 684 actual_len += (dmaflags & DMADESC_LENGTH_MASK) >> 685 DMADESC_LENGTH_SHIFT; 686 if (d == iudma->end_bd) 687 d = iudma->bd_ring; 688 else 689 d++; 690 } 691 692 iudma->read_bd = d; 693 iudma->n_bds_used = 0; 694 return actual_len; 695 } 696 697 /** 698 * iudma_reset_channel - Stop DMA on a single channel. 699 * @udc: Reference to the device controller. 700 * @iudma: IUDMA channel to reset. 701 */ 702 static void iudma_reset_channel(struct bcm63xx_udc *udc, struct iudma_ch *iudma) 703 { 704 int timeout = IUDMA_RESET_TIMEOUT_US; 705 struct bcm_enet_desc *d; 706 int ch_idx = iudma->ch_idx; 707 708 if (!iudma->is_tx) 709 bcm63xx_fifo_reset_ep(udc, max(0, iudma->ep_num)); 710 711 /* stop DMA, then wait for the hardware to wrap up */ 712 usb_dmac_writel(udc, 0, ENETDMAC_CHANCFG_REG, ch_idx); 713 714 while (usb_dmac_readl(udc, ENETDMAC_CHANCFG_REG, ch_idx) & 715 ENETDMAC_CHANCFG_EN_MASK) { 716 udelay(1); 717 718 /* repeatedly flush the FIFO data until the BD completes */ 719 if (iudma->is_tx && iudma->ep_num >= 0) 720 bcm63xx_fifo_reset_ep(udc, iudma->ep_num); 721 722 if (!timeout--) { 723 dev_err(udc->dev, "can't reset IUDMA channel %d\n", 724 ch_idx); 725 break; 726 } 727 if (timeout == IUDMA_RESET_TIMEOUT_US / 2) { 728 dev_warn(udc->dev, "forcibly halting IUDMA channel %d\n", 729 ch_idx); 730 usb_dmac_writel(udc, ENETDMAC_CHANCFG_BUFHALT_MASK, 731 ENETDMAC_CHANCFG_REG, ch_idx); 732 } 733 } 734 usb_dmac_writel(udc, ~0, ENETDMAC_IR_REG, ch_idx); 735 736 /* don't leave "live" HW-owned entries for the next guy to step on */ 737 for (d = iudma->bd_ring; d <= iudma->end_bd; d++) 738 d->len_stat = 0; 739 mb(); 740 741 iudma->read_bd = iudma->write_bd = iudma->bd_ring; 742 iudma->n_bds_used = 0; 743 744 /* set up IRQs, UBUS burst size, and BD base for this channel */ 745 usb_dmac_writel(udc, ENETDMAC_IR_BUFDONE_MASK, 746 ENETDMAC_IRMASK_REG, ch_idx); 747 usb_dmac_writel(udc, 8, ENETDMAC_MAXBURST_REG, ch_idx); 748 749 usb_dmas_writel(udc, iudma->bd_ring_dma, ENETDMAS_RSTART_REG, ch_idx); 750 usb_dmas_writel(udc, 0, ENETDMAS_SRAM2_REG, ch_idx); 751 } 752 753 /** 754 * iudma_init_channel - One-time IUDMA channel initialization. 755 * @udc: Reference to the device controller. 756 * @ch_idx: Channel to initialize. 757 */ 758 static int iudma_init_channel(struct bcm63xx_udc *udc, unsigned int ch_idx) 759 { 760 struct iudma_ch *iudma = &udc->iudma[ch_idx]; 761 const struct iudma_ch_cfg *cfg = &iudma_defaults[ch_idx]; 762 unsigned int n_bds = cfg->n_bds; 763 struct bcm63xx_ep *bep = NULL; 764 765 iudma->ep_num = cfg->ep_num; 766 iudma->ch_idx = ch_idx; 767 iudma->is_tx = !!(ch_idx & 0x01); 768 if (iudma->ep_num >= 0) { 769 bep = &udc->bep[iudma->ep_num]; 770 bep->iudma = iudma; 771 INIT_LIST_HEAD(&bep->queue); 772 } 773 774 iudma->bep = bep; 775 iudma->udc = udc; 776 777 /* ep0 is always active; others are controlled by the gadget driver */ 778 if (iudma->ep_num <= 0) 779 iudma->enabled = true; 780 781 iudma->n_bds = n_bds; 782 iudma->bd_ring = dmam_alloc_coherent(udc->dev, 783 n_bds * sizeof(struct bcm_enet_desc), 784 &iudma->bd_ring_dma, GFP_KERNEL); 785 if (!iudma->bd_ring) 786 return -ENOMEM; 787 iudma->end_bd = &iudma->bd_ring[n_bds - 1]; 788 789 return 0; 790 } 791 792 /** 793 * iudma_init - One-time initialization of all IUDMA channels. 794 * @udc: Reference to the device controller. 795 * 796 * Enable DMA, flush channels, and enable global IUDMA IRQs. 797 */ 798 static int iudma_init(struct bcm63xx_udc *udc) 799 { 800 int i, rc; 801 802 usb_dma_writel(udc, ENETDMA_CFG_EN_MASK, ENETDMA_CFG_REG); 803 804 for (i = 0; i < BCM63XX_NUM_IUDMA; i++) { 805 rc = iudma_init_channel(udc, i); 806 if (rc) 807 return rc; 808 iudma_reset_channel(udc, &udc->iudma[i]); 809 } 810 811 usb_dma_writel(udc, BIT(BCM63XX_NUM_IUDMA)-1, ENETDMA_GLB_IRQMASK_REG); 812 return 0; 813 } 814 815 /** 816 * iudma_uninit - Uninitialize IUDMA channels. 817 * @udc: Reference to the device controller. 818 * 819 * Kill global IUDMA IRQs, flush channels, and kill DMA. 820 */ 821 static void iudma_uninit(struct bcm63xx_udc *udc) 822 { 823 int i; 824 825 usb_dma_writel(udc, 0, ENETDMA_GLB_IRQMASK_REG); 826 827 for (i = 0; i < BCM63XX_NUM_IUDMA; i++) 828 iudma_reset_channel(udc, &udc->iudma[i]); 829 830 usb_dma_writel(udc, 0, ENETDMA_CFG_REG); 831 } 832 833 /*********************************************************************** 834 * Other low-level USBD operations 835 ***********************************************************************/ 836 837 /** 838 * bcm63xx_set_ctrl_irqs - Mask/unmask control path interrupts. 839 * @udc: Reference to the device controller. 840 * @enable_irqs: true to enable, false to disable. 841 */ 842 static void bcm63xx_set_ctrl_irqs(struct bcm63xx_udc *udc, bool enable_irqs) 843 { 844 u32 val; 845 846 usbd_writel(udc, 0, USBD_STATUS_REG); 847 848 val = BIT(USBD_EVENT_IRQ_USB_RESET) | 849 BIT(USBD_EVENT_IRQ_SETUP) | 850 BIT(USBD_EVENT_IRQ_SETCFG) | 851 BIT(USBD_EVENT_IRQ_SETINTF) | 852 BIT(USBD_EVENT_IRQ_USB_LINK); 853 usbd_writel(udc, enable_irqs ? val : 0, USBD_EVENT_IRQ_MASK_REG); 854 usbd_writel(udc, val, USBD_EVENT_IRQ_STATUS_REG); 855 } 856 857 /** 858 * bcm63xx_select_phy_mode - Select between USB device and host mode. 859 * @udc: Reference to the device controller. 860 * @is_device: true for device, false for host. 861 * 862 * This should probably be reworked to use the drivers/usb/otg 863 * infrastructure. 864 * 865 * By default, the AFE/pullups are disabled in device mode, until 866 * bcm63xx_select_pullup() is called. 867 */ 868 static void bcm63xx_select_phy_mode(struct bcm63xx_udc *udc, bool is_device) 869 { 870 u32 val, portmask = BIT(udc->pd->port_no); 871 872 if (BCMCPU_IS_6328()) { 873 /* configure pinmux to sense VBUS signal */ 874 val = bcm_gpio_readl(GPIO_PINMUX_OTHR_REG); 875 val &= ~GPIO_PINMUX_OTHR_6328_USB_MASK; 876 val |= is_device ? GPIO_PINMUX_OTHR_6328_USB_DEV : 877 GPIO_PINMUX_OTHR_6328_USB_HOST; 878 bcm_gpio_writel(val, GPIO_PINMUX_OTHR_REG); 879 } 880 881 val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_UTMI_CTL_6368_REG); 882 if (is_device) { 883 val |= (portmask << USBH_PRIV_UTMI_CTL_HOSTB_SHIFT); 884 val |= (portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT); 885 } else { 886 val &= ~(portmask << USBH_PRIV_UTMI_CTL_HOSTB_SHIFT); 887 val &= ~(portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT); 888 } 889 bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_UTMI_CTL_6368_REG); 890 891 val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_SWAP_6368_REG); 892 if (is_device) 893 val |= USBH_PRIV_SWAP_USBD_MASK; 894 else 895 val &= ~USBH_PRIV_SWAP_USBD_MASK; 896 bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_SWAP_6368_REG); 897 } 898 899 /** 900 * bcm63xx_select_pullup - Enable/disable the pullup on D+ 901 * @udc: Reference to the device controller. 902 * @is_on: true to enable the pullup, false to disable. 903 * 904 * If the pullup is active, the host will sense a FS/HS device connected to 905 * the port. If the pullup is inactive, the host will think the USB 906 * device has been disconnected. 907 */ 908 static void bcm63xx_select_pullup(struct bcm63xx_udc *udc, bool is_on) 909 { 910 u32 val, portmask = BIT(udc->pd->port_no); 911 912 val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_UTMI_CTL_6368_REG); 913 if (is_on) 914 val &= ~(portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT); 915 else 916 val |= (portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT); 917 bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_UTMI_CTL_6368_REG); 918 } 919 920 /** 921 * bcm63xx_uninit_udc_hw - Shut down the hardware prior to driver removal. 922 * @udc: Reference to the device controller. 923 * 924 * This just masks the IUDMA IRQs and releases the clocks. It is assumed 925 * that bcm63xx_udc_stop() has already run, and the clocks are stopped. 926 */ 927 static void bcm63xx_uninit_udc_hw(struct bcm63xx_udc *udc) 928 { 929 set_clocks(udc, true); 930 iudma_uninit(udc); 931 set_clocks(udc, false); 932 933 clk_put(udc->usbd_clk); 934 clk_put(udc->usbh_clk); 935 } 936 937 /** 938 * bcm63xx_init_udc_hw - Initialize the controller hardware and data structures. 939 * @udc: Reference to the device controller. 940 */ 941 static int bcm63xx_init_udc_hw(struct bcm63xx_udc *udc) 942 { 943 int i, rc = 0; 944 u32 val; 945 946 udc->ep0_ctrl_buf = devm_kzalloc(udc->dev, BCM63XX_MAX_CTRL_PKT, 947 GFP_KERNEL); 948 if (!udc->ep0_ctrl_buf) 949 return -ENOMEM; 950 951 INIT_LIST_HEAD(&udc->gadget.ep_list); 952 for (i = 0; i < BCM63XX_NUM_EP; i++) { 953 struct bcm63xx_ep *bep = &udc->bep[i]; 954 955 bep->ep.name = bcm63xx_ep_info[i].name; 956 bep->ep.caps = bcm63xx_ep_info[i].caps; 957 bep->ep_num = i; 958 bep->ep.ops = &bcm63xx_udc_ep_ops; 959 list_add_tail(&bep->ep.ep_list, &udc->gadget.ep_list); 960 bep->halted = 0; 961 usb_ep_set_maxpacket_limit(&bep->ep, BCM63XX_MAX_CTRL_PKT); 962 bep->udc = udc; 963 bep->ep.desc = NULL; 964 INIT_LIST_HEAD(&bep->queue); 965 } 966 967 udc->gadget.ep0 = &udc->bep[0].ep; 968 list_del(&udc->bep[0].ep.ep_list); 969 970 udc->gadget.speed = USB_SPEED_UNKNOWN; 971 udc->ep0state = EP0_SHUTDOWN; 972 973 udc->usbh_clk = clk_get(udc->dev, "usbh"); 974 if (IS_ERR(udc->usbh_clk)) 975 return -EIO; 976 977 udc->usbd_clk = clk_get(udc->dev, "usbd"); 978 if (IS_ERR(udc->usbd_clk)) { 979 clk_put(udc->usbh_clk); 980 return -EIO; 981 } 982 983 set_clocks(udc, true); 984 985 val = USBD_CONTROL_AUTO_CSRS_MASK | 986 USBD_CONTROL_DONE_CSRS_MASK | 987 (irq_coalesce ? USBD_CONTROL_RXZSCFG_MASK : 0); 988 usbd_writel(udc, val, USBD_CONTROL_REG); 989 990 val = USBD_STRAPS_APP_SELF_PWR_MASK | 991 USBD_STRAPS_APP_RAM_IF_MASK | 992 USBD_STRAPS_APP_CSRPRGSUP_MASK | 993 USBD_STRAPS_APP_8BITPHY_MASK | 994 USBD_STRAPS_APP_RMTWKUP_MASK; 995 996 if (udc->gadget.max_speed == USB_SPEED_HIGH) 997 val |= (BCM63XX_SPD_HIGH << USBD_STRAPS_SPEED_SHIFT); 998 else 999 val |= (BCM63XX_SPD_FULL << USBD_STRAPS_SPEED_SHIFT); 1000 usbd_writel(udc, val, USBD_STRAPS_REG); 1001 1002 bcm63xx_set_ctrl_irqs(udc, false); 1003 1004 usbd_writel(udc, 0, USBD_EVENT_IRQ_CFG_LO_REG); 1005 1006 val = USBD_EVENT_IRQ_CFG_FALLING(USBD_EVENT_IRQ_ENUM_ON) | 1007 USBD_EVENT_IRQ_CFG_FALLING(USBD_EVENT_IRQ_SET_CSRS); 1008 usbd_writel(udc, val, USBD_EVENT_IRQ_CFG_HI_REG); 1009 1010 rc = iudma_init(udc); 1011 set_clocks(udc, false); 1012 if (rc) 1013 bcm63xx_uninit_udc_hw(udc); 1014 1015 return 0; 1016 } 1017 1018 /*********************************************************************** 1019 * Standard EP gadget operations 1020 ***********************************************************************/ 1021 1022 /** 1023 * bcm63xx_ep_enable - Enable one endpoint. 1024 * @ep: Endpoint to enable. 1025 * @desc: Contains max packet, direction, etc. 1026 * 1027 * Most of the endpoint parameters are fixed in this controller, so there 1028 * isn't much for this function to do. 1029 */ 1030 static int bcm63xx_ep_enable(struct usb_ep *ep, 1031 const struct usb_endpoint_descriptor *desc) 1032 { 1033 struct bcm63xx_ep *bep = our_ep(ep); 1034 struct bcm63xx_udc *udc = bep->udc; 1035 struct iudma_ch *iudma = bep->iudma; 1036 unsigned long flags; 1037 1038 if (!ep || !desc || ep->name == bcm63xx_ep0name) 1039 return -EINVAL; 1040 1041 if (!udc->driver) 1042 return -ESHUTDOWN; 1043 1044 spin_lock_irqsave(&udc->lock, flags); 1045 if (iudma->enabled) { 1046 spin_unlock_irqrestore(&udc->lock, flags); 1047 return -EINVAL; 1048 } 1049 1050 iudma->enabled = true; 1051 BUG_ON(!list_empty(&bep->queue)); 1052 1053 iudma_reset_channel(udc, iudma); 1054 1055 bep->halted = 0; 1056 bcm63xx_set_stall(udc, bep, false); 1057 clear_bit(bep->ep_num, &udc->wedgemap); 1058 1059 ep->desc = desc; 1060 ep->maxpacket = usb_endpoint_maxp(desc); 1061 1062 spin_unlock_irqrestore(&udc->lock, flags); 1063 return 0; 1064 } 1065 1066 /** 1067 * bcm63xx_ep_disable - Disable one endpoint. 1068 * @ep: Endpoint to disable. 1069 */ 1070 static int bcm63xx_ep_disable(struct usb_ep *ep) 1071 { 1072 struct bcm63xx_ep *bep = our_ep(ep); 1073 struct bcm63xx_udc *udc = bep->udc; 1074 struct iudma_ch *iudma = bep->iudma; 1075 struct bcm63xx_req *breq, *n; 1076 unsigned long flags; 1077 1078 if (!ep || !ep->desc) 1079 return -EINVAL; 1080 1081 spin_lock_irqsave(&udc->lock, flags); 1082 if (!iudma->enabled) { 1083 spin_unlock_irqrestore(&udc->lock, flags); 1084 return -EINVAL; 1085 } 1086 iudma->enabled = false; 1087 1088 iudma_reset_channel(udc, iudma); 1089 1090 if (!list_empty(&bep->queue)) { 1091 list_for_each_entry_safe(breq, n, &bep->queue, queue) { 1092 usb_gadget_unmap_request(&udc->gadget, &breq->req, 1093 iudma->is_tx); 1094 list_del(&breq->queue); 1095 breq->req.status = -ESHUTDOWN; 1096 1097 spin_unlock_irqrestore(&udc->lock, flags); 1098 usb_gadget_giveback_request(&iudma->bep->ep, &breq->req); 1099 spin_lock_irqsave(&udc->lock, flags); 1100 } 1101 } 1102 ep->desc = NULL; 1103 1104 spin_unlock_irqrestore(&udc->lock, flags); 1105 return 0; 1106 } 1107 1108 /** 1109 * bcm63xx_udc_alloc_request - Allocate a new request. 1110 * @ep: Endpoint associated with the request. 1111 * @mem_flags: Flags to pass to kzalloc(). 1112 */ 1113 static struct usb_request *bcm63xx_udc_alloc_request(struct usb_ep *ep, 1114 gfp_t mem_flags) 1115 { 1116 struct bcm63xx_req *breq; 1117 1118 breq = kzalloc(sizeof(*breq), mem_flags); 1119 if (!breq) 1120 return NULL; 1121 return &breq->req; 1122 } 1123 1124 /** 1125 * bcm63xx_udc_free_request - Free a request. 1126 * @ep: Endpoint associated with the request. 1127 * @req: Request to free. 1128 */ 1129 static void bcm63xx_udc_free_request(struct usb_ep *ep, 1130 struct usb_request *req) 1131 { 1132 struct bcm63xx_req *breq = our_req(req); 1133 kfree(breq); 1134 } 1135 1136 /** 1137 * bcm63xx_udc_queue - Queue up a new request. 1138 * @ep: Endpoint associated with the request. 1139 * @req: Request to add. 1140 * @mem_flags: Unused. 1141 * 1142 * If the queue is empty, start this request immediately. Otherwise, add 1143 * it to the list. 1144 * 1145 * ep0 replies are sent through this function from the gadget driver, but 1146 * they are treated differently because they need to be handled by the ep0 1147 * state machine. (Sometimes they are replies to control requests that 1148 * were spoofed by this driver, and so they shouldn't be transmitted at all.) 1149 */ 1150 static int bcm63xx_udc_queue(struct usb_ep *ep, struct usb_request *req, 1151 gfp_t mem_flags) 1152 { 1153 struct bcm63xx_ep *bep = our_ep(ep); 1154 struct bcm63xx_udc *udc = bep->udc; 1155 struct bcm63xx_req *breq = our_req(req); 1156 unsigned long flags; 1157 int rc = 0; 1158 1159 if (unlikely(!req || !req->complete || !req->buf || !ep)) 1160 return -EINVAL; 1161 1162 req->actual = 0; 1163 req->status = 0; 1164 breq->offset = 0; 1165 1166 if (bep == &udc->bep[0]) { 1167 /* only one reply per request, please */ 1168 if (udc->ep0_reply) 1169 return -EINVAL; 1170 1171 udc->ep0_reply = req; 1172 schedule_work(&udc->ep0_wq); 1173 return 0; 1174 } 1175 1176 spin_lock_irqsave(&udc->lock, flags); 1177 if (!bep->iudma->enabled) { 1178 rc = -ESHUTDOWN; 1179 goto out; 1180 } 1181 1182 rc = usb_gadget_map_request(&udc->gadget, req, bep->iudma->is_tx); 1183 if (rc == 0) { 1184 list_add_tail(&breq->queue, &bep->queue); 1185 if (list_is_singular(&bep->queue)) 1186 iudma_write(udc, bep->iudma, breq); 1187 } 1188 1189 out: 1190 spin_unlock_irqrestore(&udc->lock, flags); 1191 return rc; 1192 } 1193 1194 /** 1195 * bcm63xx_udc_dequeue - Remove a pending request from the queue. 1196 * @ep: Endpoint associated with the request. 1197 * @req: Request to remove. 1198 * 1199 * If the request is not at the head of the queue, this is easy - just nuke 1200 * it. If the request is at the head of the queue, we'll need to stop the 1201 * DMA transaction and then queue up the successor. 1202 */ 1203 static int bcm63xx_udc_dequeue(struct usb_ep *ep, struct usb_request *req) 1204 { 1205 struct bcm63xx_ep *bep = our_ep(ep); 1206 struct bcm63xx_udc *udc = bep->udc; 1207 struct bcm63xx_req *breq = our_req(req), *cur; 1208 unsigned long flags; 1209 int rc = 0; 1210 1211 spin_lock_irqsave(&udc->lock, flags); 1212 if (list_empty(&bep->queue)) { 1213 rc = -EINVAL; 1214 goto out; 1215 } 1216 1217 cur = list_first_entry(&bep->queue, struct bcm63xx_req, queue); 1218 usb_gadget_unmap_request(&udc->gadget, &breq->req, bep->iudma->is_tx); 1219 1220 if (breq == cur) { 1221 iudma_reset_channel(udc, bep->iudma); 1222 list_del(&breq->queue); 1223 1224 if (!list_empty(&bep->queue)) { 1225 struct bcm63xx_req *next; 1226 1227 next = list_first_entry(&bep->queue, 1228 struct bcm63xx_req, queue); 1229 iudma_write(udc, bep->iudma, next); 1230 } 1231 } else { 1232 list_del(&breq->queue); 1233 } 1234 1235 out: 1236 spin_unlock_irqrestore(&udc->lock, flags); 1237 1238 req->status = -ESHUTDOWN; 1239 req->complete(ep, req); 1240 1241 return rc; 1242 } 1243 1244 /** 1245 * bcm63xx_udc_set_halt - Enable/disable STALL flag in the hardware. 1246 * @ep: Endpoint to halt. 1247 * @value: Zero to clear halt; nonzero to set halt. 1248 * 1249 * See comments in bcm63xx_update_wedge(). 1250 */ 1251 static int bcm63xx_udc_set_halt(struct usb_ep *ep, int value) 1252 { 1253 struct bcm63xx_ep *bep = our_ep(ep); 1254 struct bcm63xx_udc *udc = bep->udc; 1255 unsigned long flags; 1256 1257 spin_lock_irqsave(&udc->lock, flags); 1258 bcm63xx_set_stall(udc, bep, !!value); 1259 bep->halted = value; 1260 spin_unlock_irqrestore(&udc->lock, flags); 1261 1262 return 0; 1263 } 1264 1265 /** 1266 * bcm63xx_udc_set_wedge - Stall the endpoint until the next reset. 1267 * @ep: Endpoint to wedge. 1268 * 1269 * See comments in bcm63xx_update_wedge(). 1270 */ 1271 static int bcm63xx_udc_set_wedge(struct usb_ep *ep) 1272 { 1273 struct bcm63xx_ep *bep = our_ep(ep); 1274 struct bcm63xx_udc *udc = bep->udc; 1275 unsigned long flags; 1276 1277 spin_lock_irqsave(&udc->lock, flags); 1278 set_bit(bep->ep_num, &udc->wedgemap); 1279 bcm63xx_set_stall(udc, bep, true); 1280 spin_unlock_irqrestore(&udc->lock, flags); 1281 1282 return 0; 1283 } 1284 1285 static const struct usb_ep_ops bcm63xx_udc_ep_ops = { 1286 .enable = bcm63xx_ep_enable, 1287 .disable = bcm63xx_ep_disable, 1288 1289 .alloc_request = bcm63xx_udc_alloc_request, 1290 .free_request = bcm63xx_udc_free_request, 1291 1292 .queue = bcm63xx_udc_queue, 1293 .dequeue = bcm63xx_udc_dequeue, 1294 1295 .set_halt = bcm63xx_udc_set_halt, 1296 .set_wedge = bcm63xx_udc_set_wedge, 1297 }; 1298 1299 /*********************************************************************** 1300 * EP0 handling 1301 ***********************************************************************/ 1302 1303 /** 1304 * bcm63xx_ep0_setup_callback - Drop spinlock to invoke ->setup callback. 1305 * @udc: Reference to the device controller. 1306 * @ctrl: 8-byte SETUP request. 1307 */ 1308 static int bcm63xx_ep0_setup_callback(struct bcm63xx_udc *udc, 1309 struct usb_ctrlrequest *ctrl) 1310 { 1311 int rc; 1312 1313 spin_unlock_irq(&udc->lock); 1314 rc = udc->driver->setup(&udc->gadget, ctrl); 1315 spin_lock_irq(&udc->lock); 1316 return rc; 1317 } 1318 1319 /** 1320 * bcm63xx_ep0_spoof_set_cfg - Synthesize a SET_CONFIGURATION request. 1321 * @udc: Reference to the device controller. 1322 * 1323 * Many standard requests are handled automatically in the hardware, but 1324 * we still need to pass them to the gadget driver so that it can 1325 * reconfigure the interfaces/endpoints if necessary. 1326 * 1327 * Unfortunately we are not able to send a STALL response if the host 1328 * requests an invalid configuration. If this happens, we'll have to be 1329 * content with printing a warning. 1330 */ 1331 static int bcm63xx_ep0_spoof_set_cfg(struct bcm63xx_udc *udc) 1332 { 1333 struct usb_ctrlrequest ctrl; 1334 int rc; 1335 1336 ctrl.bRequestType = USB_DIR_OUT | USB_RECIP_DEVICE; 1337 ctrl.bRequest = USB_REQ_SET_CONFIGURATION; 1338 ctrl.wValue = cpu_to_le16(udc->cfg); 1339 ctrl.wIndex = 0; 1340 ctrl.wLength = 0; 1341 1342 rc = bcm63xx_ep0_setup_callback(udc, &ctrl); 1343 if (rc < 0) { 1344 dev_warn_ratelimited(udc->dev, 1345 "hardware auto-acked bad SET_CONFIGURATION(%d) request\n", 1346 udc->cfg); 1347 } 1348 return rc; 1349 } 1350 1351 /** 1352 * bcm63xx_ep0_spoof_set_iface - Synthesize a SET_INTERFACE request. 1353 * @udc: Reference to the device controller. 1354 */ 1355 static int bcm63xx_ep0_spoof_set_iface(struct bcm63xx_udc *udc) 1356 { 1357 struct usb_ctrlrequest ctrl; 1358 int rc; 1359 1360 ctrl.bRequestType = USB_DIR_OUT | USB_RECIP_INTERFACE; 1361 ctrl.bRequest = USB_REQ_SET_INTERFACE; 1362 ctrl.wValue = cpu_to_le16(udc->alt_iface); 1363 ctrl.wIndex = cpu_to_le16(udc->iface); 1364 ctrl.wLength = 0; 1365 1366 rc = bcm63xx_ep0_setup_callback(udc, &ctrl); 1367 if (rc < 0) { 1368 dev_warn_ratelimited(udc->dev, 1369 "hardware auto-acked bad SET_INTERFACE(%d,%d) request\n", 1370 udc->iface, udc->alt_iface); 1371 } 1372 return rc; 1373 } 1374 1375 /** 1376 * bcm63xx_ep0_map_write - dma_map and iudma_write a single request. 1377 * @udc: Reference to the device controller. 1378 * @ch_idx: IUDMA channel number. 1379 * @req: USB gadget layer representation of the request. 1380 */ 1381 static void bcm63xx_ep0_map_write(struct bcm63xx_udc *udc, int ch_idx, 1382 struct usb_request *req) 1383 { 1384 struct bcm63xx_req *breq = our_req(req); 1385 struct iudma_ch *iudma = &udc->iudma[ch_idx]; 1386 1387 BUG_ON(udc->ep0_request); 1388 udc->ep0_request = req; 1389 1390 req->actual = 0; 1391 breq->offset = 0; 1392 usb_gadget_map_request(&udc->gadget, req, iudma->is_tx); 1393 iudma_write(udc, iudma, breq); 1394 } 1395 1396 /** 1397 * bcm63xx_ep0_complete - Set completion status and "stage" the callback. 1398 * @udc: Reference to the device controller. 1399 * @req: USB gadget layer representation of the request. 1400 * @status: Status to return to the gadget driver. 1401 */ 1402 static void bcm63xx_ep0_complete(struct bcm63xx_udc *udc, 1403 struct usb_request *req, int status) 1404 { 1405 req->status = status; 1406 if (status) 1407 req->actual = 0; 1408 if (req->complete) { 1409 spin_unlock_irq(&udc->lock); 1410 req->complete(&udc->bep[0].ep, req); 1411 spin_lock_irq(&udc->lock); 1412 } 1413 } 1414 1415 /** 1416 * bcm63xx_ep0_nuke_reply - Abort request from the gadget driver due to 1417 * reset/shutdown. 1418 * @udc: Reference to the device controller. 1419 * @is_tx: Nonzero for TX (IN), zero for RX (OUT). 1420 */ 1421 static void bcm63xx_ep0_nuke_reply(struct bcm63xx_udc *udc, int is_tx) 1422 { 1423 struct usb_request *req = udc->ep0_reply; 1424 1425 udc->ep0_reply = NULL; 1426 usb_gadget_unmap_request(&udc->gadget, req, is_tx); 1427 if (udc->ep0_request == req) { 1428 udc->ep0_req_completed = 0; 1429 udc->ep0_request = NULL; 1430 } 1431 bcm63xx_ep0_complete(udc, req, -ESHUTDOWN); 1432 } 1433 1434 /** 1435 * bcm63xx_ep0_read_complete - Close out the pending ep0 request; return 1436 * transfer len. 1437 * @udc: Reference to the device controller. 1438 */ 1439 static int bcm63xx_ep0_read_complete(struct bcm63xx_udc *udc) 1440 { 1441 struct usb_request *req = udc->ep0_request; 1442 1443 udc->ep0_req_completed = 0; 1444 udc->ep0_request = NULL; 1445 1446 return req->actual; 1447 } 1448 1449 /** 1450 * bcm63xx_ep0_internal_request - Helper function to submit an ep0 request. 1451 * @udc: Reference to the device controller. 1452 * @ch_idx: IUDMA channel number. 1453 * @length: Number of bytes to TX/RX. 1454 * 1455 * Used for simple transfers performed by the ep0 worker. This will always 1456 * use ep0_ctrl_req / ep0_ctrl_buf. 1457 */ 1458 static void bcm63xx_ep0_internal_request(struct bcm63xx_udc *udc, int ch_idx, 1459 int length) 1460 { 1461 struct usb_request *req = &udc->ep0_ctrl_req.req; 1462 1463 req->buf = udc->ep0_ctrl_buf; 1464 req->length = length; 1465 req->complete = NULL; 1466 1467 bcm63xx_ep0_map_write(udc, ch_idx, req); 1468 } 1469 1470 /** 1471 * bcm63xx_ep0_do_setup - Parse new SETUP packet and decide how to handle it. 1472 * @udc: Reference to the device controller. 1473 * 1474 * EP0_IDLE probably shouldn't ever happen. EP0_REQUEUE means we're ready 1475 * for the next packet. Anything else means the transaction requires multiple 1476 * stages of handling. 1477 */ 1478 static enum bcm63xx_ep0_state bcm63xx_ep0_do_setup(struct bcm63xx_udc *udc) 1479 { 1480 int rc; 1481 struct usb_ctrlrequest *ctrl = (void *)udc->ep0_ctrl_buf; 1482 1483 rc = bcm63xx_ep0_read_complete(udc); 1484 1485 if (rc < 0) { 1486 dev_err(udc->dev, "missing SETUP packet\n"); 1487 return EP0_IDLE; 1488 } 1489 1490 /* 1491 * Handle 0-byte IN STATUS acknowledgement. The hardware doesn't 1492 * ALWAYS deliver these 100% of the time, so if we happen to see one, 1493 * just throw it away. 1494 */ 1495 if (rc == 0) 1496 return EP0_REQUEUE; 1497 1498 /* Drop malformed SETUP packets */ 1499 if (rc != sizeof(*ctrl)) { 1500 dev_warn_ratelimited(udc->dev, 1501 "malformed SETUP packet (%d bytes)\n", rc); 1502 return EP0_REQUEUE; 1503 } 1504 1505 /* Process new SETUP packet arriving on ep0 */ 1506 rc = bcm63xx_ep0_setup_callback(udc, ctrl); 1507 if (rc < 0) { 1508 bcm63xx_set_stall(udc, &udc->bep[0], true); 1509 return EP0_REQUEUE; 1510 } 1511 1512 if (!ctrl->wLength) 1513 return EP0_REQUEUE; 1514 else if (ctrl->bRequestType & USB_DIR_IN) 1515 return EP0_IN_DATA_PHASE_SETUP; 1516 else 1517 return EP0_OUT_DATA_PHASE_SETUP; 1518 } 1519 1520 /** 1521 * bcm63xx_ep0_do_idle - Check for outstanding requests if ep0 is idle. 1522 * @udc: Reference to the device controller. 1523 * 1524 * In state EP0_IDLE, the RX descriptor is either pending, or has been 1525 * filled with a SETUP packet from the host. This function handles new 1526 * SETUP packets, control IRQ events (which can generate fake SETUP packets), 1527 * and reset/shutdown events. 1528 * 1529 * Returns 0 if work was done; -EAGAIN if nothing to do. 1530 */ 1531 static int bcm63xx_ep0_do_idle(struct bcm63xx_udc *udc) 1532 { 1533 if (udc->ep0_req_reset) { 1534 udc->ep0_req_reset = 0; 1535 } else if (udc->ep0_req_set_cfg) { 1536 udc->ep0_req_set_cfg = 0; 1537 if (bcm63xx_ep0_spoof_set_cfg(udc) >= 0) 1538 udc->ep0state = EP0_IN_FAKE_STATUS_PHASE; 1539 } else if (udc->ep0_req_set_iface) { 1540 udc->ep0_req_set_iface = 0; 1541 if (bcm63xx_ep0_spoof_set_iface(udc) >= 0) 1542 udc->ep0state = EP0_IN_FAKE_STATUS_PHASE; 1543 } else if (udc->ep0_req_completed) { 1544 udc->ep0state = bcm63xx_ep0_do_setup(udc); 1545 return udc->ep0state == EP0_IDLE ? -EAGAIN : 0; 1546 } else if (udc->ep0_req_shutdown) { 1547 udc->ep0_req_shutdown = 0; 1548 udc->ep0_req_completed = 0; 1549 udc->ep0_request = NULL; 1550 iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_RXCHAN]); 1551 usb_gadget_unmap_request(&udc->gadget, 1552 &udc->ep0_ctrl_req.req, 0); 1553 1554 /* bcm63xx_udc_pullup() is waiting for this */ 1555 mb(); 1556 udc->ep0state = EP0_SHUTDOWN; 1557 } else if (udc->ep0_reply) { 1558 /* 1559 * This could happen if a USB RESET shows up during an ep0 1560 * transaction (especially if a laggy driver like gadgetfs 1561 * is in use). 1562 */ 1563 dev_warn(udc->dev, "nuking unexpected reply\n"); 1564 bcm63xx_ep0_nuke_reply(udc, 0); 1565 } else { 1566 return -EAGAIN; 1567 } 1568 1569 return 0; 1570 } 1571 1572 /** 1573 * bcm63xx_ep0_one_round - Handle the current ep0 state. 1574 * @udc: Reference to the device controller. 1575 * 1576 * Returns 0 if work was done; -EAGAIN if nothing to do. 1577 */ 1578 static int bcm63xx_ep0_one_round(struct bcm63xx_udc *udc) 1579 { 1580 enum bcm63xx_ep0_state ep0state = udc->ep0state; 1581 bool shutdown = udc->ep0_req_reset || udc->ep0_req_shutdown; 1582 1583 switch (udc->ep0state) { 1584 case EP0_REQUEUE: 1585 /* set up descriptor to receive SETUP packet */ 1586 bcm63xx_ep0_internal_request(udc, IUDMA_EP0_RXCHAN, 1587 BCM63XX_MAX_CTRL_PKT); 1588 ep0state = EP0_IDLE; 1589 break; 1590 case EP0_IDLE: 1591 return bcm63xx_ep0_do_idle(udc); 1592 case EP0_IN_DATA_PHASE_SETUP: 1593 /* 1594 * Normal case: TX request is in ep0_reply (queued by the 1595 * callback), or will be queued shortly. When it's here, 1596 * send it to the HW and go to EP0_IN_DATA_PHASE_COMPLETE. 1597 * 1598 * Shutdown case: Stop waiting for the reply. Just 1599 * REQUEUE->IDLE. The gadget driver is NOT expected to 1600 * queue anything else now. 1601 */ 1602 if (udc->ep0_reply) { 1603 bcm63xx_ep0_map_write(udc, IUDMA_EP0_TXCHAN, 1604 udc->ep0_reply); 1605 ep0state = EP0_IN_DATA_PHASE_COMPLETE; 1606 } else if (shutdown) { 1607 ep0state = EP0_REQUEUE; 1608 } 1609 break; 1610 case EP0_IN_DATA_PHASE_COMPLETE: { 1611 /* 1612 * Normal case: TX packet (ep0_reply) is in flight; wait for 1613 * it to finish, then go back to REQUEUE->IDLE. 1614 * 1615 * Shutdown case: Reset the TX channel, send -ESHUTDOWN 1616 * completion to the gadget driver, then REQUEUE->IDLE. 1617 */ 1618 if (udc->ep0_req_completed) { 1619 udc->ep0_reply = NULL; 1620 bcm63xx_ep0_read_complete(udc); 1621 /* 1622 * the "ack" sometimes gets eaten (see 1623 * bcm63xx_ep0_do_idle) 1624 */ 1625 ep0state = EP0_REQUEUE; 1626 } else if (shutdown) { 1627 iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_TXCHAN]); 1628 bcm63xx_ep0_nuke_reply(udc, 1); 1629 ep0state = EP0_REQUEUE; 1630 } 1631 break; 1632 } 1633 case EP0_OUT_DATA_PHASE_SETUP: 1634 /* Similar behavior to EP0_IN_DATA_PHASE_SETUP */ 1635 if (udc->ep0_reply) { 1636 bcm63xx_ep0_map_write(udc, IUDMA_EP0_RXCHAN, 1637 udc->ep0_reply); 1638 ep0state = EP0_OUT_DATA_PHASE_COMPLETE; 1639 } else if (shutdown) { 1640 ep0state = EP0_REQUEUE; 1641 } 1642 break; 1643 case EP0_OUT_DATA_PHASE_COMPLETE: { 1644 /* Similar behavior to EP0_IN_DATA_PHASE_COMPLETE */ 1645 if (udc->ep0_req_completed) { 1646 udc->ep0_reply = NULL; 1647 bcm63xx_ep0_read_complete(udc); 1648 1649 /* send 0-byte ack to host */ 1650 bcm63xx_ep0_internal_request(udc, IUDMA_EP0_TXCHAN, 0); 1651 ep0state = EP0_OUT_STATUS_PHASE; 1652 } else if (shutdown) { 1653 iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_RXCHAN]); 1654 bcm63xx_ep0_nuke_reply(udc, 0); 1655 ep0state = EP0_REQUEUE; 1656 } 1657 break; 1658 } 1659 case EP0_OUT_STATUS_PHASE: 1660 /* 1661 * Normal case: 0-byte OUT ack packet is in flight; wait 1662 * for it to finish, then go back to REQUEUE->IDLE. 1663 * 1664 * Shutdown case: just cancel the transmission. Don't bother 1665 * calling the completion, because it originated from this 1666 * function anyway. Then go back to REQUEUE->IDLE. 1667 */ 1668 if (udc->ep0_req_completed) { 1669 bcm63xx_ep0_read_complete(udc); 1670 ep0state = EP0_REQUEUE; 1671 } else if (shutdown) { 1672 iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_TXCHAN]); 1673 udc->ep0_request = NULL; 1674 ep0state = EP0_REQUEUE; 1675 } 1676 break; 1677 case EP0_IN_FAKE_STATUS_PHASE: { 1678 /* 1679 * Normal case: we spoofed a SETUP packet and are now 1680 * waiting for the gadget driver to send a 0-byte reply. 1681 * This doesn't actually get sent to the HW because the 1682 * HW has already sent its own reply. Once we get the 1683 * response, return to IDLE. 1684 * 1685 * Shutdown case: return to IDLE immediately. 1686 * 1687 * Note that the ep0 RX descriptor has remained queued 1688 * (and possibly unfilled) during this entire transaction. 1689 * The HW datapath (IUDMA) never even sees SET_CONFIGURATION 1690 * or SET_INTERFACE transactions. 1691 */ 1692 struct usb_request *r = udc->ep0_reply; 1693 1694 if (!r) { 1695 if (shutdown) 1696 ep0state = EP0_IDLE; 1697 break; 1698 } 1699 1700 bcm63xx_ep0_complete(udc, r, 0); 1701 udc->ep0_reply = NULL; 1702 ep0state = EP0_IDLE; 1703 break; 1704 } 1705 case EP0_SHUTDOWN: 1706 break; 1707 } 1708 1709 if (udc->ep0state == ep0state) 1710 return -EAGAIN; 1711 1712 udc->ep0state = ep0state; 1713 return 0; 1714 } 1715 1716 /** 1717 * bcm63xx_ep0_process - ep0 worker thread / state machine. 1718 * @w: Workqueue struct. 1719 * 1720 * bcm63xx_ep0_process is triggered any time an event occurs on ep0. It 1721 * is used to synchronize ep0 events and ensure that both HW and SW events 1722 * occur in a well-defined order. When the ep0 IUDMA queues are idle, it may 1723 * synthesize SET_CONFIGURATION / SET_INTERFACE requests that were consumed 1724 * by the USBD hardware. 1725 * 1726 * The worker function will continue iterating around the state machine 1727 * until there is nothing left to do. Usually "nothing left to do" means 1728 * that we're waiting for a new event from the hardware. 1729 */ 1730 static void bcm63xx_ep0_process(struct work_struct *w) 1731 { 1732 struct bcm63xx_udc *udc = container_of(w, struct bcm63xx_udc, ep0_wq); 1733 spin_lock_irq(&udc->lock); 1734 while (bcm63xx_ep0_one_round(udc) == 0) 1735 ; 1736 spin_unlock_irq(&udc->lock); 1737 } 1738 1739 /*********************************************************************** 1740 * Standard UDC gadget operations 1741 ***********************************************************************/ 1742 1743 /** 1744 * bcm63xx_udc_get_frame - Read current SOF frame number from the HW. 1745 * @gadget: USB device. 1746 */ 1747 static int bcm63xx_udc_get_frame(struct usb_gadget *gadget) 1748 { 1749 struct bcm63xx_udc *udc = gadget_to_udc(gadget); 1750 1751 return (usbd_readl(udc, USBD_STATUS_REG) & 1752 USBD_STATUS_SOF_MASK) >> USBD_STATUS_SOF_SHIFT; 1753 } 1754 1755 /** 1756 * bcm63xx_udc_pullup - Enable/disable pullup on D+ line. 1757 * @gadget: USB device. 1758 * @is_on: 0 to disable pullup, 1 to enable. 1759 * 1760 * See notes in bcm63xx_select_pullup(). 1761 */ 1762 static int bcm63xx_udc_pullup(struct usb_gadget *gadget, int is_on) 1763 { 1764 struct bcm63xx_udc *udc = gadget_to_udc(gadget); 1765 unsigned long flags; 1766 int i, rc = -EINVAL; 1767 1768 spin_lock_irqsave(&udc->lock, flags); 1769 if (is_on && udc->ep0state == EP0_SHUTDOWN) { 1770 udc->gadget.speed = USB_SPEED_UNKNOWN; 1771 udc->ep0state = EP0_REQUEUE; 1772 bcm63xx_fifo_setup(udc); 1773 bcm63xx_fifo_reset(udc); 1774 bcm63xx_ep_setup(udc); 1775 1776 bitmap_zero(&udc->wedgemap, BCM63XX_NUM_EP); 1777 for (i = 0; i < BCM63XX_NUM_EP; i++) 1778 bcm63xx_set_stall(udc, &udc->bep[i], false); 1779 1780 bcm63xx_set_ctrl_irqs(udc, true); 1781 bcm63xx_select_pullup(gadget_to_udc(gadget), true); 1782 rc = 0; 1783 } else if (!is_on && udc->ep0state != EP0_SHUTDOWN) { 1784 bcm63xx_select_pullup(gadget_to_udc(gadget), false); 1785 1786 udc->ep0_req_shutdown = 1; 1787 spin_unlock_irqrestore(&udc->lock, flags); 1788 1789 while (1) { 1790 schedule_work(&udc->ep0_wq); 1791 if (udc->ep0state == EP0_SHUTDOWN) 1792 break; 1793 msleep(50); 1794 } 1795 bcm63xx_set_ctrl_irqs(udc, false); 1796 cancel_work_sync(&udc->ep0_wq); 1797 return 0; 1798 } 1799 1800 spin_unlock_irqrestore(&udc->lock, flags); 1801 return rc; 1802 } 1803 1804 /** 1805 * bcm63xx_udc_start - Start the controller. 1806 * @gadget: USB device. 1807 * @driver: Driver for USB device. 1808 */ 1809 static int bcm63xx_udc_start(struct usb_gadget *gadget, 1810 struct usb_gadget_driver *driver) 1811 { 1812 struct bcm63xx_udc *udc = gadget_to_udc(gadget); 1813 unsigned long flags; 1814 1815 if (!driver || driver->max_speed < USB_SPEED_HIGH || 1816 !driver->setup) 1817 return -EINVAL; 1818 if (!udc) 1819 return -ENODEV; 1820 if (udc->driver) 1821 return -EBUSY; 1822 1823 spin_lock_irqsave(&udc->lock, flags); 1824 1825 set_clocks(udc, true); 1826 bcm63xx_fifo_setup(udc); 1827 bcm63xx_ep_init(udc); 1828 bcm63xx_ep_setup(udc); 1829 bcm63xx_fifo_reset(udc); 1830 bcm63xx_select_phy_mode(udc, true); 1831 1832 udc->driver = driver; 1833 driver->driver.bus = NULL; 1834 udc->gadget.dev.of_node = udc->dev->of_node; 1835 1836 spin_unlock_irqrestore(&udc->lock, flags); 1837 1838 return 0; 1839 } 1840 1841 /** 1842 * bcm63xx_udc_stop - Shut down the controller. 1843 * @gadget: USB device. 1844 * @driver: Driver for USB device. 1845 */ 1846 static int bcm63xx_udc_stop(struct usb_gadget *gadget) 1847 { 1848 struct bcm63xx_udc *udc = gadget_to_udc(gadget); 1849 unsigned long flags; 1850 1851 spin_lock_irqsave(&udc->lock, flags); 1852 1853 udc->driver = NULL; 1854 1855 /* 1856 * If we switch the PHY too abruptly after dropping D+, the host 1857 * will often complain: 1858 * 1859 * hub 1-0:1.0: port 1 disabled by hub (EMI?), re-enabling... 1860 */ 1861 msleep(100); 1862 1863 bcm63xx_select_phy_mode(udc, false); 1864 set_clocks(udc, false); 1865 1866 spin_unlock_irqrestore(&udc->lock, flags); 1867 1868 return 0; 1869 } 1870 1871 static const struct usb_gadget_ops bcm63xx_udc_ops = { 1872 .get_frame = bcm63xx_udc_get_frame, 1873 .pullup = bcm63xx_udc_pullup, 1874 .udc_start = bcm63xx_udc_start, 1875 .udc_stop = bcm63xx_udc_stop, 1876 }; 1877 1878 /*********************************************************************** 1879 * IRQ handling 1880 ***********************************************************************/ 1881 1882 /** 1883 * bcm63xx_update_cfg_iface - Read current configuration/interface settings. 1884 * @udc: Reference to the device controller. 1885 * 1886 * This controller intercepts SET_CONFIGURATION and SET_INTERFACE messages. 1887 * The driver never sees the raw control packets coming in on the ep0 1888 * IUDMA channel, but at least we get an interrupt event to tell us that 1889 * new values are waiting in the USBD_STATUS register. 1890 */ 1891 static void bcm63xx_update_cfg_iface(struct bcm63xx_udc *udc) 1892 { 1893 u32 reg = usbd_readl(udc, USBD_STATUS_REG); 1894 1895 udc->cfg = (reg & USBD_STATUS_CFG_MASK) >> USBD_STATUS_CFG_SHIFT; 1896 udc->iface = (reg & USBD_STATUS_INTF_MASK) >> USBD_STATUS_INTF_SHIFT; 1897 udc->alt_iface = (reg & USBD_STATUS_ALTINTF_MASK) >> 1898 USBD_STATUS_ALTINTF_SHIFT; 1899 bcm63xx_ep_setup(udc); 1900 } 1901 1902 /** 1903 * bcm63xx_update_link_speed - Check to see if the link speed has changed. 1904 * @udc: Reference to the device controller. 1905 * 1906 * The link speed update coincides with a SETUP IRQ. Returns 1 if the 1907 * speed has changed, so that the caller can update the endpoint settings. 1908 */ 1909 static int bcm63xx_update_link_speed(struct bcm63xx_udc *udc) 1910 { 1911 u32 reg = usbd_readl(udc, USBD_STATUS_REG); 1912 enum usb_device_speed oldspeed = udc->gadget.speed; 1913 1914 switch ((reg & USBD_STATUS_SPD_MASK) >> USBD_STATUS_SPD_SHIFT) { 1915 case BCM63XX_SPD_HIGH: 1916 udc->gadget.speed = USB_SPEED_HIGH; 1917 break; 1918 case BCM63XX_SPD_FULL: 1919 udc->gadget.speed = USB_SPEED_FULL; 1920 break; 1921 default: 1922 /* this should never happen */ 1923 udc->gadget.speed = USB_SPEED_UNKNOWN; 1924 dev_err(udc->dev, 1925 "received SETUP packet with invalid link speed\n"); 1926 return 0; 1927 } 1928 1929 if (udc->gadget.speed != oldspeed) { 1930 dev_info(udc->dev, "link up, %s-speed mode\n", 1931 udc->gadget.speed == USB_SPEED_HIGH ? "high" : "full"); 1932 return 1; 1933 } else { 1934 return 0; 1935 } 1936 } 1937 1938 /** 1939 * bcm63xx_update_wedge - Iterate through wedged endpoints. 1940 * @udc: Reference to the device controller. 1941 * @new_status: true to "refresh" wedge status; false to clear it. 1942 * 1943 * On a SETUP interrupt, we need to manually "refresh" the wedge status 1944 * because the controller hardware is designed to automatically clear 1945 * stalls in response to a CLEAR_FEATURE request from the host. 1946 * 1947 * On a RESET interrupt, we do want to restore all wedged endpoints. 1948 */ 1949 static void bcm63xx_update_wedge(struct bcm63xx_udc *udc, bool new_status) 1950 { 1951 int i; 1952 1953 for_each_set_bit(i, &udc->wedgemap, BCM63XX_NUM_EP) { 1954 bcm63xx_set_stall(udc, &udc->bep[i], new_status); 1955 if (!new_status) 1956 clear_bit(i, &udc->wedgemap); 1957 } 1958 } 1959 1960 /** 1961 * bcm63xx_udc_ctrl_isr - ISR for control path events (USBD). 1962 * @irq: IRQ number (unused). 1963 * @dev_id: Reference to the device controller. 1964 * 1965 * This is where we handle link (VBUS) down, USB reset, speed changes, 1966 * SET_CONFIGURATION, and SET_INTERFACE events. 1967 */ 1968 static irqreturn_t bcm63xx_udc_ctrl_isr(int irq, void *dev_id) 1969 { 1970 struct bcm63xx_udc *udc = dev_id; 1971 u32 stat; 1972 bool disconnected = false, bus_reset = false; 1973 1974 stat = usbd_readl(udc, USBD_EVENT_IRQ_STATUS_REG) & 1975 usbd_readl(udc, USBD_EVENT_IRQ_MASK_REG); 1976 1977 usbd_writel(udc, stat, USBD_EVENT_IRQ_STATUS_REG); 1978 1979 spin_lock(&udc->lock); 1980 if (stat & BIT(USBD_EVENT_IRQ_USB_LINK)) { 1981 /* VBUS toggled */ 1982 1983 if (!(usbd_readl(udc, USBD_EVENTS_REG) & 1984 USBD_EVENTS_USB_LINK_MASK) && 1985 udc->gadget.speed != USB_SPEED_UNKNOWN) 1986 dev_info(udc->dev, "link down\n"); 1987 1988 udc->gadget.speed = USB_SPEED_UNKNOWN; 1989 disconnected = true; 1990 } 1991 if (stat & BIT(USBD_EVENT_IRQ_USB_RESET)) { 1992 bcm63xx_fifo_setup(udc); 1993 bcm63xx_fifo_reset(udc); 1994 bcm63xx_ep_setup(udc); 1995 1996 bcm63xx_update_wedge(udc, false); 1997 1998 udc->ep0_req_reset = 1; 1999 schedule_work(&udc->ep0_wq); 2000 bus_reset = true; 2001 } 2002 if (stat & BIT(USBD_EVENT_IRQ_SETUP)) { 2003 if (bcm63xx_update_link_speed(udc)) { 2004 bcm63xx_fifo_setup(udc); 2005 bcm63xx_ep_setup(udc); 2006 } 2007 bcm63xx_update_wedge(udc, true); 2008 } 2009 if (stat & BIT(USBD_EVENT_IRQ_SETCFG)) { 2010 bcm63xx_update_cfg_iface(udc); 2011 udc->ep0_req_set_cfg = 1; 2012 schedule_work(&udc->ep0_wq); 2013 } 2014 if (stat & BIT(USBD_EVENT_IRQ_SETINTF)) { 2015 bcm63xx_update_cfg_iface(udc); 2016 udc->ep0_req_set_iface = 1; 2017 schedule_work(&udc->ep0_wq); 2018 } 2019 spin_unlock(&udc->lock); 2020 2021 if (disconnected && udc->driver) 2022 udc->driver->disconnect(&udc->gadget); 2023 else if (bus_reset && udc->driver) 2024 usb_gadget_udc_reset(&udc->gadget, udc->driver); 2025 2026 return IRQ_HANDLED; 2027 } 2028 2029 /** 2030 * bcm63xx_udc_data_isr - ISR for data path events (IUDMA). 2031 * @irq: IRQ number (unused). 2032 * @dev_id: Reference to the IUDMA channel that generated the interrupt. 2033 * 2034 * For the two ep0 channels, we have special handling that triggers the 2035 * ep0 worker thread. For normal bulk/intr channels, either queue up 2036 * the next buffer descriptor for the transaction (incomplete transaction), 2037 * or invoke the completion callback (complete transactions). 2038 */ 2039 static irqreturn_t bcm63xx_udc_data_isr(int irq, void *dev_id) 2040 { 2041 struct iudma_ch *iudma = dev_id; 2042 struct bcm63xx_udc *udc = iudma->udc; 2043 struct bcm63xx_ep *bep; 2044 struct usb_request *req = NULL; 2045 struct bcm63xx_req *breq = NULL; 2046 int rc; 2047 bool is_done = false; 2048 2049 spin_lock(&udc->lock); 2050 2051 usb_dmac_writel(udc, ENETDMAC_IR_BUFDONE_MASK, 2052 ENETDMAC_IR_REG, iudma->ch_idx); 2053 bep = iudma->bep; 2054 rc = iudma_read(udc, iudma); 2055 2056 /* special handling for EP0 RX (0) and TX (1) */ 2057 if (iudma->ch_idx == IUDMA_EP0_RXCHAN || 2058 iudma->ch_idx == IUDMA_EP0_TXCHAN) { 2059 req = udc->ep0_request; 2060 breq = our_req(req); 2061 2062 /* a single request could require multiple submissions */ 2063 if (rc >= 0) { 2064 req->actual += rc; 2065 2066 if (req->actual >= req->length || breq->bd_bytes > rc) { 2067 udc->ep0_req_completed = 1; 2068 is_done = true; 2069 schedule_work(&udc->ep0_wq); 2070 2071 /* "actual" on a ZLP is 1 byte */ 2072 req->actual = min(req->actual, req->length); 2073 } else { 2074 /* queue up the next BD (same request) */ 2075 iudma_write(udc, iudma, breq); 2076 } 2077 } 2078 } else if (!list_empty(&bep->queue)) { 2079 breq = list_first_entry(&bep->queue, struct bcm63xx_req, queue); 2080 req = &breq->req; 2081 2082 if (rc >= 0) { 2083 req->actual += rc; 2084 2085 if (req->actual >= req->length || breq->bd_bytes > rc) { 2086 is_done = true; 2087 list_del(&breq->queue); 2088 2089 req->actual = min(req->actual, req->length); 2090 2091 if (!list_empty(&bep->queue)) { 2092 struct bcm63xx_req *next; 2093 2094 next = list_first_entry(&bep->queue, 2095 struct bcm63xx_req, queue); 2096 iudma_write(udc, iudma, next); 2097 } 2098 } else { 2099 iudma_write(udc, iudma, breq); 2100 } 2101 } 2102 } 2103 spin_unlock(&udc->lock); 2104 2105 if (is_done) { 2106 usb_gadget_unmap_request(&udc->gadget, req, iudma->is_tx); 2107 if (req->complete) 2108 req->complete(&bep->ep, req); 2109 } 2110 2111 return IRQ_HANDLED; 2112 } 2113 2114 /*********************************************************************** 2115 * Debug filesystem 2116 ***********************************************************************/ 2117 2118 /* 2119 * bcm63xx_usbd_dbg_show - Show USBD controller state. 2120 * @s: seq_file to which the information will be written. 2121 * @p: Unused. 2122 * 2123 * This file nominally shows up as /sys/kernel/debug/bcm63xx_udc/usbd 2124 */ 2125 static int bcm63xx_usbd_dbg_show(struct seq_file *s, void *p) 2126 { 2127 struct bcm63xx_udc *udc = s->private; 2128 2129 if (!udc->driver) 2130 return -ENODEV; 2131 2132 seq_printf(s, "ep0 state: %s\n", 2133 bcm63xx_ep0_state_names[udc->ep0state]); 2134 seq_printf(s, " pending requests: %s%s%s%s%s%s%s\n", 2135 udc->ep0_req_reset ? "reset " : "", 2136 udc->ep0_req_set_cfg ? "set_cfg " : "", 2137 udc->ep0_req_set_iface ? "set_iface " : "", 2138 udc->ep0_req_shutdown ? "shutdown " : "", 2139 udc->ep0_request ? "pending " : "", 2140 udc->ep0_req_completed ? "completed " : "", 2141 udc->ep0_reply ? "reply " : ""); 2142 seq_printf(s, "cfg: %d; iface: %d; alt_iface: %d\n", 2143 udc->cfg, udc->iface, udc->alt_iface); 2144 seq_printf(s, "regs:\n"); 2145 seq_printf(s, " control: %08x; straps: %08x; status: %08x\n", 2146 usbd_readl(udc, USBD_CONTROL_REG), 2147 usbd_readl(udc, USBD_STRAPS_REG), 2148 usbd_readl(udc, USBD_STATUS_REG)); 2149 seq_printf(s, " events: %08x; stall: %08x\n", 2150 usbd_readl(udc, USBD_EVENTS_REG), 2151 usbd_readl(udc, USBD_STALL_REG)); 2152 2153 return 0; 2154 } 2155 DEFINE_SHOW_ATTRIBUTE(bcm63xx_usbd_dbg); 2156 2157 /* 2158 * bcm63xx_iudma_dbg_show - Show IUDMA status and descriptors. 2159 * @s: seq_file to which the information will be written. 2160 * @p: Unused. 2161 * 2162 * This file nominally shows up as /sys/kernel/debug/bcm63xx_udc/iudma 2163 */ 2164 static int bcm63xx_iudma_dbg_show(struct seq_file *s, void *p) 2165 { 2166 struct bcm63xx_udc *udc = s->private; 2167 int ch_idx, i; 2168 u32 sram2, sram3; 2169 2170 if (!udc->driver) 2171 return -ENODEV; 2172 2173 for (ch_idx = 0; ch_idx < BCM63XX_NUM_IUDMA; ch_idx++) { 2174 struct iudma_ch *iudma = &udc->iudma[ch_idx]; 2175 struct list_head *pos; 2176 2177 seq_printf(s, "IUDMA channel %d -- ", ch_idx); 2178 switch (iudma_defaults[ch_idx].ep_type) { 2179 case BCMEP_CTRL: 2180 seq_printf(s, "control"); 2181 break; 2182 case BCMEP_BULK: 2183 seq_printf(s, "bulk"); 2184 break; 2185 case BCMEP_INTR: 2186 seq_printf(s, "interrupt"); 2187 break; 2188 } 2189 seq_printf(s, ch_idx & 0x01 ? " tx" : " rx"); 2190 seq_printf(s, " [ep%d]:\n", 2191 max_t(int, iudma_defaults[ch_idx].ep_num, 0)); 2192 seq_printf(s, " cfg: %08x; irqstat: %08x; irqmask: %08x; maxburst: %08x\n", 2193 usb_dmac_readl(udc, ENETDMAC_CHANCFG_REG, ch_idx), 2194 usb_dmac_readl(udc, ENETDMAC_IR_REG, ch_idx), 2195 usb_dmac_readl(udc, ENETDMAC_IRMASK_REG, ch_idx), 2196 usb_dmac_readl(udc, ENETDMAC_MAXBURST_REG, ch_idx)); 2197 2198 sram2 = usb_dmas_readl(udc, ENETDMAS_SRAM2_REG, ch_idx); 2199 sram3 = usb_dmas_readl(udc, ENETDMAS_SRAM3_REG, ch_idx); 2200 seq_printf(s, " base: %08x; index: %04x_%04x; desc: %04x_%04x %08x\n", 2201 usb_dmas_readl(udc, ENETDMAS_RSTART_REG, ch_idx), 2202 sram2 >> 16, sram2 & 0xffff, 2203 sram3 >> 16, sram3 & 0xffff, 2204 usb_dmas_readl(udc, ENETDMAS_SRAM4_REG, ch_idx)); 2205 seq_printf(s, " desc: %d/%d used", iudma->n_bds_used, 2206 iudma->n_bds); 2207 2208 if (iudma->bep) { 2209 i = 0; 2210 list_for_each(pos, &iudma->bep->queue) 2211 i++; 2212 seq_printf(s, "; %d queued\n", i); 2213 } else { 2214 seq_printf(s, "\n"); 2215 } 2216 2217 for (i = 0; i < iudma->n_bds; i++) { 2218 struct bcm_enet_desc *d = &iudma->bd_ring[i]; 2219 2220 seq_printf(s, " %03x (%02x): len_stat: %04x_%04x; pa %08x", 2221 i * sizeof(*d), i, 2222 d->len_stat >> 16, d->len_stat & 0xffff, 2223 d->address); 2224 if (d == iudma->read_bd) 2225 seq_printf(s, " <<RD"); 2226 if (d == iudma->write_bd) 2227 seq_printf(s, " <<WR"); 2228 seq_printf(s, "\n"); 2229 } 2230 2231 seq_printf(s, "\n"); 2232 } 2233 2234 return 0; 2235 } 2236 DEFINE_SHOW_ATTRIBUTE(bcm63xx_iudma_dbg); 2237 2238 /** 2239 * bcm63xx_udc_init_debugfs - Create debugfs entries. 2240 * @udc: Reference to the device controller. 2241 */ 2242 static void bcm63xx_udc_init_debugfs(struct bcm63xx_udc *udc) 2243 { 2244 struct dentry *root; 2245 2246 if (!IS_ENABLED(CONFIG_USB_GADGET_DEBUG_FS)) 2247 return; 2248 2249 root = debugfs_create_dir(udc->gadget.name, usb_debug_root); 2250 debugfs_create_file("usbd", 0400, root, udc, &bcm63xx_usbd_dbg_fops); 2251 debugfs_create_file("iudma", 0400, root, udc, &bcm63xx_iudma_dbg_fops); 2252 } 2253 2254 /** 2255 * bcm63xx_udc_cleanup_debugfs - Remove debugfs entries. 2256 * @udc: Reference to the device controller. 2257 * 2258 * debugfs_remove() is safe to call with a NULL argument. 2259 */ 2260 static void bcm63xx_udc_cleanup_debugfs(struct bcm63xx_udc *udc) 2261 { 2262 debugfs_remove(debugfs_lookup(udc->gadget.name, usb_debug_root)); 2263 } 2264 2265 /*********************************************************************** 2266 * Driver init/exit 2267 ***********************************************************************/ 2268 2269 /** 2270 * bcm63xx_udc_probe - Initialize a new instance of the UDC. 2271 * @pdev: Platform device struct from the bcm63xx BSP code. 2272 * 2273 * Note that platform data is required, because pd.port_no varies from chip 2274 * to chip and is used to switch the correct USB port to device mode. 2275 */ 2276 static int bcm63xx_udc_probe(struct platform_device *pdev) 2277 { 2278 struct device *dev = &pdev->dev; 2279 struct bcm63xx_usbd_platform_data *pd = dev_get_platdata(dev); 2280 struct bcm63xx_udc *udc; 2281 int rc = -ENOMEM, i, irq; 2282 2283 udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL); 2284 if (!udc) 2285 return -ENOMEM; 2286 2287 platform_set_drvdata(pdev, udc); 2288 udc->dev = dev; 2289 udc->pd = pd; 2290 2291 if (!pd) { 2292 dev_err(dev, "missing platform data\n"); 2293 return -EINVAL; 2294 } 2295 2296 udc->usbd_regs = devm_platform_ioremap_resource(pdev, 0); 2297 if (IS_ERR(udc->usbd_regs)) 2298 return PTR_ERR(udc->usbd_regs); 2299 2300 udc->iudma_regs = devm_platform_ioremap_resource(pdev, 1); 2301 if (IS_ERR(udc->iudma_regs)) 2302 return PTR_ERR(udc->iudma_regs); 2303 2304 spin_lock_init(&udc->lock); 2305 INIT_WORK(&udc->ep0_wq, bcm63xx_ep0_process); 2306 2307 udc->gadget.ops = &bcm63xx_udc_ops; 2308 udc->gadget.name = dev_name(dev); 2309 2310 if (!pd->use_fullspeed && !use_fullspeed) 2311 udc->gadget.max_speed = USB_SPEED_HIGH; 2312 else 2313 udc->gadget.max_speed = USB_SPEED_FULL; 2314 2315 /* request clocks, allocate buffers, and clear any pending IRQs */ 2316 rc = bcm63xx_init_udc_hw(udc); 2317 if (rc) 2318 return rc; 2319 2320 rc = -ENXIO; 2321 2322 /* IRQ resource #0: control interrupt (VBUS, speed, etc.) */ 2323 irq = platform_get_irq(pdev, 0); 2324 if (irq < 0) { 2325 rc = irq; 2326 goto out_uninit; 2327 } 2328 if (devm_request_irq(dev, irq, &bcm63xx_udc_ctrl_isr, 0, 2329 dev_name(dev), udc) < 0) 2330 goto report_request_failure; 2331 2332 /* IRQ resources #1-6: data interrupts for IUDMA channels 0-5 */ 2333 for (i = 0; i < BCM63XX_NUM_IUDMA; i++) { 2334 irq = platform_get_irq(pdev, i + 1); 2335 if (irq < 0) { 2336 rc = irq; 2337 goto out_uninit; 2338 } 2339 if (devm_request_irq(dev, irq, &bcm63xx_udc_data_isr, 0, 2340 dev_name(dev), &udc->iudma[i]) < 0) 2341 goto report_request_failure; 2342 } 2343 2344 bcm63xx_udc_init_debugfs(udc); 2345 rc = usb_add_gadget_udc(dev, &udc->gadget); 2346 if (!rc) 2347 return 0; 2348 2349 bcm63xx_udc_cleanup_debugfs(udc); 2350 out_uninit: 2351 bcm63xx_uninit_udc_hw(udc); 2352 return rc; 2353 2354 report_request_failure: 2355 dev_err(dev, "error requesting IRQ #%d\n", irq); 2356 goto out_uninit; 2357 } 2358 2359 /** 2360 * bcm63xx_udc_remove - Remove the device from the system. 2361 * @pdev: Platform device struct from the bcm63xx BSP code. 2362 */ 2363 static int bcm63xx_udc_remove(struct platform_device *pdev) 2364 { 2365 struct bcm63xx_udc *udc = platform_get_drvdata(pdev); 2366 2367 bcm63xx_udc_cleanup_debugfs(udc); 2368 usb_del_gadget_udc(&udc->gadget); 2369 BUG_ON(udc->driver); 2370 2371 bcm63xx_uninit_udc_hw(udc); 2372 2373 return 0; 2374 } 2375 2376 static struct platform_driver bcm63xx_udc_driver = { 2377 .probe = bcm63xx_udc_probe, 2378 .remove = bcm63xx_udc_remove, 2379 .driver = { 2380 .name = DRV_MODULE_NAME, 2381 }, 2382 }; 2383 module_platform_driver(bcm63xx_udc_driver); 2384 2385 MODULE_DESCRIPTION("BCM63xx USB Peripheral Controller"); 2386 MODULE_AUTHOR("Kevin Cernekee <cernekee@gmail.com>"); 2387 MODULE_LICENSE("GPL"); 2388 MODULE_ALIAS("platform:" DRV_MODULE_NAME); 2389