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