1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * at91_udc -- driver for at91-series USB peripheral controller |
4 | * |
5 | * Copyright (C) 2004 by Thomas Rathbone |
6 | * Copyright (C) 2005 by HP Labs |
7 | * Copyright (C) 2005 by David Brownell |
8 | */ |
9 | |
10 | #undef VERBOSE_DEBUG |
11 | #undef PACKET_TRACE |
12 | |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/delay.h> |
17 | #include <linux/ioport.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/errno.h> |
20 | #include <linux/list.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/proc_fs.h> |
23 | #include <linux/prefetch.h> |
24 | #include <linux/clk.h> |
25 | #include <linux/usb/ch9.h> |
26 | #include <linux/usb/gadget.h> |
27 | #include <linux/of.h> |
28 | #include <linux/gpio/consumer.h> |
29 | #include <linux/platform_data/atmel.h> |
30 | #include <linux/regmap.h> |
31 | #include <linux/mfd/syscon.h> |
32 | #include <linux/mfd/syscon/atmel-matrix.h> |
33 | |
34 | #include "at91_udc.h" |
35 | |
36 | |
37 | /* |
38 | * This controller is simple and PIO-only. It's used in many AT91-series |
39 | * full speed USB controllers, including the at91rm9200 (arm920T, with MMU), |
40 | * at91sam926x (arm926ejs, with MMU), and several no-mmu versions. |
41 | * |
42 | * This driver expects the board has been wired with two GPIOs supporting |
43 | * a VBUS sensing IRQ, and a D+ pullup. (They may be omitted, but the |
44 | * testing hasn't covered such cases.) |
45 | * |
46 | * The pullup is most important (so it's integrated on sam926x parts). It |
47 | * provides software control over whether the host enumerates the device. |
48 | * |
49 | * The VBUS sensing helps during enumeration, and allows both USB clocks |
50 | * (and the transceiver) to stay gated off until they're necessary, saving |
51 | * power. During USB suspend, the 48 MHz clock is gated off in hardware; |
52 | * it may also be gated off by software during some Linux sleep states. |
53 | */ |
54 | |
55 | #define DRIVER_VERSION "3 May 2006" |
56 | |
57 | static const char driver_name [] = "at91_udc" ; |
58 | |
59 | static const struct { |
60 | const char *name; |
61 | const struct usb_ep_caps caps; |
62 | } ep_info[] = { |
63 | #define EP_INFO(_name, _caps) \ |
64 | { \ |
65 | .name = _name, \ |
66 | .caps = _caps, \ |
67 | } |
68 | |
69 | EP_INFO("ep0" , |
70 | USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)), |
71 | EP_INFO("ep1" , |
72 | USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_ALL)), |
73 | EP_INFO("ep2" , |
74 | USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_ALL)), |
75 | EP_INFO("ep3-int" , |
76 | USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_ALL)), |
77 | EP_INFO("ep4" , |
78 | USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_ALL)), |
79 | EP_INFO("ep5" , |
80 | USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_ALL)), |
81 | |
82 | #undef EP_INFO |
83 | }; |
84 | |
85 | #define ep0name ep_info[0].name |
86 | |
87 | #define VBUS_POLL_TIMEOUT msecs_to_jiffies(1000) |
88 | |
89 | #define at91_udp_read(udc, reg) \ |
90 | __raw_readl((udc)->udp_baseaddr + (reg)) |
91 | #define at91_udp_write(udc, reg, val) \ |
92 | __raw_writel((val), (udc)->udp_baseaddr + (reg)) |
93 | |
94 | /*-------------------------------------------------------------------------*/ |
95 | |
96 | #ifdef CONFIG_USB_GADGET_DEBUG_FILES |
97 | |
98 | #include <linux/seq_file.h> |
99 | |
100 | static const char debug_filename[] = "driver/udc" ; |
101 | |
102 | #define FOURBITS "%s%s%s%s" |
103 | #define EIGHTBITS FOURBITS FOURBITS |
104 | |
105 | static void proc_ep_show(struct seq_file *s, struct at91_ep *ep) |
106 | { |
107 | static char *types[] = { |
108 | "control" , "out-iso" , "out-bulk" , "out-int" , |
109 | "BOGUS" , "in-iso" , "in-bulk" , "in-int" }; |
110 | |
111 | u32 csr; |
112 | struct at91_request *req; |
113 | unsigned long flags; |
114 | struct at91_udc *udc = ep->udc; |
115 | |
116 | spin_lock_irqsave(&udc->lock, flags); |
117 | |
118 | csr = __raw_readl(addr: ep->creg); |
119 | |
120 | /* NOTE: not collecting per-endpoint irq statistics... */ |
121 | |
122 | seq_printf(m: s, fmt: "\n" ); |
123 | seq_printf(m: s, fmt: "%s, maxpacket %d %s%s %s%s\n" , |
124 | ep->ep.name, ep->ep.maxpacket, |
125 | ep->is_in ? "in" : "out" , |
126 | ep->is_iso ? " iso" : "" , |
127 | ep->is_pingpong |
128 | ? (ep->fifo_bank ? "pong" : "ping" ) |
129 | : "" , |
130 | ep->stopped ? " stopped" : "" ); |
131 | seq_printf(m: s, fmt: "csr %08x rxbytes=%d %s %s %s" EIGHTBITS "\n" , |
132 | csr, |
133 | (csr & 0x07ff0000) >> 16, |
134 | (csr & (1 << 15)) ? "enabled" : "disabled" , |
135 | (csr & (1 << 11)) ? "DATA1" : "DATA0" , |
136 | types[(csr & 0x700) >> 8], |
137 | |
138 | /* iff type is control then print current direction */ |
139 | (!(csr & 0x700)) |
140 | ? ((csr & (1 << 7)) ? " IN" : " OUT" ) |
141 | : "" , |
142 | (csr & (1 << 6)) ? " rxdatabk1" : "" , |
143 | (csr & (1 << 5)) ? " forcestall" : "" , |
144 | (csr & (1 << 4)) ? " txpktrdy" : "" , |
145 | |
146 | (csr & (1 << 3)) ? " stallsent" : "" , |
147 | (csr & (1 << 2)) ? " rxsetup" : "" , |
148 | (csr & (1 << 1)) ? " rxdatabk0" : "" , |
149 | (csr & (1 << 0)) ? " txcomp" : "" ); |
150 | if (list_empty (head: &ep->queue)) |
151 | seq_printf(m: s, fmt: "\t(queue empty)\n" ); |
152 | |
153 | else list_for_each_entry (req, &ep->queue, queue) { |
154 | unsigned length = req->req.actual; |
155 | |
156 | seq_printf(m: s, fmt: "\treq %p len %d/%d buf %p\n" , |
157 | &req->req, length, |
158 | req->req.length, req->req.buf); |
159 | } |
160 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
161 | } |
162 | |
163 | static void proc_irq_show(struct seq_file *s, const char *label, u32 mask) |
164 | { |
165 | int i; |
166 | |
167 | seq_printf(m: s, fmt: "%s %04x:%s%s" FOURBITS, label, mask, |
168 | (mask & (1 << 13)) ? " wakeup" : "" , |
169 | (mask & (1 << 12)) ? " endbusres" : "" , |
170 | |
171 | (mask & (1 << 11)) ? " sofint" : "" , |
172 | (mask & (1 << 10)) ? " extrsm" : "" , |
173 | (mask & (1 << 9)) ? " rxrsm" : "" , |
174 | (mask & (1 << 8)) ? " rxsusp" : "" ); |
175 | for (i = 0; i < 8; i++) { |
176 | if (mask & (1 << i)) |
177 | seq_printf(m: s, fmt: " ep%d" , i); |
178 | } |
179 | seq_printf(m: s, fmt: "\n" ); |
180 | } |
181 | |
182 | static int proc_udc_show(struct seq_file *s, void *unused) |
183 | { |
184 | struct at91_udc *udc = s->private; |
185 | struct at91_ep *ep; |
186 | u32 tmp; |
187 | |
188 | seq_printf(m: s, fmt: "%s: version %s\n" , driver_name, DRIVER_VERSION); |
189 | |
190 | seq_printf(m: s, fmt: "vbus %s, pullup %s, %s powered%s, gadget %s\n\n" , |
191 | udc->vbus ? "present" : "off" , |
192 | udc->enabled |
193 | ? (udc->vbus ? "active" : "enabled" ) |
194 | : "disabled" , |
195 | udc->gadget.is_selfpowered ? "self" : "VBUS" , |
196 | udc->suspended ? ", suspended" : "" , |
197 | udc->driver ? udc->driver->driver.name : "(none)" ); |
198 | |
199 | /* don't access registers when interface isn't clocked */ |
200 | if (!udc->clocked) { |
201 | seq_printf(m: s, fmt: "(not clocked)\n" ); |
202 | return 0; |
203 | } |
204 | |
205 | tmp = at91_udp_read(udc, AT91_UDP_FRM_NUM); |
206 | seq_printf(m: s, fmt: "frame %05x:%s%s frame=%d\n" , tmp, |
207 | (tmp & AT91_UDP_FRM_OK) ? " ok" : "" , |
208 | (tmp & AT91_UDP_FRM_ERR) ? " err" : "" , |
209 | (tmp & AT91_UDP_NUM)); |
210 | |
211 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
212 | seq_printf(m: s, fmt: "glbstate %02x:%s" FOURBITS "\n" , tmp, |
213 | (tmp & AT91_UDP_RMWUPE) ? " rmwupe" : "" , |
214 | (tmp & AT91_UDP_RSMINPR) ? " rsminpr" : "" , |
215 | (tmp & AT91_UDP_ESR) ? " esr" : "" , |
216 | (tmp & AT91_UDP_CONFG) ? " confg" : "" , |
217 | (tmp & AT91_UDP_FADDEN) ? " fadden" : "" ); |
218 | |
219 | tmp = at91_udp_read(udc, AT91_UDP_FADDR); |
220 | seq_printf(m: s, fmt: "faddr %03x:%s fadd=%d\n" , tmp, |
221 | (tmp & AT91_UDP_FEN) ? " fen" : "" , |
222 | (tmp & AT91_UDP_FADD)); |
223 | |
224 | proc_irq_show(s, label: "imr " , at91_udp_read(udc, AT91_UDP_IMR)); |
225 | proc_irq_show(s, label: "isr " , at91_udp_read(udc, AT91_UDP_ISR)); |
226 | |
227 | if (udc->enabled && udc->vbus) { |
228 | proc_ep_show(s, ep: &udc->ep[0]); |
229 | list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) { |
230 | if (ep->ep.desc) |
231 | proc_ep_show(s, ep); |
232 | } |
233 | } |
234 | return 0; |
235 | } |
236 | |
237 | static void create_debug_file(struct at91_udc *udc) |
238 | { |
239 | udc->pde = proc_create_single_data(name: debug_filename, mode: 0, NULL, |
240 | show: proc_udc_show, data: udc); |
241 | } |
242 | |
243 | static void remove_debug_file(struct at91_udc *udc) |
244 | { |
245 | if (udc->pde) |
246 | remove_proc_entry(debug_filename, NULL); |
247 | } |
248 | |
249 | #else |
250 | |
251 | static inline void create_debug_file(struct at91_udc *udc) {} |
252 | static inline void remove_debug_file(struct at91_udc *udc) {} |
253 | |
254 | #endif |
255 | |
256 | |
257 | /*-------------------------------------------------------------------------*/ |
258 | |
259 | static void done(struct at91_ep *ep, struct at91_request *req, int status) |
260 | { |
261 | unsigned stopped = ep->stopped; |
262 | struct at91_udc *udc = ep->udc; |
263 | |
264 | list_del_init(entry: &req->queue); |
265 | if (req->req.status == -EINPROGRESS) |
266 | req->req.status = status; |
267 | else |
268 | status = req->req.status; |
269 | if (status && status != -ESHUTDOWN) |
270 | VDBG("%s done %p, status %d\n" , ep->ep.name, req, status); |
271 | |
272 | ep->stopped = 1; |
273 | spin_unlock(lock: &udc->lock); |
274 | usb_gadget_giveback_request(ep: &ep->ep, req: &req->req); |
275 | spin_lock(lock: &udc->lock); |
276 | ep->stopped = stopped; |
277 | |
278 | /* ep0 is always ready; other endpoints need a non-empty queue */ |
279 | if (list_empty(head: &ep->queue) && ep->int_mask != (1 << 0)) |
280 | at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask); |
281 | } |
282 | |
283 | /*-------------------------------------------------------------------------*/ |
284 | |
285 | /* bits indicating OUT fifo has data ready */ |
286 | #define RX_DATA_READY (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1) |
287 | |
288 | /* |
289 | * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write |
290 | * back most of the value you just read (because of side effects, including |
291 | * bits that may change after reading and before writing). |
292 | * |
293 | * Except when changing a specific bit, always write values which: |
294 | * - clear SET_FX bits (setting them could change something) |
295 | * - set CLR_FX bits (clearing them could change something) |
296 | * |
297 | * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE |
298 | * that shouldn't normally be changed. |
299 | * |
300 | * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains, |
301 | * implying a need to wait for one write to complete (test relevant bits) |
302 | * before starting the next write. This shouldn't be an issue given how |
303 | * infrequently we write, except maybe for write-then-read idioms. |
304 | */ |
305 | #define SET_FX (AT91_UDP_TXPKTRDY) |
306 | #define CLR_FX (RX_DATA_READY | AT91_UDP_RXSETUP \ |
307 | | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP) |
308 | |
309 | /* pull OUT packet data from the endpoint's fifo */ |
310 | static int read_fifo (struct at91_ep *ep, struct at91_request *req) |
311 | { |
312 | u32 __iomem *creg = ep->creg; |
313 | u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0)); |
314 | u32 csr; |
315 | u8 *buf; |
316 | unsigned int count, bufferspace, is_done; |
317 | |
318 | buf = req->req.buf + req->req.actual; |
319 | bufferspace = req->req.length - req->req.actual; |
320 | |
321 | /* |
322 | * there might be nothing to read if ep_queue() calls us, |
323 | * or if we already emptied both pingpong buffers |
324 | */ |
325 | rescan: |
326 | csr = __raw_readl(addr: creg); |
327 | if ((csr & RX_DATA_READY) == 0) |
328 | return 0; |
329 | |
330 | count = (csr & AT91_UDP_RXBYTECNT) >> 16; |
331 | if (count > ep->ep.maxpacket) |
332 | count = ep->ep.maxpacket; |
333 | if (count > bufferspace) { |
334 | DBG("%s buffer overflow\n" , ep->ep.name); |
335 | req->req.status = -EOVERFLOW; |
336 | count = bufferspace; |
337 | } |
338 | __raw_readsb(dreg, buf, count); |
339 | |
340 | /* release and swap pingpong mem bank */ |
341 | csr |= CLR_FX; |
342 | if (ep->is_pingpong) { |
343 | if (ep->fifo_bank == 0) { |
344 | csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0); |
345 | ep->fifo_bank = 1; |
346 | } else { |
347 | csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1); |
348 | ep->fifo_bank = 0; |
349 | } |
350 | } else |
351 | csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0); |
352 | __raw_writel(val: csr, addr: creg); |
353 | |
354 | req->req.actual += count; |
355 | is_done = (count < ep->ep.maxpacket); |
356 | if (count == bufferspace) |
357 | is_done = 1; |
358 | |
359 | PACKET("%s %p out/%d%s\n" , ep->ep.name, &req->req, count, |
360 | is_done ? " (done)" : "" ); |
361 | |
362 | /* |
363 | * avoid extra trips through IRQ logic for packets already in |
364 | * the fifo ... maybe preventing an extra (expensive) OUT-NAK |
365 | */ |
366 | if (is_done) |
367 | done(ep, req, status: 0); |
368 | else if (ep->is_pingpong) { |
369 | /* |
370 | * One dummy read to delay the code because of a HW glitch: |
371 | * CSR returns bad RXCOUNT when read too soon after updating |
372 | * RX_DATA_BK flags. |
373 | */ |
374 | csr = __raw_readl(addr: creg); |
375 | |
376 | bufferspace -= count; |
377 | buf += count; |
378 | goto rescan; |
379 | } |
380 | |
381 | return is_done; |
382 | } |
383 | |
384 | /* load fifo for an IN packet */ |
385 | static int write_fifo(struct at91_ep *ep, struct at91_request *req) |
386 | { |
387 | u32 __iomem *creg = ep->creg; |
388 | u32 csr = __raw_readl(addr: creg); |
389 | u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0)); |
390 | unsigned total, count, is_last; |
391 | u8 *buf; |
392 | |
393 | /* |
394 | * TODO: allow for writing two packets to the fifo ... that'll |
395 | * reduce the amount of IN-NAKing, but probably won't affect |
396 | * throughput much. (Unlike preventing OUT-NAKing!) |
397 | */ |
398 | |
399 | /* |
400 | * If ep_queue() calls us, the queue is empty and possibly in |
401 | * odd states like TXCOMP not yet cleared (we do it, saving at |
402 | * least one IRQ) or the fifo not yet being free. Those aren't |
403 | * issues normally (IRQ handler fast path). |
404 | */ |
405 | if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) { |
406 | if (csr & AT91_UDP_TXCOMP) { |
407 | csr |= CLR_FX; |
408 | csr &= ~(SET_FX | AT91_UDP_TXCOMP); |
409 | __raw_writel(val: csr, addr: creg); |
410 | csr = __raw_readl(addr: creg); |
411 | } |
412 | if (csr & AT91_UDP_TXPKTRDY) |
413 | return 0; |
414 | } |
415 | |
416 | buf = req->req.buf + req->req.actual; |
417 | prefetch(buf); |
418 | total = req->req.length - req->req.actual; |
419 | if (ep->ep.maxpacket < total) { |
420 | count = ep->ep.maxpacket; |
421 | is_last = 0; |
422 | } else { |
423 | count = total; |
424 | is_last = (count < ep->ep.maxpacket) || !req->req.zero; |
425 | } |
426 | |
427 | /* |
428 | * Write the packet, maybe it's a ZLP. |
429 | * |
430 | * NOTE: incrementing req->actual before we receive the ACK means |
431 | * gadget driver IN bytecounts can be wrong in fault cases. That's |
432 | * fixable with PIO drivers like this one (save "count" here, and |
433 | * do the increment later on TX irq), but not for most DMA hardware. |
434 | * |
435 | * So all gadget drivers must accept that potential error. Some |
436 | * hardware supports precise fifo status reporting, letting them |
437 | * recover when the actual bytecount matters (e.g. for USB Test |
438 | * and Measurement Class devices). |
439 | */ |
440 | __raw_writesb(dreg, buf, count); |
441 | csr &= ~SET_FX; |
442 | csr |= CLR_FX | AT91_UDP_TXPKTRDY; |
443 | __raw_writel(val: csr, addr: creg); |
444 | req->req.actual += count; |
445 | |
446 | PACKET("%s %p in/%d%s\n" , ep->ep.name, &req->req, count, |
447 | is_last ? " (done)" : "" ); |
448 | if (is_last) |
449 | done(ep, req, status: 0); |
450 | return is_last; |
451 | } |
452 | |
453 | static void nuke(struct at91_ep *ep, int status) |
454 | { |
455 | struct at91_request *req; |
456 | |
457 | /* terminate any request in the queue */ |
458 | ep->stopped = 1; |
459 | if (list_empty(head: &ep->queue)) |
460 | return; |
461 | |
462 | VDBG("%s %s\n" , __func__, ep->ep.name); |
463 | while (!list_empty(head: &ep->queue)) { |
464 | req = list_entry(ep->queue.next, struct at91_request, queue); |
465 | done(ep, req, status); |
466 | } |
467 | } |
468 | |
469 | /*-------------------------------------------------------------------------*/ |
470 | |
471 | static int at91_ep_enable(struct usb_ep *_ep, |
472 | const struct usb_endpoint_descriptor *desc) |
473 | { |
474 | struct at91_ep *ep = container_of(_ep, struct at91_ep, ep); |
475 | struct at91_udc *udc; |
476 | u16 maxpacket; |
477 | u32 tmp; |
478 | unsigned long flags; |
479 | |
480 | if (!_ep || !ep |
481 | || !desc || _ep->name == ep0name |
482 | || desc->bDescriptorType != USB_DT_ENDPOINT |
483 | || (maxpacket = usb_endpoint_maxp(epd: desc)) == 0 |
484 | || maxpacket > ep->maxpacket) { |
485 | DBG("bad ep or descriptor\n" ); |
486 | return -EINVAL; |
487 | } |
488 | |
489 | udc = ep->udc; |
490 | if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) { |
491 | DBG("bogus device state\n" ); |
492 | return -ESHUTDOWN; |
493 | } |
494 | |
495 | tmp = usb_endpoint_type(epd: desc); |
496 | switch (tmp) { |
497 | case USB_ENDPOINT_XFER_CONTROL: |
498 | DBG("only one control endpoint\n" ); |
499 | return -EINVAL; |
500 | case USB_ENDPOINT_XFER_INT: |
501 | if (maxpacket > 64) |
502 | goto bogus_max; |
503 | break; |
504 | case USB_ENDPOINT_XFER_BULK: |
505 | switch (maxpacket) { |
506 | case 8: |
507 | case 16: |
508 | case 32: |
509 | case 64: |
510 | goto ok; |
511 | } |
512 | bogus_max: |
513 | DBG("bogus maxpacket %d\n" , maxpacket); |
514 | return -EINVAL; |
515 | case USB_ENDPOINT_XFER_ISOC: |
516 | if (!ep->is_pingpong) { |
517 | DBG("iso requires double buffering\n" ); |
518 | return -EINVAL; |
519 | } |
520 | break; |
521 | } |
522 | |
523 | ok: |
524 | spin_lock_irqsave(&udc->lock, flags); |
525 | |
526 | /* initialize endpoint to match this descriptor */ |
527 | ep->is_in = usb_endpoint_dir_in(epd: desc); |
528 | ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); |
529 | ep->stopped = 0; |
530 | if (ep->is_in) |
531 | tmp |= 0x04; |
532 | tmp <<= 8; |
533 | tmp |= AT91_UDP_EPEDS; |
534 | __raw_writel(val: tmp, addr: ep->creg); |
535 | |
536 | ep->ep.maxpacket = maxpacket; |
537 | |
538 | /* |
539 | * reset/init endpoint fifo. NOTE: leaves fifo_bank alone, |
540 | * since endpoint resets don't reset hw pingpong state. |
541 | */ |
542 | at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); |
543 | at91_udp_write(udc, AT91_UDP_RST_EP, 0); |
544 | |
545 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
546 | return 0; |
547 | } |
548 | |
549 | static int at91_ep_disable (struct usb_ep * _ep) |
550 | { |
551 | struct at91_ep *ep = container_of(_ep, struct at91_ep, ep); |
552 | struct at91_udc *udc = ep->udc; |
553 | unsigned long flags; |
554 | |
555 | if (ep == &ep->udc->ep[0]) |
556 | return -EINVAL; |
557 | |
558 | spin_lock_irqsave(&udc->lock, flags); |
559 | |
560 | nuke(ep, status: -ESHUTDOWN); |
561 | |
562 | /* restore the endpoint's pristine config */ |
563 | ep->ep.desc = NULL; |
564 | ep->ep.maxpacket = ep->maxpacket; |
565 | |
566 | /* reset fifos and endpoint */ |
567 | if (ep->udc->clocked) { |
568 | at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); |
569 | at91_udp_write(udc, AT91_UDP_RST_EP, 0); |
570 | __raw_writel(val: 0, addr: ep->creg); |
571 | } |
572 | |
573 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
574 | return 0; |
575 | } |
576 | |
577 | /* |
578 | * this is a PIO-only driver, so there's nothing |
579 | * interesting for request or buffer allocation. |
580 | */ |
581 | |
582 | static struct usb_request * |
583 | at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags) |
584 | { |
585 | struct at91_request *req; |
586 | |
587 | req = kzalloc(size: sizeof (struct at91_request), flags: gfp_flags); |
588 | if (!req) |
589 | return NULL; |
590 | |
591 | INIT_LIST_HEAD(list: &req->queue); |
592 | return &req->req; |
593 | } |
594 | |
595 | static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req) |
596 | { |
597 | struct at91_request *req; |
598 | |
599 | req = container_of(_req, struct at91_request, req); |
600 | BUG_ON(!list_empty(&req->queue)); |
601 | kfree(objp: req); |
602 | } |
603 | |
604 | static int at91_ep_queue(struct usb_ep *_ep, |
605 | struct usb_request *_req, gfp_t gfp_flags) |
606 | { |
607 | struct at91_request *req; |
608 | struct at91_ep *ep; |
609 | struct at91_udc *udc; |
610 | int status; |
611 | unsigned long flags; |
612 | |
613 | req = container_of(_req, struct at91_request, req); |
614 | ep = container_of(_ep, struct at91_ep, ep); |
615 | |
616 | if (!_req || !_req->complete |
617 | || !_req->buf || !list_empty(head: &req->queue)) { |
618 | DBG("invalid request\n" ); |
619 | return -EINVAL; |
620 | } |
621 | |
622 | if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) { |
623 | DBG("invalid ep\n" ); |
624 | return -EINVAL; |
625 | } |
626 | |
627 | udc = ep->udc; |
628 | |
629 | if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) { |
630 | DBG("invalid device\n" ); |
631 | return -EINVAL; |
632 | } |
633 | |
634 | _req->status = -EINPROGRESS; |
635 | _req->actual = 0; |
636 | |
637 | spin_lock_irqsave(&udc->lock, flags); |
638 | |
639 | /* try to kickstart any empty and idle queue */ |
640 | if (list_empty(head: &ep->queue) && !ep->stopped) { |
641 | int is_ep0; |
642 | |
643 | /* |
644 | * If this control request has a non-empty DATA stage, this |
645 | * will start that stage. It works just like a non-control |
646 | * request (until the status stage starts, maybe early). |
647 | * |
648 | * If the data stage is empty, then this starts a successful |
649 | * IN/STATUS stage. (Unsuccessful ones use set_halt.) |
650 | */ |
651 | is_ep0 = (ep->ep.name == ep0name); |
652 | if (is_ep0) { |
653 | u32 tmp; |
654 | |
655 | if (!udc->req_pending) { |
656 | status = -EINVAL; |
657 | goto done; |
658 | } |
659 | |
660 | /* |
661 | * defer changing CONFG until after the gadget driver |
662 | * reconfigures the endpoints. |
663 | */ |
664 | if (udc->wait_for_config_ack) { |
665 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
666 | tmp ^= AT91_UDP_CONFG; |
667 | VDBG("toggle config\n" ); |
668 | at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); |
669 | } |
670 | if (req->req.length == 0) { |
671 | ep0_in_status: |
672 | PACKET("ep0 in/status\n" ); |
673 | status = 0; |
674 | tmp = __raw_readl(addr: ep->creg); |
675 | tmp &= ~SET_FX; |
676 | tmp |= CLR_FX | AT91_UDP_TXPKTRDY; |
677 | __raw_writel(val: tmp, addr: ep->creg); |
678 | udc->req_pending = 0; |
679 | goto done; |
680 | } |
681 | } |
682 | |
683 | if (ep->is_in) |
684 | status = write_fifo(ep, req); |
685 | else { |
686 | status = read_fifo(ep, req); |
687 | |
688 | /* IN/STATUS stage is otherwise triggered by irq */ |
689 | if (status && is_ep0) |
690 | goto ep0_in_status; |
691 | } |
692 | } else |
693 | status = 0; |
694 | |
695 | if (req && !status) { |
696 | list_add_tail (new: &req->queue, head: &ep->queue); |
697 | at91_udp_write(udc, AT91_UDP_IER, ep->int_mask); |
698 | } |
699 | done: |
700 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
701 | return (status < 0) ? status : 0; |
702 | } |
703 | |
704 | static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) |
705 | { |
706 | struct at91_ep *ep; |
707 | struct at91_request *req = NULL, *iter; |
708 | unsigned long flags; |
709 | struct at91_udc *udc; |
710 | |
711 | ep = container_of(_ep, struct at91_ep, ep); |
712 | if (!_ep || ep->ep.name == ep0name) |
713 | return -EINVAL; |
714 | |
715 | udc = ep->udc; |
716 | |
717 | spin_lock_irqsave(&udc->lock, flags); |
718 | |
719 | /* make sure it's actually queued on this endpoint */ |
720 | list_for_each_entry(iter, &ep->queue, queue) { |
721 | if (&iter->req != _req) |
722 | continue; |
723 | req = iter; |
724 | break; |
725 | } |
726 | if (!req) { |
727 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
728 | return -EINVAL; |
729 | } |
730 | |
731 | done(ep, req, status: -ECONNRESET); |
732 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
733 | return 0; |
734 | } |
735 | |
736 | static int at91_ep_set_halt(struct usb_ep *_ep, int value) |
737 | { |
738 | struct at91_ep *ep = container_of(_ep, struct at91_ep, ep); |
739 | struct at91_udc *udc = ep->udc; |
740 | u32 __iomem *creg; |
741 | u32 csr; |
742 | unsigned long flags; |
743 | int status = 0; |
744 | |
745 | if (!_ep || ep->is_iso || !ep->udc->clocked) |
746 | return -EINVAL; |
747 | |
748 | creg = ep->creg; |
749 | spin_lock_irqsave(&udc->lock, flags); |
750 | |
751 | csr = __raw_readl(addr: creg); |
752 | |
753 | /* |
754 | * fail with still-busy IN endpoints, ensuring correct sequencing |
755 | * of data tx then stall. note that the fifo rx bytecount isn't |
756 | * completely accurate as a tx bytecount. |
757 | */ |
758 | if (ep->is_in && (!list_empty(head: &ep->queue) || (csr >> 16) != 0)) |
759 | status = -EAGAIN; |
760 | else { |
761 | csr |= CLR_FX; |
762 | csr &= ~SET_FX; |
763 | if (value) { |
764 | csr |= AT91_UDP_FORCESTALL; |
765 | VDBG("halt %s\n" , ep->ep.name); |
766 | } else { |
767 | at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); |
768 | at91_udp_write(udc, AT91_UDP_RST_EP, 0); |
769 | csr &= ~AT91_UDP_FORCESTALL; |
770 | } |
771 | __raw_writel(val: csr, addr: creg); |
772 | } |
773 | |
774 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
775 | return status; |
776 | } |
777 | |
778 | static const struct usb_ep_ops at91_ep_ops = { |
779 | .enable = at91_ep_enable, |
780 | .disable = at91_ep_disable, |
781 | .alloc_request = at91_ep_alloc_request, |
782 | .free_request = at91_ep_free_request, |
783 | .queue = at91_ep_queue, |
784 | .dequeue = at91_ep_dequeue, |
785 | .set_halt = at91_ep_set_halt, |
786 | /* there's only imprecise fifo status reporting */ |
787 | }; |
788 | |
789 | /*-------------------------------------------------------------------------*/ |
790 | |
791 | static int at91_get_frame(struct usb_gadget *gadget) |
792 | { |
793 | struct at91_udc *udc = to_udc(g: gadget); |
794 | |
795 | if (!to_udc(g: gadget)->clocked) |
796 | return -EINVAL; |
797 | return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM; |
798 | } |
799 | |
800 | static int at91_wakeup(struct usb_gadget *gadget) |
801 | { |
802 | struct at91_udc *udc = to_udc(g: gadget); |
803 | u32 glbstate; |
804 | unsigned long flags; |
805 | |
806 | DBG("%s\n" , __func__ ); |
807 | spin_lock_irqsave(&udc->lock, flags); |
808 | |
809 | if (!udc->clocked || !udc->suspended) |
810 | goto done; |
811 | |
812 | /* NOTE: some "early versions" handle ESR differently ... */ |
813 | |
814 | glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
815 | if (!(glbstate & AT91_UDP_ESR)) |
816 | goto done; |
817 | glbstate |= AT91_UDP_ESR; |
818 | at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate); |
819 | |
820 | done: |
821 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
822 | return 0; |
823 | } |
824 | |
825 | /* reinit == restore initial software state */ |
826 | static void udc_reinit(struct at91_udc *udc) |
827 | { |
828 | u32 i; |
829 | |
830 | INIT_LIST_HEAD(list: &udc->gadget.ep_list); |
831 | INIT_LIST_HEAD(list: &udc->gadget.ep0->ep_list); |
832 | udc->gadget.quirk_stall_not_supp = 1; |
833 | |
834 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
835 | struct at91_ep *ep = &udc->ep[i]; |
836 | |
837 | if (i != 0) |
838 | list_add_tail(new: &ep->ep.ep_list, head: &udc->gadget.ep_list); |
839 | ep->ep.desc = NULL; |
840 | ep->stopped = 0; |
841 | ep->fifo_bank = 0; |
842 | usb_ep_set_maxpacket_limit(ep: &ep->ep, maxpacket_limit: ep->maxpacket); |
843 | ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i); |
844 | /* initialize one queue per endpoint */ |
845 | INIT_LIST_HEAD(list: &ep->queue); |
846 | } |
847 | } |
848 | |
849 | static void reset_gadget(struct at91_udc *udc) |
850 | { |
851 | struct usb_gadget_driver *driver = udc->driver; |
852 | int i; |
853 | |
854 | if (udc->gadget.speed == USB_SPEED_UNKNOWN) |
855 | driver = NULL; |
856 | udc->gadget.speed = USB_SPEED_UNKNOWN; |
857 | udc->suspended = 0; |
858 | |
859 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
860 | struct at91_ep *ep = &udc->ep[i]; |
861 | |
862 | ep->stopped = 1; |
863 | nuke(ep, status: -ESHUTDOWN); |
864 | } |
865 | if (driver) { |
866 | spin_unlock(lock: &udc->lock); |
867 | usb_gadget_udc_reset(gadget: &udc->gadget, driver); |
868 | spin_lock(lock: &udc->lock); |
869 | } |
870 | |
871 | udc_reinit(udc); |
872 | } |
873 | |
874 | static void stop_activity(struct at91_udc *udc) |
875 | { |
876 | struct usb_gadget_driver *driver = udc->driver; |
877 | int i; |
878 | |
879 | if (udc->gadget.speed == USB_SPEED_UNKNOWN) |
880 | driver = NULL; |
881 | udc->gadget.speed = USB_SPEED_UNKNOWN; |
882 | udc->suspended = 0; |
883 | |
884 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
885 | struct at91_ep *ep = &udc->ep[i]; |
886 | ep->stopped = 1; |
887 | nuke(ep, status: -ESHUTDOWN); |
888 | } |
889 | if (driver) { |
890 | spin_unlock(lock: &udc->lock); |
891 | driver->disconnect(&udc->gadget); |
892 | spin_lock(lock: &udc->lock); |
893 | } |
894 | |
895 | udc_reinit(udc); |
896 | } |
897 | |
898 | static void clk_on(struct at91_udc *udc) |
899 | { |
900 | if (udc->clocked) |
901 | return; |
902 | udc->clocked = 1; |
903 | |
904 | clk_enable(clk: udc->iclk); |
905 | clk_enable(clk: udc->fclk); |
906 | } |
907 | |
908 | static void clk_off(struct at91_udc *udc) |
909 | { |
910 | if (!udc->clocked) |
911 | return; |
912 | udc->clocked = 0; |
913 | udc->gadget.speed = USB_SPEED_UNKNOWN; |
914 | clk_disable(clk: udc->fclk); |
915 | clk_disable(clk: udc->iclk); |
916 | } |
917 | |
918 | /* |
919 | * activate/deactivate link with host; minimize power usage for |
920 | * inactive links by cutting clocks and transceiver power. |
921 | */ |
922 | static void pullup(struct at91_udc *udc, int is_on) |
923 | { |
924 | if (!udc->enabled || !udc->vbus) |
925 | is_on = 0; |
926 | DBG("%sactive\n" , is_on ? "" : "in" ); |
927 | |
928 | if (is_on) { |
929 | clk_on(udc); |
930 | at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM); |
931 | at91_udp_write(udc, AT91_UDP_TXVC, 0); |
932 | } else { |
933 | stop_activity(udc); |
934 | at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM); |
935 | at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); |
936 | clk_off(udc); |
937 | } |
938 | |
939 | if (udc->caps && udc->caps->pullup) |
940 | udc->caps->pullup(udc, is_on); |
941 | } |
942 | |
943 | /* vbus is here! turn everything on that's ready */ |
944 | static int at91_vbus_session(struct usb_gadget *gadget, int is_active) |
945 | { |
946 | struct at91_udc *udc = to_udc(g: gadget); |
947 | unsigned long flags; |
948 | |
949 | /* VDBG("vbus %s\n", is_active ? "on" : "off"); */ |
950 | spin_lock_irqsave(&udc->lock, flags); |
951 | udc->vbus = (is_active != 0); |
952 | if (udc->driver) |
953 | pullup(udc, is_on: is_active); |
954 | else |
955 | pullup(udc, is_on: 0); |
956 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
957 | return 0; |
958 | } |
959 | |
960 | static int at91_pullup(struct usb_gadget *gadget, int is_on) |
961 | { |
962 | struct at91_udc *udc = to_udc(g: gadget); |
963 | unsigned long flags; |
964 | |
965 | spin_lock_irqsave(&udc->lock, flags); |
966 | udc->enabled = is_on = !!is_on; |
967 | pullup(udc, is_on); |
968 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
969 | return 0; |
970 | } |
971 | |
972 | static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on) |
973 | { |
974 | struct at91_udc *udc = to_udc(g: gadget); |
975 | unsigned long flags; |
976 | |
977 | spin_lock_irqsave(&udc->lock, flags); |
978 | gadget->is_selfpowered = (is_on != 0); |
979 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
980 | return 0; |
981 | } |
982 | |
983 | static int at91_start(struct usb_gadget *gadget, |
984 | struct usb_gadget_driver *driver); |
985 | static int at91_stop(struct usb_gadget *gadget); |
986 | |
987 | static const struct usb_gadget_ops at91_udc_ops = { |
988 | .get_frame = at91_get_frame, |
989 | .wakeup = at91_wakeup, |
990 | .set_selfpowered = at91_set_selfpowered, |
991 | .vbus_session = at91_vbus_session, |
992 | .pullup = at91_pullup, |
993 | .udc_start = at91_start, |
994 | .udc_stop = at91_stop, |
995 | |
996 | /* |
997 | * VBUS-powered devices may also want to support bigger |
998 | * power budgets after an appropriate SET_CONFIGURATION. |
999 | */ |
1000 | /* .vbus_power = at91_vbus_power, */ |
1001 | }; |
1002 | |
1003 | /*-------------------------------------------------------------------------*/ |
1004 | |
1005 | static int handle_ep(struct at91_ep *ep) |
1006 | { |
1007 | struct at91_request *req; |
1008 | u32 __iomem *creg = ep->creg; |
1009 | u32 csr = __raw_readl(addr: creg); |
1010 | |
1011 | if (!list_empty(head: &ep->queue)) |
1012 | req = list_entry(ep->queue.next, |
1013 | struct at91_request, queue); |
1014 | else |
1015 | req = NULL; |
1016 | |
1017 | if (ep->is_in) { |
1018 | if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) { |
1019 | csr |= CLR_FX; |
1020 | csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP); |
1021 | __raw_writel(val: csr, addr: creg); |
1022 | } |
1023 | if (req) |
1024 | return write_fifo(ep, req); |
1025 | |
1026 | } else { |
1027 | if (csr & AT91_UDP_STALLSENT) { |
1028 | /* STALLSENT bit == ISOERR */ |
1029 | if (ep->is_iso && req) |
1030 | req->req.status = -EILSEQ; |
1031 | csr |= CLR_FX; |
1032 | csr &= ~(SET_FX | AT91_UDP_STALLSENT); |
1033 | __raw_writel(val: csr, addr: creg); |
1034 | csr = __raw_readl(addr: creg); |
1035 | } |
1036 | if (req && (csr & RX_DATA_READY)) |
1037 | return read_fifo(ep, req); |
1038 | } |
1039 | return 0; |
1040 | } |
1041 | |
1042 | union setup { |
1043 | u8 raw[8]; |
1044 | struct usb_ctrlrequest r; |
1045 | }; |
1046 | |
1047 | static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr) |
1048 | { |
1049 | u32 __iomem *creg = ep->creg; |
1050 | u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0)); |
1051 | unsigned rxcount, i = 0; |
1052 | u32 tmp; |
1053 | union setup pkt; |
1054 | int status = 0; |
1055 | |
1056 | /* read and ack SETUP; hard-fail for bogus packets */ |
1057 | rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16; |
1058 | if (likely(rxcount == 8)) { |
1059 | while (rxcount--) |
1060 | pkt.raw[i++] = __raw_readb(addr: dreg); |
1061 | if (pkt.r.bRequestType & USB_DIR_IN) { |
1062 | csr |= AT91_UDP_DIR; |
1063 | ep->is_in = 1; |
1064 | } else { |
1065 | csr &= ~AT91_UDP_DIR; |
1066 | ep->is_in = 0; |
1067 | } |
1068 | } else { |
1069 | /* REVISIT this happens sometimes under load; why?? */ |
1070 | ERR("SETUP len %d, csr %08x\n" , rxcount, csr); |
1071 | status = -EINVAL; |
1072 | } |
1073 | csr |= CLR_FX; |
1074 | csr &= ~(SET_FX | AT91_UDP_RXSETUP); |
1075 | __raw_writel(val: csr, addr: creg); |
1076 | udc->wait_for_addr_ack = 0; |
1077 | udc->wait_for_config_ack = 0; |
1078 | ep->stopped = 0; |
1079 | if (unlikely(status != 0)) |
1080 | goto stall; |
1081 | |
1082 | #define w_index le16_to_cpu(pkt.r.wIndex) |
1083 | #define w_value le16_to_cpu(pkt.r.wValue) |
1084 | #define w_length le16_to_cpu(pkt.r.wLength) |
1085 | |
1086 | VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n" , |
1087 | pkt.r.bRequestType, pkt.r.bRequest, |
1088 | w_value, w_index, w_length); |
1089 | |
1090 | /* |
1091 | * A few standard requests get handled here, ones that touch |
1092 | * hardware ... notably for device and endpoint features. |
1093 | */ |
1094 | udc->req_pending = 1; |
1095 | csr = __raw_readl(addr: creg); |
1096 | csr |= CLR_FX; |
1097 | csr &= ~SET_FX; |
1098 | switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) { |
1099 | |
1100 | case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) |
1101 | | USB_REQ_SET_ADDRESS: |
1102 | __raw_writel(val: csr | AT91_UDP_TXPKTRDY, addr: creg); |
1103 | udc->addr = w_value; |
1104 | udc->wait_for_addr_ack = 1; |
1105 | udc->req_pending = 0; |
1106 | /* FADDR is set later, when we ack host STATUS */ |
1107 | return; |
1108 | |
1109 | case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) |
1110 | | USB_REQ_SET_CONFIGURATION: |
1111 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG; |
1112 | if (pkt.r.wValue) |
1113 | udc->wait_for_config_ack = (tmp == 0); |
1114 | else |
1115 | udc->wait_for_config_ack = (tmp != 0); |
1116 | if (udc->wait_for_config_ack) |
1117 | VDBG("wait for config\n" ); |
1118 | /* CONFG is toggled later, if gadget driver succeeds */ |
1119 | break; |
1120 | |
1121 | /* |
1122 | * Hosts may set or clear remote wakeup status, and |
1123 | * devices may report they're VBUS powered. |
1124 | */ |
1125 | case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) |
1126 | | USB_REQ_GET_STATUS: |
1127 | tmp = (udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED); |
1128 | if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR) |
1129 | tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP); |
1130 | PACKET("get device status\n" ); |
1131 | __raw_writeb(val: tmp, addr: dreg); |
1132 | __raw_writeb(val: 0, addr: dreg); |
1133 | goto write_in; |
1134 | /* then STATUS starts later, automatically */ |
1135 | case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) |
1136 | | USB_REQ_SET_FEATURE: |
1137 | if (w_value != USB_DEVICE_REMOTE_WAKEUP) |
1138 | goto stall; |
1139 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
1140 | tmp |= AT91_UDP_ESR; |
1141 | at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); |
1142 | goto succeed; |
1143 | case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) |
1144 | | USB_REQ_CLEAR_FEATURE: |
1145 | if (w_value != USB_DEVICE_REMOTE_WAKEUP) |
1146 | goto stall; |
1147 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
1148 | tmp &= ~AT91_UDP_ESR; |
1149 | at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); |
1150 | goto succeed; |
1151 | |
1152 | /* |
1153 | * Interfaces have no feature settings; this is pretty useless. |
1154 | * we won't even insist the interface exists... |
1155 | */ |
1156 | case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8) |
1157 | | USB_REQ_GET_STATUS: |
1158 | PACKET("get interface status\n" ); |
1159 | __raw_writeb(val: 0, addr: dreg); |
1160 | __raw_writeb(val: 0, addr: dreg); |
1161 | goto write_in; |
1162 | /* then STATUS starts later, automatically */ |
1163 | case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8) |
1164 | | USB_REQ_SET_FEATURE: |
1165 | case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8) |
1166 | | USB_REQ_CLEAR_FEATURE: |
1167 | goto stall; |
1168 | |
1169 | /* |
1170 | * Hosts may clear bulk/intr endpoint halt after the gadget |
1171 | * driver sets it (not widely used); or set it (for testing) |
1172 | */ |
1173 | case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8) |
1174 | | USB_REQ_GET_STATUS: |
1175 | tmp = w_index & USB_ENDPOINT_NUMBER_MASK; |
1176 | ep = &udc->ep[tmp]; |
1177 | if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc)) |
1178 | goto stall; |
1179 | |
1180 | if (tmp) { |
1181 | if ((w_index & USB_DIR_IN)) { |
1182 | if (!ep->is_in) |
1183 | goto stall; |
1184 | } else if (ep->is_in) |
1185 | goto stall; |
1186 | } |
1187 | PACKET("get %s status\n" , ep->ep.name); |
1188 | if (__raw_readl(addr: ep->creg) & AT91_UDP_FORCESTALL) |
1189 | tmp = (1 << USB_ENDPOINT_HALT); |
1190 | else |
1191 | tmp = 0; |
1192 | __raw_writeb(val: tmp, addr: dreg); |
1193 | __raw_writeb(val: 0, addr: dreg); |
1194 | goto write_in; |
1195 | /* then STATUS starts later, automatically */ |
1196 | case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8) |
1197 | | USB_REQ_SET_FEATURE: |
1198 | tmp = w_index & USB_ENDPOINT_NUMBER_MASK; |
1199 | ep = &udc->ep[tmp]; |
1200 | if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS) |
1201 | goto stall; |
1202 | if (!ep->ep.desc || ep->is_iso) |
1203 | goto stall; |
1204 | if ((w_index & USB_DIR_IN)) { |
1205 | if (!ep->is_in) |
1206 | goto stall; |
1207 | } else if (ep->is_in) |
1208 | goto stall; |
1209 | |
1210 | tmp = __raw_readl(addr: ep->creg); |
1211 | tmp &= ~SET_FX; |
1212 | tmp |= CLR_FX | AT91_UDP_FORCESTALL; |
1213 | __raw_writel(val: tmp, addr: ep->creg); |
1214 | goto succeed; |
1215 | case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8) |
1216 | | USB_REQ_CLEAR_FEATURE: |
1217 | tmp = w_index & USB_ENDPOINT_NUMBER_MASK; |
1218 | ep = &udc->ep[tmp]; |
1219 | if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS) |
1220 | goto stall; |
1221 | if (tmp == 0) |
1222 | goto succeed; |
1223 | if (!ep->ep.desc || ep->is_iso) |
1224 | goto stall; |
1225 | if ((w_index & USB_DIR_IN)) { |
1226 | if (!ep->is_in) |
1227 | goto stall; |
1228 | } else if (ep->is_in) |
1229 | goto stall; |
1230 | |
1231 | at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); |
1232 | at91_udp_write(udc, AT91_UDP_RST_EP, 0); |
1233 | tmp = __raw_readl(addr: ep->creg); |
1234 | tmp |= CLR_FX; |
1235 | tmp &= ~(SET_FX | AT91_UDP_FORCESTALL); |
1236 | __raw_writel(val: tmp, addr: ep->creg); |
1237 | if (!list_empty(head: &ep->queue)) |
1238 | handle_ep(ep); |
1239 | goto succeed; |
1240 | } |
1241 | |
1242 | #undef w_value |
1243 | #undef w_index |
1244 | #undef w_length |
1245 | |
1246 | /* pass request up to the gadget driver */ |
1247 | if (udc->driver) { |
1248 | spin_unlock(lock: &udc->lock); |
1249 | status = udc->driver->setup(&udc->gadget, &pkt.r); |
1250 | spin_lock(lock: &udc->lock); |
1251 | } |
1252 | else |
1253 | status = -ENODEV; |
1254 | if (status < 0) { |
1255 | stall: |
1256 | VDBG("req %02x.%02x protocol STALL; stat %d\n" , |
1257 | pkt.r.bRequestType, pkt.r.bRequest, status); |
1258 | csr |= AT91_UDP_FORCESTALL; |
1259 | __raw_writel(val: csr, addr: creg); |
1260 | udc->req_pending = 0; |
1261 | } |
1262 | return; |
1263 | |
1264 | succeed: |
1265 | /* immediate successful (IN) STATUS after zero length DATA */ |
1266 | PACKET("ep0 in/status\n" ); |
1267 | write_in: |
1268 | csr |= AT91_UDP_TXPKTRDY; |
1269 | __raw_writel(val: csr, addr: creg); |
1270 | udc->req_pending = 0; |
1271 | } |
1272 | |
1273 | static void handle_ep0(struct at91_udc *udc) |
1274 | { |
1275 | struct at91_ep *ep0 = &udc->ep[0]; |
1276 | u32 __iomem *creg = ep0->creg; |
1277 | u32 csr = __raw_readl(addr: creg); |
1278 | struct at91_request *req; |
1279 | |
1280 | if (unlikely(csr & AT91_UDP_STALLSENT)) { |
1281 | nuke(ep: ep0, status: -EPROTO); |
1282 | udc->req_pending = 0; |
1283 | csr |= CLR_FX; |
1284 | csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL); |
1285 | __raw_writel(val: csr, addr: creg); |
1286 | VDBG("ep0 stalled\n" ); |
1287 | csr = __raw_readl(addr: creg); |
1288 | } |
1289 | if (csr & AT91_UDP_RXSETUP) { |
1290 | nuke(ep: ep0, status: 0); |
1291 | udc->req_pending = 0; |
1292 | handle_setup(udc, ep: ep0, csr); |
1293 | return; |
1294 | } |
1295 | |
1296 | if (list_empty(head: &ep0->queue)) |
1297 | req = NULL; |
1298 | else |
1299 | req = list_entry(ep0->queue.next, struct at91_request, queue); |
1300 | |
1301 | /* host ACKed an IN packet that we sent */ |
1302 | if (csr & AT91_UDP_TXCOMP) { |
1303 | csr |= CLR_FX; |
1304 | csr &= ~(SET_FX | AT91_UDP_TXCOMP); |
1305 | |
1306 | /* write more IN DATA? */ |
1307 | if (req && ep0->is_in) { |
1308 | if (handle_ep(ep: ep0)) |
1309 | udc->req_pending = 0; |
1310 | |
1311 | /* |
1312 | * Ack after: |
1313 | * - last IN DATA packet (including GET_STATUS) |
1314 | * - IN/STATUS for OUT DATA |
1315 | * - IN/STATUS for any zero-length DATA stage |
1316 | * except for the IN DATA case, the host should send |
1317 | * an OUT status later, which we'll ack. |
1318 | */ |
1319 | } else { |
1320 | udc->req_pending = 0; |
1321 | __raw_writel(val: csr, addr: creg); |
1322 | |
1323 | /* |
1324 | * SET_ADDRESS takes effect only after the STATUS |
1325 | * (to the original address) gets acked. |
1326 | */ |
1327 | if (udc->wait_for_addr_ack) { |
1328 | u32 tmp; |
1329 | |
1330 | at91_udp_write(udc, AT91_UDP_FADDR, |
1331 | AT91_UDP_FEN | udc->addr); |
1332 | tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); |
1333 | tmp &= ~AT91_UDP_FADDEN; |
1334 | if (udc->addr) |
1335 | tmp |= AT91_UDP_FADDEN; |
1336 | at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); |
1337 | |
1338 | udc->wait_for_addr_ack = 0; |
1339 | VDBG("address %d\n" , udc->addr); |
1340 | } |
1341 | } |
1342 | } |
1343 | |
1344 | /* OUT packet arrived ... */ |
1345 | else if (csr & AT91_UDP_RX_DATA_BK0) { |
1346 | csr |= CLR_FX; |
1347 | csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0); |
1348 | |
1349 | /* OUT DATA stage */ |
1350 | if (!ep0->is_in) { |
1351 | if (req) { |
1352 | if (handle_ep(ep: ep0)) { |
1353 | /* send IN/STATUS */ |
1354 | PACKET("ep0 in/status\n" ); |
1355 | csr = __raw_readl(addr: creg); |
1356 | csr &= ~SET_FX; |
1357 | csr |= CLR_FX | AT91_UDP_TXPKTRDY; |
1358 | __raw_writel(val: csr, addr: creg); |
1359 | udc->req_pending = 0; |
1360 | } |
1361 | } else if (udc->req_pending) { |
1362 | /* |
1363 | * AT91 hardware has a hard time with this |
1364 | * "deferred response" mode for control-OUT |
1365 | * transfers. (For control-IN it's fine.) |
1366 | * |
1367 | * The normal solution leaves OUT data in the |
1368 | * fifo until the gadget driver is ready. |
1369 | * We couldn't do that here without disabling |
1370 | * the IRQ that tells about SETUP packets, |
1371 | * e.g. when the host gets impatient... |
1372 | * |
1373 | * Working around it by copying into a buffer |
1374 | * would almost be a non-deferred response, |
1375 | * except that it wouldn't permit reliable |
1376 | * stalling of the request. Instead, demand |
1377 | * that gadget drivers not use this mode. |
1378 | */ |
1379 | DBG("no control-OUT deferred responses!\n" ); |
1380 | __raw_writel(val: csr | AT91_UDP_FORCESTALL, addr: creg); |
1381 | udc->req_pending = 0; |
1382 | } |
1383 | |
1384 | /* STATUS stage for control-IN; ack. */ |
1385 | } else { |
1386 | PACKET("ep0 out/status ACK\n" ); |
1387 | __raw_writel(val: csr, addr: creg); |
1388 | |
1389 | /* "early" status stage */ |
1390 | if (req) |
1391 | done(ep: ep0, req, status: 0); |
1392 | } |
1393 | } |
1394 | } |
1395 | |
1396 | static irqreturn_t at91_udc_irq (int irq, void *_udc) |
1397 | { |
1398 | struct at91_udc *udc = _udc; |
1399 | u32 rescans = 5; |
1400 | int disable_clock = 0; |
1401 | unsigned long flags; |
1402 | |
1403 | spin_lock_irqsave(&udc->lock, flags); |
1404 | |
1405 | if (!udc->clocked) { |
1406 | clk_on(udc); |
1407 | disable_clock = 1; |
1408 | } |
1409 | |
1410 | while (rescans--) { |
1411 | u32 status; |
1412 | |
1413 | status = at91_udp_read(udc, AT91_UDP_ISR) |
1414 | & at91_udp_read(udc, AT91_UDP_IMR); |
1415 | if (!status) |
1416 | break; |
1417 | |
1418 | /* USB reset irq: not maskable */ |
1419 | if (status & AT91_UDP_ENDBUSRES) { |
1420 | at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS); |
1421 | at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS); |
1422 | /* Atmel code clears this irq twice */ |
1423 | at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES); |
1424 | at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES); |
1425 | VDBG("end bus reset\n" ); |
1426 | udc->addr = 0; |
1427 | reset_gadget(udc); |
1428 | |
1429 | /* enable ep0 */ |
1430 | at91_udp_write(udc, AT91_UDP_CSR(0), |
1431 | AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL); |
1432 | udc->gadget.speed = USB_SPEED_FULL; |
1433 | udc->suspended = 0; |
1434 | at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0)); |
1435 | |
1436 | /* |
1437 | * NOTE: this driver keeps clocks off unless the |
1438 | * USB host is present. That saves power, but for |
1439 | * boards that don't support VBUS detection, both |
1440 | * clocks need to be active most of the time. |
1441 | */ |
1442 | |
1443 | /* host initiated suspend (3+ms bus idle) */ |
1444 | } else if (status & AT91_UDP_RXSUSP) { |
1445 | at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP); |
1446 | at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM); |
1447 | at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP); |
1448 | /* VDBG("bus suspend\n"); */ |
1449 | if (udc->suspended) |
1450 | continue; |
1451 | udc->suspended = 1; |
1452 | |
1453 | /* |
1454 | * NOTE: when suspending a VBUS-powered device, the |
1455 | * gadget driver should switch into slow clock mode |
1456 | * and then into standby to avoid drawing more than |
1457 | * 500uA power (2500uA for some high-power configs). |
1458 | */ |
1459 | if (udc->driver && udc->driver->suspend) { |
1460 | spin_unlock(lock: &udc->lock); |
1461 | udc->driver->suspend(&udc->gadget); |
1462 | spin_lock(lock: &udc->lock); |
1463 | } |
1464 | |
1465 | /* host initiated resume */ |
1466 | } else if (status & AT91_UDP_RXRSM) { |
1467 | at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM); |
1468 | at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP); |
1469 | at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM); |
1470 | /* VDBG("bus resume\n"); */ |
1471 | if (!udc->suspended) |
1472 | continue; |
1473 | udc->suspended = 0; |
1474 | |
1475 | /* |
1476 | * NOTE: for a VBUS-powered device, the gadget driver |
1477 | * would normally want to switch out of slow clock |
1478 | * mode into normal mode. |
1479 | */ |
1480 | if (udc->driver && udc->driver->resume) { |
1481 | spin_unlock(lock: &udc->lock); |
1482 | udc->driver->resume(&udc->gadget); |
1483 | spin_lock(lock: &udc->lock); |
1484 | } |
1485 | |
1486 | /* endpoint IRQs are cleared by handling them */ |
1487 | } else { |
1488 | int i; |
1489 | unsigned mask = 1; |
1490 | struct at91_ep *ep = &udc->ep[1]; |
1491 | |
1492 | if (status & mask) |
1493 | handle_ep0(udc); |
1494 | for (i = 1; i < NUM_ENDPOINTS; i++) { |
1495 | mask <<= 1; |
1496 | if (status & mask) |
1497 | handle_ep(ep); |
1498 | ep++; |
1499 | } |
1500 | } |
1501 | } |
1502 | |
1503 | if (disable_clock) |
1504 | clk_off(udc); |
1505 | |
1506 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1507 | |
1508 | return IRQ_HANDLED; |
1509 | } |
1510 | |
1511 | /*-------------------------------------------------------------------------*/ |
1512 | |
1513 | static void at91_vbus_update(struct at91_udc *udc, unsigned value) |
1514 | { |
1515 | if (value != udc->vbus) |
1516 | at91_vbus_session(gadget: &udc->gadget, is_active: value); |
1517 | } |
1518 | |
1519 | static irqreturn_t at91_vbus_irq(int irq, void *_udc) |
1520 | { |
1521 | struct at91_udc *udc = _udc; |
1522 | |
1523 | /* vbus needs at least brief debouncing */ |
1524 | udelay(10); |
1525 | at91_vbus_update(udc, value: gpiod_get_value(desc: udc->board.vbus_pin)); |
1526 | |
1527 | return IRQ_HANDLED; |
1528 | } |
1529 | |
1530 | static void at91_vbus_timer_work(struct work_struct *work) |
1531 | { |
1532 | struct at91_udc *udc = container_of(work, struct at91_udc, |
1533 | vbus_timer_work); |
1534 | |
1535 | at91_vbus_update(udc, value: gpiod_get_value_cansleep(desc: udc->board.vbus_pin)); |
1536 | |
1537 | if (!timer_pending(timer: &udc->vbus_timer)) |
1538 | mod_timer(timer: &udc->vbus_timer, expires: jiffies + VBUS_POLL_TIMEOUT); |
1539 | } |
1540 | |
1541 | static void at91_vbus_timer(struct timer_list *t) |
1542 | { |
1543 | struct at91_udc *udc = from_timer(udc, t, vbus_timer); |
1544 | |
1545 | /* |
1546 | * If we are polling vbus it is likely that the gpio is on an |
1547 | * bus such as i2c or spi which may sleep, so schedule some work |
1548 | * to read the vbus gpio |
1549 | */ |
1550 | schedule_work(work: &udc->vbus_timer_work); |
1551 | } |
1552 | |
1553 | static int at91_start(struct usb_gadget *gadget, |
1554 | struct usb_gadget_driver *driver) |
1555 | { |
1556 | struct at91_udc *udc; |
1557 | |
1558 | udc = container_of(gadget, struct at91_udc, gadget); |
1559 | udc->driver = driver; |
1560 | udc->gadget.dev.of_node = udc->pdev->dev.of_node; |
1561 | udc->enabled = 1; |
1562 | udc->gadget.is_selfpowered = 1; |
1563 | |
1564 | return 0; |
1565 | } |
1566 | |
1567 | static int at91_stop(struct usb_gadget *gadget) |
1568 | { |
1569 | struct at91_udc *udc; |
1570 | unsigned long flags; |
1571 | |
1572 | udc = container_of(gadget, struct at91_udc, gadget); |
1573 | spin_lock_irqsave(&udc->lock, flags); |
1574 | udc->enabled = 0; |
1575 | at91_udp_write(udc, AT91_UDP_IDR, ~0); |
1576 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1577 | |
1578 | udc->driver = NULL; |
1579 | |
1580 | return 0; |
1581 | } |
1582 | |
1583 | /*-------------------------------------------------------------------------*/ |
1584 | |
1585 | static void at91udc_shutdown(struct platform_device *dev) |
1586 | { |
1587 | struct at91_udc *udc = platform_get_drvdata(pdev: dev); |
1588 | unsigned long flags; |
1589 | |
1590 | /* force disconnect on reboot */ |
1591 | spin_lock_irqsave(&udc->lock, flags); |
1592 | pullup(udc: platform_get_drvdata(pdev: dev), is_on: 0); |
1593 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1594 | } |
1595 | |
1596 | static int at91rm9200_udc_init(struct at91_udc *udc) |
1597 | { |
1598 | struct at91_ep *ep; |
1599 | int i; |
1600 | |
1601 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
1602 | ep = &udc->ep[i]; |
1603 | |
1604 | switch (i) { |
1605 | case 0: |
1606 | case 3: |
1607 | ep->maxpacket = 8; |
1608 | break; |
1609 | case 1 ... 2: |
1610 | ep->maxpacket = 64; |
1611 | break; |
1612 | case 4 ... 5: |
1613 | ep->maxpacket = 256; |
1614 | break; |
1615 | } |
1616 | } |
1617 | |
1618 | if (!udc->board.pullup_pin) { |
1619 | DBG("no D+ pullup?\n" ); |
1620 | return -ENODEV; |
1621 | } |
1622 | |
1623 | gpiod_direction_output(desc: udc->board.pullup_pin, |
1624 | value: gpiod_is_active_low(desc: udc->board.pullup_pin)); |
1625 | |
1626 | return 0; |
1627 | } |
1628 | |
1629 | static void at91rm9200_udc_pullup(struct at91_udc *udc, int is_on) |
1630 | { |
1631 | gpiod_set_value(desc: udc->board.pullup_pin, value: is_on); |
1632 | } |
1633 | |
1634 | static const struct at91_udc_caps at91rm9200_udc_caps = { |
1635 | .init = at91rm9200_udc_init, |
1636 | .pullup = at91rm9200_udc_pullup, |
1637 | }; |
1638 | |
1639 | static int at91sam9260_udc_init(struct at91_udc *udc) |
1640 | { |
1641 | struct at91_ep *ep; |
1642 | int i; |
1643 | |
1644 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
1645 | ep = &udc->ep[i]; |
1646 | |
1647 | switch (i) { |
1648 | case 0 ... 3: |
1649 | ep->maxpacket = 64; |
1650 | break; |
1651 | case 4 ... 5: |
1652 | ep->maxpacket = 512; |
1653 | break; |
1654 | } |
1655 | } |
1656 | |
1657 | return 0; |
1658 | } |
1659 | |
1660 | static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on) |
1661 | { |
1662 | u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC); |
1663 | |
1664 | if (is_on) |
1665 | txvc |= AT91_UDP_TXVC_PUON; |
1666 | else |
1667 | txvc &= ~AT91_UDP_TXVC_PUON; |
1668 | |
1669 | at91_udp_write(udc, AT91_UDP_TXVC, txvc); |
1670 | } |
1671 | |
1672 | static const struct at91_udc_caps at91sam9260_udc_caps = { |
1673 | .init = at91sam9260_udc_init, |
1674 | .pullup = at91sam9260_udc_pullup, |
1675 | }; |
1676 | |
1677 | static int at91sam9261_udc_init(struct at91_udc *udc) |
1678 | { |
1679 | struct at91_ep *ep; |
1680 | int i; |
1681 | |
1682 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
1683 | ep = &udc->ep[i]; |
1684 | |
1685 | switch (i) { |
1686 | case 0: |
1687 | ep->maxpacket = 8; |
1688 | break; |
1689 | case 1 ... 3: |
1690 | ep->maxpacket = 64; |
1691 | break; |
1692 | case 4 ... 5: |
1693 | ep->maxpacket = 256; |
1694 | break; |
1695 | } |
1696 | } |
1697 | |
1698 | udc->matrix = syscon_regmap_lookup_by_phandle(np: udc->pdev->dev.of_node, |
1699 | property: "atmel,matrix" ); |
1700 | return PTR_ERR_OR_ZERO(ptr: udc->matrix); |
1701 | } |
1702 | |
1703 | static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on) |
1704 | { |
1705 | u32 usbpucr = 0; |
1706 | |
1707 | if (is_on) |
1708 | usbpucr = AT91_MATRIX_USBPUCR_PUON; |
1709 | |
1710 | regmap_update_bits(map: udc->matrix, AT91SAM9261_MATRIX_USBPUCR, |
1711 | AT91_MATRIX_USBPUCR_PUON, val: usbpucr); |
1712 | } |
1713 | |
1714 | static const struct at91_udc_caps at91sam9261_udc_caps = { |
1715 | .init = at91sam9261_udc_init, |
1716 | .pullup = at91sam9261_udc_pullup, |
1717 | }; |
1718 | |
1719 | static int at91sam9263_udc_init(struct at91_udc *udc) |
1720 | { |
1721 | struct at91_ep *ep; |
1722 | int i; |
1723 | |
1724 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
1725 | ep = &udc->ep[i]; |
1726 | |
1727 | switch (i) { |
1728 | case 0: |
1729 | case 1: |
1730 | case 2: |
1731 | case 3: |
1732 | ep->maxpacket = 64; |
1733 | break; |
1734 | case 4: |
1735 | case 5: |
1736 | ep->maxpacket = 256; |
1737 | break; |
1738 | } |
1739 | } |
1740 | |
1741 | return 0; |
1742 | } |
1743 | |
1744 | static const struct at91_udc_caps at91sam9263_udc_caps = { |
1745 | .init = at91sam9263_udc_init, |
1746 | .pullup = at91sam9260_udc_pullup, |
1747 | }; |
1748 | |
1749 | static const struct of_device_id at91_udc_dt_ids[] = { |
1750 | { |
1751 | .compatible = "atmel,at91rm9200-udc" , |
1752 | .data = &at91rm9200_udc_caps, |
1753 | }, |
1754 | { |
1755 | .compatible = "atmel,at91sam9260-udc" , |
1756 | .data = &at91sam9260_udc_caps, |
1757 | }, |
1758 | { |
1759 | .compatible = "atmel,at91sam9261-udc" , |
1760 | .data = &at91sam9261_udc_caps, |
1761 | }, |
1762 | { |
1763 | .compatible = "atmel,at91sam9263-udc" , |
1764 | .data = &at91sam9263_udc_caps, |
1765 | }, |
1766 | { /* sentinel */ } |
1767 | }; |
1768 | MODULE_DEVICE_TABLE(of, at91_udc_dt_ids); |
1769 | |
1770 | static void at91udc_of_init(struct at91_udc *udc, struct device_node *np) |
1771 | { |
1772 | struct at91_udc_data *board = &udc->board; |
1773 | const struct of_device_id *match; |
1774 | u32 val; |
1775 | |
1776 | if (of_property_read_u32(np, propname: "atmel,vbus-polled" , out_value: &val) == 0) |
1777 | board->vbus_polled = 1; |
1778 | |
1779 | board->vbus_pin = fwnode_gpiod_get_index(of_fwnode_handle(np), |
1780 | con_id: "atmel,vbus" , index: 0, flags: GPIOD_IN, |
1781 | label: "udc_vbus" ); |
1782 | if (IS_ERR(ptr: board->vbus_pin)) |
1783 | board->vbus_pin = NULL; |
1784 | |
1785 | board->pullup_pin = fwnode_gpiod_get_index(of_fwnode_handle(np), |
1786 | con_id: "atmel,pullup" , index: 0, |
1787 | flags: GPIOD_ASIS, label: "udc_pullup" ); |
1788 | if (IS_ERR(ptr: board->pullup_pin)) |
1789 | board->pullup_pin = NULL; |
1790 | |
1791 | match = of_match_node(matches: at91_udc_dt_ids, node: np); |
1792 | if (match) |
1793 | udc->caps = match->data; |
1794 | } |
1795 | |
1796 | static int at91udc_probe(struct platform_device *pdev) |
1797 | { |
1798 | struct device *dev = &pdev->dev; |
1799 | struct at91_udc *udc; |
1800 | int retval; |
1801 | struct at91_ep *ep; |
1802 | int i; |
1803 | |
1804 | udc = devm_kzalloc(dev, size: sizeof(*udc), GFP_KERNEL); |
1805 | if (!udc) |
1806 | return -ENOMEM; |
1807 | |
1808 | /* init software state */ |
1809 | udc->gadget.dev.parent = dev; |
1810 | at91udc_of_init(udc, np: pdev->dev.of_node); |
1811 | udc->pdev = pdev; |
1812 | udc->enabled = 0; |
1813 | spin_lock_init(&udc->lock); |
1814 | |
1815 | udc->gadget.ops = &at91_udc_ops; |
1816 | udc->gadget.ep0 = &udc->ep[0].ep; |
1817 | udc->gadget.name = driver_name; |
1818 | udc->gadget.dev.init_name = "gadget" ; |
1819 | |
1820 | for (i = 0; i < NUM_ENDPOINTS; i++) { |
1821 | ep = &udc->ep[i]; |
1822 | ep->ep.name = ep_info[i].name; |
1823 | ep->ep.caps = ep_info[i].caps; |
1824 | ep->ep.ops = &at91_ep_ops; |
1825 | ep->udc = udc; |
1826 | ep->int_mask = BIT(i); |
1827 | if (i != 0 && i != 3) |
1828 | ep->is_pingpong = 1; |
1829 | } |
1830 | |
1831 | udc->udp_baseaddr = devm_platform_ioremap_resource(pdev, index: 0); |
1832 | if (IS_ERR(ptr: udc->udp_baseaddr)) |
1833 | return PTR_ERR(ptr: udc->udp_baseaddr); |
1834 | |
1835 | if (udc->caps && udc->caps->init) { |
1836 | retval = udc->caps->init(udc); |
1837 | if (retval) |
1838 | return retval; |
1839 | } |
1840 | |
1841 | udc_reinit(udc); |
1842 | |
1843 | /* get interface and function clocks */ |
1844 | udc->iclk = devm_clk_get(dev, id: "pclk" ); |
1845 | if (IS_ERR(ptr: udc->iclk)) |
1846 | return PTR_ERR(ptr: udc->iclk); |
1847 | |
1848 | udc->fclk = devm_clk_get(dev, id: "hclk" ); |
1849 | if (IS_ERR(ptr: udc->fclk)) |
1850 | return PTR_ERR(ptr: udc->fclk); |
1851 | |
1852 | /* don't do anything until we have both gadget driver and VBUS */ |
1853 | clk_set_rate(clk: udc->fclk, rate: 48000000); |
1854 | retval = clk_prepare(clk: udc->fclk); |
1855 | if (retval) |
1856 | return retval; |
1857 | |
1858 | retval = clk_prepare_enable(clk: udc->iclk); |
1859 | if (retval) |
1860 | goto err_unprepare_fclk; |
1861 | |
1862 | at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); |
1863 | at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff); |
1864 | /* Clear all pending interrupts - UDP may be used by bootloader. */ |
1865 | at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff); |
1866 | clk_disable(clk: udc->iclk); |
1867 | |
1868 | /* request UDC and maybe VBUS irqs */ |
1869 | udc->udp_irq = retval = platform_get_irq(pdev, 0); |
1870 | if (retval < 0) |
1871 | goto err_unprepare_iclk; |
1872 | retval = devm_request_irq(dev, irq: udc->udp_irq, handler: at91_udc_irq, irqflags: 0, |
1873 | devname: driver_name, dev_id: udc); |
1874 | if (retval) { |
1875 | DBG("request irq %d failed\n" , udc->udp_irq); |
1876 | goto err_unprepare_iclk; |
1877 | } |
1878 | |
1879 | if (udc->board.vbus_pin) { |
1880 | gpiod_direction_input(desc: udc->board.vbus_pin); |
1881 | |
1882 | /* |
1883 | * Get the initial state of VBUS - we cannot expect |
1884 | * a pending interrupt. |
1885 | */ |
1886 | udc->vbus = gpiod_get_value_cansleep(desc: udc->board.vbus_pin); |
1887 | |
1888 | if (udc->board.vbus_polled) { |
1889 | INIT_WORK(&udc->vbus_timer_work, at91_vbus_timer_work); |
1890 | timer_setup(&udc->vbus_timer, at91_vbus_timer, 0); |
1891 | mod_timer(timer: &udc->vbus_timer, |
1892 | expires: jiffies + VBUS_POLL_TIMEOUT); |
1893 | } else { |
1894 | retval = devm_request_irq(dev, |
1895 | irq: gpiod_to_irq(desc: udc->board.vbus_pin), |
1896 | handler: at91_vbus_irq, irqflags: 0, devname: driver_name, dev_id: udc); |
1897 | if (retval) { |
1898 | DBG("request vbus irq %d failed\n" , |
1899 | desc_to_gpio(udc->board.vbus_pin)); |
1900 | goto err_unprepare_iclk; |
1901 | } |
1902 | } |
1903 | } else { |
1904 | DBG("no VBUS detection, assuming always-on\n" ); |
1905 | udc->vbus = 1; |
1906 | } |
1907 | retval = usb_add_gadget_udc(parent: dev, gadget: &udc->gadget); |
1908 | if (retval) |
1909 | goto err_unprepare_iclk; |
1910 | dev_set_drvdata(dev, data: udc); |
1911 | device_init_wakeup(dev, enable: 1); |
1912 | create_debug_file(udc); |
1913 | |
1914 | INFO("%s version %s\n" , driver_name, DRIVER_VERSION); |
1915 | return 0; |
1916 | |
1917 | err_unprepare_iclk: |
1918 | clk_unprepare(clk: udc->iclk); |
1919 | err_unprepare_fclk: |
1920 | clk_unprepare(clk: udc->fclk); |
1921 | |
1922 | DBG("%s probe failed, %d\n" , driver_name, retval); |
1923 | |
1924 | return retval; |
1925 | } |
1926 | |
1927 | static void at91udc_remove(struct platform_device *pdev) |
1928 | { |
1929 | struct at91_udc *udc = platform_get_drvdata(pdev); |
1930 | unsigned long flags; |
1931 | |
1932 | DBG("remove\n" ); |
1933 | |
1934 | usb_del_gadget_udc(gadget: &udc->gadget); |
1935 | if (udc->driver) { |
1936 | dev_err(&pdev->dev, |
1937 | "Driver still in use but removing anyhow\n" ); |
1938 | return; |
1939 | } |
1940 | |
1941 | spin_lock_irqsave(&udc->lock, flags); |
1942 | pullup(udc, is_on: 0); |
1943 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1944 | |
1945 | device_init_wakeup(dev: &pdev->dev, enable: 0); |
1946 | remove_debug_file(udc); |
1947 | clk_unprepare(clk: udc->fclk); |
1948 | clk_unprepare(clk: udc->iclk); |
1949 | } |
1950 | |
1951 | #ifdef CONFIG_PM |
1952 | static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg) |
1953 | { |
1954 | struct at91_udc *udc = platform_get_drvdata(pdev); |
1955 | int wake = udc->driver && device_may_wakeup(dev: &pdev->dev); |
1956 | unsigned long flags; |
1957 | |
1958 | /* Unless we can act normally to the host (letting it wake us up |
1959 | * whenever it has work for us) force disconnect. Wakeup requires |
1960 | * PLLB for USB events (signaling for reset, wakeup, or incoming |
1961 | * tokens) and VBUS irqs (on systems which support them). |
1962 | */ |
1963 | if ((!udc->suspended && udc->addr) |
1964 | || !wake |
1965 | || at91_suspend_entering_slow_clock()) { |
1966 | spin_lock_irqsave(&udc->lock, flags); |
1967 | pullup(udc, is_on: 0); |
1968 | wake = 0; |
1969 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1970 | } else |
1971 | enable_irq_wake(irq: udc->udp_irq); |
1972 | |
1973 | udc->active_suspend = wake; |
1974 | if (udc->board.vbus_pin && !udc->board.vbus_polled && wake) |
1975 | enable_irq_wake(irq: gpiod_to_irq(desc: udc->board.vbus_pin)); |
1976 | return 0; |
1977 | } |
1978 | |
1979 | static int at91udc_resume(struct platform_device *pdev) |
1980 | { |
1981 | struct at91_udc *udc = platform_get_drvdata(pdev); |
1982 | unsigned long flags; |
1983 | |
1984 | if (udc->board.vbus_pin && !udc->board.vbus_polled && |
1985 | udc->active_suspend) |
1986 | disable_irq_wake(irq: gpiod_to_irq(desc: udc->board.vbus_pin)); |
1987 | |
1988 | /* maybe reconnect to host; if so, clocks on */ |
1989 | if (udc->active_suspend) |
1990 | disable_irq_wake(irq: udc->udp_irq); |
1991 | else { |
1992 | spin_lock_irqsave(&udc->lock, flags); |
1993 | pullup(udc, is_on: 1); |
1994 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
1995 | } |
1996 | return 0; |
1997 | } |
1998 | #else |
1999 | #define at91udc_suspend NULL |
2000 | #define at91udc_resume NULL |
2001 | #endif |
2002 | |
2003 | static struct platform_driver at91_udc_driver = { |
2004 | .probe = at91udc_probe, |
2005 | .remove_new = at91udc_remove, |
2006 | .shutdown = at91udc_shutdown, |
2007 | .suspend = at91udc_suspend, |
2008 | .resume = at91udc_resume, |
2009 | .driver = { |
2010 | .name = driver_name, |
2011 | .of_match_table = at91_udc_dt_ids, |
2012 | }, |
2013 | }; |
2014 | |
2015 | module_platform_driver(at91_udc_driver); |
2016 | |
2017 | MODULE_DESCRIPTION("AT91 udc driver" ); |
2018 | MODULE_AUTHOR("Thomas Rathbone, David Brownell" ); |
2019 | MODULE_LICENSE("GPL" ); |
2020 | MODULE_ALIAS("platform:at91_udc" ); |
2021 | |