?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: gadget: update ci13xxx to work with g_ether
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / gadget / ci13xxx_udc.c
blobf20e861deebfd7ea4e08b62f2f6ddb37bff49c63
1 /*
2 * ci13xxx_udc.c - MIPS USB IP core family device controller
3 *
4 * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
5 *
6 * Author: David Lopo
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 /*
14 * Description: MIPS USB IP core family device controller
15 * Currently it only supports IP part number CI13412
16 *
17 * This driver is composed of several blocks:
18 * - HW: hardware interface
19 * - DBG: debug facilities (optional)
20 * - UTIL: utilities
21 * - ISR: interrupts handling
22 * - ENDPT: endpoint operations (Gadget API)
23 * - GADGET: gadget operations (Gadget API)
24 * - BUS: bus glue code, bus abstraction layer
25 *
26 * Compile Options
27 * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
28 * - STALL_IN: non-empty bulk-in pipes cannot be halted
29 * if defined mass storage compliance succeeds but with warnings
30 * => case 4: Hi > Dn
31 * => case 5: Hi > Di
32 * => case 8: Hi <> Do
33 * if undefined usbtest 13 fails
34 * - TRACE: enable function tracing (depends on DEBUG)
35 *
36 * Main Features
37 * - Chapter 9 & Mass Storage Compliance with Gadget File Storage
38 * - Chapter 9 Compliance with Gadget Zero (STALL_IN undefined)
39 * - Normal & LPM support
40 *
41 * USBTEST Report
42 * - OK: 0-12, 13 (STALL_IN defined) & 14
43 * - Not Supported: 15 & 16 (ISO)
44 *
45 * TODO List
46 * - OTG
47 * - Isochronous & Interrupt Traffic
48 * - Handle requests which spawns into several TDs
49 * - GET_STATUS(device) - always reports 0
50 * - Gadget API (majority of optional features)
51 * - Suspend & Remote Wakeup
52 */
53 #include <linux/delay.h>
54 #include <linux/device.h>
55 #include <linux/dmapool.h>
56 #include <linux/dma-mapping.h>
57 #include <linux/init.h>
58 #include <linux/interrupt.h>
59 #include <linux/io.h>
60 #include <linux/irq.h>
61 #include <linux/kernel.h>
62 #include <linux/slab.h>
63 #include <linux/pm_runtime.h>
64 #include <linux/usb/ch9.h>
65 #include <linux/usb/gadget.h>
66 #include <linux/usb/otg.h>
67
68 #include "ci13xxx_udc.h"
69
70
71 /******************************************************************************
72 * DEFINE
73 *****************************************************************************/
74 /* ctrl register bank access */
75 static DEFINE_SPINLOCK(udc_lock);
76
77 /* control endpoint description */
78 static const struct usb_endpoint_descriptor
79 ctrl_endpt_desc = {
80 .bLength = USB_DT_ENDPOINT_SIZE,
81 .bDescriptorType = USB_DT_ENDPOINT,
82
83 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
84 .wMaxPacketSize = cpu_to_le16(CTRL_PAYLOAD_MAX),
85 };
86
87 /* UDC descriptor */
88 static struct ci13xxx *_udc;
89
90 /* Interrupt statistics */
91 #define ISR_MASK 0x1F
92 static struct {
93 u32 test;
94 u32 ui;
95 u32 uei;
96 u32 pci;
97 u32 uri;
98 u32 sli;
99 u32 none;
100 struct {
101 u32 cnt;
102 u32 buf[ISR_MASK+1];
103 u32 idx;
104 } hndl;
105 } isr_statistics;
106
107 /**
108 * ffs_nr: find first (least significant) bit set
109 * @x: the word to search
110 *
111 * This function returns bit number (instead of position)
112 */
113 static int ffs_nr(u32 x)
114 {
115 int n = ffs(x);
116
117 return n ? n-1 : 32;
118 }
119
120 /******************************************************************************
121 * HW block
122 *****************************************************************************/
123 /* register bank descriptor */
124 static struct {
125 unsigned lpm; /* is LPM? */
126 void __iomem *abs; /* bus map offset */
127 void __iomem *cap; /* bus map offset + CAP offset + CAP data */
128 size_t size; /* bank size */
129 } hw_bank;
130
131 /* MSM specific */
132 #define ABS_AHBBURST (0x0090UL)
133 #define ABS_AHBMODE (0x0098UL)
134 /* UDC register map */
135 #define ABS_CAPLENGTH (0x100UL)
136 #define ABS_HCCPARAMS (0x108UL)
137 #define ABS_DCCPARAMS (0x124UL)
138 #define ABS_TESTMODE (hw_bank.lpm ? 0x0FCUL : 0x138UL)
139 /* offset to CAPLENTGH (addr + data) */
140 #define CAP_USBCMD (0x000UL)
141 #define CAP_USBSTS (0x004UL)
142 #define CAP_USBINTR (0x008UL)
143 #define CAP_DEVICEADDR (0x014UL)
144 #define CAP_ENDPTLISTADDR (0x018UL)
145 #define CAP_PORTSC (0x044UL)
146 #define CAP_DEVLC (0x084UL)
147 #define CAP_USBMODE (hw_bank.lpm ? 0x0C8UL : 0x068UL)
148 #define CAP_ENDPTSETUPSTAT (hw_bank.lpm ? 0x0D8UL : 0x06CUL)
149 #define CAP_ENDPTPRIME (hw_bank.lpm ? 0x0DCUL : 0x070UL)
150 #define CAP_ENDPTFLUSH (hw_bank.lpm ? 0x0E0UL : 0x074UL)
151 #define CAP_ENDPTSTAT (hw_bank.lpm ? 0x0E4UL : 0x078UL)
152 #define CAP_ENDPTCOMPLETE (hw_bank.lpm ? 0x0E8UL : 0x07CUL)
153 #define CAP_ENDPTCTRL (hw_bank.lpm ? 0x0ECUL : 0x080UL)
154 #define CAP_LAST (hw_bank.lpm ? 0x12CUL : 0x0C0UL)
155
156 /* maximum number of enpoints: valid only after hw_device_reset() */
157 static unsigned hw_ep_max;
158
159 /**
160 * hw_ep_bit: calculates the bit number
161 * @num: endpoint number
162 * @dir: endpoint direction
163 *
164 * This function returns bit number
165 */
166 static inline int hw_ep_bit(int num, int dir)
167 {
168 return num + (dir ? 16 : 0);
169 }
170
171 /**
172 * hw_aread: reads from register bitfield
173 * @addr: address relative to bus map
174 * @mask: bitfield mask
175 *
176 * This function returns register bitfield data
177 */
178 static u32 hw_aread(u32 addr, u32 mask)
179 {
180 return ioread32(addr + hw_bank.abs) & mask;
181 }
182
183 /**
184 * hw_awrite: writes to register bitfield
185 * @addr: address relative to bus map
186 * @mask: bitfield mask
187 * @data: new data
188 */
189 static void hw_awrite(u32 addr, u32 mask, u32 data)
190 {
191 iowrite32(hw_aread(addr, ~mask) | (data & mask),
192 addr + hw_bank.abs);
193 }
194
195 /**
196 * hw_cread: reads from register bitfield
197 * @addr: address relative to CAP offset plus content
198 * @mask: bitfield mask
199 *
200 * This function returns register bitfield data
201 */
202 static u32 hw_cread(u32 addr, u32 mask)
203 {
204 return ioread32(addr + hw_bank.cap) & mask;
205 }
206
207 /**
208 * hw_cwrite: writes to register bitfield
209 * @addr: address relative to CAP offset plus content
210 * @mask: bitfield mask
211 * @data: new data
212 */
213 static void hw_cwrite(u32 addr, u32 mask, u32 data)
214 {
215 iowrite32(hw_cread(addr, ~mask) | (data & mask),
216 addr + hw_bank.cap);
217 }
218
219 /**
220 * hw_ctest_and_clear: tests & clears register bitfield
221 * @addr: address relative to CAP offset plus content
222 * @mask: bitfield mask
223 *
224 * This function returns register bitfield data
225 */
226 static u32 hw_ctest_and_clear(u32 addr, u32 mask)
227 {
228 u32 reg = hw_cread(addr, mask);
229
230 iowrite32(reg, addr + hw_bank.cap);
231 return reg;
232 }
233
234 /**
235 * hw_ctest_and_write: tests & writes register bitfield
236 * @addr: address relative to CAP offset plus content
237 * @mask: bitfield mask
238 * @data: new data
239 *
240 * This function returns register bitfield data
241 */
242 static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
243 {
244 u32 reg = hw_cread(addr, ~0);
245
246 iowrite32((reg & ~mask) | (data & mask), addr + hw_bank.cap);
247 return (reg & mask) >> ffs_nr(mask);
248 }
249
250 static int hw_device_init(void __iomem *base)
251 {
252 u32 reg;
253
254 /* bank is a module variable */
255 hw_bank.abs = base;
256
257 hw_bank.cap = hw_bank.abs;
258 hw_bank.cap += ABS_CAPLENGTH;
259 hw_bank.cap += ioread8(hw_bank.cap);
260
261 reg = hw_aread(ABS_HCCPARAMS, HCCPARAMS_LEN) >> ffs_nr(HCCPARAMS_LEN);
262 hw_bank.lpm = reg;
263 hw_bank.size = hw_bank.cap - hw_bank.abs;
264 hw_bank.size += CAP_LAST;
265 hw_bank.size /= sizeof(u32);
266
267 reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
268 if (reg == 0 || reg > ENDPT_MAX)
269 return -ENODEV;
270
271 hw_ep_max = reg; /* cache hw ENDPT_MAX */
272
273 /* setup lock mode ? */
274
275 /* ENDPTSETUPSTAT is '0' by default */
276
277 /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
278
279 return 0;
280 }
281 /**
282 * hw_device_reset: resets chip (execute without interruption)
283 * @base: register base address
284 *
285 * This function returns an error code
286 */
287 static int hw_device_reset(struct ci13xxx *udc)
288 {
289 /* should flush & stop before reset */
290 hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
291 hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
292
293 hw_cwrite(CAP_USBCMD, USBCMD_RST, USBCMD_RST);
294 while (hw_cread(CAP_USBCMD, USBCMD_RST))
295 udelay(10); /* not RTOS friendly */
296
297
298 if (udc->udc_driver->notify_event)
299 udc->udc_driver->notify_event(udc,
300 CI13XXX_CONTROLLER_RESET_EVENT);
301
302 if (udc->udc_driver->flags && CI13XXX_DISABLE_STREAMING)
303 hw_cwrite(CAP_USBMODE, USBMODE_SDIS, USBMODE_SDIS);
304
305 /* USBMODE should be configured step by step */
306 hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
307 hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
308 hw_cwrite(CAP_USBMODE, USBMODE_SLOM, USBMODE_SLOM); /* HW >= 2.3 */
309
310 if (hw_cread(CAP_USBMODE, USBMODE_CM) != USBMODE_CM_DEVICE) {
311 pr_err("cannot enter in device mode");
312 pr_err("lpm = %i", hw_bank.lpm);
313 return -ENODEV;
314 }
315
316 return 0;
317 }
318
319 /**
320 * hw_device_state: enables/disables interrupts & starts/stops device (execute
321 * without interruption)
322 * @dma: 0 => disable, !0 => enable and set dma engine
323 *
324 * This function returns an error code
325 */
326 static int hw_device_state(u32 dma)
327 {
328 if (dma) {
329 hw_cwrite(CAP_ENDPTLISTADDR, ~0, dma);
330 /* interrupt, error, port change, reset, sleep/suspend */
331 hw_cwrite(CAP_USBINTR, ~0,
332 USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
333 hw_cwrite(CAP_USBCMD, USBCMD_RS, USBCMD_RS);
334 } else {
335 hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
336 hw_cwrite(CAP_USBINTR, ~0, 0);
337 }
338 return 0;
339 }
340
341 /**
342 * hw_ep_flush: flush endpoint fifo (execute without interruption)
343 * @num: endpoint number
344 * @dir: endpoint direction
345 *
346 * This function returns an error code
347 */
348 static int hw_ep_flush(int num, int dir)
349 {
350 int n = hw_ep_bit(num, dir);
351
352 do {
353 /* flush any pending transfer */
354 hw_cwrite(CAP_ENDPTFLUSH, BIT(n), BIT(n));
355 while (hw_cread(CAP_ENDPTFLUSH, BIT(n)))
356 cpu_relax();
357 } while (hw_cread(CAP_ENDPTSTAT, BIT(n)));
358
359 return 0;
360 }
361
362 /**
363 * hw_ep_disable: disables endpoint (execute without interruption)
364 * @num: endpoint number
365 * @dir: endpoint direction
366 *
367 * This function returns an error code
368 */
369 static int hw_ep_disable(int num, int dir)
370 {
371 hw_ep_flush(num, dir);
372 hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32),
373 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
374 return 0;
375 }
376
377 /**
378 * hw_ep_enable: enables endpoint (execute without interruption)
379 * @num: endpoint number
380 * @dir: endpoint direction
381 * @type: endpoint type
382 *
383 * This function returns an error code
384 */
385 static int hw_ep_enable(int num, int dir, int type)
386 {
387 u32 mask, data;
388
389 if (dir) {
390 mask = ENDPTCTRL_TXT; /* type */
391 data = type << ffs_nr(mask);
392
393 mask |= ENDPTCTRL_TXS; /* unstall */
394 mask |= ENDPTCTRL_TXR; /* reset data toggle */
395 data |= ENDPTCTRL_TXR;
396 mask |= ENDPTCTRL_TXE; /* enable */
397 data |= ENDPTCTRL_TXE;
398 } else {
399 mask = ENDPTCTRL_RXT; /* type */
400 data = type << ffs_nr(mask);
401
402 mask |= ENDPTCTRL_RXS; /* unstall */
403 mask |= ENDPTCTRL_RXR; /* reset data toggle */
404 data |= ENDPTCTRL_RXR;
405 mask |= ENDPTCTRL_RXE; /* enable */
406 data |= ENDPTCTRL_RXE;
407 }
408 hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32), mask, data);
409 return 0;
410 }
411
412 /**
413 * hw_ep_get_halt: return endpoint halt status
414 * @num: endpoint number
415 * @dir: endpoint direction
416 *
417 * This function returns 1 if endpoint halted
418 */
419 static int hw_ep_get_halt(int num, int dir)
420 {
421 u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
422
423 return hw_cread(CAP_ENDPTCTRL + num * sizeof(u32), mask) ? 1 : 0;
424 }
425
426 /**
427 * hw_ep_is_primed: test if endpoint is primed (execute without interruption)
428 * @num: endpoint number
429 * @dir: endpoint direction
430 *
431 * This function returns true if endpoint primed
432 */
433 static int hw_ep_is_primed(int num, int dir)
434 {
435 u32 reg = hw_cread(CAP_ENDPTPRIME, ~0) | hw_cread(CAP_ENDPTSTAT, ~0);
436
437 return test_bit(hw_ep_bit(num, dir), (void *)&reg);
438 }
439
440 /**
441 * hw_test_and_clear_setup_status: test & clear setup status (execute without
442 * interruption)
443 * @n: bit number (endpoint)
444 *
445 * This function returns setup status
446 */
447 static int hw_test_and_clear_setup_status(int n)
448 {
449 return hw_ctest_and_clear(CAP_ENDPTSETUPSTAT, BIT(n));
450 }
451
452 /**
453 * hw_ep_prime: primes endpoint (execute without interruption)
454 * @num: endpoint number
455 * @dir: endpoint direction
456 * @is_ctrl: true if control endpoint
457 *
458 * This function returns an error code
459 */
460 static int hw_ep_prime(int num, int dir, int is_ctrl)
461 {
462 int n = hw_ep_bit(num, dir);
463
464 /* the caller should flush first */
465 if (hw_ep_is_primed(num, dir))
466 return -EBUSY;
467
468 if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
469 return -EAGAIN;
470
471 hw_cwrite(CAP_ENDPTPRIME, BIT(n), BIT(n));
472
473 while (hw_cread(CAP_ENDPTPRIME, BIT(n)))
474 cpu_relax();
475 if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
476 return -EAGAIN;
477
478 /* status shoult be tested according with manual but it doesn't work */
479 return 0;
480 }
481
482 /**
483 * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
484 * without interruption)
485 * @num: endpoint number
486 * @dir: endpoint direction
487 * @value: true => stall, false => unstall
488 *
489 * This function returns an error code
490 */
491 static int hw_ep_set_halt(int num, int dir, int value)
492 {
493 if (value != 0 && value != 1)
494 return -EINVAL;
495
496 do {
497 u32 addr = CAP_ENDPTCTRL + num * sizeof(u32);
498 u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
499 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
500
501 /* data toggle - reserved for EP0 but it's in ESS */
502 hw_cwrite(addr, mask_xs|mask_xr, value ? mask_xs : mask_xr);
503
504 } while (value != hw_ep_get_halt(num, dir));
505
506 return 0;
507 }
508
509 /**
510 * hw_intr_clear: disables interrupt & clears interrupt status (execute without
511 * interruption)
512 * @n: interrupt bit
513 *
514 * This function returns an error code
515 */
516 static int hw_intr_clear(int n)
517 {
518 if (n >= REG_BITS)
519 return -EINVAL;
520
521 hw_cwrite(CAP_USBINTR, BIT(n), 0);
522 hw_cwrite(CAP_USBSTS, BIT(n), BIT(n));
523 return 0;
524 }
525
526 /**
527 * hw_intr_force: enables interrupt & forces interrupt status (execute without
528 * interruption)
529 * @n: interrupt bit
530 *
531 * This function returns an error code
532 */
533 static int hw_intr_force(int n)
534 {
535 if (n >= REG_BITS)
536 return -EINVAL;
537
538 hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
539 hw_cwrite(CAP_USBINTR, BIT(n), BIT(n));
540 hw_cwrite(CAP_USBSTS, BIT(n), BIT(n));
541 hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, 0);
542 return 0;
543 }
544
545 /**
546 * hw_is_port_high_speed: test if port is high speed
547 *
548 * This function returns true if high speed port
549 */
550 static int hw_port_is_high_speed(void)
551 {
552 return hw_bank.lpm ? hw_cread(CAP_DEVLC, DEVLC_PSPD) :
553 hw_cread(CAP_PORTSC, PORTSC_HSP);
554 }
555
556 /**
557 * hw_port_test_get: reads port test mode value
558 *
559 * This function returns port test mode value
560 */
561 static u8 hw_port_test_get(void)
562 {
563 return hw_cread(CAP_PORTSC, PORTSC_PTC) >> ffs_nr(PORTSC_PTC);
564 }
565
566 /**
567 * hw_port_test_set: writes port test mode (execute without interruption)
568 * @mode: new value
569 *
570 * This function returns an error code
571 */
572 static int hw_port_test_set(u8 mode)
573 {
574 const u8 TEST_MODE_MAX = 7;
575
576 if (mode > TEST_MODE_MAX)
577 return -EINVAL;
578
579 hw_cwrite(CAP_PORTSC, PORTSC_PTC, mode << ffs_nr(PORTSC_PTC));
580 return 0;
581 }
582
583 /**
584 * hw_read_intr_enable: returns interrupt enable register
585 *
586 * This function returns register data
587 */
588 static u32 hw_read_intr_enable(void)
589 {
590 return hw_cread(CAP_USBINTR, ~0);
591 }
592
593 /**
594 * hw_read_intr_status: returns interrupt status register
595 *
596 * This function returns register data
597 */
598 static u32 hw_read_intr_status(void)
599 {
600 return hw_cread(CAP_USBSTS, ~0);
601 }
602
603 /**
604 * hw_register_read: reads all device registers (execute without interruption)
605 * @buf: destination buffer
606 * @size: buffer size
607 *
608 * This function returns number of registers read
609 */
610 static size_t hw_register_read(u32 *buf, size_t size)
611 {
612 unsigned i;
613
614 if (size > hw_bank.size)
615 size = hw_bank.size;
616
617 for (i = 0; i < size; i++)
618 buf[i] = hw_aread(i * sizeof(u32), ~0);
619
620 return size;
621 }
622
623 /**
624 * hw_register_write: writes to register
625 * @addr: register address
626 * @data: register value
627 *
628 * This function returns an error code
629 */
630 static int hw_register_write(u16 addr, u32 data)
631 {
632 /* align */
633 addr /= sizeof(u32);
634
635 if (addr >= hw_bank.size)
636 return -EINVAL;
637
638 /* align */
639 addr *= sizeof(u32);
640
641 hw_awrite(addr, ~0, data);
642 return 0;
643 }
644
645 /**
646 * hw_test_and_clear_complete: test & clear complete status (execute without
647 * interruption)
648 * @n: bit number (endpoint)
649 *
650 * This function returns complete status
651 */
652 static int hw_test_and_clear_complete(int n)
653 {
654 return hw_ctest_and_clear(CAP_ENDPTCOMPLETE, BIT(n));
655 }
656
657 /**
658 * hw_test_and_clear_intr_active: test & clear active interrupts (execute
659 * without interruption)
660 *
661 * This function returns active interrutps
662 */
663 static u32 hw_test_and_clear_intr_active(void)
664 {
665 u32 reg = hw_read_intr_status() & hw_read_intr_enable();
666
667 hw_cwrite(CAP_USBSTS, ~0, reg);
668 return reg;
669 }
670
671 /**
672 * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
673 * interruption)
674 *
675 * This function returns guard value
676 */
677 static int hw_test_and_clear_setup_guard(void)
678 {
679 return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, 0);
680 }
681
682 /**
683 * hw_test_and_set_setup_guard: test & set setup guard (execute without
684 * interruption)
685 *
686 * This function returns guard value
687 */
688 static int hw_test_and_set_setup_guard(void)
689 {
690 return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
691 }
692
693 /**
694 * hw_usb_set_address: configures USB address (execute without interruption)
695 * @value: new USB address
696 *
697 * This function returns an error code
698 */
699 static int hw_usb_set_address(u8 value)
700 {
701 /* advance */
702 hw_cwrite(CAP_DEVICEADDR, DEVICEADDR_USBADR | DEVICEADDR_USBADRA,
703 value << ffs_nr(DEVICEADDR_USBADR) | DEVICEADDR_USBADRA);
704 return 0;
705 }
706
707 /**
708 * hw_usb_reset: restart device after a bus reset (execute without
709 * interruption)
710 *
711 * This function returns an error code
712 */
713 static int hw_usb_reset(void)
714 {
715 hw_usb_set_address(0);
716
717 /* ESS flushes only at end?!? */
718 hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0); /* flush all EPs */
719
720 /* clear setup token semaphores */
721 hw_cwrite(CAP_ENDPTSETUPSTAT, 0, 0); /* writes its content */
722
723 /* clear complete status */
724 hw_cwrite(CAP_ENDPTCOMPLETE, 0, 0); /* writes its content */
725
726 /* wait until all bits cleared */
727 while (hw_cread(CAP_ENDPTPRIME, ~0))
728 udelay(10); /* not RTOS friendly */
729
730 /* reset all endpoints ? */
731
732 /* reset internal status and wait for further instructions
733 no need to verify the port reset status (ESS does it) */
734
735 return 0;
736 }
737
738 /******************************************************************************
739 * DBG block
740 *****************************************************************************/
741 /**
742 * show_device: prints information about device capabilities and status
743 *
744 * Check "device.h" for details
745 */
746 static ssize_t show_device(struct device *dev, struct device_attribute *attr,
747 char *buf)
748 {
749 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
750 struct usb_gadget *gadget = &udc->gadget;
751 int n = 0;
752
753 dbg_trace("[%s] %p\n", __func__, buf);
754 if (attr == NULL || buf == NULL) {
755 dev_err(dev, "[%s] EINVAL\n", __func__);
756 return 0;
757 }
758
759 n += scnprintf(buf + n, PAGE_SIZE - n, "speed = %d\n",
760 gadget->speed);
761 n += scnprintf(buf + n, PAGE_SIZE - n, "is_dualspeed = %d\n",
762 gadget->is_dualspeed);
763 n += scnprintf(buf + n, PAGE_SIZE - n, "is_otg = %d\n",
764 gadget->is_otg);
765 n += scnprintf(buf + n, PAGE_SIZE - n, "is_a_peripheral = %d\n",
766 gadget->is_a_peripheral);
767 n += scnprintf(buf + n, PAGE_SIZE - n, "b_hnp_enable = %d\n",
768 gadget->b_hnp_enable);
769 n += scnprintf(buf + n, PAGE_SIZE - n, "a_hnp_support = %d\n",
770 gadget->a_hnp_support);
771 n += scnprintf(buf + n, PAGE_SIZE - n, "a_alt_hnp_support = %d\n",
772 gadget->a_alt_hnp_support);
773 n += scnprintf(buf + n, PAGE_SIZE - n, "name = %s\n",
774 (gadget->name ? gadget->name : ""));
775
776 return n;
777 }
778 static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
779
780 /**
781 * show_driver: prints information about attached gadget (if any)
782 *
783 * Check "device.h" for details
784 */
785 static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
786 char *buf)
787 {
788 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
789 struct usb_gadget_driver *driver = udc->driver;
790 int n = 0;
791
792 dbg_trace("[%s] %p\n", __func__, buf);
793 if (attr == NULL || buf == NULL) {
794 dev_err(dev, "[%s] EINVAL\n", __func__);
795 return 0;
796 }
797
798 if (driver == NULL)
799 return scnprintf(buf, PAGE_SIZE,
800 "There is no gadget attached!\n");
801
802 n += scnprintf(buf + n, PAGE_SIZE - n, "function = %s\n",
803 (driver->function ? driver->function : ""));
804 n += scnprintf(buf + n, PAGE_SIZE - n, "max speed = %d\n",
805 driver->speed);
806
807 return n;
808 }
809 static DEVICE_ATTR(driver, S_IRUSR, show_driver, NULL);
810
811 /* Maximum event message length */
812 #define DBG_DATA_MSG 64UL
813
814 /* Maximum event messages */
815 #define DBG_DATA_MAX 128UL
816
817 /* Event buffer descriptor */
818 static struct {
819 char (buf[DBG_DATA_MAX])[DBG_DATA_MSG]; /* buffer */
820 unsigned idx; /* index */
821 unsigned tty; /* print to console? */
822 rwlock_t lck; /* lock */
823 } dbg_data = {
824 .idx = 0,
825 .tty = 0,
826 .lck = __RW_LOCK_UNLOCKED(lck)
827 };
828
829 /**
830 * dbg_dec: decrements debug event index
831 * @idx: buffer index
832 */
833 static void dbg_dec(unsigned *idx)
834 {
835 *idx = (*idx - 1) & (DBG_DATA_MAX-1);
836 }
837
838 /**
839 * dbg_inc: increments debug event index
840 * @idx: buffer index
841 */
842 static void dbg_inc(unsigned *idx)
843 {
844 *idx = (*idx + 1) & (DBG_DATA_MAX-1);
845 }
846
847 /**
848 * dbg_print: prints the common part of the event
849 * @addr: endpoint address
850 * @name: event name
851 * @status: status
852 * @extra: extra information
853 */
854 static void dbg_print(u8 addr, const char *name, int status, const char *extra)
855 {
856 struct timeval tval;
857 unsigned int stamp;
858 unsigned long flags;
859
860 write_lock_irqsave(&dbg_data.lck, flags);
861
862 do_gettimeofday(&tval);
863 stamp = tval.tv_sec & 0xFFFF; /* 2^32 = 4294967296. Limit to 4096s */
864 stamp = stamp * 1000000 + tval.tv_usec;
865
866 scnprintf(dbg_data.buf[dbg_data.idx], DBG_DATA_MSG,
867 "%04X\t» %02X %-7.7s %4i «\t%s\n",
868 stamp, addr, name, status, extra);
869
870 dbg_inc(&dbg_data.idx);
871
872 write_unlock_irqrestore(&dbg_data.lck, flags);
873
874 if (dbg_data.tty != 0)
875 pr_notice("%04X\t» %02X %-7.7s %4i «\t%s\n",
876 stamp, addr, name, status, extra);
877 }
878
879 /**
880 * dbg_done: prints a DONE event
881 * @addr: endpoint address
882 * @td: transfer descriptor
883 * @status: status
884 */
885 static void dbg_done(u8 addr, const u32 token, int status)
886 {
887 char msg[DBG_DATA_MSG];
888
889 scnprintf(msg, sizeof(msg), "%d %02X",
890 (int)(token & TD_TOTAL_BYTES) >> ffs_nr(TD_TOTAL_BYTES),
891 (int)(token & TD_STATUS) >> ffs_nr(TD_STATUS));
892 dbg_print(addr, "DONE", status, msg);
893 }
894
895 /**
896 * dbg_event: prints a generic event
897 * @addr: endpoint address
898 * @name: event name
899 * @status: status
900 */
901 static void dbg_event(u8 addr, const char *name, int status)
902 {
903 if (name != NULL)
904 dbg_print(addr, name, status, "");
905 }
906
907 /*
908 * dbg_queue: prints a QUEUE event
909 * @addr: endpoint address
910 * @req: USB request
911 * @status: status
912 */
913 static void dbg_queue(u8 addr, const struct usb_request *req, int status)
914 {
915 char msg[DBG_DATA_MSG];
916
917 if (req != NULL) {
918 scnprintf(msg, sizeof(msg),
919 "%d %d", !req->no_interrupt, req->length);
920 dbg_print(addr, "QUEUE", status, msg);
921 }
922 }
923
924 /**
925 * dbg_setup: prints a SETUP event
926 * @addr: endpoint address
927 * @req: setup request
928 */
929 static void dbg_setup(u8 addr, const struct usb_ctrlrequest *req)
930 {
931 char msg[DBG_DATA_MSG];
932
933 if (req != NULL) {
934 scnprintf(msg, sizeof(msg),
935 "%02X %02X %04X %04X %d", req->bRequestType,
936 req->bRequest, le16_to_cpu(req->wValue),
937 le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
938 dbg_print(addr, "SETUP", 0, msg);
939 }
940 }
941
942 /**
943 * show_events: displays the event buffer
944 *
945 * Check "device.h" for details
946 */
947 static ssize_t show_events(struct device *dev, struct device_attribute *attr,
948 char *buf)
949 {
950 unsigned long flags;
951 unsigned i, j, n = 0;
952
953 dbg_trace("[%s] %p\n", __func__, buf);
954 if (attr == NULL || buf == NULL) {
955 dev_err(dev, "[%s] EINVAL\n", __func__);
956 return 0;
957 }
958
959 read_lock_irqsave(&dbg_data.lck, flags);
960
961 i = dbg_data.idx;
962 for (dbg_dec(&i); i != dbg_data.idx; dbg_dec(&i)) {
963 n += strlen(dbg_data.buf[i]);
964 if (n >= PAGE_SIZE) {
965 n -= strlen(dbg_data.buf[i]);
966 break;
967 }
968 }
969 for (j = 0, dbg_inc(&i); j < n; dbg_inc(&i))
970 j += scnprintf(buf + j, PAGE_SIZE - j,
971 "%s", dbg_data.buf[i]);
972
973 read_unlock_irqrestore(&dbg_data.lck, flags);
974
975 return n;
976 }
977
978 /**
979 * store_events: configure if events are going to be also printed to console
980 *
981 * Check "device.h" for details
982 */
983 static ssize_t store_events(struct device *dev, struct device_attribute *attr,
984 const char *buf, size_t count)
985 {
986 unsigned tty;
987
988 dbg_trace("[%s] %p, %d\n", __func__, buf, count);
989 if (attr == NULL || buf == NULL) {
990 dev_err(dev, "[%s] EINVAL\n", __func__);
991 goto done;
992 }
993
994 if (sscanf(buf, "%u", &tty) != 1 || tty > 1) {
995 dev_err(dev, "<1|0>: enable|disable console log\n");
996 goto done;
997 }
998
999 dbg_data.tty = tty;
1000 dev_info(dev, "tty = %u", dbg_data.tty);
1001
1002 done:
1003 return count;
1004 }
1005 static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
1006
1007 /**
1008 * show_inters: interrupt status, enable status and historic
1009 *
1010 * Check "device.h" for details
1011 */
1012 static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
1013 char *buf)
1014 {
1015 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1016 unsigned long flags;
1017 u32 intr;
1018 unsigned i, j, n = 0;
1019
1020 dbg_trace("[%s] %p\n", __func__, buf);
1021 if (attr == NULL || buf == NULL) {
1022 dev_err(dev, "[%s] EINVAL\n", __func__);
1023 return 0;
1024 }
1025
1026 spin_lock_irqsave(udc->lock, flags);
1027
1028 n += scnprintf(buf + n, PAGE_SIZE - n,
1029 "status = %08x\n", hw_read_intr_status());
1030 n += scnprintf(buf + n, PAGE_SIZE - n,
1031 "enable = %08x\n", hw_read_intr_enable());
1032
1033 n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
1034 isr_statistics.test);
1035 n += scnprintf(buf + n, PAGE_SIZE - n, "» ui = %d\n",
1036 isr_statistics.ui);
1037 n += scnprintf(buf + n, PAGE_SIZE - n, "» uei = %d\n",
1038 isr_statistics.uei);
1039 n += scnprintf(buf + n, PAGE_SIZE - n, "» pci = %d\n",
1040 isr_statistics.pci);
1041 n += scnprintf(buf + n, PAGE_SIZE - n, "» uri = %d\n",
1042 isr_statistics.uri);
1043 n += scnprintf(buf + n, PAGE_SIZE - n, "» sli = %d\n",
1044 isr_statistics.sli);
1045 n += scnprintf(buf + n, PAGE_SIZE - n, "*none = %d\n",
1046 isr_statistics.none);
1047 n += scnprintf(buf + n, PAGE_SIZE - n, "*hndl = %d\n",
1048 isr_statistics.hndl.cnt);
1049
1050 for (i = isr_statistics.hndl.idx, j = 0; j <= ISR_MASK; j++, i++) {
1051 i &= ISR_MASK;
1052 intr = isr_statistics.hndl.buf[i];
1053
1054 if (USBi_UI & intr)
1055 n += scnprintf(buf + n, PAGE_SIZE - n, "ui ");
1056 intr &= ~USBi_UI;
1057 if (USBi_UEI & intr)
1058 n += scnprintf(buf + n, PAGE_SIZE - n, "uei ");
1059 intr &= ~USBi_UEI;
1060 if (USBi_PCI & intr)
1061 n += scnprintf(buf + n, PAGE_SIZE - n, "pci ");
1062 intr &= ~USBi_PCI;
1063 if (USBi_URI & intr)
1064 n += scnprintf(buf + n, PAGE_SIZE - n, "uri ");
1065 intr &= ~USBi_URI;
1066 if (USBi_SLI & intr)
1067 n += scnprintf(buf + n, PAGE_SIZE - n, "sli ");
1068 intr &= ~USBi_SLI;
1069 if (intr)
1070 n += scnprintf(buf + n, PAGE_SIZE - n, "??? ");
1071 if (isr_statistics.hndl.buf[i])
1072 n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
1073 }
1074
1075 spin_unlock_irqrestore(udc->lock, flags);
1076
1077 return n;
1078 }
1079
1080 /**
1081 * store_inters: enable & force or disable an individual interrutps
1082 * (to be used for test purposes only)
1083 *
1084 * Check "device.h" for details
1085 */
1086 static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
1087 const char *buf, size_t count)
1088 {
1089 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1090 unsigned long flags;
1091 unsigned en, bit;
1092
1093 dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1094 if (attr == NULL || buf == NULL) {
1095 dev_err(dev, "[%s] EINVAL\n", __func__);
1096 goto done;
1097 }
1098
1099 if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
1100 dev_err(dev, "<1|0> <bit>: enable|disable interrupt");
1101 goto done;
1102 }
1103
1104 spin_lock_irqsave(udc->lock, flags);
1105 if (en) {
1106 if (hw_intr_force(bit))
1107 dev_err(dev, "invalid bit number\n");
1108 else
1109 isr_statistics.test++;
1110 } else {
1111 if (hw_intr_clear(bit))
1112 dev_err(dev, "invalid bit number\n");
1113 }
1114 spin_unlock_irqrestore(udc->lock, flags);
1115
1116 done:
1117 return count;
1118 }
1119 static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
1120
1121 /**
1122 * show_port_test: reads port test mode
1123 *
1124 * Check "device.h" for details
1125 */
1126 static ssize_t show_port_test(struct device *dev,
1127 struct device_attribute *attr, char *buf)
1128 {
1129 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1130 unsigned long flags;
1131 unsigned mode;
1132
1133 dbg_trace("[%s] %p\n", __func__, buf);
1134 if (attr == NULL || buf == NULL) {
1135 dev_err(dev, "[%s] EINVAL\n", __func__);
1136 return 0;
1137 }
1138
1139 spin_lock_irqsave(udc->lock, flags);
1140 mode = hw_port_test_get();
1141 spin_unlock_irqrestore(udc->lock, flags);
1142
1143 return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
1144 }
1145
1146 /**
1147 * store_port_test: writes port test mode
1148 *
1149 * Check "device.h" for details
1150 */
1151 static ssize_t store_port_test(struct device *dev,
1152 struct device_attribute *attr,
1153 const char *buf, size_t count)
1154 {
1155 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1156 unsigned long flags;
1157 unsigned mode;
1158
1159 dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1160 if (attr == NULL || buf == NULL) {
1161 dev_err(dev, "[%s] EINVAL\n", __func__);
1162 goto done;
1163 }
1164
1165 if (sscanf(buf, "%u", &mode) != 1) {
1166 dev_err(dev, "<mode>: set port test mode");
1167 goto done;
1168 }
1169
1170 spin_lock_irqsave(udc->lock, flags);
1171 if (hw_port_test_set(mode))
1172 dev_err(dev, "invalid mode\n");
1173 spin_unlock_irqrestore(udc->lock, flags);
1174
1175 done:
1176 return count;
1177 }
1178 static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
1179 show_port_test, store_port_test);
1180
1181 /**
1182 * show_qheads: DMA contents of all queue heads
1183 *
1184 * Check "device.h" for details
1185 */
1186 static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
1187 char *buf)
1188 {
1189 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1190 unsigned long flags;
1191 unsigned i, j, n = 0;
1192
1193 dbg_trace("[%s] %p\n", __func__, buf);
1194 if (attr == NULL || buf == NULL) {
1195 dev_err(dev, "[%s] EINVAL\n", __func__);
1196 return 0;
1197 }
1198
1199 spin_lock_irqsave(udc->lock, flags);
1200 for (i = 0; i < hw_ep_max; i++) {
1201 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
1202 n += scnprintf(buf + n, PAGE_SIZE - n,
1203 "EP=%02i: RX=%08X TX=%08X\n",
1204 i, (u32)mEp->qh[RX].dma, (u32)mEp->qh[TX].dma);
1205 for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
1206 n += scnprintf(buf + n, PAGE_SIZE - n,
1207 " %04X: %08X %08X\n", j,
1208 *((u32 *)mEp->qh[RX].ptr + j),
1209 *((u32 *)mEp->qh[TX].ptr + j));
1210 }
1211 }
1212 spin_unlock_irqrestore(udc->lock, flags);
1213
1214 return n;
1215 }
1216 static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
1217
1218 /**
1219 * show_registers: dumps all registers
1220 *
1221 * Check "device.h" for details
1222 */
1223 static ssize_t show_registers(struct device *dev,
1224 struct device_attribute *attr, char *buf)
1225 {
1226 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1227 unsigned long flags;
1228 u32 dump[512];
1229 unsigned i, k, n = 0;
1230
1231 dbg_trace("[%s] %p\n", __func__, buf);
1232 if (attr == NULL || buf == NULL) {
1233 dev_err(dev, "[%s] EINVAL\n", __func__);
1234 return 0;
1235 }
1236
1237 spin_lock_irqsave(udc->lock, flags);
1238 k = hw_register_read(dump, sizeof(dump)/sizeof(u32));
1239 spin_unlock_irqrestore(udc->lock, flags);
1240
1241 for (i = 0; i < k; i++) {
1242 n += scnprintf(buf + n, PAGE_SIZE - n,
1243 "reg[0x%04X] = 0x%08X\n",
1244 i * (unsigned)sizeof(u32), dump[i]);
1245 }
1246
1247 return n;
1248 }
1249
1250 /**
1251 * store_registers: writes value to register address
1252 *
1253 * Check "device.h" for details
1254 */
1255 static ssize_t store_registers(struct device *dev,
1256 struct device_attribute *attr,
1257 const char *buf, size_t count)
1258 {
1259 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1260 unsigned long addr, data, flags;
1261
1262 dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1263 if (attr == NULL || buf == NULL) {
1264 dev_err(dev, "[%s] EINVAL\n", __func__);
1265 goto done;
1266 }
1267
1268 if (sscanf(buf, "%li %li", &addr, &data) != 2) {
1269 dev_err(dev, "<addr> <data>: write data to register address");
1270 goto done;
1271 }
1272
1273 spin_lock_irqsave(udc->lock, flags);
1274 if (hw_register_write(addr, data))
1275 dev_err(dev, "invalid address range\n");
1276 spin_unlock_irqrestore(udc->lock, flags);
1277
1278 done:
1279 return count;
1280 }
1281 static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
1282 show_registers, store_registers);
1283
1284 /**
1285 * show_requests: DMA contents of all requests currently queued (all endpts)
1286 *
1287 * Check "device.h" for details
1288 */
1289 static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
1290 char *buf)
1291 {
1292 struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1293 unsigned long flags;
1294 struct list_head *ptr = NULL;
1295 struct ci13xxx_req *req = NULL;
1296 unsigned i, j, k, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
1297
1298 dbg_trace("[%s] %p\n", __func__, buf);
1299 if (attr == NULL || buf == NULL) {
1300 dev_err(dev, "[%s] EINVAL\n", __func__);
1301 return 0;
1302 }
1303
1304 spin_lock_irqsave(udc->lock, flags);
1305 for (i = 0; i < hw_ep_max; i++)
1306 for (k = RX; k <= TX; k++)
1307 list_for_each(ptr, &udc->ci13xxx_ep[i].qh[k].queue)
1308 {
1309 req = list_entry(ptr,
1310 struct ci13xxx_req, queue);
1311
1312 n += scnprintf(buf + n, PAGE_SIZE - n,
1313 "EP=%02i: TD=%08X %s\n",
1314 i, (u32)req->dma,
1315 ((k == RX) ? "RX" : "TX"));
1316
1317 for (j = 0; j < qSize; j++)
1318 n += scnprintf(buf + n, PAGE_SIZE - n,
1319 " %04X: %08X\n", j,
1320 *((u32 *)req->ptr + j));
1321 }
1322 spin_unlock_irqrestore(udc->lock, flags);
1323
1324 return n;
1325 }
1326 static DEVICE_ATTR(requests, S_IRUSR, show_requests, NULL);
1327
1328 /**
1329 * dbg_create_files: initializes the attribute interface
1330 * @dev: device
1331 *
1332 * This function returns an error code
1333 */
1334 __maybe_unused static int dbg_create_files(struct device *dev)
1335 {
1336 int retval = 0;
1337
1338 if (dev == NULL)
1339 return -EINVAL;
1340 retval = device_create_file(dev, &dev_attr_device);
1341 if (retval)
1342 goto done;
1343 retval = device_create_file(dev, &dev_attr_driver);
1344 if (retval)
1345 goto rm_device;
1346 retval = device_create_file(dev, &dev_attr_events);
1347 if (retval)
1348 goto rm_driver;
1349 retval = device_create_file(dev, &dev_attr_inters);
1350 if (retval)
1351 goto rm_events;
1352 retval = device_create_file(dev, &dev_attr_port_test);
1353 if (retval)
1354 goto rm_inters;
1355 retval = device_create_file(dev, &dev_attr_qheads);
1356 if (retval)
1357 goto rm_port_test;
1358 retval = device_create_file(dev, &dev_attr_registers);
1359 if (retval)
1360 goto rm_qheads;
1361 retval = device_create_file(dev, &dev_attr_requests);
1362 if (retval)
1363 goto rm_registers;
1364 return 0;
1365
1366 rm_registers:
1367 device_remove_file(dev, &dev_attr_registers);
1368 rm_qheads:
1369 device_remove_file(dev, &dev_attr_qheads);
1370 rm_port_test:
1371 device_remove_file(dev, &dev_attr_port_test);
1372 rm_inters:
1373 device_remove_file(dev, &dev_attr_inters);
1374 rm_events:
1375 device_remove_file(dev, &dev_attr_events);
1376 rm_driver:
1377 device_remove_file(dev, &dev_attr_driver);
1378 rm_device:
1379 device_remove_file(dev, &dev_attr_device);
1380 done:
1381 return retval;
1382 }
1383
1384 /**
1385 * dbg_remove_files: destroys the attribute interface
1386 * @dev: device
1387 *
1388 * This function returns an error code
1389 */
1390 __maybe_unused static int dbg_remove_files(struct device *dev)
1391 {
1392 if (dev == NULL)
1393 return -EINVAL;
1394 device_remove_file(dev, &dev_attr_requests);
1395 device_remove_file(dev, &dev_attr_registers);
1396 device_remove_file(dev, &dev_attr_qheads);
1397 device_remove_file(dev, &dev_attr_port_test);
1398 device_remove_file(dev, &dev_attr_inters);
1399 device_remove_file(dev, &dev_attr_events);
1400 device_remove_file(dev, &dev_attr_driver);
1401 device_remove_file(dev, &dev_attr_device);
1402 return 0;
1403 }
1404
1405 /******************************************************************************
1406 * UTIL block
1407 *****************************************************************************/
1408 /**
1409 * _usb_addr: calculates endpoint address from direction & number
1410 * @ep: endpoint
1411 */
1412 static inline u8 _usb_addr(struct ci13xxx_ep *ep)
1413 {
1414 return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
1415 }
1416
1417 /**
1418 * _hardware_queue: configures a request at hardware level
1419 * @gadget: gadget
1420 * @mEp: endpoint
1421 *
1422 * This function returns an error code
1423 */
1424 static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
1425 {
1426 unsigned i;
1427
1428 trace("%p, %p", mEp, mReq);
1429
1430 /* don't queue twice */
1431 if (mReq->req.status == -EALREADY)
1432 return -EALREADY;
1433
1434 if (hw_ep_is_primed(mEp->num, mEp->dir))
1435 return -EBUSY;
1436
1437 mReq->req.status = -EALREADY;
1438
1439 if (mReq->req.length && !mReq->req.dma) {
1440 mReq->req.dma = \
1441 dma_map_single(mEp->device, mReq->req.buf,
1442 mReq->req.length, mEp->dir ?
1443 DMA_TO_DEVICE : DMA_FROM_DEVICE);
1444 if (mReq->req.dma == 0)
1445 return -ENOMEM;
1446
1447 mReq->map = 1;
1448 }
1449
1450 /*
1451 * TD configuration
1452 * TODO - handle requests which spawns into several TDs
1453 */
1454 memset(mReq->ptr, 0, sizeof(*mReq->ptr));
1455 mReq->ptr->next |= TD_TERMINATE;
1456 mReq->ptr->token = mReq->req.length << ffs_nr(TD_TOTAL_BYTES);
1457 mReq->ptr->token &= TD_TOTAL_BYTES;
1458 mReq->ptr->token |= TD_IOC;
1459 mReq->ptr->token |= TD_STATUS_ACTIVE;
1460 mReq->ptr->page[0] = mReq->req.dma;
1461 for (i = 1; i < 5; i++)
1462 mReq->ptr->page[i] =
1463 (mReq->req.dma + i * PAGE_SIZE) & ~TD_RESERVED_MASK;
1464
1465 /*
1466 * QH configuration
1467 * At this point it's guaranteed exclusive access to qhead
1468 * (endpt is not primed) so it's no need to use tripwire
1469 */
1470 mEp->qh[mEp->dir].ptr->td.next = mReq->dma; /* TERMINATE = 0 */
1471 mEp->qh[mEp->dir].ptr->td.token &= ~TD_STATUS; /* clear status */
1472 if (mReq->req.zero == 0)
1473 mEp->qh[mEp->dir].ptr->cap |= QH_ZLT;
1474 else
1475 mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
1476
1477 wmb(); /* synchronize before ep prime */
1478
1479 return hw_ep_prime(mEp->num, mEp->dir,
1480 mEp->type == USB_ENDPOINT_XFER_CONTROL);
1481 }
1482
1483 /**
1484 * _hardware_dequeue: handles a request at hardware level
1485 * @gadget: gadget
1486 * @mEp: endpoint
1487 *
1488 * This function returns an error code
1489 */
1490 static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
1491 {
1492 trace("%p, %p", mEp, mReq);
1493
1494 if (mReq->req.status != -EALREADY)
1495 return -EINVAL;
1496
1497 if (hw_ep_is_primed(mEp->num, mEp->dir))
1498 hw_ep_flush(mEp->num, mEp->dir);
1499
1500 mReq->req.status = 0;
1501
1502 if (mReq->map) {
1503 dma_unmap_single(mEp->device, mReq->req.dma, mReq->req.length,
1504 mEp->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
1505 mReq->req.dma = 0;
1506 mReq->map = 0;
1507 }
1508
1509 mReq->req.status = mReq->ptr->token & TD_STATUS;
1510 if ((TD_STATUS_ACTIVE & mReq->req.status) != 0)
1511 mReq->req.status = -ECONNRESET;
1512 else if ((TD_STATUS_HALTED & mReq->req.status) != 0)
1513 mReq->req.status = -1;
1514 else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
1515 mReq->req.status = -1;
1516 else if ((TD_STATUS_TR_ERR & mReq->req.status) != 0)
1517 mReq->req.status = -1;
1518
1519 mReq->req.actual = mReq->ptr->token & TD_TOTAL_BYTES;
1520 mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
1521 mReq->req.actual = mReq->req.length - mReq->req.actual;
1522 mReq->req.actual = mReq->req.status ? 0 : mReq->req.actual;
1523
1524 return mReq->req.actual;
1525 }
1526
1527 /**
1528 * _ep_nuke: dequeues all endpoint requests
1529 * @mEp: endpoint
1530 *
1531 * This function returns an error code
1532 * Caller must hold lock
1533 */
1534 static int _ep_nuke(struct ci13xxx_ep *mEp)
1535 __releases(mEp->lock)
1536 __acquires(mEp->lock)
1537 {
1538 trace("%p", mEp);
1539
1540 if (mEp == NULL)
1541 return -EINVAL;
1542
1543 hw_ep_flush(mEp->num, mEp->dir);
1544
1545 while (!list_empty(&mEp->qh[mEp->dir].queue)) {
1546
1547 /* pop oldest request */
1548 struct ci13xxx_req *mReq = \
1549 list_entry(mEp->qh[mEp->dir].queue.next,
1550 struct ci13xxx_req, queue);
1551 list_del_init(&mReq->queue);
1552 mReq->req.status = -ESHUTDOWN;
1553
1554 if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
1555 spin_unlock(mEp->lock);
1556 mReq->req.complete(&mEp->ep, &mReq->req);
1557 spin_lock(mEp->lock);
1558 }
1559 }
1560 return 0;
1561 }
1562
1563 /**
1564 * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
1565 * @gadget: gadget
1566 *
1567 * This function returns an error code
1568 * Caller must hold lock
1569 */
1570 static int _gadget_stop_activity(struct usb_gadget *gadget)
1571 {
1572 struct usb_ep *ep;
1573 struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget);
1574 struct ci13xxx_ep *mEp = container_of(gadget->ep0,
1575 struct ci13xxx_ep, ep);
1576
1577 trace("%p", gadget);
1578
1579 if (gadget == NULL)
1580 return -EINVAL;
1581
1582 /* flush all endpoints */
1583 gadget_for_each_ep(ep, gadget) {
1584 usb_ep_fifo_flush(ep);
1585 }
1586 usb_ep_fifo_flush(gadget->ep0);
1587
1588 udc->driver->disconnect(gadget);
1589
1590 /* make sure to disable all endpoints */
1591 gadget_for_each_ep(ep, gadget) {
1592 usb_ep_disable(ep);
1593 }
1594 usb_ep_disable(gadget->ep0);
1595
1596 if (mEp->status != NULL) {
1597 usb_ep_free_request(gadget->ep0, mEp->status);
1598 mEp->status = NULL;
1599 }
1600
1601 return 0;
1602 }
1603
1604 /******************************************************************************
1605 * ISR block
1606 *****************************************************************************/
1607 /**
1608 * isr_reset_handler: USB reset interrupt handler
1609 * @udc: UDC device
1610 *
1611 * This function resets USB engine after a bus reset occurred
1612 */
1613 static void isr_reset_handler(struct ci13xxx *udc)
1614 __releases(udc->lock)
1615 __acquires(udc->lock)
1616 {
1617 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[0];
1618 int retval;
1619
1620 trace("%p", udc);
1621
1622 if (udc == NULL) {
1623 err("EINVAL");
1624 return;
1625 }
1626
1627 dbg_event(0xFF, "BUS RST", 0);
1628
1629 spin_unlock(udc->lock);
1630 retval = _gadget_stop_activity(&udc->gadget);
1631 if (retval)
1632 goto done;
1633
1634 retval = hw_usb_reset();
1635 if (retval)
1636 goto done;
1637
1638 retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
1639 if (!retval) {
1640 mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_ATOMIC);
1641 if (mEp->status == NULL) {
1642 usb_ep_disable(&mEp->ep);
1643 retval = -ENOMEM;
1644 }
1645 }
1646 spin_lock(udc->lock);
1647
1648 done:
1649 if (retval)
1650 err("error: %i", retval);
1651 }
1652
1653 /**
1654 * isr_get_status_complete: get_status request complete function
1655 * @ep: endpoint
1656 * @req: request handled
1657 *
1658 * Caller must release lock
1659 */
1660 static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
1661 {
1662 trace("%p, %p", ep, req);
1663
1664 if (ep == NULL || req == NULL) {
1665 err("EINVAL");
1666 return;
1667 }
1668
1669 kfree(req->buf);
1670 usb_ep_free_request(ep, req);
1671 }
1672
1673 /**
1674 * isr_get_status_response: get_status request response
1675 * @ep: endpoint
1676 * @setup: setup request packet
1677 *
1678 * This function returns an error code
1679 */
1680 static int isr_get_status_response(struct ci13xxx_ep *mEp,
1681 struct usb_ctrlrequest *setup)
1682 __releases(mEp->lock)
1683 __acquires(mEp->lock)
1684 {
1685 struct usb_request *req = NULL;
1686 gfp_t gfp_flags = GFP_ATOMIC;
1687 int dir, num, retval;
1688
1689 trace("%p, %p", mEp, setup);
1690
1691 if (mEp == NULL || setup == NULL)
1692 return -EINVAL;
1693
1694 spin_unlock(mEp->lock);
1695 req = usb_ep_alloc_request(&mEp->ep, gfp_flags);
1696 spin_lock(mEp->lock);
1697 if (req == NULL)
1698 return -ENOMEM;
1699
1700 req->complete = isr_get_status_complete;
1701 req->length = 2;
1702 req->buf = kzalloc(req->length, gfp_flags);
1703 if (req->buf == NULL) {
1704 retval = -ENOMEM;
1705 goto err_free_req;
1706 }
1707
1708 if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
1709 /* TODO: D1 - Remote Wakeup; D0 - Self Powered */
1710 retval = 0;
1711 } else if ((setup->bRequestType & USB_RECIP_MASK) \
1712 == USB_RECIP_ENDPOINT) {
1713 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
1714 TX : RX;
1715 num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1716 *((u16 *)req->buf) = hw_ep_get_halt(num, dir);
1717 }
1718 /* else do nothing; reserved for future use */
1719
1720 spin_unlock(mEp->lock);
1721 retval = usb_ep_queue(&mEp->ep, req, gfp_flags);
1722 spin_lock(mEp->lock);
1723 if (retval)
1724 goto err_free_buf;
1725
1726 return 0;
1727
1728 err_free_buf:
1729 kfree(req->buf);
1730 err_free_req:
1731 spin_unlock(mEp->lock);
1732 usb_ep_free_request(&mEp->ep, req);
1733 spin_lock(mEp->lock);
1734 return retval;
1735 }
1736
1737 /**
1738 * isr_setup_status_phase: queues the status phase of a setup transation
1739 * @mEp: endpoint
1740 *
1741 * This function returns an error code
1742 */
1743 static int isr_setup_status_phase(struct ci13xxx_ep *mEp)
1744 __releases(mEp->lock)
1745 __acquires(mEp->lock)
1746 {
1747 int retval;
1748
1749 trace("%p", mEp);
1750
1751 /* mEp is always valid & configured */
1752
1753 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1754 mEp->dir = (mEp->dir == TX) ? RX : TX;
1755
1756 mEp->status->no_interrupt = 1;
1757
1758 spin_unlock(mEp->lock);
1759 retval = usb_ep_queue(&mEp->ep, mEp->status, GFP_ATOMIC);
1760 spin_lock(mEp->lock);
1761
1762 return retval;
1763 }
1764
1765 /**
1766 * isr_tr_complete_low: transaction complete low level handler
1767 * @mEp: endpoint
1768 *
1769 * This function returns an error code
1770 * Caller must hold lock
1771 */
1772 static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
1773 __releases(mEp->lock)
1774 __acquires(mEp->lock)
1775 {
1776 struct ci13xxx_req *mReq;
1777 int retval;
1778
1779 trace("%p", mEp);
1780
1781 if (list_empty(&mEp->qh[mEp->dir].queue))
1782 return -EINVAL;
1783
1784 /* pop oldest request */
1785 mReq = list_entry(mEp->qh[mEp->dir].queue.next,
1786 struct ci13xxx_req, queue);
1787 list_del_init(&mReq->queue);
1788
1789 retval = _hardware_dequeue(mEp, mReq);
1790 if (retval < 0) {
1791 dbg_event(_usb_addr(mEp), "DONE", retval);
1792 goto done;
1793 }
1794
1795 dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
1796
1797 if (!list_empty(&mEp->qh[mEp->dir].queue)) {
1798 struct ci13xxx_req* mReqEnq;
1799
1800 mReqEnq = list_entry(mEp->qh[mEp->dir].queue.next,
1801 struct ci13xxx_req, queue);
1802 _hardware_enqueue(mEp, mReqEnq);
1803 }
1804
1805 if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
1806 spin_unlock(mEp->lock);
1807 mReq->req.complete(&mEp->ep, &mReq->req);
1808 spin_lock(mEp->lock);
1809 }
1810
1811 done:
1812 return retval;
1813 }
1814
1815 /**
1816 * isr_tr_complete_handler: transaction complete interrupt handler
1817 * @udc: UDC descriptor
1818 *
1819 * This function handles traffic events
1820 */
1821 static void isr_tr_complete_handler(struct ci13xxx *udc)
1822 __releases(udc->lock)
1823 __acquires(udc->lock)
1824 {
1825 unsigned i;
1826
1827 trace("%p", udc);
1828
1829 if (udc == NULL) {
1830 err("EINVAL");
1831 return;
1832 }
1833
1834 for (i = 0; i < hw_ep_max; i++) {
1835 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
1836 int type, num, err = -EINVAL;
1837 struct usb_ctrlrequest req;
1838
1839
1840 if (mEp->desc == NULL)
1841 continue; /* not configured */
1842
1843 if ((mEp->dir == RX && hw_test_and_clear_complete(i)) ||
1844 (mEp->dir == TX && hw_test_and_clear_complete(i + 16))) {
1845 err = isr_tr_complete_low(mEp);
1846 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
1847 if (err > 0) /* needs status phase */
1848 err = isr_setup_status_phase(mEp);
1849 if (err < 0) {
1850 dbg_event(_usb_addr(mEp),
1851 "ERROR", err);
1852 spin_unlock(udc->lock);
1853 if (usb_ep_set_halt(&mEp->ep))
1854 err("error: ep_set_halt");
1855 spin_lock(udc->lock);
1856 }
1857 }
1858 }
1859
1860 if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
1861 !hw_test_and_clear_setup_status(i))
1862 continue;
1863
1864 if (i != 0) {
1865 warn("ctrl traffic received at endpoint");
1866 continue;
1867 }
1868
1869 /* read_setup_packet */
1870 do {
1871 hw_test_and_set_setup_guard();
1872 memcpy(&req, &mEp->qh[RX].ptr->setup, sizeof(req));
1873 } while (!hw_test_and_clear_setup_guard());
1874
1875 type = req.bRequestType;
1876
1877 mEp->dir = (type & USB_DIR_IN) ? TX : RX;
1878
1879 dbg_setup(_usb_addr(mEp), &req);
1880
1881 switch (req.bRequest) {
1882 case USB_REQ_CLEAR_FEATURE:
1883 if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1884 le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
1885 goto delegate;
1886 if (req.wLength != 0)
1887 break;
1888 num = le16_to_cpu(req.wIndex);
1889 num &= USB_ENDPOINT_NUMBER_MASK;
1890 if (!udc->ci13xxx_ep[num].wedge) {
1891 spin_unlock(udc->lock);
1892 err = usb_ep_clear_halt(
1893 &udc->ci13xxx_ep[num].ep);
1894 spin_lock(udc->lock);
1895 if (err)
1896 break;
1897 }
1898 err = isr_setup_status_phase(mEp);
1899 break;
1900 case USB_REQ_GET_STATUS:
1901 if (type != (USB_DIR_IN|USB_RECIP_DEVICE) &&
1902 type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
1903 type != (USB_DIR_IN|USB_RECIP_INTERFACE))
1904 goto delegate;
1905 if (le16_to_cpu(req.wLength) != 2 ||
1906 le16_to_cpu(req.wValue) != 0)
1907 break;
1908 err = isr_get_status_response(mEp, &req);
1909 break;
1910 case USB_REQ_SET_ADDRESS:
1911 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
1912 goto delegate;
1913 if (le16_to_cpu(req.wLength) != 0 ||
1914 le16_to_cpu(req.wIndex) != 0)
1915 break;
1916 err = hw_usb_set_address((u8)le16_to_cpu(req.wValue));
1917 if (err)
1918 break;
1919 err = isr_setup_status_phase(mEp);
1920 break;
1921 case USB_REQ_SET_FEATURE:
1922 if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1923 le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
1924 goto delegate;
1925 if (req.wLength != 0)
1926 break;
1927 num = le16_to_cpu(req.wIndex);
1928 num &= USB_ENDPOINT_NUMBER_MASK;
1929
1930 spin_unlock(udc->lock);
1931 err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
1932 spin_lock(udc->lock);
1933 if (err)
1934 break;
1935 err = isr_setup_status_phase(mEp);
1936 break;
1937 default:
1938 delegate:
1939 if (req.wLength == 0) /* no data phase */
1940 mEp->dir = TX;
1941
1942 spin_unlock(udc->lock);
1943 err = udc->driver->setup(&udc->gadget, &req);
1944 spin_lock(udc->lock);
1945 break;
1946 }
1947
1948 if (err < 0) {
1949 dbg_event(_usb_addr(mEp), "ERROR", err);
1950
1951 spin_unlock(udc->lock);
1952 if (usb_ep_set_halt(&mEp->ep))
1953 err("error: ep_set_halt");
1954 spin_lock(udc->lock);
1955 }
1956 }
1957 }
1958
1959 /******************************************************************************
1960 * ENDPT block
1961 *****************************************************************************/
1962 /**
1963 * ep_enable: configure endpoint, making it usable
1964 *
1965 * Check usb_ep_enable() at "usb_gadget.h" for details
1966 */
1967 static int ep_enable(struct usb_ep *ep,
1968 const struct usb_endpoint_descriptor *desc)
1969 {
1970 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1971 int direction, retval = 0;
1972 unsigned long flags;
1973
1974 trace("%p, %p", ep, desc);
1975
1976 if (ep == NULL || desc == NULL)
1977 return -EINVAL;
1978
1979 spin_lock_irqsave(mEp->lock, flags);
1980
1981 /* only internal SW should enable ctrl endpts */
1982
1983 mEp->desc = desc;
1984
1985 if (!list_empty(&mEp->qh[mEp->dir].queue))
1986 warn("enabling a non-empty endpoint!");
1987
1988 mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX;
1989 mEp->num = usb_endpoint_num(desc);
1990 mEp->type = usb_endpoint_type(desc);
1991
1992 mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize);
1993
1994 direction = mEp->dir;
1995 do {
1996 dbg_event(_usb_addr(mEp), "ENABLE", 0);
1997
1998 mEp->qh[mEp->dir].ptr->cap = 0;
1999
2000 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2001 mEp->qh[mEp->dir].ptr->cap |= QH_IOS;
2002 else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
2003 mEp->qh[mEp->dir].ptr->cap &= ~QH_MULT;
2004 else
2005 mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
2006
2007 mEp->qh[mEp->dir].ptr->cap |=
2008 (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
2009 mEp->qh[mEp->dir].ptr->td.next |= TD_TERMINATE; /* needed? */
2010
2011 retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
2012
2013 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2014 mEp->dir = (mEp->dir == TX) ? RX : TX;
2015
2016 } while (mEp->dir != direction);
2017
2018 spin_unlock_irqrestore(mEp->lock, flags);
2019 return retval;
2020 }
2021
2022 /**
2023 * ep_disable: endpoint is no longer usable
2024 *
2025 * Check usb_ep_disable() at "usb_gadget.h" for details
2026 */
2027 static int ep_disable(struct usb_ep *ep)
2028 {
2029 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2030 int direction, retval = 0;
2031 unsigned long flags;
2032
2033 trace("%p", ep);
2034
2035 if (ep == NULL)
2036 return -EINVAL;
2037 else if (mEp->desc == NULL)
2038 return -EBUSY;
2039
2040 spin_lock_irqsave(mEp->lock, flags);
2041
2042 /* only internal SW should disable ctrl endpts */
2043
2044 direction = mEp->dir;
2045 do {
2046 dbg_event(_usb_addr(mEp), "DISABLE", 0);
2047
2048 retval |= _ep_nuke(mEp);
2049 retval |= hw_ep_disable(mEp->num, mEp->dir);
2050
2051 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2052 mEp->dir = (mEp->dir == TX) ? RX : TX;
2053
2054 } while (mEp->dir != direction);
2055
2056 mEp->desc = NULL;
2057
2058 spin_unlock_irqrestore(mEp->lock, flags);
2059 return retval;
2060 }
2061
2062 /**
2063 * ep_alloc_request: allocate a request object to use with this endpoint
2064 *
2065 * Check usb_ep_alloc_request() at "usb_gadget.h" for details
2066 */
2067 static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
2068 {
2069 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2070 struct ci13xxx_req *mReq = NULL;
2071
2072 trace("%p, %i", ep, gfp_flags);
2073
2074 if (ep == NULL) {
2075 err("EINVAL");
2076 return NULL;
2077 }
2078
2079 mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
2080 if (mReq != NULL) {
2081 INIT_LIST_HEAD(&mReq->queue);
2082
2083 mReq->ptr = dma_pool_alloc(mEp->td_pool, gfp_flags,
2084 &mReq->dma);
2085 if (mReq->ptr == NULL) {
2086 kfree(mReq);
2087 mReq = NULL;
2088 }
2089 }
2090
2091 dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
2092
2093 return (mReq == NULL) ? NULL : &mReq->req;
2094 }
2095
2096 /**
2097 * ep_free_request: frees a request object
2098 *
2099 * Check usb_ep_free_request() at "usb_gadget.h" for details
2100 */
2101 static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
2102 {
2103 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2104 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2105 unsigned long flags;
2106
2107 trace("%p, %p", ep, req);
2108
2109 if (ep == NULL || req == NULL) {
2110 err("EINVAL");
2111 return;
2112 } else if (!list_empty(&mReq->queue)) {
2113 err("EBUSY");
2114 return;
2115 }
2116
2117 spin_lock_irqsave(mEp->lock, flags);
2118
2119 if (mReq->ptr)
2120 dma_pool_free(mEp->td_pool, mReq->ptr, mReq->dma);
2121 kfree(mReq);
2122
2123 dbg_event(_usb_addr(mEp), "FREE", 0);
2124
2125 spin_unlock_irqrestore(mEp->lock, flags);
2126 }
2127
2128 /**
2129 * ep_queue: queues (submits) an I/O request to an endpoint
2130 *
2131 * Check usb_ep_queue()* at usb_gadget.h" for details
2132 */
2133 static int ep_queue(struct usb_ep *ep, struct usb_request *req,
2134 gfp_t __maybe_unused gfp_flags)
2135 {
2136 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2137 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2138 int retval = 0;
2139 unsigned long flags;
2140
2141 trace("%p, %p, %X", ep, req, gfp_flags);
2142
2143 if (ep == NULL || req == NULL || mEp->desc == NULL)
2144 return -EINVAL;
2145
2146 spin_lock_irqsave(mEp->lock, flags);
2147
2148 if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
2149 !list_empty(&mEp->qh[mEp->dir].queue)) {
2150 _ep_nuke(mEp);
2151 retval = -EOVERFLOW;
2152 warn("endpoint ctrl %X nuked", _usb_addr(mEp));
2153 }
2154
2155 /* first nuke then test link, e.g. previous status has not sent */
2156 if (!list_empty(&mReq->queue)) {
2157 retval = -EBUSY;
2158 err("request already in queue");
2159 goto done;
2160 }
2161
2162 if (req->length > (4 * PAGE_SIZE)) {
2163 req->length = (4 * PAGE_SIZE);
2164 retval = -EMSGSIZE;
2165 warn("request length truncated");
2166 }
2167
2168 dbg_queue(_usb_addr(mEp), req, retval);
2169
2170 /* push request */
2171 mReq->req.status = -EINPROGRESS;
2172 mReq->req.actual = 0;
2173 list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
2174
2175 if (list_is_singular(&mEp->qh[mEp->dir].queue))
2176 retval = _hardware_enqueue(mEp, mReq);
2177
2178 if (retval == -EALREADY) {
2179 dbg_event(_usb_addr(mEp), "QUEUE", retval);
2180 retval = 0;
2181 }
2182
2183 done:
2184 spin_unlock_irqrestore(mEp->lock, flags);
2185 return retval;
2186 }
2187
2188 /**
2189 * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
2190 *
2191 * Check usb_ep_dequeue() at "usb_gadget.h" for details
2192 */
2193 static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
2194 {
2195 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2196 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2197 unsigned long flags;
2198
2199 trace("%p, %p", ep, req);
2200
2201 if (ep == NULL || req == NULL || mEp->desc == NULL ||
2202 list_empty(&mReq->queue) || list_empty(&mEp->qh[mEp->dir].queue))
2203 return -EINVAL;
2204
2205 spin_lock_irqsave(mEp->lock, flags);
2206
2207 dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
2208
2209 if (mReq->req.status == -EALREADY)
2210 _hardware_dequeue(mEp, mReq);
2211
2212 /* pop request */
2213 list_del_init(&mReq->queue);
2214 req->status = -ECONNRESET;
2215
2216 if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
2217 spin_unlock(mEp->lock);
2218 mReq->req.complete(&mEp->ep, &mReq->req);
2219 spin_lock(mEp->lock);
2220 }
2221
2222 spin_unlock_irqrestore(mEp->lock, flags);
2223 return 0;
2224 }
2225
2226 /**
2227 * ep_set_halt: sets the endpoint halt feature
2228 *
2229 * Check usb_ep_set_halt() at "usb_gadget.h" for details
2230 */
2231 static int ep_set_halt(struct usb_ep *ep, int value)
2232 {
2233 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2234 int direction, retval = 0;
2235 unsigned long flags;
2236
2237 trace("%p, %i", ep, value);
2238
2239 if (ep == NULL || mEp->desc == NULL)
2240 return -EINVAL;
2241
2242 spin_lock_irqsave(mEp->lock, flags);
2243
2244 #ifndef STALL_IN
2245 /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
2246 if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
2247 !list_empty(&mEp->qh[mEp->dir].queue)) {
2248 spin_unlock_irqrestore(mEp->lock, flags);
2249 return -EAGAIN;
2250 }
2251 #endif
2252
2253 direction = mEp->dir;
2254 do {
2255 dbg_event(_usb_addr(mEp), "HALT", value);
2256 retval |= hw_ep_set_halt(mEp->num, mEp->dir, value);
2257
2258 if (!value)
2259 mEp->wedge = 0;
2260
2261 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2262 mEp->dir = (mEp->dir == TX) ? RX : TX;
2263
2264 } while (mEp->dir != direction);
2265
2266 spin_unlock_irqrestore(mEp->lock, flags);
2267 return retval;
2268 }
2269
2270 /**
2271 * ep_set_wedge: sets the halt feature and ignores clear requests
2272 *
2273 * Check usb_ep_set_wedge() at "usb_gadget.h" for details
2274 */
2275 static int ep_set_wedge(struct usb_ep *ep)
2276 {
2277 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2278 unsigned long flags;
2279
2280 trace("%p", ep);
2281
2282 if (ep == NULL || mEp->desc == NULL)
2283 return -EINVAL;
2284
2285 spin_lock_irqsave(mEp->lock, flags);
2286
2287 dbg_event(_usb_addr(mEp), "WEDGE", 0);
2288 mEp->wedge = 1;
2289
2290 spin_unlock_irqrestore(mEp->lock, flags);
2291
2292 return usb_ep_set_halt(ep);
2293 }
2294
2295 /**
2296 * ep_fifo_flush: flushes contents of a fifo
2297 *
2298 * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
2299 */
2300 static void ep_fifo_flush(struct usb_ep *ep)
2301 {
2302 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2303 unsigned long flags;
2304
2305 trace("%p", ep);
2306
2307 if (ep == NULL) {
2308 err("%02X: -EINVAL", _usb_addr(mEp));
2309 return;
2310 }
2311
2312 spin_lock_irqsave(mEp->lock, flags);
2313
2314 dbg_event(_usb_addr(mEp), "FFLUSH", 0);
2315 hw_ep_flush(mEp->num, mEp->dir);
2316
2317 spin_unlock_irqrestore(mEp->lock, flags);
2318 }
2319
2320 /**
2321 * Endpoint-specific part of the API to the USB controller hardware
2322 * Check "usb_gadget.h" for details
2323 */
2324 static const struct usb_ep_ops usb_ep_ops = {
2325 .enable = ep_enable,
2326 .disable = ep_disable,
2327 .alloc_request = ep_alloc_request,
2328 .free_request = ep_free_request,
2329 .queue = ep_queue,
2330 .dequeue = ep_dequeue,
2331 .set_halt = ep_set_halt,
2332 .set_wedge = ep_set_wedge,
2333 .fifo_flush = ep_fifo_flush,
2334 };
2335
2336 /******************************************************************************
2337 * GADGET block
2338 *****************************************************************************/
2339 static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
2340 {
2341 struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
2342 unsigned long flags;
2343 int gadget_ready = 0;
2344
2345 if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS))
2346 return -EOPNOTSUPP;
2347
2348 spin_lock_irqsave(udc->lock, flags);
2349 udc->vbus_active = is_active;
2350 if (udc->driver)
2351 gadget_ready = 1;
2352 spin_unlock_irqrestore(udc->lock, flags);
2353
2354 if (gadget_ready) {
2355 if (is_active) {
2356 pm_runtime_get_sync(&_gadget->dev);
2357 hw_device_reset(udc);
2358 hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
2359 } else {
2360 hw_device_state(0);
2361 if (udc->udc_driver->notify_event)
2362 udc->udc_driver->notify_event(udc,
2363 CI13XXX_CONTROLLER_STOPPED_EVENT);
2364 _gadget_stop_activity(&udc->gadget);
2365 pm_runtime_put_sync(&_gadget->dev);
2366 }
2367 }
2368
2369 return 0;
2370 }
2371
2372 /**
2373 * Device operations part of the API to the USB controller hardware,
2374 * which don't involve endpoints (or i/o)
2375 * Check "usb_gadget.h" for details
2376 */
2377 static const struct usb_gadget_ops usb_gadget_ops = {
2378 .vbus_session = ci13xxx_vbus_session,
2379 };
2380
2381 /**
2382 * usb_gadget_probe_driver: register a gadget driver
2383 * @driver: the driver being registered
2384 * @bind: the driver's bind callback
2385 *
2386 * Check usb_gadget_probe_driver() at <linux/usb/gadget.h> for details.
2387 * Interrupts are enabled here.
2388 */
2389 int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
2390 int (*bind)(struct usb_gadget *))
2391 {
2392 struct ci13xxx *udc = _udc;
2393 unsigned long i, k, flags;
2394 int retval = -ENOMEM;
2395
2396 trace("%p", driver);
2397
2398 if (driver == NULL ||
2399 bind == NULL ||
2400 driver->setup == NULL ||
2401 driver->disconnect == NULL ||
2402 driver->suspend == NULL ||
2403 driver->resume == NULL)
2404 return -EINVAL;
2405 else if (udc == NULL)
2406 return -ENODEV;
2407 else if (udc->driver != NULL)
2408 return -EBUSY;
2409
2410 /* alloc resources */
2411 udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
2412 sizeof(struct ci13xxx_qh),
2413 64, PAGE_SIZE);
2414 if (udc->qh_pool == NULL)
2415 return -ENOMEM;
2416
2417 udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
2418 sizeof(struct ci13xxx_td),
2419 64, PAGE_SIZE);
2420 if (udc->td_pool == NULL) {
2421 dma_pool_destroy(udc->qh_pool);
2422 udc->qh_pool = NULL;
2423 return -ENOMEM;
2424 }
2425
2426 spin_lock_irqsave(udc->lock, flags);
2427
2428 info("hw_ep_max = %d", hw_ep_max);
2429
2430 udc->driver = driver;
2431 udc->gadget.dev.driver = NULL;
2432
2433 retval = 0;
2434 for (i = 0; i < hw_ep_max; i++) {
2435 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
2436
2437 scnprintf(mEp->name, sizeof(mEp->name), "ep%i", (int)i);
2438
2439 mEp->lock = udc->lock;
2440 mEp->device = &udc->gadget.dev;
2441 mEp->td_pool = udc->td_pool;
2442
2443 mEp->ep.name = mEp->name;
2444 mEp->ep.ops = &usb_ep_ops;
2445 mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
2446
2447 /* this allocation cannot be random */
2448 for (k = RX; k <= TX; k++) {
2449 INIT_LIST_HEAD(&mEp->qh[k].queue);
2450 spin_unlock_irqrestore(udc->lock, flags);
2451 mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
2452 GFP_KERNEL,
2453 &mEp->qh[k].dma);
2454 spin_lock_irqsave(udc->lock, flags);
2455 if (mEp->qh[k].ptr == NULL)
2456 retval = -ENOMEM;
2457 else
2458 memset(mEp->qh[k].ptr, 0,
2459 sizeof(*mEp->qh[k].ptr));
2460 }
2461 if (i == 0)
2462 udc->gadget.ep0 = &mEp->ep;
2463 else
2464 list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
2465 }
2466 if (retval)
2467 goto done;
2468
2469 /* bind gadget */
2470 driver->driver.bus = NULL;
2471 udc->gadget.dev.driver = &driver->driver;
2472
2473 spin_unlock_irqrestore(udc->lock, flags);
2474 retval = bind(&udc->gadget); /* MAY SLEEP */
2475 spin_lock_irqsave(udc->lock, flags);
2476
2477 if (retval) {
2478 udc->gadget.dev.driver = NULL;
2479 goto done;
2480 }
2481
2482 pm_runtime_get_sync(&udc->gadget.dev);
2483 if (udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) {
2484 if (udc->vbus_active) {
2485 if (udc->udc_driver->flags & CI13XXX_REGS_SHARED)
2486 hw_device_reset(udc);
2487 } else {
2488 pm_runtime_put_sync(&udc->gadget.dev);
2489 goto done;
2490 }
2491 }
2492
2493 retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
2494 if (retval)
2495 pm_runtime_put_sync(&udc->gadget.dev);
2496
2497 done:
2498 spin_unlock_irqrestore(udc->lock, flags);
2499 if (retval)
2500 usb_gadget_unregister_driver(driver);
2501 return retval;
2502 }
2503 EXPORT_SYMBOL(usb_gadget_probe_driver);
2504
2505 /**
2506 * usb_gadget_unregister_driver: unregister a gadget driver
2507 *
2508 * Check usb_gadget_unregister_driver() at "usb_gadget.h" for details
2509 */
2510 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
2511 {
2512 struct ci13xxx *udc = _udc;
2513 unsigned long i, k, flags;
2514
2515 trace("%p", driver);
2516
2517 if (driver == NULL ||
2518 driver->unbind == NULL ||
2519 driver->setup == NULL ||
2520 driver->disconnect == NULL ||
2521 driver->suspend == NULL ||
2522 driver->resume == NULL ||
2523 driver != udc->driver)
2524 return -EINVAL;
2525
2526 spin_lock_irqsave(udc->lock, flags);
2527
2528 if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) ||
2529 udc->vbus_active) {
2530 hw_device_state(0);
2531 if (udc->udc_driver->notify_event)
2532 udc->udc_driver->notify_event(udc,
2533 CI13XXX_CONTROLLER_STOPPED_EVENT);
2534 _gadget_stop_activity(&udc->gadget);
2535 pm_runtime_put(&udc->gadget.dev);
2536 }
2537
2538 /* unbind gadget */
2539 spin_unlock_irqrestore(udc->lock, flags);
2540 driver->unbind(&udc->gadget); /* MAY SLEEP */
2541 spin_lock_irqsave(udc->lock, flags);
2542
2543 udc->gadget.dev.driver = NULL;
2544
2545 /* free resources */
2546 for (i = 0; i < hw_ep_max; i++) {
2547 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
2548
2549 if (i == 0)
2550 udc->gadget.ep0 = NULL;
2551 else if (!list_empty(&mEp->ep.ep_list))
2552 list_del_init(&mEp->ep.ep_list);
2553
2554 for (k = RX; k <= TX; k++)
2555 if (mEp->qh[k].ptr != NULL)
2556 dma_pool_free(udc->qh_pool,
2557 mEp->qh[k].ptr, mEp->qh[k].dma);
2558 }
2559
2560 udc->driver = NULL;
2561
2562 spin_unlock_irqrestore(udc->lock, flags);
2563
2564 if (udc->td_pool != NULL) {
2565 dma_pool_destroy(udc->td_pool);
2566 udc->td_pool = NULL;
2567 }
2568 if (udc->qh_pool != NULL) {
2569 dma_pool_destroy(udc->qh_pool);
2570 udc->qh_pool = NULL;
2571 }
2572
2573 return 0;
2574 }
2575 EXPORT_SYMBOL(usb_gadget_unregister_driver);
2576
2577 /******************************************************************************
2578 * BUS block
2579 *****************************************************************************/
2580 /**
2581 * udc_irq: global interrupt handler
2582 *
2583 * This function returns IRQ_HANDLED if the IRQ has been handled
2584 * It locks access to registers
2585 */
2586 static irqreturn_t udc_irq(void)
2587 {
2588 struct ci13xxx *udc = _udc;
2589 irqreturn_t retval;
2590 u32 intr;
2591
2592 trace();
2593
2594 if (udc == NULL) {
2595 err("ENODEV");
2596 return IRQ_HANDLED;
2597 }
2598
2599 spin_lock(udc->lock);
2600
2601 if (udc->udc_driver->flags & CI13XXX_REGS_SHARED) {
2602 if (hw_cread(CAP_USBMODE, USBMODE_CM) !=
2603 USBMODE_CM_DEVICE) {
2604 spin_unlock(udc->lock);
2605 return IRQ_NONE;
2606 }
2607 }
2608 intr = hw_test_and_clear_intr_active();
2609 if (intr) {
2610 isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
2611 isr_statistics.hndl.idx &= ISR_MASK;
2612 isr_statistics.hndl.cnt++;
2613
2614 /* order defines priority - do NOT change it */
2615 if (USBi_URI & intr) {
2616 isr_statistics.uri++;
2617 isr_reset_handler(udc);
2618 }
2619 if (USBi_PCI & intr) {
2620 isr_statistics.pci++;
2621 udc->gadget.speed = hw_port_is_high_speed() ?
2622 USB_SPEED_HIGH : USB_SPEED_FULL;
2623 }
2624 if (USBi_UEI & intr)
2625 isr_statistics.uei++;
2626 if (USBi_UI & intr) {
2627 isr_statistics.ui++;
2628 isr_tr_complete_handler(udc);
2629 }
2630 if (USBi_SLI & intr)
2631 isr_statistics.sli++;
2632 retval = IRQ_HANDLED;
2633 } else {
2634 isr_statistics.none++;
2635 retval = IRQ_NONE;
2636 }
2637 spin_unlock(udc->lock);
2638
2639 return retval;
2640 }
2641
2642 /**
2643 * udc_release: driver release function
2644 * @dev: device
2645 *
2646 * Currently does nothing
2647 */
2648 static void udc_release(struct device *dev)
2649 {
2650 trace("%p", dev);
2651
2652 if (dev == NULL)
2653 err("EINVAL");
2654 }
2655
2656 /**
2657 * udc_probe: parent probe must call this to initialize UDC
2658 * @dev: parent device
2659 * @regs: registers base address
2660 * @name: driver name
2661 *
2662 * This function returns an error code
2663 * No interrupts active, the IRQ has not been requested yet
2664 * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
2665 */
2666 static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
2667 void __iomem *regs)
2668 {
2669 struct ci13xxx *udc;
2670 int retval = 0;
2671
2672 trace("%p, %p, %p", dev, regs, name);
2673
2674 if (dev == NULL || regs == NULL || driver == NULL ||
2675 driver->name == NULL)
2676 return -EINVAL;
2677
2678 udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
2679 if (udc == NULL)
2680 return -ENOMEM;
2681
2682 udc->lock = &udc_lock;
2683 udc->regs = regs;
2684 udc->udc_driver = driver;
2685
2686 udc->gadget.ops = &usb_gadget_ops;
2687 udc->gadget.speed = USB_SPEED_UNKNOWN;
2688 udc->gadget.is_dualspeed = 1;
2689 udc->gadget.is_otg = 0;
2690 udc->gadget.name = driver->name;
2691
2692 INIT_LIST_HEAD(&udc->gadget.ep_list);
2693 udc->gadget.ep0 = NULL;
2694
2695 dev_set_name(&udc->gadget.dev, "gadget");
2696 udc->gadget.dev.dma_mask = dev->dma_mask;
2697 udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
2698 udc->gadget.dev.parent = dev;
2699 udc->gadget.dev.release = udc_release;
2700
2701 retval = hw_device_init(regs);
2702 if (retval < 0)
2703 goto free_udc;
2704
2705 udc->transceiver = otg_get_transceiver();
2706
2707 if (udc->udc_driver->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
2708 if (udc->transceiver == NULL) {
2709 retval = -ENODEV;
2710 goto free_udc;
2711 }
2712 }
2713
2714 if (!(udc->udc_driver->flags & CI13XXX_REGS_SHARED)) {
2715 retval = hw_device_reset(udc);
2716 if (retval)
2717 goto put_transceiver;
2718 }
2719
2720 retval = device_register(&udc->gadget.dev);
2721 if (retval) {
2722 put_device(&udc->gadget.dev);
2723 goto put_transceiver;
2724 }
2725
2726 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2727 retval = dbg_create_files(&udc->gadget.dev);
2728 #endif
2729 if (retval)
2730 goto unreg_device;
2731
2732 if (udc->transceiver) {
2733 retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
2734 if (retval)
2735 goto remove_dbg;
2736 }
2737 pm_runtime_no_callbacks(&udc->gadget.dev);
2738 pm_runtime_enable(&udc->gadget.dev);
2739
2740 _udc = udc;
2741 return retval;
2742
2743 err("error = %i", retval);
2744 remove_dbg:
2745 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2746 dbg_remove_files(&udc->gadget.dev);
2747 #endif
2748 unreg_device:
2749 device_unregister(&udc->gadget.dev);
2750 put_transceiver:
2751 if (udc->transceiver)
2752 otg_put_transceiver(udc->transceiver);
2753 free_udc:
2754 kfree(udc);
2755 _udc = NULL;
2756 return retval;
2757 }
2758
2759 /**
2760 * udc_remove: parent remove must call this to remove UDC
2761 *
2762 * No interrupts active, the IRQ has been released
2763 */
2764 static void udc_remove(void)
2765 {
2766 struct ci13xxx *udc = _udc;
2767
2768 if (udc == NULL) {
2769 err("EINVAL");
2770 return;
2771 }
2772
2773 if (udc->transceiver) {
2774 otg_set_peripheral(udc->transceiver, &udc->gadget);
2775 otg_put_transceiver(udc->transceiver);
2776 }
2777 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2778 dbg_remove_files(&udc->gadget.dev);
2779 #endif
2780 device_unregister(&udc->gadget.dev);
2781
2782 kfree(udc);
2783 _udc = NULL;
2784 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree