?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.2.1
[linux/fpc-iii.git] / drivers / usb / gadget / udc / gr_udc.c
blobc8868870e21770782cf9049b4a8bdbcc80cf9a00
1 /*
2 * USB Peripheral Controller driver for Aeroflex Gaisler GRUSBDC.
3 *
4 * 2013 (c) Aeroflex Gaisler AB
5 *
6 * This driver supports GRUSBDC USB Device Controller cores available in the
7 * GRLIB VHDL IP core library.
8 *
9 * Full documentation of the GRUSBDC core can be found here:
10 * http://www.gaisler.com/products/grlib/grip.pdf
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
16 *
17 * Contributors:
18 * - Andreas Larsson <andreas@gaisler.com>
19 * - Marko Isomaki
20 */
21
22 /*
23 * A GRUSBDC core can have up to 16 IN endpoints and 16 OUT endpoints each
24 * individually configurable to any of the four USB transfer types. This driver
25 * only supports cores in DMA mode.
26 */
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/spinlock.h>
32 #include <linux/errno.h>
33 #include <linux/list.h>
34 #include <linux/interrupt.h>
35 #include <linux/device.h>
36 #include <linux/usb/ch9.h>
37 #include <linux/usb/gadget.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/dmapool.h>
40 #include <linux/debugfs.h>
41 #include <linux/seq_file.h>
42 #include <linux/of_platform.h>
43 #include <linux/of_irq.h>
44 #include <linux/of_address.h>
45
46 #include <asm/byteorder.h>
47
48 #include "gr_udc.h"
49
50 #define DRIVER_NAME "gr_udc"
51 #define DRIVER_DESC "Aeroflex Gaisler GRUSBDC USB Peripheral Controller"
52
53 static const char driver_name[] = DRIVER_NAME;
54 static const char driver_desc[] = DRIVER_DESC;
55
56 #define gr_read32(x) (ioread32be((x)))
57 #define gr_write32(x, v) (iowrite32be((v), (x)))
58
59 /* USB speed and corresponding string calculated from status register value */
60 #define GR_SPEED(status) \
61 ((status & GR_STATUS_SP) ? USB_SPEED_FULL : USB_SPEED_HIGH)
62 #define GR_SPEED_STR(status) usb_speed_string(GR_SPEED(status))
63
64 /* Size of hardware buffer calculated from epctrl register value */
65 #define GR_BUFFER_SIZE(epctrl) \
66 ((((epctrl) & GR_EPCTRL_BUFSZ_MASK) >> GR_EPCTRL_BUFSZ_POS) * \
67 GR_EPCTRL_BUFSZ_SCALER)
68
69 /* ---------------------------------------------------------------------- */
70 /* Debug printout functionality */
71
72 static const char * const gr_modestring[] = {"control", "iso", "bulk", "int"};
73
74 static const char *gr_ep0state_string(enum gr_ep0state state)
75 {
76 static const char *const names[] = {
77 [GR_EP0_DISCONNECT] = "disconnect",
78 [GR_EP0_SETUP] = "setup",
79 [GR_EP0_IDATA] = "idata",
80 [GR_EP0_ODATA] = "odata",
81 [GR_EP0_ISTATUS] = "istatus",
82 [GR_EP0_OSTATUS] = "ostatus",
83 [GR_EP0_STALL] = "stall",
84 [GR_EP0_SUSPEND] = "suspend",
85 };
86
87 if (state < 0 || state >= ARRAY_SIZE(names))
88 return "UNKNOWN";
89
90 return names[state];
91 }
92
93 #ifdef VERBOSE_DEBUG
94
95 static void gr_dbgprint_request(const char *str, struct gr_ep *ep,
96 struct gr_request *req)
97 {
98 int buflen = ep->is_in ? req->req.length : req->req.actual;
99 int rowlen = 32;
100 int plen = min(rowlen, buflen);
101
102 dev_dbg(ep->dev->dev, "%s: 0x%p, %d bytes data%s:\n", str, req, buflen,
103 (buflen > plen ? " (truncated)" : ""));
104 print_hex_dump_debug(" ", DUMP_PREFIX_NONE,
105 rowlen, 4, req->req.buf, plen, false);
106 }
107
108 static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
109 u16 value, u16 index, u16 length)
110 {
111 dev_vdbg(dev->dev, "REQ: %02x.%02x v%04x i%04x l%04x\n",
112 type, request, value, index, length);
113 }
114 #else /* !VERBOSE_DEBUG */
115
116 static void gr_dbgprint_request(const char *str, struct gr_ep *ep,
117 struct gr_request *req) {}
118
119 static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
120 u16 value, u16 index, u16 length) {}
121
122 #endif /* VERBOSE_DEBUG */
123
124 /* ---------------------------------------------------------------------- */
125 /* Debugfs functionality */
126
127 #ifdef CONFIG_USB_GADGET_DEBUG_FS
128
129 static void gr_seq_ep_show(struct seq_file *seq, struct gr_ep *ep)
130 {
131 u32 epctrl = gr_read32(&ep->regs->epctrl);
132 u32 epstat = gr_read32(&ep->regs->epstat);
133 int mode = (epctrl & GR_EPCTRL_TT_MASK) >> GR_EPCTRL_TT_POS;
134 struct gr_request *req;
135
136 seq_printf(seq, "%s:\n", ep->ep.name);
137 seq_printf(seq, " mode = %s\n", gr_modestring[mode]);
138 seq_printf(seq, " halted: %d\n", !!(epctrl & GR_EPCTRL_EH));
139 seq_printf(seq, " disabled: %d\n", !!(epctrl & GR_EPCTRL_ED));
140 seq_printf(seq, " valid: %d\n", !!(epctrl & GR_EPCTRL_EV));
141 seq_printf(seq, " dma_start = %d\n", ep->dma_start);
142 seq_printf(seq, " stopped = %d\n", ep->stopped);
143 seq_printf(seq, " wedged = %d\n", ep->wedged);
144 seq_printf(seq, " callback = %d\n", ep->callback);
145 seq_printf(seq, " maxpacket = %d\n", ep->ep.maxpacket);
146 seq_printf(seq, " maxpacket_limit = %d\n", ep->ep.maxpacket_limit);
147 seq_printf(seq, " bytes_per_buffer = %d\n", ep->bytes_per_buffer);
148 if (mode == 1 || mode == 3)
149 seq_printf(seq, " nt = %d\n",
150 (epctrl & GR_EPCTRL_NT_MASK) >> GR_EPCTRL_NT_POS);
151
152 seq_printf(seq, " Buffer 0: %s %s%d\n",
153 epstat & GR_EPSTAT_B0 ? "valid" : "invalid",
154 epstat & GR_EPSTAT_BS ? " " : "selected ",
155 (epstat & GR_EPSTAT_B0CNT_MASK) >> GR_EPSTAT_B0CNT_POS);
156 seq_printf(seq, " Buffer 1: %s %s%d\n",
157 epstat & GR_EPSTAT_B1 ? "valid" : "invalid",
158 epstat & GR_EPSTAT_BS ? "selected " : " ",
159 (epstat & GR_EPSTAT_B1CNT_MASK) >> GR_EPSTAT_B1CNT_POS);
160
161 if (list_empty(&ep->queue)) {
162 seq_puts(seq, " Queue: empty\n\n");
163 return;
164 }
165
166 seq_puts(seq, " Queue:\n");
167 list_for_each_entry(req, &ep->queue, queue) {
168 struct gr_dma_desc *desc;
169 struct gr_dma_desc *next;
170
171 seq_printf(seq, " 0x%p: 0x%p %d %d\n", req,
172 &req->req.buf, req->req.actual, req->req.length);
173
174 next = req->first_desc;
175 do {
176 desc = next;
177 next = desc->next_desc;
178 seq_printf(seq, " %c 0x%p (0x%08x): 0x%05x 0x%08x\n",
179 desc == req->curr_desc ? 'c' : ' ',
180 desc, desc->paddr, desc->ctrl, desc->data);
181 } while (desc != req->last_desc);
182 }
183 seq_puts(seq, "\n");
184 }
185
186
187 static int gr_seq_show(struct seq_file *seq, void *v)
188 {
189 struct gr_udc *dev = seq->private;
190 u32 control = gr_read32(&dev->regs->control);
191 u32 status = gr_read32(&dev->regs->status);
192 struct gr_ep *ep;
193
194 seq_printf(seq, "usb state = %s\n",
195 usb_state_string(dev->gadget.state));
196 seq_printf(seq, "address = %d\n",
197 (control & GR_CONTROL_UA_MASK) >> GR_CONTROL_UA_POS);
198 seq_printf(seq, "speed = %s\n", GR_SPEED_STR(status));
199 seq_printf(seq, "ep0state = %s\n", gr_ep0state_string(dev->ep0state));
200 seq_printf(seq, "irq_enabled = %d\n", dev->irq_enabled);
201 seq_printf(seq, "remote_wakeup = %d\n", dev->remote_wakeup);
202 seq_printf(seq, "test_mode = %d\n", dev->test_mode);
203 seq_puts(seq, "\n");
204
205 list_for_each_entry(ep, &dev->ep_list, ep_list)
206 gr_seq_ep_show(seq, ep);
207
208 return 0;
209 }
210
211 static int gr_dfs_open(struct inode *inode, struct file *file)
212 {
213 return single_open(file, gr_seq_show, inode->i_private);
214 }
215
216 static const struct file_operations gr_dfs_fops = {
217 .owner = THIS_MODULE,
218 .open = gr_dfs_open,
219 .read = seq_read,
220 .llseek = seq_lseek,
221 .release = single_release,
222 };
223
224 static void gr_dfs_create(struct gr_udc *dev)
225 {
226 const char *name = "gr_udc_state";
227
228 dev->dfs_root = debugfs_create_dir(dev_name(dev->dev), NULL);
229 dev->dfs_state = debugfs_create_file(name, 0444, dev->dfs_root, dev,
230 &gr_dfs_fops);
231 }
232
233 static void gr_dfs_delete(struct gr_udc *dev)
234 {
235 /* Handles NULL and ERR pointers internally */
236 debugfs_remove(dev->dfs_state);
237 debugfs_remove(dev->dfs_root);
238 }
239
240 #else /* !CONFIG_USB_GADGET_DEBUG_FS */
241
242 static void gr_dfs_create(struct gr_udc *dev) {}
243 static void gr_dfs_delete(struct gr_udc *dev) {}
244
245 #endif /* CONFIG_USB_GADGET_DEBUG_FS */
246
247 /* ---------------------------------------------------------------------- */
248 /* DMA and request handling */
249
250 /* Allocates a new struct gr_dma_desc, sets paddr and zeroes the rest */
251 static struct gr_dma_desc *gr_alloc_dma_desc(struct gr_ep *ep, gfp_t gfp_flags)
252 {
253 dma_addr_t paddr;
254 struct gr_dma_desc *dma_desc;
255
256 dma_desc = dma_pool_alloc(ep->dev->desc_pool, gfp_flags, &paddr);
257 if (!dma_desc) {
258 dev_err(ep->dev->dev, "Could not allocate from DMA pool\n");
259 return NULL;
260 }
261
262 memset(dma_desc, 0, sizeof(*dma_desc));
263 dma_desc->paddr = paddr;
264
265 return dma_desc;
266 }
267
268 static inline void gr_free_dma_desc(struct gr_udc *dev,
269 struct gr_dma_desc *desc)
270 {
271 dma_pool_free(dev->desc_pool, desc, (dma_addr_t)desc->paddr);
272 }
273
274 /* Frees the chain of struct gr_dma_desc for the given request */
275 static void gr_free_dma_desc_chain(struct gr_udc *dev, struct gr_request *req)
276 {
277 struct gr_dma_desc *desc;
278 struct gr_dma_desc *next;
279
280 next = req->first_desc;
281 if (!next)
282 return;
283
284 do {
285 desc = next;
286 next = desc->next_desc;
287 gr_free_dma_desc(dev, desc);
288 } while (desc != req->last_desc);
289
290 req->first_desc = NULL;
291 req->curr_desc = NULL;
292 req->last_desc = NULL;
293 }
294
295 static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req);
296
297 /*
298 * Frees allocated resources and calls the appropriate completion function/setup
299 * package handler for a finished request.
300 *
301 * Must be called with dev->lock held and irqs disabled.
302 */
303 static void gr_finish_request(struct gr_ep *ep, struct gr_request *req,
304 int status)
305 __releases(&dev->lock)
306 __acquires(&dev->lock)
307 {
308 struct gr_udc *dev;
309
310 list_del_init(&req->queue);
311
312 if (likely(req->req.status == -EINPROGRESS))
313 req->req.status = status;
314 else
315 status = req->req.status;
316
317 dev = ep->dev;
318 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
319 gr_free_dma_desc_chain(dev, req);
320
321 if (ep->is_in) { /* For OUT, req->req.actual gets updated bit by bit */
322 req->req.actual = req->req.length;
323 } else if (req->oddlen && req->req.actual > req->evenlen) {
324 /*
325 * Copy to user buffer in this case where length was not evenly
326 * divisible by ep->ep.maxpacket and the last descriptor was
327 * actually used.
328 */
329 char *buftail = ((char *)req->req.buf + req->evenlen);
330
331 memcpy(buftail, ep->tailbuf, req->oddlen);
332
333 if (req->req.actual > req->req.length) {
334 /* We got more data than was requested */
335 dev_dbg(ep->dev->dev, "Overflow for ep %s\n",
336 ep->ep.name);
337 gr_dbgprint_request("OVFL", ep, req);
338 req->req.status = -EOVERFLOW;
339 }
340 }
341
342 if (!status) {
343 if (ep->is_in)
344 gr_dbgprint_request("SENT", ep, req);
345 else
346 gr_dbgprint_request("RECV", ep, req);
347 }
348
349 /* Prevent changes to ep->queue during callback */
350 ep->callback = 1;
351 if (req == dev->ep0reqo && !status) {
352 if (req->setup)
353 gr_ep0_setup(dev, req);
354 else
355 dev_err(dev->dev,
356 "Unexpected non setup packet on ep0in\n");
357 } else if (req->req.complete) {
358 spin_unlock(&dev->lock);
359
360 usb_gadget_giveback_request(&ep->ep, &req->req);
361
362 spin_lock(&dev->lock);
363 }
364 ep->callback = 0;
365 }
366
367 static struct usb_request *gr_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
368 {
369 struct gr_request *req;
370
371 req = kzalloc(sizeof(*req), gfp_flags);
372 if (!req)
373 return NULL;
374
375 INIT_LIST_HEAD(&req->queue);
376
377 return &req->req;
378 }
379
380 /*
381 * Starts DMA for endpoint ep if there are requests in the queue.
382 *
383 * Must be called with dev->lock held and with !ep->stopped.
384 */
385 static void gr_start_dma(struct gr_ep *ep)
386 {
387 struct gr_request *req;
388 u32 dmactrl;
389
390 if (list_empty(&ep->queue)) {
391 ep->dma_start = 0;
392 return;
393 }
394
395 req = list_first_entry(&ep->queue, struct gr_request, queue);
396
397 /* A descriptor should already have been allocated */
398 BUG_ON(!req->curr_desc);
399
400 /*
401 * The DMA controller can not handle smaller OUT buffers than
402 * ep->ep.maxpacket. It could lead to buffer overruns if an unexpectedly
403 * long packet are received. Therefore an internal bounce buffer gets
404 * used when such a request gets enabled.
405 */
406 if (!ep->is_in && req->oddlen)
407 req->last_desc->data = ep->tailbuf_paddr;
408
409 wmb(); /* Make sure all is settled before handing it over to DMA */
410
411 /* Set the descriptor pointer in the hardware */
412 gr_write32(&ep->regs->dmaaddr, req->curr_desc->paddr);
413
414 /* Announce available descriptors */
415 dmactrl = gr_read32(&ep->regs->dmactrl);
416 gr_write32(&ep->regs->dmactrl, dmactrl | GR_DMACTRL_DA);
417
418 ep->dma_start = 1;
419 }
420
421 /*
422 * Finishes the first request in the ep's queue and, if available, starts the
423 * next request in queue.
424 *
425 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
426 */
427 static void gr_dma_advance(struct gr_ep *ep, int status)
428 {
429 struct gr_request *req;
430
431 req = list_first_entry(&ep->queue, struct gr_request, queue);
432 gr_finish_request(ep, req, status);
433 gr_start_dma(ep); /* Regardless of ep->dma_start */
434 }
435
436 /*
437 * Abort DMA for an endpoint. Sets the abort DMA bit which causes an ongoing DMA
438 * transfer to be canceled and clears GR_DMACTRL_DA.
439 *
440 * Must be called with dev->lock held.
441 */
442 static void gr_abort_dma(struct gr_ep *ep)
443 {
444 u32 dmactrl;
445
446 dmactrl = gr_read32(&ep->regs->dmactrl);
447 gr_write32(&ep->regs->dmactrl, dmactrl | GR_DMACTRL_AD);
448 }
449
450 /*
451 * Allocates and sets up a struct gr_dma_desc and putting it on the descriptor
452 * chain.
453 *
454 * Size is not used for OUT endpoints. Hardware can not be instructed to handle
455 * smaller buffer than MAXPL in the OUT direction.
456 */
457 static int gr_add_dma_desc(struct gr_ep *ep, struct gr_request *req,
458 dma_addr_t data, unsigned size, gfp_t gfp_flags)
459 {
460 struct gr_dma_desc *desc;
461
462 desc = gr_alloc_dma_desc(ep, gfp_flags);
463 if (!desc)
464 return -ENOMEM;
465
466 desc->data = data;
467 if (ep->is_in)
468 desc->ctrl =
469 (GR_DESC_IN_CTRL_LEN_MASK & size) | GR_DESC_IN_CTRL_EN;
470 else
471 desc->ctrl = GR_DESC_OUT_CTRL_IE;
472
473 if (!req->first_desc) {
474 req->first_desc = desc;
475 req->curr_desc = desc;
476 } else {
477 req->last_desc->next_desc = desc;
478 req->last_desc->next = desc->paddr;
479 req->last_desc->ctrl |= GR_DESC_OUT_CTRL_NX;
480 }
481 req->last_desc = desc;
482
483 return 0;
484 }
485
486 /*
487 * Sets up a chain of struct gr_dma_descriptors pointing to buffers that
488 * together covers req->req.length bytes of the buffer at DMA address
489 * req->req.dma for the OUT direction.
490 *
491 * The first descriptor in the chain is enabled, the rest disabled. The
492 * interrupt handler will later enable them one by one when needed so we can
493 * find out when the transfer is finished. For OUT endpoints, all descriptors
494 * therefore generate interrutps.
495 */
496 static int gr_setup_out_desc_list(struct gr_ep *ep, struct gr_request *req,
497 gfp_t gfp_flags)
498 {
499 u16 bytes_left; /* Bytes left to provide descriptors for */
500 u16 bytes_used; /* Bytes accommodated for */
501 int ret = 0;
502
503 req->first_desc = NULL; /* Signals that no allocation is done yet */
504 bytes_left = req->req.length;
505 bytes_used = 0;
506 while (bytes_left > 0) {
507 dma_addr_t start = req->req.dma + bytes_used;
508 u16 size = min(bytes_left, ep->bytes_per_buffer);
509
510 if (size < ep->bytes_per_buffer) {
511 /* Prepare using bounce buffer */
512 req->evenlen = req->req.length - bytes_left;
513 req->oddlen = size;
514 }
515
516 ret = gr_add_dma_desc(ep, req, start, size, gfp_flags);
517 if (ret)
518 goto alloc_err;
519
520 bytes_left -= size;
521 bytes_used += size;
522 }
523
524 req->first_desc->ctrl |= GR_DESC_OUT_CTRL_EN;
525
526 return 0;
527
528 alloc_err:
529 gr_free_dma_desc_chain(ep->dev, req);
530
531 return ret;
532 }
533
534 /*
535 * Sets up a chain of struct gr_dma_descriptors pointing to buffers that
536 * together covers req->req.length bytes of the buffer at DMA address
537 * req->req.dma for the IN direction.
538 *
539 * When more data is provided than the maximum payload size, the hardware splits
540 * this up into several payloads automatically. Moreover, ep->bytes_per_buffer
541 * is always set to a multiple of the maximum payload (restricted to the valid
542 * number of maximum payloads during high bandwidth isochronous or interrupt
543 * transfers)
544 *
545 * All descriptors are enabled from the beginning and we only generate an
546 * interrupt for the last one indicating that the entire request has been pushed
547 * to hardware.
548 */
549 static int gr_setup_in_desc_list(struct gr_ep *ep, struct gr_request *req,
550 gfp_t gfp_flags)
551 {
552 u16 bytes_left; /* Bytes left in req to provide descriptors for */
553 u16 bytes_used; /* Bytes in req accommodated for */
554 int ret = 0;
555
556 req->first_desc = NULL; /* Signals that no allocation is done yet */
557 bytes_left = req->req.length;
558 bytes_used = 0;
559 do { /* Allow for zero length packets */
560 dma_addr_t start = req->req.dma + bytes_used;
561 u16 size = min(bytes_left, ep->bytes_per_buffer);
562
563 ret = gr_add_dma_desc(ep, req, start, size, gfp_flags);
564 if (ret)
565 goto alloc_err;
566
567 bytes_left -= size;
568 bytes_used += size;
569 } while (bytes_left > 0);
570
571 /*
572 * Send an extra zero length packet to indicate that no more data is
573 * available when req->req.zero is set and the data length is even
574 * multiples of ep->ep.maxpacket.
575 */
576 if (req->req.zero && (req->req.length % ep->ep.maxpacket == 0)) {
577 ret = gr_add_dma_desc(ep, req, 0, 0, gfp_flags);
578 if (ret)
579 goto alloc_err;
580 }
581
582 /*
583 * For IN packets we only want to know when the last packet has been
584 * transmitted (not just put into internal buffers).
585 */
586 req->last_desc->ctrl |= GR_DESC_IN_CTRL_PI;
587
588 return 0;
589
590 alloc_err:
591 gr_free_dma_desc_chain(ep->dev, req);
592
593 return ret;
594 }
595
596 /* Must be called with dev->lock held */
597 static int gr_queue(struct gr_ep *ep, struct gr_request *req, gfp_t gfp_flags)
598 {
599 struct gr_udc *dev = ep->dev;
600 int ret;
601
602 if (unlikely(!ep->ep.desc && ep->num != 0)) {
603 dev_err(dev->dev, "No ep descriptor for %s\n", ep->ep.name);
604 return -EINVAL;
605 }
606
607 if (unlikely(!req->req.buf || !list_empty(&req->queue))) {
608 dev_err(dev->dev,
609 "Invalid request for %s: buf=%p list_empty=%d\n",
610 ep->ep.name, req->req.buf, list_empty(&req->queue));
611 return -EINVAL;
612 }
613
614 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
615 dev_err(dev->dev, "-ESHUTDOWN");
616 return -ESHUTDOWN;
617 }
618
619 /* Can't touch registers when suspended */
620 if (dev->ep0state == GR_EP0_SUSPEND) {
621 dev_err(dev->dev, "-EBUSY");
622 return -EBUSY;
623 }
624
625 /* Set up DMA mapping in case the caller didn't */
626 ret = usb_gadget_map_request(&dev->gadget, &req->req, ep->is_in);
627 if (ret) {
628 dev_err(dev->dev, "usb_gadget_map_request");
629 return ret;
630 }
631
632 if (ep->is_in)
633 ret = gr_setup_in_desc_list(ep, req, gfp_flags);
634 else
635 ret = gr_setup_out_desc_list(ep, req, gfp_flags);
636 if (ret)
637 return ret;
638
639 req->req.status = -EINPROGRESS;
640 req->req.actual = 0;
641 list_add_tail(&req->queue, &ep->queue);
642
643 /* Start DMA if not started, otherwise interrupt handler handles it */
644 if (!ep->dma_start && likely(!ep->stopped))
645 gr_start_dma(ep);
646
647 return 0;
648 }
649
650 /*
651 * Queue a request from within the driver.
652 *
653 * Must be called with dev->lock held.
654 */
655 static inline int gr_queue_int(struct gr_ep *ep, struct gr_request *req,
656 gfp_t gfp_flags)
657 {
658 if (ep->is_in)
659 gr_dbgprint_request("RESP", ep, req);
660
661 return gr_queue(ep, req, gfp_flags);
662 }
663
664 /* ---------------------------------------------------------------------- */
665 /* General helper functions */
666
667 /*
668 * Dequeue ALL requests.
669 *
670 * Must be called with dev->lock held and irqs disabled.
671 */
672 static void gr_ep_nuke(struct gr_ep *ep)
673 {
674 struct gr_request *req;
675
676 ep->stopped = 1;
677 ep->dma_start = 0;
678 gr_abort_dma(ep);
679
680 while (!list_empty(&ep->queue)) {
681 req = list_first_entry(&ep->queue, struct gr_request, queue);
682 gr_finish_request(ep, req, -ESHUTDOWN);
683 }
684 }
685
686 /*
687 * Reset the hardware state of this endpoint.
688 *
689 * Must be called with dev->lock held.
690 */
691 static void gr_ep_reset(struct gr_ep *ep)
692 {
693 gr_write32(&ep->regs->epctrl, 0);
694 gr_write32(&ep->regs->dmactrl, 0);
695
696 ep->ep.maxpacket = MAX_CTRL_PL_SIZE;
697 ep->ep.desc = NULL;
698 ep->stopped = 1;
699 ep->dma_start = 0;
700 }
701
702 /*
703 * Generate STALL on ep0in/out.
704 *
705 * Must be called with dev->lock held.
706 */
707 static void gr_control_stall(struct gr_udc *dev)
708 {
709 u32 epctrl;
710
711 epctrl = gr_read32(&dev->epo[0].regs->epctrl);
712 gr_write32(&dev->epo[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
713 epctrl = gr_read32(&dev->epi[0].regs->epctrl);
714 gr_write32(&dev->epi[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
715
716 dev->ep0state = GR_EP0_STALL;
717 }
718
719 /*
720 * Halts, halts and wedges, or clears halt for an endpoint.
721 *
722 * Must be called with dev->lock held.
723 */
724 static int gr_ep_halt_wedge(struct gr_ep *ep, int halt, int wedge, int fromhost)
725 {
726 u32 epctrl;
727 int retval = 0;
728
729 if (ep->num && !ep->ep.desc)
730 return -EINVAL;
731
732 if (ep->num && ep->ep.desc->bmAttributes == USB_ENDPOINT_XFER_ISOC)
733 return -EOPNOTSUPP;
734
735 /* Never actually halt ep0, and therefore never clear halt for ep0 */
736 if (!ep->num) {
737 if (halt && !fromhost) {
738 /* ep0 halt from gadget - generate protocol stall */
739 gr_control_stall(ep->dev);
740 dev_dbg(ep->dev->dev, "EP: stall ep0\n");
741 return 0;
742 }
743 return -EINVAL;
744 }
745
746 dev_dbg(ep->dev->dev, "EP: %s halt %s\n",
747 (halt ? (wedge ? "wedge" : "set") : "clear"), ep->ep.name);
748
749 epctrl = gr_read32(&ep->regs->epctrl);
750 if (halt) {
751 /* Set HALT */
752 gr_write32(&ep->regs->epctrl, epctrl | GR_EPCTRL_EH);
753 ep->stopped = 1;
754 if (wedge)
755 ep->wedged = 1;
756 } else {
757 gr_write32(&ep->regs->epctrl, epctrl & ~GR_EPCTRL_EH);
758 ep->stopped = 0;
759 ep->wedged = 0;
760
761 /* Things might have been queued up in the meantime */
762 if (!ep->dma_start)
763 gr_start_dma(ep);
764 }
765
766 return retval;
767 }
768
769 /* Must be called with dev->lock held */
770 static inline void gr_set_ep0state(struct gr_udc *dev, enum gr_ep0state value)
771 {
772 if (dev->ep0state != value)
773 dev_vdbg(dev->dev, "STATE: ep0state=%s\n",
774 gr_ep0state_string(value));
775 dev->ep0state = value;
776 }
777
778 /*
779 * Should only be called when endpoints can not generate interrupts.
780 *
781 * Must be called with dev->lock held.
782 */
783 static void gr_disable_interrupts_and_pullup(struct gr_udc *dev)
784 {
785 gr_write32(&dev->regs->control, 0);
786 wmb(); /* Make sure that we do not deny one of our interrupts */
787 dev->irq_enabled = 0;
788 }
789
790 /*
791 * Stop all device activity and disable data line pullup.
792 *
793 * Must be called with dev->lock held and irqs disabled.
794 */
795 static void gr_stop_activity(struct gr_udc *dev)
796 {
797 struct gr_ep *ep;
798
799 list_for_each_entry(ep, &dev->ep_list, ep_list)
800 gr_ep_nuke(ep);
801
802 gr_disable_interrupts_and_pullup(dev);
803
804 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
805 usb_gadget_set_state(&dev->gadget, USB_STATE_NOTATTACHED);
806 }
807
808 /* ---------------------------------------------------------------------- */
809 /* ep0 setup packet handling */
810
811 static void gr_ep0_testmode_complete(struct usb_ep *_ep,
812 struct usb_request *_req)
813 {
814 struct gr_ep *ep;
815 struct gr_udc *dev;
816 u32 control;
817
818 ep = container_of(_ep, struct gr_ep, ep);
819 dev = ep->dev;
820
821 spin_lock(&dev->lock);
822
823 control = gr_read32(&dev->regs->control);
824 control |= GR_CONTROL_TM | (dev->test_mode << GR_CONTROL_TS_POS);
825 gr_write32(&dev->regs->control, control);
826
827 spin_unlock(&dev->lock);
828 }
829
830 static void gr_ep0_dummy_complete(struct usb_ep *_ep, struct usb_request *_req)
831 {
832 /* Nothing needs to be done here */
833 }
834
835 /*
836 * Queue a response on ep0in.
837 *
838 * Must be called with dev->lock held.
839 */
840 static int gr_ep0_respond(struct gr_udc *dev, u8 *buf, int length,
841 void (*complete)(struct usb_ep *ep,
842 struct usb_request *req))
843 {
844 u8 *reqbuf = dev->ep0reqi->req.buf;
845 int status;
846 int i;
847
848 for (i = 0; i < length; i++)
849 reqbuf[i] = buf[i];
850 dev->ep0reqi->req.length = length;
851 dev->ep0reqi->req.complete = complete;
852
853 status = gr_queue_int(&dev->epi[0], dev->ep0reqi, GFP_ATOMIC);
854 if (status < 0)
855 dev_err(dev->dev,
856 "Could not queue ep0in setup response: %d\n", status);
857
858 return status;
859 }
860
861 /*
862 * Queue a 2 byte response on ep0in.
863 *
864 * Must be called with dev->lock held.
865 */
866 static inline int gr_ep0_respond_u16(struct gr_udc *dev, u16 response)
867 {
868 __le16 le_response = cpu_to_le16(response);
869
870 return gr_ep0_respond(dev, (u8 *)&le_response, 2,
871 gr_ep0_dummy_complete);
872 }
873
874 /*
875 * Queue a ZLP response on ep0in.
876 *
877 * Must be called with dev->lock held.
878 */
879 static inline int gr_ep0_respond_empty(struct gr_udc *dev)
880 {
881 return gr_ep0_respond(dev, NULL, 0, gr_ep0_dummy_complete);
882 }
883
884 /*
885 * This is run when a SET_ADDRESS request is received. First writes
886 * the new address to the control register which is updated internally
887 * when the next IN packet is ACKED.
888 *
889 * Must be called with dev->lock held.
890 */
891 static void gr_set_address(struct gr_udc *dev, u8 address)
892 {
893 u32 control;
894
895 control = gr_read32(&dev->regs->control) & ~GR_CONTROL_UA_MASK;
896 control |= (address << GR_CONTROL_UA_POS) & GR_CONTROL_UA_MASK;
897 control |= GR_CONTROL_SU;
898 gr_write32(&dev->regs->control, control);
899 }
900
901 /*
902 * Returns negative for STALL, 0 for successful handling and positive for
903 * delegation.
904 *
905 * Must be called with dev->lock held.
906 */
907 static int gr_device_request(struct gr_udc *dev, u8 type, u8 request,
908 u16 value, u16 index)
909 {
910 u16 response;
911 u8 test;
912
913 switch (request) {
914 case USB_REQ_SET_ADDRESS:
915 dev_dbg(dev->dev, "STATUS: address %d\n", value & 0xff);
916 gr_set_address(dev, value & 0xff);
917 if (value)
918 usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
919 else
920 usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
921 return gr_ep0_respond_empty(dev);
922
923 case USB_REQ_GET_STATUS:
924 /* Self powered | remote wakeup */
925 response = 0x0001 | (dev->remote_wakeup ? 0x0002 : 0);
926 return gr_ep0_respond_u16(dev, response);
927
928 case USB_REQ_SET_FEATURE:
929 switch (value) {
930 case USB_DEVICE_REMOTE_WAKEUP:
931 /* Allow remote wakeup */
932 dev->remote_wakeup = 1;
933 return gr_ep0_respond_empty(dev);
934
935 case USB_DEVICE_TEST_MODE:
936 /* The hardware does not support TEST_FORCE_EN */
937 test = index >> 8;
938 if (test >= TEST_J && test <= TEST_PACKET) {
939 dev->test_mode = test;
940 return gr_ep0_respond(dev, NULL, 0,
941 gr_ep0_testmode_complete);
942 }
943 }
944 break;
945
946 case USB_REQ_CLEAR_FEATURE:
947 switch (value) {
948 case USB_DEVICE_REMOTE_WAKEUP:
949 /* Disallow remote wakeup */
950 dev->remote_wakeup = 0;
951 return gr_ep0_respond_empty(dev);
952 }
953 break;
954 }
955
956 return 1; /* Delegate the rest */
957 }
958
959 /*
960 * Returns negative for STALL, 0 for successful handling and positive for
961 * delegation.
962 *
963 * Must be called with dev->lock held.
964 */
965 static int gr_interface_request(struct gr_udc *dev, u8 type, u8 request,
966 u16 value, u16 index)
967 {
968 if (dev->gadget.state != USB_STATE_CONFIGURED)
969 return -1;
970
971 /*
972 * Should return STALL for invalid interfaces, but udc driver does not
973 * know anything about that. However, many gadget drivers do not handle
974 * GET_STATUS so we need to take care of that.
975 */
976
977 switch (request) {
978 case USB_REQ_GET_STATUS:
979 return gr_ep0_respond_u16(dev, 0x0000);
980
981 case USB_REQ_SET_FEATURE:
982 case USB_REQ_CLEAR_FEATURE:
983 /*
984 * No possible valid standard requests. Still let gadget drivers
985 * have a go at it.
986 */
987 break;
988 }
989
990 return 1; /* Delegate the rest */
991 }
992
993 /*
994 * Returns negative for STALL, 0 for successful handling and positive for
995 * delegation.
996 *
997 * Must be called with dev->lock held.
998 */
999 static int gr_endpoint_request(struct gr_udc *dev, u8 type, u8 request,
1000 u16 value, u16 index)
1001 {
1002 struct gr_ep *ep;
1003 int status;
1004 int halted;
1005 u8 epnum = index & USB_ENDPOINT_NUMBER_MASK;
1006 u8 is_in = index & USB_ENDPOINT_DIR_MASK;
1007
1008 if ((is_in && epnum >= dev->nepi) || (!is_in && epnum >= dev->nepo))
1009 return -1;
1010
1011 if (dev->gadget.state != USB_STATE_CONFIGURED && epnum != 0)
1012 return -1;
1013
1014 ep = (is_in ? &dev->epi[epnum] : &dev->epo[epnum]);
1015
1016 switch (request) {
1017 case USB_REQ_GET_STATUS:
1018 halted = gr_read32(&ep->regs->epctrl) & GR_EPCTRL_EH;
1019 return gr_ep0_respond_u16(dev, halted ? 0x0001 : 0);
1020
1021 case USB_REQ_SET_FEATURE:
1022 switch (value) {
1023 case USB_ENDPOINT_HALT:
1024 status = gr_ep_halt_wedge(ep, 1, 0, 1);
1025 if (status >= 0)
1026 status = gr_ep0_respond_empty(dev);
1027 return status;
1028 }
1029 break;
1030
1031 case USB_REQ_CLEAR_FEATURE:
1032 switch (value) {
1033 case USB_ENDPOINT_HALT:
1034 if (ep->wedged)
1035 return -1;
1036 status = gr_ep_halt_wedge(ep, 0, 0, 1);
1037 if (status >= 0)
1038 status = gr_ep0_respond_empty(dev);
1039 return status;
1040 }
1041 break;
1042 }
1043
1044 return 1; /* Delegate the rest */
1045 }
1046
1047 /* Must be called with dev->lock held */
1048 static void gr_ep0out_requeue(struct gr_udc *dev)
1049 {
1050 int ret = gr_queue_int(&dev->epo[0], dev->ep0reqo, GFP_ATOMIC);
1051
1052 if (ret)
1053 dev_err(dev->dev, "Could not queue ep0out setup request: %d\n",
1054 ret);
1055 }
1056
1057 /*
1058 * The main function dealing with setup requests on ep0.
1059 *
1060 * Must be called with dev->lock held and irqs disabled
1061 */
1062 static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req)
1063 __releases(&dev->lock)
1064 __acquires(&dev->lock)
1065 {
1066 union {
1067 struct usb_ctrlrequest ctrl;
1068 u8 raw[8];
1069 u32 word[2];
1070 } u;
1071 u8 type;
1072 u8 request;
1073 u16 value;
1074 u16 index;
1075 u16 length;
1076 int i;
1077 int status;
1078
1079 /* Restore from ep0 halt */
1080 if (dev->ep0state == GR_EP0_STALL) {
1081 gr_set_ep0state(dev, GR_EP0_SETUP);
1082 if (!req->req.actual)
1083 goto out;
1084 }
1085
1086 if (dev->ep0state == GR_EP0_ISTATUS) {
1087 gr_set_ep0state(dev, GR_EP0_SETUP);
1088 if (req->req.actual > 0)
1089 dev_dbg(dev->dev,
1090 "Unexpected setup packet at state %s\n",
1091 gr_ep0state_string(GR_EP0_ISTATUS));
1092 else
1093 goto out; /* Got expected ZLP */
1094 } else if (dev->ep0state != GR_EP0_SETUP) {
1095 dev_info(dev->dev,
1096 "Unexpected ep0out request at state %s - stalling\n",
1097 gr_ep0state_string(dev->ep0state));
1098 gr_control_stall(dev);
1099 gr_set_ep0state(dev, GR_EP0_SETUP);
1100 goto out;
1101 } else if (!req->req.actual) {
1102 dev_dbg(dev->dev, "Unexpected ZLP at state %s\n",
1103 gr_ep0state_string(dev->ep0state));
1104 goto out;
1105 }
1106
1107 /* Handle SETUP packet */
1108 for (i = 0; i < req->req.actual; i++)
1109 u.raw[i] = ((u8 *)req->req.buf)[i];
1110
1111 type = u.ctrl.bRequestType;
1112 request = u.ctrl.bRequest;
1113 value = le16_to_cpu(u.ctrl.wValue);
1114 index = le16_to_cpu(u.ctrl.wIndex);
1115 length = le16_to_cpu(u.ctrl.wLength);
1116
1117 gr_dbgprint_devreq(dev, type, request, value, index, length);
1118
1119 /* Check for data stage */
1120 if (length) {
1121 if (type & USB_DIR_IN)
1122 gr_set_ep0state(dev, GR_EP0_IDATA);
1123 else
1124 gr_set_ep0state(dev, GR_EP0_ODATA);
1125 }
1126
1127 status = 1; /* Positive status flags delegation */
1128 if ((type & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1129 switch (type & USB_RECIP_MASK) {
1130 case USB_RECIP_DEVICE:
1131 status = gr_device_request(dev, type, request,
1132 value, index);
1133 break;
1134 case USB_RECIP_ENDPOINT:
1135 status = gr_endpoint_request(dev, type, request,
1136 value, index);
1137 break;
1138 case USB_RECIP_INTERFACE:
1139 status = gr_interface_request(dev, type, request,
1140 value, index);
1141 break;
1142 }
1143 }
1144
1145 if (status > 0) {
1146 spin_unlock(&dev->lock);
1147
1148 dev_vdbg(dev->dev, "DELEGATE\n");
1149 status = dev->driver->setup(&dev->gadget, &u.ctrl);
1150
1151 spin_lock(&dev->lock);
1152 }
1153
1154 /* Generate STALL on both ep0out and ep0in if requested */
1155 if (unlikely(status < 0)) {
1156 dev_vdbg(dev->dev, "STALL\n");
1157 gr_control_stall(dev);
1158 }
1159
1160 if ((type & USB_TYPE_MASK) == USB_TYPE_STANDARD &&
1161 request == USB_REQ_SET_CONFIGURATION) {
1162 if (!value) {
1163 dev_dbg(dev->dev, "STATUS: deconfigured\n");
1164 usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
1165 } else if (status >= 0) {
1166 /* Not configured unless gadget OK:s it */
1167 dev_dbg(dev->dev, "STATUS: configured: %d\n", value);
1168 usb_gadget_set_state(&dev->gadget,
1169 USB_STATE_CONFIGURED);
1170 }
1171 }
1172
1173 /* Get ready for next stage */
1174 if (dev->ep0state == GR_EP0_ODATA)
1175 gr_set_ep0state(dev, GR_EP0_OSTATUS);
1176 else if (dev->ep0state == GR_EP0_IDATA)
1177 gr_set_ep0state(dev, GR_EP0_ISTATUS);
1178 else
1179 gr_set_ep0state(dev, GR_EP0_SETUP);
1180
1181 out:
1182 gr_ep0out_requeue(dev);
1183 }
1184
1185 /* ---------------------------------------------------------------------- */
1186 /* VBUS and USB reset handling */
1187
1188 /* Must be called with dev->lock held and irqs disabled */
1189 static void gr_vbus_connected(struct gr_udc *dev, u32 status)
1190 {
1191 u32 control;
1192
1193 dev->gadget.speed = GR_SPEED(status);
1194 usb_gadget_set_state(&dev->gadget, USB_STATE_POWERED);
1195
1196 /* Turn on full interrupts and pullup */
1197 control = (GR_CONTROL_SI | GR_CONTROL_UI | GR_CONTROL_VI |
1198 GR_CONTROL_SP | GR_CONTROL_EP);
1199 gr_write32(&dev->regs->control, control);
1200 }
1201
1202 /* Must be called with dev->lock held */
1203 static void gr_enable_vbus_detect(struct gr_udc *dev)
1204 {
1205 u32 status;
1206
1207 dev->irq_enabled = 1;
1208 wmb(); /* Make sure we do not ignore an interrupt */
1209 gr_write32(&dev->regs->control, GR_CONTROL_VI);
1210
1211 /* Take care of the case we are already plugged in at this point */
1212 status = gr_read32(&dev->regs->status);
1213 if (status & GR_STATUS_VB)
1214 gr_vbus_connected(dev, status);
1215 }
1216
1217 /* Must be called with dev->lock held and irqs disabled */
1218 static void gr_vbus_disconnected(struct gr_udc *dev)
1219 {
1220 gr_stop_activity(dev);
1221
1222 /* Report disconnect */
1223 if (dev->driver && dev->driver->disconnect) {
1224 spin_unlock(&dev->lock);
1225
1226 dev->driver->disconnect(&dev->gadget);
1227
1228 spin_lock(&dev->lock);
1229 }
1230
1231 gr_enable_vbus_detect(dev);
1232 }
1233
1234 /* Must be called with dev->lock held and irqs disabled */
1235 static void gr_udc_usbreset(struct gr_udc *dev, u32 status)
1236 {
1237 gr_set_address(dev, 0);
1238 gr_set_ep0state(dev, GR_EP0_SETUP);
1239 usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
1240 dev->gadget.speed = GR_SPEED(status);
1241
1242 gr_ep_nuke(&dev->epo[0]);
1243 gr_ep_nuke(&dev->epi[0]);
1244 dev->epo[0].stopped = 0;
1245 dev->epi[0].stopped = 0;
1246 gr_ep0out_requeue(dev);
1247 }
1248
1249 /* ---------------------------------------------------------------------- */
1250 /* Irq handling */
1251
1252 /*
1253 * Handles interrupts from in endpoints. Returns whether something was handled.
1254 *
1255 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
1256 */
1257 static int gr_handle_in_ep(struct gr_ep *ep)
1258 {
1259 struct gr_request *req;
1260
1261 req = list_first_entry(&ep->queue, struct gr_request, queue);
1262 if (!req->last_desc)
1263 return 0;
1264
1265 if (ACCESS_ONCE(req->last_desc->ctrl) & GR_DESC_IN_CTRL_EN)
1266 return 0; /* Not put in hardware buffers yet */
1267
1268 if (gr_read32(&ep->regs->epstat) & (GR_EPSTAT_B1 | GR_EPSTAT_B0))
1269 return 0; /* Not transmitted yet, still in hardware buffers */
1270
1271 /* Write complete */
1272 gr_dma_advance(ep, 0);
1273
1274 return 1;
1275 }
1276
1277 /*
1278 * Handles interrupts from out endpoints. Returns whether something was handled.
1279 *
1280 * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
1281 */
1282 static int gr_handle_out_ep(struct gr_ep *ep)
1283 {
1284 u32 ep_dmactrl;
1285 u32 ctrl;
1286 u16 len;
1287 struct gr_request *req;
1288 struct gr_udc *dev = ep->dev;
1289
1290 req = list_first_entry(&ep->queue, struct gr_request, queue);
1291 if (!req->curr_desc)
1292 return 0;
1293
1294 ctrl = ACCESS_ONCE(req->curr_desc->ctrl);
1295 if (ctrl & GR_DESC_OUT_CTRL_EN)
1296 return 0; /* Not received yet */
1297
1298 /* Read complete */
1299 len = ctrl & GR_DESC_OUT_CTRL_LEN_MASK;
1300 req->req.actual += len;
1301 if (ctrl & GR_DESC_OUT_CTRL_SE)
1302 req->setup = 1;
1303
1304 if (len < ep->ep.maxpacket || req->req.actual >= req->req.length) {
1305 /* Short packet or >= expected size - we are done */
1306
1307 if ((ep == &dev->epo[0]) && (dev->ep0state == GR_EP0_OSTATUS)) {
1308 /*
1309 * Send a status stage ZLP to ack the DATA stage in the
1310 * OUT direction. This needs to be done before
1311 * gr_dma_advance as that can lead to a call to
1312 * ep0_setup that can change dev->ep0state.
1313 */
1314 gr_ep0_respond_empty(dev);
1315 gr_set_ep0state(dev, GR_EP0_SETUP);
1316 }
1317
1318 gr_dma_advance(ep, 0);
1319 } else {
1320 /* Not done yet. Enable the next descriptor to receive more. */
1321 req->curr_desc = req->curr_desc->next_desc;
1322 req->curr_desc->ctrl |= GR_DESC_OUT_CTRL_EN;
1323
1324 ep_dmactrl = gr_read32(&ep->regs->dmactrl);
1325 gr_write32(&ep->regs->dmactrl, ep_dmactrl | GR_DMACTRL_DA);
1326 }
1327
1328 return 1;
1329 }
1330
1331 /*
1332 * Handle state changes. Returns whether something was handled.
1333 *
1334 * Must be called with dev->lock held and irqs disabled.
1335 */
1336 static int gr_handle_state_changes(struct gr_udc *dev)
1337 {
1338 u32 status = gr_read32(&dev->regs->status);
1339 int handled = 0;
1340 int powstate = !(dev->gadget.state == USB_STATE_NOTATTACHED ||
1341 dev->gadget.state == USB_STATE_ATTACHED);
1342
1343 /* VBUS valid detected */
1344 if (!powstate && (status & GR_STATUS_VB)) {
1345 dev_dbg(dev->dev, "STATUS: vbus valid detected\n");
1346 gr_vbus_connected(dev, status);
1347 handled = 1;
1348 }
1349
1350 /* Disconnect */
1351 if (powstate && !(status & GR_STATUS_VB)) {
1352 dev_dbg(dev->dev, "STATUS: vbus invalid detected\n");
1353 gr_vbus_disconnected(dev);
1354 handled = 1;
1355 }
1356
1357 /* USB reset detected */
1358 if (status & GR_STATUS_UR) {
1359 dev_dbg(dev->dev, "STATUS: USB reset - speed is %s\n",
1360 GR_SPEED_STR(status));
1361 gr_write32(&dev->regs->status, GR_STATUS_UR);
1362 gr_udc_usbreset(dev, status);
1363 handled = 1;
1364 }
1365
1366 /* Speed change */
1367 if (dev->gadget.speed != GR_SPEED(status)) {
1368 dev_dbg(dev->dev, "STATUS: USB Speed change to %s\n",
1369 GR_SPEED_STR(status));
1370 dev->gadget.speed = GR_SPEED(status);
1371 handled = 1;
1372 }
1373
1374 /* Going into suspend */
1375 if ((dev->ep0state != GR_EP0_SUSPEND) && !(status & GR_STATUS_SU)) {
1376 dev_dbg(dev->dev, "STATUS: USB suspend\n");
1377 gr_set_ep0state(dev, GR_EP0_SUSPEND);
1378 dev->suspended_from = dev->gadget.state;
1379 usb_gadget_set_state(&dev->gadget, USB_STATE_SUSPENDED);
1380
1381 if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
1382 dev->driver && dev->driver->suspend) {
1383 spin_unlock(&dev->lock);
1384
1385 dev->driver->suspend(&dev->gadget);
1386
1387 spin_lock(&dev->lock);
1388 }
1389 handled = 1;
1390 }
1391
1392 /* Coming out of suspend */
1393 if ((dev->ep0state == GR_EP0_SUSPEND) && (status & GR_STATUS_SU)) {
1394 dev_dbg(dev->dev, "STATUS: USB resume\n");
1395 if (dev->suspended_from == USB_STATE_POWERED)
1396 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
1397 else
1398 gr_set_ep0state(dev, GR_EP0_SETUP);
1399 usb_gadget_set_state(&dev->gadget, dev->suspended_from);
1400
1401 if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
1402 dev->driver && dev->driver->resume) {
1403 spin_unlock(&dev->lock);
1404
1405 dev->driver->resume(&dev->gadget);
1406
1407 spin_lock(&dev->lock);
1408 }
1409 handled = 1;
1410 }
1411
1412 return handled;
1413 }
1414
1415 /* Non-interrupt context irq handler */
1416 static irqreturn_t gr_irq_handler(int irq, void *_dev)
1417 {
1418 struct gr_udc *dev = _dev;
1419 struct gr_ep *ep;
1420 int handled = 0;
1421 int i;
1422 unsigned long flags;
1423
1424 spin_lock_irqsave(&dev->lock, flags);
1425
1426 if (!dev->irq_enabled)
1427 goto out;
1428
1429 /*
1430 * Check IN ep interrupts. We check these before the OUT eps because
1431 * some gadgets reuse the request that might already be currently
1432 * outstanding and needs to be completed (mainly setup requests).
1433 */
1434 for (i = 0; i < dev->nepi; i++) {
1435 ep = &dev->epi[i];
1436 if (!ep->stopped && !ep->callback && !list_empty(&ep->queue))
1437 handled = gr_handle_in_ep(ep) || handled;
1438 }
1439
1440 /* Check OUT ep interrupts */
1441 for (i = 0; i < dev->nepo; i++) {
1442 ep = &dev->epo[i];
1443 if (!ep->stopped && !ep->callback && !list_empty(&ep->queue))
1444 handled = gr_handle_out_ep(ep) || handled;
1445 }
1446
1447 /* Check status interrupts */
1448 handled = gr_handle_state_changes(dev) || handled;
1449
1450 /*
1451 * Check AMBA DMA errors. Only check if we didn't find anything else to
1452 * handle because this shouldn't happen if we did everything right.
1453 */
1454 if (!handled) {
1455 list_for_each_entry(ep, &dev->ep_list, ep_list) {
1456 if (gr_read32(&ep->regs->dmactrl) & GR_DMACTRL_AE) {
1457 dev_err(dev->dev,
1458 "AMBA Error occurred for %s\n",
1459 ep->ep.name);
1460 handled = 1;
1461 }
1462 }
1463 }
1464
1465 out:
1466 spin_unlock_irqrestore(&dev->lock, flags);
1467
1468 return handled ? IRQ_HANDLED : IRQ_NONE;
1469 }
1470
1471 /* Interrupt context irq handler */
1472 static irqreturn_t gr_irq(int irq, void *_dev)
1473 {
1474 struct gr_udc *dev = _dev;
1475
1476 if (!dev->irq_enabled)
1477 return IRQ_NONE;
1478
1479 return IRQ_WAKE_THREAD;
1480 }
1481
1482 /* ---------------------------------------------------------------------- */
1483 /* USB ep ops */
1484
1485 /* Enable endpoint. Not for ep0in and ep0out that are handled separately. */
1486 static int gr_ep_enable(struct usb_ep *_ep,
1487 const struct usb_endpoint_descriptor *desc)
1488 {
1489 struct gr_udc *dev;
1490 struct gr_ep *ep;
1491 u8 mode;
1492 u8 nt;
1493 u16 max;
1494 u16 buffer_size = 0;
1495 u32 epctrl;
1496
1497 ep = container_of(_ep, struct gr_ep, ep);
1498 if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT)
1499 return -EINVAL;
1500
1501 dev = ep->dev;
1502
1503 /* 'ep0' IN and OUT are reserved */
1504 if (ep == &dev->epo[0] || ep == &dev->epi[0])
1505 return -EINVAL;
1506
1507 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
1508 return -ESHUTDOWN;
1509
1510 /* Make sure we are clear for enabling */
1511 epctrl = gr_read32(&ep->regs->epctrl);
1512 if (epctrl & GR_EPCTRL_EV)
1513 return -EBUSY;
1514
1515 /* Check that directions match */
1516 if (!ep->is_in != !usb_endpoint_dir_in(desc))
1517 return -EINVAL;
1518
1519 /* Check ep num */
1520 if ((!ep->is_in && ep->num >= dev->nepo) ||
1521 (ep->is_in && ep->num >= dev->nepi))
1522 return -EINVAL;
1523
1524 if (usb_endpoint_xfer_control(desc)) {
1525 mode = 0;
1526 } else if (usb_endpoint_xfer_isoc(desc)) {
1527 mode = 1;
1528 } else if (usb_endpoint_xfer_bulk(desc)) {
1529 mode = 2;
1530 } else if (usb_endpoint_xfer_int(desc)) {
1531 mode = 3;
1532 } else {
1533 dev_err(dev->dev, "Unknown transfer type for %s\n",
1534 ep->ep.name);
1535 return -EINVAL;
1536 }
1537
1538 /*
1539 * Bits 10-0 set the max payload. 12-11 set the number of
1540 * additional transactions.
1541 */
1542 max = 0x7ff & usb_endpoint_maxp(desc);
1543 nt = 0x3 & (usb_endpoint_maxp(desc) >> 11);
1544 buffer_size = GR_BUFFER_SIZE(epctrl);
1545 if (nt && (mode == 0 || mode == 2)) {
1546 dev_err(dev->dev,
1547 "%s mode: multiple trans./microframe not valid\n",
1548 (mode == 2 ? "Bulk" : "Control"));
1549 return -EINVAL;
1550 } else if (nt == 0x3) {
1551 dev_err(dev->dev,
1552 "Invalid value 0x3 for additional trans./microframe\n");
1553 return -EINVAL;
1554 } else if ((nt + 1) * max > buffer_size) {
1555 dev_err(dev->dev, "Hw buffer size %d < max payload %d * %d\n",
1556 buffer_size, (nt + 1), max);
1557 return -EINVAL;
1558 } else if (max == 0) {
1559 dev_err(dev->dev, "Max payload cannot be set to 0\n");
1560 return -EINVAL;
1561 } else if (max > ep->ep.maxpacket_limit) {
1562 dev_err(dev->dev, "Requested max payload %d > limit %d\n",
1563 max, ep->ep.maxpacket_limit);
1564 return -EINVAL;
1565 }
1566
1567 spin_lock(&ep->dev->lock);
1568
1569 if (!ep->stopped) {
1570 spin_unlock(&ep->dev->lock);
1571 return -EBUSY;
1572 }
1573
1574 ep->stopped = 0;
1575 ep->wedged = 0;
1576 ep->ep.desc = desc;
1577 ep->ep.maxpacket = max;
1578 ep->dma_start = 0;
1579
1580
1581 if (nt) {
1582 /*
1583 * Maximum possible size of all payloads in one microframe
1584 * regardless of direction when using high-bandwidth mode.
1585 */
1586 ep->bytes_per_buffer = (nt + 1) * max;
1587 } else if (ep->is_in) {
1588 /*
1589 * The biggest multiple of maximum packet size that fits into
1590 * the buffer. The hardware will split up into many packets in
1591 * the IN direction.
1592 */
1593 ep->bytes_per_buffer = (buffer_size / max) * max;
1594 } else {
1595 /*
1596 * Only single packets will be placed the buffers in the OUT
1597 * direction.
1598 */
1599 ep->bytes_per_buffer = max;
1600 }
1601
1602 epctrl = (max << GR_EPCTRL_MAXPL_POS)
1603 | (nt << GR_EPCTRL_NT_POS)
1604 | (mode << GR_EPCTRL_TT_POS)
1605 | GR_EPCTRL_EV;
1606 if (ep->is_in)
1607 epctrl |= GR_EPCTRL_PI;
1608 gr_write32(&ep->regs->epctrl, epctrl);
1609
1610 gr_write32(&ep->regs->dmactrl, GR_DMACTRL_IE | GR_DMACTRL_AI);
1611
1612 spin_unlock(&ep->dev->lock);
1613
1614 dev_dbg(ep->dev->dev, "EP: %s enabled - %s with %d bytes/buffer\n",
1615 ep->ep.name, gr_modestring[mode], ep->bytes_per_buffer);
1616 return 0;
1617 }
1618
1619 /* Disable endpoint. Not for ep0in and ep0out that are handled separately. */
1620 static int gr_ep_disable(struct usb_ep *_ep)
1621 {
1622 struct gr_ep *ep;
1623 struct gr_udc *dev;
1624 unsigned long flags;
1625
1626 ep = container_of(_ep, struct gr_ep, ep);
1627 if (!_ep || !ep->ep.desc)
1628 return -ENODEV;
1629
1630 dev = ep->dev;
1631
1632 /* 'ep0' IN and OUT are reserved */
1633 if (ep == &dev->epo[0] || ep == &dev->epi[0])
1634 return -EINVAL;
1635
1636 if (dev->ep0state == GR_EP0_SUSPEND)
1637 return -EBUSY;
1638
1639 dev_dbg(ep->dev->dev, "EP: disable %s\n", ep->ep.name);
1640
1641 spin_lock_irqsave(&dev->lock, flags);
1642
1643 gr_ep_nuke(ep);
1644 gr_ep_reset(ep);
1645 ep->ep.desc = NULL;
1646
1647 spin_unlock_irqrestore(&dev->lock, flags);
1648
1649 return 0;
1650 }
1651
1652 /*
1653 * Frees a request, but not any DMA buffers associated with it
1654 * (gr_finish_request should already have taken care of that).
1655 */
1656 static void gr_free_request(struct usb_ep *_ep, struct usb_request *_req)
1657 {
1658 struct gr_request *req;
1659
1660 if (!_ep || !_req)
1661 return;
1662 req = container_of(_req, struct gr_request, req);
1663
1664 /* Leads to memory leak */
1665 WARN(!list_empty(&req->queue),
1666 "request not dequeued properly before freeing\n");
1667
1668 kfree(req);
1669 }
1670
1671 /* Queue a request from the gadget */
1672 static int gr_queue_ext(struct usb_ep *_ep, struct usb_request *_req,
1673 gfp_t gfp_flags)
1674 {
1675 struct gr_ep *ep;
1676 struct gr_request *req;
1677 struct gr_udc *dev;
1678 int ret;
1679
1680 if (unlikely(!_ep || !_req))
1681 return -EINVAL;
1682
1683 ep = container_of(_ep, struct gr_ep, ep);
1684 req = container_of(_req, struct gr_request, req);
1685 dev = ep->dev;
1686
1687 spin_lock(&ep->dev->lock);
1688
1689 /*
1690 * The ep0 pointer in the gadget struct is used both for ep0in and
1691 * ep0out. In a data stage in the out direction ep0out needs to be used
1692 * instead of the default ep0in. Completion functions might use
1693 * driver_data, so that needs to be copied as well.
1694 */
1695 if ((ep == &dev->epi[0]) && (dev->ep0state == GR_EP0_ODATA)) {
1696 ep = &dev->epo[0];
1697 ep->ep.driver_data = dev->epi[0].ep.driver_data;
1698 }
1699
1700 if (ep->is_in)
1701 gr_dbgprint_request("EXTERN", ep, req);
1702
1703 ret = gr_queue(ep, req, GFP_ATOMIC);
1704
1705 spin_unlock(&ep->dev->lock);
1706
1707 return ret;
1708 }
1709
1710 /* Dequeue JUST ONE request */
1711 static int gr_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1712 {
1713 struct gr_request *req;
1714 struct gr_ep *ep;
1715 struct gr_udc *dev;
1716 int ret = 0;
1717 unsigned long flags;
1718
1719 ep = container_of(_ep, struct gr_ep, ep);
1720 if (!_ep || !_req || (!ep->ep.desc && ep->num != 0))
1721 return -EINVAL;
1722 dev = ep->dev;
1723 if (!dev->driver)
1724 return -ESHUTDOWN;
1725
1726 /* We can't touch (DMA) registers when suspended */
1727 if (dev->ep0state == GR_EP0_SUSPEND)
1728 return -EBUSY;
1729
1730 spin_lock_irqsave(&dev->lock, flags);
1731
1732 /* Make sure it's actually queued on this endpoint */
1733 list_for_each_entry(req, &ep->queue, queue) {
1734 if (&req->req == _req)
1735 break;
1736 }
1737 if (&req->req != _req) {
1738 ret = -EINVAL;
1739 goto out;
1740 }
1741
1742 if (list_first_entry(&ep->queue, struct gr_request, queue) == req) {
1743 /* This request is currently being processed */
1744 gr_abort_dma(ep);
1745 if (ep->stopped)
1746 gr_finish_request(ep, req, -ECONNRESET);
1747 else
1748 gr_dma_advance(ep, -ECONNRESET);
1749 } else if (!list_empty(&req->queue)) {
1750 /* Not being processed - gr_finish_request dequeues it */
1751 gr_finish_request(ep, req, -ECONNRESET);
1752 } else {
1753 ret = -EOPNOTSUPP;
1754 }
1755
1756 out:
1757 spin_unlock_irqrestore(&dev->lock, flags);
1758
1759 return ret;
1760 }
1761
1762 /* Helper for gr_set_halt and gr_set_wedge */
1763 static int gr_set_halt_wedge(struct usb_ep *_ep, int halt, int wedge)
1764 {
1765 int ret;
1766 struct gr_ep *ep;
1767
1768 if (!_ep)
1769 return -ENODEV;
1770 ep = container_of(_ep, struct gr_ep, ep);
1771
1772 spin_lock(&ep->dev->lock);
1773
1774 /* Halting an IN endpoint should fail if queue is not empty */
1775 if (halt && ep->is_in && !list_empty(&ep->queue)) {
1776 ret = -EAGAIN;
1777 goto out;
1778 }
1779
1780 ret = gr_ep_halt_wedge(ep, halt, wedge, 0);
1781
1782 out:
1783 spin_unlock(&ep->dev->lock);
1784
1785 return ret;
1786 }
1787
1788 /* Halt endpoint */
1789 static int gr_set_halt(struct usb_ep *_ep, int halt)
1790 {
1791 return gr_set_halt_wedge(_ep, halt, 0);
1792 }
1793
1794 /* Halt and wedge endpoint */
1795 static int gr_set_wedge(struct usb_ep *_ep)
1796 {
1797 return gr_set_halt_wedge(_ep, 1, 1);
1798 }
1799
1800 /*
1801 * Return the total number of bytes currently stored in the internal buffers of
1802 * the endpoint.
1803 */
1804 static int gr_fifo_status(struct usb_ep *_ep)
1805 {
1806 struct gr_ep *ep;
1807 u32 epstat;
1808 u32 bytes = 0;
1809
1810 if (!_ep)
1811 return -ENODEV;
1812 ep = container_of(_ep, struct gr_ep, ep);
1813
1814 epstat = gr_read32(&ep->regs->epstat);
1815
1816 if (epstat & GR_EPSTAT_B0)
1817 bytes += (epstat & GR_EPSTAT_B0CNT_MASK) >> GR_EPSTAT_B0CNT_POS;
1818 if (epstat & GR_EPSTAT_B1)
1819 bytes += (epstat & GR_EPSTAT_B1CNT_MASK) >> GR_EPSTAT_B1CNT_POS;
1820
1821 return bytes;
1822 }
1823
1824
1825 /* Empty data from internal buffers of an endpoint. */
1826 static void gr_fifo_flush(struct usb_ep *_ep)
1827 {
1828 struct gr_ep *ep;
1829 u32 epctrl;
1830
1831 if (!_ep)
1832 return;
1833 ep = container_of(_ep, struct gr_ep, ep);
1834 dev_vdbg(ep->dev->dev, "EP: flush fifo %s\n", ep->ep.name);
1835
1836 spin_lock(&ep->dev->lock);
1837
1838 epctrl = gr_read32(&ep->regs->epctrl);
1839 epctrl |= GR_EPCTRL_CB;
1840 gr_write32(&ep->regs->epctrl, epctrl);
1841
1842 spin_unlock(&ep->dev->lock);
1843 }
1844
1845 static struct usb_ep_ops gr_ep_ops = {
1846 .enable = gr_ep_enable,
1847 .disable = gr_ep_disable,
1848
1849 .alloc_request = gr_alloc_request,
1850 .free_request = gr_free_request,
1851
1852 .queue = gr_queue_ext,
1853 .dequeue = gr_dequeue,
1854
1855 .set_halt = gr_set_halt,
1856 .set_wedge = gr_set_wedge,
1857 .fifo_status = gr_fifo_status,
1858 .fifo_flush = gr_fifo_flush,
1859 };
1860
1861 /* ---------------------------------------------------------------------- */
1862 /* USB Gadget ops */
1863
1864 static int gr_get_frame(struct usb_gadget *_gadget)
1865 {
1866 struct gr_udc *dev;
1867
1868 if (!_gadget)
1869 return -ENODEV;
1870 dev = container_of(_gadget, struct gr_udc, gadget);
1871 return gr_read32(&dev->regs->status) & GR_STATUS_FN_MASK;
1872 }
1873
1874 static int gr_wakeup(struct usb_gadget *_gadget)
1875 {
1876 struct gr_udc *dev;
1877
1878 if (!_gadget)
1879 return -ENODEV;
1880 dev = container_of(_gadget, struct gr_udc, gadget);
1881
1882 /* Remote wakeup feature not enabled by host*/
1883 if (!dev->remote_wakeup)
1884 return -EINVAL;
1885
1886 spin_lock(&dev->lock);
1887
1888 gr_write32(&dev->regs->control,
1889 gr_read32(&dev->regs->control) | GR_CONTROL_RW);
1890
1891 spin_unlock(&dev->lock);
1892
1893 return 0;
1894 }
1895
1896 static int gr_pullup(struct usb_gadget *_gadget, int is_on)
1897 {
1898 struct gr_udc *dev;
1899 u32 control;
1900
1901 if (!_gadget)
1902 return -ENODEV;
1903 dev = container_of(_gadget, struct gr_udc, gadget);
1904
1905 spin_lock(&dev->lock);
1906
1907 control = gr_read32(&dev->regs->control);
1908 if (is_on)
1909 control |= GR_CONTROL_EP;
1910 else
1911 control &= ~GR_CONTROL_EP;
1912 gr_write32(&dev->regs->control, control);
1913
1914 spin_unlock(&dev->lock);
1915
1916 return 0;
1917 }
1918
1919 static int gr_udc_start(struct usb_gadget *gadget,
1920 struct usb_gadget_driver *driver)
1921 {
1922 struct gr_udc *dev = to_gr_udc(gadget);
1923
1924 spin_lock(&dev->lock);
1925
1926 /* Hook up the driver */
1927 driver->driver.bus = NULL;
1928 dev->driver = driver;
1929
1930 /* Get ready for host detection */
1931 gr_enable_vbus_detect(dev);
1932
1933 spin_unlock(&dev->lock);
1934
1935 return 0;
1936 }
1937
1938 static int gr_udc_stop(struct usb_gadget *gadget)
1939 {
1940 struct gr_udc *dev = to_gr_udc(gadget);
1941 unsigned long flags;
1942
1943 spin_lock_irqsave(&dev->lock, flags);
1944
1945 dev->driver = NULL;
1946 gr_stop_activity(dev);
1947
1948 spin_unlock_irqrestore(&dev->lock, flags);
1949
1950 return 0;
1951 }
1952
1953 static const struct usb_gadget_ops gr_ops = {
1954 .get_frame = gr_get_frame,
1955 .wakeup = gr_wakeup,
1956 .pullup = gr_pullup,
1957 .udc_start = gr_udc_start,
1958 .udc_stop = gr_udc_stop,
1959 /* Other operations not supported */
1960 };
1961
1962 /* ---------------------------------------------------------------------- */
1963 /* Module probe, removal and of-matching */
1964
1965 static const char * const onames[] = {
1966 "ep0out", "ep1out", "ep2out", "ep3out", "ep4out", "ep5out",
1967 "ep6out", "ep7out", "ep8out", "ep9out", "ep10out", "ep11out",
1968 "ep12out", "ep13out", "ep14out", "ep15out"
1969 };
1970
1971 static const char * const inames[] = {
1972 "ep0in", "ep1in", "ep2in", "ep3in", "ep4in", "ep5in",
1973 "ep6in", "ep7in", "ep8in", "ep9in", "ep10in", "ep11in",
1974 "ep12in", "ep13in", "ep14in", "ep15in"
1975 };
1976
1977 /* Must be called with dev->lock held */
1978 static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit)
1979 {
1980 struct gr_ep *ep;
1981 struct gr_request *req;
1982 struct usb_request *_req;
1983 void *buf;
1984
1985 if (is_in) {
1986 ep = &dev->epi[num];
1987 ep->ep.name = inames[num];
1988 ep->regs = &dev->regs->epi[num];
1989 } else {
1990 ep = &dev->epo[num];
1991 ep->ep.name = onames[num];
1992 ep->regs = &dev->regs->epo[num];
1993 }
1994
1995 gr_ep_reset(ep);
1996 ep->num = num;
1997 ep->is_in = is_in;
1998 ep->dev = dev;
1999 ep->ep.ops = &gr_ep_ops;
2000 INIT_LIST_HEAD(&ep->queue);
2001
2002 if (num == 0) {
2003 _req = gr_alloc_request(&ep->ep, GFP_ATOMIC);
2004 buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_ATOMIC);
2005 if (!_req || !buf) {
2006 /* possible _req freed by gr_probe via gr_remove */
2007 return -ENOMEM;
2008 }
2009
2010 req = container_of(_req, struct gr_request, req);
2011 req->req.buf = buf;
2012 req->req.length = MAX_CTRL_PL_SIZE;
2013
2014 if (is_in)
2015 dev->ep0reqi = req; /* Complete gets set as used */
2016 else
2017 dev->ep0reqo = req; /* Completion treated separately */
2018
2019 usb_ep_set_maxpacket_limit(&ep->ep, MAX_CTRL_PL_SIZE);
2020 ep->bytes_per_buffer = MAX_CTRL_PL_SIZE;
2021 } else {
2022 usb_ep_set_maxpacket_limit(&ep->ep, (u16)maxplimit);
2023 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
2024 }
2025 list_add_tail(&ep->ep_list, &dev->ep_list);
2026
2027 ep->tailbuf = dma_alloc_coherent(dev->dev, ep->ep.maxpacket_limit,
2028 &ep->tailbuf_paddr, GFP_ATOMIC);
2029 if (!ep->tailbuf)
2030 return -ENOMEM;
2031
2032 return 0;
2033 }
2034
2035 /* Must be called with dev->lock held */
2036 static int gr_udc_init(struct gr_udc *dev)
2037 {
2038 struct device_node *np = dev->dev->of_node;
2039 u32 epctrl_val;
2040 u32 dmactrl_val;
2041 int i;
2042 int ret = 0;
2043 u32 bufsize;
2044
2045 gr_set_address(dev, 0);
2046
2047 INIT_LIST_HEAD(&dev->gadget.ep_list);
2048 dev->gadget.speed = USB_SPEED_UNKNOWN;
2049 dev->gadget.ep0 = &dev->epi[0].ep;
2050
2051 INIT_LIST_HEAD(&dev->ep_list);
2052 gr_set_ep0state(dev, GR_EP0_DISCONNECT);
2053
2054 for (i = 0; i < dev->nepo; i++) {
2055 if (of_property_read_u32_index(np, "epobufsizes", i, &bufsize))
2056 bufsize = 1024;
2057 ret = gr_ep_init(dev, i, 0, bufsize);
2058 if (ret)
2059 return ret;
2060 }
2061
2062 for (i = 0; i < dev->nepi; i++) {
2063 if (of_property_read_u32_index(np, "epibufsizes", i, &bufsize))
2064 bufsize = 1024;
2065 ret = gr_ep_init(dev, i, 1, bufsize);
2066 if (ret)
2067 return ret;
2068 }
2069
2070 /* Must be disabled by default */
2071 dev->remote_wakeup = 0;
2072
2073 /* Enable ep0out and ep0in */
2074 epctrl_val = (MAX_CTRL_PL_SIZE << GR_EPCTRL_MAXPL_POS) | GR_EPCTRL_EV;
2075 dmactrl_val = GR_DMACTRL_IE | GR_DMACTRL_AI;
2076 gr_write32(&dev->epo[0].regs->epctrl, epctrl_val);
2077 gr_write32(&dev->epi[0].regs->epctrl, epctrl_val | GR_EPCTRL_PI);
2078 gr_write32(&dev->epo[0].regs->dmactrl, dmactrl_val);
2079 gr_write32(&dev->epi[0].regs->dmactrl, dmactrl_val);
2080
2081 return 0;
2082 }
2083
2084 static void gr_ep_remove(struct gr_udc *dev, int num, int is_in)
2085 {
2086 struct gr_ep *ep;
2087
2088 if (is_in)
2089 ep = &dev->epi[num];
2090 else
2091 ep = &dev->epo[num];
2092
2093 if (ep->tailbuf)
2094 dma_free_coherent(dev->dev, ep->ep.maxpacket_limit,
2095 ep->tailbuf, ep->tailbuf_paddr);
2096 }
2097
2098 static int gr_remove(struct platform_device *pdev)
2099 {
2100 struct gr_udc *dev = platform_get_drvdata(pdev);
2101 int i;
2102
2103 if (dev->added)
2104 usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
2105 if (dev->driver)
2106 return -EBUSY;
2107
2108 gr_dfs_delete(dev);
2109 if (dev->desc_pool)
2110 dma_pool_destroy(dev->desc_pool);
2111 platform_set_drvdata(pdev, NULL);
2112
2113 gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
2114 gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
2115
2116 for (i = 0; i < dev->nepo; i++)
2117 gr_ep_remove(dev, i, 0);
2118 for (i = 0; i < dev->nepi; i++)
2119 gr_ep_remove(dev, i, 1);
2120
2121 return 0;
2122 }
2123 static int gr_request_irq(struct gr_udc *dev, int irq)
2124 {
2125 return devm_request_threaded_irq(dev->dev, irq, gr_irq, gr_irq_handler,
2126 IRQF_SHARED, driver_name, dev);
2127 }
2128
2129 static int gr_probe(struct platform_device *pdev)
2130 {
2131 struct gr_udc *dev;
2132 struct resource *res;
2133 struct gr_regs __iomem *regs;
2134 int retval;
2135 u32 status;
2136
2137 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
2138 if (!dev)
2139 return -ENOMEM;
2140 dev->dev = &pdev->dev;
2141
2142 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2143 regs = devm_ioremap_resource(dev->dev, res);
2144 if (IS_ERR(regs))
2145 return PTR_ERR(regs);
2146
2147 dev->irq = platform_get_irq(pdev, 0);
2148 if (dev->irq <= 0) {
2149 dev_err(dev->dev, "No irq found\n");
2150 return -ENODEV;
2151 }
2152
2153 /* Some core configurations has separate irqs for IN and OUT events */
2154 dev->irqi = platform_get_irq(pdev, 1);
2155 if (dev->irqi > 0) {
2156 dev->irqo = platform_get_irq(pdev, 2);
2157 if (dev->irqo <= 0) {
2158 dev_err(dev->dev, "Found irqi but not irqo\n");
2159 return -ENODEV;
2160 }
2161 } else {
2162 dev->irqi = 0;
2163 }
2164
2165 dev->gadget.name = driver_name;
2166 dev->gadget.max_speed = USB_SPEED_HIGH;
2167 dev->gadget.ops = &gr_ops;
2168
2169 spin_lock_init(&dev->lock);
2170 dev->regs = regs;
2171
2172 platform_set_drvdata(pdev, dev);
2173
2174 /* Determine number of endpoints and data interface mode */
2175 status = gr_read32(&dev->regs->status);
2176 dev->nepi = ((status & GR_STATUS_NEPI_MASK) >> GR_STATUS_NEPI_POS) + 1;
2177 dev->nepo = ((status & GR_STATUS_NEPO_MASK) >> GR_STATUS_NEPO_POS) + 1;
2178
2179 if (!(status & GR_STATUS_DM)) {
2180 dev_err(dev->dev, "Slave mode cores are not supported\n");
2181 return -ENODEV;
2182 }
2183
2184 /* --- Effects of the following calls might need explicit cleanup --- */
2185
2186 /* Create DMA pool for descriptors */
2187 dev->desc_pool = dma_pool_create("desc_pool", dev->dev,
2188 sizeof(struct gr_dma_desc), 4, 0);
2189 if (!dev->desc_pool) {
2190 dev_err(dev->dev, "Could not allocate DMA pool");
2191 return -ENOMEM;
2192 }
2193
2194 spin_lock(&dev->lock);
2195
2196 /* Inside lock so that no gadget can use this udc until probe is done */
2197 retval = usb_add_gadget_udc(dev->dev, &dev->gadget);
2198 if (retval) {
2199 dev_err(dev->dev, "Could not add gadget udc");
2200 goto out;
2201 }
2202 dev->added = 1;
2203
2204 retval = gr_udc_init(dev);
2205 if (retval)
2206 goto out;
2207
2208 gr_dfs_create(dev);
2209
2210 /* Clear all interrupt enables that might be left on since last boot */
2211 gr_disable_interrupts_and_pullup(dev);
2212
2213 retval = gr_request_irq(dev, dev->irq);
2214 if (retval) {
2215 dev_err(dev->dev, "Failed to request irq %d\n", dev->irq);
2216 goto out;
2217 }
2218
2219 if (dev->irqi) {
2220 retval = gr_request_irq(dev, dev->irqi);
2221 if (retval) {
2222 dev_err(dev->dev, "Failed to request irqi %d\n",
2223 dev->irqi);
2224 goto out;
2225 }
2226 retval = gr_request_irq(dev, dev->irqo);
2227 if (retval) {
2228 dev_err(dev->dev, "Failed to request irqo %d\n",
2229 dev->irqo);
2230 goto out;
2231 }
2232 }
2233
2234 if (dev->irqi)
2235 dev_info(dev->dev, "regs: %p, irqs %d, %d, %d\n", dev->regs,
2236 dev->irq, dev->irqi, dev->irqo);
2237 else
2238 dev_info(dev->dev, "regs: %p, irq %d\n", dev->regs, dev->irq);
2239
2240 out:
2241 spin_unlock(&dev->lock);
2242
2243 if (retval)
2244 gr_remove(pdev);
2245
2246 return retval;
2247 }
2248
2249 static const struct of_device_id gr_match[] = {
2250 {.name = "GAISLER_USBDC"},
2251 {.name = "01_021"},
2252 {},
2253 };
2254 MODULE_DEVICE_TABLE(of, gr_match);
2255
2256 static struct platform_driver gr_driver = {
2257 .driver = {
2258 .name = DRIVER_NAME,
2259 .of_match_table = gr_match,
2260 },
2261 .probe = gr_probe,
2262 .remove = gr_remove,
2263 };
2264 module_platform_driver(gr_driver);
2265
2266 MODULE_AUTHOR("Aeroflex Gaisler AB.");
2267 MODULE_DESCRIPTION(DRIVER_DESC);
2268 MODULE_LICENSE("GPL");
Linux with added FPC-III support