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