1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * bcm63xx_udc.c -- BCM63xx UDC high/full speed USB device controller |
4 | * |
5 | * Copyright (C) 2012 Kevin Cernekee <cernekee@gmail.com> |
6 | * Copyright (C) 2012 Broadcom Corporation |
7 | */ |
8 | |
9 | #include <linux/bitops.h> |
10 | #include <linux/bug.h> |
11 | #include <linux/clk.h> |
12 | #include <linux/compiler.h> |
13 | #include <linux/debugfs.h> |
14 | #include <linux/delay.h> |
15 | #include <linux/device.h> |
16 | #include <linux/dma-mapping.h> |
17 | #include <linux/errno.h> |
18 | #include <linux/interrupt.h> |
19 | #include <linux/ioport.h> |
20 | #include <linux/kernel.h> |
21 | #include <linux/list.h> |
22 | #include <linux/module.h> |
23 | #include <linux/moduleparam.h> |
24 | #include <linux/platform_device.h> |
25 | #include <linux/sched.h> |
26 | #include <linux/seq_file.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/timer.h> |
29 | #include <linux/usb.h> |
30 | #include <linux/usb/ch9.h> |
31 | #include <linux/usb/gadget.h> |
32 | #include <linux/workqueue.h> |
33 | |
34 | #include <bcm63xx_cpu.h> |
35 | #include <bcm63xx_iudma.h> |
36 | #include <bcm63xx_dev_usb_usbd.h> |
37 | #include <bcm63xx_io.h> |
38 | #include <bcm63xx_regs.h> |
39 | |
40 | #define DRV_MODULE_NAME "bcm63xx_udc" |
41 | |
42 | static const char bcm63xx_ep0name[] = "ep0" ; |
43 | |
44 | static const struct { |
45 | const char *name; |
46 | const struct usb_ep_caps caps; |
47 | } bcm63xx_ep_info[] = { |
48 | #define EP_INFO(_name, _caps) \ |
49 | { \ |
50 | .name = _name, \ |
51 | .caps = _caps, \ |
52 | } |
53 | |
54 | EP_INFO(bcm63xx_ep0name, |
55 | USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)), |
56 | EP_INFO("ep1in-bulk" , |
57 | USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)), |
58 | EP_INFO("ep2out-bulk" , |
59 | USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)), |
60 | EP_INFO("ep3in-int" , |
61 | USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)), |
62 | EP_INFO("ep4out-int" , |
63 | USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_OUT)), |
64 | |
65 | #undef EP_INFO |
66 | }; |
67 | |
68 | static bool use_fullspeed; |
69 | module_param(use_fullspeed, bool, S_IRUGO); |
70 | MODULE_PARM_DESC(use_fullspeed, "true for fullspeed only" ); |
71 | |
72 | /* |
73 | * RX IRQ coalescing options: |
74 | * |
75 | * false (default) - one IRQ per DATAx packet. Slow but reliable. The |
76 | * driver is able to pass the "testusb" suite and recover from conditions like: |
77 | * |
78 | * 1) Device queues up a 2048-byte RX IUDMA transaction on an OUT bulk ep |
79 | * 2) Host sends 512 bytes of data |
80 | * 3) Host decides to reconfigure the device and sends SET_INTERFACE |
81 | * 4) Device shuts down the endpoint and cancels the RX transaction |
82 | * |
83 | * true - one IRQ per transfer, for transfers <= 2048B. Generates |
84 | * considerably fewer IRQs, but error recovery is less robust. Does not |
85 | * reliably pass "testusb". |
86 | * |
87 | * TX always uses coalescing, because we can cancel partially complete TX |
88 | * transfers by repeatedly flushing the FIFO. The hardware doesn't allow |
89 | * this on RX. |
90 | */ |
91 | static bool irq_coalesce; |
92 | module_param(irq_coalesce, bool, S_IRUGO); |
93 | MODULE_PARM_DESC(irq_coalesce, "take one IRQ per RX transfer" ); |
94 | |
95 | #define BCM63XX_NUM_EP 5 |
96 | #define BCM63XX_NUM_IUDMA 6 |
97 | #define BCM63XX_NUM_FIFO_PAIRS 3 |
98 | |
99 | #define IUDMA_RESET_TIMEOUT_US 10000 |
100 | |
101 | #define IUDMA_EP0_RXCHAN 0 |
102 | #define IUDMA_EP0_TXCHAN 1 |
103 | |
104 | #define IUDMA_MAX_FRAGMENT 2048 |
105 | #define BCM63XX_MAX_CTRL_PKT 64 |
106 | |
107 | #define BCMEP_CTRL 0x00 |
108 | #define BCMEP_ISOC 0x01 |
109 | #define BCMEP_BULK 0x02 |
110 | #define BCMEP_INTR 0x03 |
111 | |
112 | #define BCMEP_OUT 0x00 |
113 | #define BCMEP_IN 0x01 |
114 | |
115 | #define BCM63XX_SPD_FULL 1 |
116 | #define BCM63XX_SPD_HIGH 0 |
117 | |
118 | #define IUDMA_DMAC_OFFSET 0x200 |
119 | #define IUDMA_DMAS_OFFSET 0x400 |
120 | |
121 | enum bcm63xx_ep0_state { |
122 | EP0_REQUEUE, |
123 | EP0_IDLE, |
124 | EP0_IN_DATA_PHASE_SETUP, |
125 | EP0_IN_DATA_PHASE_COMPLETE, |
126 | EP0_OUT_DATA_PHASE_SETUP, |
127 | EP0_OUT_DATA_PHASE_COMPLETE, |
128 | EP0_OUT_STATUS_PHASE, |
129 | EP0_IN_FAKE_STATUS_PHASE, |
130 | EP0_SHUTDOWN, |
131 | }; |
132 | |
133 | static const char __maybe_unused bcm63xx_ep0_state_names[][32] = { |
134 | "REQUEUE" , |
135 | "IDLE" , |
136 | "IN_DATA_PHASE_SETUP" , |
137 | "IN_DATA_PHASE_COMPLETE" , |
138 | "OUT_DATA_PHASE_SETUP" , |
139 | "OUT_DATA_PHASE_COMPLETE" , |
140 | "OUT_STATUS_PHASE" , |
141 | "IN_FAKE_STATUS_PHASE" , |
142 | "SHUTDOWN" , |
143 | }; |
144 | |
145 | /** |
146 | * struct iudma_ch_cfg - Static configuration for an IUDMA channel. |
147 | * @ep_num: USB endpoint number. |
148 | * @n_bds: Number of buffer descriptors in the ring. |
149 | * @ep_type: Endpoint type (control, bulk, interrupt). |
150 | * @dir: Direction (in, out). |
151 | * @n_fifo_slots: Number of FIFO entries to allocate for this channel. |
152 | * @max_pkt_hs: Maximum packet size in high speed mode. |
153 | * @max_pkt_fs: Maximum packet size in full speed mode. |
154 | */ |
155 | struct iudma_ch_cfg { |
156 | int ep_num; |
157 | int n_bds; |
158 | int ep_type; |
159 | int dir; |
160 | int n_fifo_slots; |
161 | int max_pkt_hs; |
162 | int max_pkt_fs; |
163 | }; |
164 | |
165 | static const struct iudma_ch_cfg iudma_defaults[] = { |
166 | |
167 | /* This controller was designed to support a CDC/RNDIS application. |
168 | It may be possible to reconfigure some of the endpoints, but |
169 | the hardware limitations (FIFO sizing and number of DMA channels) |
170 | may significantly impact flexibility and/or stability. Change |
171 | these values at your own risk. |
172 | |
173 | ep_num ep_type n_fifo_slots max_pkt_fs |
174 | idx | n_bds | dir | max_pkt_hs | |
175 | | | | | | | | | */ |
176 | [0] = { -1, 4, BCMEP_CTRL, BCMEP_OUT, 32, 64, 64 }, |
177 | [1] = { 0, 4, BCMEP_CTRL, BCMEP_OUT, 32, 64, 64 }, |
178 | [2] = { 2, 16, BCMEP_BULK, BCMEP_OUT, 128, 512, 64 }, |
179 | [3] = { 1, 16, BCMEP_BULK, BCMEP_IN, 128, 512, 64 }, |
180 | [4] = { 4, 4, BCMEP_INTR, BCMEP_OUT, 32, 64, 64 }, |
181 | [5] = { 3, 4, BCMEP_INTR, BCMEP_IN, 32, 64, 64 }, |
182 | }; |
183 | |
184 | struct bcm63xx_udc; |
185 | |
186 | /** |
187 | * struct iudma_ch - Represents the current state of a single IUDMA channel. |
188 | * @ch_idx: IUDMA channel index (0 to BCM63XX_NUM_IUDMA-1). |
189 | * @ep_num: USB endpoint number. -1 for ep0 RX. |
190 | * @enabled: Whether bcm63xx_ep_enable() has been called. |
191 | * @max_pkt: "Chunk size" on the USB interface. Based on interface speed. |
192 | * @is_tx: true for TX, false for RX. |
193 | * @bep: Pointer to the associated endpoint. NULL for ep0 RX. |
194 | * @udc: Reference to the device controller. |
195 | * @read_bd: Next buffer descriptor to reap from the hardware. |
196 | * @write_bd: Next BD available for a new packet. |
197 | * @end_bd: Points to the final BD in the ring. |
198 | * @n_bds_used: Number of BD entries currently occupied. |
199 | * @bd_ring: Base pointer to the BD ring. |
200 | * @bd_ring_dma: Physical (DMA) address of bd_ring. |
201 | * @n_bds: Total number of BDs in the ring. |
202 | * |
203 | * ep0 has two IUDMA channels (IUDMA_EP0_RXCHAN and IUDMA_EP0_TXCHAN), as it is |
204 | * bidirectional. The "struct usb_ep" associated with ep0 is for TX (IN) |
205 | * only. |
206 | * |
207 | * Each bulk/intr endpoint has a single IUDMA channel and a single |
208 | * struct usb_ep. |
209 | */ |
210 | struct iudma_ch { |
211 | unsigned int ch_idx; |
212 | int ep_num; |
213 | bool enabled; |
214 | int max_pkt; |
215 | bool is_tx; |
216 | struct bcm63xx_ep *bep; |
217 | struct bcm63xx_udc *udc; |
218 | |
219 | struct bcm_enet_desc *read_bd; |
220 | struct bcm_enet_desc *write_bd; |
221 | struct bcm_enet_desc *end_bd; |
222 | int n_bds_used; |
223 | |
224 | struct bcm_enet_desc *bd_ring; |
225 | dma_addr_t bd_ring_dma; |
226 | unsigned int n_bds; |
227 | }; |
228 | |
229 | /** |
230 | * struct bcm63xx_ep - Internal (driver) state of a single endpoint. |
231 | * @ep_num: USB endpoint number. |
232 | * @iudma: Pointer to IUDMA channel state. |
233 | * @ep: USB gadget layer representation of the EP. |
234 | * @udc: Reference to the device controller. |
235 | * @queue: Linked list of outstanding requests for this EP. |
236 | * @halted: 1 if the EP is stalled; 0 otherwise. |
237 | */ |
238 | struct bcm63xx_ep { |
239 | unsigned int ep_num; |
240 | struct iudma_ch *iudma; |
241 | struct usb_ep ep; |
242 | struct bcm63xx_udc *udc; |
243 | struct list_head queue; |
244 | unsigned halted:1; |
245 | }; |
246 | |
247 | /** |
248 | * struct bcm63xx_req - Internal (driver) state of a single request. |
249 | * @queue: Links back to the EP's request list. |
250 | * @req: USB gadget layer representation of the request. |
251 | * @offset: Current byte offset into the data buffer (next byte to queue). |
252 | * @bd_bytes: Number of data bytes in outstanding BD entries. |
253 | * @iudma: IUDMA channel used for the request. |
254 | */ |
255 | struct bcm63xx_req { |
256 | struct list_head queue; /* ep's requests */ |
257 | struct usb_request req; |
258 | unsigned int offset; |
259 | unsigned int bd_bytes; |
260 | struct iudma_ch *iudma; |
261 | }; |
262 | |
263 | /** |
264 | * struct bcm63xx_udc - Driver/hardware private context. |
265 | * @lock: Spinlock to mediate access to this struct, and (most) HW regs. |
266 | * @dev: Generic Linux device structure. |
267 | * @pd: Platform data (board/port info). |
268 | * @usbd_clk: Clock descriptor for the USB device block. |
269 | * @usbh_clk: Clock descriptor for the USB host block. |
270 | * @gadget: USB device. |
271 | * @driver: Driver for USB device. |
272 | * @usbd_regs: Base address of the USBD/USB20D block. |
273 | * @iudma_regs: Base address of the USBD's associated IUDMA block. |
274 | * @bep: Array of endpoints, including ep0. |
275 | * @iudma: Array of all IUDMA channels used by this controller. |
276 | * @cfg: USB configuration number, from SET_CONFIGURATION wValue. |
277 | * @iface: USB interface number, from SET_INTERFACE wIndex. |
278 | * @alt_iface: USB alt interface number, from SET_INTERFACE wValue. |
279 | * @ep0_ctrl_req: Request object for bcm63xx_udc-initiated ep0 transactions. |
280 | * @ep0_ctrl_buf: Data buffer for ep0_ctrl_req. |
281 | * @ep0state: Current state of the ep0 state machine. |
282 | * @ep0_wq: Workqueue struct used to wake up the ep0 state machine. |
283 | * @wedgemap: Bitmap of wedged endpoints. |
284 | * @ep0_req_reset: USB reset is pending. |
285 | * @ep0_req_set_cfg: Need to spoof a SET_CONFIGURATION packet. |
286 | * @ep0_req_set_iface: Need to spoof a SET_INTERFACE packet. |
287 | * @ep0_req_shutdown: Driver is shutting down; requesting ep0 to halt activity. |
288 | * @ep0_req_completed: ep0 request has completed; worker has not seen it yet. |
289 | * @ep0_reply: Pending reply from gadget driver. |
290 | * @ep0_request: Outstanding ep0 request. |
291 | */ |
292 | struct 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 | |
331 | static const struct usb_ep_ops bcm63xx_udc_ep_ops; |
332 | |
333 | /*********************************************************************** |
334 | * Convenience functions |
335 | ***********************************************************************/ |
336 | |
337 | static inline struct bcm63xx_udc *gadget_to_udc(struct usb_gadget *g) |
338 | { |
339 | return container_of(g, struct bcm63xx_udc, gadget); |
340 | } |
341 | |
342 | static inline struct bcm63xx_ep *our_ep(struct usb_ep *ep) |
343 | { |
344 | return container_of(ep, struct bcm63xx_ep, ep); |
345 | } |
346 | |
347 | static inline struct bcm63xx_req *our_req(struct usb_request *req) |
348 | { |
349 | return container_of(req, struct bcm63xx_req, req); |
350 | } |
351 | |
352 | static inline u32 usbd_readl(struct bcm63xx_udc *udc, u32 off) |
353 | { |
354 | return bcm_readl(udc->usbd_regs + off); |
355 | } |
356 | |
357 | static inline void usbd_writel(struct bcm63xx_udc *udc, u32 val, u32 off) |
358 | { |
359 | bcm_writel(val, udc->usbd_regs + off); |
360 | } |
361 | |
362 | static inline u32 usb_dma_readl(struct bcm63xx_udc *udc, u32 off) |
363 | { |
364 | return bcm_readl(udc->iudma_regs + off); |
365 | } |
366 | |
367 | static inline void usb_dma_writel(struct bcm63xx_udc *udc, u32 val, u32 off) |
368 | { |
369 | bcm_writel(val, udc->iudma_regs + off); |
370 | } |
371 | |
372 | static 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 | |
378 | static 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 | |
385 | static 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 | |
391 | static 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 | |
398 | static 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 | */ |
423 | static 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 | */ |
441 | static 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 | */ |
459 | static 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 | */ |
499 | static 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 | */ |
515 | static 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 | */ |
527 | static 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 | */ |
550 | static 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 | */ |
592 | static 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, = 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 | */ |
668 | static 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 | */ |
702 | static 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 | */ |
758 | static 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 | */ |
798 | static 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 | */ |
821 | static 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 | */ |
842 | static 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 | */ |
868 | static 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 | */ |
908 | static 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 | */ |
927 | static 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 | */ |
941 | static 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 | */ |
1030 | static 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 | */ |
1070 | static 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 | */ |
1113 | static 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 | */ |
1129 | static 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 | */ |
1150 | static 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 | |
1189 | out: |
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 | */ |
1203 | static 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 | |
1235 | out: |
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 | */ |
1251 | static 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 | */ |
1271 | static 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 | |
1285 | static 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 | */ |
1308 | static 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 | */ |
1331 | static 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 | */ |
1355 | static 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 | */ |
1381 | static 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 | */ |
1402 | static 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 | */ |
1421 | static 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 | */ |
1439 | static 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 | */ |
1458 | static 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 | */ |
1478 | static 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 | */ |
1531 | static 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 | */ |
1578 | static 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 | */ |
1730 | static 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 | */ |
1747 | static 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 | */ |
1762 | static 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 | */ |
1809 | static 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 | */ |
1845 | static 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 | |
1870 | static 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 | */ |
1890 | static 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 | */ |
1908 | static 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 | */ |
1948 | static 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 | */ |
1967 | static 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 | */ |
2038 | static 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 | */ |
2124 | static 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 | } |
2154 | DEFINE_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 | */ |
2163 | static 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 | } |
2230 | DEFINE_SHOW_ATTRIBUTE(bcm63xx_iudma_dbg); |
2231 | |
2232 | /** |
2233 | * bcm63xx_udc_init_debugfs - Create debugfs entries. |
2234 | * @udc: Reference to the device controller. |
2235 | */ |
2236 | static 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 | */ |
2254 | static 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 | */ |
2270 | static 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); |
2344 | out_uninit: |
2345 | bcm63xx_uninit_udc_hw(udc); |
2346 | return rc; |
2347 | |
2348 | report_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 | */ |
2357 | static 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 | |
2368 | static 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 | }; |
2375 | module_platform_driver(bcm63xx_udc_driver); |
2376 | |
2377 | MODULE_DESCRIPTION("BCM63xx USB Peripheral Controller" ); |
2378 | MODULE_AUTHOR("Kevin Cernekee <cernekee@gmail.com>" ); |
2379 | MODULE_LICENSE("GPL" ); |
2380 | MODULE_ALIAS("platform:" DRV_MODULE_NAME); |
2381 | |