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