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

source code of linux/drivers/usb/gadget/udc/bcm63xx_udc.c