kernel/drivers/usb/gadget/udc/bcm63xx_udc.c

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