diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-06-16 16:06:10 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-06-16 16:06:10 -0400 |
commit | e1f5b94fd0c93c3e27ede88b7ab652d086dc960f (patch) | |
tree | e8de7a132eb88521dd1c19e128eba2d5349bdf4f | |
parent | 6fd03301d76bc439382710e449f58efbb233df1b (diff) | |
parent | 1b6ed69f974f6f32c8be0d9a7fc952822eb83b6f (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (143 commits)
USB: xhci depends on PCI.
USB: xhci: Add Makefile, MAINTAINERS, and Kconfig entries.
USB: xhci: Respect critical sections.
USB: xHCI: Fix interrupt moderation.
USB: xhci: Remove packed attribute from structures.
usb; xhci: Fix TRB offset calculations.
USB: xhci: replace if-elseif-else with switch-case
USB: xhci: Make xhci-mem.c include linux/dmapool.h
USB: xhci: drop spinlock in xhci_urb_enqueue() error path.
USB: Change names of SuperSpeed ep companion descriptor structs.
USB: xhci: Avoid compiler reordering in Link TRB giveback.
USB: xhci: Clean up xhci_irq() function.
USB: xhci: Avoid global namespace pollution.
USB: xhci: Fix Link TRB handoff bit twiddling.
USB: xhci: Fix register write order.
USB: xhci: fix some compiler warnings in xhci.h
USB: xhci: fix lots of compiler warnings.
USB: xhci: use xhci_handle_event instead of handle_event
USB: xhci: URB cancellation support.
USB: xhci: Scatter gather list support for bulk transfers.
...
164 files changed, 20947 insertions, 2080 deletions
diff --git a/MAINTAINERS b/MAINTAINERS index 09f6b3e5708a..685784cc023b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS | |||
@@ -6165,6 +6165,12 @@ L: linux-wireless@vger.kernel.org | |||
6165 | S: Maintained | 6165 | S: Maintained |
6166 | F: drivers/net/wireless/rndis_wlan.c | 6166 | F: drivers/net/wireless/rndis_wlan.c |
6167 | 6167 | ||
6168 | USB XHCI DRIVER | ||
6169 | P: Sarah Sharp | ||
6170 | M: sarah.a.sharp@intel.com | ||
6171 | L: linux-usb@vger.kernel.org | ||
6172 | S: Supported | ||
6173 | |||
6168 | USB ZC0301 DRIVER | 6174 | USB ZC0301 DRIVER |
6169 | P: Luca Risolia | 6175 | P: Luca Risolia |
6170 | M: luca.risolia@studio.unibo.it | 6176 | M: luca.risolia@studio.unibo.it |
diff --git a/arch/arm/plat-s3c/include/plat/regs-usb-hsotg-phy.h b/arch/arm/plat-s3c/include/plat/regs-usb-hsotg-phy.h new file mode 100644 index 000000000000..36a85f5000c8 --- /dev/null +++ b/arch/arm/plat-s3c/include/plat/regs-usb-hsotg-phy.h | |||
@@ -0,0 +1,50 @@ | |||
1 | /* arch/arm/plat-s3c/include/plat/regs-usb-hsotg-phy.h | ||
2 | * | ||
3 | * Copyright 2008 Openmoko, Inc. | ||
4 | * Copyright 2008 Simtec Electronics | ||
5 | * http://armlinux.simtec.co.uk/ | ||
6 | * Ben Dooks <ben@simtec.co.uk> | ||
7 | * | ||
8 | * S3C - USB2.0 Highspeed/OtG device PHY registers | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License version 2 as | ||
12 | * published by the Free Software Foundation. | ||
13 | */ | ||
14 | |||
15 | /* Note, this is a seperate header file as some of the clock framework | ||
16 | * needs to touch this if the clk_48m is used as the USB OHCI or other | ||
17 | * peripheral source. | ||
18 | */ | ||
19 | |||
20 | #ifndef __PLAT_S3C64XX_REGS_USB_HSOTG_PHY_H | ||
21 | #define __PLAT_S3C64XX_REGS_USB_HSOTG_PHY_H __FILE__ | ||
22 | |||
23 | /* S3C64XX_PA_USB_HSPHY */ | ||
24 | |||
25 | #define S3C_HSOTG_PHYREG(x) ((x) + S3C_VA_USB_HSPHY) | ||
26 | |||
27 | #define S3C_PHYPWR S3C_HSOTG_PHYREG(0x00) | ||
28 | #define SRC_PHYPWR_OTG_DISABLE (1 << 4) | ||
29 | #define SRC_PHYPWR_ANALOG_POWERDOWN (1 << 3) | ||
30 | #define SRC_PHYPWR_FORCE_SUSPEND (1 << 1) | ||
31 | |||
32 | #define S3C_PHYCLK S3C_HSOTG_PHYREG(0x04) | ||
33 | #define S3C_PHYCLK_MODE_USB11 (1 << 6) | ||
34 | #define S3C_PHYCLK_EXT_OSC (1 << 5) | ||
35 | #define S3C_PHYCLK_CLK_FORCE (1 << 4) | ||
36 | #define S3C_PHYCLK_ID_PULL (1 << 2) | ||
37 | #define S3C_PHYCLK_CLKSEL_MASK (0x3 << 0) | ||
38 | #define S3C_PHYCLK_CLKSEL_SHIFT (0) | ||
39 | #define S3C_PHYCLK_CLKSEL_48M (0x0 << 0) | ||
40 | #define S3C_PHYCLK_CLKSEL_12M (0x2 << 0) | ||
41 | #define S3C_PHYCLK_CLKSEL_24M (0x3 << 0) | ||
42 | |||
43 | #define S3C_RSTCON S3C_HSOTG_PHYREG(0x08) | ||
44 | #define S3C_RSTCON_PHYCLK (1 << 2) | ||
45 | #define S3C_RSTCON_HCLK (1 << 2) | ||
46 | #define S3C_RSTCON_PHY (1 << 0) | ||
47 | |||
48 | #define S3C_PHYTUNE S3C_HSOTG_PHYREG(0x20) | ||
49 | |||
50 | #endif /* __PLAT_S3C64XX_REGS_USB_HSOTG_PHY_H */ | ||
diff --git a/arch/arm/plat-s3c/include/plat/regs-usb-hsotg.h b/arch/arm/plat-s3c/include/plat/regs-usb-hsotg.h new file mode 100644 index 000000000000..8d18d9d4d148 --- /dev/null +++ b/arch/arm/plat-s3c/include/plat/regs-usb-hsotg.h | |||
@@ -0,0 +1,377 @@ | |||
1 | /* arch/arm/plat-s3c/include/plat/regs-usb-hsotg.h | ||
2 | * | ||
3 | * Copyright 2008 Openmoko, Inc. | ||
4 | * Copyright 2008 Simtec Electronics | ||
5 | * http://armlinux.simtec.co.uk/ | ||
6 | * Ben Dooks <ben@simtec.co.uk> | ||
7 | * | ||
8 | * S3C - USB2.0 Highspeed/OtG device block registers | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License version 2 as | ||
12 | * published by the Free Software Foundation. | ||
13 | */ | ||
14 | |||
15 | #ifndef __PLAT_S3C64XX_REGS_USB_HSOTG_H | ||
16 | #define __PLAT_S3C64XX_REGS_USB_HSOTG_H __FILE__ | ||
17 | |||
18 | #define S3C_HSOTG_REG(x) (x) | ||
19 | |||
20 | #define S3C_GOTGCTL S3C_HSOTG_REG(0x000) | ||
21 | #define S3C_GOTGCTL_BSESVLD (1 << 19) | ||
22 | #define S3C_GOTGCTL_ASESVLD (1 << 18) | ||
23 | #define S3C_GOTGCTL_DBNC_SHORT (1 << 17) | ||
24 | #define S3C_GOTGCTL_CONID_B (1 << 16) | ||
25 | #define S3C_GOTGCTL_DEVHNPEN (1 << 11) | ||
26 | #define S3C_GOTGCTL_HSSETHNPEN (1 << 10) | ||
27 | #define S3C_GOTGCTL_HNPREQ (1 << 9) | ||
28 | #define S3C_GOTGCTL_HSTNEGSCS (1 << 8) | ||
29 | #define S3C_GOTGCTL_SESREQ (1 << 1) | ||
30 | #define S3C_GOTGCTL_SESREQSCS (1 << 0) | ||
31 | |||
32 | #define S3C_GOTGINT S3C_HSOTG_REG(0x004) | ||
33 | #define S3C_GOTGINT_DbnceDone (1 << 19) | ||
34 | #define S3C_GOTGINT_ADevTOUTChg (1 << 18) | ||
35 | #define S3C_GOTGINT_HstNegDet (1 << 17) | ||
36 | #define S3C_GOTGINT_HstnegSucStsChng (1 << 9) | ||
37 | #define S3C_GOTGINT_SesReqSucStsChng (1 << 8) | ||
38 | #define S3C_GOTGINT_SesEndDet (1 << 2) | ||
39 | |||
40 | #define S3C_GAHBCFG S3C_HSOTG_REG(0x008) | ||
41 | #define S3C_GAHBCFG_PTxFEmpLvl (1 << 8) | ||
42 | #define S3C_GAHBCFG_NPTxFEmpLvl (1 << 7) | ||
43 | #define S3C_GAHBCFG_DMAEn (1 << 5) | ||
44 | #define S3C_GAHBCFG_HBstLen_MASK (0xf << 1) | ||
45 | #define S3C_GAHBCFG_HBstLen_SHIFT (1) | ||
46 | #define S3C_GAHBCFG_HBstLen_Single (0x0 << 1) | ||
47 | #define S3C_GAHBCFG_HBstLen_Incr (0x1 << 1) | ||
48 | #define S3C_GAHBCFG_HBstLen_Incr4 (0x3 << 1) | ||
49 | #define S3C_GAHBCFG_HBstLen_Incr8 (0x5 << 1) | ||
50 | #define S3C_GAHBCFG_HBstLen_Incr16 (0x7 << 1) | ||
51 | #define S3C_GAHBCFG_GlblIntrEn (1 << 0) | ||
52 | |||
53 | #define S3C_GUSBCFG S3C_HSOTG_REG(0x00C) | ||
54 | #define S3C_GUSBCFG_PHYLPClkSel (1 << 15) | ||
55 | #define S3C_GUSBCFG_HNPCap (1 << 9) | ||
56 | #define S3C_GUSBCFG_SRPCap (1 << 8) | ||
57 | #define S3C_GUSBCFG_PHYIf16 (1 << 3) | ||
58 | #define S3C_GUSBCFG_TOutCal_MASK (0x7 << 0) | ||
59 | #define S3C_GUSBCFG_TOutCal_SHIFT (0) | ||
60 | #define S3C_GUSBCFG_TOutCal_LIMIT (0x7) | ||
61 | #define S3C_GUSBCFG_TOutCal(_x) ((_x) << 0) | ||
62 | |||
63 | #define S3C_GRSTCTL S3C_HSOTG_REG(0x010) | ||
64 | |||
65 | #define S3C_GRSTCTL_AHBIdle (1 << 31) | ||
66 | #define S3C_GRSTCTL_DMAReq (1 << 30) | ||
67 | #define S3C_GRSTCTL_TxFNum_MASK (0x1f << 6) | ||
68 | #define S3C_GRSTCTL_TxFNum_SHIFT (6) | ||
69 | #define S3C_GRSTCTL_TxFNum_LIMIT (0x1f) | ||
70 | #define S3C_GRSTCTL_TxFNum(_x) ((_x) << 6) | ||
71 | #define S3C_GRSTCTL_TxFFlsh (1 << 5) | ||
72 | #define S3C_GRSTCTL_RxFFlsh (1 << 4) | ||
73 | #define S3C_GRSTCTL_INTknQFlsh (1 << 3) | ||
74 | #define S3C_GRSTCTL_FrmCntrRst (1 << 2) | ||
75 | #define S3C_GRSTCTL_HSftRst (1 << 1) | ||
76 | #define S3C_GRSTCTL_CSftRst (1 << 0) | ||
77 | |||
78 | #define S3C_GINTSTS S3C_HSOTG_REG(0x014) | ||
79 | #define S3C_GINTMSK S3C_HSOTG_REG(0x018) | ||
80 | |||
81 | #define S3C_GINTSTS_WkUpInt (1 << 31) | ||
82 | #define S3C_GINTSTS_SessReqInt (1 << 30) | ||
83 | #define S3C_GINTSTS_DisconnInt (1 << 29) | ||
84 | #define S3C_GINTSTS_ConIDStsChng (1 << 28) | ||
85 | #define S3C_GINTSTS_PTxFEmp (1 << 26) | ||
86 | #define S3C_GINTSTS_HChInt (1 << 25) | ||
87 | #define S3C_GINTSTS_PrtInt (1 << 24) | ||
88 | #define S3C_GINTSTS_FetSusp (1 << 22) | ||
89 | #define S3C_GINTSTS_incompIP (1 << 21) | ||
90 | #define S3C_GINTSTS_IncomplSOIN (1 << 20) | ||
91 | #define S3C_GINTSTS_OEPInt (1 << 19) | ||
92 | #define S3C_GINTSTS_IEPInt (1 << 18) | ||
93 | #define S3C_GINTSTS_EPMis (1 << 17) | ||
94 | #define S3C_GINTSTS_EOPF (1 << 15) | ||
95 | #define S3C_GINTSTS_ISOutDrop (1 << 14) | ||
96 | #define S3C_GINTSTS_EnumDone (1 << 13) | ||
97 | #define S3C_GINTSTS_USBRst (1 << 12) | ||
98 | #define S3C_GINTSTS_USBSusp (1 << 11) | ||
99 | #define S3C_GINTSTS_ErlySusp (1 << 10) | ||
100 | #define S3C_GINTSTS_GOUTNakEff (1 << 7) | ||
101 | #define S3C_GINTSTS_GINNakEff (1 << 6) | ||
102 | #define S3C_GINTSTS_NPTxFEmp (1 << 5) | ||
103 | #define S3C_GINTSTS_RxFLvl (1 << 4) | ||
104 | #define S3C_GINTSTS_SOF (1 << 3) | ||
105 | #define S3C_GINTSTS_OTGInt (1 << 2) | ||
106 | #define S3C_GINTSTS_ModeMis (1 << 1) | ||
107 | #define S3C_GINTSTS_CurMod_Host (1 << 0) | ||
108 | |||
109 | #define S3C_GRXSTSR S3C_HSOTG_REG(0x01C) | ||
110 | #define S3C_GRXSTSP S3C_HSOTG_REG(0x020) | ||
111 | |||
112 | #define S3C_GRXSTS_FN_MASK (0x7f << 25) | ||
113 | #define S3C_GRXSTS_FN_SHIFT (25) | ||
114 | |||
115 | #define S3C_GRXSTS_PktSts_MASK (0xf << 17) | ||
116 | #define S3C_GRXSTS_PktSts_SHIFT (17) | ||
117 | #define S3C_GRXSTS_PktSts_GlobalOutNAK (0x1 << 17) | ||
118 | #define S3C_GRXSTS_PktSts_OutRX (0x2 << 17) | ||
119 | #define S3C_GRXSTS_PktSts_OutDone (0x3 << 17) | ||
120 | #define S3C_GRXSTS_PktSts_SetupDone (0x4 << 17) | ||
121 | #define S3C_GRXSTS_PktSts_SetupRX (0x6 << 17) | ||
122 | |||
123 | #define S3C_GRXSTS_DPID_MASK (0x3 << 15) | ||
124 | #define S3C_GRXSTS_DPID_SHIFT (15) | ||
125 | #define S3C_GRXSTS_ByteCnt_MASK (0x7ff << 4) | ||
126 | #define S3C_GRXSTS_ByteCnt_SHIFT (4) | ||
127 | #define S3C_GRXSTS_EPNum_MASK (0xf << 0) | ||
128 | #define S3C_GRXSTS_EPNum_SHIFT (0) | ||
129 | |||
130 | #define S3C_GRXFSIZ S3C_HSOTG_REG(0x024) | ||
131 | |||
132 | #define S3C_GNPTXFSIZ S3C_HSOTG_REG(0x028) | ||
133 | |||
134 | #define S3C_GNPTXFSIZ_NPTxFDep_MASK (0xffff << 16) | ||
135 | #define S3C_GNPTXFSIZ_NPTxFDep_SHIFT (16) | ||
136 | #define S3C_GNPTXFSIZ_NPTxFDep_LIMIT (0xffff) | ||
137 | #define S3C_GNPTXFSIZ_NPTxFDep(_x) ((_x) << 16) | ||
138 | #define S3C_GNPTXFSIZ_NPTxFStAddr_MASK (0xffff << 0) | ||
139 | #define S3C_GNPTXFSIZ_NPTxFStAddr_SHIFT (0) | ||
140 | #define S3C_GNPTXFSIZ_NPTxFStAddr_LIMIT (0xffff) | ||
141 | #define S3C_GNPTXFSIZ_NPTxFStAddr(_x) ((_x) << 0) | ||
142 | |||
143 | #define S3C_GNPTXSTS S3C_HSOTG_REG(0x02C) | ||
144 | |||
145 | #define S3C_GNPTXSTS_NPtxQTop_MASK (0x7f << 24) | ||
146 | #define S3C_GNPTXSTS_NPtxQTop_SHIFT (24) | ||
147 | |||
148 | #define S3C_GNPTXSTS_NPTxQSpcAvail_MASK (0xff << 16) | ||
149 | #define S3C_GNPTXSTS_NPTxQSpcAvail_SHIFT (16) | ||
150 | #define S3C_GNPTXSTS_NPTxQSpcAvail_GET(_v) (((_v) >> 16) & 0xff) | ||
151 | |||
152 | #define S3C_GNPTXSTS_NPTxFSpcAvail_MASK (0xffff << 0) | ||
153 | #define S3C_GNPTXSTS_NPTxFSpcAvail_SHIFT (0) | ||
154 | #define S3C_GNPTXSTS_NPTxFSpcAvail_GET(_v) (((_v) >> 0) & 0xffff) | ||
155 | |||
156 | |||
157 | #define S3C_HPTXFSIZ S3C_HSOTG_REG(0x100) | ||
158 | |||
159 | #define S3C_DPTXFSIZn(_a) S3C_HSOTG_REG(0x104 + (((_a) - 1) * 4)) | ||
160 | |||
161 | #define S3C_DPTXFSIZn_DPTxFSize_MASK (0xffff << 16) | ||
162 | #define S3C_DPTXFSIZn_DPTxFSize_SHIFT (16) | ||
163 | #define S3C_DPTXFSIZn_DPTxFSize_GET(_v) (((_v) >> 16) & 0xffff) | ||
164 | #define S3C_DPTXFSIZn_DPTxFSize_LIMIT (0xffff) | ||
165 | #define S3C_DPTXFSIZn_DPTxFSize(_x) ((_x) << 16) | ||
166 | |||
167 | #define S3C_DPTXFSIZn_DPTxFStAddr_MASK (0xffff << 0) | ||
168 | #define S3C_DPTXFSIZn_DPTxFStAddr_SHIFT (0) | ||
169 | |||
170 | /* Device mode registers */ | ||
171 | #define S3C_DCFG S3C_HSOTG_REG(0x800) | ||
172 | |||
173 | #define S3C_DCFG_EPMisCnt_MASK (0x1f << 18) | ||
174 | #define S3C_DCFG_EPMisCnt_SHIFT (18) | ||
175 | #define S3C_DCFG_EPMisCnt_LIMIT (0x1f) | ||
176 | #define S3C_DCFG_EPMisCnt(_x) ((_x) << 18) | ||
177 | |||
178 | #define S3C_DCFG_PerFrInt_MASK (0x3 << 11) | ||
179 | #define S3C_DCFG_PerFrInt_SHIFT (11) | ||
180 | #define S3C_DCFG_PerFrInt_LIMIT (0x3) | ||
181 | #define S3C_DCFG_PerFrInt(_x) ((_x) << 11) | ||
182 | |||
183 | #define S3C_DCFG_DevAddr_MASK (0x7f << 4) | ||
184 | #define S3C_DCFG_DevAddr_SHIFT (4) | ||
185 | #define S3C_DCFG_DevAddr_LIMIT (0x7f) | ||
186 | #define S3C_DCFG_DevAddr(_x) ((_x) << 4) | ||
187 | |||
188 | #define S3C_DCFG_NZStsOUTHShk (1 << 2) | ||
189 | |||
190 | #define S3C_DCFG_DevSpd_MASK (0x3 << 0) | ||
191 | #define S3C_DCFG_DevSpd_SHIFT (0) | ||
192 | #define S3C_DCFG_DevSpd_HS (0x0 << 0) | ||
193 | #define S3C_DCFG_DevSpd_FS (0x1 << 0) | ||
194 | #define S3C_DCFG_DevSpd_LS (0x2 << 0) | ||
195 | #define S3C_DCFG_DevSpd_FS48 (0x3 << 0) | ||
196 | |||
197 | #define S3C_DCTL S3C_HSOTG_REG(0x804) | ||
198 | |||
199 | #define S3C_DCTL_PWROnPrgDone (1 << 11) | ||
200 | #define S3C_DCTL_CGOUTNak (1 << 10) | ||
201 | #define S3C_DCTL_SGOUTNak (1 << 9) | ||
202 | #define S3C_DCTL_CGNPInNAK (1 << 8) | ||
203 | #define S3C_DCTL_SGNPInNAK (1 << 7) | ||
204 | #define S3C_DCTL_TstCtl_MASK (0x7 << 4) | ||
205 | #define S3C_DCTL_TstCtl_SHIFT (4) | ||
206 | #define S3C_DCTL_GOUTNakSts (1 << 3) | ||
207 | #define S3C_DCTL_GNPINNakSts (1 << 2) | ||
208 | #define S3C_DCTL_SftDiscon (1 << 1) | ||
209 | #define S3C_DCTL_RmtWkUpSig (1 << 0) | ||
210 | |||
211 | #define S3C_DSTS S3C_HSOTG_REG(0x808) | ||
212 | |||
213 | #define S3C_DSTS_SOFFN_MASK (0x3fff << 8) | ||
214 | #define S3C_DSTS_SOFFN_SHIFT (8) | ||
215 | #define S3C_DSTS_SOFFN_LIMIT (0x3fff) | ||
216 | #define S3C_DSTS_SOFFN(_x) ((_x) << 8) | ||
217 | #define S3C_DSTS_ErraticErr (1 << 3) | ||
218 | #define S3C_DSTS_EnumSpd_MASK (0x3 << 1) | ||
219 | #define S3C_DSTS_EnumSpd_SHIFT (1) | ||
220 | #define S3C_DSTS_EnumSpd_HS (0x0 << 1) | ||
221 | #define S3C_DSTS_EnumSpd_FS (0x1 << 1) | ||
222 | #define S3C_DSTS_EnumSpd_LS (0x2 << 1) | ||
223 | #define S3C_DSTS_EnumSpd_FS48 (0x3 << 1) | ||
224 | |||
225 | #define S3C_DSTS_SuspSts (1 << 0) | ||
226 | |||
227 | #define S3C_DIEPMSK S3C_HSOTG_REG(0x810) | ||
228 | |||
229 | #define S3C_DIEPMSK_INEPNakEffMsk (1 << 6) | ||
230 | #define S3C_DIEPMSK_INTknEPMisMsk (1 << 5) | ||
231 | #define S3C_DIEPMSK_INTknTXFEmpMsk (1 << 4) | ||
232 | #define S3C_DIEPMSK_TimeOUTMsk (1 << 3) | ||
233 | #define S3C_DIEPMSK_AHBErrMsk (1 << 2) | ||
234 | #define S3C_DIEPMSK_EPDisbldMsk (1 << 1) | ||
235 | #define S3C_DIEPMSK_XferComplMsk (1 << 0) | ||
236 | |||
237 | #define S3C_DOEPMSK S3C_HSOTG_REG(0x814) | ||
238 | |||
239 | #define S3C_DOEPMSK_Back2BackSetup (1 << 6) | ||
240 | #define S3C_DOEPMSK_OUTTknEPdisMsk (1 << 4) | ||
241 | #define S3C_DOEPMSK_SetupMsk (1 << 3) | ||
242 | #define S3C_DOEPMSK_AHBErrMsk (1 << 2) | ||
243 | #define S3C_DOEPMSK_EPDisbldMsk (1 << 1) | ||
244 | #define S3C_DOEPMSK_XferComplMsk (1 << 0) | ||
245 | |||
246 | #define S3C_DAINT S3C_HSOTG_REG(0x818) | ||
247 | #define S3C_DAINTMSK S3C_HSOTG_REG(0x81C) | ||
248 | |||
249 | #define S3C_DAINT_OutEP_SHIFT (16) | ||
250 | #define S3C_DAINT_OutEP(x) (1 << ((x) + 16)) | ||
251 | #define S3C_DAINT_InEP(x) (1 << (x)) | ||
252 | |||
253 | #define S3C_DTKNQR1 S3C_HSOTG_REG(0x820) | ||
254 | #define S3C_DTKNQR2 S3C_HSOTG_REG(0x824) | ||
255 | #define S3C_DTKNQR3 S3C_HSOTG_REG(0x830) | ||
256 | #define S3C_DTKNQR4 S3C_HSOTG_REG(0x834) | ||
257 | |||
258 | #define S3C_DVBUSDIS S3C_HSOTG_REG(0x828) | ||
259 | #define S3C_DVBUSPULSE S3C_HSOTG_REG(0x82C) | ||
260 | |||
261 | #define S3C_DIEPCTL0 S3C_HSOTG_REG(0x900) | ||
262 | #define S3C_DOEPCTL0 S3C_HSOTG_REG(0xB00) | ||
263 | #define S3C_DIEPCTL(_a) S3C_HSOTG_REG(0x900 + ((_a) * 0x20)) | ||
264 | #define S3C_DOEPCTL(_a) S3C_HSOTG_REG(0xB00 + ((_a) * 0x20)) | ||
265 | |||
266 | /* EP0 specialness: | ||
267 | * bits[29..28] - reserved (no SetD0PID, SetD1PID) | ||
268 | * bits[25..22] - should always be zero, this isn't a periodic endpoint | ||
269 | * bits[10..0] - MPS setting differenct for EP0 | ||
270 | */ | ||
271 | #define S3C_D0EPCTL_MPS_MASK (0x3 << 0) | ||
272 | #define S3C_D0EPCTL_MPS_SHIFT (0) | ||
273 | #define S3C_D0EPCTL_MPS_64 (0x0 << 0) | ||
274 | #define S3C_D0EPCTL_MPS_32 (0x1 << 0) | ||
275 | #define S3C_D0EPCTL_MPS_16 (0x2 << 0) | ||
276 | #define S3C_D0EPCTL_MPS_8 (0x3 << 0) | ||
277 | |||
278 | #define S3C_DxEPCTL_EPEna (1 << 31) | ||
279 | #define S3C_DxEPCTL_EPDis (1 << 30) | ||
280 | #define S3C_DxEPCTL_SetD1PID (1 << 29) | ||
281 | #define S3C_DxEPCTL_SetOddFr (1 << 29) | ||
282 | #define S3C_DxEPCTL_SetD0PID (1 << 28) | ||
283 | #define S3C_DxEPCTL_SetEvenFr (1 << 28) | ||
284 | #define S3C_DxEPCTL_SNAK (1 << 27) | ||
285 | #define S3C_DxEPCTL_CNAK (1 << 26) | ||
286 | #define S3C_DxEPCTL_TxFNum_MASK (0xf << 22) | ||
287 | #define S3C_DxEPCTL_TxFNum_SHIFT (22) | ||
288 | #define S3C_DxEPCTL_TxFNum_LIMIT (0xf) | ||
289 | #define S3C_DxEPCTL_TxFNum(_x) ((_x) << 22) | ||
290 | |||
291 | #define S3C_DxEPCTL_Stall (1 << 21) | ||
292 | #define S3C_DxEPCTL_Snp (1 << 20) | ||
293 | #define S3C_DxEPCTL_EPType_MASK (0x3 << 18) | ||
294 | #define S3C_DxEPCTL_EPType_SHIFT (18) | ||
295 | #define S3C_DxEPCTL_EPType_Control (0x0 << 18) | ||
296 | #define S3C_DxEPCTL_EPType_Iso (0x1 << 18) | ||
297 | #define S3C_DxEPCTL_EPType_Bulk (0x2 << 18) | ||
298 | #define S3C_DxEPCTL_EPType_Intterupt (0x3 << 18) | ||
299 | |||
300 | #define S3C_DxEPCTL_NAKsts (1 << 17) | ||
301 | #define S3C_DxEPCTL_DPID (1 << 16) | ||
302 | #define S3C_DxEPCTL_EOFrNum (1 << 16) | ||
303 | #define S3C_DxEPCTL_USBActEp (1 << 15) | ||
304 | #define S3C_DxEPCTL_NextEp_MASK (0xf << 11) | ||
305 | #define S3C_DxEPCTL_NextEp_SHIFT (11) | ||
306 | #define S3C_DxEPCTL_NextEp_LIMIT (0xf) | ||
307 | #define S3C_DxEPCTL_NextEp(_x) ((_x) << 11) | ||
308 | |||
309 | #define S3C_DxEPCTL_MPS_MASK (0x7ff << 0) | ||
310 | #define S3C_DxEPCTL_MPS_SHIFT (0) | ||
311 | #define S3C_DxEPCTL_MPS_LIMIT (0x7ff) | ||
312 | #define S3C_DxEPCTL_MPS(_x) ((_x) << 0) | ||
313 | |||
314 | #define S3C_DIEPINT(_a) S3C_HSOTG_REG(0x908 + ((_a) * 0x20)) | ||
315 | #define S3C_DOEPINT(_a) S3C_HSOTG_REG(0xB08 + ((_a) * 0x20)) | ||
316 | |||
317 | #define S3C_DxEPINT_INEPNakEff (1 << 6) | ||
318 | #define S3C_DxEPINT_Back2BackSetup (1 << 6) | ||
319 | #define S3C_DxEPINT_INTknEPMis (1 << 5) | ||
320 | #define S3C_DxEPINT_INTknTXFEmp (1 << 4) | ||
321 | #define S3C_DxEPINT_OUTTknEPdis (1 << 4) | ||
322 | #define S3C_DxEPINT_Timeout (1 << 3) | ||
323 | #define S3C_DxEPINT_Setup (1 << 3) | ||
324 | #define S3C_DxEPINT_AHBErr (1 << 2) | ||
325 | #define S3C_DxEPINT_EPDisbld (1 << 1) | ||
326 | #define S3C_DxEPINT_XferCompl (1 << 0) | ||
327 | |||
328 | #define S3C_DIEPTSIZ0 S3C_HSOTG_REG(0x910) | ||
329 | |||
330 | #define S3C_DIEPTSIZ0_PktCnt_MASK (0x3 << 19) | ||
331 | #define S3C_DIEPTSIZ0_PktCnt_SHIFT (19) | ||
332 | #define S3C_DIEPTSIZ0_PktCnt_LIMIT (0x3) | ||
333 | #define S3C_DIEPTSIZ0_PktCnt(_x) ((_x) << 19) | ||
334 | |||
335 | #define S3C_DIEPTSIZ0_XferSize_MASK (0x7f << 0) | ||
336 | #define S3C_DIEPTSIZ0_XferSize_SHIFT (0) | ||
337 | #define S3C_DIEPTSIZ0_XferSize_LIMIT (0x7f) | ||
338 | #define S3C_DIEPTSIZ0_XferSize(_x) ((_x) << 0) | ||
339 | |||
340 | |||
341 | #define DOEPTSIZ0 S3C_HSOTG_REG(0xB10) | ||
342 | #define S3C_DOEPTSIZ0_SUPCnt_MASK (0x3 << 29) | ||
343 | #define S3C_DOEPTSIZ0_SUPCnt_SHIFT (29) | ||
344 | #define S3C_DOEPTSIZ0_SUPCnt_LIMIT (0x3) | ||
345 | #define S3C_DOEPTSIZ0_SUPCnt(_x) ((_x) << 29) | ||
346 | |||
347 | #define S3C_DOEPTSIZ0_PktCnt (1 << 19) | ||
348 | #define S3C_DOEPTSIZ0_XferSize_MASK (0x7f << 0) | ||
349 | #define S3C_DOEPTSIZ0_XferSize_SHIFT (0) | ||
350 | |||
351 | #define S3C_DIEPTSIZ(_a) S3C_HSOTG_REG(0x910 + ((_a) * 0x20)) | ||
352 | #define S3C_DOEPTSIZ(_a) S3C_HSOTG_REG(0xB10 + ((_a) * 0x20)) | ||
353 | |||
354 | #define S3C_DxEPTSIZ_MC_MASK (0x3 << 29) | ||
355 | #define S3C_DxEPTSIZ_MC_SHIFT (29) | ||
356 | #define S3C_DxEPTSIZ_MC_LIMIT (0x3) | ||
357 | #define S3C_DxEPTSIZ_MC(_x) ((_x) << 29) | ||
358 | |||
359 | #define S3C_DxEPTSIZ_PktCnt_MASK (0x3ff << 19) | ||
360 | #define S3C_DxEPTSIZ_PktCnt_SHIFT (19) | ||
361 | #define S3C_DxEPTSIZ_PktCnt_GET(_v) (((_v) >> 19) & 0x3ff) | ||
362 | #define S3C_DxEPTSIZ_PktCnt_LIMIT (0x3ff) | ||
363 | #define S3C_DxEPTSIZ_PktCnt(_x) ((_x) << 19) | ||
364 | |||
365 | #define S3C_DxEPTSIZ_XferSize_MASK (0x7ffff << 0) | ||
366 | #define S3C_DxEPTSIZ_XferSize_SHIFT (0) | ||
367 | #define S3C_DxEPTSIZ_XferSize_GET(_v) (((_v) >> 0) & 0x7ffff) | ||
368 | #define S3C_DxEPTSIZ_XferSize_LIMIT (0x7ffff) | ||
369 | #define S3C_DxEPTSIZ_XferSize(_x) ((_x) << 0) | ||
370 | |||
371 | |||
372 | #define S3C_DIEPDMA(_a) S3C_HSOTG_REG(0x914 + ((_a) * 0x20)) | ||
373 | #define S3C_DOEPDMA(_a) S3C_HSOTG_REG(0xB14 + ((_a) * 0x20)) | ||
374 | |||
375 | #define S3C_EPFIFO(_a) S3C_HSOTG_REG(0x1000 + ((_a) * 0x1000)) | ||
376 | |||
377 | #endif /* __PLAT_S3C64XX_REGS_USB_HSOTG_H */ | ||
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c index 1a91bf9687af..07bbb9b3b93f 100644 --- a/drivers/pci/pci.c +++ b/drivers/pci/pci.c | |||
@@ -24,6 +24,11 @@ | |||
24 | #include <asm/setup.h> | 24 | #include <asm/setup.h> |
25 | #include "pci.h" | 25 | #include "pci.h" |
26 | 26 | ||
27 | const char *pci_power_names[] = { | ||
28 | "error", "D0", "D1", "D2", "D3hot", "D3cold", "unknown", | ||
29 | }; | ||
30 | EXPORT_SYMBOL_GPL(pci_power_names); | ||
31 | |||
27 | unsigned int pci_pm_d3_delay = PCI_PM_D3_WAIT; | 32 | unsigned int pci_pm_d3_delay = PCI_PM_D3_WAIT; |
28 | 33 | ||
29 | #ifdef CONFIG_PCI_DOMAINS | 34 | #ifdef CONFIG_PCI_DOMAINS |
diff --git a/drivers/staging/uc2322/aten2011.c b/drivers/staging/uc2322/aten2011.c index 9c62f787cc9c..39d0926d1a90 100644 --- a/drivers/staging/uc2322/aten2011.c +++ b/drivers/staging/uc2322/aten2011.c | |||
@@ -2336,7 +2336,7 @@ static int ATEN2011_startup(struct usb_serial *serial) | |||
2336 | return 0; | 2336 | return 0; |
2337 | } | 2337 | } |
2338 | 2338 | ||
2339 | static void ATEN2011_shutdown(struct usb_serial *serial) | 2339 | static void ATEN2011_release(struct usb_serial *serial) |
2340 | { | 2340 | { |
2341 | int i; | 2341 | int i; |
2342 | struct ATENINTL_port *ATEN2011_port; | 2342 | struct ATENINTL_port *ATEN2011_port; |
@@ -2382,7 +2382,7 @@ static struct usb_serial_driver aten_serial_driver = { | |||
2382 | .tiocmget = ATEN2011_tiocmget, | 2382 | .tiocmget = ATEN2011_tiocmget, |
2383 | .tiocmset = ATEN2011_tiocmset, | 2383 | .tiocmset = ATEN2011_tiocmset, |
2384 | .attach = ATEN2011_startup, | 2384 | .attach = ATEN2011_startup, |
2385 | .shutdown = ATEN2011_shutdown, | 2385 | .release = ATEN2011_release, |
2386 | .read_bulk_callback = ATEN2011_bulk_in_callback, | 2386 | .read_bulk_callback = ATEN2011_bulk_in_callback, |
2387 | .read_int_callback = ATEN2011_interrupt_callback, | 2387 | .read_int_callback = ATEN2011_interrupt_callback, |
2388 | }; | 2388 | }; |
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig index 5eee3f82be5d..dcd49f1e96d0 100644 --- a/drivers/usb/Kconfig +++ b/drivers/usb/Kconfig | |||
@@ -64,6 +64,7 @@ config USB_ARCH_HAS_EHCI | |||
64 | config USB | 64 | config USB |
65 | tristate "Support for Host-side USB" | 65 | tristate "Support for Host-side USB" |
66 | depends on USB_ARCH_HAS_HCD | 66 | depends on USB_ARCH_HAS_HCD |
67 | select NLS # for UTF-8 strings | ||
67 | ---help--- | 68 | ---help--- |
68 | Universal Serial Bus (USB) is a specification for a serial bus | 69 | Universal Serial Bus (USB) is a specification for a serial bus |
69 | subsystem which offers higher speeds and more features than the | 70 | subsystem which offers higher speeds and more features than the |
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile index 0a3dc5ece634..19cb7d5480d7 100644 --- a/drivers/usb/Makefile +++ b/drivers/usb/Makefile | |||
@@ -14,6 +14,7 @@ obj-$(CONFIG_USB_ISP116X_HCD) += host/ | |||
14 | obj-$(CONFIG_USB_OHCI_HCD) += host/ | 14 | obj-$(CONFIG_USB_OHCI_HCD) += host/ |
15 | obj-$(CONFIG_USB_UHCI_HCD) += host/ | 15 | obj-$(CONFIG_USB_UHCI_HCD) += host/ |
16 | obj-$(CONFIG_USB_FHCI_HCD) += host/ | 16 | obj-$(CONFIG_USB_FHCI_HCD) += host/ |
17 | obj-$(CONFIG_USB_XHCI_HCD) += host/ | ||
17 | obj-$(CONFIG_USB_SL811_HCD) += host/ | 18 | obj-$(CONFIG_USB_SL811_HCD) += host/ |
18 | obj-$(CONFIG_USB_U132_HCD) += host/ | 19 | obj-$(CONFIG_USB_U132_HCD) += host/ |
19 | obj-$(CONFIG_USB_R8A66597_HCD) += host/ | 20 | obj-$(CONFIG_USB_R8A66597_HCD) += host/ |
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c index ddeb69192537..38bfdb0f6660 100644 --- a/drivers/usb/class/cdc-acm.c +++ b/drivers/usb/class/cdc-acm.c | |||
@@ -937,9 +937,9 @@ static int acm_probe(struct usb_interface *intf, | |||
937 | int buflen = intf->altsetting->extralen; | 937 | int buflen = intf->altsetting->extralen; |
938 | struct usb_interface *control_interface; | 938 | struct usb_interface *control_interface; |
939 | struct usb_interface *data_interface; | 939 | struct usb_interface *data_interface; |
940 | struct usb_endpoint_descriptor *epctrl; | 940 | struct usb_endpoint_descriptor *epctrl = NULL; |
941 | struct usb_endpoint_descriptor *epread; | 941 | struct usb_endpoint_descriptor *epread = NULL; |
942 | struct usb_endpoint_descriptor *epwrite; | 942 | struct usb_endpoint_descriptor *epwrite = NULL; |
943 | struct usb_device *usb_dev = interface_to_usbdev(intf); | 943 | struct usb_device *usb_dev = interface_to_usbdev(intf); |
944 | struct acm *acm; | 944 | struct acm *acm; |
945 | int minor; | 945 | int minor; |
@@ -952,6 +952,7 @@ static int acm_probe(struct usb_interface *intf, | |||
952 | unsigned long quirks; | 952 | unsigned long quirks; |
953 | int num_rx_buf; | 953 | int num_rx_buf; |
954 | int i; | 954 | int i; |
955 | int combined_interfaces = 0; | ||
955 | 956 | ||
956 | /* normal quirks */ | 957 | /* normal quirks */ |
957 | quirks = (unsigned long)id->driver_info; | 958 | quirks = (unsigned long)id->driver_info; |
@@ -1033,9 +1034,15 @@ next_desc: | |||
1033 | data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); | 1034 | data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); |
1034 | control_interface = intf; | 1035 | control_interface = intf; |
1035 | } else { | 1036 | } else { |
1036 | dev_dbg(&intf->dev, | 1037 | if (intf->cur_altsetting->desc.bNumEndpoints != 3) { |
1037 | "No union descriptor, giving up\n"); | 1038 | dev_dbg(&intf->dev,"No union descriptor, giving up\n"); |
1038 | return -ENODEV; | 1039 | return -ENODEV; |
1040 | } else { | ||
1041 | dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n"); | ||
1042 | combined_interfaces = 1; | ||
1043 | control_interface = data_interface = intf; | ||
1044 | goto look_for_collapsed_interface; | ||
1045 | } | ||
1039 | } | 1046 | } |
1040 | } else { | 1047 | } else { |
1041 | control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); | 1048 | control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); |
@@ -1049,6 +1056,36 @@ next_desc: | |||
1049 | if (data_interface_num != call_interface_num) | 1056 | if (data_interface_num != call_interface_num) |
1050 | dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); | 1057 | dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); |
1051 | 1058 | ||
1059 | if (control_interface == data_interface) { | ||
1060 | /* some broken devices designed for windows work this way */ | ||
1061 | dev_warn(&intf->dev,"Control and data interfaces are not separated!\n"); | ||
1062 | combined_interfaces = 1; | ||
1063 | /* a popular other OS doesn't use it */ | ||
1064 | quirks |= NO_CAP_LINE; | ||
1065 | if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) { | ||
1066 | dev_err(&intf->dev, "This needs exactly 3 endpoints\n"); | ||
1067 | return -EINVAL; | ||
1068 | } | ||
1069 | look_for_collapsed_interface: | ||
1070 | for (i = 0; i < 3; i++) { | ||
1071 | struct usb_endpoint_descriptor *ep; | ||
1072 | ep = &data_interface->cur_altsetting->endpoint[i].desc; | ||
1073 | |||
1074 | if (usb_endpoint_is_int_in(ep)) | ||
1075 | epctrl = ep; | ||
1076 | else if (usb_endpoint_is_bulk_out(ep)) | ||
1077 | epwrite = ep; | ||
1078 | else if (usb_endpoint_is_bulk_in(ep)) | ||
1079 | epread = ep; | ||
1080 | else | ||
1081 | return -EINVAL; | ||
1082 | } | ||
1083 | if (!epctrl || !epread || !epwrite) | ||
1084 | return -ENODEV; | ||
1085 | else | ||
1086 | goto made_compressed_probe; | ||
1087 | } | ||
1088 | |||
1052 | skip_normal_probe: | 1089 | skip_normal_probe: |
1053 | 1090 | ||
1054 | /*workaround for switched interfaces */ | 1091 | /*workaround for switched interfaces */ |
@@ -1068,10 +1105,11 @@ skip_normal_probe: | |||
1068 | } | 1105 | } |
1069 | 1106 | ||
1070 | /* Accept probe requests only for the control interface */ | 1107 | /* Accept probe requests only for the control interface */ |
1071 | if (intf != control_interface) | 1108 | if (!combined_interfaces && intf != control_interface) |
1072 | return -ENODEV; | 1109 | return -ENODEV; |
1073 | 1110 | ||
1074 | if (usb_interface_claimed(data_interface)) { /* valid in this context */ | 1111 | if (!combined_interfaces && usb_interface_claimed(data_interface)) { |
1112 | /* valid in this context */ | ||
1075 | dev_dbg(&intf->dev, "The data interface isn't available\n"); | 1113 | dev_dbg(&intf->dev, "The data interface isn't available\n"); |
1076 | return -EBUSY; | 1114 | return -EBUSY; |
1077 | } | 1115 | } |
@@ -1095,6 +1133,7 @@ skip_normal_probe: | |||
1095 | epread = epwrite; | 1133 | epread = epwrite; |
1096 | epwrite = t; | 1134 | epwrite = t; |
1097 | } | 1135 | } |
1136 | made_compressed_probe: | ||
1098 | dbg("interfaces are valid"); | 1137 | dbg("interfaces are valid"); |
1099 | for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++); | 1138 | for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++); |
1100 | 1139 | ||
@@ -1112,12 +1151,15 @@ skip_normal_probe: | |||
1112 | ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); | 1151 | ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); |
1113 | readsize = le16_to_cpu(epread->wMaxPacketSize) * | 1152 | readsize = le16_to_cpu(epread->wMaxPacketSize) * |
1114 | (quirks == SINGLE_RX_URB ? 1 : 2); | 1153 | (quirks == SINGLE_RX_URB ? 1 : 2); |
1154 | acm->combined_interfaces = combined_interfaces; | ||
1115 | acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20; | 1155 | acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20; |
1116 | acm->control = control_interface; | 1156 | acm->control = control_interface; |
1117 | acm->data = data_interface; | 1157 | acm->data = data_interface; |
1118 | acm->minor = minor; | 1158 | acm->minor = minor; |
1119 | acm->dev = usb_dev; | 1159 | acm->dev = usb_dev; |
1120 | acm->ctrl_caps = ac_management_function; | 1160 | acm->ctrl_caps = ac_management_function; |
1161 | if (quirks & NO_CAP_LINE) | ||
1162 | acm->ctrl_caps &= ~USB_CDC_CAP_LINE; | ||
1121 | acm->ctrlsize = ctrlsize; | 1163 | acm->ctrlsize = ctrlsize; |
1122 | acm->readsize = readsize; | 1164 | acm->readsize = readsize; |
1123 | acm->rx_buflimit = num_rx_buf; | 1165 | acm->rx_buflimit = num_rx_buf; |
@@ -1223,9 +1265,10 @@ skip_normal_probe: | |||
1223 | 1265 | ||
1224 | skip_countries: | 1266 | skip_countries: |
1225 | usb_fill_int_urb(acm->ctrlurb, usb_dev, | 1267 | usb_fill_int_urb(acm->ctrlurb, usb_dev, |
1226 | usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), | 1268 | usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), |
1227 | acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, | 1269 | acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, |
1228 | epctrl->bInterval); | 1270 | /* works around buggy devices */ |
1271 | epctrl->bInterval ? epctrl->bInterval : 0xff); | ||
1229 | acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; | 1272 | acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
1230 | acm->ctrlurb->transfer_dma = acm->ctrl_dma; | 1273 | acm->ctrlurb->transfer_dma = acm->ctrl_dma; |
1231 | 1274 | ||
@@ -1312,7 +1355,8 @@ static void acm_disconnect(struct usb_interface *intf) | |||
1312 | acm->ctrl_dma); | 1355 | acm->ctrl_dma); |
1313 | acm_read_buffers_free(acm); | 1356 | acm_read_buffers_free(acm); |
1314 | 1357 | ||
1315 | usb_driver_release_interface(&acm_driver, intf == acm->control ? | 1358 | if (!acm->combined_interfaces) |
1359 | usb_driver_release_interface(&acm_driver, intf == acm->control ? | ||
1316 | acm->data : acm->control); | 1360 | acm->data : acm->control); |
1317 | 1361 | ||
1318 | if (acm->port.count == 0) { | 1362 | if (acm->port.count == 0) { |
@@ -1451,6 +1495,9 @@ static struct usb_device_id acm_ids[] = { | |||
1451 | Maybe we should define a new | 1495 | Maybe we should define a new |
1452 | quirk for this. */ | 1496 | quirk for this. */ |
1453 | }, | 1497 | }, |
1498 | { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */ | ||
1499 | .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */ | ||
1500 | }, | ||
1454 | 1501 | ||
1455 | /* control interfaces with various AT-command sets */ | 1502 | /* control interfaces with various AT-command sets */ |
1456 | { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, | 1503 | { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, |
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h index 4c3856420add..1602324808ba 100644 --- a/drivers/usb/class/cdc-acm.h +++ b/drivers/usb/class/cdc-acm.h | |||
@@ -125,6 +125,7 @@ struct acm { | |||
125 | unsigned char clocal; /* termios CLOCAL */ | 125 | unsigned char clocal; /* termios CLOCAL */ |
126 | unsigned int ctrl_caps; /* control capabilities from the class specific header */ | 126 | unsigned int ctrl_caps; /* control capabilities from the class specific header */ |
127 | unsigned int susp_count; /* number of suspended interfaces */ | 127 | unsigned int susp_count; /* number of suspended interfaces */ |
128 | int combined_interfaces:1; /* control and data collapsed */ | ||
128 | struct acm_wb *delayed_wb; /* write queued for a device about to be woken */ | 129 | struct acm_wb *delayed_wb; /* write queued for a device about to be woken */ |
129 | }; | 130 | }; |
130 | 131 | ||
@@ -133,3 +134,4 @@ struct acm { | |||
133 | /* constants describing various quirks and errors */ | 134 | /* constants describing various quirks and errors */ |
134 | #define NO_UNION_NORMAL 1 | 135 | #define NO_UNION_NORMAL 1 |
135 | #define SINGLE_RX_URB 2 | 136 | #define SINGLE_RX_URB 2 |
137 | #define NO_CAP_LINE 4 | ||
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c index c40a9b284cc9..3703789d0d2a 100644 --- a/drivers/usb/class/usbtmc.c +++ b/drivers/usb/class/usbtmc.c | |||
@@ -927,21 +927,27 @@ static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |||
927 | switch (cmd) { | 927 | switch (cmd) { |
928 | case USBTMC_IOCTL_CLEAR_OUT_HALT: | 928 | case USBTMC_IOCTL_CLEAR_OUT_HALT: |
929 | retval = usbtmc_ioctl_clear_out_halt(data); | 929 | retval = usbtmc_ioctl_clear_out_halt(data); |
930 | break; | ||
930 | 931 | ||
931 | case USBTMC_IOCTL_CLEAR_IN_HALT: | 932 | case USBTMC_IOCTL_CLEAR_IN_HALT: |
932 | retval = usbtmc_ioctl_clear_in_halt(data); | 933 | retval = usbtmc_ioctl_clear_in_halt(data); |
934 | break; | ||
933 | 935 | ||
934 | case USBTMC_IOCTL_INDICATOR_PULSE: | 936 | case USBTMC_IOCTL_INDICATOR_PULSE: |
935 | retval = usbtmc_ioctl_indicator_pulse(data); | 937 | retval = usbtmc_ioctl_indicator_pulse(data); |
938 | break; | ||
936 | 939 | ||
937 | case USBTMC_IOCTL_CLEAR: | 940 | case USBTMC_IOCTL_CLEAR: |
938 | retval = usbtmc_ioctl_clear(data); | 941 | retval = usbtmc_ioctl_clear(data); |
942 | break; | ||
939 | 943 | ||
940 | case USBTMC_IOCTL_ABORT_BULK_OUT: | 944 | case USBTMC_IOCTL_ABORT_BULK_OUT: |
941 | retval = usbtmc_ioctl_abort_bulk_out(data); | 945 | retval = usbtmc_ioctl_abort_bulk_out(data); |
946 | break; | ||
942 | 947 | ||
943 | case USBTMC_IOCTL_ABORT_BULK_IN: | 948 | case USBTMC_IOCTL_ABORT_BULK_IN: |
944 | retval = usbtmc_ioctl_abort_bulk_in(data); | 949 | retval = usbtmc_ioctl_abort_bulk_in(data); |
950 | break; | ||
945 | } | 951 | } |
946 | 952 | ||
947 | mutex_unlock(&data->io_mutex); | 953 | mutex_unlock(&data->io_mutex); |
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig index e1759d17ac5d..69280c35b5cb 100644 --- a/drivers/usb/core/Kconfig +++ b/drivers/usb/core/Kconfig | |||
@@ -28,7 +28,7 @@ comment "Miscellaneous USB options" | |||
28 | depends on USB | 28 | depends on USB |
29 | 29 | ||
30 | config USB_DEVICEFS | 30 | config USB_DEVICEFS |
31 | bool "USB device filesystem" | 31 | bool "USB device filesystem (DEPRECATED)" if EMBEDDED |
32 | depends on USB | 32 | depends on USB |
33 | ---help--- | 33 | ---help--- |
34 | If you say Y here (and to "/proc file system support" in the "File | 34 | If you say Y here (and to "/proc file system support" in the "File |
@@ -46,11 +46,15 @@ config USB_DEVICEFS | |||
46 | For the format of the various /proc/bus/usb/ files, please read | 46 | For the format of the various /proc/bus/usb/ files, please read |
47 | <file:Documentation/usb/proc_usb_info.txt>. | 47 | <file:Documentation/usb/proc_usb_info.txt>. |
48 | 48 | ||
49 | Usbfs files can't handle Access Control Lists (ACL), which are the | 49 | Modern Linux systems do not use this. |
50 | default way to grant access to USB devices for untrusted users of a | 50 | |
51 | desktop system. The usbfs functionality is replaced by real | 51 | Usbfs entries are files and not character devices; usbfs can't |
52 | device-nodes managed by udev. These nodes live in /dev/bus/usb and | 52 | handle Access Control Lists (ACL) which are the default way to |
53 | are used by libusb. | 53 | grant access to USB devices for untrusted users of a desktop |
54 | system. | ||
55 | |||
56 | The usbfs functionality is replaced by real device-nodes managed by | ||
57 | udev. These nodes lived in /dev/bus/usb and are used by libusb. | ||
54 | 58 | ||
55 | config USB_DEVICE_CLASS | 59 | config USB_DEVICE_CLASS |
56 | bool "USB device class-devices (DEPRECATED)" | 60 | bool "USB device class-devices (DEPRECATED)" |
diff --git a/drivers/usb/core/Makefile b/drivers/usb/core/Makefile index b6078706fb93..ec16e6029905 100644 --- a/drivers/usb/core/Makefile +++ b/drivers/usb/core/Makefile | |||
@@ -4,14 +4,14 @@ | |||
4 | 4 | ||
5 | usbcore-objs := usb.o hub.o hcd.o urb.o message.o driver.o \ | 5 | usbcore-objs := usb.o hub.o hcd.o urb.o message.o driver.o \ |
6 | config.o file.o buffer.o sysfs.o endpoint.o \ | 6 | config.o file.o buffer.o sysfs.o endpoint.o \ |
7 | devio.o notify.o generic.o quirks.o | 7 | devio.o notify.o generic.o quirks.o devices.o |
8 | 8 | ||
9 | ifeq ($(CONFIG_PCI),y) | 9 | ifeq ($(CONFIG_PCI),y) |
10 | usbcore-objs += hcd-pci.o | 10 | usbcore-objs += hcd-pci.o |
11 | endif | 11 | endif |
12 | 12 | ||
13 | ifeq ($(CONFIG_USB_DEVICEFS),y) | 13 | ifeq ($(CONFIG_USB_DEVICEFS),y) |
14 | usbcore-objs += inode.o devices.o | 14 | usbcore-objs += inode.o |
15 | endif | 15 | endif |
16 | 16 | ||
17 | obj-$(CONFIG_USB) += usbcore.o | 17 | obj-$(CONFIG_USB) += usbcore.o |
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c index 568244c99bdc..24dfb33f90cb 100644 --- a/drivers/usb/core/config.c +++ b/drivers/usb/core/config.c | |||
@@ -19,6 +19,32 @@ static inline const char *plural(int n) | |||
19 | return (n == 1 ? "" : "s"); | 19 | return (n == 1 ? "" : "s"); |
20 | } | 20 | } |
21 | 21 | ||
22 | /* FIXME: this is a kludge */ | ||
23 | static int find_next_descriptor_more(unsigned char *buffer, int size, | ||
24 | int dt1, int dt2, int dt3, int *num_skipped) | ||
25 | { | ||
26 | struct usb_descriptor_header *h; | ||
27 | int n = 0; | ||
28 | unsigned char *buffer0 = buffer; | ||
29 | |||
30 | /* Find the next descriptor of type dt1 or dt2 or dt3 */ | ||
31 | while (size > 0) { | ||
32 | h = (struct usb_descriptor_header *) buffer; | ||
33 | if (h->bDescriptorType == dt1 || h->bDescriptorType == dt2 || | ||
34 | h->bDescriptorType == dt3) | ||
35 | break; | ||
36 | buffer += h->bLength; | ||
37 | size -= h->bLength; | ||
38 | ++n; | ||
39 | } | ||
40 | |||
41 | /* Store the number of descriptors skipped and return the | ||
42 | * number of bytes skipped */ | ||
43 | if (num_skipped) | ||
44 | *num_skipped = n; | ||
45 | return buffer - buffer0; | ||
46 | } | ||
47 | |||
22 | static int find_next_descriptor(unsigned char *buffer, int size, | 48 | static int find_next_descriptor(unsigned char *buffer, int size, |
23 | int dt1, int dt2, int *num_skipped) | 49 | int dt1, int dt2, int *num_skipped) |
24 | { | 50 | { |
@@ -43,6 +69,129 @@ static int find_next_descriptor(unsigned char *buffer, int size, | |||
43 | return buffer - buffer0; | 69 | return buffer - buffer0; |
44 | } | 70 | } |
45 | 71 | ||
72 | static int usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno, | ||
73 | int inum, int asnum, struct usb_host_endpoint *ep, | ||
74 | int num_ep, unsigned char *buffer, int size) | ||
75 | { | ||
76 | unsigned char *buffer_start = buffer; | ||
77 | struct usb_ss_ep_comp_descriptor *desc; | ||
78 | int retval; | ||
79 | int num_skipped; | ||
80 | int max_tx; | ||
81 | int i; | ||
82 | |||
83 | /* Allocate space for the SS endpoint companion descriptor */ | ||
84 | ep->ss_ep_comp = kzalloc(sizeof(struct usb_host_ss_ep_comp), | ||
85 | GFP_KERNEL); | ||
86 | if (!ep->ss_ep_comp) | ||
87 | return -ENOMEM; | ||
88 | desc = (struct usb_ss_ep_comp_descriptor *) buffer; | ||
89 | if (desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP) { | ||
90 | dev_warn(ddev, "No SuperSpeed endpoint companion for config %d " | ||
91 | " interface %d altsetting %d ep %d: " | ||
92 | "using minimum values\n", | ||
93 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
94 | ep->ss_ep_comp->desc.bLength = USB_DT_SS_EP_COMP_SIZE; | ||
95 | ep->ss_ep_comp->desc.bDescriptorType = USB_DT_SS_ENDPOINT_COMP; | ||
96 | ep->ss_ep_comp->desc.bMaxBurst = 0; | ||
97 | /* | ||
98 | * Leave bmAttributes as zero, which will mean no streams for | ||
99 | * bulk, and isoc won't support multiple bursts of packets. | ||
100 | * With bursts of only one packet, and a Mult of 1, the max | ||
101 | * amount of data moved per endpoint service interval is one | ||
102 | * packet. | ||
103 | */ | ||
104 | if (usb_endpoint_xfer_isoc(&ep->desc) || | ||
105 | usb_endpoint_xfer_int(&ep->desc)) | ||
106 | ep->ss_ep_comp->desc.wBytesPerInterval = | ||
107 | ep->desc.wMaxPacketSize; | ||
108 | /* | ||
109 | * The next descriptor is for an Endpoint or Interface, | ||
110 | * no extra descriptors to copy into the companion structure, | ||
111 | * and we didn't eat up any of the buffer. | ||
112 | */ | ||
113 | retval = 0; | ||
114 | goto valid; | ||
115 | } | ||
116 | memcpy(&ep->ss_ep_comp->desc, desc, USB_DT_SS_EP_COMP_SIZE); | ||
117 | desc = &ep->ss_ep_comp->desc; | ||
118 | buffer += desc->bLength; | ||
119 | size -= desc->bLength; | ||
120 | |||
121 | /* Eat up the other descriptors we don't care about */ | ||
122 | ep->ss_ep_comp->extra = buffer; | ||
123 | i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, | ||
124 | USB_DT_INTERFACE, &num_skipped); | ||
125 | ep->ss_ep_comp->extralen = i; | ||
126 | buffer += i; | ||
127 | size -= i; | ||
128 | retval = buffer - buffer_start + i; | ||
129 | if (num_skipped > 0) | ||
130 | dev_dbg(ddev, "skipped %d descriptor%s after %s\n", | ||
131 | num_skipped, plural(num_skipped), | ||
132 | "SuperSpeed endpoint companion"); | ||
133 | |||
134 | /* Check the various values */ | ||
135 | if (usb_endpoint_xfer_control(&ep->desc) && desc->bMaxBurst != 0) { | ||
136 | dev_warn(ddev, "Control endpoint with bMaxBurst = %d in " | ||
137 | "config %d interface %d altsetting %d ep %d: " | ||
138 | "setting to zero\n", desc->bMaxBurst, | ||
139 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
140 | desc->bMaxBurst = 0; | ||
141 | } | ||
142 | if (desc->bMaxBurst > 15) { | ||
143 | dev_warn(ddev, "Endpoint with bMaxBurst = %d in " | ||
144 | "config %d interface %d altsetting %d ep %d: " | ||
145 | "setting to 15\n", desc->bMaxBurst, | ||
146 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
147 | desc->bMaxBurst = 15; | ||
148 | } | ||
149 | if ((usb_endpoint_xfer_control(&ep->desc) || usb_endpoint_xfer_int(&ep->desc)) | ||
150 | && desc->bmAttributes != 0) { | ||
151 | dev_warn(ddev, "%s endpoint with bmAttributes = %d in " | ||
152 | "config %d interface %d altsetting %d ep %d: " | ||
153 | "setting to zero\n", | ||
154 | usb_endpoint_xfer_control(&ep->desc) ? "Control" : "Bulk", | ||
155 | desc->bmAttributes, | ||
156 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
157 | desc->bmAttributes = 0; | ||
158 | } | ||
159 | if (usb_endpoint_xfer_bulk(&ep->desc) && desc->bmAttributes > 16) { | ||
160 | dev_warn(ddev, "Bulk endpoint with more than 65536 streams in " | ||
161 | "config %d interface %d altsetting %d ep %d: " | ||
162 | "setting to max\n", | ||
163 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
164 | desc->bmAttributes = 16; | ||
165 | } | ||
166 | if (usb_endpoint_xfer_isoc(&ep->desc) && desc->bmAttributes > 2) { | ||
167 | dev_warn(ddev, "Isoc endpoint has Mult of %d in " | ||
168 | "config %d interface %d altsetting %d ep %d: " | ||
169 | "setting to 3\n", desc->bmAttributes + 1, | ||
170 | cfgno, inum, asnum, ep->desc.bEndpointAddress); | ||
171 | desc->bmAttributes = 2; | ||
172 | } | ||
173 | if (usb_endpoint_xfer_isoc(&ep->desc)) { | ||
174 | max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1) * | ||
175 | (desc->bmAttributes + 1); | ||
176 | } else if (usb_endpoint_xfer_int(&ep->desc)) { | ||
177 | max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1); | ||
178 | } else { | ||
179 | goto valid; | ||
180 | } | ||
181 | if (desc->wBytesPerInterval > max_tx) { | ||
182 | dev_warn(ddev, "%s endpoint with wBytesPerInterval of %d in " | ||
183 | "config %d interface %d altsetting %d ep %d: " | ||
184 | "setting to %d\n", | ||
185 | usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int", | ||
186 | desc->wBytesPerInterval, | ||
187 | cfgno, inum, asnum, ep->desc.bEndpointAddress, | ||
188 | max_tx); | ||
189 | desc->wBytesPerInterval = max_tx; | ||
190 | } | ||
191 | valid: | ||
192 | return retval; | ||
193 | } | ||
194 | |||
46 | static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, | 195 | static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, |
47 | int asnum, struct usb_host_interface *ifp, int num_ep, | 196 | int asnum, struct usb_host_interface *ifp, int num_ep, |
48 | unsigned char *buffer, int size) | 197 | unsigned char *buffer, int size) |
@@ -50,7 +199,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, | |||
50 | unsigned char *buffer0 = buffer; | 199 | unsigned char *buffer0 = buffer; |
51 | struct usb_endpoint_descriptor *d; | 200 | struct usb_endpoint_descriptor *d; |
52 | struct usb_host_endpoint *endpoint; | 201 | struct usb_host_endpoint *endpoint; |
53 | int n, i, j; | 202 | int n, i, j, retval; |
54 | 203 | ||
55 | d = (struct usb_endpoint_descriptor *) buffer; | 204 | d = (struct usb_endpoint_descriptor *) buffer; |
56 | buffer += d->bLength; | 205 | buffer += d->bLength; |
@@ -92,6 +241,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, | |||
92 | if (usb_endpoint_xfer_int(d)) { | 241 | if (usb_endpoint_xfer_int(d)) { |
93 | i = 1; | 242 | i = 1; |
94 | switch (to_usb_device(ddev)->speed) { | 243 | switch (to_usb_device(ddev)->speed) { |
244 | case USB_SPEED_SUPER: | ||
95 | case USB_SPEED_HIGH: | 245 | case USB_SPEED_HIGH: |
96 | /* Many device manufacturers are using full-speed | 246 | /* Many device manufacturers are using full-speed |
97 | * bInterval values in high-speed interrupt endpoint | 247 | * bInterval values in high-speed interrupt endpoint |
@@ -161,17 +311,39 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, | |||
161 | cfgno, inum, asnum, d->bEndpointAddress, | 311 | cfgno, inum, asnum, d->bEndpointAddress, |
162 | maxp); | 312 | maxp); |
163 | } | 313 | } |
164 | 314 | /* Allocate room for and parse any SS endpoint companion descriptors */ | |
165 | /* Skip over any Class Specific or Vendor Specific descriptors; | 315 | if (to_usb_device(ddev)->speed == USB_SPEED_SUPER) { |
166 | * find the next endpoint or interface descriptor */ | 316 | endpoint->extra = buffer; |
167 | endpoint->extra = buffer; | 317 | i = find_next_descriptor_more(buffer, size, USB_DT_SS_ENDPOINT_COMP, |
168 | i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, | 318 | USB_DT_ENDPOINT, USB_DT_INTERFACE, &n); |
169 | USB_DT_INTERFACE, &n); | 319 | endpoint->extralen = i; |
170 | endpoint->extralen = i; | 320 | buffer += i; |
321 | size -= i; | ||
322 | |||
323 | if (size > 0) { | ||
324 | retval = usb_parse_ss_endpoint_companion(ddev, cfgno, | ||
325 | inum, asnum, endpoint, num_ep, buffer, | ||
326 | size); | ||
327 | if (retval >= 0) { | ||
328 | buffer += retval; | ||
329 | retval = buffer - buffer0; | ||
330 | } | ||
331 | } else { | ||
332 | retval = buffer - buffer0; | ||
333 | } | ||
334 | } else { | ||
335 | /* Skip over any Class Specific or Vendor Specific descriptors; | ||
336 | * find the next endpoint or interface descriptor */ | ||
337 | endpoint->extra = buffer; | ||
338 | i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, | ||
339 | USB_DT_INTERFACE, &n); | ||
340 | endpoint->extralen = i; | ||
341 | retval = buffer - buffer0 + i; | ||
342 | } | ||
171 | if (n > 0) | 343 | if (n > 0) |
172 | dev_dbg(ddev, "skipped %d descriptor%s after %s\n", | 344 | dev_dbg(ddev, "skipped %d descriptor%s after %s\n", |
173 | n, plural(n), "endpoint"); | 345 | n, plural(n), "endpoint"); |
174 | return buffer - buffer0 + i; | 346 | return retval; |
175 | 347 | ||
176 | skip_to_next_endpoint_or_interface_descriptor: | 348 | skip_to_next_endpoint_or_interface_descriptor: |
177 | i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, | 349 | i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT, |
@@ -452,6 +624,8 @@ static int usb_parse_configuration(struct device *ddev, int cfgidx, | |||
452 | kref_init(&intfc->ref); | 624 | kref_init(&intfc->ref); |
453 | } | 625 | } |
454 | 626 | ||
627 | /* FIXME: parse the BOS descriptor */ | ||
628 | |||
455 | /* Skip over any Class Specific or Vendor Specific descriptors; | 629 | /* Skip over any Class Specific or Vendor Specific descriptors; |
456 | * find the first interface descriptor */ | 630 | * find the first interface descriptor */ |
457 | config->extra = buffer; | 631 | config->extra = buffer; |
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c index d0a21a5f8201..69e5773abfce 100644 --- a/drivers/usb/core/driver.c +++ b/drivers/usb/core/driver.c | |||
@@ -154,16 +154,11 @@ static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *in | |||
154 | static int usb_probe_device(struct device *dev) | 154 | static int usb_probe_device(struct device *dev) |
155 | { | 155 | { |
156 | struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); | 156 | struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); |
157 | struct usb_device *udev; | 157 | struct usb_device *udev = to_usb_device(dev); |
158 | int error = -ENODEV; | 158 | int error = -ENODEV; |
159 | 159 | ||
160 | dev_dbg(dev, "%s\n", __func__); | 160 | dev_dbg(dev, "%s\n", __func__); |
161 | 161 | ||
162 | if (!is_usb_device(dev)) /* Sanity check */ | ||
163 | return error; | ||
164 | |||
165 | udev = to_usb_device(dev); | ||
166 | |||
167 | /* TODO: Add real matching code */ | 162 | /* TODO: Add real matching code */ |
168 | 163 | ||
169 | /* The device should always appear to be in use | 164 | /* The device should always appear to be in use |
@@ -203,18 +198,13 @@ static void usb_cancel_queued_reset(struct usb_interface *iface) | |||
203 | static int usb_probe_interface(struct device *dev) | 198 | static int usb_probe_interface(struct device *dev) |
204 | { | 199 | { |
205 | struct usb_driver *driver = to_usb_driver(dev->driver); | 200 | struct usb_driver *driver = to_usb_driver(dev->driver); |
206 | struct usb_interface *intf; | 201 | struct usb_interface *intf = to_usb_interface(dev); |
207 | struct usb_device *udev; | 202 | struct usb_device *udev = interface_to_usbdev(intf); |
208 | const struct usb_device_id *id; | 203 | const struct usb_device_id *id; |
209 | int error = -ENODEV; | 204 | int error = -ENODEV; |
210 | 205 | ||
211 | dev_dbg(dev, "%s\n", __func__); | 206 | dev_dbg(dev, "%s\n", __func__); |
212 | 207 | ||
213 | if (is_usb_device(dev)) /* Sanity check */ | ||
214 | return error; | ||
215 | |||
216 | intf = to_usb_interface(dev); | ||
217 | udev = interface_to_usbdev(intf); | ||
218 | intf->needs_binding = 0; | 208 | intf->needs_binding = 0; |
219 | 209 | ||
220 | if (udev->authorized == 0) { | 210 | if (udev->authorized == 0) { |
@@ -385,7 +375,6 @@ void usb_driver_release_interface(struct usb_driver *driver, | |||
385 | struct usb_interface *iface) | 375 | struct usb_interface *iface) |
386 | { | 376 | { |
387 | struct device *dev = &iface->dev; | 377 | struct device *dev = &iface->dev; |
388 | struct usb_device *udev = interface_to_usbdev(iface); | ||
389 | 378 | ||
390 | /* this should never happen, don't release something that's not ours */ | 379 | /* this should never happen, don't release something that's not ours */ |
391 | if (!dev->driver || dev->driver != &driver->drvwrap.driver) | 380 | if (!dev->driver || dev->driver != &driver->drvwrap.driver) |
@@ -394,23 +383,19 @@ void usb_driver_release_interface(struct usb_driver *driver, | |||
394 | /* don't release from within disconnect() */ | 383 | /* don't release from within disconnect() */ |
395 | if (iface->condition != USB_INTERFACE_BOUND) | 384 | if (iface->condition != USB_INTERFACE_BOUND) |
396 | return; | 385 | return; |
386 | iface->condition = USB_INTERFACE_UNBINDING; | ||
397 | 387 | ||
398 | /* don't release if the interface hasn't been added yet */ | 388 | /* Release via the driver core only if the interface |
389 | * has already been registered | ||
390 | */ | ||
399 | if (device_is_registered(dev)) { | 391 | if (device_is_registered(dev)) { |
400 | iface->condition = USB_INTERFACE_UNBINDING; | ||
401 | device_release_driver(dev); | 392 | device_release_driver(dev); |
402 | } else { | 393 | } else { |
403 | iface->condition = USB_INTERFACE_UNBOUND; | 394 | down(&dev->sem); |
404 | usb_cancel_queued_reset(iface); | 395 | usb_unbind_interface(dev); |
396 | dev->driver = NULL; | ||
397 | up(&dev->sem); | ||
405 | } | 398 | } |
406 | dev->driver = NULL; | ||
407 | usb_set_intfdata(iface, NULL); | ||
408 | |||
409 | usb_pm_lock(udev); | ||
410 | iface->condition = USB_INTERFACE_UNBOUND; | ||
411 | mark_quiesced(iface); | ||
412 | iface->needs_remote_wakeup = 0; | ||
413 | usb_pm_unlock(udev); | ||
414 | } | 399 | } |
415 | EXPORT_SYMBOL_GPL(usb_driver_release_interface); | 400 | EXPORT_SYMBOL_GPL(usb_driver_release_interface); |
416 | 401 | ||
@@ -598,7 +583,7 @@ static int usb_device_match(struct device *dev, struct device_driver *drv) | |||
598 | /* TODO: Add real matching code */ | 583 | /* TODO: Add real matching code */ |
599 | return 1; | 584 | return 1; |
600 | 585 | ||
601 | } else { | 586 | } else if (is_usb_interface(dev)) { |
602 | struct usb_interface *intf; | 587 | struct usb_interface *intf; |
603 | struct usb_driver *usb_drv; | 588 | struct usb_driver *usb_drv; |
604 | const struct usb_device_id *id; | 589 | const struct usb_device_id *id; |
@@ -630,11 +615,14 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env) | |||
630 | /* driver is often null here; dev_dbg() would oops */ | 615 | /* driver is often null here; dev_dbg() would oops */ |
631 | pr_debug("usb %s: uevent\n", dev_name(dev)); | 616 | pr_debug("usb %s: uevent\n", dev_name(dev)); |
632 | 617 | ||
633 | if (is_usb_device(dev)) | 618 | if (is_usb_device(dev)) { |
634 | usb_dev = to_usb_device(dev); | 619 | usb_dev = to_usb_device(dev); |
635 | else { | 620 | } else if (is_usb_interface(dev)) { |
636 | struct usb_interface *intf = to_usb_interface(dev); | 621 | struct usb_interface *intf = to_usb_interface(dev); |
622 | |||
637 | usb_dev = interface_to_usbdev(intf); | 623 | usb_dev = interface_to_usbdev(intf); |
624 | } else { | ||
625 | return 0; | ||
638 | } | 626 | } |
639 | 627 | ||
640 | if (usb_dev->devnum < 0) { | 628 | if (usb_dev->devnum < 0) { |
@@ -1762,6 +1750,7 @@ int usb_suspend(struct device *dev, pm_message_t msg) | |||
1762 | int usb_resume(struct device *dev, pm_message_t msg) | 1750 | int usb_resume(struct device *dev, pm_message_t msg) |
1763 | { | 1751 | { |
1764 | struct usb_device *udev; | 1752 | struct usb_device *udev; |
1753 | int status; | ||
1765 | 1754 | ||
1766 | udev = to_usb_device(dev); | 1755 | udev = to_usb_device(dev); |
1767 | 1756 | ||
@@ -1771,7 +1760,14 @@ int usb_resume(struct device *dev, pm_message_t msg) | |||
1771 | */ | 1760 | */ |
1772 | if (udev->skip_sys_resume) | 1761 | if (udev->skip_sys_resume) |
1773 | return 0; | 1762 | return 0; |
1774 | return usb_external_resume_device(udev, msg); | 1763 | status = usb_external_resume_device(udev, msg); |
1764 | |||
1765 | /* Avoid PM error messages for devices disconnected while suspended | ||
1766 | * as we'll display regular disconnect messages just a bit later. | ||
1767 | */ | ||
1768 | if (status == -ENODEV) | ||
1769 | return 0; | ||
1770 | return status; | ||
1775 | } | 1771 | } |
1776 | 1772 | ||
1777 | #endif /* CONFIG_PM */ | 1773 | #endif /* CONFIG_PM */ |
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c index 40dee2ac0133..bc39fc40bbde 100644 --- a/drivers/usb/core/endpoint.c +++ b/drivers/usb/core/endpoint.c | |||
@@ -15,19 +15,18 @@ | |||
15 | #include <linux/usb.h> | 15 | #include <linux/usb.h> |
16 | #include "usb.h" | 16 | #include "usb.h" |
17 | 17 | ||
18 | #define MAX_ENDPOINT_MINORS (64*128*32) | ||
19 | static int usb_endpoint_major; | ||
20 | static DEFINE_IDR(endpoint_idr); | ||
21 | |||
22 | struct ep_device { | 18 | struct ep_device { |
23 | struct usb_endpoint_descriptor *desc; | 19 | struct usb_endpoint_descriptor *desc; |
24 | struct usb_device *udev; | 20 | struct usb_device *udev; |
25 | struct device dev; | 21 | struct device dev; |
26 | int minor; | ||
27 | }; | 22 | }; |
28 | #define to_ep_device(_dev) \ | 23 | #define to_ep_device(_dev) \ |
29 | container_of(_dev, struct ep_device, dev) | 24 | container_of(_dev, struct ep_device, dev) |
30 | 25 | ||
26 | struct device_type usb_ep_device_type = { | ||
27 | .name = "usb_endpoint", | ||
28 | }; | ||
29 | |||
31 | struct ep_attribute { | 30 | struct ep_attribute { |
32 | struct attribute attr; | 31 | struct attribute attr; |
33 | ssize_t (*show)(struct usb_device *, | 32 | ssize_t (*show)(struct usb_device *, |
@@ -160,118 +159,10 @@ static struct attribute_group *ep_dev_groups[] = { | |||
160 | NULL | 159 | NULL |
161 | }; | 160 | }; |
162 | 161 | ||
163 | static int usb_endpoint_major_init(void) | ||
164 | { | ||
165 | dev_t dev; | ||
166 | int error; | ||
167 | |||
168 | error = alloc_chrdev_region(&dev, 0, MAX_ENDPOINT_MINORS, | ||
169 | "usb_endpoint"); | ||
170 | if (error) { | ||
171 | printk(KERN_ERR "Unable to get a dynamic major for " | ||
172 | "usb endpoints.\n"); | ||
173 | return error; | ||
174 | } | ||
175 | usb_endpoint_major = MAJOR(dev); | ||
176 | |||
177 | return error; | ||
178 | } | ||
179 | |||
180 | static void usb_endpoint_major_cleanup(void) | ||
181 | { | ||
182 | unregister_chrdev_region(MKDEV(usb_endpoint_major, 0), | ||
183 | MAX_ENDPOINT_MINORS); | ||
184 | } | ||
185 | |||
186 | static int endpoint_get_minor(struct ep_device *ep_dev) | ||
187 | { | ||
188 | static DEFINE_MUTEX(minor_lock); | ||
189 | int retval = -ENOMEM; | ||
190 | int id; | ||
191 | |||
192 | mutex_lock(&minor_lock); | ||
193 | if (idr_pre_get(&endpoint_idr, GFP_KERNEL) == 0) | ||
194 | goto exit; | ||
195 | |||
196 | retval = idr_get_new(&endpoint_idr, ep_dev, &id); | ||
197 | if (retval < 0) { | ||
198 | if (retval == -EAGAIN) | ||
199 | retval = -ENOMEM; | ||
200 | goto exit; | ||
201 | } | ||
202 | ep_dev->minor = id & MAX_ID_MASK; | ||
203 | exit: | ||
204 | mutex_unlock(&minor_lock); | ||
205 | return retval; | ||
206 | } | ||
207 | |||
208 | static void endpoint_free_minor(struct ep_device *ep_dev) | ||
209 | { | ||
210 | idr_remove(&endpoint_idr, ep_dev->minor); | ||
211 | } | ||
212 | |||
213 | static struct endpoint_class { | ||
214 | struct kref kref; | ||
215 | struct class *class; | ||
216 | } *ep_class; | ||
217 | |||
218 | static int init_endpoint_class(void) | ||
219 | { | ||
220 | int result = 0; | ||
221 | |||
222 | if (ep_class != NULL) { | ||
223 | kref_get(&ep_class->kref); | ||
224 | goto exit; | ||
225 | } | ||
226 | |||
227 | ep_class = kmalloc(sizeof(*ep_class), GFP_KERNEL); | ||
228 | if (!ep_class) { | ||
229 | result = -ENOMEM; | ||
230 | goto exit; | ||
231 | } | ||
232 | |||
233 | kref_init(&ep_class->kref); | ||
234 | ep_class->class = class_create(THIS_MODULE, "usb_endpoint"); | ||
235 | if (IS_ERR(ep_class->class)) { | ||
236 | result = PTR_ERR(ep_class->class); | ||
237 | goto class_create_error; | ||
238 | } | ||
239 | |||
240 | result = usb_endpoint_major_init(); | ||
241 | if (result) | ||
242 | goto endpoint_major_error; | ||
243 | |||
244 | goto exit; | ||
245 | |||
246 | endpoint_major_error: | ||
247 | class_destroy(ep_class->class); | ||
248 | class_create_error: | ||
249 | kfree(ep_class); | ||
250 | ep_class = NULL; | ||
251 | exit: | ||
252 | return result; | ||
253 | } | ||
254 | |||
255 | static void release_endpoint_class(struct kref *kref) | ||
256 | { | ||
257 | /* Ok, we cheat as we know we only have one ep_class */ | ||
258 | class_destroy(ep_class->class); | ||
259 | kfree(ep_class); | ||
260 | ep_class = NULL; | ||
261 | usb_endpoint_major_cleanup(); | ||
262 | } | ||
263 | |||
264 | static void destroy_endpoint_class(void) | ||
265 | { | ||
266 | if (ep_class) | ||
267 | kref_put(&ep_class->kref, release_endpoint_class); | ||
268 | } | ||
269 | |||
270 | static void ep_device_release(struct device *dev) | 162 | static void ep_device_release(struct device *dev) |
271 | { | 163 | { |
272 | struct ep_device *ep_dev = to_ep_device(dev); | 164 | struct ep_device *ep_dev = to_ep_device(dev); |
273 | 165 | ||
274 | endpoint_free_minor(ep_dev); | ||
275 | kfree(ep_dev); | 166 | kfree(ep_dev); |
276 | } | 167 | } |
277 | 168 | ||
@@ -279,62 +170,32 @@ int usb_create_ep_devs(struct device *parent, | |||
279 | struct usb_host_endpoint *endpoint, | 170 | struct usb_host_endpoint *endpoint, |
280 | struct usb_device *udev) | 171 | struct usb_device *udev) |
281 | { | 172 | { |
282 | char name[8]; | ||
283 | struct ep_device *ep_dev; | 173 | struct ep_device *ep_dev; |
284 | int retval; | 174 | int retval; |
285 | 175 | ||
286 | retval = init_endpoint_class(); | ||
287 | if (retval) | ||
288 | goto exit; | ||
289 | |||
290 | ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL); | 176 | ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL); |
291 | if (!ep_dev) { | 177 | if (!ep_dev) { |
292 | retval = -ENOMEM; | 178 | retval = -ENOMEM; |
293 | goto error_alloc; | 179 | goto exit; |
294 | } | ||
295 | |||
296 | retval = endpoint_get_minor(ep_dev); | ||
297 | if (retval) { | ||
298 | dev_err(parent, "can not allocate minor number for %s\n", | ||
299 | dev_name(&ep_dev->dev)); | ||
300 | goto error_register; | ||
301 | } | 180 | } |
302 | 181 | ||
303 | ep_dev->desc = &endpoint->desc; | 182 | ep_dev->desc = &endpoint->desc; |
304 | ep_dev->udev = udev; | 183 | ep_dev->udev = udev; |
305 | ep_dev->dev.groups = ep_dev_groups; | 184 | ep_dev->dev.groups = ep_dev_groups; |
306 | ep_dev->dev.devt = MKDEV(usb_endpoint_major, ep_dev->minor); | 185 | ep_dev->dev.type = &usb_ep_device_type; |
307 | ep_dev->dev.class = ep_class->class; | ||
308 | ep_dev->dev.parent = parent; | 186 | ep_dev->dev.parent = parent; |
309 | ep_dev->dev.release = ep_device_release; | 187 | ep_dev->dev.release = ep_device_release; |
310 | dev_set_name(&ep_dev->dev, "usbdev%d.%d_ep%02x", | 188 | dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress); |
311 | udev->bus->busnum, udev->devnum, | ||
312 | endpoint->desc.bEndpointAddress); | ||
313 | 189 | ||
314 | retval = device_register(&ep_dev->dev); | 190 | retval = device_register(&ep_dev->dev); |
315 | if (retval) | 191 | if (retval) |
316 | goto error_chrdev; | 192 | goto error_register; |
317 | 193 | ||
318 | /* create the symlink to the old-style "ep_XX" directory */ | ||
319 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | ||
320 | retval = sysfs_create_link(&parent->kobj, &ep_dev->dev.kobj, name); | ||
321 | if (retval) | ||
322 | goto error_link; | ||
323 | endpoint->ep_dev = ep_dev; | 194 | endpoint->ep_dev = ep_dev; |
324 | return retval; | 195 | return retval; |
325 | 196 | ||
326 | error_link: | ||
327 | device_unregister(&ep_dev->dev); | ||
328 | destroy_endpoint_class(); | ||
329 | return retval; | ||
330 | |||
331 | error_chrdev: | ||
332 | endpoint_free_minor(ep_dev); | ||
333 | |||
334 | error_register: | 197 | error_register: |
335 | kfree(ep_dev); | 198 | kfree(ep_dev); |
336 | error_alloc: | ||
337 | destroy_endpoint_class(); | ||
338 | exit: | 199 | exit: |
339 | return retval; | 200 | return retval; |
340 | } | 201 | } |
@@ -344,12 +205,7 @@ void usb_remove_ep_devs(struct usb_host_endpoint *endpoint) | |||
344 | struct ep_device *ep_dev = endpoint->ep_dev; | 205 | struct ep_device *ep_dev = endpoint->ep_dev; |
345 | 206 | ||
346 | if (ep_dev) { | 207 | if (ep_dev) { |
347 | char name[8]; | ||
348 | |||
349 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | ||
350 | sysfs_remove_link(&ep_dev->dev.parent->kobj, name); | ||
351 | device_unregister(&ep_dev->dev); | 208 | device_unregister(&ep_dev->dev); |
352 | endpoint->ep_dev = NULL; | 209 | endpoint->ep_dev = NULL; |
353 | destroy_endpoint_class(); | ||
354 | } | 210 | } |
355 | } | 211 | } |
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c index a4301dc02d27..91f2885b6ee1 100644 --- a/drivers/usb/core/hcd-pci.c +++ b/drivers/usb/core/hcd-pci.c | |||
@@ -185,194 +185,198 @@ void usb_hcd_pci_remove(struct pci_dev *dev) | |||
185 | } | 185 | } |
186 | EXPORT_SYMBOL_GPL(usb_hcd_pci_remove); | 186 | EXPORT_SYMBOL_GPL(usb_hcd_pci_remove); |
187 | 187 | ||
188 | |||
189 | #ifdef CONFIG_PM | ||
190 | |||
191 | /** | 188 | /** |
192 | * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD | 189 | * usb_hcd_pci_shutdown - shutdown host controller |
193 | * @dev: USB Host Controller being suspended | 190 | * @dev: USB Host Controller being shutdown |
194 | * @message: Power Management message describing this state transition | ||
195 | * | ||
196 | * Store this function in the HCD's struct pci_driver as .suspend. | ||
197 | */ | 191 | */ |
198 | int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message) | 192 | void usb_hcd_pci_shutdown(struct pci_dev *dev) |
193 | { | ||
194 | struct usb_hcd *hcd; | ||
195 | |||
196 | hcd = pci_get_drvdata(dev); | ||
197 | if (!hcd) | ||
198 | return; | ||
199 | |||
200 | if (hcd->driver->shutdown) | ||
201 | hcd->driver->shutdown(hcd); | ||
202 | } | ||
203 | EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown); | ||
204 | |||
205 | #ifdef CONFIG_PM_SLEEP | ||
206 | |||
207 | static int check_root_hub_suspended(struct device *dev) | ||
208 | { | ||
209 | struct pci_dev *pci_dev = to_pci_dev(dev); | ||
210 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); | ||
211 | |||
212 | if (!(hcd->state == HC_STATE_SUSPENDED || | ||
213 | hcd->state == HC_STATE_HALT)) { | ||
214 | dev_warn(dev, "Root hub is not suspended\n"); | ||
215 | return -EBUSY; | ||
216 | } | ||
217 | return 0; | ||
218 | } | ||
219 | |||
220 | static int hcd_pci_suspend(struct device *dev) | ||
199 | { | 221 | { |
200 | struct usb_hcd *hcd = pci_get_drvdata(dev); | 222 | struct pci_dev *pci_dev = to_pci_dev(dev); |
201 | int retval = 0; | 223 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); |
202 | int wake, w; | 224 | int retval; |
203 | int has_pci_pm; | ||
204 | 225 | ||
205 | /* Root hub suspend should have stopped all downstream traffic, | 226 | /* Root hub suspend should have stopped all downstream traffic, |
206 | * and all bus master traffic. And done so for both the interface | 227 | * and all bus master traffic. And done so for both the interface |
207 | * and the stub usb_device (which we check here). But maybe it | 228 | * and the stub usb_device (which we check here). But maybe it |
208 | * didn't; writing sysfs power/state files ignores such rules... | 229 | * didn't; writing sysfs power/state files ignores such rules... |
209 | * | ||
210 | * We must ignore the FREEZE vs SUSPEND distinction here, because | ||
211 | * otherwise the swsusp will save (and restore) garbage state. | ||
212 | */ | 230 | */ |
213 | if (!(hcd->state == HC_STATE_SUSPENDED || | 231 | retval = check_root_hub_suspended(dev); |
214 | hcd->state == HC_STATE_HALT)) { | 232 | if (retval) |
215 | dev_warn(&dev->dev, "Root hub is not suspended\n"); | 233 | return retval; |
216 | retval = -EBUSY; | ||
217 | goto done; | ||
218 | } | ||
219 | 234 | ||
220 | /* We might already be suspended (runtime PM -- not yet written) */ | 235 | /* We might already be suspended (runtime PM -- not yet written) */ |
221 | if (dev->current_state != PCI_D0) | 236 | if (pci_dev->current_state != PCI_D0) |
222 | goto done; | 237 | return retval; |
223 | 238 | ||
224 | if (hcd->driver->pci_suspend) { | 239 | if (hcd->driver->pci_suspend) { |
225 | retval = hcd->driver->pci_suspend(hcd, message); | 240 | retval = hcd->driver->pci_suspend(hcd); |
226 | suspend_report_result(hcd->driver->pci_suspend, retval); | 241 | suspend_report_result(hcd->driver->pci_suspend, retval); |
227 | if (retval) | 242 | if (retval) |
228 | goto done; | 243 | return retval; |
229 | } | 244 | } |
230 | 245 | ||
231 | synchronize_irq(dev->irq); | 246 | synchronize_irq(pci_dev->irq); |
232 | 247 | ||
233 | /* Downstream ports from this root hub should already be quiesced, so | 248 | /* Downstream ports from this root hub should already be quiesced, so |
234 | * there will be no DMA activity. Now we can shut down the upstream | 249 | * there will be no DMA activity. Now we can shut down the upstream |
235 | * link (except maybe for PME# resume signaling) and enter some PCI | 250 | * link (except maybe for PME# resume signaling). We'll enter a |
236 | * low power state, if the hardware allows. | 251 | * low power state during suspend_noirq, if the hardware allows. |
237 | */ | 252 | */ |
238 | pci_disable_device(dev); | 253 | pci_disable_device(pci_dev); |
254 | return retval; | ||
255 | } | ||
256 | |||
257 | static int hcd_pci_suspend_noirq(struct device *dev) | ||
258 | { | ||
259 | struct pci_dev *pci_dev = to_pci_dev(dev); | ||
260 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); | ||
261 | int retval; | ||
262 | |||
263 | retval = check_root_hub_suspended(dev); | ||
264 | if (retval) | ||
265 | return retval; | ||
239 | 266 | ||
240 | pci_save_state(dev); | 267 | pci_save_state(pci_dev); |
241 | 268 | ||
242 | /* Don't fail on error to enable wakeup. We rely on pci code | 269 | /* If the root hub is HALTed rather than SUSPENDed, |
243 | * to reject requests the hardware can't implement, rather | 270 | * disallow remote wakeup. |
244 | * than coding the same thing. | ||
245 | */ | 271 | */ |
246 | wake = (hcd->state == HC_STATE_SUSPENDED && | 272 | if (hcd->state == HC_STATE_HALT) |
247 | device_may_wakeup(&dev->dev)); | 273 | device_set_wakeup_enable(dev, 0); |
248 | w = pci_wake_from_d3(dev, wake); | 274 | dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev)); |
249 | if (w < 0) | ||
250 | wake = w; | ||
251 | dev_dbg(&dev->dev, "wakeup: %d\n", wake); | ||
252 | |||
253 | /* Don't change state if we don't need to */ | ||
254 | if (message.event == PM_EVENT_FREEZE || | ||
255 | message.event == PM_EVENT_PRETHAW) { | ||
256 | dev_dbg(&dev->dev, "--> no state change\n"); | ||
257 | goto done; | ||
258 | } | ||
259 | 275 | ||
260 | has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); | 276 | /* Possibly enable remote wakeup, |
261 | if (!has_pci_pm) { | 277 | * choose the appropriate low-power state, and go to that state. |
262 | dev_dbg(&dev->dev, "--> PCI D0 legacy\n"); | 278 | */ |
279 | retval = pci_prepare_to_sleep(pci_dev); | ||
280 | if (retval == -EIO) { /* Low-power not supported */ | ||
281 | dev_dbg(dev, "--> PCI D0 legacy\n"); | ||
282 | retval = 0; | ||
283 | } else if (retval == 0) { | ||
284 | dev_dbg(dev, "--> PCI %s\n", | ||
285 | pci_power_name(pci_dev->current_state)); | ||
263 | } else { | 286 | } else { |
264 | 287 | suspend_report_result(pci_prepare_to_sleep, retval); | |
265 | /* NOTE: dev->current_state becomes nonzero only here, and | 288 | return retval; |
266 | * only for devices that support PCI PM. Also, exiting | ||
267 | * PCI_D3 (but not PCI_D1 or PCI_D2) is allowed to reset | ||
268 | * some device state (e.g. as part of clock reinit). | ||
269 | */ | ||
270 | retval = pci_set_power_state(dev, PCI_D3hot); | ||
271 | suspend_report_result(pci_set_power_state, retval); | ||
272 | if (retval == 0) { | ||
273 | dev_dbg(&dev->dev, "--> PCI D3\n"); | ||
274 | } else { | ||
275 | dev_dbg(&dev->dev, "PCI D3 suspend fail, %d\n", | ||
276 | retval); | ||
277 | pci_restore_state(dev); | ||
278 | } | ||
279 | } | 289 | } |
280 | 290 | ||
281 | #ifdef CONFIG_PPC_PMAC | 291 | #ifdef CONFIG_PPC_PMAC |
282 | if (retval == 0) { | 292 | /* Disable ASIC clocks for USB */ |
283 | /* Disable ASIC clocks for USB */ | 293 | if (machine_is(powermac)) { |
284 | if (machine_is(powermac)) { | 294 | struct device_node *of_node; |
285 | struct device_node *of_node; | 295 | |
286 | 296 | of_node = pci_device_to_OF_node(pci_dev); | |
287 | of_node = pci_device_to_OF_node(dev); | 297 | if (of_node) |
288 | if (of_node) | 298 | pmac_call_feature(PMAC_FTR_USB_ENABLE, of_node, 0, 0); |
289 | pmac_call_feature(PMAC_FTR_USB_ENABLE, | ||
290 | of_node, 0, 0); | ||
291 | } | ||
292 | } | 299 | } |
293 | #endif | 300 | #endif |
294 | |||
295 | done: | ||
296 | return retval; | 301 | return retval; |
297 | } | 302 | } |
298 | EXPORT_SYMBOL_GPL(usb_hcd_pci_suspend); | ||
299 | 303 | ||
300 | /** | 304 | static int hcd_pci_resume_noirq(struct device *dev) |
301 | * usb_hcd_pci_resume - power management resume of a PCI-based HCD | ||
302 | * @dev: USB Host Controller being resumed | ||
303 | * | ||
304 | * Store this function in the HCD's struct pci_driver as .resume. | ||
305 | */ | ||
306 | int usb_hcd_pci_resume(struct pci_dev *dev) | ||
307 | { | 305 | { |
308 | struct usb_hcd *hcd; | 306 | struct pci_dev *pci_dev = to_pci_dev(dev); |
309 | int retval; | ||
310 | 307 | ||
311 | #ifdef CONFIG_PPC_PMAC | 308 | #ifdef CONFIG_PPC_PMAC |
312 | /* Reenable ASIC clocks for USB */ | 309 | /* Reenable ASIC clocks for USB */ |
313 | if (machine_is(powermac)) { | 310 | if (machine_is(powermac)) { |
314 | struct device_node *of_node; | 311 | struct device_node *of_node; |
315 | 312 | ||
316 | of_node = pci_device_to_OF_node(dev); | 313 | of_node = pci_device_to_OF_node(pci_dev); |
317 | if (of_node) | 314 | if (of_node) |
318 | pmac_call_feature(PMAC_FTR_USB_ENABLE, | 315 | pmac_call_feature(PMAC_FTR_USB_ENABLE, |
319 | of_node, 0, 1); | 316 | of_node, 0, 1); |
320 | } | 317 | } |
321 | #endif | 318 | #endif |
322 | 319 | ||
323 | pci_restore_state(dev); | 320 | /* Go back to D0 and disable remote wakeup */ |
321 | pci_back_from_sleep(pci_dev); | ||
322 | return 0; | ||
323 | } | ||
324 | |||
325 | static int resume_common(struct device *dev, bool hibernated) | ||
326 | { | ||
327 | struct pci_dev *pci_dev = to_pci_dev(dev); | ||
328 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); | ||
329 | int retval; | ||
324 | 330 | ||
325 | hcd = pci_get_drvdata(dev); | ||
326 | if (hcd->state != HC_STATE_SUSPENDED) { | 331 | if (hcd->state != HC_STATE_SUSPENDED) { |
327 | dev_dbg(hcd->self.controller, | 332 | dev_dbg(dev, "can't resume, not suspended!\n"); |
328 | "can't resume, not suspended!\n"); | ||
329 | return 0; | 333 | return 0; |
330 | } | 334 | } |
331 | 335 | ||
332 | pci_enable_wake(dev, PCI_D0, false); | 336 | retval = pci_enable_device(pci_dev); |
333 | |||
334 | retval = pci_enable_device(dev); | ||
335 | if (retval < 0) { | 337 | if (retval < 0) { |
336 | dev_err(&dev->dev, "can't re-enable after resume, %d!\n", | 338 | dev_err(dev, "can't re-enable after resume, %d!\n", retval); |
337 | retval); | ||
338 | return retval; | 339 | return retval; |
339 | } | 340 | } |
340 | 341 | ||
341 | pci_set_master(dev); | 342 | pci_set_master(pci_dev); |
342 | |||
343 | /* yes, ignore this result too... */ | ||
344 | (void) pci_wake_from_d3(dev, 0); | ||
345 | 343 | ||
346 | clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); | 344 | clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); |
347 | 345 | ||
348 | if (hcd->driver->pci_resume) { | 346 | if (hcd->driver->pci_resume) { |
349 | retval = hcd->driver->pci_resume(hcd); | 347 | retval = hcd->driver->pci_resume(hcd, hibernated); |
350 | if (retval) { | 348 | if (retval) { |
351 | dev_err(hcd->self.controller, | 349 | dev_err(dev, "PCI post-resume error %d!\n", retval); |
352 | "PCI post-resume error %d!\n", retval); | ||
353 | usb_hc_died(hcd); | 350 | usb_hc_died(hcd); |
354 | } | 351 | } |
355 | } | 352 | } |
356 | return retval; | 353 | return retval; |
357 | } | 354 | } |
358 | EXPORT_SYMBOL_GPL(usb_hcd_pci_resume); | ||
359 | 355 | ||
360 | #endif /* CONFIG_PM */ | 356 | static int hcd_pci_resume(struct device *dev) |
361 | |||
362 | /** | ||
363 | * usb_hcd_pci_shutdown - shutdown host controller | ||
364 | * @dev: USB Host Controller being shutdown | ||
365 | */ | ||
366 | void usb_hcd_pci_shutdown(struct pci_dev *dev) | ||
367 | { | 357 | { |
368 | struct usb_hcd *hcd; | 358 | return resume_common(dev, false); |
369 | 359 | } | |
370 | hcd = pci_get_drvdata(dev); | ||
371 | if (!hcd) | ||
372 | return; | ||
373 | 360 | ||
374 | if (hcd->driver->shutdown) | 361 | static int hcd_pci_restore(struct device *dev) |
375 | hcd->driver->shutdown(hcd); | 362 | { |
363 | return resume_common(dev, true); | ||
376 | } | 364 | } |
377 | EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown); | ||
378 | 365 | ||
366 | struct dev_pm_ops usb_hcd_pci_pm_ops = { | ||
367 | .suspend = hcd_pci_suspend, | ||
368 | .suspend_noirq = hcd_pci_suspend_noirq, | ||
369 | .resume_noirq = hcd_pci_resume_noirq, | ||
370 | .resume = hcd_pci_resume, | ||
371 | .freeze = check_root_hub_suspended, | ||
372 | .freeze_noirq = check_root_hub_suspended, | ||
373 | .thaw_noirq = NULL, | ||
374 | .thaw = NULL, | ||
375 | .poweroff = hcd_pci_suspend, | ||
376 | .poweroff_noirq = hcd_pci_suspend_noirq, | ||
377 | .restore_noirq = hcd_pci_resume_noirq, | ||
378 | .restore = hcd_pci_restore, | ||
379 | }; | ||
380 | EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops); | ||
381 | |||
382 | #endif /* CONFIG_PM_SLEEP */ | ||
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c index 42b93da1085d..ce3f453f02ef 100644 --- a/drivers/usb/core/hcd.c +++ b/drivers/usb/core/hcd.c | |||
@@ -128,6 +128,27 @@ static inline int is_root_hub(struct usb_device *udev) | |||
128 | #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff) | 128 | #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff) |
129 | #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff) | 129 | #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff) |
130 | 130 | ||
131 | /* usb 3.0 root hub device descriptor */ | ||
132 | static const u8 usb3_rh_dev_descriptor[18] = { | ||
133 | 0x12, /* __u8 bLength; */ | ||
134 | 0x01, /* __u8 bDescriptorType; Device */ | ||
135 | 0x00, 0x03, /* __le16 bcdUSB; v3.0 */ | ||
136 | |||
137 | 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */ | ||
138 | 0x00, /* __u8 bDeviceSubClass; */ | ||
139 | 0x03, /* __u8 bDeviceProtocol; USB 3.0 hub */ | ||
140 | 0x09, /* __u8 bMaxPacketSize0; 2^9 = 512 Bytes */ | ||
141 | |||
142 | 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */ | ||
143 | 0x02, 0x00, /* __le16 idProduct; device 0x0002 */ | ||
144 | KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */ | ||
145 | |||
146 | 0x03, /* __u8 iManufacturer; */ | ||
147 | 0x02, /* __u8 iProduct; */ | ||
148 | 0x01, /* __u8 iSerialNumber; */ | ||
149 | 0x01 /* __u8 bNumConfigurations; */ | ||
150 | }; | ||
151 | |||
131 | /* usb 2.0 root hub device descriptor */ | 152 | /* usb 2.0 root hub device descriptor */ |
132 | static const u8 usb2_rh_dev_descriptor [18] = { | 153 | static const u8 usb2_rh_dev_descriptor [18] = { |
133 | 0x12, /* __u8 bLength; */ | 154 | 0x12, /* __u8 bLength; */ |
@@ -273,6 +294,47 @@ static const u8 hs_rh_config_descriptor [] = { | |||
273 | 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */ | 294 | 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */ |
274 | }; | 295 | }; |
275 | 296 | ||
297 | static const u8 ss_rh_config_descriptor[] = { | ||
298 | /* one configuration */ | ||
299 | 0x09, /* __u8 bLength; */ | ||
300 | 0x02, /* __u8 bDescriptorType; Configuration */ | ||
301 | 0x19, 0x00, /* __le16 wTotalLength; FIXME */ | ||
302 | 0x01, /* __u8 bNumInterfaces; (1) */ | ||
303 | 0x01, /* __u8 bConfigurationValue; */ | ||
304 | 0x00, /* __u8 iConfiguration; */ | ||
305 | 0xc0, /* __u8 bmAttributes; | ||
306 | Bit 7: must be set, | ||
307 | 6: Self-powered, | ||
308 | 5: Remote wakeup, | ||
309 | 4..0: resvd */ | ||
310 | 0x00, /* __u8 MaxPower; */ | ||
311 | |||
312 | /* one interface */ | ||
313 | 0x09, /* __u8 if_bLength; */ | ||
314 | 0x04, /* __u8 if_bDescriptorType; Interface */ | ||
315 | 0x00, /* __u8 if_bInterfaceNumber; */ | ||
316 | 0x00, /* __u8 if_bAlternateSetting; */ | ||
317 | 0x01, /* __u8 if_bNumEndpoints; */ | ||
318 | 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */ | ||
319 | 0x00, /* __u8 if_bInterfaceSubClass; */ | ||
320 | 0x00, /* __u8 if_bInterfaceProtocol; */ | ||
321 | 0x00, /* __u8 if_iInterface; */ | ||
322 | |||
323 | /* one endpoint (status change endpoint) */ | ||
324 | 0x07, /* __u8 ep_bLength; */ | ||
325 | 0x05, /* __u8 ep_bDescriptorType; Endpoint */ | ||
326 | 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */ | ||
327 | 0x03, /* __u8 ep_bmAttributes; Interrupt */ | ||
328 | /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) | ||
329 | * see hub.c:hub_configure() for details. */ | ||
330 | (USB_MAXCHILDREN + 1 + 7) / 8, 0x00, | ||
331 | 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */ | ||
332 | /* | ||
333 | * All 3.0 hubs should have an endpoint companion descriptor, | ||
334 | * but we're ignoring that for now. FIXME? | ||
335 | */ | ||
336 | }; | ||
337 | |||
276 | /*-------------------------------------------------------------------------*/ | 338 | /*-------------------------------------------------------------------------*/ |
277 | 339 | ||
278 | /* | 340 | /* |
@@ -426,23 +488,39 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb) | |||
426 | case DeviceRequest | USB_REQ_GET_DESCRIPTOR: | 488 | case DeviceRequest | USB_REQ_GET_DESCRIPTOR: |
427 | switch (wValue & 0xff00) { | 489 | switch (wValue & 0xff00) { |
428 | case USB_DT_DEVICE << 8: | 490 | case USB_DT_DEVICE << 8: |
429 | if (hcd->driver->flags & HCD_USB2) | 491 | switch (hcd->driver->flags & HCD_MASK) { |
492 | case HCD_USB3: | ||
493 | bufp = usb3_rh_dev_descriptor; | ||
494 | break; | ||
495 | case HCD_USB2: | ||
430 | bufp = usb2_rh_dev_descriptor; | 496 | bufp = usb2_rh_dev_descriptor; |
431 | else if (hcd->driver->flags & HCD_USB11) | 497 | break; |
498 | case HCD_USB11: | ||
432 | bufp = usb11_rh_dev_descriptor; | 499 | bufp = usb11_rh_dev_descriptor; |
433 | else | 500 | break; |
501 | default: | ||
434 | goto error; | 502 | goto error; |
503 | } | ||
435 | len = 18; | 504 | len = 18; |
436 | if (hcd->has_tt) | 505 | if (hcd->has_tt) |
437 | patch_protocol = 1; | 506 | patch_protocol = 1; |
438 | break; | 507 | break; |
439 | case USB_DT_CONFIG << 8: | 508 | case USB_DT_CONFIG << 8: |
440 | if (hcd->driver->flags & HCD_USB2) { | 509 | switch (hcd->driver->flags & HCD_MASK) { |
510 | case HCD_USB3: | ||
511 | bufp = ss_rh_config_descriptor; | ||
512 | len = sizeof ss_rh_config_descriptor; | ||
513 | break; | ||
514 | case HCD_USB2: | ||
441 | bufp = hs_rh_config_descriptor; | 515 | bufp = hs_rh_config_descriptor; |
442 | len = sizeof hs_rh_config_descriptor; | 516 | len = sizeof hs_rh_config_descriptor; |
443 | } else { | 517 | break; |
518 | case HCD_USB11: | ||
444 | bufp = fs_rh_config_descriptor; | 519 | bufp = fs_rh_config_descriptor; |
445 | len = sizeof fs_rh_config_descriptor; | 520 | len = sizeof fs_rh_config_descriptor; |
521 | break; | ||
522 | default: | ||
523 | goto error; | ||
446 | } | 524 | } |
447 | if (device_can_wakeup(&hcd->self.root_hub->dev)) | 525 | if (device_can_wakeup(&hcd->self.root_hub->dev)) |
448 | patch_wakeup = 1; | 526 | patch_wakeup = 1; |
@@ -755,23 +833,6 @@ static struct attribute_group usb_bus_attr_group = { | |||
755 | 833 | ||
756 | /*-------------------------------------------------------------------------*/ | 834 | /*-------------------------------------------------------------------------*/ |
757 | 835 | ||
758 | static struct class *usb_host_class; | ||
759 | |||
760 | int usb_host_init(void) | ||
761 | { | ||
762 | int retval = 0; | ||
763 | |||
764 | usb_host_class = class_create(THIS_MODULE, "usb_host"); | ||
765 | if (IS_ERR(usb_host_class)) | ||
766 | retval = PTR_ERR(usb_host_class); | ||
767 | return retval; | ||
768 | } | ||
769 | |||
770 | void usb_host_cleanup(void) | ||
771 | { | ||
772 | class_destroy(usb_host_class); | ||
773 | } | ||
774 | |||
775 | /** | 836 | /** |
776 | * usb_bus_init - shared initialization code | 837 | * usb_bus_init - shared initialization code |
777 | * @bus: the bus structure being initialized | 838 | * @bus: the bus structure being initialized |
@@ -818,12 +879,6 @@ static int usb_register_bus(struct usb_bus *bus) | |||
818 | set_bit (busnum, busmap.busmap); | 879 | set_bit (busnum, busmap.busmap); |
819 | bus->busnum = busnum; | 880 | bus->busnum = busnum; |
820 | 881 | ||
821 | bus->dev = device_create(usb_host_class, bus->controller, MKDEV(0, 0), | ||
822 | bus, "usb_host%d", busnum); | ||
823 | result = PTR_ERR(bus->dev); | ||
824 | if (IS_ERR(bus->dev)) | ||
825 | goto error_create_class_dev; | ||
826 | |||
827 | /* Add it to the local list of buses */ | 882 | /* Add it to the local list of buses */ |
828 | list_add (&bus->bus_list, &usb_bus_list); | 883 | list_add (&bus->bus_list, &usb_bus_list); |
829 | mutex_unlock(&usb_bus_list_lock); | 884 | mutex_unlock(&usb_bus_list_lock); |
@@ -834,8 +889,6 @@ static int usb_register_bus(struct usb_bus *bus) | |||
834 | "number %d\n", bus->busnum); | 889 | "number %d\n", bus->busnum); |
835 | return 0; | 890 | return 0; |
836 | 891 | ||
837 | error_create_class_dev: | ||
838 | clear_bit(busnum, busmap.busmap); | ||
839 | error_find_busnum: | 892 | error_find_busnum: |
840 | mutex_unlock(&usb_bus_list_lock); | 893 | mutex_unlock(&usb_bus_list_lock); |
841 | return result; | 894 | return result; |
@@ -865,8 +918,6 @@ static void usb_deregister_bus (struct usb_bus *bus) | |||
865 | usb_notify_remove_bus(bus); | 918 | usb_notify_remove_bus(bus); |
866 | 919 | ||
867 | clear_bit (bus->busnum, busmap.busmap); | 920 | clear_bit (bus->busnum, busmap.busmap); |
868 | |||
869 | device_unregister(bus->dev); | ||
870 | } | 921 | } |
871 | 922 | ||
872 | /** | 923 | /** |
@@ -1199,7 +1250,8 @@ static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, | |||
1199 | 1250 | ||
1200 | /* Map the URB's buffers for DMA access. | 1251 | /* Map the URB's buffers for DMA access. |
1201 | * Lower level HCD code should use *_dma exclusively, | 1252 | * Lower level HCD code should use *_dma exclusively, |
1202 | * unless it uses pio or talks to another transport. | 1253 | * unless it uses pio or talks to another transport, |
1254 | * or uses the provided scatter gather list for bulk. | ||
1203 | */ | 1255 | */ |
1204 | if (is_root_hub(urb->dev)) | 1256 | if (is_root_hub(urb->dev)) |
1205 | return 0; | 1257 | return 0; |
@@ -1520,6 +1572,92 @@ rescan: | |||
1520 | } | 1572 | } |
1521 | } | 1573 | } |
1522 | 1574 | ||
1575 | /* Check whether a new configuration or alt setting for an interface | ||
1576 | * will exceed the bandwidth for the bus (or the host controller resources). | ||
1577 | * Only pass in a non-NULL config or interface, not both! | ||
1578 | * Passing NULL for both new_config and new_intf means the device will be | ||
1579 | * de-configured by issuing a set configuration 0 command. | ||
1580 | */ | ||
1581 | int usb_hcd_check_bandwidth(struct usb_device *udev, | ||
1582 | struct usb_host_config *new_config, | ||
1583 | struct usb_interface *new_intf) | ||
1584 | { | ||
1585 | int num_intfs, i, j; | ||
1586 | struct usb_interface_cache *intf_cache; | ||
1587 | struct usb_host_interface *alt = 0; | ||
1588 | int ret = 0; | ||
1589 | struct usb_hcd *hcd; | ||
1590 | struct usb_host_endpoint *ep; | ||
1591 | |||
1592 | hcd = bus_to_hcd(udev->bus); | ||
1593 | if (!hcd->driver->check_bandwidth) | ||
1594 | return 0; | ||
1595 | |||
1596 | /* Configuration is being removed - set configuration 0 */ | ||
1597 | if (!new_config && !new_intf) { | ||
1598 | for (i = 1; i < 16; ++i) { | ||
1599 | ep = udev->ep_out[i]; | ||
1600 | if (ep) | ||
1601 | hcd->driver->drop_endpoint(hcd, udev, ep); | ||
1602 | ep = udev->ep_in[i]; | ||
1603 | if (ep) | ||
1604 | hcd->driver->drop_endpoint(hcd, udev, ep); | ||
1605 | } | ||
1606 | hcd->driver->check_bandwidth(hcd, udev); | ||
1607 | return 0; | ||
1608 | } | ||
1609 | /* Check if the HCD says there's enough bandwidth. Enable all endpoints | ||
1610 | * each interface's alt setting 0 and ask the HCD to check the bandwidth | ||
1611 | * of the bus. There will always be bandwidth for endpoint 0, so it's | ||
1612 | * ok to exclude it. | ||
1613 | */ | ||
1614 | if (new_config) { | ||
1615 | num_intfs = new_config->desc.bNumInterfaces; | ||
1616 | /* Remove endpoints (except endpoint 0, which is always on the | ||
1617 | * schedule) from the old config from the schedule | ||
1618 | */ | ||
1619 | for (i = 1; i < 16; ++i) { | ||
1620 | ep = udev->ep_out[i]; | ||
1621 | if (ep) { | ||
1622 | ret = hcd->driver->drop_endpoint(hcd, udev, ep); | ||
1623 | if (ret < 0) | ||
1624 | goto reset; | ||
1625 | } | ||
1626 | ep = udev->ep_in[i]; | ||
1627 | if (ep) { | ||
1628 | ret = hcd->driver->drop_endpoint(hcd, udev, ep); | ||
1629 | if (ret < 0) | ||
1630 | goto reset; | ||
1631 | } | ||
1632 | } | ||
1633 | for (i = 0; i < num_intfs; ++i) { | ||
1634 | |||
1635 | /* Dig the endpoints for alt setting 0 out of the | ||
1636 | * interface cache for this interface | ||
1637 | */ | ||
1638 | intf_cache = new_config->intf_cache[i]; | ||
1639 | for (j = 0; j < intf_cache->num_altsetting; j++) { | ||
1640 | if (intf_cache->altsetting[j].desc.bAlternateSetting == 0) | ||
1641 | alt = &intf_cache->altsetting[j]; | ||
1642 | } | ||
1643 | if (!alt) { | ||
1644 | printk(KERN_DEBUG "Did not find alt setting 0 for intf %d\n", i); | ||
1645 | continue; | ||
1646 | } | ||
1647 | for (j = 0; j < alt->desc.bNumEndpoints; j++) { | ||
1648 | ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]); | ||
1649 | if (ret < 0) | ||
1650 | goto reset; | ||
1651 | } | ||
1652 | } | ||
1653 | } | ||
1654 | ret = hcd->driver->check_bandwidth(hcd, udev); | ||
1655 | reset: | ||
1656 | if (ret < 0) | ||
1657 | hcd->driver->reset_bandwidth(hcd, udev); | ||
1658 | return ret; | ||
1659 | } | ||
1660 | |||
1523 | /* Disables the endpoint: synchronizes with the hcd to make sure all | 1661 | /* Disables the endpoint: synchronizes with the hcd to make sure all |
1524 | * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must | 1662 | * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must |
1525 | * have been called previously. Use for set_configuration, set_interface, | 1663 | * have been called previously. Use for set_configuration, set_interface, |
@@ -1897,8 +2035,20 @@ int usb_add_hcd(struct usb_hcd *hcd, | |||
1897 | retval = -ENOMEM; | 2035 | retval = -ENOMEM; |
1898 | goto err_allocate_root_hub; | 2036 | goto err_allocate_root_hub; |
1899 | } | 2037 | } |
1900 | rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH : | 2038 | |
1901 | USB_SPEED_FULL; | 2039 | switch (hcd->driver->flags & HCD_MASK) { |
2040 | case HCD_USB11: | ||
2041 | rhdev->speed = USB_SPEED_FULL; | ||
2042 | break; | ||
2043 | case HCD_USB2: | ||
2044 | rhdev->speed = USB_SPEED_HIGH; | ||
2045 | break; | ||
2046 | case HCD_USB3: | ||
2047 | rhdev->speed = USB_SPEED_SUPER; | ||
2048 | break; | ||
2049 | default: | ||
2050 | goto err_allocate_root_hub; | ||
2051 | } | ||
1902 | hcd->self.root_hub = rhdev; | 2052 | hcd->self.root_hub = rhdev; |
1903 | 2053 | ||
1904 | /* wakeup flag init defaults to "everything works" for root hubs, | 2054 | /* wakeup flag init defaults to "everything works" for root hubs, |
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h index e7d4479de41c..d397ecfd5b17 100644 --- a/drivers/usb/core/hcd.h +++ b/drivers/usb/core/hcd.h | |||
@@ -173,6 +173,8 @@ struct hc_driver { | |||
173 | #define HCD_LOCAL_MEM 0x0002 /* HC needs local memory */ | 173 | #define HCD_LOCAL_MEM 0x0002 /* HC needs local memory */ |
174 | #define HCD_USB11 0x0010 /* USB 1.1 */ | 174 | #define HCD_USB11 0x0010 /* USB 1.1 */ |
175 | #define HCD_USB2 0x0020 /* USB 2.0 */ | 175 | #define HCD_USB2 0x0020 /* USB 2.0 */ |
176 | #define HCD_USB3 0x0040 /* USB 3.0 */ | ||
177 | #define HCD_MASK 0x0070 | ||
176 | 178 | ||
177 | /* called to init HCD and root hub */ | 179 | /* called to init HCD and root hub */ |
178 | int (*reset) (struct usb_hcd *hcd); | 180 | int (*reset) (struct usb_hcd *hcd); |
@@ -182,10 +184,10 @@ struct hc_driver { | |||
182 | * a whole, not just the root hub; they're for PCI bus glue. | 184 | * a whole, not just the root hub; they're for PCI bus glue. |
183 | */ | 185 | */ |
184 | /* called after suspending the hub, before entering D3 etc */ | 186 | /* called after suspending the hub, before entering D3 etc */ |
185 | int (*pci_suspend) (struct usb_hcd *hcd, pm_message_t message); | 187 | int (*pci_suspend)(struct usb_hcd *hcd); |
186 | 188 | ||
187 | /* called after entering D0 (etc), before resuming the hub */ | 189 | /* called after entering D0 (etc), before resuming the hub */ |
188 | int (*pci_resume) (struct usb_hcd *hcd); | 190 | int (*pci_resume)(struct usb_hcd *hcd, bool hibernated); |
189 | 191 | ||
190 | /* cleanly make HCD stop writing memory and doing I/O */ | 192 | /* cleanly make HCD stop writing memory and doing I/O */ |
191 | void (*stop) (struct usb_hcd *hcd); | 193 | void (*stop) (struct usb_hcd *hcd); |
@@ -224,6 +226,43 @@ struct hc_driver { | |||
224 | void (*relinquish_port)(struct usb_hcd *, int); | 226 | void (*relinquish_port)(struct usb_hcd *, int); |
225 | /* has a port been handed over to a companion? */ | 227 | /* has a port been handed over to a companion? */ |
226 | int (*port_handed_over)(struct usb_hcd *, int); | 228 | int (*port_handed_over)(struct usb_hcd *, int); |
229 | |||
230 | /* xHCI specific functions */ | ||
231 | /* Called by usb_alloc_dev to alloc HC device structures */ | ||
232 | int (*alloc_dev)(struct usb_hcd *, struct usb_device *); | ||
233 | /* Called by usb_release_dev to free HC device structures */ | ||
234 | void (*free_dev)(struct usb_hcd *, struct usb_device *); | ||
235 | |||
236 | /* Bandwidth computation functions */ | ||
237 | /* Note that add_endpoint() can only be called once per endpoint before | ||
238 | * check_bandwidth() or reset_bandwidth() must be called. | ||
239 | * drop_endpoint() can only be called once per endpoint also. | ||
240 | * A call to xhci_drop_endpoint() followed by a call to xhci_add_endpoint() will | ||
241 | * add the endpoint to the schedule with possibly new parameters denoted by a | ||
242 | * different endpoint descriptor in usb_host_endpoint. | ||
243 | * A call to xhci_add_endpoint() followed by a call to xhci_drop_endpoint() is | ||
244 | * not allowed. | ||
245 | */ | ||
246 | /* Allocate endpoint resources and add them to a new schedule */ | ||
247 | int (*add_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *); | ||
248 | /* Drop an endpoint from a new schedule */ | ||
249 | int (*drop_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *); | ||
250 | /* Check that a new hardware configuration, set using | ||
251 | * endpoint_enable and endpoint_disable, does not exceed bus | ||
252 | * bandwidth. This must be called before any set configuration | ||
253 | * or set interface requests are sent to the device. | ||
254 | */ | ||
255 | int (*check_bandwidth)(struct usb_hcd *, struct usb_device *); | ||
256 | /* Reset the device schedule to the last known good schedule, | ||
257 | * which was set from a previous successful call to | ||
258 | * check_bandwidth(). This reverts any add_endpoint() and | ||
259 | * drop_endpoint() calls since that last successful call. | ||
260 | * Used for when a check_bandwidth() call fails due to resource | ||
261 | * or bandwidth constraints. | ||
262 | */ | ||
263 | void (*reset_bandwidth)(struct usb_hcd *, struct usb_device *); | ||
264 | /* Returns the hardware-chosen device address */ | ||
265 | int (*address_device)(struct usb_hcd *, struct usb_device *udev); | ||
227 | }; | 266 | }; |
228 | 267 | ||
229 | extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb); | 268 | extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb); |
@@ -242,6 +281,9 @@ extern void usb_hcd_disable_endpoint(struct usb_device *udev, | |||
242 | extern void usb_hcd_reset_endpoint(struct usb_device *udev, | 281 | extern void usb_hcd_reset_endpoint(struct usb_device *udev, |
243 | struct usb_host_endpoint *ep); | 282 | struct usb_host_endpoint *ep); |
244 | extern void usb_hcd_synchronize_unlinks(struct usb_device *udev); | 283 | extern void usb_hcd_synchronize_unlinks(struct usb_device *udev); |
284 | extern int usb_hcd_check_bandwidth(struct usb_device *udev, | ||
285 | struct usb_host_config *new_config, | ||
286 | struct usb_interface *new_intf); | ||
245 | extern int usb_hcd_get_frame_number(struct usb_device *udev); | 287 | extern int usb_hcd_get_frame_number(struct usb_device *udev); |
246 | 288 | ||
247 | extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver, | 289 | extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver, |
@@ -261,14 +303,11 @@ struct pci_device_id; | |||
261 | extern int usb_hcd_pci_probe(struct pci_dev *dev, | 303 | extern int usb_hcd_pci_probe(struct pci_dev *dev, |
262 | const struct pci_device_id *id); | 304 | const struct pci_device_id *id); |
263 | extern void usb_hcd_pci_remove(struct pci_dev *dev); | 305 | extern void usb_hcd_pci_remove(struct pci_dev *dev); |
264 | |||
265 | #ifdef CONFIG_PM | ||
266 | extern int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t msg); | ||
267 | extern int usb_hcd_pci_resume(struct pci_dev *dev); | ||
268 | #endif /* CONFIG_PM */ | ||
269 | |||
270 | extern void usb_hcd_pci_shutdown(struct pci_dev *dev); | 306 | extern void usb_hcd_pci_shutdown(struct pci_dev *dev); |
271 | 307 | ||
308 | #ifdef CONFIG_PM_SLEEP | ||
309 | extern struct dev_pm_ops usb_hcd_pci_pm_ops; | ||
310 | #endif | ||
272 | #endif /* CONFIG_PCI */ | 311 | #endif /* CONFIG_PCI */ |
273 | 312 | ||
274 | /* pci-ish (pdev null is ok) buffer alloc/mapping support */ | 313 | /* pci-ish (pdev null is ok) buffer alloc/mapping support */ |
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c index be86ae3f4088..2af3b4f06054 100644 --- a/drivers/usb/core/hub.c +++ b/drivers/usb/core/hub.c | |||
@@ -155,6 +155,8 @@ static inline char *portspeed(int portstatus) | |||
155 | return "480 Mb/s"; | 155 | return "480 Mb/s"; |
156 | else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED)) | 156 | else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED)) |
157 | return "1.5 Mb/s"; | 157 | return "1.5 Mb/s"; |
158 | else if (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED)) | ||
159 | return "5.0 Gb/s"; | ||
158 | else | 160 | else |
159 | return "12 Mb/s"; | 161 | return "12 Mb/s"; |
160 | } | 162 | } |
@@ -457,13 +459,13 @@ static void hub_tt_kevent (struct work_struct *work) | |||
457 | 459 | ||
458 | spin_lock_irqsave (&hub->tt.lock, flags); | 460 | spin_lock_irqsave (&hub->tt.lock, flags); |
459 | while (--limit && !list_empty (&hub->tt.clear_list)) { | 461 | while (--limit && !list_empty (&hub->tt.clear_list)) { |
460 | struct list_head *temp; | 462 | struct list_head *next; |
461 | struct usb_tt_clear *clear; | 463 | struct usb_tt_clear *clear; |
462 | struct usb_device *hdev = hub->hdev; | 464 | struct usb_device *hdev = hub->hdev; |
463 | int status; | 465 | int status; |
464 | 466 | ||
465 | temp = hub->tt.clear_list.next; | 467 | next = hub->tt.clear_list.next; |
466 | clear = list_entry (temp, struct usb_tt_clear, clear_list); | 468 | clear = list_entry (next, struct usb_tt_clear, clear_list); |
467 | list_del (&clear->clear_list); | 469 | list_del (&clear->clear_list); |
468 | 470 | ||
469 | /* drop lock so HCD can concurrently report other TT errors */ | 471 | /* drop lock so HCD can concurrently report other TT errors */ |
@@ -951,6 +953,9 @@ static int hub_configure(struct usb_hub *hub, | |||
951 | ret); | 953 | ret); |
952 | hub->tt.hub = hdev; | 954 | hub->tt.hub = hdev; |
953 | break; | 955 | break; |
956 | case 3: | ||
957 | /* USB 3.0 hubs don't have a TT */ | ||
958 | break; | ||
954 | default: | 959 | default: |
955 | dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", | 960 | dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", |
956 | hdev->descriptor.bDeviceProtocol); | 961 | hdev->descriptor.bDeviceProtocol); |
@@ -1323,6 +1328,11 @@ EXPORT_SYMBOL_GPL(usb_set_device_state); | |||
1323 | * 0 is reserved by USB for default address; (b) Linux's USB stack | 1328 | * 0 is reserved by USB for default address; (b) Linux's USB stack |
1324 | * uses always #1 for the root hub of the controller. So USB stack's | 1329 | * uses always #1 for the root hub of the controller. So USB stack's |
1325 | * port #1, which is wusb virtual-port #0 has address #2. | 1330 | * port #1, which is wusb virtual-port #0 has address #2. |
1331 | * | ||
1332 | * Devices connected under xHCI are not as simple. The host controller | ||
1333 | * supports virtualization, so the hardware assigns device addresses and | ||
1334 | * the HCD must setup data structures before issuing a set address | ||
1335 | * command to the hardware. | ||
1326 | */ | 1336 | */ |
1327 | static void choose_address(struct usb_device *udev) | 1337 | static void choose_address(struct usb_device *udev) |
1328 | { | 1338 | { |
@@ -1642,6 +1652,9 @@ int usb_new_device(struct usb_device *udev) | |||
1642 | err = usb_configure_device(udev); /* detect & probe dev/intfs */ | 1652 | err = usb_configure_device(udev); /* detect & probe dev/intfs */ |
1643 | if (err < 0) | 1653 | if (err < 0) |
1644 | goto fail; | 1654 | goto fail; |
1655 | dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n", | ||
1656 | udev->devnum, udev->bus->busnum, | ||
1657 | (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); | ||
1645 | /* export the usbdev device-node for libusb */ | 1658 | /* export the usbdev device-node for libusb */ |
1646 | udev->dev.devt = MKDEV(USB_DEVICE_MAJOR, | 1659 | udev->dev.devt = MKDEV(USB_DEVICE_MAJOR, |
1647 | (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); | 1660 | (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); |
@@ -2395,19 +2408,29 @@ EXPORT_SYMBOL_GPL(usb_ep0_reinit); | |||
2395 | static int hub_set_address(struct usb_device *udev, int devnum) | 2408 | static int hub_set_address(struct usb_device *udev, int devnum) |
2396 | { | 2409 | { |
2397 | int retval; | 2410 | int retval; |
2411 | struct usb_hcd *hcd = bus_to_hcd(udev->bus); | ||
2398 | 2412 | ||
2399 | if (devnum <= 1) | 2413 | /* |
2414 | * The host controller will choose the device address, | ||
2415 | * instead of the core having chosen it earlier | ||
2416 | */ | ||
2417 | if (!hcd->driver->address_device && devnum <= 1) | ||
2400 | return -EINVAL; | 2418 | return -EINVAL; |
2401 | if (udev->state == USB_STATE_ADDRESS) | 2419 | if (udev->state == USB_STATE_ADDRESS) |
2402 | return 0; | 2420 | return 0; |
2403 | if (udev->state != USB_STATE_DEFAULT) | 2421 | if (udev->state != USB_STATE_DEFAULT) |
2404 | return -EINVAL; | 2422 | return -EINVAL; |
2405 | retval = usb_control_msg(udev, usb_sndaddr0pipe(), | 2423 | if (hcd->driver->address_device) { |
2406 | USB_REQ_SET_ADDRESS, 0, devnum, 0, | 2424 | retval = hcd->driver->address_device(hcd, udev); |
2407 | NULL, 0, USB_CTRL_SET_TIMEOUT); | 2425 | } else { |
2426 | retval = usb_control_msg(udev, usb_sndaddr0pipe(), | ||
2427 | USB_REQ_SET_ADDRESS, 0, devnum, 0, | ||
2428 | NULL, 0, USB_CTRL_SET_TIMEOUT); | ||
2429 | if (retval == 0) | ||
2430 | update_address(udev, devnum); | ||
2431 | } | ||
2408 | if (retval == 0) { | 2432 | if (retval == 0) { |
2409 | /* Device now using proper address. */ | 2433 | /* Device now using proper address. */ |
2410 | update_address(udev, devnum); | ||
2411 | usb_set_device_state(udev, USB_STATE_ADDRESS); | 2434 | usb_set_device_state(udev, USB_STATE_ADDRESS); |
2412 | usb_ep0_reinit(udev); | 2435 | usb_ep0_reinit(udev); |
2413 | } | 2436 | } |
@@ -2430,6 +2453,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2430 | static DEFINE_MUTEX(usb_address0_mutex); | 2453 | static DEFINE_MUTEX(usb_address0_mutex); |
2431 | 2454 | ||
2432 | struct usb_device *hdev = hub->hdev; | 2455 | struct usb_device *hdev = hub->hdev; |
2456 | struct usb_hcd *hcd = bus_to_hcd(hdev->bus); | ||
2433 | int i, j, retval; | 2457 | int i, j, retval; |
2434 | unsigned delay = HUB_SHORT_RESET_TIME; | 2458 | unsigned delay = HUB_SHORT_RESET_TIME; |
2435 | enum usb_device_speed oldspeed = udev->speed; | 2459 | enum usb_device_speed oldspeed = udev->speed; |
@@ -2452,11 +2476,24 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2452 | 2476 | ||
2453 | mutex_lock(&usb_address0_mutex); | 2477 | mutex_lock(&usb_address0_mutex); |
2454 | 2478 | ||
2455 | /* Reset the device; full speed may morph to high speed */ | 2479 | if ((hcd->driver->flags & HCD_USB3) && udev->config) { |
2456 | retval = hub_port_reset(hub, port1, udev, delay); | 2480 | /* FIXME this will need special handling by the xHCI driver. */ |
2457 | if (retval < 0) /* error or disconnect */ | 2481 | dev_dbg(&udev->dev, |
2482 | "xHCI reset of configured device " | ||
2483 | "not supported yet.\n"); | ||
2484 | retval = -EINVAL; | ||
2458 | goto fail; | 2485 | goto fail; |
2459 | /* success, speed is known */ | 2486 | } else if (!udev->config && oldspeed == USB_SPEED_SUPER) { |
2487 | /* Don't reset USB 3.0 devices during an initial setup */ | ||
2488 | usb_set_device_state(udev, USB_STATE_DEFAULT); | ||
2489 | } else { | ||
2490 | /* Reset the device; full speed may morph to high speed */ | ||
2491 | /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */ | ||
2492 | retval = hub_port_reset(hub, port1, udev, delay); | ||
2493 | if (retval < 0) /* error or disconnect */ | ||
2494 | goto fail; | ||
2495 | /* success, speed is known */ | ||
2496 | } | ||
2460 | retval = -ENODEV; | 2497 | retval = -ENODEV; |
2461 | 2498 | ||
2462 | if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) { | 2499 | if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) { |
@@ -2471,6 +2508,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2471 | * reported as 0xff in the device descriptor). WUSB1.0[4.8.1]. | 2508 | * reported as 0xff in the device descriptor). WUSB1.0[4.8.1]. |
2472 | */ | 2509 | */ |
2473 | switch (udev->speed) { | 2510 | switch (udev->speed) { |
2511 | case USB_SPEED_SUPER: | ||
2474 | case USB_SPEED_VARIABLE: /* fixed at 512 */ | 2512 | case USB_SPEED_VARIABLE: /* fixed at 512 */ |
2475 | udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512); | 2513 | udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512); |
2476 | break; | 2514 | break; |
@@ -2496,16 +2534,20 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2496 | case USB_SPEED_LOW: speed = "low"; break; | 2534 | case USB_SPEED_LOW: speed = "low"; break; |
2497 | case USB_SPEED_FULL: speed = "full"; break; | 2535 | case USB_SPEED_FULL: speed = "full"; break; |
2498 | case USB_SPEED_HIGH: speed = "high"; break; | 2536 | case USB_SPEED_HIGH: speed = "high"; break; |
2537 | case USB_SPEED_SUPER: | ||
2538 | speed = "super"; | ||
2539 | break; | ||
2499 | case USB_SPEED_VARIABLE: | 2540 | case USB_SPEED_VARIABLE: |
2500 | speed = "variable"; | 2541 | speed = "variable"; |
2501 | type = "Wireless "; | 2542 | type = "Wireless "; |
2502 | break; | 2543 | break; |
2503 | default: speed = "?"; break; | 2544 | default: speed = "?"; break; |
2504 | } | 2545 | } |
2505 | dev_info (&udev->dev, | 2546 | if (udev->speed != USB_SPEED_SUPER) |
2506 | "%s %s speed %sUSB device using %s and address %d\n", | 2547 | dev_info(&udev->dev, |
2507 | (udev->config) ? "reset" : "new", speed, type, | 2548 | "%s %s speed %sUSB device using %s and address %d\n", |
2508 | udev->bus->controller->driver->name, devnum); | 2549 | (udev->config) ? "reset" : "new", speed, type, |
2550 | udev->bus->controller->driver->name, devnum); | ||
2509 | 2551 | ||
2510 | /* Set up TT records, if needed */ | 2552 | /* Set up TT records, if needed */ |
2511 | if (hdev->tt) { | 2553 | if (hdev->tt) { |
@@ -2530,7 +2572,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2530 | * value. | 2572 | * value. |
2531 | */ | 2573 | */ |
2532 | for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) { | 2574 | for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) { |
2533 | if (USE_NEW_SCHEME(retry_counter)) { | 2575 | /* |
2576 | * An xHCI controller cannot send any packets to a device until | ||
2577 | * a set address command successfully completes. | ||
2578 | */ | ||
2579 | if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) { | ||
2534 | struct usb_device_descriptor *buf; | 2580 | struct usb_device_descriptor *buf; |
2535 | int r = 0; | 2581 | int r = 0; |
2536 | 2582 | ||
@@ -2596,7 +2642,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2596 | * unauthorized address in the Connect Ack sequence; | 2642 | * unauthorized address in the Connect Ack sequence; |
2597 | * authorization will assign the final address. | 2643 | * authorization will assign the final address. |
2598 | */ | 2644 | */ |
2599 | if (udev->wusb == 0) { | 2645 | if (udev->wusb == 0) { |
2600 | for (j = 0; j < SET_ADDRESS_TRIES; ++j) { | 2646 | for (j = 0; j < SET_ADDRESS_TRIES; ++j) { |
2601 | retval = hub_set_address(udev, devnum); | 2647 | retval = hub_set_address(udev, devnum); |
2602 | if (retval >= 0) | 2648 | if (retval >= 0) |
@@ -2609,13 +2655,20 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2609 | devnum, retval); | 2655 | devnum, retval); |
2610 | goto fail; | 2656 | goto fail; |
2611 | } | 2657 | } |
2658 | if (udev->speed == USB_SPEED_SUPER) { | ||
2659 | devnum = udev->devnum; | ||
2660 | dev_info(&udev->dev, | ||
2661 | "%s SuperSpeed USB device using %s and address %d\n", | ||
2662 | (udev->config) ? "reset" : "new", | ||
2663 | udev->bus->controller->driver->name, devnum); | ||
2664 | } | ||
2612 | 2665 | ||
2613 | /* cope with hardware quirkiness: | 2666 | /* cope with hardware quirkiness: |
2614 | * - let SET_ADDRESS settle, some device hardware wants it | 2667 | * - let SET_ADDRESS settle, some device hardware wants it |
2615 | * - read ep0 maxpacket even for high and low speed, | 2668 | * - read ep0 maxpacket even for high and low speed, |
2616 | */ | 2669 | */ |
2617 | msleep(10); | 2670 | msleep(10); |
2618 | if (USE_NEW_SCHEME(retry_counter)) | 2671 | if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) |
2619 | break; | 2672 | break; |
2620 | } | 2673 | } |
2621 | 2674 | ||
@@ -2634,8 +2687,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, | |||
2634 | if (retval) | 2687 | if (retval) |
2635 | goto fail; | 2688 | goto fail; |
2636 | 2689 | ||
2637 | i = udev->descriptor.bMaxPacketSize0 == 0xff? /* wusb device? */ | 2690 | if (udev->descriptor.bMaxPacketSize0 == 0xff || |
2638 | 512 : udev->descriptor.bMaxPacketSize0; | 2691 | udev->speed == USB_SPEED_SUPER) |
2692 | i = 512; | ||
2693 | else | ||
2694 | i = udev->descriptor.bMaxPacketSize0; | ||
2639 | if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) { | 2695 | if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) { |
2640 | if (udev->speed != USB_SPEED_FULL || | 2696 | if (udev->speed != USB_SPEED_FULL || |
2641 | !(i == 8 || i == 16 || i == 32 || i == 64)) { | 2697 | !(i == 8 || i == 16 || i == 32 || i == 64)) { |
@@ -2847,19 +2903,41 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1, | |||
2847 | } | 2903 | } |
2848 | 2904 | ||
2849 | usb_set_device_state(udev, USB_STATE_POWERED); | 2905 | usb_set_device_state(udev, USB_STATE_POWERED); |
2850 | udev->speed = USB_SPEED_UNKNOWN; | ||
2851 | udev->bus_mA = hub->mA_per_port; | 2906 | udev->bus_mA = hub->mA_per_port; |
2852 | udev->level = hdev->level + 1; | 2907 | udev->level = hdev->level + 1; |
2853 | udev->wusb = hub_is_wusb(hub); | 2908 | udev->wusb = hub_is_wusb(hub); |
2854 | 2909 | ||
2855 | /* set the address */ | 2910 | /* |
2856 | choose_address(udev); | 2911 | * USB 3.0 devices are reset automatically before the connect |
2857 | if (udev->devnum <= 0) { | 2912 | * port status change appears, and the root hub port status |
2858 | status = -ENOTCONN; /* Don't retry */ | 2913 | * shows the correct speed. We also get port change |
2859 | goto loop; | 2914 | * notifications for USB 3.0 devices from the USB 3.0 portion of |
2915 | * an external USB 3.0 hub, but this isn't handled correctly yet | ||
2916 | * FIXME. | ||
2917 | */ | ||
2918 | |||
2919 | if (!(hcd->driver->flags & HCD_USB3)) | ||
2920 | udev->speed = USB_SPEED_UNKNOWN; | ||
2921 | else if ((hdev->parent == NULL) && | ||
2922 | (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED))) | ||
2923 | udev->speed = USB_SPEED_SUPER; | ||
2924 | else | ||
2925 | udev->speed = USB_SPEED_UNKNOWN; | ||
2926 | |||
2927 | /* | ||
2928 | * xHCI needs to issue an address device command later | ||
2929 | * in the hub_port_init sequence for SS/HS/FS/LS devices. | ||
2930 | */ | ||
2931 | if (!(hcd->driver->flags & HCD_USB3)) { | ||
2932 | /* set the address */ | ||
2933 | choose_address(udev); | ||
2934 | if (udev->devnum <= 0) { | ||
2935 | status = -ENOTCONN; /* Don't retry */ | ||
2936 | goto loop; | ||
2937 | } | ||
2860 | } | 2938 | } |
2861 | 2939 | ||
2862 | /* reset and get descriptor */ | 2940 | /* reset (non-USB 3.0 devices) and get descriptor */ |
2863 | status = hub_port_init(hub, udev, port1, i); | 2941 | status = hub_port_init(hub, udev, port1, i); |
2864 | if (status < 0) | 2942 | if (status < 0) |
2865 | goto loop; | 2943 | goto loop; |
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h index 2a116ce53c9b..889c0f32a40b 100644 --- a/drivers/usb/core/hub.h +++ b/drivers/usb/core/hub.h | |||
@@ -47,7 +47,10 @@ | |||
47 | #define USB_PORT_FEAT_L1 5 /* L1 suspend */ | 47 | #define USB_PORT_FEAT_L1 5 /* L1 suspend */ |
48 | #define USB_PORT_FEAT_POWER 8 | 48 | #define USB_PORT_FEAT_POWER 8 |
49 | #define USB_PORT_FEAT_LOWSPEED 9 | 49 | #define USB_PORT_FEAT_LOWSPEED 9 |
50 | /* This value was never in Table 11-17 */ | ||
50 | #define USB_PORT_FEAT_HIGHSPEED 10 | 51 | #define USB_PORT_FEAT_HIGHSPEED 10 |
52 | /* This value is also fake */ | ||
53 | #define USB_PORT_FEAT_SUPERSPEED 11 | ||
51 | #define USB_PORT_FEAT_C_CONNECTION 16 | 54 | #define USB_PORT_FEAT_C_CONNECTION 16 |
52 | #define USB_PORT_FEAT_C_ENABLE 17 | 55 | #define USB_PORT_FEAT_C_ENABLE 17 |
53 | #define USB_PORT_FEAT_C_SUSPEND 18 | 56 | #define USB_PORT_FEAT_C_SUSPEND 18 |
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c index b62628377654..2bed83caacb1 100644 --- a/drivers/usb/core/message.c +++ b/drivers/usb/core/message.c | |||
@@ -10,6 +10,7 @@ | |||
10 | #include <linux/mm.h> | 10 | #include <linux/mm.h> |
11 | #include <linux/timer.h> | 11 | #include <linux/timer.h> |
12 | #include <linux/ctype.h> | 12 | #include <linux/ctype.h> |
13 | #include <linux/nls.h> | ||
13 | #include <linux/device.h> | 14 | #include <linux/device.h> |
14 | #include <linux/scatterlist.h> | 15 | #include <linux/scatterlist.h> |
15 | #include <linux/usb/quirks.h> | 16 | #include <linux/usb/quirks.h> |
@@ -364,6 +365,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev, | |||
364 | int i; | 365 | int i; |
365 | int urb_flags; | 366 | int urb_flags; |
366 | int dma; | 367 | int dma; |
368 | int use_sg; | ||
367 | 369 | ||
368 | if (!io || !dev || !sg | 370 | if (!io || !dev || !sg |
369 | || usb_pipecontrol(pipe) | 371 | || usb_pipecontrol(pipe) |
@@ -391,7 +393,19 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev, | |||
391 | if (io->entries <= 0) | 393 | if (io->entries <= 0) |
392 | return io->entries; | 394 | return io->entries; |
393 | 395 | ||
394 | io->urbs = kmalloc(io->entries * sizeof *io->urbs, mem_flags); | 396 | /* If we're running on an xHCI host controller, queue the whole scatter |
397 | * gather list with one call to urb_enqueue(). This is only for bulk, | ||
398 | * as that endpoint type does not care how the data gets broken up | ||
399 | * across frames. | ||
400 | */ | ||
401 | if (usb_pipebulk(pipe) && | ||
402 | bus_to_hcd(dev->bus)->driver->flags & HCD_USB3) { | ||
403 | io->urbs = kmalloc(sizeof *io->urbs, mem_flags); | ||
404 | use_sg = true; | ||
405 | } else { | ||
406 | io->urbs = kmalloc(io->entries * sizeof *io->urbs, mem_flags); | ||
407 | use_sg = false; | ||
408 | } | ||
395 | if (!io->urbs) | 409 | if (!io->urbs) |
396 | goto nomem; | 410 | goto nomem; |
397 | 411 | ||
@@ -401,62 +415,92 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev, | |||
401 | if (usb_pipein(pipe)) | 415 | if (usb_pipein(pipe)) |
402 | urb_flags |= URB_SHORT_NOT_OK; | 416 | urb_flags |= URB_SHORT_NOT_OK; |
403 | 417 | ||
404 | for_each_sg(sg, sg, io->entries, i) { | 418 | if (use_sg) { |
405 | unsigned len; | 419 | io->urbs[0] = usb_alloc_urb(0, mem_flags); |
406 | 420 | if (!io->urbs[0]) { | |
407 | io->urbs[i] = usb_alloc_urb(0, mem_flags); | 421 | io->entries = 0; |
408 | if (!io->urbs[i]) { | ||
409 | io->entries = i; | ||
410 | goto nomem; | 422 | goto nomem; |
411 | } | 423 | } |
412 | 424 | ||
413 | io->urbs[i]->dev = NULL; | 425 | io->urbs[0]->dev = NULL; |
414 | io->urbs[i]->pipe = pipe; | 426 | io->urbs[0]->pipe = pipe; |
415 | io->urbs[i]->interval = period; | 427 | io->urbs[0]->interval = period; |
416 | io->urbs[i]->transfer_flags = urb_flags; | 428 | io->urbs[0]->transfer_flags = urb_flags; |
417 | 429 | ||
418 | io->urbs[i]->complete = sg_complete; | 430 | io->urbs[0]->complete = sg_complete; |
419 | io->urbs[i]->context = io; | 431 | io->urbs[0]->context = io; |
420 | 432 | /* A length of zero means transfer the whole sg list */ | |
421 | /* | 433 | io->urbs[0]->transfer_buffer_length = length; |
422 | * Some systems need to revert to PIO when DMA is temporarily | 434 | if (length == 0) { |
423 | * unavailable. For their sakes, both transfer_buffer and | 435 | for_each_sg(sg, sg, io->entries, i) { |
424 | * transfer_dma are set when possible. However this can only | 436 | io->urbs[0]->transfer_buffer_length += |
425 | * work on systems without: | 437 | sg_dma_len(sg); |
426 | * | 438 | } |
427 | * - HIGHMEM, since DMA buffers located in high memory are | 439 | } |
428 | * not directly addressable by the CPU for PIO; | 440 | io->urbs[0]->sg = io; |
429 | * | 441 | io->urbs[0]->num_sgs = io->entries; |
430 | * - IOMMU, since dma_map_sg() is allowed to use an IOMMU to | 442 | io->entries = 1; |
431 | * make virtually discontiguous buffers be "dma-contiguous" | 443 | } else { |
432 | * so that PIO and DMA need diferent numbers of URBs. | 444 | for_each_sg(sg, sg, io->entries, i) { |
433 | * | 445 | unsigned len; |
434 | * So when HIGHMEM or IOMMU are in use, transfer_buffer is NULL | 446 | |
435 | * to prevent stale pointers and to help spot bugs. | 447 | io->urbs[i] = usb_alloc_urb(0, mem_flags); |
436 | */ | 448 | if (!io->urbs[i]) { |
437 | if (dma) { | 449 | io->entries = i; |
438 | io->urbs[i]->transfer_dma = sg_dma_address(sg); | 450 | goto nomem; |
439 | len = sg_dma_len(sg); | 451 | } |
452 | |||
453 | io->urbs[i]->dev = NULL; | ||
454 | io->urbs[i]->pipe = pipe; | ||
455 | io->urbs[i]->interval = period; | ||
456 | io->urbs[i]->transfer_flags = urb_flags; | ||
457 | |||
458 | io->urbs[i]->complete = sg_complete; | ||
459 | io->urbs[i]->context = io; | ||
460 | |||
461 | /* | ||
462 | * Some systems need to revert to PIO when DMA is | ||
463 | * temporarily unavailable. For their sakes, both | ||
464 | * transfer_buffer and transfer_dma are set when | ||
465 | * possible. However this can only work on systems | ||
466 | * without: | ||
467 | * | ||
468 | * - HIGHMEM, since DMA buffers located in high memory | ||
469 | * are not directly addressable by the CPU for PIO; | ||
470 | * | ||
471 | * - IOMMU, since dma_map_sg() is allowed to use an | ||
472 | * IOMMU to make virtually discontiguous buffers be | ||
473 | * "dma-contiguous" so that PIO and DMA need diferent | ||
474 | * numbers of URBs. | ||
475 | * | ||
476 | * So when HIGHMEM or IOMMU are in use, transfer_buffer | ||
477 | * is NULL to prevent stale pointers and to help spot | ||
478 | * bugs. | ||
479 | */ | ||
480 | if (dma) { | ||
481 | io->urbs[i]->transfer_dma = sg_dma_address(sg); | ||
482 | len = sg_dma_len(sg); | ||
440 | #if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU) | 483 | #if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU) |
441 | io->urbs[i]->transfer_buffer = NULL; | 484 | io->urbs[i]->transfer_buffer = NULL; |
442 | #else | 485 | #else |
443 | io->urbs[i]->transfer_buffer = sg_virt(sg); | 486 | io->urbs[i]->transfer_buffer = sg_virt(sg); |
444 | #endif | 487 | #endif |
445 | } else { | 488 | } else { |
446 | /* hc may use _only_ transfer_buffer */ | 489 | /* hc may use _only_ transfer_buffer */ |
447 | io->urbs[i]->transfer_buffer = sg_virt(sg); | 490 | io->urbs[i]->transfer_buffer = sg_virt(sg); |
448 | len = sg->length; | 491 | len = sg->length; |
449 | } | 492 | } |
450 | 493 | ||
451 | if (length) { | 494 | if (length) { |
452 | len = min_t(unsigned, len, length); | 495 | len = min_t(unsigned, len, length); |
453 | length -= len; | 496 | length -= len; |
454 | if (length == 0) | 497 | if (length == 0) |
455 | io->entries = i + 1; | 498 | io->entries = i + 1; |
499 | } | ||
500 | io->urbs[i]->transfer_buffer_length = len; | ||
456 | } | 501 | } |
457 | io->urbs[i]->transfer_buffer_length = len; | 502 | io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; |
458 | } | 503 | } |
459 | io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; | ||
460 | 504 | ||
461 | /* transaction state */ | 505 | /* transaction state */ |
462 | io->count = io->entries; | 506 | io->count = io->entries; |
@@ -509,6 +553,10 @@ EXPORT_SYMBOL_GPL(usb_sg_init); | |||
509 | * could be transferred. That capability is less useful for low or full | 553 | * could be transferred. That capability is less useful for low or full |
510 | * speed interrupt endpoints, which allow at most one packet per millisecond, | 554 | * speed interrupt endpoints, which allow at most one packet per millisecond, |
511 | * of at most 8 or 64 bytes (respectively). | 555 | * of at most 8 or 64 bytes (respectively). |
556 | * | ||
557 | * It is not necessary to call this function to reserve bandwidth for devices | ||
558 | * under an xHCI host controller, as the bandwidth is reserved when the | ||
559 | * configuration or interface alt setting is selected. | ||
512 | */ | 560 | */ |
513 | void usb_sg_wait(struct usb_sg_request *io) | 561 | void usb_sg_wait(struct usb_sg_request *io) |
514 | { | 562 | { |
@@ -759,7 +807,7 @@ static int usb_string_sub(struct usb_device *dev, unsigned int langid, | |||
759 | } | 807 | } |
760 | 808 | ||
761 | /** | 809 | /** |
762 | * usb_string - returns ISO 8859-1 version of a string descriptor | 810 | * usb_string - returns UTF-8 version of a string descriptor |
763 | * @dev: the device whose string descriptor is being retrieved | 811 | * @dev: the device whose string descriptor is being retrieved |
764 | * @index: the number of the descriptor | 812 | * @index: the number of the descriptor |
765 | * @buf: where to put the string | 813 | * @buf: where to put the string |
@@ -767,17 +815,10 @@ static int usb_string_sub(struct usb_device *dev, unsigned int langid, | |||
767 | * Context: !in_interrupt () | 815 | * Context: !in_interrupt () |
768 | * | 816 | * |
769 | * This converts the UTF-16LE encoded strings returned by devices, from | 817 | * This converts the UTF-16LE encoded strings returned by devices, from |
770 | * usb_get_string_descriptor(), to null-terminated ISO-8859-1 encoded ones | 818 | * usb_get_string_descriptor(), to null-terminated UTF-8 encoded ones |
771 | * that are more usable in most kernel contexts. Note that all characters | 819 | * that are more usable in most kernel contexts. Note that this function |
772 | * in the chosen descriptor that can't be encoded using ISO-8859-1 | ||
773 | * are converted to the question mark ("?") character, and this function | ||
774 | * chooses strings in the first language supported by the device. | 820 | * chooses strings in the first language supported by the device. |
775 | * | 821 | * |
776 | * The ASCII (or, redundantly, "US-ASCII") character set is the seven-bit | ||
777 | * subset of ISO 8859-1. ISO-8859-1 is the eight-bit subset of Unicode, | ||
778 | * and is appropriate for use many uses of English and several other | ||
779 | * Western European languages. (But it doesn't include the "Euro" symbol.) | ||
780 | * | ||
781 | * This call is synchronous, and may not be used in an interrupt context. | 822 | * This call is synchronous, and may not be used in an interrupt context. |
782 | * | 823 | * |
783 | * Returns length of the string (>= 0) or usb_control_msg status (< 0). | 824 | * Returns length of the string (>= 0) or usb_control_msg status (< 0). |
@@ -786,7 +827,6 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size) | |||
786 | { | 827 | { |
787 | unsigned char *tbuf; | 828 | unsigned char *tbuf; |
788 | int err; | 829 | int err; |
789 | unsigned int u, idx; | ||
790 | 830 | ||
791 | if (dev->state == USB_STATE_SUSPENDED) | 831 | if (dev->state == USB_STATE_SUSPENDED) |
792 | return -EHOSTUNREACH; | 832 | return -EHOSTUNREACH; |
@@ -821,16 +861,9 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size) | |||
821 | goto errout; | 861 | goto errout; |
822 | 862 | ||
823 | size--; /* leave room for trailing NULL char in output buffer */ | 863 | size--; /* leave room for trailing NULL char in output buffer */ |
824 | for (idx = 0, u = 2; u < err; u += 2) { | 864 | err = utf16s_to_utf8s((wchar_t *) &tbuf[2], (err - 2) / 2, |
825 | if (idx >= size) | 865 | UTF16_LITTLE_ENDIAN, buf, size); |
826 | break; | 866 | buf[err] = 0; |
827 | if (tbuf[u+1]) /* high byte */ | ||
828 | buf[idx++] = '?'; /* non ISO-8859-1 character */ | ||
829 | else | ||
830 | buf[idx++] = tbuf[u]; | ||
831 | } | ||
832 | buf[idx] = 0; | ||
833 | err = idx; | ||
834 | 867 | ||
835 | if (tbuf[1] != USB_DT_STRING) | 868 | if (tbuf[1] != USB_DT_STRING) |
836 | dev_dbg(&dev->dev, | 869 | dev_dbg(&dev->dev, |
@@ -843,6 +876,9 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size) | |||
843 | } | 876 | } |
844 | EXPORT_SYMBOL_GPL(usb_string); | 877 | EXPORT_SYMBOL_GPL(usb_string); |
845 | 878 | ||
879 | /* one UTF-8-encoded 16-bit character has at most three bytes */ | ||
880 | #define MAX_USB_STRING_SIZE (127 * 3 + 1) | ||
881 | |||
846 | /** | 882 | /** |
847 | * usb_cache_string - read a string descriptor and cache it for later use | 883 | * usb_cache_string - read a string descriptor and cache it for later use |
848 | * @udev: the device whose string descriptor is being read | 884 | * @udev: the device whose string descriptor is being read |
@@ -860,9 +896,9 @@ char *usb_cache_string(struct usb_device *udev, int index) | |||
860 | if (index <= 0) | 896 | if (index <= 0) |
861 | return NULL; | 897 | return NULL; |
862 | 898 | ||
863 | buf = kmalloc(256, GFP_KERNEL); | 899 | buf = kmalloc(MAX_USB_STRING_SIZE, GFP_KERNEL); |
864 | if (buf) { | 900 | if (buf) { |
865 | len = usb_string(udev, index, buf, 256); | 901 | len = usb_string(udev, index, buf, MAX_USB_STRING_SIZE); |
866 | if (len > 0) { | 902 | if (len > 0) { |
867 | smallbuf = kmalloc(++len, GFP_KERNEL); | 903 | smallbuf = kmalloc(++len, GFP_KERNEL); |
868 | if (!smallbuf) | 904 | if (!smallbuf) |
@@ -1664,6 +1700,21 @@ free_interfaces: | |||
1664 | if (ret) | 1700 | if (ret) |
1665 | goto free_interfaces; | 1701 | goto free_interfaces; |
1666 | 1702 | ||
1703 | /* Make sure we have bandwidth (and available HCD resources) for this | ||
1704 | * configuration. Remove endpoints from the schedule if we're dropping | ||
1705 | * this configuration to set configuration 0. After this point, the | ||
1706 | * host controller will not allow submissions to dropped endpoints. If | ||
1707 | * this call fails, the device state is unchanged. | ||
1708 | */ | ||
1709 | if (cp) | ||
1710 | ret = usb_hcd_check_bandwidth(dev, cp, NULL); | ||
1711 | else | ||
1712 | ret = usb_hcd_check_bandwidth(dev, NULL, NULL); | ||
1713 | if (ret < 0) { | ||
1714 | usb_autosuspend_device(dev); | ||
1715 | goto free_interfaces; | ||
1716 | } | ||
1717 | |||
1667 | /* if it's already configured, clear out old state first. | 1718 | /* if it's already configured, clear out old state first. |
1668 | * getting rid of old interfaces means unbinding their drivers. | 1719 | * getting rid of old interfaces means unbinding their drivers. |
1669 | */ | 1720 | */ |
@@ -1686,6 +1737,7 @@ free_interfaces: | |||
1686 | dev->actconfig = cp; | 1737 | dev->actconfig = cp; |
1687 | if (!cp) { | 1738 | if (!cp) { |
1688 | usb_set_device_state(dev, USB_STATE_ADDRESS); | 1739 | usb_set_device_state(dev, USB_STATE_ADDRESS); |
1740 | usb_hcd_check_bandwidth(dev, NULL, NULL); | ||
1689 | usb_autosuspend_device(dev); | 1741 | usb_autosuspend_device(dev); |
1690 | goto free_interfaces; | 1742 | goto free_interfaces; |
1691 | } | 1743 | } |
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c index c66789197927..b5c72e458943 100644 --- a/drivers/usb/core/sysfs.c +++ b/drivers/usb/core/sysfs.c | |||
@@ -552,8 +552,8 @@ static struct attribute *dev_string_attrs[] = { | |||
552 | static mode_t dev_string_attrs_are_visible(struct kobject *kobj, | 552 | static mode_t dev_string_attrs_are_visible(struct kobject *kobj, |
553 | struct attribute *a, int n) | 553 | struct attribute *a, int n) |
554 | { | 554 | { |
555 | struct usb_device *udev = to_usb_device( | 555 | struct device *dev = container_of(kobj, struct device, kobj); |
556 | container_of(kobj, struct device, kobj)); | 556 | struct usb_device *udev = to_usb_device(dev); |
557 | 557 | ||
558 | if (a == &dev_attr_manufacturer.attr) { | 558 | if (a == &dev_attr_manufacturer.attr) { |
559 | if (udev->manufacturer == NULL) | 559 | if (udev->manufacturer == NULL) |
@@ -585,8 +585,8 @@ static ssize_t | |||
585 | read_descriptors(struct kobject *kobj, struct bin_attribute *attr, | 585 | read_descriptors(struct kobject *kobj, struct bin_attribute *attr, |
586 | char *buf, loff_t off, size_t count) | 586 | char *buf, loff_t off, size_t count) |
587 | { | 587 | { |
588 | struct usb_device *udev = to_usb_device( | 588 | struct device *dev = container_of(kobj, struct device, kobj); |
589 | container_of(kobj, struct device, kobj)); | 589 | struct usb_device *udev = to_usb_device(dev); |
590 | size_t nleft = count; | 590 | size_t nleft = count; |
591 | size_t srclen, n; | 591 | size_t srclen, n; |
592 | int cfgno; | 592 | int cfgno; |
@@ -786,8 +786,8 @@ static struct attribute *intf_assoc_attrs[] = { | |||
786 | static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj, | 786 | static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj, |
787 | struct attribute *a, int n) | 787 | struct attribute *a, int n) |
788 | { | 788 | { |
789 | struct usb_interface *intf = to_usb_interface( | 789 | struct device *dev = container_of(kobj, struct device, kobj); |
790 | container_of(kobj, struct device, kobj)); | 790 | struct usb_interface *intf = to_usb_interface(dev); |
791 | 791 | ||
792 | if (intf->intf_assoc == NULL) | 792 | if (intf->intf_assoc == NULL) |
793 | return 0; | 793 | return 0; |
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c index 3376055f36e7..0885d4abdc62 100644 --- a/drivers/usb/core/urb.c +++ b/drivers/usb/core/urb.c | |||
@@ -241,6 +241,12 @@ EXPORT_SYMBOL_GPL(usb_unanchor_urb); | |||
241 | * If the USB subsystem can't allocate sufficient bandwidth to perform | 241 | * If the USB subsystem can't allocate sufficient bandwidth to perform |
242 | * the periodic request, submitting such a periodic request should fail. | 242 | * the periodic request, submitting such a periodic request should fail. |
243 | * | 243 | * |
244 | * For devices under xHCI, the bandwidth is reserved at configuration time, or | ||
245 | * when the alt setting is selected. If there is not enough bus bandwidth, the | ||
246 | * configuration/alt setting request will fail. Therefore, submissions to | ||
247 | * periodic endpoints on devices under xHCI should never fail due to bandwidth | ||
248 | * constraints. | ||
249 | * | ||
244 | * Device drivers must explicitly request that repetition, by ensuring that | 250 | * Device drivers must explicitly request that repetition, by ensuring that |
245 | * some URB is always on the endpoint's queue (except possibly for short | 251 | * some URB is always on the endpoint's queue (except possibly for short |
246 | * periods during completion callacks). When there is no longer an urb | 252 | * periods during completion callacks). When there is no longer an urb |
@@ -351,6 +357,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags) | |||
351 | if (xfertype == USB_ENDPOINT_XFER_ISOC) { | 357 | if (xfertype == USB_ENDPOINT_XFER_ISOC) { |
352 | int n, len; | 358 | int n, len; |
353 | 359 | ||
360 | /* FIXME SuperSpeed isoc endpoints have up to 16 bursts */ | ||
354 | /* "high bandwidth" mode, 1-3 packets/uframe? */ | 361 | /* "high bandwidth" mode, 1-3 packets/uframe? */ |
355 | if (dev->speed == USB_SPEED_HIGH) { | 362 | if (dev->speed == USB_SPEED_HIGH) { |
356 | int mult = 1 + ((max >> 11) & 0x03); | 363 | int mult = 1 + ((max >> 11) & 0x03); |
@@ -426,6 +433,11 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags) | |||
426 | return -EINVAL; | 433 | return -EINVAL; |
427 | /* too big? */ | 434 | /* too big? */ |
428 | switch (dev->speed) { | 435 | switch (dev->speed) { |
436 | case USB_SPEED_SUPER: /* units are 125us */ | ||
437 | /* Handle up to 2^(16-1) microframes */ | ||
438 | if (urb->interval > (1 << 15)) | ||
439 | return -EINVAL; | ||
440 | max = 1 << 15; | ||
429 | case USB_SPEED_HIGH: /* units are microframes */ | 441 | case USB_SPEED_HIGH: /* units are microframes */ |
430 | /* NOTE usb handles 2^15 */ | 442 | /* NOTE usb handles 2^15 */ |
431 | if (urb->interval > (1024 * 8)) | 443 | if (urb->interval > (1024 * 8)) |
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c index 927a27dd2f85..a26f73880c32 100644 --- a/drivers/usb/core/usb.c +++ b/drivers/usb/core/usb.c | |||
@@ -34,6 +34,7 @@ | |||
34 | #include <linux/usb.h> | 34 | #include <linux/usb.h> |
35 | #include <linux/mutex.h> | 35 | #include <linux/mutex.h> |
36 | #include <linux/workqueue.h> | 36 | #include <linux/workqueue.h> |
37 | #include <linux/debugfs.h> | ||
37 | 38 | ||
38 | #include <asm/io.h> | 39 | #include <asm/io.h> |
39 | #include <linux/scatterlist.h> | 40 | #include <linux/scatterlist.h> |
@@ -139,8 +140,7 @@ static int __find_interface(struct device *dev, void *data) | |||
139 | struct find_interface_arg *arg = data; | 140 | struct find_interface_arg *arg = data; |
140 | struct usb_interface *intf; | 141 | struct usb_interface *intf; |
141 | 142 | ||
142 | /* can't look at usb devices, only interfaces */ | 143 | if (!is_usb_interface(dev)) |
143 | if (is_usb_device(dev)) | ||
144 | return 0; | 144 | return 0; |
145 | 145 | ||
146 | intf = to_usb_interface(dev); | 146 | intf = to_usb_interface(dev); |
@@ -184,11 +184,16 @@ EXPORT_SYMBOL_GPL(usb_find_interface); | |||
184 | static void usb_release_dev(struct device *dev) | 184 | static void usb_release_dev(struct device *dev) |
185 | { | 185 | { |
186 | struct usb_device *udev; | 186 | struct usb_device *udev; |
187 | struct usb_hcd *hcd; | ||
187 | 188 | ||
188 | udev = to_usb_device(dev); | 189 | udev = to_usb_device(dev); |
190 | hcd = bus_to_hcd(udev->bus); | ||
189 | 191 | ||
190 | usb_destroy_configuration(udev); | 192 | usb_destroy_configuration(udev); |
191 | usb_put_hcd(bus_to_hcd(udev->bus)); | 193 | /* Root hubs aren't real devices, so don't free HCD resources */ |
194 | if (hcd->driver->free_dev && udev->parent) | ||
195 | hcd->driver->free_dev(hcd, udev); | ||
196 | usb_put_hcd(hcd); | ||
192 | kfree(udev->product); | 197 | kfree(udev->product); |
193 | kfree(udev->manufacturer); | 198 | kfree(udev->manufacturer); |
194 | kfree(udev->serial); | 199 | kfree(udev->serial); |
@@ -359,6 +364,13 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent, | |||
359 | kfree(dev); | 364 | kfree(dev); |
360 | return NULL; | 365 | return NULL; |
361 | } | 366 | } |
367 | /* Root hubs aren't true devices, so don't allocate HCD resources */ | ||
368 | if (usb_hcd->driver->alloc_dev && parent && | ||
369 | !usb_hcd->driver->alloc_dev(usb_hcd, dev)) { | ||
370 | usb_put_hcd(bus_to_hcd(bus)); | ||
371 | kfree(dev); | ||
372 | return NULL; | ||
373 | } | ||
362 | 374 | ||
363 | device_initialize(&dev->dev); | 375 | device_initialize(&dev->dev); |
364 | dev->dev.bus = &usb_bus_type; | 376 | dev->dev.bus = &usb_bus_type; |
@@ -386,18 +398,24 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent, | |||
386 | */ | 398 | */ |
387 | if (unlikely(!parent)) { | 399 | if (unlikely(!parent)) { |
388 | dev->devpath[0] = '0'; | 400 | dev->devpath[0] = '0'; |
401 | dev->route = 0; | ||
389 | 402 | ||
390 | dev->dev.parent = bus->controller; | 403 | dev->dev.parent = bus->controller; |
391 | dev_set_name(&dev->dev, "usb%d", bus->busnum); | 404 | dev_set_name(&dev->dev, "usb%d", bus->busnum); |
392 | root_hub = 1; | 405 | root_hub = 1; |
393 | } else { | 406 | } else { |
394 | /* match any labeling on the hubs; it's one-based */ | 407 | /* match any labeling on the hubs; it's one-based */ |
395 | if (parent->devpath[0] == '0') | 408 | if (parent->devpath[0] == '0') { |
396 | snprintf(dev->devpath, sizeof dev->devpath, | 409 | snprintf(dev->devpath, sizeof dev->devpath, |
397 | "%d", port1); | 410 | "%d", port1); |
398 | else | 411 | /* Root ports are not counted in route string */ |
412 | dev->route = 0; | ||
413 | } else { | ||
399 | snprintf(dev->devpath, sizeof dev->devpath, | 414 | snprintf(dev->devpath, sizeof dev->devpath, |
400 | "%s.%d", parent->devpath, port1); | 415 | "%s.%d", parent->devpath, port1); |
416 | dev->route = parent->route + | ||
417 | (port1 << ((parent->level - 1)*4)); | ||
418 | } | ||
401 | 419 | ||
402 | dev->dev.parent = &parent->dev; | 420 | dev->dev.parent = &parent->dev; |
403 | dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); | 421 | dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); |
@@ -810,12 +828,12 @@ void usb_buffer_dmasync(struct urb *urb) | |||
810 | return; | 828 | return; |
811 | 829 | ||
812 | if (controller->dma_mask) { | 830 | if (controller->dma_mask) { |
813 | dma_sync_single(controller, | 831 | dma_sync_single_for_cpu(controller, |
814 | urb->transfer_dma, urb->transfer_buffer_length, | 832 | urb->transfer_dma, urb->transfer_buffer_length, |
815 | usb_pipein(urb->pipe) | 833 | usb_pipein(urb->pipe) |
816 | ? DMA_FROM_DEVICE : DMA_TO_DEVICE); | 834 | ? DMA_FROM_DEVICE : DMA_TO_DEVICE); |
817 | if (usb_pipecontrol(urb->pipe)) | 835 | if (usb_pipecontrol(urb->pipe)) |
818 | dma_sync_single(controller, | 836 | dma_sync_single_for_cpu(controller, |
819 | urb->setup_dma, | 837 | urb->setup_dma, |
820 | sizeof(struct usb_ctrlrequest), | 838 | sizeof(struct usb_ctrlrequest), |
821 | DMA_TO_DEVICE); | 839 | DMA_TO_DEVICE); |
@@ -933,8 +951,8 @@ void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in, | |||
933 | || !controller->dma_mask) | 951 | || !controller->dma_mask) |
934 | return; | 952 | return; |
935 | 953 | ||
936 | dma_sync_sg(controller, sg, n_hw_ents, | 954 | dma_sync_sg_for_cpu(controller, sg, n_hw_ents, |
937 | is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); | 955 | is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); |
938 | } | 956 | } |
939 | EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg); | 957 | EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg); |
940 | #endif | 958 | #endif |
@@ -1012,6 +1030,35 @@ static struct notifier_block usb_bus_nb = { | |||
1012 | .notifier_call = usb_bus_notify, | 1030 | .notifier_call = usb_bus_notify, |
1013 | }; | 1031 | }; |
1014 | 1032 | ||
1033 | struct dentry *usb_debug_root; | ||
1034 | EXPORT_SYMBOL_GPL(usb_debug_root); | ||
1035 | |||
1036 | struct dentry *usb_debug_devices; | ||
1037 | |||
1038 | static int usb_debugfs_init(void) | ||
1039 | { | ||
1040 | usb_debug_root = debugfs_create_dir("usb", NULL); | ||
1041 | if (!usb_debug_root) | ||
1042 | return -ENOENT; | ||
1043 | |||
1044 | usb_debug_devices = debugfs_create_file("devices", 0444, | ||
1045 | usb_debug_root, NULL, | ||
1046 | &usbfs_devices_fops); | ||
1047 | if (!usb_debug_devices) { | ||
1048 | debugfs_remove(usb_debug_root); | ||
1049 | usb_debug_root = NULL; | ||
1050 | return -ENOENT; | ||
1051 | } | ||
1052 | |||
1053 | return 0; | ||
1054 | } | ||
1055 | |||
1056 | static void usb_debugfs_cleanup(void) | ||
1057 | { | ||
1058 | debugfs_remove(usb_debug_devices); | ||
1059 | debugfs_remove(usb_debug_root); | ||
1060 | } | ||
1061 | |||
1015 | /* | 1062 | /* |
1016 | * Init | 1063 | * Init |
1017 | */ | 1064 | */ |
@@ -1023,6 +1070,10 @@ static int __init usb_init(void) | |||
1023 | return 0; | 1070 | return 0; |
1024 | } | 1071 | } |
1025 | 1072 | ||
1073 | retval = usb_debugfs_init(); | ||
1074 | if (retval) | ||
1075 | goto out; | ||
1076 | |||
1026 | retval = ksuspend_usb_init(); | 1077 | retval = ksuspend_usb_init(); |
1027 | if (retval) | 1078 | if (retval) |
1028 | goto out; | 1079 | goto out; |
@@ -1032,9 +1083,6 @@ static int __init usb_init(void) | |||
1032 | retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); | 1083 | retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); |
1033 | if (retval) | 1084 | if (retval) |
1034 | goto bus_notifier_failed; | 1085 | goto bus_notifier_failed; |
1035 | retval = usb_host_init(); | ||
1036 | if (retval) | ||
1037 | goto host_init_failed; | ||
1038 | retval = usb_major_init(); | 1086 | retval = usb_major_init(); |
1039 | if (retval) | 1087 | if (retval) |
1040 | goto major_init_failed; | 1088 | goto major_init_failed; |
@@ -1064,8 +1112,6 @@ usb_devio_init_failed: | |||
1064 | driver_register_failed: | 1112 | driver_register_failed: |
1065 | usb_major_cleanup(); | 1113 | usb_major_cleanup(); |
1066 | major_init_failed: | 1114 | major_init_failed: |
1067 | usb_host_cleanup(); | ||
1068 | host_init_failed: | ||
1069 | bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); | 1115 | bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); |
1070 | bus_notifier_failed: | 1116 | bus_notifier_failed: |
1071 | bus_unregister(&usb_bus_type); | 1117 | bus_unregister(&usb_bus_type); |
@@ -1090,10 +1136,10 @@ static void __exit usb_exit(void) | |||
1090 | usb_deregister(&usbfs_driver); | 1136 | usb_deregister(&usbfs_driver); |
1091 | usb_devio_cleanup(); | 1137 | usb_devio_cleanup(); |
1092 | usb_hub_cleanup(); | 1138 | usb_hub_cleanup(); |
1093 | usb_host_cleanup(); | ||
1094 | bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); | 1139 | bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); |
1095 | bus_unregister(&usb_bus_type); | 1140 | bus_unregister(&usb_bus_type); |
1096 | ksuspend_usb_cleanup(); | 1141 | ksuspend_usb_cleanup(); |
1142 | usb_debugfs_cleanup(); | ||
1097 | } | 1143 | } |
1098 | 1144 | ||
1099 | subsys_initcall(usb_init); | 1145 | subsys_initcall(usb_init); |
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h index 79d8a9ea559b..e2a8cfaade1d 100644 --- a/drivers/usb/core/usb.h +++ b/drivers/usb/core/usb.h | |||
@@ -41,8 +41,6 @@ extern int usb_hub_init(void); | |||
41 | extern void usb_hub_cleanup(void); | 41 | extern void usb_hub_cleanup(void); |
42 | extern int usb_major_init(void); | 42 | extern int usb_major_init(void); |
43 | extern void usb_major_cleanup(void); | 43 | extern void usb_major_cleanup(void); |
44 | extern int usb_host_init(void); | ||
45 | extern void usb_host_cleanup(void); | ||
46 | 44 | ||
47 | #ifdef CONFIG_PM | 45 | #ifdef CONFIG_PM |
48 | 46 | ||
@@ -106,6 +104,7 @@ extern struct workqueue_struct *ksuspend_usb_wq; | |||
106 | extern struct bus_type usb_bus_type; | 104 | extern struct bus_type usb_bus_type; |
107 | extern struct device_type usb_device_type; | 105 | extern struct device_type usb_device_type; |
108 | extern struct device_type usb_if_device_type; | 106 | extern struct device_type usb_if_device_type; |
107 | extern struct device_type usb_ep_device_type; | ||
109 | extern struct usb_device_driver usb_generic_driver; | 108 | extern struct usb_device_driver usb_generic_driver; |
110 | 109 | ||
111 | static inline int is_usb_device(const struct device *dev) | 110 | static inline int is_usb_device(const struct device *dev) |
@@ -113,6 +112,16 @@ static inline int is_usb_device(const struct device *dev) | |||
113 | return dev->type == &usb_device_type; | 112 | return dev->type == &usb_device_type; |
114 | } | 113 | } |
115 | 114 | ||
115 | static inline int is_usb_interface(const struct device *dev) | ||
116 | { | ||
117 | return dev->type == &usb_if_device_type; | ||
118 | } | ||
119 | |||
120 | static inline int is_usb_endpoint(const struct device *dev) | ||
121 | { | ||
122 | return dev->type == &usb_ep_device_type; | ||
123 | } | ||
124 | |||
116 | /* Do the same for device drivers and interface drivers. */ | 125 | /* Do the same for device drivers and interface drivers. */ |
117 | 126 | ||
118 | static inline int is_usb_device_driver(struct device_driver *drv) | 127 | static inline int is_usb_device_driver(struct device_driver *drv) |
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig index 080bb1e4b847..5d1ddf485d1e 100644 --- a/drivers/usb/gadget/Kconfig +++ b/drivers/usb/gadget/Kconfig | |||
@@ -156,7 +156,7 @@ config USB_ATMEL_USBA | |||
156 | 156 | ||
157 | config USB_GADGET_FSL_USB2 | 157 | config USB_GADGET_FSL_USB2 |
158 | boolean "Freescale Highspeed USB DR Peripheral Controller" | 158 | boolean "Freescale Highspeed USB DR Peripheral Controller" |
159 | depends on FSL_SOC | 159 | depends on FSL_SOC || ARCH_MXC |
160 | select USB_GADGET_DUALSPEED | 160 | select USB_GADGET_DUALSPEED |
161 | help | 161 | help |
162 | Some of Freescale PowerPC processors have a High Speed | 162 | Some of Freescale PowerPC processors have a High Speed |
@@ -253,7 +253,7 @@ config USB_PXA25X_SMALL | |||
253 | 253 | ||
254 | config USB_GADGET_PXA27X | 254 | config USB_GADGET_PXA27X |
255 | boolean "PXA 27x" | 255 | boolean "PXA 27x" |
256 | depends on ARCH_PXA && PXA27x | 256 | depends on ARCH_PXA && (PXA27x || PXA3xx) |
257 | select USB_OTG_UTILS | 257 | select USB_OTG_UTILS |
258 | help | 258 | help |
259 | Intel's PXA 27x series XScale ARM v5TE processors include | 259 | Intel's PXA 27x series XScale ARM v5TE processors include |
@@ -272,6 +272,20 @@ config USB_PXA27X | |||
272 | default USB_GADGET | 272 | default USB_GADGET |
273 | select USB_GADGET_SELECTED | 273 | select USB_GADGET_SELECTED |
274 | 274 | ||
275 | config USB_GADGET_S3C_HSOTG | ||
276 | boolean "S3C HS/OtG USB Device controller" | ||
277 | depends on S3C_DEV_USB_HSOTG | ||
278 | select USB_GADGET_S3C_HSOTG_PIO | ||
279 | help | ||
280 | The Samsung S3C64XX USB2.0 high-speed gadget controller | ||
281 | integrated into the S3C64XX series SoC. | ||
282 | |||
283 | config USB_S3C_HSOTG | ||
284 | tristate | ||
285 | depends on USB_GADGET_S3C_HSOTG | ||
286 | default USB_GADGET | ||
287 | select USB_GADGET_SELECTED | ||
288 | |||
275 | config USB_GADGET_S3C2410 | 289 | config USB_GADGET_S3C2410 |
276 | boolean "S3C2410 USB Device Controller" | 290 | boolean "S3C2410 USB Device Controller" |
277 | depends on ARCH_S3C2410 | 291 | depends on ARCH_S3C2410 |
@@ -460,6 +474,27 @@ config USB_GOKU | |||
460 | default USB_GADGET | 474 | default USB_GADGET |
461 | select USB_GADGET_SELECTED | 475 | select USB_GADGET_SELECTED |
462 | 476 | ||
477 | config USB_GADGET_LANGWELL | ||
478 | boolean "Intel Langwell USB Device Controller" | ||
479 | depends on PCI | ||
480 | select USB_GADGET_DUALSPEED | ||
481 | help | ||
482 | Intel Langwell USB Device Controller is a High-Speed USB | ||
483 | On-The-Go device controller. | ||
484 | |||
485 | The number of programmable endpoints is different through | ||
486 | controller revision. | ||
487 | |||
488 | Say "y" to link the driver statically, or "m" to build a | ||
489 | dynamically linked module called "langwell_udc" and force all | ||
490 | gadget drivers to also be dynamically linked. | ||
491 | |||
492 | config USB_LANGWELL | ||
493 | tristate | ||
494 | depends on USB_GADGET_LANGWELL | ||
495 | default USB_GADGET | ||
496 | select USB_GADGET_SELECTED | ||
497 | |||
463 | 498 | ||
464 | # | 499 | # |
465 | # LAST -- dummy/emulated controller | 500 | # LAST -- dummy/emulated controller |
@@ -566,6 +601,20 @@ config USB_ZERO_HNPTEST | |||
566 | the "B-Peripheral" role, that device will use HNP to let this | 601 | the "B-Peripheral" role, that device will use HNP to let this |
567 | one serve as the USB host instead (in the "B-Host" role). | 602 | one serve as the USB host instead (in the "B-Host" role). |
568 | 603 | ||
604 | config USB_AUDIO | ||
605 | tristate "Audio Gadget (EXPERIMENTAL)" | ||
606 | depends on SND | ||
607 | help | ||
608 | Gadget Audio is compatible with USB Audio Class specification 1.0. | ||
609 | It will include at least one AudioControl interface, zero or more | ||
610 | AudioStream interface and zero or more MIDIStream interface. | ||
611 | |||
612 | Gadget Audio will use on-board ALSA (CONFIG_SND) audio card to | ||
613 | playback or capture audio stream. | ||
614 | |||
615 | Say "y" to link the driver statically, or "m" to build a | ||
616 | dynamically linked module called "g_audio". | ||
617 | |||
569 | config USB_ETH | 618 | config USB_ETH |
570 | tristate "Ethernet Gadget (with CDC Ethernet support)" | 619 | tristate "Ethernet Gadget (with CDC Ethernet support)" |
571 | depends on NET | 620 | depends on NET |
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile index 39a51d746cb7..e6017e6bf6da 100644 --- a/drivers/usb/gadget/Makefile +++ b/drivers/usb/gadget/Makefile | |||
@@ -18,14 +18,21 @@ obj-$(CONFIG_USB_S3C2410) += s3c2410_udc.o | |||
18 | obj-$(CONFIG_USB_AT91) += at91_udc.o | 18 | obj-$(CONFIG_USB_AT91) += at91_udc.o |
19 | obj-$(CONFIG_USB_ATMEL_USBA) += atmel_usba_udc.o | 19 | obj-$(CONFIG_USB_ATMEL_USBA) += atmel_usba_udc.o |
20 | obj-$(CONFIG_USB_FSL_USB2) += fsl_usb2_udc.o | 20 | obj-$(CONFIG_USB_FSL_USB2) += fsl_usb2_udc.o |
21 | fsl_usb2_udc-objs := fsl_udc_core.o | ||
22 | ifeq ($(CONFIG_ARCH_MXC),y) | ||
23 | fsl_usb2_udc-objs += fsl_mx3_udc.o | ||
24 | endif | ||
21 | obj-$(CONFIG_USB_M66592) += m66592-udc.o | 25 | obj-$(CONFIG_USB_M66592) += m66592-udc.o |
22 | obj-$(CONFIG_USB_FSL_QE) += fsl_qe_udc.o | 26 | obj-$(CONFIG_USB_FSL_QE) += fsl_qe_udc.o |
23 | obj-$(CONFIG_USB_CI13XXX) += ci13xxx_udc.o | 27 | obj-$(CONFIG_USB_CI13XXX) += ci13xxx_udc.o |
28 | obj-$(CONFIG_USB_S3C_HSOTG) += s3c-hsotg.o | ||
29 | obj-$(CONFIG_USB_LANGWELL) += langwell_udc.o | ||
24 | 30 | ||
25 | # | 31 | # |
26 | # USB gadget drivers | 32 | # USB gadget drivers |
27 | # | 33 | # |
28 | g_zero-objs := zero.o | 34 | g_zero-objs := zero.o |
35 | g_audio-objs := audio.o | ||
29 | g_ether-objs := ether.o | 36 | g_ether-objs := ether.o |
30 | g_serial-objs := serial.o | 37 | g_serial-objs := serial.o |
31 | g_midi-objs := gmidi.o | 38 | g_midi-objs := gmidi.o |
@@ -35,6 +42,7 @@ g_printer-objs := printer.o | |||
35 | g_cdc-objs := cdc2.o | 42 | g_cdc-objs := cdc2.o |
36 | 43 | ||
37 | obj-$(CONFIG_USB_ZERO) += g_zero.o | 44 | obj-$(CONFIG_USB_ZERO) += g_zero.o |
45 | obj-$(CONFIG_USB_AUDIO) += g_audio.o | ||
38 | obj-$(CONFIG_USB_ETH) += g_ether.o | 46 | obj-$(CONFIG_USB_ETH) += g_ether.o |
39 | obj-$(CONFIG_USB_GADGETFS) += gadgetfs.o | 47 | obj-$(CONFIG_USB_GADGETFS) += gadgetfs.o |
40 | obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o | 48 | obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o |
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c index 53bcdd2f8282..72bae8f39d81 100644 --- a/drivers/usb/gadget/at91_udc.c +++ b/drivers/usb/gadget/at91_udc.c | |||
@@ -485,7 +485,7 @@ static int at91_ep_enable(struct usb_ep *_ep, | |||
485 | return -ESHUTDOWN; | 485 | return -ESHUTDOWN; |
486 | } | 486 | } |
487 | 487 | ||
488 | tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; | 488 | tmp = usb_endpoint_type(desc); |
489 | switch (tmp) { | 489 | switch (tmp) { |
490 | case USB_ENDPOINT_XFER_CONTROL: | 490 | case USB_ENDPOINT_XFER_CONTROL: |
491 | DBG("only one control endpoint\n"); | 491 | DBG("only one control endpoint\n"); |
@@ -517,7 +517,7 @@ ok: | |||
517 | local_irq_save(flags); | 517 | local_irq_save(flags); |
518 | 518 | ||
519 | /* initialize endpoint to match this descriptor */ | 519 | /* initialize endpoint to match this descriptor */ |
520 | ep->is_in = (desc->bEndpointAddress & USB_DIR_IN) != 0; | 520 | ep->is_in = usb_endpoint_dir_in(desc); |
521 | ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); | 521 | ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); |
522 | ep->stopped = 0; | 522 | ep->stopped = 0; |
523 | if (ep->is_in) | 523 | if (ep->is_in) |
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c index 05c913cc3658..4e970cf0e29a 100644 --- a/drivers/usb/gadget/atmel_usba_udc.c +++ b/drivers/usb/gadget/atmel_usba_udc.c | |||
@@ -326,13 +326,7 @@ static int vbus_is_present(struct usba_udc *udc) | |||
326 | return 1; | 326 | return 1; |
327 | } | 327 | } |
328 | 328 | ||
329 | #if defined(CONFIG_AVR32) | 329 | #if defined(CONFIG_ARCH_AT91SAM9RL) |
330 | |||
331 | static void toggle_bias(int is_on) | ||
332 | { | ||
333 | } | ||
334 | |||
335 | #elif defined(CONFIG_ARCH_AT91) | ||
336 | 330 | ||
337 | #include <mach/at91_pmc.h> | 331 | #include <mach/at91_pmc.h> |
338 | 332 | ||
@@ -346,7 +340,13 @@ static void toggle_bias(int is_on) | |||
346 | at91_sys_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN)); | 340 | at91_sys_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN)); |
347 | } | 341 | } |
348 | 342 | ||
349 | #endif /* CONFIG_ARCH_AT91 */ | 343 | #else |
344 | |||
345 | static void toggle_bias(int is_on) | ||
346 | { | ||
347 | } | ||
348 | |||
349 | #endif /* CONFIG_ARCH_AT91SAM9RL */ | ||
350 | 350 | ||
351 | static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req) | 351 | static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req) |
352 | { | 352 | { |
@@ -550,12 +550,12 @@ usba_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
550 | DBG(DBG_HW, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n", | 550 | DBG(DBG_HW, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n", |
551 | ep->ep.name, ept_cfg, maxpacket); | 551 | ep->ep.name, ept_cfg, maxpacket); |
552 | 552 | ||
553 | if ((desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) { | 553 | if (usb_endpoint_dir_in(desc)) { |
554 | ep->is_in = 1; | 554 | ep->is_in = 1; |
555 | ept_cfg |= USBA_EPT_DIR_IN; | 555 | ept_cfg |= USBA_EPT_DIR_IN; |
556 | } | 556 | } |
557 | 557 | ||
558 | switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { | 558 | switch (usb_endpoint_type(desc)) { |
559 | case USB_ENDPOINT_XFER_CONTROL: | 559 | case USB_ENDPOINT_XFER_CONTROL: |
560 | ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL); | 560 | ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL); |
561 | ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE); | 561 | ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE); |
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c new file mode 100644 index 000000000000..94de7e864614 --- /dev/null +++ b/drivers/usb/gadget/audio.c | |||
@@ -0,0 +1,302 @@ | |||
1 | /* | ||
2 | * audio.c -- Audio gadget driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> | ||
5 | * Copyright (C) 2008 Analog Devices, Inc | ||
6 | * | ||
7 | * Enter bugs at http://blackfin.uclinux.org/ | ||
8 | * | ||
9 | * Licensed under the GPL-2 or later. | ||
10 | */ | ||
11 | |||
12 | /* #define VERBOSE_DEBUG */ | ||
13 | |||
14 | #include <linux/kernel.h> | ||
15 | #include <linux/utsname.h> | ||
16 | |||
17 | #include "u_audio.h" | ||
18 | |||
19 | #define DRIVER_DESC "Linux USB Audio Gadget" | ||
20 | #define DRIVER_VERSION "Dec 18, 2008" | ||
21 | |||
22 | /*-------------------------------------------------------------------------*/ | ||
23 | |||
24 | /* | ||
25 | * Kbuild is not very cooperative with respect to linking separately | ||
26 | * compiled library objects into one module. So for now we won't use | ||
27 | * separate compilation ... ensuring init/exit sections work to shrink | ||
28 | * the runtime footprint, and giving us at least some parts of what | ||
29 | * a "gcc --combine ... part1.c part2.c part3.c ... " build would. | ||
30 | */ | ||
31 | #include "composite.c" | ||
32 | #include "usbstring.c" | ||
33 | #include "config.c" | ||
34 | #include "epautoconf.c" | ||
35 | |||
36 | #include "u_audio.c" | ||
37 | #include "f_audio.c" | ||
38 | |||
39 | /*-------------------------------------------------------------------------*/ | ||
40 | |||
41 | /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!! | ||
42 | * Instead: allocate your own, using normal USB-IF procedures. | ||
43 | */ | ||
44 | |||
45 | /* Thanks to NetChip Technologies for donating this product ID. */ | ||
46 | #define AUDIO_VENDOR_NUM 0x0525 /* NetChip */ | ||
47 | #define AUDIO_PRODUCT_NUM 0xa4a1 /* Linux-USB Audio Gadget */ | ||
48 | |||
49 | /*-------------------------------------------------------------------------*/ | ||
50 | |||
51 | static struct usb_device_descriptor device_desc = { | ||
52 | .bLength = sizeof device_desc, | ||
53 | .bDescriptorType = USB_DT_DEVICE, | ||
54 | |||
55 | .bcdUSB = __constant_cpu_to_le16(0x200), | ||
56 | |||
57 | .bDeviceClass = USB_CLASS_PER_INTERFACE, | ||
58 | .bDeviceSubClass = 0, | ||
59 | .bDeviceProtocol = 0, | ||
60 | /* .bMaxPacketSize0 = f(hardware) */ | ||
61 | |||
62 | /* Vendor and product id defaults change according to what configs | ||
63 | * we support. (As does bNumConfigurations.) These values can | ||
64 | * also be overridden by module parameters. | ||
65 | */ | ||
66 | .idVendor = __constant_cpu_to_le16(AUDIO_VENDOR_NUM), | ||
67 | .idProduct = __constant_cpu_to_le16(AUDIO_PRODUCT_NUM), | ||
68 | /* .bcdDevice = f(hardware) */ | ||
69 | /* .iManufacturer = DYNAMIC */ | ||
70 | /* .iProduct = DYNAMIC */ | ||
71 | /* NO SERIAL NUMBER */ | ||
72 | .bNumConfigurations = 1, | ||
73 | }; | ||
74 | |||
75 | static struct usb_otg_descriptor otg_descriptor = { | ||
76 | .bLength = sizeof otg_descriptor, | ||
77 | .bDescriptorType = USB_DT_OTG, | ||
78 | |||
79 | /* REVISIT SRP-only hardware is possible, although | ||
80 | * it would not be called "OTG" ... | ||
81 | */ | ||
82 | .bmAttributes = USB_OTG_SRP | USB_OTG_HNP, | ||
83 | }; | ||
84 | |||
85 | static const struct usb_descriptor_header *otg_desc[] = { | ||
86 | (struct usb_descriptor_header *) &otg_descriptor, | ||
87 | NULL, | ||
88 | }; | ||
89 | |||
90 | /*-------------------------------------------------------------------------*/ | ||
91 | |||
92 | /** | ||
93 | * Handle USB audio endpoint set/get command in setup class request | ||
94 | */ | ||
95 | |||
96 | static int audio_set_endpoint_req(struct usb_configuration *c, | ||
97 | const struct usb_ctrlrequest *ctrl) | ||
98 | { | ||
99 | struct usb_composite_dev *cdev = c->cdev; | ||
100 | int value = -EOPNOTSUPP; | ||
101 | u16 ep = le16_to_cpu(ctrl->wIndex); | ||
102 | u16 len = le16_to_cpu(ctrl->wLength); | ||
103 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
104 | |||
105 | DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n", | ||
106 | ctrl->bRequest, w_value, len, ep); | ||
107 | |||
108 | switch (ctrl->bRequest) { | ||
109 | case SET_CUR: | ||
110 | value = 0; | ||
111 | break; | ||
112 | |||
113 | case SET_MIN: | ||
114 | break; | ||
115 | |||
116 | case SET_MAX: | ||
117 | break; | ||
118 | |||
119 | case SET_RES: | ||
120 | break; | ||
121 | |||
122 | case SET_MEM: | ||
123 | break; | ||
124 | |||
125 | default: | ||
126 | break; | ||
127 | } | ||
128 | |||
129 | return value; | ||
130 | } | ||
131 | |||
132 | static int audio_get_endpoint_req(struct usb_configuration *c, | ||
133 | const struct usb_ctrlrequest *ctrl) | ||
134 | { | ||
135 | struct usb_composite_dev *cdev = c->cdev; | ||
136 | int value = -EOPNOTSUPP; | ||
137 | u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF); | ||
138 | u16 len = le16_to_cpu(ctrl->wLength); | ||
139 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
140 | |||
141 | DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n", | ||
142 | ctrl->bRequest, w_value, len, ep); | ||
143 | |||
144 | switch (ctrl->bRequest) { | ||
145 | case GET_CUR: | ||
146 | case GET_MIN: | ||
147 | case GET_MAX: | ||
148 | case GET_RES: | ||
149 | value = 3; | ||
150 | break; | ||
151 | case GET_MEM: | ||
152 | break; | ||
153 | default: | ||
154 | break; | ||
155 | } | ||
156 | |||
157 | return value; | ||
158 | } | ||
159 | |||
160 | static int | ||
161 | audio_setup(struct usb_configuration *c, const struct usb_ctrlrequest *ctrl) | ||
162 | { | ||
163 | struct usb_composite_dev *cdev = c->cdev; | ||
164 | struct usb_request *req = cdev->req; | ||
165 | int value = -EOPNOTSUPP; | ||
166 | u16 w_index = le16_to_cpu(ctrl->wIndex); | ||
167 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
168 | u16 w_length = le16_to_cpu(ctrl->wLength); | ||
169 | |||
170 | /* composite driver infrastructure handles everything except | ||
171 | * Audio class messages; interface activation uses set_alt(). | ||
172 | */ | ||
173 | switch (ctrl->bRequestType) { | ||
174 | case USB_AUDIO_SET_ENDPOINT: | ||
175 | value = audio_set_endpoint_req(c, ctrl); | ||
176 | break; | ||
177 | |||
178 | case USB_AUDIO_GET_ENDPOINT: | ||
179 | value = audio_get_endpoint_req(c, ctrl); | ||
180 | break; | ||
181 | |||
182 | default: | ||
183 | ERROR(cdev, "Invalid control req%02x.%02x v%04x i%04x l%d\n", | ||
184 | ctrl->bRequestType, ctrl->bRequest, | ||
185 | w_value, w_index, w_length); | ||
186 | } | ||
187 | |||
188 | /* respond with data transfer or status phase? */ | ||
189 | if (value >= 0) { | ||
190 | DBG(cdev, "Audio req%02x.%02x v%04x i%04x l%d\n", | ||
191 | ctrl->bRequestType, ctrl->bRequest, | ||
192 | w_value, w_index, w_length); | ||
193 | req->zero = 0; | ||
194 | req->length = value; | ||
195 | value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); | ||
196 | if (value < 0) | ||
197 | ERROR(cdev, "Audio response on err %d\n", value); | ||
198 | } | ||
199 | |||
200 | /* device either stalls (value < 0) or reports success */ | ||
201 | return value; | ||
202 | } | ||
203 | |||
204 | /*-------------------------------------------------------------------------*/ | ||
205 | |||
206 | static int __init audio_do_config(struct usb_configuration *c) | ||
207 | { | ||
208 | /* FIXME alloc iConfiguration string, set it in c->strings */ | ||
209 | |||
210 | if (gadget_is_otg(c->cdev->gadget)) { | ||
211 | c->descriptors = otg_desc; | ||
212 | c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; | ||
213 | } | ||
214 | |||
215 | audio_bind_config(c); | ||
216 | |||
217 | return 0; | ||
218 | } | ||
219 | |||
220 | static struct usb_configuration audio_config_driver = { | ||
221 | .label = DRIVER_DESC, | ||
222 | .bind = audio_do_config, | ||
223 | .setup = audio_setup, | ||
224 | .bConfigurationValue = 1, | ||
225 | /* .iConfiguration = DYNAMIC */ | ||
226 | .bmAttributes = USB_CONFIG_ATT_SELFPOWER, | ||
227 | }; | ||
228 | |||
229 | /*-------------------------------------------------------------------------*/ | ||
230 | |||
231 | static int __init audio_bind(struct usb_composite_dev *cdev) | ||
232 | { | ||
233 | int gcnum; | ||
234 | int status; | ||
235 | |||
236 | gcnum = usb_gadget_controller_number(cdev->gadget); | ||
237 | if (gcnum >= 0) | ||
238 | device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); | ||
239 | else { | ||
240 | ERROR(cdev, "controller '%s' not recognized; trying %s\n", | ||
241 | cdev->gadget->name, | ||
242 | audio_config_driver.label); | ||
243 | device_desc.bcdDevice = | ||
244 | __constant_cpu_to_le16(0x0300 | 0x0099); | ||
245 | } | ||
246 | |||
247 | /* device descriptor strings: manufacturer, product */ | ||
248 | snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", | ||
249 | init_utsname()->sysname, init_utsname()->release, | ||
250 | cdev->gadget->name); | ||
251 | status = usb_string_id(cdev); | ||
252 | if (status < 0) | ||
253 | goto fail; | ||
254 | strings_dev[STRING_MANUFACTURER_IDX].id = status; | ||
255 | device_desc.iManufacturer = status; | ||
256 | |||
257 | status = usb_string_id(cdev); | ||
258 | if (status < 0) | ||
259 | goto fail; | ||
260 | strings_dev[STRING_PRODUCT_IDX].id = status; | ||
261 | device_desc.iProduct = status; | ||
262 | |||
263 | status = usb_add_config(cdev, &audio_config_driver); | ||
264 | if (status < 0) | ||
265 | goto fail; | ||
266 | |||
267 | INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION); | ||
268 | return 0; | ||
269 | |||
270 | fail: | ||
271 | return status; | ||
272 | } | ||
273 | |||
274 | static int __exit audio_unbind(struct usb_composite_dev *cdev) | ||
275 | { | ||
276 | return 0; | ||
277 | } | ||
278 | |||
279 | static struct usb_composite_driver audio_driver = { | ||
280 | .name = "g_audio", | ||
281 | .dev = &device_desc, | ||
282 | .strings = audio_strings, | ||
283 | .bind = audio_bind, | ||
284 | .unbind = __exit_p(audio_unbind), | ||
285 | }; | ||
286 | |||
287 | static int __init init(void) | ||
288 | { | ||
289 | return usb_composite_register(&audio_driver); | ||
290 | } | ||
291 | module_init(init); | ||
292 | |||
293 | static void __exit cleanup(void) | ||
294 | { | ||
295 | usb_composite_unregister(&audio_driver); | ||
296 | } | ||
297 | module_exit(cleanup); | ||
298 | |||
299 | MODULE_DESCRIPTION(DRIVER_DESC); | ||
300 | MODULE_AUTHOR("Bryan Wu <cooloney@kernel.org>"); | ||
301 | MODULE_LICENSE("GPL"); | ||
302 | |||
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c index 38e531ecae4d..c7cb87a6fee2 100644 --- a/drivers/usb/gadget/ci13xxx_udc.c +++ b/drivers/usb/gadget/ci13xxx_udc.c | |||
@@ -1977,9 +1977,9 @@ static int ep_enable(struct usb_ep *ep, | |||
1977 | if (!list_empty(&mEp->qh[mEp->dir].queue)) | 1977 | if (!list_empty(&mEp->qh[mEp->dir].queue)) |
1978 | warn("enabling a non-empty endpoint!"); | 1978 | warn("enabling a non-empty endpoint!"); |
1979 | 1979 | ||
1980 | mEp->dir = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? TX : RX; | 1980 | mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX; |
1981 | mEp->num = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; | 1981 | mEp->num = usb_endpoint_num(desc); |
1982 | mEp->type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; | 1982 | mEp->type = usb_endpoint_type(desc); |
1983 | 1983 | ||
1984 | mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize); | 1984 | mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize); |
1985 | 1985 | ||
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c new file mode 100644 index 000000000000..66527ba2d2ea --- /dev/null +++ b/drivers/usb/gadget/f_audio.c | |||
@@ -0,0 +1,707 @@ | |||
1 | /* | ||
2 | * f_audio.c -- USB Audio class function driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> | ||
5 | * Copyright (C) 2008 Analog Devices, Inc | ||
6 | * | ||
7 | * Enter bugs at http://blackfin.uclinux.org/ | ||
8 | * | ||
9 | * Licensed under the GPL-2 or later. | ||
10 | */ | ||
11 | |||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/device.h> | ||
14 | #include <asm/atomic.h> | ||
15 | |||
16 | #include "u_audio.h" | ||
17 | |||
18 | #define OUT_EP_MAX_PACKET_SIZE 200 | ||
19 | static int req_buf_size = OUT_EP_MAX_PACKET_SIZE; | ||
20 | module_param(req_buf_size, int, S_IRUGO); | ||
21 | MODULE_PARM_DESC(req_buf_size, "ISO OUT endpoint request buffer size"); | ||
22 | |||
23 | static int req_count = 256; | ||
24 | module_param(req_count, int, S_IRUGO); | ||
25 | MODULE_PARM_DESC(req_count, "ISO OUT endpoint request count"); | ||
26 | |||
27 | static int audio_buf_size = 48000; | ||
28 | module_param(audio_buf_size, int, S_IRUGO); | ||
29 | MODULE_PARM_DESC(audio_buf_size, "Audio buffer size"); | ||
30 | |||
31 | /* | ||
32 | * DESCRIPTORS ... most are static, but strings and full | ||
33 | * configuration descriptors are built on demand. | ||
34 | */ | ||
35 | |||
36 | /* | ||
37 | * We have two interfaces- AudioControl and AudioStreaming | ||
38 | * TODO: only supcard playback currently | ||
39 | */ | ||
40 | #define F_AUDIO_AC_INTERFACE 0 | ||
41 | #define F_AUDIO_AS_INTERFACE 1 | ||
42 | #define F_AUDIO_NUM_INTERFACES 2 | ||
43 | |||
44 | /* B.3.1 Standard AC Interface Descriptor */ | ||
45 | static struct usb_interface_descriptor ac_interface_desc __initdata = { | ||
46 | .bLength = USB_DT_INTERFACE_SIZE, | ||
47 | .bDescriptorType = USB_DT_INTERFACE, | ||
48 | .bNumEndpoints = 0, | ||
49 | .bInterfaceClass = USB_CLASS_AUDIO, | ||
50 | .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, | ||
51 | }; | ||
52 | |||
53 | DECLARE_USB_AC_HEADER_DESCRIPTOR(2); | ||
54 | |||
55 | #define USB_DT_AC_HEADER_LENGH USB_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES) | ||
56 | /* B.3.2 Class-Specific AC Interface Descriptor */ | ||
57 | static struct usb_ac_header_descriptor_2 ac_header_desc = { | ||
58 | .bLength = USB_DT_AC_HEADER_LENGH, | ||
59 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
60 | .bDescriptorSubtype = HEADER, | ||
61 | .bcdADC = __constant_cpu_to_le16(0x0100), | ||
62 | .wTotalLength = __constant_cpu_to_le16(USB_DT_AC_HEADER_LENGH), | ||
63 | .bInCollection = F_AUDIO_NUM_INTERFACES, | ||
64 | .baInterfaceNr = { | ||
65 | [0] = F_AUDIO_AC_INTERFACE, | ||
66 | [1] = F_AUDIO_AS_INTERFACE, | ||
67 | } | ||
68 | }; | ||
69 | |||
70 | #define INPUT_TERMINAL_ID 1 | ||
71 | static struct usb_input_terminal_descriptor input_terminal_desc = { | ||
72 | .bLength = USB_DT_AC_INPUT_TERMINAL_SIZE, | ||
73 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
74 | .bDescriptorSubtype = INPUT_TERMINAL, | ||
75 | .bTerminalID = INPUT_TERMINAL_ID, | ||
76 | .wTerminalType = USB_AC_TERMINAL_STREAMING, | ||
77 | .bAssocTerminal = 0, | ||
78 | .wChannelConfig = 0x3, | ||
79 | }; | ||
80 | |||
81 | DECLARE_USB_AC_FEATURE_UNIT_DESCRIPTOR(0); | ||
82 | |||
83 | #define FEATURE_UNIT_ID 2 | ||
84 | static struct usb_ac_feature_unit_descriptor_0 feature_unit_desc = { | ||
85 | .bLength = USB_DT_AC_FEATURE_UNIT_SIZE(0), | ||
86 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
87 | .bDescriptorSubtype = FEATURE_UNIT, | ||
88 | .bUnitID = FEATURE_UNIT_ID, | ||
89 | .bSourceID = INPUT_TERMINAL_ID, | ||
90 | .bControlSize = 2, | ||
91 | .bmaControls[0] = (FU_MUTE | FU_VOLUME), | ||
92 | }; | ||
93 | |||
94 | static struct usb_audio_control mute_control = { | ||
95 | .list = LIST_HEAD_INIT(mute_control.list), | ||
96 | .name = "Mute Control", | ||
97 | .type = MUTE_CONTROL, | ||
98 | /* Todo: add real Mute control code */ | ||
99 | .set = generic_set_cmd, | ||
100 | .get = generic_get_cmd, | ||
101 | }; | ||
102 | |||
103 | static struct usb_audio_control volume_control = { | ||
104 | .list = LIST_HEAD_INIT(volume_control.list), | ||
105 | .name = "Volume Control", | ||
106 | .type = VOLUME_CONTROL, | ||
107 | /* Todo: add real Volume control code */ | ||
108 | .set = generic_set_cmd, | ||
109 | .get = generic_get_cmd, | ||
110 | }; | ||
111 | |||
112 | static struct usb_audio_control_selector feature_unit = { | ||
113 | .list = LIST_HEAD_INIT(feature_unit.list), | ||
114 | .id = FEATURE_UNIT_ID, | ||
115 | .name = "Mute & Volume Control", | ||
116 | .type = FEATURE_UNIT, | ||
117 | .desc = (struct usb_descriptor_header *)&feature_unit_desc, | ||
118 | }; | ||
119 | |||
120 | #define OUTPUT_TERMINAL_ID 3 | ||
121 | static struct usb_output_terminal_descriptor output_terminal_desc = { | ||
122 | .bLength = USB_DT_AC_OUTPUT_TERMINAL_SIZE, | ||
123 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
124 | .bDescriptorSubtype = OUTPUT_TERMINAL, | ||
125 | .bTerminalID = OUTPUT_TERMINAL_ID, | ||
126 | .wTerminalType = USB_AC_OUTPUT_TERMINAL_SPEAKER, | ||
127 | .bAssocTerminal = FEATURE_UNIT_ID, | ||
128 | .bSourceID = FEATURE_UNIT_ID, | ||
129 | }; | ||
130 | |||
131 | /* B.4.1 Standard AS Interface Descriptor */ | ||
132 | static struct usb_interface_descriptor as_interface_alt_0_desc = { | ||
133 | .bLength = USB_DT_INTERFACE_SIZE, | ||
134 | .bDescriptorType = USB_DT_INTERFACE, | ||
135 | .bAlternateSetting = 0, | ||
136 | .bNumEndpoints = 0, | ||
137 | .bInterfaceClass = USB_CLASS_AUDIO, | ||
138 | .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, | ||
139 | }; | ||
140 | |||
141 | static struct usb_interface_descriptor as_interface_alt_1_desc = { | ||
142 | .bLength = USB_DT_INTERFACE_SIZE, | ||
143 | .bDescriptorType = USB_DT_INTERFACE, | ||
144 | .bAlternateSetting = 1, | ||
145 | .bNumEndpoints = 1, | ||
146 | .bInterfaceClass = USB_CLASS_AUDIO, | ||
147 | .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, | ||
148 | }; | ||
149 | |||
150 | /* B.4.2 Class-Specific AS Interface Descriptor */ | ||
151 | static struct usb_as_header_descriptor as_header_desc = { | ||
152 | .bLength = USB_DT_AS_HEADER_SIZE, | ||
153 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
154 | .bDescriptorSubtype = AS_GENERAL, | ||
155 | .bTerminalLink = INPUT_TERMINAL_ID, | ||
156 | .bDelay = 1, | ||
157 | .wFormatTag = USB_AS_AUDIO_FORMAT_TYPE_I_PCM, | ||
158 | }; | ||
159 | |||
160 | DECLARE_USB_AS_FORMAT_TYPE_I_DISCRETE_DESC(1); | ||
161 | |||
162 | static struct usb_as_formate_type_i_discrete_descriptor_1 as_type_i_desc = { | ||
163 | .bLength = USB_AS_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1), | ||
164 | .bDescriptorType = USB_DT_CS_INTERFACE, | ||
165 | .bDescriptorSubtype = FORMAT_TYPE, | ||
166 | .bFormatType = USB_AS_FORMAT_TYPE_I, | ||
167 | .bSubframeSize = 2, | ||
168 | .bBitResolution = 16, | ||
169 | .bSamFreqType = 1, | ||
170 | }; | ||
171 | |||
172 | /* Standard ISO OUT Endpoint Descriptor */ | ||
173 | static struct usb_endpoint_descriptor as_out_ep_desc __initdata = { | ||
174 | .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, | ||
175 | .bDescriptorType = USB_DT_ENDPOINT, | ||
176 | .bEndpointAddress = USB_DIR_OUT, | ||
177 | .bmAttributes = USB_AS_ENDPOINT_ADAPTIVE | ||
178 | | USB_ENDPOINT_XFER_ISOC, | ||
179 | .wMaxPacketSize = __constant_cpu_to_le16(OUT_EP_MAX_PACKET_SIZE), | ||
180 | .bInterval = 4, | ||
181 | }; | ||
182 | |||
183 | /* Class-specific AS ISO OUT Endpoint Descriptor */ | ||
184 | static struct usb_as_iso_endpoint_descriptor as_iso_out_desc __initdata = { | ||
185 | .bLength = USB_AS_ISO_ENDPOINT_DESC_SIZE, | ||
186 | .bDescriptorType = USB_DT_CS_ENDPOINT, | ||
187 | .bDescriptorSubtype = EP_GENERAL, | ||
188 | .bmAttributes = 1, | ||
189 | .bLockDelayUnits = 1, | ||
190 | .wLockDelay = __constant_cpu_to_le16(1), | ||
191 | }; | ||
192 | |||
193 | static struct usb_descriptor_header *f_audio_desc[] __initdata = { | ||
194 | (struct usb_descriptor_header *)&ac_interface_desc, | ||
195 | (struct usb_descriptor_header *)&ac_header_desc, | ||
196 | |||
197 | (struct usb_descriptor_header *)&input_terminal_desc, | ||
198 | (struct usb_descriptor_header *)&output_terminal_desc, | ||
199 | (struct usb_descriptor_header *)&feature_unit_desc, | ||
200 | |||
201 | (struct usb_descriptor_header *)&as_interface_alt_0_desc, | ||
202 | (struct usb_descriptor_header *)&as_interface_alt_1_desc, | ||
203 | (struct usb_descriptor_header *)&as_header_desc, | ||
204 | |||
205 | (struct usb_descriptor_header *)&as_type_i_desc, | ||
206 | |||
207 | (struct usb_descriptor_header *)&as_out_ep_desc, | ||
208 | (struct usb_descriptor_header *)&as_iso_out_desc, | ||
209 | NULL, | ||
210 | }; | ||
211 | |||
212 | /* string IDs are assigned dynamically */ | ||
213 | |||
214 | #define STRING_MANUFACTURER_IDX 0 | ||
215 | #define STRING_PRODUCT_IDX 1 | ||
216 | |||
217 | static char manufacturer[50]; | ||
218 | |||
219 | static struct usb_string strings_dev[] = { | ||
220 | [STRING_MANUFACTURER_IDX].s = manufacturer, | ||
221 | [STRING_PRODUCT_IDX].s = DRIVER_DESC, | ||
222 | { } /* end of list */ | ||
223 | }; | ||
224 | |||
225 | static struct usb_gadget_strings stringtab_dev = { | ||
226 | .language = 0x0409, /* en-us */ | ||
227 | .strings = strings_dev, | ||
228 | }; | ||
229 | |||
230 | static struct usb_gadget_strings *audio_strings[] = { | ||
231 | &stringtab_dev, | ||
232 | NULL, | ||
233 | }; | ||
234 | |||
235 | /* | ||
236 | * This function is an ALSA sound card following USB Audio Class Spec 1.0. | ||
237 | */ | ||
238 | |||
239 | /*-------------------------------------------------------------------------*/ | ||
240 | struct f_audio_buf { | ||
241 | u8 *buf; | ||
242 | int actual; | ||
243 | struct list_head list; | ||
244 | }; | ||
245 | |||
246 | static struct f_audio_buf *f_audio_buffer_alloc(int buf_size) | ||
247 | { | ||
248 | struct f_audio_buf *copy_buf; | ||
249 | |||
250 | copy_buf = kzalloc(sizeof *copy_buf, GFP_ATOMIC); | ||
251 | if (!copy_buf) | ||
252 | return (struct f_audio_buf *)-ENOMEM; | ||
253 | |||
254 | copy_buf->buf = kzalloc(buf_size, GFP_ATOMIC); | ||
255 | if (!copy_buf->buf) { | ||
256 | kfree(copy_buf); | ||
257 | return (struct f_audio_buf *)-ENOMEM; | ||
258 | } | ||
259 | |||
260 | return copy_buf; | ||
261 | } | ||
262 | |||
263 | static void f_audio_buffer_free(struct f_audio_buf *audio_buf) | ||
264 | { | ||
265 | kfree(audio_buf->buf); | ||
266 | kfree(audio_buf); | ||
267 | } | ||
268 | /*-------------------------------------------------------------------------*/ | ||
269 | |||
270 | struct f_audio { | ||
271 | struct gaudio card; | ||
272 | |||
273 | /* endpoints handle full and/or high speeds */ | ||
274 | struct usb_ep *out_ep; | ||
275 | struct usb_endpoint_descriptor *out_desc; | ||
276 | |||
277 | spinlock_t lock; | ||
278 | struct f_audio_buf *copy_buf; | ||
279 | struct work_struct playback_work; | ||
280 | struct list_head play_queue; | ||
281 | |||
282 | /* Control Set command */ | ||
283 | struct list_head cs; | ||
284 | u8 set_cmd; | ||
285 | struct usb_audio_control *set_con; | ||
286 | }; | ||
287 | |||
288 | static inline struct f_audio *func_to_audio(struct usb_function *f) | ||
289 | { | ||
290 | return container_of(f, struct f_audio, card.func); | ||
291 | } | ||
292 | |||
293 | /*-------------------------------------------------------------------------*/ | ||
294 | |||
295 | static void f_audio_playback_work(struct work_struct *data) | ||
296 | { | ||
297 | struct f_audio *audio = container_of(data, struct f_audio, | ||
298 | playback_work); | ||
299 | struct f_audio_buf *play_buf; | ||
300 | |||
301 | spin_lock_irq(&audio->lock); | ||
302 | if (list_empty(&audio->play_queue)) { | ||
303 | spin_unlock_irq(&audio->lock); | ||
304 | return; | ||
305 | } | ||
306 | play_buf = list_first_entry(&audio->play_queue, | ||
307 | struct f_audio_buf, list); | ||
308 | list_del(&play_buf->list); | ||
309 | spin_unlock_irq(&audio->lock); | ||
310 | |||
311 | u_audio_playback(&audio->card, play_buf->buf, play_buf->actual); | ||
312 | f_audio_buffer_free(play_buf); | ||
313 | |||
314 | return; | ||
315 | } | ||
316 | |||
317 | static int f_audio_out_ep_complete(struct usb_ep *ep, struct usb_request *req) | ||
318 | { | ||
319 | struct f_audio *audio = req->context; | ||
320 | struct usb_composite_dev *cdev = audio->card.func.config->cdev; | ||
321 | struct f_audio_buf *copy_buf = audio->copy_buf; | ||
322 | int err; | ||
323 | |||
324 | if (!copy_buf) | ||
325 | return -EINVAL; | ||
326 | |||
327 | /* Copy buffer is full, add it to the play_queue */ | ||
328 | if (audio_buf_size - copy_buf->actual < req->actual) { | ||
329 | list_add_tail(©_buf->list, &audio->play_queue); | ||
330 | schedule_work(&audio->playback_work); | ||
331 | copy_buf = f_audio_buffer_alloc(audio_buf_size); | ||
332 | if (copy_buf < 0) | ||
333 | return -ENOMEM; | ||
334 | } | ||
335 | |||
336 | memcpy(copy_buf->buf + copy_buf->actual, req->buf, req->actual); | ||
337 | copy_buf->actual += req->actual; | ||
338 | audio->copy_buf = copy_buf; | ||
339 | |||
340 | err = usb_ep_queue(ep, req, GFP_ATOMIC); | ||
341 | if (err) | ||
342 | ERROR(cdev, "%s queue req: %d\n", ep->name, err); | ||
343 | |||
344 | return 0; | ||
345 | |||
346 | } | ||
347 | |||
348 | static void f_audio_complete(struct usb_ep *ep, struct usb_request *req) | ||
349 | { | ||
350 | struct f_audio *audio = req->context; | ||
351 | int status = req->status; | ||
352 | u32 data = 0; | ||
353 | struct usb_ep *out_ep = audio->out_ep; | ||
354 | |||
355 | switch (status) { | ||
356 | |||
357 | case 0: /* normal completion? */ | ||
358 | if (ep == out_ep) | ||
359 | f_audio_out_ep_complete(ep, req); | ||
360 | else if (audio->set_con) { | ||
361 | memcpy(&data, req->buf, req->length); | ||
362 | audio->set_con->set(audio->set_con, audio->set_cmd, | ||
363 | le16_to_cpu(data)); | ||
364 | audio->set_con = NULL; | ||
365 | } | ||
366 | break; | ||
367 | default: | ||
368 | break; | ||
369 | } | ||
370 | } | ||
371 | |||
372 | static int audio_set_intf_req(struct usb_function *f, | ||
373 | const struct usb_ctrlrequest *ctrl) | ||
374 | { | ||
375 | struct f_audio *audio = func_to_audio(f); | ||
376 | struct usb_composite_dev *cdev = f->config->cdev; | ||
377 | struct usb_request *req = cdev->req; | ||
378 | u8 id = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF); | ||
379 | u16 len = le16_to_cpu(ctrl->wLength); | ||
380 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
381 | u8 con_sel = (w_value >> 8) & 0xFF; | ||
382 | u8 cmd = (ctrl->bRequest & 0x0F); | ||
383 | struct usb_audio_control_selector *cs; | ||
384 | struct usb_audio_control *con; | ||
385 | |||
386 | DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, entity %d\n", | ||
387 | ctrl->bRequest, w_value, len, id); | ||
388 | |||
389 | list_for_each_entry(cs, &audio->cs, list) { | ||
390 | if (cs->id == id) { | ||
391 | list_for_each_entry(con, &cs->control, list) { | ||
392 | if (con->type == con_sel) { | ||
393 | audio->set_con = con; | ||
394 | break; | ||
395 | } | ||
396 | } | ||
397 | break; | ||
398 | } | ||
399 | } | ||
400 | |||
401 | audio->set_cmd = cmd; | ||
402 | req->context = audio; | ||
403 | req->complete = f_audio_complete; | ||
404 | |||
405 | return len; | ||
406 | } | ||
407 | |||
408 | static int audio_get_intf_req(struct usb_function *f, | ||
409 | const struct usb_ctrlrequest *ctrl) | ||
410 | { | ||
411 | struct f_audio *audio = func_to_audio(f); | ||
412 | struct usb_composite_dev *cdev = f->config->cdev; | ||
413 | struct usb_request *req = cdev->req; | ||
414 | int value = -EOPNOTSUPP; | ||
415 | u8 id = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF); | ||
416 | u16 len = le16_to_cpu(ctrl->wLength); | ||
417 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
418 | u8 con_sel = (w_value >> 8) & 0xFF; | ||
419 | u8 cmd = (ctrl->bRequest & 0x0F); | ||
420 | struct usb_audio_control_selector *cs; | ||
421 | struct usb_audio_control *con; | ||
422 | |||
423 | DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, entity %d\n", | ||
424 | ctrl->bRequest, w_value, len, id); | ||
425 | |||
426 | list_for_each_entry(cs, &audio->cs, list) { | ||
427 | if (cs->id == id) { | ||
428 | list_for_each_entry(con, &cs->control, list) { | ||
429 | if (con->type == con_sel && con->get) { | ||
430 | value = con->get(con, cmd); | ||
431 | break; | ||
432 | } | ||
433 | } | ||
434 | break; | ||
435 | } | ||
436 | } | ||
437 | |||
438 | req->context = audio; | ||
439 | req->complete = f_audio_complete; | ||
440 | memcpy(req->buf, &value, len); | ||
441 | |||
442 | return len; | ||
443 | } | ||
444 | |||
445 | static int | ||
446 | f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) | ||
447 | { | ||
448 | struct usb_composite_dev *cdev = f->config->cdev; | ||
449 | struct usb_request *req = cdev->req; | ||
450 | int value = -EOPNOTSUPP; | ||
451 | u16 w_index = le16_to_cpu(ctrl->wIndex); | ||
452 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
453 | u16 w_length = le16_to_cpu(ctrl->wLength); | ||
454 | |||
455 | /* composite driver infrastructure handles everything except | ||
456 | * Audio class messages; interface activation uses set_alt(). | ||
457 | */ | ||
458 | switch (ctrl->bRequestType) { | ||
459 | case USB_AUDIO_SET_INTF: | ||
460 | value = audio_set_intf_req(f, ctrl); | ||
461 | break; | ||
462 | |||
463 | case USB_AUDIO_GET_INTF: | ||
464 | value = audio_get_intf_req(f, ctrl); | ||
465 | break; | ||
466 | |||
467 | default: | ||
468 | ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n", | ||
469 | ctrl->bRequestType, ctrl->bRequest, | ||
470 | w_value, w_index, w_length); | ||
471 | } | ||
472 | |||
473 | /* respond with data transfer or status phase? */ | ||
474 | if (value >= 0) { | ||
475 | DBG(cdev, "audio req%02x.%02x v%04x i%04x l%d\n", | ||
476 | ctrl->bRequestType, ctrl->bRequest, | ||
477 | w_value, w_index, w_length); | ||
478 | req->zero = 0; | ||
479 | req->length = value; | ||
480 | value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); | ||
481 | if (value < 0) | ||
482 | ERROR(cdev, "audio response on err %d\n", value); | ||
483 | } | ||
484 | |||
485 | /* device either stalls (value < 0) or reports success */ | ||
486 | return value; | ||
487 | } | ||
488 | |||
489 | static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt) | ||
490 | { | ||
491 | struct f_audio *audio = func_to_audio(f); | ||
492 | struct usb_composite_dev *cdev = f->config->cdev; | ||
493 | struct usb_ep *out_ep = audio->out_ep; | ||
494 | struct usb_request *req; | ||
495 | int i = 0, err = 0; | ||
496 | |||
497 | DBG(cdev, "intf %d, alt %d\n", intf, alt); | ||
498 | |||
499 | if (intf == 1) { | ||
500 | if (alt == 1) { | ||
501 | usb_ep_enable(out_ep, audio->out_desc); | ||
502 | out_ep->driver_data = audio; | ||
503 | audio->copy_buf = f_audio_buffer_alloc(audio_buf_size); | ||
504 | |||
505 | /* | ||
506 | * allocate a bunch of read buffers | ||
507 | * and queue them all at once. | ||
508 | */ | ||
509 | for (i = 0; i < req_count && err == 0; i++) { | ||
510 | req = usb_ep_alloc_request(out_ep, GFP_ATOMIC); | ||
511 | if (req) { | ||
512 | req->buf = kzalloc(req_buf_size, | ||
513 | GFP_ATOMIC); | ||
514 | if (req->buf) { | ||
515 | req->length = req_buf_size; | ||
516 | req->context = audio; | ||
517 | req->complete = | ||
518 | f_audio_complete; | ||
519 | err = usb_ep_queue(out_ep, | ||
520 | req, GFP_ATOMIC); | ||
521 | if (err) | ||
522 | ERROR(cdev, | ||
523 | "%s queue req: %d\n", | ||
524 | out_ep->name, err); | ||
525 | } else | ||
526 | err = -ENOMEM; | ||
527 | } else | ||
528 | err = -ENOMEM; | ||
529 | } | ||
530 | |||
531 | } else { | ||
532 | struct f_audio_buf *copy_buf = audio->copy_buf; | ||
533 | if (copy_buf) { | ||
534 | list_add_tail(©_buf->list, | ||
535 | &audio->play_queue); | ||
536 | schedule_work(&audio->playback_work); | ||
537 | } | ||
538 | } | ||
539 | } | ||
540 | |||
541 | return err; | ||
542 | } | ||
543 | |||
544 | static void f_audio_disable(struct usb_function *f) | ||
545 | { | ||
546 | return; | ||
547 | } | ||
548 | |||
549 | /*-------------------------------------------------------------------------*/ | ||
550 | |||
551 | static void f_audio_build_desc(struct f_audio *audio) | ||
552 | { | ||
553 | struct gaudio *card = &audio->card; | ||
554 | u8 *sam_freq; | ||
555 | int rate; | ||
556 | |||
557 | /* Set channel numbers */ | ||
558 | input_terminal_desc.bNrChannels = u_audio_get_playback_channels(card); | ||
559 | as_type_i_desc.bNrChannels = u_audio_get_playback_channels(card); | ||
560 | |||
561 | /* Set sample rates */ | ||
562 | rate = u_audio_get_playback_rate(card); | ||
563 | sam_freq = as_type_i_desc.tSamFreq[0]; | ||
564 | memcpy(sam_freq, &rate, 3); | ||
565 | |||
566 | /* Todo: Set Sample bits and other parameters */ | ||
567 | |||
568 | return; | ||
569 | } | ||
570 | |||
571 | /* audio function driver setup/binding */ | ||
572 | static int __init | ||
573 | f_audio_bind(struct usb_configuration *c, struct usb_function *f) | ||
574 | { | ||
575 | struct usb_composite_dev *cdev = c->cdev; | ||
576 | struct f_audio *audio = func_to_audio(f); | ||
577 | int status; | ||
578 | struct usb_ep *ep; | ||
579 | |||
580 | f_audio_build_desc(audio); | ||
581 | |||
582 | /* allocate instance-specific interface IDs, and patch descriptors */ | ||
583 | status = usb_interface_id(c, f); | ||
584 | if (status < 0) | ||
585 | goto fail; | ||
586 | ac_interface_desc.bInterfaceNumber = status; | ||
587 | |||
588 | status = usb_interface_id(c, f); | ||
589 | if (status < 0) | ||
590 | goto fail; | ||
591 | as_interface_alt_0_desc.bInterfaceNumber = status; | ||
592 | as_interface_alt_1_desc.bInterfaceNumber = status; | ||
593 | |||
594 | status = -ENODEV; | ||
595 | |||
596 | /* allocate instance-specific endpoints */ | ||
597 | ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc); | ||
598 | if (!ep) | ||
599 | goto fail; | ||
600 | audio->out_ep = ep; | ||
601 | ep->driver_data = cdev; /* claim */ | ||
602 | |||
603 | status = -ENOMEM; | ||
604 | |||
605 | /* supcard all relevant hardware speeds... we expect that when | ||
606 | * hardware is dual speed, all bulk-capable endpoints work at | ||
607 | * both speeds | ||
608 | */ | ||
609 | |||
610 | /* copy descriptors, and track endpoint copies */ | ||
611 | if (gadget_is_dualspeed(c->cdev->gadget)) { | ||
612 | c->highspeed = true; | ||
613 | f->hs_descriptors = usb_copy_descriptors(f_audio_desc); | ||
614 | } else | ||
615 | f->descriptors = usb_copy_descriptors(f_audio_desc); | ||
616 | |||
617 | return 0; | ||
618 | |||
619 | fail: | ||
620 | |||
621 | return status; | ||
622 | } | ||
623 | |||
624 | static void | ||
625 | f_audio_unbind(struct usb_configuration *c, struct usb_function *f) | ||
626 | { | ||
627 | struct f_audio *audio = func_to_audio(f); | ||
628 | |||
629 | usb_free_descriptors(f->descriptors); | ||
630 | kfree(audio); | ||
631 | } | ||
632 | |||
633 | /*-------------------------------------------------------------------------*/ | ||
634 | |||
635 | /* Todo: add more control selecotor dynamically */ | ||
636 | int __init control_selector_init(struct f_audio *audio) | ||
637 | { | ||
638 | INIT_LIST_HEAD(&audio->cs); | ||
639 | list_add(&feature_unit.list, &audio->cs); | ||
640 | |||
641 | INIT_LIST_HEAD(&feature_unit.control); | ||
642 | list_add(&mute_control.list, &feature_unit.control); | ||
643 | list_add(&volume_control.list, &feature_unit.control); | ||
644 | |||
645 | volume_control.data[_CUR] = 0xffc0; | ||
646 | volume_control.data[_MIN] = 0xe3a0; | ||
647 | volume_control.data[_MAX] = 0xfff0; | ||
648 | volume_control.data[_RES] = 0x0030; | ||
649 | |||
650 | return 0; | ||
651 | } | ||
652 | |||
653 | /** | ||
654 | * audio_bind_config - add USB audio fucntion to a configuration | ||
655 | * @c: the configuration to supcard the USB audio function | ||
656 | * Context: single threaded during gadget setup | ||
657 | * | ||
658 | * Returns zero on success, else negative errno. | ||
659 | */ | ||
660 | int __init audio_bind_config(struct usb_configuration *c) | ||
661 | { | ||
662 | struct f_audio *audio; | ||
663 | int status; | ||
664 | |||
665 | /* allocate and initialize one new instance */ | ||
666 | audio = kzalloc(sizeof *audio, GFP_KERNEL); | ||
667 | if (!audio) | ||
668 | return -ENOMEM; | ||
669 | |||
670 | audio->card.func.name = "g_audio"; | ||
671 | audio->card.gadget = c->cdev->gadget; | ||
672 | |||
673 | INIT_LIST_HEAD(&audio->play_queue); | ||
674 | spin_lock_init(&audio->lock); | ||
675 | |||
676 | /* set up ASLA audio devices */ | ||
677 | status = gaudio_setup(&audio->card); | ||
678 | if (status < 0) | ||
679 | goto setup_fail; | ||
680 | |||
681 | audio->card.func.strings = audio_strings; | ||
682 | audio->card.func.bind = f_audio_bind; | ||
683 | audio->card.func.unbind = f_audio_unbind; | ||
684 | audio->card.func.set_alt = f_audio_set_alt; | ||
685 | audio->card.func.setup = f_audio_setup; | ||
686 | audio->card.func.disable = f_audio_disable; | ||
687 | audio->out_desc = &as_out_ep_desc; | ||
688 | |||
689 | control_selector_init(audio); | ||
690 | |||
691 | INIT_WORK(&audio->playback_work, f_audio_playback_work); | ||
692 | |||
693 | status = usb_add_function(c, &audio->card.func); | ||
694 | if (status) | ||
695 | goto add_fail; | ||
696 | |||
697 | INFO(c->cdev, "audio_buf_size %d, req_buf_size %d, req_count %d\n", | ||
698 | audio_buf_size, req_buf_size, req_count); | ||
699 | |||
700 | return status; | ||
701 | |||
702 | add_fail: | ||
703 | gaudio_cleanup(&audio->card); | ||
704 | setup_fail: | ||
705 | kfree(audio); | ||
706 | return status; | ||
707 | } | ||
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c index 3279a4726042..424a37c5773f 100644 --- a/drivers/usb/gadget/f_rndis.c +++ b/drivers/usb/gadget/f_rndis.c | |||
@@ -475,7 +475,9 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt) | |||
475 | if (rndis->port.in_ep->driver_data) { | 475 | if (rndis->port.in_ep->driver_data) { |
476 | DBG(cdev, "reset rndis\n"); | 476 | DBG(cdev, "reset rndis\n"); |
477 | gether_disconnect(&rndis->port); | 477 | gether_disconnect(&rndis->port); |
478 | } else { | 478 | } |
479 | |||
480 | if (!rndis->port.in) { | ||
479 | DBG(cdev, "init rndis\n"); | 481 | DBG(cdev, "init rndis\n"); |
480 | rndis->port.in = ep_choose(cdev->gadget, | 482 | rndis->port.in = ep_choose(cdev->gadget, |
481 | rndis->hs.in, rndis->fs.in); | 483 | rndis->hs.in, rndis->fs.in); |
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c index 381a53b3e11c..1e6aa504d58a 100644 --- a/drivers/usb/gadget/file_storage.c +++ b/drivers/usb/gadget/file_storage.c | |||
@@ -248,6 +248,8 @@ | |||
248 | #include <linux/freezer.h> | 248 | #include <linux/freezer.h> |
249 | #include <linux/utsname.h> | 249 | #include <linux/utsname.h> |
250 | 250 | ||
251 | #include <asm/unaligned.h> | ||
252 | |||
251 | #include <linux/usb/ch9.h> | 253 | #include <linux/usb/ch9.h> |
252 | #include <linux/usb/gadget.h> | 254 | #include <linux/usb/gadget.h> |
253 | 255 | ||
@@ -799,29 +801,9 @@ static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep) | |||
799 | 801 | ||
800 | /* Routines for unaligned data access */ | 802 | /* Routines for unaligned data access */ |
801 | 803 | ||
802 | static u16 get_be16(u8 *buf) | 804 | static u32 get_unaligned_be24(u8 *buf) |
803 | { | ||
804 | return ((u16) buf[0] << 8) | ((u16) buf[1]); | ||
805 | } | ||
806 | |||
807 | static u32 get_be32(u8 *buf) | ||
808 | { | ||
809 | return ((u32) buf[0] << 24) | ((u32) buf[1] << 16) | | ||
810 | ((u32) buf[2] << 8) | ((u32) buf[3]); | ||
811 | } | ||
812 | |||
813 | static void put_be16(u8 *buf, u16 val) | ||
814 | { | ||
815 | buf[0] = val >> 8; | ||
816 | buf[1] = val; | ||
817 | } | ||
818 | |||
819 | static void put_be32(u8 *buf, u32 val) | ||
820 | { | 805 | { |
821 | buf[0] = val >> 24; | 806 | return 0xffffff & (u32) get_unaligned_be32(buf - 1); |
822 | buf[1] = val >> 16; | ||
823 | buf[2] = val >> 8; | ||
824 | buf[3] = val & 0xff; | ||
825 | } | 807 | } |
826 | 808 | ||
827 | 809 | ||
@@ -1582,9 +1564,9 @@ static int do_read(struct fsg_dev *fsg) | |||
1582 | /* Get the starting Logical Block Address and check that it's | 1564 | /* Get the starting Logical Block Address and check that it's |
1583 | * not too big */ | 1565 | * not too big */ |
1584 | if (fsg->cmnd[0] == SC_READ_6) | 1566 | if (fsg->cmnd[0] == SC_READ_6) |
1585 | lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]); | 1567 | lba = get_unaligned_be24(&fsg->cmnd[1]); |
1586 | else { | 1568 | else { |
1587 | lba = get_be32(&fsg->cmnd[2]); | 1569 | lba = get_unaligned_be32(&fsg->cmnd[2]); |
1588 | 1570 | ||
1589 | /* We allow DPO (Disable Page Out = don't save data in the | 1571 | /* We allow DPO (Disable Page Out = don't save data in the |
1590 | * cache) and FUA (Force Unit Access = don't read from the | 1572 | * cache) and FUA (Force Unit Access = don't read from the |
@@ -1717,9 +1699,9 @@ static int do_write(struct fsg_dev *fsg) | |||
1717 | /* Get the starting Logical Block Address and check that it's | 1699 | /* Get the starting Logical Block Address and check that it's |
1718 | * not too big */ | 1700 | * not too big */ |
1719 | if (fsg->cmnd[0] == SC_WRITE_6) | 1701 | if (fsg->cmnd[0] == SC_WRITE_6) |
1720 | lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]); | 1702 | lba = get_unaligned_be24(&fsg->cmnd[1]); |
1721 | else { | 1703 | else { |
1722 | lba = get_be32(&fsg->cmnd[2]); | 1704 | lba = get_unaligned_be32(&fsg->cmnd[2]); |
1723 | 1705 | ||
1724 | /* We allow DPO (Disable Page Out = don't save data in the | 1706 | /* We allow DPO (Disable Page Out = don't save data in the |
1725 | * cache) and FUA (Force Unit Access = write directly to the | 1707 | * cache) and FUA (Force Unit Access = write directly to the |
@@ -1940,7 +1922,7 @@ static int do_verify(struct fsg_dev *fsg) | |||
1940 | 1922 | ||
1941 | /* Get the starting Logical Block Address and check that it's | 1923 | /* Get the starting Logical Block Address and check that it's |
1942 | * not too big */ | 1924 | * not too big */ |
1943 | lba = get_be32(&fsg->cmnd[2]); | 1925 | lba = get_unaligned_be32(&fsg->cmnd[2]); |
1944 | if (lba >= curlun->num_sectors) { | 1926 | if (lba >= curlun->num_sectors) { |
1945 | curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; | 1927 | curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; |
1946 | return -EINVAL; | 1928 | return -EINVAL; |
@@ -1953,7 +1935,7 @@ static int do_verify(struct fsg_dev *fsg) | |||
1953 | return -EINVAL; | 1935 | return -EINVAL; |
1954 | } | 1936 | } |
1955 | 1937 | ||
1956 | verification_length = get_be16(&fsg->cmnd[7]); | 1938 | verification_length = get_unaligned_be16(&fsg->cmnd[7]); |
1957 | if (unlikely(verification_length == 0)) | 1939 | if (unlikely(verification_length == 0)) |
1958 | return -EIO; // No default reply | 1940 | return -EIO; // No default reply |
1959 | 1941 | ||
@@ -2103,7 +2085,7 @@ static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2103 | memset(buf, 0, 18); | 2085 | memset(buf, 0, 18); |
2104 | buf[0] = valid | 0x70; // Valid, current error | 2086 | buf[0] = valid | 0x70; // Valid, current error |
2105 | buf[2] = SK(sd); | 2087 | buf[2] = SK(sd); |
2106 | put_be32(&buf[3], sdinfo); // Sense information | 2088 | put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */ |
2107 | buf[7] = 18 - 8; // Additional sense length | 2089 | buf[7] = 18 - 8; // Additional sense length |
2108 | buf[12] = ASC(sd); | 2090 | buf[12] = ASC(sd); |
2109 | buf[13] = ASCQ(sd); | 2091 | buf[13] = ASCQ(sd); |
@@ -2114,7 +2096,7 @@ static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2114 | static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh) | 2096 | static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh) |
2115 | { | 2097 | { |
2116 | struct lun *curlun = fsg->curlun; | 2098 | struct lun *curlun = fsg->curlun; |
2117 | u32 lba = get_be32(&fsg->cmnd[2]); | 2099 | u32 lba = get_unaligned_be32(&fsg->cmnd[2]); |
2118 | int pmi = fsg->cmnd[8]; | 2100 | int pmi = fsg->cmnd[8]; |
2119 | u8 *buf = (u8 *) bh->buf; | 2101 | u8 *buf = (u8 *) bh->buf; |
2120 | 2102 | ||
@@ -2124,8 +2106,9 @@ static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2124 | return -EINVAL; | 2106 | return -EINVAL; |
2125 | } | 2107 | } |
2126 | 2108 | ||
2127 | put_be32(&buf[0], curlun->num_sectors - 1); // Max logical block | 2109 | put_unaligned_be32(curlun->num_sectors - 1, &buf[0]); |
2128 | put_be32(&buf[4], 512); // Block length | 2110 | /* Max logical block */ |
2111 | put_unaligned_be32(512, &buf[4]); /* Block length */ | ||
2129 | return 8; | 2112 | return 8; |
2130 | } | 2113 | } |
2131 | 2114 | ||
@@ -2144,7 +2127,7 @@ static void store_cdrom_address(u8 *dest, int msf, u32 addr) | |||
2144 | dest[0] = 0; /* Reserved */ | 2127 | dest[0] = 0; /* Reserved */ |
2145 | } else { | 2128 | } else { |
2146 | /* Absolute sector */ | 2129 | /* Absolute sector */ |
2147 | put_be32(dest, addr); | 2130 | put_unaligned_be32(addr, dest); |
2148 | } | 2131 | } |
2149 | } | 2132 | } |
2150 | 2133 | ||
@@ -2152,7 +2135,7 @@ static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2152 | { | 2135 | { |
2153 | struct lun *curlun = fsg->curlun; | 2136 | struct lun *curlun = fsg->curlun; |
2154 | int msf = fsg->cmnd[1] & 0x02; | 2137 | int msf = fsg->cmnd[1] & 0x02; |
2155 | u32 lba = get_be32(&fsg->cmnd[2]); | 2138 | u32 lba = get_unaligned_be32(&fsg->cmnd[2]); |
2156 | u8 *buf = (u8 *) bh->buf; | 2139 | u8 *buf = (u8 *) bh->buf; |
2157 | 2140 | ||
2158 | if ((fsg->cmnd[1] & ~0x02) != 0) { /* Mask away MSF */ | 2141 | if ((fsg->cmnd[1] & ~0x02) != 0) { /* Mask away MSF */ |
@@ -2252,10 +2235,13 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2252 | buf[2] = 0x04; // Write cache enable, | 2235 | buf[2] = 0x04; // Write cache enable, |
2253 | // Read cache not disabled | 2236 | // Read cache not disabled |
2254 | // No cache retention priorities | 2237 | // No cache retention priorities |
2255 | put_be16(&buf[4], 0xffff); // Don't disable prefetch | 2238 | put_unaligned_be16(0xffff, &buf[4]); |
2256 | // Minimum prefetch = 0 | 2239 | /* Don't disable prefetch */ |
2257 | put_be16(&buf[8], 0xffff); // Maximum prefetch | 2240 | /* Minimum prefetch = 0 */ |
2258 | put_be16(&buf[10], 0xffff); // Maximum prefetch ceiling | 2241 | put_unaligned_be16(0xffff, &buf[8]); |
2242 | /* Maximum prefetch */ | ||
2243 | put_unaligned_be16(0xffff, &buf[10]); | ||
2244 | /* Maximum prefetch ceiling */ | ||
2259 | } | 2245 | } |
2260 | buf += 12; | 2246 | buf += 12; |
2261 | } | 2247 | } |
@@ -2272,7 +2258,7 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) | |||
2272 | if (mscmnd == SC_MODE_SENSE_6) | 2258 | if (mscmnd == SC_MODE_SENSE_6) |
2273 | buf0[0] = len - 1; | 2259 | buf0[0] = len - 1; |
2274 | else | 2260 | else |
2275 | put_be16(buf0, len - 2); | 2261 | put_unaligned_be16(len - 2, buf0); |
2276 | return len; | 2262 | return len; |
2277 | } | 2263 | } |
2278 | 2264 | ||
@@ -2360,9 +2346,10 @@ static int do_read_format_capacities(struct fsg_dev *fsg, | |||
2360 | buf[3] = 8; // Only the Current/Maximum Capacity Descriptor | 2346 | buf[3] = 8; // Only the Current/Maximum Capacity Descriptor |
2361 | buf += 4; | 2347 | buf += 4; |
2362 | 2348 | ||
2363 | put_be32(&buf[0], curlun->num_sectors); // Number of blocks | 2349 | put_unaligned_be32(curlun->num_sectors, &buf[0]); |
2364 | put_be32(&buf[4], 512); // Block length | 2350 | /* Number of blocks */ |
2365 | buf[4] = 0x02; // Current capacity | 2351 | put_unaligned_be32(512, &buf[4]); /* Block length */ |
2352 | buf[4] = 0x02; /* Current capacity */ | ||
2366 | return 12; | 2353 | return 12; |
2367 | } | 2354 | } |
2368 | 2355 | ||
@@ -2882,7 +2869,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2882 | break; | 2869 | break; |
2883 | 2870 | ||
2884 | case SC_MODE_SELECT_10: | 2871 | case SC_MODE_SELECT_10: |
2885 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]); | 2872 | fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]); |
2886 | if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST, | 2873 | if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST, |
2887 | (1<<1) | (3<<7), 0, | 2874 | (1<<1) | (3<<7), 0, |
2888 | "MODE SELECT(10)")) == 0) | 2875 | "MODE SELECT(10)")) == 0) |
@@ -2898,7 +2885,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2898 | break; | 2885 | break; |
2899 | 2886 | ||
2900 | case SC_MODE_SENSE_10: | 2887 | case SC_MODE_SENSE_10: |
2901 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]); | 2888 | fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]); |
2902 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, | 2889 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, |
2903 | (1<<1) | (1<<2) | (3<<7), 0, | 2890 | (1<<1) | (1<<2) | (3<<7), 0, |
2904 | "MODE SENSE(10)")) == 0) | 2891 | "MODE SENSE(10)")) == 0) |
@@ -2923,7 +2910,8 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2923 | break; | 2910 | break; |
2924 | 2911 | ||
2925 | case SC_READ_10: | 2912 | case SC_READ_10: |
2926 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9; | 2913 | fsg->data_size_from_cmnd = |
2914 | get_unaligned_be16(&fsg->cmnd[7]) << 9; | ||
2927 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, | 2915 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, |
2928 | (1<<1) | (0xf<<2) | (3<<7), 1, | 2916 | (1<<1) | (0xf<<2) | (3<<7), 1, |
2929 | "READ(10)")) == 0) | 2917 | "READ(10)")) == 0) |
@@ -2931,7 +2919,8 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2931 | break; | 2919 | break; |
2932 | 2920 | ||
2933 | case SC_READ_12: | 2921 | case SC_READ_12: |
2934 | fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9; | 2922 | fsg->data_size_from_cmnd = |
2923 | get_unaligned_be32(&fsg->cmnd[6]) << 9; | ||
2935 | if ((reply = check_command(fsg, 12, DATA_DIR_TO_HOST, | 2924 | if ((reply = check_command(fsg, 12, DATA_DIR_TO_HOST, |
2936 | (1<<1) | (0xf<<2) | (0xf<<6), 1, | 2925 | (1<<1) | (0xf<<2) | (0xf<<6), 1, |
2937 | "READ(12)")) == 0) | 2926 | "READ(12)")) == 0) |
@@ -2949,7 +2938,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2949 | case SC_READ_HEADER: | 2938 | case SC_READ_HEADER: |
2950 | if (!mod_data.cdrom) | 2939 | if (!mod_data.cdrom) |
2951 | goto unknown_cmnd; | 2940 | goto unknown_cmnd; |
2952 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]); | 2941 | fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]); |
2953 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, | 2942 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, |
2954 | (3<<7) | (0x1f<<1), 1, | 2943 | (3<<7) | (0x1f<<1), 1, |
2955 | "READ HEADER")) == 0) | 2944 | "READ HEADER")) == 0) |
@@ -2959,7 +2948,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2959 | case SC_READ_TOC: | 2948 | case SC_READ_TOC: |
2960 | if (!mod_data.cdrom) | 2949 | if (!mod_data.cdrom) |
2961 | goto unknown_cmnd; | 2950 | goto unknown_cmnd; |
2962 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]); | 2951 | fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]); |
2963 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, | 2952 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, |
2964 | (7<<6) | (1<<1), 1, | 2953 | (7<<6) | (1<<1), 1, |
2965 | "READ TOC")) == 0) | 2954 | "READ TOC")) == 0) |
@@ -2967,7 +2956,7 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
2967 | break; | 2956 | break; |
2968 | 2957 | ||
2969 | case SC_READ_FORMAT_CAPACITIES: | 2958 | case SC_READ_FORMAT_CAPACITIES: |
2970 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]); | 2959 | fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]); |
2971 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, | 2960 | if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST, |
2972 | (3<<7), 1, | 2961 | (3<<7), 1, |
2973 | "READ FORMAT CAPACITIES")) == 0) | 2962 | "READ FORMAT CAPACITIES")) == 0) |
@@ -3025,7 +3014,8 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
3025 | break; | 3014 | break; |
3026 | 3015 | ||
3027 | case SC_WRITE_10: | 3016 | case SC_WRITE_10: |
3028 | fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9; | 3017 | fsg->data_size_from_cmnd = |
3018 | get_unaligned_be16(&fsg->cmnd[7]) << 9; | ||
3029 | if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST, | 3019 | if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST, |
3030 | (1<<1) | (0xf<<2) | (3<<7), 1, | 3020 | (1<<1) | (0xf<<2) | (3<<7), 1, |
3031 | "WRITE(10)")) == 0) | 3021 | "WRITE(10)")) == 0) |
@@ -3033,7 +3023,8 @@ static int do_scsi_command(struct fsg_dev *fsg) | |||
3033 | break; | 3023 | break; |
3034 | 3024 | ||
3035 | case SC_WRITE_12: | 3025 | case SC_WRITE_12: |
3036 | fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9; | 3026 | fsg->data_size_from_cmnd = |
3027 | get_unaligned_be32(&fsg->cmnd[6]) << 9; | ||
3037 | if ((reply = check_command(fsg, 12, DATA_DIR_FROM_HOST, | 3028 | if ((reply = check_command(fsg, 12, DATA_DIR_FROM_HOST, |
3038 | (1<<1) | (0xf<<2) | (0xf<<6), 1, | 3029 | (1<<1) | (0xf<<2) | (0xf<<6), 1, |
3039 | "WRITE(12)")) == 0) | 3030 | "WRITE(12)")) == 0) |
diff --git a/drivers/usb/gadget/fsl_mx3_udc.c b/drivers/usb/gadget/fsl_mx3_udc.c new file mode 100644 index 000000000000..4bc2bf3d602e --- /dev/null +++ b/drivers/usb/gadget/fsl_mx3_udc.c | |||
@@ -0,0 +1,95 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2009 | ||
3 | * Guennadi Liakhovetski, DENX Software Engineering, <lg@denx.de> | ||
4 | * | ||
5 | * Description: | ||
6 | * Helper routines for i.MX3x SoCs from Freescale, needed by the fsl_usb2_udc.c | ||
7 | * driver to function correctly on these systems. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify it | ||
10 | * under the terms of the GNU General Public License as published by the | ||
11 | * Free Software Foundation; either version 2 of the License, or (at your | ||
12 | * option) any later version. | ||
13 | */ | ||
14 | #include <linux/clk.h> | ||
15 | #include <linux/delay.h> | ||
16 | #include <linux/err.h> | ||
17 | #include <linux/fsl_devices.h> | ||
18 | #include <linux/platform_device.h> | ||
19 | |||
20 | static struct clk *mxc_ahb_clk; | ||
21 | static struct clk *mxc_usb_clk; | ||
22 | |||
23 | int fsl_udc_clk_init(struct platform_device *pdev) | ||
24 | { | ||
25 | struct fsl_usb2_platform_data *pdata; | ||
26 | unsigned long freq; | ||
27 | int ret; | ||
28 | |||
29 | pdata = pdev->dev.platform_data; | ||
30 | |||
31 | mxc_ahb_clk = clk_get(&pdev->dev, "usb_ahb"); | ||
32 | if (IS_ERR(mxc_ahb_clk)) | ||
33 | return PTR_ERR(mxc_ahb_clk); | ||
34 | |||
35 | ret = clk_enable(mxc_ahb_clk); | ||
36 | if (ret < 0) { | ||
37 | dev_err(&pdev->dev, "clk_enable(\"usb_ahb\") failed\n"); | ||
38 | goto eenahb; | ||
39 | } | ||
40 | |||
41 | /* make sure USB_CLK is running at 60 MHz +/- 1000 Hz */ | ||
42 | mxc_usb_clk = clk_get(&pdev->dev, "usb"); | ||
43 | if (IS_ERR(mxc_usb_clk)) { | ||
44 | dev_err(&pdev->dev, "clk_get(\"usb\") failed\n"); | ||
45 | ret = PTR_ERR(mxc_usb_clk); | ||
46 | goto egusb; | ||
47 | } | ||
48 | |||
49 | freq = clk_get_rate(mxc_usb_clk); | ||
50 | if (pdata->phy_mode != FSL_USB2_PHY_ULPI && | ||
51 | (freq < 59999000 || freq > 60001000)) { | ||
52 | dev_err(&pdev->dev, "USB_CLK=%lu, should be 60MHz\n", freq); | ||
53 | goto eclkrate; | ||
54 | } | ||
55 | |||
56 | ret = clk_enable(mxc_usb_clk); | ||
57 | if (ret < 0) { | ||
58 | dev_err(&pdev->dev, "clk_enable(\"usb_clk\") failed\n"); | ||
59 | goto eenusb; | ||
60 | } | ||
61 | |||
62 | return 0; | ||
63 | |||
64 | eenusb: | ||
65 | eclkrate: | ||
66 | clk_put(mxc_usb_clk); | ||
67 | mxc_usb_clk = NULL; | ||
68 | egusb: | ||
69 | clk_disable(mxc_ahb_clk); | ||
70 | eenahb: | ||
71 | clk_put(mxc_ahb_clk); | ||
72 | return ret; | ||
73 | } | ||
74 | |||
75 | void fsl_udc_clk_finalize(struct platform_device *pdev) | ||
76 | { | ||
77 | struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data; | ||
78 | |||
79 | /* ULPI transceivers don't need usbpll */ | ||
80 | if (pdata->phy_mode == FSL_USB2_PHY_ULPI) { | ||
81 | clk_disable(mxc_usb_clk); | ||
82 | clk_put(mxc_usb_clk); | ||
83 | mxc_usb_clk = NULL; | ||
84 | } | ||
85 | } | ||
86 | |||
87 | void fsl_udc_clk_release(void) | ||
88 | { | ||
89 | if (mxc_usb_clk) { | ||
90 | clk_disable(mxc_usb_clk); | ||
91 | clk_put(mxc_usb_clk); | ||
92 | } | ||
93 | clk_disable(mxc_ahb_clk); | ||
94 | clk_put(mxc_ahb_clk); | ||
95 | } | ||
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_udc_core.c index 9d7b95d4e3d2..42a74b8a0bb8 100644 --- a/drivers/usb/gadget/fsl_usb2_udc.c +++ b/drivers/usb/gadget/fsl_udc_core.c | |||
@@ -38,6 +38,7 @@ | |||
38 | #include <linux/platform_device.h> | 38 | #include <linux/platform_device.h> |
39 | #include <linux/fsl_devices.h> | 39 | #include <linux/fsl_devices.h> |
40 | #include <linux/dmapool.h> | 40 | #include <linux/dmapool.h> |
41 | #include <linux/delay.h> | ||
41 | 42 | ||
42 | #include <asm/byteorder.h> | 43 | #include <asm/byteorder.h> |
43 | #include <asm/io.h> | 44 | #include <asm/io.h> |
@@ -57,7 +58,9 @@ static const char driver_name[] = "fsl-usb2-udc"; | |||
57 | static const char driver_desc[] = DRIVER_DESC; | 58 | static const char driver_desc[] = DRIVER_DESC; |
58 | 59 | ||
59 | static struct usb_dr_device *dr_regs; | 60 | static struct usb_dr_device *dr_regs; |
61 | #ifndef CONFIG_ARCH_MXC | ||
60 | static struct usb_sys_interface *usb_sys_regs; | 62 | static struct usb_sys_interface *usb_sys_regs; |
63 | #endif | ||
61 | 64 | ||
62 | /* it is initialized in probe() */ | 65 | /* it is initialized in probe() */ |
63 | static struct fsl_udc *udc_controller = NULL; | 66 | static struct fsl_udc *udc_controller = NULL; |
@@ -174,10 +177,34 @@ static void nuke(struct fsl_ep *ep, int status) | |||
174 | 177 | ||
175 | static int dr_controller_setup(struct fsl_udc *udc) | 178 | static int dr_controller_setup(struct fsl_udc *udc) |
176 | { | 179 | { |
177 | unsigned int tmp = 0, portctrl = 0, ctrl = 0; | 180 | unsigned int tmp, portctrl; |
181 | #ifndef CONFIG_ARCH_MXC | ||
182 | unsigned int ctrl; | ||
183 | #endif | ||
178 | unsigned long timeout; | 184 | unsigned long timeout; |
179 | #define FSL_UDC_RESET_TIMEOUT 1000 | 185 | #define FSL_UDC_RESET_TIMEOUT 1000 |
180 | 186 | ||
187 | /* Config PHY interface */ | ||
188 | portctrl = fsl_readl(&dr_regs->portsc1); | ||
189 | portctrl &= ~(PORTSCX_PHY_TYPE_SEL | PORTSCX_PORT_WIDTH); | ||
190 | switch (udc->phy_mode) { | ||
191 | case FSL_USB2_PHY_ULPI: | ||
192 | portctrl |= PORTSCX_PTS_ULPI; | ||
193 | break; | ||
194 | case FSL_USB2_PHY_UTMI_WIDE: | ||
195 | portctrl |= PORTSCX_PTW_16BIT; | ||
196 | /* fall through */ | ||
197 | case FSL_USB2_PHY_UTMI: | ||
198 | portctrl |= PORTSCX_PTS_UTMI; | ||
199 | break; | ||
200 | case FSL_USB2_PHY_SERIAL: | ||
201 | portctrl |= PORTSCX_PTS_FSLS; | ||
202 | break; | ||
203 | default: | ||
204 | return -EINVAL; | ||
205 | } | ||
206 | fsl_writel(portctrl, &dr_regs->portsc1); | ||
207 | |||
181 | /* Stop and reset the usb controller */ | 208 | /* Stop and reset the usb controller */ |
182 | tmp = fsl_readl(&dr_regs->usbcmd); | 209 | tmp = fsl_readl(&dr_regs->usbcmd); |
183 | tmp &= ~USB_CMD_RUN_STOP; | 210 | tmp &= ~USB_CMD_RUN_STOP; |
@@ -215,31 +242,12 @@ static int dr_controller_setup(struct fsl_udc *udc) | |||
215 | udc->ep_qh, (int)tmp, | 242 | udc->ep_qh, (int)tmp, |
216 | fsl_readl(&dr_regs->endpointlistaddr)); | 243 | fsl_readl(&dr_regs->endpointlistaddr)); |
217 | 244 | ||
218 | /* Config PHY interface */ | ||
219 | portctrl = fsl_readl(&dr_regs->portsc1); | ||
220 | portctrl &= ~(PORTSCX_PHY_TYPE_SEL | PORTSCX_PORT_WIDTH); | ||
221 | switch (udc->phy_mode) { | ||
222 | case FSL_USB2_PHY_ULPI: | ||
223 | portctrl |= PORTSCX_PTS_ULPI; | ||
224 | break; | ||
225 | case FSL_USB2_PHY_UTMI_WIDE: | ||
226 | portctrl |= PORTSCX_PTW_16BIT; | ||
227 | /* fall through */ | ||
228 | case FSL_USB2_PHY_UTMI: | ||
229 | portctrl |= PORTSCX_PTS_UTMI; | ||
230 | break; | ||
231 | case FSL_USB2_PHY_SERIAL: | ||
232 | portctrl |= PORTSCX_PTS_FSLS; | ||
233 | break; | ||
234 | default: | ||
235 | return -EINVAL; | ||
236 | } | ||
237 | fsl_writel(portctrl, &dr_regs->portsc1); | ||
238 | |||
239 | /* Config control enable i/o output, cpu endian register */ | 245 | /* Config control enable i/o output, cpu endian register */ |
246 | #ifndef CONFIG_ARCH_MXC | ||
240 | ctrl = __raw_readl(&usb_sys_regs->control); | 247 | ctrl = __raw_readl(&usb_sys_regs->control); |
241 | ctrl |= USB_CTRL_IOENB; | 248 | ctrl |= USB_CTRL_IOENB; |
242 | __raw_writel(ctrl, &usb_sys_regs->control); | 249 | __raw_writel(ctrl, &usb_sys_regs->control); |
250 | #endif | ||
243 | 251 | ||
244 | #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) | 252 | #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) |
245 | /* Turn on cache snooping hardware, since some PowerPC platforms | 253 | /* Turn on cache snooping hardware, since some PowerPC platforms |
@@ -2043,6 +2051,7 @@ static int fsl_proc_read(char *page, char **start, off_t off, int count, | |||
2043 | size -= t; | 2051 | size -= t; |
2044 | next += t; | 2052 | next += t; |
2045 | 2053 | ||
2054 | #ifndef CONFIG_ARCH_MXC | ||
2046 | tmp_reg = usb_sys_regs->snoop1; | 2055 | tmp_reg = usb_sys_regs->snoop1; |
2047 | t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg); | 2056 | t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg); |
2048 | size -= t; | 2057 | size -= t; |
@@ -2053,6 +2062,7 @@ static int fsl_proc_read(char *page, char **start, off_t off, int count, | |||
2053 | tmp_reg); | 2062 | tmp_reg); |
2054 | size -= t; | 2063 | size -= t; |
2055 | next += t; | 2064 | next += t; |
2065 | #endif | ||
2056 | 2066 | ||
2057 | /* ------fsl_udc, fsl_ep, fsl_request structure information ----- */ | 2067 | /* ------fsl_udc, fsl_ep, fsl_request structure information ----- */ |
2058 | ep = &udc->eps[0]; | 2068 | ep = &udc->eps[0]; |
@@ -2263,14 +2273,21 @@ static int __init fsl_udc_probe(struct platform_device *pdev) | |||
2263 | goto err_kfree; | 2273 | goto err_kfree; |
2264 | } | 2274 | } |
2265 | 2275 | ||
2266 | dr_regs = ioremap(res->start, res->end - res->start + 1); | 2276 | dr_regs = ioremap(res->start, resource_size(res)); |
2267 | if (!dr_regs) { | 2277 | if (!dr_regs) { |
2268 | ret = -ENOMEM; | 2278 | ret = -ENOMEM; |
2269 | goto err_release_mem_region; | 2279 | goto err_release_mem_region; |
2270 | } | 2280 | } |
2271 | 2281 | ||
2282 | #ifndef CONFIG_ARCH_MXC | ||
2272 | usb_sys_regs = (struct usb_sys_interface *) | 2283 | usb_sys_regs = (struct usb_sys_interface *) |
2273 | ((u32)dr_regs + USB_DR_SYS_OFFSET); | 2284 | ((u32)dr_regs + USB_DR_SYS_OFFSET); |
2285 | #endif | ||
2286 | |||
2287 | /* Initialize USB clocks */ | ||
2288 | ret = fsl_udc_clk_init(pdev); | ||
2289 | if (ret < 0) | ||
2290 | goto err_iounmap_noclk; | ||
2274 | 2291 | ||
2275 | /* Read Device Controller Capability Parameters register */ | 2292 | /* Read Device Controller Capability Parameters register */ |
2276 | dccparams = fsl_readl(&dr_regs->dccparams); | 2293 | dccparams = fsl_readl(&dr_regs->dccparams); |
@@ -2308,6 +2325,8 @@ static int __init fsl_udc_probe(struct platform_device *pdev) | |||
2308 | * leave usbintr reg untouched */ | 2325 | * leave usbintr reg untouched */ |
2309 | dr_controller_setup(udc_controller); | 2326 | dr_controller_setup(udc_controller); |
2310 | 2327 | ||
2328 | fsl_udc_clk_finalize(pdev); | ||
2329 | |||
2311 | /* Setup gadget structure */ | 2330 | /* Setup gadget structure */ |
2312 | udc_controller->gadget.ops = &fsl_gadget_ops; | 2331 | udc_controller->gadget.ops = &fsl_gadget_ops; |
2313 | udc_controller->gadget.is_dualspeed = 1; | 2332 | udc_controller->gadget.is_dualspeed = 1; |
@@ -2362,6 +2381,8 @@ err_unregister: | |||
2362 | err_free_irq: | 2381 | err_free_irq: |
2363 | free_irq(udc_controller->irq, udc_controller); | 2382 | free_irq(udc_controller->irq, udc_controller); |
2364 | err_iounmap: | 2383 | err_iounmap: |
2384 | fsl_udc_clk_release(); | ||
2385 | err_iounmap_noclk: | ||
2365 | iounmap(dr_regs); | 2386 | iounmap(dr_regs); |
2366 | err_release_mem_region: | 2387 | err_release_mem_region: |
2367 | release_mem_region(res->start, res->end - res->start + 1); | 2388 | release_mem_region(res->start, res->end - res->start + 1); |
@@ -2384,6 +2405,8 @@ static int __exit fsl_udc_remove(struct platform_device *pdev) | |||
2384 | return -ENODEV; | 2405 | return -ENODEV; |
2385 | udc_controller->done = &done; | 2406 | udc_controller->done = &done; |
2386 | 2407 | ||
2408 | fsl_udc_clk_release(); | ||
2409 | |||
2387 | /* DR has been stopped in usb_gadget_unregister_driver() */ | 2410 | /* DR has been stopped in usb_gadget_unregister_driver() */ |
2388 | remove_proc_file(); | 2411 | remove_proc_file(); |
2389 | 2412 | ||
diff --git a/drivers/usb/gadget/fsl_usb2_udc.h b/drivers/usb/gadget/fsl_usb2_udc.h index e63ef12645f5..20aeceed48c7 100644 --- a/drivers/usb/gadget/fsl_usb2_udc.h +++ b/drivers/usb/gadget/fsl_usb2_udc.h | |||
@@ -563,4 +563,22 @@ static void dump_msg(const char *label, const u8 * buf, unsigned int length) | |||
563 | * 2 + ((windex & USB_DIR_IN) ? 1 : 0)) | 563 | * 2 + ((windex & USB_DIR_IN) ? 1 : 0)) |
564 | #define get_pipe_by_ep(EP) (ep_index(EP) * 2 + ep_is_in(EP)) | 564 | #define get_pipe_by_ep(EP) (ep_index(EP) * 2 + ep_is_in(EP)) |
565 | 565 | ||
566 | struct platform_device; | ||
567 | #ifdef CONFIG_ARCH_MXC | ||
568 | int fsl_udc_clk_init(struct platform_device *pdev); | ||
569 | void fsl_udc_clk_finalize(struct platform_device *pdev); | ||
570 | void fsl_udc_clk_release(void); | ||
571 | #else | ||
572 | static inline int fsl_udc_clk_init(struct platform_device *pdev) | ||
573 | { | ||
574 | return 0; | ||
575 | } | ||
576 | static inline void fsl_udc_clk_finalize(struct platform_device *pdev) | ||
577 | { | ||
578 | } | ||
579 | static inline void fsl_udc_clk_release(void) | ||
580 | { | ||
581 | } | ||
582 | #endif | ||
583 | |||
566 | #endif | 584 | #endif |
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h index ec6d439a2aa5..8e0e9a0b7364 100644 --- a/drivers/usb/gadget/gadget_chips.h +++ b/drivers/usb/gadget/gadget_chips.h | |||
@@ -137,6 +137,12 @@ | |||
137 | #define gadget_is_musbhdrc(g) 0 | 137 | #define gadget_is_musbhdrc(g) 0 |
138 | #endif | 138 | #endif |
139 | 139 | ||
140 | #ifdef CONFIG_USB_GADGET_LANGWELL | ||
141 | #define gadget_is_langwell(g) (!strcmp("langwell_udc", (g)->name)) | ||
142 | #else | ||
143 | #define gadget_is_langwell(g) 0 | ||
144 | #endif | ||
145 | |||
140 | /* from Montavista kernel (?) */ | 146 | /* from Montavista kernel (?) */ |
141 | #ifdef CONFIG_USB_GADGET_MPC8272 | 147 | #ifdef CONFIG_USB_GADGET_MPC8272 |
142 | #define gadget_is_mpc8272(g) !strcmp("mpc8272_udc", (g)->name) | 148 | #define gadget_is_mpc8272(g) !strcmp("mpc8272_udc", (g)->name) |
@@ -231,6 +237,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget) | |||
231 | return 0x22; | 237 | return 0x22; |
232 | else if (gadget_is_ci13xxx(gadget)) | 238 | else if (gadget_is_ci13xxx(gadget)) |
233 | return 0x23; | 239 | return 0x23; |
240 | else if (gadget_is_langwell(gadget)) | ||
241 | return 0x24; | ||
234 | return -ENOENT; | 242 | return -ENOENT; |
235 | } | 243 | } |
236 | 244 | ||
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c index de010c939dbb..112bb40a427c 100644 --- a/drivers/usb/gadget/goku_udc.c +++ b/drivers/usb/gadget/goku_udc.c | |||
@@ -110,10 +110,10 @@ goku_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
110 | return -EINVAL; | 110 | return -EINVAL; |
111 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) | 111 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) |
112 | return -ESHUTDOWN; | 112 | return -ESHUTDOWN; |
113 | if (ep->num != (desc->bEndpointAddress & 0x0f)) | 113 | if (ep->num != usb_endpoint_num(desc)) |
114 | return -EINVAL; | 114 | return -EINVAL; |
115 | 115 | ||
116 | switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { | 116 | switch (usb_endpoint_type(desc)) { |
117 | case USB_ENDPOINT_XFER_BULK: | 117 | case USB_ENDPOINT_XFER_BULK: |
118 | case USB_ENDPOINT_XFER_INT: | 118 | case USB_ENDPOINT_XFER_INT: |
119 | break; | 119 | break; |
@@ -142,7 +142,7 @@ goku_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
142 | /* ep1/ep2 dma direction is chosen early; it works in the other | 142 | /* ep1/ep2 dma direction is chosen early; it works in the other |
143 | * direction, with pio. be cautious with out-dma. | 143 | * direction, with pio. be cautious with out-dma. |
144 | */ | 144 | */ |
145 | ep->is_in = (USB_DIR_IN & desc->bEndpointAddress) != 0; | 145 | ep->is_in = usb_endpoint_dir_in(desc); |
146 | if (ep->is_in) { | 146 | if (ep->is_in) { |
147 | mode |= 1; | 147 | mode |= 1; |
148 | ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT); | 148 | ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT); |
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c index 168658b4b4e2..c52a681f376c 100644 --- a/drivers/usb/gadget/imx_udc.c +++ b/drivers/usb/gadget/imx_udc.c | |||
@@ -415,6 +415,13 @@ static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req) | |||
415 | u8 *buf; | 415 | u8 *buf; |
416 | int length, count, temp; | 416 | int length, count, temp; |
417 | 417 | ||
418 | if (unlikely(__raw_readl(imx_ep->imx_usb->base + | ||
419 | USB_EP_STAT(EP_NO(imx_ep))) & EPSTAT_ZLPS)) { | ||
420 | D_TRX(imx_ep->imx_usb->dev, "<%s> zlp still queued in EP %s\n", | ||
421 | __func__, imx_ep->ep.name); | ||
422 | return -1; | ||
423 | } | ||
424 | |||
418 | buf = req->req.buf + req->req.actual; | 425 | buf = req->req.buf + req->req.actual; |
419 | prefetch(buf); | 426 | prefetch(buf); |
420 | 427 | ||
@@ -734,9 +741,12 @@ static struct usb_request *imx_ep_alloc_request | |||
734 | { | 741 | { |
735 | struct imx_request *req; | 742 | struct imx_request *req; |
736 | 743 | ||
744 | if (!usb_ep) | ||
745 | return NULL; | ||
746 | |||
737 | req = kzalloc(sizeof *req, gfp_flags); | 747 | req = kzalloc(sizeof *req, gfp_flags); |
738 | if (!req || !usb_ep) | 748 | if (!req) |
739 | return 0; | 749 | return NULL; |
740 | 750 | ||
741 | INIT_LIST_HEAD(&req->queue); | 751 | INIT_LIST_HEAD(&req->queue); |
742 | req->in_use = 0; | 752 | req->in_use = 0; |
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c index d20937f28a19..7d33f50b5874 100644 --- a/drivers/usb/gadget/inode.c +++ b/drivers/usb/gadget/inode.c | |||
@@ -384,9 +384,8 @@ ep_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr) | |||
384 | return value; | 384 | return value; |
385 | 385 | ||
386 | /* halt any endpoint by doing a "wrong direction" i/o call */ | 386 | /* halt any endpoint by doing a "wrong direction" i/o call */ |
387 | if (data->desc.bEndpointAddress & USB_DIR_IN) { | 387 | if (usb_endpoint_dir_in(&data->desc)) { |
388 | if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) | 388 | if (usb_endpoint_xfer_isoc(&data->desc)) |
389 | == USB_ENDPOINT_XFER_ISOC) | ||
390 | return -EINVAL; | 389 | return -EINVAL; |
391 | DBG (data->dev, "%s halt\n", data->name); | 390 | DBG (data->dev, "%s halt\n", data->name); |
392 | spin_lock_irq (&data->dev->lock); | 391 | spin_lock_irq (&data->dev->lock); |
@@ -428,9 +427,8 @@ ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr) | |||
428 | return value; | 427 | return value; |
429 | 428 | ||
430 | /* halt any endpoint by doing a "wrong direction" i/o call */ | 429 | /* halt any endpoint by doing a "wrong direction" i/o call */ |
431 | if (!(data->desc.bEndpointAddress & USB_DIR_IN)) { | 430 | if (!usb_endpoint_dir_in(&data->desc)) { |
432 | if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) | 431 | if (usb_endpoint_xfer_isoc(&data->desc)) |
433 | == USB_ENDPOINT_XFER_ISOC) | ||
434 | return -EINVAL; | 432 | return -EINVAL; |
435 | DBG (data->dev, "%s halt\n", data->name); | 433 | DBG (data->dev, "%s halt\n", data->name); |
436 | spin_lock_irq (&data->dev->lock); | 434 | spin_lock_irq (&data->dev->lock); |
@@ -691,7 +689,7 @@ ep_aio_read(struct kiocb *iocb, const struct iovec *iov, | |||
691 | struct ep_data *epdata = iocb->ki_filp->private_data; | 689 | struct ep_data *epdata = iocb->ki_filp->private_data; |
692 | char *buf; | 690 | char *buf; |
693 | 691 | ||
694 | if (unlikely(epdata->desc.bEndpointAddress & USB_DIR_IN)) | 692 | if (unlikely(usb_endpoint_dir_in(&epdata->desc))) |
695 | return -EINVAL; | 693 | return -EINVAL; |
696 | 694 | ||
697 | buf = kmalloc(iocb->ki_left, GFP_KERNEL); | 695 | buf = kmalloc(iocb->ki_left, GFP_KERNEL); |
@@ -711,7 +709,7 @@ ep_aio_write(struct kiocb *iocb, const struct iovec *iov, | |||
711 | size_t len = 0; | 709 | size_t len = 0; |
712 | int i = 0; | 710 | int i = 0; |
713 | 711 | ||
714 | if (unlikely(!(epdata->desc.bEndpointAddress & USB_DIR_IN))) | 712 | if (unlikely(!usb_endpoint_dir_in(&epdata->desc))) |
715 | return -EINVAL; | 713 | return -EINVAL; |
716 | 714 | ||
717 | buf = kmalloc(iocb->ki_left, GFP_KERNEL); | 715 | buf = kmalloc(iocb->ki_left, GFP_KERNEL); |
diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c new file mode 100644 index 000000000000..6829d5961359 --- /dev/null +++ b/drivers/usb/gadget/langwell_udc.c | |||
@@ -0,0 +1,3373 @@ | |||
1 | /* | ||
2 | * Intel Langwell USB Device Controller driver | ||
3 | * Copyright (C) 2008-2009, Intel Corporation. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms and conditions of the GNU General Public License, | ||
7 | * version 2, as published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., | ||
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | |||
21 | /* #undef DEBUG */ | ||
22 | /* #undef VERBOSE */ | ||
23 | |||
24 | #if defined(CONFIG_USB_LANGWELL_OTG) | ||
25 | #define OTG_TRANSCEIVER | ||
26 | #endif | ||
27 | |||
28 | |||
29 | #include <linux/module.h> | ||
30 | #include <linux/pci.h> | ||
31 | #include <linux/dma-mapping.h> | ||
32 | #include <linux/kernel.h> | ||
33 | #include <linux/delay.h> | ||
34 | #include <linux/ioport.h> | ||
35 | #include <linux/sched.h> | ||
36 | #include <linux/slab.h> | ||
37 | #include <linux/smp_lock.h> | ||
38 | #include <linux/errno.h> | ||
39 | #include <linux/init.h> | ||
40 | #include <linux/timer.h> | ||
41 | #include <linux/list.h> | ||
42 | #include <linux/interrupt.h> | ||
43 | #include <linux/moduleparam.h> | ||
44 | #include <linux/device.h> | ||
45 | #include <linux/usb/ch9.h> | ||
46 | #include <linux/usb/gadget.h> | ||
47 | #include <linux/usb/otg.h> | ||
48 | #include <linux/pm.h> | ||
49 | #include <linux/io.h> | ||
50 | #include <linux/irq.h> | ||
51 | #include <asm/system.h> | ||
52 | #include <asm/unaligned.h> | ||
53 | |||
54 | #include "langwell_udc.h" | ||
55 | |||
56 | |||
57 | #define DRIVER_DESC "Intel Langwell USB Device Controller driver" | ||
58 | #define DRIVER_VERSION "16 May 2009" | ||
59 | |||
60 | static const char driver_name[] = "langwell_udc"; | ||
61 | static const char driver_desc[] = DRIVER_DESC; | ||
62 | |||
63 | |||
64 | /* controller device global variable */ | ||
65 | static struct langwell_udc *the_controller; | ||
66 | |||
67 | /* for endpoint 0 operations */ | ||
68 | static const struct usb_endpoint_descriptor | ||
69 | langwell_ep0_desc = { | ||
70 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
71 | .bDescriptorType = USB_DT_ENDPOINT, | ||
72 | .bEndpointAddress = 0, | ||
73 | .bmAttributes = USB_ENDPOINT_XFER_CONTROL, | ||
74 | .wMaxPacketSize = EP0_MAX_PKT_SIZE, | ||
75 | }; | ||
76 | |||
77 | |||
78 | /*-------------------------------------------------------------------------*/ | ||
79 | /* debugging */ | ||
80 | |||
81 | #ifdef DEBUG | ||
82 | #define DBG(dev, fmt, args...) \ | ||
83 | pr_debug("%s %s: " fmt , driver_name, \ | ||
84 | pci_name(dev->pdev), ## args) | ||
85 | #else | ||
86 | #define DBG(dev, fmt, args...) \ | ||
87 | do { } while (0) | ||
88 | #endif /* DEBUG */ | ||
89 | |||
90 | |||
91 | #ifdef VERBOSE | ||
92 | #define VDBG DBG | ||
93 | #else | ||
94 | #define VDBG(dev, fmt, args...) \ | ||
95 | do { } while (0) | ||
96 | #endif /* VERBOSE */ | ||
97 | |||
98 | |||
99 | #define ERROR(dev, fmt, args...) \ | ||
100 | pr_err("%s %s: " fmt , driver_name, \ | ||
101 | pci_name(dev->pdev), ## args) | ||
102 | |||
103 | #define WARNING(dev, fmt, args...) \ | ||
104 | pr_warning("%s %s: " fmt , driver_name, \ | ||
105 | pci_name(dev->pdev), ## args) | ||
106 | |||
107 | #define INFO(dev, fmt, args...) \ | ||
108 | pr_info("%s %s: " fmt , driver_name, \ | ||
109 | pci_name(dev->pdev), ## args) | ||
110 | |||
111 | |||
112 | #ifdef VERBOSE | ||
113 | static inline void print_all_registers(struct langwell_udc *dev) | ||
114 | { | ||
115 | int i; | ||
116 | |||
117 | /* Capability Registers */ | ||
118 | printk(KERN_DEBUG "Capability Registers (offset: " | ||
119 | "0x%04x, length: 0x%08x)\n", | ||
120 | CAP_REG_OFFSET, | ||
121 | (u32)sizeof(struct langwell_cap_regs)); | ||
122 | printk(KERN_DEBUG "caplength=0x%02x\n", | ||
123 | readb(&dev->cap_regs->caplength)); | ||
124 | printk(KERN_DEBUG "hciversion=0x%04x\n", | ||
125 | readw(&dev->cap_regs->hciversion)); | ||
126 | printk(KERN_DEBUG "hcsparams=0x%08x\n", | ||
127 | readl(&dev->cap_regs->hcsparams)); | ||
128 | printk(KERN_DEBUG "hccparams=0x%08x\n", | ||
129 | readl(&dev->cap_regs->hccparams)); | ||
130 | printk(KERN_DEBUG "dciversion=0x%04x\n", | ||
131 | readw(&dev->cap_regs->dciversion)); | ||
132 | printk(KERN_DEBUG "dccparams=0x%08x\n", | ||
133 | readl(&dev->cap_regs->dccparams)); | ||
134 | |||
135 | /* Operational Registers */ | ||
136 | printk(KERN_DEBUG "Operational Registers (offset: " | ||
137 | "0x%04x, length: 0x%08x)\n", | ||
138 | OP_REG_OFFSET, | ||
139 | (u32)sizeof(struct langwell_op_regs)); | ||
140 | printk(KERN_DEBUG "extsts=0x%08x\n", | ||
141 | readl(&dev->op_regs->extsts)); | ||
142 | printk(KERN_DEBUG "extintr=0x%08x\n", | ||
143 | readl(&dev->op_regs->extintr)); | ||
144 | printk(KERN_DEBUG "usbcmd=0x%08x\n", | ||
145 | readl(&dev->op_regs->usbcmd)); | ||
146 | printk(KERN_DEBUG "usbsts=0x%08x\n", | ||
147 | readl(&dev->op_regs->usbsts)); | ||
148 | printk(KERN_DEBUG "usbintr=0x%08x\n", | ||
149 | readl(&dev->op_regs->usbintr)); | ||
150 | printk(KERN_DEBUG "frindex=0x%08x\n", | ||
151 | readl(&dev->op_regs->frindex)); | ||
152 | printk(KERN_DEBUG "ctrldssegment=0x%08x\n", | ||
153 | readl(&dev->op_regs->ctrldssegment)); | ||
154 | printk(KERN_DEBUG "deviceaddr=0x%08x\n", | ||
155 | readl(&dev->op_regs->deviceaddr)); | ||
156 | printk(KERN_DEBUG "endpointlistaddr=0x%08x\n", | ||
157 | readl(&dev->op_regs->endpointlistaddr)); | ||
158 | printk(KERN_DEBUG "ttctrl=0x%08x\n", | ||
159 | readl(&dev->op_regs->ttctrl)); | ||
160 | printk(KERN_DEBUG "burstsize=0x%08x\n", | ||
161 | readl(&dev->op_regs->burstsize)); | ||
162 | printk(KERN_DEBUG "txfilltuning=0x%08x\n", | ||
163 | readl(&dev->op_regs->txfilltuning)); | ||
164 | printk(KERN_DEBUG "txttfilltuning=0x%08x\n", | ||
165 | readl(&dev->op_regs->txttfilltuning)); | ||
166 | printk(KERN_DEBUG "ic_usb=0x%08x\n", | ||
167 | readl(&dev->op_regs->ic_usb)); | ||
168 | printk(KERN_DEBUG "ulpi_viewport=0x%08x\n", | ||
169 | readl(&dev->op_regs->ulpi_viewport)); | ||
170 | printk(KERN_DEBUG "configflag=0x%08x\n", | ||
171 | readl(&dev->op_regs->configflag)); | ||
172 | printk(KERN_DEBUG "portsc1=0x%08x\n", | ||
173 | readl(&dev->op_regs->portsc1)); | ||
174 | printk(KERN_DEBUG "devlc=0x%08x\n", | ||
175 | readl(&dev->op_regs->devlc)); | ||
176 | printk(KERN_DEBUG "otgsc=0x%08x\n", | ||
177 | readl(&dev->op_regs->otgsc)); | ||
178 | printk(KERN_DEBUG "usbmode=0x%08x\n", | ||
179 | readl(&dev->op_regs->usbmode)); | ||
180 | printk(KERN_DEBUG "endptnak=0x%08x\n", | ||
181 | readl(&dev->op_regs->endptnak)); | ||
182 | printk(KERN_DEBUG "endptnaken=0x%08x\n", | ||
183 | readl(&dev->op_regs->endptnaken)); | ||
184 | printk(KERN_DEBUG "endptsetupstat=0x%08x\n", | ||
185 | readl(&dev->op_regs->endptsetupstat)); | ||
186 | printk(KERN_DEBUG "endptprime=0x%08x\n", | ||
187 | readl(&dev->op_regs->endptprime)); | ||
188 | printk(KERN_DEBUG "endptflush=0x%08x\n", | ||
189 | readl(&dev->op_regs->endptflush)); | ||
190 | printk(KERN_DEBUG "endptstat=0x%08x\n", | ||
191 | readl(&dev->op_regs->endptstat)); | ||
192 | printk(KERN_DEBUG "endptcomplete=0x%08x\n", | ||
193 | readl(&dev->op_regs->endptcomplete)); | ||
194 | |||
195 | for (i = 0; i < dev->ep_max / 2; i++) { | ||
196 | printk(KERN_DEBUG "endptctrl[%d]=0x%08x\n", | ||
197 | i, readl(&dev->op_regs->endptctrl[i])); | ||
198 | } | ||
199 | } | ||
200 | #endif /* VERBOSE */ | ||
201 | |||
202 | |||
203 | /*-------------------------------------------------------------------------*/ | ||
204 | |||
205 | #define DIR_STRING(bAddress) (((bAddress) & USB_DIR_IN) ? "in" : "out") | ||
206 | |||
207 | #define is_in(ep) (((ep)->ep_num == 0) ? ((ep)->dev->ep0_dir == \ | ||
208 | USB_DIR_IN) : ((ep)->desc->bEndpointAddress \ | ||
209 | & USB_DIR_IN) == USB_DIR_IN) | ||
210 | |||
211 | |||
212 | #ifdef DEBUG | ||
213 | static char *type_string(u8 bmAttributes) | ||
214 | { | ||
215 | switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) { | ||
216 | case USB_ENDPOINT_XFER_BULK: | ||
217 | return "bulk"; | ||
218 | case USB_ENDPOINT_XFER_ISOC: | ||
219 | return "iso"; | ||
220 | case USB_ENDPOINT_XFER_INT: | ||
221 | return "int"; | ||
222 | }; | ||
223 | |||
224 | return "control"; | ||
225 | } | ||
226 | #endif | ||
227 | |||
228 | |||
229 | /* configure endpoint control registers */ | ||
230 | static void ep_reset(struct langwell_ep *ep, unsigned char ep_num, | ||
231 | unsigned char is_in, unsigned char ep_type) | ||
232 | { | ||
233 | struct langwell_udc *dev; | ||
234 | u32 endptctrl; | ||
235 | |||
236 | dev = ep->dev; | ||
237 | VDBG(dev, "---> %s()\n", __func__); | ||
238 | |||
239 | endptctrl = readl(&dev->op_regs->endptctrl[ep_num]); | ||
240 | if (is_in) { /* TX */ | ||
241 | if (ep_num) | ||
242 | endptctrl |= EPCTRL_TXR; | ||
243 | endptctrl |= EPCTRL_TXE; | ||
244 | endptctrl |= ep_type << EPCTRL_TXT_SHIFT; | ||
245 | } else { /* RX */ | ||
246 | if (ep_num) | ||
247 | endptctrl |= EPCTRL_RXR; | ||
248 | endptctrl |= EPCTRL_RXE; | ||
249 | endptctrl |= ep_type << EPCTRL_RXT_SHIFT; | ||
250 | } | ||
251 | |||
252 | writel(endptctrl, &dev->op_regs->endptctrl[ep_num]); | ||
253 | |||
254 | VDBG(dev, "<--- %s()\n", __func__); | ||
255 | } | ||
256 | |||
257 | |||
258 | /* reset ep0 dQH and endptctrl */ | ||
259 | static void ep0_reset(struct langwell_udc *dev) | ||
260 | { | ||
261 | struct langwell_ep *ep; | ||
262 | int i; | ||
263 | |||
264 | VDBG(dev, "---> %s()\n", __func__); | ||
265 | |||
266 | /* ep0 in and out */ | ||
267 | for (i = 0; i < 2; i++) { | ||
268 | ep = &dev->ep[i]; | ||
269 | ep->dev = dev; | ||
270 | |||
271 | /* ep0 dQH */ | ||
272 | ep->dqh = &dev->ep_dqh[i]; | ||
273 | |||
274 | /* configure ep0 endpoint capabilities in dQH */ | ||
275 | ep->dqh->dqh_ios = 1; | ||
276 | ep->dqh->dqh_mpl = EP0_MAX_PKT_SIZE; | ||
277 | |||
278 | /* FIXME: enable ep0-in HW zero length termination select */ | ||
279 | if (is_in(ep)) | ||
280 | ep->dqh->dqh_zlt = 0; | ||
281 | ep->dqh->dqh_mult = 0; | ||
282 | |||
283 | /* configure ep0 control registers */ | ||
284 | ep_reset(&dev->ep[0], 0, i, USB_ENDPOINT_XFER_CONTROL); | ||
285 | } | ||
286 | |||
287 | VDBG(dev, "<--- %s()\n", __func__); | ||
288 | return; | ||
289 | } | ||
290 | |||
291 | |||
292 | /*-------------------------------------------------------------------------*/ | ||
293 | |||
294 | /* endpoints operations */ | ||
295 | |||
296 | /* configure endpoint, making it usable */ | ||
297 | static int langwell_ep_enable(struct usb_ep *_ep, | ||
298 | const struct usb_endpoint_descriptor *desc) | ||
299 | { | ||
300 | struct langwell_udc *dev; | ||
301 | struct langwell_ep *ep; | ||
302 | u16 max = 0; | ||
303 | unsigned long flags; | ||
304 | int retval = 0; | ||
305 | unsigned char zlt, ios = 0, mult = 0; | ||
306 | |||
307 | ep = container_of(_ep, struct langwell_ep, ep); | ||
308 | dev = ep->dev; | ||
309 | VDBG(dev, "---> %s()\n", __func__); | ||
310 | |||
311 | if (!_ep || !desc || ep->desc | ||
312 | || desc->bDescriptorType != USB_DT_ENDPOINT) | ||
313 | return -EINVAL; | ||
314 | |||
315 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) | ||
316 | return -ESHUTDOWN; | ||
317 | |||
318 | max = le16_to_cpu(desc->wMaxPacketSize); | ||
319 | |||
320 | /* | ||
321 | * disable HW zero length termination select | ||
322 | * driver handles zero length packet through req->req.zero | ||
323 | */ | ||
324 | zlt = 1; | ||
325 | |||
326 | /* | ||
327 | * sanity check type, direction, address, and then | ||
328 | * initialize the endpoint capabilities fields in dQH | ||
329 | */ | ||
330 | switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { | ||
331 | case USB_ENDPOINT_XFER_CONTROL: | ||
332 | ios = 1; | ||
333 | break; | ||
334 | case USB_ENDPOINT_XFER_BULK: | ||
335 | if ((dev->gadget.speed == USB_SPEED_HIGH | ||
336 | && max != 512) | ||
337 | || (dev->gadget.speed == USB_SPEED_FULL | ||
338 | && max > 64)) { | ||
339 | goto done; | ||
340 | } | ||
341 | break; | ||
342 | case USB_ENDPOINT_XFER_INT: | ||
343 | if (strstr(ep->ep.name, "-iso")) /* bulk is ok */ | ||
344 | goto done; | ||
345 | |||
346 | switch (dev->gadget.speed) { | ||
347 | case USB_SPEED_HIGH: | ||
348 | if (max <= 1024) | ||
349 | break; | ||
350 | case USB_SPEED_FULL: | ||
351 | if (max <= 64) | ||
352 | break; | ||
353 | default: | ||
354 | if (max <= 8) | ||
355 | break; | ||
356 | goto done; | ||
357 | } | ||
358 | break; | ||
359 | case USB_ENDPOINT_XFER_ISOC: | ||
360 | if (strstr(ep->ep.name, "-bulk") | ||
361 | || strstr(ep->ep.name, "-int")) | ||
362 | goto done; | ||
363 | |||
364 | switch (dev->gadget.speed) { | ||
365 | case USB_SPEED_HIGH: | ||
366 | if (max <= 1024) | ||
367 | break; | ||
368 | case USB_SPEED_FULL: | ||
369 | if (max <= 1023) | ||
370 | break; | ||
371 | default: | ||
372 | goto done; | ||
373 | } | ||
374 | /* | ||
375 | * FIXME: | ||
376 | * calculate transactions needed for high bandwidth iso | ||
377 | */ | ||
378 | mult = (unsigned char)(1 + ((max >> 11) & 0x03)); | ||
379 | max = max & 0x8ff; /* bit 0~10 */ | ||
380 | /* 3 transactions at most */ | ||
381 | if (mult > 3) | ||
382 | goto done; | ||
383 | break; | ||
384 | default: | ||
385 | goto done; | ||
386 | } | ||
387 | |||
388 | spin_lock_irqsave(&dev->lock, flags); | ||
389 | |||
390 | /* configure endpoint capabilities in dQH */ | ||
391 | ep->dqh->dqh_ios = ios; | ||
392 | ep->dqh->dqh_mpl = cpu_to_le16(max); | ||
393 | ep->dqh->dqh_zlt = zlt; | ||
394 | ep->dqh->dqh_mult = mult; | ||
395 | |||
396 | ep->ep.maxpacket = max; | ||
397 | ep->desc = desc; | ||
398 | ep->stopped = 0; | ||
399 | ep->ep_num = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; | ||
400 | |||
401 | /* ep_type */ | ||
402 | ep->ep_type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; | ||
403 | |||
404 | /* configure endpoint control registers */ | ||
405 | ep_reset(ep, ep->ep_num, is_in(ep), ep->ep_type); | ||
406 | |||
407 | DBG(dev, "enabled %s (ep%d%s-%s), max %04x\n", | ||
408 | _ep->name, | ||
409 | ep->ep_num, | ||
410 | DIR_STRING(desc->bEndpointAddress), | ||
411 | type_string(desc->bmAttributes), | ||
412 | max); | ||
413 | |||
414 | spin_unlock_irqrestore(&dev->lock, flags); | ||
415 | done: | ||
416 | VDBG(dev, "<--- %s()\n", __func__); | ||
417 | return retval; | ||
418 | } | ||
419 | |||
420 | |||
421 | /*-------------------------------------------------------------------------*/ | ||
422 | |||
423 | /* retire a request */ | ||
424 | static void done(struct langwell_ep *ep, struct langwell_request *req, | ||
425 | int status) | ||
426 | { | ||
427 | struct langwell_udc *dev = ep->dev; | ||
428 | unsigned stopped = ep->stopped; | ||
429 | struct langwell_dtd *curr_dtd, *next_dtd; | ||
430 | int i; | ||
431 | |||
432 | VDBG(dev, "---> %s()\n", __func__); | ||
433 | |||
434 | /* remove the req from ep->queue */ | ||
435 | list_del_init(&req->queue); | ||
436 | |||
437 | if (req->req.status == -EINPROGRESS) | ||
438 | req->req.status = status; | ||
439 | else | ||
440 | status = req->req.status; | ||
441 | |||
442 | /* free dTD for the request */ | ||
443 | next_dtd = req->head; | ||
444 | for (i = 0; i < req->dtd_count; i++) { | ||
445 | curr_dtd = next_dtd; | ||
446 | if (i != req->dtd_count - 1) | ||
447 | next_dtd = curr_dtd->next_dtd_virt; | ||
448 | dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma); | ||
449 | } | ||
450 | |||
451 | if (req->mapped) { | ||
452 | dma_unmap_single(&dev->pdev->dev, req->req.dma, req->req.length, | ||
453 | is_in(ep) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE); | ||
454 | req->req.dma = DMA_ADDR_INVALID; | ||
455 | req->mapped = 0; | ||
456 | } else | ||
457 | dma_sync_single_for_cpu(&dev->pdev->dev, req->req.dma, | ||
458 | req->req.length, | ||
459 | is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE); | ||
460 | |||
461 | if (status != -ESHUTDOWN) | ||
462 | DBG(dev, "complete %s, req %p, stat %d, len %u/%u\n", | ||
463 | ep->ep.name, &req->req, status, | ||
464 | req->req.actual, req->req.length); | ||
465 | |||
466 | /* don't modify queue heads during completion callback */ | ||
467 | ep->stopped = 1; | ||
468 | |||
469 | spin_unlock(&dev->lock); | ||
470 | /* complete routine from gadget driver */ | ||
471 | if (req->req.complete) | ||
472 | req->req.complete(&ep->ep, &req->req); | ||
473 | |||
474 | spin_lock(&dev->lock); | ||
475 | ep->stopped = stopped; | ||
476 | |||
477 | VDBG(dev, "<--- %s()\n", __func__); | ||
478 | } | ||
479 | |||
480 | |||
481 | static void langwell_ep_fifo_flush(struct usb_ep *_ep); | ||
482 | |||
483 | /* delete all endpoint requests, called with spinlock held */ | ||
484 | static void nuke(struct langwell_ep *ep, int status) | ||
485 | { | ||
486 | /* called with spinlock held */ | ||
487 | ep->stopped = 1; | ||
488 | |||
489 | /* endpoint fifo flush */ | ||
490 | if (&ep->ep && ep->desc) | ||
491 | langwell_ep_fifo_flush(&ep->ep); | ||
492 | |||
493 | while (!list_empty(&ep->queue)) { | ||
494 | struct langwell_request *req = NULL; | ||
495 | req = list_entry(ep->queue.next, struct langwell_request, | ||
496 | queue); | ||
497 | done(ep, req, status); | ||
498 | } | ||
499 | } | ||
500 | |||
501 | |||
502 | /*-------------------------------------------------------------------------*/ | ||
503 | |||
504 | /* endpoint is no longer usable */ | ||
505 | static int langwell_ep_disable(struct usb_ep *_ep) | ||
506 | { | ||
507 | struct langwell_ep *ep; | ||
508 | unsigned long flags; | ||
509 | struct langwell_udc *dev; | ||
510 | int ep_num; | ||
511 | u32 endptctrl; | ||
512 | |||
513 | ep = container_of(_ep, struct langwell_ep, ep); | ||
514 | dev = ep->dev; | ||
515 | VDBG(dev, "---> %s()\n", __func__); | ||
516 | |||
517 | if (!_ep || !ep->desc) | ||
518 | return -EINVAL; | ||
519 | |||
520 | spin_lock_irqsave(&dev->lock, flags); | ||
521 | |||
522 | /* disable endpoint control register */ | ||
523 | ep_num = ep->ep_num; | ||
524 | endptctrl = readl(&dev->op_regs->endptctrl[ep_num]); | ||
525 | if (is_in(ep)) | ||
526 | endptctrl &= ~EPCTRL_TXE; | ||
527 | else | ||
528 | endptctrl &= ~EPCTRL_RXE; | ||
529 | writel(endptctrl, &dev->op_regs->endptctrl[ep_num]); | ||
530 | |||
531 | /* nuke all pending requests (does flush) */ | ||
532 | nuke(ep, -ESHUTDOWN); | ||
533 | |||
534 | ep->desc = NULL; | ||
535 | ep->stopped = 1; | ||
536 | |||
537 | spin_unlock_irqrestore(&dev->lock, flags); | ||
538 | |||
539 | DBG(dev, "disabled %s\n", _ep->name); | ||
540 | VDBG(dev, "<--- %s()\n", __func__); | ||
541 | |||
542 | return 0; | ||
543 | } | ||
544 | |||
545 | |||
546 | /* allocate a request object to use with this endpoint */ | ||
547 | static struct usb_request *langwell_alloc_request(struct usb_ep *_ep, | ||
548 | gfp_t gfp_flags) | ||
549 | { | ||
550 | struct langwell_ep *ep; | ||
551 | struct langwell_udc *dev; | ||
552 | struct langwell_request *req = NULL; | ||
553 | |||
554 | if (!_ep) | ||
555 | return NULL; | ||
556 | |||
557 | ep = container_of(_ep, struct langwell_ep, ep); | ||
558 | dev = ep->dev; | ||
559 | VDBG(dev, "---> %s()\n", __func__); | ||
560 | |||
561 | req = kzalloc(sizeof(*req), gfp_flags); | ||
562 | if (!req) | ||
563 | return NULL; | ||
564 | |||
565 | req->req.dma = DMA_ADDR_INVALID; | ||
566 | INIT_LIST_HEAD(&req->queue); | ||
567 | |||
568 | VDBG(dev, "alloc request for %s\n", _ep->name); | ||
569 | VDBG(dev, "<--- %s()\n", __func__); | ||
570 | return &req->req; | ||
571 | } | ||
572 | |||
573 | |||
574 | /* free a request object */ | ||
575 | static void langwell_free_request(struct usb_ep *_ep, | ||
576 | struct usb_request *_req) | ||
577 | { | ||
578 | struct langwell_ep *ep; | ||
579 | struct langwell_udc *dev; | ||
580 | struct langwell_request *req = NULL; | ||
581 | |||
582 | ep = container_of(_ep, struct langwell_ep, ep); | ||
583 | dev = ep->dev; | ||
584 | VDBG(dev, "---> %s()\n", __func__); | ||
585 | |||
586 | if (!_ep || !_req) | ||
587 | return; | ||
588 | |||
589 | req = container_of(_req, struct langwell_request, req); | ||
590 | WARN_ON(!list_empty(&req->queue)); | ||
591 | |||
592 | if (_req) | ||
593 | kfree(req); | ||
594 | |||
595 | VDBG(dev, "free request for %s\n", _ep->name); | ||
596 | VDBG(dev, "<--- %s()\n", __func__); | ||
597 | } | ||
598 | |||
599 | |||
600 | /*-------------------------------------------------------------------------*/ | ||
601 | |||
602 | /* queue dTD and PRIME endpoint */ | ||
603 | static int queue_dtd(struct langwell_ep *ep, struct langwell_request *req) | ||
604 | { | ||
605 | u32 bit_mask, usbcmd, endptstat, dtd_dma; | ||
606 | u8 dtd_status; | ||
607 | int i; | ||
608 | struct langwell_dqh *dqh; | ||
609 | struct langwell_udc *dev; | ||
610 | |||
611 | dev = ep->dev; | ||
612 | VDBG(dev, "---> %s()\n", __func__); | ||
613 | |||
614 | i = ep->ep_num * 2 + is_in(ep); | ||
615 | dqh = &dev->ep_dqh[i]; | ||
616 | |||
617 | if (ep->ep_num) | ||
618 | VDBG(dev, "%s\n", ep->name); | ||
619 | else | ||
620 | /* ep0 */ | ||
621 | VDBG(dev, "%s-%s\n", ep->name, is_in(ep) ? "in" : "out"); | ||
622 | |||
623 | VDBG(dev, "ep_dqh[%d] addr: 0x%08x\n", i, (u32)&(dev->ep_dqh[i])); | ||
624 | |||
625 | bit_mask = is_in(ep) ? | ||
626 | (1 << (ep->ep_num + 16)) : (1 << (ep->ep_num)); | ||
627 | |||
628 | VDBG(dev, "bit_mask = 0x%08x\n", bit_mask); | ||
629 | |||
630 | /* check if the pipe is empty */ | ||
631 | if (!(list_empty(&ep->queue))) { | ||
632 | /* add dTD to the end of linked list */ | ||
633 | struct langwell_request *lastreq; | ||
634 | lastreq = list_entry(ep->queue.prev, | ||
635 | struct langwell_request, queue); | ||
636 | |||
637 | lastreq->tail->dtd_next = | ||
638 | cpu_to_le32(req->head->dtd_dma & DTD_NEXT_MASK); | ||
639 | |||
640 | /* read prime bit, if 1 goto out */ | ||
641 | if (readl(&dev->op_regs->endptprime) & bit_mask) | ||
642 | goto out; | ||
643 | |||
644 | do { | ||
645 | /* set ATDTW bit in USBCMD */ | ||
646 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
647 | writel(usbcmd | CMD_ATDTW, &dev->op_regs->usbcmd); | ||
648 | |||
649 | /* read correct status bit */ | ||
650 | endptstat = readl(&dev->op_regs->endptstat) & bit_mask; | ||
651 | |||
652 | } while (!(readl(&dev->op_regs->usbcmd) & CMD_ATDTW)); | ||
653 | |||
654 | /* write ATDTW bit to 0 */ | ||
655 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
656 | writel(usbcmd & ~CMD_ATDTW, &dev->op_regs->usbcmd); | ||
657 | |||
658 | if (endptstat) | ||
659 | goto out; | ||
660 | } | ||
661 | |||
662 | /* write dQH next pointer and terminate bit to 0 */ | ||
663 | dtd_dma = req->head->dtd_dma & DTD_NEXT_MASK; | ||
664 | dqh->dtd_next = cpu_to_le32(dtd_dma); | ||
665 | |||
666 | /* clear active and halt bit */ | ||
667 | dtd_status = (u8) ~(DTD_STS_ACTIVE | DTD_STS_HALTED); | ||
668 | dqh->dtd_status &= dtd_status; | ||
669 | VDBG(dev, "dqh->dtd_status = 0x%x\n", dqh->dtd_status); | ||
670 | |||
671 | /* write 1 to endptprime register to PRIME endpoint */ | ||
672 | bit_mask = is_in(ep) ? (1 << (ep->ep_num + 16)) : (1 << ep->ep_num); | ||
673 | VDBG(dev, "endprime bit_mask = 0x%08x\n", bit_mask); | ||
674 | writel(bit_mask, &dev->op_regs->endptprime); | ||
675 | out: | ||
676 | VDBG(dev, "<--- %s()\n", __func__); | ||
677 | return 0; | ||
678 | } | ||
679 | |||
680 | |||
681 | /* fill in the dTD structure to build a transfer descriptor */ | ||
682 | static struct langwell_dtd *build_dtd(struct langwell_request *req, | ||
683 | unsigned *length, dma_addr_t *dma, int *is_last) | ||
684 | { | ||
685 | u32 buf_ptr; | ||
686 | struct langwell_dtd *dtd; | ||
687 | struct langwell_udc *dev; | ||
688 | int i; | ||
689 | |||
690 | dev = req->ep->dev; | ||
691 | VDBG(dev, "---> %s()\n", __func__); | ||
692 | |||
693 | /* the maximum transfer length, up to 16k bytes */ | ||
694 | *length = min(req->req.length - req->req.actual, | ||
695 | (unsigned)DTD_MAX_TRANSFER_LENGTH); | ||
696 | |||
697 | /* create dTD dma_pool resource */ | ||
698 | dtd = dma_pool_alloc(dev->dtd_pool, GFP_KERNEL, dma); | ||
699 | if (dtd == NULL) | ||
700 | return dtd; | ||
701 | dtd->dtd_dma = *dma; | ||
702 | |||
703 | /* initialize buffer page pointers */ | ||
704 | buf_ptr = (u32)(req->req.dma + req->req.actual); | ||
705 | for (i = 0; i < 5; i++) | ||
706 | dtd->dtd_buf[i] = cpu_to_le32(buf_ptr + i * PAGE_SIZE); | ||
707 | |||
708 | req->req.actual += *length; | ||
709 | |||
710 | /* fill in total bytes with transfer size */ | ||
711 | dtd->dtd_total = cpu_to_le16(*length); | ||
712 | VDBG(dev, "dtd->dtd_total = %d\n", dtd->dtd_total); | ||
713 | |||
714 | /* set is_last flag if req->req.zero is set or not */ | ||
715 | if (req->req.zero) { | ||
716 | if (*length == 0 || (*length % req->ep->ep.maxpacket) != 0) | ||
717 | *is_last = 1; | ||
718 | else | ||
719 | *is_last = 0; | ||
720 | } else if (req->req.length == req->req.actual) { | ||
721 | *is_last = 1; | ||
722 | } else | ||
723 | *is_last = 0; | ||
724 | |||
725 | if (*is_last == 0) | ||
726 | VDBG(dev, "multi-dtd request!\n"); | ||
727 | |||
728 | /* set interrupt on complete bit for the last dTD */ | ||
729 | if (*is_last && !req->req.no_interrupt) | ||
730 | dtd->dtd_ioc = 1; | ||
731 | |||
732 | /* set multiplier override 0 for non-ISO and non-TX endpoint */ | ||
733 | dtd->dtd_multo = 0; | ||
734 | |||
735 | /* set the active bit of status field to 1 */ | ||
736 | dtd->dtd_status = DTD_STS_ACTIVE; | ||
737 | VDBG(dev, "dtd->dtd_status = 0x%02x\n", dtd->dtd_status); | ||
738 | |||
739 | VDBG(dev, "length = %d, dma addr= 0x%08x\n", *length, (int)*dma); | ||
740 | VDBG(dev, "<--- %s()\n", __func__); | ||
741 | return dtd; | ||
742 | } | ||
743 | |||
744 | |||
745 | /* generate dTD linked list for a request */ | ||
746 | static int req_to_dtd(struct langwell_request *req) | ||
747 | { | ||
748 | unsigned count; | ||
749 | int is_last, is_first = 1; | ||
750 | struct langwell_dtd *dtd, *last_dtd = NULL; | ||
751 | struct langwell_udc *dev; | ||
752 | dma_addr_t dma; | ||
753 | |||
754 | dev = req->ep->dev; | ||
755 | VDBG(dev, "---> %s()\n", __func__); | ||
756 | do { | ||
757 | dtd = build_dtd(req, &count, &dma, &is_last); | ||
758 | if (dtd == NULL) | ||
759 | return -ENOMEM; | ||
760 | |||
761 | if (is_first) { | ||
762 | is_first = 0; | ||
763 | req->head = dtd; | ||
764 | } else { | ||
765 | last_dtd->dtd_next = cpu_to_le32(dma); | ||
766 | last_dtd->next_dtd_virt = dtd; | ||
767 | } | ||
768 | last_dtd = dtd; | ||
769 | req->dtd_count++; | ||
770 | } while (!is_last); | ||
771 | |||
772 | /* set terminate bit to 1 for the last dTD */ | ||
773 | dtd->dtd_next = DTD_TERM; | ||
774 | |||
775 | req->tail = dtd; | ||
776 | |||
777 | VDBG(dev, "<--- %s()\n", __func__); | ||
778 | return 0; | ||
779 | } | ||
780 | |||
781 | /*-------------------------------------------------------------------------*/ | ||
782 | |||
783 | /* queue (submits) an I/O requests to an endpoint */ | ||
784 | static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req, | ||
785 | gfp_t gfp_flags) | ||
786 | { | ||
787 | struct langwell_request *req; | ||
788 | struct langwell_ep *ep; | ||
789 | struct langwell_udc *dev; | ||
790 | unsigned long flags; | ||
791 | int is_iso = 0, zlflag = 0; | ||
792 | |||
793 | /* always require a cpu-view buffer */ | ||
794 | req = container_of(_req, struct langwell_request, req); | ||
795 | ep = container_of(_ep, struct langwell_ep, ep); | ||
796 | |||
797 | if (!_req || !_req->complete || !_req->buf | ||
798 | || !list_empty(&req->queue)) { | ||
799 | return -EINVAL; | ||
800 | } | ||
801 | |||
802 | if (unlikely(!_ep || !ep->desc)) | ||
803 | return -EINVAL; | ||
804 | |||
805 | dev = ep->dev; | ||
806 | req->ep = ep; | ||
807 | VDBG(dev, "---> %s()\n", __func__); | ||
808 | |||
809 | if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) { | ||
810 | if (req->req.length > ep->ep.maxpacket) | ||
811 | return -EMSGSIZE; | ||
812 | is_iso = 1; | ||
813 | } | ||
814 | |||
815 | if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) | ||
816 | return -ESHUTDOWN; | ||
817 | |||
818 | /* set up dma mapping in case the caller didn't */ | ||
819 | if (_req->dma == DMA_ADDR_INVALID) { | ||
820 | /* WORKAROUND: WARN_ON(size == 0) */ | ||
821 | if (_req->length == 0) { | ||
822 | VDBG(dev, "req->length: 0->1\n"); | ||
823 | zlflag = 1; | ||
824 | _req->length++; | ||
825 | } | ||
826 | |||
827 | _req->dma = dma_map_single(&dev->pdev->dev, | ||
828 | _req->buf, _req->length, | ||
829 | is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE); | ||
830 | if (zlflag && (_req->length == 1)) { | ||
831 | VDBG(dev, "req->length: 1->0\n"); | ||
832 | zlflag = 0; | ||
833 | _req->length = 0; | ||
834 | } | ||
835 | |||
836 | req->mapped = 1; | ||
837 | VDBG(dev, "req->mapped = 1\n"); | ||
838 | } else { | ||
839 | dma_sync_single_for_device(&dev->pdev->dev, | ||
840 | _req->dma, _req->length, | ||
841 | is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE); | ||
842 | req->mapped = 0; | ||
843 | VDBG(dev, "req->mapped = 0\n"); | ||
844 | } | ||
845 | |||
846 | DBG(dev, "%s queue req %p, len %u, buf %p, dma 0x%08x\n", | ||
847 | _ep->name, | ||
848 | _req, _req->length, _req->buf, _req->dma); | ||
849 | |||
850 | _req->status = -EINPROGRESS; | ||
851 | _req->actual = 0; | ||
852 | req->dtd_count = 0; | ||
853 | |||
854 | spin_lock_irqsave(&dev->lock, flags); | ||
855 | |||
856 | /* build and put dTDs to endpoint queue */ | ||
857 | if (!req_to_dtd(req)) { | ||
858 | queue_dtd(ep, req); | ||
859 | } else { | ||
860 | spin_unlock_irqrestore(&dev->lock, flags); | ||
861 | return -ENOMEM; | ||
862 | } | ||
863 | |||
864 | /* update ep0 state */ | ||
865 | if (ep->ep_num == 0) | ||
866 | dev->ep0_state = DATA_STATE_XMIT; | ||
867 | |||
868 | if (likely(req != NULL)) { | ||
869 | list_add_tail(&req->queue, &ep->queue); | ||
870 | VDBG(dev, "list_add_tail() \n"); | ||
871 | } | ||
872 | |||
873 | spin_unlock_irqrestore(&dev->lock, flags); | ||
874 | |||
875 | VDBG(dev, "<--- %s()\n", __func__); | ||
876 | return 0; | ||
877 | } | ||
878 | |||
879 | |||
880 | /* dequeue (cancels, unlinks) an I/O request from an endpoint */ | ||
881 | static int langwell_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) | ||
882 | { | ||
883 | struct langwell_ep *ep; | ||
884 | struct langwell_udc *dev; | ||
885 | struct langwell_request *req; | ||
886 | unsigned long flags; | ||
887 | int stopped, ep_num, retval = 0; | ||
888 | u32 endptctrl; | ||
889 | |||
890 | ep = container_of(_ep, struct langwell_ep, ep); | ||
891 | dev = ep->dev; | ||
892 | VDBG(dev, "---> %s()\n", __func__); | ||
893 | |||
894 | if (!_ep || !ep->desc || !_req) | ||
895 | return -EINVAL; | ||
896 | |||
897 | if (!dev->driver) | ||
898 | return -ESHUTDOWN; | ||
899 | |||
900 | spin_lock_irqsave(&dev->lock, flags); | ||
901 | stopped = ep->stopped; | ||
902 | |||
903 | /* quiesce dma while we patch the queue */ | ||
904 | ep->stopped = 1; | ||
905 | ep_num = ep->ep_num; | ||
906 | |||
907 | /* disable endpoint control register */ | ||
908 | endptctrl = readl(&dev->op_regs->endptctrl[ep_num]); | ||
909 | if (is_in(ep)) | ||
910 | endptctrl &= ~EPCTRL_TXE; | ||
911 | else | ||
912 | endptctrl &= ~EPCTRL_RXE; | ||
913 | writel(endptctrl, &dev->op_regs->endptctrl[ep_num]); | ||
914 | |||
915 | /* make sure it's still queued on this endpoint */ | ||
916 | list_for_each_entry(req, &ep->queue, queue) { | ||
917 | if (&req->req == _req) | ||
918 | break; | ||
919 | } | ||
920 | |||
921 | if (&req->req != _req) { | ||
922 | retval = -EINVAL; | ||
923 | goto done; | ||
924 | } | ||
925 | |||
926 | /* queue head may be partially complete. */ | ||
927 | if (ep->queue.next == &req->queue) { | ||
928 | DBG(dev, "unlink (%s) dma\n", _ep->name); | ||
929 | _req->status = -ECONNRESET; | ||
930 | langwell_ep_fifo_flush(&ep->ep); | ||
931 | |||
932 | /* not the last request in endpoint queue */ | ||
933 | if (likely(ep->queue.next == &req->queue)) { | ||
934 | struct langwell_dqh *dqh; | ||
935 | struct langwell_request *next_req; | ||
936 | |||
937 | dqh = ep->dqh; | ||
938 | next_req = list_entry(req->queue.next, | ||
939 | struct langwell_request, queue); | ||
940 | |||
941 | /* point the dQH to the first dTD of next request */ | ||
942 | writel((u32) next_req->head, &dqh->dqh_current); | ||
943 | } | ||
944 | } else { | ||
945 | struct langwell_request *prev_req; | ||
946 | |||
947 | prev_req = list_entry(req->queue.prev, | ||
948 | struct langwell_request, queue); | ||
949 | writel(readl(&req->tail->dtd_next), | ||
950 | &prev_req->tail->dtd_next); | ||
951 | } | ||
952 | |||
953 | done(ep, req, -ECONNRESET); | ||
954 | |||
955 | done: | ||
956 | /* enable endpoint again */ | ||
957 | endptctrl = readl(&dev->op_regs->endptctrl[ep_num]); | ||
958 | if (is_in(ep)) | ||
959 | endptctrl |= EPCTRL_TXE; | ||
960 | else | ||
961 | endptctrl |= EPCTRL_RXE; | ||
962 | writel(endptctrl, &dev->op_regs->endptctrl[ep_num]); | ||
963 | |||
964 | ep->stopped = stopped; | ||
965 | spin_unlock_irqrestore(&dev->lock, flags); | ||
966 | |||
967 | VDBG(dev, "<--- %s()\n", __func__); | ||
968 | return retval; | ||
969 | } | ||
970 | |||
971 | |||
972 | /*-------------------------------------------------------------------------*/ | ||
973 | |||
974 | /* endpoint set/clear halt */ | ||
975 | static void ep_set_halt(struct langwell_ep *ep, int value) | ||
976 | { | ||
977 | u32 endptctrl = 0; | ||
978 | int ep_num; | ||
979 | struct langwell_udc *dev = ep->dev; | ||
980 | VDBG(dev, "---> %s()\n", __func__); | ||
981 | |||
982 | ep_num = ep->ep_num; | ||
983 | endptctrl = readl(&dev->op_regs->endptctrl[ep_num]); | ||
984 | |||
985 | /* value: 1 - set halt, 0 - clear halt */ | ||
986 | if (value) { | ||
987 | /* set the stall bit */ | ||
988 | if (is_in(ep)) | ||
989 | endptctrl |= EPCTRL_TXS; | ||
990 | else | ||
991 | endptctrl |= EPCTRL_RXS; | ||
992 | } else { | ||
993 | /* clear the stall bit and reset data toggle */ | ||
994 | if (is_in(ep)) { | ||
995 | endptctrl &= ~EPCTRL_TXS; | ||
996 | endptctrl |= EPCTRL_TXR; | ||
997 | } else { | ||
998 | endptctrl &= ~EPCTRL_RXS; | ||
999 | endptctrl |= EPCTRL_RXR; | ||
1000 | } | ||
1001 | } | ||
1002 | |||
1003 | writel(endptctrl, &dev->op_regs->endptctrl[ep_num]); | ||
1004 | |||
1005 | VDBG(dev, "<--- %s()\n", __func__); | ||
1006 | } | ||
1007 | |||
1008 | |||
1009 | /* set the endpoint halt feature */ | ||
1010 | static int langwell_ep_set_halt(struct usb_ep *_ep, int value) | ||
1011 | { | ||
1012 | struct langwell_ep *ep; | ||
1013 | struct langwell_udc *dev; | ||
1014 | unsigned long flags; | ||
1015 | int retval = 0; | ||
1016 | |||
1017 | ep = container_of(_ep, struct langwell_ep, ep); | ||
1018 | dev = ep->dev; | ||
1019 | |||
1020 | VDBG(dev, "---> %s()\n", __func__); | ||
1021 | |||
1022 | if (!_ep || !ep->desc) | ||
1023 | return -EINVAL; | ||
1024 | |||
1025 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) | ||
1026 | return -ESHUTDOWN; | ||
1027 | |||
1028 | if (ep->desc && (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) | ||
1029 | == USB_ENDPOINT_XFER_ISOC) | ||
1030 | return -EOPNOTSUPP; | ||
1031 | |||
1032 | spin_lock_irqsave(&dev->lock, flags); | ||
1033 | |||
1034 | /* | ||
1035 | * attempt to halt IN ep will fail if any transfer requests | ||
1036 | * are still queue | ||
1037 | */ | ||
1038 | if (!list_empty(&ep->queue) && is_in(ep) && value) { | ||
1039 | /* IN endpoint FIFO holds bytes */ | ||
1040 | DBG(dev, "%s FIFO holds bytes\n", _ep->name); | ||
1041 | retval = -EAGAIN; | ||
1042 | goto done; | ||
1043 | } | ||
1044 | |||
1045 | /* endpoint set/clear halt */ | ||
1046 | if (ep->ep_num) { | ||
1047 | ep_set_halt(ep, value); | ||
1048 | } else { /* endpoint 0 */ | ||
1049 | dev->ep0_state = WAIT_FOR_SETUP; | ||
1050 | dev->ep0_dir = USB_DIR_OUT; | ||
1051 | } | ||
1052 | done: | ||
1053 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1054 | DBG(dev, "%s %s halt\n", _ep->name, value ? "set" : "clear"); | ||
1055 | VDBG(dev, "<--- %s()\n", __func__); | ||
1056 | return retval; | ||
1057 | } | ||
1058 | |||
1059 | |||
1060 | /* set the halt feature and ignores clear requests */ | ||
1061 | static int langwell_ep_set_wedge(struct usb_ep *_ep) | ||
1062 | { | ||
1063 | struct langwell_ep *ep; | ||
1064 | struct langwell_udc *dev; | ||
1065 | |||
1066 | ep = container_of(_ep, struct langwell_ep, ep); | ||
1067 | dev = ep->dev; | ||
1068 | |||
1069 | VDBG(dev, "---> %s()\n", __func__); | ||
1070 | |||
1071 | if (!_ep || !ep->desc) | ||
1072 | return -EINVAL; | ||
1073 | |||
1074 | VDBG(dev, "<--- %s()\n", __func__); | ||
1075 | return usb_ep_set_halt(_ep); | ||
1076 | } | ||
1077 | |||
1078 | |||
1079 | /* flush contents of a fifo */ | ||
1080 | static void langwell_ep_fifo_flush(struct usb_ep *_ep) | ||
1081 | { | ||
1082 | struct langwell_ep *ep; | ||
1083 | struct langwell_udc *dev; | ||
1084 | u32 flush_bit; | ||
1085 | unsigned long timeout; | ||
1086 | |||
1087 | ep = container_of(_ep, struct langwell_ep, ep); | ||
1088 | dev = ep->dev; | ||
1089 | |||
1090 | VDBG(dev, "---> %s()\n", __func__); | ||
1091 | |||
1092 | if (!_ep || !ep->desc) { | ||
1093 | VDBG(dev, "ep or ep->desc is NULL\n"); | ||
1094 | VDBG(dev, "<--- %s()\n", __func__); | ||
1095 | return; | ||
1096 | } | ||
1097 | |||
1098 | VDBG(dev, "%s-%s fifo flush\n", _ep->name, is_in(ep) ? "in" : "out"); | ||
1099 | |||
1100 | /* flush endpoint buffer */ | ||
1101 | if (ep->ep_num == 0) | ||
1102 | flush_bit = (1 << 16) | 1; | ||
1103 | else if (is_in(ep)) | ||
1104 | flush_bit = 1 << (ep->ep_num + 16); /* TX */ | ||
1105 | else | ||
1106 | flush_bit = 1 << ep->ep_num; /* RX */ | ||
1107 | |||
1108 | /* wait until flush complete */ | ||
1109 | timeout = jiffies + FLUSH_TIMEOUT; | ||
1110 | do { | ||
1111 | writel(flush_bit, &dev->op_regs->endptflush); | ||
1112 | while (readl(&dev->op_regs->endptflush)) { | ||
1113 | if (time_after(jiffies, timeout)) { | ||
1114 | ERROR(dev, "ep flush timeout\n"); | ||
1115 | goto done; | ||
1116 | } | ||
1117 | cpu_relax(); | ||
1118 | } | ||
1119 | } while (readl(&dev->op_regs->endptstat) & flush_bit); | ||
1120 | done: | ||
1121 | VDBG(dev, "<--- %s()\n", __func__); | ||
1122 | } | ||
1123 | |||
1124 | |||
1125 | /* endpoints operations structure */ | ||
1126 | static const struct usb_ep_ops langwell_ep_ops = { | ||
1127 | |||
1128 | /* configure endpoint, making it usable */ | ||
1129 | .enable = langwell_ep_enable, | ||
1130 | |||
1131 | /* endpoint is no longer usable */ | ||
1132 | .disable = langwell_ep_disable, | ||
1133 | |||
1134 | /* allocate a request object to use with this endpoint */ | ||
1135 | .alloc_request = langwell_alloc_request, | ||
1136 | |||
1137 | /* free a request object */ | ||
1138 | .free_request = langwell_free_request, | ||
1139 | |||
1140 | /* queue (submits) an I/O requests to an endpoint */ | ||
1141 | .queue = langwell_ep_queue, | ||
1142 | |||
1143 | /* dequeue (cancels, unlinks) an I/O request from an endpoint */ | ||
1144 | .dequeue = langwell_ep_dequeue, | ||
1145 | |||
1146 | /* set the endpoint halt feature */ | ||
1147 | .set_halt = langwell_ep_set_halt, | ||
1148 | |||
1149 | /* set the halt feature and ignores clear requests */ | ||
1150 | .set_wedge = langwell_ep_set_wedge, | ||
1151 | |||
1152 | /* flush contents of a fifo */ | ||
1153 | .fifo_flush = langwell_ep_fifo_flush, | ||
1154 | }; | ||
1155 | |||
1156 | |||
1157 | /*-------------------------------------------------------------------------*/ | ||
1158 | |||
1159 | /* device controller usb_gadget_ops structure */ | ||
1160 | |||
1161 | /* returns the current frame number */ | ||
1162 | static int langwell_get_frame(struct usb_gadget *_gadget) | ||
1163 | { | ||
1164 | struct langwell_udc *dev; | ||
1165 | u16 retval; | ||
1166 | |||
1167 | if (!_gadget) | ||
1168 | return -ENODEV; | ||
1169 | |||
1170 | dev = container_of(_gadget, struct langwell_udc, gadget); | ||
1171 | VDBG(dev, "---> %s()\n", __func__); | ||
1172 | |||
1173 | retval = readl(&dev->op_regs->frindex) & FRINDEX_MASK; | ||
1174 | |||
1175 | VDBG(dev, "<--- %s()\n", __func__); | ||
1176 | return retval; | ||
1177 | } | ||
1178 | |||
1179 | |||
1180 | /* tries to wake up the host connected to this gadget */ | ||
1181 | static int langwell_wakeup(struct usb_gadget *_gadget) | ||
1182 | { | ||
1183 | struct langwell_udc *dev; | ||
1184 | u32 portsc1, devlc; | ||
1185 | unsigned long flags; | ||
1186 | |||
1187 | if (!_gadget) | ||
1188 | return 0; | ||
1189 | |||
1190 | dev = container_of(_gadget, struct langwell_udc, gadget); | ||
1191 | VDBG(dev, "---> %s()\n", __func__); | ||
1192 | |||
1193 | /* Remote Wakeup feature not enabled by host */ | ||
1194 | if (!dev->remote_wakeup) | ||
1195 | return -ENOTSUPP; | ||
1196 | |||
1197 | spin_lock_irqsave(&dev->lock, flags); | ||
1198 | |||
1199 | portsc1 = readl(&dev->op_regs->portsc1); | ||
1200 | if (!(portsc1 & PORTS_SUSP)) { | ||
1201 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1202 | return 0; | ||
1203 | } | ||
1204 | |||
1205 | /* LPM L1 to L0, remote wakeup */ | ||
1206 | if (dev->lpm && dev->lpm_state == LPM_L1) { | ||
1207 | portsc1 |= PORTS_SLP; | ||
1208 | writel(portsc1, &dev->op_regs->portsc1); | ||
1209 | } | ||
1210 | |||
1211 | /* force port resume */ | ||
1212 | if (dev->usb_state == USB_STATE_SUSPENDED) { | ||
1213 | portsc1 |= PORTS_FPR; | ||
1214 | writel(portsc1, &dev->op_regs->portsc1); | ||
1215 | } | ||
1216 | |||
1217 | /* exit PHY low power suspend */ | ||
1218 | devlc = readl(&dev->op_regs->devlc); | ||
1219 | VDBG(dev, "devlc = 0x%08x\n", devlc); | ||
1220 | devlc &= ~LPM_PHCD; | ||
1221 | writel(devlc, &dev->op_regs->devlc); | ||
1222 | |||
1223 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1224 | |||
1225 | VDBG(dev, "<--- %s()\n", __func__); | ||
1226 | return 0; | ||
1227 | } | ||
1228 | |||
1229 | |||
1230 | /* notify controller that VBUS is powered or not */ | ||
1231 | static int langwell_vbus_session(struct usb_gadget *_gadget, int is_active) | ||
1232 | { | ||
1233 | struct langwell_udc *dev; | ||
1234 | unsigned long flags; | ||
1235 | u32 usbcmd; | ||
1236 | |||
1237 | if (!_gadget) | ||
1238 | return -ENODEV; | ||
1239 | |||
1240 | dev = container_of(_gadget, struct langwell_udc, gadget); | ||
1241 | VDBG(dev, "---> %s()\n", __func__); | ||
1242 | |||
1243 | spin_lock_irqsave(&dev->lock, flags); | ||
1244 | VDBG(dev, "VBUS status: %s\n", is_active ? "on" : "off"); | ||
1245 | |||
1246 | dev->vbus_active = (is_active != 0); | ||
1247 | if (dev->driver && dev->softconnected && dev->vbus_active) { | ||
1248 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1249 | usbcmd |= CMD_RUNSTOP; | ||
1250 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1251 | } else { | ||
1252 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1253 | usbcmd &= ~CMD_RUNSTOP; | ||
1254 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1255 | } | ||
1256 | |||
1257 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1258 | |||
1259 | VDBG(dev, "<--- %s()\n", __func__); | ||
1260 | return 0; | ||
1261 | } | ||
1262 | |||
1263 | |||
1264 | /* constrain controller's VBUS power usage */ | ||
1265 | static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA) | ||
1266 | { | ||
1267 | struct langwell_udc *dev; | ||
1268 | |||
1269 | if (!_gadget) | ||
1270 | return -ENODEV; | ||
1271 | |||
1272 | dev = container_of(_gadget, struct langwell_udc, gadget); | ||
1273 | VDBG(dev, "---> %s()\n", __func__); | ||
1274 | |||
1275 | if (dev->transceiver) { | ||
1276 | VDBG(dev, "otg_set_power\n"); | ||
1277 | VDBG(dev, "<--- %s()\n", __func__); | ||
1278 | return otg_set_power(dev->transceiver, mA); | ||
1279 | } | ||
1280 | |||
1281 | VDBG(dev, "<--- %s()\n", __func__); | ||
1282 | return -ENOTSUPP; | ||
1283 | } | ||
1284 | |||
1285 | |||
1286 | /* D+ pullup, software-controlled connect/disconnect to USB host */ | ||
1287 | static int langwell_pullup(struct usb_gadget *_gadget, int is_on) | ||
1288 | { | ||
1289 | struct langwell_udc *dev; | ||
1290 | u32 usbcmd; | ||
1291 | unsigned long flags; | ||
1292 | |||
1293 | if (!_gadget) | ||
1294 | return -ENODEV; | ||
1295 | |||
1296 | dev = container_of(_gadget, struct langwell_udc, gadget); | ||
1297 | |||
1298 | VDBG(dev, "---> %s()\n", __func__); | ||
1299 | |||
1300 | spin_lock_irqsave(&dev->lock, flags); | ||
1301 | dev->softconnected = (is_on != 0); | ||
1302 | |||
1303 | if (dev->driver && dev->softconnected && dev->vbus_active) { | ||
1304 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1305 | usbcmd |= CMD_RUNSTOP; | ||
1306 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1307 | } else { | ||
1308 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1309 | usbcmd &= ~CMD_RUNSTOP; | ||
1310 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1311 | } | ||
1312 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1313 | |||
1314 | VDBG(dev, "<--- %s()\n", __func__); | ||
1315 | return 0; | ||
1316 | } | ||
1317 | |||
1318 | |||
1319 | /* device controller usb_gadget_ops structure */ | ||
1320 | static const struct usb_gadget_ops langwell_ops = { | ||
1321 | |||
1322 | /* returns the current frame number */ | ||
1323 | .get_frame = langwell_get_frame, | ||
1324 | |||
1325 | /* tries to wake up the host connected to this gadget */ | ||
1326 | .wakeup = langwell_wakeup, | ||
1327 | |||
1328 | /* set the device selfpowered feature, always selfpowered */ | ||
1329 | /* .set_selfpowered = langwell_set_selfpowered, */ | ||
1330 | |||
1331 | /* notify controller that VBUS is powered or not */ | ||
1332 | .vbus_session = langwell_vbus_session, | ||
1333 | |||
1334 | /* constrain controller's VBUS power usage */ | ||
1335 | .vbus_draw = langwell_vbus_draw, | ||
1336 | |||
1337 | /* D+ pullup, software-controlled connect/disconnect to USB host */ | ||
1338 | .pullup = langwell_pullup, | ||
1339 | }; | ||
1340 | |||
1341 | |||
1342 | /*-------------------------------------------------------------------------*/ | ||
1343 | |||
1344 | /* device controller operations */ | ||
1345 | |||
1346 | /* reset device controller */ | ||
1347 | static int langwell_udc_reset(struct langwell_udc *dev) | ||
1348 | { | ||
1349 | u32 usbcmd, usbmode, devlc, endpointlistaddr; | ||
1350 | unsigned long timeout; | ||
1351 | |||
1352 | if (!dev) | ||
1353 | return -EINVAL; | ||
1354 | |||
1355 | DBG(dev, "---> %s()\n", __func__); | ||
1356 | |||
1357 | /* set controller to stop state */ | ||
1358 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1359 | usbcmd &= ~CMD_RUNSTOP; | ||
1360 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1361 | |||
1362 | /* reset device controller */ | ||
1363 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1364 | usbcmd |= CMD_RST; | ||
1365 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1366 | |||
1367 | /* wait for reset to complete */ | ||
1368 | timeout = jiffies + RESET_TIMEOUT; | ||
1369 | while (readl(&dev->op_regs->usbcmd) & CMD_RST) { | ||
1370 | if (time_after(jiffies, timeout)) { | ||
1371 | ERROR(dev, "device reset timeout\n"); | ||
1372 | return -ETIMEDOUT; | ||
1373 | } | ||
1374 | cpu_relax(); | ||
1375 | } | ||
1376 | |||
1377 | /* set controller to device mode */ | ||
1378 | usbmode = readl(&dev->op_regs->usbmode); | ||
1379 | usbmode |= MODE_DEVICE; | ||
1380 | |||
1381 | /* turn setup lockout off, require setup tripwire in usbcmd */ | ||
1382 | usbmode |= MODE_SLOM; | ||
1383 | |||
1384 | writel(usbmode, &dev->op_regs->usbmode); | ||
1385 | usbmode = readl(&dev->op_regs->usbmode); | ||
1386 | VDBG(dev, "usbmode=0x%08x\n", usbmode); | ||
1387 | |||
1388 | /* Write-Clear setup status */ | ||
1389 | writel(0, &dev->op_regs->usbsts); | ||
1390 | |||
1391 | /* if support USB LPM, ACK all LPM token */ | ||
1392 | if (dev->lpm) { | ||
1393 | devlc = readl(&dev->op_regs->devlc); | ||
1394 | devlc &= ~LPM_STL; /* don't STALL LPM token */ | ||
1395 | devlc &= ~LPM_NYT_ACK; /* ACK LPM token */ | ||
1396 | writel(devlc, &dev->op_regs->devlc); | ||
1397 | } | ||
1398 | |||
1399 | /* fill endpointlistaddr register */ | ||
1400 | endpointlistaddr = dev->ep_dqh_dma; | ||
1401 | endpointlistaddr &= ENDPOINTLISTADDR_MASK; | ||
1402 | writel(endpointlistaddr, &dev->op_regs->endpointlistaddr); | ||
1403 | |||
1404 | VDBG(dev, "dQH base (vir: %p, phy: 0x%08x), endpointlistaddr=0x%08x\n", | ||
1405 | dev->ep_dqh, endpointlistaddr, | ||
1406 | readl(&dev->op_regs->endpointlistaddr)); | ||
1407 | DBG(dev, "<--- %s()\n", __func__); | ||
1408 | return 0; | ||
1409 | } | ||
1410 | |||
1411 | |||
1412 | /* reinitialize device controller endpoints */ | ||
1413 | static int eps_reinit(struct langwell_udc *dev) | ||
1414 | { | ||
1415 | struct langwell_ep *ep; | ||
1416 | char name[14]; | ||
1417 | int i; | ||
1418 | |||
1419 | VDBG(dev, "---> %s()\n", __func__); | ||
1420 | |||
1421 | /* initialize ep0 */ | ||
1422 | ep = &dev->ep[0]; | ||
1423 | ep->dev = dev; | ||
1424 | strncpy(ep->name, "ep0", sizeof(ep->name)); | ||
1425 | ep->ep.name = ep->name; | ||
1426 | ep->ep.ops = &langwell_ep_ops; | ||
1427 | ep->stopped = 0; | ||
1428 | ep->ep.maxpacket = EP0_MAX_PKT_SIZE; | ||
1429 | ep->ep_num = 0; | ||
1430 | ep->desc = &langwell_ep0_desc; | ||
1431 | INIT_LIST_HEAD(&ep->queue); | ||
1432 | |||
1433 | ep->ep_type = USB_ENDPOINT_XFER_CONTROL; | ||
1434 | |||
1435 | /* initialize other endpoints */ | ||
1436 | for (i = 2; i < dev->ep_max; i++) { | ||
1437 | ep = &dev->ep[i]; | ||
1438 | if (i % 2) | ||
1439 | snprintf(name, sizeof(name), "ep%din", i / 2); | ||
1440 | else | ||
1441 | snprintf(name, sizeof(name), "ep%dout", i / 2); | ||
1442 | ep->dev = dev; | ||
1443 | strncpy(ep->name, name, sizeof(ep->name)); | ||
1444 | ep->ep.name = ep->name; | ||
1445 | |||
1446 | ep->ep.ops = &langwell_ep_ops; | ||
1447 | ep->stopped = 0; | ||
1448 | ep->ep.maxpacket = (unsigned short) ~0; | ||
1449 | ep->ep_num = i / 2; | ||
1450 | |||
1451 | INIT_LIST_HEAD(&ep->queue); | ||
1452 | list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list); | ||
1453 | |||
1454 | ep->dqh = &dev->ep_dqh[i]; | ||
1455 | } | ||
1456 | |||
1457 | VDBG(dev, "<--- %s()\n", __func__); | ||
1458 | return 0; | ||
1459 | } | ||
1460 | |||
1461 | |||
1462 | /* enable interrupt and set controller to run state */ | ||
1463 | static void langwell_udc_start(struct langwell_udc *dev) | ||
1464 | { | ||
1465 | u32 usbintr, usbcmd; | ||
1466 | DBG(dev, "---> %s()\n", __func__); | ||
1467 | |||
1468 | /* enable interrupts */ | ||
1469 | usbintr = INTR_ULPIE /* ULPI */ | ||
1470 | | INTR_SLE /* suspend */ | ||
1471 | /* | INTR_SRE SOF received */ | ||
1472 | | INTR_URE /* USB reset */ | ||
1473 | | INTR_AAE /* async advance */ | ||
1474 | | INTR_SEE /* system error */ | ||
1475 | | INTR_FRE /* frame list rollover */ | ||
1476 | | INTR_PCE /* port change detect */ | ||
1477 | | INTR_UEE /* USB error interrupt */ | ||
1478 | | INTR_UE; /* USB interrupt */ | ||
1479 | writel(usbintr, &dev->op_regs->usbintr); | ||
1480 | |||
1481 | /* clear stopped bit */ | ||
1482 | dev->stopped = 0; | ||
1483 | |||
1484 | /* set controller to run */ | ||
1485 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1486 | usbcmd |= CMD_RUNSTOP; | ||
1487 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1488 | |||
1489 | DBG(dev, "<--- %s()\n", __func__); | ||
1490 | return; | ||
1491 | } | ||
1492 | |||
1493 | |||
1494 | /* disable interrupt and set controller to stop state */ | ||
1495 | static void langwell_udc_stop(struct langwell_udc *dev) | ||
1496 | { | ||
1497 | u32 usbcmd; | ||
1498 | |||
1499 | DBG(dev, "---> %s()\n", __func__); | ||
1500 | |||
1501 | /* disable all interrupts */ | ||
1502 | writel(0, &dev->op_regs->usbintr); | ||
1503 | |||
1504 | /* set stopped bit */ | ||
1505 | dev->stopped = 1; | ||
1506 | |||
1507 | /* set controller to stop state */ | ||
1508 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1509 | usbcmd &= ~CMD_RUNSTOP; | ||
1510 | writel(usbcmd, &dev->op_regs->usbcmd); | ||
1511 | |||
1512 | DBG(dev, "<--- %s()\n", __func__); | ||
1513 | return; | ||
1514 | } | ||
1515 | |||
1516 | |||
1517 | /* stop all USB activities */ | ||
1518 | static void stop_activity(struct langwell_udc *dev, | ||
1519 | struct usb_gadget_driver *driver) | ||
1520 | { | ||
1521 | struct langwell_ep *ep; | ||
1522 | DBG(dev, "---> %s()\n", __func__); | ||
1523 | |||
1524 | nuke(&dev->ep[0], -ESHUTDOWN); | ||
1525 | |||
1526 | list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { | ||
1527 | nuke(ep, -ESHUTDOWN); | ||
1528 | } | ||
1529 | |||
1530 | /* report disconnect; the driver is already quiesced */ | ||
1531 | if (driver) { | ||
1532 | spin_unlock(&dev->lock); | ||
1533 | driver->disconnect(&dev->gadget); | ||
1534 | spin_lock(&dev->lock); | ||
1535 | } | ||
1536 | |||
1537 | DBG(dev, "<--- %s()\n", __func__); | ||
1538 | } | ||
1539 | |||
1540 | |||
1541 | /*-------------------------------------------------------------------------*/ | ||
1542 | |||
1543 | /* device "function" sysfs attribute file */ | ||
1544 | static ssize_t show_function(struct device *_dev, | ||
1545 | struct device_attribute *attr, char *buf) | ||
1546 | { | ||
1547 | struct langwell_udc *dev = the_controller; | ||
1548 | |||
1549 | if (!dev->driver || !dev->driver->function | ||
1550 | || strlen(dev->driver->function) > PAGE_SIZE) | ||
1551 | return 0; | ||
1552 | |||
1553 | return scnprintf(buf, PAGE_SIZE, "%s\n", dev->driver->function); | ||
1554 | } | ||
1555 | static DEVICE_ATTR(function, S_IRUGO, show_function, NULL); | ||
1556 | |||
1557 | |||
1558 | /* device "langwell_udc" sysfs attribute file */ | ||
1559 | static ssize_t show_langwell_udc(struct device *_dev, | ||
1560 | struct device_attribute *attr, char *buf) | ||
1561 | { | ||
1562 | struct langwell_udc *dev = the_controller; | ||
1563 | struct langwell_request *req; | ||
1564 | struct langwell_ep *ep = NULL; | ||
1565 | char *next; | ||
1566 | unsigned size; | ||
1567 | unsigned t; | ||
1568 | unsigned i; | ||
1569 | unsigned long flags; | ||
1570 | u32 tmp_reg; | ||
1571 | |||
1572 | next = buf; | ||
1573 | size = PAGE_SIZE; | ||
1574 | spin_lock_irqsave(&dev->lock, flags); | ||
1575 | |||
1576 | /* driver basic information */ | ||
1577 | t = scnprintf(next, size, | ||
1578 | DRIVER_DESC "\n" | ||
1579 | "%s version: %s\n" | ||
1580 | "Gadget driver: %s\n\n", | ||
1581 | driver_name, DRIVER_VERSION, | ||
1582 | dev->driver ? dev->driver->driver.name : "(none)"); | ||
1583 | size -= t; | ||
1584 | next += t; | ||
1585 | |||
1586 | /* device registers */ | ||
1587 | tmp_reg = readl(&dev->op_regs->usbcmd); | ||
1588 | t = scnprintf(next, size, | ||
1589 | "USBCMD reg:\n" | ||
1590 | "SetupTW: %d\n" | ||
1591 | "Run/Stop: %s\n\n", | ||
1592 | (tmp_reg & CMD_SUTW) ? 1 : 0, | ||
1593 | (tmp_reg & CMD_RUNSTOP) ? "Run" : "Stop"); | ||
1594 | size -= t; | ||
1595 | next += t; | ||
1596 | |||
1597 | tmp_reg = readl(&dev->op_regs->usbsts); | ||
1598 | t = scnprintf(next, size, | ||
1599 | "USB Status Reg:\n" | ||
1600 | "Device Suspend: %d\n" | ||
1601 | "Reset Received: %d\n" | ||
1602 | "System Error: %s\n" | ||
1603 | "USB Error Interrupt: %s\n\n", | ||
1604 | (tmp_reg & STS_SLI) ? 1 : 0, | ||
1605 | (tmp_reg & STS_URI) ? 1 : 0, | ||
1606 | (tmp_reg & STS_SEI) ? "Error" : "No error", | ||
1607 | (tmp_reg & STS_UEI) ? "Error detected" : "No error"); | ||
1608 | size -= t; | ||
1609 | next += t; | ||
1610 | |||
1611 | tmp_reg = readl(&dev->op_regs->usbintr); | ||
1612 | t = scnprintf(next, size, | ||
1613 | "USB Intrrupt Enable Reg:\n" | ||
1614 | "Sleep Enable: %d\n" | ||
1615 | "SOF Received Enable: %d\n" | ||
1616 | "Reset Enable: %d\n" | ||
1617 | "System Error Enable: %d\n" | ||
1618 | "Port Change Dectected Enable: %d\n" | ||
1619 | "USB Error Intr Enable: %d\n" | ||
1620 | "USB Intr Enable: %d\n\n", | ||
1621 | (tmp_reg & INTR_SLE) ? 1 : 0, | ||
1622 | (tmp_reg & INTR_SRE) ? 1 : 0, | ||
1623 | (tmp_reg & INTR_URE) ? 1 : 0, | ||
1624 | (tmp_reg & INTR_SEE) ? 1 : 0, | ||
1625 | (tmp_reg & INTR_PCE) ? 1 : 0, | ||
1626 | (tmp_reg & INTR_UEE) ? 1 : 0, | ||
1627 | (tmp_reg & INTR_UE) ? 1 : 0); | ||
1628 | size -= t; | ||
1629 | next += t; | ||
1630 | |||
1631 | tmp_reg = readl(&dev->op_regs->frindex); | ||
1632 | t = scnprintf(next, size, | ||
1633 | "USB Frame Index Reg:\n" | ||
1634 | "Frame Number is 0x%08x\n\n", | ||
1635 | (tmp_reg & FRINDEX_MASK)); | ||
1636 | size -= t; | ||
1637 | next += t; | ||
1638 | |||
1639 | tmp_reg = readl(&dev->op_regs->deviceaddr); | ||
1640 | t = scnprintf(next, size, | ||
1641 | "USB Device Address Reg:\n" | ||
1642 | "Device Addr is 0x%x\n\n", | ||
1643 | USBADR(tmp_reg)); | ||
1644 | size -= t; | ||
1645 | next += t; | ||
1646 | |||
1647 | tmp_reg = readl(&dev->op_regs->endpointlistaddr); | ||
1648 | t = scnprintf(next, size, | ||
1649 | "USB Endpoint List Address Reg:\n" | ||
1650 | "Endpoint List Pointer is 0x%x\n\n", | ||
1651 | EPBASE(tmp_reg)); | ||
1652 | size -= t; | ||
1653 | next += t; | ||
1654 | |||
1655 | tmp_reg = readl(&dev->op_regs->portsc1); | ||
1656 | t = scnprintf(next, size, | ||
1657 | "USB Port Status & Control Reg:\n" | ||
1658 | "Port Reset: %s\n" | ||
1659 | "Port Suspend Mode: %s\n" | ||
1660 | "Over-current Change: %s\n" | ||
1661 | "Port Enable/Disable Change: %s\n" | ||
1662 | "Port Enabled/Disabled: %s\n" | ||
1663 | "Current Connect Status: %s\n\n", | ||
1664 | (tmp_reg & PORTS_PR) ? "Reset" : "Not Reset", | ||
1665 | (tmp_reg & PORTS_SUSP) ? "Suspend " : "Not Suspend", | ||
1666 | (tmp_reg & PORTS_OCC) ? "Detected" : "No", | ||
1667 | (tmp_reg & PORTS_PEC) ? "Changed" : "Not Changed", | ||
1668 | (tmp_reg & PORTS_PE) ? "Enable" : "Not Correct", | ||
1669 | (tmp_reg & PORTS_CCS) ? "Attached" : "Not Attached"); | ||
1670 | size -= t; | ||
1671 | next += t; | ||
1672 | |||
1673 | tmp_reg = readl(&dev->op_regs->devlc); | ||
1674 | t = scnprintf(next, size, | ||
1675 | "Device LPM Control Reg:\n" | ||
1676 | "Parallel Transceiver : %d\n" | ||
1677 | "Serial Transceiver : %d\n" | ||
1678 | "Port Speed: %s\n" | ||
1679 | "Port Force Full Speed Connenct: %s\n" | ||
1680 | "PHY Low Power Suspend Clock Disable: %s\n" | ||
1681 | "BmAttributes: %d\n\n", | ||
1682 | LPM_PTS(tmp_reg), | ||
1683 | (tmp_reg & LPM_STS) ? 1 : 0, | ||
1684 | ({ | ||
1685 | char *s; | ||
1686 | switch (LPM_PSPD(tmp_reg)) { | ||
1687 | case LPM_SPEED_FULL: | ||
1688 | s = "Full Speed"; break; | ||
1689 | case LPM_SPEED_LOW: | ||
1690 | s = "Low Speed"; break; | ||
1691 | case LPM_SPEED_HIGH: | ||
1692 | s = "High Speed"; break; | ||
1693 | default: | ||
1694 | s = "Unknown Speed"; break; | ||
1695 | } | ||
1696 | s; | ||
1697 | }), | ||
1698 | (tmp_reg & LPM_PFSC) ? "Force Full Speed" : "Not Force", | ||
1699 | (tmp_reg & LPM_PHCD) ? "Disabled" : "Enabled", | ||
1700 | LPM_BA(tmp_reg)); | ||
1701 | size -= t; | ||
1702 | next += t; | ||
1703 | |||
1704 | tmp_reg = readl(&dev->op_regs->usbmode); | ||
1705 | t = scnprintf(next, size, | ||
1706 | "USB Mode Reg:\n" | ||
1707 | "Controller Mode is : %s\n\n", ({ | ||
1708 | char *s; | ||
1709 | switch (MODE_CM(tmp_reg)) { | ||
1710 | case MODE_IDLE: | ||
1711 | s = "Idle"; break; | ||
1712 | case MODE_DEVICE: | ||
1713 | s = "Device Controller"; break; | ||
1714 | case MODE_HOST: | ||
1715 | s = "Host Controller"; break; | ||
1716 | default: | ||
1717 | s = "None"; break; | ||
1718 | } | ||
1719 | s; | ||
1720 | })); | ||
1721 | size -= t; | ||
1722 | next += t; | ||
1723 | |||
1724 | tmp_reg = readl(&dev->op_regs->endptsetupstat); | ||
1725 | t = scnprintf(next, size, | ||
1726 | "Endpoint Setup Status Reg:\n" | ||
1727 | "SETUP on ep 0x%04x\n\n", | ||
1728 | tmp_reg & SETUPSTAT_MASK); | ||
1729 | size -= t; | ||
1730 | next += t; | ||
1731 | |||
1732 | for (i = 0; i < dev->ep_max / 2; i++) { | ||
1733 | tmp_reg = readl(&dev->op_regs->endptctrl[i]); | ||
1734 | t = scnprintf(next, size, "EP Ctrl Reg [%d]: 0x%08x\n", | ||
1735 | i, tmp_reg); | ||
1736 | size -= t; | ||
1737 | next += t; | ||
1738 | } | ||
1739 | tmp_reg = readl(&dev->op_regs->endptprime); | ||
1740 | t = scnprintf(next, size, "EP Prime Reg: 0x%08x\n\n", tmp_reg); | ||
1741 | size -= t; | ||
1742 | next += t; | ||
1743 | |||
1744 | /* langwell_udc, langwell_ep, langwell_request structure information */ | ||
1745 | ep = &dev->ep[0]; | ||
1746 | t = scnprintf(next, size, "%s MaxPacketSize: 0x%x, ep_num: %d\n", | ||
1747 | ep->ep.name, ep->ep.maxpacket, ep->ep_num); | ||
1748 | size -= t; | ||
1749 | next += t; | ||
1750 | |||
1751 | if (list_empty(&ep->queue)) { | ||
1752 | t = scnprintf(next, size, "its req queue is empty\n\n"); | ||
1753 | size -= t; | ||
1754 | next += t; | ||
1755 | } else { | ||
1756 | list_for_each_entry(req, &ep->queue, queue) { | ||
1757 | t = scnprintf(next, size, | ||
1758 | "req %p actual 0x%x length 0x%x buf %p\n", | ||
1759 | &req->req, req->req.actual, | ||
1760 | req->req.length, req->req.buf); | ||
1761 | size -= t; | ||
1762 | next += t; | ||
1763 | } | ||
1764 | } | ||
1765 | /* other gadget->eplist ep */ | ||
1766 | list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { | ||
1767 | if (ep->desc) { | ||
1768 | t = scnprintf(next, size, | ||
1769 | "\n%s MaxPacketSize: 0x%x, " | ||
1770 | "ep_num: %d\n", | ||
1771 | ep->ep.name, ep->ep.maxpacket, | ||
1772 | ep->ep_num); | ||
1773 | size -= t; | ||
1774 | next += t; | ||
1775 | |||
1776 | if (list_empty(&ep->queue)) { | ||
1777 | t = scnprintf(next, size, | ||
1778 | "its req queue is empty\n\n"); | ||
1779 | size -= t; | ||
1780 | next += t; | ||
1781 | } else { | ||
1782 | list_for_each_entry(req, &ep->queue, queue) { | ||
1783 | t = scnprintf(next, size, | ||
1784 | "req %p actual 0x%x length " | ||
1785 | "0x%x buf %p\n", | ||
1786 | &req->req, req->req.actual, | ||
1787 | req->req.length, req->req.buf); | ||
1788 | size -= t; | ||
1789 | next += t; | ||
1790 | } | ||
1791 | } | ||
1792 | } | ||
1793 | } | ||
1794 | |||
1795 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1796 | return PAGE_SIZE - size; | ||
1797 | } | ||
1798 | static DEVICE_ATTR(langwell_udc, S_IRUGO, show_langwell_udc, NULL); | ||
1799 | |||
1800 | |||
1801 | /*-------------------------------------------------------------------------*/ | ||
1802 | |||
1803 | /* | ||
1804 | * when a driver is successfully registered, it will receive | ||
1805 | * control requests including set_configuration(), which enables | ||
1806 | * non-control requests. then usb traffic follows until a | ||
1807 | * disconnect is reported. then a host may connect again, or | ||
1808 | * the driver might get unbound. | ||
1809 | */ | ||
1810 | |||
1811 | int usb_gadget_register_driver(struct usb_gadget_driver *driver) | ||
1812 | { | ||
1813 | struct langwell_udc *dev = the_controller; | ||
1814 | unsigned long flags; | ||
1815 | int retval; | ||
1816 | |||
1817 | if (!dev) | ||
1818 | return -ENODEV; | ||
1819 | |||
1820 | DBG(dev, "---> %s()\n", __func__); | ||
1821 | |||
1822 | if (dev->driver) | ||
1823 | return -EBUSY; | ||
1824 | |||
1825 | spin_lock_irqsave(&dev->lock, flags); | ||
1826 | |||
1827 | /* hook up the driver ... */ | ||
1828 | driver->driver.bus = NULL; | ||
1829 | dev->driver = driver; | ||
1830 | dev->gadget.dev.driver = &driver->driver; | ||
1831 | |||
1832 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1833 | |||
1834 | retval = driver->bind(&dev->gadget); | ||
1835 | if (retval) { | ||
1836 | DBG(dev, "bind to driver %s --> %d\n", | ||
1837 | driver->driver.name, retval); | ||
1838 | dev->driver = NULL; | ||
1839 | dev->gadget.dev.driver = NULL; | ||
1840 | return retval; | ||
1841 | } | ||
1842 | |||
1843 | retval = device_create_file(&dev->pdev->dev, &dev_attr_function); | ||
1844 | if (retval) | ||
1845 | goto err_unbind; | ||
1846 | |||
1847 | dev->usb_state = USB_STATE_ATTACHED; | ||
1848 | dev->ep0_state = WAIT_FOR_SETUP; | ||
1849 | dev->ep0_dir = USB_DIR_OUT; | ||
1850 | |||
1851 | /* enable interrupt and set controller to run state */ | ||
1852 | if (dev->got_irq) | ||
1853 | langwell_udc_start(dev); | ||
1854 | |||
1855 | VDBG(dev, "After langwell_udc_start(), print all registers:\n"); | ||
1856 | #ifdef VERBOSE | ||
1857 | print_all_registers(dev); | ||
1858 | #endif | ||
1859 | |||
1860 | INFO(dev, "register driver: %s\n", driver->driver.name); | ||
1861 | VDBG(dev, "<--- %s()\n", __func__); | ||
1862 | return 0; | ||
1863 | |||
1864 | err_unbind: | ||
1865 | driver->unbind(&dev->gadget); | ||
1866 | dev->gadget.dev.driver = NULL; | ||
1867 | dev->driver = NULL; | ||
1868 | |||
1869 | DBG(dev, "<--- %s()\n", __func__); | ||
1870 | return retval; | ||
1871 | } | ||
1872 | EXPORT_SYMBOL(usb_gadget_register_driver); | ||
1873 | |||
1874 | |||
1875 | /* unregister gadget driver */ | ||
1876 | int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) | ||
1877 | { | ||
1878 | struct langwell_udc *dev = the_controller; | ||
1879 | unsigned long flags; | ||
1880 | |||
1881 | if (!dev) | ||
1882 | return -ENODEV; | ||
1883 | |||
1884 | DBG(dev, "---> %s()\n", __func__); | ||
1885 | |||
1886 | if (unlikely(!driver || !driver->bind || !driver->unbind)) | ||
1887 | return -EINVAL; | ||
1888 | |||
1889 | /* unbind OTG transceiver */ | ||
1890 | if (dev->transceiver) | ||
1891 | (void)otg_set_peripheral(dev->transceiver, 0); | ||
1892 | |||
1893 | /* disable interrupt and set controller to stop state */ | ||
1894 | langwell_udc_stop(dev); | ||
1895 | |||
1896 | dev->usb_state = USB_STATE_ATTACHED; | ||
1897 | dev->ep0_state = WAIT_FOR_SETUP; | ||
1898 | dev->ep0_dir = USB_DIR_OUT; | ||
1899 | |||
1900 | spin_lock_irqsave(&dev->lock, flags); | ||
1901 | |||
1902 | /* stop all usb activities */ | ||
1903 | dev->gadget.speed = USB_SPEED_UNKNOWN; | ||
1904 | stop_activity(dev, driver); | ||
1905 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1906 | |||
1907 | /* unbind gadget driver */ | ||
1908 | driver->unbind(&dev->gadget); | ||
1909 | dev->gadget.dev.driver = NULL; | ||
1910 | dev->driver = NULL; | ||
1911 | |||
1912 | device_remove_file(&dev->pdev->dev, &dev_attr_function); | ||
1913 | |||
1914 | INFO(dev, "unregistered driver '%s'\n", driver->driver.name); | ||
1915 | DBG(dev, "<--- %s()\n", __func__); | ||
1916 | return 0; | ||
1917 | } | ||
1918 | EXPORT_SYMBOL(usb_gadget_unregister_driver); | ||
1919 | |||
1920 | |||
1921 | /*-------------------------------------------------------------------------*/ | ||
1922 | |||
1923 | /* | ||
1924 | * setup tripwire is used as a semaphore to ensure that the setup data | ||
1925 | * payload is extracted from a dQH without being corrupted | ||
1926 | */ | ||
1927 | static void setup_tripwire(struct langwell_udc *dev) | ||
1928 | { | ||
1929 | u32 usbcmd, | ||
1930 | endptsetupstat; | ||
1931 | unsigned long timeout; | ||
1932 | struct langwell_dqh *dqh; | ||
1933 | |||
1934 | VDBG(dev, "---> %s()\n", __func__); | ||
1935 | |||
1936 | /* ep0 OUT dQH */ | ||
1937 | dqh = &dev->ep_dqh[EP_DIR_OUT]; | ||
1938 | |||
1939 | /* Write-Clear endptsetupstat */ | ||
1940 | endptsetupstat = readl(&dev->op_regs->endptsetupstat); | ||
1941 | writel(endptsetupstat, &dev->op_regs->endptsetupstat); | ||
1942 | |||
1943 | /* wait until endptsetupstat is cleared */ | ||
1944 | timeout = jiffies + SETUPSTAT_TIMEOUT; | ||
1945 | while (readl(&dev->op_regs->endptsetupstat)) { | ||
1946 | if (time_after(jiffies, timeout)) { | ||
1947 | ERROR(dev, "setup_tripwire timeout\n"); | ||
1948 | break; | ||
1949 | } | ||
1950 | cpu_relax(); | ||
1951 | } | ||
1952 | |||
1953 | /* while a hazard exists when setup packet arrives */ | ||
1954 | do { | ||
1955 | /* set setup tripwire bit */ | ||
1956 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1957 | writel(usbcmd | CMD_SUTW, &dev->op_regs->usbcmd); | ||
1958 | |||
1959 | /* copy the setup packet to local buffer */ | ||
1960 | memcpy(&dev->local_setup_buff, &dqh->dqh_setup, 8); | ||
1961 | } while (!(readl(&dev->op_regs->usbcmd) & CMD_SUTW)); | ||
1962 | |||
1963 | /* Write-Clear setup tripwire bit */ | ||
1964 | usbcmd = readl(&dev->op_regs->usbcmd); | ||
1965 | writel(usbcmd & ~CMD_SUTW, &dev->op_regs->usbcmd); | ||
1966 | |||
1967 | VDBG(dev, "<--- %s()\n", __func__); | ||
1968 | } | ||
1969 | |||
1970 | |||
1971 | /* protocol ep0 stall, will automatically be cleared on new transaction */ | ||
1972 | static void ep0_stall(struct langwell_udc *dev) | ||
1973 | { | ||
1974 | u32 endptctrl; | ||
1975 | |||
1976 | VDBG(dev, "---> %s()\n", __func__); | ||
1977 | |||
1978 | /* set TX and RX to stall */ | ||
1979 | endptctrl = readl(&dev->op_regs->endptctrl[0]); | ||
1980 | endptctrl |= EPCTRL_TXS | EPCTRL_RXS; | ||
1981 | writel(endptctrl, &dev->op_regs->endptctrl[0]); | ||
1982 | |||
1983 | /* update ep0 state */ | ||
1984 | dev->ep0_state = WAIT_FOR_SETUP; | ||
1985 | dev->ep0_dir = USB_DIR_OUT; | ||
1986 | |||
1987 | VDBG(dev, "<--- %s()\n", __func__); | ||
1988 | } | ||
1989 | |||
1990 | |||
1991 | /* PRIME a status phase for ep0 */ | ||
1992 | static int prime_status_phase(struct langwell_udc *dev, int dir) | ||
1993 | { | ||
1994 | struct langwell_request *req; | ||
1995 | struct langwell_ep *ep; | ||
1996 | int status = 0; | ||
1997 | |||
1998 | VDBG(dev, "---> %s()\n", __func__); | ||
1999 | |||
2000 | if (dir == EP_DIR_IN) | ||
2001 | dev->ep0_dir = USB_DIR_IN; | ||
2002 | else | ||
2003 | dev->ep0_dir = USB_DIR_OUT; | ||
2004 | |||
2005 | ep = &dev->ep[0]; | ||
2006 | dev->ep0_state = WAIT_FOR_OUT_STATUS; | ||
2007 | |||
2008 | req = dev->status_req; | ||
2009 | |||
2010 | req->ep = ep; | ||
2011 | req->req.length = 0; | ||
2012 | req->req.status = -EINPROGRESS; | ||
2013 | req->req.actual = 0; | ||
2014 | req->req.complete = NULL; | ||
2015 | req->dtd_count = 0; | ||
2016 | |||
2017 | if (!req_to_dtd(req)) | ||
2018 | status = queue_dtd(ep, req); | ||
2019 | else | ||
2020 | return -ENOMEM; | ||
2021 | |||
2022 | if (status) | ||
2023 | ERROR(dev, "can't queue ep0 status request\n"); | ||
2024 | |||
2025 | list_add_tail(&req->queue, &ep->queue); | ||
2026 | |||
2027 | VDBG(dev, "<--- %s()\n", __func__); | ||
2028 | return status; | ||
2029 | } | ||
2030 | |||
2031 | |||
2032 | /* SET_ADDRESS request routine */ | ||
2033 | static void set_address(struct langwell_udc *dev, u16 value, | ||
2034 | u16 index, u16 length) | ||
2035 | { | ||
2036 | VDBG(dev, "---> %s()\n", __func__); | ||
2037 | |||
2038 | /* save the new address to device struct */ | ||
2039 | dev->dev_addr = (u8) value; | ||
2040 | VDBG(dev, "dev->dev_addr = %d\n", dev->dev_addr); | ||
2041 | |||
2042 | /* update usb state */ | ||
2043 | dev->usb_state = USB_STATE_ADDRESS; | ||
2044 | |||
2045 | /* STATUS phase */ | ||
2046 | if (prime_status_phase(dev, EP_DIR_IN)) | ||
2047 | ep0_stall(dev); | ||
2048 | |||
2049 | VDBG(dev, "<--- %s()\n", __func__); | ||
2050 | } | ||
2051 | |||
2052 | |||
2053 | /* return endpoint by windex */ | ||
2054 | static struct langwell_ep *get_ep_by_windex(struct langwell_udc *dev, | ||
2055 | u16 wIndex) | ||
2056 | { | ||
2057 | struct langwell_ep *ep; | ||
2058 | VDBG(dev, "---> %s()\n", __func__); | ||
2059 | |||
2060 | if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0) | ||
2061 | return &dev->ep[0]; | ||
2062 | |||
2063 | list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { | ||
2064 | u8 bEndpointAddress; | ||
2065 | if (!ep->desc) | ||
2066 | continue; | ||
2067 | |||
2068 | bEndpointAddress = ep->desc->bEndpointAddress; | ||
2069 | if ((wIndex ^ bEndpointAddress) & USB_DIR_IN) | ||
2070 | continue; | ||
2071 | |||
2072 | if ((wIndex & USB_ENDPOINT_NUMBER_MASK) | ||
2073 | == (bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)) | ||
2074 | return ep; | ||
2075 | } | ||
2076 | |||
2077 | VDBG(dev, "<--- %s()\n", __func__); | ||
2078 | return NULL; | ||
2079 | } | ||
2080 | |||
2081 | |||
2082 | /* return whether endpoint is stalled, 0: not stalled; 1: stalled */ | ||
2083 | static int ep_is_stall(struct langwell_ep *ep) | ||
2084 | { | ||
2085 | struct langwell_udc *dev = ep->dev; | ||
2086 | u32 endptctrl; | ||
2087 | int retval; | ||
2088 | |||
2089 | VDBG(dev, "---> %s()\n", __func__); | ||
2090 | |||
2091 | endptctrl = readl(&dev->op_regs->endptctrl[ep->ep_num]); | ||
2092 | if (is_in(ep)) | ||
2093 | retval = endptctrl & EPCTRL_TXS ? 1 : 0; | ||
2094 | else | ||
2095 | retval = endptctrl & EPCTRL_RXS ? 1 : 0; | ||
2096 | |||
2097 | VDBG(dev, "<--- %s()\n", __func__); | ||
2098 | return retval; | ||
2099 | } | ||
2100 | |||
2101 | |||
2102 | /* GET_STATUS request routine */ | ||
2103 | static void get_status(struct langwell_udc *dev, u8 request_type, u16 value, | ||
2104 | u16 index, u16 length) | ||
2105 | { | ||
2106 | struct langwell_request *req; | ||
2107 | struct langwell_ep *ep; | ||
2108 | u16 status_data = 0; /* 16 bits cpu view status data */ | ||
2109 | int status = 0; | ||
2110 | |||
2111 | VDBG(dev, "---> %s()\n", __func__); | ||
2112 | |||
2113 | ep = &dev->ep[0]; | ||
2114 | |||
2115 | if ((request_type & USB_RECIP_MASK) == USB_RECIP_DEVICE) { | ||
2116 | /* get device status */ | ||
2117 | status_data = 1 << USB_DEVICE_SELF_POWERED; | ||
2118 | status_data |= dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP; | ||
2119 | } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_INTERFACE) { | ||
2120 | /* get interface status */ | ||
2121 | status_data = 0; | ||
2122 | } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_ENDPOINT) { | ||
2123 | /* get endpoint status */ | ||
2124 | struct langwell_ep *epn; | ||
2125 | epn = get_ep_by_windex(dev, index); | ||
2126 | /* stall if endpoint doesn't exist */ | ||
2127 | if (!epn) | ||
2128 | goto stall; | ||
2129 | |||
2130 | status_data = ep_is_stall(epn) << USB_ENDPOINT_HALT; | ||
2131 | } | ||
2132 | |||
2133 | dev->ep0_dir = USB_DIR_IN; | ||
2134 | |||
2135 | /* borrow the per device status_req */ | ||
2136 | req = dev->status_req; | ||
2137 | |||
2138 | /* fill in the reqest structure */ | ||
2139 | *((u16 *) req->req.buf) = cpu_to_le16(status_data); | ||
2140 | req->ep = ep; | ||
2141 | req->req.length = 2; | ||
2142 | req->req.status = -EINPROGRESS; | ||
2143 | req->req.actual = 0; | ||
2144 | req->req.complete = NULL; | ||
2145 | req->dtd_count = 0; | ||
2146 | |||
2147 | /* prime the data phase */ | ||
2148 | if (!req_to_dtd(req)) | ||
2149 | status = queue_dtd(ep, req); | ||
2150 | else /* no mem */ | ||
2151 | goto stall; | ||
2152 | |||
2153 | if (status) { | ||
2154 | ERROR(dev, "response error on GET_STATUS request\n"); | ||
2155 | goto stall; | ||
2156 | } | ||
2157 | |||
2158 | list_add_tail(&req->queue, &ep->queue); | ||
2159 | dev->ep0_state = DATA_STATE_XMIT; | ||
2160 | |||
2161 | VDBG(dev, "<--- %s()\n", __func__); | ||
2162 | return; | ||
2163 | stall: | ||
2164 | ep0_stall(dev); | ||
2165 | VDBG(dev, "<--- %s()\n", __func__); | ||
2166 | } | ||
2167 | |||
2168 | |||
2169 | /* setup packet interrupt handler */ | ||
2170 | static void handle_setup_packet(struct langwell_udc *dev, | ||
2171 | struct usb_ctrlrequest *setup) | ||
2172 | { | ||
2173 | u16 wValue = le16_to_cpu(setup->wValue); | ||
2174 | u16 wIndex = le16_to_cpu(setup->wIndex); | ||
2175 | u16 wLength = le16_to_cpu(setup->wLength); | ||
2176 | |||
2177 | VDBG(dev, "---> %s()\n", __func__); | ||
2178 | |||
2179 | /* ep0 fifo flush */ | ||
2180 | nuke(&dev->ep[0], -ESHUTDOWN); | ||
2181 | |||
2182 | DBG(dev, "SETUP %02x.%02x v%04x i%04x l%04x\n", | ||
2183 | setup->bRequestType, setup->bRequest, | ||
2184 | wValue, wIndex, wLength); | ||
2185 | |||
2186 | /* RNDIS gadget delegate */ | ||
2187 | if ((setup->bRequestType == 0x21) && (setup->bRequest == 0x00)) { | ||
2188 | /* USB_CDC_SEND_ENCAPSULATED_COMMAND */ | ||
2189 | goto delegate; | ||
2190 | } | ||
2191 | |||
2192 | /* USB_CDC_GET_ENCAPSULATED_RESPONSE */ | ||
2193 | if ((setup->bRequestType == 0xa1) && (setup->bRequest == 0x01)) { | ||
2194 | /* USB_CDC_GET_ENCAPSULATED_RESPONSE */ | ||
2195 | goto delegate; | ||
2196 | } | ||
2197 | |||
2198 | /* We process some stardard setup requests here */ | ||
2199 | switch (setup->bRequest) { | ||
2200 | case USB_REQ_GET_STATUS: | ||
2201 | DBG(dev, "SETUP: USB_REQ_GET_STATUS\n"); | ||
2202 | /* get status, DATA and STATUS phase */ | ||
2203 | if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK)) | ||
2204 | != (USB_DIR_IN | USB_TYPE_STANDARD)) | ||
2205 | break; | ||
2206 | get_status(dev, setup->bRequestType, wValue, wIndex, wLength); | ||
2207 | goto end; | ||
2208 | |||
2209 | case USB_REQ_SET_ADDRESS: | ||
2210 | DBG(dev, "SETUP: USB_REQ_SET_ADDRESS\n"); | ||
2211 | /* STATUS phase */ | ||
2212 | if (setup->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD | ||
2213 | | USB_RECIP_DEVICE)) | ||
2214 | break; | ||
2215 | set_address(dev, wValue, wIndex, wLength); | ||
2216 | goto end; | ||
2217 | |||
2218 | case USB_REQ_CLEAR_FEATURE: | ||
2219 | case USB_REQ_SET_FEATURE: | ||
2220 | /* STATUS phase */ | ||
2221 | { | ||
2222 | int rc = -EOPNOTSUPP; | ||
2223 | if (setup->bRequest == USB_REQ_SET_FEATURE) | ||
2224 | DBG(dev, "SETUP: USB_REQ_SET_FEATURE\n"); | ||
2225 | else if (setup->bRequest == USB_REQ_CLEAR_FEATURE) | ||
2226 | DBG(dev, "SETUP: USB_REQ_CLEAR_FEATURE\n"); | ||
2227 | |||
2228 | if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK)) | ||
2229 | == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) { | ||
2230 | struct langwell_ep *epn; | ||
2231 | epn = get_ep_by_windex(dev, wIndex); | ||
2232 | /* stall if endpoint doesn't exist */ | ||
2233 | if (!epn) { | ||
2234 | ep0_stall(dev); | ||
2235 | goto end; | ||
2236 | } | ||
2237 | |||
2238 | if (wValue != 0 || wLength != 0 | ||
2239 | || epn->ep_num > dev->ep_max) | ||
2240 | break; | ||
2241 | |||
2242 | spin_unlock(&dev->lock); | ||
2243 | rc = langwell_ep_set_halt(&epn->ep, | ||
2244 | (setup->bRequest == USB_REQ_SET_FEATURE) | ||
2245 | ? 1 : 0); | ||
2246 | spin_lock(&dev->lock); | ||
2247 | |||
2248 | } else if ((setup->bRequestType & (USB_RECIP_MASK | ||
2249 | | USB_TYPE_MASK)) == (USB_RECIP_DEVICE | ||
2250 | | USB_TYPE_STANDARD)) { | ||
2251 | if (!gadget_is_otg(&dev->gadget)) | ||
2252 | break; | ||
2253 | else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE) { | ||
2254 | dev->gadget.b_hnp_enable = 1; | ||
2255 | #ifdef OTG_TRANSCEIVER | ||
2256 | if (!dev->lotg->otg.default_a) | ||
2257 | dev->lotg->hsm.b_hnp_enable = 1; | ||
2258 | #endif | ||
2259 | } else if (setup->bRequest == USB_DEVICE_A_HNP_SUPPORT) | ||
2260 | dev->gadget.a_hnp_support = 1; | ||
2261 | else if (setup->bRequest == | ||
2262 | USB_DEVICE_A_ALT_HNP_SUPPORT) | ||
2263 | dev->gadget.a_alt_hnp_support = 1; | ||
2264 | else | ||
2265 | break; | ||
2266 | rc = 0; | ||
2267 | } else | ||
2268 | break; | ||
2269 | |||
2270 | if (rc == 0) { | ||
2271 | if (prime_status_phase(dev, EP_DIR_IN)) | ||
2272 | ep0_stall(dev); | ||
2273 | } | ||
2274 | goto end; | ||
2275 | } | ||
2276 | |||
2277 | case USB_REQ_GET_DESCRIPTOR: | ||
2278 | DBG(dev, "SETUP: USB_REQ_GET_DESCRIPTOR\n"); | ||
2279 | goto delegate; | ||
2280 | |||
2281 | case USB_REQ_SET_DESCRIPTOR: | ||
2282 | DBG(dev, "SETUP: USB_REQ_SET_DESCRIPTOR unsupported\n"); | ||
2283 | goto delegate; | ||
2284 | |||
2285 | case USB_REQ_GET_CONFIGURATION: | ||
2286 | DBG(dev, "SETUP: USB_REQ_GET_CONFIGURATION\n"); | ||
2287 | goto delegate; | ||
2288 | |||
2289 | case USB_REQ_SET_CONFIGURATION: | ||
2290 | DBG(dev, "SETUP: USB_REQ_SET_CONFIGURATION\n"); | ||
2291 | goto delegate; | ||
2292 | |||
2293 | case USB_REQ_GET_INTERFACE: | ||
2294 | DBG(dev, "SETUP: USB_REQ_GET_INTERFACE\n"); | ||
2295 | goto delegate; | ||
2296 | |||
2297 | case USB_REQ_SET_INTERFACE: | ||
2298 | DBG(dev, "SETUP: USB_REQ_SET_INTERFACE\n"); | ||
2299 | goto delegate; | ||
2300 | |||
2301 | case USB_REQ_SYNCH_FRAME: | ||
2302 | DBG(dev, "SETUP: USB_REQ_SYNCH_FRAME unsupported\n"); | ||
2303 | goto delegate; | ||
2304 | |||
2305 | default: | ||
2306 | /* delegate USB standard requests to the gadget driver */ | ||
2307 | goto delegate; | ||
2308 | delegate: | ||
2309 | /* USB requests handled by gadget */ | ||
2310 | if (wLength) { | ||
2311 | /* DATA phase from gadget, STATUS phase from udc */ | ||
2312 | dev->ep0_dir = (setup->bRequestType & USB_DIR_IN) | ||
2313 | ? USB_DIR_IN : USB_DIR_OUT; | ||
2314 | VDBG(dev, "dev->ep0_dir = 0x%x, wLength = %d\n", | ||
2315 | dev->ep0_dir, wLength); | ||
2316 | spin_unlock(&dev->lock); | ||
2317 | if (dev->driver->setup(&dev->gadget, | ||
2318 | &dev->local_setup_buff) < 0) | ||
2319 | ep0_stall(dev); | ||
2320 | spin_lock(&dev->lock); | ||
2321 | dev->ep0_state = (setup->bRequestType & USB_DIR_IN) | ||
2322 | ? DATA_STATE_XMIT : DATA_STATE_RECV; | ||
2323 | } else { | ||
2324 | /* no DATA phase, IN STATUS phase from gadget */ | ||
2325 | dev->ep0_dir = USB_DIR_IN; | ||
2326 | VDBG(dev, "dev->ep0_dir = 0x%x, wLength = %d\n", | ||
2327 | dev->ep0_dir, wLength); | ||
2328 | spin_unlock(&dev->lock); | ||
2329 | if (dev->driver->setup(&dev->gadget, | ||
2330 | &dev->local_setup_buff) < 0) | ||
2331 | ep0_stall(dev); | ||
2332 | spin_lock(&dev->lock); | ||
2333 | dev->ep0_state = WAIT_FOR_OUT_STATUS; | ||
2334 | } | ||
2335 | break; | ||
2336 | } | ||
2337 | end: | ||
2338 | VDBG(dev, "<--- %s()\n", __func__); | ||
2339 | return; | ||
2340 | } | ||
2341 | |||
2342 | |||
2343 | /* transfer completion, process endpoint request and free the completed dTDs | ||
2344 | * for this request | ||
2345 | */ | ||
2346 | static int process_ep_req(struct langwell_udc *dev, int index, | ||
2347 | struct langwell_request *curr_req) | ||
2348 | { | ||
2349 | struct langwell_dtd *curr_dtd; | ||
2350 | struct langwell_dqh *curr_dqh; | ||
2351 | int td_complete, actual, remaining_length; | ||
2352 | int i, dir; | ||
2353 | u8 dtd_status = 0; | ||
2354 | int retval = 0; | ||
2355 | |||
2356 | curr_dqh = &dev->ep_dqh[index]; | ||
2357 | dir = index % 2; | ||
2358 | |||
2359 | curr_dtd = curr_req->head; | ||
2360 | td_complete = 0; | ||
2361 | actual = curr_req->req.length; | ||
2362 | |||
2363 | VDBG(dev, "---> %s()\n", __func__); | ||
2364 | |||
2365 | for (i = 0; i < curr_req->dtd_count; i++) { | ||
2366 | remaining_length = le16_to_cpu(curr_dtd->dtd_total); | ||
2367 | actual -= remaining_length; | ||
2368 | |||
2369 | /* command execution states by dTD */ | ||
2370 | dtd_status = curr_dtd->dtd_status; | ||
2371 | |||
2372 | if (!dtd_status) { | ||
2373 | /* transfers completed successfully */ | ||
2374 | if (!remaining_length) { | ||
2375 | td_complete++; | ||
2376 | VDBG(dev, "dTD transmitted successfully\n"); | ||
2377 | } else { | ||
2378 | if (dir) { | ||
2379 | VDBG(dev, "TX dTD remains data\n"); | ||
2380 | retval = -EPROTO; | ||
2381 | break; | ||
2382 | |||
2383 | } else { | ||
2384 | td_complete++; | ||
2385 | break; | ||
2386 | } | ||
2387 | } | ||
2388 | } else { | ||
2389 | /* transfers completed with errors */ | ||
2390 | if (dtd_status & DTD_STS_ACTIVE) { | ||
2391 | DBG(dev, "request not completed\n"); | ||
2392 | retval = 1; | ||
2393 | return retval; | ||
2394 | } else if (dtd_status & DTD_STS_HALTED) { | ||
2395 | ERROR(dev, "dTD error %08x dQH[%d]\n", | ||
2396 | dtd_status, index); | ||
2397 | /* clear the errors and halt condition */ | ||
2398 | curr_dqh->dtd_status = 0; | ||
2399 | retval = -EPIPE; | ||
2400 | break; | ||
2401 | } else if (dtd_status & DTD_STS_DBE) { | ||
2402 | DBG(dev, "data buffer (overflow) error\n"); | ||
2403 | retval = -EPROTO; | ||
2404 | break; | ||
2405 | } else if (dtd_status & DTD_STS_TRE) { | ||
2406 | DBG(dev, "transaction(ISO) error\n"); | ||
2407 | retval = -EILSEQ; | ||
2408 | break; | ||
2409 | } else | ||
2410 | ERROR(dev, "unknown error (0x%x)!\n", | ||
2411 | dtd_status); | ||
2412 | } | ||
2413 | |||
2414 | if (i != curr_req->dtd_count - 1) | ||
2415 | curr_dtd = (struct langwell_dtd *) | ||
2416 | curr_dtd->next_dtd_virt; | ||
2417 | } | ||
2418 | |||
2419 | if (retval) | ||
2420 | return retval; | ||
2421 | |||
2422 | curr_req->req.actual = actual; | ||
2423 | |||
2424 | VDBG(dev, "<--- %s()\n", __func__); | ||
2425 | return 0; | ||
2426 | } | ||
2427 | |||
2428 | |||
2429 | /* complete DATA or STATUS phase of ep0 prime status phase if needed */ | ||
2430 | static void ep0_req_complete(struct langwell_udc *dev, | ||
2431 | struct langwell_ep *ep0, struct langwell_request *req) | ||
2432 | { | ||
2433 | u32 new_addr; | ||
2434 | VDBG(dev, "---> %s()\n", __func__); | ||
2435 | |||
2436 | if (dev->usb_state == USB_STATE_ADDRESS) { | ||
2437 | /* set the new address */ | ||
2438 | new_addr = (u32)dev->dev_addr; | ||
2439 | writel(new_addr << USBADR_SHIFT, &dev->op_regs->deviceaddr); | ||
2440 | |||
2441 | new_addr = USBADR(readl(&dev->op_regs->deviceaddr)); | ||
2442 | VDBG(dev, "new_addr = %d\n", new_addr); | ||
2443 | } | ||
2444 | |||
2445 | done(ep0, req, 0); | ||
2446 | |||
2447 | switch (dev->ep0_state) { | ||
2448 | case DATA_STATE_XMIT: | ||
2449 | /* receive status phase */ | ||
2450 | if (prime_status_phase(dev, EP_DIR_OUT)) | ||
2451 | ep0_stall(dev); | ||
2452 | break; | ||
2453 | case DATA_STATE_RECV: | ||
2454 | /* send status phase */ | ||
2455 | if (prime_status_phase(dev, EP_DIR_IN)) | ||
2456 | ep0_stall(dev); | ||
2457 | break; | ||
2458 | case WAIT_FOR_OUT_STATUS: | ||
2459 | dev->ep0_state = WAIT_FOR_SETUP; | ||
2460 | break; | ||
2461 | case WAIT_FOR_SETUP: | ||
2462 | ERROR(dev, "unexpect ep0 packets\n"); | ||
2463 | break; | ||
2464 | default: | ||
2465 | ep0_stall(dev); | ||
2466 | break; | ||
2467 | } | ||
2468 | |||
2469 | VDBG(dev, "<--- %s()\n", __func__); | ||
2470 | } | ||
2471 | |||
2472 | |||
2473 | /* USB transfer completion interrupt */ | ||
2474 | static void handle_trans_complete(struct langwell_udc *dev) | ||
2475 | { | ||
2476 | u32 complete_bits; | ||
2477 | int i, ep_num, dir, bit_mask, status; | ||
2478 | struct langwell_ep *epn; | ||
2479 | struct langwell_request *curr_req, *temp_req; | ||
2480 | |||
2481 | VDBG(dev, "---> %s()\n", __func__); | ||
2482 | |||
2483 | complete_bits = readl(&dev->op_regs->endptcomplete); | ||
2484 | VDBG(dev, "endptcomplete register: 0x%08x\n", complete_bits); | ||
2485 | |||
2486 | /* Write-Clear the bits in endptcomplete register */ | ||
2487 | writel(complete_bits, &dev->op_regs->endptcomplete); | ||
2488 | |||
2489 | if (!complete_bits) { | ||
2490 | DBG(dev, "complete_bits = 0\n"); | ||
2491 | goto done; | ||
2492 | } | ||
2493 | |||
2494 | for (i = 0; i < dev->ep_max; i++) { | ||
2495 | ep_num = i / 2; | ||
2496 | dir = i % 2; | ||
2497 | |||
2498 | bit_mask = 1 << (ep_num + 16 * dir); | ||
2499 | |||
2500 | if (!(complete_bits & bit_mask)) | ||
2501 | continue; | ||
2502 | |||
2503 | /* ep0 */ | ||
2504 | if (i == 1) | ||
2505 | epn = &dev->ep[0]; | ||
2506 | else | ||
2507 | epn = &dev->ep[i]; | ||
2508 | |||
2509 | if (epn->name == NULL) { | ||
2510 | WARNING(dev, "invalid endpoint\n"); | ||
2511 | continue; | ||
2512 | } | ||
2513 | |||
2514 | if (i < 2) | ||
2515 | /* ep0 in and out */ | ||
2516 | DBG(dev, "%s-%s transfer completed\n", | ||
2517 | epn->name, | ||
2518 | is_in(epn) ? "in" : "out"); | ||
2519 | else | ||
2520 | DBG(dev, "%s transfer completed\n", epn->name); | ||
2521 | |||
2522 | /* process the req queue until an uncomplete request */ | ||
2523 | list_for_each_entry_safe(curr_req, temp_req, | ||
2524 | &epn->queue, queue) { | ||
2525 | status = process_ep_req(dev, i, curr_req); | ||
2526 | VDBG(dev, "%s req status: %d\n", epn->name, status); | ||
2527 | |||
2528 | if (status) | ||
2529 | break; | ||
2530 | |||
2531 | /* write back status to req */ | ||
2532 | curr_req->req.status = status; | ||
2533 | |||
2534 | /* ep0 request completion */ | ||
2535 | if (ep_num == 0) { | ||
2536 | ep0_req_complete(dev, epn, curr_req); | ||
2537 | break; | ||
2538 | } else { | ||
2539 | done(epn, curr_req, status); | ||
2540 | } | ||
2541 | } | ||
2542 | } | ||
2543 | done: | ||
2544 | VDBG(dev, "<--- %s()\n", __func__); | ||
2545 | return; | ||
2546 | } | ||
2547 | |||
2548 | |||
2549 | /* port change detect interrupt handler */ | ||
2550 | static void handle_port_change(struct langwell_udc *dev) | ||
2551 | { | ||
2552 | u32 portsc1, devlc; | ||
2553 | u32 speed; | ||
2554 | |||
2555 | VDBG(dev, "---> %s()\n", __func__); | ||
2556 | |||
2557 | if (dev->bus_reset) | ||
2558 | dev->bus_reset = 0; | ||
2559 | |||
2560 | portsc1 = readl(&dev->op_regs->portsc1); | ||
2561 | devlc = readl(&dev->op_regs->devlc); | ||
2562 | VDBG(dev, "portsc1 = 0x%08x, devlc = 0x%08x\n", | ||
2563 | portsc1, devlc); | ||
2564 | |||
2565 | /* bus reset is finished */ | ||
2566 | if (!(portsc1 & PORTS_PR)) { | ||
2567 | /* get the speed */ | ||
2568 | speed = LPM_PSPD(devlc); | ||
2569 | switch (speed) { | ||
2570 | case LPM_SPEED_HIGH: | ||
2571 | dev->gadget.speed = USB_SPEED_HIGH; | ||
2572 | break; | ||
2573 | case LPM_SPEED_FULL: | ||
2574 | dev->gadget.speed = USB_SPEED_FULL; | ||
2575 | break; | ||
2576 | case LPM_SPEED_LOW: | ||
2577 | dev->gadget.speed = USB_SPEED_LOW; | ||
2578 | break; | ||
2579 | default: | ||
2580 | dev->gadget.speed = USB_SPEED_UNKNOWN; | ||
2581 | break; | ||
2582 | } | ||
2583 | VDBG(dev, "speed = %d, dev->gadget.speed = %d\n", | ||
2584 | speed, dev->gadget.speed); | ||
2585 | } | ||
2586 | |||
2587 | /* LPM L0 to L1 */ | ||
2588 | if (dev->lpm && dev->lpm_state == LPM_L0) | ||
2589 | if (portsc1 & PORTS_SUSP && portsc1 & PORTS_SLP) { | ||
2590 | INFO(dev, "LPM L0 to L1\n"); | ||
2591 | dev->lpm_state = LPM_L1; | ||
2592 | } | ||
2593 | |||
2594 | /* LPM L1 to L0, force resume or remote wakeup finished */ | ||
2595 | if (dev->lpm && dev->lpm_state == LPM_L1) | ||
2596 | if (!(portsc1 & PORTS_SUSP)) { | ||
2597 | if (portsc1 & PORTS_SLP) | ||
2598 | INFO(dev, "LPM L1 to L0, force resume\n"); | ||
2599 | else | ||
2600 | INFO(dev, "LPM L1 to L0, remote wakeup\n"); | ||
2601 | |||
2602 | dev->lpm_state = LPM_L0; | ||
2603 | } | ||
2604 | |||
2605 | /* update USB state */ | ||
2606 | if (!dev->resume_state) | ||
2607 | dev->usb_state = USB_STATE_DEFAULT; | ||
2608 | |||
2609 | VDBG(dev, "<--- %s()\n", __func__); | ||
2610 | } | ||
2611 | |||
2612 | |||
2613 | /* USB reset interrupt handler */ | ||
2614 | static void handle_usb_reset(struct langwell_udc *dev) | ||
2615 | { | ||
2616 | u32 deviceaddr, | ||
2617 | endptsetupstat, | ||
2618 | endptcomplete; | ||
2619 | unsigned long timeout; | ||
2620 | |||
2621 | VDBG(dev, "---> %s()\n", __func__); | ||
2622 | |||
2623 | /* Write-Clear the device address */ | ||
2624 | deviceaddr = readl(&dev->op_regs->deviceaddr); | ||
2625 | writel(deviceaddr & ~USBADR_MASK, &dev->op_regs->deviceaddr); | ||
2626 | |||
2627 | dev->dev_addr = 0; | ||
2628 | |||
2629 | /* clear usb state */ | ||
2630 | dev->resume_state = 0; | ||
2631 | |||
2632 | /* LPM L1 to L0, reset */ | ||
2633 | if (dev->lpm) | ||
2634 | dev->lpm_state = LPM_L0; | ||
2635 | |||
2636 | dev->ep0_dir = USB_DIR_OUT; | ||
2637 | dev->ep0_state = WAIT_FOR_SETUP; | ||
2638 | dev->remote_wakeup = 0; /* default to 0 on reset */ | ||
2639 | dev->gadget.b_hnp_enable = 0; | ||
2640 | dev->gadget.a_hnp_support = 0; | ||
2641 | dev->gadget.a_alt_hnp_support = 0; | ||
2642 | |||
2643 | /* Write-Clear all the setup token semaphores */ | ||
2644 | endptsetupstat = readl(&dev->op_regs->endptsetupstat); | ||
2645 | writel(endptsetupstat, &dev->op_regs->endptsetupstat); | ||
2646 | |||
2647 | /* Write-Clear all the endpoint complete status bits */ | ||
2648 | endptcomplete = readl(&dev->op_regs->endptcomplete); | ||
2649 | writel(endptcomplete, &dev->op_regs->endptcomplete); | ||
2650 | |||
2651 | /* wait until all endptprime bits cleared */ | ||
2652 | timeout = jiffies + PRIME_TIMEOUT; | ||
2653 | while (readl(&dev->op_regs->endptprime)) { | ||
2654 | if (time_after(jiffies, timeout)) { | ||
2655 | ERROR(dev, "USB reset timeout\n"); | ||
2656 | break; | ||
2657 | } | ||
2658 | cpu_relax(); | ||
2659 | } | ||
2660 | |||
2661 | /* write 1s to endptflush register to clear any primed buffers */ | ||
2662 | writel((u32) ~0, &dev->op_regs->endptflush); | ||
2663 | |||
2664 | if (readl(&dev->op_regs->portsc1) & PORTS_PR) { | ||
2665 | VDBG(dev, "USB bus reset\n"); | ||
2666 | /* bus is reseting */ | ||
2667 | dev->bus_reset = 1; | ||
2668 | |||
2669 | /* reset all the queues, stop all USB activities */ | ||
2670 | stop_activity(dev, dev->driver); | ||
2671 | dev->usb_state = USB_STATE_DEFAULT; | ||
2672 | } else { | ||
2673 | VDBG(dev, "device controller reset\n"); | ||
2674 | /* controller reset */ | ||
2675 | langwell_udc_reset(dev); | ||
2676 | |||
2677 | /* reset all the queues, stop all USB activities */ | ||
2678 | stop_activity(dev, dev->driver); | ||
2679 | |||
2680 | /* reset ep0 dQH and endptctrl */ | ||
2681 | ep0_reset(dev); | ||
2682 | |||
2683 | /* enable interrupt and set controller to run state */ | ||
2684 | langwell_udc_start(dev); | ||
2685 | |||
2686 | dev->usb_state = USB_STATE_ATTACHED; | ||
2687 | } | ||
2688 | |||
2689 | #ifdef OTG_TRANSCEIVER | ||
2690 | /* refer to USB OTG 6.6.2.3 b_hnp_en is cleared */ | ||
2691 | if (!dev->lotg->otg.default_a) | ||
2692 | dev->lotg->hsm.b_hnp_enable = 0; | ||
2693 | #endif | ||
2694 | |||
2695 | VDBG(dev, "<--- %s()\n", __func__); | ||
2696 | } | ||
2697 | |||
2698 | |||
2699 | /* USB bus suspend/resume interrupt */ | ||
2700 | static void handle_bus_suspend(struct langwell_udc *dev) | ||
2701 | { | ||
2702 | u32 devlc; | ||
2703 | DBG(dev, "---> %s()\n", __func__); | ||
2704 | |||
2705 | dev->resume_state = dev->usb_state; | ||
2706 | dev->usb_state = USB_STATE_SUSPENDED; | ||
2707 | |||
2708 | #ifdef OTG_TRANSCEIVER | ||
2709 | if (dev->lotg->otg.default_a) { | ||
2710 | if (dev->lotg->hsm.b_bus_suspend_vld == 1) { | ||
2711 | dev->lotg->hsm.b_bus_suspend = 1; | ||
2712 | /* notify transceiver the state changes */ | ||
2713 | if (spin_trylock(&dev->lotg->wq_lock)) { | ||
2714 | langwell_update_transceiver(); | ||
2715 | spin_unlock(&dev->lotg->wq_lock); | ||
2716 | } | ||
2717 | } | ||
2718 | dev->lotg->hsm.b_bus_suspend_vld++; | ||
2719 | } else { | ||
2720 | if (!dev->lotg->hsm.a_bus_suspend) { | ||
2721 | dev->lotg->hsm.a_bus_suspend = 1; | ||
2722 | /* notify transceiver the state changes */ | ||
2723 | if (spin_trylock(&dev->lotg->wq_lock)) { | ||
2724 | langwell_update_transceiver(); | ||
2725 | spin_unlock(&dev->lotg->wq_lock); | ||
2726 | } | ||
2727 | } | ||
2728 | } | ||
2729 | #endif | ||
2730 | |||
2731 | /* report suspend to the driver */ | ||
2732 | if (dev->driver) { | ||
2733 | if (dev->driver->suspend) { | ||
2734 | spin_unlock(&dev->lock); | ||
2735 | dev->driver->suspend(&dev->gadget); | ||
2736 | spin_lock(&dev->lock); | ||
2737 | DBG(dev, "suspend %s\n", dev->driver->driver.name); | ||
2738 | } | ||
2739 | } | ||
2740 | |||
2741 | /* enter PHY low power suspend */ | ||
2742 | devlc = readl(&dev->op_regs->devlc); | ||
2743 | VDBG(dev, "devlc = 0x%08x\n", devlc); | ||
2744 | devlc |= LPM_PHCD; | ||
2745 | writel(devlc, &dev->op_regs->devlc); | ||
2746 | |||
2747 | DBG(dev, "<--- %s()\n", __func__); | ||
2748 | } | ||
2749 | |||
2750 | |||
2751 | static void handle_bus_resume(struct langwell_udc *dev) | ||
2752 | { | ||
2753 | u32 devlc; | ||
2754 | DBG(dev, "---> %s()\n", __func__); | ||
2755 | |||
2756 | dev->usb_state = dev->resume_state; | ||
2757 | dev->resume_state = 0; | ||
2758 | |||
2759 | /* exit PHY low power suspend */ | ||
2760 | devlc = readl(&dev->op_regs->devlc); | ||
2761 | VDBG(dev, "devlc = 0x%08x\n", devlc); | ||
2762 | devlc &= ~LPM_PHCD; | ||
2763 | writel(devlc, &dev->op_regs->devlc); | ||
2764 | |||
2765 | #ifdef OTG_TRANSCEIVER | ||
2766 | if (dev->lotg->otg.default_a == 0) | ||
2767 | dev->lotg->hsm.a_bus_suspend = 0; | ||
2768 | #endif | ||
2769 | |||
2770 | /* report resume to the driver */ | ||
2771 | if (dev->driver) { | ||
2772 | if (dev->driver->resume) { | ||
2773 | spin_unlock(&dev->lock); | ||
2774 | dev->driver->resume(&dev->gadget); | ||
2775 | spin_lock(&dev->lock); | ||
2776 | DBG(dev, "resume %s\n", dev->driver->driver.name); | ||
2777 | } | ||
2778 | } | ||
2779 | |||
2780 | DBG(dev, "<--- %s()\n", __func__); | ||
2781 | } | ||
2782 | |||
2783 | |||
2784 | /* USB device controller interrupt handler */ | ||
2785 | static irqreturn_t langwell_irq(int irq, void *_dev) | ||
2786 | { | ||
2787 | struct langwell_udc *dev = _dev; | ||
2788 | u32 usbsts, | ||
2789 | usbintr, | ||
2790 | irq_sts, | ||
2791 | portsc1; | ||
2792 | |||
2793 | VDBG(dev, "---> %s()\n", __func__); | ||
2794 | |||
2795 | if (dev->stopped) { | ||
2796 | VDBG(dev, "handle IRQ_NONE\n"); | ||
2797 | VDBG(dev, "<--- %s()\n", __func__); | ||
2798 | return IRQ_NONE; | ||
2799 | } | ||
2800 | |||
2801 | spin_lock(&dev->lock); | ||
2802 | |||
2803 | /* USB status */ | ||
2804 | usbsts = readl(&dev->op_regs->usbsts); | ||
2805 | |||
2806 | /* USB interrupt enable */ | ||
2807 | usbintr = readl(&dev->op_regs->usbintr); | ||
2808 | |||
2809 | irq_sts = usbsts & usbintr; | ||
2810 | VDBG(dev, "usbsts = 0x%08x, usbintr = 0x%08x, irq_sts = 0x%08x\n", | ||
2811 | usbsts, usbintr, irq_sts); | ||
2812 | |||
2813 | if (!irq_sts) { | ||
2814 | VDBG(dev, "handle IRQ_NONE\n"); | ||
2815 | VDBG(dev, "<--- %s()\n", __func__); | ||
2816 | spin_unlock(&dev->lock); | ||
2817 | return IRQ_NONE; | ||
2818 | } | ||
2819 | |||
2820 | /* Write-Clear interrupt status bits */ | ||
2821 | writel(irq_sts, &dev->op_regs->usbsts); | ||
2822 | |||
2823 | /* resume from suspend */ | ||
2824 | portsc1 = readl(&dev->op_regs->portsc1); | ||
2825 | if (dev->usb_state == USB_STATE_SUSPENDED) | ||
2826 | if (!(portsc1 & PORTS_SUSP)) | ||
2827 | handle_bus_resume(dev); | ||
2828 | |||
2829 | /* USB interrupt */ | ||
2830 | if (irq_sts & STS_UI) { | ||
2831 | VDBG(dev, "USB interrupt\n"); | ||
2832 | |||
2833 | /* setup packet received from ep0 */ | ||
2834 | if (readl(&dev->op_regs->endptsetupstat) | ||
2835 | & EP0SETUPSTAT_MASK) { | ||
2836 | VDBG(dev, "USB SETUP packet received interrupt\n"); | ||
2837 | /* setup tripwire semaphone */ | ||
2838 | setup_tripwire(dev); | ||
2839 | handle_setup_packet(dev, &dev->local_setup_buff); | ||
2840 | } | ||
2841 | |||
2842 | /* USB transfer completion */ | ||
2843 | if (readl(&dev->op_regs->endptcomplete)) { | ||
2844 | VDBG(dev, "USB transfer completion interrupt\n"); | ||
2845 | handle_trans_complete(dev); | ||
2846 | } | ||
2847 | } | ||
2848 | |||
2849 | /* SOF received interrupt (for ISO transfer) */ | ||
2850 | if (irq_sts & STS_SRI) { | ||
2851 | /* FIXME */ | ||
2852 | /* VDBG(dev, "SOF received interrupt\n"); */ | ||
2853 | } | ||
2854 | |||
2855 | /* port change detect interrupt */ | ||
2856 | if (irq_sts & STS_PCI) { | ||
2857 | VDBG(dev, "port change detect interrupt\n"); | ||
2858 | handle_port_change(dev); | ||
2859 | } | ||
2860 | |||
2861 | /* suspend interrrupt */ | ||
2862 | if (irq_sts & STS_SLI) { | ||
2863 | VDBG(dev, "suspend interrupt\n"); | ||
2864 | handle_bus_suspend(dev); | ||
2865 | } | ||
2866 | |||
2867 | /* USB reset interrupt */ | ||
2868 | if (irq_sts & STS_URI) { | ||
2869 | VDBG(dev, "USB reset interrupt\n"); | ||
2870 | handle_usb_reset(dev); | ||
2871 | } | ||
2872 | |||
2873 | /* USB error or system error interrupt */ | ||
2874 | if (irq_sts & (STS_UEI | STS_SEI)) { | ||
2875 | /* FIXME */ | ||
2876 | WARNING(dev, "error IRQ, irq_sts: %x\n", irq_sts); | ||
2877 | } | ||
2878 | |||
2879 | spin_unlock(&dev->lock); | ||
2880 | |||
2881 | VDBG(dev, "<--- %s()\n", __func__); | ||
2882 | return IRQ_HANDLED; | ||
2883 | } | ||
2884 | |||
2885 | |||
2886 | /*-------------------------------------------------------------------------*/ | ||
2887 | |||
2888 | /* release device structure */ | ||
2889 | static void gadget_release(struct device *_dev) | ||
2890 | { | ||
2891 | struct langwell_udc *dev = the_controller; | ||
2892 | |||
2893 | DBG(dev, "---> %s()\n", __func__); | ||
2894 | |||
2895 | complete(dev->done); | ||
2896 | |||
2897 | DBG(dev, "<--- %s()\n", __func__); | ||
2898 | kfree(dev); | ||
2899 | } | ||
2900 | |||
2901 | |||
2902 | /* tear down the binding between this driver and the pci device */ | ||
2903 | static void langwell_udc_remove(struct pci_dev *pdev) | ||
2904 | { | ||
2905 | struct langwell_udc *dev = the_controller; | ||
2906 | |||
2907 | DECLARE_COMPLETION(done); | ||
2908 | |||
2909 | BUG_ON(dev->driver); | ||
2910 | DBG(dev, "---> %s()\n", __func__); | ||
2911 | |||
2912 | dev->done = &done; | ||
2913 | |||
2914 | /* free memory allocated in probe */ | ||
2915 | if (dev->dtd_pool) | ||
2916 | dma_pool_destroy(dev->dtd_pool); | ||
2917 | |||
2918 | if (dev->status_req) { | ||
2919 | kfree(dev->status_req->req.buf); | ||
2920 | kfree(dev->status_req); | ||
2921 | } | ||
2922 | |||
2923 | if (dev->ep_dqh) | ||
2924 | dma_free_coherent(&pdev->dev, dev->ep_dqh_size, | ||
2925 | dev->ep_dqh, dev->ep_dqh_dma); | ||
2926 | |||
2927 | kfree(dev->ep); | ||
2928 | |||
2929 | /* diable IRQ handler */ | ||
2930 | if (dev->got_irq) | ||
2931 | free_irq(pdev->irq, dev); | ||
2932 | |||
2933 | #ifndef OTG_TRANSCEIVER | ||
2934 | if (dev->cap_regs) | ||
2935 | iounmap(dev->cap_regs); | ||
2936 | |||
2937 | if (dev->region) | ||
2938 | release_mem_region(pci_resource_start(pdev, 0), | ||
2939 | pci_resource_len(pdev, 0)); | ||
2940 | |||
2941 | if (dev->enabled) | ||
2942 | pci_disable_device(pdev); | ||
2943 | #else | ||
2944 | if (dev->transceiver) { | ||
2945 | otg_put_transceiver(dev->transceiver); | ||
2946 | dev->transceiver = NULL; | ||
2947 | dev->lotg = NULL; | ||
2948 | } | ||
2949 | #endif | ||
2950 | |||
2951 | dev->cap_regs = NULL; | ||
2952 | |||
2953 | INFO(dev, "unbind\n"); | ||
2954 | DBG(dev, "<--- %s()\n", __func__); | ||
2955 | |||
2956 | device_unregister(&dev->gadget.dev); | ||
2957 | device_remove_file(&pdev->dev, &dev_attr_langwell_udc); | ||
2958 | |||
2959 | #ifndef OTG_TRANSCEIVER | ||
2960 | pci_set_drvdata(pdev, NULL); | ||
2961 | #endif | ||
2962 | |||
2963 | /* free dev, wait for the release() finished */ | ||
2964 | wait_for_completion(&done); | ||
2965 | |||
2966 | the_controller = NULL; | ||
2967 | } | ||
2968 | |||
2969 | |||
2970 | /* | ||
2971 | * wrap this driver around the specified device, but | ||
2972 | * don't respond over USB until a gadget driver binds to us. | ||
2973 | */ | ||
2974 | static int langwell_udc_probe(struct pci_dev *pdev, | ||
2975 | const struct pci_device_id *id) | ||
2976 | { | ||
2977 | struct langwell_udc *dev; | ||
2978 | #ifndef OTG_TRANSCEIVER | ||
2979 | unsigned long resource, len; | ||
2980 | #endif | ||
2981 | void __iomem *base = NULL; | ||
2982 | size_t size; | ||
2983 | int retval; | ||
2984 | |||
2985 | if (the_controller) { | ||
2986 | dev_warn(&pdev->dev, "ignoring\n"); | ||
2987 | return -EBUSY; | ||
2988 | } | ||
2989 | |||
2990 | /* alloc, and start init */ | ||
2991 | dev = kzalloc(sizeof *dev, GFP_KERNEL); | ||
2992 | if (dev == NULL) { | ||
2993 | retval = -ENOMEM; | ||
2994 | goto error; | ||
2995 | } | ||
2996 | |||
2997 | /* initialize device spinlock */ | ||
2998 | spin_lock_init(&dev->lock); | ||
2999 | |||
3000 | dev->pdev = pdev; | ||
3001 | DBG(dev, "---> %s()\n", __func__); | ||
3002 | |||
3003 | #ifdef OTG_TRANSCEIVER | ||
3004 | /* PCI device is already enabled by otg_transceiver driver */ | ||
3005 | dev->enabled = 1; | ||
3006 | |||
3007 | /* mem region and register base */ | ||
3008 | dev->region = 1; | ||
3009 | dev->transceiver = otg_get_transceiver(); | ||
3010 | dev->lotg = otg_to_langwell(dev->transceiver); | ||
3011 | base = dev->lotg->regs; | ||
3012 | #else | ||
3013 | pci_set_drvdata(pdev, dev); | ||
3014 | |||
3015 | /* now all the pci goodies ... */ | ||
3016 | if (pci_enable_device(pdev) < 0) { | ||
3017 | retval = -ENODEV; | ||
3018 | goto error; | ||
3019 | } | ||
3020 | dev->enabled = 1; | ||
3021 | |||
3022 | /* control register: BAR 0 */ | ||
3023 | resource = pci_resource_start(pdev, 0); | ||
3024 | len = pci_resource_len(pdev, 0); | ||
3025 | if (!request_mem_region(resource, len, driver_name)) { | ||
3026 | ERROR(dev, "controller already in use\n"); | ||
3027 | retval = -EBUSY; | ||
3028 | goto error; | ||
3029 | } | ||
3030 | dev->region = 1; | ||
3031 | |||
3032 | base = ioremap_nocache(resource, len); | ||
3033 | #endif | ||
3034 | if (base == NULL) { | ||
3035 | ERROR(dev, "can't map memory\n"); | ||
3036 | retval = -EFAULT; | ||
3037 | goto error; | ||
3038 | } | ||
3039 | |||
3040 | dev->cap_regs = (struct langwell_cap_regs __iomem *) base; | ||
3041 | VDBG(dev, "dev->cap_regs: %p\n", dev->cap_regs); | ||
3042 | dev->op_regs = (struct langwell_op_regs __iomem *) | ||
3043 | (base + OP_REG_OFFSET); | ||
3044 | VDBG(dev, "dev->op_regs: %p\n", dev->op_regs); | ||
3045 | |||
3046 | /* irq setup after old hardware is cleaned up */ | ||
3047 | if (!pdev->irq) { | ||
3048 | ERROR(dev, "No IRQ. Check PCI setup!\n"); | ||
3049 | retval = -ENODEV; | ||
3050 | goto error; | ||
3051 | } | ||
3052 | |||
3053 | #ifndef OTG_TRANSCEIVER | ||
3054 | INFO(dev, "irq %d, io mem: 0x%08lx, len: 0x%08lx, pci mem 0x%p\n", | ||
3055 | pdev->irq, resource, len, base); | ||
3056 | /* enables bus-mastering for device dev */ | ||
3057 | pci_set_master(pdev); | ||
3058 | |||
3059 | if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED, | ||
3060 | driver_name, dev) != 0) { | ||
3061 | ERROR(dev, "request interrupt %d failed\n", pdev->irq); | ||
3062 | retval = -EBUSY; | ||
3063 | goto error; | ||
3064 | } | ||
3065 | dev->got_irq = 1; | ||
3066 | #endif | ||
3067 | |||
3068 | /* set stopped bit */ | ||
3069 | dev->stopped = 1; | ||
3070 | |||
3071 | /* capabilities and endpoint number */ | ||
3072 | dev->lpm = (readl(&dev->cap_regs->hccparams) & HCC_LEN) ? 1 : 0; | ||
3073 | dev->dciversion = readw(&dev->cap_regs->dciversion); | ||
3074 | dev->devcap = (readl(&dev->cap_regs->dccparams) & DEVCAP) ? 1 : 0; | ||
3075 | VDBG(dev, "dev->lpm: %d\n", dev->lpm); | ||
3076 | VDBG(dev, "dev->dciversion: 0x%04x\n", dev->dciversion); | ||
3077 | VDBG(dev, "dccparams: 0x%08x\n", readl(&dev->cap_regs->dccparams)); | ||
3078 | VDBG(dev, "dev->devcap: %d\n", dev->devcap); | ||
3079 | if (!dev->devcap) { | ||
3080 | ERROR(dev, "can't support device mode\n"); | ||
3081 | retval = -ENODEV; | ||
3082 | goto error; | ||
3083 | } | ||
3084 | |||
3085 | /* a pair of endpoints (out/in) for each address */ | ||
3086 | dev->ep_max = DEN(readl(&dev->cap_regs->dccparams)) * 2; | ||
3087 | VDBG(dev, "dev->ep_max: %d\n", dev->ep_max); | ||
3088 | |||
3089 | /* allocate endpoints memory */ | ||
3090 | dev->ep = kzalloc(sizeof(struct langwell_ep) * dev->ep_max, | ||
3091 | GFP_KERNEL); | ||
3092 | if (!dev->ep) { | ||
3093 | ERROR(dev, "allocate endpoints memory failed\n"); | ||
3094 | retval = -ENOMEM; | ||
3095 | goto error; | ||
3096 | } | ||
3097 | |||
3098 | /* allocate device dQH memory */ | ||
3099 | size = dev->ep_max * sizeof(struct langwell_dqh); | ||
3100 | VDBG(dev, "orig size = %d\n", size); | ||
3101 | if (size < DQH_ALIGNMENT) | ||
3102 | size = DQH_ALIGNMENT; | ||
3103 | else if ((size % DQH_ALIGNMENT) != 0) { | ||
3104 | size += DQH_ALIGNMENT + 1; | ||
3105 | size &= ~(DQH_ALIGNMENT - 1); | ||
3106 | } | ||
3107 | dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size, | ||
3108 | &dev->ep_dqh_dma, GFP_KERNEL); | ||
3109 | if (!dev->ep_dqh) { | ||
3110 | ERROR(dev, "allocate dQH memory failed\n"); | ||
3111 | retval = -ENOMEM; | ||
3112 | goto error; | ||
3113 | } | ||
3114 | dev->ep_dqh_size = size; | ||
3115 | VDBG(dev, "ep_dqh_size = %d\n", dev->ep_dqh_size); | ||
3116 | |||
3117 | /* initialize ep0 status request structure */ | ||
3118 | dev->status_req = kzalloc(sizeof(struct langwell_request), GFP_KERNEL); | ||
3119 | if (!dev->status_req) { | ||
3120 | ERROR(dev, "allocate status_req memory failed\n"); | ||
3121 | retval = -ENOMEM; | ||
3122 | goto error; | ||
3123 | } | ||
3124 | INIT_LIST_HEAD(&dev->status_req->queue); | ||
3125 | |||
3126 | /* allocate a small amount of memory to get valid address */ | ||
3127 | dev->status_req->req.buf = kmalloc(8, GFP_KERNEL); | ||
3128 | dev->status_req->req.dma = virt_to_phys(dev->status_req->req.buf); | ||
3129 | |||
3130 | dev->resume_state = USB_STATE_NOTATTACHED; | ||
3131 | dev->usb_state = USB_STATE_POWERED; | ||
3132 | dev->ep0_dir = USB_DIR_OUT; | ||
3133 | dev->remote_wakeup = 0; /* default to 0 on reset */ | ||
3134 | |||
3135 | #ifndef OTG_TRANSCEIVER | ||
3136 | /* reset device controller */ | ||
3137 | langwell_udc_reset(dev); | ||
3138 | #endif | ||
3139 | |||
3140 | /* initialize gadget structure */ | ||
3141 | dev->gadget.ops = &langwell_ops; /* usb_gadget_ops */ | ||
3142 | dev->gadget.ep0 = &dev->ep[0].ep; /* gadget ep0 */ | ||
3143 | INIT_LIST_HEAD(&dev->gadget.ep_list); /* ep_list */ | ||
3144 | dev->gadget.speed = USB_SPEED_UNKNOWN; /* speed */ | ||
3145 | dev->gadget.is_dualspeed = 1; /* support dual speed */ | ||
3146 | #ifdef OTG_TRANSCEIVER | ||
3147 | dev->gadget.is_otg = 1; /* support otg mode */ | ||
3148 | #endif | ||
3149 | |||
3150 | /* the "gadget" abstracts/virtualizes the controller */ | ||
3151 | dev_set_name(&dev->gadget.dev, "gadget"); | ||
3152 | dev->gadget.dev.parent = &pdev->dev; | ||
3153 | dev->gadget.dev.dma_mask = pdev->dev.dma_mask; | ||
3154 | dev->gadget.dev.release = gadget_release; | ||
3155 | dev->gadget.name = driver_name; /* gadget name */ | ||
3156 | |||
3157 | /* controller endpoints reinit */ | ||
3158 | eps_reinit(dev); | ||
3159 | |||
3160 | #ifndef OTG_TRANSCEIVER | ||
3161 | /* reset ep0 dQH and endptctrl */ | ||
3162 | ep0_reset(dev); | ||
3163 | #endif | ||
3164 | |||
3165 | /* create dTD dma_pool resource */ | ||
3166 | dev->dtd_pool = dma_pool_create("langwell_dtd", | ||
3167 | &dev->pdev->dev, | ||
3168 | sizeof(struct langwell_dtd), | ||
3169 | DTD_ALIGNMENT, | ||
3170 | DMA_BOUNDARY); | ||
3171 | |||
3172 | if (!dev->dtd_pool) { | ||
3173 | retval = -ENOMEM; | ||
3174 | goto error; | ||
3175 | } | ||
3176 | |||
3177 | /* done */ | ||
3178 | INFO(dev, "%s\n", driver_desc); | ||
3179 | INFO(dev, "irq %d, pci mem %p\n", pdev->irq, base); | ||
3180 | INFO(dev, "Driver version: " DRIVER_VERSION "\n"); | ||
3181 | INFO(dev, "Support (max) %d endpoints\n", dev->ep_max); | ||
3182 | INFO(dev, "Device interface version: 0x%04x\n", dev->dciversion); | ||
3183 | INFO(dev, "Controller mode: %s\n", dev->devcap ? "Device" : "Host"); | ||
3184 | INFO(dev, "Support USB LPM: %s\n", dev->lpm ? "Yes" : "No"); | ||
3185 | |||
3186 | VDBG(dev, "After langwell_udc_probe(), print all registers:\n"); | ||
3187 | #ifdef VERBOSE | ||
3188 | print_all_registers(dev); | ||
3189 | #endif | ||
3190 | |||
3191 | the_controller = dev; | ||
3192 | |||
3193 | retval = device_register(&dev->gadget.dev); | ||
3194 | if (retval) | ||
3195 | goto error; | ||
3196 | |||
3197 | retval = device_create_file(&pdev->dev, &dev_attr_langwell_udc); | ||
3198 | if (retval) | ||
3199 | goto error; | ||
3200 | |||
3201 | VDBG(dev, "<--- %s()\n", __func__); | ||
3202 | return 0; | ||
3203 | |||
3204 | error: | ||
3205 | if (dev) { | ||
3206 | DBG(dev, "<--- %s()\n", __func__); | ||
3207 | langwell_udc_remove(pdev); | ||
3208 | } | ||
3209 | |||
3210 | return retval; | ||
3211 | } | ||
3212 | |||
3213 | |||
3214 | /* device controller suspend */ | ||
3215 | static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state) | ||
3216 | { | ||
3217 | struct langwell_udc *dev = the_controller; | ||
3218 | u32 devlc; | ||
3219 | |||
3220 | DBG(dev, "---> %s()\n", __func__); | ||
3221 | |||
3222 | /* disable interrupt and set controller to stop state */ | ||
3223 | langwell_udc_stop(dev); | ||
3224 | |||
3225 | /* diable IRQ handler */ | ||
3226 | if (dev->got_irq) | ||
3227 | free_irq(pdev->irq, dev); | ||
3228 | dev->got_irq = 0; | ||
3229 | |||
3230 | |||
3231 | /* save PCI state */ | ||
3232 | pci_save_state(pdev); | ||
3233 | |||
3234 | /* set device power state */ | ||
3235 | pci_set_power_state(pdev, PCI_D3hot); | ||
3236 | |||
3237 | /* enter PHY low power suspend */ | ||
3238 | devlc = readl(&dev->op_regs->devlc); | ||
3239 | VDBG(dev, "devlc = 0x%08x\n", devlc); | ||
3240 | devlc |= LPM_PHCD; | ||
3241 | writel(devlc, &dev->op_regs->devlc); | ||
3242 | |||
3243 | DBG(dev, "<--- %s()\n", __func__); | ||
3244 | return 0; | ||
3245 | } | ||
3246 | |||
3247 | |||
3248 | /* device controller resume */ | ||
3249 | static int langwell_udc_resume(struct pci_dev *pdev) | ||
3250 | { | ||
3251 | struct langwell_udc *dev = the_controller; | ||
3252 | u32 devlc; | ||
3253 | |||
3254 | DBG(dev, "---> %s()\n", __func__); | ||
3255 | |||
3256 | /* exit PHY low power suspend */ | ||
3257 | devlc = readl(&dev->op_regs->devlc); | ||
3258 | VDBG(dev, "devlc = 0x%08x\n", devlc); | ||
3259 | devlc &= ~LPM_PHCD; | ||
3260 | writel(devlc, &dev->op_regs->devlc); | ||
3261 | |||
3262 | /* set device D0 power state */ | ||
3263 | pci_set_power_state(pdev, PCI_D0); | ||
3264 | |||
3265 | /* restore PCI state */ | ||
3266 | pci_restore_state(pdev); | ||
3267 | |||
3268 | /* enable IRQ handler */ | ||
3269 | if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED, driver_name, dev) | ||
3270 | != 0) { | ||
3271 | ERROR(dev, "request interrupt %d failed\n", pdev->irq); | ||
3272 | return -1; | ||
3273 | } | ||
3274 | dev->got_irq = 1; | ||
3275 | |||
3276 | /* reset and start controller to run state */ | ||
3277 | if (dev->stopped) { | ||
3278 | /* reset device controller */ | ||
3279 | langwell_udc_reset(dev); | ||
3280 | |||
3281 | /* reset ep0 dQH and endptctrl */ | ||
3282 | ep0_reset(dev); | ||
3283 | |||
3284 | /* start device if gadget is loaded */ | ||
3285 | if (dev->driver) | ||
3286 | langwell_udc_start(dev); | ||
3287 | } | ||
3288 | |||
3289 | /* reset USB status */ | ||
3290 | dev->usb_state = USB_STATE_ATTACHED; | ||
3291 | dev->ep0_state = WAIT_FOR_SETUP; | ||
3292 | dev->ep0_dir = USB_DIR_OUT; | ||
3293 | |||
3294 | DBG(dev, "<--- %s()\n", __func__); | ||
3295 | return 0; | ||
3296 | } | ||
3297 | |||
3298 | |||
3299 | /* pci driver shutdown */ | ||
3300 | static void langwell_udc_shutdown(struct pci_dev *pdev) | ||
3301 | { | ||
3302 | struct langwell_udc *dev = the_controller; | ||
3303 | u32 usbmode; | ||
3304 | |||
3305 | DBG(dev, "---> %s()\n", __func__); | ||
3306 | |||
3307 | /* reset controller mode to IDLE */ | ||
3308 | usbmode = readl(&dev->op_regs->usbmode); | ||
3309 | DBG(dev, "usbmode = 0x%08x\n", usbmode); | ||
3310 | usbmode &= (~3 | MODE_IDLE); | ||
3311 | writel(usbmode, &dev->op_regs->usbmode); | ||
3312 | |||
3313 | DBG(dev, "<--- %s()\n", __func__); | ||
3314 | } | ||
3315 | |||
3316 | /*-------------------------------------------------------------------------*/ | ||
3317 | |||
3318 | static const struct pci_device_id pci_ids[] = { { | ||
3319 | .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), | ||
3320 | .class_mask = ~0, | ||
3321 | .vendor = 0x8086, | ||
3322 | .device = 0x0811, | ||
3323 | .subvendor = PCI_ANY_ID, | ||
3324 | .subdevice = PCI_ANY_ID, | ||
3325 | }, { /* end: all zeroes */ } | ||
3326 | }; | ||
3327 | |||
3328 | |||
3329 | MODULE_DEVICE_TABLE(pci, pci_ids); | ||
3330 | |||
3331 | |||
3332 | static struct pci_driver langwell_pci_driver = { | ||
3333 | .name = (char *) driver_name, | ||
3334 | .id_table = pci_ids, | ||
3335 | |||
3336 | .probe = langwell_udc_probe, | ||
3337 | .remove = langwell_udc_remove, | ||
3338 | |||
3339 | /* device controller suspend/resume */ | ||
3340 | .suspend = langwell_udc_suspend, | ||
3341 | .resume = langwell_udc_resume, | ||
3342 | |||
3343 | .shutdown = langwell_udc_shutdown, | ||
3344 | }; | ||
3345 | |||
3346 | |||
3347 | MODULE_DESCRIPTION(DRIVER_DESC); | ||
3348 | MODULE_AUTHOR("Xiaochen Shen <xiaochen.shen@intel.com>"); | ||
3349 | MODULE_VERSION(DRIVER_VERSION); | ||
3350 | MODULE_LICENSE("GPL"); | ||
3351 | |||
3352 | |||
3353 | static int __init init(void) | ||
3354 | { | ||
3355 | #ifdef OTG_TRANSCEIVER | ||
3356 | return langwell_register_peripheral(&langwell_pci_driver); | ||
3357 | #else | ||
3358 | return pci_register_driver(&langwell_pci_driver); | ||
3359 | #endif | ||
3360 | } | ||
3361 | module_init(init); | ||
3362 | |||
3363 | |||
3364 | static void __exit cleanup(void) | ||
3365 | { | ||
3366 | #ifdef OTG_TRANSCEIVER | ||
3367 | return langwell_unregister_peripheral(&langwell_pci_driver); | ||
3368 | #else | ||
3369 | pci_unregister_driver(&langwell_pci_driver); | ||
3370 | #endif | ||
3371 | } | ||
3372 | module_exit(cleanup); | ||
3373 | |||
diff --git a/drivers/usb/gadget/langwell_udc.h b/drivers/usb/gadget/langwell_udc.h new file mode 100644 index 000000000000..9719934e1c08 --- /dev/null +++ b/drivers/usb/gadget/langwell_udc.h | |||
@@ -0,0 +1,228 @@ | |||
1 | /* | ||
2 | * Intel Langwell USB Device Controller driver | ||
3 | * Copyright (C) 2008-2009, Intel Corporation. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms and conditions of the GNU General Public License, | ||
7 | * version 2, as published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., | ||
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | #include <linux/usb/langwell_udc.h> | ||
21 | |||
22 | #if defined(CONFIG_USB_LANGWELL_OTG) | ||
23 | #include <linux/usb/langwell_otg.h> | ||
24 | #endif | ||
25 | |||
26 | |||
27 | /*-------------------------------------------------------------------------*/ | ||
28 | |||
29 | /* driver data structures and utilities */ | ||
30 | |||
31 | /* | ||
32 | * dTD: Device Endpoint Transfer Descriptor | ||
33 | * describe to the device controller the location and quantity of | ||
34 | * data to be send/received for given transfer | ||
35 | */ | ||
36 | struct langwell_dtd { | ||
37 | u32 dtd_next; | ||
38 | /* bits 31:5, next transfer element pointer */ | ||
39 | #define DTD_NEXT(d) (((d)>>5)&0x7ffffff) | ||
40 | #define DTD_NEXT_MASK (0x7ffffff << 5) | ||
41 | /* terminate */ | ||
42 | #define DTD_TERM BIT(0) | ||
43 | /* bits 7:0, execution back states */ | ||
44 | u32 dtd_status:8; | ||
45 | #define DTD_STATUS(d) (((d)>>0)&0xff) | ||
46 | #define DTD_STS_ACTIVE BIT(7) /* active */ | ||
47 | #define DTD_STS_HALTED BIT(6) /* halted */ | ||
48 | #define DTD_STS_DBE BIT(5) /* data buffer error */ | ||
49 | #define DTD_STS_TRE BIT(3) /* transaction error */ | ||
50 | /* bits 9:8 */ | ||
51 | u32 dtd_res0:2; | ||
52 | /* bits 11:10, multipier override */ | ||
53 | u32 dtd_multo:2; | ||
54 | #define DTD_MULTO (BIT(11) | BIT(10)) | ||
55 | /* bits 14:12 */ | ||
56 | u32 dtd_res1:3; | ||
57 | /* bit 15, interrupt on complete */ | ||
58 | u32 dtd_ioc:1; | ||
59 | #define DTD_IOC BIT(15) | ||
60 | /* bits 30:16, total bytes */ | ||
61 | u32 dtd_total:15; | ||
62 | #define DTD_TOTAL(d) (((d)>>16)&0x7fff) | ||
63 | #define DTD_MAX_TRANSFER_LENGTH 0x4000 | ||
64 | /* bit 31 */ | ||
65 | u32 dtd_res2:1; | ||
66 | /* dTD buffer pointer page 0 to 4 */ | ||
67 | u32 dtd_buf[5]; | ||
68 | #define DTD_OFFSET_MASK 0xfff | ||
69 | /* bits 31:12, buffer pointer */ | ||
70 | #define DTD_BUFFER(d) (((d)>>12)&0x3ff) | ||
71 | /* bits 11:0, current offset */ | ||
72 | #define DTD_C_OFFSET(d) (((d)>>0)&0xfff) | ||
73 | /* bits 10:0, frame number */ | ||
74 | #define DTD_FRAME(d) (((d)>>0)&0x7ff) | ||
75 | |||
76 | /* driver-private parts */ | ||
77 | |||
78 | /* dtd dma address */ | ||
79 | dma_addr_t dtd_dma; | ||
80 | /* next dtd virtual address */ | ||
81 | struct langwell_dtd *next_dtd_virt; | ||
82 | }; | ||
83 | |||
84 | |||
85 | /* | ||
86 | * dQH: Device Endpoint Queue Head | ||
87 | * describe where all transfers are managed | ||
88 | * 48-byte data structure, aligned on 64-byte boundary | ||
89 | * | ||
90 | * These are associated with dTD structure | ||
91 | */ | ||
92 | struct langwell_dqh { | ||
93 | /* endpoint capabilities and characteristics */ | ||
94 | u32 dqh_res0:15; /* bits 14:0 */ | ||
95 | u32 dqh_ios:1; /* bit 15, interrupt on setup */ | ||
96 | #define DQH_IOS BIT(15) | ||
97 | u32 dqh_mpl:11; /* bits 26:16, maximum packet length */ | ||
98 | #define DQH_MPL (0x7ff << 16) | ||
99 | u32 dqh_res1:2; /* bits 28:27 */ | ||
100 | u32 dqh_zlt:1; /* bit 29, zero length termination */ | ||
101 | #define DQH_ZLT BIT(29) | ||
102 | u32 dqh_mult:2; /* bits 31:30 */ | ||
103 | #define DQH_MULT (BIT(30) | BIT(31)) | ||
104 | |||
105 | /* current dTD pointer */ | ||
106 | u32 dqh_current; /* locate the transfer in progress */ | ||
107 | #define DQH_C_DTD(e) \ | ||
108 | (((e)>>5)&0x7ffffff) /* bits 31:5, current dTD pointer */ | ||
109 | |||
110 | /* transfer overlay, hardware parts of a struct langwell_dtd */ | ||
111 | u32 dtd_next; | ||
112 | u32 dtd_status:8; /* bits 7:0, execution back states */ | ||
113 | u32 dtd_res0:2; /* bits 9:8 */ | ||
114 | u32 dtd_multo:2; /* bits 11:10, multipier override */ | ||
115 | u32 dtd_res1:3; /* bits 14:12 */ | ||
116 | u32 dtd_ioc:1; /* bit 15, interrupt on complete */ | ||
117 | u32 dtd_total:15; /* bits 30:16, total bytes */ | ||
118 | u32 dtd_res2:1; /* bit 31 */ | ||
119 | u32 dtd_buf[5]; /* dTD buffer pointer page 0 to 4 */ | ||
120 | |||
121 | u32 dqh_res2; | ||
122 | struct usb_ctrlrequest dqh_setup; /* setup packet buffer */ | ||
123 | } __attribute__ ((aligned(64))); | ||
124 | |||
125 | |||
126 | /* endpoint data structure */ | ||
127 | struct langwell_ep { | ||
128 | struct usb_ep ep; | ||
129 | dma_addr_t dma; | ||
130 | struct langwell_udc *dev; | ||
131 | unsigned long irqs; | ||
132 | struct list_head queue; | ||
133 | struct langwell_dqh *dqh; | ||
134 | const struct usb_endpoint_descriptor *desc; | ||
135 | char name[14]; | ||
136 | unsigned stopped:1, | ||
137 | ep_type:2, | ||
138 | ep_num:8; | ||
139 | }; | ||
140 | |||
141 | |||
142 | /* request data structure */ | ||
143 | struct langwell_request { | ||
144 | struct usb_request req; | ||
145 | struct langwell_dtd *dtd, *head, *tail; | ||
146 | struct langwell_ep *ep; | ||
147 | dma_addr_t dtd_dma; | ||
148 | struct list_head queue; | ||
149 | unsigned dtd_count; | ||
150 | unsigned mapped:1; | ||
151 | }; | ||
152 | |||
153 | |||
154 | /* ep0 transfer state */ | ||
155 | enum ep0_state { | ||
156 | WAIT_FOR_SETUP, | ||
157 | DATA_STATE_XMIT, | ||
158 | DATA_STATE_NEED_ZLP, | ||
159 | WAIT_FOR_OUT_STATUS, | ||
160 | DATA_STATE_RECV, | ||
161 | }; | ||
162 | |||
163 | |||
164 | /* device suspend state */ | ||
165 | enum lpm_state { | ||
166 | LPM_L0, /* on */ | ||
167 | LPM_L1, /* LPM L1 sleep */ | ||
168 | LPM_L2, /* suspend */ | ||
169 | LPM_L3, /* off */ | ||
170 | }; | ||
171 | |||
172 | |||
173 | /* device data structure */ | ||
174 | struct langwell_udc { | ||
175 | /* each pci device provides one gadget, several endpoints */ | ||
176 | struct usb_gadget gadget; | ||
177 | spinlock_t lock; /* device lock */ | ||
178 | struct langwell_ep *ep; | ||
179 | struct usb_gadget_driver *driver; | ||
180 | struct otg_transceiver *transceiver; | ||
181 | u8 dev_addr; | ||
182 | u32 usb_state; | ||
183 | u32 resume_state; | ||
184 | u32 bus_reset; | ||
185 | enum lpm_state lpm_state; | ||
186 | enum ep0_state ep0_state; | ||
187 | u32 ep0_dir; | ||
188 | u16 dciversion; | ||
189 | unsigned ep_max; | ||
190 | unsigned devcap:1, | ||
191 | enabled:1, | ||
192 | region:1, | ||
193 | got_irq:1, | ||
194 | powered:1, | ||
195 | remote_wakeup:1, | ||
196 | rate:1, | ||
197 | is_reset:1, | ||
198 | softconnected:1, | ||
199 | vbus_active:1, | ||
200 | suspended:1, | ||
201 | stopped:1, | ||
202 | lpm:1; /* LPM capability */ | ||
203 | |||
204 | /* pci state used to access those endpoints */ | ||
205 | struct pci_dev *pdev; | ||
206 | |||
207 | /* Langwell otg transceiver */ | ||
208 | struct langwell_otg *lotg; | ||
209 | |||
210 | /* control registers */ | ||
211 | struct langwell_cap_regs __iomem *cap_regs; | ||
212 | struct langwell_op_regs __iomem *op_regs; | ||
213 | |||
214 | struct usb_ctrlrequest local_setup_buff; | ||
215 | struct langwell_dqh *ep_dqh; | ||
216 | size_t ep_dqh_size; | ||
217 | dma_addr_t ep_dqh_dma; | ||
218 | |||
219 | /* ep0 status request */ | ||
220 | struct langwell_request *status_req; | ||
221 | |||
222 | /* dma pool */ | ||
223 | struct dma_pool *dtd_pool; | ||
224 | |||
225 | /* make sure release() is done */ | ||
226 | struct completion *done; | ||
227 | }; | ||
228 | |||
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c index 8cc676ecbb23..1937d8c7b433 100644 --- a/drivers/usb/gadget/pxa27x_udc.c +++ b/drivers/usb/gadget/pxa27x_udc.c | |||
@@ -38,7 +38,6 @@ | |||
38 | #include <linux/usb.h> | 38 | #include <linux/usb.h> |
39 | #include <linux/usb/ch9.h> | 39 | #include <linux/usb/ch9.h> |
40 | #include <linux/usb/gadget.h> | 40 | #include <linux/usb/gadget.h> |
41 | #include <mach/pxa2xx-regs.h> /* FIXME: for PSSR */ | ||
42 | #include <mach/udc.h> | 41 | #include <mach/udc.h> |
43 | 42 | ||
44 | #include "pxa27x_udc.h" | 43 | #include "pxa27x_udc.h" |
@@ -474,6 +473,23 @@ static inline void udc_clear_mask_UDCCR(struct pxa_udc *udc, int mask) | |||
474 | } | 473 | } |
475 | 474 | ||
476 | /** | 475 | /** |
476 | * ep_write_UDCCSR - set bits in UDCCSR | ||
477 | * @udc: udc device | ||
478 | * @mask: bits to set in UDCCR | ||
479 | * | ||
480 | * Sets bits in UDCCSR (UDCCSR0 and UDCCSR*). | ||
481 | * | ||
482 | * A specific case is applied to ep0 : the ACM bit is always set to 1, for | ||
483 | * SET_INTERFACE and SET_CONFIGURATION. | ||
484 | */ | ||
485 | static inline void ep_write_UDCCSR(struct pxa_ep *ep, int mask) | ||
486 | { | ||
487 | if (is_ep0(ep)) | ||
488 | mask |= UDCCSR0_ACM; | ||
489 | udc_ep_writel(ep, UDCCSR, mask); | ||
490 | } | ||
491 | |||
492 | /** | ||
477 | * ep_count_bytes_remain - get how many bytes in udc endpoint | 493 | * ep_count_bytes_remain - get how many bytes in udc endpoint |
478 | * @ep: udc endpoint | 494 | * @ep: udc endpoint |
479 | * | 495 | * |
@@ -861,7 +877,7 @@ static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req) | |||
861 | *buf++ = udc_ep_readl(ep, UDCDR); | 877 | *buf++ = udc_ep_readl(ep, UDCDR); |
862 | req->req.actual += count; | 878 | req->req.actual += count; |
863 | 879 | ||
864 | udc_ep_writel(ep, UDCCSR, UDCCSR_PC); | 880 | ep_write_UDCCSR(ep, UDCCSR_PC); |
865 | 881 | ||
866 | return count; | 882 | return count; |
867 | } | 883 | } |
@@ -969,12 +985,12 @@ static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req) | |||
969 | if (udccsr & UDCCSR_PC) { | 985 | if (udccsr & UDCCSR_PC) { |
970 | ep_vdbg(ep, "Clearing Transmit Complete, udccsr=%x\n", | 986 | ep_vdbg(ep, "Clearing Transmit Complete, udccsr=%x\n", |
971 | udccsr); | 987 | udccsr); |
972 | udc_ep_writel(ep, UDCCSR, UDCCSR_PC); | 988 | ep_write_UDCCSR(ep, UDCCSR_PC); |
973 | } | 989 | } |
974 | if (udccsr & UDCCSR_TRN) { | 990 | if (udccsr & UDCCSR_TRN) { |
975 | ep_vdbg(ep, "Clearing Underrun on, udccsr=%x\n", | 991 | ep_vdbg(ep, "Clearing Underrun on, udccsr=%x\n", |
976 | udccsr); | 992 | udccsr); |
977 | udc_ep_writel(ep, UDCCSR, UDCCSR_TRN); | 993 | ep_write_UDCCSR(ep, UDCCSR_TRN); |
978 | } | 994 | } |
979 | 995 | ||
980 | count = write_packet(ep, req, max); | 996 | count = write_packet(ep, req, max); |
@@ -996,7 +1012,7 @@ static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req) | |||
996 | } | 1012 | } |
997 | 1013 | ||
998 | if (is_short) | 1014 | if (is_short) |
999 | udc_ep_writel(ep, UDCCSR, UDCCSR_SP); | 1015 | ep_write_UDCCSR(ep, UDCCSR_SP); |
1000 | 1016 | ||
1001 | /* requests complete when all IN data is in the FIFO */ | 1017 | /* requests complete when all IN data is in the FIFO */ |
1002 | if (is_last) { | 1018 | if (is_last) { |
@@ -1029,7 +1045,7 @@ static int read_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req) | |||
1029 | 1045 | ||
1030 | while (epout_has_pkt(ep)) { | 1046 | while (epout_has_pkt(ep)) { |
1031 | count = read_packet(ep, req); | 1047 | count = read_packet(ep, req); |
1032 | udc_ep_writel(ep, UDCCSR, UDCCSR0_OPC); | 1048 | ep_write_UDCCSR(ep, UDCCSR0_OPC); |
1033 | inc_ep_stats_bytes(ep, count, !USB_DIR_IN); | 1049 | inc_ep_stats_bytes(ep, count, !USB_DIR_IN); |
1034 | 1050 | ||
1035 | is_short = (count < ep->fifo_size); | 1051 | is_short = (count < ep->fifo_size); |
@@ -1074,7 +1090,7 @@ static int write_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req) | |||
1074 | 1090 | ||
1075 | /* Sends either a short packet or a 0 length packet */ | 1091 | /* Sends either a short packet or a 0 length packet */ |
1076 | if (unlikely(is_short)) | 1092 | if (unlikely(is_short)) |
1077 | udc_ep_writel(ep, UDCCSR, UDCCSR0_IPR); | 1093 | ep_write_UDCCSR(ep, UDCCSR0_IPR); |
1078 | 1094 | ||
1079 | ep_dbg(ep, "in %d bytes%s%s, %d left, req=%p, udccsr0=0x%03x\n", | 1095 | ep_dbg(ep, "in %d bytes%s%s, %d left, req=%p, udccsr0=0x%03x\n", |
1080 | count, is_short ? "/S" : "", is_last ? "/L" : "", | 1096 | count, is_short ? "/S" : "", is_last ? "/L" : "", |
@@ -1277,7 +1293,7 @@ static int pxa_ep_set_halt(struct usb_ep *_ep, int value) | |||
1277 | 1293 | ||
1278 | /* FST, FEF bits are the same for control and non control endpoints */ | 1294 | /* FST, FEF bits are the same for control and non control endpoints */ |
1279 | rc = 0; | 1295 | rc = 0; |
1280 | udc_ep_writel(ep, UDCCSR, UDCCSR_FST | UDCCSR_FEF); | 1296 | ep_write_UDCCSR(ep, UDCCSR_FST | UDCCSR_FEF); |
1281 | if (is_ep0(ep)) | 1297 | if (is_ep0(ep)) |
1282 | set_ep0state(ep->dev, STALL); | 1298 | set_ep0state(ep->dev, STALL); |
1283 | 1299 | ||
@@ -1343,7 +1359,7 @@ static void pxa_ep_fifo_flush(struct usb_ep *_ep) | |||
1343 | udc_ep_readl(ep, UDCDR); | 1359 | udc_ep_readl(ep, UDCDR); |
1344 | } else { | 1360 | } else { |
1345 | /* most IN status is the same, but ISO can't stall */ | 1361 | /* most IN status is the same, but ISO can't stall */ |
1346 | udc_ep_writel(ep, UDCCSR, | 1362 | ep_write_UDCCSR(ep, |
1347 | UDCCSR_PC | UDCCSR_FEF | UDCCSR_TRN | 1363 | UDCCSR_PC | UDCCSR_FEF | UDCCSR_TRN |
1348 | | (EPXFERTYPE_is_ISO(ep) ? 0 : UDCCSR_SST)); | 1364 | | (EPXFERTYPE_is_ISO(ep) ? 0 : UDCCSR_SST)); |
1349 | } | 1365 | } |
@@ -1728,6 +1744,7 @@ static void udc_enable(struct pxa_udc *udc) | |||
1728 | memset(&udc->stats, 0, sizeof(udc->stats)); | 1744 | memset(&udc->stats, 0, sizeof(udc->stats)); |
1729 | 1745 | ||
1730 | udc_set_mask_UDCCR(udc, UDCCR_UDE); | 1746 | udc_set_mask_UDCCR(udc, UDCCR_UDE); |
1747 | ep_write_UDCCSR(&udc->pxa_ep[0], UDCCSR0_ACM); | ||
1731 | udelay(2); | 1748 | udelay(2); |
1732 | if (udc_readl(udc, UDCCR) & UDCCR_EMCE) | 1749 | if (udc_readl(udc, UDCCR) & UDCCR_EMCE) |
1733 | dev_err(udc->dev, "Configuration errors, udc disabled\n"); | 1750 | dev_err(udc->dev, "Configuration errors, udc disabled\n"); |
@@ -1893,6 +1910,15 @@ static void handle_ep0_ctrl_req(struct pxa_udc *udc, | |||
1893 | 1910 | ||
1894 | nuke(ep, -EPROTO); | 1911 | nuke(ep, -EPROTO); |
1895 | 1912 | ||
1913 | /* | ||
1914 | * In the PXA320 manual, in the section about Back-to-Back setup | ||
1915 | * packets, it describes this situation. The solution is to set OPC to | ||
1916 | * get rid of the status packet, and then continue with the setup | ||
1917 | * packet. Generalize to pxa27x CPUs. | ||
1918 | */ | ||
1919 | if (epout_has_pkt(ep) && (ep_count_bytes_remain(ep) == 0)) | ||
1920 | ep_write_UDCCSR(ep, UDCCSR0_OPC); | ||
1921 | |||
1896 | /* read SETUP packet */ | 1922 | /* read SETUP packet */ |
1897 | for (i = 0; i < 2; i++) { | 1923 | for (i = 0; i < 2; i++) { |
1898 | if (unlikely(ep_is_empty(ep))) | 1924 | if (unlikely(ep_is_empty(ep))) |
@@ -1919,7 +1945,7 @@ static void handle_ep0_ctrl_req(struct pxa_udc *udc, | |||
1919 | set_ep0state(udc, OUT_DATA_STAGE); | 1945 | set_ep0state(udc, OUT_DATA_STAGE); |
1920 | 1946 | ||
1921 | /* Tell UDC to enter Data Stage */ | 1947 | /* Tell UDC to enter Data Stage */ |
1922 | udc_ep_writel(ep, UDCCSR, UDCCSR0_SA | UDCCSR0_OPC); | 1948 | ep_write_UDCCSR(ep, UDCCSR0_SA | UDCCSR0_OPC); |
1923 | 1949 | ||
1924 | i = udc->driver->setup(&udc->gadget, &u.r); | 1950 | i = udc->driver->setup(&udc->gadget, &u.r); |
1925 | if (i < 0) | 1951 | if (i < 0) |
@@ -1929,7 +1955,7 @@ out: | |||
1929 | stall: | 1955 | stall: |
1930 | ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n", | 1956 | ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n", |
1931 | udc_ep_readl(ep, UDCCSR), i); | 1957 | udc_ep_readl(ep, UDCCSR), i); |
1932 | udc_ep_writel(ep, UDCCSR, UDCCSR0_FST | UDCCSR0_FTF); | 1958 | ep_write_UDCCSR(ep, UDCCSR0_FST | UDCCSR0_FTF); |
1933 | set_ep0state(udc, STALL); | 1959 | set_ep0state(udc, STALL); |
1934 | goto out; | 1960 | goto out; |
1935 | } | 1961 | } |
@@ -1966,6 +1992,8 @@ stall: | |||
1966 | * cleared by software. | 1992 | * cleared by software. |
1967 | * - clearing UDCCSR0_OPC always flushes ep0. If in setup stage, never do it | 1993 | * - clearing UDCCSR0_OPC always flushes ep0. If in setup stage, never do it |
1968 | * before reading ep0. | 1994 | * before reading ep0. |
1995 | * This is true only for PXA27x. This is not true anymore for PXA3xx family | ||
1996 | * (check Back-to-Back setup packet in developers guide). | ||
1969 | * - irq can be called on a "packet complete" event (opc_irq=1), while | 1997 | * - irq can be called on a "packet complete" event (opc_irq=1), while |
1970 | * UDCCSR0_OPC is not yet raised (delta can be as big as 100ms | 1998 | * UDCCSR0_OPC is not yet raised (delta can be as big as 100ms |
1971 | * from experimentation). | 1999 | * from experimentation). |
@@ -1998,7 +2026,7 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq) | |||
1998 | if (udccsr0 & UDCCSR0_SST) { | 2026 | if (udccsr0 & UDCCSR0_SST) { |
1999 | ep_dbg(ep, "clearing stall status\n"); | 2027 | ep_dbg(ep, "clearing stall status\n"); |
2000 | nuke(ep, -EPIPE); | 2028 | nuke(ep, -EPIPE); |
2001 | udc_ep_writel(ep, UDCCSR, UDCCSR0_SST); | 2029 | ep_write_UDCCSR(ep, UDCCSR0_SST); |
2002 | ep0_idle(udc); | 2030 | ep0_idle(udc); |
2003 | } | 2031 | } |
2004 | 2032 | ||
@@ -2023,7 +2051,7 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq) | |||
2023 | break; | 2051 | break; |
2024 | case IN_DATA_STAGE: /* GET_DESCRIPTOR */ | 2052 | case IN_DATA_STAGE: /* GET_DESCRIPTOR */ |
2025 | if (epout_has_pkt(ep)) | 2053 | if (epout_has_pkt(ep)) |
2026 | udc_ep_writel(ep, UDCCSR, UDCCSR0_OPC); | 2054 | ep_write_UDCCSR(ep, UDCCSR0_OPC); |
2027 | if (req && !ep_is_full(ep)) | 2055 | if (req && !ep_is_full(ep)) |
2028 | completed = write_ep0_fifo(ep, req); | 2056 | completed = write_ep0_fifo(ep, req); |
2029 | if (completed) | 2057 | if (completed) |
@@ -2036,7 +2064,7 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq) | |||
2036 | ep0_end_out_req(ep, req); | 2064 | ep0_end_out_req(ep, req); |
2037 | break; | 2065 | break; |
2038 | case STALL: | 2066 | case STALL: |
2039 | udc_ep_writel(ep, UDCCSR, UDCCSR0_FST); | 2067 | ep_write_UDCCSR(ep, UDCCSR0_FST); |
2040 | break; | 2068 | break; |
2041 | case IN_STATUS_STAGE: | 2069 | case IN_STATUS_STAGE: |
2042 | /* | 2070 | /* |
@@ -2131,6 +2159,7 @@ static void pxa27x_change_configuration(struct pxa_udc *udc, int config) | |||
2131 | 2159 | ||
2132 | set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF); | 2160 | set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF); |
2133 | udc->driver->setup(&udc->gadget, &req); | 2161 | udc->driver->setup(&udc->gadget, &req); |
2162 | ep_write_UDCCSR(&udc->pxa_ep[0], UDCCSR0_AREN); | ||
2134 | } | 2163 | } |
2135 | 2164 | ||
2136 | /** | 2165 | /** |
@@ -2159,6 +2188,7 @@ static void pxa27x_change_interface(struct pxa_udc *udc, int iface, int alt) | |||
2159 | 2188 | ||
2160 | set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF); | 2189 | set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF); |
2161 | udc->driver->setup(&udc->gadget, &req); | 2190 | udc->driver->setup(&udc->gadget, &req); |
2191 | ep_write_UDCCSR(&udc->pxa_ep[0], UDCCSR0_AREN); | ||
2162 | } | 2192 | } |
2163 | 2193 | ||
2164 | /* | 2194 | /* |
@@ -2280,7 +2310,7 @@ static void irq_udc_reset(struct pxa_udc *udc) | |||
2280 | memset(&udc->stats, 0, sizeof udc->stats); | 2310 | memset(&udc->stats, 0, sizeof udc->stats); |
2281 | 2311 | ||
2282 | nuke(ep, -EPROTO); | 2312 | nuke(ep, -EPROTO); |
2283 | udc_ep_writel(ep, UDCCSR, UDCCSR0_FTF | UDCCSR0_OPC); | 2313 | ep_write_UDCCSR(ep, UDCCSR0_FTF | UDCCSR0_OPC); |
2284 | ep0_idle(udc); | 2314 | ep0_idle(udc); |
2285 | } | 2315 | } |
2286 | 2316 | ||
@@ -2479,6 +2509,12 @@ static void pxa_udc_shutdown(struct platform_device *_dev) | |||
2479 | udc_disable(udc); | 2509 | udc_disable(udc); |
2480 | } | 2510 | } |
2481 | 2511 | ||
2512 | #ifdef CONFIG_CPU_PXA27x | ||
2513 | extern void pxa27x_clear_otgph(void); | ||
2514 | #else | ||
2515 | #define pxa27x_clear_otgph() do {} while (0) | ||
2516 | #endif | ||
2517 | |||
2482 | #ifdef CONFIG_PM | 2518 | #ifdef CONFIG_PM |
2483 | /** | 2519 | /** |
2484 | * pxa_udc_suspend - Suspend udc device | 2520 | * pxa_udc_suspend - Suspend udc device |
@@ -2546,8 +2582,7 @@ static int pxa_udc_resume(struct platform_device *_dev) | |||
2546 | * Software must configure the USB OTG pad, UDC, and UHC | 2582 | * Software must configure the USB OTG pad, UDC, and UHC |
2547 | * to the state they were in before entering sleep mode. | 2583 | * to the state they were in before entering sleep mode. |
2548 | */ | 2584 | */ |
2549 | if (cpu_is_pxa27x()) | 2585 | pxa27x_clear_otgph(); |
2550 | PSSR |= PSSR_OTGPH; | ||
2551 | 2586 | ||
2552 | return 0; | 2587 | return 0; |
2553 | } | 2588 | } |
@@ -2571,7 +2606,7 @@ static struct platform_driver udc_driver = { | |||
2571 | 2606 | ||
2572 | static int __init udc_init(void) | 2607 | static int __init udc_init(void) |
2573 | { | 2608 | { |
2574 | if (!cpu_is_pxa27x()) | 2609 | if (!cpu_is_pxa27x() && !cpu_is_pxa3xx()) |
2575 | return -ENODEV; | 2610 | return -ENODEV; |
2576 | 2611 | ||
2577 | printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION); | 2612 | printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION); |
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h index db58125331da..e25225e26586 100644 --- a/drivers/usb/gadget/pxa27x_udc.h +++ b/drivers/usb/gadget/pxa27x_udc.h | |||
@@ -130,6 +130,8 @@ | |||
130 | #define UP2OCR_HXOE (1 << 17) /* Transceiver Output Enable */ | 130 | #define UP2OCR_HXOE (1 << 17) /* Transceiver Output Enable */ |
131 | #define UP2OCR_SEOS (1 << 24) /* Single-Ended Output Select */ | 131 | #define UP2OCR_SEOS (1 << 24) /* Single-Ended Output Select */ |
132 | 132 | ||
133 | #define UDCCSR0_ACM (1 << 9) /* Ack Control Mode */ | ||
134 | #define UDCCSR0_AREN (1 << 8) /* Ack Response Enable */ | ||
133 | #define UDCCSR0_SA (1 << 7) /* Setup Active */ | 135 | #define UDCCSR0_SA (1 << 7) /* Setup Active */ |
134 | #define UDCCSR0_RNE (1 << 6) /* Receive FIFO Not Empty */ | 136 | #define UDCCSR0_RNE (1 << 6) /* Receive FIFO Not Empty */ |
135 | #define UDCCSR0_FST (1 << 5) /* Force Stall */ | 137 | #define UDCCSR0_FST (1 << 5) /* Force Stall */ |
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c new file mode 100644 index 000000000000..50c71aae2cc2 --- /dev/null +++ b/drivers/usb/gadget/s3c-hsotg.c | |||
@@ -0,0 +1,3269 @@ | |||
1 | /* linux/drivers/usb/gadget/s3c-hsotg.c | ||
2 | * | ||
3 | * Copyright 2008 Openmoko, Inc. | ||
4 | * Copyright 2008 Simtec Electronics | ||
5 | * Ben Dooks <ben@simtec.co.uk> | ||
6 | * http://armlinux.simtec.co.uk/ | ||
7 | * | ||
8 | * S3C USB2.0 High-speed / OtG driver | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License version 2 as | ||
12 | * published by the Free Software Foundation. | ||
13 | */ | ||
14 | |||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/module.h> | ||
17 | #include <linux/spinlock.h> | ||
18 | #include <linux/interrupt.h> | ||
19 | #include <linux/platform_device.h> | ||
20 | #include <linux/dma-mapping.h> | ||
21 | #include <linux/debugfs.h> | ||
22 | #include <linux/seq_file.h> | ||
23 | #include <linux/delay.h> | ||
24 | #include <linux/io.h> | ||
25 | |||
26 | #include <linux/usb/ch9.h> | ||
27 | #include <linux/usb/gadget.h> | ||
28 | |||
29 | #include <mach/map.h> | ||
30 | |||
31 | #include <plat/regs-usb-hsotg-phy.h> | ||
32 | #include <plat/regs-usb-hsotg.h> | ||
33 | #include <plat/regs-sys.h> | ||
34 | #include <plat/udc-hs.h> | ||
35 | |||
36 | #define DMA_ADDR_INVALID (~((dma_addr_t)0)) | ||
37 | |||
38 | /* EP0_MPS_LIMIT | ||
39 | * | ||
40 | * Unfortunately there seems to be a limit of the amount of data that can | ||
41 | * be transfered by IN transactions on EP0. This is either 127 bytes or 3 | ||
42 | * packets (which practially means 1 packet and 63 bytes of data) when the | ||
43 | * MPS is set to 64. | ||
44 | * | ||
45 | * This means if we are wanting to move >127 bytes of data, we need to | ||
46 | * split the transactions up, but just doing one packet at a time does | ||
47 | * not work (this may be an implicit DATA0 PID on first packet of the | ||
48 | * transaction) and doing 2 packets is outside the controller's limits. | ||
49 | * | ||
50 | * If we try to lower the MPS size for EP0, then no transfers work properly | ||
51 | * for EP0, and the system will fail basic enumeration. As no cause for this | ||
52 | * has currently been found, we cannot support any large IN transfers for | ||
53 | * EP0. | ||
54 | */ | ||
55 | #define EP0_MPS_LIMIT 64 | ||
56 | |||
57 | struct s3c_hsotg; | ||
58 | struct s3c_hsotg_req; | ||
59 | |||
60 | /** | ||
61 | * struct s3c_hsotg_ep - driver endpoint definition. | ||
62 | * @ep: The gadget layer representation of the endpoint. | ||
63 | * @name: The driver generated name for the endpoint. | ||
64 | * @queue: Queue of requests for this endpoint. | ||
65 | * @parent: Reference back to the parent device structure. | ||
66 | * @req: The current request that the endpoint is processing. This is | ||
67 | * used to indicate an request has been loaded onto the endpoint | ||
68 | * and has yet to be completed (maybe due to data move, or simply | ||
69 | * awaiting an ack from the core all the data has been completed). | ||
70 | * @debugfs: File entry for debugfs file for this endpoint. | ||
71 | * @lock: State lock to protect contents of endpoint. | ||
72 | * @dir_in: Set to true if this endpoint is of the IN direction, which | ||
73 | * means that it is sending data to the Host. | ||
74 | * @index: The index for the endpoint registers. | ||
75 | * @name: The name array passed to the USB core. | ||
76 | * @halted: Set if the endpoint has been halted. | ||
77 | * @periodic: Set if this is a periodic ep, such as Interrupt | ||
78 | * @sent_zlp: Set if we've sent a zero-length packet. | ||
79 | * @total_data: The total number of data bytes done. | ||
80 | * @fifo_size: The size of the FIFO (for periodic IN endpoints) | ||
81 | * @fifo_load: The amount of data loaded into the FIFO (periodic IN) | ||
82 | * @last_load: The offset of data for the last start of request. | ||
83 | * @size_loaded: The last loaded size for DxEPTSIZE for periodic IN | ||
84 | * | ||
85 | * This is the driver's state for each registered enpoint, allowing it | ||
86 | * to keep track of transactions that need doing. Each endpoint has a | ||
87 | * lock to protect the state, to try and avoid using an overall lock | ||
88 | * for the host controller as much as possible. | ||
89 | * | ||
90 | * For periodic IN endpoints, we have fifo_size and fifo_load to try | ||
91 | * and keep track of the amount of data in the periodic FIFO for each | ||
92 | * of these as we don't have a status register that tells us how much | ||
93 | * is in each of them. | ||
94 | */ | ||
95 | struct s3c_hsotg_ep { | ||
96 | struct usb_ep ep; | ||
97 | struct list_head queue; | ||
98 | struct s3c_hsotg *parent; | ||
99 | struct s3c_hsotg_req *req; | ||
100 | struct dentry *debugfs; | ||
101 | |||
102 | spinlock_t lock; | ||
103 | |||
104 | unsigned long total_data; | ||
105 | unsigned int size_loaded; | ||
106 | unsigned int last_load; | ||
107 | unsigned int fifo_load; | ||
108 | unsigned short fifo_size; | ||
109 | |||
110 | unsigned char dir_in; | ||
111 | unsigned char index; | ||
112 | |||
113 | unsigned int halted:1; | ||
114 | unsigned int periodic:1; | ||
115 | unsigned int sent_zlp:1; | ||
116 | |||
117 | char name[10]; | ||
118 | }; | ||
119 | |||
120 | #define S3C_HSOTG_EPS (8+1) /* limit to 9 for the moment */ | ||
121 | |||
122 | /** | ||
123 | * struct s3c_hsotg - driver state. | ||
124 | * @dev: The parent device supplied to the probe function | ||
125 | * @driver: USB gadget driver | ||
126 | * @plat: The platform specific configuration data. | ||
127 | * @regs: The memory area mapped for accessing registers. | ||
128 | * @regs_res: The resource that was allocated when claiming register space. | ||
129 | * @irq: The IRQ number we are using | ||
130 | * @debug_root: root directrory for debugfs. | ||
131 | * @debug_file: main status file for debugfs. | ||
132 | * @debug_fifo: FIFO status file for debugfs. | ||
133 | * @ep0_reply: Request used for ep0 reply. | ||
134 | * @ep0_buff: Buffer for EP0 reply data, if needed. | ||
135 | * @ctrl_buff: Buffer for EP0 control requests. | ||
136 | * @ctrl_req: Request for EP0 control packets. | ||
137 | * @eps: The endpoints being supplied to the gadget framework | ||
138 | */ | ||
139 | struct s3c_hsotg { | ||
140 | struct device *dev; | ||
141 | struct usb_gadget_driver *driver; | ||
142 | struct s3c_hsotg_plat *plat; | ||
143 | |||
144 | void __iomem *regs; | ||
145 | struct resource *regs_res; | ||
146 | int irq; | ||
147 | |||
148 | struct dentry *debug_root; | ||
149 | struct dentry *debug_file; | ||
150 | struct dentry *debug_fifo; | ||
151 | |||
152 | struct usb_request *ep0_reply; | ||
153 | struct usb_request *ctrl_req; | ||
154 | u8 ep0_buff[8]; | ||
155 | u8 ctrl_buff[8]; | ||
156 | |||
157 | struct usb_gadget gadget; | ||
158 | struct s3c_hsotg_ep eps[]; | ||
159 | }; | ||
160 | |||
161 | /** | ||
162 | * struct s3c_hsotg_req - data transfer request | ||
163 | * @req: The USB gadget request | ||
164 | * @queue: The list of requests for the endpoint this is queued for. | ||
165 | * @in_progress: Has already had size/packets written to core | ||
166 | * @mapped: DMA buffer for this request has been mapped via dma_map_single(). | ||
167 | */ | ||
168 | struct s3c_hsotg_req { | ||
169 | struct usb_request req; | ||
170 | struct list_head queue; | ||
171 | unsigned char in_progress; | ||
172 | unsigned char mapped; | ||
173 | }; | ||
174 | |||
175 | /* conversion functions */ | ||
176 | static inline struct s3c_hsotg_req *our_req(struct usb_request *req) | ||
177 | { | ||
178 | return container_of(req, struct s3c_hsotg_req, req); | ||
179 | } | ||
180 | |||
181 | static inline struct s3c_hsotg_ep *our_ep(struct usb_ep *ep) | ||
182 | { | ||
183 | return container_of(ep, struct s3c_hsotg_ep, ep); | ||
184 | } | ||
185 | |||
186 | static inline struct s3c_hsotg *to_hsotg(struct usb_gadget *gadget) | ||
187 | { | ||
188 | return container_of(gadget, struct s3c_hsotg, gadget); | ||
189 | } | ||
190 | |||
191 | static inline void __orr32(void __iomem *ptr, u32 val) | ||
192 | { | ||
193 | writel(readl(ptr) | val, ptr); | ||
194 | } | ||
195 | |||
196 | static inline void __bic32(void __iomem *ptr, u32 val) | ||
197 | { | ||
198 | writel(readl(ptr) & ~val, ptr); | ||
199 | } | ||
200 | |||
201 | /* forward decleration of functions */ | ||
202 | static void s3c_hsotg_dump(struct s3c_hsotg *hsotg); | ||
203 | |||
204 | /** | ||
205 | * using_dma - return the DMA status of the driver. | ||
206 | * @hsotg: The driver state. | ||
207 | * | ||
208 | * Return true if we're using DMA. | ||
209 | * | ||
210 | * Currently, we have the DMA support code worked into everywhere | ||
211 | * that needs it, but the AMBA DMA implementation in the hardware can | ||
212 | * only DMA from 32bit aligned addresses. This means that gadgets such | ||
213 | * as the CDC Ethernet cannot work as they often pass packets which are | ||
214 | * not 32bit aligned. | ||
215 | * | ||
216 | * Unfortunately the choice to use DMA or not is global to the controller | ||
217 | * and seems to be only settable when the controller is being put through | ||
218 | * a core reset. This means we either need to fix the gadgets to take | ||
219 | * account of DMA alignment, or add bounce buffers (yuerk). | ||
220 | * | ||
221 | * Until this issue is sorted out, we always return 'false'. | ||
222 | */ | ||
223 | static inline bool using_dma(struct s3c_hsotg *hsotg) | ||
224 | { | ||
225 | return false; /* support is not complete */ | ||
226 | } | ||
227 | |||
228 | /** | ||
229 | * s3c_hsotg_en_gsint - enable one or more of the general interrupt | ||
230 | * @hsotg: The device state | ||
231 | * @ints: A bitmask of the interrupts to enable | ||
232 | */ | ||
233 | static void s3c_hsotg_en_gsint(struct s3c_hsotg *hsotg, u32 ints) | ||
234 | { | ||
235 | u32 gsintmsk = readl(hsotg->regs + S3C_GINTMSK); | ||
236 | u32 new_gsintmsk; | ||
237 | |||
238 | new_gsintmsk = gsintmsk | ints; | ||
239 | |||
240 | if (new_gsintmsk != gsintmsk) { | ||
241 | dev_dbg(hsotg->dev, "gsintmsk now 0x%08x\n", new_gsintmsk); | ||
242 | writel(new_gsintmsk, hsotg->regs + S3C_GINTMSK); | ||
243 | } | ||
244 | } | ||
245 | |||
246 | /** | ||
247 | * s3c_hsotg_disable_gsint - disable one or more of the general interrupt | ||
248 | * @hsotg: The device state | ||
249 | * @ints: A bitmask of the interrupts to enable | ||
250 | */ | ||
251 | static void s3c_hsotg_disable_gsint(struct s3c_hsotg *hsotg, u32 ints) | ||
252 | { | ||
253 | u32 gsintmsk = readl(hsotg->regs + S3C_GINTMSK); | ||
254 | u32 new_gsintmsk; | ||
255 | |||
256 | new_gsintmsk = gsintmsk & ~ints; | ||
257 | |||
258 | if (new_gsintmsk != gsintmsk) | ||
259 | writel(new_gsintmsk, hsotg->regs + S3C_GINTMSK); | ||
260 | } | ||
261 | |||
262 | /** | ||
263 | * s3c_hsotg_ctrl_epint - enable/disable an endpoint irq | ||
264 | * @hsotg: The device state | ||
265 | * @ep: The endpoint index | ||
266 | * @dir_in: True if direction is in. | ||
267 | * @en: The enable value, true to enable | ||
268 | * | ||
269 | * Set or clear the mask for an individual endpoint's interrupt | ||
270 | * request. | ||
271 | */ | ||
272 | static void s3c_hsotg_ctrl_epint(struct s3c_hsotg *hsotg, | ||
273 | unsigned int ep, unsigned int dir_in, | ||
274 | unsigned int en) | ||
275 | { | ||
276 | unsigned long flags; | ||
277 | u32 bit = 1 << ep; | ||
278 | u32 daint; | ||
279 | |||
280 | if (!dir_in) | ||
281 | bit <<= 16; | ||
282 | |||
283 | local_irq_save(flags); | ||
284 | daint = readl(hsotg->regs + S3C_DAINTMSK); | ||
285 | if (en) | ||
286 | daint |= bit; | ||
287 | else | ||
288 | daint &= ~bit; | ||
289 | writel(daint, hsotg->regs + S3C_DAINTMSK); | ||
290 | local_irq_restore(flags); | ||
291 | } | ||
292 | |||
293 | /** | ||
294 | * s3c_hsotg_init_fifo - initialise non-periodic FIFOs | ||
295 | * @hsotg: The device instance. | ||
296 | */ | ||
297 | static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg) | ||
298 | { | ||
299 | /* the ryu 2.6.24 release ahs | ||
300 | writel(0x1C0, hsotg->regs + S3C_GRXFSIZ); | ||
301 | writel(S3C_GNPTXFSIZ_NPTxFStAddr(0x200) | | ||
302 | S3C_GNPTXFSIZ_NPTxFDep(0x1C0), | ||
303 | hsotg->regs + S3C_GNPTXFSIZ); | ||
304 | */ | ||
305 | |||
306 | /* set FIFO sizes to 2048/0x1C0 */ | ||
307 | |||
308 | writel(2048, hsotg->regs + S3C_GRXFSIZ); | ||
309 | writel(S3C_GNPTXFSIZ_NPTxFStAddr(2048) | | ||
310 | S3C_GNPTXFSIZ_NPTxFDep(0x1C0), | ||
311 | hsotg->regs + S3C_GNPTXFSIZ); | ||
312 | } | ||
313 | |||
314 | /** | ||
315 | * @ep: USB endpoint to allocate request for. | ||
316 | * @flags: Allocation flags | ||
317 | * | ||
318 | * Allocate a new USB request structure appropriate for the specified endpoint | ||
319 | */ | ||
320 | struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep, gfp_t flags) | ||
321 | { | ||
322 | struct s3c_hsotg_req *req; | ||
323 | |||
324 | req = kzalloc(sizeof(struct s3c_hsotg_req), flags); | ||
325 | if (!req) | ||
326 | return NULL; | ||
327 | |||
328 | INIT_LIST_HEAD(&req->queue); | ||
329 | |||
330 | req->req.dma = DMA_ADDR_INVALID; | ||
331 | return &req->req; | ||
332 | } | ||
333 | |||
334 | /** | ||
335 | * is_ep_periodic - return true if the endpoint is in periodic mode. | ||
336 | * @hs_ep: The endpoint to query. | ||
337 | * | ||
338 | * Returns true if the endpoint is in periodic mode, meaning it is being | ||
339 | * used for an Interrupt or ISO transfer. | ||
340 | */ | ||
341 | static inline int is_ep_periodic(struct s3c_hsotg_ep *hs_ep) | ||
342 | { | ||
343 | return hs_ep->periodic; | ||
344 | } | ||
345 | |||
346 | /** | ||
347 | * s3c_hsotg_unmap_dma - unmap the DMA memory being used for the request | ||
348 | * @hsotg: The device state. | ||
349 | * @hs_ep: The endpoint for the request | ||
350 | * @hs_req: The request being processed. | ||
351 | * | ||
352 | * This is the reverse of s3c_hsotg_map_dma(), called for the completion | ||
353 | * of a request to ensure the buffer is ready for access by the caller. | ||
354 | */ | ||
355 | static void s3c_hsotg_unmap_dma(struct s3c_hsotg *hsotg, | ||
356 | struct s3c_hsotg_ep *hs_ep, | ||
357 | struct s3c_hsotg_req *hs_req) | ||
358 | { | ||
359 | struct usb_request *req = &hs_req->req; | ||
360 | enum dma_data_direction dir; | ||
361 | |||
362 | dir = hs_ep->dir_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE; | ||
363 | |||
364 | /* ignore this if we're not moving any data */ | ||
365 | if (hs_req->req.length == 0) | ||
366 | return; | ||
367 | |||
368 | if (hs_req->mapped) { | ||
369 | /* we mapped this, so unmap and remove the dma */ | ||
370 | |||
371 | dma_unmap_single(hsotg->dev, req->dma, req->length, dir); | ||
372 | |||
373 | req->dma = DMA_ADDR_INVALID; | ||
374 | hs_req->mapped = 0; | ||
375 | } else { | ||
376 | dma_sync_single(hsotg->dev, req->dma, req->length, dir); | ||
377 | } | ||
378 | } | ||
379 | |||
380 | /** | ||
381 | * s3c_hsotg_write_fifo - write packet Data to the TxFIFO | ||
382 | * @hsotg: The controller state. | ||
383 | * @hs_ep: The endpoint we're going to write for. | ||
384 | * @hs_req: The request to write data for. | ||
385 | * | ||
386 | * This is called when the TxFIFO has some space in it to hold a new | ||
387 | * transmission and we have something to give it. The actual setup of | ||
388 | * the data size is done elsewhere, so all we have to do is to actually | ||
389 | * write the data. | ||
390 | * | ||
391 | * The return value is zero if there is more space (or nothing was done) | ||
392 | * otherwise -ENOSPC is returned if the FIFO space was used up. | ||
393 | * | ||
394 | * This routine is only needed for PIO | ||
395 | */ | ||
396 | static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg, | ||
397 | struct s3c_hsotg_ep *hs_ep, | ||
398 | struct s3c_hsotg_req *hs_req) | ||
399 | { | ||
400 | bool periodic = is_ep_periodic(hs_ep); | ||
401 | u32 gnptxsts = readl(hsotg->regs + S3C_GNPTXSTS); | ||
402 | int buf_pos = hs_req->req.actual; | ||
403 | int to_write = hs_ep->size_loaded; | ||
404 | void *data; | ||
405 | int can_write; | ||
406 | int pkt_round; | ||
407 | |||
408 | to_write -= (buf_pos - hs_ep->last_load); | ||
409 | |||
410 | /* if there's nothing to write, get out early */ | ||
411 | if (to_write == 0) | ||
412 | return 0; | ||
413 | |||
414 | if (periodic) { | ||
415 | u32 epsize = readl(hsotg->regs + S3C_DIEPTSIZ(hs_ep->index)); | ||
416 | int size_left; | ||
417 | int size_done; | ||
418 | |||
419 | /* work out how much data was loaded so we can calculate | ||
420 | * how much data is left in the fifo. */ | ||
421 | |||
422 | size_left = S3C_DxEPTSIZ_XferSize_GET(epsize); | ||
423 | |||
424 | dev_dbg(hsotg->dev, "%s: left=%d, load=%d, fifo=%d, size %d\n", | ||
425 | __func__, size_left, | ||
426 | hs_ep->size_loaded, hs_ep->fifo_load, hs_ep->fifo_size); | ||
427 | |||
428 | /* how much of the data has moved */ | ||
429 | size_done = hs_ep->size_loaded - size_left; | ||
430 | |||
431 | /* how much data is left in the fifo */ | ||
432 | can_write = hs_ep->fifo_load - size_done; | ||
433 | dev_dbg(hsotg->dev, "%s: => can_write1=%d\n", | ||
434 | __func__, can_write); | ||
435 | |||
436 | can_write = hs_ep->fifo_size - can_write; | ||
437 | dev_dbg(hsotg->dev, "%s: => can_write2=%d\n", | ||
438 | __func__, can_write); | ||
439 | |||
440 | if (can_write <= 0) { | ||
441 | s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_PTxFEmp); | ||
442 | return -ENOSPC; | ||
443 | } | ||
444 | } else { | ||
445 | if (S3C_GNPTXSTS_NPTxQSpcAvail_GET(gnptxsts) == 0) { | ||
446 | dev_dbg(hsotg->dev, | ||
447 | "%s: no queue slots available (0x%08x)\n", | ||
448 | __func__, gnptxsts); | ||
449 | |||
450 | s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_NPTxFEmp); | ||
451 | return -ENOSPC; | ||
452 | } | ||
453 | |||
454 | can_write = S3C_GNPTXSTS_NPTxFSpcAvail_GET(gnptxsts); | ||
455 | } | ||
456 | |||
457 | dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, mps %d\n", | ||
458 | __func__, gnptxsts, can_write, to_write, hs_ep->ep.maxpacket); | ||
459 | |||
460 | /* limit to 512 bytes of data, it seems at least on the non-periodic | ||
461 | * FIFO, requests of >512 cause the endpoint to get stuck with a | ||
462 | * fragment of the end of the transfer in it. | ||
463 | */ | ||
464 | if (can_write > 512) | ||
465 | can_write = 512; | ||
466 | |||
467 | /* see if we can write data */ | ||
468 | |||
469 | if (to_write > can_write) { | ||
470 | to_write = can_write; | ||
471 | pkt_round = to_write % hs_ep->ep.maxpacket; | ||
472 | |||
473 | /* Not sure, but we probably shouldn't be writing partial | ||
474 | * packets into the FIFO, so round the write down to an | ||
475 | * exact number of packets. | ||
476 | * | ||
477 | * Note, we do not currently check to see if we can ever | ||
478 | * write a full packet or not to the FIFO. | ||
479 | */ | ||
480 | |||
481 | if (pkt_round) | ||
482 | to_write -= pkt_round; | ||
483 | |||
484 | /* enable correct FIFO interrupt to alert us when there | ||
485 | * is more room left. */ | ||
486 | |||
487 | s3c_hsotg_en_gsint(hsotg, | ||
488 | periodic ? S3C_GINTSTS_PTxFEmp : | ||
489 | S3C_GINTSTS_NPTxFEmp); | ||
490 | } | ||
491 | |||
492 | dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n", | ||
493 | to_write, hs_req->req.length, can_write, buf_pos); | ||
494 | |||
495 | if (to_write <= 0) | ||
496 | return -ENOSPC; | ||
497 | |||
498 | hs_req->req.actual = buf_pos + to_write; | ||
499 | hs_ep->total_data += to_write; | ||
500 | |||
501 | if (periodic) | ||
502 | hs_ep->fifo_load += to_write; | ||
503 | |||
504 | to_write = DIV_ROUND_UP(to_write, 4); | ||
505 | data = hs_req->req.buf + buf_pos; | ||
506 | |||
507 | writesl(hsotg->regs + S3C_EPFIFO(hs_ep->index), data, to_write); | ||
508 | |||
509 | return (to_write >= can_write) ? -ENOSPC : 0; | ||
510 | } | ||
511 | |||
512 | /** | ||
513 | * get_ep_limit - get the maximum data legnth for this endpoint | ||
514 | * @hs_ep: The endpoint | ||
515 | * | ||
516 | * Return the maximum data that can be queued in one go on a given endpoint | ||
517 | * so that transfers that are too long can be split. | ||
518 | */ | ||
519 | static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep) | ||
520 | { | ||
521 | int index = hs_ep->index; | ||
522 | unsigned maxsize; | ||
523 | unsigned maxpkt; | ||
524 | |||
525 | if (index != 0) { | ||
526 | maxsize = S3C_DxEPTSIZ_XferSize_LIMIT + 1; | ||
527 | maxpkt = S3C_DxEPTSIZ_PktCnt_LIMIT + 1; | ||
528 | } else { | ||
529 | if (hs_ep->dir_in) { | ||
530 | /* maxsize = S3C_DIEPTSIZ0_XferSize_LIMIT + 1; */ | ||
531 | maxsize = 64+64+1; | ||
532 | maxpkt = S3C_DIEPTSIZ0_PktCnt_LIMIT + 1; | ||
533 | } else { | ||
534 | maxsize = 0x3f; | ||
535 | maxpkt = 2; | ||
536 | } | ||
537 | } | ||
538 | |||
539 | /* we made the constant loading easier above by using +1 */ | ||
540 | maxpkt--; | ||
541 | maxsize--; | ||
542 | |||
543 | /* constrain by packet count if maxpkts*pktsize is greater | ||
544 | * than the length register size. */ | ||
545 | |||
546 | if ((maxpkt * hs_ep->ep.maxpacket) < maxsize) | ||
547 | maxsize = maxpkt * hs_ep->ep.maxpacket; | ||
548 | |||
549 | return maxsize; | ||
550 | } | ||
551 | |||
552 | /** | ||
553 | * s3c_hsotg_start_req - start a USB request from an endpoint's queue | ||
554 | * @hsotg: The controller state. | ||
555 | * @hs_ep: The endpoint to process a request for | ||
556 | * @hs_req: The request to start. | ||
557 | * @continuing: True if we are doing more for the current request. | ||
558 | * | ||
559 | * Start the given request running by setting the endpoint registers | ||
560 | * appropriately, and writing any data to the FIFOs. | ||
561 | */ | ||
562 | static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg, | ||
563 | struct s3c_hsotg_ep *hs_ep, | ||
564 | struct s3c_hsotg_req *hs_req, | ||
565 | bool continuing) | ||
566 | { | ||
567 | struct usb_request *ureq = &hs_req->req; | ||
568 | int index = hs_ep->index; | ||
569 | int dir_in = hs_ep->dir_in; | ||
570 | u32 epctrl_reg; | ||
571 | u32 epsize_reg; | ||
572 | u32 epsize; | ||
573 | u32 ctrl; | ||
574 | unsigned length; | ||
575 | unsigned packets; | ||
576 | unsigned maxreq; | ||
577 | |||
578 | if (index != 0) { | ||
579 | if (hs_ep->req && !continuing) { | ||
580 | dev_err(hsotg->dev, "%s: active request\n", __func__); | ||
581 | WARN_ON(1); | ||
582 | return; | ||
583 | } else if (hs_ep->req != hs_req && continuing) { | ||
584 | dev_err(hsotg->dev, | ||
585 | "%s: continue different req\n", __func__); | ||
586 | WARN_ON(1); | ||
587 | return; | ||
588 | } | ||
589 | } | ||
590 | |||
591 | epctrl_reg = dir_in ? S3C_DIEPCTL(index) : S3C_DOEPCTL(index); | ||
592 | epsize_reg = dir_in ? S3C_DIEPTSIZ(index) : S3C_DOEPTSIZ(index); | ||
593 | |||
594 | dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x, ep %d, dir %s\n", | ||
595 | __func__, readl(hsotg->regs + epctrl_reg), index, | ||
596 | hs_ep->dir_in ? "in" : "out"); | ||
597 | |||
598 | length = ureq->length - ureq->actual; | ||
599 | |||
600 | if (0) | ||
601 | dev_dbg(hsotg->dev, | ||
602 | "REQ buf %p len %d dma 0x%08x noi=%d zp=%d snok=%d\n", | ||
603 | ureq->buf, length, ureq->dma, | ||
604 | ureq->no_interrupt, ureq->zero, ureq->short_not_ok); | ||
605 | |||
606 | maxreq = get_ep_limit(hs_ep); | ||
607 | if (length > maxreq) { | ||
608 | int round = maxreq % hs_ep->ep.maxpacket; | ||
609 | |||
610 | dev_dbg(hsotg->dev, "%s: length %d, max-req %d, r %d\n", | ||
611 | __func__, length, maxreq, round); | ||
612 | |||
613 | /* round down to multiple of packets */ | ||
614 | if (round) | ||
615 | maxreq -= round; | ||
616 | |||
617 | length = maxreq; | ||
618 | } | ||
619 | |||
620 | if (length) | ||
621 | packets = DIV_ROUND_UP(length, hs_ep->ep.maxpacket); | ||
622 | else | ||
623 | packets = 1; /* send one packet if length is zero. */ | ||
624 | |||
625 | if (dir_in && index != 0) | ||
626 | epsize = S3C_DxEPTSIZ_MC(1); | ||
627 | else | ||
628 | epsize = 0; | ||
629 | |||
630 | if (index != 0 && ureq->zero) { | ||
631 | /* test for the packets being exactly right for the | ||
632 | * transfer */ | ||
633 | |||
634 | if (length == (packets * hs_ep->ep.maxpacket)) | ||
635 | packets++; | ||
636 | } | ||
637 | |||
638 | epsize |= S3C_DxEPTSIZ_PktCnt(packets); | ||
639 | epsize |= S3C_DxEPTSIZ_XferSize(length); | ||
640 | |||
641 | dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n", | ||
642 | __func__, packets, length, ureq->length, epsize, epsize_reg); | ||
643 | |||
644 | /* store the request as the current one we're doing */ | ||
645 | hs_ep->req = hs_req; | ||
646 | |||
647 | /* write size / packets */ | ||
648 | writel(epsize, hsotg->regs + epsize_reg); | ||
649 | |||
650 | ctrl = readl(hsotg->regs + epctrl_reg); | ||
651 | |||
652 | if (ctrl & S3C_DxEPCTL_Stall) { | ||
653 | dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index); | ||
654 | |||
655 | /* not sure what we can do here, if it is EP0 then we should | ||
656 | * get this cleared once the endpoint has transmitted the | ||
657 | * STALL packet, otherwise it needs to be cleared by the | ||
658 | * host. | ||
659 | */ | ||
660 | } | ||
661 | |||
662 | if (using_dma(hsotg)) { | ||
663 | unsigned int dma_reg; | ||
664 | |||
665 | /* write DMA address to control register, buffer already | ||
666 | * synced by s3c_hsotg_ep_queue(). */ | ||
667 | |||
668 | dma_reg = dir_in ? S3C_DIEPDMA(index) : S3C_DOEPDMA(index); | ||
669 | writel(ureq->dma, hsotg->regs + dma_reg); | ||
670 | |||
671 | dev_dbg(hsotg->dev, "%s: 0x%08x => 0x%08x\n", | ||
672 | __func__, ureq->dma, dma_reg); | ||
673 | } | ||
674 | |||
675 | ctrl |= S3C_DxEPCTL_EPEna; /* ensure ep enabled */ | ||
676 | ctrl |= S3C_DxEPCTL_USBActEp; | ||
677 | ctrl |= S3C_DxEPCTL_CNAK; /* clear NAK set by core */ | ||
678 | |||
679 | dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl); | ||
680 | writel(ctrl, hsotg->regs + epctrl_reg); | ||
681 | |||
682 | /* set these, it seems that DMA support increments past the end | ||
683 | * of the packet buffer so we need to calculate the length from | ||
684 | * this information. */ | ||
685 | hs_ep->size_loaded = length; | ||
686 | hs_ep->last_load = ureq->actual; | ||
687 | |||
688 | if (dir_in && !using_dma(hsotg)) { | ||
689 | /* set these anyway, we may need them for non-periodic in */ | ||
690 | hs_ep->fifo_load = 0; | ||
691 | |||
692 | s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req); | ||
693 | } | ||
694 | |||
695 | /* clear the INTknTXFEmpMsk when we start request, more as a aide | ||
696 | * to debugging to see what is going on. */ | ||
697 | if (dir_in) | ||
698 | writel(S3C_DIEPMSK_INTknTXFEmpMsk, | ||
699 | hsotg->regs + S3C_DIEPINT(index)); | ||
700 | |||
701 | /* Note, trying to clear the NAK here causes problems with transmit | ||
702 | * on the S3C6400 ending up with the TXFIFO becomming full. */ | ||
703 | |||
704 | /* check ep is enabled */ | ||
705 | if (!(readl(hsotg->regs + epctrl_reg) & S3C_DxEPCTL_EPEna)) | ||
706 | dev_warn(hsotg->dev, | ||
707 | "ep%d: failed to become enabled (DxEPCTL=0x%08x)?\n", | ||
708 | index, readl(hsotg->regs + epctrl_reg)); | ||
709 | |||
710 | dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", | ||
711 | __func__, readl(hsotg->regs + epctrl_reg)); | ||
712 | } | ||
713 | |||
714 | /** | ||
715 | * s3c_hsotg_map_dma - map the DMA memory being used for the request | ||
716 | * @hsotg: The device state. | ||
717 | * @hs_ep: The endpoint the request is on. | ||
718 | * @req: The request being processed. | ||
719 | * | ||
720 | * We've been asked to queue a request, so ensure that the memory buffer | ||
721 | * is correctly setup for DMA. If we've been passed an extant DMA address | ||
722 | * then ensure the buffer has been synced to memory. If our buffer has no | ||
723 | * DMA memory, then we map the memory and mark our request to allow us to | ||
724 | * cleanup on completion. | ||
725 | */ | ||
726 | static int s3c_hsotg_map_dma(struct s3c_hsotg *hsotg, | ||
727 | struct s3c_hsotg_ep *hs_ep, | ||
728 | struct usb_request *req) | ||
729 | { | ||
730 | enum dma_data_direction dir; | ||
731 | struct s3c_hsotg_req *hs_req = our_req(req); | ||
732 | |||
733 | dir = hs_ep->dir_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE; | ||
734 | |||
735 | /* if the length is zero, ignore the DMA data */ | ||
736 | if (hs_req->req.length == 0) | ||
737 | return 0; | ||
738 | |||
739 | if (req->dma == DMA_ADDR_INVALID) { | ||
740 | dma_addr_t dma; | ||
741 | |||
742 | dma = dma_map_single(hsotg->dev, req->buf, req->length, dir); | ||
743 | |||
744 | if (unlikely(dma_mapping_error(hsotg->dev, dma))) | ||
745 | goto dma_error; | ||
746 | |||
747 | if (dma & 3) { | ||
748 | dev_err(hsotg->dev, "%s: unaligned dma buffer\n", | ||
749 | __func__); | ||
750 | |||
751 | dma_unmap_single(hsotg->dev, dma, req->length, dir); | ||
752 | return -EINVAL; | ||
753 | } | ||
754 | |||
755 | hs_req->mapped = 1; | ||
756 | req->dma = dma; | ||
757 | } else { | ||
758 | dma_sync_single(hsotg->dev, req->dma, req->length, dir); | ||
759 | hs_req->mapped = 0; | ||
760 | } | ||
761 | |||
762 | return 0; | ||
763 | |||
764 | dma_error: | ||
765 | dev_err(hsotg->dev, "%s: failed to map buffer %p, %d bytes\n", | ||
766 | __func__, req->buf, req->length); | ||
767 | |||
768 | return -EIO; | ||
769 | } | ||
770 | |||
771 | static int s3c_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req, | ||
772 | gfp_t gfp_flags) | ||
773 | { | ||
774 | struct s3c_hsotg_req *hs_req = our_req(req); | ||
775 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
776 | struct s3c_hsotg *hs = hs_ep->parent; | ||
777 | unsigned long irqflags; | ||
778 | bool first; | ||
779 | |||
780 | dev_dbg(hs->dev, "%s: req %p: %d@%p, noi=%d, zero=%d, snok=%d\n", | ||
781 | ep->name, req, req->length, req->buf, req->no_interrupt, | ||
782 | req->zero, req->short_not_ok); | ||
783 | |||
784 | /* initialise status of the request */ | ||
785 | INIT_LIST_HEAD(&hs_req->queue); | ||
786 | req->actual = 0; | ||
787 | req->status = -EINPROGRESS; | ||
788 | |||
789 | /* if we're using DMA, sync the buffers as necessary */ | ||
790 | if (using_dma(hs)) { | ||
791 | int ret = s3c_hsotg_map_dma(hs, hs_ep, req); | ||
792 | if (ret) | ||
793 | return ret; | ||
794 | } | ||
795 | |||
796 | spin_lock_irqsave(&hs_ep->lock, irqflags); | ||
797 | |||
798 | first = list_empty(&hs_ep->queue); | ||
799 | list_add_tail(&hs_req->queue, &hs_ep->queue); | ||
800 | |||
801 | if (first) | ||
802 | s3c_hsotg_start_req(hs, hs_ep, hs_req, false); | ||
803 | |||
804 | spin_unlock_irqrestore(&hs_ep->lock, irqflags); | ||
805 | |||
806 | return 0; | ||
807 | } | ||
808 | |||
809 | static void s3c_hsotg_ep_free_request(struct usb_ep *ep, | ||
810 | struct usb_request *req) | ||
811 | { | ||
812 | struct s3c_hsotg_req *hs_req = our_req(req); | ||
813 | |||
814 | kfree(hs_req); | ||
815 | } | ||
816 | |||
817 | /** | ||
818 | * s3c_hsotg_complete_oursetup - setup completion callback | ||
819 | * @ep: The endpoint the request was on. | ||
820 | * @req: The request completed. | ||
821 | * | ||
822 | * Called on completion of any requests the driver itself | ||
823 | * submitted that need cleaning up. | ||
824 | */ | ||
825 | static void s3c_hsotg_complete_oursetup(struct usb_ep *ep, | ||
826 | struct usb_request *req) | ||
827 | { | ||
828 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
829 | struct s3c_hsotg *hsotg = hs_ep->parent; | ||
830 | |||
831 | dev_dbg(hsotg->dev, "%s: ep %p, req %p\n", __func__, ep, req); | ||
832 | |||
833 | s3c_hsotg_ep_free_request(ep, req); | ||
834 | } | ||
835 | |||
836 | /** | ||
837 | * ep_from_windex - convert control wIndex value to endpoint | ||
838 | * @hsotg: The driver state. | ||
839 | * @windex: The control request wIndex field (in host order). | ||
840 | * | ||
841 | * Convert the given wIndex into a pointer to an driver endpoint | ||
842 | * structure, or return NULL if it is not a valid endpoint. | ||
843 | */ | ||
844 | static struct s3c_hsotg_ep *ep_from_windex(struct s3c_hsotg *hsotg, | ||
845 | u32 windex) | ||
846 | { | ||
847 | struct s3c_hsotg_ep *ep = &hsotg->eps[windex & 0x7F]; | ||
848 | int dir = (windex & USB_DIR_IN) ? 1 : 0; | ||
849 | int idx = windex & 0x7F; | ||
850 | |||
851 | if (windex >= 0x100) | ||
852 | return NULL; | ||
853 | |||
854 | if (idx > S3C_HSOTG_EPS) | ||
855 | return NULL; | ||
856 | |||
857 | if (idx && ep->dir_in != dir) | ||
858 | return NULL; | ||
859 | |||
860 | return ep; | ||
861 | } | ||
862 | |||
863 | /** | ||
864 | * s3c_hsotg_send_reply - send reply to control request | ||
865 | * @hsotg: The device state | ||
866 | * @ep: Endpoint 0 | ||
867 | * @buff: Buffer for request | ||
868 | * @length: Length of reply. | ||
869 | * | ||
870 | * Create a request and queue it on the given endpoint. This is useful as | ||
871 | * an internal method of sending replies to certain control requests, etc. | ||
872 | */ | ||
873 | static int s3c_hsotg_send_reply(struct s3c_hsotg *hsotg, | ||
874 | struct s3c_hsotg_ep *ep, | ||
875 | void *buff, | ||
876 | int length) | ||
877 | { | ||
878 | struct usb_request *req; | ||
879 | int ret; | ||
880 | |||
881 | dev_dbg(hsotg->dev, "%s: buff %p, len %d\n", __func__, buff, length); | ||
882 | |||
883 | req = s3c_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC); | ||
884 | hsotg->ep0_reply = req; | ||
885 | if (!req) { | ||
886 | dev_warn(hsotg->dev, "%s: cannot alloc req\n", __func__); | ||
887 | return -ENOMEM; | ||
888 | } | ||
889 | |||
890 | req->buf = hsotg->ep0_buff; | ||
891 | req->length = length; | ||
892 | req->zero = 1; /* always do zero-length final transfer */ | ||
893 | req->complete = s3c_hsotg_complete_oursetup; | ||
894 | |||
895 | if (length) | ||
896 | memcpy(req->buf, buff, length); | ||
897 | else | ||
898 | ep->sent_zlp = 1; | ||
899 | |||
900 | ret = s3c_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC); | ||
901 | if (ret) { | ||
902 | dev_warn(hsotg->dev, "%s: cannot queue req\n", __func__); | ||
903 | return ret; | ||
904 | } | ||
905 | |||
906 | return 0; | ||
907 | } | ||
908 | |||
909 | /** | ||
910 | * s3c_hsotg_process_req_status - process request GET_STATUS | ||
911 | * @hsotg: The device state | ||
912 | * @ctrl: USB control request | ||
913 | */ | ||
914 | static int s3c_hsotg_process_req_status(struct s3c_hsotg *hsotg, | ||
915 | struct usb_ctrlrequest *ctrl) | ||
916 | { | ||
917 | struct s3c_hsotg_ep *ep0 = &hsotg->eps[0]; | ||
918 | struct s3c_hsotg_ep *ep; | ||
919 | __le16 reply; | ||
920 | int ret; | ||
921 | |||
922 | dev_dbg(hsotg->dev, "%s: USB_REQ_GET_STATUS\n", __func__); | ||
923 | |||
924 | if (!ep0->dir_in) { | ||
925 | dev_warn(hsotg->dev, "%s: direction out?\n", __func__); | ||
926 | return -EINVAL; | ||
927 | } | ||
928 | |||
929 | switch (ctrl->bRequestType & USB_RECIP_MASK) { | ||
930 | case USB_RECIP_DEVICE: | ||
931 | reply = cpu_to_le16(0); /* bit 0 => self powered, | ||
932 | * bit 1 => remote wakeup */ | ||
933 | break; | ||
934 | |||
935 | case USB_RECIP_INTERFACE: | ||
936 | /* currently, the data result should be zero */ | ||
937 | reply = cpu_to_le16(0); | ||
938 | break; | ||
939 | |||
940 | case USB_RECIP_ENDPOINT: | ||
941 | ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex)); | ||
942 | if (!ep) | ||
943 | return -ENOENT; | ||
944 | |||
945 | reply = cpu_to_le16(ep->halted ? 1 : 0); | ||
946 | break; | ||
947 | |||
948 | default: | ||
949 | return 0; | ||
950 | } | ||
951 | |||
952 | if (le16_to_cpu(ctrl->wLength) != 2) | ||
953 | return -EINVAL; | ||
954 | |||
955 | ret = s3c_hsotg_send_reply(hsotg, ep0, &reply, 2); | ||
956 | if (ret) { | ||
957 | dev_err(hsotg->dev, "%s: failed to send reply\n", __func__); | ||
958 | return ret; | ||
959 | } | ||
960 | |||
961 | return 1; | ||
962 | } | ||
963 | |||
964 | static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value); | ||
965 | |||
966 | /** | ||
967 | * s3c_hsotg_process_req_featire - process request {SET,CLEAR}_FEATURE | ||
968 | * @hsotg: The device state | ||
969 | * @ctrl: USB control request | ||
970 | */ | ||
971 | static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg, | ||
972 | struct usb_ctrlrequest *ctrl) | ||
973 | { | ||
974 | bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE); | ||
975 | struct s3c_hsotg_ep *ep; | ||
976 | |||
977 | dev_dbg(hsotg->dev, "%s: %s_FEATURE\n", | ||
978 | __func__, set ? "SET" : "CLEAR"); | ||
979 | |||
980 | if (ctrl->bRequestType == USB_RECIP_ENDPOINT) { | ||
981 | ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex)); | ||
982 | if (!ep) { | ||
983 | dev_dbg(hsotg->dev, "%s: no endpoint for 0x%04x\n", | ||
984 | __func__, le16_to_cpu(ctrl->wIndex)); | ||
985 | return -ENOENT; | ||
986 | } | ||
987 | |||
988 | switch (le16_to_cpu(ctrl->wValue)) { | ||
989 | case USB_ENDPOINT_HALT: | ||
990 | s3c_hsotg_ep_sethalt(&ep->ep, set); | ||
991 | break; | ||
992 | |||
993 | default: | ||
994 | return -ENOENT; | ||
995 | } | ||
996 | } else | ||
997 | return -ENOENT; /* currently only deal with endpoint */ | ||
998 | |||
999 | return 1; | ||
1000 | } | ||
1001 | |||
1002 | /** | ||
1003 | * s3c_hsotg_process_control - process a control request | ||
1004 | * @hsotg: The device state | ||
1005 | * @ctrl: The control request received | ||
1006 | * | ||
1007 | * The controller has received the SETUP phase of a control request, and | ||
1008 | * needs to work out what to do next (and whether to pass it on to the | ||
1009 | * gadget driver). | ||
1010 | */ | ||
1011 | static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg, | ||
1012 | struct usb_ctrlrequest *ctrl) | ||
1013 | { | ||
1014 | struct s3c_hsotg_ep *ep0 = &hsotg->eps[0]; | ||
1015 | int ret = 0; | ||
1016 | u32 dcfg; | ||
1017 | |||
1018 | ep0->sent_zlp = 0; | ||
1019 | |||
1020 | dev_dbg(hsotg->dev, "ctrl Req=%02x, Type=%02x, V=%04x, L=%04x\n", | ||
1021 | ctrl->bRequest, ctrl->bRequestType, | ||
1022 | ctrl->wValue, ctrl->wLength); | ||
1023 | |||
1024 | /* record the direction of the request, for later use when enquing | ||
1025 | * packets onto EP0. */ | ||
1026 | |||
1027 | ep0->dir_in = (ctrl->bRequestType & USB_DIR_IN) ? 1 : 0; | ||
1028 | dev_dbg(hsotg->dev, "ctrl: dir_in=%d\n", ep0->dir_in); | ||
1029 | |||
1030 | /* if we've no data with this request, then the last part of the | ||
1031 | * transaction is going to implicitly be IN. */ | ||
1032 | if (ctrl->wLength == 0) | ||
1033 | ep0->dir_in = 1; | ||
1034 | |||
1035 | if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { | ||
1036 | switch (ctrl->bRequest) { | ||
1037 | case USB_REQ_SET_ADDRESS: | ||
1038 | dcfg = readl(hsotg->regs + S3C_DCFG); | ||
1039 | dcfg &= ~S3C_DCFG_DevAddr_MASK; | ||
1040 | dcfg |= ctrl->wValue << S3C_DCFG_DevAddr_SHIFT; | ||
1041 | writel(dcfg, hsotg->regs + S3C_DCFG); | ||
1042 | |||
1043 | dev_info(hsotg->dev, "new address %d\n", ctrl->wValue); | ||
1044 | |||
1045 | ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0); | ||
1046 | return; | ||
1047 | |||
1048 | case USB_REQ_GET_STATUS: | ||
1049 | ret = s3c_hsotg_process_req_status(hsotg, ctrl); | ||
1050 | break; | ||
1051 | |||
1052 | case USB_REQ_CLEAR_FEATURE: | ||
1053 | case USB_REQ_SET_FEATURE: | ||
1054 | ret = s3c_hsotg_process_req_feature(hsotg, ctrl); | ||
1055 | break; | ||
1056 | } | ||
1057 | } | ||
1058 | |||
1059 | /* as a fallback, try delivering it to the driver to deal with */ | ||
1060 | |||
1061 | if (ret == 0 && hsotg->driver) { | ||
1062 | ret = hsotg->driver->setup(&hsotg->gadget, ctrl); | ||
1063 | if (ret < 0) | ||
1064 | dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret); | ||
1065 | } | ||
1066 | |||
1067 | if (ret > 0) { | ||
1068 | if (!ep0->dir_in) { | ||
1069 | /* need to generate zlp in reply or take data */ | ||
1070 | /* todo - deal with any data we might be sent? */ | ||
1071 | ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0); | ||
1072 | } | ||
1073 | } | ||
1074 | |||
1075 | /* the request is either unhandlable, or is not formatted correctly | ||
1076 | * so respond with a STALL for the status stage to indicate failure. | ||
1077 | */ | ||
1078 | |||
1079 | if (ret < 0) { | ||
1080 | u32 reg; | ||
1081 | u32 ctrl; | ||
1082 | |||
1083 | dev_dbg(hsotg->dev, "ep0 stall (dir=%d)\n", ep0->dir_in); | ||
1084 | reg = (ep0->dir_in) ? S3C_DIEPCTL0 : S3C_DOEPCTL0; | ||
1085 | |||
1086 | /* S3C_DxEPCTL_Stall will be cleared by EP once it has | ||
1087 | * taken effect, so no need to clear later. */ | ||
1088 | |||
1089 | ctrl = readl(hsotg->regs + reg); | ||
1090 | ctrl |= S3C_DxEPCTL_Stall; | ||
1091 | ctrl |= S3C_DxEPCTL_CNAK; | ||
1092 | writel(ctrl, hsotg->regs + reg); | ||
1093 | |||
1094 | dev_dbg(hsotg->dev, | ||
1095 | "writen DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n", | ||
1096 | ctrl, reg, readl(hsotg->regs + reg)); | ||
1097 | |||
1098 | /* don't belive we need to anything more to get the EP | ||
1099 | * to reply with a STALL packet */ | ||
1100 | } | ||
1101 | } | ||
1102 | |||
1103 | static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg); | ||
1104 | |||
1105 | /** | ||
1106 | * s3c_hsotg_complete_setup - completion of a setup transfer | ||
1107 | * @ep: The endpoint the request was on. | ||
1108 | * @req: The request completed. | ||
1109 | * | ||
1110 | * Called on completion of any requests the driver itself submitted for | ||
1111 | * EP0 setup packets | ||
1112 | */ | ||
1113 | static void s3c_hsotg_complete_setup(struct usb_ep *ep, | ||
1114 | struct usb_request *req) | ||
1115 | { | ||
1116 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
1117 | struct s3c_hsotg *hsotg = hs_ep->parent; | ||
1118 | |||
1119 | if (req->status < 0) { | ||
1120 | dev_dbg(hsotg->dev, "%s: failed %d\n", __func__, req->status); | ||
1121 | return; | ||
1122 | } | ||
1123 | |||
1124 | if (req->actual == 0) | ||
1125 | s3c_hsotg_enqueue_setup(hsotg); | ||
1126 | else | ||
1127 | s3c_hsotg_process_control(hsotg, req->buf); | ||
1128 | } | ||
1129 | |||
1130 | /** | ||
1131 | * s3c_hsotg_enqueue_setup - start a request for EP0 packets | ||
1132 | * @hsotg: The device state. | ||
1133 | * | ||
1134 | * Enqueue a request on EP0 if necessary to received any SETUP packets | ||
1135 | * received from the host. | ||
1136 | */ | ||
1137 | static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg) | ||
1138 | { | ||
1139 | struct usb_request *req = hsotg->ctrl_req; | ||
1140 | struct s3c_hsotg_req *hs_req = our_req(req); | ||
1141 | int ret; | ||
1142 | |||
1143 | dev_dbg(hsotg->dev, "%s: queueing setup request\n", __func__); | ||
1144 | |||
1145 | req->zero = 0; | ||
1146 | req->length = 8; | ||
1147 | req->buf = hsotg->ctrl_buff; | ||
1148 | req->complete = s3c_hsotg_complete_setup; | ||
1149 | |||
1150 | if (!list_empty(&hs_req->queue)) { | ||
1151 | dev_dbg(hsotg->dev, "%s already queued???\n", __func__); | ||
1152 | return; | ||
1153 | } | ||
1154 | |||
1155 | hsotg->eps[0].dir_in = 0; | ||
1156 | |||
1157 | ret = s3c_hsotg_ep_queue(&hsotg->eps[0].ep, req, GFP_ATOMIC); | ||
1158 | if (ret < 0) { | ||
1159 | dev_err(hsotg->dev, "%s: failed queue (%d)\n", __func__, ret); | ||
1160 | /* Don't think there's much we can do other than watch the | ||
1161 | * driver fail. */ | ||
1162 | } | ||
1163 | } | ||
1164 | |||
1165 | /** | ||
1166 | * get_ep_head - return the first request on the endpoint | ||
1167 | * @hs_ep: The controller endpoint to get | ||
1168 | * | ||
1169 | * Get the first request on the endpoint. | ||
1170 | */ | ||
1171 | static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep) | ||
1172 | { | ||
1173 | if (list_empty(&hs_ep->queue)) | ||
1174 | return NULL; | ||
1175 | |||
1176 | return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue); | ||
1177 | } | ||
1178 | |||
1179 | /** | ||
1180 | * s3c_hsotg_complete_request - complete a request given to us | ||
1181 | * @hsotg: The device state. | ||
1182 | * @hs_ep: The endpoint the request was on. | ||
1183 | * @hs_req: The request to complete. | ||
1184 | * @result: The result code (0 => Ok, otherwise errno) | ||
1185 | * | ||
1186 | * The given request has finished, so call the necessary completion | ||
1187 | * if it has one and then look to see if we can start a new request | ||
1188 | * on the endpoint. | ||
1189 | * | ||
1190 | * Note, expects the ep to already be locked as appropriate. | ||
1191 | */ | ||
1192 | static void s3c_hsotg_complete_request(struct s3c_hsotg *hsotg, | ||
1193 | struct s3c_hsotg_ep *hs_ep, | ||
1194 | struct s3c_hsotg_req *hs_req, | ||
1195 | int result) | ||
1196 | { | ||
1197 | bool restart; | ||
1198 | |||
1199 | if (!hs_req) { | ||
1200 | dev_dbg(hsotg->dev, "%s: nothing to complete?\n", __func__); | ||
1201 | return; | ||
1202 | } | ||
1203 | |||
1204 | dev_dbg(hsotg->dev, "complete: ep %p %s, req %p, %d => %p\n", | ||
1205 | hs_ep, hs_ep->ep.name, hs_req, result, hs_req->req.complete); | ||
1206 | |||
1207 | /* only replace the status if we've not already set an error | ||
1208 | * from a previous transaction */ | ||
1209 | |||
1210 | if (hs_req->req.status == -EINPROGRESS) | ||
1211 | hs_req->req.status = result; | ||
1212 | |||
1213 | hs_ep->req = NULL; | ||
1214 | list_del_init(&hs_req->queue); | ||
1215 | |||
1216 | if (using_dma(hsotg)) | ||
1217 | s3c_hsotg_unmap_dma(hsotg, hs_ep, hs_req); | ||
1218 | |||
1219 | /* call the complete request with the locks off, just in case the | ||
1220 | * request tries to queue more work for this endpoint. */ | ||
1221 | |||
1222 | if (hs_req->req.complete) { | ||
1223 | spin_unlock(&hs_ep->lock); | ||
1224 | hs_req->req.complete(&hs_ep->ep, &hs_req->req); | ||
1225 | spin_lock(&hs_ep->lock); | ||
1226 | } | ||
1227 | |||
1228 | /* Look to see if there is anything else to do. Note, the completion | ||
1229 | * of the previous request may have caused a new request to be started | ||
1230 | * so be careful when doing this. */ | ||
1231 | |||
1232 | if (!hs_ep->req && result >= 0) { | ||
1233 | restart = !list_empty(&hs_ep->queue); | ||
1234 | if (restart) { | ||
1235 | hs_req = get_ep_head(hs_ep); | ||
1236 | s3c_hsotg_start_req(hsotg, hs_ep, hs_req, false); | ||
1237 | } | ||
1238 | } | ||
1239 | } | ||
1240 | |||
1241 | /** | ||
1242 | * s3c_hsotg_complete_request_lock - complete a request given to us (locked) | ||
1243 | * @hsotg: The device state. | ||
1244 | * @hs_ep: The endpoint the request was on. | ||
1245 | * @hs_req: The request to complete. | ||
1246 | * @result: The result code (0 => Ok, otherwise errno) | ||
1247 | * | ||
1248 | * See s3c_hsotg_complete_request(), but called with the endpoint's | ||
1249 | * lock held. | ||
1250 | */ | ||
1251 | static void s3c_hsotg_complete_request_lock(struct s3c_hsotg *hsotg, | ||
1252 | struct s3c_hsotg_ep *hs_ep, | ||
1253 | struct s3c_hsotg_req *hs_req, | ||
1254 | int result) | ||
1255 | { | ||
1256 | unsigned long flags; | ||
1257 | |||
1258 | spin_lock_irqsave(&hs_ep->lock, flags); | ||
1259 | s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, result); | ||
1260 | spin_unlock_irqrestore(&hs_ep->lock, flags); | ||
1261 | } | ||
1262 | |||
1263 | /** | ||
1264 | * s3c_hsotg_rx_data - receive data from the FIFO for an endpoint | ||
1265 | * @hsotg: The device state. | ||
1266 | * @ep_idx: The endpoint index for the data | ||
1267 | * @size: The size of data in the fifo, in bytes | ||
1268 | * | ||
1269 | * The FIFO status shows there is data to read from the FIFO for a given | ||
1270 | * endpoint, so sort out whether we need to read the data into a request | ||
1271 | * that has been made for that endpoint. | ||
1272 | */ | ||
1273 | static void s3c_hsotg_rx_data(struct s3c_hsotg *hsotg, int ep_idx, int size) | ||
1274 | { | ||
1275 | struct s3c_hsotg_ep *hs_ep = &hsotg->eps[ep_idx]; | ||
1276 | struct s3c_hsotg_req *hs_req = hs_ep->req; | ||
1277 | void __iomem *fifo = hsotg->regs + S3C_EPFIFO(ep_idx); | ||
1278 | int to_read; | ||
1279 | int max_req; | ||
1280 | int read_ptr; | ||
1281 | |||
1282 | if (!hs_req) { | ||
1283 | u32 epctl = readl(hsotg->regs + S3C_DOEPCTL(ep_idx)); | ||
1284 | int ptr; | ||
1285 | |||
1286 | dev_warn(hsotg->dev, | ||
1287 | "%s: FIFO %d bytes on ep%d but no req (DxEPCTl=0x%08x)\n", | ||
1288 | __func__, size, ep_idx, epctl); | ||
1289 | |||
1290 | /* dump the data from the FIFO, we've nothing we can do */ | ||
1291 | for (ptr = 0; ptr < size; ptr += 4) | ||
1292 | (void)readl(fifo); | ||
1293 | |||
1294 | return; | ||
1295 | } | ||
1296 | |||
1297 | spin_lock(&hs_ep->lock); | ||
1298 | |||
1299 | to_read = size; | ||
1300 | read_ptr = hs_req->req.actual; | ||
1301 | max_req = hs_req->req.length - read_ptr; | ||
1302 | |||
1303 | if (to_read > max_req) { | ||
1304 | /* more data appeared than we where willing | ||
1305 | * to deal with in this request. | ||
1306 | */ | ||
1307 | |||
1308 | /* currently we don't deal this */ | ||
1309 | WARN_ON_ONCE(1); | ||
1310 | } | ||
1311 | |||
1312 | dev_dbg(hsotg->dev, "%s: read %d/%d, done %d/%d\n", | ||
1313 | __func__, to_read, max_req, read_ptr, hs_req->req.length); | ||
1314 | |||
1315 | hs_ep->total_data += to_read; | ||
1316 | hs_req->req.actual += to_read; | ||
1317 | to_read = DIV_ROUND_UP(to_read, 4); | ||
1318 | |||
1319 | /* note, we might over-write the buffer end by 3 bytes depending on | ||
1320 | * alignment of the data. */ | ||
1321 | readsl(fifo, hs_req->req.buf + read_ptr, to_read); | ||
1322 | |||
1323 | spin_unlock(&hs_ep->lock); | ||
1324 | } | ||
1325 | |||
1326 | /** | ||
1327 | * s3c_hsotg_send_zlp - send zero-length packet on control endpoint | ||
1328 | * @hsotg: The device instance | ||
1329 | * @req: The request currently on this endpoint | ||
1330 | * | ||
1331 | * Generate a zero-length IN packet request for terminating a SETUP | ||
1332 | * transaction. | ||
1333 | * | ||
1334 | * Note, since we don't write any data to the TxFIFO, then it is | ||
1335 | * currently belived that we do not need to wait for any space in | ||
1336 | * the TxFIFO. | ||
1337 | */ | ||
1338 | static void s3c_hsotg_send_zlp(struct s3c_hsotg *hsotg, | ||
1339 | struct s3c_hsotg_req *req) | ||
1340 | { | ||
1341 | u32 ctrl; | ||
1342 | |||
1343 | if (!req) { | ||
1344 | dev_warn(hsotg->dev, "%s: no request?\n", __func__); | ||
1345 | return; | ||
1346 | } | ||
1347 | |||
1348 | if (req->req.length == 0) { | ||
1349 | hsotg->eps[0].sent_zlp = 1; | ||
1350 | s3c_hsotg_enqueue_setup(hsotg); | ||
1351 | return; | ||
1352 | } | ||
1353 | |||
1354 | hsotg->eps[0].dir_in = 1; | ||
1355 | hsotg->eps[0].sent_zlp = 1; | ||
1356 | |||
1357 | dev_dbg(hsotg->dev, "sending zero-length packet\n"); | ||
1358 | |||
1359 | /* issue a zero-sized packet to terminate this */ | ||
1360 | writel(S3C_DxEPTSIZ_MC(1) | S3C_DxEPTSIZ_PktCnt(1) | | ||
1361 | S3C_DxEPTSIZ_XferSize(0), hsotg->regs + S3C_DIEPTSIZ(0)); | ||
1362 | |||
1363 | ctrl = readl(hsotg->regs + S3C_DIEPCTL0); | ||
1364 | ctrl |= S3C_DxEPCTL_CNAK; /* clear NAK set by core */ | ||
1365 | ctrl |= S3C_DxEPCTL_EPEna; /* ensure ep enabled */ | ||
1366 | ctrl |= S3C_DxEPCTL_USBActEp; | ||
1367 | writel(ctrl, hsotg->regs + S3C_DIEPCTL0); | ||
1368 | } | ||
1369 | |||
1370 | /** | ||
1371 | * s3c_hsotg_handle_outdone - handle receiving OutDone/SetupDone from RXFIFO | ||
1372 | * @hsotg: The device instance | ||
1373 | * @epnum: The endpoint received from | ||
1374 | * @was_setup: Set if processing a SetupDone event. | ||
1375 | * | ||
1376 | * The RXFIFO has delivered an OutDone event, which means that the data | ||
1377 | * transfer for an OUT endpoint has been completed, either by a short | ||
1378 | * packet or by the finish of a transfer. | ||
1379 | */ | ||
1380 | static void s3c_hsotg_handle_outdone(struct s3c_hsotg *hsotg, | ||
1381 | int epnum, bool was_setup) | ||
1382 | { | ||
1383 | struct s3c_hsotg_ep *hs_ep = &hsotg->eps[epnum]; | ||
1384 | struct s3c_hsotg_req *hs_req = hs_ep->req; | ||
1385 | struct usb_request *req = &hs_req->req; | ||
1386 | int result = 0; | ||
1387 | |||
1388 | if (!hs_req) { | ||
1389 | dev_dbg(hsotg->dev, "%s: no request active\n", __func__); | ||
1390 | return; | ||
1391 | } | ||
1392 | |||
1393 | if (using_dma(hsotg)) { | ||
1394 | u32 epsize = readl(hsotg->regs + S3C_DOEPTSIZ(epnum)); | ||
1395 | unsigned size_done; | ||
1396 | unsigned size_left; | ||
1397 | |||
1398 | /* Calculate the size of the transfer by checking how much | ||
1399 | * is left in the endpoint size register and then working it | ||
1400 | * out from the amount we loaded for the transfer. | ||
1401 | * | ||
1402 | * We need to do this as DMA pointers are always 32bit aligned | ||
1403 | * so may overshoot/undershoot the transfer. | ||
1404 | */ | ||
1405 | |||
1406 | size_left = S3C_DxEPTSIZ_XferSize_GET(epsize); | ||
1407 | |||
1408 | size_done = hs_ep->size_loaded - size_left; | ||
1409 | size_done += hs_ep->last_load; | ||
1410 | |||
1411 | req->actual = size_done; | ||
1412 | } | ||
1413 | |||
1414 | if (req->actual < req->length && req->short_not_ok) { | ||
1415 | dev_dbg(hsotg->dev, "%s: got %d/%d (short not ok) => error\n", | ||
1416 | __func__, req->actual, req->length); | ||
1417 | |||
1418 | /* todo - what should we return here? there's no one else | ||
1419 | * even bothering to check the status. */ | ||
1420 | } | ||
1421 | |||
1422 | if (epnum == 0) { | ||
1423 | if (!was_setup && req->complete != s3c_hsotg_complete_setup) | ||
1424 | s3c_hsotg_send_zlp(hsotg, hs_req); | ||
1425 | } | ||
1426 | |||
1427 | s3c_hsotg_complete_request_lock(hsotg, hs_ep, hs_req, result); | ||
1428 | } | ||
1429 | |||
1430 | /** | ||
1431 | * s3c_hsotg_read_frameno - read current frame number | ||
1432 | * @hsotg: The device instance | ||
1433 | * | ||
1434 | * Return the current frame number | ||
1435 | */ | ||
1436 | static u32 s3c_hsotg_read_frameno(struct s3c_hsotg *hsotg) | ||
1437 | { | ||
1438 | u32 dsts; | ||
1439 | |||
1440 | dsts = readl(hsotg->regs + S3C_DSTS); | ||
1441 | dsts &= S3C_DSTS_SOFFN_MASK; | ||
1442 | dsts >>= S3C_DSTS_SOFFN_SHIFT; | ||
1443 | |||
1444 | return dsts; | ||
1445 | } | ||
1446 | |||
1447 | /** | ||
1448 | * s3c_hsotg_handle_rx - RX FIFO has data | ||
1449 | * @hsotg: The device instance | ||
1450 | * | ||
1451 | * The IRQ handler has detected that the RX FIFO has some data in it | ||
1452 | * that requires processing, so find out what is in there and do the | ||
1453 | * appropriate read. | ||
1454 | * | ||
1455 | * The RXFIFO is a true FIFO, the packets comming out are still in packet | ||
1456 | * chunks, so if you have x packets received on an endpoint you'll get x | ||
1457 | * FIFO events delivered, each with a packet's worth of data in it. | ||
1458 | * | ||
1459 | * When using DMA, we should not be processing events from the RXFIFO | ||
1460 | * as the actual data should be sent to the memory directly and we turn | ||
1461 | * on the completion interrupts to get notifications of transfer completion. | ||
1462 | */ | ||
1463 | void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg) | ||
1464 | { | ||
1465 | u32 grxstsr = readl(hsotg->regs + S3C_GRXSTSP); | ||
1466 | u32 epnum, status, size; | ||
1467 | |||
1468 | WARN_ON(using_dma(hsotg)); | ||
1469 | |||
1470 | epnum = grxstsr & S3C_GRXSTS_EPNum_MASK; | ||
1471 | status = grxstsr & S3C_GRXSTS_PktSts_MASK; | ||
1472 | |||
1473 | size = grxstsr & S3C_GRXSTS_ByteCnt_MASK; | ||
1474 | size >>= S3C_GRXSTS_ByteCnt_SHIFT; | ||
1475 | |||
1476 | if (1) | ||
1477 | dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n", | ||
1478 | __func__, grxstsr, size, epnum); | ||
1479 | |||
1480 | #define __status(x) ((x) >> S3C_GRXSTS_PktSts_SHIFT) | ||
1481 | |||
1482 | switch (status >> S3C_GRXSTS_PktSts_SHIFT) { | ||
1483 | case __status(S3C_GRXSTS_PktSts_GlobalOutNAK): | ||
1484 | dev_dbg(hsotg->dev, "GlobalOutNAK\n"); | ||
1485 | break; | ||
1486 | |||
1487 | case __status(S3C_GRXSTS_PktSts_OutDone): | ||
1488 | dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n", | ||
1489 | s3c_hsotg_read_frameno(hsotg)); | ||
1490 | |||
1491 | if (!using_dma(hsotg)) | ||
1492 | s3c_hsotg_handle_outdone(hsotg, epnum, false); | ||
1493 | break; | ||
1494 | |||
1495 | case __status(S3C_GRXSTS_PktSts_SetupDone): | ||
1496 | dev_dbg(hsotg->dev, | ||
1497 | "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n", | ||
1498 | s3c_hsotg_read_frameno(hsotg), | ||
1499 | readl(hsotg->regs + S3C_DOEPCTL(0))); | ||
1500 | |||
1501 | s3c_hsotg_handle_outdone(hsotg, epnum, true); | ||
1502 | break; | ||
1503 | |||
1504 | case __status(S3C_GRXSTS_PktSts_OutRX): | ||
1505 | s3c_hsotg_rx_data(hsotg, epnum, size); | ||
1506 | break; | ||
1507 | |||
1508 | case __status(S3C_GRXSTS_PktSts_SetupRX): | ||
1509 | dev_dbg(hsotg->dev, | ||
1510 | "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n", | ||
1511 | s3c_hsotg_read_frameno(hsotg), | ||
1512 | readl(hsotg->regs + S3C_DOEPCTL(0))); | ||
1513 | |||
1514 | s3c_hsotg_rx_data(hsotg, epnum, size); | ||
1515 | break; | ||
1516 | |||
1517 | default: | ||
1518 | dev_warn(hsotg->dev, "%s: unknown status %08x\n", | ||
1519 | __func__, grxstsr); | ||
1520 | |||
1521 | s3c_hsotg_dump(hsotg); | ||
1522 | break; | ||
1523 | } | ||
1524 | } | ||
1525 | |||
1526 | /** | ||
1527 | * s3c_hsotg_ep0_mps - turn max packet size into register setting | ||
1528 | * @mps: The maximum packet size in bytes. | ||
1529 | */ | ||
1530 | static u32 s3c_hsotg_ep0_mps(unsigned int mps) | ||
1531 | { | ||
1532 | switch (mps) { | ||
1533 | case 64: | ||
1534 | return S3C_D0EPCTL_MPS_64; | ||
1535 | case 32: | ||
1536 | return S3C_D0EPCTL_MPS_32; | ||
1537 | case 16: | ||
1538 | return S3C_D0EPCTL_MPS_16; | ||
1539 | case 8: | ||
1540 | return S3C_D0EPCTL_MPS_8; | ||
1541 | } | ||
1542 | |||
1543 | /* bad max packet size, warn and return invalid result */ | ||
1544 | WARN_ON(1); | ||
1545 | return (u32)-1; | ||
1546 | } | ||
1547 | |||
1548 | /** | ||
1549 | * s3c_hsotg_set_ep_maxpacket - set endpoint's max-packet field | ||
1550 | * @hsotg: The driver state. | ||
1551 | * @ep: The index number of the endpoint | ||
1552 | * @mps: The maximum packet size in bytes | ||
1553 | * | ||
1554 | * Configure the maximum packet size for the given endpoint, updating | ||
1555 | * the hardware control registers to reflect this. | ||
1556 | */ | ||
1557 | static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg, | ||
1558 | unsigned int ep, unsigned int mps) | ||
1559 | { | ||
1560 | struct s3c_hsotg_ep *hs_ep = &hsotg->eps[ep]; | ||
1561 | void __iomem *regs = hsotg->regs; | ||
1562 | u32 mpsval; | ||
1563 | u32 reg; | ||
1564 | |||
1565 | if (ep == 0) { | ||
1566 | /* EP0 is a special case */ | ||
1567 | mpsval = s3c_hsotg_ep0_mps(mps); | ||
1568 | if (mpsval > 3) | ||
1569 | goto bad_mps; | ||
1570 | } else { | ||
1571 | if (mps >= S3C_DxEPCTL_MPS_LIMIT+1) | ||
1572 | goto bad_mps; | ||
1573 | |||
1574 | mpsval = mps; | ||
1575 | } | ||
1576 | |||
1577 | hs_ep->ep.maxpacket = mps; | ||
1578 | |||
1579 | /* update both the in and out endpoint controldir_ registers, even | ||
1580 | * if one of the directions may not be in use. */ | ||
1581 | |||
1582 | reg = readl(regs + S3C_DIEPCTL(ep)); | ||
1583 | reg &= ~S3C_DxEPCTL_MPS_MASK; | ||
1584 | reg |= mpsval; | ||
1585 | writel(reg, regs + S3C_DIEPCTL(ep)); | ||
1586 | |||
1587 | reg = readl(regs + S3C_DOEPCTL(ep)); | ||
1588 | reg &= ~S3C_DxEPCTL_MPS_MASK; | ||
1589 | reg |= mpsval; | ||
1590 | writel(reg, regs + S3C_DOEPCTL(ep)); | ||
1591 | |||
1592 | return; | ||
1593 | |||
1594 | bad_mps: | ||
1595 | dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps); | ||
1596 | } | ||
1597 | |||
1598 | |||
1599 | /** | ||
1600 | * s3c_hsotg_trytx - check to see if anything needs transmitting | ||
1601 | * @hsotg: The driver state | ||
1602 | * @hs_ep: The driver endpoint to check. | ||
1603 | * | ||
1604 | * Check to see if there is a request that has data to send, and if so | ||
1605 | * make an attempt to write data into the FIFO. | ||
1606 | */ | ||
1607 | static int s3c_hsotg_trytx(struct s3c_hsotg *hsotg, | ||
1608 | struct s3c_hsotg_ep *hs_ep) | ||
1609 | { | ||
1610 | struct s3c_hsotg_req *hs_req = hs_ep->req; | ||
1611 | |||
1612 | if (!hs_ep->dir_in || !hs_req) | ||
1613 | return 0; | ||
1614 | |||
1615 | if (hs_req->req.actual < hs_req->req.length) { | ||
1616 | dev_dbg(hsotg->dev, "trying to write more for ep%d\n", | ||
1617 | hs_ep->index); | ||
1618 | return s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req); | ||
1619 | } | ||
1620 | |||
1621 | return 0; | ||
1622 | } | ||
1623 | |||
1624 | /** | ||
1625 | * s3c_hsotg_complete_in - complete IN transfer | ||
1626 | * @hsotg: The device state. | ||
1627 | * @hs_ep: The endpoint that has just completed. | ||
1628 | * | ||
1629 | * An IN transfer has been completed, update the transfer's state and then | ||
1630 | * call the relevant completion routines. | ||
1631 | */ | ||
1632 | static void s3c_hsotg_complete_in(struct s3c_hsotg *hsotg, | ||
1633 | struct s3c_hsotg_ep *hs_ep) | ||
1634 | { | ||
1635 | struct s3c_hsotg_req *hs_req = hs_ep->req; | ||
1636 | u32 epsize = readl(hsotg->regs + S3C_DIEPTSIZ(hs_ep->index)); | ||
1637 | int size_left, size_done; | ||
1638 | |||
1639 | if (!hs_req) { | ||
1640 | dev_dbg(hsotg->dev, "XferCompl but no req\n"); | ||
1641 | return; | ||
1642 | } | ||
1643 | |||
1644 | /* Calculate the size of the transfer by checking how much is left | ||
1645 | * in the endpoint size register and then working it out from | ||
1646 | * the amount we loaded for the transfer. | ||
1647 | * | ||
1648 | * We do this even for DMA, as the transfer may have incremented | ||
1649 | * past the end of the buffer (DMA transfers are always 32bit | ||
1650 | * aligned). | ||
1651 | */ | ||
1652 | |||
1653 | size_left = S3C_DxEPTSIZ_XferSize_GET(epsize); | ||
1654 | |||
1655 | size_done = hs_ep->size_loaded - size_left; | ||
1656 | size_done += hs_ep->last_load; | ||
1657 | |||
1658 | if (hs_req->req.actual != size_done) | ||
1659 | dev_dbg(hsotg->dev, "%s: adjusting size done %d => %d\n", | ||
1660 | __func__, hs_req->req.actual, size_done); | ||
1661 | |||
1662 | hs_req->req.actual = size_done; | ||
1663 | |||
1664 | /* if we did all of the transfer, and there is more data left | ||
1665 | * around, then try restarting the rest of the request */ | ||
1666 | |||
1667 | if (!size_left && hs_req->req.actual < hs_req->req.length) { | ||
1668 | dev_dbg(hsotg->dev, "%s trying more for req...\n", __func__); | ||
1669 | s3c_hsotg_start_req(hsotg, hs_ep, hs_req, true); | ||
1670 | } else | ||
1671 | s3c_hsotg_complete_request_lock(hsotg, hs_ep, hs_req, 0); | ||
1672 | } | ||
1673 | |||
1674 | /** | ||
1675 | * s3c_hsotg_epint - handle an in/out endpoint interrupt | ||
1676 | * @hsotg: The driver state | ||
1677 | * @idx: The index for the endpoint (0..15) | ||
1678 | * @dir_in: Set if this is an IN endpoint | ||
1679 | * | ||
1680 | * Process and clear any interrupt pending for an individual endpoint | ||
1681 | */ | ||
1682 | static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx, | ||
1683 | int dir_in) | ||
1684 | { | ||
1685 | struct s3c_hsotg_ep *hs_ep = &hsotg->eps[idx]; | ||
1686 | u32 epint_reg = dir_in ? S3C_DIEPINT(idx) : S3C_DOEPINT(idx); | ||
1687 | u32 epctl_reg = dir_in ? S3C_DIEPCTL(idx) : S3C_DOEPCTL(idx); | ||
1688 | u32 epsiz_reg = dir_in ? S3C_DIEPTSIZ(idx) : S3C_DOEPTSIZ(idx); | ||
1689 | u32 ints; | ||
1690 | u32 clear = 0; | ||
1691 | |||
1692 | ints = readl(hsotg->regs + epint_reg); | ||
1693 | |||
1694 | dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n", | ||
1695 | __func__, idx, dir_in ? "in" : "out", ints); | ||
1696 | |||
1697 | if (ints & S3C_DxEPINT_XferCompl) { | ||
1698 | dev_dbg(hsotg->dev, | ||
1699 | "%s: XferCompl: DxEPCTL=0x%08x, DxEPTSIZ=%08x\n", | ||
1700 | __func__, readl(hsotg->regs + epctl_reg), | ||
1701 | readl(hsotg->regs + epsiz_reg)); | ||
1702 | |||
1703 | /* we get OutDone from the FIFO, so we only need to look | ||
1704 | * at completing IN requests here */ | ||
1705 | if (dir_in) { | ||
1706 | s3c_hsotg_complete_in(hsotg, hs_ep); | ||
1707 | |||
1708 | if (idx == 0) | ||
1709 | s3c_hsotg_enqueue_setup(hsotg); | ||
1710 | } else if (using_dma(hsotg)) { | ||
1711 | /* We're using DMA, we need to fire an OutDone here | ||
1712 | * as we ignore the RXFIFO. */ | ||
1713 | |||
1714 | s3c_hsotg_handle_outdone(hsotg, idx, false); | ||
1715 | } | ||
1716 | |||
1717 | clear |= S3C_DxEPINT_XferCompl; | ||
1718 | } | ||
1719 | |||
1720 | if (ints & S3C_DxEPINT_EPDisbld) { | ||
1721 | dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__); | ||
1722 | clear |= S3C_DxEPINT_EPDisbld; | ||
1723 | } | ||
1724 | |||
1725 | if (ints & S3C_DxEPINT_AHBErr) { | ||
1726 | dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__); | ||
1727 | clear |= S3C_DxEPINT_AHBErr; | ||
1728 | } | ||
1729 | |||
1730 | if (ints & S3C_DxEPINT_Setup) { /* Setup or Timeout */ | ||
1731 | dev_dbg(hsotg->dev, "%s: Setup/Timeout\n", __func__); | ||
1732 | |||
1733 | if (using_dma(hsotg) && idx == 0) { | ||
1734 | /* this is the notification we've received a | ||
1735 | * setup packet. In non-DMA mode we'd get this | ||
1736 | * from the RXFIFO, instead we need to process | ||
1737 | * the setup here. */ | ||
1738 | |||
1739 | if (dir_in) | ||
1740 | WARN_ON_ONCE(1); | ||
1741 | else | ||
1742 | s3c_hsotg_handle_outdone(hsotg, 0, true); | ||
1743 | } | ||
1744 | |||
1745 | clear |= S3C_DxEPINT_Setup; | ||
1746 | } | ||
1747 | |||
1748 | if (ints & S3C_DxEPINT_Back2BackSetup) { | ||
1749 | dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__); | ||
1750 | clear |= S3C_DxEPINT_Back2BackSetup; | ||
1751 | } | ||
1752 | |||
1753 | if (dir_in) { | ||
1754 | /* not sure if this is important, but we'll clear it anyway | ||
1755 | */ | ||
1756 | if (ints & S3C_DIEPMSK_INTknTXFEmpMsk) { | ||
1757 | dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n", | ||
1758 | __func__, idx); | ||
1759 | clear |= S3C_DIEPMSK_INTknTXFEmpMsk; | ||
1760 | } | ||
1761 | |||
1762 | /* this probably means something bad is happening */ | ||
1763 | if (ints & S3C_DIEPMSK_INTknEPMisMsk) { | ||
1764 | dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n", | ||
1765 | __func__, idx); | ||
1766 | clear |= S3C_DIEPMSK_INTknEPMisMsk; | ||
1767 | } | ||
1768 | } | ||
1769 | |||
1770 | writel(clear, hsotg->regs + epint_reg); | ||
1771 | } | ||
1772 | |||
1773 | /** | ||
1774 | * s3c_hsotg_irq_enumdone - Handle EnumDone interrupt (enumeration done) | ||
1775 | * @hsotg: The device state. | ||
1776 | * | ||
1777 | * Handle updating the device settings after the enumeration phase has | ||
1778 | * been completed. | ||
1779 | */ | ||
1780 | static void s3c_hsotg_irq_enumdone(struct s3c_hsotg *hsotg) | ||
1781 | { | ||
1782 | u32 dsts = readl(hsotg->regs + S3C_DSTS); | ||
1783 | int ep0_mps = 0, ep_mps; | ||
1784 | |||
1785 | /* This should signal the finish of the enumeration phase | ||
1786 | * of the USB handshaking, so we should now know what rate | ||
1787 | * we connected at. */ | ||
1788 | |||
1789 | dev_dbg(hsotg->dev, "EnumDone (DSTS=0x%08x)\n", dsts); | ||
1790 | |||
1791 | /* note, since we're limited by the size of transfer on EP0, and | ||
1792 | * it seems IN transfers must be a even number of packets we do | ||
1793 | * not advertise a 64byte MPS on EP0. */ | ||
1794 | |||
1795 | /* catch both EnumSpd_FS and EnumSpd_FS48 */ | ||
1796 | switch (dsts & S3C_DSTS_EnumSpd_MASK) { | ||
1797 | case S3C_DSTS_EnumSpd_FS: | ||
1798 | case S3C_DSTS_EnumSpd_FS48: | ||
1799 | hsotg->gadget.speed = USB_SPEED_FULL; | ||
1800 | dev_info(hsotg->dev, "new device is full-speed\n"); | ||
1801 | |||
1802 | ep0_mps = EP0_MPS_LIMIT; | ||
1803 | ep_mps = 64; | ||
1804 | break; | ||
1805 | |||
1806 | case S3C_DSTS_EnumSpd_HS: | ||
1807 | dev_info(hsotg->dev, "new device is high-speed\n"); | ||
1808 | hsotg->gadget.speed = USB_SPEED_HIGH; | ||
1809 | |||
1810 | ep0_mps = EP0_MPS_LIMIT; | ||
1811 | ep_mps = 512; | ||
1812 | break; | ||
1813 | |||
1814 | case S3C_DSTS_EnumSpd_LS: | ||
1815 | hsotg->gadget.speed = USB_SPEED_LOW; | ||
1816 | dev_info(hsotg->dev, "new device is low-speed\n"); | ||
1817 | |||
1818 | /* note, we don't actually support LS in this driver at the | ||
1819 | * moment, and the documentation seems to imply that it isn't | ||
1820 | * supported by the PHYs on some of the devices. | ||
1821 | */ | ||
1822 | break; | ||
1823 | } | ||
1824 | |||
1825 | /* we should now know the maximum packet size for an | ||
1826 | * endpoint, so set the endpoints to a default value. */ | ||
1827 | |||
1828 | if (ep0_mps) { | ||
1829 | int i; | ||
1830 | s3c_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps); | ||
1831 | for (i = 1; i < S3C_HSOTG_EPS; i++) | ||
1832 | s3c_hsotg_set_ep_maxpacket(hsotg, i, ep_mps); | ||
1833 | } | ||
1834 | |||
1835 | /* ensure after enumeration our EP0 is active */ | ||
1836 | |||
1837 | s3c_hsotg_enqueue_setup(hsotg); | ||
1838 | |||
1839 | dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n", | ||
1840 | readl(hsotg->regs + S3C_DIEPCTL0), | ||
1841 | readl(hsotg->regs + S3C_DOEPCTL0)); | ||
1842 | } | ||
1843 | |||
1844 | /** | ||
1845 | * kill_all_requests - remove all requests from the endpoint's queue | ||
1846 | * @hsotg: The device state. | ||
1847 | * @ep: The endpoint the requests may be on. | ||
1848 | * @result: The result code to use. | ||
1849 | * @force: Force removal of any current requests | ||
1850 | * | ||
1851 | * Go through the requests on the given endpoint and mark them | ||
1852 | * completed with the given result code. | ||
1853 | */ | ||
1854 | static void kill_all_requests(struct s3c_hsotg *hsotg, | ||
1855 | struct s3c_hsotg_ep *ep, | ||
1856 | int result, bool force) | ||
1857 | { | ||
1858 | struct s3c_hsotg_req *req, *treq; | ||
1859 | unsigned long flags; | ||
1860 | |||
1861 | spin_lock_irqsave(&ep->lock, flags); | ||
1862 | |||
1863 | list_for_each_entry_safe(req, treq, &ep->queue, queue) { | ||
1864 | /* currently, we can't do much about an already | ||
1865 | * running request on an in endpoint */ | ||
1866 | |||
1867 | if (ep->req == req && ep->dir_in && !force) | ||
1868 | continue; | ||
1869 | |||
1870 | s3c_hsotg_complete_request(hsotg, ep, req, | ||
1871 | result); | ||
1872 | } | ||
1873 | |||
1874 | spin_unlock_irqrestore(&ep->lock, flags); | ||
1875 | } | ||
1876 | |||
1877 | #define call_gadget(_hs, _entry) \ | ||
1878 | if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \ | ||
1879 | (_hs)->driver && (_hs)->driver->_entry) \ | ||
1880 | (_hs)->driver->_entry(&(_hs)->gadget); | ||
1881 | |||
1882 | /** | ||
1883 | * s3c_hsotg_disconnect_irq - disconnect irq service | ||
1884 | * @hsotg: The device state. | ||
1885 | * | ||
1886 | * A disconnect IRQ has been received, meaning that the host has | ||
1887 | * lost contact with the bus. Remove all current transactions | ||
1888 | * and signal the gadget driver that this has happened. | ||
1889 | */ | ||
1890 | static void s3c_hsotg_disconnect_irq(struct s3c_hsotg *hsotg) | ||
1891 | { | ||
1892 | unsigned ep; | ||
1893 | |||
1894 | for (ep = 0; ep < S3C_HSOTG_EPS; ep++) | ||
1895 | kill_all_requests(hsotg, &hsotg->eps[ep], -ESHUTDOWN, true); | ||
1896 | |||
1897 | call_gadget(hsotg, disconnect); | ||
1898 | } | ||
1899 | |||
1900 | /** | ||
1901 | * s3c_hsotg_irq_fifoempty - TX FIFO empty interrupt handler | ||
1902 | * @hsotg: The device state: | ||
1903 | * @periodic: True if this is a periodic FIFO interrupt | ||
1904 | */ | ||
1905 | static void s3c_hsotg_irq_fifoempty(struct s3c_hsotg *hsotg, bool periodic) | ||
1906 | { | ||
1907 | struct s3c_hsotg_ep *ep; | ||
1908 | int epno, ret; | ||
1909 | |||
1910 | /* look through for any more data to transmit */ | ||
1911 | |||
1912 | for (epno = 0; epno < S3C_HSOTG_EPS; epno++) { | ||
1913 | ep = &hsotg->eps[epno]; | ||
1914 | |||
1915 | if (!ep->dir_in) | ||
1916 | continue; | ||
1917 | |||
1918 | if ((periodic && !ep->periodic) || | ||
1919 | (!periodic && ep->periodic)) | ||
1920 | continue; | ||
1921 | |||
1922 | ret = s3c_hsotg_trytx(hsotg, ep); | ||
1923 | if (ret < 0) | ||
1924 | break; | ||
1925 | } | ||
1926 | } | ||
1927 | |||
1928 | static struct s3c_hsotg *our_hsotg; | ||
1929 | |||
1930 | /* IRQ flags which will trigger a retry around the IRQ loop */ | ||
1931 | #define IRQ_RETRY_MASK (S3C_GINTSTS_NPTxFEmp | \ | ||
1932 | S3C_GINTSTS_PTxFEmp | \ | ||
1933 | S3C_GINTSTS_RxFLvl) | ||
1934 | |||
1935 | /** | ||
1936 | * s3c_hsotg_irq - handle device interrupt | ||
1937 | * @irq: The IRQ number triggered | ||
1938 | * @pw: The pw value when registered the handler. | ||
1939 | */ | ||
1940 | static irqreturn_t s3c_hsotg_irq(int irq, void *pw) | ||
1941 | { | ||
1942 | struct s3c_hsotg *hsotg = pw; | ||
1943 | int retry_count = 8; | ||
1944 | u32 gintsts; | ||
1945 | u32 gintmsk; | ||
1946 | |||
1947 | irq_retry: | ||
1948 | gintsts = readl(hsotg->regs + S3C_GINTSTS); | ||
1949 | gintmsk = readl(hsotg->regs + S3C_GINTMSK); | ||
1950 | |||
1951 | dev_dbg(hsotg->dev, "%s: %08x %08x (%08x) retry %d\n", | ||
1952 | __func__, gintsts, gintsts & gintmsk, gintmsk, retry_count); | ||
1953 | |||
1954 | gintsts &= gintmsk; | ||
1955 | |||
1956 | if (gintsts & S3C_GINTSTS_OTGInt) { | ||
1957 | u32 otgint = readl(hsotg->regs + S3C_GOTGINT); | ||
1958 | |||
1959 | dev_info(hsotg->dev, "OTGInt: %08x\n", otgint); | ||
1960 | |||
1961 | writel(otgint, hsotg->regs + S3C_GOTGINT); | ||
1962 | writel(S3C_GINTSTS_OTGInt, hsotg->regs + S3C_GINTSTS); | ||
1963 | } | ||
1964 | |||
1965 | if (gintsts & S3C_GINTSTS_DisconnInt) { | ||
1966 | dev_dbg(hsotg->dev, "%s: DisconnInt\n", __func__); | ||
1967 | writel(S3C_GINTSTS_DisconnInt, hsotg->regs + S3C_GINTSTS); | ||
1968 | |||
1969 | s3c_hsotg_disconnect_irq(hsotg); | ||
1970 | } | ||
1971 | |||
1972 | if (gintsts & S3C_GINTSTS_SessReqInt) { | ||
1973 | dev_dbg(hsotg->dev, "%s: SessReqInt\n", __func__); | ||
1974 | writel(S3C_GINTSTS_SessReqInt, hsotg->regs + S3C_GINTSTS); | ||
1975 | } | ||
1976 | |||
1977 | if (gintsts & S3C_GINTSTS_EnumDone) { | ||
1978 | s3c_hsotg_irq_enumdone(hsotg); | ||
1979 | writel(S3C_GINTSTS_EnumDone, hsotg->regs + S3C_GINTSTS); | ||
1980 | } | ||
1981 | |||
1982 | if (gintsts & S3C_GINTSTS_ConIDStsChng) { | ||
1983 | dev_dbg(hsotg->dev, "ConIDStsChg (DSTS=0x%08x, GOTCTL=%08x)\n", | ||
1984 | readl(hsotg->regs + S3C_DSTS), | ||
1985 | readl(hsotg->regs + S3C_GOTGCTL)); | ||
1986 | |||
1987 | writel(S3C_GINTSTS_ConIDStsChng, hsotg->regs + S3C_GINTSTS); | ||
1988 | } | ||
1989 | |||
1990 | if (gintsts & (S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt)) { | ||
1991 | u32 daint = readl(hsotg->regs + S3C_DAINT); | ||
1992 | u32 daint_out = daint >> S3C_DAINT_OutEP_SHIFT; | ||
1993 | u32 daint_in = daint & ~(daint_out << S3C_DAINT_OutEP_SHIFT); | ||
1994 | int ep; | ||
1995 | |||
1996 | dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint); | ||
1997 | |||
1998 | for (ep = 0; ep < 15 && daint_out; ep++, daint_out >>= 1) { | ||
1999 | if (daint_out & 1) | ||
2000 | s3c_hsotg_epint(hsotg, ep, 0); | ||
2001 | } | ||
2002 | |||
2003 | for (ep = 0; ep < 15 && daint_in; ep++, daint_in >>= 1) { | ||
2004 | if (daint_in & 1) | ||
2005 | s3c_hsotg_epint(hsotg, ep, 1); | ||
2006 | } | ||
2007 | |||
2008 | writel(daint, hsotg->regs + S3C_DAINT); | ||
2009 | writel(gintsts & (S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt), | ||
2010 | hsotg->regs + S3C_GINTSTS); | ||
2011 | } | ||
2012 | |||
2013 | if (gintsts & S3C_GINTSTS_USBRst) { | ||
2014 | dev_info(hsotg->dev, "%s: USBRst\n", __func__); | ||
2015 | dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n", | ||
2016 | readl(hsotg->regs + S3C_GNPTXSTS)); | ||
2017 | |||
2018 | kill_all_requests(hsotg, &hsotg->eps[0], -ECONNRESET, true); | ||
2019 | |||
2020 | /* it seems after a reset we can end up with a situation | ||
2021 | * where the TXFIFO still has data in it... try flushing | ||
2022 | * it to remove anything that may still be in it. | ||
2023 | */ | ||
2024 | |||
2025 | if (1) { | ||
2026 | writel(S3C_GRSTCTL_TxFNum(0) | S3C_GRSTCTL_TxFFlsh, | ||
2027 | hsotg->regs + S3C_GRSTCTL); | ||
2028 | |||
2029 | dev_info(hsotg->dev, "GNPTXSTS=%08x\n", | ||
2030 | readl(hsotg->regs + S3C_GNPTXSTS)); | ||
2031 | } | ||
2032 | |||
2033 | s3c_hsotg_enqueue_setup(hsotg); | ||
2034 | |||
2035 | writel(S3C_GINTSTS_USBRst, hsotg->regs + S3C_GINTSTS); | ||
2036 | } | ||
2037 | |||
2038 | /* check both FIFOs */ | ||
2039 | |||
2040 | if (gintsts & S3C_GINTSTS_NPTxFEmp) { | ||
2041 | dev_dbg(hsotg->dev, "NPTxFEmp\n"); | ||
2042 | |||
2043 | /* Disable the interrupt to stop it happening again | ||
2044 | * unless one of these endpoint routines decides that | ||
2045 | * it needs re-enabling */ | ||
2046 | |||
2047 | s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_NPTxFEmp); | ||
2048 | s3c_hsotg_irq_fifoempty(hsotg, false); | ||
2049 | |||
2050 | writel(S3C_GINTSTS_NPTxFEmp, hsotg->regs + S3C_GINTSTS); | ||
2051 | } | ||
2052 | |||
2053 | if (gintsts & S3C_GINTSTS_PTxFEmp) { | ||
2054 | dev_dbg(hsotg->dev, "PTxFEmp\n"); | ||
2055 | |||
2056 | /* See note in S3C_GINTSTS_NPTxFEmp */ | ||
2057 | |||
2058 | s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_PTxFEmp); | ||
2059 | s3c_hsotg_irq_fifoempty(hsotg, true); | ||
2060 | |||
2061 | writel(S3C_GINTSTS_PTxFEmp, hsotg->regs + S3C_GINTSTS); | ||
2062 | } | ||
2063 | |||
2064 | if (gintsts & S3C_GINTSTS_RxFLvl) { | ||
2065 | /* note, since GINTSTS_RxFLvl doubles as FIFO-not-empty, | ||
2066 | * we need to retry s3c_hsotg_handle_rx if this is still | ||
2067 | * set. */ | ||
2068 | |||
2069 | s3c_hsotg_handle_rx(hsotg); | ||
2070 | writel(S3C_GINTSTS_RxFLvl, hsotg->regs + S3C_GINTSTS); | ||
2071 | } | ||
2072 | |||
2073 | if (gintsts & S3C_GINTSTS_ModeMis) { | ||
2074 | dev_warn(hsotg->dev, "warning, mode mismatch triggered\n"); | ||
2075 | writel(S3C_GINTSTS_ModeMis, hsotg->regs + S3C_GINTSTS); | ||
2076 | } | ||
2077 | |||
2078 | if (gintsts & S3C_GINTSTS_USBSusp) { | ||
2079 | dev_info(hsotg->dev, "S3C_GINTSTS_USBSusp\n"); | ||
2080 | writel(S3C_GINTSTS_USBSusp, hsotg->regs + S3C_GINTSTS); | ||
2081 | |||
2082 | call_gadget(hsotg, suspend); | ||
2083 | } | ||
2084 | |||
2085 | if (gintsts & S3C_GINTSTS_WkUpInt) { | ||
2086 | dev_info(hsotg->dev, "S3C_GINTSTS_WkUpIn\n"); | ||
2087 | writel(S3C_GINTSTS_WkUpInt, hsotg->regs + S3C_GINTSTS); | ||
2088 | |||
2089 | call_gadget(hsotg, resume); | ||
2090 | } | ||
2091 | |||
2092 | if (gintsts & S3C_GINTSTS_ErlySusp) { | ||
2093 | dev_dbg(hsotg->dev, "S3C_GINTSTS_ErlySusp\n"); | ||
2094 | writel(S3C_GINTSTS_ErlySusp, hsotg->regs + S3C_GINTSTS); | ||
2095 | } | ||
2096 | |||
2097 | /* these next two seem to crop-up occasionally causing the core | ||
2098 | * to shutdown the USB transfer, so try clearing them and logging | ||
2099 | * the occurence. */ | ||
2100 | |||
2101 | if (gintsts & S3C_GINTSTS_GOUTNakEff) { | ||
2102 | dev_info(hsotg->dev, "GOUTNakEff triggered\n"); | ||
2103 | |||
2104 | s3c_hsotg_dump(hsotg); | ||
2105 | |||
2106 | writel(S3C_DCTL_CGOUTNak, hsotg->regs + S3C_DCTL); | ||
2107 | writel(S3C_GINTSTS_GOUTNakEff, hsotg->regs + S3C_GINTSTS); | ||
2108 | } | ||
2109 | |||
2110 | if (gintsts & S3C_GINTSTS_GINNakEff) { | ||
2111 | dev_info(hsotg->dev, "GINNakEff triggered\n"); | ||
2112 | |||
2113 | s3c_hsotg_dump(hsotg); | ||
2114 | |||
2115 | writel(S3C_DCTL_CGNPInNAK, hsotg->regs + S3C_DCTL); | ||
2116 | writel(S3C_GINTSTS_GINNakEff, hsotg->regs + S3C_GINTSTS); | ||
2117 | } | ||
2118 | |||
2119 | /* if we've had fifo events, we should try and go around the | ||
2120 | * loop again to see if there's any point in returning yet. */ | ||
2121 | |||
2122 | if (gintsts & IRQ_RETRY_MASK && --retry_count > 0) | ||
2123 | goto irq_retry; | ||
2124 | |||
2125 | return IRQ_HANDLED; | ||
2126 | } | ||
2127 | |||
2128 | /** | ||
2129 | * s3c_hsotg_ep_enable - enable the given endpoint | ||
2130 | * @ep: The USB endpint to configure | ||
2131 | * @desc: The USB endpoint descriptor to configure with. | ||
2132 | * | ||
2133 | * This is called from the USB gadget code's usb_ep_enable(). | ||
2134 | */ | ||
2135 | static int s3c_hsotg_ep_enable(struct usb_ep *ep, | ||
2136 | const struct usb_endpoint_descriptor *desc) | ||
2137 | { | ||
2138 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
2139 | struct s3c_hsotg *hsotg = hs_ep->parent; | ||
2140 | unsigned long flags; | ||
2141 | int index = hs_ep->index; | ||
2142 | u32 epctrl_reg; | ||
2143 | u32 epctrl; | ||
2144 | u32 mps; | ||
2145 | int dir_in; | ||
2146 | |||
2147 | dev_dbg(hsotg->dev, | ||
2148 | "%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n", | ||
2149 | __func__, ep->name, desc->bEndpointAddress, desc->bmAttributes, | ||
2150 | desc->wMaxPacketSize, desc->bInterval); | ||
2151 | |||
2152 | /* not to be called for EP0 */ | ||
2153 | WARN_ON(index == 0); | ||
2154 | |||
2155 | dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0; | ||
2156 | if (dir_in != hs_ep->dir_in) { | ||
2157 | dev_err(hsotg->dev, "%s: direction mismatch!\n", __func__); | ||
2158 | return -EINVAL; | ||
2159 | } | ||
2160 | |||
2161 | mps = le16_to_cpu(desc->wMaxPacketSize); | ||
2162 | |||
2163 | /* note, we handle this here instead of s3c_hsotg_set_ep_maxpacket */ | ||
2164 | |||
2165 | epctrl_reg = dir_in ? S3C_DIEPCTL(index) : S3C_DOEPCTL(index); | ||
2166 | epctrl = readl(hsotg->regs + epctrl_reg); | ||
2167 | |||
2168 | dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x from 0x%08x\n", | ||
2169 | __func__, epctrl, epctrl_reg); | ||
2170 | |||
2171 | spin_lock_irqsave(&hs_ep->lock, flags); | ||
2172 | |||
2173 | epctrl &= ~(S3C_DxEPCTL_EPType_MASK | S3C_DxEPCTL_MPS_MASK); | ||
2174 | epctrl |= S3C_DxEPCTL_MPS(mps); | ||
2175 | |||
2176 | /* mark the endpoint as active, otherwise the core may ignore | ||
2177 | * transactions entirely for this endpoint */ | ||
2178 | epctrl |= S3C_DxEPCTL_USBActEp; | ||
2179 | |||
2180 | /* set the NAK status on the endpoint, otherwise we might try and | ||
2181 | * do something with data that we've yet got a request to process | ||
2182 | * since the RXFIFO will take data for an endpoint even if the | ||
2183 | * size register hasn't been set. | ||
2184 | */ | ||
2185 | |||
2186 | epctrl |= S3C_DxEPCTL_SNAK; | ||
2187 | |||
2188 | /* update the endpoint state */ | ||
2189 | hs_ep->ep.maxpacket = mps; | ||
2190 | |||
2191 | /* default, set to non-periodic */ | ||
2192 | hs_ep->periodic = 0; | ||
2193 | |||
2194 | switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { | ||
2195 | case USB_ENDPOINT_XFER_ISOC: | ||
2196 | dev_err(hsotg->dev, "no current ISOC support\n"); | ||
2197 | return -EINVAL; | ||
2198 | |||
2199 | case USB_ENDPOINT_XFER_BULK: | ||
2200 | epctrl |= S3C_DxEPCTL_EPType_Bulk; | ||
2201 | break; | ||
2202 | |||
2203 | case USB_ENDPOINT_XFER_INT: | ||
2204 | if (dir_in) { | ||
2205 | /* Allocate our TxFNum by simply using the index | ||
2206 | * of the endpoint for the moment. We could do | ||
2207 | * something better if the host indicates how | ||
2208 | * many FIFOs we are expecting to use. */ | ||
2209 | |||
2210 | hs_ep->periodic = 1; | ||
2211 | epctrl |= S3C_DxEPCTL_TxFNum(index); | ||
2212 | } | ||
2213 | |||
2214 | epctrl |= S3C_DxEPCTL_EPType_Intterupt; | ||
2215 | break; | ||
2216 | |||
2217 | case USB_ENDPOINT_XFER_CONTROL: | ||
2218 | epctrl |= S3C_DxEPCTL_EPType_Control; | ||
2219 | break; | ||
2220 | } | ||
2221 | |||
2222 | /* for non control endpoints, set PID to D0 */ | ||
2223 | if (index) | ||
2224 | epctrl |= S3C_DxEPCTL_SetD0PID; | ||
2225 | |||
2226 | dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n", | ||
2227 | __func__, epctrl); | ||
2228 | |||
2229 | writel(epctrl, hsotg->regs + epctrl_reg); | ||
2230 | dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x\n", | ||
2231 | __func__, readl(hsotg->regs + epctrl_reg)); | ||
2232 | |||
2233 | /* enable the endpoint interrupt */ | ||
2234 | s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1); | ||
2235 | |||
2236 | spin_unlock_irqrestore(&hs_ep->lock, flags); | ||
2237 | return 0; | ||
2238 | } | ||
2239 | |||
2240 | static int s3c_hsotg_ep_disable(struct usb_ep *ep) | ||
2241 | { | ||
2242 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
2243 | struct s3c_hsotg *hsotg = hs_ep->parent; | ||
2244 | int dir_in = hs_ep->dir_in; | ||
2245 | int index = hs_ep->index; | ||
2246 | unsigned long flags; | ||
2247 | u32 epctrl_reg; | ||
2248 | u32 ctrl; | ||
2249 | |||
2250 | dev_info(hsotg->dev, "%s(ep %p)\n", __func__, ep); | ||
2251 | |||
2252 | if (ep == &hsotg->eps[0].ep) { | ||
2253 | dev_err(hsotg->dev, "%s: called for ep0\n", __func__); | ||
2254 | return -EINVAL; | ||
2255 | } | ||
2256 | |||
2257 | epctrl_reg = dir_in ? S3C_DIEPCTL(index) : S3C_DOEPCTL(index); | ||
2258 | |||
2259 | /* terminate all requests with shutdown */ | ||
2260 | kill_all_requests(hsotg, hs_ep, -ESHUTDOWN, false); | ||
2261 | |||
2262 | spin_lock_irqsave(&hs_ep->lock, flags); | ||
2263 | |||
2264 | ctrl = readl(hsotg->regs + epctrl_reg); | ||
2265 | ctrl &= ~S3C_DxEPCTL_EPEna; | ||
2266 | ctrl &= ~S3C_DxEPCTL_USBActEp; | ||
2267 | ctrl |= S3C_DxEPCTL_SNAK; | ||
2268 | |||
2269 | dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl); | ||
2270 | writel(ctrl, hsotg->regs + epctrl_reg); | ||
2271 | |||
2272 | /* disable endpoint interrupts */ | ||
2273 | s3c_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0); | ||
2274 | |||
2275 | spin_unlock_irqrestore(&hs_ep->lock, flags); | ||
2276 | return 0; | ||
2277 | } | ||
2278 | |||
2279 | /** | ||
2280 | * on_list - check request is on the given endpoint | ||
2281 | * @ep: The endpoint to check. | ||
2282 | * @test: The request to test if it is on the endpoint. | ||
2283 | */ | ||
2284 | static bool on_list(struct s3c_hsotg_ep *ep, struct s3c_hsotg_req *test) | ||
2285 | { | ||
2286 | struct s3c_hsotg_req *req, *treq; | ||
2287 | |||
2288 | list_for_each_entry_safe(req, treq, &ep->queue, queue) { | ||
2289 | if (req == test) | ||
2290 | return true; | ||
2291 | } | ||
2292 | |||
2293 | return false; | ||
2294 | } | ||
2295 | |||
2296 | static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req) | ||
2297 | { | ||
2298 | struct s3c_hsotg_req *hs_req = our_req(req); | ||
2299 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
2300 | struct s3c_hsotg *hs = hs_ep->parent; | ||
2301 | unsigned long flags; | ||
2302 | |||
2303 | dev_info(hs->dev, "ep_dequeue(%p,%p)\n", ep, req); | ||
2304 | |||
2305 | if (hs_req == hs_ep->req) { | ||
2306 | dev_dbg(hs->dev, "%s: already in progress\n", __func__); | ||
2307 | return -EINPROGRESS; | ||
2308 | } | ||
2309 | |||
2310 | spin_lock_irqsave(&hs_ep->lock, flags); | ||
2311 | |||
2312 | if (!on_list(hs_ep, hs_req)) { | ||
2313 | spin_unlock_irqrestore(&hs_ep->lock, flags); | ||
2314 | return -EINVAL; | ||
2315 | } | ||
2316 | |||
2317 | s3c_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET); | ||
2318 | spin_unlock_irqrestore(&hs_ep->lock, flags); | ||
2319 | |||
2320 | return 0; | ||
2321 | } | ||
2322 | |||
2323 | static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value) | ||
2324 | { | ||
2325 | struct s3c_hsotg_ep *hs_ep = our_ep(ep); | ||
2326 | struct s3c_hsotg *hs = hs_ep->parent; | ||
2327 | int index = hs_ep->index; | ||
2328 | unsigned long irqflags; | ||
2329 | u32 epreg; | ||
2330 | u32 epctl; | ||
2331 | |||
2332 | dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value); | ||
2333 | |||
2334 | spin_lock_irqsave(&hs_ep->lock, irqflags); | ||
2335 | |||
2336 | /* write both IN and OUT control registers */ | ||
2337 | |||
2338 | epreg = S3C_DIEPCTL(index); | ||
2339 | epctl = readl(hs->regs + epreg); | ||
2340 | |||
2341 | if (value) | ||
2342 | epctl |= S3C_DxEPCTL_Stall; | ||
2343 | else | ||
2344 | epctl &= ~S3C_DxEPCTL_Stall; | ||
2345 | |||
2346 | writel(epctl, hs->regs + epreg); | ||
2347 | |||
2348 | epreg = S3C_DOEPCTL(index); | ||
2349 | epctl = readl(hs->regs + epreg); | ||
2350 | |||
2351 | if (value) | ||
2352 | epctl |= S3C_DxEPCTL_Stall; | ||
2353 | else | ||
2354 | epctl &= ~S3C_DxEPCTL_Stall; | ||
2355 | |||
2356 | writel(epctl, hs->regs + epreg); | ||
2357 | |||
2358 | spin_unlock_irqrestore(&hs_ep->lock, irqflags); | ||
2359 | |||
2360 | return 0; | ||
2361 | } | ||
2362 | |||
2363 | static struct usb_ep_ops s3c_hsotg_ep_ops = { | ||
2364 | .enable = s3c_hsotg_ep_enable, | ||
2365 | .disable = s3c_hsotg_ep_disable, | ||
2366 | .alloc_request = s3c_hsotg_ep_alloc_request, | ||
2367 | .free_request = s3c_hsotg_ep_free_request, | ||
2368 | .queue = s3c_hsotg_ep_queue, | ||
2369 | .dequeue = s3c_hsotg_ep_dequeue, | ||
2370 | .set_halt = s3c_hsotg_ep_sethalt, | ||
2371 | /* note, don't belive we have any call for the fifo routines */ | ||
2372 | }; | ||
2373 | |||
2374 | /** | ||
2375 | * s3c_hsotg_corereset - issue softreset to the core | ||
2376 | * @hsotg: The device state | ||
2377 | * | ||
2378 | * Issue a soft reset to the core, and await the core finishing it. | ||
2379 | */ | ||
2380 | static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg) | ||
2381 | { | ||
2382 | int timeout; | ||
2383 | u32 grstctl; | ||
2384 | |||
2385 | dev_dbg(hsotg->dev, "resetting core\n"); | ||
2386 | |||
2387 | /* issue soft reset */ | ||
2388 | writel(S3C_GRSTCTL_CSftRst, hsotg->regs + S3C_GRSTCTL); | ||
2389 | |||
2390 | timeout = 1000; | ||
2391 | do { | ||
2392 | grstctl = readl(hsotg->regs + S3C_GRSTCTL); | ||
2393 | } while (!(grstctl & S3C_GRSTCTL_CSftRst) && timeout-- > 0); | ||
2394 | |||
2395 | if (!grstctl & S3C_GRSTCTL_CSftRst) { | ||
2396 | dev_err(hsotg->dev, "Failed to get CSftRst asserted\n"); | ||
2397 | return -EINVAL; | ||
2398 | } | ||
2399 | |||
2400 | timeout = 1000; | ||
2401 | |||
2402 | while (1) { | ||
2403 | u32 grstctl = readl(hsotg->regs + S3C_GRSTCTL); | ||
2404 | |||
2405 | if (timeout-- < 0) { | ||
2406 | dev_info(hsotg->dev, | ||
2407 | "%s: reset failed, GRSTCTL=%08x\n", | ||
2408 | __func__, grstctl); | ||
2409 | return -ETIMEDOUT; | ||
2410 | } | ||
2411 | |||
2412 | if (grstctl & S3C_GRSTCTL_CSftRst) | ||
2413 | continue; | ||
2414 | |||
2415 | if (!(grstctl & S3C_GRSTCTL_AHBIdle)) | ||
2416 | continue; | ||
2417 | |||
2418 | break; /* reset done */ | ||
2419 | } | ||
2420 | |||
2421 | dev_dbg(hsotg->dev, "reset successful\n"); | ||
2422 | return 0; | ||
2423 | } | ||
2424 | |||
2425 | int usb_gadget_register_driver(struct usb_gadget_driver *driver) | ||
2426 | { | ||
2427 | struct s3c_hsotg *hsotg = our_hsotg; | ||
2428 | int ret; | ||
2429 | |||
2430 | if (!hsotg) { | ||
2431 | printk(KERN_ERR "%s: called with no device\n", __func__); | ||
2432 | return -ENODEV; | ||
2433 | } | ||
2434 | |||
2435 | if (!driver) { | ||
2436 | dev_err(hsotg->dev, "%s: no driver\n", __func__); | ||
2437 | return -EINVAL; | ||
2438 | } | ||
2439 | |||
2440 | if (driver->speed != USB_SPEED_HIGH && | ||
2441 | driver->speed != USB_SPEED_FULL) { | ||
2442 | dev_err(hsotg->dev, "%s: bad speed\n", __func__); | ||
2443 | } | ||
2444 | |||
2445 | if (!driver->bind || !driver->setup) { | ||
2446 | dev_err(hsotg->dev, "%s: missing entry points\n", __func__); | ||
2447 | return -EINVAL; | ||
2448 | } | ||
2449 | |||
2450 | WARN_ON(hsotg->driver); | ||
2451 | |||
2452 | driver->driver.bus = NULL; | ||
2453 | hsotg->driver = driver; | ||
2454 | hsotg->gadget.dev.driver = &driver->driver; | ||
2455 | hsotg->gadget.dev.dma_mask = hsotg->dev->dma_mask; | ||
2456 | hsotg->gadget.speed = USB_SPEED_UNKNOWN; | ||
2457 | |||
2458 | ret = device_add(&hsotg->gadget.dev); | ||
2459 | if (ret) { | ||
2460 | dev_err(hsotg->dev, "failed to register gadget device\n"); | ||
2461 | goto err; | ||
2462 | } | ||
2463 | |||
2464 | ret = driver->bind(&hsotg->gadget); | ||
2465 | if (ret) { | ||
2466 | dev_err(hsotg->dev, "failed bind %s\n", driver->driver.name); | ||
2467 | |||
2468 | hsotg->gadget.dev.driver = NULL; | ||
2469 | hsotg->driver = NULL; | ||
2470 | goto err; | ||
2471 | } | ||
2472 | |||
2473 | /* we must now enable ep0 ready for host detection and then | ||
2474 | * set configuration. */ | ||
2475 | |||
2476 | s3c_hsotg_corereset(hsotg); | ||
2477 | |||
2478 | /* set the PLL on, remove the HNP/SRP and set the PHY */ | ||
2479 | writel(S3C_GUSBCFG_PHYIf16 | S3C_GUSBCFG_TOutCal(7) | | ||
2480 | (0x5 << 10), hsotg->regs + S3C_GUSBCFG); | ||
2481 | |||
2482 | /* looks like soft-reset changes state of FIFOs */ | ||
2483 | s3c_hsotg_init_fifo(hsotg); | ||
2484 | |||
2485 | __orr32(hsotg->regs + S3C_DCTL, S3C_DCTL_SftDiscon); | ||
2486 | |||
2487 | writel(1 << 18 | S3C_DCFG_DevSpd_HS, hsotg->regs + S3C_DCFG); | ||
2488 | |||
2489 | writel(S3C_GINTSTS_DisconnInt | S3C_GINTSTS_SessReqInt | | ||
2490 | S3C_GINTSTS_ConIDStsChng | S3C_GINTSTS_USBRst | | ||
2491 | S3C_GINTSTS_EnumDone | S3C_GINTSTS_OTGInt | | ||
2492 | S3C_GINTSTS_USBSusp | S3C_GINTSTS_WkUpInt | | ||
2493 | S3C_GINTSTS_GOUTNakEff | S3C_GINTSTS_GINNakEff | | ||
2494 | S3C_GINTSTS_ErlySusp, | ||
2495 | hsotg->regs + S3C_GINTMSK); | ||
2496 | |||
2497 | if (using_dma(hsotg)) | ||
2498 | writel(S3C_GAHBCFG_GlblIntrEn | S3C_GAHBCFG_DMAEn | | ||
2499 | S3C_GAHBCFG_HBstLen_Incr4, | ||
2500 | hsotg->regs + S3C_GAHBCFG); | ||
2501 | else | ||
2502 | writel(S3C_GAHBCFG_GlblIntrEn, hsotg->regs + S3C_GAHBCFG); | ||
2503 | |||
2504 | /* Enabling INTknTXFEmpMsk here seems to be a big mistake, we end | ||
2505 | * up being flooded with interrupts if the host is polling the | ||
2506 | * endpoint to try and read data. */ | ||
2507 | |||
2508 | writel(S3C_DIEPMSK_TimeOUTMsk | S3C_DIEPMSK_AHBErrMsk | | ||
2509 | S3C_DIEPMSK_INTknEPMisMsk | | ||
2510 | S3C_DIEPMSK_EPDisbldMsk | S3C_DIEPMSK_XferComplMsk, | ||
2511 | hsotg->regs + S3C_DIEPMSK); | ||
2512 | |||
2513 | /* don't need XferCompl, we get that from RXFIFO in slave mode. In | ||
2514 | * DMA mode we may need this. */ | ||
2515 | writel(S3C_DOEPMSK_SetupMsk | S3C_DOEPMSK_AHBErrMsk | | ||
2516 | S3C_DOEPMSK_EPDisbldMsk | | ||
2517 | using_dma(hsotg) ? (S3C_DIEPMSK_XferComplMsk | | ||
2518 | S3C_DIEPMSK_TimeOUTMsk) : 0, | ||
2519 | hsotg->regs + S3C_DOEPMSK); | ||
2520 | |||
2521 | writel(0, hsotg->regs + S3C_DAINTMSK); | ||
2522 | |||
2523 | dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n", | ||
2524 | readl(hsotg->regs + S3C_DIEPCTL0), | ||
2525 | readl(hsotg->regs + S3C_DOEPCTL0)); | ||
2526 | |||
2527 | /* enable in and out endpoint interrupts */ | ||
2528 | s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt); | ||
2529 | |||
2530 | /* Enable the RXFIFO when in slave mode, as this is how we collect | ||
2531 | * the data. In DMA mode, we get events from the FIFO but also | ||
2532 | * things we cannot process, so do not use it. */ | ||
2533 | if (!using_dma(hsotg)) | ||
2534 | s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_RxFLvl); | ||
2535 | |||
2536 | /* Enable interrupts for EP0 in and out */ | ||
2537 | s3c_hsotg_ctrl_epint(hsotg, 0, 0, 1); | ||
2538 | s3c_hsotg_ctrl_epint(hsotg, 0, 1, 1); | ||
2539 | |||
2540 | __orr32(hsotg->regs + S3C_DCTL, S3C_DCTL_PWROnPrgDone); | ||
2541 | udelay(10); /* see openiboot */ | ||
2542 | __bic32(hsotg->regs + S3C_DCTL, S3C_DCTL_PWROnPrgDone); | ||
2543 | |||
2544 | dev_info(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + S3C_DCTL)); | ||
2545 | |||
2546 | /* S3C_DxEPCTL_USBActEp says RO in manual, but seems to be set by | ||
2547 | writing to the EPCTL register.. */ | ||
2548 | |||
2549 | /* set to read 1 8byte packet */ | ||
2550 | writel(S3C_DxEPTSIZ_MC(1) | S3C_DxEPTSIZ_PktCnt(1) | | ||
2551 | S3C_DxEPTSIZ_XferSize(8), hsotg->regs + DOEPTSIZ0); | ||
2552 | |||
2553 | writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) | | ||
2554 | S3C_DxEPCTL_CNAK | S3C_DxEPCTL_EPEna | | ||
2555 | S3C_DxEPCTL_USBActEp, | ||
2556 | hsotg->regs + S3C_DOEPCTL0); | ||
2557 | |||
2558 | /* enable, but don't activate EP0in */ | ||
2559 | writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) | | ||
2560 | S3C_DxEPCTL_USBActEp, hsotg->regs + S3C_DIEPCTL0); | ||
2561 | |||
2562 | s3c_hsotg_enqueue_setup(hsotg); | ||
2563 | |||
2564 | dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n", | ||
2565 | readl(hsotg->regs + S3C_DIEPCTL0), | ||
2566 | readl(hsotg->regs + S3C_DOEPCTL0)); | ||
2567 | |||
2568 | /* clear global NAKs */ | ||
2569 | writel(S3C_DCTL_CGOUTNak | S3C_DCTL_CGNPInNAK, | ||
2570 | hsotg->regs + S3C_DCTL); | ||
2571 | |||
2572 | /* remove the soft-disconnect and let's go */ | ||
2573 | __bic32(hsotg->regs + S3C_DCTL, S3C_DCTL_SftDiscon); | ||
2574 | |||
2575 | /* report to the user, and return */ | ||
2576 | |||
2577 | dev_info(hsotg->dev, "bound driver %s\n", driver->driver.name); | ||
2578 | return 0; | ||
2579 | |||
2580 | err: | ||
2581 | hsotg->driver = NULL; | ||
2582 | hsotg->gadget.dev.driver = NULL; | ||
2583 | return ret; | ||
2584 | } | ||
2585 | |||
2586 | int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) | ||
2587 | { | ||
2588 | struct s3c_hsotg *hsotg = our_hsotg; | ||
2589 | int ep; | ||
2590 | |||
2591 | if (!hsotg) | ||
2592 | return -ENODEV; | ||
2593 | |||
2594 | if (!driver || driver != hsotg->driver || !driver->unbind) | ||
2595 | return -EINVAL; | ||
2596 | |||
2597 | /* all endpoints should be shutdown */ | ||
2598 | for (ep = 0; ep < S3C_HSOTG_EPS; ep++) | ||
2599 | s3c_hsotg_ep_disable(&hsotg->eps[ep].ep); | ||
2600 | |||
2601 | call_gadget(hsotg, disconnect); | ||
2602 | |||
2603 | driver->unbind(&hsotg->gadget); | ||
2604 | hsotg->driver = NULL; | ||
2605 | hsotg->gadget.speed = USB_SPEED_UNKNOWN; | ||
2606 | |||
2607 | device_del(&hsotg->gadget.dev); | ||
2608 | |||
2609 | dev_info(hsotg->dev, "unregistered gadget driver '%s'\n", | ||
2610 | driver->driver.name); | ||
2611 | |||
2612 | return 0; | ||
2613 | } | ||
2614 | EXPORT_SYMBOL(usb_gadget_unregister_driver); | ||
2615 | |||
2616 | static int s3c_hsotg_gadget_getframe(struct usb_gadget *gadget) | ||
2617 | { | ||
2618 | return s3c_hsotg_read_frameno(to_hsotg(gadget)); | ||
2619 | } | ||
2620 | |||
2621 | static struct usb_gadget_ops s3c_hsotg_gadget_ops = { | ||
2622 | .get_frame = s3c_hsotg_gadget_getframe, | ||
2623 | }; | ||
2624 | |||
2625 | /** | ||
2626 | * s3c_hsotg_initep - initialise a single endpoint | ||
2627 | * @hsotg: The device state. | ||
2628 | * @hs_ep: The endpoint to be initialised. | ||
2629 | * @epnum: The endpoint number | ||
2630 | * | ||
2631 | * Initialise the given endpoint (as part of the probe and device state | ||
2632 | * creation) to give to the gadget driver. Setup the endpoint name, any | ||
2633 | * direction information and other state that may be required. | ||
2634 | */ | ||
2635 | static void __devinit s3c_hsotg_initep(struct s3c_hsotg *hsotg, | ||
2636 | struct s3c_hsotg_ep *hs_ep, | ||
2637 | int epnum) | ||
2638 | { | ||
2639 | u32 ptxfifo; | ||
2640 | char *dir; | ||
2641 | |||
2642 | if (epnum == 0) | ||
2643 | dir = ""; | ||
2644 | else if ((epnum % 2) == 0) { | ||
2645 | dir = "out"; | ||
2646 | } else { | ||
2647 | dir = "in"; | ||
2648 | hs_ep->dir_in = 1; | ||
2649 | } | ||
2650 | |||
2651 | hs_ep->index = epnum; | ||
2652 | |||
2653 | snprintf(hs_ep->name, sizeof(hs_ep->name), "ep%d%s", epnum, dir); | ||
2654 | |||
2655 | INIT_LIST_HEAD(&hs_ep->queue); | ||
2656 | INIT_LIST_HEAD(&hs_ep->ep.ep_list); | ||
2657 | |||
2658 | spin_lock_init(&hs_ep->lock); | ||
2659 | |||
2660 | /* add to the list of endpoints known by the gadget driver */ | ||
2661 | if (epnum) | ||
2662 | list_add_tail(&hs_ep->ep.ep_list, &hsotg->gadget.ep_list); | ||
2663 | |||
2664 | hs_ep->parent = hsotg; | ||
2665 | hs_ep->ep.name = hs_ep->name; | ||
2666 | hs_ep->ep.maxpacket = epnum ? 512 : EP0_MPS_LIMIT; | ||
2667 | hs_ep->ep.ops = &s3c_hsotg_ep_ops; | ||
2668 | |||
2669 | /* Read the FIFO size for the Periodic TX FIFO, even if we're | ||
2670 | * an OUT endpoint, we may as well do this if in future the | ||
2671 | * code is changed to make each endpoint's direction changeable. | ||
2672 | */ | ||
2673 | |||
2674 | ptxfifo = readl(hsotg->regs + S3C_DPTXFSIZn(epnum)); | ||
2675 | hs_ep->fifo_size = S3C_DPTXFSIZn_DPTxFSize_GET(ptxfifo); | ||
2676 | |||
2677 | /* if we're using dma, we need to set the next-endpoint pointer | ||
2678 | * to be something valid. | ||
2679 | */ | ||
2680 | |||
2681 | if (using_dma(hsotg)) { | ||
2682 | u32 next = S3C_DxEPCTL_NextEp((epnum + 1) % 15); | ||
2683 | writel(next, hsotg->regs + S3C_DIEPCTL(epnum)); | ||
2684 | writel(next, hsotg->regs + S3C_DOEPCTL(epnum)); | ||
2685 | } | ||
2686 | } | ||
2687 | |||
2688 | /** | ||
2689 | * s3c_hsotg_otgreset - reset the OtG phy block | ||
2690 | * @hsotg: The host state. | ||
2691 | * | ||
2692 | * Power up the phy, set the basic configuration and start the PHY. | ||
2693 | */ | ||
2694 | static void s3c_hsotg_otgreset(struct s3c_hsotg *hsotg) | ||
2695 | { | ||
2696 | u32 osc; | ||
2697 | |||
2698 | writel(0, S3C_PHYPWR); | ||
2699 | mdelay(1); | ||
2700 | |||
2701 | osc = hsotg->plat->is_osc ? S3C_PHYCLK_EXT_OSC : 0; | ||
2702 | |||
2703 | writel(osc | 0x10, S3C_PHYCLK); | ||
2704 | |||
2705 | /* issue a full set of resets to the otg and core */ | ||
2706 | |||
2707 | writel(S3C_RSTCON_PHY, S3C_RSTCON); | ||
2708 | udelay(20); /* at-least 10uS */ | ||
2709 | writel(0, S3C_RSTCON); | ||
2710 | } | ||
2711 | |||
2712 | |||
2713 | static void s3c_hsotg_init(struct s3c_hsotg *hsotg) | ||
2714 | { | ||
2715 | /* unmask subset of endpoint interrupts */ | ||
2716 | |||
2717 | writel(S3C_DIEPMSK_TimeOUTMsk | S3C_DIEPMSK_AHBErrMsk | | ||
2718 | S3C_DIEPMSK_EPDisbldMsk | S3C_DIEPMSK_XferComplMsk, | ||
2719 | hsotg->regs + S3C_DIEPMSK); | ||
2720 | |||
2721 | writel(S3C_DOEPMSK_SetupMsk | S3C_DOEPMSK_AHBErrMsk | | ||
2722 | S3C_DOEPMSK_EPDisbldMsk | S3C_DOEPMSK_XferComplMsk, | ||
2723 | hsotg->regs + S3C_DOEPMSK); | ||
2724 | |||
2725 | writel(0, hsotg->regs + S3C_DAINTMSK); | ||
2726 | |||
2727 | if (0) { | ||
2728 | /* post global nak until we're ready */ | ||
2729 | writel(S3C_DCTL_SGNPInNAK | S3C_DCTL_SGOUTNak, | ||
2730 | hsotg->regs + S3C_DCTL); | ||
2731 | } | ||
2732 | |||
2733 | /* setup fifos */ | ||
2734 | |||
2735 | dev_info(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n", | ||
2736 | readl(hsotg->regs + S3C_GRXFSIZ), | ||
2737 | readl(hsotg->regs + S3C_GNPTXFSIZ)); | ||
2738 | |||
2739 | s3c_hsotg_init_fifo(hsotg); | ||
2740 | |||
2741 | /* set the PLL on, remove the HNP/SRP and set the PHY */ | ||
2742 | writel(S3C_GUSBCFG_PHYIf16 | S3C_GUSBCFG_TOutCal(7) | (0x5 << 10), | ||
2743 | hsotg->regs + S3C_GUSBCFG); | ||
2744 | |||
2745 | writel(using_dma(hsotg) ? S3C_GAHBCFG_DMAEn : 0x0, | ||
2746 | hsotg->regs + S3C_GAHBCFG); | ||
2747 | } | ||
2748 | |||
2749 | static void s3c_hsotg_dump(struct s3c_hsotg *hsotg) | ||
2750 | { | ||
2751 | struct device *dev = hsotg->dev; | ||
2752 | void __iomem *regs = hsotg->regs; | ||
2753 | u32 val; | ||
2754 | int idx; | ||
2755 | |||
2756 | dev_info(dev, "DCFG=0x%08x, DCTL=0x%08x, DIEPMSK=%08x\n", | ||
2757 | readl(regs + S3C_DCFG), readl(regs + S3C_DCTL), | ||
2758 | readl(regs + S3C_DIEPMSK)); | ||
2759 | |||
2760 | dev_info(dev, "GAHBCFG=0x%08x, 0x44=0x%08x\n", | ||
2761 | readl(regs + S3C_GAHBCFG), readl(regs + 0x44)); | ||
2762 | |||
2763 | dev_info(dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n", | ||
2764 | readl(regs + S3C_GRXFSIZ), readl(regs + S3C_GNPTXFSIZ)); | ||
2765 | |||
2766 | /* show periodic fifo settings */ | ||
2767 | |||
2768 | for (idx = 1; idx <= 15; idx++) { | ||
2769 | val = readl(regs + S3C_DPTXFSIZn(idx)); | ||
2770 | dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx, | ||
2771 | val >> S3C_DPTXFSIZn_DPTxFSize_SHIFT, | ||
2772 | val & S3C_DPTXFSIZn_DPTxFStAddr_MASK); | ||
2773 | } | ||
2774 | |||
2775 | for (idx = 0; idx < 15; idx++) { | ||
2776 | dev_info(dev, | ||
2777 | "ep%d-in: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n", idx, | ||
2778 | readl(regs + S3C_DIEPCTL(idx)), | ||
2779 | readl(regs + S3C_DIEPTSIZ(idx)), | ||
2780 | readl(regs + S3C_DIEPDMA(idx))); | ||
2781 | |||
2782 | val = readl(regs + S3C_DOEPCTL(idx)); | ||
2783 | dev_info(dev, | ||
2784 | "ep%d-out: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n", | ||
2785 | idx, readl(regs + S3C_DOEPCTL(idx)), | ||
2786 | readl(regs + S3C_DOEPTSIZ(idx)), | ||
2787 | readl(regs + S3C_DOEPDMA(idx))); | ||
2788 | |||
2789 | } | ||
2790 | |||
2791 | dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n", | ||
2792 | readl(regs + S3C_DVBUSDIS), readl(regs + S3C_DVBUSPULSE)); | ||
2793 | } | ||
2794 | |||
2795 | |||
2796 | /** | ||
2797 | * state_show - debugfs: show overall driver and device state. | ||
2798 | * @seq: The seq file to write to. | ||
2799 | * @v: Unused parameter. | ||
2800 | * | ||
2801 | * This debugfs entry shows the overall state of the hardware and | ||
2802 | * some general information about each of the endpoints available | ||
2803 | * to the system. | ||
2804 | */ | ||
2805 | static int state_show(struct seq_file *seq, void *v) | ||
2806 | { | ||
2807 | struct s3c_hsotg *hsotg = seq->private; | ||
2808 | void __iomem *regs = hsotg->regs; | ||
2809 | int idx; | ||
2810 | |||
2811 | seq_printf(seq, "DCFG=0x%08x, DCTL=0x%08x, DSTS=0x%08x\n", | ||
2812 | readl(regs + S3C_DCFG), | ||
2813 | readl(regs + S3C_DCTL), | ||
2814 | readl(regs + S3C_DSTS)); | ||
2815 | |||
2816 | seq_printf(seq, "DIEPMSK=0x%08x, DOEPMASK=0x%08x\n", | ||
2817 | readl(regs + S3C_DIEPMSK), readl(regs + S3C_DOEPMSK)); | ||
2818 | |||
2819 | seq_printf(seq, "GINTMSK=0x%08x, GINTSTS=0x%08x\n", | ||
2820 | readl(regs + S3C_GINTMSK), | ||
2821 | readl(regs + S3C_GINTSTS)); | ||
2822 | |||
2823 | seq_printf(seq, "DAINTMSK=0x%08x, DAINT=0x%08x\n", | ||
2824 | readl(regs + S3C_DAINTMSK), | ||
2825 | readl(regs + S3C_DAINT)); | ||
2826 | |||
2827 | seq_printf(seq, "GNPTXSTS=0x%08x, GRXSTSR=%08x\n", | ||
2828 | readl(regs + S3C_GNPTXSTS), | ||
2829 | readl(regs + S3C_GRXSTSR)); | ||
2830 | |||
2831 | seq_printf(seq, "\nEndpoint status:\n"); | ||
2832 | |||
2833 | for (idx = 0; idx < 15; idx++) { | ||
2834 | u32 in, out; | ||
2835 | |||
2836 | in = readl(regs + S3C_DIEPCTL(idx)); | ||
2837 | out = readl(regs + S3C_DOEPCTL(idx)); | ||
2838 | |||
2839 | seq_printf(seq, "ep%d: DIEPCTL=0x%08x, DOEPCTL=0x%08x", | ||
2840 | idx, in, out); | ||
2841 | |||
2842 | in = readl(regs + S3C_DIEPTSIZ(idx)); | ||
2843 | out = readl(regs + S3C_DOEPTSIZ(idx)); | ||
2844 | |||
2845 | seq_printf(seq, ", DIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x", | ||
2846 | in, out); | ||
2847 | |||
2848 | seq_printf(seq, "\n"); | ||
2849 | } | ||
2850 | |||
2851 | return 0; | ||
2852 | } | ||
2853 | |||
2854 | static int state_open(struct inode *inode, struct file *file) | ||
2855 | { | ||
2856 | return single_open(file, state_show, inode->i_private); | ||
2857 | } | ||
2858 | |||
2859 | static const struct file_operations state_fops = { | ||
2860 | .owner = THIS_MODULE, | ||
2861 | .open = state_open, | ||
2862 | .read = seq_read, | ||
2863 | .llseek = seq_lseek, | ||
2864 | .release = single_release, | ||
2865 | }; | ||
2866 | |||
2867 | /** | ||
2868 | * fifo_show - debugfs: show the fifo information | ||
2869 | * @seq: The seq_file to write data to. | ||
2870 | * @v: Unused parameter. | ||
2871 | * | ||
2872 | * Show the FIFO information for the overall fifo and all the | ||
2873 | * periodic transmission FIFOs. | ||
2874 | */ | ||
2875 | static int fifo_show(struct seq_file *seq, void *v) | ||
2876 | { | ||
2877 | struct s3c_hsotg *hsotg = seq->private; | ||
2878 | void __iomem *regs = hsotg->regs; | ||
2879 | u32 val; | ||
2880 | int idx; | ||
2881 | |||
2882 | seq_printf(seq, "Non-periodic FIFOs:\n"); | ||
2883 | seq_printf(seq, "RXFIFO: Size %d\n", readl(regs + S3C_GRXFSIZ)); | ||
2884 | |||
2885 | val = readl(regs + S3C_GNPTXFSIZ); | ||
2886 | seq_printf(seq, "NPTXFIFO: Size %d, Start 0x%08x\n", | ||
2887 | val >> S3C_GNPTXFSIZ_NPTxFDep_SHIFT, | ||
2888 | val & S3C_GNPTXFSIZ_NPTxFStAddr_MASK); | ||
2889 | |||
2890 | seq_printf(seq, "\nPeriodic TXFIFOs:\n"); | ||
2891 | |||
2892 | for (idx = 1; idx <= 15; idx++) { | ||
2893 | val = readl(regs + S3C_DPTXFSIZn(idx)); | ||
2894 | |||
2895 | seq_printf(seq, "\tDPTXFIFO%2d: Size %d, Start 0x%08x\n", idx, | ||
2896 | val >> S3C_DPTXFSIZn_DPTxFSize_SHIFT, | ||
2897 | val & S3C_DPTXFSIZn_DPTxFStAddr_MASK); | ||
2898 | } | ||
2899 | |||
2900 | return 0; | ||
2901 | } | ||
2902 | |||
2903 | static int fifo_open(struct inode *inode, struct file *file) | ||
2904 | { | ||
2905 | return single_open(file, fifo_show, inode->i_private); | ||
2906 | } | ||
2907 | |||
2908 | static const struct file_operations fifo_fops = { | ||
2909 | .owner = THIS_MODULE, | ||
2910 | .open = fifo_open, | ||
2911 | .read = seq_read, | ||
2912 | .llseek = seq_lseek, | ||
2913 | .release = single_release, | ||
2914 | }; | ||
2915 | |||
2916 | |||
2917 | static const char *decode_direction(int is_in) | ||
2918 | { | ||
2919 | return is_in ? "in" : "out"; | ||
2920 | } | ||
2921 | |||
2922 | /** | ||
2923 | * ep_show - debugfs: show the state of an endpoint. | ||
2924 | * @seq: The seq_file to write data to. | ||
2925 | * @v: Unused parameter. | ||
2926 | * | ||
2927 | * This debugfs entry shows the state of the given endpoint (one is | ||
2928 | * registered for each available). | ||
2929 | */ | ||
2930 | static int ep_show(struct seq_file *seq, void *v) | ||
2931 | { | ||
2932 | struct s3c_hsotg_ep *ep = seq->private; | ||
2933 | struct s3c_hsotg *hsotg = ep->parent; | ||
2934 | struct s3c_hsotg_req *req; | ||
2935 | void __iomem *regs = hsotg->regs; | ||
2936 | int index = ep->index; | ||
2937 | int show_limit = 15; | ||
2938 | unsigned long flags; | ||
2939 | |||
2940 | seq_printf(seq, "Endpoint index %d, named %s, dir %s:\n", | ||
2941 | ep->index, ep->ep.name, decode_direction(ep->dir_in)); | ||
2942 | |||
2943 | /* first show the register state */ | ||
2944 | |||
2945 | seq_printf(seq, "\tDIEPCTL=0x%08x, DOEPCTL=0x%08x\n", | ||
2946 | readl(regs + S3C_DIEPCTL(index)), | ||
2947 | readl(regs + S3C_DOEPCTL(index))); | ||
2948 | |||
2949 | seq_printf(seq, "\tDIEPDMA=0x%08x, DOEPDMA=0x%08x\n", | ||
2950 | readl(regs + S3C_DIEPDMA(index)), | ||
2951 | readl(regs + S3C_DOEPDMA(index))); | ||
2952 | |||
2953 | seq_printf(seq, "\tDIEPINT=0x%08x, DOEPINT=0x%08x\n", | ||
2954 | readl(regs + S3C_DIEPINT(index)), | ||
2955 | readl(regs + S3C_DOEPINT(index))); | ||
2956 | |||
2957 | seq_printf(seq, "\tDIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x\n", | ||
2958 | readl(regs + S3C_DIEPTSIZ(index)), | ||
2959 | readl(regs + S3C_DOEPTSIZ(index))); | ||
2960 | |||
2961 | seq_printf(seq, "\n"); | ||
2962 | seq_printf(seq, "mps %d\n", ep->ep.maxpacket); | ||
2963 | seq_printf(seq, "total_data=%ld\n", ep->total_data); | ||
2964 | |||
2965 | seq_printf(seq, "request list (%p,%p):\n", | ||
2966 | ep->queue.next, ep->queue.prev); | ||
2967 | |||
2968 | spin_lock_irqsave(&ep->lock, flags); | ||
2969 | |||
2970 | list_for_each_entry(req, &ep->queue, queue) { | ||
2971 | if (--show_limit < 0) { | ||
2972 | seq_printf(seq, "not showing more requests...\n"); | ||
2973 | break; | ||
2974 | } | ||
2975 | |||
2976 | seq_printf(seq, "%c req %p: %d bytes @%p, ", | ||
2977 | req == ep->req ? '*' : ' ', | ||
2978 | req, req->req.length, req->req.buf); | ||
2979 | seq_printf(seq, "%d done, res %d\n", | ||
2980 | req->req.actual, req->req.status); | ||
2981 | } | ||
2982 | |||
2983 | spin_unlock_irqrestore(&ep->lock, flags); | ||
2984 | |||
2985 | return 0; | ||
2986 | } | ||
2987 | |||
2988 | static int ep_open(struct inode *inode, struct file *file) | ||
2989 | { | ||
2990 | return single_open(file, ep_show, inode->i_private); | ||
2991 | } | ||
2992 | |||
2993 | static const struct file_operations ep_fops = { | ||
2994 | .owner = THIS_MODULE, | ||
2995 | .open = ep_open, | ||
2996 | .read = seq_read, | ||
2997 | .llseek = seq_lseek, | ||
2998 | .release = single_release, | ||
2999 | }; | ||
3000 | |||
3001 | /** | ||
3002 | * s3c_hsotg_create_debug - create debugfs directory and files | ||
3003 | * @hsotg: The driver state | ||
3004 | * | ||
3005 | * Create the debugfs files to allow the user to get information | ||
3006 | * about the state of the system. The directory name is created | ||
3007 | * with the same name as the device itself, in case we end up | ||
3008 | * with multiple blocks in future systems. | ||
3009 | */ | ||
3010 | static void __devinit s3c_hsotg_create_debug(struct s3c_hsotg *hsotg) | ||
3011 | { | ||
3012 | struct dentry *root; | ||
3013 | unsigned epidx; | ||
3014 | |||
3015 | root = debugfs_create_dir(dev_name(hsotg->dev), NULL); | ||
3016 | hsotg->debug_root = root; | ||
3017 | if (IS_ERR(root)) { | ||
3018 | dev_err(hsotg->dev, "cannot create debug root\n"); | ||
3019 | return; | ||
3020 | } | ||
3021 | |||
3022 | /* create general state file */ | ||
3023 | |||
3024 | hsotg->debug_file = debugfs_create_file("state", 0444, root, | ||
3025 | hsotg, &state_fops); | ||
3026 | |||
3027 | if (IS_ERR(hsotg->debug_file)) | ||
3028 | dev_err(hsotg->dev, "%s: failed to create state\n", __func__); | ||
3029 | |||
3030 | hsotg->debug_fifo = debugfs_create_file("fifo", 0444, root, | ||
3031 | hsotg, &fifo_fops); | ||
3032 | |||
3033 | if (IS_ERR(hsotg->debug_fifo)) | ||
3034 | dev_err(hsotg->dev, "%s: failed to create fifo\n", __func__); | ||
3035 | |||
3036 | /* create one file for each endpoint */ | ||
3037 | |||
3038 | for (epidx = 0; epidx < S3C_HSOTG_EPS; epidx++) { | ||
3039 | struct s3c_hsotg_ep *ep = &hsotg->eps[epidx]; | ||
3040 | |||
3041 | ep->debugfs = debugfs_create_file(ep->name, 0444, | ||
3042 | root, ep, &ep_fops); | ||
3043 | |||
3044 | if (IS_ERR(ep->debugfs)) | ||
3045 | dev_err(hsotg->dev, "failed to create %s debug file\n", | ||
3046 | ep->name); | ||
3047 | } | ||
3048 | } | ||
3049 | |||
3050 | /** | ||
3051 | * s3c_hsotg_delete_debug - cleanup debugfs entries | ||
3052 | * @hsotg: The driver state | ||
3053 | * | ||
3054 | * Cleanup (remove) the debugfs files for use on module exit. | ||
3055 | */ | ||
3056 | static void __devexit s3c_hsotg_delete_debug(struct s3c_hsotg *hsotg) | ||
3057 | { | ||
3058 | unsigned epidx; | ||
3059 | |||
3060 | for (epidx = 0; epidx < S3C_HSOTG_EPS; epidx++) { | ||
3061 | struct s3c_hsotg_ep *ep = &hsotg->eps[epidx]; | ||
3062 | debugfs_remove(ep->debugfs); | ||
3063 | } | ||
3064 | |||
3065 | debugfs_remove(hsotg->debug_file); | ||
3066 | debugfs_remove(hsotg->debug_fifo); | ||
3067 | debugfs_remove(hsotg->debug_root); | ||
3068 | } | ||
3069 | |||
3070 | /** | ||
3071 | * s3c_hsotg_gate - set the hardware gate for the block | ||
3072 | * @pdev: The device we bound to | ||
3073 | * @on: On or off. | ||
3074 | * | ||
3075 | * Set the hardware gate setting into the block. If we end up on | ||
3076 | * something other than an S3C64XX, then we might need to change this | ||
3077 | * to using a platform data callback, or some other mechanism. | ||
3078 | */ | ||
3079 | static void s3c_hsotg_gate(struct platform_device *pdev, bool on) | ||
3080 | { | ||
3081 | unsigned long flags; | ||
3082 | u32 others; | ||
3083 | |||
3084 | local_irq_save(flags); | ||
3085 | |||
3086 | others = __raw_readl(S3C64XX_OTHERS); | ||
3087 | if (on) | ||
3088 | others |= S3C64XX_OTHERS_USBMASK; | ||
3089 | else | ||
3090 | others &= ~S3C64XX_OTHERS_USBMASK; | ||
3091 | __raw_writel(others, S3C64XX_OTHERS); | ||
3092 | |||
3093 | local_irq_restore(flags); | ||
3094 | } | ||
3095 | |||
3096 | struct s3c_hsotg_plat s3c_hsotg_default_pdata; | ||
3097 | |||
3098 | static int __devinit s3c_hsotg_probe(struct platform_device *pdev) | ||
3099 | { | ||
3100 | struct s3c_hsotg_plat *plat = pdev->dev.platform_data; | ||
3101 | struct device *dev = &pdev->dev; | ||
3102 | struct s3c_hsotg *hsotg; | ||
3103 | struct resource *res; | ||
3104 | int epnum; | ||
3105 | int ret; | ||
3106 | |||
3107 | if (!plat) | ||
3108 | plat = &s3c_hsotg_default_pdata; | ||
3109 | |||
3110 | hsotg = kzalloc(sizeof(struct s3c_hsotg) + | ||
3111 | sizeof(struct s3c_hsotg_ep) * S3C_HSOTG_EPS, | ||
3112 | GFP_KERNEL); | ||
3113 | if (!hsotg) { | ||
3114 | dev_err(dev, "cannot get memory\n"); | ||
3115 | return -ENOMEM; | ||
3116 | } | ||
3117 | |||
3118 | hsotg->dev = dev; | ||
3119 | hsotg->plat = plat; | ||
3120 | |||
3121 | platform_set_drvdata(pdev, hsotg); | ||
3122 | |||
3123 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
3124 | if (!res) { | ||
3125 | dev_err(dev, "cannot find register resource 0\n"); | ||
3126 | ret = -EINVAL; | ||
3127 | goto err_mem; | ||
3128 | } | ||
3129 | |||
3130 | hsotg->regs_res = request_mem_region(res->start, resource_size(res), | ||
3131 | dev_name(dev)); | ||
3132 | if (!hsotg->regs_res) { | ||
3133 | dev_err(dev, "cannot reserve registers\n"); | ||
3134 | ret = -ENOENT; | ||
3135 | goto err_mem; | ||
3136 | } | ||
3137 | |||
3138 | hsotg->regs = ioremap(res->start, resource_size(res)); | ||
3139 | if (!hsotg->regs) { | ||
3140 | dev_err(dev, "cannot map registers\n"); | ||
3141 | ret = -ENXIO; | ||
3142 | goto err_regs_res; | ||
3143 | } | ||
3144 | |||
3145 | ret = platform_get_irq(pdev, 0); | ||
3146 | if (ret < 0) { | ||
3147 | dev_err(dev, "cannot find IRQ\n"); | ||
3148 | goto err_regs; | ||
3149 | } | ||
3150 | |||
3151 | hsotg->irq = ret; | ||
3152 | |||
3153 | ret = request_irq(ret, s3c_hsotg_irq, 0, dev_name(dev), hsotg); | ||
3154 | if (ret < 0) { | ||
3155 | dev_err(dev, "cannot claim IRQ\n"); | ||
3156 | goto err_regs; | ||
3157 | } | ||
3158 | |||
3159 | dev_info(dev, "regs %p, irq %d\n", hsotg->regs, hsotg->irq); | ||
3160 | |||
3161 | device_initialize(&hsotg->gadget.dev); | ||
3162 | |||
3163 | dev_set_name(&hsotg->gadget.dev, "gadget"); | ||
3164 | |||
3165 | hsotg->gadget.is_dualspeed = 1; | ||
3166 | hsotg->gadget.ops = &s3c_hsotg_gadget_ops; | ||
3167 | hsotg->gadget.name = dev_name(dev); | ||
3168 | |||
3169 | hsotg->gadget.dev.parent = dev; | ||
3170 | hsotg->gadget.dev.dma_mask = dev->dma_mask; | ||
3171 | |||
3172 | /* setup endpoint information */ | ||
3173 | |||
3174 | INIT_LIST_HEAD(&hsotg->gadget.ep_list); | ||
3175 | hsotg->gadget.ep0 = &hsotg->eps[0].ep; | ||
3176 | |||
3177 | /* allocate EP0 request */ | ||
3178 | |||
3179 | hsotg->ctrl_req = s3c_hsotg_ep_alloc_request(&hsotg->eps[0].ep, | ||
3180 | GFP_KERNEL); | ||
3181 | if (!hsotg->ctrl_req) { | ||
3182 | dev_err(dev, "failed to allocate ctrl req\n"); | ||
3183 | goto err_regs; | ||
3184 | } | ||
3185 | |||
3186 | /* reset the system */ | ||
3187 | |||
3188 | s3c_hsotg_gate(pdev, true); | ||
3189 | |||
3190 | s3c_hsotg_otgreset(hsotg); | ||
3191 | s3c_hsotg_corereset(hsotg); | ||
3192 | s3c_hsotg_init(hsotg); | ||
3193 | |||
3194 | /* initialise the endpoints now the core has been initialised */ | ||
3195 | for (epnum = 0; epnum < S3C_HSOTG_EPS; epnum++) | ||
3196 | s3c_hsotg_initep(hsotg, &hsotg->eps[epnum], epnum); | ||
3197 | |||
3198 | s3c_hsotg_create_debug(hsotg); | ||
3199 | |||
3200 | s3c_hsotg_dump(hsotg); | ||
3201 | |||
3202 | our_hsotg = hsotg; | ||
3203 | return 0; | ||
3204 | |||
3205 | err_regs: | ||
3206 | iounmap(hsotg->regs); | ||
3207 | |||
3208 | err_regs_res: | ||
3209 | release_resource(hsotg->regs_res); | ||
3210 | kfree(hsotg->regs_res); | ||
3211 | |||
3212 | err_mem: | ||
3213 | kfree(hsotg); | ||
3214 | return ret; | ||
3215 | } | ||
3216 | |||
3217 | static int __devexit s3c_hsotg_remove(struct platform_device *pdev) | ||
3218 | { | ||
3219 | struct s3c_hsotg *hsotg = platform_get_drvdata(pdev); | ||
3220 | |||
3221 | s3c_hsotg_delete_debug(hsotg); | ||
3222 | |||
3223 | usb_gadget_unregister_driver(hsotg->driver); | ||
3224 | |||
3225 | free_irq(hsotg->irq, hsotg); | ||
3226 | iounmap(hsotg->regs); | ||
3227 | |||
3228 | release_resource(hsotg->regs_res); | ||
3229 | kfree(hsotg->regs_res); | ||
3230 | |||
3231 | s3c_hsotg_gate(pdev, false); | ||
3232 | |||
3233 | kfree(hsotg); | ||
3234 | return 0; | ||
3235 | } | ||
3236 | |||
3237 | #if 1 | ||
3238 | #define s3c_hsotg_suspend NULL | ||
3239 | #define s3c_hsotg_resume NULL | ||
3240 | #endif | ||
3241 | |||
3242 | static struct platform_driver s3c_hsotg_driver = { | ||
3243 | .driver = { | ||
3244 | .name = "s3c-hsotg", | ||
3245 | .owner = THIS_MODULE, | ||
3246 | }, | ||
3247 | .probe = s3c_hsotg_probe, | ||
3248 | .remove = __devexit_p(s3c_hsotg_remove), | ||
3249 | .suspend = s3c_hsotg_suspend, | ||
3250 | .resume = s3c_hsotg_resume, | ||
3251 | }; | ||
3252 | |||
3253 | static int __init s3c_hsotg_modinit(void) | ||
3254 | { | ||
3255 | return platform_driver_register(&s3c_hsotg_driver); | ||
3256 | } | ||
3257 | |||
3258 | static void __exit s3c_hsotg_modexit(void) | ||
3259 | { | ||
3260 | platform_driver_unregister(&s3c_hsotg_driver); | ||
3261 | } | ||
3262 | |||
3263 | module_init(s3c_hsotg_modinit); | ||
3264 | module_exit(s3c_hsotg_modexit); | ||
3265 | |||
3266 | MODULE_DESCRIPTION("Samsung S3C USB High-speed/OtG device"); | ||
3267 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); | ||
3268 | MODULE_LICENSE("GPL"); | ||
3269 | MODULE_ALIAS("platform:s3c-hsotg"); | ||
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_audio.c new file mode 100644 index 000000000000..0f3d22fc030e --- /dev/null +++ b/drivers/usb/gadget/u_audio.c | |||
@@ -0,0 +1,319 @@ | |||
1 | /* | ||
2 | * u_audio.c -- ALSA audio utilities for Gadget stack | ||
3 | * | ||
4 | * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> | ||
5 | * Copyright (C) 2008 Analog Devices, Inc | ||
6 | * | ||
7 | * Enter bugs at http://blackfin.uclinux.org/ | ||
8 | * | ||
9 | * Licensed under the GPL-2 or later. | ||
10 | */ | ||
11 | |||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/utsname.h> | ||
14 | #include <linux/device.h> | ||
15 | #include <linux/delay.h> | ||
16 | #include <linux/ctype.h> | ||
17 | #include <linux/random.h> | ||
18 | #include <linux/syscalls.h> | ||
19 | |||
20 | #include "u_audio.h" | ||
21 | |||
22 | /* | ||
23 | * This component encapsulates the ALSA devices for USB audio gadget | ||
24 | */ | ||
25 | |||
26 | #define FILE_PCM_PLAYBACK "/dev/snd/pcmC0D0p" | ||
27 | #define FILE_PCM_CAPTURE "/dev/snd/pcmC0D0c" | ||
28 | #define FILE_CONTROL "/dev/snd/controlC0" | ||
29 | |||
30 | static char *fn_play = FILE_PCM_PLAYBACK; | ||
31 | module_param(fn_play, charp, S_IRUGO); | ||
32 | MODULE_PARM_DESC(fn_play, "Playback PCM device file name"); | ||
33 | |||
34 | static char *fn_cap = FILE_PCM_CAPTURE; | ||
35 | module_param(fn_cap, charp, S_IRUGO); | ||
36 | MODULE_PARM_DESC(fn_cap, "Capture PCM device file name"); | ||
37 | |||
38 | static char *fn_cntl = FILE_CONTROL; | ||
39 | module_param(fn_cntl, charp, S_IRUGO); | ||
40 | MODULE_PARM_DESC(fn_cntl, "Control device file name"); | ||
41 | |||
42 | /*-------------------------------------------------------------------------*/ | ||
43 | |||
44 | /** | ||
45 | * Some ALSA internal helper functions | ||
46 | */ | ||
47 | static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) | ||
48 | { | ||
49 | struct snd_interval t; | ||
50 | t.empty = 0; | ||
51 | t.min = t.max = val; | ||
52 | t.openmin = t.openmax = 0; | ||
53 | t.integer = 1; | ||
54 | return snd_interval_refine(i, &t); | ||
55 | } | ||
56 | |||
57 | static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, | ||
58 | snd_pcm_hw_param_t var, unsigned int val, | ||
59 | int dir) | ||
60 | { | ||
61 | int changed; | ||
62 | if (hw_is_mask(var)) { | ||
63 | struct snd_mask *m = hw_param_mask(params, var); | ||
64 | if (val == 0 && dir < 0) { | ||
65 | changed = -EINVAL; | ||
66 | snd_mask_none(m); | ||
67 | } else { | ||
68 | if (dir > 0) | ||
69 | val++; | ||
70 | else if (dir < 0) | ||
71 | val--; | ||
72 | changed = snd_mask_refine_set( | ||
73 | hw_param_mask(params, var), val); | ||
74 | } | ||
75 | } else if (hw_is_interval(var)) { | ||
76 | struct snd_interval *i = hw_param_interval(params, var); | ||
77 | if (val == 0 && dir < 0) { | ||
78 | changed = -EINVAL; | ||
79 | snd_interval_none(i); | ||
80 | } else if (dir == 0) | ||
81 | changed = snd_interval_refine_set(i, val); | ||
82 | else { | ||
83 | struct snd_interval t; | ||
84 | t.openmin = 1; | ||
85 | t.openmax = 1; | ||
86 | t.empty = 0; | ||
87 | t.integer = 0; | ||
88 | if (dir < 0) { | ||
89 | t.min = val - 1; | ||
90 | t.max = val; | ||
91 | } else { | ||
92 | t.min = val; | ||
93 | t.max = val+1; | ||
94 | } | ||
95 | changed = snd_interval_refine(i, &t); | ||
96 | } | ||
97 | } else | ||
98 | return -EINVAL; | ||
99 | if (changed) { | ||
100 | params->cmask |= 1 << var; | ||
101 | params->rmask |= 1 << var; | ||
102 | } | ||
103 | return changed; | ||
104 | } | ||
105 | /*-------------------------------------------------------------------------*/ | ||
106 | |||
107 | /** | ||
108 | * Set default hardware params | ||
109 | */ | ||
110 | static int playback_default_hw_params(struct gaudio_snd_dev *snd) | ||
111 | { | ||
112 | struct snd_pcm_substream *substream = snd->substream; | ||
113 | struct snd_pcm_hw_params *params; | ||
114 | snd_pcm_sframes_t result; | ||
115 | |||
116 | /* | ||
117 | * SNDRV_PCM_ACCESS_RW_INTERLEAVED, | ||
118 | * SNDRV_PCM_FORMAT_S16_LE | ||
119 | * CHANNELS: 2 | ||
120 | * RATE: 48000 | ||
121 | */ | ||
122 | snd->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; | ||
123 | snd->format = SNDRV_PCM_FORMAT_S16_LE; | ||
124 | snd->channels = 2; | ||
125 | snd->rate = 48000; | ||
126 | |||
127 | params = kzalloc(sizeof(*params), GFP_KERNEL); | ||
128 | if (!params) | ||
129 | return -ENOMEM; | ||
130 | |||
131 | _snd_pcm_hw_params_any(params); | ||
132 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS, | ||
133 | snd->access, 0); | ||
134 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT, | ||
135 | snd->format, 0); | ||
136 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS, | ||
137 | snd->channels, 0); | ||
138 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE, | ||
139 | snd->rate, 0); | ||
140 | |||
141 | snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL); | ||
142 | snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, params); | ||
143 | |||
144 | result = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL); | ||
145 | if (result < 0) { | ||
146 | ERROR(snd->card, | ||
147 | "Preparing sound card failed: %d\n", (int)result); | ||
148 | kfree(params); | ||
149 | return result; | ||
150 | } | ||
151 | |||
152 | /* Store the hardware parameters */ | ||
153 | snd->access = params_access(params); | ||
154 | snd->format = params_format(params); | ||
155 | snd->channels = params_channels(params); | ||
156 | snd->rate = params_rate(params); | ||
157 | |||
158 | kfree(params); | ||
159 | |||
160 | INFO(snd->card, | ||
161 | "Hardware params: access %x, format %x, channels %d, rate %d\n", | ||
162 | snd->access, snd->format, snd->channels, snd->rate); | ||
163 | |||
164 | return 0; | ||
165 | } | ||
166 | |||
167 | /** | ||
168 | * Playback audio buffer data by ALSA PCM device | ||
169 | */ | ||
170 | static size_t u_audio_playback(struct gaudio *card, void *buf, size_t count) | ||
171 | { | ||
172 | struct gaudio_snd_dev *snd = &card->playback; | ||
173 | struct snd_pcm_substream *substream = snd->substream; | ||
174 | struct snd_pcm_runtime *runtime = substream->runtime; | ||
175 | mm_segment_t old_fs; | ||
176 | ssize_t result; | ||
177 | snd_pcm_sframes_t frames; | ||
178 | |||
179 | try_again: | ||
180 | if (runtime->status->state == SNDRV_PCM_STATE_XRUN || | ||
181 | runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) { | ||
182 | result = snd_pcm_kernel_ioctl(substream, | ||
183 | SNDRV_PCM_IOCTL_PREPARE, NULL); | ||
184 | if (result < 0) { | ||
185 | ERROR(card, "Preparing sound card failed: %d\n", | ||
186 | (int)result); | ||
187 | return result; | ||
188 | } | ||
189 | } | ||
190 | |||
191 | frames = bytes_to_frames(runtime, count); | ||
192 | old_fs = get_fs(); | ||
193 | set_fs(KERNEL_DS); | ||
194 | result = snd_pcm_lib_write(snd->substream, buf, frames); | ||
195 | if (result != frames) { | ||
196 | ERROR(card, "Playback error: %d\n", (int)result); | ||
197 | set_fs(old_fs); | ||
198 | goto try_again; | ||
199 | } | ||
200 | set_fs(old_fs); | ||
201 | |||
202 | return 0; | ||
203 | } | ||
204 | |||
205 | static int u_audio_get_playback_channels(struct gaudio *card) | ||
206 | { | ||
207 | return card->playback.channels; | ||
208 | } | ||
209 | |||
210 | static int u_audio_get_playback_rate(struct gaudio *card) | ||
211 | { | ||
212 | return card->playback.rate; | ||
213 | } | ||
214 | |||
215 | /** | ||
216 | * Open ALSA PCM and control device files | ||
217 | * Initial the PCM or control device | ||
218 | */ | ||
219 | static int gaudio_open_snd_dev(struct gaudio *card) | ||
220 | { | ||
221 | struct snd_pcm_file *pcm_file; | ||
222 | struct gaudio_snd_dev *snd; | ||
223 | |||
224 | if (!card) | ||
225 | return -ENODEV; | ||
226 | |||
227 | /* Open control device */ | ||
228 | snd = &card->control; | ||
229 | snd->filp = filp_open(fn_cntl, O_RDWR, 0); | ||
230 | if (IS_ERR(snd->filp)) { | ||
231 | int ret = PTR_ERR(snd->filp); | ||
232 | ERROR(card, "unable to open sound control device file: %s\n", | ||
233 | fn_cntl); | ||
234 | snd->filp = NULL; | ||
235 | return ret; | ||
236 | } | ||
237 | snd->card = card; | ||
238 | |||
239 | /* Open PCM playback device and setup substream */ | ||
240 | snd = &card->playback; | ||
241 | snd->filp = filp_open(fn_play, O_WRONLY, 0); | ||
242 | if (IS_ERR(snd->filp)) { | ||
243 | ERROR(card, "No such PCM playback device: %s\n", fn_play); | ||
244 | snd->filp = NULL; | ||
245 | } | ||
246 | pcm_file = snd->filp->private_data; | ||
247 | snd->substream = pcm_file->substream; | ||
248 | snd->card = card; | ||
249 | playback_default_hw_params(snd); | ||
250 | |||
251 | /* Open PCM capture device and setup substream */ | ||
252 | snd = &card->capture; | ||
253 | snd->filp = filp_open(fn_cap, O_RDONLY, 0); | ||
254 | if (IS_ERR(snd->filp)) { | ||
255 | ERROR(card, "No such PCM capture device: %s\n", fn_cap); | ||
256 | snd->filp = NULL; | ||
257 | } | ||
258 | pcm_file = snd->filp->private_data; | ||
259 | snd->substream = pcm_file->substream; | ||
260 | snd->card = card; | ||
261 | |||
262 | return 0; | ||
263 | } | ||
264 | |||
265 | /** | ||
266 | * Close ALSA PCM and control device files | ||
267 | */ | ||
268 | static int gaudio_close_snd_dev(struct gaudio *gau) | ||
269 | { | ||
270 | struct gaudio_snd_dev *snd; | ||
271 | |||
272 | /* Close control device */ | ||
273 | snd = &gau->control; | ||
274 | if (!IS_ERR(snd->filp)) | ||
275 | filp_close(snd->filp, current->files); | ||
276 | |||
277 | /* Close PCM playback device and setup substream */ | ||
278 | snd = &gau->playback; | ||
279 | if (!IS_ERR(snd->filp)) | ||
280 | filp_close(snd->filp, current->files); | ||
281 | |||
282 | /* Close PCM capture device and setup substream */ | ||
283 | snd = &gau->capture; | ||
284 | if (!IS_ERR(snd->filp)) | ||
285 | filp_close(snd->filp, current->files); | ||
286 | |||
287 | return 0; | ||
288 | } | ||
289 | |||
290 | /** | ||
291 | * gaudio_setup - setup ALSA interface and preparing for USB transfer | ||
292 | * | ||
293 | * This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using. | ||
294 | * | ||
295 | * Returns negative errno, or zero on success | ||
296 | */ | ||
297 | int __init gaudio_setup(struct gaudio *card) | ||
298 | { | ||
299 | int ret; | ||
300 | |||
301 | ret = gaudio_open_snd_dev(card); | ||
302 | if (ret) | ||
303 | ERROR(card, "we need at least one control device\n"); | ||
304 | |||
305 | return ret; | ||
306 | |||
307 | } | ||
308 | |||
309 | /** | ||
310 | * gaudio_cleanup - remove ALSA device interface | ||
311 | * | ||
312 | * This is called to free all resources allocated by @gaudio_setup(). | ||
313 | */ | ||
314 | void gaudio_cleanup(struct gaudio *card) | ||
315 | { | ||
316 | if (card) | ||
317 | gaudio_close_snd_dev(card); | ||
318 | } | ||
319 | |||
diff --git a/drivers/usb/gadget/u_audio.h b/drivers/usb/gadget/u_audio.h new file mode 100644 index 000000000000..cc8d159c648a --- /dev/null +++ b/drivers/usb/gadget/u_audio.h | |||
@@ -0,0 +1,56 @@ | |||
1 | /* | ||
2 | * u_audio.h -- interface to USB gadget "ALSA AUDIO" utilities | ||
3 | * | ||
4 | * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> | ||
5 | * Copyright (C) 2008 Analog Devices, Inc | ||
6 | * | ||
7 | * Enter bugs at http://blackfin.uclinux.org/ | ||
8 | * | ||
9 | * Licensed under the GPL-2 or later. | ||
10 | */ | ||
11 | |||
12 | #ifndef __U_AUDIO_H | ||
13 | #define __U_AUDIO_H | ||
14 | |||
15 | #include <linux/device.h> | ||
16 | #include <linux/err.h> | ||
17 | #include <linux/usb/audio.h> | ||
18 | #include <linux/usb/composite.h> | ||
19 | |||
20 | #include <sound/core.h> | ||
21 | #include <sound/pcm.h> | ||
22 | #include <sound/pcm_params.h> | ||
23 | |||
24 | #include "gadget_chips.h" | ||
25 | |||
26 | /* | ||
27 | * This represents the USB side of an audio card device, managed by a USB | ||
28 | * function which provides control and stream interfaces. | ||
29 | */ | ||
30 | |||
31 | struct gaudio_snd_dev { | ||
32 | struct gaudio *card; | ||
33 | struct file *filp; | ||
34 | struct snd_pcm_substream *substream; | ||
35 | int access; | ||
36 | int format; | ||
37 | int channels; | ||
38 | int rate; | ||
39 | }; | ||
40 | |||
41 | struct gaudio { | ||
42 | struct usb_function func; | ||
43 | struct usb_gadget *gadget; | ||
44 | |||
45 | /* ALSA sound device interfaces */ | ||
46 | struct gaudio_snd_dev control; | ||
47 | struct gaudio_snd_dev playback; | ||
48 | struct gaudio_snd_dev capture; | ||
49 | |||
50 | /* TODO */ | ||
51 | }; | ||
52 | |||
53 | int gaudio_setup(struct gaudio *card); | ||
54 | void gaudio_cleanup(struct gaudio *card); | ||
55 | |||
56 | #endif /* __U_AUDIO_H */ | ||
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c index 0a4d99ab40d8..fc6e709f45b1 100644 --- a/drivers/usb/gadget/u_serial.c +++ b/drivers/usb/gadget/u_serial.c | |||
@@ -371,6 +371,7 @@ __acquires(&port->port_lock) | |||
371 | 371 | ||
372 | req->length = len; | 372 | req->length = len; |
373 | list_del(&req->list); | 373 | list_del(&req->list); |
374 | req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0); | ||
374 | 375 | ||
375 | pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n", | 376 | pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n", |
376 | port->port_num, len, *((u8 *)req->buf), | 377 | port->port_num, len, *((u8 *)req->buf), |
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig index 845479f7c707..1576a0520adf 100644 --- a/drivers/usb/host/Kconfig +++ b/drivers/usb/host/Kconfig | |||
@@ -17,6 +17,26 @@ config USB_C67X00_HCD | |||
17 | To compile this driver as a module, choose M here: the | 17 | To compile this driver as a module, choose M here: the |
18 | module will be called c67x00. | 18 | module will be called c67x00. |
19 | 19 | ||
20 | config USB_XHCI_HCD | ||
21 | tristate "xHCI HCD (USB 3.0) support (EXPERIMENTAL)" | ||
22 | depends on USB && PCI && EXPERIMENTAL | ||
23 | ---help--- | ||
24 | The eXtensible Host Controller Interface (xHCI) is standard for USB 3.0 | ||
25 | "SuperSpeed" host controller hardware. | ||
26 | |||
27 | To compile this driver as a module, choose M here: the | ||
28 | module will be called xhci-hcd. | ||
29 | |||
30 | config USB_XHCI_HCD_DEBUGGING | ||
31 | bool "Debugging for the xHCI host controller" | ||
32 | depends on USB_XHCI_HCD | ||
33 | ---help--- | ||
34 | Say 'Y' to turn on debugging for the xHCI host controller driver. | ||
35 | This will spew debugging output, even in interrupt context. | ||
36 | This should only be used for debugging xHCI driver bugs. | ||
37 | |||
38 | If unsure, say N. | ||
39 | |||
20 | config USB_EHCI_HCD | 40 | config USB_EHCI_HCD |
21 | tristate "EHCI HCD (USB 2.0) support" | 41 | tristate "EHCI HCD (USB 2.0) support" |
22 | depends on USB && USB_ARCH_HAS_EHCI | 42 | depends on USB && USB_ARCH_HAS_EHCI |
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile index f163571e33d8..289d748bb414 100644 --- a/drivers/usb/host/Makefile +++ b/drivers/usb/host/Makefile | |||
@@ -12,6 +12,7 @@ fhci-objs := fhci-hcd.o fhci-hub.o fhci-q.o fhci-mem.o \ | |||
12 | ifeq ($(CONFIG_FHCI_DEBUG),y) | 12 | ifeq ($(CONFIG_FHCI_DEBUG),y) |
13 | fhci-objs += fhci-dbg.o | 13 | fhci-objs += fhci-dbg.o |
14 | endif | 14 | endif |
15 | xhci-objs := xhci-hcd.o xhci-mem.o xhci-pci.o xhci-ring.o xhci-hub.o xhci-dbg.o | ||
15 | 16 | ||
16 | obj-$(CONFIG_USB_WHCI_HCD) += whci/ | 17 | obj-$(CONFIG_USB_WHCI_HCD) += whci/ |
17 | 18 | ||
@@ -23,6 +24,7 @@ obj-$(CONFIG_USB_ISP116X_HCD) += isp116x-hcd.o | |||
23 | obj-$(CONFIG_USB_OHCI_HCD) += ohci-hcd.o | 24 | obj-$(CONFIG_USB_OHCI_HCD) += ohci-hcd.o |
24 | obj-$(CONFIG_USB_UHCI_HCD) += uhci-hcd.o | 25 | obj-$(CONFIG_USB_UHCI_HCD) += uhci-hcd.o |
25 | obj-$(CONFIG_USB_FHCI_HCD) += fhci.o | 26 | obj-$(CONFIG_USB_FHCI_HCD) += fhci.o |
27 | obj-$(CONFIG_USB_XHCI_HCD) += xhci.o | ||
26 | obj-$(CONFIG_USB_SL811_HCD) += sl811-hcd.o | 28 | obj-$(CONFIG_USB_SL811_HCD) += sl811-hcd.o |
27 | obj-$(CONFIG_USB_SL811_CS) += sl811_cs.o | 29 | obj-$(CONFIG_USB_SL811_CS) += sl811_cs.o |
28 | obj-$(CONFIG_USB_U132_HCD) += u132-hcd.o | 30 | obj-$(CONFIG_USB_U132_HCD) += u132-hcd.o |
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c index bf69f4739107..c3a778bd359c 100644 --- a/drivers/usb/host/ehci-au1xxx.c +++ b/drivers/usb/host/ehci-au1xxx.c | |||
@@ -97,6 +97,7 @@ static const struct hc_driver ehci_au1xxx_hc_driver = { | |||
97 | .urb_enqueue = ehci_urb_enqueue, | 97 | .urb_enqueue = ehci_urb_enqueue, |
98 | .urb_dequeue = ehci_urb_dequeue, | 98 | .urb_dequeue = ehci_urb_dequeue, |
99 | .endpoint_disable = ehci_endpoint_disable, | 99 | .endpoint_disable = ehci_endpoint_disable, |
100 | .endpoint_reset = ehci_endpoint_reset, | ||
100 | 101 | ||
101 | /* | 102 | /* |
102 | * scheduling support | 103 | * scheduling support |
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c index 01c3da34f678..bf86809c5120 100644 --- a/drivers/usb/host/ehci-fsl.c +++ b/drivers/usb/host/ehci-fsl.c | |||
@@ -309,6 +309,7 @@ static const struct hc_driver ehci_fsl_hc_driver = { | |||
309 | .urb_enqueue = ehci_urb_enqueue, | 309 | .urb_enqueue = ehci_urb_enqueue, |
310 | .urb_dequeue = ehci_urb_dequeue, | 310 | .urb_dequeue = ehci_urb_dequeue, |
311 | .endpoint_disable = ehci_endpoint_disable, | 311 | .endpoint_disable = ehci_endpoint_disable, |
312 | .endpoint_reset = ehci_endpoint_reset, | ||
312 | 313 | ||
313 | /* | 314 | /* |
314 | * scheduling support | 315 | * scheduling support |
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c index c637207a1c80..2b72473544d3 100644 --- a/drivers/usb/host/ehci-hcd.c +++ b/drivers/usb/host/ehci-hcd.c | |||
@@ -1024,6 +1024,51 @@ done: | |||
1024 | return; | 1024 | return; |
1025 | } | 1025 | } |
1026 | 1026 | ||
1027 | static void | ||
1028 | ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep) | ||
1029 | { | ||
1030 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); | ||
1031 | struct ehci_qh *qh; | ||
1032 | int eptype = usb_endpoint_type(&ep->desc); | ||
1033 | |||
1034 | if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT) | ||
1035 | return; | ||
1036 | |||
1037 | rescan: | ||
1038 | spin_lock_irq(&ehci->lock); | ||
1039 | qh = ep->hcpriv; | ||
1040 | |||
1041 | /* For Bulk and Interrupt endpoints we maintain the toggle state | ||
1042 | * in the hardware; the toggle bits in udev aren't used at all. | ||
1043 | * When an endpoint is reset by usb_clear_halt() we must reset | ||
1044 | * the toggle bit in the QH. | ||
1045 | */ | ||
1046 | if (qh) { | ||
1047 | if (!list_empty(&qh->qtd_list)) { | ||
1048 | WARN_ONCE(1, "clear_halt for a busy endpoint\n"); | ||
1049 | } else if (qh->qh_state == QH_STATE_IDLE) { | ||
1050 | qh->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE); | ||
1051 | } else { | ||
1052 | /* It's not safe to write into the overlay area | ||
1053 | * while the QH is active. Unlink it first and | ||
1054 | * wait for the unlink to complete. | ||
1055 | */ | ||
1056 | if (qh->qh_state == QH_STATE_LINKED) { | ||
1057 | if (eptype == USB_ENDPOINT_XFER_BULK) { | ||
1058 | unlink_async(ehci, qh); | ||
1059 | } else { | ||
1060 | intr_deschedule(ehci, qh); | ||
1061 | (void) qh_schedule(ehci, qh); | ||
1062 | } | ||
1063 | } | ||
1064 | spin_unlock_irq(&ehci->lock); | ||
1065 | schedule_timeout_uninterruptible(1); | ||
1066 | goto rescan; | ||
1067 | } | ||
1068 | } | ||
1069 | spin_unlock_irq(&ehci->lock); | ||
1070 | } | ||
1071 | |||
1027 | static int ehci_get_frame (struct usb_hcd *hcd) | 1072 | static int ehci_get_frame (struct usb_hcd *hcd) |
1028 | { | 1073 | { |
1029 | struct ehci_hcd *ehci = hcd_to_ehci (hcd); | 1074 | struct ehci_hcd *ehci = hcd_to_ehci (hcd); |
@@ -1097,7 +1142,7 @@ static int __init ehci_hcd_init(void) | |||
1097 | sizeof(struct ehci_itd), sizeof(struct ehci_sitd)); | 1142 | sizeof(struct ehci_itd), sizeof(struct ehci_sitd)); |
1098 | 1143 | ||
1099 | #ifdef DEBUG | 1144 | #ifdef DEBUG |
1100 | ehci_debug_root = debugfs_create_dir("ehci", NULL); | 1145 | ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root); |
1101 | if (!ehci_debug_root) { | 1146 | if (!ehci_debug_root) { |
1102 | retval = -ENOENT; | 1147 | retval = -ENOENT; |
1103 | goto err_debug; | 1148 | goto err_debug; |
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c index 97a53a48a3d8..f46ad27c9a90 100644 --- a/drivers/usb/host/ehci-hub.c +++ b/drivers/usb/host/ehci-hub.c | |||
@@ -391,7 +391,7 @@ static inline void create_companion_file(struct ehci_hcd *ehci) | |||
391 | 391 | ||
392 | /* with integrated TT there is no companion! */ | 392 | /* with integrated TT there is no companion! */ |
393 | if (!ehci_is_TDI(ehci)) | 393 | if (!ehci_is_TDI(ehci)) |
394 | i = device_create_file(ehci_to_hcd(ehci)->self.dev, | 394 | i = device_create_file(ehci_to_hcd(ehci)->self.controller, |
395 | &dev_attr_companion); | 395 | &dev_attr_companion); |
396 | } | 396 | } |
397 | 397 | ||
@@ -399,7 +399,7 @@ static inline void remove_companion_file(struct ehci_hcd *ehci) | |||
399 | { | 399 | { |
400 | /* with integrated TT there is no companion! */ | 400 | /* with integrated TT there is no companion! */ |
401 | if (!ehci_is_TDI(ehci)) | 401 | if (!ehci_is_TDI(ehci)) |
402 | device_remove_file(ehci_to_hcd(ehci)->self.dev, | 402 | device_remove_file(ehci_to_hcd(ehci)->self.controller, |
403 | &dev_attr_companion); | 403 | &dev_attr_companion); |
404 | } | 404 | } |
405 | 405 | ||
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c index 9c32063a0c2f..a44bb4a94954 100644 --- a/drivers/usb/host/ehci-ixp4xx.c +++ b/drivers/usb/host/ehci-ixp4xx.c | |||
@@ -51,6 +51,7 @@ static const struct hc_driver ixp4xx_ehci_hc_driver = { | |||
51 | .urb_enqueue = ehci_urb_enqueue, | 51 | .urb_enqueue = ehci_urb_enqueue, |
52 | .urb_dequeue = ehci_urb_dequeue, | 52 | .urb_dequeue = ehci_urb_dequeue, |
53 | .endpoint_disable = ehci_endpoint_disable, | 53 | .endpoint_disable = ehci_endpoint_disable, |
54 | .endpoint_reset = ehci_endpoint_reset, | ||
54 | .get_frame_number = ehci_get_frame, | 55 | .get_frame_number = ehci_get_frame, |
55 | .hub_status_data = ehci_hub_status_data, | 56 | .hub_status_data = ehci_hub_status_data, |
56 | .hub_control = ehci_hub_control, | 57 | .hub_control = ehci_hub_control, |
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c index 9d487908012e..770dd9aba62a 100644 --- a/drivers/usb/host/ehci-orion.c +++ b/drivers/usb/host/ehci-orion.c | |||
@@ -149,6 +149,7 @@ static const struct hc_driver ehci_orion_hc_driver = { | |||
149 | .urb_enqueue = ehci_urb_enqueue, | 149 | .urb_enqueue = ehci_urb_enqueue, |
150 | .urb_dequeue = ehci_urb_dequeue, | 150 | .urb_dequeue = ehci_urb_dequeue, |
151 | .endpoint_disable = ehci_endpoint_disable, | 151 | .endpoint_disable = ehci_endpoint_disable, |
152 | .endpoint_reset = ehci_endpoint_reset, | ||
152 | 153 | ||
153 | /* | 154 | /* |
154 | * scheduling support | 155 | * scheduling support |
@@ -187,7 +188,7 @@ ehci_orion_conf_mbus_windows(struct usb_hcd *hcd, | |||
187 | } | 188 | } |
188 | } | 189 | } |
189 | 190 | ||
190 | static int __init ehci_orion_drv_probe(struct platform_device *pdev) | 191 | static int __devinit ehci_orion_drv_probe(struct platform_device *pdev) |
191 | { | 192 | { |
192 | struct orion_ehci_data *pd = pdev->dev.platform_data; | 193 | struct orion_ehci_data *pd = pdev->dev.platform_data; |
193 | struct resource *res; | 194 | struct resource *res; |
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c index 5aa8bce90e1f..f3683e1da161 100644 --- a/drivers/usb/host/ehci-pci.c +++ b/drivers/usb/host/ehci-pci.c | |||
@@ -268,7 +268,7 @@ done: | |||
268 | * Also they depend on separate root hub suspend/resume. | 268 | * Also they depend on separate root hub suspend/resume. |
269 | */ | 269 | */ |
270 | 270 | ||
271 | static int ehci_pci_suspend(struct usb_hcd *hcd, pm_message_t message) | 271 | static int ehci_pci_suspend(struct usb_hcd *hcd) |
272 | { | 272 | { |
273 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); | 273 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
274 | unsigned long flags; | 274 | unsigned long flags; |
@@ -293,12 +293,6 @@ static int ehci_pci_suspend(struct usb_hcd *hcd, pm_message_t message) | |||
293 | ehci_writel(ehci, 0, &ehci->regs->intr_enable); | 293 | ehci_writel(ehci, 0, &ehci->regs->intr_enable); |
294 | (void)ehci_readl(ehci, &ehci->regs->intr_enable); | 294 | (void)ehci_readl(ehci, &ehci->regs->intr_enable); |
295 | 295 | ||
296 | /* make sure snapshot being resumed re-enumerates everything */ | ||
297 | if (message.event == PM_EVENT_PRETHAW) { | ||
298 | ehci_halt(ehci); | ||
299 | ehci_reset(ehci); | ||
300 | } | ||
301 | |||
302 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | 296 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
303 | bail: | 297 | bail: |
304 | spin_unlock_irqrestore (&ehci->lock, flags); | 298 | spin_unlock_irqrestore (&ehci->lock, flags); |
@@ -309,7 +303,7 @@ static int ehci_pci_suspend(struct usb_hcd *hcd, pm_message_t message) | |||
309 | return rc; | 303 | return rc; |
310 | } | 304 | } |
311 | 305 | ||
312 | static int ehci_pci_resume(struct usb_hcd *hcd) | 306 | static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated) |
313 | { | 307 | { |
314 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); | 308 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
315 | struct pci_dev *pdev = to_pci_dev(hcd->self.controller); | 309 | struct pci_dev *pdev = to_pci_dev(hcd->self.controller); |
@@ -322,10 +316,12 @@ static int ehci_pci_resume(struct usb_hcd *hcd) | |||
322 | /* Mark hardware accessible again as we are out of D3 state by now */ | 316 | /* Mark hardware accessible again as we are out of D3 state by now */ |
323 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | 317 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
324 | 318 | ||
325 | /* If CF is still set, we maintained PCI Vaux power. | 319 | /* If CF is still set and we aren't resuming from hibernation |
320 | * then we maintained PCI Vaux power. | ||
326 | * Just undo the effect of ehci_pci_suspend(). | 321 | * Just undo the effect of ehci_pci_suspend(). |
327 | */ | 322 | */ |
328 | if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) { | 323 | if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF && |
324 | !hibernated) { | ||
329 | int mask = INTR_MASK; | 325 | int mask = INTR_MASK; |
330 | 326 | ||
331 | if (!hcd->self.root_hub->do_remote_wakeup) | 327 | if (!hcd->self.root_hub->do_remote_wakeup) |
@@ -335,7 +331,6 @@ static int ehci_pci_resume(struct usb_hcd *hcd) | |||
335 | return 0; | 331 | return 0; |
336 | } | 332 | } |
337 | 333 | ||
338 | ehci_dbg(ehci, "lost power, restarting\n"); | ||
339 | usb_root_hub_lost_power(hcd->self.root_hub); | 334 | usb_root_hub_lost_power(hcd->self.root_hub); |
340 | 335 | ||
341 | /* Else reset, to cope with power loss or flush-to-storage | 336 | /* Else reset, to cope with power loss or flush-to-storage |
@@ -393,6 +388,7 @@ static const struct hc_driver ehci_pci_hc_driver = { | |||
393 | .urb_enqueue = ehci_urb_enqueue, | 388 | .urb_enqueue = ehci_urb_enqueue, |
394 | .urb_dequeue = ehci_urb_dequeue, | 389 | .urb_dequeue = ehci_urb_dequeue, |
395 | .endpoint_disable = ehci_endpoint_disable, | 390 | .endpoint_disable = ehci_endpoint_disable, |
391 | .endpoint_reset = ehci_endpoint_reset, | ||
396 | 392 | ||
397 | /* | 393 | /* |
398 | * scheduling support | 394 | * scheduling support |
@@ -429,10 +425,11 @@ static struct pci_driver ehci_pci_driver = { | |||
429 | 425 | ||
430 | .probe = usb_hcd_pci_probe, | 426 | .probe = usb_hcd_pci_probe, |
431 | .remove = usb_hcd_pci_remove, | 427 | .remove = usb_hcd_pci_remove, |
428 | .shutdown = usb_hcd_pci_shutdown, | ||
432 | 429 | ||
433 | #ifdef CONFIG_PM | 430 | #ifdef CONFIG_PM_SLEEP |
434 | .suspend = usb_hcd_pci_suspend, | 431 | .driver = { |
435 | .resume = usb_hcd_pci_resume, | 432 | .pm = &usb_hcd_pci_pm_ops |
433 | }, | ||
436 | #endif | 434 | #endif |
437 | .shutdown = usb_hcd_pci_shutdown, | ||
438 | }; | 435 | }; |
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c index ef732b704f53..fbd272288fc2 100644 --- a/drivers/usb/host/ehci-ppc-of.c +++ b/drivers/usb/host/ehci-ppc-of.c | |||
@@ -61,6 +61,7 @@ static const struct hc_driver ehci_ppc_of_hc_driver = { | |||
61 | .urb_enqueue = ehci_urb_enqueue, | 61 | .urb_enqueue = ehci_urb_enqueue, |
62 | .urb_dequeue = ehci_urb_dequeue, | 62 | .urb_dequeue = ehci_urb_dequeue, |
63 | .endpoint_disable = ehci_endpoint_disable, | 63 | .endpoint_disable = ehci_endpoint_disable, |
64 | .endpoint_reset = ehci_endpoint_reset, | ||
64 | 65 | ||
65 | /* | 66 | /* |
66 | * scheduling support | 67 | * scheduling support |
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c index bb870b8f81bc..eecd2a0680a2 100644 --- a/drivers/usb/host/ehci-ps3.c +++ b/drivers/usb/host/ehci-ps3.c | |||
@@ -65,6 +65,7 @@ static const struct hc_driver ps3_ehci_hc_driver = { | |||
65 | .urb_enqueue = ehci_urb_enqueue, | 65 | .urb_enqueue = ehci_urb_enqueue, |
66 | .urb_dequeue = ehci_urb_dequeue, | 66 | .urb_dequeue = ehci_urb_dequeue, |
67 | .endpoint_disable = ehci_endpoint_disable, | 67 | .endpoint_disable = ehci_endpoint_disable, |
68 | .endpoint_reset = ehci_endpoint_reset, | ||
68 | .get_frame_number = ehci_get_frame, | 69 | .get_frame_number = ehci_get_frame, |
69 | .hub_status_data = ehci_hub_status_data, | 70 | .hub_status_data = ehci_hub_status_data, |
70 | .hub_control = ehci_hub_control, | 71 | .hub_control = ehci_hub_control, |
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c index 1976b1b3778c..3192f683f807 100644 --- a/drivers/usb/host/ehci-q.c +++ b/drivers/usb/host/ehci-q.c | |||
@@ -93,22 +93,6 @@ qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd) | |||
93 | qh->hw_qtd_next = QTD_NEXT(ehci, qtd->qtd_dma); | 93 | qh->hw_qtd_next = QTD_NEXT(ehci, qtd->qtd_dma); |
94 | qh->hw_alt_next = EHCI_LIST_END(ehci); | 94 | qh->hw_alt_next = EHCI_LIST_END(ehci); |
95 | 95 | ||
96 | /* Except for control endpoints, we make hardware maintain data | ||
97 | * toggle (like OHCI) ... here (re)initialize the toggle in the QH, | ||
98 | * and set the pseudo-toggle in udev. Only usb_clear_halt() will | ||
99 | * ever clear it. | ||
100 | */ | ||
101 | if (!(qh->hw_info1 & cpu_to_hc32(ehci, 1 << 14))) { | ||
102 | unsigned is_out, epnum; | ||
103 | |||
104 | is_out = !(qtd->hw_token & cpu_to_hc32(ehci, 1 << 8)); | ||
105 | epnum = (hc32_to_cpup(ehci, &qh->hw_info1) >> 8) & 0x0f; | ||
106 | if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) { | ||
107 | qh->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE); | ||
108 | usb_settoggle (qh->dev, epnum, is_out, 1); | ||
109 | } | ||
110 | } | ||
111 | |||
112 | /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */ | 96 | /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */ |
113 | wmb (); | 97 | wmb (); |
114 | qh->hw_token &= cpu_to_hc32(ehci, QTD_TOGGLE | QTD_STS_PING); | 98 | qh->hw_token &= cpu_to_hc32(ehci, QTD_TOGGLE | QTD_STS_PING); |
@@ -850,7 +834,6 @@ done: | |||
850 | qh->qh_state = QH_STATE_IDLE; | 834 | qh->qh_state = QH_STATE_IDLE; |
851 | qh->hw_info1 = cpu_to_hc32(ehci, info1); | 835 | qh->hw_info1 = cpu_to_hc32(ehci, info1); |
852 | qh->hw_info2 = cpu_to_hc32(ehci, info2); | 836 | qh->hw_info2 = cpu_to_hc32(ehci, info2); |
853 | usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1); | ||
854 | qh_refresh (ehci, qh); | 837 | qh_refresh (ehci, qh); |
855 | return qh; | 838 | return qh; |
856 | } | 839 | } |
@@ -881,7 +864,7 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh) | |||
881 | } | 864 | } |
882 | } | 865 | } |
883 | 866 | ||
884 | /* clear halt and/or toggle; and maybe recover from silicon quirk */ | 867 | /* clear halt and maybe recover from silicon quirk */ |
885 | if (qh->qh_state == QH_STATE_IDLE) | 868 | if (qh->qh_state == QH_STATE_IDLE) |
886 | qh_refresh (ehci, qh); | 869 | qh_refresh (ehci, qh); |
887 | 870 | ||
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c index 556d0ec0c1f8..9d1babc7ff65 100644 --- a/drivers/usb/host/ehci-sched.c +++ b/drivers/usb/host/ehci-sched.c | |||
@@ -760,8 +760,10 @@ static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh) | |||
760 | if (status) { | 760 | if (status) { |
761 | /* "normal" case, uframing flexible except with splits */ | 761 | /* "normal" case, uframing flexible except with splits */ |
762 | if (qh->period) { | 762 | if (qh->period) { |
763 | frame = qh->period - 1; | 763 | int i; |
764 | do { | 764 | |
765 | for (i = qh->period; status && i > 0; --i) { | ||
766 | frame = ++ehci->random_frame % qh->period; | ||
765 | for (uframe = 0; uframe < 8; uframe++) { | 767 | for (uframe = 0; uframe < 8; uframe++) { |
766 | status = check_intr_schedule (ehci, | 768 | status = check_intr_schedule (ehci, |
767 | frame, uframe, qh, | 769 | frame, uframe, qh, |
@@ -769,7 +771,7 @@ static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh) | |||
769 | if (status == 0) | 771 | if (status == 0) |
770 | break; | 772 | break; |
771 | } | 773 | } |
772 | } while (status && frame--); | 774 | } |
773 | 775 | ||
774 | /* qh->period == 0 means every uframe */ | 776 | /* qh->period == 0 means every uframe */ |
775 | } else { | 777 | } else { |
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h index 6cff195e1a36..90ad3395bb21 100644 --- a/drivers/usb/host/ehci.h +++ b/drivers/usb/host/ehci.h | |||
@@ -116,6 +116,7 @@ struct ehci_hcd { /* one per controller */ | |||
116 | struct timer_list watchdog; | 116 | struct timer_list watchdog; |
117 | unsigned long actions; | 117 | unsigned long actions; |
118 | unsigned stamp; | 118 | unsigned stamp; |
119 | unsigned random_frame; | ||
119 | unsigned long next_statechange; | 120 | unsigned long next_statechange; |
120 | u32 command; | 121 | u32 command; |
121 | 122 | ||
diff --git a/drivers/usb/host/fhci-dbg.c b/drivers/usb/host/fhci-dbg.c index ea8a4255c5da..e799f86dab11 100644 --- a/drivers/usb/host/fhci-dbg.c +++ b/drivers/usb/host/fhci-dbg.c | |||
@@ -108,7 +108,7 @@ void fhci_dfs_create(struct fhci_hcd *fhci) | |||
108 | { | 108 | { |
109 | struct device *dev = fhci_to_hcd(fhci)->self.controller; | 109 | struct device *dev = fhci_to_hcd(fhci)->self.controller; |
110 | 110 | ||
111 | fhci->dfs_root = debugfs_create_dir(dev_name(dev), NULL); | 111 | fhci->dfs_root = debugfs_create_dir(dev_name(dev), usb_debug_root); |
112 | if (!fhci->dfs_root) { | 112 | if (!fhci->dfs_root) { |
113 | WARN_ON(1); | 113 | WARN_ON(1); |
114 | return; | 114 | return; |
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c index cbf30e515f29..88b03214622b 100644 --- a/drivers/usb/host/hwa-hc.c +++ b/drivers/usb/host/hwa-hc.c | |||
@@ -172,25 +172,6 @@ error_cluster_id_get: | |||
172 | 172 | ||
173 | } | 173 | } |
174 | 174 | ||
175 | static int hwahc_op_suspend(struct usb_hcd *usb_hcd, pm_message_t msg) | ||
176 | { | ||
177 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | ||
178 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | ||
179 | dev_err(wusbhc->dev, "%s (%p [%p], 0x%lx) UNIMPLEMENTED\n", __func__, | ||
180 | usb_hcd, hwahc, *(unsigned long *) &msg); | ||
181 | return -ENOSYS; | ||
182 | } | ||
183 | |||
184 | static int hwahc_op_resume(struct usb_hcd *usb_hcd) | ||
185 | { | ||
186 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | ||
187 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | ||
188 | |||
189 | dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__, | ||
190 | usb_hcd, hwahc); | ||
191 | return -ENOSYS; | ||
192 | } | ||
193 | |||
194 | /* | 175 | /* |
195 | * No need to abort pipes, as when this is called, all the children | 176 | * No need to abort pipes, as when this is called, all the children |
196 | * has been disconnected and that has done it [through | 177 | * has been disconnected and that has done it [through |
@@ -598,8 +579,6 @@ static struct hc_driver hwahc_hc_driver = { | |||
598 | .flags = HCD_USB2, /* FIXME */ | 579 | .flags = HCD_USB2, /* FIXME */ |
599 | .reset = hwahc_op_reset, | 580 | .reset = hwahc_op_reset, |
600 | .start = hwahc_op_start, | 581 | .start = hwahc_op_start, |
601 | .pci_suspend = hwahc_op_suspend, | ||
602 | .pci_resume = hwahc_op_resume, | ||
603 | .stop = hwahc_op_stop, | 582 | .stop = hwahc_op_stop, |
604 | .get_frame_number = hwahc_op_get_frame_number, | 583 | .get_frame_number = hwahc_op_get_frame_number, |
605 | .urb_enqueue = hwahc_op_urb_enqueue, | 584 | .urb_enqueue = hwahc_op_urb_enqueue, |
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c index d3269656aa4d..811f5dfdc582 100644 --- a/drivers/usb/host/ohci-dbg.c +++ b/drivers/usb/host/ohci-dbg.c | |||
@@ -431,7 +431,7 @@ static struct dentry *ohci_debug_root; | |||
431 | 431 | ||
432 | struct debug_buffer { | 432 | struct debug_buffer { |
433 | ssize_t (*fill_func)(struct debug_buffer *); /* fill method */ | 433 | ssize_t (*fill_func)(struct debug_buffer *); /* fill method */ |
434 | struct device *dev; | 434 | struct ohci_hcd *ohci; |
435 | struct mutex mutex; /* protect filling of buffer */ | 435 | struct mutex mutex; /* protect filling of buffer */ |
436 | size_t count; /* number of characters filled into buffer */ | 436 | size_t count; /* number of characters filled into buffer */ |
437 | char *page; | 437 | char *page; |
@@ -505,15 +505,11 @@ show_list (struct ohci_hcd *ohci, char *buf, size_t count, struct ed *ed) | |||
505 | 505 | ||
506 | static ssize_t fill_async_buffer(struct debug_buffer *buf) | 506 | static ssize_t fill_async_buffer(struct debug_buffer *buf) |
507 | { | 507 | { |
508 | struct usb_bus *bus; | ||
509 | struct usb_hcd *hcd; | ||
510 | struct ohci_hcd *ohci; | 508 | struct ohci_hcd *ohci; |
511 | size_t temp; | 509 | size_t temp; |
512 | unsigned long flags; | 510 | unsigned long flags; |
513 | 511 | ||
514 | bus = dev_get_drvdata(buf->dev); | 512 | ohci = buf->ohci; |
515 | hcd = bus_to_hcd(bus); | ||
516 | ohci = hcd_to_ohci(hcd); | ||
517 | 513 | ||
518 | /* display control and bulk lists together, for simplicity */ | 514 | /* display control and bulk lists together, for simplicity */ |
519 | spin_lock_irqsave (&ohci->lock, flags); | 515 | spin_lock_irqsave (&ohci->lock, flags); |
@@ -529,8 +525,6 @@ static ssize_t fill_async_buffer(struct debug_buffer *buf) | |||
529 | 525 | ||
530 | static ssize_t fill_periodic_buffer(struct debug_buffer *buf) | 526 | static ssize_t fill_periodic_buffer(struct debug_buffer *buf) |
531 | { | 527 | { |
532 | struct usb_bus *bus; | ||
533 | struct usb_hcd *hcd; | ||
534 | struct ohci_hcd *ohci; | 528 | struct ohci_hcd *ohci; |
535 | struct ed **seen, *ed; | 529 | struct ed **seen, *ed; |
536 | unsigned long flags; | 530 | unsigned long flags; |
@@ -542,9 +536,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf) | |||
542 | return 0; | 536 | return 0; |
543 | seen_count = 0; | 537 | seen_count = 0; |
544 | 538 | ||
545 | bus = (struct usb_bus *)dev_get_drvdata(buf->dev); | 539 | ohci = buf->ohci; |
546 | hcd = bus_to_hcd(bus); | ||
547 | ohci = hcd_to_ohci(hcd); | ||
548 | next = buf->page; | 540 | next = buf->page; |
549 | size = PAGE_SIZE; | 541 | size = PAGE_SIZE; |
550 | 542 | ||
@@ -626,7 +618,6 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf) | |||
626 | 618 | ||
627 | static ssize_t fill_registers_buffer(struct debug_buffer *buf) | 619 | static ssize_t fill_registers_buffer(struct debug_buffer *buf) |
628 | { | 620 | { |
629 | struct usb_bus *bus; | ||
630 | struct usb_hcd *hcd; | 621 | struct usb_hcd *hcd; |
631 | struct ohci_hcd *ohci; | 622 | struct ohci_hcd *ohci; |
632 | struct ohci_regs __iomem *regs; | 623 | struct ohci_regs __iomem *regs; |
@@ -635,9 +626,8 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf) | |||
635 | char *next; | 626 | char *next; |
636 | u32 rdata; | 627 | u32 rdata; |
637 | 628 | ||
638 | bus = (struct usb_bus *)dev_get_drvdata(buf->dev); | 629 | ohci = buf->ohci; |
639 | hcd = bus_to_hcd(bus); | 630 | hcd = ohci_to_hcd(ohci); |
640 | ohci = hcd_to_ohci(hcd); | ||
641 | regs = ohci->regs; | 631 | regs = ohci->regs; |
642 | next = buf->page; | 632 | next = buf->page; |
643 | size = PAGE_SIZE; | 633 | size = PAGE_SIZE; |
@@ -710,7 +700,7 @@ done: | |||
710 | return PAGE_SIZE - size; | 700 | return PAGE_SIZE - size; |
711 | } | 701 | } |
712 | 702 | ||
713 | static struct debug_buffer *alloc_buffer(struct device *dev, | 703 | static struct debug_buffer *alloc_buffer(struct ohci_hcd *ohci, |
714 | ssize_t (*fill_func)(struct debug_buffer *)) | 704 | ssize_t (*fill_func)(struct debug_buffer *)) |
715 | { | 705 | { |
716 | struct debug_buffer *buf; | 706 | struct debug_buffer *buf; |
@@ -718,7 +708,7 @@ static struct debug_buffer *alloc_buffer(struct device *dev, | |||
718 | buf = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL); | 708 | buf = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL); |
719 | 709 | ||
720 | if (buf) { | 710 | if (buf) { |
721 | buf->dev = dev; | 711 | buf->ohci = ohci; |
722 | buf->fill_func = fill_func; | 712 | buf->fill_func = fill_func; |
723 | mutex_init(&buf->mutex); | 713 | mutex_init(&buf->mutex); |
724 | } | 714 | } |
@@ -810,26 +800,25 @@ static int debug_registers_open(struct inode *inode, struct file *file) | |||
810 | static inline void create_debug_files (struct ohci_hcd *ohci) | 800 | static inline void create_debug_files (struct ohci_hcd *ohci) |
811 | { | 801 | { |
812 | struct usb_bus *bus = &ohci_to_hcd(ohci)->self; | 802 | struct usb_bus *bus = &ohci_to_hcd(ohci)->self; |
813 | struct device *dev = bus->dev; | ||
814 | 803 | ||
815 | ohci->debug_dir = debugfs_create_dir(bus->bus_name, ohci_debug_root); | 804 | ohci->debug_dir = debugfs_create_dir(bus->bus_name, ohci_debug_root); |
816 | if (!ohci->debug_dir) | 805 | if (!ohci->debug_dir) |
817 | goto dir_error; | 806 | goto dir_error; |
818 | 807 | ||
819 | ohci->debug_async = debugfs_create_file("async", S_IRUGO, | 808 | ohci->debug_async = debugfs_create_file("async", S_IRUGO, |
820 | ohci->debug_dir, dev, | 809 | ohci->debug_dir, ohci, |
821 | &debug_async_fops); | 810 | &debug_async_fops); |
822 | if (!ohci->debug_async) | 811 | if (!ohci->debug_async) |
823 | goto async_error; | 812 | goto async_error; |
824 | 813 | ||
825 | ohci->debug_periodic = debugfs_create_file("periodic", S_IRUGO, | 814 | ohci->debug_periodic = debugfs_create_file("periodic", S_IRUGO, |
826 | ohci->debug_dir, dev, | 815 | ohci->debug_dir, ohci, |
827 | &debug_periodic_fops); | 816 | &debug_periodic_fops); |
828 | if (!ohci->debug_periodic) | 817 | if (!ohci->debug_periodic) |
829 | goto periodic_error; | 818 | goto periodic_error; |
830 | 819 | ||
831 | ohci->debug_registers = debugfs_create_file("registers", S_IRUGO, | 820 | ohci->debug_registers = debugfs_create_file("registers", S_IRUGO, |
832 | ohci->debug_dir, dev, | 821 | ohci->debug_dir, ohci, |
833 | &debug_registers_fops); | 822 | &debug_registers_fops); |
834 | if (!ohci->debug_registers) | 823 | if (!ohci->debug_registers) |
835 | goto registers_error; | 824 | goto registers_error; |
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c index 25db704f3a2a..58151687d351 100644 --- a/drivers/usb/host/ohci-hcd.c +++ b/drivers/usb/host/ohci-hcd.c | |||
@@ -571,7 +571,7 @@ static int ohci_init (struct ohci_hcd *ohci) | |||
571 | */ | 571 | */ |
572 | static int ohci_run (struct ohci_hcd *ohci) | 572 | static int ohci_run (struct ohci_hcd *ohci) |
573 | { | 573 | { |
574 | u32 mask, temp; | 574 | u32 mask, val; |
575 | int first = ohci->fminterval == 0; | 575 | int first = ohci->fminterval == 0; |
576 | struct usb_hcd *hcd = ohci_to_hcd(ohci); | 576 | struct usb_hcd *hcd = ohci_to_hcd(ohci); |
577 | 577 | ||
@@ -580,8 +580,8 @@ static int ohci_run (struct ohci_hcd *ohci) | |||
580 | /* boot firmware should have set this up (5.1.1.3.1) */ | 580 | /* boot firmware should have set this up (5.1.1.3.1) */ |
581 | if (first) { | 581 | if (first) { |
582 | 582 | ||
583 | temp = ohci_readl (ohci, &ohci->regs->fminterval); | 583 | val = ohci_readl (ohci, &ohci->regs->fminterval); |
584 | ohci->fminterval = temp & 0x3fff; | 584 | ohci->fminterval = val & 0x3fff; |
585 | if (ohci->fminterval != FI) | 585 | if (ohci->fminterval != FI) |
586 | ohci_dbg (ohci, "fminterval delta %d\n", | 586 | ohci_dbg (ohci, "fminterval delta %d\n", |
587 | ohci->fminterval - FI); | 587 | ohci->fminterval - FI); |
@@ -600,25 +600,25 @@ static int ohci_run (struct ohci_hcd *ohci) | |||
600 | 600 | ||
601 | switch (ohci->hc_control & OHCI_CTRL_HCFS) { | 601 | switch (ohci->hc_control & OHCI_CTRL_HCFS) { |
602 | case OHCI_USB_OPER: | 602 | case OHCI_USB_OPER: |
603 | temp = 0; | 603 | val = 0; |
604 | break; | 604 | break; |
605 | case OHCI_USB_SUSPEND: | 605 | case OHCI_USB_SUSPEND: |
606 | case OHCI_USB_RESUME: | 606 | case OHCI_USB_RESUME: |
607 | ohci->hc_control &= OHCI_CTRL_RWC; | 607 | ohci->hc_control &= OHCI_CTRL_RWC; |
608 | ohci->hc_control |= OHCI_USB_RESUME; | 608 | ohci->hc_control |= OHCI_USB_RESUME; |
609 | temp = 10 /* msec wait */; | 609 | val = 10 /* msec wait */; |
610 | break; | 610 | break; |
611 | // case OHCI_USB_RESET: | 611 | // case OHCI_USB_RESET: |
612 | default: | 612 | default: |
613 | ohci->hc_control &= OHCI_CTRL_RWC; | 613 | ohci->hc_control &= OHCI_CTRL_RWC; |
614 | ohci->hc_control |= OHCI_USB_RESET; | 614 | ohci->hc_control |= OHCI_USB_RESET; |
615 | temp = 50 /* msec wait */; | 615 | val = 50 /* msec wait */; |
616 | break; | 616 | break; |
617 | } | 617 | } |
618 | ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); | 618 | ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); |
619 | // flush the writes | 619 | // flush the writes |
620 | (void) ohci_readl (ohci, &ohci->regs->control); | 620 | (void) ohci_readl (ohci, &ohci->regs->control); |
621 | msleep(temp); | 621 | msleep(val); |
622 | 622 | ||
623 | memset (ohci->hcca, 0, sizeof (struct ohci_hcca)); | 623 | memset (ohci->hcca, 0, sizeof (struct ohci_hcca)); |
624 | 624 | ||
@@ -628,9 +628,9 @@ static int ohci_run (struct ohci_hcd *ohci) | |||
628 | retry: | 628 | retry: |
629 | /* HC Reset requires max 10 us delay */ | 629 | /* HC Reset requires max 10 us delay */ |
630 | ohci_writel (ohci, OHCI_HCR, &ohci->regs->cmdstatus); | 630 | ohci_writel (ohci, OHCI_HCR, &ohci->regs->cmdstatus); |
631 | temp = 30; /* ... allow extra time */ | 631 | val = 30; /* ... allow extra time */ |
632 | while ((ohci_readl (ohci, &ohci->regs->cmdstatus) & OHCI_HCR) != 0) { | 632 | while ((ohci_readl (ohci, &ohci->regs->cmdstatus) & OHCI_HCR) != 0) { |
633 | if (--temp == 0) { | 633 | if (--val == 0) { |
634 | spin_unlock_irq (&ohci->lock); | 634 | spin_unlock_irq (&ohci->lock); |
635 | ohci_err (ohci, "USB HC reset timed out!\n"); | 635 | ohci_err (ohci, "USB HC reset timed out!\n"); |
636 | return -1; | 636 | return -1; |
@@ -699,23 +699,23 @@ retry: | |||
699 | ohci_writel (ohci, mask, &ohci->regs->intrenable); | 699 | ohci_writel (ohci, mask, &ohci->regs->intrenable); |
700 | 700 | ||
701 | /* handle root hub init quirks ... */ | 701 | /* handle root hub init quirks ... */ |
702 | temp = roothub_a (ohci); | 702 | val = roothub_a (ohci); |
703 | temp &= ~(RH_A_PSM | RH_A_OCPM); | 703 | val &= ~(RH_A_PSM | RH_A_OCPM); |
704 | if (ohci->flags & OHCI_QUIRK_SUPERIO) { | 704 | if (ohci->flags & OHCI_QUIRK_SUPERIO) { |
705 | /* NSC 87560 and maybe others */ | 705 | /* NSC 87560 and maybe others */ |
706 | temp |= RH_A_NOCP; | 706 | val |= RH_A_NOCP; |
707 | temp &= ~(RH_A_POTPGT | RH_A_NPS); | 707 | val &= ~(RH_A_POTPGT | RH_A_NPS); |
708 | ohci_writel (ohci, temp, &ohci->regs->roothub.a); | 708 | ohci_writel (ohci, val, &ohci->regs->roothub.a); |
709 | } else if ((ohci->flags & OHCI_QUIRK_AMD756) || | 709 | } else if ((ohci->flags & OHCI_QUIRK_AMD756) || |
710 | (ohci->flags & OHCI_QUIRK_HUB_POWER)) { | 710 | (ohci->flags & OHCI_QUIRK_HUB_POWER)) { |
711 | /* hub power always on; required for AMD-756 and some | 711 | /* hub power always on; required for AMD-756 and some |
712 | * Mac platforms. ganged overcurrent reporting, if any. | 712 | * Mac platforms. ganged overcurrent reporting, if any. |
713 | */ | 713 | */ |
714 | temp |= RH_A_NPS; | 714 | val |= RH_A_NPS; |
715 | ohci_writel (ohci, temp, &ohci->regs->roothub.a); | 715 | ohci_writel (ohci, val, &ohci->regs->roothub.a); |
716 | } | 716 | } |
717 | ohci_writel (ohci, RH_HS_LPSC, &ohci->regs->roothub.status); | 717 | ohci_writel (ohci, RH_HS_LPSC, &ohci->regs->roothub.status); |
718 | ohci_writel (ohci, (temp & RH_A_NPS) ? 0 : RH_B_PPCM, | 718 | ohci_writel (ohci, (val & RH_A_NPS) ? 0 : RH_B_PPCM, |
719 | &ohci->regs->roothub.b); | 719 | &ohci->regs->roothub.b); |
720 | // flush those writes | 720 | // flush those writes |
721 | (void) ohci_readl (ohci, &ohci->regs->control); | 721 | (void) ohci_readl (ohci, &ohci->regs->control); |
@@ -724,7 +724,7 @@ retry: | |||
724 | spin_unlock_irq (&ohci->lock); | 724 | spin_unlock_irq (&ohci->lock); |
725 | 725 | ||
726 | // POTPGT delay is bits 24-31, in 2 ms units. | 726 | // POTPGT delay is bits 24-31, in 2 ms units. |
727 | mdelay ((temp >> 23) & 0x1fe); | 727 | mdelay ((val >> 23) & 0x1fe); |
728 | hcd->state = HC_STATE_RUNNING; | 728 | hcd->state = HC_STATE_RUNNING; |
729 | 729 | ||
730 | if (quirk_zfmicro(ohci)) { | 730 | if (quirk_zfmicro(ohci)) { |
@@ -1105,7 +1105,7 @@ static int __init ohci_hcd_mod_init(void) | |||
1105 | set_bit(USB_OHCI_LOADED, &usb_hcds_loaded); | 1105 | set_bit(USB_OHCI_LOADED, &usb_hcds_loaded); |
1106 | 1106 | ||
1107 | #ifdef DEBUG | 1107 | #ifdef DEBUG |
1108 | ohci_debug_root = debugfs_create_dir("ohci", NULL); | 1108 | ohci_debug_root = debugfs_create_dir("ohci", usb_debug_root); |
1109 | if (!ohci_debug_root) { | 1109 | if (!ohci_debug_root) { |
1110 | retval = -ENOENT; | 1110 | retval = -ENOENT; |
1111 | goto error_debug; | 1111 | goto error_debug; |
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c index f9961b4c0da3..d2ba04dd785e 100644 --- a/drivers/usb/host/ohci-pci.c +++ b/drivers/usb/host/ohci-pci.c | |||
@@ -372,7 +372,7 @@ static int __devinit ohci_pci_start (struct usb_hcd *hcd) | |||
372 | 372 | ||
373 | #ifdef CONFIG_PM | 373 | #ifdef CONFIG_PM |
374 | 374 | ||
375 | static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message) | 375 | static int ohci_pci_suspend(struct usb_hcd *hcd) |
376 | { | 376 | { |
377 | struct ohci_hcd *ohci = hcd_to_ohci (hcd); | 377 | struct ohci_hcd *ohci = hcd_to_ohci (hcd); |
378 | unsigned long flags; | 378 | unsigned long flags; |
@@ -394,10 +394,6 @@ static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message) | |||
394 | ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable); | 394 | ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable); |
395 | (void)ohci_readl(ohci, &ohci->regs->intrdisable); | 395 | (void)ohci_readl(ohci, &ohci->regs->intrdisable); |
396 | 396 | ||
397 | /* make sure snapshot being resumed re-enumerates everything */ | ||
398 | if (message.event == PM_EVENT_PRETHAW) | ||
399 | ohci_usb_reset(ohci); | ||
400 | |||
401 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | 397 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
402 | bail: | 398 | bail: |
403 | spin_unlock_irqrestore (&ohci->lock, flags); | 399 | spin_unlock_irqrestore (&ohci->lock, flags); |
@@ -406,9 +402,14 @@ static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message) | |||
406 | } | 402 | } |
407 | 403 | ||
408 | 404 | ||
409 | static int ohci_pci_resume (struct usb_hcd *hcd) | 405 | static int ohci_pci_resume(struct usb_hcd *hcd, bool hibernated) |
410 | { | 406 | { |
411 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | 407 | set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
408 | |||
409 | /* Make sure resume from hibernation re-enumerates everything */ | ||
410 | if (hibernated) | ||
411 | ohci_usb_reset(hcd_to_ohci(hcd)); | ||
412 | |||
412 | ohci_finish_controller_resume(hcd); | 413 | ohci_finish_controller_resume(hcd); |
413 | return 0; | 414 | return 0; |
414 | } | 415 | } |
@@ -484,12 +485,11 @@ static struct pci_driver ohci_pci_driver = { | |||
484 | 485 | ||
485 | .probe = usb_hcd_pci_probe, | 486 | .probe = usb_hcd_pci_probe, |
486 | .remove = usb_hcd_pci_remove, | 487 | .remove = usb_hcd_pci_remove, |
488 | .shutdown = usb_hcd_pci_shutdown, | ||
487 | 489 | ||
488 | #ifdef CONFIG_PM | 490 | #ifdef CONFIG_PM_SLEEP |
489 | .suspend = usb_hcd_pci_suspend, | 491 | .driver = { |
490 | .resume = usb_hcd_pci_resume, | 492 | .pm = &usb_hcd_pci_pm_ops |
493 | }, | ||
491 | #endif | 494 | #endif |
492 | |||
493 | .shutdown = usb_hcd_pci_shutdown, | ||
494 | }; | 495 | }; |
495 | |||
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c index 033c2846ce59..83b5f9cea85a 100644 --- a/drivers/usb/host/pci-quirks.c +++ b/drivers/usb/host/pci-quirks.c | |||
@@ -15,6 +15,7 @@ | |||
15 | #include <linux/delay.h> | 15 | #include <linux/delay.h> |
16 | #include <linux/acpi.h> | 16 | #include <linux/acpi.h> |
17 | #include "pci-quirks.h" | 17 | #include "pci-quirks.h" |
18 | #include "xhci-ext-caps.h" | ||
18 | 19 | ||
19 | 20 | ||
20 | #define UHCI_USBLEGSUP 0xc0 /* legacy support */ | 21 | #define UHCI_USBLEGSUP 0xc0 /* legacy support */ |
@@ -341,7 +342,127 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev) | |||
341 | return; | 342 | return; |
342 | } | 343 | } |
343 | 344 | ||
345 | /* | ||
346 | * handshake - spin reading a register until handshake completes | ||
347 | * @ptr: address of hc register to be read | ||
348 | * @mask: bits to look at in result of read | ||
349 | * @done: value of those bits when handshake succeeds | ||
350 | * @wait_usec: timeout in microseconds | ||
351 | * @delay_usec: delay in microseconds to wait between polling | ||
352 | * | ||
353 | * Polls a register every delay_usec microseconds. | ||
354 | * Returns 0 when the mask bits have the value done. | ||
355 | * Returns -ETIMEDOUT if this condition is not true after | ||
356 | * wait_usec microseconds have passed. | ||
357 | */ | ||
358 | static int handshake(void __iomem *ptr, u32 mask, u32 done, | ||
359 | int wait_usec, int delay_usec) | ||
360 | { | ||
361 | u32 result; | ||
362 | |||
363 | do { | ||
364 | result = readl(ptr); | ||
365 | result &= mask; | ||
366 | if (result == done) | ||
367 | return 0; | ||
368 | udelay(delay_usec); | ||
369 | wait_usec -= delay_usec; | ||
370 | } while (wait_usec > 0); | ||
371 | return -ETIMEDOUT; | ||
372 | } | ||
373 | |||
374 | /** | ||
375 | * PCI Quirks for xHCI. | ||
376 | * | ||
377 | * Takes care of the handoff between the Pre-OS (i.e. BIOS) and the OS. | ||
378 | * It signals to the BIOS that the OS wants control of the host controller, | ||
379 | * and then waits 5 seconds for the BIOS to hand over control. | ||
380 | * If we timeout, assume the BIOS is broken and take control anyway. | ||
381 | */ | ||
382 | static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev) | ||
383 | { | ||
384 | void __iomem *base; | ||
385 | int ext_cap_offset; | ||
386 | void __iomem *op_reg_base; | ||
387 | u32 val; | ||
388 | int timeout; | ||
389 | |||
390 | if (!mmio_resource_enabled(pdev, 0)) | ||
391 | return; | ||
392 | |||
393 | base = ioremap_nocache(pci_resource_start(pdev, 0), | ||
394 | pci_resource_len(pdev, 0)); | ||
395 | if (base == NULL) | ||
396 | return; | ||
344 | 397 | ||
398 | /* | ||
399 | * Find the Legacy Support Capability register - | ||
400 | * this is optional for xHCI host controllers. | ||
401 | */ | ||
402 | ext_cap_offset = xhci_find_next_cap_offset(base, XHCI_HCC_PARAMS_OFFSET); | ||
403 | do { | ||
404 | if (!ext_cap_offset) | ||
405 | /* We've reached the end of the extended capabilities */ | ||
406 | goto hc_init; | ||
407 | val = readl(base + ext_cap_offset); | ||
408 | if (XHCI_EXT_CAPS_ID(val) == XHCI_EXT_CAPS_LEGACY) | ||
409 | break; | ||
410 | ext_cap_offset = xhci_find_next_cap_offset(base, ext_cap_offset); | ||
411 | } while (1); | ||
412 | |||
413 | /* If the BIOS owns the HC, signal that the OS wants it, and wait */ | ||
414 | if (val & XHCI_HC_BIOS_OWNED) { | ||
415 | writel(val & XHCI_HC_OS_OWNED, base + ext_cap_offset); | ||
416 | |||
417 | /* Wait for 5 seconds with 10 microsecond polling interval */ | ||
418 | timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED, | ||
419 | 0, 5000, 10); | ||
420 | |||
421 | /* Assume a buggy BIOS and take HC ownership anyway */ | ||
422 | if (timeout) { | ||
423 | dev_warn(&pdev->dev, "xHCI BIOS handoff failed" | ||
424 | " (BIOS bug ?) %08x\n", val); | ||
425 | writel(val & ~XHCI_HC_BIOS_OWNED, base + ext_cap_offset); | ||
426 | } | ||
427 | } | ||
428 | |||
429 | /* Disable any BIOS SMIs */ | ||
430 | writel(XHCI_LEGACY_DISABLE_SMI, | ||
431 | base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET); | ||
432 | |||
433 | hc_init: | ||
434 | op_reg_base = base + XHCI_HC_LENGTH(readl(base)); | ||
435 | |||
436 | /* Wait for the host controller to be ready before writing any | ||
437 | * operational or runtime registers. Wait 5 seconds and no more. | ||
438 | */ | ||
439 | timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_CNR, 0, | ||
440 | 5000, 10); | ||
441 | /* Assume a buggy HC and start HC initialization anyway */ | ||
442 | if (timeout) { | ||
443 | val = readl(op_reg_base + XHCI_STS_OFFSET); | ||
444 | dev_warn(&pdev->dev, | ||
445 | "xHCI HW not ready after 5 sec (HC bug?) " | ||
446 | "status = 0x%x\n", val); | ||
447 | } | ||
448 | |||
449 | /* Send the halt and disable interrupts command */ | ||
450 | val = readl(op_reg_base + XHCI_CMD_OFFSET); | ||
451 | val &= ~(XHCI_CMD_RUN | XHCI_IRQS); | ||
452 | writel(val, op_reg_base + XHCI_CMD_OFFSET); | ||
453 | |||
454 | /* Wait for the HC to halt - poll every 125 usec (one microframe). */ | ||
455 | timeout = handshake(op_reg_base + XHCI_STS_OFFSET, XHCI_STS_HALT, 1, | ||
456 | XHCI_MAX_HALT_USEC, 125); | ||
457 | if (timeout) { | ||
458 | val = readl(op_reg_base + XHCI_STS_OFFSET); | ||
459 | dev_warn(&pdev->dev, | ||
460 | "xHCI HW did not halt within %d usec " | ||
461 | "status = 0x%x\n", XHCI_MAX_HALT_USEC, val); | ||
462 | } | ||
463 | |||
464 | iounmap(base); | ||
465 | } | ||
345 | 466 | ||
346 | static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev) | 467 | static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev) |
347 | { | 468 | { |
@@ -351,5 +472,7 @@ static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev) | |||
351 | quirk_usb_handoff_ohci(pdev); | 472 | quirk_usb_handoff_ohci(pdev); |
352 | else if (pdev->class == PCI_CLASS_SERIAL_USB_EHCI) | 473 | else if (pdev->class == PCI_CLASS_SERIAL_USB_EHCI) |
353 | quirk_usb_disable_ehci(pdev); | 474 | quirk_usb_disable_ehci(pdev); |
475 | else if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI) | ||
476 | quirk_usb_handoff_xhci(pdev); | ||
354 | } | 477 | } |
355 | DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff); | 478 | DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff); |
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c index f1626e58c141..56976cc0352a 100644 --- a/drivers/usb/host/r8a66597-hcd.c +++ b/drivers/usb/host/r8a66597-hcd.c | |||
@@ -46,31 +46,10 @@ MODULE_LICENSE("GPL"); | |||
46 | MODULE_AUTHOR("Yoshihiro Shimoda"); | 46 | MODULE_AUTHOR("Yoshihiro Shimoda"); |
47 | MODULE_ALIAS("platform:r8a66597_hcd"); | 47 | MODULE_ALIAS("platform:r8a66597_hcd"); |
48 | 48 | ||
49 | #define DRIVER_VERSION "10 Apr 2008" | 49 | #define DRIVER_VERSION "2009-05-26" |
50 | 50 | ||
51 | static const char hcd_name[] = "r8a66597_hcd"; | 51 | static const char hcd_name[] = "r8a66597_hcd"; |
52 | 52 | ||
53 | /* module parameters */ | ||
54 | #if !defined(CONFIG_SUPERH_ON_CHIP_R8A66597) | ||
55 | static unsigned short clock = XTAL12; | ||
56 | module_param(clock, ushort, 0644); | ||
57 | MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 " | ||
58 | "(default=0)"); | ||
59 | #endif | ||
60 | |||
61 | static unsigned short vif = LDRV; | ||
62 | module_param(vif, ushort, 0644); | ||
63 | MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0(default=32768)"); | ||
64 | |||
65 | static unsigned short endian; | ||
66 | module_param(endian, ushort, 0644); | ||
67 | MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)"); | ||
68 | |||
69 | static unsigned short irq_sense = 0xff; | ||
70 | module_param(irq_sense, ushort, 0644); | ||
71 | MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=32, falling edge=0 " | ||
72 | "(default=32)"); | ||
73 | |||
74 | static void packet_write(struct r8a66597 *r8a66597, u16 pipenum); | 53 | static void packet_write(struct r8a66597 *r8a66597, u16 pipenum); |
75 | static int r8a66597_get_frame(struct usb_hcd *hcd); | 54 | static int r8a66597_get_frame(struct usb_hcd *hcd); |
76 | 55 | ||
@@ -136,7 +115,8 @@ static int r8a66597_clock_enable(struct r8a66597 *r8a66597) | |||
136 | } | 115 | } |
137 | } while ((tmp & USBE) != USBE); | 116 | } while ((tmp & USBE) != USBE); |
138 | r8a66597_bclr(r8a66597, USBE, SYSCFG0); | 117 | r8a66597_bclr(r8a66597, USBE, SYSCFG0); |
139 | r8a66597_mdfy(r8a66597, clock, XTAL, SYSCFG0); | 118 | r8a66597_mdfy(r8a66597, get_xtal_from_pdata(r8a66597->pdata), XTAL, |
119 | SYSCFG0); | ||
140 | 120 | ||
141 | i = 0; | 121 | i = 0; |
142 | r8a66597_bset(r8a66597, XCKE, SYSCFG0); | 122 | r8a66597_bset(r8a66597, XCKE, SYSCFG0); |
@@ -203,6 +183,9 @@ static void r8a66597_disable_port(struct r8a66597 *r8a66597, int port) | |||
203 | static int enable_controller(struct r8a66597 *r8a66597) | 183 | static int enable_controller(struct r8a66597 *r8a66597) |
204 | { | 184 | { |
205 | int ret, port; | 185 | int ret, port; |
186 | u16 vif = r8a66597->pdata->vif ? LDRV : 0; | ||
187 | u16 irq_sense = r8a66597->irq_sense_low ? INTL : 0; | ||
188 | u16 endian = r8a66597->pdata->endian ? BIGEND : 0; | ||
206 | 189 | ||
207 | ret = r8a66597_clock_enable(r8a66597); | 190 | ret = r8a66597_clock_enable(r8a66597); |
208 | if (ret < 0) | 191 | if (ret < 0) |
@@ -2373,7 +2356,7 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev) | |||
2373 | return 0; | 2356 | return 0; |
2374 | } | 2357 | } |
2375 | 2358 | ||
2376 | static int __init r8a66597_probe(struct platform_device *pdev) | 2359 | static int __devinit r8a66597_probe(struct platform_device *pdev) |
2377 | { | 2360 | { |
2378 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) | 2361 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) |
2379 | char clk_name[8]; | 2362 | char clk_name[8]; |
@@ -2418,6 +2401,12 @@ static int __init r8a66597_probe(struct platform_device *pdev) | |||
2418 | goto clean_up; | 2401 | goto clean_up; |
2419 | } | 2402 | } |
2420 | 2403 | ||
2404 | if (pdev->dev.platform_data == NULL) { | ||
2405 | dev_err(&pdev->dev, "no platform data\n"); | ||
2406 | ret = -ENODEV; | ||
2407 | goto clean_up; | ||
2408 | } | ||
2409 | |||
2421 | /* initialize hcd */ | 2410 | /* initialize hcd */ |
2422 | hcd = usb_create_hcd(&r8a66597_hc_driver, &pdev->dev, (char *)hcd_name); | 2411 | hcd = usb_create_hcd(&r8a66597_hc_driver, &pdev->dev, (char *)hcd_name); |
2423 | if (!hcd) { | 2412 | if (!hcd) { |
@@ -2428,6 +2417,8 @@ static int __init r8a66597_probe(struct platform_device *pdev) | |||
2428 | r8a66597 = hcd_to_r8a66597(hcd); | 2417 | r8a66597 = hcd_to_r8a66597(hcd); |
2429 | memset(r8a66597, 0, sizeof(struct r8a66597)); | 2418 | memset(r8a66597, 0, sizeof(struct r8a66597)); |
2430 | dev_set_drvdata(&pdev->dev, r8a66597); | 2419 | dev_set_drvdata(&pdev->dev, r8a66597); |
2420 | r8a66597->pdata = pdev->dev.platform_data; | ||
2421 | r8a66597->irq_sense_low = irq_trigger == IRQF_TRIGGER_LOW; | ||
2431 | 2422 | ||
2432 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) | 2423 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) |
2433 | snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id); | 2424 | snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id); |
@@ -2458,29 +2449,6 @@ static int __init r8a66597_probe(struct platform_device *pdev) | |||
2458 | 2449 | ||
2459 | hcd->rsrc_start = res->start; | 2450 | hcd->rsrc_start = res->start; |
2460 | 2451 | ||
2461 | /* irq_sense setting on cmdline takes precedence over resource | ||
2462 | * settings, so the introduction of irqflags in IRQ resourse | ||
2463 | * won't disturb existing setups */ | ||
2464 | switch (irq_sense) { | ||
2465 | case INTL: | ||
2466 | irq_trigger = IRQF_TRIGGER_LOW; | ||
2467 | break; | ||
2468 | case 0: | ||
2469 | irq_trigger = IRQF_TRIGGER_FALLING; | ||
2470 | break; | ||
2471 | case 0xff: | ||
2472 | if (irq_trigger) | ||
2473 | irq_sense = (irq_trigger & IRQF_TRIGGER_LOW) ? | ||
2474 | INTL : 0; | ||
2475 | else { | ||
2476 | irq_sense = INTL; | ||
2477 | irq_trigger = IRQF_TRIGGER_LOW; | ||
2478 | } | ||
2479 | break; | ||
2480 | default: | ||
2481 | dev_err(&pdev->dev, "Unknown irq_sense value.\n"); | ||
2482 | } | ||
2483 | |||
2484 | ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger); | 2452 | ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger); |
2485 | if (ret != 0) { | 2453 | if (ret != 0) { |
2486 | dev_err(&pdev->dev, "Failed to add hcd\n"); | 2454 | dev_err(&pdev->dev, "Failed to add hcd\n"); |
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h index f49208f1bb74..d72680b433f9 100644 --- a/drivers/usb/host/r8a66597.h +++ b/drivers/usb/host/r8a66597.h | |||
@@ -30,6 +30,8 @@ | |||
30 | #include <linux/clk.h> | 30 | #include <linux/clk.h> |
31 | #endif | 31 | #endif |
32 | 32 | ||
33 | #include <linux/usb/r8a66597.h> | ||
34 | |||
33 | #define SYSCFG0 0x00 | 35 | #define SYSCFG0 0x00 |
34 | #define SYSCFG1 0x02 | 36 | #define SYSCFG1 0x02 |
35 | #define SYSSTS0 0x04 | 37 | #define SYSSTS0 0x04 |
@@ -488,6 +490,7 @@ struct r8a66597 { | |||
488 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) | 490 | #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK) |
489 | struct clk *clk; | 491 | struct clk *clk; |
490 | #endif | 492 | #endif |
493 | struct r8a66597_platdata *pdata; | ||
491 | struct r8a66597_device device0; | 494 | struct r8a66597_device device0; |
492 | struct r8a66597_root_hub root_hub[R8A66597_MAX_ROOT_HUB]; | 495 | struct r8a66597_root_hub root_hub[R8A66597_MAX_ROOT_HUB]; |
493 | struct list_head pipe_queue[R8A66597_MAX_NUM_PIPE]; | 496 | struct list_head pipe_queue[R8A66597_MAX_NUM_PIPE]; |
@@ -506,6 +509,7 @@ struct r8a66597 { | |||
506 | unsigned long child_connect_map[4]; | 509 | unsigned long child_connect_map[4]; |
507 | 510 | ||
508 | unsigned bus_suspended:1; | 511 | unsigned bus_suspended:1; |
512 | unsigned irq_sense_low:1; | ||
509 | }; | 513 | }; |
510 | 514 | ||
511 | static inline struct r8a66597 *hcd_to_r8a66597(struct usb_hcd *hcd) | 515 | static inline struct r8a66597 *hcd_to_r8a66597(struct usb_hcd *hcd) |
@@ -660,10 +664,36 @@ static inline void r8a66597_port_power(struct r8a66597 *r8a66597, int port, | |||
660 | { | 664 | { |
661 | unsigned long dvstctr_reg = get_dvstctr_reg(port); | 665 | unsigned long dvstctr_reg = get_dvstctr_reg(port); |
662 | 666 | ||
663 | if (power) | 667 | if (r8a66597->pdata->port_power) { |
664 | r8a66597_bset(r8a66597, VBOUT, dvstctr_reg); | 668 | r8a66597->pdata->port_power(port, power); |
665 | else | 669 | } else { |
666 | r8a66597_bclr(r8a66597, VBOUT, dvstctr_reg); | 670 | if (power) |
671 | r8a66597_bset(r8a66597, VBOUT, dvstctr_reg); | ||
672 | else | ||
673 | r8a66597_bclr(r8a66597, VBOUT, dvstctr_reg); | ||
674 | } | ||
675 | } | ||
676 | |||
677 | static inline u16 get_xtal_from_pdata(struct r8a66597_platdata *pdata) | ||
678 | { | ||
679 | u16 clock = 0; | ||
680 | |||
681 | switch (pdata->xtal) { | ||
682 | case R8A66597_PLATDATA_XTAL_12MHZ: | ||
683 | clock = XTAL12; | ||
684 | break; | ||
685 | case R8A66597_PLATDATA_XTAL_24MHZ: | ||
686 | clock = XTAL24; | ||
687 | break; | ||
688 | case R8A66597_PLATDATA_XTAL_48MHZ: | ||
689 | clock = XTAL48; | ||
690 | break; | ||
691 | default: | ||
692 | printk(KERN_ERR "r8a66597: platdata clock is wrong.\n"); | ||
693 | break; | ||
694 | } | ||
695 | |||
696 | return clock; | ||
667 | } | 697 | } |
668 | 698 | ||
669 | #define get_pipectr_addr(pipenum) (PIPE1CTR + (pipenum - 1) * 2) | 699 | #define get_pipectr_addr(pipenum) (PIPE1CTR + (pipenum - 1) * 2) |
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c index cf5e4cf7ea42..274751b4409c 100644 --- a/drivers/usb/host/uhci-hcd.c +++ b/drivers/usb/host/uhci-hcd.c | |||
@@ -769,7 +769,7 @@ static int uhci_rh_resume(struct usb_hcd *hcd) | |||
769 | return rc; | 769 | return rc; |
770 | } | 770 | } |
771 | 771 | ||
772 | static int uhci_pci_suspend(struct usb_hcd *hcd, pm_message_t message) | 772 | static int uhci_pci_suspend(struct usb_hcd *hcd) |
773 | { | 773 | { |
774 | struct uhci_hcd *uhci = hcd_to_uhci(hcd); | 774 | struct uhci_hcd *uhci = hcd_to_uhci(hcd); |
775 | int rc = 0; | 775 | int rc = 0; |
@@ -795,10 +795,6 @@ static int uhci_pci_suspend(struct usb_hcd *hcd, pm_message_t message) | |||
795 | 795 | ||
796 | /* FIXME: Enable non-PME# remote wakeup? */ | 796 | /* FIXME: Enable non-PME# remote wakeup? */ |
797 | 797 | ||
798 | /* make sure snapshot being resumed re-enumerates everything */ | ||
799 | if (message.event == PM_EVENT_PRETHAW) | ||
800 | uhci_hc_died(uhci); | ||
801 | |||
802 | done_okay: | 798 | done_okay: |
803 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); | 799 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
804 | done: | 800 | done: |
@@ -806,7 +802,7 @@ done: | |||
806 | return rc; | 802 | return rc; |
807 | } | 803 | } |
808 | 804 | ||
809 | static int uhci_pci_resume(struct usb_hcd *hcd) | 805 | static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated) |
810 | { | 806 | { |
811 | struct uhci_hcd *uhci = hcd_to_uhci(hcd); | 807 | struct uhci_hcd *uhci = hcd_to_uhci(hcd); |
812 | 808 | ||
@@ -820,6 +816,10 @@ static int uhci_pci_resume(struct usb_hcd *hcd) | |||
820 | 816 | ||
821 | spin_lock_irq(&uhci->lock); | 817 | spin_lock_irq(&uhci->lock); |
822 | 818 | ||
819 | /* Make sure resume from hibernation re-enumerates everything */ | ||
820 | if (hibernated) | ||
821 | uhci_hc_died(uhci); | ||
822 | |||
823 | /* FIXME: Disable non-PME# remote wakeup? */ | 823 | /* FIXME: Disable non-PME# remote wakeup? */ |
824 | 824 | ||
825 | /* The firmware or a boot kernel may have changed the controller | 825 | /* The firmware or a boot kernel may have changed the controller |
@@ -940,10 +940,11 @@ static struct pci_driver uhci_pci_driver = { | |||
940 | .remove = usb_hcd_pci_remove, | 940 | .remove = usb_hcd_pci_remove, |
941 | .shutdown = uhci_shutdown, | 941 | .shutdown = uhci_shutdown, |
942 | 942 | ||
943 | #ifdef CONFIG_PM | 943 | #ifdef CONFIG_PM_SLEEP |
944 | .suspend = usb_hcd_pci_suspend, | 944 | .driver = { |
945 | .resume = usb_hcd_pci_resume, | 945 | .pm = &usb_hcd_pci_pm_ops |
946 | #endif /* PM */ | 946 | }, |
947 | #endif | ||
947 | }; | 948 | }; |
948 | 949 | ||
949 | static int __init uhci_hcd_init(void) | 950 | static int __init uhci_hcd_init(void) |
@@ -961,7 +962,7 @@ static int __init uhci_hcd_init(void) | |||
961 | errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL); | 962 | errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL); |
962 | if (!errbuf) | 963 | if (!errbuf) |
963 | goto errbuf_failed; | 964 | goto errbuf_failed; |
964 | uhci_debugfs_root = debugfs_create_dir("uhci", NULL); | 965 | uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root); |
965 | if (!uhci_debugfs_root) | 966 | if (!uhci_debugfs_root) |
966 | goto debug_failed; | 967 | goto debug_failed; |
967 | } | 968 | } |
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c index 3e5807d14ffb..64e57bfe236b 100644 --- a/drivers/usb/host/uhci-q.c +++ b/drivers/usb/host/uhci-q.c | |||
@@ -260,7 +260,7 @@ static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci, | |||
260 | INIT_LIST_HEAD(&qh->node); | 260 | INIT_LIST_HEAD(&qh->node); |
261 | 261 | ||
262 | if (udev) { /* Normal QH */ | 262 | if (udev) { /* Normal QH */ |
263 | qh->type = hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; | 263 | qh->type = usb_endpoint_type(&hep->desc); |
264 | if (qh->type != USB_ENDPOINT_XFER_ISOC) { | 264 | if (qh->type != USB_ENDPOINT_XFER_ISOC) { |
265 | qh->dummy_td = uhci_alloc_td(uhci); | 265 | qh->dummy_td = uhci_alloc_td(uhci); |
266 | if (!qh->dummy_td) { | 266 | if (!qh->dummy_td) { |
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c new file mode 100644 index 000000000000..2501c571f855 --- /dev/null +++ b/drivers/usb/host/xhci-dbg.c | |||
@@ -0,0 +1,485 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #include "xhci.h" | ||
24 | |||
25 | #define XHCI_INIT_VALUE 0x0 | ||
26 | |||
27 | /* Add verbose debugging later, just print everything for now */ | ||
28 | |||
29 | void xhci_dbg_regs(struct xhci_hcd *xhci) | ||
30 | { | ||
31 | u32 temp; | ||
32 | |||
33 | xhci_dbg(xhci, "// xHCI capability registers at %p:\n", | ||
34 | xhci->cap_regs); | ||
35 | temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase); | ||
36 | xhci_dbg(xhci, "// @%p = 0x%x (CAPLENGTH AND HCIVERSION)\n", | ||
37 | &xhci->cap_regs->hc_capbase, temp); | ||
38 | xhci_dbg(xhci, "// CAPLENGTH: 0x%x\n", | ||
39 | (unsigned int) HC_LENGTH(temp)); | ||
40 | #if 0 | ||
41 | xhci_dbg(xhci, "// HCIVERSION: 0x%x\n", | ||
42 | (unsigned int) HC_VERSION(temp)); | ||
43 | #endif | ||
44 | |||
45 | xhci_dbg(xhci, "// xHCI operational registers at %p:\n", xhci->op_regs); | ||
46 | |||
47 | temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off); | ||
48 | xhci_dbg(xhci, "// @%p = 0x%x RTSOFF\n", | ||
49 | &xhci->cap_regs->run_regs_off, | ||
50 | (unsigned int) temp & RTSOFF_MASK); | ||
51 | xhci_dbg(xhci, "// xHCI runtime registers at %p:\n", xhci->run_regs); | ||
52 | |||
53 | temp = xhci_readl(xhci, &xhci->cap_regs->db_off); | ||
54 | xhci_dbg(xhci, "// @%p = 0x%x DBOFF\n", &xhci->cap_regs->db_off, temp); | ||
55 | xhci_dbg(xhci, "// Doorbell array at %p:\n", xhci->dba); | ||
56 | } | ||
57 | |||
58 | static void xhci_print_cap_regs(struct xhci_hcd *xhci) | ||
59 | { | ||
60 | u32 temp; | ||
61 | |||
62 | xhci_dbg(xhci, "xHCI capability registers at %p:\n", xhci->cap_regs); | ||
63 | |||
64 | temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase); | ||
65 | xhci_dbg(xhci, "CAPLENGTH AND HCIVERSION 0x%x:\n", | ||
66 | (unsigned int) temp); | ||
67 | xhci_dbg(xhci, "CAPLENGTH: 0x%x\n", | ||
68 | (unsigned int) HC_LENGTH(temp)); | ||
69 | xhci_dbg(xhci, "HCIVERSION: 0x%x\n", | ||
70 | (unsigned int) HC_VERSION(temp)); | ||
71 | |||
72 | temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params1); | ||
73 | xhci_dbg(xhci, "HCSPARAMS 1: 0x%x\n", | ||
74 | (unsigned int) temp); | ||
75 | xhci_dbg(xhci, " Max device slots: %u\n", | ||
76 | (unsigned int) HCS_MAX_SLOTS(temp)); | ||
77 | xhci_dbg(xhci, " Max interrupters: %u\n", | ||
78 | (unsigned int) HCS_MAX_INTRS(temp)); | ||
79 | xhci_dbg(xhci, " Max ports: %u\n", | ||
80 | (unsigned int) HCS_MAX_PORTS(temp)); | ||
81 | |||
82 | temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params2); | ||
83 | xhci_dbg(xhci, "HCSPARAMS 2: 0x%x\n", | ||
84 | (unsigned int) temp); | ||
85 | xhci_dbg(xhci, " Isoc scheduling threshold: %u\n", | ||
86 | (unsigned int) HCS_IST(temp)); | ||
87 | xhci_dbg(xhci, " Maximum allowed segments in event ring: %u\n", | ||
88 | (unsigned int) HCS_ERST_MAX(temp)); | ||
89 | |||
90 | temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3); | ||
91 | xhci_dbg(xhci, "HCSPARAMS 3 0x%x:\n", | ||
92 | (unsigned int) temp); | ||
93 | xhci_dbg(xhci, " Worst case U1 device exit latency: %u\n", | ||
94 | (unsigned int) HCS_U1_LATENCY(temp)); | ||
95 | xhci_dbg(xhci, " Worst case U2 device exit latency: %u\n", | ||
96 | (unsigned int) HCS_U2_LATENCY(temp)); | ||
97 | |||
98 | temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params); | ||
99 | xhci_dbg(xhci, "HCC PARAMS 0x%x:\n", (unsigned int) temp); | ||
100 | xhci_dbg(xhci, " HC generates %s bit addresses\n", | ||
101 | HCC_64BIT_ADDR(temp) ? "64" : "32"); | ||
102 | /* FIXME */ | ||
103 | xhci_dbg(xhci, " FIXME: more HCCPARAMS debugging\n"); | ||
104 | |||
105 | temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off); | ||
106 | xhci_dbg(xhci, "RTSOFF 0x%x:\n", temp & RTSOFF_MASK); | ||
107 | } | ||
108 | |||
109 | static void xhci_print_command_reg(struct xhci_hcd *xhci) | ||
110 | { | ||
111 | u32 temp; | ||
112 | |||
113 | temp = xhci_readl(xhci, &xhci->op_regs->command); | ||
114 | xhci_dbg(xhci, "USBCMD 0x%x:\n", temp); | ||
115 | xhci_dbg(xhci, " HC is %s\n", | ||
116 | (temp & CMD_RUN) ? "running" : "being stopped"); | ||
117 | xhci_dbg(xhci, " HC has %sfinished hard reset\n", | ||
118 | (temp & CMD_RESET) ? "not " : ""); | ||
119 | xhci_dbg(xhci, " Event Interrupts %s\n", | ||
120 | (temp & CMD_EIE) ? "enabled " : "disabled"); | ||
121 | xhci_dbg(xhci, " Host System Error Interrupts %s\n", | ||
122 | (temp & CMD_EIE) ? "enabled " : "disabled"); | ||
123 | xhci_dbg(xhci, " HC has %sfinished light reset\n", | ||
124 | (temp & CMD_LRESET) ? "not " : ""); | ||
125 | } | ||
126 | |||
127 | static void xhci_print_status(struct xhci_hcd *xhci) | ||
128 | { | ||
129 | u32 temp; | ||
130 | |||
131 | temp = xhci_readl(xhci, &xhci->op_regs->status); | ||
132 | xhci_dbg(xhci, "USBSTS 0x%x:\n", temp); | ||
133 | xhci_dbg(xhci, " Event ring is %sempty\n", | ||
134 | (temp & STS_EINT) ? "not " : ""); | ||
135 | xhci_dbg(xhci, " %sHost System Error\n", | ||
136 | (temp & STS_FATAL) ? "WARNING: " : "No "); | ||
137 | xhci_dbg(xhci, " HC is %s\n", | ||
138 | (temp & STS_HALT) ? "halted" : "running"); | ||
139 | } | ||
140 | |||
141 | static void xhci_print_op_regs(struct xhci_hcd *xhci) | ||
142 | { | ||
143 | xhci_dbg(xhci, "xHCI operational registers at %p:\n", xhci->op_regs); | ||
144 | xhci_print_command_reg(xhci); | ||
145 | xhci_print_status(xhci); | ||
146 | } | ||
147 | |||
148 | static void xhci_print_ports(struct xhci_hcd *xhci) | ||
149 | { | ||
150 | u32 __iomem *addr; | ||
151 | int i, j; | ||
152 | int ports; | ||
153 | char *names[NUM_PORT_REGS] = { | ||
154 | "status", | ||
155 | "power", | ||
156 | "link", | ||
157 | "reserved", | ||
158 | }; | ||
159 | |||
160 | ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
161 | addr = &xhci->op_regs->port_status_base; | ||
162 | for (i = 0; i < ports; i++) { | ||
163 | for (j = 0; j < NUM_PORT_REGS; ++j) { | ||
164 | xhci_dbg(xhci, "%p port %s reg = 0x%x\n", | ||
165 | addr, names[j], | ||
166 | (unsigned int) xhci_readl(xhci, addr)); | ||
167 | addr++; | ||
168 | } | ||
169 | } | ||
170 | } | ||
171 | |||
172 | void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int set_num) | ||
173 | { | ||
174 | void *addr; | ||
175 | u32 temp; | ||
176 | |||
177 | addr = &ir_set->irq_pending; | ||
178 | temp = xhci_readl(xhci, addr); | ||
179 | if (temp == XHCI_INIT_VALUE) | ||
180 | return; | ||
181 | |||
182 | xhci_dbg(xhci, " %p: ir_set[%i]\n", ir_set, set_num); | ||
183 | |||
184 | xhci_dbg(xhci, " %p: ir_set.pending = 0x%x\n", addr, | ||
185 | (unsigned int)temp); | ||
186 | |||
187 | addr = &ir_set->irq_control; | ||
188 | temp = xhci_readl(xhci, addr); | ||
189 | xhci_dbg(xhci, " %p: ir_set.control = 0x%x\n", addr, | ||
190 | (unsigned int)temp); | ||
191 | |||
192 | addr = &ir_set->erst_size; | ||
193 | temp = xhci_readl(xhci, addr); | ||
194 | xhci_dbg(xhci, " %p: ir_set.erst_size = 0x%x\n", addr, | ||
195 | (unsigned int)temp); | ||
196 | |||
197 | addr = &ir_set->rsvd; | ||
198 | temp = xhci_readl(xhci, addr); | ||
199 | if (temp != XHCI_INIT_VALUE) | ||
200 | xhci_dbg(xhci, " WARN: %p: ir_set.rsvd = 0x%x\n", | ||
201 | addr, (unsigned int)temp); | ||
202 | |||
203 | addr = &ir_set->erst_base[0]; | ||
204 | temp = xhci_readl(xhci, addr); | ||
205 | xhci_dbg(xhci, " %p: ir_set.erst_base[0] = 0x%x\n", | ||
206 | addr, (unsigned int) temp); | ||
207 | |||
208 | addr = &ir_set->erst_base[1]; | ||
209 | temp = xhci_readl(xhci, addr); | ||
210 | xhci_dbg(xhci, " %p: ir_set.erst_base[1] = 0x%x\n", | ||
211 | addr, (unsigned int) temp); | ||
212 | |||
213 | addr = &ir_set->erst_dequeue[0]; | ||
214 | temp = xhci_readl(xhci, addr); | ||
215 | xhci_dbg(xhci, " %p: ir_set.erst_dequeue[0] = 0x%x\n", | ||
216 | addr, (unsigned int) temp); | ||
217 | |||
218 | addr = &ir_set->erst_dequeue[1]; | ||
219 | temp = xhci_readl(xhci, addr); | ||
220 | xhci_dbg(xhci, " %p: ir_set.erst_dequeue[1] = 0x%x\n", | ||
221 | addr, (unsigned int) temp); | ||
222 | } | ||
223 | |||
224 | void xhci_print_run_regs(struct xhci_hcd *xhci) | ||
225 | { | ||
226 | u32 temp; | ||
227 | int i; | ||
228 | |||
229 | xhci_dbg(xhci, "xHCI runtime registers at %p:\n", xhci->run_regs); | ||
230 | temp = xhci_readl(xhci, &xhci->run_regs->microframe_index); | ||
231 | xhci_dbg(xhci, " %p: Microframe index = 0x%x\n", | ||
232 | &xhci->run_regs->microframe_index, | ||
233 | (unsigned int) temp); | ||
234 | for (i = 0; i < 7; ++i) { | ||
235 | temp = xhci_readl(xhci, &xhci->run_regs->rsvd[i]); | ||
236 | if (temp != XHCI_INIT_VALUE) | ||
237 | xhci_dbg(xhci, " WARN: %p: Rsvd[%i] = 0x%x\n", | ||
238 | &xhci->run_regs->rsvd[i], | ||
239 | i, (unsigned int) temp); | ||
240 | } | ||
241 | } | ||
242 | |||
243 | void xhci_print_registers(struct xhci_hcd *xhci) | ||
244 | { | ||
245 | xhci_print_cap_regs(xhci); | ||
246 | xhci_print_op_regs(xhci); | ||
247 | xhci_print_ports(xhci); | ||
248 | } | ||
249 | |||
250 | void xhci_print_trb_offsets(struct xhci_hcd *xhci, union xhci_trb *trb) | ||
251 | { | ||
252 | int i; | ||
253 | for (i = 0; i < 4; ++i) | ||
254 | xhci_dbg(xhci, "Offset 0x%x = 0x%x\n", | ||
255 | i*4, trb->generic.field[i]); | ||
256 | } | ||
257 | |||
258 | /** | ||
259 | * Debug a transfer request block (TRB). | ||
260 | */ | ||
261 | void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb) | ||
262 | { | ||
263 | u64 address; | ||
264 | u32 type = xhci_readl(xhci, &trb->link.control) & TRB_TYPE_BITMASK; | ||
265 | |||
266 | switch (type) { | ||
267 | case TRB_TYPE(TRB_LINK): | ||
268 | xhci_dbg(xhci, "Link TRB:\n"); | ||
269 | xhci_print_trb_offsets(xhci, trb); | ||
270 | |||
271 | address = trb->link.segment_ptr[0] + | ||
272 | (((u64) trb->link.segment_ptr[1]) << 32); | ||
273 | xhci_dbg(xhci, "Next ring segment DMA address = 0x%llx\n", address); | ||
274 | |||
275 | xhci_dbg(xhci, "Interrupter target = 0x%x\n", | ||
276 | GET_INTR_TARGET(trb->link.intr_target)); | ||
277 | xhci_dbg(xhci, "Cycle bit = %u\n", | ||
278 | (unsigned int) (trb->link.control & TRB_CYCLE)); | ||
279 | xhci_dbg(xhci, "Toggle cycle bit = %u\n", | ||
280 | (unsigned int) (trb->link.control & LINK_TOGGLE)); | ||
281 | xhci_dbg(xhci, "No Snoop bit = %u\n", | ||
282 | (unsigned int) (trb->link.control & TRB_NO_SNOOP)); | ||
283 | break; | ||
284 | case TRB_TYPE(TRB_TRANSFER): | ||
285 | address = trb->trans_event.buffer[0] + | ||
286 | (((u64) trb->trans_event.buffer[1]) << 32); | ||
287 | /* | ||
288 | * FIXME: look at flags to figure out if it's an address or if | ||
289 | * the data is directly in the buffer field. | ||
290 | */ | ||
291 | xhci_dbg(xhci, "DMA address or buffer contents= %llu\n", address); | ||
292 | break; | ||
293 | case TRB_TYPE(TRB_COMPLETION): | ||
294 | address = trb->event_cmd.cmd_trb[0] + | ||
295 | (((u64) trb->event_cmd.cmd_trb[1]) << 32); | ||
296 | xhci_dbg(xhci, "Command TRB pointer = %llu\n", address); | ||
297 | xhci_dbg(xhci, "Completion status = %u\n", | ||
298 | (unsigned int) GET_COMP_CODE(trb->event_cmd.status)); | ||
299 | xhci_dbg(xhci, "Flags = 0x%x\n", (unsigned int) trb->event_cmd.flags); | ||
300 | break; | ||
301 | default: | ||
302 | xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n", | ||
303 | (unsigned int) type>>10); | ||
304 | xhci_print_trb_offsets(xhci, trb); | ||
305 | break; | ||
306 | } | ||
307 | } | ||
308 | |||
309 | /** | ||
310 | * Debug a segment with an xHCI ring. | ||
311 | * | ||
312 | * @return The Link TRB of the segment, or NULL if there is no Link TRB | ||
313 | * (which is a bug, since all segments must have a Link TRB). | ||
314 | * | ||
315 | * Prints out all TRBs in the segment, even those after the Link TRB. | ||
316 | * | ||
317 | * XXX: should we print out TRBs that the HC owns? As long as we don't | ||
318 | * write, that should be fine... We shouldn't expect that the memory pointed to | ||
319 | * by the TRB is valid at all. Do we care about ones the HC owns? Probably, | ||
320 | * for HC debugging. | ||
321 | */ | ||
322 | void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg) | ||
323 | { | ||
324 | int i; | ||
325 | u32 addr = (u32) seg->dma; | ||
326 | union xhci_trb *trb = seg->trbs; | ||
327 | |||
328 | for (i = 0; i < TRBS_PER_SEGMENT; ++i) { | ||
329 | trb = &seg->trbs[i]; | ||
330 | xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n", addr, | ||
331 | (unsigned int) trb->link.segment_ptr[0], | ||
332 | (unsigned int) trb->link.segment_ptr[1], | ||
333 | (unsigned int) trb->link.intr_target, | ||
334 | (unsigned int) trb->link.control); | ||
335 | addr += sizeof(*trb); | ||
336 | } | ||
337 | } | ||
338 | |||
339 | void xhci_dbg_ring_ptrs(struct xhci_hcd *xhci, struct xhci_ring *ring) | ||
340 | { | ||
341 | xhci_dbg(xhci, "Ring deq = %p (virt), 0x%llx (dma)\n", | ||
342 | ring->dequeue, | ||
343 | (unsigned long long)xhci_trb_virt_to_dma(ring->deq_seg, | ||
344 | ring->dequeue)); | ||
345 | xhci_dbg(xhci, "Ring deq updated %u times\n", | ||
346 | ring->deq_updates); | ||
347 | xhci_dbg(xhci, "Ring enq = %p (virt), 0x%llx (dma)\n", | ||
348 | ring->enqueue, | ||
349 | (unsigned long long)xhci_trb_virt_to_dma(ring->enq_seg, | ||
350 | ring->enqueue)); | ||
351 | xhci_dbg(xhci, "Ring enq updated %u times\n", | ||
352 | ring->enq_updates); | ||
353 | } | ||
354 | |||
355 | /** | ||
356 | * Debugging for an xHCI ring, which is a queue broken into multiple segments. | ||
357 | * | ||
358 | * Print out each segment in the ring. Check that the DMA address in | ||
359 | * each link segment actually matches the segment's stored DMA address. | ||
360 | * Check that the link end bit is only set at the end of the ring. | ||
361 | * Check that the dequeue and enqueue pointers point to real data in this ring | ||
362 | * (not some other ring). | ||
363 | */ | ||
364 | void xhci_debug_ring(struct xhci_hcd *xhci, struct xhci_ring *ring) | ||
365 | { | ||
366 | /* FIXME: Throw an error if any segment doesn't have a Link TRB */ | ||
367 | struct xhci_segment *seg; | ||
368 | struct xhci_segment *first_seg = ring->first_seg; | ||
369 | xhci_debug_segment(xhci, first_seg); | ||
370 | |||
371 | if (!ring->enq_updates && !ring->deq_updates) { | ||
372 | xhci_dbg(xhci, " Ring has not been updated\n"); | ||
373 | return; | ||
374 | } | ||
375 | for (seg = first_seg->next; seg != first_seg; seg = seg->next) | ||
376 | xhci_debug_segment(xhci, seg); | ||
377 | } | ||
378 | |||
379 | void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst) | ||
380 | { | ||
381 | u32 addr = (u32) erst->erst_dma_addr; | ||
382 | int i; | ||
383 | struct xhci_erst_entry *entry; | ||
384 | |||
385 | for (i = 0; i < erst->num_entries; ++i) { | ||
386 | entry = &erst->entries[i]; | ||
387 | xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n", | ||
388 | (unsigned int) addr, | ||
389 | (unsigned int) entry->seg_addr[0], | ||
390 | (unsigned int) entry->seg_addr[1], | ||
391 | (unsigned int) entry->seg_size, | ||
392 | (unsigned int) entry->rsvd); | ||
393 | addr += sizeof(*entry); | ||
394 | } | ||
395 | } | ||
396 | |||
397 | void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci) | ||
398 | { | ||
399 | u32 val; | ||
400 | |||
401 | val = xhci_readl(xhci, &xhci->op_regs->cmd_ring[0]); | ||
402 | xhci_dbg(xhci, "// xHC command ring deq ptr low bits + flags = 0x%x\n", val); | ||
403 | val = xhci_readl(xhci, &xhci->op_regs->cmd_ring[1]); | ||
404 | xhci_dbg(xhci, "// xHC command ring deq ptr high bits = 0x%x\n", val); | ||
405 | } | ||
406 | |||
407 | void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_device_control *ctx, dma_addr_t dma, unsigned int last_ep) | ||
408 | { | ||
409 | int i, j; | ||
410 | int last_ep_ctx = 31; | ||
411 | /* Fields are 32 bits wide, DMA addresses are in bytes */ | ||
412 | int field_size = 32 / 8; | ||
413 | |||
414 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - drop flags\n", | ||
415 | &ctx->drop_flags, (unsigned long long)dma, | ||
416 | ctx->drop_flags); | ||
417 | dma += field_size; | ||
418 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - add flags\n", | ||
419 | &ctx->add_flags, (unsigned long long)dma, | ||
420 | ctx->add_flags); | ||
421 | dma += field_size; | ||
422 | for (i = 0; i > 6; ++i) { | ||
423 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n", | ||
424 | &ctx->rsvd[i], (unsigned long long)dma, | ||
425 | ctx->rsvd[i], i); | ||
426 | dma += field_size; | ||
427 | } | ||
428 | |||
429 | xhci_dbg(xhci, "Slot Context:\n"); | ||
430 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info\n", | ||
431 | &ctx->slot.dev_info, | ||
432 | (unsigned long long)dma, ctx->slot.dev_info); | ||
433 | dma += field_size; | ||
434 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_info2\n", | ||
435 | &ctx->slot.dev_info2, | ||
436 | (unsigned long long)dma, ctx->slot.dev_info2); | ||
437 | dma += field_size; | ||
438 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tt_info\n", | ||
439 | &ctx->slot.tt_info, | ||
440 | (unsigned long long)dma, ctx->slot.tt_info); | ||
441 | dma += field_size; | ||
442 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - dev_state\n", | ||
443 | &ctx->slot.dev_state, | ||
444 | (unsigned long long)dma, ctx->slot.dev_state); | ||
445 | dma += field_size; | ||
446 | for (i = 0; i > 4; ++i) { | ||
447 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n", | ||
448 | &ctx->slot.reserved[i], (unsigned long long)dma, | ||
449 | ctx->slot.reserved[i], i); | ||
450 | dma += field_size; | ||
451 | } | ||
452 | |||
453 | if (last_ep < 31) | ||
454 | last_ep_ctx = last_ep + 1; | ||
455 | for (i = 0; i < last_ep_ctx; ++i) { | ||
456 | xhci_dbg(xhci, "Endpoint %02d Context:\n", i); | ||
457 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info\n", | ||
458 | &ctx->ep[i].ep_info, | ||
459 | (unsigned long long)dma, ctx->ep[i].ep_info); | ||
460 | dma += field_size; | ||
461 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info2\n", | ||
462 | &ctx->ep[i].ep_info2, | ||
463 | (unsigned long long)dma, ctx->ep[i].ep_info2); | ||
464 | dma += field_size; | ||
465 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - deq[0]\n", | ||
466 | &ctx->ep[i].deq[0], | ||
467 | (unsigned long long)dma, ctx->ep[i].deq[0]); | ||
468 | dma += field_size; | ||
469 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - deq[1]\n", | ||
470 | &ctx->ep[i].deq[1], | ||
471 | (unsigned long long)dma, ctx->ep[i].deq[1]); | ||
472 | dma += field_size; | ||
473 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - tx_info\n", | ||
474 | &ctx->ep[i].tx_info, | ||
475 | (unsigned long long)dma, ctx->ep[i].tx_info); | ||
476 | dma += field_size; | ||
477 | for (j = 0; j < 3; ++j) { | ||
478 | xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - rsvd[%d]\n", | ||
479 | &ctx->ep[i].reserved[j], | ||
480 | (unsigned long long)dma, | ||
481 | ctx->ep[i].reserved[j], j); | ||
482 | dma += field_size; | ||
483 | } | ||
484 | } | ||
485 | } | ||
diff --git a/drivers/usb/host/xhci-ext-caps.h b/drivers/usb/host/xhci-ext-caps.h new file mode 100644 index 000000000000..ecc131c3fe33 --- /dev/null +++ b/drivers/usb/host/xhci-ext-caps.h | |||
@@ -0,0 +1,145 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | /* Up to 16 microframes to halt an HC - one microframe is 125 microsectonds */ | ||
23 | #define XHCI_MAX_HALT_USEC (16*125) | ||
24 | /* HC not running - set to 1 when run/stop bit is cleared. */ | ||
25 | #define XHCI_STS_HALT (1<<0) | ||
26 | |||
27 | /* HCCPARAMS offset from PCI base address */ | ||
28 | #define XHCI_HCC_PARAMS_OFFSET 0x10 | ||
29 | /* HCCPARAMS contains the first extended capability pointer */ | ||
30 | #define XHCI_HCC_EXT_CAPS(p) (((p)>>16)&0xffff) | ||
31 | |||
32 | /* Command and Status registers offset from the Operational Registers address */ | ||
33 | #define XHCI_CMD_OFFSET 0x00 | ||
34 | #define XHCI_STS_OFFSET 0x04 | ||
35 | |||
36 | #define XHCI_MAX_EXT_CAPS 50 | ||
37 | |||
38 | /* Capability Register */ | ||
39 | /* bits 7:0 - how long is the Capabilities register */ | ||
40 | #define XHCI_HC_LENGTH(p) (((p)>>00)&0x00ff) | ||
41 | |||
42 | /* Extended capability register fields */ | ||
43 | #define XHCI_EXT_CAPS_ID(p) (((p)>>0)&0xff) | ||
44 | #define XHCI_EXT_CAPS_NEXT(p) (((p)>>8)&0xff) | ||
45 | #define XHCI_EXT_CAPS_VAL(p) ((p)>>16) | ||
46 | /* Extended capability IDs - ID 0 reserved */ | ||
47 | #define XHCI_EXT_CAPS_LEGACY 1 | ||
48 | #define XHCI_EXT_CAPS_PROTOCOL 2 | ||
49 | #define XHCI_EXT_CAPS_PM 3 | ||
50 | #define XHCI_EXT_CAPS_VIRT 4 | ||
51 | #define XHCI_EXT_CAPS_ROUTE 5 | ||
52 | /* IDs 6-9 reserved */ | ||
53 | #define XHCI_EXT_CAPS_DEBUG 10 | ||
54 | /* USB Legacy Support Capability - section 7.1.1 */ | ||
55 | #define XHCI_HC_BIOS_OWNED (1 << 16) | ||
56 | #define XHCI_HC_OS_OWNED (1 << 24) | ||
57 | |||
58 | /* USB Legacy Support Capability - section 7.1.1 */ | ||
59 | /* Add this offset, plus the value of xECP in HCCPARAMS to the base address */ | ||
60 | #define XHCI_LEGACY_SUPPORT_OFFSET (0x00) | ||
61 | |||
62 | /* USB Legacy Support Control and Status Register - section 7.1.2 */ | ||
63 | /* Add this offset, plus the value of xECP in HCCPARAMS to the base address */ | ||
64 | #define XHCI_LEGACY_CONTROL_OFFSET (0x04) | ||
65 | /* bits 1:2, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */ | ||
66 | #define XHCI_LEGACY_DISABLE_SMI ((0x3 << 1) + (0xff << 5) + (0x7 << 17)) | ||
67 | |||
68 | /* command register values to disable interrupts and halt the HC */ | ||
69 | /* start/stop HC execution - do not write unless HC is halted*/ | ||
70 | #define XHCI_CMD_RUN (1 << 0) | ||
71 | /* Event Interrupt Enable - get irq when EINT bit is set in USBSTS register */ | ||
72 | #define XHCI_CMD_EIE (1 << 2) | ||
73 | /* Host System Error Interrupt Enable - get irq when HSEIE bit set in USBSTS */ | ||
74 | #define XHCI_CMD_HSEIE (1 << 3) | ||
75 | /* Enable Wrap Event - '1' means xHC generates an event when MFINDEX wraps. */ | ||
76 | #define XHCI_CMD_EWE (1 << 10) | ||
77 | |||
78 | #define XHCI_IRQS (XHCI_CMD_EIE | XHCI_CMD_HSEIE | XHCI_CMD_EWE) | ||
79 | |||
80 | /* true: Controller Not Ready to accept doorbell or op reg writes after reset */ | ||
81 | #define XHCI_STS_CNR (1 << 11) | ||
82 | |||
83 | #include <linux/io.h> | ||
84 | |||
85 | /** | ||
86 | * Return the next extended capability pointer register. | ||
87 | * | ||
88 | * @base PCI register base address. | ||
89 | * | ||
90 | * @ext_offset Offset of the 32-bit register that contains the extended | ||
91 | * capabilites pointer. If searching for the first extended capability, pass | ||
92 | * in XHCI_HCC_PARAMS_OFFSET. If searching for the next extended capability, | ||
93 | * pass in the offset of the current extended capability register. | ||
94 | * | ||
95 | * Returns 0 if there is no next extended capability register or returns the register offset | ||
96 | * from the PCI registers base address. | ||
97 | */ | ||
98 | static inline int xhci_find_next_cap_offset(void __iomem *base, int ext_offset) | ||
99 | { | ||
100 | u32 next; | ||
101 | |||
102 | next = readl(base + ext_offset); | ||
103 | |||
104 | if (ext_offset == XHCI_HCC_PARAMS_OFFSET) | ||
105 | /* Find the first extended capability */ | ||
106 | next = XHCI_HCC_EXT_CAPS(next); | ||
107 | else | ||
108 | /* Find the next extended capability */ | ||
109 | next = XHCI_EXT_CAPS_NEXT(next); | ||
110 | if (!next) | ||
111 | return 0; | ||
112 | /* | ||
113 | * Address calculation from offset of extended capabilities | ||
114 | * (or HCCPARAMS) register - see section 5.3.6 and section 7. | ||
115 | */ | ||
116 | return ext_offset + (next << 2); | ||
117 | } | ||
118 | |||
119 | /** | ||
120 | * Find the offset of the extended capabilities with capability ID id. | ||
121 | * | ||
122 | * @base PCI MMIO registers base address. | ||
123 | * @ext_offset Offset from base of the first extended capability to look at, | ||
124 | * or the address of HCCPARAMS. | ||
125 | * @id Extended capability ID to search for. | ||
126 | * | ||
127 | * This uses an arbitrary limit of XHCI_MAX_EXT_CAPS extended capabilities | ||
128 | * to make sure that the list doesn't contain a loop. | ||
129 | */ | ||
130 | static inline int xhci_find_ext_cap_by_id(void __iomem *base, int ext_offset, int id) | ||
131 | { | ||
132 | u32 val; | ||
133 | int limit = XHCI_MAX_EXT_CAPS; | ||
134 | |||
135 | while (ext_offset && limit > 0) { | ||
136 | val = readl(base + ext_offset); | ||
137 | if (XHCI_EXT_CAPS_ID(val) == id) | ||
138 | break; | ||
139 | ext_offset = xhci_find_next_cap_offset(base, ext_offset); | ||
140 | limit--; | ||
141 | } | ||
142 | if (limit > 0) | ||
143 | return ext_offset; | ||
144 | return 0; | ||
145 | } | ||
diff --git a/drivers/usb/host/xhci-hcd.c b/drivers/usb/host/xhci-hcd.c new file mode 100644 index 000000000000..dba3e07ccd09 --- /dev/null +++ b/drivers/usb/host/xhci-hcd.c | |||
@@ -0,0 +1,1274 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #include <linux/irq.h> | ||
24 | #include <linux/module.h> | ||
25 | |||
26 | #include "xhci.h" | ||
27 | |||
28 | #define DRIVER_AUTHOR "Sarah Sharp" | ||
29 | #define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver" | ||
30 | |||
31 | /* TODO: copied from ehci-hcd.c - can this be refactored? */ | ||
32 | /* | ||
33 | * handshake - spin reading hc until handshake completes or fails | ||
34 | * @ptr: address of hc register to be read | ||
35 | * @mask: bits to look at in result of read | ||
36 | * @done: value of those bits when handshake succeeds | ||
37 | * @usec: timeout in microseconds | ||
38 | * | ||
39 | * Returns negative errno, or zero on success | ||
40 | * | ||
41 | * Success happens when the "mask" bits have the specified value (hardware | ||
42 | * handshake done). There are two failure modes: "usec" have passed (major | ||
43 | * hardware flakeout), or the register reads as all-ones (hardware removed). | ||
44 | */ | ||
45 | static int handshake(struct xhci_hcd *xhci, void __iomem *ptr, | ||
46 | u32 mask, u32 done, int usec) | ||
47 | { | ||
48 | u32 result; | ||
49 | |||
50 | do { | ||
51 | result = xhci_readl(xhci, ptr); | ||
52 | if (result == ~(u32)0) /* card removed */ | ||
53 | return -ENODEV; | ||
54 | result &= mask; | ||
55 | if (result == done) | ||
56 | return 0; | ||
57 | udelay(1); | ||
58 | usec--; | ||
59 | } while (usec > 0); | ||
60 | return -ETIMEDOUT; | ||
61 | } | ||
62 | |||
63 | /* | ||
64 | * Force HC into halt state. | ||
65 | * | ||
66 | * Disable any IRQs and clear the run/stop bit. | ||
67 | * HC will complete any current and actively pipelined transactions, and | ||
68 | * should halt within 16 microframes of the run/stop bit being cleared. | ||
69 | * Read HC Halted bit in the status register to see when the HC is finished. | ||
70 | * XXX: shouldn't we set HC_STATE_HALT here somewhere? | ||
71 | */ | ||
72 | int xhci_halt(struct xhci_hcd *xhci) | ||
73 | { | ||
74 | u32 halted; | ||
75 | u32 cmd; | ||
76 | u32 mask; | ||
77 | |||
78 | xhci_dbg(xhci, "// Halt the HC\n"); | ||
79 | /* Disable all interrupts from the host controller */ | ||
80 | mask = ~(XHCI_IRQS); | ||
81 | halted = xhci_readl(xhci, &xhci->op_regs->status) & STS_HALT; | ||
82 | if (!halted) | ||
83 | mask &= ~CMD_RUN; | ||
84 | |||
85 | cmd = xhci_readl(xhci, &xhci->op_regs->command); | ||
86 | cmd &= mask; | ||
87 | xhci_writel(xhci, cmd, &xhci->op_regs->command); | ||
88 | |||
89 | return handshake(xhci, &xhci->op_regs->status, | ||
90 | STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC); | ||
91 | } | ||
92 | |||
93 | /* | ||
94 | * Reset a halted HC, and set the internal HC state to HC_STATE_HALT. | ||
95 | * | ||
96 | * This resets pipelines, timers, counters, state machines, etc. | ||
97 | * Transactions will be terminated immediately, and operational registers | ||
98 | * will be set to their defaults. | ||
99 | */ | ||
100 | int xhci_reset(struct xhci_hcd *xhci) | ||
101 | { | ||
102 | u32 command; | ||
103 | u32 state; | ||
104 | |||
105 | state = xhci_readl(xhci, &xhci->op_regs->status); | ||
106 | BUG_ON((state & STS_HALT) == 0); | ||
107 | |||
108 | xhci_dbg(xhci, "// Reset the HC\n"); | ||
109 | command = xhci_readl(xhci, &xhci->op_regs->command); | ||
110 | command |= CMD_RESET; | ||
111 | xhci_writel(xhci, command, &xhci->op_regs->command); | ||
112 | /* XXX: Why does EHCI set this here? Shouldn't other code do this? */ | ||
113 | xhci_to_hcd(xhci)->state = HC_STATE_HALT; | ||
114 | |||
115 | return handshake(xhci, &xhci->op_regs->command, CMD_RESET, 0, 250 * 1000); | ||
116 | } | ||
117 | |||
118 | /* | ||
119 | * Stop the HC from processing the endpoint queues. | ||
120 | */ | ||
121 | static void xhci_quiesce(struct xhci_hcd *xhci) | ||
122 | { | ||
123 | /* | ||
124 | * Queues are per endpoint, so we need to disable an endpoint or slot. | ||
125 | * | ||
126 | * To disable a slot, we need to insert a disable slot command on the | ||
127 | * command ring and ring the doorbell. This will also free any internal | ||
128 | * resources associated with the slot (which might not be what we want). | ||
129 | * | ||
130 | * A Release Endpoint command sounds better - doesn't free internal HC | ||
131 | * memory, but removes the endpoints from the schedule and releases the | ||
132 | * bandwidth, disables the doorbells, and clears the endpoint enable | ||
133 | * flag. Usually used prior to a set interface command. | ||
134 | * | ||
135 | * TODO: Implement after command ring code is done. | ||
136 | */ | ||
137 | BUG_ON(!HC_IS_RUNNING(xhci_to_hcd(xhci)->state)); | ||
138 | xhci_dbg(xhci, "Finished quiescing -- code not written yet\n"); | ||
139 | } | ||
140 | |||
141 | #if 0 | ||
142 | /* Set up MSI-X table for entry 0 (may claim other entries later) */ | ||
143 | static int xhci_setup_msix(struct xhci_hcd *xhci) | ||
144 | { | ||
145 | int ret; | ||
146 | struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); | ||
147 | |||
148 | xhci->msix_count = 0; | ||
149 | /* XXX: did I do this right? ixgbe does kcalloc for more than one */ | ||
150 | xhci->msix_entries = kmalloc(sizeof(struct msix_entry), GFP_KERNEL); | ||
151 | if (!xhci->msix_entries) { | ||
152 | xhci_err(xhci, "Failed to allocate MSI-X entries\n"); | ||
153 | return -ENOMEM; | ||
154 | } | ||
155 | xhci->msix_entries[0].entry = 0; | ||
156 | |||
157 | ret = pci_enable_msix(pdev, xhci->msix_entries, xhci->msix_count); | ||
158 | if (ret) { | ||
159 | xhci_err(xhci, "Failed to enable MSI-X\n"); | ||
160 | goto free_entries; | ||
161 | } | ||
162 | |||
163 | /* | ||
164 | * Pass the xhci pointer value as the request_irq "cookie". | ||
165 | * If more irqs are added, this will need to be unique for each one. | ||
166 | */ | ||
167 | ret = request_irq(xhci->msix_entries[0].vector, &xhci_irq, 0, | ||
168 | "xHCI", xhci_to_hcd(xhci)); | ||
169 | if (ret) { | ||
170 | xhci_err(xhci, "Failed to allocate MSI-X interrupt\n"); | ||
171 | goto disable_msix; | ||
172 | } | ||
173 | xhci_dbg(xhci, "Finished setting up MSI-X\n"); | ||
174 | return 0; | ||
175 | |||
176 | disable_msix: | ||
177 | pci_disable_msix(pdev); | ||
178 | free_entries: | ||
179 | kfree(xhci->msix_entries); | ||
180 | xhci->msix_entries = NULL; | ||
181 | return ret; | ||
182 | } | ||
183 | |||
184 | /* XXX: code duplication; can xhci_setup_msix call this? */ | ||
185 | /* Free any IRQs and disable MSI-X */ | ||
186 | static void xhci_cleanup_msix(struct xhci_hcd *xhci) | ||
187 | { | ||
188 | struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); | ||
189 | if (!xhci->msix_entries) | ||
190 | return; | ||
191 | |||
192 | free_irq(xhci->msix_entries[0].vector, xhci); | ||
193 | pci_disable_msix(pdev); | ||
194 | kfree(xhci->msix_entries); | ||
195 | xhci->msix_entries = NULL; | ||
196 | xhci_dbg(xhci, "Finished cleaning up MSI-X\n"); | ||
197 | } | ||
198 | #endif | ||
199 | |||
200 | /* | ||
201 | * Initialize memory for HCD and xHC (one-time init). | ||
202 | * | ||
203 | * Program the PAGESIZE register, initialize the device context array, create | ||
204 | * device contexts (?), set up a command ring segment (or two?), create event | ||
205 | * ring (one for now). | ||
206 | */ | ||
207 | int xhci_init(struct usb_hcd *hcd) | ||
208 | { | ||
209 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
210 | int retval = 0; | ||
211 | |||
212 | xhci_dbg(xhci, "xhci_init\n"); | ||
213 | spin_lock_init(&xhci->lock); | ||
214 | retval = xhci_mem_init(xhci, GFP_KERNEL); | ||
215 | xhci_dbg(xhci, "Finished xhci_init\n"); | ||
216 | |||
217 | return retval; | ||
218 | } | ||
219 | |||
220 | /* | ||
221 | * Called in interrupt context when there might be work | ||
222 | * queued on the event ring | ||
223 | * | ||
224 | * xhci->lock must be held by caller. | ||
225 | */ | ||
226 | static void xhci_work(struct xhci_hcd *xhci) | ||
227 | { | ||
228 | u32 temp; | ||
229 | |||
230 | /* | ||
231 | * Clear the op reg interrupt status first, | ||
232 | * so we can receive interrupts from other MSI-X interrupters. | ||
233 | * Write 1 to clear the interrupt status. | ||
234 | */ | ||
235 | temp = xhci_readl(xhci, &xhci->op_regs->status); | ||
236 | temp |= STS_EINT; | ||
237 | xhci_writel(xhci, temp, &xhci->op_regs->status); | ||
238 | /* FIXME when MSI-X is supported and there are multiple vectors */ | ||
239 | /* Clear the MSI-X event interrupt status */ | ||
240 | |||
241 | /* Acknowledge the interrupt */ | ||
242 | temp = xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
243 | temp |= 0x3; | ||
244 | xhci_writel(xhci, temp, &xhci->ir_set->irq_pending); | ||
245 | /* Flush posted writes */ | ||
246 | xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
247 | |||
248 | /* FIXME this should be a delayed service routine that clears the EHB */ | ||
249 | xhci_handle_event(xhci); | ||
250 | |||
251 | /* Clear the event handler busy flag; the event ring should be empty. */ | ||
252 | temp = xhci_readl(xhci, &xhci->ir_set->erst_dequeue[0]); | ||
253 | xhci_writel(xhci, temp & ~ERST_EHB, &xhci->ir_set->erst_dequeue[0]); | ||
254 | /* Flush posted writes -- FIXME is this necessary? */ | ||
255 | xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
256 | } | ||
257 | |||
258 | /*-------------------------------------------------------------------------*/ | ||
259 | |||
260 | /* | ||
261 | * xHCI spec says we can get an interrupt, and if the HC has an error condition, | ||
262 | * we might get bad data out of the event ring. Section 4.10.2.7 has a list of | ||
263 | * indicators of an event TRB error, but we check the status *first* to be safe. | ||
264 | */ | ||
265 | irqreturn_t xhci_irq(struct usb_hcd *hcd) | ||
266 | { | ||
267 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
268 | u32 temp, temp2; | ||
269 | |||
270 | spin_lock(&xhci->lock); | ||
271 | /* Check if the xHC generated the interrupt, or the irq is shared */ | ||
272 | temp = xhci_readl(xhci, &xhci->op_regs->status); | ||
273 | temp2 = xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
274 | if (!(temp & STS_EINT) && !ER_IRQ_PENDING(temp2)) { | ||
275 | spin_unlock(&xhci->lock); | ||
276 | return IRQ_NONE; | ||
277 | } | ||
278 | |||
279 | if (temp & STS_FATAL) { | ||
280 | xhci_warn(xhci, "WARNING: Host System Error\n"); | ||
281 | xhci_halt(xhci); | ||
282 | xhci_to_hcd(xhci)->state = HC_STATE_HALT; | ||
283 | spin_unlock(&xhci->lock); | ||
284 | return -ESHUTDOWN; | ||
285 | } | ||
286 | |||
287 | xhci_work(xhci); | ||
288 | spin_unlock(&xhci->lock); | ||
289 | |||
290 | return IRQ_HANDLED; | ||
291 | } | ||
292 | |||
293 | #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING | ||
294 | void xhci_event_ring_work(unsigned long arg) | ||
295 | { | ||
296 | unsigned long flags; | ||
297 | int temp; | ||
298 | struct xhci_hcd *xhci = (struct xhci_hcd *) arg; | ||
299 | int i, j; | ||
300 | |||
301 | xhci_dbg(xhci, "Poll event ring: %lu\n", jiffies); | ||
302 | |||
303 | spin_lock_irqsave(&xhci->lock, flags); | ||
304 | temp = xhci_readl(xhci, &xhci->op_regs->status); | ||
305 | xhci_dbg(xhci, "op reg status = 0x%x\n", temp); | ||
306 | temp = xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
307 | xhci_dbg(xhci, "ir_set 0 pending = 0x%x\n", temp); | ||
308 | xhci_dbg(xhci, "No-op commands handled = %d\n", xhci->noops_handled); | ||
309 | xhci_dbg(xhci, "HC error bitmask = 0x%x\n", xhci->error_bitmask); | ||
310 | xhci->error_bitmask = 0; | ||
311 | xhci_dbg(xhci, "Event ring:\n"); | ||
312 | xhci_debug_segment(xhci, xhci->event_ring->deq_seg); | ||
313 | xhci_dbg_ring_ptrs(xhci, xhci->event_ring); | ||
314 | temp = xhci_readl(xhci, &xhci->ir_set->erst_dequeue[0]); | ||
315 | temp &= ERST_PTR_MASK; | ||
316 | xhci_dbg(xhci, "ERST deq = 0x%x\n", temp); | ||
317 | xhci_dbg(xhci, "Command ring:\n"); | ||
318 | xhci_debug_segment(xhci, xhci->cmd_ring->deq_seg); | ||
319 | xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring); | ||
320 | xhci_dbg_cmd_ptrs(xhci); | ||
321 | for (i = 0; i < MAX_HC_SLOTS; ++i) { | ||
322 | if (xhci->devs[i]) { | ||
323 | for (j = 0; j < 31; ++j) { | ||
324 | if (xhci->devs[i]->ep_rings[j]) { | ||
325 | xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j); | ||
326 | xhci_debug_segment(xhci, xhci->devs[i]->ep_rings[j]->deq_seg); | ||
327 | } | ||
328 | } | ||
329 | } | ||
330 | } | ||
331 | |||
332 | if (xhci->noops_submitted != NUM_TEST_NOOPS) | ||
333 | if (xhci_setup_one_noop(xhci)) | ||
334 | xhci_ring_cmd_db(xhci); | ||
335 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
336 | |||
337 | if (!xhci->zombie) | ||
338 | mod_timer(&xhci->event_ring_timer, jiffies + POLL_TIMEOUT * HZ); | ||
339 | else | ||
340 | xhci_dbg(xhci, "Quit polling the event ring.\n"); | ||
341 | } | ||
342 | #endif | ||
343 | |||
344 | /* | ||
345 | * Start the HC after it was halted. | ||
346 | * | ||
347 | * This function is called by the USB core when the HC driver is added. | ||
348 | * Its opposite is xhci_stop(). | ||
349 | * | ||
350 | * xhci_init() must be called once before this function can be called. | ||
351 | * Reset the HC, enable device slot contexts, program DCBAAP, and | ||
352 | * set command ring pointer and event ring pointer. | ||
353 | * | ||
354 | * Setup MSI-X vectors and enable interrupts. | ||
355 | */ | ||
356 | int xhci_run(struct usb_hcd *hcd) | ||
357 | { | ||
358 | u32 temp; | ||
359 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
360 | void (*doorbell)(struct xhci_hcd *) = NULL; | ||
361 | |||
362 | hcd->uses_new_polling = 1; | ||
363 | hcd->poll_rh = 0; | ||
364 | |||
365 | xhci_dbg(xhci, "xhci_run\n"); | ||
366 | #if 0 /* FIXME: MSI not setup yet */ | ||
367 | /* Do this at the very last minute */ | ||
368 | ret = xhci_setup_msix(xhci); | ||
369 | if (!ret) | ||
370 | return ret; | ||
371 | |||
372 | return -ENOSYS; | ||
373 | #endif | ||
374 | #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING | ||
375 | init_timer(&xhci->event_ring_timer); | ||
376 | xhci->event_ring_timer.data = (unsigned long) xhci; | ||
377 | xhci->event_ring_timer.function = xhci_event_ring_work; | ||
378 | /* Poll the event ring */ | ||
379 | xhci->event_ring_timer.expires = jiffies + POLL_TIMEOUT * HZ; | ||
380 | xhci->zombie = 0; | ||
381 | xhci_dbg(xhci, "Setting event ring polling timer\n"); | ||
382 | add_timer(&xhci->event_ring_timer); | ||
383 | #endif | ||
384 | |||
385 | xhci_dbg(xhci, "// Set the interrupt modulation register\n"); | ||
386 | temp = xhci_readl(xhci, &xhci->ir_set->irq_control); | ||
387 | temp &= ~ER_IRQ_INTERVAL_MASK; | ||
388 | temp |= (u32) 160; | ||
389 | xhci_writel(xhci, temp, &xhci->ir_set->irq_control); | ||
390 | |||
391 | /* Set the HCD state before we enable the irqs */ | ||
392 | hcd->state = HC_STATE_RUNNING; | ||
393 | temp = xhci_readl(xhci, &xhci->op_regs->command); | ||
394 | temp |= (CMD_EIE); | ||
395 | xhci_dbg(xhci, "// Enable interrupts, cmd = 0x%x.\n", | ||
396 | temp); | ||
397 | xhci_writel(xhci, temp, &xhci->op_regs->command); | ||
398 | |||
399 | temp = xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
400 | xhci_dbg(xhci, "// Enabling event ring interrupter %p by writing 0x%x to irq_pending\n", | ||
401 | xhci->ir_set, (unsigned int) ER_IRQ_ENABLE(temp)); | ||
402 | xhci_writel(xhci, ER_IRQ_ENABLE(temp), | ||
403 | &xhci->ir_set->irq_pending); | ||
404 | xhci_print_ir_set(xhci, xhci->ir_set, 0); | ||
405 | |||
406 | if (NUM_TEST_NOOPS > 0) | ||
407 | doorbell = xhci_setup_one_noop(xhci); | ||
408 | |||
409 | xhci_dbg(xhci, "Command ring memory map follows:\n"); | ||
410 | xhci_debug_ring(xhci, xhci->cmd_ring); | ||
411 | xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring); | ||
412 | xhci_dbg_cmd_ptrs(xhci); | ||
413 | |||
414 | xhci_dbg(xhci, "ERST memory map follows:\n"); | ||
415 | xhci_dbg_erst(xhci, &xhci->erst); | ||
416 | xhci_dbg(xhci, "Event ring:\n"); | ||
417 | xhci_debug_ring(xhci, xhci->event_ring); | ||
418 | xhci_dbg_ring_ptrs(xhci, xhci->event_ring); | ||
419 | temp = xhci_readl(xhci, &xhci->ir_set->erst_dequeue[0]); | ||
420 | temp &= ERST_PTR_MASK; | ||
421 | xhci_dbg(xhci, "ERST deq = 0x%x\n", temp); | ||
422 | temp = xhci_readl(xhci, &xhci->ir_set->erst_dequeue[1]); | ||
423 | xhci_dbg(xhci, "ERST deq upper = 0x%x\n", temp); | ||
424 | |||
425 | temp = xhci_readl(xhci, &xhci->op_regs->command); | ||
426 | temp |= (CMD_RUN); | ||
427 | xhci_dbg(xhci, "// Turn on HC, cmd = 0x%x.\n", | ||
428 | temp); | ||
429 | xhci_writel(xhci, temp, &xhci->op_regs->command); | ||
430 | /* Flush PCI posted writes */ | ||
431 | temp = xhci_readl(xhci, &xhci->op_regs->command); | ||
432 | xhci_dbg(xhci, "// @%p = 0x%x\n", &xhci->op_regs->command, temp); | ||
433 | if (doorbell) | ||
434 | (*doorbell)(xhci); | ||
435 | |||
436 | xhci_dbg(xhci, "Finished xhci_run\n"); | ||
437 | return 0; | ||
438 | } | ||
439 | |||
440 | /* | ||
441 | * Stop xHCI driver. | ||
442 | * | ||
443 | * This function is called by the USB core when the HC driver is removed. | ||
444 | * Its opposite is xhci_run(). | ||
445 | * | ||
446 | * Disable device contexts, disable IRQs, and quiesce the HC. | ||
447 | * Reset the HC, finish any completed transactions, and cleanup memory. | ||
448 | */ | ||
449 | void xhci_stop(struct usb_hcd *hcd) | ||
450 | { | ||
451 | u32 temp; | ||
452 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
453 | |||
454 | spin_lock_irq(&xhci->lock); | ||
455 | if (HC_IS_RUNNING(hcd->state)) | ||
456 | xhci_quiesce(xhci); | ||
457 | xhci_halt(xhci); | ||
458 | xhci_reset(xhci); | ||
459 | spin_unlock_irq(&xhci->lock); | ||
460 | |||
461 | #if 0 /* No MSI yet */ | ||
462 | xhci_cleanup_msix(xhci); | ||
463 | #endif | ||
464 | #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING | ||
465 | /* Tell the event ring poll function not to reschedule */ | ||
466 | xhci->zombie = 1; | ||
467 | del_timer_sync(&xhci->event_ring_timer); | ||
468 | #endif | ||
469 | |||
470 | xhci_dbg(xhci, "// Disabling event ring interrupts\n"); | ||
471 | temp = xhci_readl(xhci, &xhci->op_regs->status); | ||
472 | xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status); | ||
473 | temp = xhci_readl(xhci, &xhci->ir_set->irq_pending); | ||
474 | xhci_writel(xhci, ER_IRQ_DISABLE(temp), | ||
475 | &xhci->ir_set->irq_pending); | ||
476 | xhci_print_ir_set(xhci, xhci->ir_set, 0); | ||
477 | |||
478 | xhci_dbg(xhci, "cleaning up memory\n"); | ||
479 | xhci_mem_cleanup(xhci); | ||
480 | xhci_dbg(xhci, "xhci_stop completed - status = %x\n", | ||
481 | xhci_readl(xhci, &xhci->op_regs->status)); | ||
482 | } | ||
483 | |||
484 | /* | ||
485 | * Shutdown HC (not bus-specific) | ||
486 | * | ||
487 | * This is called when the machine is rebooting or halting. We assume that the | ||
488 | * machine will be powered off, and the HC's internal state will be reset. | ||
489 | * Don't bother to free memory. | ||
490 | */ | ||
491 | void xhci_shutdown(struct usb_hcd *hcd) | ||
492 | { | ||
493 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
494 | |||
495 | spin_lock_irq(&xhci->lock); | ||
496 | xhci_halt(xhci); | ||
497 | spin_unlock_irq(&xhci->lock); | ||
498 | |||
499 | #if 0 | ||
500 | xhci_cleanup_msix(xhci); | ||
501 | #endif | ||
502 | |||
503 | xhci_dbg(xhci, "xhci_shutdown completed - status = %x\n", | ||
504 | xhci_readl(xhci, &xhci->op_regs->status)); | ||
505 | } | ||
506 | |||
507 | /*-------------------------------------------------------------------------*/ | ||
508 | |||
509 | /** | ||
510 | * xhci_get_endpoint_index - Used for passing endpoint bitmasks between the core and | ||
511 | * HCDs. Find the index for an endpoint given its descriptor. Use the return | ||
512 | * value to right shift 1 for the bitmask. | ||
513 | * | ||
514 | * Index = (epnum * 2) + direction - 1, | ||
515 | * where direction = 0 for OUT, 1 for IN. | ||
516 | * For control endpoints, the IN index is used (OUT index is unused), so | ||
517 | * index = (epnum * 2) + direction - 1 = (epnum * 2) + 1 - 1 = (epnum * 2) | ||
518 | */ | ||
519 | unsigned int xhci_get_endpoint_index(struct usb_endpoint_descriptor *desc) | ||
520 | { | ||
521 | unsigned int index; | ||
522 | if (usb_endpoint_xfer_control(desc)) | ||
523 | index = (unsigned int) (usb_endpoint_num(desc)*2); | ||
524 | else | ||
525 | index = (unsigned int) (usb_endpoint_num(desc)*2) + | ||
526 | (usb_endpoint_dir_in(desc) ? 1 : 0) - 1; | ||
527 | return index; | ||
528 | } | ||
529 | |||
530 | /* Find the flag for this endpoint (for use in the control context). Use the | ||
531 | * endpoint index to create a bitmask. The slot context is bit 0, endpoint 0 is | ||
532 | * bit 1, etc. | ||
533 | */ | ||
534 | unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc) | ||
535 | { | ||
536 | return 1 << (xhci_get_endpoint_index(desc) + 1); | ||
537 | } | ||
538 | |||
539 | /* Compute the last valid endpoint context index. Basically, this is the | ||
540 | * endpoint index plus one. For slot contexts with more than valid endpoint, | ||
541 | * we find the most significant bit set in the added contexts flags. | ||
542 | * e.g. ep 1 IN (with epnum 0x81) => added_ctxs = 0b1000 | ||
543 | * fls(0b1000) = 4, but the endpoint context index is 3, so subtract one. | ||
544 | */ | ||
545 | static inline unsigned int xhci_last_valid_endpoint(u32 added_ctxs) | ||
546 | { | ||
547 | return fls(added_ctxs) - 1; | ||
548 | } | ||
549 | |||
550 | /* Returns 1 if the arguments are OK; | ||
551 | * returns 0 this is a root hub; returns -EINVAL for NULL pointers. | ||
552 | */ | ||
553 | int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev, | ||
554 | struct usb_host_endpoint *ep, int check_ep, const char *func) { | ||
555 | if (!hcd || (check_ep && !ep) || !udev) { | ||
556 | printk(KERN_DEBUG "xHCI %s called with invalid args\n", | ||
557 | func); | ||
558 | return -EINVAL; | ||
559 | } | ||
560 | if (!udev->parent) { | ||
561 | printk(KERN_DEBUG "xHCI %s called for root hub\n", | ||
562 | func); | ||
563 | return 0; | ||
564 | } | ||
565 | if (!udev->slot_id) { | ||
566 | printk(KERN_DEBUG "xHCI %s called with unaddressed device\n", | ||
567 | func); | ||
568 | return -EINVAL; | ||
569 | } | ||
570 | return 1; | ||
571 | } | ||
572 | |||
573 | /* | ||
574 | * non-error returns are a promise to giveback() the urb later | ||
575 | * we drop ownership so next owner (or urb unlink) can get it | ||
576 | */ | ||
577 | int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) | ||
578 | { | ||
579 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
580 | unsigned long flags; | ||
581 | int ret = 0; | ||
582 | unsigned int slot_id, ep_index; | ||
583 | |||
584 | if (!urb || xhci_check_args(hcd, urb->dev, urb->ep, true, __func__) <= 0) | ||
585 | return -EINVAL; | ||
586 | |||
587 | slot_id = urb->dev->slot_id; | ||
588 | ep_index = xhci_get_endpoint_index(&urb->ep->desc); | ||
589 | |||
590 | spin_lock_irqsave(&xhci->lock, flags); | ||
591 | if (!xhci->devs || !xhci->devs[slot_id]) { | ||
592 | if (!in_interrupt()) | ||
593 | dev_warn(&urb->dev->dev, "WARN: urb submitted for dev with no Slot ID\n"); | ||
594 | ret = -EINVAL; | ||
595 | goto exit; | ||
596 | } | ||
597 | if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { | ||
598 | if (!in_interrupt()) | ||
599 | xhci_dbg(xhci, "urb submitted during PCI suspend\n"); | ||
600 | ret = -ESHUTDOWN; | ||
601 | goto exit; | ||
602 | } | ||
603 | if (usb_endpoint_xfer_control(&urb->ep->desc)) | ||
604 | ret = xhci_queue_ctrl_tx(xhci, mem_flags, urb, | ||
605 | slot_id, ep_index); | ||
606 | else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) | ||
607 | ret = xhci_queue_bulk_tx(xhci, mem_flags, urb, | ||
608 | slot_id, ep_index); | ||
609 | else | ||
610 | ret = -EINVAL; | ||
611 | exit: | ||
612 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
613 | return ret; | ||
614 | } | ||
615 | |||
616 | /* | ||
617 | * Remove the URB's TD from the endpoint ring. This may cause the HC to stop | ||
618 | * USB transfers, potentially stopping in the middle of a TRB buffer. The HC | ||
619 | * should pick up where it left off in the TD, unless a Set Transfer Ring | ||
620 | * Dequeue Pointer is issued. | ||
621 | * | ||
622 | * The TRBs that make up the buffers for the canceled URB will be "removed" from | ||
623 | * the ring. Since the ring is a contiguous structure, they can't be physically | ||
624 | * removed. Instead, there are two options: | ||
625 | * | ||
626 | * 1) If the HC is in the middle of processing the URB to be canceled, we | ||
627 | * simply move the ring's dequeue pointer past those TRBs using the Set | ||
628 | * Transfer Ring Dequeue Pointer command. This will be the common case, | ||
629 | * when drivers timeout on the last submitted URB and attempt to cancel. | ||
630 | * | ||
631 | * 2) If the HC is in the middle of a different TD, we turn the TRBs into a | ||
632 | * series of 1-TRB transfer no-op TDs. (No-ops shouldn't be chained.) The | ||
633 | * HC will need to invalidate the any TRBs it has cached after the stop | ||
634 | * endpoint command, as noted in the xHCI 0.95 errata. | ||
635 | * | ||
636 | * 3) The TD may have completed by the time the Stop Endpoint Command | ||
637 | * completes, so software needs to handle that case too. | ||
638 | * | ||
639 | * This function should protect against the TD enqueueing code ringing the | ||
640 | * doorbell while this code is waiting for a Stop Endpoint command to complete. | ||
641 | * It also needs to account for multiple cancellations on happening at the same | ||
642 | * time for the same endpoint. | ||
643 | * | ||
644 | * Note that this function can be called in any context, or so says | ||
645 | * usb_hcd_unlink_urb() | ||
646 | */ | ||
647 | int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) | ||
648 | { | ||
649 | unsigned long flags; | ||
650 | int ret; | ||
651 | struct xhci_hcd *xhci; | ||
652 | struct xhci_td *td; | ||
653 | unsigned int ep_index; | ||
654 | struct xhci_ring *ep_ring; | ||
655 | |||
656 | xhci = hcd_to_xhci(hcd); | ||
657 | spin_lock_irqsave(&xhci->lock, flags); | ||
658 | /* Make sure the URB hasn't completed or been unlinked already */ | ||
659 | ret = usb_hcd_check_unlink_urb(hcd, urb, status); | ||
660 | if (ret || !urb->hcpriv) | ||
661 | goto done; | ||
662 | |||
663 | xhci_dbg(xhci, "Cancel URB %p\n", urb); | ||
664 | ep_index = xhci_get_endpoint_index(&urb->ep->desc); | ||
665 | ep_ring = xhci->devs[urb->dev->slot_id]->ep_rings[ep_index]; | ||
666 | td = (struct xhci_td *) urb->hcpriv; | ||
667 | |||
668 | ep_ring->cancels_pending++; | ||
669 | list_add_tail(&td->cancelled_td_list, &ep_ring->cancelled_td_list); | ||
670 | /* Queue a stop endpoint command, but only if this is | ||
671 | * the first cancellation to be handled. | ||
672 | */ | ||
673 | if (ep_ring->cancels_pending == 1) { | ||
674 | xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index); | ||
675 | xhci_ring_cmd_db(xhci); | ||
676 | } | ||
677 | done: | ||
678 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
679 | return ret; | ||
680 | } | ||
681 | |||
682 | /* Drop an endpoint from a new bandwidth configuration for this device. | ||
683 | * Only one call to this function is allowed per endpoint before | ||
684 | * check_bandwidth() or reset_bandwidth() must be called. | ||
685 | * A call to xhci_drop_endpoint() followed by a call to xhci_add_endpoint() will | ||
686 | * add the endpoint to the schedule with possibly new parameters denoted by a | ||
687 | * different endpoint descriptor in usb_host_endpoint. | ||
688 | * A call to xhci_add_endpoint() followed by a call to xhci_drop_endpoint() is | ||
689 | * not allowed. | ||
690 | * | ||
691 | * The USB core will not allow URBs to be queued to an endpoint that is being | ||
692 | * disabled, so there's no need for mutual exclusion to protect | ||
693 | * the xhci->devs[slot_id] structure. | ||
694 | */ | ||
695 | int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, | ||
696 | struct usb_host_endpoint *ep) | ||
697 | { | ||
698 | struct xhci_hcd *xhci; | ||
699 | struct xhci_device_control *in_ctx; | ||
700 | unsigned int last_ctx; | ||
701 | unsigned int ep_index; | ||
702 | struct xhci_ep_ctx *ep_ctx; | ||
703 | u32 drop_flag; | ||
704 | u32 new_add_flags, new_drop_flags, new_slot_info; | ||
705 | int ret; | ||
706 | |||
707 | ret = xhci_check_args(hcd, udev, ep, 1, __func__); | ||
708 | if (ret <= 0) | ||
709 | return ret; | ||
710 | xhci = hcd_to_xhci(hcd); | ||
711 | xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); | ||
712 | |||
713 | drop_flag = xhci_get_endpoint_flag(&ep->desc); | ||
714 | if (drop_flag == SLOT_FLAG || drop_flag == EP0_FLAG) { | ||
715 | xhci_dbg(xhci, "xHCI %s - can't drop slot or ep 0 %#x\n", | ||
716 | __func__, drop_flag); | ||
717 | return 0; | ||
718 | } | ||
719 | |||
720 | if (!xhci->devs || !xhci->devs[udev->slot_id]) { | ||
721 | xhci_warn(xhci, "xHCI %s called with unaddressed device\n", | ||
722 | __func__); | ||
723 | return -EINVAL; | ||
724 | } | ||
725 | |||
726 | in_ctx = xhci->devs[udev->slot_id]->in_ctx; | ||
727 | ep_index = xhci_get_endpoint_index(&ep->desc); | ||
728 | ep_ctx = &xhci->devs[udev->slot_id]->out_ctx->ep[ep_index]; | ||
729 | /* If the HC already knows the endpoint is disabled, | ||
730 | * or the HCD has noted it is disabled, ignore this request | ||
731 | */ | ||
732 | if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED || | ||
733 | in_ctx->drop_flags & xhci_get_endpoint_flag(&ep->desc)) { | ||
734 | xhci_warn(xhci, "xHCI %s called with disabled ep %p\n", | ||
735 | __func__, ep); | ||
736 | return 0; | ||
737 | } | ||
738 | |||
739 | in_ctx->drop_flags |= drop_flag; | ||
740 | new_drop_flags = in_ctx->drop_flags; | ||
741 | |||
742 | in_ctx->add_flags = ~drop_flag; | ||
743 | new_add_flags = in_ctx->add_flags; | ||
744 | |||
745 | last_ctx = xhci_last_valid_endpoint(in_ctx->add_flags); | ||
746 | /* Update the last valid endpoint context, if we deleted the last one */ | ||
747 | if ((in_ctx->slot.dev_info & LAST_CTX_MASK) > LAST_CTX(last_ctx)) { | ||
748 | in_ctx->slot.dev_info &= ~LAST_CTX_MASK; | ||
749 | in_ctx->slot.dev_info |= LAST_CTX(last_ctx); | ||
750 | } | ||
751 | new_slot_info = in_ctx->slot.dev_info; | ||
752 | |||
753 | xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep); | ||
754 | |||
755 | xhci_dbg(xhci, "drop ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x, new slot info = %#x\n", | ||
756 | (unsigned int) ep->desc.bEndpointAddress, | ||
757 | udev->slot_id, | ||
758 | (unsigned int) new_drop_flags, | ||
759 | (unsigned int) new_add_flags, | ||
760 | (unsigned int) new_slot_info); | ||
761 | return 0; | ||
762 | } | ||
763 | |||
764 | /* Add an endpoint to a new possible bandwidth configuration for this device. | ||
765 | * Only one call to this function is allowed per endpoint before | ||
766 | * check_bandwidth() or reset_bandwidth() must be called. | ||
767 | * A call to xhci_drop_endpoint() followed by a call to xhci_add_endpoint() will | ||
768 | * add the endpoint to the schedule with possibly new parameters denoted by a | ||
769 | * different endpoint descriptor in usb_host_endpoint. | ||
770 | * A call to xhci_add_endpoint() followed by a call to xhci_drop_endpoint() is | ||
771 | * not allowed. | ||
772 | * | ||
773 | * The USB core will not allow URBs to be queued to an endpoint until the | ||
774 | * configuration or alt setting is installed in the device, so there's no need | ||
775 | * for mutual exclusion to protect the xhci->devs[slot_id] structure. | ||
776 | */ | ||
777 | int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, | ||
778 | struct usb_host_endpoint *ep) | ||
779 | { | ||
780 | struct xhci_hcd *xhci; | ||
781 | struct xhci_device_control *in_ctx; | ||
782 | unsigned int ep_index; | ||
783 | struct xhci_ep_ctx *ep_ctx; | ||
784 | u32 added_ctxs; | ||
785 | unsigned int last_ctx; | ||
786 | u32 new_add_flags, new_drop_flags, new_slot_info; | ||
787 | int ret = 0; | ||
788 | |||
789 | ret = xhci_check_args(hcd, udev, ep, 1, __func__); | ||
790 | if (ret <= 0) | ||
791 | return ret; | ||
792 | xhci = hcd_to_xhci(hcd); | ||
793 | |||
794 | added_ctxs = xhci_get_endpoint_flag(&ep->desc); | ||
795 | last_ctx = xhci_last_valid_endpoint(added_ctxs); | ||
796 | if (added_ctxs == SLOT_FLAG || added_ctxs == EP0_FLAG) { | ||
797 | /* FIXME when we have to issue an evaluate endpoint command to | ||
798 | * deal with ep0 max packet size changing once we get the | ||
799 | * descriptors | ||
800 | */ | ||
801 | xhci_dbg(xhci, "xHCI %s - can't add slot or ep 0 %#x\n", | ||
802 | __func__, added_ctxs); | ||
803 | return 0; | ||
804 | } | ||
805 | |||
806 | if (!xhci->devs || !xhci->devs[udev->slot_id]) { | ||
807 | xhci_warn(xhci, "xHCI %s called with unaddressed device\n", | ||
808 | __func__); | ||
809 | return -EINVAL; | ||
810 | } | ||
811 | |||
812 | in_ctx = xhci->devs[udev->slot_id]->in_ctx; | ||
813 | ep_index = xhci_get_endpoint_index(&ep->desc); | ||
814 | ep_ctx = &xhci->devs[udev->slot_id]->out_ctx->ep[ep_index]; | ||
815 | /* If the HCD has already noted the endpoint is enabled, | ||
816 | * ignore this request. | ||
817 | */ | ||
818 | if (in_ctx->add_flags & xhci_get_endpoint_flag(&ep->desc)) { | ||
819 | xhci_warn(xhci, "xHCI %s called with enabled ep %p\n", | ||
820 | __func__, ep); | ||
821 | return 0; | ||
822 | } | ||
823 | |||
824 | /* | ||
825 | * Configuration and alternate setting changes must be done in | ||
826 | * process context, not interrupt context (or so documenation | ||
827 | * for usb_set_interface() and usb_set_configuration() claim). | ||
828 | */ | ||
829 | if (xhci_endpoint_init(xhci, xhci->devs[udev->slot_id], | ||
830 | udev, ep, GFP_KERNEL) < 0) { | ||
831 | dev_dbg(&udev->dev, "%s - could not initialize ep %#x\n", | ||
832 | __func__, ep->desc.bEndpointAddress); | ||
833 | return -ENOMEM; | ||
834 | } | ||
835 | |||
836 | in_ctx->add_flags |= added_ctxs; | ||
837 | new_add_flags = in_ctx->add_flags; | ||
838 | |||
839 | /* If xhci_endpoint_disable() was called for this endpoint, but the | ||
840 | * xHC hasn't been notified yet through the check_bandwidth() call, | ||
841 | * this re-adds a new state for the endpoint from the new endpoint | ||
842 | * descriptors. We must drop and re-add this endpoint, so we leave the | ||
843 | * drop flags alone. | ||
844 | */ | ||
845 | new_drop_flags = in_ctx->drop_flags; | ||
846 | |||
847 | /* Update the last valid endpoint context, if we just added one past */ | ||
848 | if ((in_ctx->slot.dev_info & LAST_CTX_MASK) < LAST_CTX(last_ctx)) { | ||
849 | in_ctx->slot.dev_info &= ~LAST_CTX_MASK; | ||
850 | in_ctx->slot.dev_info |= LAST_CTX(last_ctx); | ||
851 | } | ||
852 | new_slot_info = in_ctx->slot.dev_info; | ||
853 | |||
854 | xhci_dbg(xhci, "add ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x, new slot info = %#x\n", | ||
855 | (unsigned int) ep->desc.bEndpointAddress, | ||
856 | udev->slot_id, | ||
857 | (unsigned int) new_drop_flags, | ||
858 | (unsigned int) new_add_flags, | ||
859 | (unsigned int) new_slot_info); | ||
860 | return 0; | ||
861 | } | ||
862 | |||
863 | static void xhci_zero_in_ctx(struct xhci_virt_device *virt_dev) | ||
864 | { | ||
865 | struct xhci_ep_ctx *ep_ctx; | ||
866 | int i; | ||
867 | |||
868 | /* When a device's add flag and drop flag are zero, any subsequent | ||
869 | * configure endpoint command will leave that endpoint's state | ||
870 | * untouched. Make sure we don't leave any old state in the input | ||
871 | * endpoint contexts. | ||
872 | */ | ||
873 | virt_dev->in_ctx->drop_flags = 0; | ||
874 | virt_dev->in_ctx->add_flags = 0; | ||
875 | virt_dev->in_ctx->slot.dev_info &= ~LAST_CTX_MASK; | ||
876 | /* Endpoint 0 is always valid */ | ||
877 | virt_dev->in_ctx->slot.dev_info |= LAST_CTX(1); | ||
878 | for (i = 1; i < 31; ++i) { | ||
879 | ep_ctx = &virt_dev->in_ctx->ep[i]; | ||
880 | ep_ctx->ep_info = 0; | ||
881 | ep_ctx->ep_info2 = 0; | ||
882 | ep_ctx->deq[0] = 0; | ||
883 | ep_ctx->deq[1] = 0; | ||
884 | ep_ctx->tx_info = 0; | ||
885 | } | ||
886 | } | ||
887 | |||
888 | /* Called after one or more calls to xhci_add_endpoint() or | ||
889 | * xhci_drop_endpoint(). If this call fails, the USB core is expected | ||
890 | * to call xhci_reset_bandwidth(). | ||
891 | * | ||
892 | * Since we are in the middle of changing either configuration or | ||
893 | * installing a new alt setting, the USB core won't allow URBs to be | ||
894 | * enqueued for any endpoint on the old config or interface. Nothing | ||
895 | * else should be touching the xhci->devs[slot_id] structure, so we | ||
896 | * don't need to take the xhci->lock for manipulating that. | ||
897 | */ | ||
898 | int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) | ||
899 | { | ||
900 | int i; | ||
901 | int ret = 0; | ||
902 | int timeleft; | ||
903 | unsigned long flags; | ||
904 | struct xhci_hcd *xhci; | ||
905 | struct xhci_virt_device *virt_dev; | ||
906 | |||
907 | ret = xhci_check_args(hcd, udev, NULL, 0, __func__); | ||
908 | if (ret <= 0) | ||
909 | return ret; | ||
910 | xhci = hcd_to_xhci(hcd); | ||
911 | |||
912 | if (!udev->slot_id || !xhci->devs || !xhci->devs[udev->slot_id]) { | ||
913 | xhci_warn(xhci, "xHCI %s called with unaddressed device\n", | ||
914 | __func__); | ||
915 | return -EINVAL; | ||
916 | } | ||
917 | xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); | ||
918 | virt_dev = xhci->devs[udev->slot_id]; | ||
919 | |||
920 | /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */ | ||
921 | virt_dev->in_ctx->add_flags |= SLOT_FLAG; | ||
922 | virt_dev->in_ctx->add_flags &= ~EP0_FLAG; | ||
923 | virt_dev->in_ctx->drop_flags &= ~SLOT_FLAG; | ||
924 | virt_dev->in_ctx->drop_flags &= ~EP0_FLAG; | ||
925 | xhci_dbg(xhci, "New Input Control Context:\n"); | ||
926 | xhci_dbg_ctx(xhci, virt_dev->in_ctx, virt_dev->in_ctx_dma, | ||
927 | LAST_CTX_TO_EP_NUM(virt_dev->in_ctx->slot.dev_info)); | ||
928 | |||
929 | spin_lock_irqsave(&xhci->lock, flags); | ||
930 | ret = xhci_queue_configure_endpoint(xhci, virt_dev->in_ctx_dma, | ||
931 | udev->slot_id); | ||
932 | if (ret < 0) { | ||
933 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
934 | xhci_dbg(xhci, "FIXME allocate a new ring segment\n"); | ||
935 | return -ENOMEM; | ||
936 | } | ||
937 | xhci_ring_cmd_db(xhci); | ||
938 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
939 | |||
940 | /* Wait for the configure endpoint command to complete */ | ||
941 | timeleft = wait_for_completion_interruptible_timeout( | ||
942 | &virt_dev->cmd_completion, | ||
943 | USB_CTRL_SET_TIMEOUT); | ||
944 | if (timeleft <= 0) { | ||
945 | xhci_warn(xhci, "%s while waiting for configure endpoint command\n", | ||
946 | timeleft == 0 ? "Timeout" : "Signal"); | ||
947 | /* FIXME cancel the configure endpoint command */ | ||
948 | return -ETIME; | ||
949 | } | ||
950 | |||
951 | switch (virt_dev->cmd_status) { | ||
952 | case COMP_ENOMEM: | ||
953 | dev_warn(&udev->dev, "Not enough host controller resources " | ||
954 | "for new device state.\n"); | ||
955 | ret = -ENOMEM; | ||
956 | /* FIXME: can we allocate more resources for the HC? */ | ||
957 | break; | ||
958 | case COMP_BW_ERR: | ||
959 | dev_warn(&udev->dev, "Not enough bandwidth " | ||
960 | "for new device state.\n"); | ||
961 | ret = -ENOSPC; | ||
962 | /* FIXME: can we go back to the old state? */ | ||
963 | break; | ||
964 | case COMP_TRB_ERR: | ||
965 | /* the HCD set up something wrong */ | ||
966 | dev_warn(&udev->dev, "ERROR: Endpoint drop flag = 0, add flag = 1, " | ||
967 | "and endpoint is not disabled.\n"); | ||
968 | ret = -EINVAL; | ||
969 | break; | ||
970 | case COMP_SUCCESS: | ||
971 | dev_dbg(&udev->dev, "Successful Endpoint Configure command\n"); | ||
972 | break; | ||
973 | default: | ||
974 | xhci_err(xhci, "ERROR: unexpected command completion " | ||
975 | "code 0x%x.\n", virt_dev->cmd_status); | ||
976 | ret = -EINVAL; | ||
977 | break; | ||
978 | } | ||
979 | if (ret) { | ||
980 | /* Callee should call reset_bandwidth() */ | ||
981 | return ret; | ||
982 | } | ||
983 | |||
984 | xhci_dbg(xhci, "Output context after successful config ep cmd:\n"); | ||
985 | xhci_dbg_ctx(xhci, virt_dev->out_ctx, virt_dev->out_ctx_dma, | ||
986 | LAST_CTX_TO_EP_NUM(virt_dev->in_ctx->slot.dev_info)); | ||
987 | |||
988 | xhci_zero_in_ctx(virt_dev); | ||
989 | /* Free any old rings */ | ||
990 | for (i = 1; i < 31; ++i) { | ||
991 | if (virt_dev->new_ep_rings[i]) { | ||
992 | xhci_ring_free(xhci, virt_dev->ep_rings[i]); | ||
993 | virt_dev->ep_rings[i] = virt_dev->new_ep_rings[i]; | ||
994 | virt_dev->new_ep_rings[i] = NULL; | ||
995 | } | ||
996 | } | ||
997 | |||
998 | return ret; | ||
999 | } | ||
1000 | |||
1001 | void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) | ||
1002 | { | ||
1003 | struct xhci_hcd *xhci; | ||
1004 | struct xhci_virt_device *virt_dev; | ||
1005 | int i, ret; | ||
1006 | |||
1007 | ret = xhci_check_args(hcd, udev, NULL, 0, __func__); | ||
1008 | if (ret <= 0) | ||
1009 | return; | ||
1010 | xhci = hcd_to_xhci(hcd); | ||
1011 | |||
1012 | if (!xhci->devs || !xhci->devs[udev->slot_id]) { | ||
1013 | xhci_warn(xhci, "xHCI %s called with unaddressed device\n", | ||
1014 | __func__); | ||
1015 | return; | ||
1016 | } | ||
1017 | xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); | ||
1018 | virt_dev = xhci->devs[udev->slot_id]; | ||
1019 | /* Free any rings allocated for added endpoints */ | ||
1020 | for (i = 0; i < 31; ++i) { | ||
1021 | if (virt_dev->new_ep_rings[i]) { | ||
1022 | xhci_ring_free(xhci, virt_dev->new_ep_rings[i]); | ||
1023 | virt_dev->new_ep_rings[i] = NULL; | ||
1024 | } | ||
1025 | } | ||
1026 | xhci_zero_in_ctx(virt_dev); | ||
1027 | } | ||
1028 | |||
1029 | /* | ||
1030 | * At this point, the struct usb_device is about to go away, the device has | ||
1031 | * disconnected, and all traffic has been stopped and the endpoints have been | ||
1032 | * disabled. Free any HC data structures associated with that device. | ||
1033 | */ | ||
1034 | void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev) | ||
1035 | { | ||
1036 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
1037 | unsigned long flags; | ||
1038 | |||
1039 | if (udev->slot_id == 0) | ||
1040 | return; | ||
1041 | |||
1042 | spin_lock_irqsave(&xhci->lock, flags); | ||
1043 | if (xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id)) { | ||
1044 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1045 | xhci_dbg(xhci, "FIXME: allocate a command ring segment\n"); | ||
1046 | return; | ||
1047 | } | ||
1048 | xhci_ring_cmd_db(xhci); | ||
1049 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1050 | /* | ||
1051 | * Event command completion handler will free any data structures | ||
1052 | * associated with the slot. XXX Can free sleep? | ||
1053 | */ | ||
1054 | } | ||
1055 | |||
1056 | /* | ||
1057 | * Returns 0 if the xHC ran out of device slots, the Enable Slot command | ||
1058 | * timed out, or allocating memory failed. Returns 1 on success. | ||
1059 | */ | ||
1060 | int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev) | ||
1061 | { | ||
1062 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
1063 | unsigned long flags; | ||
1064 | int timeleft; | ||
1065 | int ret; | ||
1066 | |||
1067 | spin_lock_irqsave(&xhci->lock, flags); | ||
1068 | ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0); | ||
1069 | if (ret) { | ||
1070 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1071 | xhci_dbg(xhci, "FIXME: allocate a command ring segment\n"); | ||
1072 | return 0; | ||
1073 | } | ||
1074 | xhci_ring_cmd_db(xhci); | ||
1075 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1076 | |||
1077 | /* XXX: how much time for xHC slot assignment? */ | ||
1078 | timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev, | ||
1079 | USB_CTRL_SET_TIMEOUT); | ||
1080 | if (timeleft <= 0) { | ||
1081 | xhci_warn(xhci, "%s while waiting for a slot\n", | ||
1082 | timeleft == 0 ? "Timeout" : "Signal"); | ||
1083 | /* FIXME cancel the enable slot request */ | ||
1084 | return 0; | ||
1085 | } | ||
1086 | |||
1087 | if (!xhci->slot_id) { | ||
1088 | xhci_err(xhci, "Error while assigning device slot ID\n"); | ||
1089 | return 0; | ||
1090 | } | ||
1091 | /* xhci_alloc_virt_device() does not touch rings; no need to lock */ | ||
1092 | if (!xhci_alloc_virt_device(xhci, xhci->slot_id, udev, GFP_KERNEL)) { | ||
1093 | /* Disable slot, if we can do it without mem alloc */ | ||
1094 | xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n"); | ||
1095 | spin_lock_irqsave(&xhci->lock, flags); | ||
1096 | if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id)) | ||
1097 | xhci_ring_cmd_db(xhci); | ||
1098 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1099 | return 0; | ||
1100 | } | ||
1101 | udev->slot_id = xhci->slot_id; | ||
1102 | /* Is this a LS or FS device under a HS hub? */ | ||
1103 | /* Hub or peripherial? */ | ||
1104 | return 1; | ||
1105 | } | ||
1106 | |||
1107 | /* | ||
1108 | * Issue an Address Device command (which will issue a SetAddress request to | ||
1109 | * the device). | ||
1110 | * We should be protected by the usb_address0_mutex in khubd's hub_port_init, so | ||
1111 | * we should only issue and wait on one address command at the same time. | ||
1112 | * | ||
1113 | * We add one to the device address issued by the hardware because the USB core | ||
1114 | * uses address 1 for the root hubs (even though they're not really devices). | ||
1115 | */ | ||
1116 | int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev) | ||
1117 | { | ||
1118 | unsigned long flags; | ||
1119 | int timeleft; | ||
1120 | struct xhci_virt_device *virt_dev; | ||
1121 | int ret = 0; | ||
1122 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
1123 | u32 temp; | ||
1124 | |||
1125 | if (!udev->slot_id) { | ||
1126 | xhci_dbg(xhci, "Bad Slot ID %d\n", udev->slot_id); | ||
1127 | return -EINVAL; | ||
1128 | } | ||
1129 | |||
1130 | virt_dev = xhci->devs[udev->slot_id]; | ||
1131 | |||
1132 | /* If this is a Set Address to an unconfigured device, setup ep 0 */ | ||
1133 | if (!udev->config) | ||
1134 | xhci_setup_addressable_virt_dev(xhci, udev); | ||
1135 | /* Otherwise, assume the core has the device configured how it wants */ | ||
1136 | |||
1137 | spin_lock_irqsave(&xhci->lock, flags); | ||
1138 | ret = xhci_queue_address_device(xhci, virt_dev->in_ctx_dma, | ||
1139 | udev->slot_id); | ||
1140 | if (ret) { | ||
1141 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1142 | xhci_dbg(xhci, "FIXME: allocate a command ring segment\n"); | ||
1143 | return ret; | ||
1144 | } | ||
1145 | xhci_ring_cmd_db(xhci); | ||
1146 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
1147 | |||
1148 | /* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */ | ||
1149 | timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev, | ||
1150 | USB_CTRL_SET_TIMEOUT); | ||
1151 | /* FIXME: From section 4.3.4: "Software shall be responsible for timing | ||
1152 | * the SetAddress() "recovery interval" required by USB and aborting the | ||
1153 | * command on a timeout. | ||
1154 | */ | ||
1155 | if (timeleft <= 0) { | ||
1156 | xhci_warn(xhci, "%s while waiting for a slot\n", | ||
1157 | timeleft == 0 ? "Timeout" : "Signal"); | ||
1158 | /* FIXME cancel the address device command */ | ||
1159 | return -ETIME; | ||
1160 | } | ||
1161 | |||
1162 | switch (virt_dev->cmd_status) { | ||
1163 | case COMP_CTX_STATE: | ||
1164 | case COMP_EBADSLT: | ||
1165 | xhci_err(xhci, "Setup ERROR: address device command for slot %d.\n", | ||
1166 | udev->slot_id); | ||
1167 | ret = -EINVAL; | ||
1168 | break; | ||
1169 | case COMP_TX_ERR: | ||
1170 | dev_warn(&udev->dev, "Device not responding to set address.\n"); | ||
1171 | ret = -EPROTO; | ||
1172 | break; | ||
1173 | case COMP_SUCCESS: | ||
1174 | xhci_dbg(xhci, "Successful Address Device command\n"); | ||
1175 | break; | ||
1176 | default: | ||
1177 | xhci_err(xhci, "ERROR: unexpected command completion " | ||
1178 | "code 0x%x.\n", virt_dev->cmd_status); | ||
1179 | ret = -EINVAL; | ||
1180 | break; | ||
1181 | } | ||
1182 | if (ret) { | ||
1183 | return ret; | ||
1184 | } | ||
1185 | temp = xhci_readl(xhci, &xhci->op_regs->dcbaa_ptr[0]); | ||
1186 | xhci_dbg(xhci, "Op regs DCBAA ptr[0] = %#08x\n", temp); | ||
1187 | temp = xhci_readl(xhci, &xhci->op_regs->dcbaa_ptr[1]); | ||
1188 | xhci_dbg(xhci, "Op regs DCBAA ptr[1] = %#08x\n", temp); | ||
1189 | xhci_dbg(xhci, "Slot ID %d dcbaa entry[0] @%p = %#08x\n", | ||
1190 | udev->slot_id, | ||
1191 | &xhci->dcbaa->dev_context_ptrs[2*udev->slot_id], | ||
1192 | xhci->dcbaa->dev_context_ptrs[2*udev->slot_id]); | ||
1193 | xhci_dbg(xhci, "Slot ID %d dcbaa entry[1] @%p = %#08x\n", | ||
1194 | udev->slot_id, | ||
1195 | &xhci->dcbaa->dev_context_ptrs[2*udev->slot_id+1], | ||
1196 | xhci->dcbaa->dev_context_ptrs[2*udev->slot_id+1]); | ||
1197 | xhci_dbg(xhci, "Output Context DMA address = %#08llx\n", | ||
1198 | (unsigned long long)virt_dev->out_ctx_dma); | ||
1199 | xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id); | ||
1200 | xhci_dbg_ctx(xhci, virt_dev->in_ctx, virt_dev->in_ctx_dma, 2); | ||
1201 | xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id); | ||
1202 | xhci_dbg_ctx(xhci, virt_dev->out_ctx, virt_dev->out_ctx_dma, 2); | ||
1203 | /* | ||
1204 | * USB core uses address 1 for the roothubs, so we add one to the | ||
1205 | * address given back to us by the HC. | ||
1206 | */ | ||
1207 | udev->devnum = (virt_dev->out_ctx->slot.dev_state & DEV_ADDR_MASK) + 1; | ||
1208 | /* Zero the input context control for later use */ | ||
1209 | virt_dev->in_ctx->add_flags = 0; | ||
1210 | virt_dev->in_ctx->drop_flags = 0; | ||
1211 | /* Mirror flags in the output context for future ep enable/disable */ | ||
1212 | virt_dev->out_ctx->add_flags = SLOT_FLAG | EP0_FLAG; | ||
1213 | virt_dev->out_ctx->drop_flags = 0; | ||
1214 | |||
1215 | xhci_dbg(xhci, "Device address = %d\n", udev->devnum); | ||
1216 | /* XXX Meh, not sure if anyone else but choose_address uses this. */ | ||
1217 | set_bit(udev->devnum, udev->bus->devmap.devicemap); | ||
1218 | |||
1219 | return 0; | ||
1220 | } | ||
1221 | |||
1222 | int xhci_get_frame(struct usb_hcd *hcd) | ||
1223 | { | ||
1224 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
1225 | /* EHCI mods by the periodic size. Why? */ | ||
1226 | return xhci_readl(xhci, &xhci->run_regs->microframe_index) >> 3; | ||
1227 | } | ||
1228 | |||
1229 | MODULE_DESCRIPTION(DRIVER_DESC); | ||
1230 | MODULE_AUTHOR(DRIVER_AUTHOR); | ||
1231 | MODULE_LICENSE("GPL"); | ||
1232 | |||
1233 | static int __init xhci_hcd_init(void) | ||
1234 | { | ||
1235 | #ifdef CONFIG_PCI | ||
1236 | int retval = 0; | ||
1237 | |||
1238 | retval = xhci_register_pci(); | ||
1239 | |||
1240 | if (retval < 0) { | ||
1241 | printk(KERN_DEBUG "Problem registering PCI driver."); | ||
1242 | return retval; | ||
1243 | } | ||
1244 | #endif | ||
1245 | /* | ||
1246 | * Check the compiler generated sizes of structures that must be laid | ||
1247 | * out in specific ways for hardware access. | ||
1248 | */ | ||
1249 | BUILD_BUG_ON(sizeof(struct xhci_doorbell_array) != 256*32/8); | ||
1250 | BUILD_BUG_ON(sizeof(struct xhci_slot_ctx) != 8*32/8); | ||
1251 | BUILD_BUG_ON(sizeof(struct xhci_ep_ctx) != 8*32/8); | ||
1252 | /* xhci_device_control has eight fields, and also | ||
1253 | * embeds one xhci_slot_ctx and 31 xhci_ep_ctx | ||
1254 | */ | ||
1255 | BUILD_BUG_ON(sizeof(struct xhci_device_control) != (8+8+8*31)*32/8); | ||
1256 | BUILD_BUG_ON(sizeof(struct xhci_stream_ctx) != 4*32/8); | ||
1257 | BUILD_BUG_ON(sizeof(union xhci_trb) != 4*32/8); | ||
1258 | BUILD_BUG_ON(sizeof(struct xhci_erst_entry) != 4*32/8); | ||
1259 | BUILD_BUG_ON(sizeof(struct xhci_cap_regs) != 7*32/8); | ||
1260 | BUILD_BUG_ON(sizeof(struct xhci_intr_reg) != 8*32/8); | ||
1261 | /* xhci_run_regs has eight fields and embeds 128 xhci_intr_regs */ | ||
1262 | BUILD_BUG_ON(sizeof(struct xhci_run_regs) != (8+8*128)*32/8); | ||
1263 | BUILD_BUG_ON(sizeof(struct xhci_doorbell_array) != 256*32/8); | ||
1264 | return 0; | ||
1265 | } | ||
1266 | module_init(xhci_hcd_init); | ||
1267 | |||
1268 | static void __exit xhci_hcd_cleanup(void) | ||
1269 | { | ||
1270 | #ifdef CONFIG_PCI | ||
1271 | xhci_unregister_pci(); | ||
1272 | #endif | ||
1273 | } | ||
1274 | module_exit(xhci_hcd_cleanup); | ||
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c new file mode 100644 index 000000000000..eac5b53aa9e7 --- /dev/null +++ b/drivers/usb/host/xhci-hub.c | |||
@@ -0,0 +1,308 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #include <asm/unaligned.h> | ||
24 | |||
25 | #include "xhci.h" | ||
26 | |||
27 | static void xhci_hub_descriptor(struct xhci_hcd *xhci, | ||
28 | struct usb_hub_descriptor *desc) | ||
29 | { | ||
30 | int ports; | ||
31 | u16 temp; | ||
32 | |||
33 | ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
34 | |||
35 | /* USB 3.0 hubs have a different descriptor, but we fake this for now */ | ||
36 | desc->bDescriptorType = 0x29; | ||
37 | desc->bPwrOn2PwrGood = 10; /* xhci section 5.4.9 says 20ms max */ | ||
38 | desc->bHubContrCurrent = 0; | ||
39 | |||
40 | desc->bNbrPorts = ports; | ||
41 | temp = 1 + (ports / 8); | ||
42 | desc->bDescLength = 7 + 2 * temp; | ||
43 | |||
44 | /* Why does core/hcd.h define bitmap? It's just confusing. */ | ||
45 | memset(&desc->DeviceRemovable[0], 0, temp); | ||
46 | memset(&desc->DeviceRemovable[temp], 0xff, temp); | ||
47 | |||
48 | /* Ugh, these should be #defines, FIXME */ | ||
49 | /* Using table 11-13 in USB 2.0 spec. */ | ||
50 | temp = 0; | ||
51 | /* Bits 1:0 - support port power switching, or power always on */ | ||
52 | if (HCC_PPC(xhci->hcc_params)) | ||
53 | temp |= 0x0001; | ||
54 | else | ||
55 | temp |= 0x0002; | ||
56 | /* Bit 2 - root hubs are not part of a compound device */ | ||
57 | /* Bits 4:3 - individual port over current protection */ | ||
58 | temp |= 0x0008; | ||
59 | /* Bits 6:5 - no TTs in root ports */ | ||
60 | /* Bit 7 - no port indicators */ | ||
61 | desc->wHubCharacteristics = (__force __u16) cpu_to_le16(temp); | ||
62 | } | ||
63 | |||
64 | static unsigned int xhci_port_speed(unsigned int port_status) | ||
65 | { | ||
66 | if (DEV_LOWSPEED(port_status)) | ||
67 | return 1 << USB_PORT_FEAT_LOWSPEED; | ||
68 | if (DEV_HIGHSPEED(port_status)) | ||
69 | return 1 << USB_PORT_FEAT_HIGHSPEED; | ||
70 | if (DEV_SUPERSPEED(port_status)) | ||
71 | return 1 << USB_PORT_FEAT_SUPERSPEED; | ||
72 | /* | ||
73 | * FIXME: Yes, we should check for full speed, but the core uses that as | ||
74 | * a default in portspeed() in usb/core/hub.c (which is the only place | ||
75 | * USB_PORT_FEAT_*SPEED is used). | ||
76 | */ | ||
77 | return 0; | ||
78 | } | ||
79 | |||
80 | /* | ||
81 | * These bits are Read Only (RO) and should be saved and written to the | ||
82 | * registers: 0, 3, 10:13, 30 | ||
83 | * connect status, over-current status, port speed, and device removable. | ||
84 | * connect status and port speed are also sticky - meaning they're in | ||
85 | * the AUX well and they aren't changed by a hot, warm, or cold reset. | ||
86 | */ | ||
87 | #define XHCI_PORT_RO ((1<<0) | (1<<3) | (0xf<<10) | (1<<30)) | ||
88 | /* | ||
89 | * These bits are RW; writing a 0 clears the bit, writing a 1 sets the bit: | ||
90 | * bits 5:8, 9, 14:15, 25:27 | ||
91 | * link state, port power, port indicator state, "wake on" enable state | ||
92 | */ | ||
93 | #define XHCI_PORT_RWS ((0xf<<5) | (1<<9) | (0x3<<14) | (0x7<<25)) | ||
94 | /* | ||
95 | * These bits are RW; writing a 1 sets the bit, writing a 0 has no effect: | ||
96 | * bit 4 (port reset) | ||
97 | */ | ||
98 | #define XHCI_PORT_RW1S ((1<<4)) | ||
99 | /* | ||
100 | * These bits are RW; writing a 1 clears the bit, writing a 0 has no effect: | ||
101 | * bits 1, 17, 18, 19, 20, 21, 22, 23 | ||
102 | * port enable/disable, and | ||
103 | * change bits: connect, PED, warm port reset changed (reserved zero for USB 2.0 ports), | ||
104 | * over-current, reset, link state, and L1 change | ||
105 | */ | ||
106 | #define XHCI_PORT_RW1CS ((1<<1) | (0x7f<<17)) | ||
107 | /* | ||
108 | * Bit 16 is RW, and writing a '1' to it causes the link state control to be | ||
109 | * latched in | ||
110 | */ | ||
111 | #define XHCI_PORT_RW ((1<<16)) | ||
112 | /* | ||
113 | * These bits are Reserved Zero (RsvdZ) and zero should be written to them: | ||
114 | * bits 2, 24, 28:31 | ||
115 | */ | ||
116 | #define XHCI_PORT_RZ ((1<<2) | (1<<24) | (0xf<<28)) | ||
117 | |||
118 | /* | ||
119 | * Given a port state, this function returns a value that would result in the | ||
120 | * port being in the same state, if the value was written to the port status | ||
121 | * control register. | ||
122 | * Save Read Only (RO) bits and save read/write bits where | ||
123 | * writing a 0 clears the bit and writing a 1 sets the bit (RWS). | ||
124 | * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect. | ||
125 | */ | ||
126 | static u32 xhci_port_state_to_neutral(u32 state) | ||
127 | { | ||
128 | /* Save read-only status and port state */ | ||
129 | return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS); | ||
130 | } | ||
131 | |||
132 | int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, | ||
133 | u16 wIndex, char *buf, u16 wLength) | ||
134 | { | ||
135 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
136 | int ports; | ||
137 | unsigned long flags; | ||
138 | u32 temp, status; | ||
139 | int retval = 0; | ||
140 | u32 __iomem *addr; | ||
141 | char *port_change_bit; | ||
142 | |||
143 | ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
144 | |||
145 | spin_lock_irqsave(&xhci->lock, flags); | ||
146 | switch (typeReq) { | ||
147 | case GetHubStatus: | ||
148 | /* No power source, over-current reported per port */ | ||
149 | memset(buf, 0, 4); | ||
150 | break; | ||
151 | case GetHubDescriptor: | ||
152 | xhci_hub_descriptor(xhci, (struct usb_hub_descriptor *) buf); | ||
153 | break; | ||
154 | case GetPortStatus: | ||
155 | if (!wIndex || wIndex > ports) | ||
156 | goto error; | ||
157 | wIndex--; | ||
158 | status = 0; | ||
159 | addr = &xhci->op_regs->port_status_base + NUM_PORT_REGS*(wIndex & 0xff); | ||
160 | temp = xhci_readl(xhci, addr); | ||
161 | xhci_dbg(xhci, "get port status, actual port %d status = 0x%x\n", wIndex, temp); | ||
162 | |||
163 | /* wPortChange bits */ | ||
164 | if (temp & PORT_CSC) | ||
165 | status |= 1 << USB_PORT_FEAT_C_CONNECTION; | ||
166 | if (temp & PORT_PEC) | ||
167 | status |= 1 << USB_PORT_FEAT_C_ENABLE; | ||
168 | if ((temp & PORT_OCC)) | ||
169 | status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT; | ||
170 | /* | ||
171 | * FIXME ignoring suspend, reset, and USB 2.1/3.0 specific | ||
172 | * changes | ||
173 | */ | ||
174 | if (temp & PORT_CONNECT) { | ||
175 | status |= 1 << USB_PORT_FEAT_CONNECTION; | ||
176 | status |= xhci_port_speed(temp); | ||
177 | } | ||
178 | if (temp & PORT_PE) | ||
179 | status |= 1 << USB_PORT_FEAT_ENABLE; | ||
180 | if (temp & PORT_OC) | ||
181 | status |= 1 << USB_PORT_FEAT_OVER_CURRENT; | ||
182 | if (temp & PORT_RESET) | ||
183 | status |= 1 << USB_PORT_FEAT_RESET; | ||
184 | if (temp & PORT_POWER) | ||
185 | status |= 1 << USB_PORT_FEAT_POWER; | ||
186 | xhci_dbg(xhci, "Get port status returned 0x%x\n", status); | ||
187 | put_unaligned(cpu_to_le32(status), (__le32 *) buf); | ||
188 | break; | ||
189 | case SetPortFeature: | ||
190 | wIndex &= 0xff; | ||
191 | if (!wIndex || wIndex > ports) | ||
192 | goto error; | ||
193 | wIndex--; | ||
194 | addr = &xhci->op_regs->port_status_base + NUM_PORT_REGS*(wIndex & 0xff); | ||
195 | temp = xhci_readl(xhci, addr); | ||
196 | temp = xhci_port_state_to_neutral(temp); | ||
197 | switch (wValue) { | ||
198 | case USB_PORT_FEAT_POWER: | ||
199 | /* | ||
200 | * Turn on ports, even if there isn't per-port switching. | ||
201 | * HC will report connect events even before this is set. | ||
202 | * However, khubd will ignore the roothub events until | ||
203 | * the roothub is registered. | ||
204 | */ | ||
205 | xhci_writel(xhci, temp | PORT_POWER, addr); | ||
206 | |||
207 | temp = xhci_readl(xhci, addr); | ||
208 | xhci_dbg(xhci, "set port power, actual port %d status = 0x%x\n", wIndex, temp); | ||
209 | break; | ||
210 | case USB_PORT_FEAT_RESET: | ||
211 | temp = (temp | PORT_RESET); | ||
212 | xhci_writel(xhci, temp, addr); | ||
213 | |||
214 | temp = xhci_readl(xhci, addr); | ||
215 | xhci_dbg(xhci, "set port reset, actual port %d status = 0x%x\n", wIndex, temp); | ||
216 | break; | ||
217 | default: | ||
218 | goto error; | ||
219 | } | ||
220 | temp = xhci_readl(xhci, addr); /* unblock any posted writes */ | ||
221 | break; | ||
222 | case ClearPortFeature: | ||
223 | if (!wIndex || wIndex > ports) | ||
224 | goto error; | ||
225 | wIndex--; | ||
226 | addr = &xhci->op_regs->port_status_base + | ||
227 | NUM_PORT_REGS*(wIndex & 0xff); | ||
228 | temp = xhci_readl(xhci, addr); | ||
229 | temp = xhci_port_state_to_neutral(temp); | ||
230 | switch (wValue) { | ||
231 | case USB_PORT_FEAT_C_RESET: | ||
232 | status = PORT_RC; | ||
233 | port_change_bit = "reset"; | ||
234 | break; | ||
235 | case USB_PORT_FEAT_C_CONNECTION: | ||
236 | status = PORT_CSC; | ||
237 | port_change_bit = "connect"; | ||
238 | break; | ||
239 | case USB_PORT_FEAT_C_OVER_CURRENT: | ||
240 | status = PORT_OCC; | ||
241 | port_change_bit = "over-current"; | ||
242 | break; | ||
243 | default: | ||
244 | goto error; | ||
245 | } | ||
246 | /* Change bits are all write 1 to clear */ | ||
247 | xhci_writel(xhci, temp | status, addr); | ||
248 | temp = xhci_readl(xhci, addr); | ||
249 | xhci_dbg(xhci, "clear port %s change, actual port %d status = 0x%x\n", | ||
250 | port_change_bit, wIndex, temp); | ||
251 | temp = xhci_readl(xhci, addr); /* unblock any posted writes */ | ||
252 | break; | ||
253 | default: | ||
254 | error: | ||
255 | /* "stall" on error */ | ||
256 | retval = -EPIPE; | ||
257 | } | ||
258 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
259 | return retval; | ||
260 | } | ||
261 | |||
262 | /* | ||
263 | * Returns 0 if the status hasn't changed, or the number of bytes in buf. | ||
264 | * Ports are 0-indexed from the HCD point of view, | ||
265 | * and 1-indexed from the USB core pointer of view. | ||
266 | * xHCI instances can have up to 127 ports, so FIXME if you see more than 15. | ||
267 | * | ||
268 | * Note that the status change bits will be cleared as soon as a port status | ||
269 | * change event is generated, so we use the saved status from that event. | ||
270 | */ | ||
271 | int xhci_hub_status_data(struct usb_hcd *hcd, char *buf) | ||
272 | { | ||
273 | unsigned long flags; | ||
274 | u32 temp, status; | ||
275 | int i, retval; | ||
276 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
277 | int ports; | ||
278 | u32 __iomem *addr; | ||
279 | |||
280 | ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
281 | |||
282 | /* Initial status is no changes */ | ||
283 | buf[0] = 0; | ||
284 | status = 0; | ||
285 | if (ports > 7) { | ||
286 | buf[1] = 0; | ||
287 | retval = 2; | ||
288 | } else { | ||
289 | retval = 1; | ||
290 | } | ||
291 | |||
292 | spin_lock_irqsave(&xhci->lock, flags); | ||
293 | /* For each port, did anything change? If so, set that bit in buf. */ | ||
294 | for (i = 0; i < ports; i++) { | ||
295 | addr = &xhci->op_regs->port_status_base + | ||
296 | NUM_PORT_REGS*i; | ||
297 | temp = xhci_readl(xhci, addr); | ||
298 | if (temp & (PORT_CSC | PORT_PEC | PORT_OCC)) { | ||
299 | if (i < 7) | ||
300 | buf[0] |= 1 << (i + 1); | ||
301 | else | ||
302 | buf[1] |= 1 << (i - 7); | ||
303 | status = 1; | ||
304 | } | ||
305 | } | ||
306 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
307 | return status ? retval : 0; | ||
308 | } | ||
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c new file mode 100644 index 000000000000..c8a72de1c508 --- /dev/null +++ b/drivers/usb/host/xhci-mem.c | |||
@@ -0,0 +1,769 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #include <linux/usb.h> | ||
24 | #include <linux/pci.h> | ||
25 | #include <linux/dmapool.h> | ||
26 | |||
27 | #include "xhci.h" | ||
28 | |||
29 | /* | ||
30 | * Allocates a generic ring segment from the ring pool, sets the dma address, | ||
31 | * initializes the segment to zero, and sets the private next pointer to NULL. | ||
32 | * | ||
33 | * Section 4.11.1.1: | ||
34 | * "All components of all Command and Transfer TRBs shall be initialized to '0'" | ||
35 | */ | ||
36 | static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flags) | ||
37 | { | ||
38 | struct xhci_segment *seg; | ||
39 | dma_addr_t dma; | ||
40 | |||
41 | seg = kzalloc(sizeof *seg, flags); | ||
42 | if (!seg) | ||
43 | return 0; | ||
44 | xhci_dbg(xhci, "Allocating priv segment structure at %p\n", seg); | ||
45 | |||
46 | seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma); | ||
47 | if (!seg->trbs) { | ||
48 | kfree(seg); | ||
49 | return 0; | ||
50 | } | ||
51 | xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n", | ||
52 | seg->trbs, (unsigned long long)dma); | ||
53 | |||
54 | memset(seg->trbs, 0, SEGMENT_SIZE); | ||
55 | seg->dma = dma; | ||
56 | seg->next = NULL; | ||
57 | |||
58 | return seg; | ||
59 | } | ||
60 | |||
61 | static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg) | ||
62 | { | ||
63 | if (!seg) | ||
64 | return; | ||
65 | if (seg->trbs) { | ||
66 | xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n", | ||
67 | seg->trbs, (unsigned long long)seg->dma); | ||
68 | dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma); | ||
69 | seg->trbs = NULL; | ||
70 | } | ||
71 | xhci_dbg(xhci, "Freeing priv segment structure at %p\n", seg); | ||
72 | kfree(seg); | ||
73 | } | ||
74 | |||
75 | /* | ||
76 | * Make the prev segment point to the next segment. | ||
77 | * | ||
78 | * Change the last TRB in the prev segment to be a Link TRB which points to the | ||
79 | * DMA address of the next segment. The caller needs to set any Link TRB | ||
80 | * related flags, such as End TRB, Toggle Cycle, and no snoop. | ||
81 | */ | ||
82 | static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev, | ||
83 | struct xhci_segment *next, bool link_trbs) | ||
84 | { | ||
85 | u32 val; | ||
86 | |||
87 | if (!prev || !next) | ||
88 | return; | ||
89 | prev->next = next; | ||
90 | if (link_trbs) { | ||
91 | prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr[0] = next->dma; | ||
92 | |||
93 | /* Set the last TRB in the segment to have a TRB type ID of Link TRB */ | ||
94 | val = prev->trbs[TRBS_PER_SEGMENT-1].link.control; | ||
95 | val &= ~TRB_TYPE_BITMASK; | ||
96 | val |= TRB_TYPE(TRB_LINK); | ||
97 | prev->trbs[TRBS_PER_SEGMENT-1].link.control = val; | ||
98 | } | ||
99 | xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n", | ||
100 | (unsigned long long)prev->dma, | ||
101 | (unsigned long long)next->dma); | ||
102 | } | ||
103 | |||
104 | /* XXX: Do we need the hcd structure in all these functions? */ | ||
105 | void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring) | ||
106 | { | ||
107 | struct xhci_segment *seg; | ||
108 | struct xhci_segment *first_seg; | ||
109 | |||
110 | if (!ring || !ring->first_seg) | ||
111 | return; | ||
112 | first_seg = ring->first_seg; | ||
113 | seg = first_seg->next; | ||
114 | xhci_dbg(xhci, "Freeing ring at %p\n", ring); | ||
115 | while (seg != first_seg) { | ||
116 | struct xhci_segment *next = seg->next; | ||
117 | xhci_segment_free(xhci, seg); | ||
118 | seg = next; | ||
119 | } | ||
120 | xhci_segment_free(xhci, first_seg); | ||
121 | ring->first_seg = NULL; | ||
122 | kfree(ring); | ||
123 | } | ||
124 | |||
125 | /** | ||
126 | * Create a new ring with zero or more segments. | ||
127 | * | ||
128 | * Link each segment together into a ring. | ||
129 | * Set the end flag and the cycle toggle bit on the last segment. | ||
130 | * See section 4.9.1 and figures 15 and 16. | ||
131 | */ | ||
132 | static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, | ||
133 | unsigned int num_segs, bool link_trbs, gfp_t flags) | ||
134 | { | ||
135 | struct xhci_ring *ring; | ||
136 | struct xhci_segment *prev; | ||
137 | |||
138 | ring = kzalloc(sizeof *(ring), flags); | ||
139 | xhci_dbg(xhci, "Allocating ring at %p\n", ring); | ||
140 | if (!ring) | ||
141 | return 0; | ||
142 | |||
143 | INIT_LIST_HEAD(&ring->td_list); | ||
144 | INIT_LIST_HEAD(&ring->cancelled_td_list); | ||
145 | if (num_segs == 0) | ||
146 | return ring; | ||
147 | |||
148 | ring->first_seg = xhci_segment_alloc(xhci, flags); | ||
149 | if (!ring->first_seg) | ||
150 | goto fail; | ||
151 | num_segs--; | ||
152 | |||
153 | prev = ring->first_seg; | ||
154 | while (num_segs > 0) { | ||
155 | struct xhci_segment *next; | ||
156 | |||
157 | next = xhci_segment_alloc(xhci, flags); | ||
158 | if (!next) | ||
159 | goto fail; | ||
160 | xhci_link_segments(xhci, prev, next, link_trbs); | ||
161 | |||
162 | prev = next; | ||
163 | num_segs--; | ||
164 | } | ||
165 | xhci_link_segments(xhci, prev, ring->first_seg, link_trbs); | ||
166 | |||
167 | if (link_trbs) { | ||
168 | /* See section 4.9.2.1 and 6.4.4.1 */ | ||
169 | prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE); | ||
170 | xhci_dbg(xhci, "Wrote link toggle flag to" | ||
171 | " segment %p (virtual), 0x%llx (DMA)\n", | ||
172 | prev, (unsigned long long)prev->dma); | ||
173 | } | ||
174 | /* The ring is empty, so the enqueue pointer == dequeue pointer */ | ||
175 | ring->enqueue = ring->first_seg->trbs; | ||
176 | ring->enq_seg = ring->first_seg; | ||
177 | ring->dequeue = ring->enqueue; | ||
178 | ring->deq_seg = ring->first_seg; | ||
179 | /* The ring is initialized to 0. The producer must write 1 to the cycle | ||
180 | * bit to handover ownership of the TRB, so PCS = 1. The consumer must | ||
181 | * compare CCS to the cycle bit to check ownership, so CCS = 1. | ||
182 | */ | ||
183 | ring->cycle_state = 1; | ||
184 | |||
185 | return ring; | ||
186 | |||
187 | fail: | ||
188 | xhci_ring_free(xhci, ring); | ||
189 | return 0; | ||
190 | } | ||
191 | |||
192 | /* All the xhci_tds in the ring's TD list should be freed at this point */ | ||
193 | void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) | ||
194 | { | ||
195 | struct xhci_virt_device *dev; | ||
196 | int i; | ||
197 | |||
198 | /* Slot ID 0 is reserved */ | ||
199 | if (slot_id == 0 || !xhci->devs[slot_id]) | ||
200 | return; | ||
201 | |||
202 | dev = xhci->devs[slot_id]; | ||
203 | xhci->dcbaa->dev_context_ptrs[2*slot_id] = 0; | ||
204 | xhci->dcbaa->dev_context_ptrs[2*slot_id + 1] = 0; | ||
205 | if (!dev) | ||
206 | return; | ||
207 | |||
208 | for (i = 0; i < 31; ++i) | ||
209 | if (dev->ep_rings[i]) | ||
210 | xhci_ring_free(xhci, dev->ep_rings[i]); | ||
211 | |||
212 | if (dev->in_ctx) | ||
213 | dma_pool_free(xhci->device_pool, | ||
214 | dev->in_ctx, dev->in_ctx_dma); | ||
215 | if (dev->out_ctx) | ||
216 | dma_pool_free(xhci->device_pool, | ||
217 | dev->out_ctx, dev->out_ctx_dma); | ||
218 | kfree(xhci->devs[slot_id]); | ||
219 | xhci->devs[slot_id] = 0; | ||
220 | } | ||
221 | |||
222 | int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, | ||
223 | struct usb_device *udev, gfp_t flags) | ||
224 | { | ||
225 | dma_addr_t dma; | ||
226 | struct xhci_virt_device *dev; | ||
227 | |||
228 | /* Slot ID 0 is reserved */ | ||
229 | if (slot_id == 0 || xhci->devs[slot_id]) { | ||
230 | xhci_warn(xhci, "Bad Slot ID %d\n", slot_id); | ||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags); | ||
235 | if (!xhci->devs[slot_id]) | ||
236 | return 0; | ||
237 | dev = xhci->devs[slot_id]; | ||
238 | |||
239 | /* Allocate the (output) device context that will be used in the HC */ | ||
240 | dev->out_ctx = dma_pool_alloc(xhci->device_pool, flags, &dma); | ||
241 | if (!dev->out_ctx) | ||
242 | goto fail; | ||
243 | dev->out_ctx_dma = dma; | ||
244 | xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id, | ||
245 | (unsigned long long)dma); | ||
246 | memset(dev->out_ctx, 0, sizeof(*dev->out_ctx)); | ||
247 | |||
248 | /* Allocate the (input) device context for address device command */ | ||
249 | dev->in_ctx = dma_pool_alloc(xhci->device_pool, flags, &dma); | ||
250 | if (!dev->in_ctx) | ||
251 | goto fail; | ||
252 | dev->in_ctx_dma = dma; | ||
253 | xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id, | ||
254 | (unsigned long long)dma); | ||
255 | memset(dev->in_ctx, 0, sizeof(*dev->in_ctx)); | ||
256 | |||
257 | /* Allocate endpoint 0 ring */ | ||
258 | dev->ep_rings[0] = xhci_ring_alloc(xhci, 1, true, flags); | ||
259 | if (!dev->ep_rings[0]) | ||
260 | goto fail; | ||
261 | |||
262 | init_completion(&dev->cmd_completion); | ||
263 | |||
264 | /* | ||
265 | * Point to output device context in dcbaa; skip the output control | ||
266 | * context, which is eight 32 bit fields (or 32 bytes long) | ||
267 | */ | ||
268 | xhci->dcbaa->dev_context_ptrs[2*slot_id] = | ||
269 | (u32) dev->out_ctx_dma + (32); | ||
270 | xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n", | ||
271 | slot_id, | ||
272 | &xhci->dcbaa->dev_context_ptrs[2*slot_id], | ||
273 | (unsigned long long)dev->out_ctx_dma); | ||
274 | xhci->dcbaa->dev_context_ptrs[2*slot_id + 1] = 0; | ||
275 | |||
276 | return 1; | ||
277 | fail: | ||
278 | xhci_free_virt_device(xhci, slot_id); | ||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | /* Setup an xHCI virtual device for a Set Address command */ | ||
283 | int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev) | ||
284 | { | ||
285 | struct xhci_virt_device *dev; | ||
286 | struct xhci_ep_ctx *ep0_ctx; | ||
287 | struct usb_device *top_dev; | ||
288 | |||
289 | dev = xhci->devs[udev->slot_id]; | ||
290 | /* Slot ID 0 is reserved */ | ||
291 | if (udev->slot_id == 0 || !dev) { | ||
292 | xhci_warn(xhci, "Slot ID %d is not assigned to this device\n", | ||
293 | udev->slot_id); | ||
294 | return -EINVAL; | ||
295 | } | ||
296 | ep0_ctx = &dev->in_ctx->ep[0]; | ||
297 | |||
298 | /* 2) New slot context and endpoint 0 context are valid*/ | ||
299 | dev->in_ctx->add_flags = SLOT_FLAG | EP0_FLAG; | ||
300 | |||
301 | /* 3) Only the control endpoint is valid - one endpoint context */ | ||
302 | dev->in_ctx->slot.dev_info |= LAST_CTX(1); | ||
303 | |||
304 | switch (udev->speed) { | ||
305 | case USB_SPEED_SUPER: | ||
306 | dev->in_ctx->slot.dev_info |= (u32) udev->route; | ||
307 | dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_SS; | ||
308 | break; | ||
309 | case USB_SPEED_HIGH: | ||
310 | dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_HS; | ||
311 | break; | ||
312 | case USB_SPEED_FULL: | ||
313 | dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_FS; | ||
314 | break; | ||
315 | case USB_SPEED_LOW: | ||
316 | dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_LS; | ||
317 | break; | ||
318 | case USB_SPEED_VARIABLE: | ||
319 | xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); | ||
320 | return -EINVAL; | ||
321 | break; | ||
322 | default: | ||
323 | /* Speed was set earlier, this shouldn't happen. */ | ||
324 | BUG(); | ||
325 | } | ||
326 | /* Find the root hub port this device is under */ | ||
327 | for (top_dev = udev; top_dev->parent && top_dev->parent->parent; | ||
328 | top_dev = top_dev->parent) | ||
329 | /* Found device below root hub */; | ||
330 | dev->in_ctx->slot.dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum); | ||
331 | xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum); | ||
332 | |||
333 | /* Is this a LS/FS device under a HS hub? */ | ||
334 | /* | ||
335 | * FIXME: I don't think this is right, where does the TT info for the | ||
336 | * roothub or parent hub come from? | ||
337 | */ | ||
338 | if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) && | ||
339 | udev->tt) { | ||
340 | dev->in_ctx->slot.tt_info = udev->tt->hub->slot_id; | ||
341 | dev->in_ctx->slot.tt_info |= udev->ttport << 8; | ||
342 | } | ||
343 | xhci_dbg(xhci, "udev->tt = %p\n", udev->tt); | ||
344 | xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport); | ||
345 | |||
346 | /* Step 4 - ring already allocated */ | ||
347 | /* Step 5 */ | ||
348 | ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP); | ||
349 | /* | ||
350 | * See section 4.3 bullet 6: | ||
351 | * The default Max Packet size for ep0 is "8 bytes for a USB2 | ||
352 | * LS/FS/HS device or 512 bytes for a USB3 SS device" | ||
353 | * XXX: Not sure about wireless USB devices. | ||
354 | */ | ||
355 | if (udev->speed == USB_SPEED_SUPER) | ||
356 | ep0_ctx->ep_info2 |= MAX_PACKET(512); | ||
357 | else | ||
358 | ep0_ctx->ep_info2 |= MAX_PACKET(8); | ||
359 | /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */ | ||
360 | ep0_ctx->ep_info2 |= MAX_BURST(0); | ||
361 | ep0_ctx->ep_info2 |= ERROR_COUNT(3); | ||
362 | |||
363 | ep0_ctx->deq[0] = | ||
364 | dev->ep_rings[0]->first_seg->dma; | ||
365 | ep0_ctx->deq[0] |= dev->ep_rings[0]->cycle_state; | ||
366 | ep0_ctx->deq[1] = 0; | ||
367 | |||
368 | /* Steps 7 and 8 were done in xhci_alloc_virt_device() */ | ||
369 | |||
370 | return 0; | ||
371 | } | ||
372 | |||
373 | /* Return the polling or NAK interval. | ||
374 | * | ||
375 | * The polling interval is expressed in "microframes". If xHCI's Interval field | ||
376 | * is set to N, it will service the endpoint every 2^(Interval)*125us. | ||
377 | * | ||
378 | * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval | ||
379 | * is set to 0. | ||
380 | */ | ||
381 | static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev, | ||
382 | struct usb_host_endpoint *ep) | ||
383 | { | ||
384 | unsigned int interval = 0; | ||
385 | |||
386 | switch (udev->speed) { | ||
387 | case USB_SPEED_HIGH: | ||
388 | /* Max NAK rate */ | ||
389 | if (usb_endpoint_xfer_control(&ep->desc) || | ||
390 | usb_endpoint_xfer_bulk(&ep->desc)) | ||
391 | interval = ep->desc.bInterval; | ||
392 | /* Fall through - SS and HS isoc/int have same decoding */ | ||
393 | case USB_SPEED_SUPER: | ||
394 | if (usb_endpoint_xfer_int(&ep->desc) || | ||
395 | usb_endpoint_xfer_isoc(&ep->desc)) { | ||
396 | if (ep->desc.bInterval == 0) | ||
397 | interval = 0; | ||
398 | else | ||
399 | interval = ep->desc.bInterval - 1; | ||
400 | if (interval > 15) | ||
401 | interval = 15; | ||
402 | if (interval != ep->desc.bInterval + 1) | ||
403 | dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", | ||
404 | ep->desc.bEndpointAddress, 1 << interval); | ||
405 | } | ||
406 | break; | ||
407 | /* Convert bInterval (in 1-255 frames) to microframes and round down to | ||
408 | * nearest power of 2. | ||
409 | */ | ||
410 | case USB_SPEED_FULL: | ||
411 | case USB_SPEED_LOW: | ||
412 | if (usb_endpoint_xfer_int(&ep->desc) || | ||
413 | usb_endpoint_xfer_isoc(&ep->desc)) { | ||
414 | interval = fls(8*ep->desc.bInterval) - 1; | ||
415 | if (interval > 10) | ||
416 | interval = 10; | ||
417 | if (interval < 3) | ||
418 | interval = 3; | ||
419 | if ((1 << interval) != 8*ep->desc.bInterval) | ||
420 | dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", | ||
421 | ep->desc.bEndpointAddress, 1 << interval); | ||
422 | } | ||
423 | break; | ||
424 | default: | ||
425 | BUG(); | ||
426 | } | ||
427 | return EP_INTERVAL(interval); | ||
428 | } | ||
429 | |||
430 | static inline u32 xhci_get_endpoint_type(struct usb_device *udev, | ||
431 | struct usb_host_endpoint *ep) | ||
432 | { | ||
433 | int in; | ||
434 | u32 type; | ||
435 | |||
436 | in = usb_endpoint_dir_in(&ep->desc); | ||
437 | if (usb_endpoint_xfer_control(&ep->desc)) { | ||
438 | type = EP_TYPE(CTRL_EP); | ||
439 | } else if (usb_endpoint_xfer_bulk(&ep->desc)) { | ||
440 | if (in) | ||
441 | type = EP_TYPE(BULK_IN_EP); | ||
442 | else | ||
443 | type = EP_TYPE(BULK_OUT_EP); | ||
444 | } else if (usb_endpoint_xfer_isoc(&ep->desc)) { | ||
445 | if (in) | ||
446 | type = EP_TYPE(ISOC_IN_EP); | ||
447 | else | ||
448 | type = EP_TYPE(ISOC_OUT_EP); | ||
449 | } else if (usb_endpoint_xfer_int(&ep->desc)) { | ||
450 | if (in) | ||
451 | type = EP_TYPE(INT_IN_EP); | ||
452 | else | ||
453 | type = EP_TYPE(INT_OUT_EP); | ||
454 | } else { | ||
455 | BUG(); | ||
456 | } | ||
457 | return type; | ||
458 | } | ||
459 | |||
460 | int xhci_endpoint_init(struct xhci_hcd *xhci, | ||
461 | struct xhci_virt_device *virt_dev, | ||
462 | struct usb_device *udev, | ||
463 | struct usb_host_endpoint *ep, | ||
464 | gfp_t mem_flags) | ||
465 | { | ||
466 | unsigned int ep_index; | ||
467 | struct xhci_ep_ctx *ep_ctx; | ||
468 | struct xhci_ring *ep_ring; | ||
469 | unsigned int max_packet; | ||
470 | unsigned int max_burst; | ||
471 | |||
472 | ep_index = xhci_get_endpoint_index(&ep->desc); | ||
473 | ep_ctx = &virt_dev->in_ctx->ep[ep_index]; | ||
474 | |||
475 | /* Set up the endpoint ring */ | ||
476 | virt_dev->new_ep_rings[ep_index] = xhci_ring_alloc(xhci, 1, true, mem_flags); | ||
477 | if (!virt_dev->new_ep_rings[ep_index]) | ||
478 | return -ENOMEM; | ||
479 | ep_ring = virt_dev->new_ep_rings[ep_index]; | ||
480 | ep_ctx->deq[0] = ep_ring->first_seg->dma | ep_ring->cycle_state; | ||
481 | ep_ctx->deq[1] = 0; | ||
482 | |||
483 | ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep); | ||
484 | |||
485 | /* FIXME dig Mult and streams info out of ep companion desc */ | ||
486 | |||
487 | /* Allow 3 retries for everything but isoc */ | ||
488 | if (!usb_endpoint_xfer_isoc(&ep->desc)) | ||
489 | ep_ctx->ep_info2 = ERROR_COUNT(3); | ||
490 | else | ||
491 | ep_ctx->ep_info2 = ERROR_COUNT(0); | ||
492 | |||
493 | ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep); | ||
494 | |||
495 | /* Set the max packet size and max burst */ | ||
496 | switch (udev->speed) { | ||
497 | case USB_SPEED_SUPER: | ||
498 | max_packet = ep->desc.wMaxPacketSize; | ||
499 | ep_ctx->ep_info2 |= MAX_PACKET(max_packet); | ||
500 | /* dig out max burst from ep companion desc */ | ||
501 | max_packet = ep->ss_ep_comp->desc.bMaxBurst; | ||
502 | ep_ctx->ep_info2 |= MAX_BURST(max_packet); | ||
503 | break; | ||
504 | case USB_SPEED_HIGH: | ||
505 | /* bits 11:12 specify the number of additional transaction | ||
506 | * opportunities per microframe (USB 2.0, section 9.6.6) | ||
507 | */ | ||
508 | if (usb_endpoint_xfer_isoc(&ep->desc) || | ||
509 | usb_endpoint_xfer_int(&ep->desc)) { | ||
510 | max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11; | ||
511 | ep_ctx->ep_info2 |= MAX_BURST(max_burst); | ||
512 | } | ||
513 | /* Fall through */ | ||
514 | case USB_SPEED_FULL: | ||
515 | case USB_SPEED_LOW: | ||
516 | max_packet = ep->desc.wMaxPacketSize & 0x3ff; | ||
517 | ep_ctx->ep_info2 |= MAX_PACKET(max_packet); | ||
518 | break; | ||
519 | default: | ||
520 | BUG(); | ||
521 | } | ||
522 | /* FIXME Debug endpoint context */ | ||
523 | return 0; | ||
524 | } | ||
525 | |||
526 | void xhci_endpoint_zero(struct xhci_hcd *xhci, | ||
527 | struct xhci_virt_device *virt_dev, | ||
528 | struct usb_host_endpoint *ep) | ||
529 | { | ||
530 | unsigned int ep_index; | ||
531 | struct xhci_ep_ctx *ep_ctx; | ||
532 | |||
533 | ep_index = xhci_get_endpoint_index(&ep->desc); | ||
534 | ep_ctx = &virt_dev->in_ctx->ep[ep_index]; | ||
535 | |||
536 | ep_ctx->ep_info = 0; | ||
537 | ep_ctx->ep_info2 = 0; | ||
538 | ep_ctx->deq[0] = 0; | ||
539 | ep_ctx->deq[1] = 0; | ||
540 | ep_ctx->tx_info = 0; | ||
541 | /* Don't free the endpoint ring until the set interface or configuration | ||
542 | * request succeeds. | ||
543 | */ | ||
544 | } | ||
545 | |||
546 | void xhci_mem_cleanup(struct xhci_hcd *xhci) | ||
547 | { | ||
548 | struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); | ||
549 | int size; | ||
550 | int i; | ||
551 | |||
552 | /* Free the Event Ring Segment Table and the actual Event Ring */ | ||
553 | xhci_writel(xhci, 0, &xhci->ir_set->erst_size); | ||
554 | xhci_writel(xhci, 0, &xhci->ir_set->erst_base[0]); | ||
555 | xhci_writel(xhci, 0, &xhci->ir_set->erst_base[1]); | ||
556 | xhci_writel(xhci, 0, &xhci->ir_set->erst_dequeue[0]); | ||
557 | xhci_writel(xhci, 0, &xhci->ir_set->erst_dequeue[1]); | ||
558 | size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); | ||
559 | if (xhci->erst.entries) | ||
560 | pci_free_consistent(pdev, size, | ||
561 | xhci->erst.entries, xhci->erst.erst_dma_addr); | ||
562 | xhci->erst.entries = NULL; | ||
563 | xhci_dbg(xhci, "Freed ERST\n"); | ||
564 | if (xhci->event_ring) | ||
565 | xhci_ring_free(xhci, xhci->event_ring); | ||
566 | xhci->event_ring = NULL; | ||
567 | xhci_dbg(xhci, "Freed event ring\n"); | ||
568 | |||
569 | xhci_writel(xhci, 0, &xhci->op_regs->cmd_ring[0]); | ||
570 | xhci_writel(xhci, 0, &xhci->op_regs->cmd_ring[1]); | ||
571 | if (xhci->cmd_ring) | ||
572 | xhci_ring_free(xhci, xhci->cmd_ring); | ||
573 | xhci->cmd_ring = NULL; | ||
574 | xhci_dbg(xhci, "Freed command ring\n"); | ||
575 | |||
576 | for (i = 1; i < MAX_HC_SLOTS; ++i) | ||
577 | xhci_free_virt_device(xhci, i); | ||
578 | |||
579 | if (xhci->segment_pool) | ||
580 | dma_pool_destroy(xhci->segment_pool); | ||
581 | xhci->segment_pool = NULL; | ||
582 | xhci_dbg(xhci, "Freed segment pool\n"); | ||
583 | |||
584 | if (xhci->device_pool) | ||
585 | dma_pool_destroy(xhci->device_pool); | ||
586 | xhci->device_pool = NULL; | ||
587 | xhci_dbg(xhci, "Freed device context pool\n"); | ||
588 | |||
589 | xhci_writel(xhci, 0, &xhci->op_regs->dcbaa_ptr[0]); | ||
590 | xhci_writel(xhci, 0, &xhci->op_regs->dcbaa_ptr[1]); | ||
591 | if (xhci->dcbaa) | ||
592 | pci_free_consistent(pdev, sizeof(*xhci->dcbaa), | ||
593 | xhci->dcbaa, xhci->dcbaa->dma); | ||
594 | xhci->dcbaa = NULL; | ||
595 | |||
596 | xhci->page_size = 0; | ||
597 | xhci->page_shift = 0; | ||
598 | } | ||
599 | |||
600 | int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) | ||
601 | { | ||
602 | dma_addr_t dma; | ||
603 | struct device *dev = xhci_to_hcd(xhci)->self.controller; | ||
604 | unsigned int val, val2; | ||
605 | struct xhci_segment *seg; | ||
606 | u32 page_size; | ||
607 | int i; | ||
608 | |||
609 | page_size = xhci_readl(xhci, &xhci->op_regs->page_size); | ||
610 | xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size); | ||
611 | for (i = 0; i < 16; i++) { | ||
612 | if ((0x1 & page_size) != 0) | ||
613 | break; | ||
614 | page_size = page_size >> 1; | ||
615 | } | ||
616 | if (i < 16) | ||
617 | xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024); | ||
618 | else | ||
619 | xhci_warn(xhci, "WARN: no supported page size\n"); | ||
620 | /* Use 4K pages, since that's common and the minimum the HC supports */ | ||
621 | xhci->page_shift = 12; | ||
622 | xhci->page_size = 1 << xhci->page_shift; | ||
623 | xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024); | ||
624 | |||
625 | /* | ||
626 | * Program the Number of Device Slots Enabled field in the CONFIG | ||
627 | * register with the max value of slots the HC can handle. | ||
628 | */ | ||
629 | val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1)); | ||
630 | xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n", | ||
631 | (unsigned int) val); | ||
632 | val2 = xhci_readl(xhci, &xhci->op_regs->config_reg); | ||
633 | val |= (val2 & ~HCS_SLOTS_MASK); | ||
634 | xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n", | ||
635 | (unsigned int) val); | ||
636 | xhci_writel(xhci, val, &xhci->op_regs->config_reg); | ||
637 | |||
638 | /* | ||
639 | * Section 5.4.8 - doorbell array must be | ||
640 | * "physically contiguous and 64-byte (cache line) aligned". | ||
641 | */ | ||
642 | xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev), | ||
643 | sizeof(*xhci->dcbaa), &dma); | ||
644 | if (!xhci->dcbaa) | ||
645 | goto fail; | ||
646 | memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa)); | ||
647 | xhci->dcbaa->dma = dma; | ||
648 | xhci_dbg(xhci, "// Device context base array address = 0x%llx (DMA), %p (virt)\n", | ||
649 | (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa); | ||
650 | xhci_writel(xhci, dma, &xhci->op_regs->dcbaa_ptr[0]); | ||
651 | xhci_writel(xhci, (u32) 0, &xhci->op_regs->dcbaa_ptr[1]); | ||
652 | |||
653 | /* | ||
654 | * Initialize the ring segment pool. The ring must be a contiguous | ||
655 | * structure comprised of TRBs. The TRBs must be 16 byte aligned, | ||
656 | * however, the command ring segment needs 64-byte aligned segments, | ||
657 | * so we pick the greater alignment need. | ||
658 | */ | ||
659 | xhci->segment_pool = dma_pool_create("xHCI ring segments", dev, | ||
660 | SEGMENT_SIZE, 64, xhci->page_size); | ||
661 | /* See Table 46 and Note on Figure 55 */ | ||
662 | /* FIXME support 64-byte contexts */ | ||
663 | xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev, | ||
664 | sizeof(struct xhci_device_control), | ||
665 | 64, xhci->page_size); | ||
666 | if (!xhci->segment_pool || !xhci->device_pool) | ||
667 | goto fail; | ||
668 | |||
669 | /* Set up the command ring to have one segments for now. */ | ||
670 | xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags); | ||
671 | if (!xhci->cmd_ring) | ||
672 | goto fail; | ||
673 | xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring); | ||
674 | xhci_dbg(xhci, "First segment DMA is 0x%llx\n", | ||
675 | (unsigned long long)xhci->cmd_ring->first_seg->dma); | ||
676 | |||
677 | /* Set the address in the Command Ring Control register */ | ||
678 | val = xhci_readl(xhci, &xhci->op_regs->cmd_ring[0]); | ||
679 | val = (val & ~CMD_RING_ADDR_MASK) | | ||
680 | (xhci->cmd_ring->first_seg->dma & CMD_RING_ADDR_MASK) | | ||
681 | xhci->cmd_ring->cycle_state; | ||
682 | xhci_dbg(xhci, "// Setting command ring address low bits to 0x%x\n", val); | ||
683 | xhci_writel(xhci, val, &xhci->op_regs->cmd_ring[0]); | ||
684 | xhci_dbg(xhci, "// Setting command ring address high bits to 0x0\n"); | ||
685 | xhci_writel(xhci, (u32) 0, &xhci->op_regs->cmd_ring[1]); | ||
686 | xhci_dbg_cmd_ptrs(xhci); | ||
687 | |||
688 | val = xhci_readl(xhci, &xhci->cap_regs->db_off); | ||
689 | val &= DBOFF_MASK; | ||
690 | xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x" | ||
691 | " from cap regs base addr\n", val); | ||
692 | xhci->dba = (void *) xhci->cap_regs + val; | ||
693 | xhci_dbg_regs(xhci); | ||
694 | xhci_print_run_regs(xhci); | ||
695 | /* Set ir_set to interrupt register set 0 */ | ||
696 | xhci->ir_set = (void *) xhci->run_regs->ir_set; | ||
697 | |||
698 | /* | ||
699 | * Event ring setup: Allocate a normal ring, but also setup | ||
700 | * the event ring segment table (ERST). Section 4.9.3. | ||
701 | */ | ||
702 | xhci_dbg(xhci, "// Allocating event ring\n"); | ||
703 | xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags); | ||
704 | if (!xhci->event_ring) | ||
705 | goto fail; | ||
706 | |||
707 | xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev), | ||
708 | sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma); | ||
709 | if (!xhci->erst.entries) | ||
710 | goto fail; | ||
711 | xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n", | ||
712 | (unsigned long long)dma); | ||
713 | |||
714 | memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS); | ||
715 | xhci->erst.num_entries = ERST_NUM_SEGS; | ||
716 | xhci->erst.erst_dma_addr = dma; | ||
717 | xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx\n", | ||
718 | xhci->erst.num_entries, | ||
719 | xhci->erst.entries, | ||
720 | (unsigned long long)xhci->erst.erst_dma_addr); | ||
721 | |||
722 | /* set ring base address and size for each segment table entry */ | ||
723 | for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) { | ||
724 | struct xhci_erst_entry *entry = &xhci->erst.entries[val]; | ||
725 | entry->seg_addr[0] = seg->dma; | ||
726 | entry->seg_addr[1] = 0; | ||
727 | entry->seg_size = TRBS_PER_SEGMENT; | ||
728 | entry->rsvd = 0; | ||
729 | seg = seg->next; | ||
730 | } | ||
731 | |||
732 | /* set ERST count with the number of entries in the segment table */ | ||
733 | val = xhci_readl(xhci, &xhci->ir_set->erst_size); | ||
734 | val &= ERST_SIZE_MASK; | ||
735 | val |= ERST_NUM_SEGS; | ||
736 | xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n", | ||
737 | val); | ||
738 | xhci_writel(xhci, val, &xhci->ir_set->erst_size); | ||
739 | |||
740 | xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n"); | ||
741 | /* set the segment table base address */ | ||
742 | xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%llx\n", | ||
743 | (unsigned long long)xhci->erst.erst_dma_addr); | ||
744 | val = xhci_readl(xhci, &xhci->ir_set->erst_base[0]); | ||
745 | val &= ERST_PTR_MASK; | ||
746 | val |= (xhci->erst.erst_dma_addr & ~ERST_PTR_MASK); | ||
747 | xhci_writel(xhci, val, &xhci->ir_set->erst_base[0]); | ||
748 | xhci_writel(xhci, 0, &xhci->ir_set->erst_base[1]); | ||
749 | |||
750 | /* Set the event ring dequeue address */ | ||
751 | xhci_set_hc_event_deq(xhci); | ||
752 | xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n"); | ||
753 | xhci_print_ir_set(xhci, xhci->ir_set, 0); | ||
754 | |||
755 | /* | ||
756 | * XXX: Might need to set the Interrupter Moderation Register to | ||
757 | * something other than the default (~1ms minimum between interrupts). | ||
758 | * See section 5.5.1.2. | ||
759 | */ | ||
760 | init_completion(&xhci->addr_dev); | ||
761 | for (i = 0; i < MAX_HC_SLOTS; ++i) | ||
762 | xhci->devs[i] = 0; | ||
763 | |||
764 | return 0; | ||
765 | fail: | ||
766 | xhci_warn(xhci, "Couldn't initialize memory\n"); | ||
767 | xhci_mem_cleanup(xhci); | ||
768 | return -ENOMEM; | ||
769 | } | ||
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c new file mode 100644 index 000000000000..1462709e26c0 --- /dev/null +++ b/drivers/usb/host/xhci-pci.c | |||
@@ -0,0 +1,166 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver PCI Bus Glue. | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #include <linux/pci.h> | ||
24 | |||
25 | #include "xhci.h" | ||
26 | |||
27 | static const char hcd_name[] = "xhci_hcd"; | ||
28 | |||
29 | /* called after powerup, by probe or system-pm "wakeup" */ | ||
30 | static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev) | ||
31 | { | ||
32 | /* | ||
33 | * TODO: Implement finding debug ports later. | ||
34 | * TODO: see if there are any quirks that need to be added to handle | ||
35 | * new extended capabilities. | ||
36 | */ | ||
37 | |||
38 | /* PCI Memory-Write-Invalidate cycle support is optional (uncommon) */ | ||
39 | if (!pci_set_mwi(pdev)) | ||
40 | xhci_dbg(xhci, "MWI active\n"); | ||
41 | |||
42 | xhci_dbg(xhci, "Finished xhci_pci_reinit\n"); | ||
43 | return 0; | ||
44 | } | ||
45 | |||
46 | /* called during probe() after chip reset completes */ | ||
47 | static int xhci_pci_setup(struct usb_hcd *hcd) | ||
48 | { | ||
49 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); | ||
50 | struct pci_dev *pdev = to_pci_dev(hcd->self.controller); | ||
51 | int retval; | ||
52 | |||
53 | xhci->cap_regs = hcd->regs; | ||
54 | xhci->op_regs = hcd->regs + | ||
55 | HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase)); | ||
56 | xhci->run_regs = hcd->regs + | ||
57 | (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK); | ||
58 | /* Cache read-only capability registers */ | ||
59 | xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1); | ||
60 | xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2); | ||
61 | xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3); | ||
62 | xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params); | ||
63 | xhci_print_registers(xhci); | ||
64 | |||
65 | /* Make sure the HC is halted. */ | ||
66 | retval = xhci_halt(xhci); | ||
67 | if (retval) | ||
68 | return retval; | ||
69 | |||
70 | xhci_dbg(xhci, "Resetting HCD\n"); | ||
71 | /* Reset the internal HC memory state and registers. */ | ||
72 | retval = xhci_reset(xhci); | ||
73 | if (retval) | ||
74 | return retval; | ||
75 | xhci_dbg(xhci, "Reset complete\n"); | ||
76 | |||
77 | xhci_dbg(xhci, "Calling HCD init\n"); | ||
78 | /* Initialize HCD and host controller data structures. */ | ||
79 | retval = xhci_init(hcd); | ||
80 | if (retval) | ||
81 | return retval; | ||
82 | xhci_dbg(xhci, "Called HCD init\n"); | ||
83 | |||
84 | pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn); | ||
85 | xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn); | ||
86 | |||
87 | /* Find any debug ports */ | ||
88 | return xhci_pci_reinit(xhci, pdev); | ||
89 | } | ||
90 | |||
91 | static const struct hc_driver xhci_pci_hc_driver = { | ||
92 | .description = hcd_name, | ||
93 | .product_desc = "xHCI Host Controller", | ||
94 | .hcd_priv_size = sizeof(struct xhci_hcd), | ||
95 | |||
96 | /* | ||
97 | * generic hardware linkage | ||
98 | */ | ||
99 | .irq = xhci_irq, | ||
100 | .flags = HCD_MEMORY | HCD_USB3, | ||
101 | |||
102 | /* | ||
103 | * basic lifecycle operations | ||
104 | */ | ||
105 | .reset = xhci_pci_setup, | ||
106 | .start = xhci_run, | ||
107 | /* suspend and resume implemented later */ | ||
108 | .stop = xhci_stop, | ||
109 | .shutdown = xhci_shutdown, | ||
110 | |||
111 | /* | ||
112 | * managing i/o requests and associated device resources | ||
113 | */ | ||
114 | .urb_enqueue = xhci_urb_enqueue, | ||
115 | .urb_dequeue = xhci_urb_dequeue, | ||
116 | .alloc_dev = xhci_alloc_dev, | ||
117 | .free_dev = xhci_free_dev, | ||
118 | .add_endpoint = xhci_add_endpoint, | ||
119 | .drop_endpoint = xhci_drop_endpoint, | ||
120 | .check_bandwidth = xhci_check_bandwidth, | ||
121 | .reset_bandwidth = xhci_reset_bandwidth, | ||
122 | .address_device = xhci_address_device, | ||
123 | |||
124 | /* | ||
125 | * scheduling support | ||
126 | */ | ||
127 | .get_frame_number = xhci_get_frame, | ||
128 | |||
129 | /* Root hub support */ | ||
130 | .hub_control = xhci_hub_control, | ||
131 | .hub_status_data = xhci_hub_status_data, | ||
132 | }; | ||
133 | |||
134 | /*-------------------------------------------------------------------------*/ | ||
135 | |||
136 | /* PCI driver selection metadata; PCI hotplugging uses this */ | ||
137 | static const struct pci_device_id pci_ids[] = { { | ||
138 | /* handle any USB 3.0 xHCI controller */ | ||
139 | PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_XHCI, ~0), | ||
140 | .driver_data = (unsigned long) &xhci_pci_hc_driver, | ||
141 | }, | ||
142 | { /* end: all zeroes */ } | ||
143 | }; | ||
144 | MODULE_DEVICE_TABLE(pci, pci_ids); | ||
145 | |||
146 | /* pci driver glue; this is a "new style" PCI driver module */ | ||
147 | static struct pci_driver xhci_pci_driver = { | ||
148 | .name = (char *) hcd_name, | ||
149 | .id_table = pci_ids, | ||
150 | |||
151 | .probe = usb_hcd_pci_probe, | ||
152 | .remove = usb_hcd_pci_remove, | ||
153 | /* suspend and resume implemented later */ | ||
154 | |||
155 | .shutdown = usb_hcd_pci_shutdown, | ||
156 | }; | ||
157 | |||
158 | int xhci_register_pci() | ||
159 | { | ||
160 | return pci_register_driver(&xhci_pci_driver); | ||
161 | } | ||
162 | |||
163 | void xhci_unregister_pci() | ||
164 | { | ||
165 | pci_unregister_driver(&xhci_pci_driver); | ||
166 | } | ||
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c new file mode 100644 index 000000000000..02d81985c454 --- /dev/null +++ b/drivers/usb/host/xhci-ring.c | |||
@@ -0,0 +1,1648 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | /* | ||
24 | * Ring initialization rules: | ||
25 | * 1. Each segment is initialized to zero, except for link TRBs. | ||
26 | * 2. Ring cycle state = 0. This represents Producer Cycle State (PCS) or | ||
27 | * Consumer Cycle State (CCS), depending on ring function. | ||
28 | * 3. Enqueue pointer = dequeue pointer = address of first TRB in the segment. | ||
29 | * | ||
30 | * Ring behavior rules: | ||
31 | * 1. A ring is empty if enqueue == dequeue. This means there will always be at | ||
32 | * least one free TRB in the ring. This is useful if you want to turn that | ||
33 | * into a link TRB and expand the ring. | ||
34 | * 2. When incrementing an enqueue or dequeue pointer, if the next TRB is a | ||
35 | * link TRB, then load the pointer with the address in the link TRB. If the | ||
36 | * link TRB had its toggle bit set, you may need to update the ring cycle | ||
37 | * state (see cycle bit rules). You may have to do this multiple times | ||
38 | * until you reach a non-link TRB. | ||
39 | * 3. A ring is full if enqueue++ (for the definition of increment above) | ||
40 | * equals the dequeue pointer. | ||
41 | * | ||
42 | * Cycle bit rules: | ||
43 | * 1. When a consumer increments a dequeue pointer and encounters a toggle bit | ||
44 | * in a link TRB, it must toggle the ring cycle state. | ||
45 | * 2. When a producer increments an enqueue pointer and encounters a toggle bit | ||
46 | * in a link TRB, it must toggle the ring cycle state. | ||
47 | * | ||
48 | * Producer rules: | ||
49 | * 1. Check if ring is full before you enqueue. | ||
50 | * 2. Write the ring cycle state to the cycle bit in the TRB you're enqueuing. | ||
51 | * Update enqueue pointer between each write (which may update the ring | ||
52 | * cycle state). | ||
53 | * 3. Notify consumer. If SW is producer, it rings the doorbell for command | ||
54 | * and endpoint rings. If HC is the producer for the event ring, | ||
55 | * and it generates an interrupt according to interrupt modulation rules. | ||
56 | * | ||
57 | * Consumer rules: | ||
58 | * 1. Check if TRB belongs to you. If the cycle bit == your ring cycle state, | ||
59 | * the TRB is owned by the consumer. | ||
60 | * 2. Update dequeue pointer (which may update the ring cycle state) and | ||
61 | * continue processing TRBs until you reach a TRB which is not owned by you. | ||
62 | * 3. Notify the producer. SW is the consumer for the event ring, and it | ||
63 | * updates event ring dequeue pointer. HC is the consumer for the command and | ||
64 | * endpoint rings; it generates events on the event ring for these. | ||
65 | */ | ||
66 | |||
67 | #include <linux/scatterlist.h> | ||
68 | #include "xhci.h" | ||
69 | |||
70 | /* | ||
71 | * Returns zero if the TRB isn't in this segment, otherwise it returns the DMA | ||
72 | * address of the TRB. | ||
73 | */ | ||
74 | dma_addr_t xhci_trb_virt_to_dma(struct xhci_segment *seg, | ||
75 | union xhci_trb *trb) | ||
76 | { | ||
77 | unsigned long segment_offset; | ||
78 | |||
79 | if (!seg || !trb || trb < seg->trbs) | ||
80 | return 0; | ||
81 | /* offset in TRBs */ | ||
82 | segment_offset = trb - seg->trbs; | ||
83 | if (segment_offset > TRBS_PER_SEGMENT) | ||
84 | return 0; | ||
85 | return seg->dma + (segment_offset * sizeof(*trb)); | ||
86 | } | ||
87 | |||
88 | /* Does this link TRB point to the first segment in a ring, | ||
89 | * or was the previous TRB the last TRB on the last segment in the ERST? | ||
90 | */ | ||
91 | static inline bool last_trb_on_last_seg(struct xhci_hcd *xhci, struct xhci_ring *ring, | ||
92 | struct xhci_segment *seg, union xhci_trb *trb) | ||
93 | { | ||
94 | if (ring == xhci->event_ring) | ||
95 | return (trb == &seg->trbs[TRBS_PER_SEGMENT]) && | ||
96 | (seg->next == xhci->event_ring->first_seg); | ||
97 | else | ||
98 | return trb->link.control & LINK_TOGGLE; | ||
99 | } | ||
100 | |||
101 | /* Is this TRB a link TRB or was the last TRB the last TRB in this event ring | ||
102 | * segment? I.e. would the updated event TRB pointer step off the end of the | ||
103 | * event seg? | ||
104 | */ | ||
105 | static inline int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring, | ||
106 | struct xhci_segment *seg, union xhci_trb *trb) | ||
107 | { | ||
108 | if (ring == xhci->event_ring) | ||
109 | return trb == &seg->trbs[TRBS_PER_SEGMENT]; | ||
110 | else | ||
111 | return (trb->link.control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK); | ||
112 | } | ||
113 | |||
114 | /* Updates trb to point to the next TRB in the ring, and updates seg if the next | ||
115 | * TRB is in a new segment. This does not skip over link TRBs, and it does not | ||
116 | * effect the ring dequeue or enqueue pointers. | ||
117 | */ | ||
118 | static void next_trb(struct xhci_hcd *xhci, | ||
119 | struct xhci_ring *ring, | ||
120 | struct xhci_segment **seg, | ||
121 | union xhci_trb **trb) | ||
122 | { | ||
123 | if (last_trb(xhci, ring, *seg, *trb)) { | ||
124 | *seg = (*seg)->next; | ||
125 | *trb = ((*seg)->trbs); | ||
126 | } else { | ||
127 | *trb = (*trb)++; | ||
128 | } | ||
129 | } | ||
130 | |||
131 | /* | ||
132 | * See Cycle bit rules. SW is the consumer for the event ring only. | ||
133 | * Don't make a ring full of link TRBs. That would be dumb and this would loop. | ||
134 | */ | ||
135 | static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer) | ||
136 | { | ||
137 | union xhci_trb *next = ++(ring->dequeue); | ||
138 | |||
139 | ring->deq_updates++; | ||
140 | /* Update the dequeue pointer further if that was a link TRB or we're at | ||
141 | * the end of an event ring segment (which doesn't have link TRBS) | ||
142 | */ | ||
143 | while (last_trb(xhci, ring, ring->deq_seg, next)) { | ||
144 | if (consumer && last_trb_on_last_seg(xhci, ring, ring->deq_seg, next)) { | ||
145 | ring->cycle_state = (ring->cycle_state ? 0 : 1); | ||
146 | if (!in_interrupt()) | ||
147 | xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n", | ||
148 | ring, | ||
149 | (unsigned int) ring->cycle_state); | ||
150 | } | ||
151 | ring->deq_seg = ring->deq_seg->next; | ||
152 | ring->dequeue = ring->deq_seg->trbs; | ||
153 | next = ring->dequeue; | ||
154 | } | ||
155 | } | ||
156 | |||
157 | /* | ||
158 | * See Cycle bit rules. SW is the consumer for the event ring only. | ||
159 | * Don't make a ring full of link TRBs. That would be dumb and this would loop. | ||
160 | * | ||
161 | * If we've just enqueued a TRB that is in the middle of a TD (meaning the | ||
162 | * chain bit is set), then set the chain bit in all the following link TRBs. | ||
163 | * If we've enqueued the last TRB in a TD, make sure the following link TRBs | ||
164 | * have their chain bit cleared (so that each Link TRB is a separate TD). | ||
165 | * | ||
166 | * Section 6.4.4.1 of the 0.95 spec says link TRBs cannot have the chain bit | ||
167 | * set, but other sections talk about dealing with the chain bit set. | ||
168 | * Assume section 6.4.4.1 is wrong, and the chain bit can be set in a Link TRB. | ||
169 | */ | ||
170 | static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer) | ||
171 | { | ||
172 | u32 chain; | ||
173 | union xhci_trb *next; | ||
174 | |||
175 | chain = ring->enqueue->generic.field[3] & TRB_CHAIN; | ||
176 | next = ++(ring->enqueue); | ||
177 | |||
178 | ring->enq_updates++; | ||
179 | /* Update the dequeue pointer further if that was a link TRB or we're at | ||
180 | * the end of an event ring segment (which doesn't have link TRBS) | ||
181 | */ | ||
182 | while (last_trb(xhci, ring, ring->enq_seg, next)) { | ||
183 | if (!consumer) { | ||
184 | if (ring != xhci->event_ring) { | ||
185 | next->link.control &= ~TRB_CHAIN; | ||
186 | next->link.control |= chain; | ||
187 | /* Give this link TRB to the hardware */ | ||
188 | wmb(); | ||
189 | if (next->link.control & TRB_CYCLE) | ||
190 | next->link.control &= (u32) ~TRB_CYCLE; | ||
191 | else | ||
192 | next->link.control |= (u32) TRB_CYCLE; | ||
193 | } | ||
194 | /* Toggle the cycle bit after the last ring segment. */ | ||
195 | if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) { | ||
196 | ring->cycle_state = (ring->cycle_state ? 0 : 1); | ||
197 | if (!in_interrupt()) | ||
198 | xhci_dbg(xhci, "Toggle cycle state for ring %p = %i\n", | ||
199 | ring, | ||
200 | (unsigned int) ring->cycle_state); | ||
201 | } | ||
202 | } | ||
203 | ring->enq_seg = ring->enq_seg->next; | ||
204 | ring->enqueue = ring->enq_seg->trbs; | ||
205 | next = ring->enqueue; | ||
206 | } | ||
207 | } | ||
208 | |||
209 | /* | ||
210 | * Check to see if there's room to enqueue num_trbs on the ring. See rules | ||
211 | * above. | ||
212 | * FIXME: this would be simpler and faster if we just kept track of the number | ||
213 | * of free TRBs in a ring. | ||
214 | */ | ||
215 | static int room_on_ring(struct xhci_hcd *xhci, struct xhci_ring *ring, | ||
216 | unsigned int num_trbs) | ||
217 | { | ||
218 | int i; | ||
219 | union xhci_trb *enq = ring->enqueue; | ||
220 | struct xhci_segment *enq_seg = ring->enq_seg; | ||
221 | |||
222 | /* Check if ring is empty */ | ||
223 | if (enq == ring->dequeue) | ||
224 | return 1; | ||
225 | /* Make sure there's an extra empty TRB available */ | ||
226 | for (i = 0; i <= num_trbs; ++i) { | ||
227 | if (enq == ring->dequeue) | ||
228 | return 0; | ||
229 | enq++; | ||
230 | while (last_trb(xhci, ring, enq_seg, enq)) { | ||
231 | enq_seg = enq_seg->next; | ||
232 | enq = enq_seg->trbs; | ||
233 | } | ||
234 | } | ||
235 | return 1; | ||
236 | } | ||
237 | |||
238 | void xhci_set_hc_event_deq(struct xhci_hcd *xhci) | ||
239 | { | ||
240 | u32 temp; | ||
241 | dma_addr_t deq; | ||
242 | |||
243 | deq = xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, | ||
244 | xhci->event_ring->dequeue); | ||
245 | if (deq == 0 && !in_interrupt()) | ||
246 | xhci_warn(xhci, "WARN something wrong with SW event ring " | ||
247 | "dequeue ptr.\n"); | ||
248 | /* Update HC event ring dequeue pointer */ | ||
249 | temp = xhci_readl(xhci, &xhci->ir_set->erst_dequeue[0]); | ||
250 | temp &= ERST_PTR_MASK; | ||
251 | if (!in_interrupt()) | ||
252 | xhci_dbg(xhci, "// Write event ring dequeue pointer\n"); | ||
253 | xhci_writel(xhci, 0, &xhci->ir_set->erst_dequeue[1]); | ||
254 | xhci_writel(xhci, (deq & ~ERST_PTR_MASK) | temp, | ||
255 | &xhci->ir_set->erst_dequeue[0]); | ||
256 | } | ||
257 | |||
258 | /* Ring the host controller doorbell after placing a command on the ring */ | ||
259 | void xhci_ring_cmd_db(struct xhci_hcd *xhci) | ||
260 | { | ||
261 | u32 temp; | ||
262 | |||
263 | xhci_dbg(xhci, "// Ding dong!\n"); | ||
264 | temp = xhci_readl(xhci, &xhci->dba->doorbell[0]) & DB_MASK; | ||
265 | xhci_writel(xhci, temp | DB_TARGET_HOST, &xhci->dba->doorbell[0]); | ||
266 | /* Flush PCI posted writes */ | ||
267 | xhci_readl(xhci, &xhci->dba->doorbell[0]); | ||
268 | } | ||
269 | |||
270 | static void ring_ep_doorbell(struct xhci_hcd *xhci, | ||
271 | unsigned int slot_id, | ||
272 | unsigned int ep_index) | ||
273 | { | ||
274 | struct xhci_ring *ep_ring; | ||
275 | u32 field; | ||
276 | __u32 __iomem *db_addr = &xhci->dba->doorbell[slot_id]; | ||
277 | |||
278 | ep_ring = xhci->devs[slot_id]->ep_rings[ep_index]; | ||
279 | /* Don't ring the doorbell for this endpoint if there are pending | ||
280 | * cancellations because the we don't want to interrupt processing. | ||
281 | */ | ||
282 | if (!ep_ring->cancels_pending && !(ep_ring->state & SET_DEQ_PENDING)) { | ||
283 | field = xhci_readl(xhci, db_addr) & DB_MASK; | ||
284 | xhci_writel(xhci, field | EPI_TO_DB(ep_index), db_addr); | ||
285 | /* Flush PCI posted writes - FIXME Matthew Wilcox says this | ||
286 | * isn't time-critical and we shouldn't make the CPU wait for | ||
287 | * the flush. | ||
288 | */ | ||
289 | xhci_readl(xhci, db_addr); | ||
290 | } | ||
291 | } | ||
292 | |||
293 | /* | ||
294 | * Find the segment that trb is in. Start searching in start_seg. | ||
295 | * If we must move past a segment that has a link TRB with a toggle cycle state | ||
296 | * bit set, then we will toggle the value pointed at by cycle_state. | ||
297 | */ | ||
298 | static struct xhci_segment *find_trb_seg( | ||
299 | struct xhci_segment *start_seg, | ||
300 | union xhci_trb *trb, int *cycle_state) | ||
301 | { | ||
302 | struct xhci_segment *cur_seg = start_seg; | ||
303 | struct xhci_generic_trb *generic_trb; | ||
304 | |||
305 | while (cur_seg->trbs > trb || | ||
306 | &cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) { | ||
307 | generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic; | ||
308 | if (TRB_TYPE(generic_trb->field[3]) == TRB_LINK && | ||
309 | (generic_trb->field[3] & LINK_TOGGLE)) | ||
310 | *cycle_state = ~(*cycle_state) & 0x1; | ||
311 | cur_seg = cur_seg->next; | ||
312 | if (cur_seg == start_seg) | ||
313 | /* Looped over the entire list. Oops! */ | ||
314 | return 0; | ||
315 | } | ||
316 | return cur_seg; | ||
317 | } | ||
318 | |||
319 | struct dequeue_state { | ||
320 | struct xhci_segment *new_deq_seg; | ||
321 | union xhci_trb *new_deq_ptr; | ||
322 | int new_cycle_state; | ||
323 | }; | ||
324 | |||
325 | /* | ||
326 | * Move the xHC's endpoint ring dequeue pointer past cur_td. | ||
327 | * Record the new state of the xHC's endpoint ring dequeue segment, | ||
328 | * dequeue pointer, and new consumer cycle state in state. | ||
329 | * Update our internal representation of the ring's dequeue pointer. | ||
330 | * | ||
331 | * We do this in three jumps: | ||
332 | * - First we update our new ring state to be the same as when the xHC stopped. | ||
333 | * - Then we traverse the ring to find the segment that contains | ||
334 | * the last TRB in the TD. We toggle the xHC's new cycle state when we pass | ||
335 | * any link TRBs with the toggle cycle bit set. | ||
336 | * - Finally we move the dequeue state one TRB further, toggling the cycle bit | ||
337 | * if we've moved it past a link TRB with the toggle cycle bit set. | ||
338 | */ | ||
339 | static void find_new_dequeue_state(struct xhci_hcd *xhci, | ||
340 | unsigned int slot_id, unsigned int ep_index, | ||
341 | struct xhci_td *cur_td, struct dequeue_state *state) | ||
342 | { | ||
343 | struct xhci_virt_device *dev = xhci->devs[slot_id]; | ||
344 | struct xhci_ring *ep_ring = dev->ep_rings[ep_index]; | ||
345 | struct xhci_generic_trb *trb; | ||
346 | |||
347 | state->new_cycle_state = 0; | ||
348 | state->new_deq_seg = find_trb_seg(cur_td->start_seg, | ||
349 | ep_ring->stopped_trb, | ||
350 | &state->new_cycle_state); | ||
351 | if (!state->new_deq_seg) | ||
352 | BUG(); | ||
353 | /* Dig out the cycle state saved by the xHC during the stop ep cmd */ | ||
354 | state->new_cycle_state = 0x1 & dev->out_ctx->ep[ep_index].deq[0]; | ||
355 | |||
356 | state->new_deq_ptr = cur_td->last_trb; | ||
357 | state->new_deq_seg = find_trb_seg(state->new_deq_seg, | ||
358 | state->new_deq_ptr, | ||
359 | &state->new_cycle_state); | ||
360 | if (!state->new_deq_seg) | ||
361 | BUG(); | ||
362 | |||
363 | trb = &state->new_deq_ptr->generic; | ||
364 | if (TRB_TYPE(trb->field[3]) == TRB_LINK && | ||
365 | (trb->field[3] & LINK_TOGGLE)) | ||
366 | state->new_cycle_state = ~(state->new_cycle_state) & 0x1; | ||
367 | next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr); | ||
368 | |||
369 | /* Don't update the ring cycle state for the producer (us). */ | ||
370 | ep_ring->dequeue = state->new_deq_ptr; | ||
371 | ep_ring->deq_seg = state->new_deq_seg; | ||
372 | } | ||
373 | |||
374 | static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring, | ||
375 | struct xhci_td *cur_td) | ||
376 | { | ||
377 | struct xhci_segment *cur_seg; | ||
378 | union xhci_trb *cur_trb; | ||
379 | |||
380 | for (cur_seg = cur_td->start_seg, cur_trb = cur_td->first_trb; | ||
381 | true; | ||
382 | next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) { | ||
383 | if ((cur_trb->generic.field[3] & TRB_TYPE_BITMASK) == | ||
384 | TRB_TYPE(TRB_LINK)) { | ||
385 | /* Unchain any chained Link TRBs, but | ||
386 | * leave the pointers intact. | ||
387 | */ | ||
388 | cur_trb->generic.field[3] &= ~TRB_CHAIN; | ||
389 | xhci_dbg(xhci, "Cancel (unchain) link TRB\n"); | ||
390 | xhci_dbg(xhci, "Address = %p (0x%llx dma); " | ||
391 | "in seg %p (0x%llx dma)\n", | ||
392 | cur_trb, | ||
393 | (unsigned long long)xhci_trb_virt_to_dma(cur_seg, cur_trb), | ||
394 | cur_seg, | ||
395 | (unsigned long long)cur_seg->dma); | ||
396 | } else { | ||
397 | cur_trb->generic.field[0] = 0; | ||
398 | cur_trb->generic.field[1] = 0; | ||
399 | cur_trb->generic.field[2] = 0; | ||
400 | /* Preserve only the cycle bit of this TRB */ | ||
401 | cur_trb->generic.field[3] &= TRB_CYCLE; | ||
402 | cur_trb->generic.field[3] |= TRB_TYPE(TRB_TR_NOOP); | ||
403 | xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) " | ||
404 | "in seg %p (0x%llx dma)\n", | ||
405 | cur_trb, | ||
406 | (unsigned long long)xhci_trb_virt_to_dma(cur_seg, cur_trb), | ||
407 | cur_seg, | ||
408 | (unsigned long long)cur_seg->dma); | ||
409 | } | ||
410 | if (cur_trb == cur_td->last_trb) | ||
411 | break; | ||
412 | } | ||
413 | } | ||
414 | |||
415 | static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id, | ||
416 | unsigned int ep_index, struct xhci_segment *deq_seg, | ||
417 | union xhci_trb *deq_ptr, u32 cycle_state); | ||
418 | |||
419 | /* | ||
420 | * When we get a command completion for a Stop Endpoint Command, we need to | ||
421 | * unlink any cancelled TDs from the ring. There are two ways to do that: | ||
422 | * | ||
423 | * 1. If the HW was in the middle of processing the TD that needs to be | ||
424 | * cancelled, then we must move the ring's dequeue pointer past the last TRB | ||
425 | * in the TD with a Set Dequeue Pointer Command. | ||
426 | * 2. Otherwise, we turn all the TRBs in the TD into No-op TRBs (with the chain | ||
427 | * bit cleared) so that the HW will skip over them. | ||
428 | */ | ||
429 | static void handle_stopped_endpoint(struct xhci_hcd *xhci, | ||
430 | union xhci_trb *trb) | ||
431 | { | ||
432 | unsigned int slot_id; | ||
433 | unsigned int ep_index; | ||
434 | struct xhci_ring *ep_ring; | ||
435 | struct list_head *entry; | ||
436 | struct xhci_td *cur_td = 0; | ||
437 | struct xhci_td *last_unlinked_td; | ||
438 | |||
439 | struct dequeue_state deq_state; | ||
440 | #ifdef CONFIG_USB_HCD_STAT | ||
441 | ktime_t stop_time = ktime_get(); | ||
442 | #endif | ||
443 | |||
444 | memset(&deq_state, 0, sizeof(deq_state)); | ||
445 | slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]); | ||
446 | ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]); | ||
447 | ep_ring = xhci->devs[slot_id]->ep_rings[ep_index]; | ||
448 | |||
449 | if (list_empty(&ep_ring->cancelled_td_list)) | ||
450 | return; | ||
451 | |||
452 | /* Fix up the ep ring first, so HW stops executing cancelled TDs. | ||
453 | * We have the xHCI lock, so nothing can modify this list until we drop | ||
454 | * it. We're also in the event handler, so we can't get re-interrupted | ||
455 | * if another Stop Endpoint command completes | ||
456 | */ | ||
457 | list_for_each(entry, &ep_ring->cancelled_td_list) { | ||
458 | cur_td = list_entry(entry, struct xhci_td, cancelled_td_list); | ||
459 | xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n", | ||
460 | cur_td->first_trb, | ||
461 | (unsigned long long)xhci_trb_virt_to_dma(cur_td->start_seg, cur_td->first_trb)); | ||
462 | /* | ||
463 | * If we stopped on the TD we need to cancel, then we have to | ||
464 | * move the xHC endpoint ring dequeue pointer past this TD. | ||
465 | */ | ||
466 | if (cur_td == ep_ring->stopped_td) | ||
467 | find_new_dequeue_state(xhci, slot_id, ep_index, cur_td, | ||
468 | &deq_state); | ||
469 | else | ||
470 | td_to_noop(xhci, ep_ring, cur_td); | ||
471 | /* | ||
472 | * The event handler won't see a completion for this TD anymore, | ||
473 | * so remove it from the endpoint ring's TD list. Keep it in | ||
474 | * the cancelled TD list for URB completion later. | ||
475 | */ | ||
476 | list_del(&cur_td->td_list); | ||
477 | ep_ring->cancels_pending--; | ||
478 | } | ||
479 | last_unlinked_td = cur_td; | ||
480 | |||
481 | /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */ | ||
482 | if (deq_state.new_deq_ptr && deq_state.new_deq_seg) { | ||
483 | xhci_dbg(xhci, "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), " | ||
484 | "new deq ptr = %p (0x%llx dma), new cycle = %u\n", | ||
485 | deq_state.new_deq_seg, | ||
486 | (unsigned long long)deq_state.new_deq_seg->dma, | ||
487 | deq_state.new_deq_ptr, | ||
488 | (unsigned long long)xhci_trb_virt_to_dma(deq_state.new_deq_seg, deq_state.new_deq_ptr), | ||
489 | deq_state.new_cycle_state); | ||
490 | queue_set_tr_deq(xhci, slot_id, ep_index, | ||
491 | deq_state.new_deq_seg, | ||
492 | deq_state.new_deq_ptr, | ||
493 | (u32) deq_state.new_cycle_state); | ||
494 | /* Stop the TD queueing code from ringing the doorbell until | ||
495 | * this command completes. The HC won't set the dequeue pointer | ||
496 | * if the ring is running, and ringing the doorbell starts the | ||
497 | * ring running. | ||
498 | */ | ||
499 | ep_ring->state |= SET_DEQ_PENDING; | ||
500 | xhci_ring_cmd_db(xhci); | ||
501 | } else { | ||
502 | /* Otherwise just ring the doorbell to restart the ring */ | ||
503 | ring_ep_doorbell(xhci, slot_id, ep_index); | ||
504 | } | ||
505 | |||
506 | /* | ||
507 | * Drop the lock and complete the URBs in the cancelled TD list. | ||
508 | * New TDs to be cancelled might be added to the end of the list before | ||
509 | * we can complete all the URBs for the TDs we already unlinked. | ||
510 | * So stop when we've completed the URB for the last TD we unlinked. | ||
511 | */ | ||
512 | do { | ||
513 | cur_td = list_entry(ep_ring->cancelled_td_list.next, | ||
514 | struct xhci_td, cancelled_td_list); | ||
515 | list_del(&cur_td->cancelled_td_list); | ||
516 | |||
517 | /* Clean up the cancelled URB */ | ||
518 | #ifdef CONFIG_USB_HCD_STAT | ||
519 | hcd_stat_update(xhci->tp_stat, cur_td->urb->actual_length, | ||
520 | ktime_sub(stop_time, cur_td->start_time)); | ||
521 | #endif | ||
522 | cur_td->urb->hcpriv = NULL; | ||
523 | usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), cur_td->urb); | ||
524 | |||
525 | xhci_dbg(xhci, "Giveback cancelled URB %p\n", cur_td->urb); | ||
526 | spin_unlock(&xhci->lock); | ||
527 | /* Doesn't matter what we pass for status, since the core will | ||
528 | * just overwrite it (because the URB has been unlinked). | ||
529 | */ | ||
530 | usb_hcd_giveback_urb(xhci_to_hcd(xhci), cur_td->urb, 0); | ||
531 | kfree(cur_td); | ||
532 | |||
533 | spin_lock(&xhci->lock); | ||
534 | } while (cur_td != last_unlinked_td); | ||
535 | |||
536 | /* Return to the event handler with xhci->lock re-acquired */ | ||
537 | } | ||
538 | |||
539 | /* | ||
540 | * When we get a completion for a Set Transfer Ring Dequeue Pointer command, | ||
541 | * we need to clear the set deq pending flag in the endpoint ring state, so that | ||
542 | * the TD queueing code can ring the doorbell again. We also need to ring the | ||
543 | * endpoint doorbell to restart the ring, but only if there aren't more | ||
544 | * cancellations pending. | ||
545 | */ | ||
546 | static void handle_set_deq_completion(struct xhci_hcd *xhci, | ||
547 | struct xhci_event_cmd *event, | ||
548 | union xhci_trb *trb) | ||
549 | { | ||
550 | unsigned int slot_id; | ||
551 | unsigned int ep_index; | ||
552 | struct xhci_ring *ep_ring; | ||
553 | struct xhci_virt_device *dev; | ||
554 | |||
555 | slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]); | ||
556 | ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]); | ||
557 | dev = xhci->devs[slot_id]; | ||
558 | ep_ring = dev->ep_rings[ep_index]; | ||
559 | |||
560 | if (GET_COMP_CODE(event->status) != COMP_SUCCESS) { | ||
561 | unsigned int ep_state; | ||
562 | unsigned int slot_state; | ||
563 | |||
564 | switch (GET_COMP_CODE(event->status)) { | ||
565 | case COMP_TRB_ERR: | ||
566 | xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because " | ||
567 | "of stream ID configuration\n"); | ||
568 | break; | ||
569 | case COMP_CTX_STATE: | ||
570 | xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed due " | ||
571 | "to incorrect slot or ep state.\n"); | ||
572 | ep_state = dev->out_ctx->ep[ep_index].ep_info; | ||
573 | ep_state &= EP_STATE_MASK; | ||
574 | slot_state = dev->out_ctx->slot.dev_state; | ||
575 | slot_state = GET_SLOT_STATE(slot_state); | ||
576 | xhci_dbg(xhci, "Slot state = %u, EP state = %u\n", | ||
577 | slot_state, ep_state); | ||
578 | break; | ||
579 | case COMP_EBADSLT: | ||
580 | xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed because " | ||
581 | "slot %u was not enabled.\n", slot_id); | ||
582 | break; | ||
583 | default: | ||
584 | xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown " | ||
585 | "completion code of %u.\n", | ||
586 | GET_COMP_CODE(event->status)); | ||
587 | break; | ||
588 | } | ||
589 | /* OK what do we do now? The endpoint state is hosed, and we | ||
590 | * should never get to this point if the synchronization between | ||
591 | * queueing, and endpoint state are correct. This might happen | ||
592 | * if the device gets disconnected after we've finished | ||
593 | * cancelling URBs, which might not be an error... | ||
594 | */ | ||
595 | } else { | ||
596 | xhci_dbg(xhci, "Successful Set TR Deq Ptr cmd, deq[0] = 0x%x, " | ||
597 | "deq[1] = 0x%x.\n", | ||
598 | dev->out_ctx->ep[ep_index].deq[0], | ||
599 | dev->out_ctx->ep[ep_index].deq[1]); | ||
600 | } | ||
601 | |||
602 | ep_ring->state &= ~SET_DEQ_PENDING; | ||
603 | ring_ep_doorbell(xhci, slot_id, ep_index); | ||
604 | } | ||
605 | |||
606 | |||
607 | static void handle_cmd_completion(struct xhci_hcd *xhci, | ||
608 | struct xhci_event_cmd *event) | ||
609 | { | ||
610 | int slot_id = TRB_TO_SLOT_ID(event->flags); | ||
611 | u64 cmd_dma; | ||
612 | dma_addr_t cmd_dequeue_dma; | ||
613 | |||
614 | cmd_dma = (((u64) event->cmd_trb[1]) << 32) + event->cmd_trb[0]; | ||
615 | cmd_dequeue_dma = xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg, | ||
616 | xhci->cmd_ring->dequeue); | ||
617 | /* Is the command ring deq ptr out of sync with the deq seg ptr? */ | ||
618 | if (cmd_dequeue_dma == 0) { | ||
619 | xhci->error_bitmask |= 1 << 4; | ||
620 | return; | ||
621 | } | ||
622 | /* Does the DMA address match our internal dequeue pointer address? */ | ||
623 | if (cmd_dma != (u64) cmd_dequeue_dma) { | ||
624 | xhci->error_bitmask |= 1 << 5; | ||
625 | return; | ||
626 | } | ||
627 | switch (xhci->cmd_ring->dequeue->generic.field[3] & TRB_TYPE_BITMASK) { | ||
628 | case TRB_TYPE(TRB_ENABLE_SLOT): | ||
629 | if (GET_COMP_CODE(event->status) == COMP_SUCCESS) | ||
630 | xhci->slot_id = slot_id; | ||
631 | else | ||
632 | xhci->slot_id = 0; | ||
633 | complete(&xhci->addr_dev); | ||
634 | break; | ||
635 | case TRB_TYPE(TRB_DISABLE_SLOT): | ||
636 | if (xhci->devs[slot_id]) | ||
637 | xhci_free_virt_device(xhci, slot_id); | ||
638 | break; | ||
639 | case TRB_TYPE(TRB_CONFIG_EP): | ||
640 | xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status); | ||
641 | complete(&xhci->devs[slot_id]->cmd_completion); | ||
642 | break; | ||
643 | case TRB_TYPE(TRB_ADDR_DEV): | ||
644 | xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status); | ||
645 | complete(&xhci->addr_dev); | ||
646 | break; | ||
647 | case TRB_TYPE(TRB_STOP_RING): | ||
648 | handle_stopped_endpoint(xhci, xhci->cmd_ring->dequeue); | ||
649 | break; | ||
650 | case TRB_TYPE(TRB_SET_DEQ): | ||
651 | handle_set_deq_completion(xhci, event, xhci->cmd_ring->dequeue); | ||
652 | break; | ||
653 | case TRB_TYPE(TRB_CMD_NOOP): | ||
654 | ++xhci->noops_handled; | ||
655 | break; | ||
656 | default: | ||
657 | /* Skip over unknown commands on the event ring */ | ||
658 | xhci->error_bitmask |= 1 << 6; | ||
659 | break; | ||
660 | } | ||
661 | inc_deq(xhci, xhci->cmd_ring, false); | ||
662 | } | ||
663 | |||
664 | static void handle_port_status(struct xhci_hcd *xhci, | ||
665 | union xhci_trb *event) | ||
666 | { | ||
667 | u32 port_id; | ||
668 | |||
669 | /* Port status change events always have a successful completion code */ | ||
670 | if (GET_COMP_CODE(event->generic.field[2]) != COMP_SUCCESS) { | ||
671 | xhci_warn(xhci, "WARN: xHC returned failed port status event\n"); | ||
672 | xhci->error_bitmask |= 1 << 8; | ||
673 | } | ||
674 | /* FIXME: core doesn't care about all port link state changes yet */ | ||
675 | port_id = GET_PORT_ID(event->generic.field[0]); | ||
676 | xhci_dbg(xhci, "Port Status Change Event for port %d\n", port_id); | ||
677 | |||
678 | /* Update event ring dequeue pointer before dropping the lock */ | ||
679 | inc_deq(xhci, xhci->event_ring, true); | ||
680 | xhci_set_hc_event_deq(xhci); | ||
681 | |||
682 | spin_unlock(&xhci->lock); | ||
683 | /* Pass this up to the core */ | ||
684 | usb_hcd_poll_rh_status(xhci_to_hcd(xhci)); | ||
685 | spin_lock(&xhci->lock); | ||
686 | } | ||
687 | |||
688 | /* | ||
689 | * This TD is defined by the TRBs starting at start_trb in start_seg and ending | ||
690 | * at end_trb, which may be in another segment. If the suspect DMA address is a | ||
691 | * TRB in this TD, this function returns that TRB's segment. Otherwise it | ||
692 | * returns 0. | ||
693 | */ | ||
694 | static struct xhci_segment *trb_in_td( | ||
695 | struct xhci_segment *start_seg, | ||
696 | union xhci_trb *start_trb, | ||
697 | union xhci_trb *end_trb, | ||
698 | dma_addr_t suspect_dma) | ||
699 | { | ||
700 | dma_addr_t start_dma; | ||
701 | dma_addr_t end_seg_dma; | ||
702 | dma_addr_t end_trb_dma; | ||
703 | struct xhci_segment *cur_seg; | ||
704 | |||
705 | start_dma = xhci_trb_virt_to_dma(start_seg, start_trb); | ||
706 | cur_seg = start_seg; | ||
707 | |||
708 | do { | ||
709 | /* We may get an event for a Link TRB in the middle of a TD */ | ||
710 | end_seg_dma = xhci_trb_virt_to_dma(cur_seg, | ||
711 | &start_seg->trbs[TRBS_PER_SEGMENT - 1]); | ||
712 | /* If the end TRB isn't in this segment, this is set to 0 */ | ||
713 | end_trb_dma = xhci_trb_virt_to_dma(cur_seg, end_trb); | ||
714 | |||
715 | if (end_trb_dma > 0) { | ||
716 | /* The end TRB is in this segment, so suspect should be here */ | ||
717 | if (start_dma <= end_trb_dma) { | ||
718 | if (suspect_dma >= start_dma && suspect_dma <= end_trb_dma) | ||
719 | return cur_seg; | ||
720 | } else { | ||
721 | /* Case for one segment with | ||
722 | * a TD wrapped around to the top | ||
723 | */ | ||
724 | if ((suspect_dma >= start_dma && | ||
725 | suspect_dma <= end_seg_dma) || | ||
726 | (suspect_dma >= cur_seg->dma && | ||
727 | suspect_dma <= end_trb_dma)) | ||
728 | return cur_seg; | ||
729 | } | ||
730 | return 0; | ||
731 | } else { | ||
732 | /* Might still be somewhere in this segment */ | ||
733 | if (suspect_dma >= start_dma && suspect_dma <= end_seg_dma) | ||
734 | return cur_seg; | ||
735 | } | ||
736 | cur_seg = cur_seg->next; | ||
737 | start_dma = xhci_trb_virt_to_dma(cur_seg, &cur_seg->trbs[0]); | ||
738 | } while (1); | ||
739 | |||
740 | } | ||
741 | |||
742 | /* | ||
743 | * If this function returns an error condition, it means it got a Transfer | ||
744 | * event with a corrupted Slot ID, Endpoint ID, or TRB DMA address. | ||
745 | * At this point, the host controller is probably hosed and should be reset. | ||
746 | */ | ||
747 | static int handle_tx_event(struct xhci_hcd *xhci, | ||
748 | struct xhci_transfer_event *event) | ||
749 | { | ||
750 | struct xhci_virt_device *xdev; | ||
751 | struct xhci_ring *ep_ring; | ||
752 | int ep_index; | ||
753 | struct xhci_td *td = 0; | ||
754 | dma_addr_t event_dma; | ||
755 | struct xhci_segment *event_seg; | ||
756 | union xhci_trb *event_trb; | ||
757 | struct urb *urb = 0; | ||
758 | int status = -EINPROGRESS; | ||
759 | |||
760 | xdev = xhci->devs[TRB_TO_SLOT_ID(event->flags)]; | ||
761 | if (!xdev) { | ||
762 | xhci_err(xhci, "ERROR Transfer event pointed to bad slot\n"); | ||
763 | return -ENODEV; | ||
764 | } | ||
765 | |||
766 | /* Endpoint ID is 1 based, our index is zero based */ | ||
767 | ep_index = TRB_TO_EP_ID(event->flags) - 1; | ||
768 | ep_ring = xdev->ep_rings[ep_index]; | ||
769 | if (!ep_ring || (xdev->out_ctx->ep[ep_index].ep_info & EP_STATE_MASK) == EP_STATE_DISABLED) { | ||
770 | xhci_err(xhci, "ERROR Transfer event pointed to disabled endpoint\n"); | ||
771 | return -ENODEV; | ||
772 | } | ||
773 | |||
774 | event_dma = event->buffer[0]; | ||
775 | if (event->buffer[1] != 0) | ||
776 | xhci_warn(xhci, "WARN ignoring upper 32-bits of 64-bit TRB dma address\n"); | ||
777 | |||
778 | /* This TRB should be in the TD at the head of this ring's TD list */ | ||
779 | if (list_empty(&ep_ring->td_list)) { | ||
780 | xhci_warn(xhci, "WARN Event TRB for slot %d ep %d with no TDs queued?\n", | ||
781 | TRB_TO_SLOT_ID(event->flags), ep_index); | ||
782 | xhci_dbg(xhci, "Event TRB with TRB type ID %u\n", | ||
783 | (unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10); | ||
784 | xhci_print_trb_offsets(xhci, (union xhci_trb *) event); | ||
785 | urb = NULL; | ||
786 | goto cleanup; | ||
787 | } | ||
788 | td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list); | ||
789 | |||
790 | /* Is this a TRB in the currently executing TD? */ | ||
791 | event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue, | ||
792 | td->last_trb, event_dma); | ||
793 | if (!event_seg) { | ||
794 | /* HC is busted, give up! */ | ||
795 | xhci_err(xhci, "ERROR Transfer event TRB DMA ptr not part of current TD\n"); | ||
796 | return -ESHUTDOWN; | ||
797 | } | ||
798 | event_trb = &event_seg->trbs[(event_dma - event_seg->dma) / sizeof(*event_trb)]; | ||
799 | xhci_dbg(xhci, "Event TRB with TRB type ID %u\n", | ||
800 | (unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10); | ||
801 | xhci_dbg(xhci, "Offset 0x00 (buffer[0]) = 0x%x\n", | ||
802 | (unsigned int) event->buffer[0]); | ||
803 | xhci_dbg(xhci, "Offset 0x04 (buffer[0]) = 0x%x\n", | ||
804 | (unsigned int) event->buffer[1]); | ||
805 | xhci_dbg(xhci, "Offset 0x08 (transfer length) = 0x%x\n", | ||
806 | (unsigned int) event->transfer_len); | ||
807 | xhci_dbg(xhci, "Offset 0x0C (flags) = 0x%x\n", | ||
808 | (unsigned int) event->flags); | ||
809 | |||
810 | /* Look for common error cases */ | ||
811 | switch (GET_COMP_CODE(event->transfer_len)) { | ||
812 | /* Skip codes that require special handling depending on | ||
813 | * transfer type | ||
814 | */ | ||
815 | case COMP_SUCCESS: | ||
816 | case COMP_SHORT_TX: | ||
817 | break; | ||
818 | case COMP_STOP: | ||
819 | xhci_dbg(xhci, "Stopped on Transfer TRB\n"); | ||
820 | break; | ||
821 | case COMP_STOP_INVAL: | ||
822 | xhci_dbg(xhci, "Stopped on No-op or Link TRB\n"); | ||
823 | break; | ||
824 | case COMP_STALL: | ||
825 | xhci_warn(xhci, "WARN: Stalled endpoint\n"); | ||
826 | status = -EPIPE; | ||
827 | break; | ||
828 | case COMP_TRB_ERR: | ||
829 | xhci_warn(xhci, "WARN: TRB error on endpoint\n"); | ||
830 | status = -EILSEQ; | ||
831 | break; | ||
832 | case COMP_TX_ERR: | ||
833 | xhci_warn(xhci, "WARN: transfer error on endpoint\n"); | ||
834 | status = -EPROTO; | ||
835 | break; | ||
836 | case COMP_DB_ERR: | ||
837 | xhci_warn(xhci, "WARN: HC couldn't access mem fast enough\n"); | ||
838 | status = -ENOSR; | ||
839 | break; | ||
840 | default: | ||
841 | xhci_warn(xhci, "ERROR Unknown event condition, HC probably busted\n"); | ||
842 | urb = NULL; | ||
843 | goto cleanup; | ||
844 | } | ||
845 | /* Now update the urb's actual_length and give back to the core */ | ||
846 | /* Was this a control transfer? */ | ||
847 | if (usb_endpoint_xfer_control(&td->urb->ep->desc)) { | ||
848 | xhci_debug_trb(xhci, xhci->event_ring->dequeue); | ||
849 | switch (GET_COMP_CODE(event->transfer_len)) { | ||
850 | case COMP_SUCCESS: | ||
851 | if (event_trb == ep_ring->dequeue) { | ||
852 | xhci_warn(xhci, "WARN: Success on ctrl setup TRB without IOC set??\n"); | ||
853 | status = -ESHUTDOWN; | ||
854 | } else if (event_trb != td->last_trb) { | ||
855 | xhci_warn(xhci, "WARN: Success on ctrl data TRB without IOC set??\n"); | ||
856 | status = -ESHUTDOWN; | ||
857 | } else { | ||
858 | xhci_dbg(xhci, "Successful control transfer!\n"); | ||
859 | status = 0; | ||
860 | } | ||
861 | break; | ||
862 | case COMP_SHORT_TX: | ||
863 | xhci_warn(xhci, "WARN: short transfer on control ep\n"); | ||
864 | status = -EREMOTEIO; | ||
865 | break; | ||
866 | default: | ||
867 | /* Others already handled above */ | ||
868 | break; | ||
869 | } | ||
870 | /* | ||
871 | * Did we transfer any data, despite the errors that might have | ||
872 | * happened? I.e. did we get past the setup stage? | ||
873 | */ | ||
874 | if (event_trb != ep_ring->dequeue) { | ||
875 | /* The event was for the status stage */ | ||
876 | if (event_trb == td->last_trb) { | ||
877 | td->urb->actual_length = | ||
878 | td->urb->transfer_buffer_length; | ||
879 | } else { | ||
880 | /* Maybe the event was for the data stage? */ | ||
881 | if (GET_COMP_CODE(event->transfer_len) != COMP_STOP_INVAL) | ||
882 | /* We didn't stop on a link TRB in the middle */ | ||
883 | td->urb->actual_length = | ||
884 | td->urb->transfer_buffer_length - | ||
885 | TRB_LEN(event->transfer_len); | ||
886 | } | ||
887 | } | ||
888 | } else { | ||
889 | switch (GET_COMP_CODE(event->transfer_len)) { | ||
890 | case COMP_SUCCESS: | ||
891 | /* Double check that the HW transferred everything. */ | ||
892 | if (event_trb != td->last_trb) { | ||
893 | xhci_warn(xhci, "WARN Successful completion " | ||
894 | "on short TX\n"); | ||
895 | if (td->urb->transfer_flags & URB_SHORT_NOT_OK) | ||
896 | status = -EREMOTEIO; | ||
897 | else | ||
898 | status = 0; | ||
899 | } else { | ||
900 | xhci_dbg(xhci, "Successful bulk transfer!\n"); | ||
901 | status = 0; | ||
902 | } | ||
903 | break; | ||
904 | case COMP_SHORT_TX: | ||
905 | if (td->urb->transfer_flags & URB_SHORT_NOT_OK) | ||
906 | status = -EREMOTEIO; | ||
907 | else | ||
908 | status = 0; | ||
909 | break; | ||
910 | default: | ||
911 | /* Others already handled above */ | ||
912 | break; | ||
913 | } | ||
914 | dev_dbg(&td->urb->dev->dev, | ||
915 | "ep %#x - asked for %d bytes, " | ||
916 | "%d bytes untransferred\n", | ||
917 | td->urb->ep->desc.bEndpointAddress, | ||
918 | td->urb->transfer_buffer_length, | ||
919 | TRB_LEN(event->transfer_len)); | ||
920 | /* Fast path - was this the last TRB in the TD for this URB? */ | ||
921 | if (event_trb == td->last_trb) { | ||
922 | if (TRB_LEN(event->transfer_len) != 0) { | ||
923 | td->urb->actual_length = | ||
924 | td->urb->transfer_buffer_length - | ||
925 | TRB_LEN(event->transfer_len); | ||
926 | if (td->urb->actual_length < 0) { | ||
927 | xhci_warn(xhci, "HC gave bad length " | ||
928 | "of %d bytes left\n", | ||
929 | TRB_LEN(event->transfer_len)); | ||
930 | td->urb->actual_length = 0; | ||
931 | } | ||
932 | if (td->urb->transfer_flags & URB_SHORT_NOT_OK) | ||
933 | status = -EREMOTEIO; | ||
934 | else | ||
935 | status = 0; | ||
936 | } else { | ||
937 | td->urb->actual_length = td->urb->transfer_buffer_length; | ||
938 | /* Ignore a short packet completion if the | ||
939 | * untransferred length was zero. | ||
940 | */ | ||
941 | status = 0; | ||
942 | } | ||
943 | } else { | ||
944 | /* Slow path - walk the list, starting from the dequeue | ||
945 | * pointer, to get the actual length transferred. | ||
946 | */ | ||
947 | union xhci_trb *cur_trb; | ||
948 | struct xhci_segment *cur_seg; | ||
949 | |||
950 | td->urb->actual_length = 0; | ||
951 | for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg; | ||
952 | cur_trb != event_trb; | ||
953 | next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) { | ||
954 | if (TRB_TYPE(cur_trb->generic.field[3]) != TRB_TR_NOOP && | ||
955 | TRB_TYPE(cur_trb->generic.field[3]) != TRB_LINK) | ||
956 | td->urb->actual_length += | ||
957 | TRB_LEN(cur_trb->generic.field[2]); | ||
958 | } | ||
959 | /* If the ring didn't stop on a Link or No-op TRB, add | ||
960 | * in the actual bytes transferred from the Normal TRB | ||
961 | */ | ||
962 | if (GET_COMP_CODE(event->transfer_len) != COMP_STOP_INVAL) | ||
963 | td->urb->actual_length += | ||
964 | TRB_LEN(cur_trb->generic.field[2]) - | ||
965 | TRB_LEN(event->transfer_len); | ||
966 | } | ||
967 | } | ||
968 | /* The Endpoint Stop Command completion will take care of | ||
969 | * any stopped TDs. A stopped TD may be restarted, so don't update the | ||
970 | * ring dequeue pointer or take this TD off any lists yet. | ||
971 | */ | ||
972 | if (GET_COMP_CODE(event->transfer_len) == COMP_STOP_INVAL || | ||
973 | GET_COMP_CODE(event->transfer_len) == COMP_STOP) { | ||
974 | ep_ring->stopped_td = td; | ||
975 | ep_ring->stopped_trb = event_trb; | ||
976 | } else { | ||
977 | /* Update ring dequeue pointer */ | ||
978 | while (ep_ring->dequeue != td->last_trb) | ||
979 | inc_deq(xhci, ep_ring, false); | ||
980 | inc_deq(xhci, ep_ring, false); | ||
981 | |||
982 | /* Clean up the endpoint's TD list */ | ||
983 | urb = td->urb; | ||
984 | list_del(&td->td_list); | ||
985 | /* Was this TD slated to be cancelled but completed anyway? */ | ||
986 | if (!list_empty(&td->cancelled_td_list)) { | ||
987 | list_del(&td->cancelled_td_list); | ||
988 | ep_ring->cancels_pending--; | ||
989 | } | ||
990 | kfree(td); | ||
991 | urb->hcpriv = NULL; | ||
992 | } | ||
993 | cleanup: | ||
994 | inc_deq(xhci, xhci->event_ring, true); | ||
995 | xhci_set_hc_event_deq(xhci); | ||
996 | |||
997 | /* FIXME for multi-TD URBs (who have buffers bigger than 64MB) */ | ||
998 | if (urb) { | ||
999 | usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), urb); | ||
1000 | spin_unlock(&xhci->lock); | ||
1001 | usb_hcd_giveback_urb(xhci_to_hcd(xhci), urb, status); | ||
1002 | spin_lock(&xhci->lock); | ||
1003 | } | ||
1004 | return 0; | ||
1005 | } | ||
1006 | |||
1007 | /* | ||
1008 | * This function handles all OS-owned events on the event ring. It may drop | ||
1009 | * xhci->lock between event processing (e.g. to pass up port status changes). | ||
1010 | */ | ||
1011 | void xhci_handle_event(struct xhci_hcd *xhci) | ||
1012 | { | ||
1013 | union xhci_trb *event; | ||
1014 | int update_ptrs = 1; | ||
1015 | int ret; | ||
1016 | |||
1017 | if (!xhci->event_ring || !xhci->event_ring->dequeue) { | ||
1018 | xhci->error_bitmask |= 1 << 1; | ||
1019 | return; | ||
1020 | } | ||
1021 | |||
1022 | event = xhci->event_ring->dequeue; | ||
1023 | /* Does the HC or OS own the TRB? */ | ||
1024 | if ((event->event_cmd.flags & TRB_CYCLE) != | ||
1025 | xhci->event_ring->cycle_state) { | ||
1026 | xhci->error_bitmask |= 1 << 2; | ||
1027 | return; | ||
1028 | } | ||
1029 | |||
1030 | /* FIXME: Handle more event types. */ | ||
1031 | switch ((event->event_cmd.flags & TRB_TYPE_BITMASK)) { | ||
1032 | case TRB_TYPE(TRB_COMPLETION): | ||
1033 | handle_cmd_completion(xhci, &event->event_cmd); | ||
1034 | break; | ||
1035 | case TRB_TYPE(TRB_PORT_STATUS): | ||
1036 | handle_port_status(xhci, event); | ||
1037 | update_ptrs = 0; | ||
1038 | break; | ||
1039 | case TRB_TYPE(TRB_TRANSFER): | ||
1040 | ret = handle_tx_event(xhci, &event->trans_event); | ||
1041 | if (ret < 0) | ||
1042 | xhci->error_bitmask |= 1 << 9; | ||
1043 | else | ||
1044 | update_ptrs = 0; | ||
1045 | break; | ||
1046 | default: | ||
1047 | xhci->error_bitmask |= 1 << 3; | ||
1048 | } | ||
1049 | |||
1050 | if (update_ptrs) { | ||
1051 | /* Update SW and HC event ring dequeue pointer */ | ||
1052 | inc_deq(xhci, xhci->event_ring, true); | ||
1053 | xhci_set_hc_event_deq(xhci); | ||
1054 | } | ||
1055 | /* Are there more items on the event ring? */ | ||
1056 | xhci_handle_event(xhci); | ||
1057 | } | ||
1058 | |||
1059 | /**** Endpoint Ring Operations ****/ | ||
1060 | |||
1061 | /* | ||
1062 | * Generic function for queueing a TRB on a ring. | ||
1063 | * The caller must have checked to make sure there's room on the ring. | ||
1064 | */ | ||
1065 | static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring, | ||
1066 | bool consumer, | ||
1067 | u32 field1, u32 field2, u32 field3, u32 field4) | ||
1068 | { | ||
1069 | struct xhci_generic_trb *trb; | ||
1070 | |||
1071 | trb = &ring->enqueue->generic; | ||
1072 | trb->field[0] = field1; | ||
1073 | trb->field[1] = field2; | ||
1074 | trb->field[2] = field3; | ||
1075 | trb->field[3] = field4; | ||
1076 | inc_enq(xhci, ring, consumer); | ||
1077 | } | ||
1078 | |||
1079 | /* | ||
1080 | * Does various checks on the endpoint ring, and makes it ready to queue num_trbs. | ||
1081 | * FIXME allocate segments if the ring is full. | ||
1082 | */ | ||
1083 | static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring, | ||
1084 | u32 ep_state, unsigned int num_trbs, gfp_t mem_flags) | ||
1085 | { | ||
1086 | /* Make sure the endpoint has been added to xHC schedule */ | ||
1087 | xhci_dbg(xhci, "Endpoint state = 0x%x\n", ep_state); | ||
1088 | switch (ep_state) { | ||
1089 | case EP_STATE_DISABLED: | ||
1090 | /* | ||
1091 | * USB core changed config/interfaces without notifying us, | ||
1092 | * or hardware is reporting the wrong state. | ||
1093 | */ | ||
1094 | xhci_warn(xhci, "WARN urb submitted to disabled ep\n"); | ||
1095 | return -ENOENT; | ||
1096 | case EP_STATE_HALTED: | ||
1097 | case EP_STATE_ERROR: | ||
1098 | xhci_warn(xhci, "WARN waiting for halt or error on ep " | ||
1099 | "to be cleared\n"); | ||
1100 | /* FIXME event handling code for error needs to clear it */ | ||
1101 | /* XXX not sure if this should be -ENOENT or not */ | ||
1102 | return -EINVAL; | ||
1103 | case EP_STATE_STOPPED: | ||
1104 | case EP_STATE_RUNNING: | ||
1105 | break; | ||
1106 | default: | ||
1107 | xhci_err(xhci, "ERROR unknown endpoint state for ep\n"); | ||
1108 | /* | ||
1109 | * FIXME issue Configure Endpoint command to try to get the HC | ||
1110 | * back into a known state. | ||
1111 | */ | ||
1112 | return -EINVAL; | ||
1113 | } | ||
1114 | if (!room_on_ring(xhci, ep_ring, num_trbs)) { | ||
1115 | /* FIXME allocate more room */ | ||
1116 | xhci_err(xhci, "ERROR no room on ep ring\n"); | ||
1117 | return -ENOMEM; | ||
1118 | } | ||
1119 | return 0; | ||
1120 | } | ||
1121 | |||
1122 | static int prepare_transfer(struct xhci_hcd *xhci, | ||
1123 | struct xhci_virt_device *xdev, | ||
1124 | unsigned int ep_index, | ||
1125 | unsigned int num_trbs, | ||
1126 | struct urb *urb, | ||
1127 | struct xhci_td **td, | ||
1128 | gfp_t mem_flags) | ||
1129 | { | ||
1130 | int ret; | ||
1131 | |||
1132 | ret = prepare_ring(xhci, xdev->ep_rings[ep_index], | ||
1133 | xdev->out_ctx->ep[ep_index].ep_info & EP_STATE_MASK, | ||
1134 | num_trbs, mem_flags); | ||
1135 | if (ret) | ||
1136 | return ret; | ||
1137 | *td = kzalloc(sizeof(struct xhci_td), mem_flags); | ||
1138 | if (!*td) | ||
1139 | return -ENOMEM; | ||
1140 | INIT_LIST_HEAD(&(*td)->td_list); | ||
1141 | INIT_LIST_HEAD(&(*td)->cancelled_td_list); | ||
1142 | |||
1143 | ret = usb_hcd_link_urb_to_ep(xhci_to_hcd(xhci), urb); | ||
1144 | if (unlikely(ret)) { | ||
1145 | kfree(*td); | ||
1146 | return ret; | ||
1147 | } | ||
1148 | |||
1149 | (*td)->urb = urb; | ||
1150 | urb->hcpriv = (void *) (*td); | ||
1151 | /* Add this TD to the tail of the endpoint ring's TD list */ | ||
1152 | list_add_tail(&(*td)->td_list, &xdev->ep_rings[ep_index]->td_list); | ||
1153 | (*td)->start_seg = xdev->ep_rings[ep_index]->enq_seg; | ||
1154 | (*td)->first_trb = xdev->ep_rings[ep_index]->enqueue; | ||
1155 | |||
1156 | return 0; | ||
1157 | } | ||
1158 | |||
1159 | static unsigned int count_sg_trbs_needed(struct xhci_hcd *xhci, struct urb *urb) | ||
1160 | { | ||
1161 | int num_sgs, num_trbs, running_total, temp, i; | ||
1162 | struct scatterlist *sg; | ||
1163 | |||
1164 | sg = NULL; | ||
1165 | num_sgs = urb->num_sgs; | ||
1166 | temp = urb->transfer_buffer_length; | ||
1167 | |||
1168 | xhci_dbg(xhci, "count sg list trbs: \n"); | ||
1169 | num_trbs = 0; | ||
1170 | for_each_sg(urb->sg->sg, sg, num_sgs, i) { | ||
1171 | unsigned int previous_total_trbs = num_trbs; | ||
1172 | unsigned int len = sg_dma_len(sg); | ||
1173 | |||
1174 | /* Scatter gather list entries may cross 64KB boundaries */ | ||
1175 | running_total = TRB_MAX_BUFF_SIZE - | ||
1176 | (sg_dma_address(sg) & ((1 << TRB_MAX_BUFF_SHIFT) - 1)); | ||
1177 | if (running_total != 0) | ||
1178 | num_trbs++; | ||
1179 | |||
1180 | /* How many more 64KB chunks to transfer, how many more TRBs? */ | ||
1181 | while (running_total < sg_dma_len(sg)) { | ||
1182 | num_trbs++; | ||
1183 | running_total += TRB_MAX_BUFF_SIZE; | ||
1184 | } | ||
1185 | xhci_dbg(xhci, " sg #%d: dma = %#llx, len = %#x (%d), num_trbs = %d\n", | ||
1186 | i, (unsigned long long)sg_dma_address(sg), | ||
1187 | len, len, num_trbs - previous_total_trbs); | ||
1188 | |||
1189 | len = min_t(int, len, temp); | ||
1190 | temp -= len; | ||
1191 | if (temp == 0) | ||
1192 | break; | ||
1193 | } | ||
1194 | xhci_dbg(xhci, "\n"); | ||
1195 | if (!in_interrupt()) | ||
1196 | dev_dbg(&urb->dev->dev, "ep %#x - urb len = %d, sglist used, num_trbs = %d\n", | ||
1197 | urb->ep->desc.bEndpointAddress, | ||
1198 | urb->transfer_buffer_length, | ||
1199 | num_trbs); | ||
1200 | return num_trbs; | ||
1201 | } | ||
1202 | |||
1203 | static void check_trb_math(struct urb *urb, int num_trbs, int running_total) | ||
1204 | { | ||
1205 | if (num_trbs != 0) | ||
1206 | dev_dbg(&urb->dev->dev, "%s - ep %#x - Miscalculated number of " | ||
1207 | "TRBs, %d left\n", __func__, | ||
1208 | urb->ep->desc.bEndpointAddress, num_trbs); | ||
1209 | if (running_total != urb->transfer_buffer_length) | ||
1210 | dev_dbg(&urb->dev->dev, "%s - ep %#x - Miscalculated tx length, " | ||
1211 | "queued %#x (%d), asked for %#x (%d)\n", | ||
1212 | __func__, | ||
1213 | urb->ep->desc.bEndpointAddress, | ||
1214 | running_total, running_total, | ||
1215 | urb->transfer_buffer_length, | ||
1216 | urb->transfer_buffer_length); | ||
1217 | } | ||
1218 | |||
1219 | static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id, | ||
1220 | unsigned int ep_index, int start_cycle, | ||
1221 | struct xhci_generic_trb *start_trb, struct xhci_td *td) | ||
1222 | { | ||
1223 | /* | ||
1224 | * Pass all the TRBs to the hardware at once and make sure this write | ||
1225 | * isn't reordered. | ||
1226 | */ | ||
1227 | wmb(); | ||
1228 | start_trb->field[3] |= start_cycle; | ||
1229 | ring_ep_doorbell(xhci, slot_id, ep_index); | ||
1230 | } | ||
1231 | |||
1232 | static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags, | ||
1233 | struct urb *urb, int slot_id, unsigned int ep_index) | ||
1234 | { | ||
1235 | struct xhci_ring *ep_ring; | ||
1236 | unsigned int num_trbs; | ||
1237 | struct xhci_td *td; | ||
1238 | struct scatterlist *sg; | ||
1239 | int num_sgs; | ||
1240 | int trb_buff_len, this_sg_len, running_total; | ||
1241 | bool first_trb; | ||
1242 | u64 addr; | ||
1243 | |||
1244 | struct xhci_generic_trb *start_trb; | ||
1245 | int start_cycle; | ||
1246 | |||
1247 | ep_ring = xhci->devs[slot_id]->ep_rings[ep_index]; | ||
1248 | num_trbs = count_sg_trbs_needed(xhci, urb); | ||
1249 | num_sgs = urb->num_sgs; | ||
1250 | |||
1251 | trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id], | ||
1252 | ep_index, num_trbs, urb, &td, mem_flags); | ||
1253 | if (trb_buff_len < 0) | ||
1254 | return trb_buff_len; | ||
1255 | /* | ||
1256 | * Don't give the first TRB to the hardware (by toggling the cycle bit) | ||
1257 | * until we've finished creating all the other TRBs. The ring's cycle | ||
1258 | * state may change as we enqueue the other TRBs, so save it too. | ||
1259 | */ | ||
1260 | start_trb = &ep_ring->enqueue->generic; | ||
1261 | start_cycle = ep_ring->cycle_state; | ||
1262 | |||
1263 | running_total = 0; | ||
1264 | /* | ||
1265 | * How much data is in the first TRB? | ||
1266 | * | ||
1267 | * There are three forces at work for TRB buffer pointers and lengths: | ||
1268 | * 1. We don't want to walk off the end of this sg-list entry buffer. | ||
1269 | * 2. The transfer length that the driver requested may be smaller than | ||
1270 | * the amount of memory allocated for this scatter-gather list. | ||
1271 | * 3. TRBs buffers can't cross 64KB boundaries. | ||
1272 | */ | ||
1273 | sg = urb->sg->sg; | ||
1274 | addr = (u64) sg_dma_address(sg); | ||
1275 | this_sg_len = sg_dma_len(sg); | ||
1276 | trb_buff_len = TRB_MAX_BUFF_SIZE - | ||
1277 | (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1)); | ||
1278 | trb_buff_len = min_t(int, trb_buff_len, this_sg_len); | ||
1279 | if (trb_buff_len > urb->transfer_buffer_length) | ||
1280 | trb_buff_len = urb->transfer_buffer_length; | ||
1281 | xhci_dbg(xhci, "First length to xfer from 1st sglist entry = %u\n", | ||
1282 | trb_buff_len); | ||
1283 | |||
1284 | first_trb = true; | ||
1285 | /* Queue the first TRB, even if it's zero-length */ | ||
1286 | do { | ||
1287 | u32 field = 0; | ||
1288 | |||
1289 | /* Don't change the cycle bit of the first TRB until later */ | ||
1290 | if (first_trb) | ||
1291 | first_trb = false; | ||
1292 | else | ||
1293 | field |= ep_ring->cycle_state; | ||
1294 | |||
1295 | /* Chain all the TRBs together; clear the chain bit in the last | ||
1296 | * TRB to indicate it's the last TRB in the chain. | ||
1297 | */ | ||
1298 | if (num_trbs > 1) { | ||
1299 | field |= TRB_CHAIN; | ||
1300 | } else { | ||
1301 | /* FIXME - add check for ZERO_PACKET flag before this */ | ||
1302 | td->last_trb = ep_ring->enqueue; | ||
1303 | field |= TRB_IOC; | ||
1304 | } | ||
1305 | xhci_dbg(xhci, " sg entry: dma = %#x, len = %#x (%d), " | ||
1306 | "64KB boundary at %#x, end dma = %#x\n", | ||
1307 | (unsigned int) addr, trb_buff_len, trb_buff_len, | ||
1308 | (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1), | ||
1309 | (unsigned int) addr + trb_buff_len); | ||
1310 | if (TRB_MAX_BUFF_SIZE - | ||
1311 | (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1)) < trb_buff_len) { | ||
1312 | xhci_warn(xhci, "WARN: sg dma xfer crosses 64KB boundaries!\n"); | ||
1313 | xhci_dbg(xhci, "Next boundary at %#x, end dma = %#x\n", | ||
1314 | (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1), | ||
1315 | (unsigned int) addr + trb_buff_len); | ||
1316 | } | ||
1317 | queue_trb(xhci, ep_ring, false, | ||
1318 | (u32) addr, | ||
1319 | (u32) ((u64) addr >> 32), | ||
1320 | TRB_LEN(trb_buff_len) | TRB_INTR_TARGET(0), | ||
1321 | /* We always want to know if the TRB was short, | ||
1322 | * or we won't get an event when it completes. | ||
1323 | * (Unless we use event data TRBs, which are a | ||
1324 | * waste of space and HC resources.) | ||
1325 | */ | ||
1326 | field | TRB_ISP | TRB_TYPE(TRB_NORMAL)); | ||
1327 | --num_trbs; | ||
1328 | running_total += trb_buff_len; | ||
1329 | |||
1330 | /* Calculate length for next transfer -- | ||
1331 | * Are we done queueing all the TRBs for this sg entry? | ||
1332 | */ | ||
1333 | this_sg_len -= trb_buff_len; | ||
1334 | if (this_sg_len == 0) { | ||
1335 | --num_sgs; | ||
1336 | if (num_sgs == 0) | ||
1337 | break; | ||
1338 | sg = sg_next(sg); | ||
1339 | addr = (u64) sg_dma_address(sg); | ||
1340 | this_sg_len = sg_dma_len(sg); | ||
1341 | } else { | ||
1342 | addr += trb_buff_len; | ||
1343 | } | ||
1344 | |||
1345 | trb_buff_len = TRB_MAX_BUFF_SIZE - | ||
1346 | (addr & ((1 << TRB_MAX_BUFF_SHIFT) - 1)); | ||
1347 | trb_buff_len = min_t(int, trb_buff_len, this_sg_len); | ||
1348 | if (running_total + trb_buff_len > urb->transfer_buffer_length) | ||
1349 | trb_buff_len = | ||
1350 | urb->transfer_buffer_length - running_total; | ||
1351 | } while (running_total < urb->transfer_buffer_length); | ||
1352 | |||
1353 | check_trb_math(urb, num_trbs, running_total); | ||
1354 | giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td); | ||
1355 | return 0; | ||
1356 | } | ||
1357 | |||
1358 | /* This is very similar to what ehci-q.c qtd_fill() does */ | ||
1359 | int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, | ||
1360 | struct urb *urb, int slot_id, unsigned int ep_index) | ||
1361 | { | ||
1362 | struct xhci_ring *ep_ring; | ||
1363 | struct xhci_td *td; | ||
1364 | int num_trbs; | ||
1365 | struct xhci_generic_trb *start_trb; | ||
1366 | bool first_trb; | ||
1367 | int start_cycle; | ||
1368 | u32 field; | ||
1369 | |||
1370 | int running_total, trb_buff_len, ret; | ||
1371 | u64 addr; | ||
1372 | |||
1373 | if (urb->sg) | ||
1374 | return queue_bulk_sg_tx(xhci, mem_flags, urb, slot_id, ep_index); | ||
1375 | |||
1376 | ep_ring = xhci->devs[slot_id]->ep_rings[ep_index]; | ||
1377 | |||
1378 | num_trbs = 0; | ||
1379 | /* How much data is (potentially) left before the 64KB boundary? */ | ||
1380 | running_total = TRB_MAX_BUFF_SIZE - | ||
1381 | (urb->transfer_dma & ((1 << TRB_MAX_BUFF_SHIFT) - 1)); | ||
1382 | |||
1383 | /* If there's some data on this 64KB chunk, or we have to send a | ||
1384 | * zero-length transfer, we need at least one TRB | ||
1385 | */ | ||
1386 | if (running_total != 0 || urb->transfer_buffer_length == 0) | ||
1387 | num_trbs++; | ||
1388 | /* How many more 64KB chunks to transfer, how many more TRBs? */ | ||
1389 | while (running_total < urb->transfer_buffer_length) { | ||
1390 | num_trbs++; | ||
1391 | running_total += TRB_MAX_BUFF_SIZE; | ||
1392 | } | ||
1393 | /* FIXME: this doesn't deal with URB_ZERO_PACKET - need one more */ | ||
1394 | |||
1395 | if (!in_interrupt()) | ||
1396 | dev_dbg(&urb->dev->dev, "ep %#x - urb len = %#x (%d), addr = %#llx, num_trbs = %d\n", | ||
1397 | urb->ep->desc.bEndpointAddress, | ||
1398 | urb->transfer_buffer_length, | ||
1399 | urb->transfer_buffer_length, | ||
1400 | (unsigned long long)urb->transfer_dma, | ||
1401 | num_trbs); | ||
1402 | |||
1403 | ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index, | ||
1404 | num_trbs, urb, &td, mem_flags); | ||
1405 | if (ret < 0) | ||
1406 | return ret; | ||
1407 | |||
1408 | /* | ||
1409 | * Don't give the first TRB to the hardware (by toggling the cycle bit) | ||
1410 | * until we've finished creating all the other TRBs. The ring's cycle | ||
1411 | * state may change as we enqueue the other TRBs, so save it too. | ||
1412 | */ | ||
1413 | start_trb = &ep_ring->enqueue->generic; | ||
1414 | start_cycle = ep_ring->cycle_state; | ||
1415 | |||
1416 | running_total = 0; | ||
1417 | /* How much data is in the first TRB? */ | ||
1418 | addr = (u64) urb->transfer_dma; | ||
1419 | trb_buff_len = TRB_MAX_BUFF_SIZE - | ||
1420 | (urb->transfer_dma & ((1 << TRB_MAX_BUFF_SHIFT) - 1)); | ||
1421 | if (urb->transfer_buffer_length < trb_buff_len) | ||
1422 | trb_buff_len = urb->transfer_buffer_length; | ||
1423 | |||
1424 | first_trb = true; | ||
1425 | |||
1426 | /* Queue the first TRB, even if it's zero-length */ | ||
1427 | do { | ||
1428 | field = 0; | ||
1429 | |||
1430 | /* Don't change the cycle bit of the first TRB until later */ | ||
1431 | if (first_trb) | ||
1432 | first_trb = false; | ||
1433 | else | ||
1434 | field |= ep_ring->cycle_state; | ||
1435 | |||
1436 | /* Chain all the TRBs together; clear the chain bit in the last | ||
1437 | * TRB to indicate it's the last TRB in the chain. | ||
1438 | */ | ||
1439 | if (num_trbs > 1) { | ||
1440 | field |= TRB_CHAIN; | ||
1441 | } else { | ||
1442 | /* FIXME - add check for ZERO_PACKET flag before this */ | ||
1443 | td->last_trb = ep_ring->enqueue; | ||
1444 | field |= TRB_IOC; | ||
1445 | } | ||
1446 | queue_trb(xhci, ep_ring, false, | ||
1447 | (u32) addr, | ||
1448 | (u32) ((u64) addr >> 32), | ||
1449 | TRB_LEN(trb_buff_len) | TRB_INTR_TARGET(0), | ||
1450 | /* We always want to know if the TRB was short, | ||
1451 | * or we won't get an event when it completes. | ||
1452 | * (Unless we use event data TRBs, which are a | ||
1453 | * waste of space and HC resources.) | ||
1454 | */ | ||
1455 | field | TRB_ISP | TRB_TYPE(TRB_NORMAL)); | ||
1456 | --num_trbs; | ||
1457 | running_total += trb_buff_len; | ||
1458 | |||
1459 | /* Calculate length for next transfer */ | ||
1460 | addr += trb_buff_len; | ||
1461 | trb_buff_len = urb->transfer_buffer_length - running_total; | ||
1462 | if (trb_buff_len > TRB_MAX_BUFF_SIZE) | ||
1463 | trb_buff_len = TRB_MAX_BUFF_SIZE; | ||
1464 | } while (running_total < urb->transfer_buffer_length); | ||
1465 | |||
1466 | check_trb_math(urb, num_trbs, running_total); | ||
1467 | giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td); | ||
1468 | return 0; | ||
1469 | } | ||
1470 | |||
1471 | /* Caller must have locked xhci->lock */ | ||
1472 | int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, | ||
1473 | struct urb *urb, int slot_id, unsigned int ep_index) | ||
1474 | { | ||
1475 | struct xhci_ring *ep_ring; | ||
1476 | int num_trbs; | ||
1477 | int ret; | ||
1478 | struct usb_ctrlrequest *setup; | ||
1479 | struct xhci_generic_trb *start_trb; | ||
1480 | int start_cycle; | ||
1481 | u32 field; | ||
1482 | struct xhci_td *td; | ||
1483 | |||
1484 | ep_ring = xhci->devs[slot_id]->ep_rings[ep_index]; | ||
1485 | |||
1486 | /* | ||
1487 | * Need to copy setup packet into setup TRB, so we can't use the setup | ||
1488 | * DMA address. | ||
1489 | */ | ||
1490 | if (!urb->setup_packet) | ||
1491 | return -EINVAL; | ||
1492 | |||
1493 | if (!in_interrupt()) | ||
1494 | xhci_dbg(xhci, "Queueing ctrl tx for slot id %d, ep %d\n", | ||
1495 | slot_id, ep_index); | ||
1496 | /* 1 TRB for setup, 1 for status */ | ||
1497 | num_trbs = 2; | ||
1498 | /* | ||
1499 | * Don't need to check if we need additional event data and normal TRBs, | ||
1500 | * since data in control transfers will never get bigger than 16MB | ||
1501 | * XXX: can we get a buffer that crosses 64KB boundaries? | ||
1502 | */ | ||
1503 | if (urb->transfer_buffer_length > 0) | ||
1504 | num_trbs++; | ||
1505 | ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index, num_trbs, | ||
1506 | urb, &td, mem_flags); | ||
1507 | if (ret < 0) | ||
1508 | return ret; | ||
1509 | |||
1510 | /* | ||
1511 | * Don't give the first TRB to the hardware (by toggling the cycle bit) | ||
1512 | * until we've finished creating all the other TRBs. The ring's cycle | ||
1513 | * state may change as we enqueue the other TRBs, so save it too. | ||
1514 | */ | ||
1515 | start_trb = &ep_ring->enqueue->generic; | ||
1516 | start_cycle = ep_ring->cycle_state; | ||
1517 | |||
1518 | /* Queue setup TRB - see section 6.4.1.2.1 */ | ||
1519 | /* FIXME better way to translate setup_packet into two u32 fields? */ | ||
1520 | setup = (struct usb_ctrlrequest *) urb->setup_packet; | ||
1521 | queue_trb(xhci, ep_ring, false, | ||
1522 | /* FIXME endianness is probably going to bite my ass here. */ | ||
1523 | setup->bRequestType | setup->bRequest << 8 | setup->wValue << 16, | ||
1524 | setup->wIndex | setup->wLength << 16, | ||
1525 | TRB_LEN(8) | TRB_INTR_TARGET(0), | ||
1526 | /* Immediate data in pointer */ | ||
1527 | TRB_IDT | TRB_TYPE(TRB_SETUP)); | ||
1528 | |||
1529 | /* If there's data, queue data TRBs */ | ||
1530 | field = 0; | ||
1531 | if (urb->transfer_buffer_length > 0) { | ||
1532 | if (setup->bRequestType & USB_DIR_IN) | ||
1533 | field |= TRB_DIR_IN; | ||
1534 | queue_trb(xhci, ep_ring, false, | ||
1535 | lower_32_bits(urb->transfer_dma), | ||
1536 | upper_32_bits(urb->transfer_dma), | ||
1537 | TRB_LEN(urb->transfer_buffer_length) | TRB_INTR_TARGET(0), | ||
1538 | /* Event on short tx */ | ||
1539 | field | TRB_ISP | TRB_TYPE(TRB_DATA) | ep_ring->cycle_state); | ||
1540 | } | ||
1541 | |||
1542 | /* Save the DMA address of the last TRB in the TD */ | ||
1543 | td->last_trb = ep_ring->enqueue; | ||
1544 | |||
1545 | /* Queue status TRB - see Table 7 and sections 4.11.2.2 and 6.4.1.2.3 */ | ||
1546 | /* If the device sent data, the status stage is an OUT transfer */ | ||
1547 | if (urb->transfer_buffer_length > 0 && setup->bRequestType & USB_DIR_IN) | ||
1548 | field = 0; | ||
1549 | else | ||
1550 | field = TRB_DIR_IN; | ||
1551 | queue_trb(xhci, ep_ring, false, | ||
1552 | 0, | ||
1553 | 0, | ||
1554 | TRB_INTR_TARGET(0), | ||
1555 | /* Event on completion */ | ||
1556 | field | TRB_IOC | TRB_TYPE(TRB_STATUS) | ep_ring->cycle_state); | ||
1557 | |||
1558 | giveback_first_trb(xhci, slot_id, ep_index, start_cycle, start_trb, td); | ||
1559 | return 0; | ||
1560 | } | ||
1561 | |||
1562 | /**** Command Ring Operations ****/ | ||
1563 | |||
1564 | /* Generic function for queueing a command TRB on the command ring */ | ||
1565 | static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2, u32 field3, u32 field4) | ||
1566 | { | ||
1567 | if (!room_on_ring(xhci, xhci->cmd_ring, 1)) { | ||
1568 | if (!in_interrupt()) | ||
1569 | xhci_err(xhci, "ERR: No room for command on command ring\n"); | ||
1570 | return -ENOMEM; | ||
1571 | } | ||
1572 | queue_trb(xhci, xhci->cmd_ring, false, field1, field2, field3, | ||
1573 | field4 | xhci->cmd_ring->cycle_state); | ||
1574 | return 0; | ||
1575 | } | ||
1576 | |||
1577 | /* Queue a no-op command on the command ring */ | ||
1578 | static int queue_cmd_noop(struct xhci_hcd *xhci) | ||
1579 | { | ||
1580 | return queue_command(xhci, 0, 0, 0, TRB_TYPE(TRB_CMD_NOOP)); | ||
1581 | } | ||
1582 | |||
1583 | /* | ||
1584 | * Place a no-op command on the command ring to test the command and | ||
1585 | * event ring. | ||
1586 | */ | ||
1587 | void *xhci_setup_one_noop(struct xhci_hcd *xhci) | ||
1588 | { | ||
1589 | if (queue_cmd_noop(xhci) < 0) | ||
1590 | return NULL; | ||
1591 | xhci->noops_submitted++; | ||
1592 | return xhci_ring_cmd_db; | ||
1593 | } | ||
1594 | |||
1595 | /* Queue a slot enable or disable request on the command ring */ | ||
1596 | int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id) | ||
1597 | { | ||
1598 | return queue_command(xhci, 0, 0, 0, | ||
1599 | TRB_TYPE(trb_type) | SLOT_ID_FOR_TRB(slot_id)); | ||
1600 | } | ||
1601 | |||
1602 | /* Queue an address device command TRB */ | ||
1603 | int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr, | ||
1604 | u32 slot_id) | ||
1605 | { | ||
1606 | return queue_command(xhci, in_ctx_ptr, 0, 0, | ||
1607 | TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id)); | ||
1608 | } | ||
1609 | |||
1610 | /* Queue a configure endpoint command TRB */ | ||
1611 | int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr, | ||
1612 | u32 slot_id) | ||
1613 | { | ||
1614 | return queue_command(xhci, in_ctx_ptr, 0, 0, | ||
1615 | TRB_TYPE(TRB_CONFIG_EP) | SLOT_ID_FOR_TRB(slot_id)); | ||
1616 | } | ||
1617 | |||
1618 | int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id, | ||
1619 | unsigned int ep_index) | ||
1620 | { | ||
1621 | u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id); | ||
1622 | u32 trb_ep_index = EP_ID_FOR_TRB(ep_index); | ||
1623 | u32 type = TRB_TYPE(TRB_STOP_RING); | ||
1624 | |||
1625 | return queue_command(xhci, 0, 0, 0, | ||
1626 | trb_slot_id | trb_ep_index | type); | ||
1627 | } | ||
1628 | |||
1629 | /* Set Transfer Ring Dequeue Pointer command. | ||
1630 | * This should not be used for endpoints that have streams enabled. | ||
1631 | */ | ||
1632 | static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id, | ||
1633 | unsigned int ep_index, struct xhci_segment *deq_seg, | ||
1634 | union xhci_trb *deq_ptr, u32 cycle_state) | ||
1635 | { | ||
1636 | dma_addr_t addr; | ||
1637 | u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id); | ||
1638 | u32 trb_ep_index = EP_ID_FOR_TRB(ep_index); | ||
1639 | u32 type = TRB_TYPE(TRB_SET_DEQ); | ||
1640 | |||
1641 | addr = xhci_trb_virt_to_dma(deq_seg, deq_ptr); | ||
1642 | if (addr == 0) | ||
1643 | xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr\n"); | ||
1644 | xhci_warn(xhci, "WARN deq seg = %p, deq pt = %p\n", | ||
1645 | deq_seg, deq_ptr); | ||
1646 | return queue_command(xhci, (u32) addr | cycle_state, 0, 0, | ||
1647 | trb_slot_id | trb_ep_index | type); | ||
1648 | } | ||
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h new file mode 100644 index 000000000000..8936eeb5588b --- /dev/null +++ b/drivers/usb/host/xhci.h | |||
@@ -0,0 +1,1157 @@ | |||
1 | /* | ||
2 | * xHCI host controller driver | ||
3 | * | ||
4 | * Copyright (C) 2008 Intel Corp. | ||
5 | * | ||
6 | * Author: Sarah Sharp | ||
7 | * Some code borrowed from the Linux EHCI driver. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
16 | * for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
21 | */ | ||
22 | |||
23 | #ifndef __LINUX_XHCI_HCD_H | ||
24 | #define __LINUX_XHCI_HCD_H | ||
25 | |||
26 | #include <linux/usb.h> | ||
27 | #include <linux/timer.h> | ||
28 | |||
29 | #include "../core/hcd.h" | ||
30 | /* Code sharing between pci-quirks and xhci hcd */ | ||
31 | #include "xhci-ext-caps.h" | ||
32 | |||
33 | /* xHCI PCI Configuration Registers */ | ||
34 | #define XHCI_SBRN_OFFSET (0x60) | ||
35 | |||
36 | /* Max number of USB devices for any host controller - limit in section 6.1 */ | ||
37 | #define MAX_HC_SLOTS 256 | ||
38 | /* Section 5.3.3 - MaxPorts */ | ||
39 | #define MAX_HC_PORTS 127 | ||
40 | |||
41 | /* | ||
42 | * xHCI register interface. | ||
43 | * This corresponds to the eXtensible Host Controller Interface (xHCI) | ||
44 | * Revision 0.95 specification | ||
45 | * | ||
46 | * Registers should always be accessed with double word or quad word accesses. | ||
47 | * | ||
48 | * Some xHCI implementations may support 64-bit address pointers. Registers | ||
49 | * with 64-bit address pointers should be written to with dword accesses by | ||
50 | * writing the low dword first (ptr[0]), then the high dword (ptr[1]) second. | ||
51 | * xHCI implementations that do not support 64-bit address pointers will ignore | ||
52 | * the high dword, and write order is irrelevant. | ||
53 | */ | ||
54 | |||
55 | /** | ||
56 | * struct xhci_cap_regs - xHCI Host Controller Capability Registers. | ||
57 | * @hc_capbase: length of the capabilities register and HC version number | ||
58 | * @hcs_params1: HCSPARAMS1 - Structural Parameters 1 | ||
59 | * @hcs_params2: HCSPARAMS2 - Structural Parameters 2 | ||
60 | * @hcs_params3: HCSPARAMS3 - Structural Parameters 3 | ||
61 | * @hcc_params: HCCPARAMS - Capability Parameters | ||
62 | * @db_off: DBOFF - Doorbell array offset | ||
63 | * @run_regs_off: RTSOFF - Runtime register space offset | ||
64 | */ | ||
65 | struct xhci_cap_regs { | ||
66 | u32 hc_capbase; | ||
67 | u32 hcs_params1; | ||
68 | u32 hcs_params2; | ||
69 | u32 hcs_params3; | ||
70 | u32 hcc_params; | ||
71 | u32 db_off; | ||
72 | u32 run_regs_off; | ||
73 | /* Reserved up to (CAPLENGTH - 0x1C) */ | ||
74 | }; | ||
75 | |||
76 | /* hc_capbase bitmasks */ | ||
77 | /* bits 7:0 - how long is the Capabilities register */ | ||
78 | #define HC_LENGTH(p) XHCI_HC_LENGTH(p) | ||
79 | /* bits 31:16 */ | ||
80 | #define HC_VERSION(p) (((p) >> 16) & 0xffff) | ||
81 | |||
82 | /* HCSPARAMS1 - hcs_params1 - bitmasks */ | ||
83 | /* bits 0:7, Max Device Slots */ | ||
84 | #define HCS_MAX_SLOTS(p) (((p) >> 0) & 0xff) | ||
85 | #define HCS_SLOTS_MASK 0xff | ||
86 | /* bits 8:18, Max Interrupters */ | ||
87 | #define HCS_MAX_INTRS(p) (((p) >> 8) & 0x7ff) | ||
88 | /* bits 24:31, Max Ports - max value is 0x7F = 127 ports */ | ||
89 | #define HCS_MAX_PORTS(p) (((p) >> 24) & 0x7f) | ||
90 | |||
91 | /* HCSPARAMS2 - hcs_params2 - bitmasks */ | ||
92 | /* bits 0:3, frames or uframes that SW needs to queue transactions | ||
93 | * ahead of the HW to meet periodic deadlines */ | ||
94 | #define HCS_IST(p) (((p) >> 0) & 0xf) | ||
95 | /* bits 4:7, max number of Event Ring segments */ | ||
96 | #define HCS_ERST_MAX(p) (((p) >> 4) & 0xf) | ||
97 | /* bit 26 Scratchpad restore - for save/restore HW state - not used yet */ | ||
98 | /* bits 27:31 number of Scratchpad buffers SW must allocate for the HW */ | ||
99 | |||
100 | /* HCSPARAMS3 - hcs_params3 - bitmasks */ | ||
101 | /* bits 0:7, Max U1 to U0 latency for the roothub ports */ | ||
102 | #define HCS_U1_LATENCY(p) (((p) >> 0) & 0xff) | ||
103 | /* bits 16:31, Max U2 to U0 latency for the roothub ports */ | ||
104 | #define HCS_U2_LATENCY(p) (((p) >> 16) & 0xffff) | ||
105 | |||
106 | /* HCCPARAMS - hcc_params - bitmasks */ | ||
107 | /* true: HC can use 64-bit address pointers */ | ||
108 | #define HCC_64BIT_ADDR(p) ((p) & (1 << 0)) | ||
109 | /* true: HC can do bandwidth negotiation */ | ||
110 | #define HCC_BANDWIDTH_NEG(p) ((p) & (1 << 1)) | ||
111 | /* true: HC uses 64-byte Device Context structures | ||
112 | * FIXME 64-byte context structures aren't supported yet. | ||
113 | */ | ||
114 | #define HCC_64BYTE_CONTEXT(p) ((p) & (1 << 2)) | ||
115 | /* true: HC has port power switches */ | ||
116 | #define HCC_PPC(p) ((p) & (1 << 3)) | ||
117 | /* true: HC has port indicators */ | ||
118 | #define HCS_INDICATOR(p) ((p) & (1 << 4)) | ||
119 | /* true: HC has Light HC Reset Capability */ | ||
120 | #define HCC_LIGHT_RESET(p) ((p) & (1 << 5)) | ||
121 | /* true: HC supports latency tolerance messaging */ | ||
122 | #define HCC_LTC(p) ((p) & (1 << 6)) | ||
123 | /* true: no secondary Stream ID Support */ | ||
124 | #define HCC_NSS(p) ((p) & (1 << 7)) | ||
125 | /* Max size for Primary Stream Arrays - 2^(n+1), where n is bits 12:15 */ | ||
126 | #define HCC_MAX_PSA (1 << ((((p) >> 12) & 0xf) + 1)) | ||
127 | /* Extended Capabilities pointer from PCI base - section 5.3.6 */ | ||
128 | #define HCC_EXT_CAPS(p) XHCI_HCC_EXT_CAPS(p) | ||
129 | |||
130 | /* db_off bitmask - bits 0:1 reserved */ | ||
131 | #define DBOFF_MASK (~0x3) | ||
132 | |||
133 | /* run_regs_off bitmask - bits 0:4 reserved */ | ||
134 | #define RTSOFF_MASK (~0x1f) | ||
135 | |||
136 | |||
137 | /* Number of registers per port */ | ||
138 | #define NUM_PORT_REGS 4 | ||
139 | |||
140 | /** | ||
141 | * struct xhci_op_regs - xHCI Host Controller Operational Registers. | ||
142 | * @command: USBCMD - xHC command register | ||
143 | * @status: USBSTS - xHC status register | ||
144 | * @page_size: This indicates the page size that the host controller | ||
145 | * supports. If bit n is set, the HC supports a page size | ||
146 | * of 2^(n+12), up to a 128MB page size. | ||
147 | * 4K is the minimum page size. | ||
148 | * @cmd_ring: CRP - 64-bit Command Ring Pointer | ||
149 | * @dcbaa_ptr: DCBAAP - 64-bit Device Context Base Address Array Pointer | ||
150 | * @config_reg: CONFIG - Configure Register | ||
151 | * @port_status_base: PORTSCn - base address for Port Status and Control | ||
152 | * Each port has a Port Status and Control register, | ||
153 | * followed by a Port Power Management Status and Control | ||
154 | * register, a Port Link Info register, and a reserved | ||
155 | * register. | ||
156 | * @port_power_base: PORTPMSCn - base address for | ||
157 | * Port Power Management Status and Control | ||
158 | * @port_link_base: PORTLIn - base address for Port Link Info (current | ||
159 | * Link PM state and control) for USB 2.1 and USB 3.0 | ||
160 | * devices. | ||
161 | */ | ||
162 | struct xhci_op_regs { | ||
163 | u32 command; | ||
164 | u32 status; | ||
165 | u32 page_size; | ||
166 | u32 reserved1; | ||
167 | u32 reserved2; | ||
168 | u32 dev_notification; | ||
169 | u32 cmd_ring[2]; | ||
170 | /* rsvd: offset 0x20-2F */ | ||
171 | u32 reserved3[4]; | ||
172 | u32 dcbaa_ptr[2]; | ||
173 | u32 config_reg; | ||
174 | /* rsvd: offset 0x3C-3FF */ | ||
175 | u32 reserved4[241]; | ||
176 | /* port 1 registers, which serve as a base address for other ports */ | ||
177 | u32 port_status_base; | ||
178 | u32 port_power_base; | ||
179 | u32 port_link_base; | ||
180 | u32 reserved5; | ||
181 | /* registers for ports 2-255 */ | ||
182 | u32 reserved6[NUM_PORT_REGS*254]; | ||
183 | }; | ||
184 | |||
185 | /* USBCMD - USB command - command bitmasks */ | ||
186 | /* start/stop HC execution - do not write unless HC is halted*/ | ||
187 | #define CMD_RUN XHCI_CMD_RUN | ||
188 | /* Reset HC - resets internal HC state machine and all registers (except | ||
189 | * PCI config regs). HC does NOT drive a USB reset on the downstream ports. | ||
190 | * The xHCI driver must reinitialize the xHC after setting this bit. | ||
191 | */ | ||
192 | #define CMD_RESET (1 << 1) | ||
193 | /* Event Interrupt Enable - a '1' allows interrupts from the host controller */ | ||
194 | #define CMD_EIE XHCI_CMD_EIE | ||
195 | /* Host System Error Interrupt Enable - get out-of-band signal for HC errors */ | ||
196 | #define CMD_HSEIE XHCI_CMD_HSEIE | ||
197 | /* bits 4:6 are reserved (and should be preserved on writes). */ | ||
198 | /* light reset (port status stays unchanged) - reset completed when this is 0 */ | ||
199 | #define CMD_LRESET (1 << 7) | ||
200 | /* FIXME: ignoring host controller save/restore state for now. */ | ||
201 | #define CMD_CSS (1 << 8) | ||
202 | #define CMD_CRS (1 << 9) | ||
203 | /* Enable Wrap Event - '1' means xHC generates an event when MFINDEX wraps. */ | ||
204 | #define CMD_EWE XHCI_CMD_EWE | ||
205 | /* MFINDEX power management - '1' means xHC can stop MFINDEX counter if all root | ||
206 | * hubs are in U3 (selective suspend), disconnect, disabled, or powered-off. | ||
207 | * '0' means the xHC can power it off if all ports are in the disconnect, | ||
208 | * disabled, or powered-off state. | ||
209 | */ | ||
210 | #define CMD_PM_INDEX (1 << 11) | ||
211 | /* bits 12:31 are reserved (and should be preserved on writes). */ | ||
212 | |||
213 | /* USBSTS - USB status - status bitmasks */ | ||
214 | /* HC not running - set to 1 when run/stop bit is cleared. */ | ||
215 | #define STS_HALT XHCI_STS_HALT | ||
216 | /* serious error, e.g. PCI parity error. The HC will clear the run/stop bit. */ | ||
217 | #define STS_FATAL (1 << 2) | ||
218 | /* event interrupt - clear this prior to clearing any IP flags in IR set*/ | ||
219 | #define STS_EINT (1 << 3) | ||
220 | /* port change detect */ | ||
221 | #define STS_PORT (1 << 4) | ||
222 | /* bits 5:7 reserved and zeroed */ | ||
223 | /* save state status - '1' means xHC is saving state */ | ||
224 | #define STS_SAVE (1 << 8) | ||
225 | /* restore state status - '1' means xHC is restoring state */ | ||
226 | #define STS_RESTORE (1 << 9) | ||
227 | /* true: save or restore error */ | ||
228 | #define STS_SRE (1 << 10) | ||
229 | /* true: Controller Not Ready to accept doorbell or op reg writes after reset */ | ||
230 | #define STS_CNR XHCI_STS_CNR | ||
231 | /* true: internal Host Controller Error - SW needs to reset and reinitialize */ | ||
232 | #define STS_HCE (1 << 12) | ||
233 | /* bits 13:31 reserved and should be preserved */ | ||
234 | |||
235 | /* | ||
236 | * DNCTRL - Device Notification Control Register - dev_notification bitmasks | ||
237 | * Generate a device notification event when the HC sees a transaction with a | ||
238 | * notification type that matches a bit set in this bit field. | ||
239 | */ | ||
240 | #define DEV_NOTE_MASK (0xffff) | ||
241 | #define ENABLE_DEV_NOTE(x) (1 << x) | ||
242 | /* Most of the device notification types should only be used for debug. | ||
243 | * SW does need to pay attention to function wake notifications. | ||
244 | */ | ||
245 | #define DEV_NOTE_FWAKE ENABLE_DEV_NOTE(1) | ||
246 | |||
247 | /* CRCR - Command Ring Control Register - cmd_ring bitmasks */ | ||
248 | /* bit 0 is the command ring cycle state */ | ||
249 | /* stop ring operation after completion of the currently executing command */ | ||
250 | #define CMD_RING_PAUSE (1 << 1) | ||
251 | /* stop ring immediately - abort the currently executing command */ | ||
252 | #define CMD_RING_ABORT (1 << 2) | ||
253 | /* true: command ring is running */ | ||
254 | #define CMD_RING_RUNNING (1 << 3) | ||
255 | /* bits 4:5 reserved and should be preserved */ | ||
256 | /* Command Ring pointer - bit mask for the lower 32 bits. */ | ||
257 | #define CMD_RING_ADDR_MASK (0xffffffc0) | ||
258 | |||
259 | /* CONFIG - Configure Register - config_reg bitmasks */ | ||
260 | /* bits 0:7 - maximum number of device slots enabled (NumSlotsEn) */ | ||
261 | #define MAX_DEVS(p) ((p) & 0xff) | ||
262 | /* bits 8:31 - reserved and should be preserved */ | ||
263 | |||
264 | /* PORTSC - Port Status and Control Register - port_status_base bitmasks */ | ||
265 | /* true: device connected */ | ||
266 | #define PORT_CONNECT (1 << 0) | ||
267 | /* true: port enabled */ | ||
268 | #define PORT_PE (1 << 1) | ||
269 | /* bit 2 reserved and zeroed */ | ||
270 | /* true: port has an over-current condition */ | ||
271 | #define PORT_OC (1 << 3) | ||
272 | /* true: port reset signaling asserted */ | ||
273 | #define PORT_RESET (1 << 4) | ||
274 | /* Port Link State - bits 5:8 | ||
275 | * A read gives the current link PM state of the port, | ||
276 | * a write with Link State Write Strobe set sets the link state. | ||
277 | */ | ||
278 | /* true: port has power (see HCC_PPC) */ | ||
279 | #define PORT_POWER (1 << 9) | ||
280 | /* bits 10:13 indicate device speed: | ||
281 | * 0 - undefined speed - port hasn't be initialized by a reset yet | ||
282 | * 1 - full speed | ||
283 | * 2 - low speed | ||
284 | * 3 - high speed | ||
285 | * 4 - super speed | ||
286 | * 5-15 reserved | ||
287 | */ | ||
288 | #define DEV_SPEED_MASK (0xf << 10) | ||
289 | #define XDEV_FS (0x1 << 10) | ||
290 | #define XDEV_LS (0x2 << 10) | ||
291 | #define XDEV_HS (0x3 << 10) | ||
292 | #define XDEV_SS (0x4 << 10) | ||
293 | #define DEV_UNDEFSPEED(p) (((p) & DEV_SPEED_MASK) == (0x0<<10)) | ||
294 | #define DEV_FULLSPEED(p) (((p) & DEV_SPEED_MASK) == XDEV_FS) | ||
295 | #define DEV_LOWSPEED(p) (((p) & DEV_SPEED_MASK) == XDEV_LS) | ||
296 | #define DEV_HIGHSPEED(p) (((p) & DEV_SPEED_MASK) == XDEV_HS) | ||
297 | #define DEV_SUPERSPEED(p) (((p) & DEV_SPEED_MASK) == XDEV_SS) | ||
298 | /* Bits 20:23 in the Slot Context are the speed for the device */ | ||
299 | #define SLOT_SPEED_FS (XDEV_FS << 10) | ||
300 | #define SLOT_SPEED_LS (XDEV_LS << 10) | ||
301 | #define SLOT_SPEED_HS (XDEV_HS << 10) | ||
302 | #define SLOT_SPEED_SS (XDEV_SS << 10) | ||
303 | /* Port Indicator Control */ | ||
304 | #define PORT_LED_OFF (0 << 14) | ||
305 | #define PORT_LED_AMBER (1 << 14) | ||
306 | #define PORT_LED_GREEN (2 << 14) | ||
307 | #define PORT_LED_MASK (3 << 14) | ||
308 | /* Port Link State Write Strobe - set this when changing link state */ | ||
309 | #define PORT_LINK_STROBE (1 << 16) | ||
310 | /* true: connect status change */ | ||
311 | #define PORT_CSC (1 << 17) | ||
312 | /* true: port enable change */ | ||
313 | #define PORT_PEC (1 << 18) | ||
314 | /* true: warm reset for a USB 3.0 device is done. A "hot" reset puts the port | ||
315 | * into an enabled state, and the device into the default state. A "warm" reset | ||
316 | * also resets the link, forcing the device through the link training sequence. | ||
317 | * SW can also look at the Port Reset register to see when warm reset is done. | ||
318 | */ | ||
319 | #define PORT_WRC (1 << 19) | ||
320 | /* true: over-current change */ | ||
321 | #define PORT_OCC (1 << 20) | ||
322 | /* true: reset change - 1 to 0 transition of PORT_RESET */ | ||
323 | #define PORT_RC (1 << 21) | ||
324 | /* port link status change - set on some port link state transitions: | ||
325 | * Transition Reason | ||
326 | * ------------------------------------------------------------------------------ | ||
327 | * - U3 to Resume Wakeup signaling from a device | ||
328 | * - Resume to Recovery to U0 USB 3.0 device resume | ||
329 | * - Resume to U0 USB 2.0 device resume | ||
330 | * - U3 to Recovery to U0 Software resume of USB 3.0 device complete | ||
331 | * - U3 to U0 Software resume of USB 2.0 device complete | ||
332 | * - U2 to U0 L1 resume of USB 2.1 device complete | ||
333 | * - U0 to U0 (???) L1 entry rejection by USB 2.1 device | ||
334 | * - U0 to disabled L1 entry error with USB 2.1 device | ||
335 | * - Any state to inactive Error on USB 3.0 port | ||
336 | */ | ||
337 | #define PORT_PLC (1 << 22) | ||
338 | /* port configure error change - port failed to configure its link partner */ | ||
339 | #define PORT_CEC (1 << 23) | ||
340 | /* bit 24 reserved */ | ||
341 | /* wake on connect (enable) */ | ||
342 | #define PORT_WKCONN_E (1 << 25) | ||
343 | /* wake on disconnect (enable) */ | ||
344 | #define PORT_WKDISC_E (1 << 26) | ||
345 | /* wake on over-current (enable) */ | ||
346 | #define PORT_WKOC_E (1 << 27) | ||
347 | /* bits 28:29 reserved */ | ||
348 | /* true: device is removable - for USB 3.0 roothub emulation */ | ||
349 | #define PORT_DEV_REMOVE (1 << 30) | ||
350 | /* Initiate a warm port reset - complete when PORT_WRC is '1' */ | ||
351 | #define PORT_WR (1 << 31) | ||
352 | |||
353 | /* Port Power Management Status and Control - port_power_base bitmasks */ | ||
354 | /* Inactivity timer value for transitions into U1, in microseconds. | ||
355 | * Timeout can be up to 127us. 0xFF means an infinite timeout. | ||
356 | */ | ||
357 | #define PORT_U1_TIMEOUT(p) ((p) & 0xff) | ||
358 | /* Inactivity timer value for transitions into U2 */ | ||
359 | #define PORT_U2_TIMEOUT(p) (((p) & 0xff) << 8) | ||
360 | /* Bits 24:31 for port testing */ | ||
361 | |||
362 | |||
363 | /** | ||
364 | * struct xhci_intr_reg - Interrupt Register Set | ||
365 | * @irq_pending: IMAN - Interrupt Management Register. Used to enable | ||
366 | * interrupts and check for pending interrupts. | ||
367 | * @irq_control: IMOD - Interrupt Moderation Register. | ||
368 | * Used to throttle interrupts. | ||
369 | * @erst_size: Number of segments in the Event Ring Segment Table (ERST). | ||
370 | * @erst_base: ERST base address. | ||
371 | * @erst_dequeue: Event ring dequeue pointer. | ||
372 | * | ||
373 | * Each interrupter (defined by a MSI-X vector) has an event ring and an Event | ||
374 | * Ring Segment Table (ERST) associated with it. The event ring is comprised of | ||
375 | * multiple segments of the same size. The HC places events on the ring and | ||
376 | * "updates the Cycle bit in the TRBs to indicate to software the current | ||
377 | * position of the Enqueue Pointer." The HCD (Linux) processes those events and | ||
378 | * updates the dequeue pointer. | ||
379 | */ | ||
380 | struct xhci_intr_reg { | ||
381 | u32 irq_pending; | ||
382 | u32 irq_control; | ||
383 | u32 erst_size; | ||
384 | u32 rsvd; | ||
385 | u32 erst_base[2]; | ||
386 | u32 erst_dequeue[2]; | ||
387 | }; | ||
388 | |||
389 | /* irq_pending bitmasks */ | ||
390 | #define ER_IRQ_PENDING(p) ((p) & 0x1) | ||
391 | /* bits 2:31 need to be preserved */ | ||
392 | /* THIS IS BUGGY - FIXME - IP IS WRITE 1 TO CLEAR */ | ||
393 | #define ER_IRQ_CLEAR(p) ((p) & 0xfffffffe) | ||
394 | #define ER_IRQ_ENABLE(p) ((ER_IRQ_CLEAR(p)) | 0x2) | ||
395 | #define ER_IRQ_DISABLE(p) ((ER_IRQ_CLEAR(p)) & ~(0x2)) | ||
396 | |||
397 | /* irq_control bitmasks */ | ||
398 | /* Minimum interval between interrupts (in 250ns intervals). The interval | ||
399 | * between interrupts will be longer if there are no events on the event ring. | ||
400 | * Default is 4000 (1 ms). | ||
401 | */ | ||
402 | #define ER_IRQ_INTERVAL_MASK (0xffff) | ||
403 | /* Counter used to count down the time to the next interrupt - HW use only */ | ||
404 | #define ER_IRQ_COUNTER_MASK (0xffff << 16) | ||
405 | |||
406 | /* erst_size bitmasks */ | ||
407 | /* Preserve bits 16:31 of erst_size */ | ||
408 | #define ERST_SIZE_MASK (0xffff << 16) | ||
409 | |||
410 | /* erst_dequeue bitmasks */ | ||
411 | /* Dequeue ERST Segment Index (DESI) - Segment number (or alias) | ||
412 | * where the current dequeue pointer lies. This is an optional HW hint. | ||
413 | */ | ||
414 | #define ERST_DESI_MASK (0x7) | ||
415 | /* Event Handler Busy (EHB) - is the event ring scheduled to be serviced by | ||
416 | * a work queue (or delayed service routine)? | ||
417 | */ | ||
418 | #define ERST_EHB (1 << 3) | ||
419 | #define ERST_PTR_MASK (0xf) | ||
420 | |||
421 | /** | ||
422 | * struct xhci_run_regs | ||
423 | * @microframe_index: | ||
424 | * MFINDEX - current microframe number | ||
425 | * | ||
426 | * Section 5.5 Host Controller Runtime Registers: | ||
427 | * "Software should read and write these registers using only Dword (32 bit) | ||
428 | * or larger accesses" | ||
429 | */ | ||
430 | struct xhci_run_regs { | ||
431 | u32 microframe_index; | ||
432 | u32 rsvd[7]; | ||
433 | struct xhci_intr_reg ir_set[128]; | ||
434 | }; | ||
435 | |||
436 | /** | ||
437 | * struct doorbell_array | ||
438 | * | ||
439 | * Section 5.6 | ||
440 | */ | ||
441 | struct xhci_doorbell_array { | ||
442 | u32 doorbell[256]; | ||
443 | }; | ||
444 | |||
445 | #define DB_TARGET_MASK 0xFFFFFF00 | ||
446 | #define DB_STREAM_ID_MASK 0x0000FFFF | ||
447 | #define DB_TARGET_HOST 0x0 | ||
448 | #define DB_STREAM_ID_HOST 0x0 | ||
449 | #define DB_MASK (0xff << 8) | ||
450 | |||
451 | /* Endpoint Target - bits 0:7 */ | ||
452 | #define EPI_TO_DB(p) (((p) + 1) & 0xff) | ||
453 | |||
454 | |||
455 | /** | ||
456 | * struct xhci_slot_ctx | ||
457 | * @dev_info: Route string, device speed, hub info, and last valid endpoint | ||
458 | * @dev_info2: Max exit latency for device number, root hub port number | ||
459 | * @tt_info: tt_info is used to construct split transaction tokens | ||
460 | * @dev_state: slot state and device address | ||
461 | * | ||
462 | * Slot Context - section 6.2.1.1. This assumes the HC uses 32-byte context | ||
463 | * structures. If the HC uses 64-byte contexts, there is an additional 32 bytes | ||
464 | * reserved at the end of the slot context for HC internal use. | ||
465 | */ | ||
466 | struct xhci_slot_ctx { | ||
467 | u32 dev_info; | ||
468 | u32 dev_info2; | ||
469 | u32 tt_info; | ||
470 | u32 dev_state; | ||
471 | /* offset 0x10 to 0x1f reserved for HC internal use */ | ||
472 | u32 reserved[4]; | ||
473 | }; | ||
474 | |||
475 | /* dev_info bitmasks */ | ||
476 | /* Route String - 0:19 */ | ||
477 | #define ROUTE_STRING_MASK (0xfffff) | ||
478 | /* Device speed - values defined by PORTSC Device Speed field - 20:23 */ | ||
479 | #define DEV_SPEED (0xf << 20) | ||
480 | /* bit 24 reserved */ | ||
481 | /* Is this LS/FS device connected through a HS hub? - bit 25 */ | ||
482 | #define DEV_MTT (0x1 << 25) | ||
483 | /* Set if the device is a hub - bit 26 */ | ||
484 | #define DEV_HUB (0x1 << 26) | ||
485 | /* Index of the last valid endpoint context in this device context - 27:31 */ | ||
486 | #define LAST_CTX_MASK (0x1f << 27) | ||
487 | #define LAST_CTX(p) ((p) << 27) | ||
488 | #define LAST_CTX_TO_EP_NUM(p) (((p) >> 27) - 1) | ||
489 | #define SLOT_FLAG (1 << 0) | ||
490 | #define EP0_FLAG (1 << 1) | ||
491 | |||
492 | /* dev_info2 bitmasks */ | ||
493 | /* Max Exit Latency (ms) - worst case time to wake up all links in dev path */ | ||
494 | #define MAX_EXIT (0xffff) | ||
495 | /* Root hub port number that is needed to access the USB device */ | ||
496 | #define ROOT_HUB_PORT(p) (((p) & 0xff) << 16) | ||
497 | |||
498 | /* tt_info bitmasks */ | ||
499 | /* | ||
500 | * TT Hub Slot ID - for low or full speed devices attached to a high-speed hub | ||
501 | * The Slot ID of the hub that isolates the high speed signaling from | ||
502 | * this low or full-speed device. '0' if attached to root hub port. | ||
503 | */ | ||
504 | #define TT_SLOT (0xff) | ||
505 | /* | ||
506 | * The number of the downstream facing port of the high-speed hub | ||
507 | * '0' if the device is not low or full speed. | ||
508 | */ | ||
509 | #define TT_PORT (0xff << 8) | ||
510 | |||
511 | /* dev_state bitmasks */ | ||
512 | /* USB device address - assigned by the HC */ | ||
513 | #define DEV_ADDR_MASK (0xff) | ||
514 | /* bits 8:26 reserved */ | ||
515 | /* Slot state */ | ||
516 | #define SLOT_STATE (0x1f << 27) | ||
517 | #define GET_SLOT_STATE(p) (((p) & (0x1f << 27)) >> 27) | ||
518 | |||
519 | |||
520 | /** | ||
521 | * struct xhci_ep_ctx | ||
522 | * @ep_info: endpoint state, streams, mult, and interval information. | ||
523 | * @ep_info2: information on endpoint type, max packet size, max burst size, | ||
524 | * error count, and whether the HC will force an event for all | ||
525 | * transactions. | ||
526 | * @deq: 64-bit ring dequeue pointer address. If the endpoint only | ||
527 | * defines one stream, this points to the endpoint transfer ring. | ||
528 | * Otherwise, it points to a stream context array, which has a | ||
529 | * ring pointer for each flow. | ||
530 | * @tx_info: | ||
531 | * Average TRB lengths for the endpoint ring and | ||
532 | * max payload within an Endpoint Service Interval Time (ESIT). | ||
533 | * | ||
534 | * Endpoint Context - section 6.2.1.2. This assumes the HC uses 32-byte context | ||
535 | * structures. If the HC uses 64-byte contexts, there is an additional 32 bytes | ||
536 | * reserved at the end of the endpoint context for HC internal use. | ||
537 | */ | ||
538 | struct xhci_ep_ctx { | ||
539 | u32 ep_info; | ||
540 | u32 ep_info2; | ||
541 | u32 deq[2]; | ||
542 | u32 tx_info; | ||
543 | /* offset 0x14 - 0x1f reserved for HC internal use */ | ||
544 | u32 reserved[3]; | ||
545 | }; | ||
546 | |||
547 | /* ep_info bitmasks */ | ||
548 | /* | ||
549 | * Endpoint State - bits 0:2 | ||
550 | * 0 - disabled | ||
551 | * 1 - running | ||
552 | * 2 - halted due to halt condition - ok to manipulate endpoint ring | ||
553 | * 3 - stopped | ||
554 | * 4 - TRB error | ||
555 | * 5-7 - reserved | ||
556 | */ | ||
557 | #define EP_STATE_MASK (0xf) | ||
558 | #define EP_STATE_DISABLED 0 | ||
559 | #define EP_STATE_RUNNING 1 | ||
560 | #define EP_STATE_HALTED 2 | ||
561 | #define EP_STATE_STOPPED 3 | ||
562 | #define EP_STATE_ERROR 4 | ||
563 | /* Mult - Max number of burtst within an interval, in EP companion desc. */ | ||
564 | #define EP_MULT(p) ((p & 0x3) << 8) | ||
565 | /* bits 10:14 are Max Primary Streams */ | ||
566 | /* bit 15 is Linear Stream Array */ | ||
567 | /* Interval - period between requests to an endpoint - 125u increments. */ | ||
568 | #define EP_INTERVAL(p) ((p & 0xff) << 16) | ||
569 | |||
570 | /* ep_info2 bitmasks */ | ||
571 | /* | ||
572 | * Force Event - generate transfer events for all TRBs for this endpoint | ||
573 | * This will tell the HC to ignore the IOC and ISP flags (for debugging only). | ||
574 | */ | ||
575 | #define FORCE_EVENT (0x1) | ||
576 | #define ERROR_COUNT(p) (((p) & 0x3) << 1) | ||
577 | #define EP_TYPE(p) ((p) << 3) | ||
578 | #define ISOC_OUT_EP 1 | ||
579 | #define BULK_OUT_EP 2 | ||
580 | #define INT_OUT_EP 3 | ||
581 | #define CTRL_EP 4 | ||
582 | #define ISOC_IN_EP 5 | ||
583 | #define BULK_IN_EP 6 | ||
584 | #define INT_IN_EP 7 | ||
585 | /* bit 6 reserved */ | ||
586 | /* bit 7 is Host Initiate Disable - for disabling stream selection */ | ||
587 | #define MAX_BURST(p) (((p)&0xff) << 8) | ||
588 | #define MAX_PACKET(p) (((p)&0xffff) << 16) | ||
589 | |||
590 | |||
591 | /** | ||
592 | * struct xhci_device_control | ||
593 | * Input/Output context; see section 6.2.5. | ||
594 | * | ||
595 | * @drop_context: set the bit of the endpoint context you want to disable | ||
596 | * @add_context: set the bit of the endpoint context you want to enable | ||
597 | */ | ||
598 | struct xhci_device_control { | ||
599 | u32 drop_flags; | ||
600 | u32 add_flags; | ||
601 | u32 rsvd[6]; | ||
602 | struct xhci_slot_ctx slot; | ||
603 | struct xhci_ep_ctx ep[31]; | ||
604 | }; | ||
605 | |||
606 | /* drop context bitmasks */ | ||
607 | #define DROP_EP(x) (0x1 << x) | ||
608 | /* add context bitmasks */ | ||
609 | #define ADD_EP(x) (0x1 << x) | ||
610 | |||
611 | |||
612 | struct xhci_virt_device { | ||
613 | /* | ||
614 | * Commands to the hardware are passed an "input context" that | ||
615 | * tells the hardware what to change in its data structures. | ||
616 | * The hardware will return changes in an "output context" that | ||
617 | * software must allocate for the hardware. We need to keep | ||
618 | * track of input and output contexts separately because | ||
619 | * these commands might fail and we don't trust the hardware. | ||
620 | */ | ||
621 | struct xhci_device_control *out_ctx; | ||
622 | dma_addr_t out_ctx_dma; | ||
623 | /* Used for addressing devices and configuration changes */ | ||
624 | struct xhci_device_control *in_ctx; | ||
625 | dma_addr_t in_ctx_dma; | ||
626 | /* FIXME when stream support is added */ | ||
627 | struct xhci_ring *ep_rings[31]; | ||
628 | /* Temporary storage in case the configure endpoint command fails and we | ||
629 | * have to restore the device state to the previous state | ||
630 | */ | ||
631 | struct xhci_ring *new_ep_rings[31]; | ||
632 | struct completion cmd_completion; | ||
633 | /* Status of the last command issued for this device */ | ||
634 | u32 cmd_status; | ||
635 | }; | ||
636 | |||
637 | |||
638 | /** | ||
639 | * struct xhci_device_context_array | ||
640 | * @dev_context_ptr array of 64-bit DMA addresses for device contexts | ||
641 | */ | ||
642 | struct xhci_device_context_array { | ||
643 | /* 64-bit device addresses; we only write 32-bit addresses */ | ||
644 | u32 dev_context_ptrs[2*MAX_HC_SLOTS]; | ||
645 | /* private xHCD pointers */ | ||
646 | dma_addr_t dma; | ||
647 | }; | ||
648 | /* TODO: write function to set the 64-bit device DMA address */ | ||
649 | /* | ||
650 | * TODO: change this to be dynamically sized at HC mem init time since the HC | ||
651 | * might not be able to handle the maximum number of devices possible. | ||
652 | */ | ||
653 | |||
654 | |||
655 | struct xhci_stream_ctx { | ||
656 | /* 64-bit stream ring address, cycle state, and stream type */ | ||
657 | u32 stream_ring[2]; | ||
658 | /* offset 0x14 - 0x1f reserved for HC internal use */ | ||
659 | u32 reserved[2]; | ||
660 | }; | ||
661 | |||
662 | |||
663 | struct xhci_transfer_event { | ||
664 | /* 64-bit buffer address, or immediate data */ | ||
665 | u32 buffer[2]; | ||
666 | u32 transfer_len; | ||
667 | /* This field is interpreted differently based on the type of TRB */ | ||
668 | u32 flags; | ||
669 | }; | ||
670 | |||
671 | /** Transfer Event bit fields **/ | ||
672 | #define TRB_TO_EP_ID(p) (((p) >> 16) & 0x1f) | ||
673 | |||
674 | /* Completion Code - only applicable for some types of TRBs */ | ||
675 | #define COMP_CODE_MASK (0xff << 24) | ||
676 | #define GET_COMP_CODE(p) (((p) & COMP_CODE_MASK) >> 24) | ||
677 | #define COMP_SUCCESS 1 | ||
678 | /* Data Buffer Error */ | ||
679 | #define COMP_DB_ERR 2 | ||
680 | /* Babble Detected Error */ | ||
681 | #define COMP_BABBLE 3 | ||
682 | /* USB Transaction Error */ | ||
683 | #define COMP_TX_ERR 4 | ||
684 | /* TRB Error - some TRB field is invalid */ | ||
685 | #define COMP_TRB_ERR 5 | ||
686 | /* Stall Error - USB device is stalled */ | ||
687 | #define COMP_STALL 6 | ||
688 | /* Resource Error - HC doesn't have memory for that device configuration */ | ||
689 | #define COMP_ENOMEM 7 | ||
690 | /* Bandwidth Error - not enough room in schedule for this dev config */ | ||
691 | #define COMP_BW_ERR 8 | ||
692 | /* No Slots Available Error - HC ran out of device slots */ | ||
693 | #define COMP_ENOSLOTS 9 | ||
694 | /* Invalid Stream Type Error */ | ||
695 | #define COMP_STREAM_ERR 10 | ||
696 | /* Slot Not Enabled Error - doorbell rung for disabled device slot */ | ||
697 | #define COMP_EBADSLT 11 | ||
698 | /* Endpoint Not Enabled Error */ | ||
699 | #define COMP_EBADEP 12 | ||
700 | /* Short Packet */ | ||
701 | #define COMP_SHORT_TX 13 | ||
702 | /* Ring Underrun - doorbell rung for an empty isoc OUT ep ring */ | ||
703 | #define COMP_UNDERRUN 14 | ||
704 | /* Ring Overrun - isoc IN ep ring is empty when ep is scheduled to RX */ | ||
705 | #define COMP_OVERRUN 15 | ||
706 | /* Virtual Function Event Ring Full Error */ | ||
707 | #define COMP_VF_FULL 16 | ||
708 | /* Parameter Error - Context parameter is invalid */ | ||
709 | #define COMP_EINVAL 17 | ||
710 | /* Bandwidth Overrun Error - isoc ep exceeded its allocated bandwidth */ | ||
711 | #define COMP_BW_OVER 18 | ||
712 | /* Context State Error - illegal context state transition requested */ | ||
713 | #define COMP_CTX_STATE 19 | ||
714 | /* No Ping Response Error - HC didn't get PING_RESPONSE in time to TX */ | ||
715 | #define COMP_PING_ERR 20 | ||
716 | /* Event Ring is full */ | ||
717 | #define COMP_ER_FULL 21 | ||
718 | /* Missed Service Error - HC couldn't service an isoc ep within interval */ | ||
719 | #define COMP_MISSED_INT 23 | ||
720 | /* Successfully stopped command ring */ | ||
721 | #define COMP_CMD_STOP 24 | ||
722 | /* Successfully aborted current command and stopped command ring */ | ||
723 | #define COMP_CMD_ABORT 25 | ||
724 | /* Stopped - transfer was terminated by a stop endpoint command */ | ||
725 | #define COMP_STOP 26 | ||
726 | /* Same as COMP_EP_STOPPED, but the transfered length in the event is invalid */ | ||
727 | #define COMP_STOP_INVAL 27 | ||
728 | /* Control Abort Error - Debug Capability - control pipe aborted */ | ||
729 | #define COMP_DBG_ABORT 28 | ||
730 | /* TRB type 29 and 30 reserved */ | ||
731 | /* Isoc Buffer Overrun - an isoc IN ep sent more data than could fit in TD */ | ||
732 | #define COMP_BUFF_OVER 31 | ||
733 | /* Event Lost Error - xHC has an "internal event overrun condition" */ | ||
734 | #define COMP_ISSUES 32 | ||
735 | /* Undefined Error - reported when other error codes don't apply */ | ||
736 | #define COMP_UNKNOWN 33 | ||
737 | /* Invalid Stream ID Error */ | ||
738 | #define COMP_STRID_ERR 34 | ||
739 | /* Secondary Bandwidth Error - may be returned by a Configure Endpoint cmd */ | ||
740 | /* FIXME - check for this */ | ||
741 | #define COMP_2ND_BW_ERR 35 | ||
742 | /* Split Transaction Error */ | ||
743 | #define COMP_SPLIT_ERR 36 | ||
744 | |||
745 | struct xhci_link_trb { | ||
746 | /* 64-bit segment pointer*/ | ||
747 | u32 segment_ptr[2]; | ||
748 | u32 intr_target; | ||
749 | u32 control; | ||
750 | }; | ||
751 | |||
752 | /* control bitfields */ | ||
753 | #define LINK_TOGGLE (0x1<<1) | ||
754 | |||
755 | /* Command completion event TRB */ | ||
756 | struct xhci_event_cmd { | ||
757 | /* Pointer to command TRB, or the value passed by the event data trb */ | ||
758 | u32 cmd_trb[2]; | ||
759 | u32 status; | ||
760 | u32 flags; | ||
761 | }; | ||
762 | |||
763 | /* flags bitmasks */ | ||
764 | /* bits 16:23 are the virtual function ID */ | ||
765 | /* bits 24:31 are the slot ID */ | ||
766 | #define TRB_TO_SLOT_ID(p) (((p) & (0xff<<24)) >> 24) | ||
767 | #define SLOT_ID_FOR_TRB(p) (((p) & 0xff) << 24) | ||
768 | |||
769 | /* Stop Endpoint TRB - ep_index to endpoint ID for this TRB */ | ||
770 | #define TRB_TO_EP_INDEX(p) ((((p) & (0x1f << 16)) >> 16) - 1) | ||
771 | #define EP_ID_FOR_TRB(p) ((((p) + 1) & 0x1f) << 16) | ||
772 | |||
773 | |||
774 | /* Port Status Change Event TRB fields */ | ||
775 | /* Port ID - bits 31:24 */ | ||
776 | #define GET_PORT_ID(p) (((p) & (0xff << 24)) >> 24) | ||
777 | |||
778 | /* Normal TRB fields */ | ||
779 | /* transfer_len bitmasks - bits 0:16 */ | ||
780 | #define TRB_LEN(p) ((p) & 0x1ffff) | ||
781 | /* TD size - number of bytes remaining in the TD (including this TRB): | ||
782 | * bits 17 - 21. Shift the number of bytes by 10. */ | ||
783 | #define TD_REMAINDER(p) ((((p) >> 10) & 0x1f) << 17) | ||
784 | /* Interrupter Target - which MSI-X vector to target the completion event at */ | ||
785 | #define TRB_INTR_TARGET(p) (((p) & 0x3ff) << 22) | ||
786 | #define GET_INTR_TARGET(p) (((p) >> 22) & 0x3ff) | ||
787 | |||
788 | /* Cycle bit - indicates TRB ownership by HC or HCD */ | ||
789 | #define TRB_CYCLE (1<<0) | ||
790 | /* | ||
791 | * Force next event data TRB to be evaluated before task switch. | ||
792 | * Used to pass OS data back after a TD completes. | ||
793 | */ | ||
794 | #define TRB_ENT (1<<1) | ||
795 | /* Interrupt on short packet */ | ||
796 | #define TRB_ISP (1<<2) | ||
797 | /* Set PCIe no snoop attribute */ | ||
798 | #define TRB_NO_SNOOP (1<<3) | ||
799 | /* Chain multiple TRBs into a TD */ | ||
800 | #define TRB_CHAIN (1<<4) | ||
801 | /* Interrupt on completion */ | ||
802 | #define TRB_IOC (1<<5) | ||
803 | /* The buffer pointer contains immediate data */ | ||
804 | #define TRB_IDT (1<<6) | ||
805 | |||
806 | |||
807 | /* Control transfer TRB specific fields */ | ||
808 | #define TRB_DIR_IN (1<<16) | ||
809 | |||
810 | struct xhci_generic_trb { | ||
811 | u32 field[4]; | ||
812 | }; | ||
813 | |||
814 | union xhci_trb { | ||
815 | struct xhci_link_trb link; | ||
816 | struct xhci_transfer_event trans_event; | ||
817 | struct xhci_event_cmd event_cmd; | ||
818 | struct xhci_generic_trb generic; | ||
819 | }; | ||
820 | |||
821 | /* TRB bit mask */ | ||
822 | #define TRB_TYPE_BITMASK (0xfc00) | ||
823 | #define TRB_TYPE(p) ((p) << 10) | ||
824 | /* TRB type IDs */ | ||
825 | /* bulk, interrupt, isoc scatter/gather, and control data stage */ | ||
826 | #define TRB_NORMAL 1 | ||
827 | /* setup stage for control transfers */ | ||
828 | #define TRB_SETUP 2 | ||
829 | /* data stage for control transfers */ | ||
830 | #define TRB_DATA 3 | ||
831 | /* status stage for control transfers */ | ||
832 | #define TRB_STATUS 4 | ||
833 | /* isoc transfers */ | ||
834 | #define TRB_ISOC 5 | ||
835 | /* TRB for linking ring segments */ | ||
836 | #define TRB_LINK 6 | ||
837 | #define TRB_EVENT_DATA 7 | ||
838 | /* Transfer Ring No-op (not for the command ring) */ | ||
839 | #define TRB_TR_NOOP 8 | ||
840 | /* Command TRBs */ | ||
841 | /* Enable Slot Command */ | ||
842 | #define TRB_ENABLE_SLOT 9 | ||
843 | /* Disable Slot Command */ | ||
844 | #define TRB_DISABLE_SLOT 10 | ||
845 | /* Address Device Command */ | ||
846 | #define TRB_ADDR_DEV 11 | ||
847 | /* Configure Endpoint Command */ | ||
848 | #define TRB_CONFIG_EP 12 | ||
849 | /* Evaluate Context Command */ | ||
850 | #define TRB_EVAL_CONTEXT 13 | ||
851 | /* Reset Transfer Ring Command */ | ||
852 | #define TRB_RESET_RING 14 | ||
853 | /* Stop Transfer Ring Command */ | ||
854 | #define TRB_STOP_RING 15 | ||
855 | /* Set Transfer Ring Dequeue Pointer Command */ | ||
856 | #define TRB_SET_DEQ 16 | ||
857 | /* Reset Device Command */ | ||
858 | #define TRB_RESET_DEV 17 | ||
859 | /* Force Event Command (opt) */ | ||
860 | #define TRB_FORCE_EVENT 18 | ||
861 | /* Negotiate Bandwidth Command (opt) */ | ||
862 | #define TRB_NEG_BANDWIDTH 19 | ||
863 | /* Set Latency Tolerance Value Command (opt) */ | ||
864 | #define TRB_SET_LT 20 | ||
865 | /* Get port bandwidth Command */ | ||
866 | #define TRB_GET_BW 21 | ||
867 | /* Force Header Command - generate a transaction or link management packet */ | ||
868 | #define TRB_FORCE_HEADER 22 | ||
869 | /* No-op Command - not for transfer rings */ | ||
870 | #define TRB_CMD_NOOP 23 | ||
871 | /* TRB IDs 24-31 reserved */ | ||
872 | /* Event TRBS */ | ||
873 | /* Transfer Event */ | ||
874 | #define TRB_TRANSFER 32 | ||
875 | /* Command Completion Event */ | ||
876 | #define TRB_COMPLETION 33 | ||
877 | /* Port Status Change Event */ | ||
878 | #define TRB_PORT_STATUS 34 | ||
879 | /* Bandwidth Request Event (opt) */ | ||
880 | #define TRB_BANDWIDTH_EVENT 35 | ||
881 | /* Doorbell Event (opt) */ | ||
882 | #define TRB_DOORBELL 36 | ||
883 | /* Host Controller Event */ | ||
884 | #define TRB_HC_EVENT 37 | ||
885 | /* Device Notification Event - device sent function wake notification */ | ||
886 | #define TRB_DEV_NOTE 38 | ||
887 | /* MFINDEX Wrap Event - microframe counter wrapped */ | ||
888 | #define TRB_MFINDEX_WRAP 39 | ||
889 | /* TRB IDs 40-47 reserved, 48-63 is vendor-defined */ | ||
890 | |||
891 | /* | ||
892 | * TRBS_PER_SEGMENT must be a multiple of 4, | ||
893 | * since the command ring is 64-byte aligned. | ||
894 | * It must also be greater than 16. | ||
895 | */ | ||
896 | #define TRBS_PER_SEGMENT 64 | ||
897 | #define SEGMENT_SIZE (TRBS_PER_SEGMENT*16) | ||
898 | /* TRB buffer pointers can't cross 64KB boundaries */ | ||
899 | #define TRB_MAX_BUFF_SHIFT 16 | ||
900 | #define TRB_MAX_BUFF_SIZE (1 << TRB_MAX_BUFF_SHIFT) | ||
901 | |||
902 | struct xhci_segment { | ||
903 | union xhci_trb *trbs; | ||
904 | /* private to HCD */ | ||
905 | struct xhci_segment *next; | ||
906 | dma_addr_t dma; | ||
907 | }; | ||
908 | |||
909 | struct xhci_td { | ||
910 | struct list_head td_list; | ||
911 | struct list_head cancelled_td_list; | ||
912 | struct urb *urb; | ||
913 | struct xhci_segment *start_seg; | ||
914 | union xhci_trb *first_trb; | ||
915 | union xhci_trb *last_trb; | ||
916 | }; | ||
917 | |||
918 | struct xhci_ring { | ||
919 | struct xhci_segment *first_seg; | ||
920 | union xhci_trb *enqueue; | ||
921 | struct xhci_segment *enq_seg; | ||
922 | unsigned int enq_updates; | ||
923 | union xhci_trb *dequeue; | ||
924 | struct xhci_segment *deq_seg; | ||
925 | unsigned int deq_updates; | ||
926 | struct list_head td_list; | ||
927 | /* ---- Related to URB cancellation ---- */ | ||
928 | struct list_head cancelled_td_list; | ||
929 | unsigned int cancels_pending; | ||
930 | unsigned int state; | ||
931 | #define SET_DEQ_PENDING (1 << 0) | ||
932 | /* The TRB that was last reported in a stopped endpoint ring */ | ||
933 | union xhci_trb *stopped_trb; | ||
934 | struct xhci_td *stopped_td; | ||
935 | /* | ||
936 | * Write the cycle state into the TRB cycle field to give ownership of | ||
937 | * the TRB to the host controller (if we are the producer), or to check | ||
938 | * if we own the TRB (if we are the consumer). See section 4.9.1. | ||
939 | */ | ||
940 | u32 cycle_state; | ||
941 | }; | ||
942 | |||
943 | struct xhci_erst_entry { | ||
944 | /* 64-bit event ring segment address */ | ||
945 | u32 seg_addr[2]; | ||
946 | u32 seg_size; | ||
947 | /* Set to zero */ | ||
948 | u32 rsvd; | ||
949 | }; | ||
950 | |||
951 | struct xhci_erst { | ||
952 | struct xhci_erst_entry *entries; | ||
953 | unsigned int num_entries; | ||
954 | /* xhci->event_ring keeps track of segment dma addresses */ | ||
955 | dma_addr_t erst_dma_addr; | ||
956 | /* Num entries the ERST can contain */ | ||
957 | unsigned int erst_size; | ||
958 | }; | ||
959 | |||
960 | /* | ||
961 | * Each segment table entry is 4*32bits long. 1K seems like an ok size: | ||
962 | * (1K bytes * 8bytes/bit) / (4*32 bits) = 64 segment entries in the table, | ||
963 | * meaning 64 ring segments. | ||
964 | * Initial allocated size of the ERST, in number of entries */ | ||
965 | #define ERST_NUM_SEGS 1 | ||
966 | /* Initial allocated size of the ERST, in number of entries */ | ||
967 | #define ERST_SIZE 64 | ||
968 | /* Initial number of event segment rings allocated */ | ||
969 | #define ERST_ENTRIES 1 | ||
970 | /* Poll every 60 seconds */ | ||
971 | #define POLL_TIMEOUT 60 | ||
972 | /* XXX: Make these module parameters */ | ||
973 | |||
974 | |||
975 | /* There is one ehci_hci structure per controller */ | ||
976 | struct xhci_hcd { | ||
977 | /* glue to PCI and HCD framework */ | ||
978 | struct xhci_cap_regs __iomem *cap_regs; | ||
979 | struct xhci_op_regs __iomem *op_regs; | ||
980 | struct xhci_run_regs __iomem *run_regs; | ||
981 | struct xhci_doorbell_array __iomem *dba; | ||
982 | /* Our HCD's current interrupter register set */ | ||
983 | struct xhci_intr_reg __iomem *ir_set; | ||
984 | |||
985 | /* Cached register copies of read-only HC data */ | ||
986 | __u32 hcs_params1; | ||
987 | __u32 hcs_params2; | ||
988 | __u32 hcs_params3; | ||
989 | __u32 hcc_params; | ||
990 | |||
991 | spinlock_t lock; | ||
992 | |||
993 | /* packed release number */ | ||
994 | u8 sbrn; | ||
995 | u16 hci_version; | ||
996 | u8 max_slots; | ||
997 | u8 max_interrupters; | ||
998 | u8 max_ports; | ||
999 | u8 isoc_threshold; | ||
1000 | int event_ring_max; | ||
1001 | int addr_64; | ||
1002 | /* 4KB min, 128MB max */ | ||
1003 | int page_size; | ||
1004 | /* Valid values are 12 to 20, inclusive */ | ||
1005 | int page_shift; | ||
1006 | /* only one MSI vector for now, but might need more later */ | ||
1007 | int msix_count; | ||
1008 | struct msix_entry *msix_entries; | ||
1009 | /* data structures */ | ||
1010 | struct xhci_device_context_array *dcbaa; | ||
1011 | struct xhci_ring *cmd_ring; | ||
1012 | struct xhci_ring *event_ring; | ||
1013 | struct xhci_erst erst; | ||
1014 | /* slot enabling and address device helpers */ | ||
1015 | struct completion addr_dev; | ||
1016 | int slot_id; | ||
1017 | /* Internal mirror of the HW's dcbaa */ | ||
1018 | struct xhci_virt_device *devs[MAX_HC_SLOTS]; | ||
1019 | |||
1020 | /* DMA pools */ | ||
1021 | struct dma_pool *device_pool; | ||
1022 | struct dma_pool *segment_pool; | ||
1023 | |||
1024 | #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING | ||
1025 | /* Poll the rings - for debugging */ | ||
1026 | struct timer_list event_ring_timer; | ||
1027 | int zombie; | ||
1028 | #endif | ||
1029 | /* Statistics */ | ||
1030 | int noops_submitted; | ||
1031 | int noops_handled; | ||
1032 | int error_bitmask; | ||
1033 | }; | ||
1034 | |||
1035 | /* For testing purposes */ | ||
1036 | #define NUM_TEST_NOOPS 0 | ||
1037 | |||
1038 | /* convert between an HCD pointer and the corresponding EHCI_HCD */ | ||
1039 | static inline struct xhci_hcd *hcd_to_xhci(struct usb_hcd *hcd) | ||
1040 | { | ||
1041 | return (struct xhci_hcd *) (hcd->hcd_priv); | ||
1042 | } | ||
1043 | |||
1044 | static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci) | ||
1045 | { | ||
1046 | return container_of((void *) xhci, struct usb_hcd, hcd_priv); | ||
1047 | } | ||
1048 | |||
1049 | #ifdef CONFIG_USB_XHCI_HCD_DEBUGGING | ||
1050 | #define XHCI_DEBUG 1 | ||
1051 | #else | ||
1052 | #define XHCI_DEBUG 0 | ||
1053 | #endif | ||
1054 | |||
1055 | #define xhci_dbg(xhci, fmt, args...) \ | ||
1056 | do { if (XHCI_DEBUG) dev_dbg(xhci_to_hcd(xhci)->self.controller , fmt , ## args); } while (0) | ||
1057 | #define xhci_info(xhci, fmt, args...) \ | ||
1058 | do { if (XHCI_DEBUG) dev_info(xhci_to_hcd(xhci)->self.controller , fmt , ## args); } while (0) | ||
1059 | #define xhci_err(xhci, fmt, args...) \ | ||
1060 | dev_err(xhci_to_hcd(xhci)->self.controller , fmt , ## args) | ||
1061 | #define xhci_warn(xhci, fmt, args...) \ | ||
1062 | dev_warn(xhci_to_hcd(xhci)->self.controller , fmt , ## args) | ||
1063 | |||
1064 | /* TODO: copied from ehci.h - can be refactored? */ | ||
1065 | /* xHCI spec says all registers are little endian */ | ||
1066 | static inline unsigned int xhci_readl(const struct xhci_hcd *xhci, | ||
1067 | __u32 __iomem *regs) | ||
1068 | { | ||
1069 | return readl(regs); | ||
1070 | } | ||
1071 | static inline void xhci_writel(struct xhci_hcd *xhci, | ||
1072 | const unsigned int val, __u32 __iomem *regs) | ||
1073 | { | ||
1074 | if (!in_interrupt()) | ||
1075 | xhci_dbg(xhci, | ||
1076 | "`MEM_WRITE_DWORD(3'b000, 32'h%p, 32'h%0x, 4'hf);\n", | ||
1077 | regs, val); | ||
1078 | writel(val, regs); | ||
1079 | } | ||
1080 | |||
1081 | /* xHCI debugging */ | ||
1082 | void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int set_num); | ||
1083 | void xhci_print_registers(struct xhci_hcd *xhci); | ||
1084 | void xhci_dbg_regs(struct xhci_hcd *xhci); | ||
1085 | void xhci_print_run_regs(struct xhci_hcd *xhci); | ||
1086 | void xhci_print_trb_offsets(struct xhci_hcd *xhci, union xhci_trb *trb); | ||
1087 | void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb); | ||
1088 | void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg); | ||
1089 | void xhci_debug_ring(struct xhci_hcd *xhci, struct xhci_ring *ring); | ||
1090 | void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst); | ||
1091 | void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci); | ||
1092 | void xhci_dbg_ring_ptrs(struct xhci_hcd *xhci, struct xhci_ring *ring); | ||
1093 | void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_device_control *ctx, dma_addr_t dma, unsigned int last_ep); | ||
1094 | |||
1095 | /* xHCI memory managment */ | ||
1096 | void xhci_mem_cleanup(struct xhci_hcd *xhci); | ||
1097 | int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags); | ||
1098 | void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id); | ||
1099 | int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, struct usb_device *udev, gfp_t flags); | ||
1100 | int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev); | ||
1101 | unsigned int xhci_get_endpoint_index(struct usb_endpoint_descriptor *desc); | ||
1102 | unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc); | ||
1103 | void xhci_endpoint_zero(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, struct usb_host_endpoint *ep); | ||
1104 | int xhci_endpoint_init(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, | ||
1105 | struct usb_device *udev, struct usb_host_endpoint *ep, | ||
1106 | gfp_t mem_flags); | ||
1107 | void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring); | ||
1108 | |||
1109 | #ifdef CONFIG_PCI | ||
1110 | /* xHCI PCI glue */ | ||
1111 | int xhci_register_pci(void); | ||
1112 | void xhci_unregister_pci(void); | ||
1113 | #endif | ||
1114 | |||
1115 | /* xHCI host controller glue */ | ||
1116 | int xhci_halt(struct xhci_hcd *xhci); | ||
1117 | int xhci_reset(struct xhci_hcd *xhci); | ||
1118 | int xhci_init(struct usb_hcd *hcd); | ||
1119 | int xhci_run(struct usb_hcd *hcd); | ||
1120 | void xhci_stop(struct usb_hcd *hcd); | ||
1121 | void xhci_shutdown(struct usb_hcd *hcd); | ||
1122 | int xhci_get_frame(struct usb_hcd *hcd); | ||
1123 | irqreturn_t xhci_irq(struct usb_hcd *hcd); | ||
1124 | int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev); | ||
1125 | void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev); | ||
1126 | int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev); | ||
1127 | int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags); | ||
1128 | int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status); | ||
1129 | int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep); | ||
1130 | int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep); | ||
1131 | int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev); | ||
1132 | void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev); | ||
1133 | |||
1134 | /* xHCI ring, segment, TRB, and TD functions */ | ||
1135 | dma_addr_t xhci_trb_virt_to_dma(struct xhci_segment *seg, union xhci_trb *trb); | ||
1136 | void xhci_ring_cmd_db(struct xhci_hcd *xhci); | ||
1137 | void *xhci_setup_one_noop(struct xhci_hcd *xhci); | ||
1138 | void xhci_handle_event(struct xhci_hcd *xhci); | ||
1139 | void xhci_set_hc_event_deq(struct xhci_hcd *xhci); | ||
1140 | int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id); | ||
1141 | int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr, | ||
1142 | u32 slot_id); | ||
1143 | int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id, | ||
1144 | unsigned int ep_index); | ||
1145 | int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb, | ||
1146 | int slot_id, unsigned int ep_index); | ||
1147 | int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb, | ||
1148 | int slot_id, unsigned int ep_index); | ||
1149 | int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr, | ||
1150 | u32 slot_id); | ||
1151 | |||
1152 | /* xHCI roothub code */ | ||
1153 | int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex, | ||
1154 | char *buf, u16 wLength); | ||
1155 | int xhci_hub_status_data(struct usb_hcd *hcd, char *buf); | ||
1156 | |||
1157 | #endif /* __LINUX_XHCI_HCD_H */ | ||
diff --git a/drivers/usb/misc/sisusbvga/Kconfig b/drivers/usb/misc/sisusbvga/Kconfig index 7603cbe0865d..30ea7ca6846e 100644 --- a/drivers/usb/misc/sisusbvga/Kconfig +++ b/drivers/usb/misc/sisusbvga/Kconfig | |||
@@ -1,7 +1,7 @@ | |||
1 | 1 | ||
2 | config USB_SISUSBVGA | 2 | config USB_SISUSBVGA |
3 | tristate "USB 2.0 SVGA dongle support (Net2280/SiS315)" | 3 | tristate "USB 2.0 SVGA dongle support (Net2280/SiS315)" |
4 | depends on USB && USB_EHCI_HCD | 4 | depends on USB && (USB_MUSB_HDRC || USB_EHCI_HCD) |
5 | ---help--- | 5 | ---help--- |
6 | Say Y here if you intend to attach a USB2VGA dongle based on a | 6 | Say Y here if you intend to attach a USB2VGA dongle based on a |
7 | Net2280 and a SiS315 chip. | 7 | Net2280 and a SiS315 chip. |
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c index 5f1a19d1497d..a9f06d76960f 100644 --- a/drivers/usb/misc/usbtest.c +++ b/drivers/usb/misc/usbtest.c | |||
@@ -1072,23 +1072,34 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async) | |||
1072 | */ | 1072 | */ |
1073 | msleep (jiffies % (2 * INTERRUPT_RATE)); | 1073 | msleep (jiffies % (2 * INTERRUPT_RATE)); |
1074 | if (async) { | 1074 | if (async) { |
1075 | retry: | 1075 | while (!completion_done(&completion)) { |
1076 | retval = usb_unlink_urb (urb); | 1076 | retval = usb_unlink_urb(urb); |
1077 | if (retval == -EBUSY || retval == -EIDRM) { | 1077 | |
1078 | /* we can't unlink urbs while they're completing. | 1078 | switch (retval) { |
1079 | * or if they've completed, and we haven't resubmitted. | 1079 | case -EBUSY: |
1080 | * "normal" drivers would prevent resubmission, but | 1080 | case -EIDRM: |
1081 | * since we're testing unlink paths, we can't. | 1081 | /* we can't unlink urbs while they're completing |
1082 | */ | 1082 | * or if they've completed, and we haven't |
1083 | ERROR(dev, "unlink retry\n"); | 1083 | * resubmitted. "normal" drivers would prevent |
1084 | goto retry; | 1084 | * resubmission, but since we're testing unlink |
1085 | * paths, we can't. | ||
1086 | */ | ||
1087 | ERROR(dev, "unlink retry\n"); | ||
1088 | continue; | ||
1089 | case 0: | ||
1090 | case -EINPROGRESS: | ||
1091 | break; | ||
1092 | |||
1093 | default: | ||
1094 | dev_err(&dev->intf->dev, | ||
1095 | "unlink fail %d\n", retval); | ||
1096 | return retval; | ||
1097 | } | ||
1098 | |||
1099 | break; | ||
1085 | } | 1100 | } |
1086 | } else | 1101 | } else |
1087 | usb_kill_urb (urb); | 1102 | usb_kill_urb (urb); |
1088 | if (!(retval == 0 || retval == -EINPROGRESS)) { | ||
1089 | dev_err(&dev->intf->dev, "unlink fail %d\n", retval); | ||
1090 | return retval; | ||
1091 | } | ||
1092 | 1103 | ||
1093 | wait_for_completion (&completion); | 1104 | wait_for_completion (&completion); |
1094 | retval = urb->status; | 1105 | retval = urb->status; |
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c index 1f715436d6d3..a7eb4c99342c 100644 --- a/drivers/usb/mon/mon_text.c +++ b/drivers/usb/mon/mon_text.c | |||
@@ -733,7 +733,7 @@ int __init mon_text_init(void) | |||
733 | { | 733 | { |
734 | struct dentry *mondir; | 734 | struct dentry *mondir; |
735 | 735 | ||
736 | mondir = debugfs_create_dir("usbmon", NULL); | 736 | mondir = debugfs_create_dir("usbmon", usb_debug_root); |
737 | if (IS_ERR(mondir)) { | 737 | if (IS_ERR(mondir)) { |
738 | printk(KERN_NOTICE TAG ": debugfs is not available\n"); | 738 | printk(KERN_NOTICE TAG ": debugfs is not available\n"); |
739 | return -ENODEV; | 739 | return -ENODEV; |
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig index b66e8544d8b9..70073b157f0a 100644 --- a/drivers/usb/musb/Kconfig +++ b/drivers/usb/musb/Kconfig | |||
@@ -10,6 +10,7 @@ comment "Enable Host or Gadget support to see Inventra options" | |||
10 | config USB_MUSB_HDRC | 10 | config USB_MUSB_HDRC |
11 | depends on (USB || USB_GADGET) && HAVE_CLK | 11 | depends on (USB || USB_GADGET) && HAVE_CLK |
12 | depends on !SUPERH | 12 | depends on !SUPERH |
13 | select NOP_USB_XCEIV if ARCH_DAVINCI | ||
13 | select TWL4030_USB if MACH_OMAP_3430SDP | 14 | select TWL4030_USB if MACH_OMAP_3430SDP |
14 | select USB_OTG_UTILS | 15 | select USB_OTG_UTILS |
15 | tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)' | 16 | tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)' |
@@ -55,6 +56,7 @@ comment "Blackfin high speed USB Support" | |||
55 | config USB_TUSB6010 | 56 | config USB_TUSB6010 |
56 | boolean "TUSB 6010 support" | 57 | boolean "TUSB 6010 support" |
57 | depends on USB_MUSB_HDRC && !USB_MUSB_SOC | 58 | depends on USB_MUSB_HDRC && !USB_MUSB_SOC |
59 | select NOP_USB_XCEIV | ||
58 | default y | 60 | default y |
59 | help | 61 | help |
60 | The TUSB 6010 chip, from Texas Instruments, connects a discrete | 62 | The TUSB 6010 chip, from Texas Instruments, connects a discrete |
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c index 786134852092..f2f66ebc7362 100644 --- a/drivers/usb/musb/blackfin.c +++ b/drivers/usb/musb/blackfin.c | |||
@@ -143,7 +143,7 @@ static void musb_conn_timer_handler(unsigned long _musb) | |||
143 | u16 val; | 143 | u16 val; |
144 | 144 | ||
145 | spin_lock_irqsave(&musb->lock, flags); | 145 | spin_lock_irqsave(&musb->lock, flags); |
146 | switch (musb->xceiv.state) { | 146 | switch (musb->xceiv->state) { |
147 | case OTG_STATE_A_IDLE: | 147 | case OTG_STATE_A_IDLE: |
148 | case OTG_STATE_A_WAIT_BCON: | 148 | case OTG_STATE_A_WAIT_BCON: |
149 | /* Start a new session */ | 149 | /* Start a new session */ |
@@ -154,7 +154,7 @@ static void musb_conn_timer_handler(unsigned long _musb) | |||
154 | val = musb_readw(musb->mregs, MUSB_DEVCTL); | 154 | val = musb_readw(musb->mregs, MUSB_DEVCTL); |
155 | if (!(val & MUSB_DEVCTL_BDEVICE)) { | 155 | if (!(val & MUSB_DEVCTL_BDEVICE)) { |
156 | gpio_set_value(musb->config->gpio_vrsel, 1); | 156 | gpio_set_value(musb->config->gpio_vrsel, 1); |
157 | musb->xceiv.state = OTG_STATE_A_WAIT_BCON; | 157 | musb->xceiv->state = OTG_STATE_A_WAIT_BCON; |
158 | } else { | 158 | } else { |
159 | gpio_set_value(musb->config->gpio_vrsel, 0); | 159 | gpio_set_value(musb->config->gpio_vrsel, 0); |
160 | 160 | ||
@@ -247,6 +247,11 @@ int __init musb_platform_init(struct musb *musb) | |||
247 | } | 247 | } |
248 | gpio_direction_output(musb->config->gpio_vrsel, 0); | 248 | gpio_direction_output(musb->config->gpio_vrsel, 0); |
249 | 249 | ||
250 | usb_nop_xceiv_register(); | ||
251 | musb->xceiv = otg_get_transceiver(); | ||
252 | if (!musb->xceiv) | ||
253 | return -ENODEV; | ||
254 | |||
250 | if (ANOMALY_05000346) { | 255 | if (ANOMALY_05000346) { |
251 | bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value); | 256 | bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value); |
252 | SSYNC(); | 257 | SSYNC(); |
@@ -291,7 +296,7 @@ int __init musb_platform_init(struct musb *musb) | |||
291 | musb_conn_timer_handler, (unsigned long) musb); | 296 | musb_conn_timer_handler, (unsigned long) musb); |
292 | } | 297 | } |
293 | if (is_peripheral_enabled(musb)) | 298 | if (is_peripheral_enabled(musb)) |
294 | musb->xceiv.set_power = bfin_set_power; | 299 | musb->xceiv->set_power = bfin_set_power; |
295 | 300 | ||
296 | musb->isr = blackfin_interrupt; | 301 | musb->isr = blackfin_interrupt; |
297 | 302 | ||
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c index 1976e9b41800..c3577bbbae6c 100644 --- a/drivers/usb/musb/cppi_dma.c +++ b/drivers/usb/musb/cppi_dma.c | |||
@@ -6,6 +6,7 @@ | |||
6 | * The TUSB6020, using VLYNQ, has CPPI that looks much like DaVinci. | 6 | * The TUSB6020, using VLYNQ, has CPPI that looks much like DaVinci. |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include <linux/platform_device.h> | ||
9 | #include <linux/usb.h> | 10 | #include <linux/usb.h> |
10 | 11 | ||
11 | #include "musb_core.h" | 12 | #include "musb_core.h" |
@@ -1145,17 +1146,27 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch) | |||
1145 | return completed; | 1146 | return completed; |
1146 | } | 1147 | } |
1147 | 1148 | ||
1148 | void cppi_completion(struct musb *musb, u32 rx, u32 tx) | 1149 | irqreturn_t cppi_interrupt(int irq, void *dev_id) |
1149 | { | 1150 | { |
1150 | void __iomem *tibase; | 1151 | struct musb *musb = dev_id; |
1151 | int i, index; | ||
1152 | struct cppi *cppi; | 1152 | struct cppi *cppi; |
1153 | void __iomem *tibase; | ||
1153 | struct musb_hw_ep *hw_ep = NULL; | 1154 | struct musb_hw_ep *hw_ep = NULL; |
1155 | u32 rx, tx; | ||
1156 | int i, index; | ||
1154 | 1157 | ||
1155 | cppi = container_of(musb->dma_controller, struct cppi, controller); | 1158 | cppi = container_of(musb->dma_controller, struct cppi, controller); |
1156 | 1159 | ||
1157 | tibase = musb->ctrl_base; | 1160 | tibase = musb->ctrl_base; |
1158 | 1161 | ||
1162 | tx = musb_readl(tibase, DAVINCI_TXCPPI_MASKED_REG); | ||
1163 | rx = musb_readl(tibase, DAVINCI_RXCPPI_MASKED_REG); | ||
1164 | |||
1165 | if (!tx && !rx) | ||
1166 | return IRQ_NONE; | ||
1167 | |||
1168 | DBG(4, "CPPI IRQ Tx%x Rx%x\n", tx, rx); | ||
1169 | |||
1159 | /* process TX channels */ | 1170 | /* process TX channels */ |
1160 | for (index = 0; tx; tx = tx >> 1, index++) { | 1171 | for (index = 0; tx; tx = tx >> 1, index++) { |
1161 | struct cppi_channel *tx_ch; | 1172 | struct cppi_channel *tx_ch; |
@@ -1273,6 +1284,8 @@ void cppi_completion(struct musb *musb, u32 rx, u32 tx) | |||
1273 | 1284 | ||
1274 | /* write to CPPI EOI register to re-enable interrupts */ | 1285 | /* write to CPPI EOI register to re-enable interrupts */ |
1275 | musb_writel(tibase, DAVINCI_CPPI_EOI_REG, 0); | 1286 | musb_writel(tibase, DAVINCI_CPPI_EOI_REG, 0); |
1287 | |||
1288 | return IRQ_HANDLED; | ||
1276 | } | 1289 | } |
1277 | 1290 | ||
1278 | /* Instantiate a software object representing a DMA controller. */ | 1291 | /* Instantiate a software object representing a DMA controller. */ |
@@ -1280,6 +1293,9 @@ struct dma_controller *__init | |||
1280 | dma_controller_create(struct musb *musb, void __iomem *mregs) | 1293 | dma_controller_create(struct musb *musb, void __iomem *mregs) |
1281 | { | 1294 | { |
1282 | struct cppi *controller; | 1295 | struct cppi *controller; |
1296 | struct device *dev = musb->controller; | ||
1297 | struct platform_device *pdev = to_platform_device(dev); | ||
1298 | int irq = platform_get_irq(pdev, 1); | ||
1283 | 1299 | ||
1284 | controller = kzalloc(sizeof *controller, GFP_KERNEL); | 1300 | controller = kzalloc(sizeof *controller, GFP_KERNEL); |
1285 | if (!controller) | 1301 | if (!controller) |
@@ -1310,6 +1326,15 @@ dma_controller_create(struct musb *musb, void __iomem *mregs) | |||
1310 | return NULL; | 1326 | return NULL; |
1311 | } | 1327 | } |
1312 | 1328 | ||
1329 | if (irq > 0) { | ||
1330 | if (request_irq(irq, cppi_interrupt, 0, "cppi-dma", musb)) { | ||
1331 | dev_err(dev, "request_irq %d failed!\n", irq); | ||
1332 | dma_controller_destroy(&controller->controller); | ||
1333 | return NULL; | ||
1334 | } | ||
1335 | controller->irq = irq; | ||
1336 | } | ||
1337 | |||
1313 | return &controller->controller; | 1338 | return &controller->controller; |
1314 | } | 1339 | } |
1315 | 1340 | ||
@@ -1322,6 +1347,9 @@ void dma_controller_destroy(struct dma_controller *c) | |||
1322 | 1347 | ||
1323 | cppi = container_of(c, struct cppi, controller); | 1348 | cppi = container_of(c, struct cppi, controller); |
1324 | 1349 | ||
1350 | if (cppi->irq) | ||
1351 | free_irq(cppi->irq, cppi->musb); | ||
1352 | |||
1325 | /* assert: caller stopped the controller first */ | 1353 | /* assert: caller stopped the controller first */ |
1326 | dma_pool_destroy(cppi->pool); | 1354 | dma_pool_destroy(cppi->pool); |
1327 | 1355 | ||
diff --git a/drivers/usb/musb/cppi_dma.h b/drivers/usb/musb/cppi_dma.h index 729b4071787b..8a39de3e6e47 100644 --- a/drivers/usb/musb/cppi_dma.h +++ b/drivers/usb/musb/cppi_dma.h | |||
@@ -119,6 +119,8 @@ struct cppi { | |||
119 | void __iomem *mregs; /* Mentor regs */ | 119 | void __iomem *mregs; /* Mentor regs */ |
120 | void __iomem *tibase; /* TI/CPPI regs */ | 120 | void __iomem *tibase; /* TI/CPPI regs */ |
121 | 121 | ||
122 | int irq; | ||
123 | |||
122 | struct cppi_channel tx[4]; | 124 | struct cppi_channel tx[4]; |
123 | struct cppi_channel rx[4]; | 125 | struct cppi_channel rx[4]; |
124 | 126 | ||
@@ -127,7 +129,7 @@ struct cppi { | |||
127 | struct list_head tx_complete; | 129 | struct list_head tx_complete; |
128 | }; | 130 | }; |
129 | 131 | ||
130 | /* irq handling hook */ | 132 | /* CPPI IRQ handler */ |
131 | extern void cppi_completion(struct musb *, u32 rx, u32 tx); | 133 | extern irqreturn_t cppi_interrupt(int, void *); |
132 | 134 | ||
133 | #endif /* end of ifndef _CPPI_DMA_H_ */ | 135 | #endif /* end of ifndef _CPPI_DMA_H_ */ |
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c index 10d11ab113ab..180d7daa4099 100644 --- a/drivers/usb/musb/davinci.c +++ b/drivers/usb/musb/davinci.c | |||
@@ -215,7 +215,7 @@ static void otg_timer(unsigned long _musb) | |||
215 | DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb)); | 215 | DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb)); |
216 | 216 | ||
217 | spin_lock_irqsave(&musb->lock, flags); | 217 | spin_lock_irqsave(&musb->lock, flags); |
218 | switch (musb->xceiv.state) { | 218 | switch (musb->xceiv->state) { |
219 | case OTG_STATE_A_WAIT_VFALL: | 219 | case OTG_STATE_A_WAIT_VFALL: |
220 | /* Wait till VBUS falls below SessionEnd (~0.2V); the 1.3 RTL | 220 | /* Wait till VBUS falls below SessionEnd (~0.2V); the 1.3 RTL |
221 | * seems to mis-handle session "start" otherwise (or in our | 221 | * seems to mis-handle session "start" otherwise (or in our |
@@ -226,7 +226,7 @@ static void otg_timer(unsigned long _musb) | |||
226 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); | 226 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); |
227 | break; | 227 | break; |
228 | } | 228 | } |
229 | musb->xceiv.state = OTG_STATE_A_WAIT_VRISE; | 229 | musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; |
230 | musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG, | 230 | musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG, |
231 | MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT); | 231 | MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT); |
232 | break; | 232 | break; |
@@ -251,7 +251,7 @@ static void otg_timer(unsigned long _musb) | |||
251 | if (devctl & MUSB_DEVCTL_BDEVICE) | 251 | if (devctl & MUSB_DEVCTL_BDEVICE) |
252 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); | 252 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); |
253 | else | 253 | else |
254 | musb->xceiv.state = OTG_STATE_A_IDLE; | 254 | musb->xceiv->state = OTG_STATE_A_IDLE; |
255 | break; | 255 | break; |
256 | default: | 256 | default: |
257 | break; | 257 | break; |
@@ -265,6 +265,7 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci) | |||
265 | irqreturn_t retval = IRQ_NONE; | 265 | irqreturn_t retval = IRQ_NONE; |
266 | struct musb *musb = __hci; | 266 | struct musb *musb = __hci; |
267 | void __iomem *tibase = musb->ctrl_base; | 267 | void __iomem *tibase = musb->ctrl_base; |
268 | struct cppi *cppi; | ||
268 | u32 tmp; | 269 | u32 tmp; |
269 | 270 | ||
270 | spin_lock_irqsave(&musb->lock, flags); | 271 | spin_lock_irqsave(&musb->lock, flags); |
@@ -281,16 +282,9 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci) | |||
281 | /* CPPI interrupts share the same IRQ line, but have their own | 282 | /* CPPI interrupts share the same IRQ line, but have their own |
282 | * mask, state, "vector", and EOI registers. | 283 | * mask, state, "vector", and EOI registers. |
283 | */ | 284 | */ |
284 | if (is_cppi_enabled()) { | 285 | cppi = container_of(musb->dma_controller, struct cppi, controller); |
285 | u32 cppi_tx = musb_readl(tibase, DAVINCI_TXCPPI_MASKED_REG); | 286 | if (is_cppi_enabled() && musb->dma_controller && !cppi->irq) |
286 | u32 cppi_rx = musb_readl(tibase, DAVINCI_RXCPPI_MASKED_REG); | 287 | retval = cppi_interrupt(irq, __hci); |
287 | |||
288 | if (cppi_tx || cppi_rx) { | ||
289 | DBG(4, "CPPI IRQ t%x r%x\n", cppi_tx, cppi_rx); | ||
290 | cppi_completion(musb, cppi_rx, cppi_tx); | ||
291 | retval = IRQ_HANDLED; | ||
292 | } | ||
293 | } | ||
294 | 288 | ||
295 | /* ack and handle non-CPPI interrupts */ | 289 | /* ack and handle non-CPPI interrupts */ |
296 | tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG); | 290 | tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG); |
@@ -331,21 +325,21 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci) | |||
331 | * to stop registering in devctl. | 325 | * to stop registering in devctl. |
332 | */ | 326 | */ |
333 | musb->int_usb &= ~MUSB_INTR_VBUSERROR; | 327 | musb->int_usb &= ~MUSB_INTR_VBUSERROR; |
334 | musb->xceiv.state = OTG_STATE_A_WAIT_VFALL; | 328 | musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; |
335 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); | 329 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); |
336 | WARNING("VBUS error workaround (delay coming)\n"); | 330 | WARNING("VBUS error workaround (delay coming)\n"); |
337 | } else if (is_host_enabled(musb) && drvvbus) { | 331 | } else if (is_host_enabled(musb) && drvvbus) { |
338 | musb->is_active = 1; | 332 | musb->is_active = 1; |
339 | MUSB_HST_MODE(musb); | 333 | MUSB_HST_MODE(musb); |
340 | musb->xceiv.default_a = 1; | 334 | musb->xceiv->default_a = 1; |
341 | musb->xceiv.state = OTG_STATE_A_WAIT_VRISE; | 335 | musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; |
342 | portstate(musb->port1_status |= USB_PORT_STAT_POWER); | 336 | portstate(musb->port1_status |= USB_PORT_STAT_POWER); |
343 | del_timer(&otg_workaround); | 337 | del_timer(&otg_workaround); |
344 | } else { | 338 | } else { |
345 | musb->is_active = 0; | 339 | musb->is_active = 0; |
346 | MUSB_DEV_MODE(musb); | 340 | MUSB_DEV_MODE(musb); |
347 | musb->xceiv.default_a = 0; | 341 | musb->xceiv->default_a = 0; |
348 | musb->xceiv.state = OTG_STATE_B_IDLE; | 342 | musb->xceiv->state = OTG_STATE_B_IDLE; |
349 | portstate(musb->port1_status &= ~USB_PORT_STAT_POWER); | 343 | portstate(musb->port1_status &= ~USB_PORT_STAT_POWER); |
350 | } | 344 | } |
351 | 345 | ||
@@ -367,17 +361,12 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci) | |||
367 | 361 | ||
368 | /* poll for ID change */ | 362 | /* poll for ID change */ |
369 | if (is_otg_enabled(musb) | 363 | if (is_otg_enabled(musb) |
370 | && musb->xceiv.state == OTG_STATE_B_IDLE) | 364 | && musb->xceiv->state == OTG_STATE_B_IDLE) |
371 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); | 365 | mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); |
372 | 366 | ||
373 | spin_unlock_irqrestore(&musb->lock, flags); | 367 | spin_unlock_irqrestore(&musb->lock, flags); |
374 | 368 | ||
375 | /* REVISIT we sometimes get unhandled IRQs | 369 | return retval; |
376 | * (e.g. ep0). not clear why... | ||
377 | */ | ||
378 | if (retval != IRQ_HANDLED) | ||
379 | DBG(5, "unhandled? %08x\n", tmp); | ||
380 | return IRQ_HANDLED; | ||
381 | } | 370 | } |
382 | 371 | ||
383 | int musb_platform_set_mode(struct musb *musb, u8 mode) | 372 | int musb_platform_set_mode(struct musb *musb, u8 mode) |
@@ -391,6 +380,11 @@ int __init musb_platform_init(struct musb *musb) | |||
391 | void __iomem *tibase = musb->ctrl_base; | 380 | void __iomem *tibase = musb->ctrl_base; |
392 | u32 revision; | 381 | u32 revision; |
393 | 382 | ||
383 | usb_nop_xceiv_register(); | ||
384 | musb->xceiv = otg_get_transceiver(); | ||
385 | if (!musb->xceiv) | ||
386 | return -ENODEV; | ||
387 | |||
394 | musb->mregs += DAVINCI_BASE_OFFSET; | 388 | musb->mregs += DAVINCI_BASE_OFFSET; |
395 | 389 | ||
396 | clk_enable(musb->clock); | 390 | clk_enable(musb->clock); |
@@ -398,7 +392,7 @@ int __init musb_platform_init(struct musb *musb) | |||
398 | /* returns zero if e.g. not clocked */ | 392 | /* returns zero if e.g. not clocked */ |
399 | revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG); | 393 | revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG); |
400 | if (revision == 0) | 394 | if (revision == 0) |
401 | return -ENODEV; | 395 | goto fail; |
402 | 396 | ||
403 | if (is_host_enabled(musb)) | 397 | if (is_host_enabled(musb)) |
404 | setup_timer(&otg_workaround, otg_timer, (unsigned long) musb); | 398 | setup_timer(&otg_workaround, otg_timer, (unsigned long) musb); |
@@ -432,6 +426,10 @@ int __init musb_platform_init(struct musb *musb) | |||
432 | 426 | ||
433 | musb->isr = davinci_interrupt; | 427 | musb->isr = davinci_interrupt; |
434 | return 0; | 428 | return 0; |
429 | |||
430 | fail: | ||
431 | usb_nop_xceiv_unregister(); | ||
432 | return -ENODEV; | ||
435 | } | 433 | } |
436 | 434 | ||
437 | int musb_platform_exit(struct musb *musb) | 435 | int musb_platform_exit(struct musb *musb) |
@@ -442,7 +440,7 @@ int musb_platform_exit(struct musb *musb) | |||
442 | davinci_source_power(musb, 0 /*off*/, 1); | 440 | davinci_source_power(musb, 0 /*off*/, 1); |
443 | 441 | ||
444 | /* delay, to avoid problems with module reload */ | 442 | /* delay, to avoid problems with module reload */ |
445 | if (is_host_enabled(musb) && musb->xceiv.default_a) { | 443 | if (is_host_enabled(musb) && musb->xceiv->default_a) { |
446 | int maxdelay = 30; | 444 | int maxdelay = 30; |
447 | u8 devctl, warn = 0; | 445 | u8 devctl, warn = 0; |
448 | 446 | ||
@@ -471,5 +469,7 @@ int musb_platform_exit(struct musb *musb) | |||
471 | 469 | ||
472 | clk_disable(musb->clock); | 470 | clk_disable(musb->clock); |
473 | 471 | ||
472 | usb_nop_xceiv_unregister(); | ||
473 | |||
474 | return 0; | 474 | return 0; |
475 | } | 475 | } |
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c index 4000cf6d1e81..554a414f65d1 100644 --- a/drivers/usb/musb/musb_core.c +++ b/drivers/usb/musb/musb_core.c | |||
@@ -112,6 +112,7 @@ | |||
112 | #include "davinci.h" | 112 | #include "davinci.h" |
113 | #endif | 113 | #endif |
114 | 114 | ||
115 | #define TA_WAIT_BCON(m) max_t(int, (m)->a_wait_bcon, OTG_TIME_A_WAIT_BCON) | ||
115 | 116 | ||
116 | 117 | ||
117 | unsigned musb_debug; | 118 | unsigned musb_debug; |
@@ -267,7 +268,7 @@ void musb_load_testpacket(struct musb *musb) | |||
267 | 268 | ||
268 | const char *otg_state_string(struct musb *musb) | 269 | const char *otg_state_string(struct musb *musb) |
269 | { | 270 | { |
270 | switch (musb->xceiv.state) { | 271 | switch (musb->xceiv->state) { |
271 | case OTG_STATE_A_IDLE: return "a_idle"; | 272 | case OTG_STATE_A_IDLE: return "a_idle"; |
272 | case OTG_STATE_A_WAIT_VRISE: return "a_wait_vrise"; | 273 | case OTG_STATE_A_WAIT_VRISE: return "a_wait_vrise"; |
273 | case OTG_STATE_A_WAIT_BCON: return "a_wait_bcon"; | 274 | case OTG_STATE_A_WAIT_BCON: return "a_wait_bcon"; |
@@ -288,12 +289,6 @@ const char *otg_state_string(struct musb *musb) | |||
288 | #ifdef CONFIG_USB_MUSB_OTG | 289 | #ifdef CONFIG_USB_MUSB_OTG |
289 | 290 | ||
290 | /* | 291 | /* |
291 | * See also USB_OTG_1-3.pdf 6.6.5 Timers | ||
292 | * REVISIT: Are the other timers done in the hardware? | ||
293 | */ | ||
294 | #define TB_ASE0_BRST 100 /* Min 3.125 ms */ | ||
295 | |||
296 | /* | ||
297 | * Handles OTG hnp timeouts, such as b_ase0_brst | 292 | * Handles OTG hnp timeouts, such as b_ase0_brst |
298 | */ | 293 | */ |
299 | void musb_otg_timer_func(unsigned long data) | 294 | void musb_otg_timer_func(unsigned long data) |
@@ -302,16 +297,18 @@ void musb_otg_timer_func(unsigned long data) | |||
302 | unsigned long flags; | 297 | unsigned long flags; |
303 | 298 | ||
304 | spin_lock_irqsave(&musb->lock, flags); | 299 | spin_lock_irqsave(&musb->lock, flags); |
305 | switch (musb->xceiv.state) { | 300 | switch (musb->xceiv->state) { |
306 | case OTG_STATE_B_WAIT_ACON: | 301 | case OTG_STATE_B_WAIT_ACON: |
307 | DBG(1, "HNP: b_wait_acon timeout; back to b_peripheral\n"); | 302 | DBG(1, "HNP: b_wait_acon timeout; back to b_peripheral\n"); |
308 | musb_g_disconnect(musb); | 303 | musb_g_disconnect(musb); |
309 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 304 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
310 | musb->is_active = 0; | 305 | musb->is_active = 0; |
311 | break; | 306 | break; |
307 | case OTG_STATE_A_SUSPEND: | ||
312 | case OTG_STATE_A_WAIT_BCON: | 308 | case OTG_STATE_A_WAIT_BCON: |
313 | DBG(1, "HNP: a_wait_bcon timeout; back to a_host\n"); | 309 | DBG(1, "HNP: %s timeout\n", otg_state_string(musb)); |
314 | musb_hnp_stop(musb); | 310 | musb_set_vbus(musb, 0); |
311 | musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; | ||
315 | break; | 312 | break; |
316 | default: | 313 | default: |
317 | DBG(1, "HNP: Unhandled mode %s\n", otg_state_string(musb)); | 314 | DBG(1, "HNP: Unhandled mode %s\n", otg_state_string(musb)); |
@@ -320,10 +317,8 @@ void musb_otg_timer_func(unsigned long data) | |||
320 | spin_unlock_irqrestore(&musb->lock, flags); | 317 | spin_unlock_irqrestore(&musb->lock, flags); |
321 | } | 318 | } |
322 | 319 | ||
323 | static DEFINE_TIMER(musb_otg_timer, musb_otg_timer_func, 0, 0); | ||
324 | |||
325 | /* | 320 | /* |
326 | * Stops the B-device HNP state. Caller must take care of locking. | 321 | * Stops the HNP transition. Caller must take care of locking. |
327 | */ | 322 | */ |
328 | void musb_hnp_stop(struct musb *musb) | 323 | void musb_hnp_stop(struct musb *musb) |
329 | { | 324 | { |
@@ -331,20 +326,17 @@ void musb_hnp_stop(struct musb *musb) | |||
331 | void __iomem *mbase = musb->mregs; | 326 | void __iomem *mbase = musb->mregs; |
332 | u8 reg; | 327 | u8 reg; |
333 | 328 | ||
334 | switch (musb->xceiv.state) { | 329 | DBG(1, "HNP: stop from %s\n", otg_state_string(musb)); |
330 | |||
331 | switch (musb->xceiv->state) { | ||
335 | case OTG_STATE_A_PERIPHERAL: | 332 | case OTG_STATE_A_PERIPHERAL: |
336 | case OTG_STATE_A_WAIT_VFALL: | ||
337 | case OTG_STATE_A_WAIT_BCON: | ||
338 | DBG(1, "HNP: Switching back to A-host\n"); | ||
339 | musb_g_disconnect(musb); | 333 | musb_g_disconnect(musb); |
340 | musb->xceiv.state = OTG_STATE_A_IDLE; | 334 | DBG(1, "HNP: back to %s\n", otg_state_string(musb)); |
341 | MUSB_HST_MODE(musb); | ||
342 | musb->is_active = 0; | ||
343 | break; | 335 | break; |
344 | case OTG_STATE_B_HOST: | 336 | case OTG_STATE_B_HOST: |
345 | DBG(1, "HNP: Disabling HR\n"); | 337 | DBG(1, "HNP: Disabling HR\n"); |
346 | hcd->self.is_b_host = 0; | 338 | hcd->self.is_b_host = 0; |
347 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 339 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
348 | MUSB_DEV_MODE(musb); | 340 | MUSB_DEV_MODE(musb); |
349 | reg = musb_readb(mbase, MUSB_POWER); | 341 | reg = musb_readb(mbase, MUSB_POWER); |
350 | reg |= MUSB_POWER_SUSPENDM; | 342 | reg |= MUSB_POWER_SUSPENDM; |
@@ -402,7 +394,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
402 | 394 | ||
403 | if (devctl & MUSB_DEVCTL_HM) { | 395 | if (devctl & MUSB_DEVCTL_HM) { |
404 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 396 | #ifdef CONFIG_USB_MUSB_HDRC_HCD |
405 | switch (musb->xceiv.state) { | 397 | switch (musb->xceiv->state) { |
406 | case OTG_STATE_A_SUSPEND: | 398 | case OTG_STATE_A_SUSPEND: |
407 | /* remote wakeup? later, GetPortStatus | 399 | /* remote wakeup? later, GetPortStatus |
408 | * will stop RESUME signaling | 400 | * will stop RESUME signaling |
@@ -425,12 +417,12 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
425 | musb->rh_timer = jiffies | 417 | musb->rh_timer = jiffies |
426 | + msecs_to_jiffies(20); | 418 | + msecs_to_jiffies(20); |
427 | 419 | ||
428 | musb->xceiv.state = OTG_STATE_A_HOST; | 420 | musb->xceiv->state = OTG_STATE_A_HOST; |
429 | musb->is_active = 1; | 421 | musb->is_active = 1; |
430 | usb_hcd_resume_root_hub(musb_to_hcd(musb)); | 422 | usb_hcd_resume_root_hub(musb_to_hcd(musb)); |
431 | break; | 423 | break; |
432 | case OTG_STATE_B_WAIT_ACON: | 424 | case OTG_STATE_B_WAIT_ACON: |
433 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 425 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
434 | musb->is_active = 1; | 426 | musb->is_active = 1; |
435 | MUSB_DEV_MODE(musb); | 427 | MUSB_DEV_MODE(musb); |
436 | break; | 428 | break; |
@@ -441,11 +433,11 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
441 | } | 433 | } |
442 | #endif | 434 | #endif |
443 | } else { | 435 | } else { |
444 | switch (musb->xceiv.state) { | 436 | switch (musb->xceiv->state) { |
445 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 437 | #ifdef CONFIG_USB_MUSB_HDRC_HCD |
446 | case OTG_STATE_A_SUSPEND: | 438 | case OTG_STATE_A_SUSPEND: |
447 | /* possibly DISCONNECT is upcoming */ | 439 | /* possibly DISCONNECT is upcoming */ |
448 | musb->xceiv.state = OTG_STATE_A_HOST; | 440 | musb->xceiv->state = OTG_STATE_A_HOST; |
449 | usb_hcd_resume_root_hub(musb_to_hcd(musb)); | 441 | usb_hcd_resume_root_hub(musb_to_hcd(musb)); |
450 | break; | 442 | break; |
451 | #endif | 443 | #endif |
@@ -490,7 +482,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
490 | */ | 482 | */ |
491 | musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION); | 483 | musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION); |
492 | musb->ep0_stage = MUSB_EP0_START; | 484 | musb->ep0_stage = MUSB_EP0_START; |
493 | musb->xceiv.state = OTG_STATE_A_IDLE; | 485 | musb->xceiv->state = OTG_STATE_A_IDLE; |
494 | MUSB_HST_MODE(musb); | 486 | MUSB_HST_MODE(musb); |
495 | musb_set_vbus(musb, 1); | 487 | musb_set_vbus(musb, 1); |
496 | 488 | ||
@@ -516,7 +508,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
516 | * REVISIT: do delays from lots of DEBUG_KERNEL checks | 508 | * REVISIT: do delays from lots of DEBUG_KERNEL checks |
517 | * make trouble here, keeping VBUS < 4.4V ? | 509 | * make trouble here, keeping VBUS < 4.4V ? |
518 | */ | 510 | */ |
519 | switch (musb->xceiv.state) { | 511 | switch (musb->xceiv->state) { |
520 | case OTG_STATE_A_HOST: | 512 | case OTG_STATE_A_HOST: |
521 | /* recovery is dicey once we've gotten past the | 513 | /* recovery is dicey once we've gotten past the |
522 | * initial stages of enumeration, but if VBUS | 514 | * initial stages of enumeration, but if VBUS |
@@ -594,37 +586,40 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
594 | if (devctl & MUSB_DEVCTL_LSDEV) | 586 | if (devctl & MUSB_DEVCTL_LSDEV) |
595 | musb->port1_status |= USB_PORT_STAT_LOW_SPEED; | 587 | musb->port1_status |= USB_PORT_STAT_LOW_SPEED; |
596 | 588 | ||
597 | if (hcd->status_urb) | ||
598 | usb_hcd_poll_rh_status(hcd); | ||
599 | else | ||
600 | usb_hcd_resume_root_hub(hcd); | ||
601 | |||
602 | MUSB_HST_MODE(musb); | ||
603 | |||
604 | /* indicate new connection to OTG machine */ | 589 | /* indicate new connection to OTG machine */ |
605 | switch (musb->xceiv.state) { | 590 | switch (musb->xceiv->state) { |
606 | case OTG_STATE_B_PERIPHERAL: | 591 | case OTG_STATE_B_PERIPHERAL: |
607 | if (int_usb & MUSB_INTR_SUSPEND) { | 592 | if (int_usb & MUSB_INTR_SUSPEND) { |
608 | DBG(1, "HNP: SUSPEND+CONNECT, now b_host\n"); | 593 | DBG(1, "HNP: SUSPEND+CONNECT, now b_host\n"); |
609 | musb->xceiv.state = OTG_STATE_B_HOST; | ||
610 | hcd->self.is_b_host = 1; | ||
611 | int_usb &= ~MUSB_INTR_SUSPEND; | 594 | int_usb &= ~MUSB_INTR_SUSPEND; |
595 | goto b_host; | ||
612 | } else | 596 | } else |
613 | DBG(1, "CONNECT as b_peripheral???\n"); | 597 | DBG(1, "CONNECT as b_peripheral???\n"); |
614 | break; | 598 | break; |
615 | case OTG_STATE_B_WAIT_ACON: | 599 | case OTG_STATE_B_WAIT_ACON: |
616 | DBG(1, "HNP: Waiting to switch to b_host state\n"); | 600 | DBG(1, "HNP: CONNECT, now b_host\n"); |
617 | musb->xceiv.state = OTG_STATE_B_HOST; | 601 | b_host: |
602 | musb->xceiv->state = OTG_STATE_B_HOST; | ||
618 | hcd->self.is_b_host = 1; | 603 | hcd->self.is_b_host = 1; |
604 | musb->ignore_disconnect = 0; | ||
605 | del_timer(&musb->otg_timer); | ||
619 | break; | 606 | break; |
620 | default: | 607 | default: |
621 | if ((devctl & MUSB_DEVCTL_VBUS) | 608 | if ((devctl & MUSB_DEVCTL_VBUS) |
622 | == (3 << MUSB_DEVCTL_VBUS_SHIFT)) { | 609 | == (3 << MUSB_DEVCTL_VBUS_SHIFT)) { |
623 | musb->xceiv.state = OTG_STATE_A_HOST; | 610 | musb->xceiv->state = OTG_STATE_A_HOST; |
624 | hcd->self.is_b_host = 0; | 611 | hcd->self.is_b_host = 0; |
625 | } | 612 | } |
626 | break; | 613 | break; |
627 | } | 614 | } |
615 | |||
616 | /* poke the root hub */ | ||
617 | MUSB_HST_MODE(musb); | ||
618 | if (hcd->status_urb) | ||
619 | usb_hcd_poll_rh_status(hcd); | ||
620 | else | ||
621 | usb_hcd_resume_root_hub(hcd); | ||
622 | |||
628 | DBG(1, "CONNECT (%s) devctl %02x\n", | 623 | DBG(1, "CONNECT (%s) devctl %02x\n", |
629 | otg_state_string(musb), devctl); | 624 | otg_state_string(musb), devctl); |
630 | } | 625 | } |
@@ -650,7 +645,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
650 | } | 645 | } |
651 | } else if (is_peripheral_capable()) { | 646 | } else if (is_peripheral_capable()) { |
652 | DBG(1, "BUS RESET as %s\n", otg_state_string(musb)); | 647 | DBG(1, "BUS RESET as %s\n", otg_state_string(musb)); |
653 | switch (musb->xceiv.state) { | 648 | switch (musb->xceiv->state) { |
654 | #ifdef CONFIG_USB_OTG | 649 | #ifdef CONFIG_USB_OTG |
655 | case OTG_STATE_A_SUSPEND: | 650 | case OTG_STATE_A_SUSPEND: |
656 | /* We need to ignore disconnect on suspend | 651 | /* We need to ignore disconnect on suspend |
@@ -661,24 +656,27 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, | |||
661 | musb_g_reset(musb); | 656 | musb_g_reset(musb); |
662 | /* FALLTHROUGH */ | 657 | /* FALLTHROUGH */ |
663 | case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */ | 658 | case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */ |
664 | DBG(1, "HNP: Setting timer as %s\n", | 659 | /* never use invalid T(a_wait_bcon) */ |
665 | otg_state_string(musb)); | 660 | DBG(1, "HNP: in %s, %d msec timeout\n", |
666 | musb_otg_timer.data = (unsigned long)musb; | 661 | otg_state_string(musb), |
667 | mod_timer(&musb_otg_timer, jiffies | 662 | TA_WAIT_BCON(musb)); |
668 | + msecs_to_jiffies(100)); | 663 | mod_timer(&musb->otg_timer, jiffies |
664 | + msecs_to_jiffies(TA_WAIT_BCON(musb))); | ||
669 | break; | 665 | break; |
670 | case OTG_STATE_A_PERIPHERAL: | 666 | case OTG_STATE_A_PERIPHERAL: |
671 | musb_hnp_stop(musb); | 667 | musb->ignore_disconnect = 0; |
668 | del_timer(&musb->otg_timer); | ||
669 | musb_g_reset(musb); | ||
672 | break; | 670 | break; |
673 | case OTG_STATE_B_WAIT_ACON: | 671 | case OTG_STATE_B_WAIT_ACON: |
674 | DBG(1, "HNP: RESET (%s), to b_peripheral\n", | 672 | DBG(1, "HNP: RESET (%s), to b_peripheral\n", |
675 | otg_state_string(musb)); | 673 | otg_state_string(musb)); |
676 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 674 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
677 | musb_g_reset(musb); | 675 | musb_g_reset(musb); |
678 | break; | 676 | break; |
679 | #endif | 677 | #endif |
680 | case OTG_STATE_B_IDLE: | 678 | case OTG_STATE_B_IDLE: |
681 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 679 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
682 | /* FALLTHROUGH */ | 680 | /* FALLTHROUGH */ |
683 | case OTG_STATE_B_PERIPHERAL: | 681 | case OTG_STATE_B_PERIPHERAL: |
684 | musb_g_reset(musb); | 682 | musb_g_reset(musb); |
@@ -763,7 +761,7 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb, | |||
763 | MUSB_MODE(musb), devctl); | 761 | MUSB_MODE(musb), devctl); |
764 | handled = IRQ_HANDLED; | 762 | handled = IRQ_HANDLED; |
765 | 763 | ||
766 | switch (musb->xceiv.state) { | 764 | switch (musb->xceiv->state) { |
767 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 765 | #ifdef CONFIG_USB_MUSB_HDRC_HCD |
768 | case OTG_STATE_A_HOST: | 766 | case OTG_STATE_A_HOST: |
769 | case OTG_STATE_A_SUSPEND: | 767 | case OTG_STATE_A_SUSPEND: |
@@ -776,7 +774,16 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb, | |||
776 | #endif /* HOST */ | 774 | #endif /* HOST */ |
777 | #ifdef CONFIG_USB_MUSB_OTG | 775 | #ifdef CONFIG_USB_MUSB_OTG |
778 | case OTG_STATE_B_HOST: | 776 | case OTG_STATE_B_HOST: |
779 | musb_hnp_stop(musb); | 777 | /* REVISIT this behaves for "real disconnect" |
778 | * cases; make sure the other transitions from | ||
779 | * from B_HOST act right too. The B_HOST code | ||
780 | * in hnp_stop() is currently not used... | ||
781 | */ | ||
782 | musb_root_disconnect(musb); | ||
783 | musb_to_hcd(musb)->self.is_b_host = 0; | ||
784 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; | ||
785 | MUSB_DEV_MODE(musb); | ||
786 | musb_g_disconnect(musb); | ||
780 | break; | 787 | break; |
781 | case OTG_STATE_A_PERIPHERAL: | 788 | case OTG_STATE_A_PERIPHERAL: |
782 | musb_hnp_stop(musb); | 789 | musb_hnp_stop(musb); |
@@ -805,26 +812,35 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb, | |||
805 | otg_state_string(musb), devctl, power); | 812 | otg_state_string(musb), devctl, power); |
806 | handled = IRQ_HANDLED; | 813 | handled = IRQ_HANDLED; |
807 | 814 | ||
808 | switch (musb->xceiv.state) { | 815 | switch (musb->xceiv->state) { |
809 | #ifdef CONFIG_USB_MUSB_OTG | 816 | #ifdef CONFIG_USB_MUSB_OTG |
810 | case OTG_STATE_A_PERIPHERAL: | 817 | case OTG_STATE_A_PERIPHERAL: |
811 | /* | 818 | /* We also come here if the cable is removed, since |
812 | * We cannot stop HNP here, devctl BDEVICE might be | 819 | * this silicon doesn't report ID-no-longer-grounded. |
813 | * still set. | 820 | * |
821 | * We depend on T(a_wait_bcon) to shut us down, and | ||
822 | * hope users don't do anything dicey during this | ||
823 | * undesired detour through A_WAIT_BCON. | ||
814 | */ | 824 | */ |
825 | musb_hnp_stop(musb); | ||
826 | usb_hcd_resume_root_hub(musb_to_hcd(musb)); | ||
827 | musb_root_disconnect(musb); | ||
828 | musb_platform_try_idle(musb, jiffies | ||
829 | + msecs_to_jiffies(musb->a_wait_bcon | ||
830 | ? : OTG_TIME_A_WAIT_BCON)); | ||
815 | break; | 831 | break; |
816 | #endif | 832 | #endif |
817 | case OTG_STATE_B_PERIPHERAL: | 833 | case OTG_STATE_B_PERIPHERAL: |
818 | musb_g_suspend(musb); | 834 | musb_g_suspend(musb); |
819 | musb->is_active = is_otg_enabled(musb) | 835 | musb->is_active = is_otg_enabled(musb) |
820 | && musb->xceiv.gadget->b_hnp_enable; | 836 | && musb->xceiv->gadget->b_hnp_enable; |
821 | if (musb->is_active) { | 837 | if (musb->is_active) { |
822 | #ifdef CONFIG_USB_MUSB_OTG | 838 | #ifdef CONFIG_USB_MUSB_OTG |
823 | musb->xceiv.state = OTG_STATE_B_WAIT_ACON; | 839 | musb->xceiv->state = OTG_STATE_B_WAIT_ACON; |
824 | DBG(1, "HNP: Setting timer for b_ase0_brst\n"); | 840 | DBG(1, "HNP: Setting timer for b_ase0_brst\n"); |
825 | musb_otg_timer.data = (unsigned long)musb; | 841 | mod_timer(&musb->otg_timer, jiffies |
826 | mod_timer(&musb_otg_timer, jiffies | 842 | + msecs_to_jiffies( |
827 | + msecs_to_jiffies(TB_ASE0_BRST)); | 843 | OTG_TIME_B_ASE0_BRST)); |
828 | #endif | 844 | #endif |
829 | } | 845 | } |
830 | break; | 846 | break; |
@@ -834,9 +850,9 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb, | |||
834 | + msecs_to_jiffies(musb->a_wait_bcon)); | 850 | + msecs_to_jiffies(musb->a_wait_bcon)); |
835 | break; | 851 | break; |
836 | case OTG_STATE_A_HOST: | 852 | case OTG_STATE_A_HOST: |
837 | musb->xceiv.state = OTG_STATE_A_SUSPEND; | 853 | musb->xceiv->state = OTG_STATE_A_SUSPEND; |
838 | musb->is_active = is_otg_enabled(musb) | 854 | musb->is_active = is_otg_enabled(musb) |
839 | && musb->xceiv.host->b_hnp_enable; | 855 | && musb->xceiv->host->b_hnp_enable; |
840 | break; | 856 | break; |
841 | case OTG_STATE_B_HOST: | 857 | case OTG_STATE_B_HOST: |
842 | /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */ | 858 | /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */ |
@@ -1068,14 +1084,13 @@ static struct fifo_cfg __initdata mode_4_cfg[] = { | |||
1068 | { .hw_ep_num = 8, .style = FIFO_RX, .maxpacket = 512, }, | 1084 | { .hw_ep_num = 8, .style = FIFO_RX, .maxpacket = 512, }, |
1069 | { .hw_ep_num = 9, .style = FIFO_TX, .maxpacket = 512, }, | 1085 | { .hw_ep_num = 9, .style = FIFO_TX, .maxpacket = 512, }, |
1070 | { .hw_ep_num = 9, .style = FIFO_RX, .maxpacket = 512, }, | 1086 | { .hw_ep_num = 9, .style = FIFO_RX, .maxpacket = 512, }, |
1071 | { .hw_ep_num = 10, .style = FIFO_TX, .maxpacket = 512, }, | 1087 | { .hw_ep_num = 10, .style = FIFO_TX, .maxpacket = 256, }, |
1072 | { .hw_ep_num = 10, .style = FIFO_RX, .maxpacket = 512, }, | 1088 | { .hw_ep_num = 10, .style = FIFO_RX, .maxpacket = 64, }, |
1073 | { .hw_ep_num = 11, .style = FIFO_TX, .maxpacket = 512, }, | 1089 | { .hw_ep_num = 11, .style = FIFO_TX, .maxpacket = 256, }, |
1074 | { .hw_ep_num = 11, .style = FIFO_RX, .maxpacket = 512, }, | 1090 | { .hw_ep_num = 11, .style = FIFO_RX, .maxpacket = 64, }, |
1075 | { .hw_ep_num = 12, .style = FIFO_TX, .maxpacket = 512, }, | 1091 | { .hw_ep_num = 12, .style = FIFO_TX, .maxpacket = 256, }, |
1076 | { .hw_ep_num = 12, .style = FIFO_RX, .maxpacket = 512, }, | 1092 | { .hw_ep_num = 12, .style = FIFO_RX, .maxpacket = 64, }, |
1077 | { .hw_ep_num = 13, .style = FIFO_TX, .maxpacket = 512, }, | 1093 | { .hw_ep_num = 13, .style = FIFO_RXTX, .maxpacket = 4096, }, |
1078 | { .hw_ep_num = 13, .style = FIFO_RX, .maxpacket = 512, }, | ||
1079 | { .hw_ep_num = 14, .style = FIFO_RXTX, .maxpacket = 1024, }, | 1094 | { .hw_ep_num = 14, .style = FIFO_RXTX, .maxpacket = 1024, }, |
1080 | { .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, }, | 1095 | { .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, }, |
1081 | }; | 1096 | }; |
@@ -1335,11 +1350,11 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb) | |||
1335 | } | 1350 | } |
1336 | if (reg & MUSB_CONFIGDATA_HBRXE) { | 1351 | if (reg & MUSB_CONFIGDATA_HBRXE) { |
1337 | strcat(aInfo, ", HB-ISO Rx"); | 1352 | strcat(aInfo, ", HB-ISO Rx"); |
1338 | strcat(aInfo, " (X)"); /* no driver support */ | 1353 | musb->hb_iso_rx = true; |
1339 | } | 1354 | } |
1340 | if (reg & MUSB_CONFIGDATA_HBTXE) { | 1355 | if (reg & MUSB_CONFIGDATA_HBTXE) { |
1341 | strcat(aInfo, ", HB-ISO Tx"); | 1356 | strcat(aInfo, ", HB-ISO Tx"); |
1342 | strcat(aInfo, " (X)"); /* no driver support */ | 1357 | musb->hb_iso_tx = true; |
1343 | } | 1358 | } |
1344 | if (reg & MUSB_CONFIGDATA_SOFTCONE) | 1359 | if (reg & MUSB_CONFIGDATA_SOFTCONE) |
1345 | strcat(aInfo, ", SoftConn"); | 1360 | strcat(aInfo, ", SoftConn"); |
@@ -1481,13 +1496,7 @@ static irqreturn_t generic_interrupt(int irq, void *__hci) | |||
1481 | 1496 | ||
1482 | spin_unlock_irqrestore(&musb->lock, flags); | 1497 | spin_unlock_irqrestore(&musb->lock, flags); |
1483 | 1498 | ||
1484 | /* REVISIT we sometimes get spurious IRQs on g_ep0 | 1499 | return retval; |
1485 | * not clear why... | ||
1486 | */ | ||
1487 | if (retval != IRQ_HANDLED) | ||
1488 | DBG(5, "spurious?\n"); | ||
1489 | |||
1490 | return IRQ_HANDLED; | ||
1491 | } | 1500 | } |
1492 | 1501 | ||
1493 | #else | 1502 | #else |
@@ -1687,8 +1696,9 @@ musb_vbus_store(struct device *dev, struct device_attribute *attr, | |||
1687 | } | 1696 | } |
1688 | 1697 | ||
1689 | spin_lock_irqsave(&musb->lock, flags); | 1698 | spin_lock_irqsave(&musb->lock, flags); |
1690 | musb->a_wait_bcon = val; | 1699 | /* force T(a_wait_bcon) to be zero/unlimited *OR* valid */ |
1691 | if (musb->xceiv.state == OTG_STATE_A_WAIT_BCON) | 1700 | musb->a_wait_bcon = val ? max_t(int, val, OTG_TIME_A_WAIT_BCON) : 0 ; |
1701 | if (musb->xceiv->state == OTG_STATE_A_WAIT_BCON) | ||
1692 | musb->is_active = 0; | 1702 | musb->is_active = 0; |
1693 | musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val)); | 1703 | musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val)); |
1694 | spin_unlock_irqrestore(&musb->lock, flags); | 1704 | spin_unlock_irqrestore(&musb->lock, flags); |
@@ -1706,10 +1716,13 @@ musb_vbus_show(struct device *dev, struct device_attribute *attr, char *buf) | |||
1706 | 1716 | ||
1707 | spin_lock_irqsave(&musb->lock, flags); | 1717 | spin_lock_irqsave(&musb->lock, flags); |
1708 | val = musb->a_wait_bcon; | 1718 | val = musb->a_wait_bcon; |
1719 | /* FIXME get_vbus_status() is normally #defined as false... | ||
1720 | * and is effectively TUSB-specific. | ||
1721 | */ | ||
1709 | vbus = musb_platform_get_vbus_status(musb); | 1722 | vbus = musb_platform_get_vbus_status(musb); |
1710 | spin_unlock_irqrestore(&musb->lock, flags); | 1723 | spin_unlock_irqrestore(&musb->lock, flags); |
1711 | 1724 | ||
1712 | return sprintf(buf, "Vbus %s, timeout %lu\n", | 1725 | return sprintf(buf, "Vbus %s, timeout %lu msec\n", |
1713 | vbus ? "on" : "off", val); | 1726 | vbus ? "on" : "off", val); |
1714 | } | 1727 | } |
1715 | static DEVICE_ATTR(vbus, 0644, musb_vbus_show, musb_vbus_store); | 1728 | static DEVICE_ATTR(vbus, 0644, musb_vbus_show, musb_vbus_store); |
@@ -1749,8 +1762,8 @@ static void musb_irq_work(struct work_struct *data) | |||
1749 | struct musb *musb = container_of(data, struct musb, irq_work); | 1762 | struct musb *musb = container_of(data, struct musb, irq_work); |
1750 | static int old_state; | 1763 | static int old_state; |
1751 | 1764 | ||
1752 | if (musb->xceiv.state != old_state) { | 1765 | if (musb->xceiv->state != old_state) { |
1753 | old_state = musb->xceiv.state; | 1766 | old_state = musb->xceiv->state; |
1754 | sysfs_notify(&musb->controller->kobj, NULL, "mode"); | 1767 | sysfs_notify(&musb->controller->kobj, NULL, "mode"); |
1755 | } | 1768 | } |
1756 | } | 1769 | } |
@@ -1782,6 +1795,7 @@ allocate_instance(struct device *dev, | |||
1782 | hcd->uses_new_polling = 1; | 1795 | hcd->uses_new_polling = 1; |
1783 | 1796 | ||
1784 | musb->vbuserr_retry = VBUSERR_RETRY_COUNT; | 1797 | musb->vbuserr_retry = VBUSERR_RETRY_COUNT; |
1798 | musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON; | ||
1785 | #else | 1799 | #else |
1786 | musb = kzalloc(sizeof *musb, GFP_KERNEL); | 1800 | musb = kzalloc(sizeof *musb, GFP_KERNEL); |
1787 | if (!musb) | 1801 | if (!musb) |
@@ -1847,7 +1861,7 @@ static void musb_free(struct musb *musb) | |||
1847 | } | 1861 | } |
1848 | 1862 | ||
1849 | #ifdef CONFIG_USB_MUSB_OTG | 1863 | #ifdef CONFIG_USB_MUSB_OTG |
1850 | put_device(musb->xceiv.dev); | 1864 | put_device(musb->xceiv->dev); |
1851 | #endif | 1865 | #endif |
1852 | 1866 | ||
1853 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 1867 | #ifdef CONFIG_USB_MUSB_HDRC_HCD |
@@ -1928,10 +1942,18 @@ bad_config: | |||
1928 | } | 1942 | } |
1929 | } | 1943 | } |
1930 | 1944 | ||
1931 | /* assume vbus is off */ | 1945 | /* The musb_platform_init() call: |
1932 | 1946 | * - adjusts musb->mregs and musb->isr if needed, | |
1933 | /* platform adjusts musb->mregs and musb->isr if needed, | 1947 | * - may initialize an integrated tranceiver |
1934 | * and activates clocks | 1948 | * - initializes musb->xceiv, usually by otg_get_transceiver() |
1949 | * - activates clocks. | ||
1950 | * - stops powering VBUS | ||
1951 | * - assigns musb->board_set_vbus if host mode is enabled | ||
1952 | * | ||
1953 | * There are various transciever configurations. Blackfin, | ||
1954 | * DaVinci, TUSB60x0, and others integrate them. OMAP3 uses | ||
1955 | * external/discrete ones in various flavors (twl4030 family, | ||
1956 | * isp1504, non-OTG, etc) mostly hooking up through ULPI. | ||
1935 | */ | 1957 | */ |
1936 | musb->isr = generic_interrupt; | 1958 | musb->isr = generic_interrupt; |
1937 | status = musb_platform_init(musb); | 1959 | status = musb_platform_init(musb); |
@@ -1968,6 +1990,10 @@ bad_config: | |||
1968 | if (status < 0) | 1990 | if (status < 0) |
1969 | goto fail2; | 1991 | goto fail2; |
1970 | 1992 | ||
1993 | #ifdef CONFIG_USB_OTG | ||
1994 | setup_timer(&musb->otg_timer, musb_otg_timer_func, (unsigned long) musb); | ||
1995 | #endif | ||
1996 | |||
1971 | /* Init IRQ workqueue before request_irq */ | 1997 | /* Init IRQ workqueue before request_irq */ |
1972 | INIT_WORK(&musb->irq_work, musb_irq_work); | 1998 | INIT_WORK(&musb->irq_work, musb_irq_work); |
1973 | 1999 | ||
@@ -1999,17 +2025,17 @@ bad_config: | |||
1999 | ? "DMA" : "PIO", | 2025 | ? "DMA" : "PIO", |
2000 | musb->nIrq); | 2026 | musb->nIrq); |
2001 | 2027 | ||
2002 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 2028 | /* host side needs more setup */ |
2003 | /* host side needs more setup, except for no-host modes */ | 2029 | if (is_host_enabled(musb)) { |
2004 | if (musb->board_mode != MUSB_PERIPHERAL) { | ||
2005 | struct usb_hcd *hcd = musb_to_hcd(musb); | 2030 | struct usb_hcd *hcd = musb_to_hcd(musb); |
2006 | 2031 | ||
2007 | if (musb->board_mode == MUSB_OTG) | 2032 | otg_set_host(musb->xceiv, &hcd->self); |
2033 | |||
2034 | if (is_otg_enabled(musb)) | ||
2008 | hcd->self.otg_port = 1; | 2035 | hcd->self.otg_port = 1; |
2009 | musb->xceiv.host = &hcd->self; | 2036 | musb->xceiv->host = &hcd->self; |
2010 | hcd->power_budget = 2 * (plat->power ? : 250); | 2037 | hcd->power_budget = 2 * (plat->power ? : 250); |
2011 | } | 2038 | } |
2012 | #endif /* CONFIG_USB_MUSB_HDRC_HCD */ | ||
2013 | 2039 | ||
2014 | /* For the host-only role, we can activate right away. | 2040 | /* For the host-only role, we can activate right away. |
2015 | * (We expect the ID pin to be forcibly grounded!!) | 2041 | * (We expect the ID pin to be forcibly grounded!!) |
@@ -2017,8 +2043,8 @@ bad_config: | |||
2017 | */ | 2043 | */ |
2018 | if (!is_otg_enabled(musb) && is_host_enabled(musb)) { | 2044 | if (!is_otg_enabled(musb) && is_host_enabled(musb)) { |
2019 | MUSB_HST_MODE(musb); | 2045 | MUSB_HST_MODE(musb); |
2020 | musb->xceiv.default_a = 1; | 2046 | musb->xceiv->default_a = 1; |
2021 | musb->xceiv.state = OTG_STATE_A_IDLE; | 2047 | musb->xceiv->state = OTG_STATE_A_IDLE; |
2022 | 2048 | ||
2023 | status = usb_add_hcd(musb_to_hcd(musb), -1, 0); | 2049 | status = usb_add_hcd(musb_to_hcd(musb), -1, 0); |
2024 | if (status) | 2050 | if (status) |
@@ -2033,8 +2059,8 @@ bad_config: | |||
2033 | 2059 | ||
2034 | } else /* peripheral is enabled */ { | 2060 | } else /* peripheral is enabled */ { |
2035 | MUSB_DEV_MODE(musb); | 2061 | MUSB_DEV_MODE(musb); |
2036 | musb->xceiv.default_a = 0; | 2062 | musb->xceiv->default_a = 0; |
2037 | musb->xceiv.state = OTG_STATE_B_IDLE; | 2063 | musb->xceiv->state = OTG_STATE_B_IDLE; |
2038 | 2064 | ||
2039 | status = musb_gadget_setup(musb); | 2065 | status = musb_gadget_setup(musb); |
2040 | if (status) | 2066 | if (status) |
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h index efb39b5e55b5..f3772ca3b2cf 100644 --- a/drivers/usb/musb/musb_core.h +++ b/drivers/usb/musb/musb_core.h | |||
@@ -40,6 +40,7 @@ | |||
40 | #include <linux/interrupt.h> | 40 | #include <linux/interrupt.h> |
41 | #include <linux/smp_lock.h> | 41 | #include <linux/smp_lock.h> |
42 | #include <linux/errno.h> | 42 | #include <linux/errno.h> |
43 | #include <linux/timer.h> | ||
43 | #include <linux/clk.h> | 44 | #include <linux/clk.h> |
44 | #include <linux/device.h> | 45 | #include <linux/device.h> |
45 | #include <linux/usb/ch9.h> | 46 | #include <linux/usb/ch9.h> |
@@ -171,7 +172,8 @@ enum musb_h_ep0_state { | |||
171 | 172 | ||
172 | /* peripheral side ep0 states */ | 173 | /* peripheral side ep0 states */ |
173 | enum musb_g_ep0_state { | 174 | enum musb_g_ep0_state { |
174 | MUSB_EP0_STAGE_SETUP, /* idle, waiting for setup */ | 175 | MUSB_EP0_STAGE_IDLE, /* idle, waiting for SETUP */ |
176 | MUSB_EP0_STAGE_SETUP, /* received SETUP */ | ||
175 | MUSB_EP0_STAGE_TX, /* IN data */ | 177 | MUSB_EP0_STAGE_TX, /* IN data */ |
176 | MUSB_EP0_STAGE_RX, /* OUT data */ | 178 | MUSB_EP0_STAGE_RX, /* OUT data */ |
177 | MUSB_EP0_STAGE_STATUSIN, /* (after OUT data) */ | 179 | MUSB_EP0_STAGE_STATUSIN, /* (after OUT data) */ |
@@ -179,10 +181,15 @@ enum musb_g_ep0_state { | |||
179 | MUSB_EP0_STAGE_ACKWAIT, /* after zlp, before statusin */ | 181 | MUSB_EP0_STAGE_ACKWAIT, /* after zlp, before statusin */ |
180 | } __attribute__ ((packed)); | 182 | } __attribute__ ((packed)); |
181 | 183 | ||
182 | /* OTG protocol constants */ | 184 | /* |
185 | * OTG protocol constants. See USB OTG 1.3 spec, | ||
186 | * sections 5.5 "Device Timings" and 6.6.5 "Timers". | ||
187 | */ | ||
183 | #define OTG_TIME_A_WAIT_VRISE 100 /* msec (max) */ | 188 | #define OTG_TIME_A_WAIT_VRISE 100 /* msec (max) */ |
184 | #define OTG_TIME_A_WAIT_BCON 0 /* 0=infinite; min 1000 msec */ | 189 | #define OTG_TIME_A_WAIT_BCON 1100 /* min 1 second */ |
185 | #define OTG_TIME_A_IDLE_BDIS 200 /* msec (min) */ | 190 | #define OTG_TIME_A_AIDL_BDIS 200 /* min 200 msec */ |
191 | #define OTG_TIME_B_ASE0_BRST 100 /* min 3.125 ms */ | ||
192 | |||
186 | 193 | ||
187 | /*************************** REGISTER ACCESS ********************************/ | 194 | /*************************** REGISTER ACCESS ********************************/ |
188 | 195 | ||
@@ -331,6 +338,8 @@ struct musb { | |||
331 | struct list_head control; /* of musb_qh */ | 338 | struct list_head control; /* of musb_qh */ |
332 | struct list_head in_bulk; /* of musb_qh */ | 339 | struct list_head in_bulk; /* of musb_qh */ |
333 | struct list_head out_bulk; /* of musb_qh */ | 340 | struct list_head out_bulk; /* of musb_qh */ |
341 | |||
342 | struct timer_list otg_timer; | ||
334 | #endif | 343 | #endif |
335 | 344 | ||
336 | /* called with IRQs blocked; ON/nonzero implies starting a session, | 345 | /* called with IRQs blocked; ON/nonzero implies starting a session, |
@@ -355,7 +364,7 @@ struct musb { | |||
355 | u16 int_rx; | 364 | u16 int_rx; |
356 | u16 int_tx; | 365 | u16 int_tx; |
357 | 366 | ||
358 | struct otg_transceiver xceiv; | 367 | struct otg_transceiver *xceiv; |
359 | 368 | ||
360 | int nIrq; | 369 | int nIrq; |
361 | unsigned irq_wake:1; | 370 | unsigned irq_wake:1; |
@@ -386,6 +395,9 @@ struct musb { | |||
386 | unsigned is_multipoint:1; | 395 | unsigned is_multipoint:1; |
387 | unsigned ignore_disconnect:1; /* during bus resets */ | 396 | unsigned ignore_disconnect:1; /* during bus resets */ |
388 | 397 | ||
398 | unsigned hb_iso_rx:1; /* high bandwidth iso rx? */ | ||
399 | unsigned hb_iso_tx:1; /* high bandwidth iso tx? */ | ||
400 | |||
389 | #ifdef C_MP_TX | 401 | #ifdef C_MP_TX |
390 | unsigned bulk_split:1; | 402 | unsigned bulk_split:1; |
391 | #define can_bulk_split(musb,type) \ | 403 | #define can_bulk_split(musb,type) \ |
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c index f79440cdfe7e..8b3c4e2ed7b8 100644 --- a/drivers/usb/musb/musb_gadget.c +++ b/drivers/usb/musb/musb_gadget.c | |||
@@ -310,7 +310,7 @@ static void txstate(struct musb *musb, struct musb_request *req) | |||
310 | /* setup DMA, then program endpoint CSR */ | 310 | /* setup DMA, then program endpoint CSR */ |
311 | request_size = min(request->length, | 311 | request_size = min(request->length, |
312 | musb_ep->dma->max_len); | 312 | musb_ep->dma->max_len); |
313 | if (request_size <= musb_ep->packet_sz) | 313 | if (request_size < musb_ep->packet_sz) |
314 | musb_ep->dma->desired_mode = 0; | 314 | musb_ep->dma->desired_mode = 0; |
315 | else | 315 | else |
316 | musb_ep->dma->desired_mode = 1; | 316 | musb_ep->dma->desired_mode = 1; |
@@ -349,7 +349,8 @@ static void txstate(struct musb *musb, struct musb_request *req) | |||
349 | #elif defined(CONFIG_USB_TI_CPPI_DMA) | 349 | #elif defined(CONFIG_USB_TI_CPPI_DMA) |
350 | /* program endpoint CSR first, then setup DMA */ | 350 | /* program endpoint CSR first, then setup DMA */ |
351 | csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY); | 351 | csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY); |
352 | csr |= MUSB_TXCSR_MODE | MUSB_TXCSR_DMAENAB; | 352 | csr |= MUSB_TXCSR_DMAENAB | MUSB_TXCSR_DMAMODE | |
353 | MUSB_TXCSR_MODE; | ||
353 | musb_writew(epio, MUSB_TXCSR, | 354 | musb_writew(epio, MUSB_TXCSR, |
354 | (MUSB_TXCSR_P_WZC_BITS & ~MUSB_TXCSR_P_UNDERRUN) | 355 | (MUSB_TXCSR_P_WZC_BITS & ~MUSB_TXCSR_P_UNDERRUN) |
355 | | csr); | 356 | | csr); |
@@ -1405,7 +1406,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget) | |||
1405 | 1406 | ||
1406 | spin_lock_irqsave(&musb->lock, flags); | 1407 | spin_lock_irqsave(&musb->lock, flags); |
1407 | 1408 | ||
1408 | switch (musb->xceiv.state) { | 1409 | switch (musb->xceiv->state) { |
1409 | case OTG_STATE_B_PERIPHERAL: | 1410 | case OTG_STATE_B_PERIPHERAL: |
1410 | /* NOTE: OTG state machine doesn't include B_SUSPENDED; | 1411 | /* NOTE: OTG state machine doesn't include B_SUSPENDED; |
1411 | * that's part of the standard usb 1.1 state machine, and | 1412 | * that's part of the standard usb 1.1 state machine, and |
@@ -1507,9 +1508,9 @@ static int musb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA) | |||
1507 | { | 1508 | { |
1508 | struct musb *musb = gadget_to_musb(gadget); | 1509 | struct musb *musb = gadget_to_musb(gadget); |
1509 | 1510 | ||
1510 | if (!musb->xceiv.set_power) | 1511 | if (!musb->xceiv->set_power) |
1511 | return -EOPNOTSUPP; | 1512 | return -EOPNOTSUPP; |
1512 | return otg_set_power(&musb->xceiv, mA); | 1513 | return otg_set_power(musb->xceiv, mA); |
1513 | } | 1514 | } |
1514 | 1515 | ||
1515 | static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on) | 1516 | static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on) |
@@ -1732,11 +1733,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver) | |||
1732 | 1733 | ||
1733 | spin_lock_irqsave(&musb->lock, flags); | 1734 | spin_lock_irqsave(&musb->lock, flags); |
1734 | 1735 | ||
1735 | /* REVISIT always use otg_set_peripheral(), handling | 1736 | otg_set_peripheral(musb->xceiv, &musb->g); |
1736 | * issues including the root hub one below ... | ||
1737 | */ | ||
1738 | musb->xceiv.gadget = &musb->g; | ||
1739 | musb->xceiv.state = OTG_STATE_B_IDLE; | ||
1740 | musb->is_active = 1; | 1737 | musb->is_active = 1; |
1741 | 1738 | ||
1742 | /* FIXME this ignores the softconnect flag. Drivers are | 1739 | /* FIXME this ignores the softconnect flag. Drivers are |
@@ -1748,6 +1745,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver) | |||
1748 | if (!is_otg_enabled(musb)) | 1745 | if (!is_otg_enabled(musb)) |
1749 | musb_start(musb); | 1746 | musb_start(musb); |
1750 | 1747 | ||
1748 | otg_set_peripheral(musb->xceiv, &musb->g); | ||
1749 | |||
1751 | spin_unlock_irqrestore(&musb->lock, flags); | 1750 | spin_unlock_irqrestore(&musb->lock, flags); |
1752 | 1751 | ||
1753 | if (is_otg_enabled(musb)) { | 1752 | if (is_otg_enabled(musb)) { |
@@ -1761,8 +1760,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver) | |||
1761 | if (retval < 0) { | 1760 | if (retval < 0) { |
1762 | DBG(1, "add_hcd failed, %d\n", retval); | 1761 | DBG(1, "add_hcd failed, %d\n", retval); |
1763 | spin_lock_irqsave(&musb->lock, flags); | 1762 | spin_lock_irqsave(&musb->lock, flags); |
1764 | musb->xceiv.gadget = NULL; | 1763 | otg_set_peripheral(musb->xceiv, NULL); |
1765 | musb->xceiv.state = OTG_STATE_UNDEFINED; | ||
1766 | musb->gadget_driver = NULL; | 1764 | musb->gadget_driver = NULL; |
1767 | musb->g.dev.driver = NULL; | 1765 | musb->g.dev.driver = NULL; |
1768 | spin_unlock_irqrestore(&musb->lock, flags); | 1766 | spin_unlock_irqrestore(&musb->lock, flags); |
@@ -1845,8 +1843,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) | |||
1845 | 1843 | ||
1846 | (void) musb_gadget_vbus_draw(&musb->g, 0); | 1844 | (void) musb_gadget_vbus_draw(&musb->g, 0); |
1847 | 1845 | ||
1848 | musb->xceiv.state = OTG_STATE_UNDEFINED; | 1846 | musb->xceiv->state = OTG_STATE_UNDEFINED; |
1849 | stop_activity(musb, driver); | 1847 | stop_activity(musb, driver); |
1848 | otg_set_peripheral(musb->xceiv, NULL); | ||
1850 | 1849 | ||
1851 | DBG(3, "unregistering driver %s\n", driver->function); | 1850 | DBG(3, "unregistering driver %s\n", driver->function); |
1852 | spin_unlock_irqrestore(&musb->lock, flags); | 1851 | spin_unlock_irqrestore(&musb->lock, flags); |
@@ -1882,7 +1881,7 @@ EXPORT_SYMBOL(usb_gadget_unregister_driver); | |||
1882 | void musb_g_resume(struct musb *musb) | 1881 | void musb_g_resume(struct musb *musb) |
1883 | { | 1882 | { |
1884 | musb->is_suspended = 0; | 1883 | musb->is_suspended = 0; |
1885 | switch (musb->xceiv.state) { | 1884 | switch (musb->xceiv->state) { |
1886 | case OTG_STATE_B_IDLE: | 1885 | case OTG_STATE_B_IDLE: |
1887 | break; | 1886 | break; |
1888 | case OTG_STATE_B_WAIT_ACON: | 1887 | case OTG_STATE_B_WAIT_ACON: |
@@ -1908,10 +1907,10 @@ void musb_g_suspend(struct musb *musb) | |||
1908 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); | 1907 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); |
1909 | DBG(3, "devctl %02x\n", devctl); | 1908 | DBG(3, "devctl %02x\n", devctl); |
1910 | 1909 | ||
1911 | switch (musb->xceiv.state) { | 1910 | switch (musb->xceiv->state) { |
1912 | case OTG_STATE_B_IDLE: | 1911 | case OTG_STATE_B_IDLE: |
1913 | if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) | 1912 | if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) |
1914 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 1913 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
1915 | break; | 1914 | break; |
1916 | case OTG_STATE_B_PERIPHERAL: | 1915 | case OTG_STATE_B_PERIPHERAL: |
1917 | musb->is_suspended = 1; | 1916 | musb->is_suspended = 1; |
@@ -1957,22 +1956,24 @@ void musb_g_disconnect(struct musb *musb) | |||
1957 | spin_lock(&musb->lock); | 1956 | spin_lock(&musb->lock); |
1958 | } | 1957 | } |
1959 | 1958 | ||
1960 | switch (musb->xceiv.state) { | 1959 | switch (musb->xceiv->state) { |
1961 | default: | 1960 | default: |
1962 | #ifdef CONFIG_USB_MUSB_OTG | 1961 | #ifdef CONFIG_USB_MUSB_OTG |
1963 | DBG(2, "Unhandled disconnect %s, setting a_idle\n", | 1962 | DBG(2, "Unhandled disconnect %s, setting a_idle\n", |
1964 | otg_state_string(musb)); | 1963 | otg_state_string(musb)); |
1965 | musb->xceiv.state = OTG_STATE_A_IDLE; | 1964 | musb->xceiv->state = OTG_STATE_A_IDLE; |
1965 | MUSB_HST_MODE(musb); | ||
1966 | break; | 1966 | break; |
1967 | case OTG_STATE_A_PERIPHERAL: | 1967 | case OTG_STATE_A_PERIPHERAL: |
1968 | musb->xceiv.state = OTG_STATE_A_WAIT_VFALL; | 1968 | musb->xceiv->state = OTG_STATE_A_WAIT_BCON; |
1969 | MUSB_HST_MODE(musb); | ||
1969 | break; | 1970 | break; |
1970 | case OTG_STATE_B_WAIT_ACON: | 1971 | case OTG_STATE_B_WAIT_ACON: |
1971 | case OTG_STATE_B_HOST: | 1972 | case OTG_STATE_B_HOST: |
1972 | #endif | 1973 | #endif |
1973 | case OTG_STATE_B_PERIPHERAL: | 1974 | case OTG_STATE_B_PERIPHERAL: |
1974 | case OTG_STATE_B_IDLE: | 1975 | case OTG_STATE_B_IDLE: |
1975 | musb->xceiv.state = OTG_STATE_B_IDLE; | 1976 | musb->xceiv->state = OTG_STATE_B_IDLE; |
1976 | break; | 1977 | break; |
1977 | case OTG_STATE_B_SRP_INIT: | 1978 | case OTG_STATE_B_SRP_INIT: |
1978 | break; | 1979 | break; |
@@ -2028,10 +2029,10 @@ __acquires(musb->lock) | |||
2028 | * or else after HNP, as A-Device | 2029 | * or else after HNP, as A-Device |
2029 | */ | 2030 | */ |
2030 | if (devctl & MUSB_DEVCTL_BDEVICE) { | 2031 | if (devctl & MUSB_DEVCTL_BDEVICE) { |
2031 | musb->xceiv.state = OTG_STATE_B_PERIPHERAL; | 2032 | musb->xceiv->state = OTG_STATE_B_PERIPHERAL; |
2032 | musb->g.is_a_peripheral = 0; | 2033 | musb->g.is_a_peripheral = 0; |
2033 | } else if (is_otg_enabled(musb)) { | 2034 | } else if (is_otg_enabled(musb)) { |
2034 | musb->xceiv.state = OTG_STATE_A_PERIPHERAL; | 2035 | musb->xceiv->state = OTG_STATE_A_PERIPHERAL; |
2035 | musb->g.is_a_peripheral = 1; | 2036 | musb->g.is_a_peripheral = 1; |
2036 | } else | 2037 | } else |
2037 | WARN_ON(1); | 2038 | WARN_ON(1); |
diff --git a/drivers/usb/musb/musb_gadget_ep0.c b/drivers/usb/musb/musb_gadget_ep0.c index 3f5e30ddfa27..40ed50ecedff 100644 --- a/drivers/usb/musb/musb_gadget_ep0.c +++ b/drivers/usb/musb/musb_gadget_ep0.c | |||
@@ -4,6 +4,7 @@ | |||
4 | * Copyright 2005 Mentor Graphics Corporation | 4 | * Copyright 2005 Mentor Graphics Corporation |
5 | * Copyright (C) 2005-2006 by Texas Instruments | 5 | * Copyright (C) 2005-2006 by Texas Instruments |
6 | * Copyright (C) 2006-2007 Nokia Corporation | 6 | * Copyright (C) 2006-2007 Nokia Corporation |
7 | * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com> | ||
7 | * | 8 | * |
8 | * This program is free software; you can redistribute it and/or | 9 | * This program is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU General Public License | 10 | * modify it under the terms of the GNU General Public License |
@@ -58,7 +59,8 @@ | |||
58 | static char *decode_ep0stage(u8 stage) | 59 | static char *decode_ep0stage(u8 stage) |
59 | { | 60 | { |
60 | switch (stage) { | 61 | switch (stage) { |
61 | case MUSB_EP0_STAGE_SETUP: return "idle"; | 62 | case MUSB_EP0_STAGE_IDLE: return "idle"; |
63 | case MUSB_EP0_STAGE_SETUP: return "setup"; | ||
62 | case MUSB_EP0_STAGE_TX: return "in"; | 64 | case MUSB_EP0_STAGE_TX: return "in"; |
63 | case MUSB_EP0_STAGE_RX: return "out"; | 65 | case MUSB_EP0_STAGE_RX: return "out"; |
64 | case MUSB_EP0_STAGE_ACKWAIT: return "wait"; | 66 | case MUSB_EP0_STAGE_ACKWAIT: return "wait"; |
@@ -628,7 +630,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb) | |||
628 | musb_writew(regs, MUSB_CSR0, | 630 | musb_writew(regs, MUSB_CSR0, |
629 | csr & ~MUSB_CSR0_P_SENTSTALL); | 631 | csr & ~MUSB_CSR0_P_SENTSTALL); |
630 | retval = IRQ_HANDLED; | 632 | retval = IRQ_HANDLED; |
631 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 633 | musb->ep0_state = MUSB_EP0_STAGE_IDLE; |
632 | csr = musb_readw(regs, MUSB_CSR0); | 634 | csr = musb_readw(regs, MUSB_CSR0); |
633 | } | 635 | } |
634 | 636 | ||
@@ -636,7 +638,18 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb) | |||
636 | if (csr & MUSB_CSR0_P_SETUPEND) { | 638 | if (csr & MUSB_CSR0_P_SETUPEND) { |
637 | musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SVDSETUPEND); | 639 | musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SVDSETUPEND); |
638 | retval = IRQ_HANDLED; | 640 | retval = IRQ_HANDLED; |
639 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 641 | /* Transition into the early status phase */ |
642 | switch (musb->ep0_state) { | ||
643 | case MUSB_EP0_STAGE_TX: | ||
644 | musb->ep0_state = MUSB_EP0_STAGE_STATUSOUT; | ||
645 | break; | ||
646 | case MUSB_EP0_STAGE_RX: | ||
647 | musb->ep0_state = MUSB_EP0_STAGE_STATUSIN; | ||
648 | break; | ||
649 | default: | ||
650 | ERR("SetupEnd came in a wrong ep0stage %s", | ||
651 | decode_ep0stage(musb->ep0_state)); | ||
652 | } | ||
640 | csr = musb_readw(regs, MUSB_CSR0); | 653 | csr = musb_readw(regs, MUSB_CSR0); |
641 | /* NOTE: request may need completion */ | 654 | /* NOTE: request may need completion */ |
642 | } | 655 | } |
@@ -697,11 +710,31 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb) | |||
697 | if (req) | 710 | if (req) |
698 | musb_g_ep0_giveback(musb, req); | 711 | musb_g_ep0_giveback(musb, req); |
699 | } | 712 | } |
713 | |||
714 | /* | ||
715 | * In case when several interrupts can get coalesced, | ||
716 | * check to see if we've already received a SETUP packet... | ||
717 | */ | ||
718 | if (csr & MUSB_CSR0_RXPKTRDY) | ||
719 | goto setup; | ||
720 | |||
721 | retval = IRQ_HANDLED; | ||
722 | musb->ep0_state = MUSB_EP0_STAGE_IDLE; | ||
723 | break; | ||
724 | |||
725 | case MUSB_EP0_STAGE_IDLE: | ||
726 | /* | ||
727 | * This state is typically (but not always) indiscernible | ||
728 | * from the status states since the corresponding interrupts | ||
729 | * tend to happen within too little period of time (with only | ||
730 | * a zero-length packet in between) and so get coalesced... | ||
731 | */ | ||
700 | retval = IRQ_HANDLED; | 732 | retval = IRQ_HANDLED; |
701 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 733 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; |
702 | /* FALLTHROUGH */ | 734 | /* FALLTHROUGH */ |
703 | 735 | ||
704 | case MUSB_EP0_STAGE_SETUP: | 736 | case MUSB_EP0_STAGE_SETUP: |
737 | setup: | ||
705 | if (csr & MUSB_CSR0_RXPKTRDY) { | 738 | if (csr & MUSB_CSR0_RXPKTRDY) { |
706 | struct usb_ctrlrequest setup; | 739 | struct usb_ctrlrequest setup; |
707 | int handled = 0; | 740 | int handled = 0; |
@@ -783,7 +816,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb) | |||
783 | stall: | 816 | stall: |
784 | DBG(3, "stall (%d)\n", handled); | 817 | DBG(3, "stall (%d)\n", handled); |
785 | musb->ackpend |= MUSB_CSR0_P_SENDSTALL; | 818 | musb->ackpend |= MUSB_CSR0_P_SENDSTALL; |
786 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 819 | musb->ep0_state = MUSB_EP0_STAGE_IDLE; |
787 | finish: | 820 | finish: |
788 | musb_writew(regs, MUSB_CSR0, | 821 | musb_writew(regs, MUSB_CSR0, |
789 | musb->ackpend); | 822 | musb->ackpend); |
@@ -803,7 +836,7 @@ finish: | |||
803 | /* "can't happen" */ | 836 | /* "can't happen" */ |
804 | WARN_ON(1); | 837 | WARN_ON(1); |
805 | musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SENDSTALL); | 838 | musb_writew(regs, MUSB_CSR0, MUSB_CSR0_P_SENDSTALL); |
806 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 839 | musb->ep0_state = MUSB_EP0_STAGE_IDLE; |
807 | break; | 840 | break; |
808 | } | 841 | } |
809 | 842 | ||
@@ -959,7 +992,7 @@ static int musb_g_ep0_halt(struct usb_ep *e, int value) | |||
959 | 992 | ||
960 | csr |= MUSB_CSR0_P_SENDSTALL; | 993 | csr |= MUSB_CSR0_P_SENDSTALL; |
961 | musb_writew(regs, MUSB_CSR0, csr); | 994 | musb_writew(regs, MUSB_CSR0, csr); |
962 | musb->ep0_state = MUSB_EP0_STAGE_SETUP; | 995 | musb->ep0_state = MUSB_EP0_STAGE_IDLE; |
963 | musb->ackpend = 0; | 996 | musb->ackpend = 0; |
964 | break; | 997 | break; |
965 | default: | 998 | default: |
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c index db1b57415ec7..94a2a350a414 100644 --- a/drivers/usb/musb/musb_host.c +++ b/drivers/usb/musb/musb_host.c | |||
@@ -181,6 +181,19 @@ static inline void musb_h_tx_dma_start(struct musb_hw_ep *ep) | |||
181 | musb_writew(ep->regs, MUSB_TXCSR, txcsr); | 181 | musb_writew(ep->regs, MUSB_TXCSR, txcsr); |
182 | } | 182 | } |
183 | 183 | ||
184 | static void musb_ep_set_qh(struct musb_hw_ep *ep, int is_in, struct musb_qh *qh) | ||
185 | { | ||
186 | if (is_in != 0 || ep->is_shared_fifo) | ||
187 | ep->in_qh = qh; | ||
188 | if (is_in == 0 || ep->is_shared_fifo) | ||
189 | ep->out_qh = qh; | ||
190 | } | ||
191 | |||
192 | static struct musb_qh *musb_ep_get_qh(struct musb_hw_ep *ep, int is_in) | ||
193 | { | ||
194 | return is_in ? ep->in_qh : ep->out_qh; | ||
195 | } | ||
196 | |||
184 | /* | 197 | /* |
185 | * Start the URB at the front of an endpoint's queue | 198 | * Start the URB at the front of an endpoint's queue |
186 | * end must be claimed from the caller. | 199 | * end must be claimed from the caller. |
@@ -210,7 +223,6 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh) | |||
210 | case USB_ENDPOINT_XFER_CONTROL: | 223 | case USB_ENDPOINT_XFER_CONTROL: |
211 | /* control transfers always start with SETUP */ | 224 | /* control transfers always start with SETUP */ |
212 | is_in = 0; | 225 | is_in = 0; |
213 | hw_ep->out_qh = qh; | ||
214 | musb->ep0_stage = MUSB_EP0_START; | 226 | musb->ep0_stage = MUSB_EP0_START; |
215 | buf = urb->setup_packet; | 227 | buf = urb->setup_packet; |
216 | len = 8; | 228 | len = 8; |
@@ -239,10 +251,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh) | |||
239 | epnum, buf + offset, len); | 251 | epnum, buf + offset, len); |
240 | 252 | ||
241 | /* Configure endpoint */ | 253 | /* Configure endpoint */ |
242 | if (is_in || hw_ep->is_shared_fifo) | 254 | musb_ep_set_qh(hw_ep, is_in, qh); |
243 | hw_ep->in_qh = qh; | ||
244 | else | ||
245 | hw_ep->out_qh = qh; | ||
246 | musb_ep_program(musb, epnum, urb, !is_in, buf, offset, len); | 255 | musb_ep_program(musb, epnum, urb, !is_in, buf, offset, len); |
247 | 256 | ||
248 | /* transmit may have more work: start it when it is time */ | 257 | /* transmit may have more work: start it when it is time */ |
@@ -286,9 +295,8 @@ start: | |||
286 | } | 295 | } |
287 | } | 296 | } |
288 | 297 | ||
289 | /* caller owns controller lock, irqs are blocked */ | 298 | /* Context: caller owns controller lock, IRQs are blocked */ |
290 | static void | 299 | static void musb_giveback(struct musb *musb, struct urb *urb, int status) |
291 | __musb_giveback(struct musb *musb, struct urb *urb, int status) | ||
292 | __releases(musb->lock) | 300 | __releases(musb->lock) |
293 | __acquires(musb->lock) | 301 | __acquires(musb->lock) |
294 | { | 302 | { |
@@ -321,60 +329,57 @@ __acquires(musb->lock) | |||
321 | spin_lock(&musb->lock); | 329 | spin_lock(&musb->lock); |
322 | } | 330 | } |
323 | 331 | ||
324 | /* for bulk/interrupt endpoints only */ | 332 | /* For bulk/interrupt endpoints only */ |
325 | static inline void | 333 | static inline void musb_save_toggle(struct musb_qh *qh, int is_in, |
326 | musb_save_toggle(struct musb_hw_ep *ep, int is_in, struct urb *urb) | 334 | struct urb *urb) |
327 | { | 335 | { |
328 | struct usb_device *udev = urb->dev; | 336 | void __iomem *epio = qh->hw_ep->regs; |
329 | u16 csr; | 337 | u16 csr; |
330 | void __iomem *epio = ep->regs; | ||
331 | struct musb_qh *qh; | ||
332 | 338 | ||
333 | /* FIXME: the current Mentor DMA code seems to have | 339 | /* |
340 | * FIXME: the current Mentor DMA code seems to have | ||
334 | * problems getting toggle correct. | 341 | * problems getting toggle correct. |
335 | */ | 342 | */ |
336 | 343 | ||
337 | if (is_in || ep->is_shared_fifo) | 344 | if (is_in) |
338 | qh = ep->in_qh; | 345 | csr = musb_readw(epio, MUSB_RXCSR) & MUSB_RXCSR_H_DATATOGGLE; |
339 | else | 346 | else |
340 | qh = ep->out_qh; | 347 | csr = musb_readw(epio, MUSB_TXCSR) & MUSB_TXCSR_H_DATATOGGLE; |
341 | 348 | ||
342 | if (!is_in) { | 349 | usb_settoggle(urb->dev, qh->epnum, !is_in, csr ? 1 : 0); |
343 | csr = musb_readw(epio, MUSB_TXCSR); | ||
344 | usb_settoggle(udev, qh->epnum, 1, | ||
345 | (csr & MUSB_TXCSR_H_DATATOGGLE) | ||
346 | ? 1 : 0); | ||
347 | } else { | ||
348 | csr = musb_readw(epio, MUSB_RXCSR); | ||
349 | usb_settoggle(udev, qh->epnum, 0, | ||
350 | (csr & MUSB_RXCSR_H_DATATOGGLE) | ||
351 | ? 1 : 0); | ||
352 | } | ||
353 | } | 350 | } |
354 | 351 | ||
355 | /* caller owns controller lock, irqs are blocked */ | 352 | /* |
356 | static struct musb_qh * | 353 | * Advance this hardware endpoint's queue, completing the specified URB and |
357 | musb_giveback(struct musb_qh *qh, struct urb *urb, int status) | 354 | * advancing to either the next URB queued to that qh, or else invalidating |
355 | * that qh and advancing to the next qh scheduled after the current one. | ||
356 | * | ||
357 | * Context: caller owns controller lock, IRQs are blocked | ||
358 | */ | ||
359 | static void musb_advance_schedule(struct musb *musb, struct urb *urb, | ||
360 | struct musb_hw_ep *hw_ep, int is_in) | ||
358 | { | 361 | { |
362 | struct musb_qh *qh = musb_ep_get_qh(hw_ep, is_in); | ||
359 | struct musb_hw_ep *ep = qh->hw_ep; | 363 | struct musb_hw_ep *ep = qh->hw_ep; |
360 | struct musb *musb = ep->musb; | ||
361 | int is_in = usb_pipein(urb->pipe); | ||
362 | int ready = qh->is_ready; | 364 | int ready = qh->is_ready; |
365 | int status; | ||
366 | |||
367 | status = (urb->status == -EINPROGRESS) ? 0 : urb->status; | ||
363 | 368 | ||
364 | /* save toggle eagerly, for paranoia */ | 369 | /* save toggle eagerly, for paranoia */ |
365 | switch (qh->type) { | 370 | switch (qh->type) { |
366 | case USB_ENDPOINT_XFER_BULK: | 371 | case USB_ENDPOINT_XFER_BULK: |
367 | case USB_ENDPOINT_XFER_INT: | 372 | case USB_ENDPOINT_XFER_INT: |
368 | musb_save_toggle(ep, is_in, urb); | 373 | musb_save_toggle(qh, is_in, urb); |
369 | break; | 374 | break; |
370 | case USB_ENDPOINT_XFER_ISOC: | 375 | case USB_ENDPOINT_XFER_ISOC: |
371 | if (status == 0 && urb->error_count) | 376 | if (urb->error_count) |
372 | status = -EXDEV; | 377 | status = -EXDEV; |
373 | break; | 378 | break; |
374 | } | 379 | } |
375 | 380 | ||
376 | qh->is_ready = 0; | 381 | qh->is_ready = 0; |
377 | __musb_giveback(musb, urb, status); | 382 | musb_giveback(musb, urb, status); |
378 | qh->is_ready = ready; | 383 | qh->is_ready = ready; |
379 | 384 | ||
380 | /* reclaim resources (and bandwidth) ASAP; deschedule it, and | 385 | /* reclaim resources (and bandwidth) ASAP; deschedule it, and |
@@ -388,11 +393,8 @@ musb_giveback(struct musb_qh *qh, struct urb *urb, int status) | |||
388 | else | 393 | else |
389 | ep->tx_reinit = 1; | 394 | ep->tx_reinit = 1; |
390 | 395 | ||
391 | /* clobber old pointers to this qh */ | 396 | /* Clobber old pointers to this qh */ |
392 | if (is_in || ep->is_shared_fifo) | 397 | musb_ep_set_qh(ep, is_in, NULL); |
393 | ep->in_qh = NULL; | ||
394 | else | ||
395 | ep->out_qh = NULL; | ||
396 | qh->hep->hcpriv = NULL; | 398 | qh->hep->hcpriv = NULL; |
397 | 399 | ||
398 | switch (qh->type) { | 400 | switch (qh->type) { |
@@ -421,36 +423,10 @@ musb_giveback(struct musb_qh *qh, struct urb *urb, int status) | |||
421 | break; | 423 | break; |
422 | } | 424 | } |
423 | } | 425 | } |
424 | return qh; | ||
425 | } | ||
426 | |||
427 | /* | ||
428 | * Advance this hardware endpoint's queue, completing the specified urb and | ||
429 | * advancing to either the next urb queued to that qh, or else invalidating | ||
430 | * that qh and advancing to the next qh scheduled after the current one. | ||
431 | * | ||
432 | * Context: caller owns controller lock, irqs are blocked | ||
433 | */ | ||
434 | static void | ||
435 | musb_advance_schedule(struct musb *musb, struct urb *urb, | ||
436 | struct musb_hw_ep *hw_ep, int is_in) | ||
437 | { | ||
438 | struct musb_qh *qh; | ||
439 | |||
440 | if (is_in || hw_ep->is_shared_fifo) | ||
441 | qh = hw_ep->in_qh; | ||
442 | else | ||
443 | qh = hw_ep->out_qh; | ||
444 | |||
445 | if (urb->status == -EINPROGRESS) | ||
446 | qh = musb_giveback(qh, urb, 0); | ||
447 | else | ||
448 | qh = musb_giveback(qh, urb, urb->status); | ||
449 | 426 | ||
450 | if (qh != NULL && qh->is_ready) { | 427 | if (qh != NULL && qh->is_ready) { |
451 | DBG(4, "... next ep%d %cX urb %p\n", | 428 | DBG(4, "... next ep%d %cX urb %p\n", |
452 | hw_ep->epnum, is_in ? 'R' : 'T', | 429 | hw_ep->epnum, is_in ? 'R' : 'T', next_urb(qh)); |
453 | next_urb(qh)); | ||
454 | musb_start_urb(musb, is_in, qh); | 430 | musb_start_urb(musb, is_in, qh); |
455 | } | 431 | } |
456 | } | 432 | } |
@@ -629,7 +605,8 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep) | |||
629 | musb_writeb(ep->regs, MUSB_RXTYPE, qh->type_reg); | 605 | musb_writeb(ep->regs, MUSB_RXTYPE, qh->type_reg); |
630 | musb_writeb(ep->regs, MUSB_RXINTERVAL, qh->intv_reg); | 606 | musb_writeb(ep->regs, MUSB_RXINTERVAL, qh->intv_reg); |
631 | /* NOTE: bulk combining rewrites high bits of maxpacket */ | 607 | /* NOTE: bulk combining rewrites high bits of maxpacket */ |
632 | musb_writew(ep->regs, MUSB_RXMAXP, qh->maxpacket); | 608 | musb_writew(ep->regs, MUSB_RXMAXP, |
609 | qh->maxpacket | ((qh->hb_mult - 1) << 11)); | ||
633 | 610 | ||
634 | ep->rx_reinit = 0; | 611 | ep->rx_reinit = 0; |
635 | } | 612 | } |
@@ -651,9 +628,10 @@ static bool musb_tx_dma_program(struct dma_controller *dma, | |||
651 | csr = musb_readw(epio, MUSB_TXCSR); | 628 | csr = musb_readw(epio, MUSB_TXCSR); |
652 | if (length > pkt_size) { | 629 | if (length > pkt_size) { |
653 | mode = 1; | 630 | mode = 1; |
654 | csr |= MUSB_TXCSR_AUTOSET | 631 | csr |= MUSB_TXCSR_DMAMODE | MUSB_TXCSR_DMAENAB; |
655 | | MUSB_TXCSR_DMAMODE | 632 | /* autoset shouldn't be set in high bandwidth */ |
656 | | MUSB_TXCSR_DMAENAB; | 633 | if (qh->hb_mult == 1) |
634 | csr |= MUSB_TXCSR_AUTOSET; | ||
657 | } else { | 635 | } else { |
658 | mode = 0; | 636 | mode = 0; |
659 | csr &= ~(MUSB_TXCSR_AUTOSET | MUSB_TXCSR_DMAMODE); | 637 | csr &= ~(MUSB_TXCSR_AUTOSET | MUSB_TXCSR_DMAMODE); |
@@ -703,15 +681,8 @@ static void musb_ep_program(struct musb *musb, u8 epnum, | |||
703 | void __iomem *mbase = musb->mregs; | 681 | void __iomem *mbase = musb->mregs; |
704 | struct musb_hw_ep *hw_ep = musb->endpoints + epnum; | 682 | struct musb_hw_ep *hw_ep = musb->endpoints + epnum; |
705 | void __iomem *epio = hw_ep->regs; | 683 | void __iomem *epio = hw_ep->regs; |
706 | struct musb_qh *qh; | 684 | struct musb_qh *qh = musb_ep_get_qh(hw_ep, !is_out); |
707 | u16 packet_sz; | 685 | u16 packet_sz = qh->maxpacket; |
708 | |||
709 | if (!is_out || hw_ep->is_shared_fifo) | ||
710 | qh = hw_ep->in_qh; | ||
711 | else | ||
712 | qh = hw_ep->out_qh; | ||
713 | |||
714 | packet_sz = qh->maxpacket; | ||
715 | 686 | ||
716 | DBG(3, "%s hw%d urb %p spd%d dev%d ep%d%s " | 687 | DBG(3, "%s hw%d urb %p spd%d dev%d ep%d%s " |
717 | "h_addr%02x h_port%02x bytes %d\n", | 688 | "h_addr%02x h_port%02x bytes %d\n", |
@@ -1129,17 +1100,14 @@ void musb_host_tx(struct musb *musb, u8 epnum) | |||
1129 | u16 tx_csr; | 1100 | u16 tx_csr; |
1130 | size_t length = 0; | 1101 | size_t length = 0; |
1131 | size_t offset = 0; | 1102 | size_t offset = 0; |
1132 | struct urb *urb; | ||
1133 | struct musb_hw_ep *hw_ep = musb->endpoints + epnum; | 1103 | struct musb_hw_ep *hw_ep = musb->endpoints + epnum; |
1134 | void __iomem *epio = hw_ep->regs; | 1104 | void __iomem *epio = hw_ep->regs; |
1135 | struct musb_qh *qh = hw_ep->is_shared_fifo ? hw_ep->in_qh | 1105 | struct musb_qh *qh = hw_ep->out_qh; |
1136 | : hw_ep->out_qh; | 1106 | struct urb *urb = next_urb(qh); |
1137 | u32 status = 0; | 1107 | u32 status = 0; |
1138 | void __iomem *mbase = musb->mregs; | 1108 | void __iomem *mbase = musb->mregs; |
1139 | struct dma_channel *dma; | 1109 | struct dma_channel *dma; |
1140 | 1110 | ||
1141 | urb = next_urb(qh); | ||
1142 | |||
1143 | musb_ep_select(mbase, epnum); | 1111 | musb_ep_select(mbase, epnum); |
1144 | tx_csr = musb_readw(epio, MUSB_TXCSR); | 1112 | tx_csr = musb_readw(epio, MUSB_TXCSR); |
1145 | 1113 | ||
@@ -1427,7 +1395,7 @@ static void musb_bulk_rx_nak_timeout(struct musb *musb, struct musb_hw_ep *ep) | |||
1427 | urb->actual_length += dma->actual_len; | 1395 | urb->actual_length += dma->actual_len; |
1428 | dma->actual_len = 0L; | 1396 | dma->actual_len = 0L; |
1429 | } | 1397 | } |
1430 | musb_save_toggle(ep, 1, urb); | 1398 | musb_save_toggle(cur_qh, 1, urb); |
1431 | 1399 | ||
1432 | /* move cur_qh to end of queue */ | 1400 | /* move cur_qh to end of queue */ |
1433 | list_move_tail(&cur_qh->ring, &musb->in_bulk); | 1401 | list_move_tail(&cur_qh->ring, &musb->in_bulk); |
@@ -1531,6 +1499,10 @@ void musb_host_rx(struct musb *musb, u8 epnum) | |||
1531 | /* packet error reported later */ | 1499 | /* packet error reported later */ |
1532 | iso_err = true; | 1500 | iso_err = true; |
1533 | } | 1501 | } |
1502 | } else if (rx_csr & MUSB_RXCSR_INCOMPRX) { | ||
1503 | DBG(3, "end %d high bandwidth incomplete ISO packet RX\n", | ||
1504 | epnum); | ||
1505 | status = -EPROTO; | ||
1534 | } | 1506 | } |
1535 | 1507 | ||
1536 | /* faults abort the transfer */ | 1508 | /* faults abort the transfer */ |
@@ -1738,7 +1710,11 @@ void musb_host_rx(struct musb *musb, u8 epnum) | |||
1738 | val &= ~MUSB_RXCSR_H_AUTOREQ; | 1710 | val &= ~MUSB_RXCSR_H_AUTOREQ; |
1739 | else | 1711 | else |
1740 | val |= MUSB_RXCSR_H_AUTOREQ; | 1712 | val |= MUSB_RXCSR_H_AUTOREQ; |
1741 | val |= MUSB_RXCSR_AUTOCLEAR | MUSB_RXCSR_DMAENAB; | 1713 | val |= MUSB_RXCSR_DMAENAB; |
1714 | |||
1715 | /* autoclear shouldn't be set in high bandwidth */ | ||
1716 | if (qh->hb_mult == 1) | ||
1717 | val |= MUSB_RXCSR_AUTOCLEAR; | ||
1742 | 1718 | ||
1743 | musb_writew(epio, MUSB_RXCSR, | 1719 | musb_writew(epio, MUSB_RXCSR, |
1744 | MUSB_RXCSR_H_WZC_BITS | val); | 1720 | MUSB_RXCSR_H_WZC_BITS | val); |
@@ -1817,19 +1793,17 @@ static int musb_schedule( | |||
1817 | epnum++, hw_ep++) { | 1793 | epnum++, hw_ep++) { |
1818 | int diff; | 1794 | int diff; |
1819 | 1795 | ||
1820 | if (is_in || hw_ep->is_shared_fifo) { | 1796 | if (musb_ep_get_qh(hw_ep, is_in) != NULL) |
1821 | if (hw_ep->in_qh != NULL) | ||
1822 | continue; | ||
1823 | } else if (hw_ep->out_qh != NULL) | ||
1824 | continue; | 1797 | continue; |
1825 | 1798 | ||
1826 | if (hw_ep == musb->bulk_ep) | 1799 | if (hw_ep == musb->bulk_ep) |
1827 | continue; | 1800 | continue; |
1828 | 1801 | ||
1829 | if (is_in) | 1802 | if (is_in) |
1830 | diff = hw_ep->max_packet_sz_rx - qh->maxpacket; | 1803 | diff = hw_ep->max_packet_sz_rx; |
1831 | else | 1804 | else |
1832 | diff = hw_ep->max_packet_sz_tx - qh->maxpacket; | 1805 | diff = hw_ep->max_packet_sz_tx; |
1806 | diff -= (qh->maxpacket * qh->hb_mult); | ||
1833 | 1807 | ||
1834 | if (diff >= 0 && best_diff > diff) { | 1808 | if (diff >= 0 && best_diff > diff) { |
1835 | best_diff = diff; | 1809 | best_diff = diff; |
@@ -1932,15 +1906,27 @@ static int musb_urb_enqueue( | |||
1932 | qh->is_ready = 1; | 1906 | qh->is_ready = 1; |
1933 | 1907 | ||
1934 | qh->maxpacket = le16_to_cpu(epd->wMaxPacketSize); | 1908 | qh->maxpacket = le16_to_cpu(epd->wMaxPacketSize); |
1909 | qh->type = usb_endpoint_type(epd); | ||
1935 | 1910 | ||
1936 | /* no high bandwidth support yet */ | 1911 | /* Bits 11 & 12 of wMaxPacketSize encode high bandwidth multiplier. |
1937 | if (qh->maxpacket & ~0x7ff) { | 1912 | * Some musb cores don't support high bandwidth ISO transfers; and |
1938 | ret = -EMSGSIZE; | 1913 | * we don't (yet!) support high bandwidth interrupt transfers. |
1939 | goto done; | 1914 | */ |
1915 | qh->hb_mult = 1 + ((qh->maxpacket >> 11) & 0x03); | ||
1916 | if (qh->hb_mult > 1) { | ||
1917 | int ok = (qh->type == USB_ENDPOINT_XFER_ISOC); | ||
1918 | |||
1919 | if (ok) | ||
1920 | ok = (usb_pipein(urb->pipe) && musb->hb_iso_rx) | ||
1921 | || (usb_pipeout(urb->pipe) && musb->hb_iso_tx); | ||
1922 | if (!ok) { | ||
1923 | ret = -EMSGSIZE; | ||
1924 | goto done; | ||
1925 | } | ||
1926 | qh->maxpacket &= 0x7ff; | ||
1940 | } | 1927 | } |
1941 | 1928 | ||
1942 | qh->epnum = usb_endpoint_num(epd); | 1929 | qh->epnum = usb_endpoint_num(epd); |
1943 | qh->type = usb_endpoint_type(epd); | ||
1944 | 1930 | ||
1945 | /* NOTE: urb->dev->devnum is wrong during SET_ADDRESS */ | 1931 | /* NOTE: urb->dev->devnum is wrong during SET_ADDRESS */ |
1946 | qh->addr_reg = (u8) usb_pipedevice(urb->pipe); | 1932 | qh->addr_reg = (u8) usb_pipedevice(urb->pipe); |
@@ -2052,14 +2038,15 @@ done: | |||
2052 | * called with controller locked, irqs blocked | 2038 | * called with controller locked, irqs blocked |
2053 | * that hardware queue advances to the next transfer, unless prevented | 2039 | * that hardware queue advances to the next transfer, unless prevented |
2054 | */ | 2040 | */ |
2055 | static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh, int is_in) | 2041 | static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh) |
2056 | { | 2042 | { |
2057 | struct musb_hw_ep *ep = qh->hw_ep; | 2043 | struct musb_hw_ep *ep = qh->hw_ep; |
2058 | void __iomem *epio = ep->regs; | 2044 | void __iomem *epio = ep->regs; |
2059 | unsigned hw_end = ep->epnum; | 2045 | unsigned hw_end = ep->epnum; |
2060 | void __iomem *regs = ep->musb->mregs; | 2046 | void __iomem *regs = ep->musb->mregs; |
2061 | u16 csr; | 2047 | int is_in = usb_pipein(urb->pipe); |
2062 | int status = 0; | 2048 | int status = 0; |
2049 | u16 csr; | ||
2063 | 2050 | ||
2064 | musb_ep_select(regs, hw_end); | 2051 | musb_ep_select(regs, hw_end); |
2065 | 2052 | ||
@@ -2112,14 +2099,14 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) | |||
2112 | { | 2099 | { |
2113 | struct musb *musb = hcd_to_musb(hcd); | 2100 | struct musb *musb = hcd_to_musb(hcd); |
2114 | struct musb_qh *qh; | 2101 | struct musb_qh *qh; |
2115 | struct list_head *sched; | ||
2116 | unsigned long flags; | 2102 | unsigned long flags; |
2103 | int is_in = usb_pipein(urb->pipe); | ||
2117 | int ret; | 2104 | int ret; |
2118 | 2105 | ||
2119 | DBG(4, "urb=%p, dev%d ep%d%s\n", urb, | 2106 | DBG(4, "urb=%p, dev%d ep%d%s\n", urb, |
2120 | usb_pipedevice(urb->pipe), | 2107 | usb_pipedevice(urb->pipe), |
2121 | usb_pipeendpoint(urb->pipe), | 2108 | usb_pipeendpoint(urb->pipe), |
2122 | usb_pipein(urb->pipe) ? "in" : "out"); | 2109 | is_in ? "in" : "out"); |
2123 | 2110 | ||
2124 | spin_lock_irqsave(&musb->lock, flags); | 2111 | spin_lock_irqsave(&musb->lock, flags); |
2125 | ret = usb_hcd_check_unlink_urb(hcd, urb, status); | 2112 | ret = usb_hcd_check_unlink_urb(hcd, urb, status); |
@@ -2130,47 +2117,25 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) | |||
2130 | if (!qh) | 2117 | if (!qh) |
2131 | goto done; | 2118 | goto done; |
2132 | 2119 | ||
2133 | /* Any URB not actively programmed into endpoint hardware can be | 2120 | /* |
2121 | * Any URB not actively programmed into endpoint hardware can be | ||
2134 | * immediately given back; that's any URB not at the head of an | 2122 | * immediately given back; that's any URB not at the head of an |
2135 | * endpoint queue, unless someday we get real DMA queues. And even | 2123 | * endpoint queue, unless someday we get real DMA queues. And even |
2136 | * if it's at the head, it might not be known to the hardware... | 2124 | * if it's at the head, it might not be known to the hardware... |
2137 | * | 2125 | * |
2138 | * Otherwise abort current transfer, pending dma, etc.; urb->status | 2126 | * Otherwise abort current transfer, pending DMA, etc.; urb->status |
2139 | * has already been updated. This is a synchronous abort; it'd be | 2127 | * has already been updated. This is a synchronous abort; it'd be |
2140 | * OK to hold off until after some IRQ, though. | 2128 | * OK to hold off until after some IRQ, though. |
2129 | * | ||
2130 | * NOTE: qh is invalid unless !list_empty(&hep->urb_list) | ||
2141 | */ | 2131 | */ |
2142 | if (!qh->is_ready || urb->urb_list.prev != &qh->hep->urb_list) | 2132 | if (!qh->is_ready |
2143 | ret = -EINPROGRESS; | 2133 | || urb->urb_list.prev != &qh->hep->urb_list |
2144 | else { | 2134 | || musb_ep_get_qh(qh->hw_ep, is_in) != qh) { |
2145 | switch (qh->type) { | ||
2146 | case USB_ENDPOINT_XFER_CONTROL: | ||
2147 | sched = &musb->control; | ||
2148 | break; | ||
2149 | case USB_ENDPOINT_XFER_BULK: | ||
2150 | if (qh->mux == 1) { | ||
2151 | if (usb_pipein(urb->pipe)) | ||
2152 | sched = &musb->in_bulk; | ||
2153 | else | ||
2154 | sched = &musb->out_bulk; | ||
2155 | break; | ||
2156 | } | ||
2157 | default: | ||
2158 | /* REVISIT when we get a schedule tree, periodic | ||
2159 | * transfers won't always be at the head of a | ||
2160 | * singleton queue... | ||
2161 | */ | ||
2162 | sched = NULL; | ||
2163 | break; | ||
2164 | } | ||
2165 | } | ||
2166 | |||
2167 | /* NOTE: qh is invalid unless !list_empty(&hep->urb_list) */ | ||
2168 | if (ret < 0 || (sched && qh != first_qh(sched))) { | ||
2169 | int ready = qh->is_ready; | 2135 | int ready = qh->is_ready; |
2170 | 2136 | ||
2171 | ret = 0; | ||
2172 | qh->is_ready = 0; | 2137 | qh->is_ready = 0; |
2173 | __musb_giveback(musb, urb, 0); | 2138 | musb_giveback(musb, urb, 0); |
2174 | qh->is_ready = ready; | 2139 | qh->is_ready = ready; |
2175 | 2140 | ||
2176 | /* If nothing else (usually musb_giveback) is using it | 2141 | /* If nothing else (usually musb_giveback) is using it |
@@ -2182,7 +2147,7 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) | |||
2182 | kfree(qh); | 2147 | kfree(qh); |
2183 | } | 2148 | } |
2184 | } else | 2149 | } else |
2185 | ret = musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN); | 2150 | ret = musb_cleanup_urb(urb, qh); |
2186 | done: | 2151 | done: |
2187 | spin_unlock_irqrestore(&musb->lock, flags); | 2152 | spin_unlock_irqrestore(&musb->lock, flags); |
2188 | return ret; | 2153 | return ret; |
@@ -2192,13 +2157,11 @@ done: | |||
2192 | static void | 2157 | static void |
2193 | musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) | 2158 | musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) |
2194 | { | 2159 | { |
2195 | u8 epnum = hep->desc.bEndpointAddress; | 2160 | u8 is_in = hep->desc.bEndpointAddress & USB_DIR_IN; |
2196 | unsigned long flags; | 2161 | unsigned long flags; |
2197 | struct musb *musb = hcd_to_musb(hcd); | 2162 | struct musb *musb = hcd_to_musb(hcd); |
2198 | u8 is_in = epnum & USB_DIR_IN; | ||
2199 | struct musb_qh *qh; | 2163 | struct musb_qh *qh; |
2200 | struct urb *urb; | 2164 | struct urb *urb; |
2201 | struct list_head *sched; | ||
2202 | 2165 | ||
2203 | spin_lock_irqsave(&musb->lock, flags); | 2166 | spin_lock_irqsave(&musb->lock, flags); |
2204 | 2167 | ||
@@ -2206,31 +2169,11 @@ musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) | |||
2206 | if (qh == NULL) | 2169 | if (qh == NULL) |
2207 | goto exit; | 2170 | goto exit; |
2208 | 2171 | ||
2209 | switch (qh->type) { | 2172 | /* NOTE: qh is invalid unless !list_empty(&hep->urb_list) */ |
2210 | case USB_ENDPOINT_XFER_CONTROL: | ||
2211 | sched = &musb->control; | ||
2212 | break; | ||
2213 | case USB_ENDPOINT_XFER_BULK: | ||
2214 | if (qh->mux == 1) { | ||
2215 | if (is_in) | ||
2216 | sched = &musb->in_bulk; | ||
2217 | else | ||
2218 | sched = &musb->out_bulk; | ||
2219 | break; | ||
2220 | } | ||
2221 | default: | ||
2222 | /* REVISIT when we get a schedule tree, periodic transfers | ||
2223 | * won't always be at the head of a singleton queue... | ||
2224 | */ | ||
2225 | sched = NULL; | ||
2226 | break; | ||
2227 | } | ||
2228 | |||
2229 | /* NOTE: qh is invalid unless !list_empty(&hep->urb_list) */ | ||
2230 | 2173 | ||
2231 | /* kick first urb off the hardware, if needed */ | 2174 | /* Kick the first URB off the hardware, if needed */ |
2232 | qh->is_ready = 0; | 2175 | qh->is_ready = 0; |
2233 | if (!sched || qh == first_qh(sched)) { | 2176 | if (musb_ep_get_qh(qh->hw_ep, is_in) == qh) { |
2234 | urb = next_urb(qh); | 2177 | urb = next_urb(qh); |
2235 | 2178 | ||
2236 | /* make software (then hardware) stop ASAP */ | 2179 | /* make software (then hardware) stop ASAP */ |
@@ -2238,7 +2181,7 @@ musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) | |||
2238 | urb->status = -ESHUTDOWN; | 2181 | urb->status = -ESHUTDOWN; |
2239 | 2182 | ||
2240 | /* cleanup */ | 2183 | /* cleanup */ |
2241 | musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN); | 2184 | musb_cleanup_urb(urb, qh); |
2242 | 2185 | ||
2243 | /* Then nuke all the others ... and advance the | 2186 | /* Then nuke all the others ... and advance the |
2244 | * queue on hw_ep (e.g. bulk ring) when we're done. | 2187 | * queue on hw_ep (e.g. bulk ring) when we're done. |
@@ -2254,7 +2197,7 @@ musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) | |||
2254 | * will activate any of these as it advances. | 2197 | * will activate any of these as it advances. |
2255 | */ | 2198 | */ |
2256 | while (!list_empty(&hep->urb_list)) | 2199 | while (!list_empty(&hep->urb_list)) |
2257 | __musb_giveback(musb, next_urb(qh), -ESHUTDOWN); | 2200 | musb_giveback(musb, next_urb(qh), -ESHUTDOWN); |
2258 | 2201 | ||
2259 | hep->hcpriv = NULL; | 2202 | hep->hcpriv = NULL; |
2260 | list_del(&qh->ring); | 2203 | list_del(&qh->ring); |
@@ -2293,7 +2236,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd) | |||
2293 | { | 2236 | { |
2294 | struct musb *musb = hcd_to_musb(hcd); | 2237 | struct musb *musb = hcd_to_musb(hcd); |
2295 | 2238 | ||
2296 | if (musb->xceiv.state == OTG_STATE_A_SUSPEND) | 2239 | if (musb->xceiv->state == OTG_STATE_A_SUSPEND) |
2297 | return 0; | 2240 | return 0; |
2298 | 2241 | ||
2299 | if (is_host_active(musb) && musb->is_active) { | 2242 | if (is_host_active(musb) && musb->is_active) { |
diff --git a/drivers/usb/musb/musb_host.h b/drivers/usb/musb/musb_host.h index 0b7fbcd21963..14b00776638d 100644 --- a/drivers/usb/musb/musb_host.h +++ b/drivers/usb/musb/musb_host.h | |||
@@ -67,6 +67,7 @@ struct musb_qh { | |||
67 | u8 is_ready; /* safe to modify hw_ep */ | 67 | u8 is_ready; /* safe to modify hw_ep */ |
68 | u8 type; /* XFERTYPE_* */ | 68 | u8 type; /* XFERTYPE_* */ |
69 | u8 epnum; | 69 | u8 epnum; |
70 | u8 hb_mult; /* high bandwidth pkts per uf */ | ||
70 | u16 maxpacket; | 71 | u16 maxpacket; |
71 | u16 frame; /* for periodic schedule */ | 72 | u16 frame; /* for periodic schedule */ |
72 | unsigned iso_idx; /* in urb->iso_frame_desc[] */ | 73 | unsigned iso_idx; /* in urb->iso_frame_desc[] */ |
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c index bf677acc83db..bfe5fe4ebfee 100644 --- a/drivers/usb/musb/musb_virthub.c +++ b/drivers/usb/musb/musb_virthub.c | |||
@@ -78,18 +78,22 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend) | |||
78 | DBG(3, "Root port suspended, power %02x\n", power); | 78 | DBG(3, "Root port suspended, power %02x\n", power); |
79 | 79 | ||
80 | musb->port1_status |= USB_PORT_STAT_SUSPEND; | 80 | musb->port1_status |= USB_PORT_STAT_SUSPEND; |
81 | switch (musb->xceiv.state) { | 81 | switch (musb->xceiv->state) { |
82 | case OTG_STATE_A_HOST: | 82 | case OTG_STATE_A_HOST: |
83 | musb->xceiv.state = OTG_STATE_A_SUSPEND; | 83 | musb->xceiv->state = OTG_STATE_A_SUSPEND; |
84 | musb->is_active = is_otg_enabled(musb) | 84 | musb->is_active = is_otg_enabled(musb) |
85 | && musb->xceiv.host->b_hnp_enable; | 85 | && musb->xceiv->host->b_hnp_enable; |
86 | if (musb->is_active) | ||
87 | mod_timer(&musb->otg_timer, jiffies | ||
88 | + msecs_to_jiffies( | ||
89 | OTG_TIME_A_AIDL_BDIS)); | ||
86 | musb_platform_try_idle(musb, 0); | 90 | musb_platform_try_idle(musb, 0); |
87 | break; | 91 | break; |
88 | #ifdef CONFIG_USB_MUSB_OTG | 92 | #ifdef CONFIG_USB_MUSB_OTG |
89 | case OTG_STATE_B_HOST: | 93 | case OTG_STATE_B_HOST: |
90 | musb->xceiv.state = OTG_STATE_B_WAIT_ACON; | 94 | musb->xceiv->state = OTG_STATE_B_WAIT_ACON; |
91 | musb->is_active = is_otg_enabled(musb) | 95 | musb->is_active = is_otg_enabled(musb) |
92 | && musb->xceiv.host->b_hnp_enable; | 96 | && musb->xceiv->host->b_hnp_enable; |
93 | musb_platform_try_idle(musb, 0); | 97 | musb_platform_try_idle(musb, 0); |
94 | break; | 98 | break; |
95 | #endif | 99 | #endif |
@@ -116,7 +120,7 @@ static void musb_port_reset(struct musb *musb, bool do_reset) | |||
116 | void __iomem *mbase = musb->mregs; | 120 | void __iomem *mbase = musb->mregs; |
117 | 121 | ||
118 | #ifdef CONFIG_USB_MUSB_OTG | 122 | #ifdef CONFIG_USB_MUSB_OTG |
119 | if (musb->xceiv.state == OTG_STATE_B_IDLE) { | 123 | if (musb->xceiv->state == OTG_STATE_B_IDLE) { |
120 | DBG(2, "HNP: Returning from HNP; no hub reset from b_idle\n"); | 124 | DBG(2, "HNP: Returning from HNP; no hub reset from b_idle\n"); |
121 | musb->port1_status &= ~USB_PORT_STAT_RESET; | 125 | musb->port1_status &= ~USB_PORT_STAT_RESET; |
122 | return; | 126 | return; |
@@ -186,14 +190,23 @@ void musb_root_disconnect(struct musb *musb) | |||
186 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); | 190 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); |
187 | musb->is_active = 0; | 191 | musb->is_active = 0; |
188 | 192 | ||
189 | switch (musb->xceiv.state) { | 193 | switch (musb->xceiv->state) { |
190 | case OTG_STATE_A_HOST: | ||
191 | case OTG_STATE_A_SUSPEND: | 194 | case OTG_STATE_A_SUSPEND: |
192 | musb->xceiv.state = OTG_STATE_A_WAIT_BCON; | 195 | #ifdef CONFIG_USB_MUSB_OTG |
196 | if (is_otg_enabled(musb) | ||
197 | && musb->xceiv->host->b_hnp_enable) { | ||
198 | musb->xceiv->state = OTG_STATE_A_PERIPHERAL; | ||
199 | musb->g.is_a_peripheral = 1; | ||
200 | break; | ||
201 | } | ||
202 | #endif | ||
203 | /* FALLTHROUGH */ | ||
204 | case OTG_STATE_A_HOST: | ||
205 | musb->xceiv->state = OTG_STATE_A_WAIT_BCON; | ||
193 | musb->is_active = 0; | 206 | musb->is_active = 0; |
194 | break; | 207 | break; |
195 | case OTG_STATE_A_WAIT_VFALL: | 208 | case OTG_STATE_A_WAIT_VFALL: |
196 | musb->xceiv.state = OTG_STATE_B_IDLE; | 209 | musb->xceiv->state = OTG_STATE_B_IDLE; |
197 | break; | 210 | break; |
198 | default: | 211 | default: |
199 | DBG(1, "host disconnect (%s)\n", otg_state_string(musb)); | 212 | DBG(1, "host disconnect (%s)\n", otg_state_string(musb)); |
@@ -332,7 +345,7 @@ int musb_hub_control( | |||
332 | musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; | 345 | musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; |
333 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); | 346 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); |
334 | /* NOTE: it might really be A_WAIT_BCON ... */ | 347 | /* NOTE: it might really be A_WAIT_BCON ... */ |
335 | musb->xceiv.state = OTG_STATE_A_HOST; | 348 | musb->xceiv->state = OTG_STATE_A_HOST; |
336 | } | 349 | } |
337 | 350 | ||
338 | put_unaligned(cpu_to_le32(musb->port1_status | 351 | put_unaligned(cpu_to_le32(musb->port1_status |
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c index 60924ce08493..34875201ee04 100644 --- a/drivers/usb/musb/omap2430.c +++ b/drivers/usb/musb/omap2430.c | |||
@@ -44,7 +44,6 @@ | |||
44 | #define get_cpu_rev() 2 | 44 | #define get_cpu_rev() 2 |
45 | #endif | 45 | #endif |
46 | 46 | ||
47 | #define MUSB_TIMEOUT_A_WAIT_BCON 1100 | ||
48 | 47 | ||
49 | static struct timer_list musb_idle_timer; | 48 | static struct timer_list musb_idle_timer; |
50 | 49 | ||
@@ -61,17 +60,17 @@ static void musb_do_idle(unsigned long _musb) | |||
61 | 60 | ||
62 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); | 61 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); |
63 | 62 | ||
64 | switch (musb->xceiv.state) { | 63 | switch (musb->xceiv->state) { |
65 | case OTG_STATE_A_WAIT_BCON: | 64 | case OTG_STATE_A_WAIT_BCON: |
66 | devctl &= ~MUSB_DEVCTL_SESSION; | 65 | devctl &= ~MUSB_DEVCTL_SESSION; |
67 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); | 66 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); |
68 | 67 | ||
69 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); | 68 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); |
70 | if (devctl & MUSB_DEVCTL_BDEVICE) { | 69 | if (devctl & MUSB_DEVCTL_BDEVICE) { |
71 | musb->xceiv.state = OTG_STATE_B_IDLE; | 70 | musb->xceiv->state = OTG_STATE_B_IDLE; |
72 | MUSB_DEV_MODE(musb); | 71 | MUSB_DEV_MODE(musb); |
73 | } else { | 72 | } else { |
74 | musb->xceiv.state = OTG_STATE_A_IDLE; | 73 | musb->xceiv->state = OTG_STATE_A_IDLE; |
75 | MUSB_HST_MODE(musb); | 74 | MUSB_HST_MODE(musb); |
76 | } | 75 | } |
77 | break; | 76 | break; |
@@ -89,7 +88,7 @@ static void musb_do_idle(unsigned long _musb) | |||
89 | musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; | 88 | musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; |
90 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); | 89 | usb_hcd_poll_rh_status(musb_to_hcd(musb)); |
91 | /* NOTE: it might really be A_WAIT_BCON ... */ | 90 | /* NOTE: it might really be A_WAIT_BCON ... */ |
92 | musb->xceiv.state = OTG_STATE_A_HOST; | 91 | musb->xceiv->state = OTG_STATE_A_HOST; |
93 | } | 92 | } |
94 | break; | 93 | break; |
95 | #endif | 94 | #endif |
@@ -97,9 +96,9 @@ static void musb_do_idle(unsigned long _musb) | |||
97 | case OTG_STATE_A_HOST: | 96 | case OTG_STATE_A_HOST: |
98 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); | 97 | devctl = musb_readb(musb->mregs, MUSB_DEVCTL); |
99 | if (devctl & MUSB_DEVCTL_BDEVICE) | 98 | if (devctl & MUSB_DEVCTL_BDEVICE) |
100 | musb->xceiv.state = OTG_STATE_B_IDLE; | 99 | musb->xceiv->state = OTG_STATE_B_IDLE; |
101 | else | 100 | else |
102 | musb->xceiv.state = OTG_STATE_A_WAIT_BCON; | 101 | musb->xceiv->state = OTG_STATE_A_WAIT_BCON; |
103 | #endif | 102 | #endif |
104 | default: | 103 | default: |
105 | break; | 104 | break; |
@@ -118,7 +117,7 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout) | |||
118 | 117 | ||
119 | /* Never idle if active, or when VBUS timeout is not set as host */ | 118 | /* Never idle if active, or when VBUS timeout is not set as host */ |
120 | if (musb->is_active || ((musb->a_wait_bcon == 0) | 119 | if (musb->is_active || ((musb->a_wait_bcon == 0) |
121 | && (musb->xceiv.state == OTG_STATE_A_WAIT_BCON))) { | 120 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { |
122 | DBG(4, "%s active, deleting timer\n", otg_state_string(musb)); | 121 | DBG(4, "%s active, deleting timer\n", otg_state_string(musb)); |
123 | del_timer(&musb_idle_timer); | 122 | del_timer(&musb_idle_timer); |
124 | last_timer = jiffies; | 123 | last_timer = jiffies; |
@@ -163,8 +162,8 @@ static void omap_set_vbus(struct musb *musb, int is_on) | |||
163 | 162 | ||
164 | if (is_on) { | 163 | if (is_on) { |
165 | musb->is_active = 1; | 164 | musb->is_active = 1; |
166 | musb->xceiv.default_a = 1; | 165 | musb->xceiv->default_a = 1; |
167 | musb->xceiv.state = OTG_STATE_A_WAIT_VRISE; | 166 | musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; |
168 | devctl |= MUSB_DEVCTL_SESSION; | 167 | devctl |= MUSB_DEVCTL_SESSION; |
169 | 168 | ||
170 | MUSB_HST_MODE(musb); | 169 | MUSB_HST_MODE(musb); |
@@ -175,8 +174,8 @@ static void omap_set_vbus(struct musb *musb, int is_on) | |||
175 | * jumping right to B_IDLE... | 174 | * jumping right to B_IDLE... |
176 | */ | 175 | */ |
177 | 176 | ||
178 | musb->xceiv.default_a = 0; | 177 | musb->xceiv->default_a = 0; |
179 | musb->xceiv.state = OTG_STATE_B_IDLE; | 178 | musb->xceiv->state = OTG_STATE_B_IDLE; |
180 | devctl &= ~MUSB_DEVCTL_SESSION; | 179 | devctl &= ~MUSB_DEVCTL_SESSION; |
181 | 180 | ||
182 | MUSB_DEV_MODE(musb); | 181 | MUSB_DEV_MODE(musb); |
@@ -188,10 +187,6 @@ static void omap_set_vbus(struct musb *musb, int is_on) | |||
188 | otg_state_string(musb), | 187 | otg_state_string(musb), |
189 | musb_readb(musb->mregs, MUSB_DEVCTL)); | 188 | musb_readb(musb->mregs, MUSB_DEVCTL)); |
190 | } | 189 | } |
191 | static int omap_set_power(struct otg_transceiver *x, unsigned mA) | ||
192 | { | ||
193 | return 0; | ||
194 | } | ||
195 | 190 | ||
196 | static int musb_platform_resume(struct musb *musb); | 191 | static int musb_platform_resume(struct musb *musb); |
197 | 192 | ||
@@ -202,24 +197,6 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode) | |||
202 | devctl |= MUSB_DEVCTL_SESSION; | 197 | devctl |= MUSB_DEVCTL_SESSION; |
203 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); | 198 | musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); |
204 | 199 | ||
205 | switch (musb_mode) { | ||
206 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | ||
207 | case MUSB_HOST: | ||
208 | otg_set_host(&musb->xceiv, musb->xceiv.host); | ||
209 | break; | ||
210 | #endif | ||
211 | #ifdef CONFIG_USB_GADGET_MUSB_HDRC | ||
212 | case MUSB_PERIPHERAL: | ||
213 | otg_set_peripheral(&musb->xceiv, musb->xceiv.gadget); | ||
214 | break; | ||
215 | #endif | ||
216 | #ifdef CONFIG_USB_MUSB_OTG | ||
217 | case MUSB_OTG: | ||
218 | break; | ||
219 | #endif | ||
220 | default: | ||
221 | return -EINVAL; | ||
222 | } | ||
223 | return 0; | 200 | return 0; |
224 | } | 201 | } |
225 | 202 | ||
@@ -231,6 +208,16 @@ int __init musb_platform_init(struct musb *musb) | |||
231 | omap_cfg_reg(AE5_2430_USB0HS_STP); | 208 | omap_cfg_reg(AE5_2430_USB0HS_STP); |
232 | #endif | 209 | #endif |
233 | 210 | ||
211 | /* We require some kind of external transceiver, hooked | ||
212 | * up through ULPI. TWL4030-family PMICs include one, | ||
213 | * which needs a driver, drivers aren't always needed. | ||
214 | */ | ||
215 | musb->xceiv = otg_get_transceiver(); | ||
216 | if (!musb->xceiv) { | ||
217 | pr_err("HS USB OTG: no transceiver configured\n"); | ||
218 | return -ENODEV; | ||
219 | } | ||
220 | |||
234 | musb_platform_resume(musb); | 221 | musb_platform_resume(musb); |
235 | 222 | ||
236 | l = omap_readl(OTG_SYSCONFIG); | 223 | l = omap_readl(OTG_SYSCONFIG); |
@@ -240,7 +227,12 @@ int __init musb_platform_init(struct musb *musb) | |||
240 | l &= ~AUTOIDLE; /* disable auto idle */ | 227 | l &= ~AUTOIDLE; /* disable auto idle */ |
241 | l &= ~NOIDLE; /* remove possible noidle */ | 228 | l &= ~NOIDLE; /* remove possible noidle */ |
242 | l |= SMARTIDLE; /* enable smart idle */ | 229 | l |= SMARTIDLE; /* enable smart idle */ |
243 | l |= AUTOIDLE; /* enable auto idle */ | 230 | /* |
231 | * MUSB AUTOIDLE don't work in 3430. | ||
232 | * Workaround by Richard Woodruff/TI | ||
233 | */ | ||
234 | if (!cpu_is_omap3430()) | ||
235 | l |= AUTOIDLE; /* enable auto idle */ | ||
244 | omap_writel(l, OTG_SYSCONFIG); | 236 | omap_writel(l, OTG_SYSCONFIG); |
245 | 237 | ||
246 | l = omap_readl(OTG_INTERFSEL); | 238 | l = omap_readl(OTG_INTERFSEL); |
@@ -257,9 +249,6 @@ int __init musb_platform_init(struct musb *musb) | |||
257 | 249 | ||
258 | if (is_host_enabled(musb)) | 250 | if (is_host_enabled(musb)) |
259 | musb->board_set_vbus = omap_set_vbus; | 251 | musb->board_set_vbus = omap_set_vbus; |
260 | if (is_peripheral_enabled(musb)) | ||
261 | musb->xceiv.set_power = omap_set_power; | ||
262 | musb->a_wait_bcon = MUSB_TIMEOUT_A_WAIT_BCON; | ||
263 | 252 | ||
264 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); | 253 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); |
265 | 254 | ||
@@ -282,8 +271,7 @@ int musb_platform_suspend(struct musb *musb) | |||
282 | l |= ENABLEWAKEUP; /* enable wakeup */ | 271 | l |= ENABLEWAKEUP; /* enable wakeup */ |
283 | omap_writel(l, OTG_SYSCONFIG); | 272 | omap_writel(l, OTG_SYSCONFIG); |
284 | 273 | ||
285 | if (musb->xceiv.set_suspend) | 274 | otg_set_suspend(musb->xceiv, 1); |
286 | musb->xceiv.set_suspend(&musb->xceiv, 1); | ||
287 | 275 | ||
288 | if (musb->set_clock) | 276 | if (musb->set_clock) |
289 | musb->set_clock(musb->clock, 0); | 277 | musb->set_clock(musb->clock, 0); |
@@ -300,8 +288,7 @@ static int musb_platform_resume(struct musb *musb) | |||
300 | if (!musb->clock) | 288 | if (!musb->clock) |
301 | return 0; | 289 | return 0; |
302 | 290 | ||
303 | if (musb->xceiv.set_suspend) | 291 | otg_set_suspend(musb->xceiv, 0); |
304 | musb->xceiv.set_suspend(&musb->xceiv, 0); | ||
305 | 292 | ||
306 | if (musb->set_clock) | 293 | if (musb->set_clock) |
307 | musb->set_clock(musb->clock, 1); | 294 | musb->set_clock(musb->clock, 1); |
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c index 4ac1477d3569..88b587c703e9 100644 --- a/drivers/usb/musb/tusb6010.c +++ b/drivers/usb/musb/tusb6010.c | |||
@@ -259,6 +259,8 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *buf) | |||
259 | tusb_fifo_read_unaligned(fifo, buf, len); | 259 | tusb_fifo_read_unaligned(fifo, buf, len); |
260 | } | 260 | } |
261 | 261 | ||
262 | static struct musb *the_musb; | ||
263 | |||
262 | #ifdef CONFIG_USB_GADGET_MUSB_HDRC | 264 | #ifdef CONFIG_USB_GADGET_MUSB_HDRC |
263 | 265 | ||
264 | /* This is used by gadget drivers, and OTG transceiver logic, allowing | 266 | /* This is used by gadget drivers, and OTG transceiver logic, allowing |
@@ -269,7 +271,7 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *buf) | |||
269 | */ | 271 | */ |
270 | static int tusb_draw_power(struct otg_transceiver *x, unsigned mA) | 272 | static int tusb_draw_power(struct otg_transceiver *x, unsigned mA) |
271 | { | 273 | { |
272 | struct musb *musb = container_of(x, struct musb, xceiv); | 274 | struct musb *musb = the_musb; |
273 | void __iomem *tbase = musb->ctrl_base; | 275 | void __iomem *tbase = musb->ctrl_base; |
274 | u32 reg; | 276 | u32 reg; |
275 | 277 | ||
@@ -419,7 +421,7 @@ static void musb_do_idle(unsigned long _musb) | |||
419 | 421 | ||
420 | spin_lock_irqsave(&musb->lock, flags); | 422 | spin_lock_irqsave(&musb->lock, flags); |
421 | 423 | ||
422 | switch (musb->xceiv.state) { | 424 | switch (musb->xceiv->state) { |
423 | case OTG_STATE_A_WAIT_BCON: | 425 | case OTG_STATE_A_WAIT_BCON: |
424 | if ((musb->a_wait_bcon != 0) | 426 | if ((musb->a_wait_bcon != 0) |
425 | && (musb->idle_timeout == 0 | 427 | && (musb->idle_timeout == 0 |
@@ -483,7 +485,7 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout) | |||
483 | 485 | ||
484 | /* Never idle if active, or when VBUS timeout is not set as host */ | 486 | /* Never idle if active, or when VBUS timeout is not set as host */ |
485 | if (musb->is_active || ((musb->a_wait_bcon == 0) | 487 | if (musb->is_active || ((musb->a_wait_bcon == 0) |
486 | && (musb->xceiv.state == OTG_STATE_A_WAIT_BCON))) { | 488 | && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { |
487 | DBG(4, "%s active, deleting timer\n", otg_state_string(musb)); | 489 | DBG(4, "%s active, deleting timer\n", otg_state_string(musb)); |
488 | del_timer(&musb_idle_timer); | 490 | del_timer(&musb_idle_timer); |
489 | last_timer = jiffies; | 491 | last_timer = jiffies; |
@@ -532,8 +534,8 @@ static void tusb_source_power(struct musb *musb, int is_on) | |||
532 | if (musb->set_clock) | 534 | if (musb->set_clock) |
533 | musb->set_clock(musb->clock, 1); | 535 | musb->set_clock(musb->clock, 1); |
534 | timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE); | 536 | timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE); |
535 | musb->xceiv.default_a = 1; | 537 | musb->xceiv->default_a = 1; |
536 | musb->xceiv.state = OTG_STATE_A_WAIT_VRISE; | 538 | musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; |
537 | devctl |= MUSB_DEVCTL_SESSION; | 539 | devctl |= MUSB_DEVCTL_SESSION; |
538 | 540 | ||
539 | conf |= TUSB_DEV_CONF_USB_HOST_MODE; | 541 | conf |= TUSB_DEV_CONF_USB_HOST_MODE; |
@@ -546,24 +548,24 @@ static void tusb_source_power(struct musb *musb, int is_on) | |||
546 | /* If ID pin is grounded, we want to be a_idle */ | 548 | /* If ID pin is grounded, we want to be a_idle */ |
547 | otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT); | 549 | otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT); |
548 | if (!(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS)) { | 550 | if (!(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS)) { |
549 | switch (musb->xceiv.state) { | 551 | switch (musb->xceiv->state) { |
550 | case OTG_STATE_A_WAIT_VRISE: | 552 | case OTG_STATE_A_WAIT_VRISE: |
551 | case OTG_STATE_A_WAIT_BCON: | 553 | case OTG_STATE_A_WAIT_BCON: |
552 | musb->xceiv.state = OTG_STATE_A_WAIT_VFALL; | 554 | musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; |
553 | break; | 555 | break; |
554 | case OTG_STATE_A_WAIT_VFALL: | 556 | case OTG_STATE_A_WAIT_VFALL: |
555 | musb->xceiv.state = OTG_STATE_A_IDLE; | 557 | musb->xceiv->state = OTG_STATE_A_IDLE; |
556 | break; | 558 | break; |
557 | default: | 559 | default: |
558 | musb->xceiv.state = OTG_STATE_A_IDLE; | 560 | musb->xceiv->state = OTG_STATE_A_IDLE; |
559 | } | 561 | } |
560 | musb->is_active = 0; | 562 | musb->is_active = 0; |
561 | musb->xceiv.default_a = 1; | 563 | musb->xceiv->default_a = 1; |
562 | MUSB_HST_MODE(musb); | 564 | MUSB_HST_MODE(musb); |
563 | } else { | 565 | } else { |
564 | musb->is_active = 0; | 566 | musb->is_active = 0; |
565 | musb->xceiv.default_a = 0; | 567 | musb->xceiv->default_a = 0; |
566 | musb->xceiv.state = OTG_STATE_B_IDLE; | 568 | musb->xceiv->state = OTG_STATE_B_IDLE; |
567 | MUSB_DEV_MODE(musb); | 569 | MUSB_DEV_MODE(musb); |
568 | } | 570 | } |
569 | 571 | ||
@@ -674,7 +676,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
674 | else | 676 | else |
675 | default_a = is_host_enabled(musb); | 677 | default_a = is_host_enabled(musb); |
676 | DBG(2, "Default-%c\n", default_a ? 'A' : 'B'); | 678 | DBG(2, "Default-%c\n", default_a ? 'A' : 'B'); |
677 | musb->xceiv.default_a = default_a; | 679 | musb->xceiv->default_a = default_a; |
678 | tusb_source_power(musb, default_a); | 680 | tusb_source_power(musb, default_a); |
679 | 681 | ||
680 | /* Don't allow idling immediately */ | 682 | /* Don't allow idling immediately */ |
@@ -686,7 +688,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
686 | if (int_src & TUSB_INT_SRC_VBUS_SENSE_CHNG) { | 688 | if (int_src & TUSB_INT_SRC_VBUS_SENSE_CHNG) { |
687 | 689 | ||
688 | /* B-dev state machine: no vbus ~= disconnect */ | 690 | /* B-dev state machine: no vbus ~= disconnect */ |
689 | if ((is_otg_enabled(musb) && !musb->xceiv.default_a) | 691 | if ((is_otg_enabled(musb) && !musb->xceiv->default_a) |
690 | || !is_host_enabled(musb)) { | 692 | || !is_host_enabled(musb)) { |
691 | #ifdef CONFIG_USB_MUSB_HDRC_HCD | 693 | #ifdef CONFIG_USB_MUSB_HDRC_HCD |
692 | /* ? musb_root_disconnect(musb); */ | 694 | /* ? musb_root_disconnect(musb); */ |
@@ -701,9 +703,9 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
701 | 703 | ||
702 | if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) { | 704 | if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) { |
703 | DBG(1, "Forcing disconnect (no interrupt)\n"); | 705 | DBG(1, "Forcing disconnect (no interrupt)\n"); |
704 | if (musb->xceiv.state != OTG_STATE_B_IDLE) { | 706 | if (musb->xceiv->state != OTG_STATE_B_IDLE) { |
705 | /* INTR_DISCONNECT can hide... */ | 707 | /* INTR_DISCONNECT can hide... */ |
706 | musb->xceiv.state = OTG_STATE_B_IDLE; | 708 | musb->xceiv->state = OTG_STATE_B_IDLE; |
707 | musb->int_usb |= MUSB_INTR_DISCONNECT; | 709 | musb->int_usb |= MUSB_INTR_DISCONNECT; |
708 | } | 710 | } |
709 | musb->is_active = 0; | 711 | musb->is_active = 0; |
@@ -717,7 +719,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
717 | DBG(2, "vbus change, %s, otg %03x\n", | 719 | DBG(2, "vbus change, %s, otg %03x\n", |
718 | otg_state_string(musb), otg_stat); | 720 | otg_state_string(musb), otg_stat); |
719 | 721 | ||
720 | switch (musb->xceiv.state) { | 722 | switch (musb->xceiv->state) { |
721 | case OTG_STATE_A_IDLE: | 723 | case OTG_STATE_A_IDLE: |
722 | DBG(2, "Got SRP, turning on VBUS\n"); | 724 | DBG(2, "Got SRP, turning on VBUS\n"); |
723 | musb_set_vbus(musb, 1); | 725 | musb_set_vbus(musb, 1); |
@@ -765,7 +767,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
765 | 767 | ||
766 | DBG(4, "%s timer, %03x\n", otg_state_string(musb), otg_stat); | 768 | DBG(4, "%s timer, %03x\n", otg_state_string(musb), otg_stat); |
767 | 769 | ||
768 | switch (musb->xceiv.state) { | 770 | switch (musb->xceiv->state) { |
769 | case OTG_STATE_A_WAIT_VRISE: | 771 | case OTG_STATE_A_WAIT_VRISE: |
770 | /* VBUS has probably been valid for a while now, | 772 | /* VBUS has probably been valid for a while now, |
771 | * but may well have bounced out of range a bit | 773 | * but may well have bounced out of range a bit |
@@ -777,7 +779,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) | |||
777 | DBG(2, "devctl %02x\n", devctl); | 779 | DBG(2, "devctl %02x\n", devctl); |
778 | break; | 780 | break; |
779 | } | 781 | } |
780 | musb->xceiv.state = OTG_STATE_A_WAIT_BCON; | 782 | musb->xceiv->state = OTG_STATE_A_WAIT_BCON; |
781 | musb->is_active = 0; | 783 | musb->is_active = 0; |
782 | idle_timeout = jiffies | 784 | idle_timeout = jiffies |
783 | + msecs_to_jiffies(musb->a_wait_bcon); | 785 | + msecs_to_jiffies(musb->a_wait_bcon); |
@@ -1093,9 +1095,14 @@ int __init musb_platform_init(struct musb *musb) | |||
1093 | { | 1095 | { |
1094 | struct platform_device *pdev; | 1096 | struct platform_device *pdev; |
1095 | struct resource *mem; | 1097 | struct resource *mem; |
1096 | void __iomem *sync; | 1098 | void __iomem *sync = NULL; |
1097 | int ret; | 1099 | int ret; |
1098 | 1100 | ||
1101 | usb_nop_xceiv_register(); | ||
1102 | musb->xceiv = otg_get_transceiver(); | ||
1103 | if (!musb->xceiv) | ||
1104 | return -ENODEV; | ||
1105 | |||
1099 | pdev = to_platform_device(musb->controller); | 1106 | pdev = to_platform_device(musb->controller); |
1100 | 1107 | ||
1101 | /* dma address for async dma */ | 1108 | /* dma address for async dma */ |
@@ -1106,14 +1113,16 @@ int __init musb_platform_init(struct musb *musb) | |||
1106 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); | 1113 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); |
1107 | if (!mem) { | 1114 | if (!mem) { |
1108 | pr_debug("no sync dma resource?\n"); | 1115 | pr_debug("no sync dma resource?\n"); |
1109 | return -ENODEV; | 1116 | ret = -ENODEV; |
1117 | goto done; | ||
1110 | } | 1118 | } |
1111 | musb->sync = mem->start; | 1119 | musb->sync = mem->start; |
1112 | 1120 | ||
1113 | sync = ioremap(mem->start, mem->end - mem->start + 1); | 1121 | sync = ioremap(mem->start, mem->end - mem->start + 1); |
1114 | if (!sync) { | 1122 | if (!sync) { |
1115 | pr_debug("ioremap for sync failed\n"); | 1123 | pr_debug("ioremap for sync failed\n"); |
1116 | return -ENOMEM; | 1124 | ret = -ENOMEM; |
1125 | goto done; | ||
1117 | } | 1126 | } |
1118 | musb->sync_va = sync; | 1127 | musb->sync_va = sync; |
1119 | 1128 | ||
@@ -1126,28 +1135,37 @@ int __init musb_platform_init(struct musb *musb) | |||
1126 | if (ret) { | 1135 | if (ret) { |
1127 | printk(KERN_ERR "Could not start tusb6010 (%d)\n", | 1136 | printk(KERN_ERR "Could not start tusb6010 (%d)\n", |
1128 | ret); | 1137 | ret); |
1129 | return -ENODEV; | 1138 | goto done; |
1130 | } | 1139 | } |
1131 | musb->isr = tusb_interrupt; | 1140 | musb->isr = tusb_interrupt; |
1132 | 1141 | ||
1133 | if (is_host_enabled(musb)) | 1142 | if (is_host_enabled(musb)) |
1134 | musb->board_set_vbus = tusb_source_power; | 1143 | musb->board_set_vbus = tusb_source_power; |
1135 | if (is_peripheral_enabled(musb)) | 1144 | if (is_peripheral_enabled(musb)) { |
1136 | musb->xceiv.set_power = tusb_draw_power; | 1145 | musb->xceiv->set_power = tusb_draw_power; |
1146 | the_musb = musb; | ||
1147 | } | ||
1137 | 1148 | ||
1138 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); | 1149 | setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb); |
1139 | 1150 | ||
1151 | done: | ||
1152 | if (ret < 0) { | ||
1153 | if (sync) | ||
1154 | iounmap(sync); | ||
1155 | usb_nop_xceiv_unregister(); | ||
1156 | } | ||
1140 | return ret; | 1157 | return ret; |
1141 | } | 1158 | } |
1142 | 1159 | ||
1143 | int musb_platform_exit(struct musb *musb) | 1160 | int musb_platform_exit(struct musb *musb) |
1144 | { | 1161 | { |
1145 | del_timer_sync(&musb_idle_timer); | 1162 | del_timer_sync(&musb_idle_timer); |
1163 | the_musb = NULL; | ||
1146 | 1164 | ||
1147 | if (musb->board_set_power) | 1165 | if (musb->board_set_power) |
1148 | musb->board_set_power(0); | 1166 | musb->board_set_power(0); |
1149 | 1167 | ||
1150 | iounmap(musb->sync_va); | 1168 | iounmap(musb->sync_va); |
1151 | 1169 | usb_nop_xceiv_unregister(); | |
1152 | return 0; | 1170 | return 0; |
1153 | } | 1171 | } |
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig index aa884d072f0b..69feeec1628c 100644 --- a/drivers/usb/otg/Kconfig +++ b/drivers/usb/otg/Kconfig | |||
@@ -59,4 +59,18 @@ config NOP_USB_XCEIV | |||
59 | built-in with usb ip or which are autonomous and doesn't require any | 59 | built-in with usb ip or which are autonomous and doesn't require any |
60 | phy programming such as ISP1x04 etc. | 60 | phy programming such as ISP1x04 etc. |
61 | 61 | ||
62 | config USB_LANGWELL_OTG | ||
63 | tristate "Intel Langwell USB OTG dual-role support" | ||
64 | depends on USB && MRST | ||
65 | select USB_OTG | ||
66 | select USB_OTG_UTILS | ||
67 | help | ||
68 | Say Y here if you want to build Intel Langwell USB OTG | ||
69 | transciever driver in kernel. This driver implements role | ||
70 | switch between EHCI host driver and Langwell USB OTG | ||
71 | client driver. | ||
72 | |||
73 | To compile this driver as a module, choose M here: the | ||
74 | module will be called langwell_otg. | ||
75 | |||
62 | endif # USB || OTG | 76 | endif # USB || OTG |
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile index 208167856529..6d1abdd3c0ac 100644 --- a/drivers/usb/otg/Makefile +++ b/drivers/usb/otg/Makefile | |||
@@ -9,6 +9,7 @@ obj-$(CONFIG_USB_OTG_UTILS) += otg.o | |||
9 | obj-$(CONFIG_USB_GPIO_VBUS) += gpio_vbus.o | 9 | obj-$(CONFIG_USB_GPIO_VBUS) += gpio_vbus.o |
10 | obj-$(CONFIG_ISP1301_OMAP) += isp1301_omap.o | 10 | obj-$(CONFIG_ISP1301_OMAP) += isp1301_omap.o |
11 | obj-$(CONFIG_TWL4030_USB) += twl4030-usb.o | 11 | obj-$(CONFIG_TWL4030_USB) += twl4030-usb.o |
12 | obj-$(CONFIG_USB_LANGWELL_OTG) += langwell_otg.o | ||
12 | obj-$(CONFIG_NOP_USB_XCEIV) += nop-usb-xceiv.o | 13 | obj-$(CONFIG_NOP_USB_XCEIV) += nop-usb-xceiv.o |
13 | 14 | ||
14 | ccflags-$(CONFIG_USB_DEBUG) += -DDEBUG | 15 | ccflags-$(CONFIG_USB_DEBUG) += -DDEBUG |
diff --git a/drivers/usb/otg/langwell_otg.c b/drivers/usb/otg/langwell_otg.c new file mode 100644 index 000000000000..6f628d0e9f39 --- /dev/null +++ b/drivers/usb/otg/langwell_otg.c | |||
@@ -0,0 +1,1915 @@ | |||
1 | /* | ||
2 | * Intel Langwell USB OTG transceiver driver | ||
3 | * Copyright (C) 2008 - 2009, Intel Corporation. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms and conditions of the GNU General Public License, | ||
7 | * version 2, as published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., | ||
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
17 | * | ||
18 | */ | ||
19 | /* This driver helps to switch Langwell OTG controller function between host | ||
20 | * and peripheral. It works with EHCI driver and Langwell client controller | ||
21 | * driver together. | ||
22 | */ | ||
23 | #include <linux/module.h> | ||
24 | #include <linux/init.h> | ||
25 | #include <linux/pci.h> | ||
26 | #include <linux/errno.h> | ||
27 | #include <linux/interrupt.h> | ||
28 | #include <linux/kernel.h> | ||
29 | #include <linux/device.h> | ||
30 | #include <linux/moduleparam.h> | ||
31 | #include <linux/usb/ch9.h> | ||
32 | #include <linux/usb/gadget.h> | ||
33 | #include <linux/usb.h> | ||
34 | #include <linux/usb/otg.h> | ||
35 | #include <linux/notifier.h> | ||
36 | #include <asm/ipc_defs.h> | ||
37 | #include <linux/delay.h> | ||
38 | #include "../core/hcd.h" | ||
39 | |||
40 | #include <linux/usb/langwell_otg.h> | ||
41 | |||
42 | #define DRIVER_DESC "Intel Langwell USB OTG transceiver driver" | ||
43 | #define DRIVER_VERSION "3.0.0.32L.0002" | ||
44 | |||
45 | MODULE_DESCRIPTION(DRIVER_DESC); | ||
46 | MODULE_AUTHOR("Henry Yuan <hang.yuan@intel.com>, Hao Wu <hao.wu@intel.com>"); | ||
47 | MODULE_VERSION(DRIVER_VERSION); | ||
48 | MODULE_LICENSE("GPL"); | ||
49 | |||
50 | static const char driver_name[] = "langwell_otg"; | ||
51 | |||
52 | static int langwell_otg_probe(struct pci_dev *pdev, | ||
53 | const struct pci_device_id *id); | ||
54 | static void langwell_otg_remove(struct pci_dev *pdev); | ||
55 | static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message); | ||
56 | static int langwell_otg_resume(struct pci_dev *pdev); | ||
57 | |||
58 | static int langwell_otg_set_host(struct otg_transceiver *otg, | ||
59 | struct usb_bus *host); | ||
60 | static int langwell_otg_set_peripheral(struct otg_transceiver *otg, | ||
61 | struct usb_gadget *gadget); | ||
62 | static int langwell_otg_start_srp(struct otg_transceiver *otg); | ||
63 | |||
64 | static const struct pci_device_id pci_ids[] = {{ | ||
65 | .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), | ||
66 | .class_mask = ~0, | ||
67 | .vendor = 0x8086, | ||
68 | .device = 0x0811, | ||
69 | .subvendor = PCI_ANY_ID, | ||
70 | .subdevice = PCI_ANY_ID, | ||
71 | }, { /* end: all zeroes */ } | ||
72 | }; | ||
73 | |||
74 | static struct pci_driver otg_pci_driver = { | ||
75 | .name = (char *) driver_name, | ||
76 | .id_table = pci_ids, | ||
77 | |||
78 | .probe = langwell_otg_probe, | ||
79 | .remove = langwell_otg_remove, | ||
80 | |||
81 | .suspend = langwell_otg_suspend, | ||
82 | .resume = langwell_otg_resume, | ||
83 | }; | ||
84 | |||
85 | static const char *state_string(enum usb_otg_state state) | ||
86 | { | ||
87 | switch (state) { | ||
88 | case OTG_STATE_A_IDLE: | ||
89 | return "a_idle"; | ||
90 | case OTG_STATE_A_WAIT_VRISE: | ||
91 | return "a_wait_vrise"; | ||
92 | case OTG_STATE_A_WAIT_BCON: | ||
93 | return "a_wait_bcon"; | ||
94 | case OTG_STATE_A_HOST: | ||
95 | return "a_host"; | ||
96 | case OTG_STATE_A_SUSPEND: | ||
97 | return "a_suspend"; | ||
98 | case OTG_STATE_A_PERIPHERAL: | ||
99 | return "a_peripheral"; | ||
100 | case OTG_STATE_A_WAIT_VFALL: | ||
101 | return "a_wait_vfall"; | ||
102 | case OTG_STATE_A_VBUS_ERR: | ||
103 | return "a_vbus_err"; | ||
104 | case OTG_STATE_B_IDLE: | ||
105 | return "b_idle"; | ||
106 | case OTG_STATE_B_SRP_INIT: | ||
107 | return "b_srp_init"; | ||
108 | case OTG_STATE_B_PERIPHERAL: | ||
109 | return "b_peripheral"; | ||
110 | case OTG_STATE_B_WAIT_ACON: | ||
111 | return "b_wait_acon"; | ||
112 | case OTG_STATE_B_HOST: | ||
113 | return "b_host"; | ||
114 | default: | ||
115 | return "UNDEFINED"; | ||
116 | } | ||
117 | } | ||
118 | |||
119 | /* HSM timers */ | ||
120 | static inline struct langwell_otg_timer *otg_timer_initializer | ||
121 | (void (*function)(unsigned long), unsigned long expires, unsigned long data) | ||
122 | { | ||
123 | struct langwell_otg_timer *timer; | ||
124 | timer = kmalloc(sizeof(struct langwell_otg_timer), GFP_KERNEL); | ||
125 | timer->function = function; | ||
126 | timer->expires = expires; | ||
127 | timer->data = data; | ||
128 | return timer; | ||
129 | } | ||
130 | |||
131 | static struct langwell_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr, | ||
132 | *a_aidl_bdis_tmr, *b_ase0_brst_tmr, *b_se0_srp_tmr, *b_srp_res_tmr, | ||
133 | *b_bus_suspend_tmr; | ||
134 | |||
135 | static struct list_head active_timers; | ||
136 | |||
137 | static struct langwell_otg *the_transceiver; | ||
138 | |||
139 | /* host/client notify transceiver when event affects HNP state */ | ||
140 | void langwell_update_transceiver() | ||
141 | { | ||
142 | otg_dbg("transceiver driver is notified\n"); | ||
143 | queue_work(the_transceiver->qwork, &the_transceiver->work); | ||
144 | } | ||
145 | EXPORT_SYMBOL(langwell_update_transceiver); | ||
146 | |||
147 | static int langwell_otg_set_host(struct otg_transceiver *otg, | ||
148 | struct usb_bus *host) | ||
149 | { | ||
150 | otg->host = host; | ||
151 | |||
152 | return 0; | ||
153 | } | ||
154 | |||
155 | static int langwell_otg_set_peripheral(struct otg_transceiver *otg, | ||
156 | struct usb_gadget *gadget) | ||
157 | { | ||
158 | otg->gadget = gadget; | ||
159 | |||
160 | return 0; | ||
161 | } | ||
162 | |||
163 | static int langwell_otg_set_power(struct otg_transceiver *otg, | ||
164 | unsigned mA) | ||
165 | { | ||
166 | return 0; | ||
167 | } | ||
168 | |||
169 | /* A-device drives vbus, controlled through PMIC CHRGCNTL register*/ | ||
170 | static void langwell_otg_drv_vbus(int on) | ||
171 | { | ||
172 | struct ipc_pmic_reg_data pmic_data = {0}; | ||
173 | struct ipc_pmic_reg_data battery_data; | ||
174 | |||
175 | /* Check if battery is attached or not */ | ||
176 | battery_data.pmic_reg_data[0].register_address = 0xd2; | ||
177 | battery_data.ioc = 0; | ||
178 | battery_data.num_entries = 1; | ||
179 | if (ipc_pmic_register_read(&battery_data)) { | ||
180 | otg_dbg("Failed to read PMIC register 0xd2.\n"); | ||
181 | return; | ||
182 | } | ||
183 | |||
184 | if ((battery_data.pmic_reg_data[0].value & 0x20) == 0) { | ||
185 | otg_dbg("no battery attached\n"); | ||
186 | return; | ||
187 | } | ||
188 | |||
189 | /* Workaround for battery attachment issue */ | ||
190 | if (battery_data.pmic_reg_data[0].value == 0x34) { | ||
191 | otg_dbg("battery \n"); | ||
192 | return; | ||
193 | } | ||
194 | |||
195 | otg_dbg("battery attached\n"); | ||
196 | |||
197 | pmic_data.ioc = 0; | ||
198 | pmic_data.pmic_reg_data[0].register_address = 0xD4; | ||
199 | pmic_data.num_entries = 1; | ||
200 | if (on) | ||
201 | pmic_data.pmic_reg_data[0].value = 0x20; | ||
202 | else | ||
203 | pmic_data.pmic_reg_data[0].value = 0xc0; | ||
204 | |||
205 | if (ipc_pmic_register_write(&pmic_data, TRUE)) | ||
206 | otg_dbg("Failed to write PMIC.\n"); | ||
207 | |||
208 | } | ||
209 | |||
210 | /* charge vbus or discharge vbus through a resistor to ground */ | ||
211 | static void langwell_otg_chrg_vbus(int on) | ||
212 | { | ||
213 | |||
214 | u32 val; | ||
215 | |||
216 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
217 | |||
218 | if (on) | ||
219 | writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VC, | ||
220 | the_transceiver->regs + CI_OTGSC); | ||
221 | else | ||
222 | writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VD, | ||
223 | the_transceiver->regs + CI_OTGSC); | ||
224 | |||
225 | } | ||
226 | |||
227 | /* Start SRP */ | ||
228 | static int langwell_otg_start_srp(struct otg_transceiver *otg) | ||
229 | { | ||
230 | u32 val; | ||
231 | |||
232 | otg_dbg("Start SRP ->\n"); | ||
233 | |||
234 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
235 | |||
236 | writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HADP, | ||
237 | the_transceiver->regs + CI_OTGSC); | ||
238 | |||
239 | /* Check if the data plus is finished or not */ | ||
240 | msleep(8); | ||
241 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
242 | if (val & (OTGSC_HADP | OTGSC_DP)) | ||
243 | otg_dbg("DataLine SRP Error\n"); | ||
244 | |||
245 | /* FIXME: VBus SRP */ | ||
246 | |||
247 | return 0; | ||
248 | } | ||
249 | |||
250 | |||
251 | /* stop SOF via bus_suspend */ | ||
252 | static void langwell_otg_loc_sof(int on) | ||
253 | { | ||
254 | struct usb_hcd *hcd; | ||
255 | int err; | ||
256 | |||
257 | otg_dbg("loc_sof -> %d\n", on); | ||
258 | |||
259 | hcd = bus_to_hcd(the_transceiver->otg.host); | ||
260 | if (on) | ||
261 | err = hcd->driver->bus_resume(hcd); | ||
262 | else | ||
263 | err = hcd->driver->bus_suspend(hcd); | ||
264 | |||
265 | if (err) | ||
266 | otg_dbg("Failed to resume/suspend bus - %d\n", err); | ||
267 | } | ||
268 | |||
269 | static void langwell_otg_phy_low_power(int on) | ||
270 | { | ||
271 | u32 val; | ||
272 | |||
273 | otg_dbg("phy low power mode-> %d\n", on); | ||
274 | |||
275 | val = readl(the_transceiver->regs + CI_HOSTPC1); | ||
276 | if (on) | ||
277 | writel(val | HOSTPC1_PHCD, the_transceiver->regs + CI_HOSTPC1); | ||
278 | else | ||
279 | writel(val & ~HOSTPC1_PHCD, the_transceiver->regs + CI_HOSTPC1); | ||
280 | } | ||
281 | |||
282 | /* Enable/Disable OTG interrupt */ | ||
283 | static void langwell_otg_intr(int on) | ||
284 | { | ||
285 | u32 val; | ||
286 | |||
287 | otg_dbg("interrupt -> %d\n", on); | ||
288 | |||
289 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
290 | if (on) { | ||
291 | val = val | (OTGSC_INTEN_MASK | OTGSC_IDPU); | ||
292 | writel(val, the_transceiver->regs + CI_OTGSC); | ||
293 | } else { | ||
294 | val = val & ~(OTGSC_INTEN_MASK | OTGSC_IDPU); | ||
295 | writel(val, the_transceiver->regs + CI_OTGSC); | ||
296 | } | ||
297 | } | ||
298 | |||
299 | /* set HAAR: Hardware Assist Auto-Reset */ | ||
300 | static void langwell_otg_HAAR(int on) | ||
301 | { | ||
302 | u32 val; | ||
303 | |||
304 | otg_dbg("HAAR -> %d\n", on); | ||
305 | |||
306 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
307 | if (on) | ||
308 | writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HAAR, | ||
309 | the_transceiver->regs + CI_OTGSC); | ||
310 | else | ||
311 | writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HAAR, | ||
312 | the_transceiver->regs + CI_OTGSC); | ||
313 | } | ||
314 | |||
315 | /* set HABA: Hardware Assist B-Disconnect to A-Connect */ | ||
316 | static void langwell_otg_HABA(int on) | ||
317 | { | ||
318 | u32 val; | ||
319 | |||
320 | otg_dbg("HABA -> %d\n", on); | ||
321 | |||
322 | val = readl(the_transceiver->regs + CI_OTGSC); | ||
323 | if (on) | ||
324 | writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HABA, | ||
325 | the_transceiver->regs + CI_OTGSC); | ||
326 | else | ||
327 | writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HABA, | ||
328 | the_transceiver->regs + CI_OTGSC); | ||
329 | } | ||
330 | |||
331 | static int langwell_otg_check_se0_srp(int on) | ||
332 | { | ||
333 | u32 val; | ||
334 | |||
335 | int delay_time = TB_SE0_SRP * 10; /* step is 100us */ | ||
336 | |||
337 | otg_dbg("check_se0_srp -> \n"); | ||
338 | |||
339 | do { | ||
340 | udelay(100); | ||
341 | if (!delay_time--) | ||
342 | break; | ||
343 | val = readl(the_transceiver->regs + CI_PORTSC1); | ||
344 | val &= PORTSC_LS; | ||
345 | } while (!val); | ||
346 | |||
347 | otg_dbg("check_se0_srp <- \n"); | ||
348 | return val; | ||
349 | } | ||
350 | |||
351 | /* The timeout callback function to set time out bit */ | ||
352 | static void set_tmout(unsigned long indicator) | ||
353 | { | ||
354 | *(int *)indicator = 1; | ||
355 | } | ||
356 | |||
357 | void langwell_otg_nsf_msg(unsigned long indicator) | ||
358 | { | ||
359 | switch (indicator) { | ||
360 | case 2: | ||
361 | case 4: | ||
362 | case 6: | ||
363 | case 7: | ||
364 | printk(KERN_ERR "OTG:NSF-%lu - deivce not responding\n", | ||
365 | indicator); | ||
366 | break; | ||
367 | case 3: | ||
368 | printk(KERN_ERR "OTG:NSF-%lu - deivce not supported\n", | ||
369 | indicator); | ||
370 | break; | ||
371 | default: | ||
372 | printk(KERN_ERR "Do not have this kind of NSF\n"); | ||
373 | break; | ||
374 | } | ||
375 | } | ||
376 | |||
377 | /* Initialize timers */ | ||
378 | static void langwell_otg_init_timers(struct otg_hsm *hsm) | ||
379 | { | ||
380 | /* HSM used timers */ | ||
381 | a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE, | ||
382 | (unsigned long)&hsm->a_wait_vrise_tmout); | ||
383 | a_wait_bcon_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_BCON, | ||
384 | (unsigned long)&hsm->a_wait_bcon_tmout); | ||
385 | a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS, | ||
386 | (unsigned long)&hsm->a_aidl_bdis_tmout); | ||
387 | b_ase0_brst_tmr = otg_timer_initializer(&set_tmout, TB_ASE0_BRST, | ||
388 | (unsigned long)&hsm->b_ase0_brst_tmout); | ||
389 | b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP, | ||
390 | (unsigned long)&hsm->b_se0_srp); | ||
391 | b_srp_res_tmr = otg_timer_initializer(&set_tmout, TB_SRP_RES, | ||
392 | (unsigned long)&hsm->b_srp_res_tmout); | ||
393 | b_bus_suspend_tmr = otg_timer_initializer(&set_tmout, TB_BUS_SUSPEND, | ||
394 | (unsigned long)&hsm->b_bus_suspend_tmout); | ||
395 | } | ||
396 | |||
397 | /* Free timers */ | ||
398 | static void langwell_otg_free_timers(void) | ||
399 | { | ||
400 | kfree(a_wait_vrise_tmr); | ||
401 | kfree(a_wait_bcon_tmr); | ||
402 | kfree(a_aidl_bdis_tmr); | ||
403 | kfree(b_ase0_brst_tmr); | ||
404 | kfree(b_se0_srp_tmr); | ||
405 | kfree(b_srp_res_tmr); | ||
406 | kfree(b_bus_suspend_tmr); | ||
407 | } | ||
408 | |||
409 | /* Add timer to timer list */ | ||
410 | static void langwell_otg_add_timer(void *gtimer) | ||
411 | { | ||
412 | struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer; | ||
413 | struct langwell_otg_timer *tmp_timer; | ||
414 | u32 val32; | ||
415 | |||
416 | /* Check if the timer is already in the active list, | ||
417 | * if so update timer count | ||
418 | */ | ||
419 | list_for_each_entry(tmp_timer, &active_timers, list) | ||
420 | if (tmp_timer == timer) { | ||
421 | timer->count = timer->expires; | ||
422 | return; | ||
423 | } | ||
424 | timer->count = timer->expires; | ||
425 | |||
426 | if (list_empty(&active_timers)) { | ||
427 | val32 = readl(the_transceiver->regs + CI_OTGSC); | ||
428 | writel(val32 | OTGSC_1MSE, the_transceiver->regs + CI_OTGSC); | ||
429 | } | ||
430 | |||
431 | list_add_tail(&timer->list, &active_timers); | ||
432 | } | ||
433 | |||
434 | /* Remove timer from the timer list; clear timeout status */ | ||
435 | static void langwell_otg_del_timer(void *gtimer) | ||
436 | { | ||
437 | struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer; | ||
438 | struct langwell_otg_timer *tmp_timer, *del_tmp; | ||
439 | u32 val32; | ||
440 | |||
441 | list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) | ||
442 | if (tmp_timer == timer) | ||
443 | list_del(&timer->list); | ||
444 | |||
445 | if (list_empty(&active_timers)) { | ||
446 | val32 = readl(the_transceiver->regs + CI_OTGSC); | ||
447 | writel(val32 & ~OTGSC_1MSE, the_transceiver->regs + CI_OTGSC); | ||
448 | } | ||
449 | } | ||
450 | |||
451 | /* Reduce timer count by 1, and find timeout conditions.*/ | ||
452 | static int langwell_otg_tick_timer(u32 *int_sts) | ||
453 | { | ||
454 | struct langwell_otg_timer *tmp_timer, *del_tmp; | ||
455 | int expired = 0; | ||
456 | |||
457 | list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) { | ||
458 | tmp_timer->count--; | ||
459 | /* check if timer expires */ | ||
460 | if (!tmp_timer->count) { | ||
461 | list_del(&tmp_timer->list); | ||
462 | tmp_timer->function(tmp_timer->data); | ||
463 | expired = 1; | ||
464 | } | ||
465 | } | ||
466 | |||
467 | if (list_empty(&active_timers)) { | ||
468 | otg_dbg("tick timer: disable 1ms int\n"); | ||
469 | *int_sts = *int_sts & ~OTGSC_1MSE; | ||
470 | } | ||
471 | return expired; | ||
472 | } | ||
473 | |||
474 | static void reset_otg(void) | ||
475 | { | ||
476 | u32 val; | ||
477 | int delay_time = 1000; | ||
478 | |||
479 | otg_dbg("reseting OTG controller ...\n"); | ||
480 | val = readl(the_transceiver->regs + CI_USBCMD); | ||
481 | writel(val | USBCMD_RST, the_transceiver->regs + CI_USBCMD); | ||
482 | do { | ||
483 | udelay(100); | ||
484 | if (!delay_time--) | ||
485 | otg_dbg("reset timeout\n"); | ||
486 | val = readl(the_transceiver->regs + CI_USBCMD); | ||
487 | val &= USBCMD_RST; | ||
488 | } while (val != 0); | ||
489 | otg_dbg("reset done.\n"); | ||
490 | } | ||
491 | |||
492 | static void set_host_mode(void) | ||
493 | { | ||
494 | u32 val; | ||
495 | |||
496 | reset_otg(); | ||
497 | val = readl(the_transceiver->regs + CI_USBMODE); | ||
498 | val = (val & (~USBMODE_CM)) | USBMODE_HOST; | ||
499 | writel(val, the_transceiver->regs + CI_USBMODE); | ||
500 | } | ||
501 | |||
502 | static void set_client_mode(void) | ||
503 | { | ||
504 | u32 val; | ||
505 | |||
506 | reset_otg(); | ||
507 | val = readl(the_transceiver->regs + CI_USBMODE); | ||
508 | val = (val & (~USBMODE_CM)) | USBMODE_DEVICE; | ||
509 | writel(val, the_transceiver->regs + CI_USBMODE); | ||
510 | } | ||
511 | |||
512 | static void init_hsm(void) | ||
513 | { | ||
514 | struct langwell_otg *langwell = the_transceiver; | ||
515 | u32 val32; | ||
516 | |||
517 | /* read OTGSC after reset */ | ||
518 | val32 = readl(langwell->regs + CI_OTGSC); | ||
519 | otg_dbg("%s: OTGSC init value = 0x%x\n", __func__, val32); | ||
520 | |||
521 | /* set init state */ | ||
522 | if (val32 & OTGSC_ID) { | ||
523 | langwell->hsm.id = 1; | ||
524 | langwell->otg.default_a = 0; | ||
525 | set_client_mode(); | ||
526 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
527 | langwell_otg_drv_vbus(0); | ||
528 | } else { | ||
529 | langwell->hsm.id = 0; | ||
530 | langwell->otg.default_a = 1; | ||
531 | set_host_mode(); | ||
532 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
533 | } | ||
534 | |||
535 | /* set session indicator */ | ||
536 | if (val32 & OTGSC_BSE) | ||
537 | langwell->hsm.b_sess_end = 1; | ||
538 | if (val32 & OTGSC_BSV) | ||
539 | langwell->hsm.b_sess_vld = 1; | ||
540 | if (val32 & OTGSC_ASV) | ||
541 | langwell->hsm.a_sess_vld = 1; | ||
542 | if (val32 & OTGSC_AVV) | ||
543 | langwell->hsm.a_vbus_vld = 1; | ||
544 | |||
545 | /* defautly power the bus */ | ||
546 | langwell->hsm.a_bus_req = 1; | ||
547 | langwell->hsm.a_bus_drop = 0; | ||
548 | /* defautly don't request bus as B device */ | ||
549 | langwell->hsm.b_bus_req = 0; | ||
550 | /* no system error */ | ||
551 | langwell->hsm.a_clr_err = 0; | ||
552 | } | ||
553 | |||
554 | static irqreturn_t otg_dummy_irq(int irq, void *_dev) | ||
555 | { | ||
556 | void __iomem *reg_base = _dev; | ||
557 | u32 val; | ||
558 | u32 int_mask = 0; | ||
559 | |||
560 | val = readl(reg_base + CI_USBMODE); | ||
561 | if ((val & USBMODE_CM) != USBMODE_DEVICE) | ||
562 | return IRQ_NONE; | ||
563 | |||
564 | val = readl(reg_base + CI_USBSTS); | ||
565 | int_mask = val & INTR_DUMMY_MASK; | ||
566 | |||
567 | if (int_mask == 0) | ||
568 | return IRQ_NONE; | ||
569 | |||
570 | /* clear hsm.b_conn here since host driver can't detect it | ||
571 | * otg_dummy_irq called means B-disconnect happened. | ||
572 | */ | ||
573 | if (the_transceiver->hsm.b_conn) { | ||
574 | the_transceiver->hsm.b_conn = 0; | ||
575 | if (spin_trylock(&the_transceiver->wq_lock)) { | ||
576 | queue_work(the_transceiver->qwork, | ||
577 | &the_transceiver->work); | ||
578 | spin_unlock(&the_transceiver->wq_lock); | ||
579 | } | ||
580 | } | ||
581 | /* Clear interrupts */ | ||
582 | writel(int_mask, reg_base + CI_USBSTS); | ||
583 | return IRQ_HANDLED; | ||
584 | } | ||
585 | |||
586 | static irqreturn_t otg_irq(int irq, void *_dev) | ||
587 | { | ||
588 | struct langwell_otg *langwell = _dev; | ||
589 | u32 int_sts, int_en; | ||
590 | u32 int_mask = 0; | ||
591 | int flag = 0; | ||
592 | |||
593 | int_sts = readl(langwell->regs + CI_OTGSC); | ||
594 | int_en = (int_sts & OTGSC_INTEN_MASK) >> 8; | ||
595 | int_mask = int_sts & int_en; | ||
596 | if (int_mask == 0) | ||
597 | return IRQ_NONE; | ||
598 | |||
599 | if (int_mask & OTGSC_IDIS) { | ||
600 | otg_dbg("%s: id change int\n", __func__); | ||
601 | langwell->hsm.id = (int_sts & OTGSC_ID) ? 1 : 0; | ||
602 | flag = 1; | ||
603 | } | ||
604 | if (int_mask & OTGSC_DPIS) { | ||
605 | otg_dbg("%s: data pulse int\n", __func__); | ||
606 | langwell->hsm.a_srp_det = (int_sts & OTGSC_DPS) ? 1 : 0; | ||
607 | flag = 1; | ||
608 | } | ||
609 | if (int_mask & OTGSC_BSEIS) { | ||
610 | otg_dbg("%s: b session end int\n", __func__); | ||
611 | langwell->hsm.b_sess_end = (int_sts & OTGSC_BSE) ? 1 : 0; | ||
612 | flag = 1; | ||
613 | } | ||
614 | if (int_mask & OTGSC_BSVIS) { | ||
615 | otg_dbg("%s: b session valid int\n", __func__); | ||
616 | langwell->hsm.b_sess_vld = (int_sts & OTGSC_BSV) ? 1 : 0; | ||
617 | flag = 1; | ||
618 | } | ||
619 | if (int_mask & OTGSC_ASVIS) { | ||
620 | otg_dbg("%s: a session valid int\n", __func__); | ||
621 | langwell->hsm.a_sess_vld = (int_sts & OTGSC_ASV) ? 1 : 0; | ||
622 | flag = 1; | ||
623 | } | ||
624 | if (int_mask & OTGSC_AVVIS) { | ||
625 | otg_dbg("%s: a vbus valid int\n", __func__); | ||
626 | langwell->hsm.a_vbus_vld = (int_sts & OTGSC_AVV) ? 1 : 0; | ||
627 | flag = 1; | ||
628 | } | ||
629 | |||
630 | if (int_mask & OTGSC_1MSS) { | ||
631 | /* need to schedule otg_work if any timer is expired */ | ||
632 | if (langwell_otg_tick_timer(&int_sts)) | ||
633 | flag = 1; | ||
634 | } | ||
635 | |||
636 | writel((int_sts & ~OTGSC_INTSTS_MASK) | int_mask, | ||
637 | langwell->regs + CI_OTGSC); | ||
638 | if (flag) | ||
639 | queue_work(langwell->qwork, &langwell->work); | ||
640 | |||
641 | return IRQ_HANDLED; | ||
642 | } | ||
643 | |||
644 | static void langwell_otg_work(struct work_struct *work) | ||
645 | { | ||
646 | struct langwell_otg *langwell = container_of(work, | ||
647 | struct langwell_otg, work); | ||
648 | int retval; | ||
649 | |||
650 | otg_dbg("%s: old state = %s\n", __func__, | ||
651 | state_string(langwell->otg.state)); | ||
652 | |||
653 | switch (langwell->otg.state) { | ||
654 | case OTG_STATE_UNDEFINED: | ||
655 | case OTG_STATE_B_IDLE: | ||
656 | if (!langwell->hsm.id) { | ||
657 | langwell_otg_del_timer(b_srp_res_tmr); | ||
658 | langwell->otg.default_a = 1; | ||
659 | langwell->hsm.a_srp_det = 0; | ||
660 | |||
661 | langwell_otg_chrg_vbus(0); | ||
662 | langwell_otg_drv_vbus(0); | ||
663 | |||
664 | set_host_mode(); | ||
665 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
666 | queue_work(langwell->qwork, &langwell->work); | ||
667 | } else if (langwell->hsm.b_srp_res_tmout) { | ||
668 | langwell->hsm.b_srp_res_tmout = 0; | ||
669 | langwell->hsm.b_bus_req = 0; | ||
670 | langwell_otg_nsf_msg(6); | ||
671 | } else if (langwell->hsm.b_sess_vld) { | ||
672 | langwell_otg_del_timer(b_srp_res_tmr); | ||
673 | langwell->hsm.b_sess_end = 0; | ||
674 | langwell->hsm.a_bus_suspend = 0; | ||
675 | |||
676 | langwell_otg_chrg_vbus(0); | ||
677 | if (langwell->client_ops) { | ||
678 | langwell->client_ops->resume(langwell->pdev); | ||
679 | langwell->otg.state = OTG_STATE_B_PERIPHERAL; | ||
680 | } else | ||
681 | otg_dbg("client driver not loaded.\n"); | ||
682 | |||
683 | } else if (langwell->hsm.b_bus_req && | ||
684 | (langwell->hsm.b_sess_end)) { | ||
685 | /* workaround for b_se0_srp detection */ | ||
686 | retval = langwell_otg_check_se0_srp(0); | ||
687 | if (retval) { | ||
688 | langwell->hsm.b_bus_req = 0; | ||
689 | otg_dbg("LS is not SE0, try again later\n"); | ||
690 | } else { | ||
691 | /* Start SRP */ | ||
692 | langwell_otg_start_srp(&langwell->otg); | ||
693 | langwell_otg_add_timer(b_srp_res_tmr); | ||
694 | } | ||
695 | } | ||
696 | break; | ||
697 | case OTG_STATE_B_SRP_INIT: | ||
698 | if (!langwell->hsm.id) { | ||
699 | langwell->otg.default_a = 1; | ||
700 | langwell->hsm.a_srp_det = 0; | ||
701 | |||
702 | langwell_otg_drv_vbus(0); | ||
703 | langwell_otg_chrg_vbus(0); | ||
704 | |||
705 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
706 | queue_work(langwell->qwork, &langwell->work); | ||
707 | } else if (langwell->hsm.b_sess_vld) { | ||
708 | langwell_otg_chrg_vbus(0); | ||
709 | if (langwell->client_ops) { | ||
710 | langwell->client_ops->resume(langwell->pdev); | ||
711 | langwell->otg.state = OTG_STATE_B_PERIPHERAL; | ||
712 | } else | ||
713 | otg_dbg("client driver not loaded.\n"); | ||
714 | } | ||
715 | break; | ||
716 | case OTG_STATE_B_PERIPHERAL: | ||
717 | if (!langwell->hsm.id) { | ||
718 | langwell->otg.default_a = 1; | ||
719 | langwell->hsm.a_srp_det = 0; | ||
720 | |||
721 | langwell_otg_drv_vbus(0); | ||
722 | langwell_otg_chrg_vbus(0); | ||
723 | set_host_mode(); | ||
724 | |||
725 | if (langwell->client_ops) { | ||
726 | langwell->client_ops->suspend(langwell->pdev, | ||
727 | PMSG_FREEZE); | ||
728 | } else | ||
729 | otg_dbg("client driver has been removed.\n"); | ||
730 | |||
731 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
732 | queue_work(langwell->qwork, &langwell->work); | ||
733 | } else if (!langwell->hsm.b_sess_vld) { | ||
734 | langwell->hsm.b_hnp_enable = 0; | ||
735 | |||
736 | if (langwell->client_ops) { | ||
737 | langwell->client_ops->suspend(langwell->pdev, | ||
738 | PMSG_FREEZE); | ||
739 | } else | ||
740 | otg_dbg("client driver has been removed.\n"); | ||
741 | |||
742 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
743 | } else if (langwell->hsm.b_bus_req && langwell->hsm.b_hnp_enable | ||
744 | && langwell->hsm.a_bus_suspend) { | ||
745 | |||
746 | if (langwell->client_ops) { | ||
747 | langwell->client_ops->suspend(langwell->pdev, | ||
748 | PMSG_FREEZE); | ||
749 | } else | ||
750 | otg_dbg("client driver has been removed.\n"); | ||
751 | |||
752 | langwell_otg_HAAR(1); | ||
753 | langwell->hsm.a_conn = 0; | ||
754 | |||
755 | if (langwell->host_ops) { | ||
756 | langwell->host_ops->probe(langwell->pdev, | ||
757 | langwell->host_ops->id_table); | ||
758 | langwell->otg.state = OTG_STATE_B_WAIT_ACON; | ||
759 | } else | ||
760 | otg_dbg("host driver not loaded.\n"); | ||
761 | |||
762 | langwell->hsm.a_bus_resume = 0; | ||
763 | langwell->hsm.b_ase0_brst_tmout = 0; | ||
764 | langwell_otg_add_timer(b_ase0_brst_tmr); | ||
765 | } | ||
766 | break; | ||
767 | |||
768 | case OTG_STATE_B_WAIT_ACON: | ||
769 | if (!langwell->hsm.id) { | ||
770 | langwell_otg_del_timer(b_ase0_brst_tmr); | ||
771 | langwell->otg.default_a = 1; | ||
772 | langwell->hsm.a_srp_det = 0; | ||
773 | |||
774 | langwell_otg_drv_vbus(0); | ||
775 | langwell_otg_chrg_vbus(0); | ||
776 | set_host_mode(); | ||
777 | |||
778 | langwell_otg_HAAR(0); | ||
779 | if (langwell->host_ops) | ||
780 | langwell->host_ops->remove(langwell->pdev); | ||
781 | else | ||
782 | otg_dbg("host driver has been removed.\n"); | ||
783 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
784 | queue_work(langwell->qwork, &langwell->work); | ||
785 | } else if (!langwell->hsm.b_sess_vld) { | ||
786 | langwell_otg_del_timer(b_ase0_brst_tmr); | ||
787 | langwell->hsm.b_hnp_enable = 0; | ||
788 | langwell->hsm.b_bus_req = 0; | ||
789 | langwell_otg_chrg_vbus(0); | ||
790 | langwell_otg_HAAR(0); | ||
791 | |||
792 | if (langwell->host_ops) | ||
793 | langwell->host_ops->remove(langwell->pdev); | ||
794 | else | ||
795 | otg_dbg("host driver has been removed.\n"); | ||
796 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
797 | } else if (langwell->hsm.a_conn) { | ||
798 | langwell_otg_del_timer(b_ase0_brst_tmr); | ||
799 | langwell_otg_HAAR(0); | ||
800 | langwell->otg.state = OTG_STATE_B_HOST; | ||
801 | queue_work(langwell->qwork, &langwell->work); | ||
802 | } else if (langwell->hsm.a_bus_resume || | ||
803 | langwell->hsm.b_ase0_brst_tmout) { | ||
804 | langwell_otg_del_timer(b_ase0_brst_tmr); | ||
805 | langwell_otg_HAAR(0); | ||
806 | langwell_otg_nsf_msg(7); | ||
807 | |||
808 | if (langwell->host_ops) | ||
809 | langwell->host_ops->remove(langwell->pdev); | ||
810 | else | ||
811 | otg_dbg("host driver has been removed.\n"); | ||
812 | |||
813 | langwell->hsm.a_bus_suspend = 0; | ||
814 | langwell->hsm.b_bus_req = 0; | ||
815 | |||
816 | if (langwell->client_ops) | ||
817 | langwell->client_ops->resume(langwell->pdev); | ||
818 | else | ||
819 | otg_dbg("client driver not loaded.\n"); | ||
820 | |||
821 | langwell->otg.state = OTG_STATE_B_PERIPHERAL; | ||
822 | } | ||
823 | break; | ||
824 | |||
825 | case OTG_STATE_B_HOST: | ||
826 | if (!langwell->hsm.id) { | ||
827 | langwell->otg.default_a = 1; | ||
828 | langwell->hsm.a_srp_det = 0; | ||
829 | |||
830 | langwell_otg_drv_vbus(0); | ||
831 | langwell_otg_chrg_vbus(0); | ||
832 | set_host_mode(); | ||
833 | if (langwell->host_ops) | ||
834 | langwell->host_ops->remove(langwell->pdev); | ||
835 | else | ||
836 | otg_dbg("host driver has been removed.\n"); | ||
837 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
838 | queue_work(langwell->qwork, &langwell->work); | ||
839 | } else if (!langwell->hsm.b_sess_vld) { | ||
840 | langwell->hsm.b_hnp_enable = 0; | ||
841 | langwell->hsm.b_bus_req = 0; | ||
842 | langwell_otg_chrg_vbus(0); | ||
843 | if (langwell->host_ops) | ||
844 | langwell->host_ops->remove(langwell->pdev); | ||
845 | else | ||
846 | otg_dbg("host driver has been removed.\n"); | ||
847 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
848 | } else if ((!langwell->hsm.b_bus_req) || | ||
849 | (!langwell->hsm.a_conn)) { | ||
850 | langwell->hsm.b_bus_req = 0; | ||
851 | langwell_otg_loc_sof(0); | ||
852 | if (langwell->host_ops) | ||
853 | langwell->host_ops->remove(langwell->pdev); | ||
854 | else | ||
855 | otg_dbg("host driver has been removed.\n"); | ||
856 | |||
857 | langwell->hsm.a_bus_suspend = 0; | ||
858 | |||
859 | if (langwell->client_ops) | ||
860 | langwell->client_ops->resume(langwell->pdev); | ||
861 | else | ||
862 | otg_dbg("client driver not loaded.\n"); | ||
863 | |||
864 | langwell->otg.state = OTG_STATE_B_PERIPHERAL; | ||
865 | } | ||
866 | break; | ||
867 | |||
868 | case OTG_STATE_A_IDLE: | ||
869 | langwell->otg.default_a = 1; | ||
870 | if (langwell->hsm.id) { | ||
871 | langwell->otg.default_a = 0; | ||
872 | langwell->hsm.b_bus_req = 0; | ||
873 | langwell_otg_drv_vbus(0); | ||
874 | langwell_otg_chrg_vbus(0); | ||
875 | |||
876 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
877 | queue_work(langwell->qwork, &langwell->work); | ||
878 | } else if (langwell->hsm.a_sess_vld) { | ||
879 | langwell_otg_drv_vbus(1); | ||
880 | langwell->hsm.a_srp_det = 1; | ||
881 | langwell->hsm.a_wait_vrise_tmout = 0; | ||
882 | langwell_otg_add_timer(a_wait_vrise_tmr); | ||
883 | langwell->otg.state = OTG_STATE_A_WAIT_VRISE; | ||
884 | queue_work(langwell->qwork, &langwell->work); | ||
885 | } else if (!langwell->hsm.a_bus_drop && | ||
886 | (langwell->hsm.a_srp_det || langwell->hsm.a_bus_req)) { | ||
887 | langwell_otg_drv_vbus(1); | ||
888 | langwell->hsm.a_wait_vrise_tmout = 0; | ||
889 | langwell_otg_add_timer(a_wait_vrise_tmr); | ||
890 | langwell->otg.state = OTG_STATE_A_WAIT_VRISE; | ||
891 | queue_work(langwell->qwork, &langwell->work); | ||
892 | } | ||
893 | break; | ||
894 | case OTG_STATE_A_WAIT_VRISE: | ||
895 | if (langwell->hsm.id) { | ||
896 | langwell_otg_del_timer(a_wait_vrise_tmr); | ||
897 | langwell->hsm.b_bus_req = 0; | ||
898 | langwell->otg.default_a = 0; | ||
899 | langwell_otg_drv_vbus(0); | ||
900 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
901 | } else if (langwell->hsm.a_vbus_vld) { | ||
902 | langwell_otg_del_timer(a_wait_vrise_tmr); | ||
903 | if (langwell->host_ops) | ||
904 | langwell->host_ops->probe(langwell->pdev, | ||
905 | langwell->host_ops->id_table); | ||
906 | else | ||
907 | otg_dbg("host driver not loaded.\n"); | ||
908 | langwell->hsm.b_conn = 0; | ||
909 | langwell->hsm.a_set_b_hnp_en = 0; | ||
910 | langwell->hsm.a_wait_bcon_tmout = 0; | ||
911 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
912 | langwell->otg.state = OTG_STATE_A_WAIT_BCON; | ||
913 | } else if (langwell->hsm.a_wait_vrise_tmout) { | ||
914 | if (langwell->hsm.a_vbus_vld) { | ||
915 | if (langwell->host_ops) | ||
916 | langwell->host_ops->probe( | ||
917 | langwell->pdev, | ||
918 | langwell->host_ops->id_table); | ||
919 | else | ||
920 | otg_dbg("host driver not loaded.\n"); | ||
921 | langwell->hsm.b_conn = 0; | ||
922 | langwell->hsm.a_set_b_hnp_en = 0; | ||
923 | langwell->hsm.a_wait_bcon_tmout = 0; | ||
924 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
925 | langwell->otg.state = OTG_STATE_A_WAIT_BCON; | ||
926 | } else { | ||
927 | langwell_otg_drv_vbus(0); | ||
928 | langwell->otg.state = OTG_STATE_A_VBUS_ERR; | ||
929 | } | ||
930 | } | ||
931 | break; | ||
932 | case OTG_STATE_A_WAIT_BCON: | ||
933 | if (langwell->hsm.id) { | ||
934 | langwell_otg_del_timer(a_wait_bcon_tmr); | ||
935 | |||
936 | langwell->otg.default_a = 0; | ||
937 | langwell->hsm.b_bus_req = 0; | ||
938 | if (langwell->host_ops) | ||
939 | langwell->host_ops->remove(langwell->pdev); | ||
940 | else | ||
941 | otg_dbg("host driver has been removed.\n"); | ||
942 | langwell_otg_drv_vbus(0); | ||
943 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
944 | queue_work(langwell->qwork, &langwell->work); | ||
945 | } else if (!langwell->hsm.a_vbus_vld) { | ||
946 | langwell_otg_del_timer(a_wait_bcon_tmr); | ||
947 | |||
948 | if (langwell->host_ops) | ||
949 | langwell->host_ops->remove(langwell->pdev); | ||
950 | else | ||
951 | otg_dbg("host driver has been removed.\n"); | ||
952 | langwell_otg_drv_vbus(0); | ||
953 | langwell->otg.state = OTG_STATE_A_VBUS_ERR; | ||
954 | } else if (langwell->hsm.a_bus_drop || | ||
955 | (langwell->hsm.a_wait_bcon_tmout && | ||
956 | !langwell->hsm.a_bus_req)) { | ||
957 | langwell_otg_del_timer(a_wait_bcon_tmr); | ||
958 | |||
959 | if (langwell->host_ops) | ||
960 | langwell->host_ops->remove(langwell->pdev); | ||
961 | else | ||
962 | otg_dbg("host driver has been removed.\n"); | ||
963 | langwell_otg_drv_vbus(0); | ||
964 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
965 | } else if (langwell->hsm.b_conn) { | ||
966 | langwell_otg_del_timer(a_wait_bcon_tmr); | ||
967 | |||
968 | langwell->hsm.a_suspend_req = 0; | ||
969 | langwell->otg.state = OTG_STATE_A_HOST; | ||
970 | if (!langwell->hsm.a_bus_req && | ||
971 | langwell->hsm.a_set_b_hnp_en) { | ||
972 | /* It is not safe enough to do a fast | ||
973 | * transistion from A_WAIT_BCON to | ||
974 | * A_SUSPEND */ | ||
975 | msleep(10000); | ||
976 | if (langwell->hsm.a_bus_req) | ||
977 | break; | ||
978 | |||
979 | if (request_irq(langwell->pdev->irq, | ||
980 | otg_dummy_irq, IRQF_SHARED, | ||
981 | driver_name, langwell->regs) != 0) { | ||
982 | otg_dbg("request interrupt %d fail\n", | ||
983 | langwell->pdev->irq); | ||
984 | } | ||
985 | |||
986 | langwell_otg_HABA(1); | ||
987 | langwell->hsm.b_bus_resume = 0; | ||
988 | langwell->hsm.a_aidl_bdis_tmout = 0; | ||
989 | langwell_otg_add_timer(a_aidl_bdis_tmr); | ||
990 | |||
991 | langwell_otg_loc_sof(0); | ||
992 | langwell->otg.state = OTG_STATE_A_SUSPEND; | ||
993 | } else if (!langwell->hsm.a_bus_req && | ||
994 | !langwell->hsm.a_set_b_hnp_en) { | ||
995 | struct pci_dev *pdev = langwell->pdev; | ||
996 | if (langwell->host_ops) | ||
997 | langwell->host_ops->remove(pdev); | ||
998 | else | ||
999 | otg_dbg("host driver removed.\n"); | ||
1000 | langwell_otg_drv_vbus(0); | ||
1001 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1002 | } | ||
1003 | } | ||
1004 | break; | ||
1005 | case OTG_STATE_A_HOST: | ||
1006 | if (langwell->hsm.id) { | ||
1007 | langwell->otg.default_a = 0; | ||
1008 | langwell->hsm.b_bus_req = 0; | ||
1009 | if (langwell->host_ops) | ||
1010 | langwell->host_ops->remove(langwell->pdev); | ||
1011 | else | ||
1012 | otg_dbg("host driver has been removed.\n"); | ||
1013 | langwell_otg_drv_vbus(0); | ||
1014 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1015 | queue_work(langwell->qwork, &langwell->work); | ||
1016 | } else if (langwell->hsm.a_bus_drop || | ||
1017 | (!langwell->hsm.a_set_b_hnp_en && !langwell->hsm.a_bus_req)) { | ||
1018 | if (langwell->host_ops) | ||
1019 | langwell->host_ops->remove(langwell->pdev); | ||
1020 | else | ||
1021 | otg_dbg("host driver has been removed.\n"); | ||
1022 | langwell_otg_drv_vbus(0); | ||
1023 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1024 | } else if (!langwell->hsm.a_vbus_vld) { | ||
1025 | if (langwell->host_ops) | ||
1026 | langwell->host_ops->remove(langwell->pdev); | ||
1027 | else | ||
1028 | otg_dbg("host driver has been removed.\n"); | ||
1029 | langwell_otg_drv_vbus(0); | ||
1030 | langwell->otg.state = OTG_STATE_A_VBUS_ERR; | ||
1031 | } else if (langwell->hsm.a_set_b_hnp_en | ||
1032 | && !langwell->hsm.a_bus_req) { | ||
1033 | /* Set HABA to enable hardware assistance to signal | ||
1034 | * A-connect after receiver B-disconnect. Hardware | ||
1035 | * will then set client mode and enable URE, SLE and | ||
1036 | * PCE after the assistance. otg_dummy_irq is used to | ||
1037 | * clean these ints when client driver is not resumed. | ||
1038 | */ | ||
1039 | if (request_irq(langwell->pdev->irq, | ||
1040 | otg_dummy_irq, IRQF_SHARED, driver_name, | ||
1041 | langwell->regs) != 0) { | ||
1042 | otg_dbg("request interrupt %d failed\n", | ||
1043 | langwell->pdev->irq); | ||
1044 | } | ||
1045 | |||
1046 | /* set HABA */ | ||
1047 | langwell_otg_HABA(1); | ||
1048 | langwell->hsm.b_bus_resume = 0; | ||
1049 | langwell->hsm.a_aidl_bdis_tmout = 0; | ||
1050 | langwell_otg_add_timer(a_aidl_bdis_tmr); | ||
1051 | langwell_otg_loc_sof(0); | ||
1052 | langwell->otg.state = OTG_STATE_A_SUSPEND; | ||
1053 | } else if (!langwell->hsm.b_conn || !langwell->hsm.a_bus_req) { | ||
1054 | langwell->hsm.a_wait_bcon_tmout = 0; | ||
1055 | langwell->hsm.a_set_b_hnp_en = 0; | ||
1056 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
1057 | langwell->otg.state = OTG_STATE_A_WAIT_BCON; | ||
1058 | } | ||
1059 | break; | ||
1060 | case OTG_STATE_A_SUSPEND: | ||
1061 | if (langwell->hsm.id) { | ||
1062 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1063 | langwell_otg_HABA(0); | ||
1064 | free_irq(langwell->pdev->irq, langwell->regs); | ||
1065 | langwell->otg.default_a = 0; | ||
1066 | langwell->hsm.b_bus_req = 0; | ||
1067 | if (langwell->host_ops) | ||
1068 | langwell->host_ops->remove(langwell->pdev); | ||
1069 | else | ||
1070 | otg_dbg("host driver has been removed.\n"); | ||
1071 | langwell_otg_drv_vbus(0); | ||
1072 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1073 | queue_work(langwell->qwork, &langwell->work); | ||
1074 | } else if (langwell->hsm.a_bus_req || | ||
1075 | langwell->hsm.b_bus_resume) { | ||
1076 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1077 | langwell_otg_HABA(0); | ||
1078 | free_irq(langwell->pdev->irq, langwell->regs); | ||
1079 | langwell->hsm.a_suspend_req = 0; | ||
1080 | langwell_otg_loc_sof(1); | ||
1081 | langwell->otg.state = OTG_STATE_A_HOST; | ||
1082 | } else if (langwell->hsm.a_aidl_bdis_tmout || | ||
1083 | langwell->hsm.a_bus_drop) { | ||
1084 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1085 | langwell_otg_HABA(0); | ||
1086 | free_irq(langwell->pdev->irq, langwell->regs); | ||
1087 | if (langwell->host_ops) | ||
1088 | langwell->host_ops->remove(langwell->pdev); | ||
1089 | else | ||
1090 | otg_dbg("host driver has been removed.\n"); | ||
1091 | langwell_otg_drv_vbus(0); | ||
1092 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1093 | } else if (!langwell->hsm.b_conn && | ||
1094 | langwell->hsm.a_set_b_hnp_en) { | ||
1095 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1096 | langwell_otg_HABA(0); | ||
1097 | free_irq(langwell->pdev->irq, langwell->regs); | ||
1098 | |||
1099 | if (langwell->host_ops) | ||
1100 | langwell->host_ops->remove(langwell->pdev); | ||
1101 | else | ||
1102 | otg_dbg("host driver has been removed.\n"); | ||
1103 | |||
1104 | langwell->hsm.b_bus_suspend = 0; | ||
1105 | langwell->hsm.b_bus_suspend_vld = 0; | ||
1106 | langwell->hsm.b_bus_suspend_tmout = 0; | ||
1107 | |||
1108 | /* msleep(200); */ | ||
1109 | if (langwell->client_ops) | ||
1110 | langwell->client_ops->resume(langwell->pdev); | ||
1111 | else | ||
1112 | otg_dbg("client driver not loaded.\n"); | ||
1113 | |||
1114 | langwell_otg_add_timer(b_bus_suspend_tmr); | ||
1115 | langwell->otg.state = OTG_STATE_A_PERIPHERAL; | ||
1116 | break; | ||
1117 | } else if (!langwell->hsm.a_vbus_vld) { | ||
1118 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1119 | langwell_otg_HABA(0); | ||
1120 | free_irq(langwell->pdev->irq, langwell->regs); | ||
1121 | if (langwell->host_ops) | ||
1122 | langwell->host_ops->remove(langwell->pdev); | ||
1123 | else | ||
1124 | otg_dbg("host driver has been removed.\n"); | ||
1125 | langwell_otg_drv_vbus(0); | ||
1126 | langwell->otg.state = OTG_STATE_A_VBUS_ERR; | ||
1127 | } | ||
1128 | break; | ||
1129 | case OTG_STATE_A_PERIPHERAL: | ||
1130 | if (langwell->hsm.id) { | ||
1131 | langwell_otg_del_timer(b_bus_suspend_tmr); | ||
1132 | langwell->otg.default_a = 0; | ||
1133 | langwell->hsm.b_bus_req = 0; | ||
1134 | if (langwell->client_ops) | ||
1135 | langwell->client_ops->suspend(langwell->pdev, | ||
1136 | PMSG_FREEZE); | ||
1137 | else | ||
1138 | otg_dbg("client driver has been removed.\n"); | ||
1139 | langwell_otg_drv_vbus(0); | ||
1140 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1141 | queue_work(langwell->qwork, &langwell->work); | ||
1142 | } else if (!langwell->hsm.a_vbus_vld) { | ||
1143 | langwell_otg_del_timer(b_bus_suspend_tmr); | ||
1144 | if (langwell->client_ops) | ||
1145 | langwell->client_ops->suspend(langwell->pdev, | ||
1146 | PMSG_FREEZE); | ||
1147 | else | ||
1148 | otg_dbg("client driver has been removed.\n"); | ||
1149 | langwell_otg_drv_vbus(0); | ||
1150 | langwell->otg.state = OTG_STATE_A_VBUS_ERR; | ||
1151 | } else if (langwell->hsm.a_bus_drop) { | ||
1152 | langwell_otg_del_timer(b_bus_suspend_tmr); | ||
1153 | if (langwell->client_ops) | ||
1154 | langwell->client_ops->suspend(langwell->pdev, | ||
1155 | PMSG_FREEZE); | ||
1156 | else | ||
1157 | otg_dbg("client driver has been removed.\n"); | ||
1158 | langwell_otg_drv_vbus(0); | ||
1159 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1160 | } else if (langwell->hsm.b_bus_suspend) { | ||
1161 | langwell_otg_del_timer(b_bus_suspend_tmr); | ||
1162 | if (langwell->client_ops) | ||
1163 | langwell->client_ops->suspend(langwell->pdev, | ||
1164 | PMSG_FREEZE); | ||
1165 | else | ||
1166 | otg_dbg("client driver has been removed.\n"); | ||
1167 | |||
1168 | if (langwell->host_ops) | ||
1169 | langwell->host_ops->probe(langwell->pdev, | ||
1170 | langwell->host_ops->id_table); | ||
1171 | else | ||
1172 | otg_dbg("host driver not loaded.\n"); | ||
1173 | langwell->hsm.a_set_b_hnp_en = 0; | ||
1174 | langwell->hsm.a_wait_bcon_tmout = 0; | ||
1175 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
1176 | langwell->otg.state = OTG_STATE_A_WAIT_BCON; | ||
1177 | } else if (langwell->hsm.b_bus_suspend_tmout) { | ||
1178 | u32 val; | ||
1179 | val = readl(langwell->regs + CI_PORTSC1); | ||
1180 | if (!(val & PORTSC_SUSP)) | ||
1181 | break; | ||
1182 | if (langwell->client_ops) | ||
1183 | langwell->client_ops->suspend(langwell->pdev, | ||
1184 | PMSG_FREEZE); | ||
1185 | else | ||
1186 | otg_dbg("client driver has been removed.\n"); | ||
1187 | if (langwell->host_ops) | ||
1188 | langwell->host_ops->probe(langwell->pdev, | ||
1189 | langwell->host_ops->id_table); | ||
1190 | else | ||
1191 | otg_dbg("host driver not loaded.\n"); | ||
1192 | langwell->hsm.a_set_b_hnp_en = 0; | ||
1193 | langwell->hsm.a_wait_bcon_tmout = 0; | ||
1194 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
1195 | langwell->otg.state = OTG_STATE_A_WAIT_BCON; | ||
1196 | } | ||
1197 | break; | ||
1198 | case OTG_STATE_A_VBUS_ERR: | ||
1199 | if (langwell->hsm.id) { | ||
1200 | langwell->otg.default_a = 0; | ||
1201 | langwell->hsm.a_clr_err = 0; | ||
1202 | langwell->hsm.a_srp_det = 0; | ||
1203 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1204 | queue_work(langwell->qwork, &langwell->work); | ||
1205 | } else if (langwell->hsm.a_clr_err) { | ||
1206 | langwell->hsm.a_clr_err = 0; | ||
1207 | langwell->hsm.a_srp_det = 0; | ||
1208 | reset_otg(); | ||
1209 | init_hsm(); | ||
1210 | if (langwell->otg.state == OTG_STATE_A_IDLE) | ||
1211 | queue_work(langwell->qwork, &langwell->work); | ||
1212 | } | ||
1213 | break; | ||
1214 | case OTG_STATE_A_WAIT_VFALL: | ||
1215 | if (langwell->hsm.id) { | ||
1216 | langwell->otg.default_a = 0; | ||
1217 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1218 | queue_work(langwell->qwork, &langwell->work); | ||
1219 | } else if (langwell->hsm.a_bus_req) { | ||
1220 | langwell_otg_drv_vbus(1); | ||
1221 | langwell->hsm.a_wait_vrise_tmout = 0; | ||
1222 | langwell_otg_add_timer(a_wait_vrise_tmr); | ||
1223 | langwell->otg.state = OTG_STATE_A_WAIT_VRISE; | ||
1224 | } else if (!langwell->hsm.a_sess_vld) { | ||
1225 | langwell->hsm.a_srp_det = 0; | ||
1226 | langwell_otg_drv_vbus(0); | ||
1227 | set_host_mode(); | ||
1228 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
1229 | } | ||
1230 | break; | ||
1231 | default: | ||
1232 | ; | ||
1233 | } | ||
1234 | |||
1235 | otg_dbg("%s: new state = %s\n", __func__, | ||
1236 | state_string(langwell->otg.state)); | ||
1237 | } | ||
1238 | |||
1239 | static ssize_t | ||
1240 | show_registers(struct device *_dev, struct device_attribute *attr, char *buf) | ||
1241 | { | ||
1242 | struct langwell_otg *langwell; | ||
1243 | char *next; | ||
1244 | unsigned size; | ||
1245 | unsigned t; | ||
1246 | |||
1247 | langwell = the_transceiver; | ||
1248 | next = buf; | ||
1249 | size = PAGE_SIZE; | ||
1250 | |||
1251 | t = scnprintf(next, size, | ||
1252 | "\n" | ||
1253 | "USBCMD = 0x%08x \n" | ||
1254 | "USBSTS = 0x%08x \n" | ||
1255 | "USBINTR = 0x%08x \n" | ||
1256 | "ASYNCLISTADDR = 0x%08x \n" | ||
1257 | "PORTSC1 = 0x%08x \n" | ||
1258 | "HOSTPC1 = 0x%08x \n" | ||
1259 | "OTGSC = 0x%08x \n" | ||
1260 | "USBMODE = 0x%08x \n", | ||
1261 | readl(langwell->regs + 0x30), | ||
1262 | readl(langwell->regs + 0x34), | ||
1263 | readl(langwell->regs + 0x38), | ||
1264 | readl(langwell->regs + 0x48), | ||
1265 | readl(langwell->regs + 0x74), | ||
1266 | readl(langwell->regs + 0xb4), | ||
1267 | readl(langwell->regs + 0xf4), | ||
1268 | readl(langwell->regs + 0xf8) | ||
1269 | ); | ||
1270 | size -= t; | ||
1271 | next += t; | ||
1272 | |||
1273 | return PAGE_SIZE - size; | ||
1274 | } | ||
1275 | static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL); | ||
1276 | |||
1277 | static ssize_t | ||
1278 | show_hsm(struct device *_dev, struct device_attribute *attr, char *buf) | ||
1279 | { | ||
1280 | struct langwell_otg *langwell; | ||
1281 | char *next; | ||
1282 | unsigned size; | ||
1283 | unsigned t; | ||
1284 | |||
1285 | langwell = the_transceiver; | ||
1286 | next = buf; | ||
1287 | size = PAGE_SIZE; | ||
1288 | |||
1289 | t = scnprintf(next, size, | ||
1290 | "\n" | ||
1291 | "current state = %s\n" | ||
1292 | "a_bus_resume = \t%d\n" | ||
1293 | "a_bus_suspend = \t%d\n" | ||
1294 | "a_conn = \t%d\n" | ||
1295 | "a_sess_vld = \t%d\n" | ||
1296 | "a_srp_det = \t%d\n" | ||
1297 | "a_vbus_vld = \t%d\n" | ||
1298 | "b_bus_resume = \t%d\n" | ||
1299 | "b_bus_suspend = \t%d\n" | ||
1300 | "b_conn = \t%d\n" | ||
1301 | "b_se0_srp = \t%d\n" | ||
1302 | "b_sess_end = \t%d\n" | ||
1303 | "b_sess_vld = \t%d\n" | ||
1304 | "id = \t%d\n" | ||
1305 | "a_set_b_hnp_en = \t%d\n" | ||
1306 | "b_srp_done = \t%d\n" | ||
1307 | "b_hnp_enable = \t%d\n" | ||
1308 | "a_wait_vrise_tmout = \t%d\n" | ||
1309 | "a_wait_bcon_tmout = \t%d\n" | ||
1310 | "a_aidl_bdis_tmout = \t%d\n" | ||
1311 | "b_ase0_brst_tmout = \t%d\n" | ||
1312 | "a_bus_drop = \t%d\n" | ||
1313 | "a_bus_req = \t%d\n" | ||
1314 | "a_clr_err = \t%d\n" | ||
1315 | "a_suspend_req = \t%d\n" | ||
1316 | "b_bus_req = \t%d\n" | ||
1317 | "b_bus_suspend_tmout = \t%d\n" | ||
1318 | "b_bus_suspend_vld = \t%d\n", | ||
1319 | state_string(langwell->otg.state), | ||
1320 | langwell->hsm.a_bus_resume, | ||
1321 | langwell->hsm.a_bus_suspend, | ||
1322 | langwell->hsm.a_conn, | ||
1323 | langwell->hsm.a_sess_vld, | ||
1324 | langwell->hsm.a_srp_det, | ||
1325 | langwell->hsm.a_vbus_vld, | ||
1326 | langwell->hsm.b_bus_resume, | ||
1327 | langwell->hsm.b_bus_suspend, | ||
1328 | langwell->hsm.b_conn, | ||
1329 | langwell->hsm.b_se0_srp, | ||
1330 | langwell->hsm.b_sess_end, | ||
1331 | langwell->hsm.b_sess_vld, | ||
1332 | langwell->hsm.id, | ||
1333 | langwell->hsm.a_set_b_hnp_en, | ||
1334 | langwell->hsm.b_srp_done, | ||
1335 | langwell->hsm.b_hnp_enable, | ||
1336 | langwell->hsm.a_wait_vrise_tmout, | ||
1337 | langwell->hsm.a_wait_bcon_tmout, | ||
1338 | langwell->hsm.a_aidl_bdis_tmout, | ||
1339 | langwell->hsm.b_ase0_brst_tmout, | ||
1340 | langwell->hsm.a_bus_drop, | ||
1341 | langwell->hsm.a_bus_req, | ||
1342 | langwell->hsm.a_clr_err, | ||
1343 | langwell->hsm.a_suspend_req, | ||
1344 | langwell->hsm.b_bus_req, | ||
1345 | langwell->hsm.b_bus_suspend_tmout, | ||
1346 | langwell->hsm.b_bus_suspend_vld | ||
1347 | ); | ||
1348 | size -= t; | ||
1349 | next += t; | ||
1350 | |||
1351 | return PAGE_SIZE - size; | ||
1352 | } | ||
1353 | static DEVICE_ATTR(hsm, S_IRUGO, show_hsm, NULL); | ||
1354 | |||
1355 | static ssize_t | ||
1356 | get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf) | ||
1357 | { | ||
1358 | struct langwell_otg *langwell; | ||
1359 | char *next; | ||
1360 | unsigned size; | ||
1361 | unsigned t; | ||
1362 | |||
1363 | langwell = the_transceiver; | ||
1364 | next = buf; | ||
1365 | size = PAGE_SIZE; | ||
1366 | |||
1367 | t = scnprintf(next, size, "%d", langwell->hsm.a_bus_req); | ||
1368 | size -= t; | ||
1369 | next += t; | ||
1370 | |||
1371 | return PAGE_SIZE - size; | ||
1372 | } | ||
1373 | |||
1374 | static ssize_t | ||
1375 | set_a_bus_req(struct device *dev, struct device_attribute *attr, | ||
1376 | const char *buf, size_t count) | ||
1377 | { | ||
1378 | struct langwell_otg *langwell; | ||
1379 | langwell = the_transceiver; | ||
1380 | if (!langwell->otg.default_a) | ||
1381 | return -1; | ||
1382 | if (count > 2) | ||
1383 | return -1; | ||
1384 | |||
1385 | if (buf[0] == '0') { | ||
1386 | langwell->hsm.a_bus_req = 0; | ||
1387 | otg_dbg("a_bus_req = 0\n"); | ||
1388 | } else if (buf[0] == '1') { | ||
1389 | /* If a_bus_drop is TRUE, a_bus_req can't be set */ | ||
1390 | if (langwell->hsm.a_bus_drop) | ||
1391 | return -1; | ||
1392 | langwell->hsm.a_bus_req = 1; | ||
1393 | otg_dbg("a_bus_req = 1\n"); | ||
1394 | } | ||
1395 | if (spin_trylock(&langwell->wq_lock)) { | ||
1396 | queue_work(langwell->qwork, &langwell->work); | ||
1397 | spin_unlock(&langwell->wq_lock); | ||
1398 | } | ||
1399 | return count; | ||
1400 | } | ||
1401 | static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUGO, get_a_bus_req, set_a_bus_req); | ||
1402 | |||
1403 | static ssize_t | ||
1404 | get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf) | ||
1405 | { | ||
1406 | struct langwell_otg *langwell; | ||
1407 | char *next; | ||
1408 | unsigned size; | ||
1409 | unsigned t; | ||
1410 | |||
1411 | langwell = the_transceiver; | ||
1412 | next = buf; | ||
1413 | size = PAGE_SIZE; | ||
1414 | |||
1415 | t = scnprintf(next, size, "%d", langwell->hsm.a_bus_drop); | ||
1416 | size -= t; | ||
1417 | next += t; | ||
1418 | |||
1419 | return PAGE_SIZE - size; | ||
1420 | } | ||
1421 | |||
1422 | static ssize_t | ||
1423 | set_a_bus_drop(struct device *dev, struct device_attribute *attr, | ||
1424 | const char *buf, size_t count) | ||
1425 | { | ||
1426 | struct langwell_otg *langwell; | ||
1427 | langwell = the_transceiver; | ||
1428 | if (!langwell->otg.default_a) | ||
1429 | return -1; | ||
1430 | if (count > 2) | ||
1431 | return -1; | ||
1432 | |||
1433 | if (buf[0] == '0') { | ||
1434 | langwell->hsm.a_bus_drop = 0; | ||
1435 | otg_dbg("a_bus_drop = 0\n"); | ||
1436 | } else if (buf[0] == '1') { | ||
1437 | langwell->hsm.a_bus_drop = 1; | ||
1438 | langwell->hsm.a_bus_req = 0; | ||
1439 | otg_dbg("a_bus_drop = 1, then a_bus_req = 0\n"); | ||
1440 | } | ||
1441 | if (spin_trylock(&langwell->wq_lock)) { | ||
1442 | queue_work(langwell->qwork, &langwell->work); | ||
1443 | spin_unlock(&langwell->wq_lock); | ||
1444 | } | ||
1445 | return count; | ||
1446 | } | ||
1447 | static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUGO, | ||
1448 | get_a_bus_drop, set_a_bus_drop); | ||
1449 | |||
1450 | static ssize_t | ||
1451 | get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf) | ||
1452 | { | ||
1453 | struct langwell_otg *langwell; | ||
1454 | char *next; | ||
1455 | unsigned size; | ||
1456 | unsigned t; | ||
1457 | |||
1458 | langwell = the_transceiver; | ||
1459 | next = buf; | ||
1460 | size = PAGE_SIZE; | ||
1461 | |||
1462 | t = scnprintf(next, size, "%d", langwell->hsm.b_bus_req); | ||
1463 | size -= t; | ||
1464 | next += t; | ||
1465 | |||
1466 | return PAGE_SIZE - size; | ||
1467 | } | ||
1468 | |||
1469 | static ssize_t | ||
1470 | set_b_bus_req(struct device *dev, struct device_attribute *attr, | ||
1471 | const char *buf, size_t count) | ||
1472 | { | ||
1473 | struct langwell_otg *langwell; | ||
1474 | langwell = the_transceiver; | ||
1475 | |||
1476 | if (langwell->otg.default_a) | ||
1477 | return -1; | ||
1478 | |||
1479 | if (count > 2) | ||
1480 | return -1; | ||
1481 | |||
1482 | if (buf[0] == '0') { | ||
1483 | langwell->hsm.b_bus_req = 0; | ||
1484 | otg_dbg("b_bus_req = 0\n"); | ||
1485 | } else if (buf[0] == '1') { | ||
1486 | langwell->hsm.b_bus_req = 1; | ||
1487 | otg_dbg("b_bus_req = 1\n"); | ||
1488 | } | ||
1489 | if (spin_trylock(&langwell->wq_lock)) { | ||
1490 | queue_work(langwell->qwork, &langwell->work); | ||
1491 | spin_unlock(&langwell->wq_lock); | ||
1492 | } | ||
1493 | return count; | ||
1494 | } | ||
1495 | static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUGO, get_b_bus_req, set_b_bus_req); | ||
1496 | |||
1497 | static ssize_t | ||
1498 | set_a_clr_err(struct device *dev, struct device_attribute *attr, | ||
1499 | const char *buf, size_t count) | ||
1500 | { | ||
1501 | struct langwell_otg *langwell; | ||
1502 | langwell = the_transceiver; | ||
1503 | |||
1504 | if (!langwell->otg.default_a) | ||
1505 | return -1; | ||
1506 | if (count > 2) | ||
1507 | return -1; | ||
1508 | |||
1509 | if (buf[0] == '1') { | ||
1510 | langwell->hsm.a_clr_err = 1; | ||
1511 | otg_dbg("a_clr_err = 1\n"); | ||
1512 | } | ||
1513 | if (spin_trylock(&langwell->wq_lock)) { | ||
1514 | queue_work(langwell->qwork, &langwell->work); | ||
1515 | spin_unlock(&langwell->wq_lock); | ||
1516 | } | ||
1517 | return count; | ||
1518 | } | ||
1519 | static DEVICE_ATTR(a_clr_err, S_IWUGO, NULL, set_a_clr_err); | ||
1520 | |||
1521 | static struct attribute *inputs_attrs[] = { | ||
1522 | &dev_attr_a_bus_req.attr, | ||
1523 | &dev_attr_a_bus_drop.attr, | ||
1524 | &dev_attr_b_bus_req.attr, | ||
1525 | &dev_attr_a_clr_err.attr, | ||
1526 | NULL, | ||
1527 | }; | ||
1528 | |||
1529 | static struct attribute_group debug_dev_attr_group = { | ||
1530 | .name = "inputs", | ||
1531 | .attrs = inputs_attrs, | ||
1532 | }; | ||
1533 | |||
1534 | int langwell_register_host(struct pci_driver *host_driver) | ||
1535 | { | ||
1536 | int ret = 0; | ||
1537 | |||
1538 | the_transceiver->host_ops = host_driver; | ||
1539 | queue_work(the_transceiver->qwork, &the_transceiver->work); | ||
1540 | otg_dbg("host controller driver is registered\n"); | ||
1541 | |||
1542 | return ret; | ||
1543 | } | ||
1544 | EXPORT_SYMBOL(langwell_register_host); | ||
1545 | |||
1546 | void langwell_unregister_host(struct pci_driver *host_driver) | ||
1547 | { | ||
1548 | if (the_transceiver->host_ops) | ||
1549 | the_transceiver->host_ops->remove(the_transceiver->pdev); | ||
1550 | the_transceiver->host_ops = NULL; | ||
1551 | the_transceiver->hsm.a_bus_drop = 1; | ||
1552 | queue_work(the_transceiver->qwork, &the_transceiver->work); | ||
1553 | otg_dbg("host controller driver is unregistered\n"); | ||
1554 | } | ||
1555 | EXPORT_SYMBOL(langwell_unregister_host); | ||
1556 | |||
1557 | int langwell_register_peripheral(struct pci_driver *client_driver) | ||
1558 | { | ||
1559 | int ret = 0; | ||
1560 | |||
1561 | if (client_driver) | ||
1562 | ret = client_driver->probe(the_transceiver->pdev, | ||
1563 | client_driver->id_table); | ||
1564 | if (!ret) { | ||
1565 | the_transceiver->client_ops = client_driver; | ||
1566 | queue_work(the_transceiver->qwork, &the_transceiver->work); | ||
1567 | otg_dbg("client controller driver is registered\n"); | ||
1568 | } | ||
1569 | |||
1570 | return ret; | ||
1571 | } | ||
1572 | EXPORT_SYMBOL(langwell_register_peripheral); | ||
1573 | |||
1574 | void langwell_unregister_peripheral(struct pci_driver *client_driver) | ||
1575 | { | ||
1576 | if (the_transceiver->client_ops) | ||
1577 | the_transceiver->client_ops->remove(the_transceiver->pdev); | ||
1578 | the_transceiver->client_ops = NULL; | ||
1579 | the_transceiver->hsm.b_bus_req = 0; | ||
1580 | queue_work(the_transceiver->qwork, &the_transceiver->work); | ||
1581 | otg_dbg("client controller driver is unregistered\n"); | ||
1582 | } | ||
1583 | EXPORT_SYMBOL(langwell_unregister_peripheral); | ||
1584 | |||
1585 | static int langwell_otg_probe(struct pci_dev *pdev, | ||
1586 | const struct pci_device_id *id) | ||
1587 | { | ||
1588 | unsigned long resource, len; | ||
1589 | void __iomem *base = NULL; | ||
1590 | int retval; | ||
1591 | u32 val32; | ||
1592 | struct langwell_otg *langwell; | ||
1593 | char qname[] = "langwell_otg_queue"; | ||
1594 | |||
1595 | retval = 0; | ||
1596 | otg_dbg("\notg controller is detected.\n"); | ||
1597 | if (pci_enable_device(pdev) < 0) { | ||
1598 | retval = -ENODEV; | ||
1599 | goto done; | ||
1600 | } | ||
1601 | |||
1602 | langwell = kzalloc(sizeof *langwell, GFP_KERNEL); | ||
1603 | if (langwell == NULL) { | ||
1604 | retval = -ENOMEM; | ||
1605 | goto done; | ||
1606 | } | ||
1607 | the_transceiver = langwell; | ||
1608 | |||
1609 | /* control register: BAR 0 */ | ||
1610 | resource = pci_resource_start(pdev, 0); | ||
1611 | len = pci_resource_len(pdev, 0); | ||
1612 | if (!request_mem_region(resource, len, driver_name)) { | ||
1613 | retval = -EBUSY; | ||
1614 | goto err; | ||
1615 | } | ||
1616 | langwell->region = 1; | ||
1617 | |||
1618 | base = ioremap_nocache(resource, len); | ||
1619 | if (base == NULL) { | ||
1620 | retval = -EFAULT; | ||
1621 | goto err; | ||
1622 | } | ||
1623 | langwell->regs = base; | ||
1624 | |||
1625 | if (!pdev->irq) { | ||
1626 | otg_dbg("No IRQ.\n"); | ||
1627 | retval = -ENODEV; | ||
1628 | goto err; | ||
1629 | } | ||
1630 | |||
1631 | langwell->qwork = create_workqueue(qname); | ||
1632 | if (!langwell->qwork) { | ||
1633 | otg_dbg("cannot create workqueue %s\n", qname); | ||
1634 | retval = -ENOMEM; | ||
1635 | goto err; | ||
1636 | } | ||
1637 | INIT_WORK(&langwell->work, langwell_otg_work); | ||
1638 | |||
1639 | /* OTG common part */ | ||
1640 | langwell->pdev = pdev; | ||
1641 | langwell->otg.dev = &pdev->dev; | ||
1642 | langwell->otg.label = driver_name; | ||
1643 | langwell->otg.set_host = langwell_otg_set_host; | ||
1644 | langwell->otg.set_peripheral = langwell_otg_set_peripheral; | ||
1645 | langwell->otg.set_power = langwell_otg_set_power; | ||
1646 | langwell->otg.start_srp = langwell_otg_start_srp; | ||
1647 | langwell->otg.state = OTG_STATE_UNDEFINED; | ||
1648 | if (otg_set_transceiver(&langwell->otg)) { | ||
1649 | otg_dbg("can't set transceiver\n"); | ||
1650 | retval = -EBUSY; | ||
1651 | goto err; | ||
1652 | } | ||
1653 | |||
1654 | reset_otg(); | ||
1655 | init_hsm(); | ||
1656 | |||
1657 | spin_lock_init(&langwell->lock); | ||
1658 | spin_lock_init(&langwell->wq_lock); | ||
1659 | INIT_LIST_HEAD(&active_timers); | ||
1660 | langwell_otg_init_timers(&langwell->hsm); | ||
1661 | |||
1662 | if (request_irq(pdev->irq, otg_irq, IRQF_SHARED, | ||
1663 | driver_name, langwell) != 0) { | ||
1664 | otg_dbg("request interrupt %d failed\n", pdev->irq); | ||
1665 | retval = -EBUSY; | ||
1666 | goto err; | ||
1667 | } | ||
1668 | |||
1669 | /* enable OTGSC int */ | ||
1670 | val32 = OTGSC_DPIE | OTGSC_BSEIE | OTGSC_BSVIE | | ||
1671 | OTGSC_ASVIE | OTGSC_AVVIE | OTGSC_IDIE | OTGSC_IDPU; | ||
1672 | writel(val32, langwell->regs + CI_OTGSC); | ||
1673 | |||
1674 | retval = device_create_file(&pdev->dev, &dev_attr_registers); | ||
1675 | if (retval < 0) { | ||
1676 | otg_dbg("Can't register sysfs attribute: %d\n", retval); | ||
1677 | goto err; | ||
1678 | } | ||
1679 | |||
1680 | retval = device_create_file(&pdev->dev, &dev_attr_hsm); | ||
1681 | if (retval < 0) { | ||
1682 | otg_dbg("Can't hsm sysfs attribute: %d\n", retval); | ||
1683 | goto err; | ||
1684 | } | ||
1685 | |||
1686 | retval = sysfs_create_group(&pdev->dev.kobj, &debug_dev_attr_group); | ||
1687 | if (retval < 0) { | ||
1688 | otg_dbg("Can't register sysfs attr group: %d\n", retval); | ||
1689 | goto err; | ||
1690 | } | ||
1691 | |||
1692 | if (langwell->otg.state == OTG_STATE_A_IDLE) | ||
1693 | queue_work(langwell->qwork, &langwell->work); | ||
1694 | |||
1695 | return 0; | ||
1696 | |||
1697 | err: | ||
1698 | if (the_transceiver) | ||
1699 | langwell_otg_remove(pdev); | ||
1700 | done: | ||
1701 | return retval; | ||
1702 | } | ||
1703 | |||
1704 | static void langwell_otg_remove(struct pci_dev *pdev) | ||
1705 | { | ||
1706 | struct langwell_otg *langwell; | ||
1707 | |||
1708 | langwell = the_transceiver; | ||
1709 | |||
1710 | if (langwell->qwork) { | ||
1711 | flush_workqueue(langwell->qwork); | ||
1712 | destroy_workqueue(langwell->qwork); | ||
1713 | } | ||
1714 | langwell_otg_free_timers(); | ||
1715 | |||
1716 | /* disable OTGSC interrupt as OTGSC doesn't change in reset */ | ||
1717 | writel(0, langwell->regs + CI_OTGSC); | ||
1718 | |||
1719 | if (pdev->irq) | ||
1720 | free_irq(pdev->irq, langwell); | ||
1721 | if (langwell->regs) | ||
1722 | iounmap(langwell->regs); | ||
1723 | if (langwell->region) | ||
1724 | release_mem_region(pci_resource_start(pdev, 0), | ||
1725 | pci_resource_len(pdev, 0)); | ||
1726 | |||
1727 | otg_set_transceiver(NULL); | ||
1728 | pci_disable_device(pdev); | ||
1729 | sysfs_remove_group(&pdev->dev.kobj, &debug_dev_attr_group); | ||
1730 | device_remove_file(&pdev->dev, &dev_attr_hsm); | ||
1731 | device_remove_file(&pdev->dev, &dev_attr_registers); | ||
1732 | kfree(langwell); | ||
1733 | langwell = NULL; | ||
1734 | } | ||
1735 | |||
1736 | static void transceiver_suspend(struct pci_dev *pdev) | ||
1737 | { | ||
1738 | pci_save_state(pdev); | ||
1739 | pci_set_power_state(pdev, PCI_D3hot); | ||
1740 | langwell_otg_phy_low_power(1); | ||
1741 | } | ||
1742 | |||
1743 | static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message) | ||
1744 | { | ||
1745 | int ret = 0; | ||
1746 | struct langwell_otg *langwell; | ||
1747 | |||
1748 | langwell = the_transceiver; | ||
1749 | |||
1750 | /* Disbale OTG interrupts */ | ||
1751 | langwell_otg_intr(0); | ||
1752 | |||
1753 | if (pdev->irq) | ||
1754 | free_irq(pdev->irq, langwell); | ||
1755 | |||
1756 | /* Prevent more otg_work */ | ||
1757 | flush_workqueue(langwell->qwork); | ||
1758 | spin_lock(&langwell->wq_lock); | ||
1759 | |||
1760 | /* start actions */ | ||
1761 | switch (langwell->otg.state) { | ||
1762 | case OTG_STATE_A_IDLE: | ||
1763 | case OTG_STATE_B_IDLE: | ||
1764 | case OTG_STATE_A_WAIT_VFALL: | ||
1765 | case OTG_STATE_A_VBUS_ERR: | ||
1766 | transceiver_suspend(pdev); | ||
1767 | break; | ||
1768 | case OTG_STATE_A_WAIT_VRISE: | ||
1769 | langwell_otg_del_timer(a_wait_vrise_tmr); | ||
1770 | langwell->hsm.a_srp_det = 0; | ||
1771 | langwell_otg_drv_vbus(0); | ||
1772 | langwell->otg.state = OTG_STATE_A_IDLE; | ||
1773 | transceiver_suspend(pdev); | ||
1774 | break; | ||
1775 | case OTG_STATE_A_WAIT_BCON: | ||
1776 | langwell_otg_del_timer(a_wait_bcon_tmr); | ||
1777 | if (langwell->host_ops) | ||
1778 | ret = langwell->host_ops->suspend(pdev, message); | ||
1779 | langwell_otg_drv_vbus(0); | ||
1780 | break; | ||
1781 | case OTG_STATE_A_HOST: | ||
1782 | if (langwell->host_ops) | ||
1783 | ret = langwell->host_ops->suspend(pdev, message); | ||
1784 | langwell_otg_drv_vbus(0); | ||
1785 | langwell_otg_phy_low_power(1); | ||
1786 | break; | ||
1787 | case OTG_STATE_A_SUSPEND: | ||
1788 | langwell_otg_del_timer(a_aidl_bdis_tmr); | ||
1789 | langwell_otg_HABA(0); | ||
1790 | if (langwell->host_ops) | ||
1791 | langwell->host_ops->remove(pdev); | ||
1792 | else | ||
1793 | otg_dbg("host driver has been removed.\n"); | ||
1794 | langwell_otg_drv_vbus(0); | ||
1795 | transceiver_suspend(pdev); | ||
1796 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1797 | break; | ||
1798 | case OTG_STATE_A_PERIPHERAL: | ||
1799 | if (langwell->client_ops) | ||
1800 | ret = langwell->client_ops->suspend(pdev, message); | ||
1801 | else | ||
1802 | otg_dbg("client driver has been removed.\n"); | ||
1803 | langwell_otg_drv_vbus(0); | ||
1804 | transceiver_suspend(pdev); | ||
1805 | langwell->otg.state = OTG_STATE_A_WAIT_VFALL; | ||
1806 | break; | ||
1807 | case OTG_STATE_B_HOST: | ||
1808 | if (langwell->host_ops) | ||
1809 | langwell->host_ops->remove(pdev); | ||
1810 | else | ||
1811 | otg_dbg("host driver has been removed.\n"); | ||
1812 | langwell->hsm.b_bus_req = 0; | ||
1813 | transceiver_suspend(pdev); | ||
1814 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1815 | break; | ||
1816 | case OTG_STATE_B_PERIPHERAL: | ||
1817 | if (langwell->client_ops) | ||
1818 | ret = langwell->client_ops->suspend(pdev, message); | ||
1819 | else | ||
1820 | otg_dbg("client driver has been removed.\n"); | ||
1821 | break; | ||
1822 | case OTG_STATE_B_WAIT_ACON: | ||
1823 | langwell_otg_del_timer(b_ase0_brst_tmr); | ||
1824 | langwell_otg_HAAR(0); | ||
1825 | if (langwell->host_ops) | ||
1826 | langwell->host_ops->remove(pdev); | ||
1827 | else | ||
1828 | otg_dbg("host driver has been removed.\n"); | ||
1829 | langwell->hsm.b_bus_req = 0; | ||
1830 | langwell->otg.state = OTG_STATE_B_IDLE; | ||
1831 | transceiver_suspend(pdev); | ||
1832 | break; | ||
1833 | default: | ||
1834 | otg_dbg("error state before suspend\n "); | ||
1835 | break; | ||
1836 | } | ||
1837 | spin_unlock(&langwell->wq_lock); | ||
1838 | |||
1839 | return ret; | ||
1840 | } | ||
1841 | |||
1842 | static void transceiver_resume(struct pci_dev *pdev) | ||
1843 | { | ||
1844 | pci_restore_state(pdev); | ||
1845 | pci_set_power_state(pdev, PCI_D0); | ||
1846 | langwell_otg_phy_low_power(0); | ||
1847 | } | ||
1848 | |||
1849 | static int langwell_otg_resume(struct pci_dev *pdev) | ||
1850 | { | ||
1851 | int ret = 0; | ||
1852 | struct langwell_otg *langwell; | ||
1853 | |||
1854 | langwell = the_transceiver; | ||
1855 | |||
1856 | spin_lock(&langwell->wq_lock); | ||
1857 | |||
1858 | switch (langwell->otg.state) { | ||
1859 | case OTG_STATE_A_IDLE: | ||
1860 | case OTG_STATE_B_IDLE: | ||
1861 | case OTG_STATE_A_WAIT_VFALL: | ||
1862 | case OTG_STATE_A_VBUS_ERR: | ||
1863 | transceiver_resume(pdev); | ||
1864 | break; | ||
1865 | case OTG_STATE_A_WAIT_BCON: | ||
1866 | langwell_otg_add_timer(a_wait_bcon_tmr); | ||
1867 | langwell_otg_drv_vbus(1); | ||
1868 | if (langwell->host_ops) | ||
1869 | ret = langwell->host_ops->resume(pdev); | ||
1870 | break; | ||
1871 | case OTG_STATE_A_HOST: | ||
1872 | langwell_otg_drv_vbus(1); | ||
1873 | langwell_otg_phy_low_power(0); | ||
1874 | if (langwell->host_ops) | ||
1875 | ret = langwell->host_ops->resume(pdev); | ||
1876 | break; | ||
1877 | case OTG_STATE_B_PERIPHERAL: | ||
1878 | if (langwell->client_ops) | ||
1879 | ret = langwell->client_ops->resume(pdev); | ||
1880 | else | ||
1881 | otg_dbg("client driver not loaded.\n"); | ||
1882 | break; | ||
1883 | default: | ||
1884 | otg_dbg("error state before suspend\n "); | ||
1885 | break; | ||
1886 | } | ||
1887 | |||
1888 | if (request_irq(pdev->irq, otg_irq, IRQF_SHARED, | ||
1889 | driver_name, the_transceiver) != 0) { | ||
1890 | otg_dbg("request interrupt %d failed\n", pdev->irq); | ||
1891 | ret = -EBUSY; | ||
1892 | } | ||
1893 | |||
1894 | /* enable OTG interrupts */ | ||
1895 | langwell_otg_intr(1); | ||
1896 | |||
1897 | spin_unlock(&langwell->wq_lock); | ||
1898 | |||
1899 | queue_work(langwell->qwork, &langwell->work); | ||
1900 | |||
1901 | |||
1902 | return ret; | ||
1903 | } | ||
1904 | |||
1905 | static int __init langwell_otg_init(void) | ||
1906 | { | ||
1907 | return pci_register_driver(&otg_pci_driver); | ||
1908 | } | ||
1909 | module_init(langwell_otg_init); | ||
1910 | |||
1911 | static void __exit langwell_otg_cleanup(void) | ||
1912 | { | ||
1913 | pci_unregister_driver(&otg_pci_driver); | ||
1914 | } | ||
1915 | module_exit(langwell_otg_cleanup); | ||
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c index c567168f89af..9ed5ea568679 100644 --- a/drivers/usb/otg/nop-usb-xceiv.c +++ b/drivers/usb/otg/nop-usb-xceiv.c | |||
@@ -22,8 +22,8 @@ | |||
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | 22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
23 | * | 23 | * |
24 | * Current status: | 24 | * Current status: |
25 | * this is to add "nop" transceiver for all those phy which is | 25 | * This provides a "nop" transceiver for PHYs which are |
26 | * autonomous such as isp1504 etc. | 26 | * autonomous such as isp1504, isp1707, etc. |
27 | */ | 27 | */ |
28 | 28 | ||
29 | #include <linux/module.h> | 29 | #include <linux/module.h> |
@@ -36,30 +36,25 @@ struct nop_usb_xceiv { | |||
36 | struct device *dev; | 36 | struct device *dev; |
37 | }; | 37 | }; |
38 | 38 | ||
39 | static u64 nop_xceiv_dmamask = DMA_BIT_MASK(32); | 39 | static struct platform_device *pd; |
40 | |||
41 | static struct platform_device nop_xceiv_device = { | ||
42 | .name = "nop_usb_xceiv", | ||
43 | .id = -1, | ||
44 | .dev = { | ||
45 | .dma_mask = &nop_xceiv_dmamask, | ||
46 | .coherent_dma_mask = DMA_BIT_MASK(32), | ||
47 | .platform_data = NULL, | ||
48 | }, | ||
49 | }; | ||
50 | 40 | ||
51 | void usb_nop_xceiv_register(void) | 41 | void usb_nop_xceiv_register(void) |
52 | { | 42 | { |
53 | if (platform_device_register(&nop_xceiv_device) < 0) { | 43 | if (pd) |
44 | return; | ||
45 | pd = platform_device_register_simple("nop_usb_xceiv", -1, NULL, 0); | ||
46 | if (!pd) { | ||
54 | printk(KERN_ERR "Unable to register usb nop transceiver\n"); | 47 | printk(KERN_ERR "Unable to register usb nop transceiver\n"); |
55 | return; | 48 | return; |
56 | } | 49 | } |
57 | } | 50 | } |
51 | EXPORT_SYMBOL(usb_nop_xceiv_register); | ||
58 | 52 | ||
59 | void usb_nop_xceiv_unregister(void) | 53 | void usb_nop_xceiv_unregister(void) |
60 | { | 54 | { |
61 | platform_device_unregister(&nop_xceiv_device); | 55 | platform_device_unregister(pd); |
62 | } | 56 | } |
57 | EXPORT_SYMBOL(usb_nop_xceiv_unregister); | ||
63 | 58 | ||
64 | static inline struct nop_usb_xceiv *xceiv_to_nop(struct otg_transceiver *x) | 59 | static inline struct nop_usb_xceiv *xceiv_to_nop(struct otg_transceiver *x) |
65 | { | 60 | { |
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c index d9478d0e1c8b..9e3e7a5c258b 100644 --- a/drivers/usb/otg/twl4030-usb.c +++ b/drivers/usb/otg/twl4030-usb.c | |||
@@ -217,6 +217,7 @@ | |||
217 | 217 | ||
218 | /* In module TWL4030_MODULE_PM_MASTER */ | 218 | /* In module TWL4030_MODULE_PM_MASTER */ |
219 | #define PROTECT_KEY 0x0E | 219 | #define PROTECT_KEY 0x0E |
220 | #define STS_HW_CONDITIONS 0x0F | ||
220 | 221 | ||
221 | /* In module TWL4030_MODULE_PM_RECEIVER */ | 222 | /* In module TWL4030_MODULE_PM_RECEIVER */ |
222 | #define VUSB_DEDICATED1 0x7D | 223 | #define VUSB_DEDICATED1 0x7D |
@@ -351,15 +352,26 @@ static enum linkstat twl4030_usb_linkstat(struct twl4030_usb *twl) | |||
351 | int status; | 352 | int status; |
352 | int linkstat = USB_LINK_UNKNOWN; | 353 | int linkstat = USB_LINK_UNKNOWN; |
353 | 354 | ||
354 | /* STS_HW_CONDITIONS */ | 355 | /* |
355 | status = twl4030_readb(twl, TWL4030_MODULE_PM_MASTER, 0x0f); | 356 | * For ID/VBUS sensing, see manual section 15.4.8 ... |
357 | * except when using only battery backup power, two | ||
358 | * comparators produce VBUS_PRES and ID_PRES signals, | ||
359 | * which don't match docs elsewhere. But ... BIT(7) | ||
360 | * and BIT(2) of STS_HW_CONDITIONS, respectively, do | ||
361 | * seem to match up. If either is true the USB_PRES | ||
362 | * signal is active, the OTG module is activated, and | ||
363 | * its interrupt may be raised (may wake the system). | ||
364 | */ | ||
365 | status = twl4030_readb(twl, TWL4030_MODULE_PM_MASTER, | ||
366 | STS_HW_CONDITIONS); | ||
356 | if (status < 0) | 367 | if (status < 0) |
357 | dev_err(twl->dev, "USB link status err %d\n", status); | 368 | dev_err(twl->dev, "USB link status err %d\n", status); |
358 | else if (status & BIT(7)) | 369 | else if (status & (BIT(7) | BIT(2))) { |
359 | linkstat = USB_LINK_VBUS; | 370 | if (status & BIT(2)) |
360 | else if (status & BIT(2)) | 371 | linkstat = USB_LINK_ID; |
361 | linkstat = USB_LINK_ID; | 372 | else |
362 | else | 373 | linkstat = USB_LINK_VBUS; |
374 | } else | ||
363 | linkstat = USB_LINK_NONE; | 375 | linkstat = USB_LINK_NONE; |
364 | 376 | ||
365 | dev_dbg(twl->dev, "HW_CONDITIONS 0x%02x/%d; link %d\n", | 377 | dev_dbg(twl->dev, "HW_CONDITIONS 0x%02x/%d; link %d\n", |
@@ -641,7 +653,7 @@ static int twl4030_set_host(struct otg_transceiver *x, struct usb_bus *host) | |||
641 | return 0; | 653 | return 0; |
642 | } | 654 | } |
643 | 655 | ||
644 | static int __init twl4030_usb_probe(struct platform_device *pdev) | 656 | static int __devinit twl4030_usb_probe(struct platform_device *pdev) |
645 | { | 657 | { |
646 | struct twl4030_usb_data *pdata = pdev->dev.platform_data; | 658 | struct twl4030_usb_data *pdata = pdev->dev.platform_data; |
647 | struct twl4030_usb *twl; | 659 | struct twl4030_usb *twl; |
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c index 6d106e74265e..2cbfab3716e5 100644 --- a/drivers/usb/serial/aircable.c +++ b/drivers/usb/serial/aircable.c | |||
@@ -364,7 +364,7 @@ static int aircable_attach(struct usb_serial *serial) | |||
364 | return 0; | 364 | return 0; |
365 | } | 365 | } |
366 | 366 | ||
367 | static void aircable_shutdown(struct usb_serial *serial) | 367 | static void aircable_release(struct usb_serial *serial) |
368 | { | 368 | { |
369 | 369 | ||
370 | struct usb_serial_port *port = serial->port[0]; | 370 | struct usb_serial_port *port = serial->port[0]; |
@@ -375,7 +375,6 @@ static void aircable_shutdown(struct usb_serial *serial) | |||
375 | if (priv) { | 375 | if (priv) { |
376 | serial_buf_free(priv->tx_buf); | 376 | serial_buf_free(priv->tx_buf); |
377 | serial_buf_free(priv->rx_buf); | 377 | serial_buf_free(priv->rx_buf); |
378 | usb_set_serial_port_data(port, NULL); | ||
379 | kfree(priv); | 378 | kfree(priv); |
380 | } | 379 | } |
381 | } | 380 | } |
@@ -601,7 +600,7 @@ static struct usb_serial_driver aircable_device = { | |||
601 | .num_ports = 1, | 600 | .num_ports = 1, |
602 | .attach = aircable_attach, | 601 | .attach = aircable_attach, |
603 | .probe = aircable_probe, | 602 | .probe = aircable_probe, |
604 | .shutdown = aircable_shutdown, | 603 | .release = aircable_release, |
605 | .write = aircable_write, | 604 | .write = aircable_write, |
606 | .write_room = aircable_write_room, | 605 | .write_room = aircable_write_room, |
607 | .write_bulk_callback = aircable_write_bulk_callback, | 606 | .write_bulk_callback = aircable_write_bulk_callback, |
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c index 2bfd6dd85b5a..7033b031b443 100644 --- a/drivers/usb/serial/belkin_sa.c +++ b/drivers/usb/serial/belkin_sa.c | |||
@@ -90,7 +90,7 @@ static int debug; | |||
90 | 90 | ||
91 | /* function prototypes for a Belkin USB Serial Adapter F5U103 */ | 91 | /* function prototypes for a Belkin USB Serial Adapter F5U103 */ |
92 | static int belkin_sa_startup(struct usb_serial *serial); | 92 | static int belkin_sa_startup(struct usb_serial *serial); |
93 | static void belkin_sa_shutdown(struct usb_serial *serial); | 93 | static void belkin_sa_release(struct usb_serial *serial); |
94 | static int belkin_sa_open(struct tty_struct *tty, | 94 | static int belkin_sa_open(struct tty_struct *tty, |
95 | struct usb_serial_port *port, struct file *filp); | 95 | struct usb_serial_port *port, struct file *filp); |
96 | static void belkin_sa_close(struct usb_serial_port *port); | 96 | static void belkin_sa_close(struct usb_serial_port *port); |
@@ -142,7 +142,7 @@ static struct usb_serial_driver belkin_device = { | |||
142 | .tiocmget = belkin_sa_tiocmget, | 142 | .tiocmget = belkin_sa_tiocmget, |
143 | .tiocmset = belkin_sa_tiocmset, | 143 | .tiocmset = belkin_sa_tiocmset, |
144 | .attach = belkin_sa_startup, | 144 | .attach = belkin_sa_startup, |
145 | .shutdown = belkin_sa_shutdown, | 145 | .release = belkin_sa_release, |
146 | }; | 146 | }; |
147 | 147 | ||
148 | 148 | ||
@@ -197,14 +197,13 @@ static int belkin_sa_startup(struct usb_serial *serial) | |||
197 | } | 197 | } |
198 | 198 | ||
199 | 199 | ||
200 | static void belkin_sa_shutdown(struct usb_serial *serial) | 200 | static void belkin_sa_release(struct usb_serial *serial) |
201 | { | 201 | { |
202 | struct belkin_sa_private *priv; | 202 | struct belkin_sa_private *priv; |
203 | int i; | 203 | int i; |
204 | 204 | ||
205 | dbg("%s", __func__); | 205 | dbg("%s", __func__); |
206 | 206 | ||
207 | /* stop reads and writes on all ports */ | ||
208 | for (i = 0; i < serial->num_ports; ++i) { | 207 | for (i = 0; i < serial->num_ports; ++i) { |
209 | /* My special items, the standard routines free my urbs */ | 208 | /* My special items, the standard routines free my urbs */ |
210 | priv = usb_get_serial_port_data(serial->port[i]); | 209 | priv = usb_get_serial_port_data(serial->port[i]); |
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c index 83bbb5bca2ef..ba555c528cc6 100644 --- a/drivers/usb/serial/bus.c +++ b/drivers/usb/serial/bus.c | |||
@@ -59,23 +59,22 @@ static int usb_serial_device_probe(struct device *dev) | |||
59 | retval = -ENODEV; | 59 | retval = -ENODEV; |
60 | goto exit; | 60 | goto exit; |
61 | } | 61 | } |
62 | if (port->dev_state != PORT_REGISTERING) | ||
63 | goto exit; | ||
62 | 64 | ||
63 | driver = port->serial->type; | 65 | driver = port->serial->type; |
64 | if (driver->port_probe) { | 66 | if (driver->port_probe) { |
65 | if (!try_module_get(driver->driver.owner)) { | ||
66 | dev_err(dev, "module get failed, exiting\n"); | ||
67 | retval = -EIO; | ||
68 | goto exit; | ||
69 | } | ||
70 | retval = driver->port_probe(port); | 67 | retval = driver->port_probe(port); |
71 | module_put(driver->driver.owner); | ||
72 | if (retval) | 68 | if (retval) |
73 | goto exit; | 69 | goto exit; |
74 | } | 70 | } |
75 | 71 | ||
76 | retval = device_create_file(dev, &dev_attr_port_number); | 72 | retval = device_create_file(dev, &dev_attr_port_number); |
77 | if (retval) | 73 | if (retval) { |
74 | if (driver->port_remove) | ||
75 | retval = driver->port_remove(port); | ||
78 | goto exit; | 76 | goto exit; |
77 | } | ||
79 | 78 | ||
80 | minor = port->number; | 79 | minor = port->number; |
81 | tty_register_device(usb_serial_tty_driver, minor, dev); | 80 | tty_register_device(usb_serial_tty_driver, minor, dev); |
@@ -98,19 +97,15 @@ static int usb_serial_device_remove(struct device *dev) | |||
98 | if (!port) | 97 | if (!port) |
99 | return -ENODEV; | 98 | return -ENODEV; |
100 | 99 | ||
100 | if (port->dev_state != PORT_UNREGISTERING) | ||
101 | return retval; | ||
102 | |||
101 | device_remove_file(&port->dev, &dev_attr_port_number); | 103 | device_remove_file(&port->dev, &dev_attr_port_number); |
102 | 104 | ||
103 | driver = port->serial->type; | 105 | driver = port->serial->type; |
104 | if (driver->port_remove) { | 106 | if (driver->port_remove) |
105 | if (!try_module_get(driver->driver.owner)) { | ||
106 | dev_err(dev, "module get failed, exiting\n"); | ||
107 | retval = -EIO; | ||
108 | goto exit; | ||
109 | } | ||
110 | retval = driver->port_remove(port); | 107 | retval = driver->port_remove(port); |
111 | module_put(driver->driver.owner); | 108 | |
112 | } | ||
113 | exit: | ||
114 | minor = port->number; | 109 | minor = port->number; |
115 | tty_unregister_device(usb_serial_tty_driver, minor); | 110 | tty_unregister_device(usb_serial_tty_driver, minor); |
116 | dev_info(dev, "%s converter now disconnected from ttyUSB%d\n", | 111 | dev_info(dev, "%s converter now disconnected from ttyUSB%d\n", |
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c index 16a154d3b2fe..2b9eeda62bfe 100644 --- a/drivers/usb/serial/cp210x.c +++ b/drivers/usb/serial/cp210x.c | |||
@@ -50,7 +50,7 @@ static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *, | |||
50 | unsigned int, unsigned int); | 50 | unsigned int, unsigned int); |
51 | static void cp210x_break_ctl(struct tty_struct *, int); | 51 | static void cp210x_break_ctl(struct tty_struct *, int); |
52 | static int cp210x_startup(struct usb_serial *); | 52 | static int cp210x_startup(struct usb_serial *); |
53 | static void cp210x_shutdown(struct usb_serial *); | 53 | static void cp210x_disconnect(struct usb_serial *); |
54 | 54 | ||
55 | static int debug; | 55 | static int debug; |
56 | 56 | ||
@@ -137,7 +137,7 @@ static struct usb_serial_driver cp210x_device = { | |||
137 | .tiocmget = cp210x_tiocmget, | 137 | .tiocmget = cp210x_tiocmget, |
138 | .tiocmset = cp210x_tiocmset, | 138 | .tiocmset = cp210x_tiocmset, |
139 | .attach = cp210x_startup, | 139 | .attach = cp210x_startup, |
140 | .shutdown = cp210x_shutdown, | 140 | .disconnect = cp210x_disconnect, |
141 | }; | 141 | }; |
142 | 142 | ||
143 | /* Config request types */ | 143 | /* Config request types */ |
@@ -792,7 +792,7 @@ static int cp210x_startup(struct usb_serial *serial) | |||
792 | return 0; | 792 | return 0; |
793 | } | 793 | } |
794 | 794 | ||
795 | static void cp210x_shutdown(struct usb_serial *serial) | 795 | static void cp210x_disconnect(struct usb_serial *serial) |
796 | { | 796 | { |
797 | int i; | 797 | int i; |
798 | 798 | ||
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c index 933ba913e66c..336523fd7366 100644 --- a/drivers/usb/serial/cyberjack.c +++ b/drivers/usb/serial/cyberjack.c | |||
@@ -58,7 +58,8 @@ static int debug; | |||
58 | 58 | ||
59 | /* Function prototypes */ | 59 | /* Function prototypes */ |
60 | static int cyberjack_startup(struct usb_serial *serial); | 60 | static int cyberjack_startup(struct usb_serial *serial); |
61 | static void cyberjack_shutdown(struct usb_serial *serial); | 61 | static void cyberjack_disconnect(struct usb_serial *serial); |
62 | static void cyberjack_release(struct usb_serial *serial); | ||
62 | static int cyberjack_open(struct tty_struct *tty, | 63 | static int cyberjack_open(struct tty_struct *tty, |
63 | struct usb_serial_port *port, struct file *filp); | 64 | struct usb_serial_port *port, struct file *filp); |
64 | static void cyberjack_close(struct usb_serial_port *port); | 65 | static void cyberjack_close(struct usb_serial_port *port); |
@@ -94,7 +95,8 @@ static struct usb_serial_driver cyberjack_device = { | |||
94 | .id_table = id_table, | 95 | .id_table = id_table, |
95 | .num_ports = 1, | 96 | .num_ports = 1, |
96 | .attach = cyberjack_startup, | 97 | .attach = cyberjack_startup, |
97 | .shutdown = cyberjack_shutdown, | 98 | .disconnect = cyberjack_disconnect, |
99 | .release = cyberjack_release, | ||
98 | .open = cyberjack_open, | 100 | .open = cyberjack_open, |
99 | .close = cyberjack_close, | 101 | .close = cyberjack_close, |
100 | .write = cyberjack_write, | 102 | .write = cyberjack_write, |
@@ -148,17 +150,25 @@ static int cyberjack_startup(struct usb_serial *serial) | |||
148 | return 0; | 150 | return 0; |
149 | } | 151 | } |
150 | 152 | ||
151 | static void cyberjack_shutdown(struct usb_serial *serial) | 153 | static void cyberjack_disconnect(struct usb_serial *serial) |
152 | { | 154 | { |
153 | int i; | 155 | int i; |
154 | 156 | ||
155 | dbg("%s", __func__); | 157 | dbg("%s", __func__); |
156 | 158 | ||
157 | for (i = 0; i < serial->num_ports; ++i) { | 159 | for (i = 0; i < serial->num_ports; ++i) |
158 | usb_kill_urb(serial->port[i]->interrupt_in_urb); | 160 | usb_kill_urb(serial->port[i]->interrupt_in_urb); |
161 | } | ||
162 | |||
163 | static void cyberjack_release(struct usb_serial *serial) | ||
164 | { | ||
165 | int i; | ||
166 | |||
167 | dbg("%s", __func__); | ||
168 | |||
169 | for (i = 0; i < serial->num_ports; ++i) { | ||
159 | /* My special items, the standard routines free my urbs */ | 170 | /* My special items, the standard routines free my urbs */ |
160 | kfree(usb_get_serial_port_data(serial->port[i])); | 171 | kfree(usb_get_serial_port_data(serial->port[i])); |
161 | usb_set_serial_port_data(serial->port[i], NULL); | ||
162 | } | 172 | } |
163 | } | 173 | } |
164 | 174 | ||
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c index 669f93848539..9734085fd2fe 100644 --- a/drivers/usb/serial/cypress_m8.c +++ b/drivers/usb/serial/cypress_m8.c | |||
@@ -171,7 +171,7 @@ struct cypress_buf { | |||
171 | static int cypress_earthmate_startup(struct usb_serial *serial); | 171 | static int cypress_earthmate_startup(struct usb_serial *serial); |
172 | static int cypress_hidcom_startup(struct usb_serial *serial); | 172 | static int cypress_hidcom_startup(struct usb_serial *serial); |
173 | static int cypress_ca42v2_startup(struct usb_serial *serial); | 173 | static int cypress_ca42v2_startup(struct usb_serial *serial); |
174 | static void cypress_shutdown(struct usb_serial *serial); | 174 | static void cypress_release(struct usb_serial *serial); |
175 | static int cypress_open(struct tty_struct *tty, | 175 | static int cypress_open(struct tty_struct *tty, |
176 | struct usb_serial_port *port, struct file *filp); | 176 | struct usb_serial_port *port, struct file *filp); |
177 | static void cypress_close(struct usb_serial_port *port); | 177 | static void cypress_close(struct usb_serial_port *port); |
@@ -215,7 +215,7 @@ static struct usb_serial_driver cypress_earthmate_device = { | |||
215 | .id_table = id_table_earthmate, | 215 | .id_table = id_table_earthmate, |
216 | .num_ports = 1, | 216 | .num_ports = 1, |
217 | .attach = cypress_earthmate_startup, | 217 | .attach = cypress_earthmate_startup, |
218 | .shutdown = cypress_shutdown, | 218 | .release = cypress_release, |
219 | .open = cypress_open, | 219 | .open = cypress_open, |
220 | .close = cypress_close, | 220 | .close = cypress_close, |
221 | .dtr_rts = cypress_dtr_rts, | 221 | .dtr_rts = cypress_dtr_rts, |
@@ -242,7 +242,7 @@ static struct usb_serial_driver cypress_hidcom_device = { | |||
242 | .id_table = id_table_cyphidcomrs232, | 242 | .id_table = id_table_cyphidcomrs232, |
243 | .num_ports = 1, | 243 | .num_ports = 1, |
244 | .attach = cypress_hidcom_startup, | 244 | .attach = cypress_hidcom_startup, |
245 | .shutdown = cypress_shutdown, | 245 | .release = cypress_release, |
246 | .open = cypress_open, | 246 | .open = cypress_open, |
247 | .close = cypress_close, | 247 | .close = cypress_close, |
248 | .dtr_rts = cypress_dtr_rts, | 248 | .dtr_rts = cypress_dtr_rts, |
@@ -269,7 +269,7 @@ static struct usb_serial_driver cypress_ca42v2_device = { | |||
269 | .id_table = id_table_nokiaca42v2, | 269 | .id_table = id_table_nokiaca42v2, |
270 | .num_ports = 1, | 270 | .num_ports = 1, |
271 | .attach = cypress_ca42v2_startup, | 271 | .attach = cypress_ca42v2_startup, |
272 | .shutdown = cypress_shutdown, | 272 | .release = cypress_release, |
273 | .open = cypress_open, | 273 | .open = cypress_open, |
274 | .close = cypress_close, | 274 | .close = cypress_close, |
275 | .dtr_rts = cypress_dtr_rts, | 275 | .dtr_rts = cypress_dtr_rts, |
@@ -616,7 +616,7 @@ static int cypress_ca42v2_startup(struct usb_serial *serial) | |||
616 | } /* cypress_ca42v2_startup */ | 616 | } /* cypress_ca42v2_startup */ |
617 | 617 | ||
618 | 618 | ||
619 | static void cypress_shutdown(struct usb_serial *serial) | 619 | static void cypress_release(struct usb_serial *serial) |
620 | { | 620 | { |
621 | struct cypress_private *priv; | 621 | struct cypress_private *priv; |
622 | 622 | ||
@@ -629,7 +629,6 @@ static void cypress_shutdown(struct usb_serial *serial) | |||
629 | if (priv) { | 629 | if (priv) { |
630 | cypress_buf_free(priv->buf); | 630 | cypress_buf_free(priv->buf); |
631 | kfree(priv); | 631 | kfree(priv); |
632 | usb_set_serial_port_data(serial->port[0], NULL); | ||
633 | } | 632 | } |
634 | } | 633 | } |
635 | 634 | ||
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c index 30f5140eff03..f4808091c47c 100644 --- a/drivers/usb/serial/digi_acceleport.c +++ b/drivers/usb/serial/digi_acceleport.c | |||
@@ -460,7 +460,8 @@ static int digi_carrier_raised(struct usb_serial_port *port); | |||
460 | static void digi_dtr_rts(struct usb_serial_port *port, int on); | 460 | static void digi_dtr_rts(struct usb_serial_port *port, int on); |
461 | static int digi_startup_device(struct usb_serial *serial); | 461 | static int digi_startup_device(struct usb_serial *serial); |
462 | static int digi_startup(struct usb_serial *serial); | 462 | static int digi_startup(struct usb_serial *serial); |
463 | static void digi_shutdown(struct usb_serial *serial); | 463 | static void digi_disconnect(struct usb_serial *serial); |
464 | static void digi_release(struct usb_serial *serial); | ||
464 | static void digi_read_bulk_callback(struct urb *urb); | 465 | static void digi_read_bulk_callback(struct urb *urb); |
465 | static int digi_read_inb_callback(struct urb *urb); | 466 | static int digi_read_inb_callback(struct urb *urb); |
466 | static int digi_read_oob_callback(struct urb *urb); | 467 | static int digi_read_oob_callback(struct urb *urb); |
@@ -524,7 +525,8 @@ static struct usb_serial_driver digi_acceleport_2_device = { | |||
524 | .tiocmget = digi_tiocmget, | 525 | .tiocmget = digi_tiocmget, |
525 | .tiocmset = digi_tiocmset, | 526 | .tiocmset = digi_tiocmset, |
526 | .attach = digi_startup, | 527 | .attach = digi_startup, |
527 | .shutdown = digi_shutdown, | 528 | .disconnect = digi_disconnect, |
529 | .release = digi_release, | ||
528 | }; | 530 | }; |
529 | 531 | ||
530 | static struct usb_serial_driver digi_acceleport_4_device = { | 532 | static struct usb_serial_driver digi_acceleport_4_device = { |
@@ -550,7 +552,8 @@ static struct usb_serial_driver digi_acceleport_4_device = { | |||
550 | .tiocmget = digi_tiocmget, | 552 | .tiocmget = digi_tiocmget, |
551 | .tiocmset = digi_tiocmset, | 553 | .tiocmset = digi_tiocmset, |
552 | .attach = digi_startup, | 554 | .attach = digi_startup, |
553 | .shutdown = digi_shutdown, | 555 | .disconnect = digi_disconnect, |
556 | .release = digi_release, | ||
554 | }; | 557 | }; |
555 | 558 | ||
556 | 559 | ||
@@ -1556,16 +1559,23 @@ static int digi_startup(struct usb_serial *serial) | |||
1556 | } | 1559 | } |
1557 | 1560 | ||
1558 | 1561 | ||
1559 | static void digi_shutdown(struct usb_serial *serial) | 1562 | static void digi_disconnect(struct usb_serial *serial) |
1560 | { | 1563 | { |
1561 | int i; | 1564 | int i; |
1562 | dbg("digi_shutdown: TOP, in_interrupt()=%ld", in_interrupt()); | 1565 | dbg("digi_disconnect: TOP, in_interrupt()=%ld", in_interrupt()); |
1563 | 1566 | ||
1564 | /* stop reads and writes on all ports */ | 1567 | /* stop reads and writes on all ports */ |
1565 | for (i = 0; i < serial->type->num_ports + 1; i++) { | 1568 | for (i = 0; i < serial->type->num_ports + 1; i++) { |
1566 | usb_kill_urb(serial->port[i]->read_urb); | 1569 | usb_kill_urb(serial->port[i]->read_urb); |
1567 | usb_kill_urb(serial->port[i]->write_urb); | 1570 | usb_kill_urb(serial->port[i]->write_urb); |
1568 | } | 1571 | } |
1572 | } | ||
1573 | |||
1574 | |||
1575 | static void digi_release(struct usb_serial *serial) | ||
1576 | { | ||
1577 | int i; | ||
1578 | dbg("digi_release: TOP, in_interrupt()=%ld", in_interrupt()); | ||
1569 | 1579 | ||
1570 | /* free the private data structures for all ports */ | 1580 | /* free the private data structures for all ports */ |
1571 | /* number of regular ports + 1 for the out-of-band port */ | 1581 | /* number of regular ports + 1 for the out-of-band port */ |
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c index 2b141ccb0cd9..80cb3471adbe 100644 --- a/drivers/usb/serial/empeg.c +++ b/drivers/usb/serial/empeg.c | |||
@@ -90,7 +90,6 @@ static int empeg_chars_in_buffer(struct tty_struct *tty); | |||
90 | static void empeg_throttle(struct tty_struct *tty); | 90 | static void empeg_throttle(struct tty_struct *tty); |
91 | static void empeg_unthrottle(struct tty_struct *tty); | 91 | static void empeg_unthrottle(struct tty_struct *tty); |
92 | static int empeg_startup(struct usb_serial *serial); | 92 | static int empeg_startup(struct usb_serial *serial); |
93 | static void empeg_shutdown(struct usb_serial *serial); | ||
94 | static void empeg_set_termios(struct tty_struct *tty, | 93 | static void empeg_set_termios(struct tty_struct *tty, |
95 | struct usb_serial_port *port, struct ktermios *old_termios); | 94 | struct usb_serial_port *port, struct ktermios *old_termios); |
96 | static void empeg_write_bulk_callback(struct urb *urb); | 95 | static void empeg_write_bulk_callback(struct urb *urb); |
@@ -124,7 +123,6 @@ static struct usb_serial_driver empeg_device = { | |||
124 | .throttle = empeg_throttle, | 123 | .throttle = empeg_throttle, |
125 | .unthrottle = empeg_unthrottle, | 124 | .unthrottle = empeg_unthrottle, |
126 | .attach = empeg_startup, | 125 | .attach = empeg_startup, |
127 | .shutdown = empeg_shutdown, | ||
128 | .set_termios = empeg_set_termios, | 126 | .set_termios = empeg_set_termios, |
129 | .write = empeg_write, | 127 | .write = empeg_write, |
130 | .write_room = empeg_write_room, | 128 | .write_room = empeg_write_room, |
@@ -427,12 +425,6 @@ static int empeg_startup(struct usb_serial *serial) | |||
427 | } | 425 | } |
428 | 426 | ||
429 | 427 | ||
430 | static void empeg_shutdown(struct usb_serial *serial) | ||
431 | { | ||
432 | dbg("%s", __func__); | ||
433 | } | ||
434 | |||
435 | |||
436 | static void empeg_set_termios(struct tty_struct *tty, | 428 | static void empeg_set_termios(struct tty_struct *tty, |
437 | struct usb_serial_port *port, struct ktermios *old_termios) | 429 | struct usb_serial_port *port, struct ktermios *old_termios) |
438 | { | 430 | { |
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c index 683304d60615..3dc3768ca71c 100644 --- a/drivers/usb/serial/ftdi_sio.c +++ b/drivers/usb/serial/ftdi_sio.c | |||
@@ -47,7 +47,7 @@ | |||
47 | /* | 47 | /* |
48 | * Version Information | 48 | * Version Information |
49 | */ | 49 | */ |
50 | #define DRIVER_VERSION "v1.4.3" | 50 | #define DRIVER_VERSION "v1.5.0" |
51 | #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>" | 51 | #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>" |
52 | #define DRIVER_DESC "USB FTDI Serial Converters Driver" | 52 | #define DRIVER_DESC "USB FTDI Serial Converters Driver" |
53 | 53 | ||
@@ -82,7 +82,8 @@ struct ftdi_private { | |||
82 | int rx_processed; | 82 | int rx_processed; |
83 | unsigned long rx_bytes; | 83 | unsigned long rx_bytes; |
84 | 84 | ||
85 | __u16 interface; /* FT2232C port interface (0 for FT232/245) */ | 85 | __u16 interface; /* FT2232C, FT2232H or FT4232H port interface |
86 | (0 for FT232/245) */ | ||
86 | 87 | ||
87 | speed_t force_baud; /* if non-zero, force the baud rate to | 88 | speed_t force_baud; /* if non-zero, force the baud rate to |
88 | this value */ | 89 | this value */ |
@@ -94,6 +95,7 @@ struct ftdi_private { | |||
94 | unsigned long tx_bytes; | 95 | unsigned long tx_bytes; |
95 | unsigned long tx_outstanding_bytes; | 96 | unsigned long tx_outstanding_bytes; |
96 | unsigned long tx_outstanding_urbs; | 97 | unsigned long tx_outstanding_urbs; |
98 | unsigned short max_packet_size; | ||
97 | }; | 99 | }; |
98 | 100 | ||
99 | /* struct ftdi_sio_quirk is used by devices requiring special attention. */ | 101 | /* struct ftdi_sio_quirk is used by devices requiring special attention. */ |
@@ -164,6 +166,7 @@ static struct usb_device_id id_table_combined [] = { | |||
164 | { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) }, | 166 | { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) }, |
165 | { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) }, | 167 | { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) }, |
166 | { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) }, | 168 | { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) }, |
169 | { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) }, | ||
167 | { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) }, | 170 | { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) }, |
168 | { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) }, | 171 | { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) }, |
169 | { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) }, | 172 | { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) }, |
@@ -673,6 +676,7 @@ static struct usb_device_id id_table_combined [] = { | |||
673 | { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) }, | 676 | { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) }, |
674 | { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID), | 677 | { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID), |
675 | .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk }, | 678 | .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk }, |
679 | { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) }, | ||
676 | { }, /* Optional parameter entry */ | 680 | { }, /* Optional parameter entry */ |
677 | { } /* Terminating entry */ | 681 | { } /* Terminating entry */ |
678 | }; | 682 | }; |
@@ -693,12 +697,13 @@ static const char *ftdi_chip_name[] = { | |||
693 | [FT232BM] = "FT232BM", | 697 | [FT232BM] = "FT232BM", |
694 | [FT2232C] = "FT2232C", | 698 | [FT2232C] = "FT2232C", |
695 | [FT232RL] = "FT232RL", | 699 | [FT232RL] = "FT232RL", |
700 | [FT2232H] = "FT2232H", | ||
701 | [FT4232H] = "FT4232H" | ||
696 | }; | 702 | }; |
697 | 703 | ||
698 | 704 | ||
699 | /* Constants for read urb and write urb */ | 705 | /* Constants for read urb and write urb */ |
700 | #define BUFSZ 512 | 706 | #define BUFSZ 512 |
701 | #define PKTSZ 64 | ||
702 | 707 | ||
703 | /* rx_flags */ | 708 | /* rx_flags */ |
704 | #define THROTTLED 0x01 | 709 | #define THROTTLED 0x01 |
@@ -715,7 +720,6 @@ static const char *ftdi_chip_name[] = { | |||
715 | /* function prototypes for a FTDI serial converter */ | 720 | /* function prototypes for a FTDI serial converter */ |
716 | static int ftdi_sio_probe(struct usb_serial *serial, | 721 | static int ftdi_sio_probe(struct usb_serial *serial, |
717 | const struct usb_device_id *id); | 722 | const struct usb_device_id *id); |
718 | static void ftdi_shutdown(struct usb_serial *serial); | ||
719 | static int ftdi_sio_port_probe(struct usb_serial_port *port); | 723 | static int ftdi_sio_port_probe(struct usb_serial_port *port); |
720 | static int ftdi_sio_port_remove(struct usb_serial_port *port); | 724 | static int ftdi_sio_port_remove(struct usb_serial_port *port); |
721 | static int ftdi_open(struct tty_struct *tty, | 725 | static int ftdi_open(struct tty_struct *tty, |
@@ -744,6 +748,8 @@ static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base); | |||
744 | static unsigned short int ftdi_232am_baud_to_divisor(int baud); | 748 | static unsigned short int ftdi_232am_baud_to_divisor(int baud); |
745 | static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base); | 749 | static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base); |
746 | static __u32 ftdi_232bm_baud_to_divisor(int baud); | 750 | static __u32 ftdi_232bm_baud_to_divisor(int baud); |
751 | static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base); | ||
752 | static __u32 ftdi_2232h_baud_to_divisor(int baud); | ||
747 | 753 | ||
748 | static struct usb_serial_driver ftdi_sio_device = { | 754 | static struct usb_serial_driver ftdi_sio_device = { |
749 | .driver = { | 755 | .driver = { |
@@ -772,7 +778,6 @@ static struct usb_serial_driver ftdi_sio_device = { | |||
772 | .ioctl = ftdi_ioctl, | 778 | .ioctl = ftdi_ioctl, |
773 | .set_termios = ftdi_set_termios, | 779 | .set_termios = ftdi_set_termios, |
774 | .break_ctl = ftdi_break_ctl, | 780 | .break_ctl = ftdi_break_ctl, |
775 | .shutdown = ftdi_shutdown, | ||
776 | }; | 781 | }; |
777 | 782 | ||
778 | 783 | ||
@@ -838,6 +843,36 @@ static __u32 ftdi_232bm_baud_to_divisor(int baud) | |||
838 | return ftdi_232bm_baud_base_to_divisor(baud, 48000000); | 843 | return ftdi_232bm_baud_base_to_divisor(baud, 48000000); |
839 | } | 844 | } |
840 | 845 | ||
846 | static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base) | ||
847 | { | ||
848 | static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 }; | ||
849 | __u32 divisor; | ||
850 | int divisor3; | ||
851 | |||
852 | /* hi-speed baud rate is 10-bit sampling instead of 16-bit */ | ||
853 | divisor3 = (base / 10 / baud) * 8; | ||
854 | |||
855 | divisor = divisor3 >> 3; | ||
856 | divisor |= (__u32)divfrac[divisor3 & 0x7] << 14; | ||
857 | /* Deal with special cases for highest baud rates. */ | ||
858 | if (divisor == 1) | ||
859 | divisor = 0; | ||
860 | else if (divisor == 0x4001) | ||
861 | divisor = 1; | ||
862 | /* | ||
863 | * Set this bit to turn off a divide by 2.5 on baud rate generator | ||
864 | * This enables baud rates up to 12Mbaud but cannot reach below 1200 | ||
865 | * baud with this bit set | ||
866 | */ | ||
867 | divisor |= 0x00020000; | ||
868 | return divisor; | ||
869 | } | ||
870 | |||
871 | static __u32 ftdi_2232h_baud_to_divisor(int baud) | ||
872 | { | ||
873 | return ftdi_2232h_baud_base_to_divisor(baud, 120000000); | ||
874 | } | ||
875 | |||
841 | #define set_mctrl(port, set) update_mctrl((port), (set), 0) | 876 | #define set_mctrl(port, set) update_mctrl((port), (set), 0) |
842 | #define clear_mctrl(port, clear) update_mctrl((port), 0, (clear)) | 877 | #define clear_mctrl(port, clear) update_mctrl((port), 0, (clear)) |
843 | 878 | ||
@@ -996,6 +1031,19 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty, | |||
996 | baud = 9600; | 1031 | baud = 9600; |
997 | } | 1032 | } |
998 | break; | 1033 | break; |
1034 | case FT2232H: /* FT2232H chip */ | ||
1035 | case FT4232H: /* FT4232H chip */ | ||
1036 | if ((baud <= 12000000) & (baud >= 1200)) { | ||
1037 | div_value = ftdi_2232h_baud_to_divisor(baud); | ||
1038 | } else if (baud < 1200) { | ||
1039 | div_value = ftdi_232bm_baud_to_divisor(baud); | ||
1040 | } else { | ||
1041 | dbg("%s - Baud rate too high!", __func__); | ||
1042 | div_value = ftdi_232bm_baud_to_divisor(9600); | ||
1043 | div_okay = 0; | ||
1044 | baud = 9600; | ||
1045 | } | ||
1046 | break; | ||
999 | } /* priv->chip_type */ | 1047 | } /* priv->chip_type */ |
1000 | 1048 | ||
1001 | if (div_okay) { | 1049 | if (div_okay) { |
@@ -1196,14 +1244,29 @@ static void ftdi_determine_type(struct usb_serial_port *port) | |||
1196 | if (interfaces > 1) { | 1244 | if (interfaces > 1) { |
1197 | int inter; | 1245 | int inter; |
1198 | 1246 | ||
1199 | /* Multiple interfaces. Assume FT2232C. */ | 1247 | /* Multiple interfaces.*/ |
1200 | priv->chip_type = FT2232C; | 1248 | if (version == 0x0800) { |
1249 | priv->chip_type = FT4232H; | ||
1250 | /* Hi-speed - baud clock runs at 120MHz */ | ||
1251 | priv->baud_base = 120000000 / 2; | ||
1252 | } else if (version == 0x0700) { | ||
1253 | priv->chip_type = FT2232H; | ||
1254 | /* Hi-speed - baud clock runs at 120MHz */ | ||
1255 | priv->baud_base = 120000000 / 2; | ||
1256 | } else | ||
1257 | priv->chip_type = FT2232C; | ||
1258 | |||
1201 | /* Determine interface code. */ | 1259 | /* Determine interface code. */ |
1202 | inter = serial->interface->altsetting->desc.bInterfaceNumber; | 1260 | inter = serial->interface->altsetting->desc.bInterfaceNumber; |
1203 | if (inter == 0) | 1261 | if (inter == 0) { |
1204 | priv->interface = PIT_SIOA; | 1262 | priv->interface = INTERFACE_A; |
1205 | else | 1263 | } else if (inter == 1) { |
1206 | priv->interface = PIT_SIOB; | 1264 | priv->interface = INTERFACE_B; |
1265 | } else if (inter == 2) { | ||
1266 | priv->interface = INTERFACE_C; | ||
1267 | } else if (inter == 3) { | ||
1268 | priv->interface = INTERFACE_D; | ||
1269 | } | ||
1207 | /* BM-type devices have a bug where bcdDevice gets set | 1270 | /* BM-type devices have a bug where bcdDevice gets set |
1208 | * to 0x200 when iSerialNumber is 0. */ | 1271 | * to 0x200 when iSerialNumber is 0. */ |
1209 | if (version < 0x500) { | 1272 | if (version < 0x500) { |
@@ -1231,6 +1294,45 @@ static void ftdi_determine_type(struct usb_serial_port *port) | |||
1231 | } | 1294 | } |
1232 | 1295 | ||
1233 | 1296 | ||
1297 | /* Determine the maximum packet size for the device. This depends on the chip | ||
1298 | * type and the USB host capabilities. The value should be obtained from the | ||
1299 | * device descriptor as the chip will use the appropriate values for the host.*/ | ||
1300 | static void ftdi_set_max_packet_size(struct usb_serial_port *port) | ||
1301 | { | ||
1302 | struct ftdi_private *priv = usb_get_serial_port_data(port); | ||
1303 | struct usb_serial *serial = port->serial; | ||
1304 | struct usb_device *udev = serial->dev; | ||
1305 | |||
1306 | struct usb_interface *interface = serial->interface; | ||
1307 | struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc; | ||
1308 | |||
1309 | unsigned num_endpoints; | ||
1310 | int i = 0; | ||
1311 | |||
1312 | num_endpoints = interface->cur_altsetting->desc.bNumEndpoints; | ||
1313 | dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints); | ||
1314 | |||
1315 | /* NOTE: some customers have programmed FT232R/FT245R devices | ||
1316 | * with an endpoint size of 0 - not good. In this case, we | ||
1317 | * want to override the endpoint descriptor setting and use a | ||
1318 | * value of 64 for wMaxPacketSize */ | ||
1319 | for (i = 0; i < num_endpoints; i++) { | ||
1320 | dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1, | ||
1321 | interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize); | ||
1322 | ep_desc = &interface->cur_altsetting->endpoint[i].desc; | ||
1323 | if (ep_desc->wMaxPacketSize == 0) { | ||
1324 | ep_desc->wMaxPacketSize = cpu_to_le16(0x40); | ||
1325 | dev_info(&udev->dev, "Overriding wMaxPacketSize on endpoint %d\n", i); | ||
1326 | } | ||
1327 | } | ||
1328 | |||
1329 | /* set max packet size based on descriptor */ | ||
1330 | priv->max_packet_size = ep_desc->wMaxPacketSize; | ||
1331 | |||
1332 | dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size); | ||
1333 | } | ||
1334 | |||
1335 | |||
1234 | /* | 1336 | /* |
1235 | * *************************************************************************** | 1337 | * *************************************************************************** |
1236 | * Sysfs Attribute | 1338 | * Sysfs Attribute |
@@ -1314,7 +1416,9 @@ static int create_sysfs_attrs(struct usb_serial_port *port) | |||
1314 | if ((!retval) && | 1416 | if ((!retval) && |
1315 | (priv->chip_type == FT232BM || | 1417 | (priv->chip_type == FT232BM || |
1316 | priv->chip_type == FT2232C || | 1418 | priv->chip_type == FT2232C || |
1317 | priv->chip_type == FT232RL)) { | 1419 | priv->chip_type == FT232RL || |
1420 | priv->chip_type == FT2232H || | ||
1421 | priv->chip_type == FT4232H)) { | ||
1318 | retval = device_create_file(&port->dev, | 1422 | retval = device_create_file(&port->dev, |
1319 | &dev_attr_latency_timer); | 1423 | &dev_attr_latency_timer); |
1320 | } | 1424 | } |
@@ -1333,7 +1437,9 @@ static void remove_sysfs_attrs(struct usb_serial_port *port) | |||
1333 | device_remove_file(&port->dev, &dev_attr_event_char); | 1437 | device_remove_file(&port->dev, &dev_attr_event_char); |
1334 | if (priv->chip_type == FT232BM || | 1438 | if (priv->chip_type == FT232BM || |
1335 | priv->chip_type == FT2232C || | 1439 | priv->chip_type == FT2232C || |
1336 | priv->chip_type == FT232RL) { | 1440 | priv->chip_type == FT232RL || |
1441 | priv->chip_type == FT2232H || | ||
1442 | priv->chip_type == FT4232H) { | ||
1337 | device_remove_file(&port->dev, &dev_attr_latency_timer); | 1443 | device_remove_file(&port->dev, &dev_attr_latency_timer); |
1338 | } | 1444 | } |
1339 | } | 1445 | } |
@@ -1416,6 +1522,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port) | |||
1416 | usb_set_serial_port_data(port, priv); | 1522 | usb_set_serial_port_data(port, priv); |
1417 | 1523 | ||
1418 | ftdi_determine_type(port); | 1524 | ftdi_determine_type(port); |
1525 | ftdi_set_max_packet_size(port); | ||
1419 | read_latency_timer(port); | 1526 | read_latency_timer(port); |
1420 | create_sysfs_attrs(port); | 1527 | create_sysfs_attrs(port); |
1421 | return 0; | 1528 | return 0; |
@@ -1485,18 +1592,6 @@ static int ftdi_mtxorb_hack_setup(struct usb_serial *serial) | |||
1485 | return 0; | 1592 | return 0; |
1486 | } | 1593 | } |
1487 | 1594 | ||
1488 | /* ftdi_shutdown is called from usbserial:usb_serial_disconnect | ||
1489 | * it is called when the usb device is disconnected | ||
1490 | * | ||
1491 | * usbserial:usb_serial_disconnect | ||
1492 | * calls __serial_close for each open of the port | ||
1493 | * shutdown is called then (ie ftdi_shutdown) | ||
1494 | */ | ||
1495 | static void ftdi_shutdown(struct usb_serial *serial) | ||
1496 | { | ||
1497 | dbg("%s", __func__); | ||
1498 | } | ||
1499 | |||
1500 | static void ftdi_sio_priv_release(struct kref *k) | 1595 | static void ftdi_sio_priv_release(struct kref *k) |
1501 | { | 1596 | { |
1502 | struct ftdi_private *priv = container_of(k, struct ftdi_private, kref); | 1597 | struct ftdi_private *priv = container_of(k, struct ftdi_private, kref); |
@@ -1671,8 +1766,8 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1671 | if (data_offset > 0) { | 1766 | if (data_offset > 0) { |
1672 | /* Original sio needs control bytes too... */ | 1767 | /* Original sio needs control bytes too... */ |
1673 | transfer_size += (data_offset * | 1768 | transfer_size += (data_offset * |
1674 | ((count + (PKTSZ - 1 - data_offset)) / | 1769 | ((count + (priv->max_packet_size - 1 - data_offset)) / |
1675 | (PKTSZ - data_offset))); | 1770 | (priv->max_packet_size - data_offset))); |
1676 | } | 1771 | } |
1677 | 1772 | ||
1678 | buffer = kmalloc(transfer_size, GFP_ATOMIC); | 1773 | buffer = kmalloc(transfer_size, GFP_ATOMIC); |
@@ -1694,7 +1789,7 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1694 | if (data_offset > 0) { | 1789 | if (data_offset > 0) { |
1695 | /* Original sio requires control byte at start of | 1790 | /* Original sio requires control byte at start of |
1696 | each packet. */ | 1791 | each packet. */ |
1697 | int user_pktsz = PKTSZ - data_offset; | 1792 | int user_pktsz = priv->max_packet_size - data_offset; |
1698 | int todo = count; | 1793 | int todo = count; |
1699 | unsigned char *first_byte = buffer; | 1794 | unsigned char *first_byte = buffer; |
1700 | const unsigned char *current_position = buf; | 1795 | const unsigned char *current_position = buf; |
@@ -1775,11 +1870,6 @@ static void ftdi_write_bulk_callback(struct urb *urb) | |||
1775 | 1870 | ||
1776 | dbg("%s - port %d", __func__, port->number); | 1871 | dbg("%s - port %d", __func__, port->number); |
1777 | 1872 | ||
1778 | if (status) { | ||
1779 | dbg("nonzero write bulk status received: %d", status); | ||
1780 | return; | ||
1781 | } | ||
1782 | |||
1783 | priv = usb_get_serial_port_data(port); | 1873 | priv = usb_get_serial_port_data(port); |
1784 | if (!priv) { | 1874 | if (!priv) { |
1785 | dbg("%s - bad port private data pointer - exiting", __func__); | 1875 | dbg("%s - bad port private data pointer - exiting", __func__); |
@@ -1790,13 +1880,18 @@ static void ftdi_write_bulk_callback(struct urb *urb) | |||
1790 | data_offset = priv->write_offset; | 1880 | data_offset = priv->write_offset; |
1791 | if (data_offset > 0) { | 1881 | if (data_offset > 0) { |
1792 | /* Subtract the control bytes */ | 1882 | /* Subtract the control bytes */ |
1793 | countback -= (data_offset * DIV_ROUND_UP(countback, PKTSZ)); | 1883 | countback -= (data_offset * DIV_ROUND_UP(countback, priv->max_packet_size)); |
1794 | } | 1884 | } |
1795 | spin_lock_irqsave(&priv->tx_lock, flags); | 1885 | spin_lock_irqsave(&priv->tx_lock, flags); |
1796 | --priv->tx_outstanding_urbs; | 1886 | --priv->tx_outstanding_urbs; |
1797 | priv->tx_outstanding_bytes -= countback; | 1887 | priv->tx_outstanding_bytes -= countback; |
1798 | spin_unlock_irqrestore(&priv->tx_lock, flags); | 1888 | spin_unlock_irqrestore(&priv->tx_lock, flags); |
1799 | 1889 | ||
1890 | if (status) { | ||
1891 | dbg("nonzero write bulk status received: %d", status); | ||
1892 | return; | ||
1893 | } | ||
1894 | |||
1800 | usb_serial_port_softint(port); | 1895 | usb_serial_port_softint(port); |
1801 | } /* ftdi_write_bulk_callback */ | 1896 | } /* ftdi_write_bulk_callback */ |
1802 | 1897 | ||
@@ -1892,7 +1987,7 @@ static void ftdi_read_bulk_callback(struct urb *urb) | |||
1892 | 1987 | ||
1893 | /* count data bytes, but not status bytes */ | 1988 | /* count data bytes, but not status bytes */ |
1894 | countread = urb->actual_length; | 1989 | countread = urb->actual_length; |
1895 | countread -= 2 * DIV_ROUND_UP(countread, PKTSZ); | 1990 | countread -= 2 * DIV_ROUND_UP(countread, priv->max_packet_size); |
1896 | spin_lock_irqsave(&priv->rx_lock, flags); | 1991 | spin_lock_irqsave(&priv->rx_lock, flags); |
1897 | priv->rx_bytes += countread; | 1992 | priv->rx_bytes += countread; |
1898 | spin_unlock_irqrestore(&priv->rx_lock, flags); | 1993 | spin_unlock_irqrestore(&priv->rx_lock, flags); |
@@ -1965,7 +2060,7 @@ static void ftdi_process_read(struct work_struct *work) | |||
1965 | 2060 | ||
1966 | need_flip = 0; | 2061 | need_flip = 0; |
1967 | for (packet_offset = priv->rx_processed; | 2062 | for (packet_offset = priv->rx_processed; |
1968 | packet_offset < urb->actual_length; packet_offset += PKTSZ) { | 2063 | packet_offset < urb->actual_length; packet_offset += priv->max_packet_size) { |
1969 | int length; | 2064 | int length; |
1970 | 2065 | ||
1971 | /* Compare new line status to the old one, signal if different/ | 2066 | /* Compare new line status to the old one, signal if different/ |
@@ -1980,7 +2075,7 @@ static void ftdi_process_read(struct work_struct *work) | |||
1980 | priv->prev_status = new_status; | 2075 | priv->prev_status = new_status; |
1981 | } | 2076 | } |
1982 | 2077 | ||
1983 | length = min_t(u32, PKTSZ, urb->actual_length-packet_offset)-2; | 2078 | length = min_t(u32, priv->max_packet_size, urb->actual_length-packet_offset)-2; |
1984 | if (length < 0) { | 2079 | if (length < 0) { |
1985 | dev_err(&port->dev, "%s - bad packet length: %d\n", | 2080 | dev_err(&port->dev, "%s - bad packet length: %d\n", |
1986 | __func__, length+2); | 2081 | __func__, length+2); |
@@ -2011,6 +2106,7 @@ static void ftdi_process_read(struct work_struct *work) | |||
2011 | if (data[packet_offset+1] & FTDI_RS_BI) { | 2106 | if (data[packet_offset+1] & FTDI_RS_BI) { |
2012 | error_flag = TTY_BREAK; | 2107 | error_flag = TTY_BREAK; |
2013 | dbg("BREAK received"); | 2108 | dbg("BREAK received"); |
2109 | usb_serial_handle_break(port); | ||
2014 | } | 2110 | } |
2015 | if (data[packet_offset+1] & FTDI_RS_PE) { | 2111 | if (data[packet_offset+1] & FTDI_RS_PE) { |
2016 | error_flag = TTY_PARITY; | 2112 | error_flag = TTY_PARITY; |
@@ -2025,8 +2121,11 @@ static void ftdi_process_read(struct work_struct *work) | |||
2025 | /* Note that the error flag is duplicated for | 2121 | /* Note that the error flag is duplicated for |
2026 | every character received since we don't know | 2122 | every character received since we don't know |
2027 | which character it applied to */ | 2123 | which character it applied to */ |
2028 | tty_insert_flip_char(tty, | 2124 | if (!usb_serial_handle_sysrq_char(port, |
2029 | data[packet_offset + i], error_flag); | 2125 | data[packet_offset + i])) |
2126 | tty_insert_flip_char(tty, | ||
2127 | data[packet_offset + i], | ||
2128 | error_flag); | ||
2030 | } | 2129 | } |
2031 | need_flip = 1; | 2130 | need_flip = 1; |
2032 | } | 2131 | } |
@@ -2332,6 +2431,8 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file) | |||
2332 | case FT232BM: | 2431 | case FT232BM: |
2333 | case FT2232C: | 2432 | case FT2232C: |
2334 | case FT232RL: | 2433 | case FT232RL: |
2434 | case FT2232H: | ||
2435 | case FT4232H: | ||
2335 | /* the 8U232AM returns a two byte value (the sio is a 1 byte | 2436 | /* the 8U232AM returns a two byte value (the sio is a 1 byte |
2336 | value) - in the same format as the data returned from the in | 2437 | value) - in the same format as the data returned from the in |
2337 | point */ | 2438 | point */ |
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h index 12330fa1c095..f1d440a728a3 100644 --- a/drivers/usb/serial/ftdi_sio.h +++ b/drivers/usb/serial/ftdi_sio.h | |||
@@ -10,7 +10,7 @@ | |||
10 | * The device is based on the FTDI FT8U100AX chip. It has a DB25 on one side, | 10 | * The device is based on the FTDI FT8U100AX chip. It has a DB25 on one side, |
11 | * USB on the other. | 11 | * USB on the other. |
12 | * | 12 | * |
13 | * Thanx to FTDI (http://www.ftdi.co.uk) for so kindly providing details | 13 | * Thanx to FTDI (http://www.ftdichip.com) for so kindly providing details |
14 | * of the protocol required to talk to the device and ongoing assistence | 14 | * of the protocol required to talk to the device and ongoing assistence |
15 | * during development. | 15 | * during development. |
16 | * | 16 | * |
@@ -28,11 +28,15 @@ | |||
28 | #define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */ | 28 | #define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */ |
29 | #define FTDI_8U2232C_PID 0x6010 /* Dual channel device */ | 29 | #define FTDI_8U2232C_PID 0x6010 /* Dual channel device */ |
30 | #define FTDI_232RL_PID 0xFBFA /* Product ID for FT232RL */ | 30 | #define FTDI_232RL_PID 0xFBFA /* Product ID for FT232RL */ |
31 | #define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */ | ||
31 | #define FTDI_RELAIS_PID 0xFA10 /* Relais device from Rudolf Gugler */ | 32 | #define FTDI_RELAIS_PID 0xFA10 /* Relais device from Rudolf Gugler */ |
32 | #define FTDI_NF_RIC_VID 0x0DCD /* Vendor Id */ | 33 | #define FTDI_NF_RIC_VID 0x0DCD /* Vendor Id */ |
33 | #define FTDI_NF_RIC_PID 0x0001 /* Product Id */ | 34 | #define FTDI_NF_RIC_PID 0x0001 /* Product Id */ |
34 | #define FTDI_USBX_707_PID 0xF857 /* ADSTech IR Blaster USBX-707 */ | 35 | #define FTDI_USBX_707_PID 0xF857 /* ADSTech IR Blaster USBX-707 */ |
35 | 36 | ||
37 | /* Larsen and Brusgaard AltiTrack/USBtrack */ | ||
38 | #define LARSENBRUSGAARD_VID 0x0FD8 | ||
39 | #define LB_ALTITRACK_PID 0x0001 | ||
36 | 40 | ||
37 | /* www.canusb.com Lawicel CANUSB device */ | 41 | /* www.canusb.com Lawicel CANUSB device */ |
38 | #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */ | 42 | #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */ |
@@ -873,6 +877,11 @@ | |||
873 | #define FTDI_SIO_SET_LATENCY_TIMER 9 /* Set the latency timer */ | 877 | #define FTDI_SIO_SET_LATENCY_TIMER 9 /* Set the latency timer */ |
874 | #define FTDI_SIO_GET_LATENCY_TIMER 10 /* Get the latency timer */ | 878 | #define FTDI_SIO_GET_LATENCY_TIMER 10 /* Get the latency timer */ |
875 | 879 | ||
880 | /* Interface indicies for FT2232, FT2232H and FT4232H devices*/ | ||
881 | #define INTERFACE_A 1 | ||
882 | #define INTERFACE_B 2 | ||
883 | #define INTERFACE_C 3 | ||
884 | #define INTERFACE_D 4 | ||
876 | 885 | ||
877 | /* | 886 | /* |
878 | * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3 | 887 | * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3 |
@@ -1036,6 +1045,8 @@ typedef enum { | |||
1036 | FT232BM = 3, | 1045 | FT232BM = 3, |
1037 | FT2232C = 4, | 1046 | FT2232C = 4, |
1038 | FT232RL = 5, | 1047 | FT232RL = 5, |
1048 | FT2232H = 6, | ||
1049 | FT4232H = 7 | ||
1039 | } ftdi_chip_type_t; | 1050 | } ftdi_chip_type_t; |
1040 | 1051 | ||
1041 | typedef enum { | 1052 | typedef enum { |
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c index ee25a3fe3b09..8839f1c70b7f 100644 --- a/drivers/usb/serial/garmin_gps.c +++ b/drivers/usb/serial/garmin_gps.c | |||
@@ -1,7 +1,7 @@ | |||
1 | /* | 1 | /* |
2 | * Garmin GPS driver | 2 | * Garmin GPS driver |
3 | * | 3 | * |
4 | * Copyright (C) 2006,2007 Hermann Kneissel herkne@users.sourceforge.net | 4 | * Copyright (C) 2006-2009 Hermann Kneissel herkne@users.sourceforge.net |
5 | * | 5 | * |
6 | * The latest version of the driver can be found at | 6 | * The latest version of the driver can be found at |
7 | * http://sourceforge.net/projects/garmin-gps/ | 7 | * http://sourceforge.net/projects/garmin-gps/ |
@@ -51,7 +51,7 @@ static int debug; | |||
51 | */ | 51 | */ |
52 | 52 | ||
53 | #define VERSION_MAJOR 0 | 53 | #define VERSION_MAJOR 0 |
54 | #define VERSION_MINOR 31 | 54 | #define VERSION_MINOR 33 |
55 | 55 | ||
56 | #define _STR(s) #s | 56 | #define _STR(s) #s |
57 | #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b) | 57 | #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b) |
@@ -129,7 +129,6 @@ struct garmin_data { | |||
129 | __u8 state; | 129 | __u8 state; |
130 | __u16 flags; | 130 | __u16 flags; |
131 | __u8 mode; | 131 | __u8 mode; |
132 | __u8 ignorePkts; | ||
133 | __u8 count; | 132 | __u8 count; |
134 | __u8 pkt_id; | 133 | __u8 pkt_id; |
135 | __u32 serial_num; | 134 | __u32 serial_num; |
@@ -141,8 +140,6 @@ struct garmin_data { | |||
141 | __u8 inbuffer [GPS_IN_BUFSIZ]; /* tty -> usb */ | 140 | __u8 inbuffer [GPS_IN_BUFSIZ]; /* tty -> usb */ |
142 | __u8 outbuffer[GPS_OUT_BUFSIZ]; /* usb -> tty */ | 141 | __u8 outbuffer[GPS_OUT_BUFSIZ]; /* usb -> tty */ |
143 | __u8 privpkt[4*6]; | 142 | __u8 privpkt[4*6]; |
144 | atomic_t req_count; | ||
145 | atomic_t resp_count; | ||
146 | spinlock_t lock; | 143 | spinlock_t lock; |
147 | struct list_head pktlist; | 144 | struct list_head pktlist; |
148 | }; | 145 | }; |
@@ -170,6 +167,8 @@ struct garmin_data { | |||
170 | #define FLAGS_BULK_IN_ACTIVE 0x0020 | 167 | #define FLAGS_BULK_IN_ACTIVE 0x0020 |
171 | #define FLAGS_BULK_IN_RESTART 0x0010 | 168 | #define FLAGS_BULK_IN_RESTART 0x0010 |
172 | #define FLAGS_THROTTLED 0x0008 | 169 | #define FLAGS_THROTTLED 0x0008 |
170 | #define APP_REQ_SEEN 0x0004 | ||
171 | #define APP_RESP_SEEN 0x0002 | ||
173 | #define CLEAR_HALT_REQUIRED 0x0001 | 172 | #define CLEAR_HALT_REQUIRED 0x0001 |
174 | 173 | ||
175 | #define FLAGS_QUEUING 0x0100 | 174 | #define FLAGS_QUEUING 0x0100 |
@@ -184,20 +183,16 @@ struct garmin_data { | |||
184 | 183 | ||
185 | 184 | ||
186 | /* function prototypes */ | 185 | /* function prototypes */ |
187 | static void gsp_next_packet(struct garmin_data *garmin_data_p); | 186 | static int gsp_next_packet(struct garmin_data *garmin_data_p); |
188 | static int garmin_write_bulk(struct usb_serial_port *port, | 187 | static int garmin_write_bulk(struct usb_serial_port *port, |
189 | const unsigned char *buf, int count, | 188 | const unsigned char *buf, int count, |
190 | int dismiss_ack); | 189 | int dismiss_ack); |
191 | 190 | ||
192 | /* some special packets to be send or received */ | 191 | /* some special packets to be send or received */ |
193 | static unsigned char const GARMIN_START_SESSION_REQ[] | 192 | static unsigned char const GARMIN_START_SESSION_REQ[] |
194 | = { 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0 }; | 193 | = { 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0 }; |
195 | static unsigned char const GARMIN_START_SESSION_REQ2[] | ||
196 | = { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 }; | ||
197 | static unsigned char const GARMIN_START_SESSION_REPLY[] | 194 | static unsigned char const GARMIN_START_SESSION_REPLY[] |
198 | = { 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0 }; | 195 | = { 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0 }; |
199 | static unsigned char const GARMIN_SESSION_ACTIVE_REPLY[] | ||
200 | = { 0, 0, 0, 0, 17, 0, 0, 0, 4, 0, 0, 0, 0, 16, 0, 0 }; | ||
201 | static unsigned char const GARMIN_BULK_IN_AVAIL_REPLY[] | 196 | static unsigned char const GARMIN_BULK_IN_AVAIL_REPLY[] |
202 | = { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 }; | 197 | = { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 }; |
203 | static unsigned char const GARMIN_APP_LAYER_REPLY[] | 198 | static unsigned char const GARMIN_APP_LAYER_REPLY[] |
@@ -233,13 +228,6 @@ static struct usb_driver garmin_driver = { | |||
233 | }; | 228 | }; |
234 | 229 | ||
235 | 230 | ||
236 | static inline int noResponseFromAppLayer(struct garmin_data *garmin_data_p) | ||
237 | { | ||
238 | return atomic_read(&garmin_data_p->req_count) == | ||
239 | atomic_read(&garmin_data_p->resp_count); | ||
240 | } | ||
241 | |||
242 | |||
243 | static inline int getLayerId(const __u8 *usbPacket) | 231 | static inline int getLayerId(const __u8 *usbPacket) |
244 | { | 232 | { |
245 | return __le32_to_cpup((__le32 *)(usbPacket)); | 233 | return __le32_to_cpup((__le32 *)(usbPacket)); |
@@ -325,8 +313,11 @@ static int pkt_add(struct garmin_data *garmin_data_p, | |||
325 | state = garmin_data_p->state; | 313 | state = garmin_data_p->state; |
326 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | 314 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); |
327 | 315 | ||
316 | dbg("%s - added: pkt: %d - %d bytes", | ||
317 | __func__, pkt->seq, data_length); | ||
318 | |||
328 | /* in serial mode, if someone is waiting for data from | 319 | /* in serial mode, if someone is waiting for data from |
329 | the device, iconvert and send the next packet to tty. */ | 320 | the device, convert and send the next packet to tty. */ |
330 | if (result && (state == STATE_GSP_WAIT_DATA)) | 321 | if (result && (state == STATE_GSP_WAIT_DATA)) |
331 | gsp_next_packet(garmin_data_p); | 322 | gsp_next_packet(garmin_data_p); |
332 | } | 323 | } |
@@ -411,7 +402,7 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id) | |||
411 | /* | 402 | /* |
412 | * called for a complete packet received from tty layer | 403 | * called for a complete packet received from tty layer |
413 | * | 404 | * |
414 | * the complete packet (pkzid ... cksum) is in garmin_data_p->inbuf starting | 405 | * the complete packet (pktid ... cksum) is in garmin_data_p->inbuf starting |
415 | * at GSP_INITIAL_OFFSET. | 406 | * at GSP_INITIAL_OFFSET. |
416 | * | 407 | * |
417 | * count - number of bytes in the input buffer including space reserved for | 408 | * count - number of bytes in the input buffer including space reserved for |
@@ -501,7 +492,6 @@ static int gsp_receive(struct garmin_data *garmin_data_p, | |||
501 | unsigned long flags; | 492 | unsigned long flags; |
502 | int offs = 0; | 493 | int offs = 0; |
503 | int ack_or_nak_seen = 0; | 494 | int ack_or_nak_seen = 0; |
504 | int i = 0; | ||
505 | __u8 *dest; | 495 | __u8 *dest; |
506 | int size; | 496 | int size; |
507 | /* dleSeen: set if last byte read was a DLE */ | 497 | /* dleSeen: set if last byte read was a DLE */ |
@@ -519,8 +509,8 @@ static int gsp_receive(struct garmin_data *garmin_data_p, | |||
519 | skip = garmin_data_p->flags & FLAGS_GSP_SKIP; | 509 | skip = garmin_data_p->flags & FLAGS_GSP_SKIP; |
520 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | 510 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); |
521 | 511 | ||
522 | dbg("%s - dle=%d skip=%d size=%d count=%d", | 512 | /* dbg("%s - dle=%d skip=%d size=%d count=%d", |
523 | __func__, dleSeen, skip, size, count); | 513 | __func__, dleSeen, skip, size, count); */ |
524 | 514 | ||
525 | if (size == 0) | 515 | if (size == 0) |
526 | size = GSP_INITIAL_OFFSET; | 516 | size = GSP_INITIAL_OFFSET; |
@@ -568,7 +558,6 @@ static int gsp_receive(struct garmin_data *garmin_data_p, | |||
568 | } else if (!skip) { | 558 | } else if (!skip) { |
569 | 559 | ||
570 | if (dleSeen) { | 560 | if (dleSeen) { |
571 | dbg("non-masked DLE at %d - restarting", i); | ||
572 | size = GSP_INITIAL_OFFSET; | 561 | size = GSP_INITIAL_OFFSET; |
573 | dleSeen = 0; | 562 | dleSeen = 0; |
574 | } | 563 | } |
@@ -599,19 +588,19 @@ static int gsp_receive(struct garmin_data *garmin_data_p, | |||
599 | else | 588 | else |
600 | garmin_data_p->flags &= ~FLAGS_GSP_DLESEEN; | 589 | garmin_data_p->flags &= ~FLAGS_GSP_DLESEEN; |
601 | 590 | ||
602 | if (ack_or_nak_seen) | ||
603 | garmin_data_p->state = STATE_GSP_WAIT_DATA; | ||
604 | |||
605 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | 591 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); |
606 | 592 | ||
607 | if (ack_or_nak_seen) | 593 | if (ack_or_nak_seen) { |
608 | gsp_next_packet(garmin_data_p); | 594 | if (gsp_next_packet(garmin_data_p) > 0) |
595 | garmin_data_p->state = STATE_ACTIVE; | ||
596 | else | ||
597 | garmin_data_p->state = STATE_GSP_WAIT_DATA; | ||
598 | } | ||
609 | return count; | 599 | return count; |
610 | } | 600 | } |
611 | 601 | ||
612 | 602 | ||
613 | 603 | ||
614 | |||
615 | /* | 604 | /* |
616 | * Sends a usb packet to the tty | 605 | * Sends a usb packet to the tty |
617 | * | 606 | * |
@@ -733,29 +722,28 @@ static int gsp_send(struct garmin_data *garmin_data_p, | |||
733 | } | 722 | } |
734 | 723 | ||
735 | 724 | ||
736 | |||
737 | |||
738 | |||
739 | /* | 725 | /* |
740 | * Process the next pending data packet - if there is one | 726 | * Process the next pending data packet - if there is one |
741 | */ | 727 | */ |
742 | static void gsp_next_packet(struct garmin_data *garmin_data_p) | 728 | static int gsp_next_packet(struct garmin_data *garmin_data_p) |
743 | { | 729 | { |
730 | int result = 0; | ||
744 | struct garmin_packet *pkt = NULL; | 731 | struct garmin_packet *pkt = NULL; |
745 | 732 | ||
746 | while ((pkt = pkt_pop(garmin_data_p)) != NULL) { | 733 | while ((pkt = pkt_pop(garmin_data_p)) != NULL) { |
747 | dbg("%s - next pkt: %d", __func__, pkt->seq); | 734 | dbg("%s - next pkt: %d", __func__, pkt->seq); |
748 | if (gsp_send(garmin_data_p, pkt->data, pkt->size) > 0) { | 735 | result = gsp_send(garmin_data_p, pkt->data, pkt->size); |
736 | if (result > 0) { | ||
749 | kfree(pkt); | 737 | kfree(pkt); |
750 | return; | 738 | return result; |
751 | } | 739 | } |
752 | kfree(pkt); | 740 | kfree(pkt); |
753 | } | 741 | } |
742 | return result; | ||
754 | } | 743 | } |
755 | 744 | ||
756 | 745 | ||
757 | 746 | ||
758 | |||
759 | /****************************************************************************** | 747 | /****************************************************************************** |
760 | * garmin native mode | 748 | * garmin native mode |
761 | ******************************************************************************/ | 749 | ******************************************************************************/ |
@@ -888,14 +876,6 @@ static int garmin_clear(struct garmin_data *garmin_data_p) | |||
888 | unsigned long flags; | 876 | unsigned long flags; |
889 | int status = 0; | 877 | int status = 0; |
890 | 878 | ||
891 | struct usb_serial_port *port = garmin_data_p->port; | ||
892 | |||
893 | if (port != NULL && atomic_read(&garmin_data_p->resp_count)) { | ||
894 | /* send a terminate command */ | ||
895 | status = garmin_write_bulk(port, GARMIN_STOP_TRANSFER_REQ, | ||
896 | sizeof(GARMIN_STOP_TRANSFER_REQ), 1); | ||
897 | } | ||
898 | |||
899 | /* flush all queued data */ | 879 | /* flush all queued data */ |
900 | pkt_clear(garmin_data_p); | 880 | pkt_clear(garmin_data_p); |
901 | 881 | ||
@@ -908,16 +888,12 @@ static int garmin_clear(struct garmin_data *garmin_data_p) | |||
908 | } | 888 | } |
909 | 889 | ||
910 | 890 | ||
911 | |||
912 | |||
913 | |||
914 | |||
915 | static int garmin_init_session(struct usb_serial_port *port) | 891 | static int garmin_init_session(struct usb_serial_port *port) |
916 | { | 892 | { |
917 | unsigned long flags; | ||
918 | struct usb_serial *serial = port->serial; | 893 | struct usb_serial *serial = port->serial; |
919 | struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); | 894 | struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); |
920 | int status = 0; | 895 | int status = 0; |
896 | int i = 0; | ||
921 | 897 | ||
922 | if (status == 0) { | 898 | if (status == 0) { |
923 | usb_kill_urb(port->interrupt_in_urb); | 899 | usb_kill_urb(port->interrupt_in_urb); |
@@ -931,30 +907,25 @@ static int garmin_init_session(struct usb_serial_port *port) | |||
931 | __func__, status); | 907 | __func__, status); |
932 | } | 908 | } |
933 | 909 | ||
910 | /* | ||
911 | * using the initialization method from gpsbabel. See comments in | ||
912 | * gpsbabel/jeeps/gpslibusb.c gusb_reset_toggles() | ||
913 | */ | ||
934 | if (status == 0) { | 914 | if (status == 0) { |
935 | dbg("%s - starting session ...", __func__); | 915 | dbg("%s - starting session ...", __func__); |
936 | garmin_data_p->state = STATE_ACTIVE; | 916 | garmin_data_p->state = STATE_ACTIVE; |
937 | status = garmin_write_bulk(port, GARMIN_START_SESSION_REQ, | ||
938 | sizeof(GARMIN_START_SESSION_REQ), 0); | ||
939 | |||
940 | if (status >= 0) { | ||
941 | |||
942 | spin_lock_irqsave(&garmin_data_p->lock, flags); | ||
943 | garmin_data_p->ignorePkts++; | ||
944 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | ||
945 | 917 | ||
946 | /* not needed, but the win32 driver does it too ... */ | 918 | for (i = 0; i < 3; i++) { |
947 | status = garmin_write_bulk(port, | 919 | status = garmin_write_bulk(port, |
948 | GARMIN_START_SESSION_REQ2, | 920 | GARMIN_START_SESSION_REQ, |
949 | sizeof(GARMIN_START_SESSION_REQ2), 0); | 921 | sizeof(GARMIN_START_SESSION_REQ), 0); |
950 | if (status >= 0) { | 922 | |
951 | status = 0; | 923 | if (status < 0) |
952 | spin_lock_irqsave(&garmin_data_p->lock, flags); | 924 | break; |
953 | garmin_data_p->ignorePkts++; | ||
954 | spin_unlock_irqrestore(&garmin_data_p->lock, | ||
955 | flags); | ||
956 | } | ||
957 | } | 925 | } |
926 | |||
927 | if (status > 0) | ||
928 | status = 0; | ||
958 | } | 929 | } |
959 | 930 | ||
960 | return status; | 931 | return status; |
@@ -962,8 +933,6 @@ static int garmin_init_session(struct usb_serial_port *port) | |||
962 | 933 | ||
963 | 934 | ||
964 | 935 | ||
965 | |||
966 | |||
967 | static int garmin_open(struct tty_struct *tty, | 936 | static int garmin_open(struct tty_struct *tty, |
968 | struct usb_serial_port *port, struct file *filp) | 937 | struct usb_serial_port *port, struct file *filp) |
969 | { | 938 | { |
@@ -977,8 +946,6 @@ static int garmin_open(struct tty_struct *tty, | |||
977 | garmin_data_p->mode = initial_mode; | 946 | garmin_data_p->mode = initial_mode; |
978 | garmin_data_p->count = 0; | 947 | garmin_data_p->count = 0; |
979 | garmin_data_p->flags = 0; | 948 | garmin_data_p->flags = 0; |
980 | atomic_set(&garmin_data_p->req_count, 0); | ||
981 | atomic_set(&garmin_data_p->resp_count, 0); | ||
982 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | 949 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); |
983 | 950 | ||
984 | /* shutdown any bulk reads that might be going on */ | 951 | /* shutdown any bulk reads that might be going on */ |
@@ -1006,6 +973,7 @@ static void garmin_close(struct usb_serial_port *port) | |||
1006 | return; | 973 | return; |
1007 | 974 | ||
1008 | mutex_lock(&port->serial->disc_mutex); | 975 | mutex_lock(&port->serial->disc_mutex); |
976 | |||
1009 | if (!port->serial->disconnected) | 977 | if (!port->serial->disconnected) |
1010 | garmin_clear(garmin_data_p); | 978 | garmin_clear(garmin_data_p); |
1011 | 979 | ||
@@ -1013,25 +981,17 @@ static void garmin_close(struct usb_serial_port *port) | |||
1013 | usb_kill_urb(port->read_urb); | 981 | usb_kill_urb(port->read_urb); |
1014 | usb_kill_urb(port->write_urb); | 982 | usb_kill_urb(port->write_urb); |
1015 | 983 | ||
1016 | if (!port->serial->disconnected) { | 984 | /* keep reset state so we know that we must start a new session */ |
1017 | if (noResponseFromAppLayer(garmin_data_p) || | 985 | if (garmin_data_p->state != STATE_RESET) |
1018 | ((garmin_data_p->flags & CLEAR_HALT_REQUIRED) != 0)) { | ||
1019 | process_resetdev_request(port); | ||
1020 | garmin_data_p->state = STATE_RESET; | ||
1021 | } else { | ||
1022 | garmin_data_p->state = STATE_DISCONNECTED; | ||
1023 | } | ||
1024 | } else { | ||
1025 | garmin_data_p->state = STATE_DISCONNECTED; | 986 | garmin_data_p->state = STATE_DISCONNECTED; |
1026 | } | 987 | |
1027 | mutex_unlock(&port->serial->disc_mutex); | 988 | mutex_unlock(&port->serial->disc_mutex); |
1028 | } | 989 | } |
1029 | 990 | ||
991 | |||
1030 | static void garmin_write_bulk_callback(struct urb *urb) | 992 | static void garmin_write_bulk_callback(struct urb *urb) |
1031 | { | 993 | { |
1032 | unsigned long flags; | ||
1033 | struct usb_serial_port *port = urb->context; | 994 | struct usb_serial_port *port = urb->context; |
1034 | int status = urb->status; | ||
1035 | 995 | ||
1036 | if (port) { | 996 | if (port) { |
1037 | struct garmin_data *garmin_data_p = | 997 | struct garmin_data *garmin_data_p = |
@@ -1039,20 +999,13 @@ static void garmin_write_bulk_callback(struct urb *urb) | |||
1039 | 999 | ||
1040 | dbg("%s - port %d", __func__, port->number); | 1000 | dbg("%s - port %d", __func__, port->number); |
1041 | 1001 | ||
1042 | if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer) | 1002 | if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)) { |
1043 | && (garmin_data_p->mode == MODE_GARMIN_SERIAL)) { | ||
1044 | gsp_send_ack(garmin_data_p, | ||
1045 | ((__u8 *)urb->transfer_buffer)[4]); | ||
1046 | } | ||
1047 | 1003 | ||
1048 | if (status) { | 1004 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { |
1049 | dbg("%s - nonzero write bulk status received: %d", | 1005 | gsp_send_ack(garmin_data_p, |
1050 | __func__, status); | 1006 | ((__u8 *)urb->transfer_buffer)[4]); |
1051 | spin_lock_irqsave(&garmin_data_p->lock, flags); | 1007 | } |
1052 | garmin_data_p->flags |= CLEAR_HALT_REQUIRED; | ||
1053 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | ||
1054 | } | 1008 | } |
1055 | |||
1056 | usb_serial_port_softint(port); | 1009 | usb_serial_port_softint(port); |
1057 | } | 1010 | } |
1058 | 1011 | ||
@@ -1108,7 +1061,11 @@ static int garmin_write_bulk(struct usb_serial_port *port, | |||
1108 | urb->transfer_flags |= URB_ZERO_PACKET; | 1061 | urb->transfer_flags |= URB_ZERO_PACKET; |
1109 | 1062 | ||
1110 | if (GARMIN_LAYERID_APPL == getLayerId(buffer)) { | 1063 | if (GARMIN_LAYERID_APPL == getLayerId(buffer)) { |
1111 | atomic_inc(&garmin_data_p->req_count); | 1064 | |
1065 | spin_lock_irqsave(&garmin_data_p->lock, flags); | ||
1066 | garmin_data_p->flags |= APP_REQ_SEEN; | ||
1067 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | ||
1068 | |||
1112 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { | 1069 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { |
1113 | pkt_clear(garmin_data_p); | 1070 | pkt_clear(garmin_data_p); |
1114 | garmin_data_p->state = STATE_GSP_WAIT_DATA; | 1071 | garmin_data_p->state = STATE_GSP_WAIT_DATA; |
@@ -1140,6 +1097,9 @@ static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1140 | 1097 | ||
1141 | usb_serial_debug_data(debug, &port->dev, __func__, count, buf); | 1098 | usb_serial_debug_data(debug, &port->dev, __func__, count, buf); |
1142 | 1099 | ||
1100 | if (garmin_data_p->state == STATE_RESET) | ||
1101 | return -EIO; | ||
1102 | |||
1143 | /* check for our private packets */ | 1103 | /* check for our private packets */ |
1144 | if (count >= GARMIN_PKTHDR_LENGTH) { | 1104 | if (count >= GARMIN_PKTHDR_LENGTH) { |
1145 | len = PRIVPKTSIZ; | 1105 | len = PRIVPKTSIZ; |
@@ -1184,7 +1144,7 @@ static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1184 | break; | 1144 | break; |
1185 | 1145 | ||
1186 | case PRIV_PKTID_RESET_REQ: | 1146 | case PRIV_PKTID_RESET_REQ: |
1187 | atomic_inc(&garmin_data_p->req_count); | 1147 | process_resetdev_request(port); |
1188 | break; | 1148 | break; |
1189 | 1149 | ||
1190 | case PRIV_PKTID_SET_DEF_MODE: | 1150 | case PRIV_PKTID_SET_DEF_MODE: |
@@ -1200,8 +1160,6 @@ static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1200 | } | 1160 | } |
1201 | } | 1161 | } |
1202 | 1162 | ||
1203 | garmin_data_p->ignorePkts = 0; | ||
1204 | |||
1205 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { | 1163 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { |
1206 | return gsp_receive(garmin_data_p, buf, count); | 1164 | return gsp_receive(garmin_data_p, buf, count); |
1207 | } else { /* MODE_NATIVE */ | 1165 | } else { /* MODE_NATIVE */ |
@@ -1224,31 +1182,33 @@ static int garmin_write_room(struct tty_struct *tty) | |||
1224 | static void garmin_read_process(struct garmin_data *garmin_data_p, | 1182 | static void garmin_read_process(struct garmin_data *garmin_data_p, |
1225 | unsigned char *data, unsigned data_length) | 1183 | unsigned char *data, unsigned data_length) |
1226 | { | 1184 | { |
1185 | unsigned long flags; | ||
1186 | |||
1227 | if (garmin_data_p->flags & FLAGS_DROP_DATA) { | 1187 | if (garmin_data_p->flags & FLAGS_DROP_DATA) { |
1228 | /* abort-transfer cmd is actice */ | 1188 | /* abort-transfer cmd is actice */ |
1229 | dbg("%s - pkt dropped", __func__); | 1189 | dbg("%s - pkt dropped", __func__); |
1230 | } else if (garmin_data_p->state != STATE_DISCONNECTED && | 1190 | } else if (garmin_data_p->state != STATE_DISCONNECTED && |
1231 | garmin_data_p->state != STATE_RESET) { | 1191 | garmin_data_p->state != STATE_RESET) { |
1232 | 1192 | ||
1233 | /* remember any appl.layer packets, so we know | ||
1234 | if a reset is required or not when closing | ||
1235 | the device */ | ||
1236 | if (0 == memcmp(data, GARMIN_APP_LAYER_REPLY, | ||
1237 | sizeof(GARMIN_APP_LAYER_REPLY))) { | ||
1238 | atomic_inc(&garmin_data_p->resp_count); | ||
1239 | } | ||
1240 | |||
1241 | /* if throttling is active or postprecessing is required | 1193 | /* if throttling is active or postprecessing is required |
1242 | put the received data in the input queue, otherwise | 1194 | put the received data in the input queue, otherwise |
1243 | send it directly to the tty port */ | 1195 | send it directly to the tty port */ |
1244 | if (garmin_data_p->flags & FLAGS_QUEUING) { | 1196 | if (garmin_data_p->flags & FLAGS_QUEUING) { |
1245 | pkt_add(garmin_data_p, data, data_length); | 1197 | pkt_add(garmin_data_p, data, data_length); |
1246 | } else if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { | 1198 | } else if (getLayerId(data) == GARMIN_LAYERID_APPL) { |
1247 | if (getLayerId(data) == GARMIN_LAYERID_APPL) | 1199 | |
1200 | spin_lock_irqsave(&garmin_data_p->lock, flags); | ||
1201 | garmin_data_p->flags |= APP_RESP_SEEN; | ||
1202 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | ||
1203 | |||
1204 | if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { | ||
1248 | pkt_add(garmin_data_p, data, data_length); | 1205 | pkt_add(garmin_data_p, data, data_length); |
1249 | } else { | 1206 | } else { |
1250 | send_to_tty(garmin_data_p->port, data, data_length); | 1207 | send_to_tty(garmin_data_p->port, data, |
1208 | data_length); | ||
1209 | } | ||
1251 | } | 1210 | } |
1211 | /* ignore system layer packets ... */ | ||
1252 | } | 1212 | } |
1253 | } | 1213 | } |
1254 | 1214 | ||
@@ -1363,8 +1323,6 @@ static void garmin_read_int_callback(struct urb *urb) | |||
1363 | } else { | 1323 | } else { |
1364 | spin_lock_irqsave(&garmin_data_p->lock, flags); | 1324 | spin_lock_irqsave(&garmin_data_p->lock, flags); |
1365 | garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE; | 1325 | garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE; |
1366 | /* do not send this packet to the user */ | ||
1367 | garmin_data_p->ignorePkts = 1; | ||
1368 | spin_unlock_irqrestore(&garmin_data_p->lock, | 1326 | spin_unlock_irqrestore(&garmin_data_p->lock, |
1369 | flags); | 1327 | flags); |
1370 | } | 1328 | } |
@@ -1391,17 +1349,7 @@ static void garmin_read_int_callback(struct urb *urb) | |||
1391 | __func__, garmin_data_p->serial_num); | 1349 | __func__, garmin_data_p->serial_num); |
1392 | } | 1350 | } |
1393 | 1351 | ||
1394 | if (garmin_data_p->ignorePkts) { | 1352 | garmin_read_process(garmin_data_p, data, urb->actual_length); |
1395 | /* this reply belongs to a request generated by the driver, | ||
1396 | ignore it. */ | ||
1397 | dbg("%s - pkt ignored (%d)", | ||
1398 | __func__, garmin_data_p->ignorePkts); | ||
1399 | spin_lock_irqsave(&garmin_data_p->lock, flags); | ||
1400 | garmin_data_p->ignorePkts--; | ||
1401 | spin_unlock_irqrestore(&garmin_data_p->lock, flags); | ||
1402 | } else { | ||
1403 | garmin_read_process(garmin_data_p, data, urb->actual_length); | ||
1404 | } | ||
1405 | 1353 | ||
1406 | port->interrupt_in_urb->dev = port->serial->dev; | 1354 | port->interrupt_in_urb->dev = port->serial->dev; |
1407 | retval = usb_submit_urb(urb, GFP_ATOMIC); | 1355 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
@@ -1527,7 +1475,7 @@ static int garmin_attach(struct usb_serial *serial) | |||
1527 | } | 1475 | } |
1528 | 1476 | ||
1529 | 1477 | ||
1530 | static void garmin_shutdown(struct usb_serial *serial) | 1478 | static void garmin_disconnect(struct usb_serial *serial) |
1531 | { | 1479 | { |
1532 | struct usb_serial_port *port = serial->port[0]; | 1480 | struct usb_serial_port *port = serial->port[0]; |
1533 | struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); | 1481 | struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); |
@@ -1536,8 +1484,17 @@ static void garmin_shutdown(struct usb_serial *serial) | |||
1536 | 1484 | ||
1537 | usb_kill_urb(port->interrupt_in_urb); | 1485 | usb_kill_urb(port->interrupt_in_urb); |
1538 | del_timer_sync(&garmin_data_p->timer); | 1486 | del_timer_sync(&garmin_data_p->timer); |
1487 | } | ||
1488 | |||
1489 | |||
1490 | static void garmin_release(struct usb_serial *serial) | ||
1491 | { | ||
1492 | struct usb_serial_port *port = serial->port[0]; | ||
1493 | struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); | ||
1494 | |||
1495 | dbg("%s", __func__); | ||
1496 | |||
1539 | kfree(garmin_data_p); | 1497 | kfree(garmin_data_p); |
1540 | usb_set_serial_port_data(port, NULL); | ||
1541 | } | 1498 | } |
1542 | 1499 | ||
1543 | 1500 | ||
@@ -1556,7 +1513,8 @@ static struct usb_serial_driver garmin_device = { | |||
1556 | .throttle = garmin_throttle, | 1513 | .throttle = garmin_throttle, |
1557 | .unthrottle = garmin_unthrottle, | 1514 | .unthrottle = garmin_unthrottle, |
1558 | .attach = garmin_attach, | 1515 | .attach = garmin_attach, |
1559 | .shutdown = garmin_shutdown, | 1516 | .disconnect = garmin_disconnect, |
1517 | .release = garmin_release, | ||
1560 | .write = garmin_write, | 1518 | .write = garmin_write, |
1561 | .write_room = garmin_write_room, | 1519 | .write_room = garmin_write_room, |
1562 | .write_bulk_callback = garmin_write_bulk_callback, | 1520 | .write_bulk_callback = garmin_write_bulk_callback, |
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c index be82ea956720..932d6241b787 100644 --- a/drivers/usb/serial/generic.c +++ b/drivers/usb/serial/generic.c | |||
@@ -63,7 +63,8 @@ struct usb_serial_driver usb_serial_generic_device = { | |||
63 | .id_table = generic_device_ids, | 63 | .id_table = generic_device_ids, |
64 | .usb_driver = &generic_driver, | 64 | .usb_driver = &generic_driver, |
65 | .num_ports = 1, | 65 | .num_ports = 1, |
66 | .shutdown = usb_serial_generic_shutdown, | 66 | .disconnect = usb_serial_generic_disconnect, |
67 | .release = usb_serial_generic_release, | ||
67 | .throttle = usb_serial_generic_throttle, | 68 | .throttle = usb_serial_generic_throttle, |
68 | .unthrottle = usb_serial_generic_unthrottle, | 69 | .unthrottle = usb_serial_generic_unthrottle, |
69 | .resume = usb_serial_generic_resume, | 70 | .resume = usb_serial_generic_resume, |
@@ -190,6 +191,88 @@ void usb_serial_generic_close(struct usb_serial_port *port) | |||
190 | generic_cleanup(port); | 191 | generic_cleanup(port); |
191 | } | 192 | } |
192 | 193 | ||
194 | static int usb_serial_multi_urb_write(struct tty_struct *tty, | ||
195 | struct usb_serial_port *port, const unsigned char *buf, int count) | ||
196 | { | ||
197 | unsigned long flags; | ||
198 | struct urb *urb; | ||
199 | unsigned char *buffer; | ||
200 | int status; | ||
201 | int towrite; | ||
202 | int bwrite = 0; | ||
203 | |||
204 | dbg("%s - port %d", __func__, port->number); | ||
205 | |||
206 | if (count == 0) | ||
207 | dbg("%s - write request of 0 bytes", __func__); | ||
208 | |||
209 | while (count > 0) { | ||
210 | towrite = (count > port->bulk_out_size) ? | ||
211 | port->bulk_out_size : count; | ||
212 | spin_lock_irqsave(&port->lock, flags); | ||
213 | if (port->urbs_in_flight > | ||
214 | port->serial->type->max_in_flight_urbs) { | ||
215 | spin_unlock_irqrestore(&port->lock, flags); | ||
216 | dbg("%s - write limit hit\n", __func__); | ||
217 | return bwrite; | ||
218 | } | ||
219 | port->tx_bytes_flight += towrite; | ||
220 | port->urbs_in_flight++; | ||
221 | spin_unlock_irqrestore(&port->lock, flags); | ||
222 | |||
223 | buffer = kmalloc(towrite, GFP_ATOMIC); | ||
224 | if (!buffer) { | ||
225 | dev_err(&port->dev, | ||
226 | "%s ran out of kernel memory for urb ...\n", __func__); | ||
227 | goto error_no_buffer; | ||
228 | } | ||
229 | |||
230 | urb = usb_alloc_urb(0, GFP_ATOMIC); | ||
231 | if (!urb) { | ||
232 | dev_err(&port->dev, "%s - no more free urbs\n", | ||
233 | __func__); | ||
234 | goto error_no_urb; | ||
235 | } | ||
236 | |||
237 | /* Copy data */ | ||
238 | memcpy(buffer, buf + bwrite, towrite); | ||
239 | usb_serial_debug_data(debug, &port->dev, __func__, | ||
240 | towrite, buffer); | ||
241 | /* fill the buffer and send it */ | ||
242 | usb_fill_bulk_urb(urb, port->serial->dev, | ||
243 | usb_sndbulkpipe(port->serial->dev, | ||
244 | port->bulk_out_endpointAddress), | ||
245 | buffer, towrite, | ||
246 | usb_serial_generic_write_bulk_callback, port); | ||
247 | |||
248 | status = usb_submit_urb(urb, GFP_ATOMIC); | ||
249 | if (status) { | ||
250 | dev_err(&port->dev, | ||
251 | "%s - failed submitting write urb, error %d\n", | ||
252 | __func__, status); | ||
253 | goto error; | ||
254 | } | ||
255 | |||
256 | /* This urb is the responsibility of the host driver now */ | ||
257 | usb_free_urb(urb); | ||
258 | dbg("%s write: %d", __func__, towrite); | ||
259 | count -= towrite; | ||
260 | bwrite += towrite; | ||
261 | } | ||
262 | return bwrite; | ||
263 | |||
264 | error: | ||
265 | usb_free_urb(urb); | ||
266 | error_no_urb: | ||
267 | kfree(buffer); | ||
268 | error_no_buffer: | ||
269 | spin_lock_irqsave(&port->lock, flags); | ||
270 | port->urbs_in_flight--; | ||
271 | port->tx_bytes_flight -= towrite; | ||
272 | spin_unlock_irqrestore(&port->lock, flags); | ||
273 | return bwrite; | ||
274 | } | ||
275 | |||
193 | int usb_serial_generic_write(struct tty_struct *tty, | 276 | int usb_serial_generic_write(struct tty_struct *tty, |
194 | struct usb_serial_port *port, const unsigned char *buf, int count) | 277 | struct usb_serial_port *port, const unsigned char *buf, int count) |
195 | { | 278 | { |
@@ -207,6 +290,11 @@ int usb_serial_generic_write(struct tty_struct *tty, | |||
207 | /* only do something if we have a bulk out endpoint */ | 290 | /* only do something if we have a bulk out endpoint */ |
208 | if (serial->num_bulk_out) { | 291 | if (serial->num_bulk_out) { |
209 | unsigned long flags; | 292 | unsigned long flags; |
293 | |||
294 | if (serial->type->max_in_flight_urbs) | ||
295 | return usb_serial_multi_urb_write(tty, port, | ||
296 | buf, count); | ||
297 | |||
210 | spin_lock_irqsave(&port->lock, flags); | 298 | spin_lock_irqsave(&port->lock, flags); |
211 | if (port->write_urb_busy) { | 299 | if (port->write_urb_busy) { |
212 | spin_unlock_irqrestore(&port->lock, flags); | 300 | spin_unlock_irqrestore(&port->lock, flags); |
@@ -252,20 +340,26 @@ int usb_serial_generic_write(struct tty_struct *tty, | |||
252 | /* no bulk out, so return 0 bytes written */ | 340 | /* no bulk out, so return 0 bytes written */ |
253 | return 0; | 341 | return 0; |
254 | } | 342 | } |
343 | EXPORT_SYMBOL_GPL(usb_serial_generic_write); | ||
255 | 344 | ||
256 | int usb_serial_generic_write_room(struct tty_struct *tty) | 345 | int usb_serial_generic_write_room(struct tty_struct *tty) |
257 | { | 346 | { |
258 | struct usb_serial_port *port = tty->driver_data; | 347 | struct usb_serial_port *port = tty->driver_data; |
259 | struct usb_serial *serial = port->serial; | 348 | struct usb_serial *serial = port->serial; |
349 | unsigned long flags; | ||
260 | int room = 0; | 350 | int room = 0; |
261 | 351 | ||
262 | dbg("%s - port %d", __func__, port->number); | 352 | dbg("%s - port %d", __func__, port->number); |
263 | 353 | spin_lock_irqsave(&port->lock, flags); | |
264 | /* FIXME: Locking */ | 354 | if (serial->type->max_in_flight_urbs) { |
265 | if (serial->num_bulk_out) { | 355 | if (port->urbs_in_flight < serial->type->max_in_flight_urbs) |
266 | if (!(port->write_urb_busy)) | 356 | room = port->bulk_out_size * |
267 | room = port->bulk_out_size; | 357 | (serial->type->max_in_flight_urbs - |
358 | port->urbs_in_flight); | ||
359 | } else if (serial->num_bulk_out && !(port->write_urb_busy)) { | ||
360 | room = port->bulk_out_size; | ||
268 | } | 361 | } |
362 | spin_unlock_irqrestore(&port->lock, flags); | ||
269 | 363 | ||
270 | dbg("%s - returns %d", __func__, room); | 364 | dbg("%s - returns %d", __func__, room); |
271 | return room; | 365 | return room; |
@@ -276,11 +370,16 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty) | |||
276 | struct usb_serial_port *port = tty->driver_data; | 370 | struct usb_serial_port *port = tty->driver_data; |
277 | struct usb_serial *serial = port->serial; | 371 | struct usb_serial *serial = port->serial; |
278 | int chars = 0; | 372 | int chars = 0; |
373 | unsigned long flags; | ||
279 | 374 | ||
280 | dbg("%s - port %d", __func__, port->number); | 375 | dbg("%s - port %d", __func__, port->number); |
281 | 376 | ||
282 | /* FIXME: Locking */ | 377 | if (serial->type->max_in_flight_urbs) { |
283 | if (serial->num_bulk_out) { | 378 | spin_lock_irqsave(&port->lock, flags); |
379 | chars = port->tx_bytes_flight; | ||
380 | spin_unlock_irqrestore(&port->lock, flags); | ||
381 | } else if (serial->num_bulk_out) { | ||
382 | /* FIXME: Locking */ | ||
284 | if (port->write_urb_busy) | 383 | if (port->write_urb_busy) |
285 | chars = port->write_urb->transfer_buffer_length; | 384 | chars = port->write_urb->transfer_buffer_length; |
286 | } | 385 | } |
@@ -290,7 +389,8 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty) | |||
290 | } | 389 | } |
291 | 390 | ||
292 | 391 | ||
293 | static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags) | 392 | void usb_serial_generic_resubmit_read_urb(struct usb_serial_port *port, |
393 | gfp_t mem_flags) | ||
294 | { | 394 | { |
295 | struct urb *urb = port->read_urb; | 395 | struct urb *urb = port->read_urb; |
296 | struct usb_serial *serial = port->serial; | 396 | struct usb_serial *serial = port->serial; |
@@ -311,25 +411,28 @@ static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags) | |||
311 | "%s - failed resubmitting read urb, error %d\n", | 411 | "%s - failed resubmitting read urb, error %d\n", |
312 | __func__, result); | 412 | __func__, result); |
313 | } | 413 | } |
414 | EXPORT_SYMBOL_GPL(usb_serial_generic_resubmit_read_urb); | ||
314 | 415 | ||
315 | /* Push data to tty layer and resubmit the bulk read URB */ | 416 | /* Push data to tty layer and resubmit the bulk read URB */ |
316 | static void flush_and_resubmit_read_urb(struct usb_serial_port *port) | 417 | static void flush_and_resubmit_read_urb(struct usb_serial_port *port) |
317 | { | 418 | { |
318 | struct urb *urb = port->read_urb; | 419 | struct urb *urb = port->read_urb; |
319 | struct tty_struct *tty = tty_port_tty_get(&port->port); | 420 | struct tty_struct *tty = tty_port_tty_get(&port->port); |
320 | int room; | 421 | char *ch = (char *)urb->transfer_buffer; |
422 | int i; | ||
423 | |||
424 | if (!tty) | ||
425 | goto done; | ||
321 | 426 | ||
322 | /* Push data to tty */ | 427 | /* Push data to tty */ |
323 | if (tty && urb->actual_length) { | 428 | for (i = 0; i < urb->actual_length; i++, ch++) { |
324 | room = tty_buffer_request_room(tty, urb->actual_length); | 429 | if (!usb_serial_handle_sysrq_char(port, *ch)) |
325 | if (room) { | 430 | tty_insert_flip_char(tty, *ch, TTY_NORMAL); |
326 | tty_insert_flip_string(tty, urb->transfer_buffer, room); | ||
327 | tty_flip_buffer_push(tty); | ||
328 | } | ||
329 | } | 431 | } |
432 | tty_flip_buffer_push(tty); | ||
330 | tty_kref_put(tty); | 433 | tty_kref_put(tty); |
331 | 434 | done: | |
332 | resubmit_read_urb(port, GFP_ATOMIC); | 435 | usb_serial_generic_resubmit_read_urb(port, GFP_ATOMIC); |
333 | } | 436 | } |
334 | 437 | ||
335 | void usb_serial_generic_read_bulk_callback(struct urb *urb) | 438 | void usb_serial_generic_read_bulk_callback(struct urb *urb) |
@@ -363,12 +466,24 @@ EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback); | |||
363 | 466 | ||
364 | void usb_serial_generic_write_bulk_callback(struct urb *urb) | 467 | void usb_serial_generic_write_bulk_callback(struct urb *urb) |
365 | { | 468 | { |
469 | unsigned long flags; | ||
366 | struct usb_serial_port *port = urb->context; | 470 | struct usb_serial_port *port = urb->context; |
367 | int status = urb->status; | 471 | int status = urb->status; |
368 | 472 | ||
369 | dbg("%s - port %d", __func__, port->number); | 473 | dbg("%s - port %d", __func__, port->number); |
370 | 474 | ||
371 | port->write_urb_busy = 0; | 475 | if (port->serial->type->max_in_flight_urbs) { |
476 | spin_lock_irqsave(&port->lock, flags); | ||
477 | --port->urbs_in_flight; | ||
478 | port->tx_bytes_flight -= urb->transfer_buffer_length; | ||
479 | if (port->urbs_in_flight < 0) | ||
480 | port->urbs_in_flight = 0; | ||
481 | spin_unlock_irqrestore(&port->lock, flags); | ||
482 | } else { | ||
483 | /* Handle the case for single urb mode */ | ||
484 | port->write_urb_busy = 0; | ||
485 | } | ||
486 | |||
372 | if (status) { | 487 | if (status) { |
373 | dbg("%s - nonzero write bulk status received: %d", | 488 | dbg("%s - nonzero write bulk status received: %d", |
374 | __func__, status); | 489 | __func__, status); |
@@ -408,11 +523,36 @@ void usb_serial_generic_unthrottle(struct tty_struct *tty) | |||
408 | 523 | ||
409 | if (was_throttled) { | 524 | if (was_throttled) { |
410 | /* Resume reading from device */ | 525 | /* Resume reading from device */ |
411 | resubmit_read_urb(port, GFP_KERNEL); | 526 | usb_serial_generic_resubmit_read_urb(port, GFP_KERNEL); |
527 | } | ||
528 | } | ||
529 | |||
530 | int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch) | ||
531 | { | ||
532 | if (port->sysrq && port->console) { | ||
533 | if (ch && time_before(jiffies, port->sysrq)) { | ||
534 | handle_sysrq(ch, tty_port_tty_get(&port->port)); | ||
535 | port->sysrq = 0; | ||
536 | return 1; | ||
537 | } | ||
538 | port->sysrq = 0; | ||
539 | } | ||
540 | return 0; | ||
541 | } | ||
542 | EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char); | ||
543 | |||
544 | int usb_serial_handle_break(struct usb_serial_port *port) | ||
545 | { | ||
546 | if (!port->sysrq) { | ||
547 | port->sysrq = jiffies + HZ*5; | ||
548 | return 1; | ||
412 | } | 549 | } |
550 | port->sysrq = 0; | ||
551 | return 0; | ||
413 | } | 552 | } |
553 | EXPORT_SYMBOL_GPL(usb_serial_handle_break); | ||
414 | 554 | ||
415 | void usb_serial_generic_shutdown(struct usb_serial *serial) | 555 | void usb_serial_generic_disconnect(struct usb_serial *serial) |
416 | { | 556 | { |
417 | int i; | 557 | int i; |
418 | 558 | ||
@@ -423,3 +563,7 @@ void usb_serial_generic_shutdown(struct usb_serial *serial) | |||
423 | generic_cleanup(serial->port[i]); | 563 | generic_cleanup(serial->port[i]); |
424 | } | 564 | } |
425 | 565 | ||
566 | void usb_serial_generic_release(struct usb_serial *serial) | ||
567 | { | ||
568 | dbg("%s", __func__); | ||
569 | } | ||
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c index 53ef5996e33d..0191693625d6 100644 --- a/drivers/usb/serial/io_edgeport.c +++ b/drivers/usb/serial/io_edgeport.c | |||
@@ -224,7 +224,8 @@ static int edge_tiocmget(struct tty_struct *tty, struct file *file); | |||
224 | static int edge_tiocmset(struct tty_struct *tty, struct file *file, | 224 | static int edge_tiocmset(struct tty_struct *tty, struct file *file, |
225 | unsigned int set, unsigned int clear); | 225 | unsigned int set, unsigned int clear); |
226 | static int edge_startup(struct usb_serial *serial); | 226 | static int edge_startup(struct usb_serial *serial); |
227 | static void edge_shutdown(struct usb_serial *serial); | 227 | static void edge_disconnect(struct usb_serial *serial); |
228 | static void edge_release(struct usb_serial *serial); | ||
228 | 229 | ||
229 | #include "io_tables.h" /* all of the devices that this driver supports */ | 230 | #include "io_tables.h" /* all of the devices that this driver supports */ |
230 | 231 | ||
@@ -3193,21 +3194,16 @@ static int edge_startup(struct usb_serial *serial) | |||
3193 | 3194 | ||
3194 | 3195 | ||
3195 | /**************************************************************************** | 3196 | /**************************************************************************** |
3196 | * edge_shutdown | 3197 | * edge_disconnect |
3197 | * This function is called whenever the device is removed from the usb bus. | 3198 | * This function is called whenever the device is removed from the usb bus. |
3198 | ****************************************************************************/ | 3199 | ****************************************************************************/ |
3199 | static void edge_shutdown(struct usb_serial *serial) | 3200 | static void edge_disconnect(struct usb_serial *serial) |
3200 | { | 3201 | { |
3201 | struct edgeport_serial *edge_serial = usb_get_serial_data(serial); | 3202 | struct edgeport_serial *edge_serial = usb_get_serial_data(serial); |
3202 | int i; | ||
3203 | 3203 | ||
3204 | dbg("%s", __func__); | 3204 | dbg("%s", __func__); |
3205 | 3205 | ||
3206 | /* stop reads and writes on all ports */ | 3206 | /* stop reads and writes on all ports */ |
3207 | for (i = 0; i < serial->num_ports; ++i) { | ||
3208 | kfree(usb_get_serial_port_data(serial->port[i])); | ||
3209 | usb_set_serial_port_data(serial->port[i], NULL); | ||
3210 | } | ||
3211 | /* free up our endpoint stuff */ | 3207 | /* free up our endpoint stuff */ |
3212 | if (edge_serial->is_epic) { | 3208 | if (edge_serial->is_epic) { |
3213 | usb_kill_urb(edge_serial->interrupt_read_urb); | 3209 | usb_kill_urb(edge_serial->interrupt_read_urb); |
@@ -3218,9 +3214,24 @@ static void edge_shutdown(struct usb_serial *serial) | |||
3218 | usb_free_urb(edge_serial->read_urb); | 3214 | usb_free_urb(edge_serial->read_urb); |
3219 | kfree(edge_serial->bulk_in_buffer); | 3215 | kfree(edge_serial->bulk_in_buffer); |
3220 | } | 3216 | } |
3217 | } | ||
3218 | |||
3219 | |||
3220 | /**************************************************************************** | ||
3221 | * edge_release | ||
3222 | * This function is called when the device structure is deallocated. | ||
3223 | ****************************************************************************/ | ||
3224 | static void edge_release(struct usb_serial *serial) | ||
3225 | { | ||
3226 | struct edgeport_serial *edge_serial = usb_get_serial_data(serial); | ||
3227 | int i; | ||
3228 | |||
3229 | dbg("%s", __func__); | ||
3230 | |||
3231 | for (i = 0; i < serial->num_ports; ++i) | ||
3232 | kfree(usb_get_serial_port_data(serial->port[i])); | ||
3221 | 3233 | ||
3222 | kfree(edge_serial); | 3234 | kfree(edge_serial); |
3223 | usb_set_serial_data(serial, NULL); | ||
3224 | } | 3235 | } |
3225 | 3236 | ||
3226 | 3237 | ||
diff --git a/drivers/usb/serial/io_tables.h b/drivers/usb/serial/io_tables.h index 7eb9d67b81b6..9241d3147513 100644 --- a/drivers/usb/serial/io_tables.h +++ b/drivers/usb/serial/io_tables.h | |||
@@ -117,7 +117,8 @@ static struct usb_serial_driver edgeport_2port_device = { | |||
117 | .throttle = edge_throttle, | 117 | .throttle = edge_throttle, |
118 | .unthrottle = edge_unthrottle, | 118 | .unthrottle = edge_unthrottle, |
119 | .attach = edge_startup, | 119 | .attach = edge_startup, |
120 | .shutdown = edge_shutdown, | 120 | .disconnect = edge_disconnect, |
121 | .release = edge_release, | ||
121 | .ioctl = edge_ioctl, | 122 | .ioctl = edge_ioctl, |
122 | .set_termios = edge_set_termios, | 123 | .set_termios = edge_set_termios, |
123 | .tiocmget = edge_tiocmget, | 124 | .tiocmget = edge_tiocmget, |
@@ -145,7 +146,8 @@ static struct usb_serial_driver edgeport_4port_device = { | |||
145 | .throttle = edge_throttle, | 146 | .throttle = edge_throttle, |
146 | .unthrottle = edge_unthrottle, | 147 | .unthrottle = edge_unthrottle, |
147 | .attach = edge_startup, | 148 | .attach = edge_startup, |
148 | .shutdown = edge_shutdown, | 149 | .disconnect = edge_disconnect, |
150 | .release = edge_release, | ||
149 | .ioctl = edge_ioctl, | 151 | .ioctl = edge_ioctl, |
150 | .set_termios = edge_set_termios, | 152 | .set_termios = edge_set_termios, |
151 | .tiocmget = edge_tiocmget, | 153 | .tiocmget = edge_tiocmget, |
@@ -173,7 +175,8 @@ static struct usb_serial_driver edgeport_8port_device = { | |||
173 | .throttle = edge_throttle, | 175 | .throttle = edge_throttle, |
174 | .unthrottle = edge_unthrottle, | 176 | .unthrottle = edge_unthrottle, |
175 | .attach = edge_startup, | 177 | .attach = edge_startup, |
176 | .shutdown = edge_shutdown, | 178 | .disconnect = edge_disconnect, |
179 | .release = edge_release, | ||
177 | .ioctl = edge_ioctl, | 180 | .ioctl = edge_ioctl, |
178 | .set_termios = edge_set_termios, | 181 | .set_termios = edge_set_termios, |
179 | .tiocmget = edge_tiocmget, | 182 | .tiocmget = edge_tiocmget, |
@@ -200,7 +203,8 @@ static struct usb_serial_driver epic_device = { | |||
200 | .throttle = edge_throttle, | 203 | .throttle = edge_throttle, |
201 | .unthrottle = edge_unthrottle, | 204 | .unthrottle = edge_unthrottle, |
202 | .attach = edge_startup, | 205 | .attach = edge_startup, |
203 | .shutdown = edge_shutdown, | 206 | .disconnect = edge_disconnect, |
207 | .release = edge_release, | ||
204 | .ioctl = edge_ioctl, | 208 | .ioctl = edge_ioctl, |
205 | .set_termios = edge_set_termios, | 209 | .set_termios = edge_set_termios, |
206 | .tiocmget = edge_tiocmget, | 210 | .tiocmget = edge_tiocmget, |
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c index db964db42d3c..e8bc42f92e79 100644 --- a/drivers/usb/serial/io_ti.c +++ b/drivers/usb/serial/io_ti.c | |||
@@ -2663,7 +2663,7 @@ cleanup: | |||
2663 | return -ENOMEM; | 2663 | return -ENOMEM; |
2664 | } | 2664 | } |
2665 | 2665 | ||
2666 | static void edge_shutdown(struct usb_serial *serial) | 2666 | static void edge_disconnect(struct usb_serial *serial) |
2667 | { | 2667 | { |
2668 | int i; | 2668 | int i; |
2669 | struct edgeport_port *edge_port; | 2669 | struct edgeport_port *edge_port; |
@@ -2673,12 +2673,22 @@ static void edge_shutdown(struct usb_serial *serial) | |||
2673 | for (i = 0; i < serial->num_ports; ++i) { | 2673 | for (i = 0; i < serial->num_ports; ++i) { |
2674 | edge_port = usb_get_serial_port_data(serial->port[i]); | 2674 | edge_port = usb_get_serial_port_data(serial->port[i]); |
2675 | edge_remove_sysfs_attrs(edge_port->port); | 2675 | edge_remove_sysfs_attrs(edge_port->port); |
2676 | } | ||
2677 | } | ||
2678 | |||
2679 | static void edge_release(struct usb_serial *serial) | ||
2680 | { | ||
2681 | int i; | ||
2682 | struct edgeport_port *edge_port; | ||
2683 | |||
2684 | dbg("%s", __func__); | ||
2685 | |||
2686 | for (i = 0; i < serial->num_ports; ++i) { | ||
2687 | edge_port = usb_get_serial_port_data(serial->port[i]); | ||
2676 | edge_buf_free(edge_port->ep_out_buf); | 2688 | edge_buf_free(edge_port->ep_out_buf); |
2677 | kfree(edge_port); | 2689 | kfree(edge_port); |
2678 | usb_set_serial_port_data(serial->port[i], NULL); | ||
2679 | } | 2690 | } |
2680 | kfree(usb_get_serial_data(serial)); | 2691 | kfree(usb_get_serial_data(serial)); |
2681 | usb_set_serial_data(serial, NULL); | ||
2682 | } | 2692 | } |
2683 | 2693 | ||
2684 | 2694 | ||
@@ -2915,7 +2925,8 @@ static struct usb_serial_driver edgeport_1port_device = { | |||
2915 | .throttle = edge_throttle, | 2925 | .throttle = edge_throttle, |
2916 | .unthrottle = edge_unthrottle, | 2926 | .unthrottle = edge_unthrottle, |
2917 | .attach = edge_startup, | 2927 | .attach = edge_startup, |
2918 | .shutdown = edge_shutdown, | 2928 | .disconnect = edge_disconnect, |
2929 | .release = edge_release, | ||
2919 | .port_probe = edge_create_sysfs_attrs, | 2930 | .port_probe = edge_create_sysfs_attrs, |
2920 | .ioctl = edge_ioctl, | 2931 | .ioctl = edge_ioctl, |
2921 | .set_termios = edge_set_termios, | 2932 | .set_termios = edge_set_termios, |
@@ -2944,7 +2955,8 @@ static struct usb_serial_driver edgeport_2port_device = { | |||
2944 | .throttle = edge_throttle, | 2955 | .throttle = edge_throttle, |
2945 | .unthrottle = edge_unthrottle, | 2956 | .unthrottle = edge_unthrottle, |
2946 | .attach = edge_startup, | 2957 | .attach = edge_startup, |
2947 | .shutdown = edge_shutdown, | 2958 | .disconnect = edge_disconnect, |
2959 | .release = edge_release, | ||
2948 | .port_probe = edge_create_sysfs_attrs, | 2960 | .port_probe = edge_create_sysfs_attrs, |
2949 | .ioctl = edge_ioctl, | 2961 | .ioctl = edge_ioctl, |
2950 | .set_termios = edge_set_termios, | 2962 | .set_termios = edge_set_termios, |
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c index c610a99fa477..2545d45ce16f 100644 --- a/drivers/usb/serial/ipaq.c +++ b/drivers/usb/serial/ipaq.c | |||
@@ -79,7 +79,6 @@ static int ipaq_open(struct tty_struct *tty, | |||
79 | static void ipaq_close(struct usb_serial_port *port); | 79 | static void ipaq_close(struct usb_serial_port *port); |
80 | static int ipaq_calc_num_ports(struct usb_serial *serial); | 80 | static int ipaq_calc_num_ports(struct usb_serial *serial); |
81 | static int ipaq_startup(struct usb_serial *serial); | 81 | static int ipaq_startup(struct usb_serial *serial); |
82 | static void ipaq_shutdown(struct usb_serial *serial); | ||
83 | static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port, | 82 | static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port, |
84 | const unsigned char *buf, int count); | 83 | const unsigned char *buf, int count); |
85 | static int ipaq_write_bulk(struct usb_serial_port *port, | 84 | static int ipaq_write_bulk(struct usb_serial_port *port, |
@@ -576,7 +575,6 @@ static struct usb_serial_driver ipaq_device = { | |||
576 | .close = ipaq_close, | 575 | .close = ipaq_close, |
577 | .attach = ipaq_startup, | 576 | .attach = ipaq_startup, |
578 | .calc_num_ports = ipaq_calc_num_ports, | 577 | .calc_num_ports = ipaq_calc_num_ports, |
579 | .shutdown = ipaq_shutdown, | ||
580 | .write = ipaq_write, | 578 | .write = ipaq_write, |
581 | .write_room = ipaq_write_room, | 579 | .write_room = ipaq_write_room, |
582 | .chars_in_buffer = ipaq_chars_in_buffer, | 580 | .chars_in_buffer = ipaq_chars_in_buffer, |
@@ -990,11 +988,6 @@ static int ipaq_startup(struct usb_serial *serial) | |||
990 | return usb_reset_configuration(serial->dev); | 988 | return usb_reset_configuration(serial->dev); |
991 | } | 989 | } |
992 | 990 | ||
993 | static void ipaq_shutdown(struct usb_serial *serial) | ||
994 | { | ||
995 | dbg("%s", __func__); | ||
996 | } | ||
997 | |||
998 | static int __init ipaq_init(void) | 991 | static int __init ipaq_init(void) |
999 | { | 992 | { |
1000 | int retval; | 993 | int retval; |
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c index 76a3cc327bb9..96873a7a32b0 100644 --- a/drivers/usb/serial/iuu_phoenix.c +++ b/drivers/usb/serial/iuu_phoenix.c | |||
@@ -121,8 +121,8 @@ static int iuu_startup(struct usb_serial *serial) | |||
121 | return 0; | 121 | return 0; |
122 | } | 122 | } |
123 | 123 | ||
124 | /* Shutdown function */ | 124 | /* Release function */ |
125 | static void iuu_shutdown(struct usb_serial *serial) | 125 | static void iuu_release(struct usb_serial *serial) |
126 | { | 126 | { |
127 | struct usb_serial_port *port = serial->port[0]; | 127 | struct usb_serial_port *port = serial->port[0]; |
128 | struct iuu_private *priv = usb_get_serial_port_data(port); | 128 | struct iuu_private *priv = usb_get_serial_port_data(port); |
@@ -1202,7 +1202,7 @@ static struct usb_serial_driver iuu_device = { | |||
1202 | .tiocmset = iuu_tiocmset, | 1202 | .tiocmset = iuu_tiocmset, |
1203 | .set_termios = iuu_set_termios, | 1203 | .set_termios = iuu_set_termios, |
1204 | .attach = iuu_startup, | 1204 | .attach = iuu_startup, |
1205 | .shutdown = iuu_shutdown, | 1205 | .release = iuu_release, |
1206 | }; | 1206 | }; |
1207 | 1207 | ||
1208 | static int __init iuu_init(void) | 1208 | static int __init iuu_init(void) |
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c index f1195a98f316..2594b8743d3f 100644 --- a/drivers/usb/serial/keyspan.c +++ b/drivers/usb/serial/keyspan.c | |||
@@ -2689,7 +2689,7 @@ static int keyspan_startup(struct usb_serial *serial) | |||
2689 | return 0; | 2689 | return 0; |
2690 | } | 2690 | } |
2691 | 2691 | ||
2692 | static void keyspan_shutdown(struct usb_serial *serial) | 2692 | static void keyspan_disconnect(struct usb_serial *serial) |
2693 | { | 2693 | { |
2694 | int i, j; | 2694 | int i, j; |
2695 | struct usb_serial_port *port; | 2695 | struct usb_serial_port *port; |
@@ -2729,6 +2729,17 @@ static void keyspan_shutdown(struct usb_serial *serial) | |||
2729 | usb_free_urb(p_priv->out_urbs[j]); | 2729 | usb_free_urb(p_priv->out_urbs[j]); |
2730 | } | 2730 | } |
2731 | } | 2731 | } |
2732 | } | ||
2733 | |||
2734 | static void keyspan_release(struct usb_serial *serial) | ||
2735 | { | ||
2736 | int i; | ||
2737 | struct usb_serial_port *port; | ||
2738 | struct keyspan_serial_private *s_priv; | ||
2739 | |||
2740 | dbg("%s", __func__); | ||
2741 | |||
2742 | s_priv = usb_get_serial_data(serial); | ||
2732 | 2743 | ||
2733 | /* dbg("Freeing serial->private."); */ | 2744 | /* dbg("Freeing serial->private."); */ |
2734 | kfree(s_priv); | 2745 | kfree(s_priv); |
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h index 0d4569b60768..3107ed15af64 100644 --- a/drivers/usb/serial/keyspan.h +++ b/drivers/usb/serial/keyspan.h | |||
@@ -41,7 +41,8 @@ static int keyspan_open (struct tty_struct *tty, | |||
41 | static void keyspan_close (struct usb_serial_port *port); | 41 | static void keyspan_close (struct usb_serial_port *port); |
42 | static void keyspan_dtr_rts (struct usb_serial_port *port, int on); | 42 | static void keyspan_dtr_rts (struct usb_serial_port *port, int on); |
43 | static int keyspan_startup (struct usb_serial *serial); | 43 | static int keyspan_startup (struct usb_serial *serial); |
44 | static void keyspan_shutdown (struct usb_serial *serial); | 44 | static void keyspan_disconnect (struct usb_serial *serial); |
45 | static void keyspan_release (struct usb_serial *serial); | ||
45 | static int keyspan_write_room (struct tty_struct *tty); | 46 | static int keyspan_write_room (struct tty_struct *tty); |
46 | 47 | ||
47 | static int keyspan_write (struct tty_struct *tty, | 48 | static int keyspan_write (struct tty_struct *tty, |
@@ -569,7 +570,8 @@ static struct usb_serial_driver keyspan_1port_device = { | |||
569 | .tiocmget = keyspan_tiocmget, | 570 | .tiocmget = keyspan_tiocmget, |
570 | .tiocmset = keyspan_tiocmset, | 571 | .tiocmset = keyspan_tiocmset, |
571 | .attach = keyspan_startup, | 572 | .attach = keyspan_startup, |
572 | .shutdown = keyspan_shutdown, | 573 | .disconnect = keyspan_disconnect, |
574 | .release = keyspan_release, | ||
573 | }; | 575 | }; |
574 | 576 | ||
575 | static struct usb_serial_driver keyspan_2port_device = { | 577 | static struct usb_serial_driver keyspan_2port_device = { |
@@ -590,7 +592,8 @@ static struct usb_serial_driver keyspan_2port_device = { | |||
590 | .tiocmget = keyspan_tiocmget, | 592 | .tiocmget = keyspan_tiocmget, |
591 | .tiocmset = keyspan_tiocmset, | 593 | .tiocmset = keyspan_tiocmset, |
592 | .attach = keyspan_startup, | 594 | .attach = keyspan_startup, |
593 | .shutdown = keyspan_shutdown, | 595 | .disconnect = keyspan_disconnect, |
596 | .release = keyspan_release, | ||
594 | }; | 597 | }; |
595 | 598 | ||
596 | static struct usb_serial_driver keyspan_4port_device = { | 599 | static struct usb_serial_driver keyspan_4port_device = { |
@@ -611,7 +614,8 @@ static struct usb_serial_driver keyspan_4port_device = { | |||
611 | .tiocmget = keyspan_tiocmget, | 614 | .tiocmget = keyspan_tiocmget, |
612 | .tiocmset = keyspan_tiocmset, | 615 | .tiocmset = keyspan_tiocmset, |
613 | .attach = keyspan_startup, | 616 | .attach = keyspan_startup, |
614 | .shutdown = keyspan_shutdown, | 617 | .disconnect = keyspan_disconnect, |
618 | .release = keyspan_release, | ||
615 | }; | 619 | }; |
616 | 620 | ||
617 | #endif | 621 | #endif |
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c index ab769dbea1b3..d0b12e40c2b1 100644 --- a/drivers/usb/serial/keyspan_pda.c +++ b/drivers/usb/serial/keyspan_pda.c | |||
@@ -809,7 +809,7 @@ static int keyspan_pda_startup(struct usb_serial *serial) | |||
809 | return 0; | 809 | return 0; |
810 | } | 810 | } |
811 | 811 | ||
812 | static void keyspan_pda_shutdown(struct usb_serial *serial) | 812 | static void keyspan_pda_release(struct usb_serial *serial) |
813 | { | 813 | { |
814 | dbg("%s", __func__); | 814 | dbg("%s", __func__); |
815 | 815 | ||
@@ -869,7 +869,7 @@ static struct usb_serial_driver keyspan_pda_device = { | |||
869 | .tiocmget = keyspan_pda_tiocmget, | 869 | .tiocmget = keyspan_pda_tiocmget, |
870 | .tiocmset = keyspan_pda_tiocmset, | 870 | .tiocmset = keyspan_pda_tiocmset, |
871 | .attach = keyspan_pda_startup, | 871 | .attach = keyspan_pda_startup, |
872 | .shutdown = keyspan_pda_shutdown, | 872 | .release = keyspan_pda_release, |
873 | }; | 873 | }; |
874 | 874 | ||
875 | 875 | ||
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c index fa817c66b3e8..0f44bb8e8d4f 100644 --- a/drivers/usb/serial/kl5kusb105.c +++ b/drivers/usb/serial/kl5kusb105.c | |||
@@ -73,7 +73,8 @@ static int debug; | |||
73 | * Function prototypes | 73 | * Function prototypes |
74 | */ | 74 | */ |
75 | static int klsi_105_startup(struct usb_serial *serial); | 75 | static int klsi_105_startup(struct usb_serial *serial); |
76 | static void klsi_105_shutdown(struct usb_serial *serial); | 76 | static void klsi_105_disconnect(struct usb_serial *serial); |
77 | static void klsi_105_release(struct usb_serial *serial); | ||
77 | static int klsi_105_open(struct tty_struct *tty, | 78 | static int klsi_105_open(struct tty_struct *tty, |
78 | struct usb_serial_port *port, struct file *filp); | 79 | struct usb_serial_port *port, struct file *filp); |
79 | static void klsi_105_close(struct usb_serial_port *port); | 80 | static void klsi_105_close(struct usb_serial_port *port); |
@@ -131,7 +132,8 @@ static struct usb_serial_driver kl5kusb105d_device = { | |||
131 | .tiocmget = klsi_105_tiocmget, | 132 | .tiocmget = klsi_105_tiocmget, |
132 | .tiocmset = klsi_105_tiocmset, | 133 | .tiocmset = klsi_105_tiocmset, |
133 | .attach = klsi_105_startup, | 134 | .attach = klsi_105_startup, |
134 | .shutdown = klsi_105_shutdown, | 135 | .disconnect = klsi_105_disconnect, |
136 | .release = klsi_105_release, | ||
135 | .throttle = klsi_105_throttle, | 137 | .throttle = klsi_105_throttle, |
136 | .unthrottle = klsi_105_unthrottle, | 138 | .unthrottle = klsi_105_unthrottle, |
137 | }; | 139 | }; |
@@ -315,7 +317,7 @@ err_cleanup: | |||
315 | } /* klsi_105_startup */ | 317 | } /* klsi_105_startup */ |
316 | 318 | ||
317 | 319 | ||
318 | static void klsi_105_shutdown(struct usb_serial *serial) | 320 | static void klsi_105_disconnect(struct usb_serial *serial) |
319 | { | 321 | { |
320 | int i; | 322 | int i; |
321 | 323 | ||
@@ -325,33 +327,36 @@ static void klsi_105_shutdown(struct usb_serial *serial) | |||
325 | for (i = 0; i < serial->num_ports; ++i) { | 327 | for (i = 0; i < serial->num_ports; ++i) { |
326 | struct klsi_105_private *priv = | 328 | struct klsi_105_private *priv = |
327 | usb_get_serial_port_data(serial->port[i]); | 329 | usb_get_serial_port_data(serial->port[i]); |
328 | unsigned long flags; | ||
329 | 330 | ||
330 | if (priv) { | 331 | if (priv) { |
331 | /* kill our write urb pool */ | 332 | /* kill our write urb pool */ |
332 | int j; | 333 | int j; |
333 | struct urb **write_urbs = priv->write_urb_pool; | 334 | struct urb **write_urbs = priv->write_urb_pool; |
334 | spin_lock_irqsave(&priv->lock, flags); | ||
335 | 335 | ||
336 | for (j = 0; j < NUM_URBS; j++) { | 336 | for (j = 0; j < NUM_URBS; j++) { |
337 | if (write_urbs[j]) { | 337 | if (write_urbs[j]) { |
338 | /* FIXME - uncomment the following | 338 | usb_kill_urb(write_urbs[j]); |
339 | * usb_kill_urb call when the host | ||
340 | * controllers get fixed to set | ||
341 | * urb->dev = NULL after the urb is | ||
342 | * finished. Otherwise this call | ||
343 | * oopses. */ | ||
344 | /* usb_kill_urb(write_urbs[j]); */ | ||
345 | kfree(write_urbs[j]->transfer_buffer); | ||
346 | usb_free_urb(write_urbs[j]); | 339 | usb_free_urb(write_urbs[j]); |
347 | } | 340 | } |
348 | } | 341 | } |
349 | spin_unlock_irqrestore(&priv->lock, flags); | ||
350 | kfree(priv); | ||
351 | usb_set_serial_port_data(serial->port[i], NULL); | ||
352 | } | 342 | } |
353 | } | 343 | } |
354 | } /* klsi_105_shutdown */ | 344 | } /* klsi_105_disconnect */ |
345 | |||
346 | |||
347 | static void klsi_105_release(struct usb_serial *serial) | ||
348 | { | ||
349 | int i; | ||
350 | |||
351 | dbg("%s", __func__); | ||
352 | |||
353 | for (i = 0; i < serial->num_ports; ++i) { | ||
354 | struct klsi_105_private *priv = | ||
355 | usb_get_serial_port_data(serial->port[i]); | ||
356 | |||
357 | kfree(priv); | ||
358 | } | ||
359 | } /* klsi_105_release */ | ||
355 | 360 | ||
356 | static int klsi_105_open(struct tty_struct *tty, | 361 | static int klsi_105_open(struct tty_struct *tty, |
357 | struct usb_serial_port *port, struct file *filp) | 362 | struct usb_serial_port *port, struct file *filp) |
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c index 6b570498287f..6db0e561f680 100644 --- a/drivers/usb/serial/kobil_sct.c +++ b/drivers/usb/serial/kobil_sct.c | |||
@@ -69,7 +69,7 @@ static int debug; | |||
69 | 69 | ||
70 | /* Function prototypes */ | 70 | /* Function prototypes */ |
71 | static int kobil_startup(struct usb_serial *serial); | 71 | static int kobil_startup(struct usb_serial *serial); |
72 | static void kobil_shutdown(struct usb_serial *serial); | 72 | static void kobil_release(struct usb_serial *serial); |
73 | static int kobil_open(struct tty_struct *tty, | 73 | static int kobil_open(struct tty_struct *tty, |
74 | struct usb_serial_port *port, struct file *filp); | 74 | struct usb_serial_port *port, struct file *filp); |
75 | static void kobil_close(struct usb_serial_port *port); | 75 | static void kobil_close(struct usb_serial_port *port); |
@@ -117,7 +117,7 @@ static struct usb_serial_driver kobil_device = { | |||
117 | .id_table = id_table, | 117 | .id_table = id_table, |
118 | .num_ports = 1, | 118 | .num_ports = 1, |
119 | .attach = kobil_startup, | 119 | .attach = kobil_startup, |
120 | .shutdown = kobil_shutdown, | 120 | .release = kobil_release, |
121 | .ioctl = kobil_ioctl, | 121 | .ioctl = kobil_ioctl, |
122 | .set_termios = kobil_set_termios, | 122 | .set_termios = kobil_set_termios, |
123 | .tiocmget = kobil_tiocmget, | 123 | .tiocmget = kobil_tiocmget, |
@@ -201,17 +201,13 @@ static int kobil_startup(struct usb_serial *serial) | |||
201 | } | 201 | } |
202 | 202 | ||
203 | 203 | ||
204 | static void kobil_shutdown(struct usb_serial *serial) | 204 | static void kobil_release(struct usb_serial *serial) |
205 | { | 205 | { |
206 | int i; | 206 | int i; |
207 | dbg("%s - port %d", __func__, serial->port[0]->number); | 207 | dbg("%s - port %d", __func__, serial->port[0]->number); |
208 | 208 | ||
209 | for (i = 0; i < serial->num_ports; ++i) { | 209 | for (i = 0; i < serial->num_ports; ++i) |
210 | while (serial->port[i]->port.count > 0) | ||
211 | kobil_close(serial->port[i]); | ||
212 | kfree(usb_get_serial_port_data(serial->port[i])); | 210 | kfree(usb_get_serial_port_data(serial->port[i])); |
213 | usb_set_serial_port_data(serial->port[i], NULL); | ||
214 | } | ||
215 | } | 211 | } |
216 | 212 | ||
217 | 213 | ||
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c index 873795548fc0..d8825e159aa5 100644 --- a/drivers/usb/serial/mct_u232.c +++ b/drivers/usb/serial/mct_u232.c | |||
@@ -92,7 +92,7 @@ static int debug; | |||
92 | * Function prototypes | 92 | * Function prototypes |
93 | */ | 93 | */ |
94 | static int mct_u232_startup(struct usb_serial *serial); | 94 | static int mct_u232_startup(struct usb_serial *serial); |
95 | static void mct_u232_shutdown(struct usb_serial *serial); | 95 | static void mct_u232_release(struct usb_serial *serial); |
96 | static int mct_u232_open(struct tty_struct *tty, | 96 | static int mct_u232_open(struct tty_struct *tty, |
97 | struct usb_serial_port *port, struct file *filp); | 97 | struct usb_serial_port *port, struct file *filp); |
98 | static void mct_u232_close(struct usb_serial_port *port); | 98 | static void mct_u232_close(struct usb_serial_port *port); |
@@ -149,7 +149,7 @@ static struct usb_serial_driver mct_u232_device = { | |||
149 | .tiocmget = mct_u232_tiocmget, | 149 | .tiocmget = mct_u232_tiocmget, |
150 | .tiocmset = mct_u232_tiocmset, | 150 | .tiocmset = mct_u232_tiocmset, |
151 | .attach = mct_u232_startup, | 151 | .attach = mct_u232_startup, |
152 | .shutdown = mct_u232_shutdown, | 152 | .release = mct_u232_release, |
153 | }; | 153 | }; |
154 | 154 | ||
155 | 155 | ||
@@ -407,7 +407,7 @@ static int mct_u232_startup(struct usb_serial *serial) | |||
407 | } /* mct_u232_startup */ | 407 | } /* mct_u232_startup */ |
408 | 408 | ||
409 | 409 | ||
410 | static void mct_u232_shutdown(struct usb_serial *serial) | 410 | static void mct_u232_release(struct usb_serial *serial) |
411 | { | 411 | { |
412 | struct mct_u232_private *priv; | 412 | struct mct_u232_private *priv; |
413 | int i; | 413 | int i; |
@@ -417,12 +417,9 @@ static void mct_u232_shutdown(struct usb_serial *serial) | |||
417 | for (i = 0; i < serial->num_ports; ++i) { | 417 | for (i = 0; i < serial->num_ports; ++i) { |
418 | /* My special items, the standard routines free my urbs */ | 418 | /* My special items, the standard routines free my urbs */ |
419 | priv = usb_get_serial_port_data(serial->port[i]); | 419 | priv = usb_get_serial_port_data(serial->port[i]); |
420 | if (priv) { | 420 | kfree(priv); |
421 | usb_set_serial_port_data(serial->port[i], NULL); | ||
422 | kfree(priv); | ||
423 | } | ||
424 | } | 421 | } |
425 | } /* mct_u232_shutdown */ | 422 | } /* mct_u232_release */ |
426 | 423 | ||
427 | static int mct_u232_open(struct tty_struct *tty, | 424 | static int mct_u232_open(struct tty_struct *tty, |
428 | struct usb_serial_port *port, struct file *filp) | 425 | struct usb_serial_port *port, struct file *filp) |
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c index 9e1a013ee7f6..bfc5ce000ef9 100644 --- a/drivers/usb/serial/mos7720.c +++ b/drivers/usb/serial/mos7720.c | |||
@@ -1521,19 +1521,16 @@ static int mos7720_startup(struct usb_serial *serial) | |||
1521 | return 0; | 1521 | return 0; |
1522 | } | 1522 | } |
1523 | 1523 | ||
1524 | static void mos7720_shutdown(struct usb_serial *serial) | 1524 | static void mos7720_release(struct usb_serial *serial) |
1525 | { | 1525 | { |
1526 | int i; | 1526 | int i; |
1527 | 1527 | ||
1528 | /* free private structure allocated for serial port */ | 1528 | /* free private structure allocated for serial port */ |
1529 | for (i = 0; i < serial->num_ports; ++i) { | 1529 | for (i = 0; i < serial->num_ports; ++i) |
1530 | kfree(usb_get_serial_port_data(serial->port[i])); | 1530 | kfree(usb_get_serial_port_data(serial->port[i])); |
1531 | usb_set_serial_port_data(serial->port[i], NULL); | ||
1532 | } | ||
1533 | 1531 | ||
1534 | /* free private structure allocated for serial device */ | 1532 | /* free private structure allocated for serial device */ |
1535 | kfree(usb_get_serial_data(serial)); | 1533 | kfree(usb_get_serial_data(serial)); |
1536 | usb_set_serial_data(serial, NULL); | ||
1537 | } | 1534 | } |
1538 | 1535 | ||
1539 | static struct usb_driver usb_driver = { | 1536 | static struct usb_driver usb_driver = { |
@@ -1558,7 +1555,7 @@ static struct usb_serial_driver moschip7720_2port_driver = { | |||
1558 | .throttle = mos7720_throttle, | 1555 | .throttle = mos7720_throttle, |
1559 | .unthrottle = mos7720_unthrottle, | 1556 | .unthrottle = mos7720_unthrottle, |
1560 | .attach = mos7720_startup, | 1557 | .attach = mos7720_startup, |
1561 | .shutdown = mos7720_shutdown, | 1558 | .release = mos7720_release, |
1562 | .ioctl = mos7720_ioctl, | 1559 | .ioctl = mos7720_ioctl, |
1563 | .set_termios = mos7720_set_termios, | 1560 | .set_termios = mos7720_set_termios, |
1564 | .write = mos7720_write, | 1561 | .write = mos7720_write, |
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c index 10b78a37214f..c40f95c1951c 100644 --- a/drivers/usb/serial/mos7840.c +++ b/drivers/usb/serial/mos7840.c | |||
@@ -238,7 +238,7 @@ static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg, | |||
238 | { | 238 | { |
239 | struct usb_device *dev = port->serial->dev; | 239 | struct usb_device *dev = port->serial->dev; |
240 | val = val & 0x00ff; | 240 | val = val & 0x00ff; |
241 | dbg("mos7840_set_reg_sync offset is %x, value %x\n", reg, val); | 241 | dbg("mos7840_set_reg_sync offset is %x, value %x", reg, val); |
242 | 242 | ||
243 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, | 243 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, |
244 | MCS_WR_RTYPE, val, reg, NULL, 0, | 244 | MCS_WR_RTYPE, val, reg, NULL, 0, |
@@ -260,7 +260,7 @@ static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg, | |||
260 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, | 260 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, |
261 | MCS_RD_RTYPE, 0, reg, val, VENDOR_READ_LENGTH, | 261 | MCS_RD_RTYPE, 0, reg, val, VENDOR_READ_LENGTH, |
262 | MOS_WDR_TIMEOUT); | 262 | MOS_WDR_TIMEOUT); |
263 | dbg("mos7840_get_reg_sync offset is %x, return val %x\n", reg, *val); | 263 | dbg("mos7840_get_reg_sync offset is %x, return val %x", reg, *val); |
264 | *val = (*val) & 0x00ff; | 264 | *val = (*val) & 0x00ff; |
265 | return ret; | 265 | return ret; |
266 | } | 266 | } |
@@ -282,18 +282,18 @@ static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg, | |||
282 | if (port->serial->num_ports == 4) { | 282 | if (port->serial->num_ports == 4) { |
283 | val |= (((__u16) port->number - | 283 | val |= (((__u16) port->number - |
284 | (__u16) (port->serial->minor)) + 1) << 8; | 284 | (__u16) (port->serial->minor)) + 1) << 8; |
285 | dbg("mos7840_set_uart_reg application number is %x\n", val); | 285 | dbg("mos7840_set_uart_reg application number is %x", val); |
286 | } else { | 286 | } else { |
287 | if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { | 287 | if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { |
288 | val |= (((__u16) port->number - | 288 | val |= (((__u16) port->number - |
289 | (__u16) (port->serial->minor)) + 1) << 8; | 289 | (__u16) (port->serial->minor)) + 1) << 8; |
290 | dbg("mos7840_set_uart_reg application number is %x\n", | 290 | dbg("mos7840_set_uart_reg application number is %x", |
291 | val); | 291 | val); |
292 | } else { | 292 | } else { |
293 | val |= | 293 | val |= |
294 | (((__u16) port->number - | 294 | (((__u16) port->number - |
295 | (__u16) (port->serial->minor)) + 2) << 8; | 295 | (__u16) (port->serial->minor)) + 2) << 8; |
296 | dbg("mos7840_set_uart_reg application number is %x\n", | 296 | dbg("mos7840_set_uart_reg application number is %x", |
297 | val); | 297 | val); |
298 | } | 298 | } |
299 | } | 299 | } |
@@ -315,24 +315,24 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg, | |||
315 | int ret = 0; | 315 | int ret = 0; |
316 | __u16 Wval; | 316 | __u16 Wval; |
317 | 317 | ||
318 | /* dbg("application number is %4x \n", | 318 | /* dbg("application number is %4x", |
319 | (((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); */ | 319 | (((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); */ |
320 | /* Wval is same as application number */ | 320 | /* Wval is same as application number */ |
321 | if (port->serial->num_ports == 4) { | 321 | if (port->serial->num_ports == 4) { |
322 | Wval = | 322 | Wval = |
323 | (((__u16) port->number - (__u16) (port->serial->minor)) + | 323 | (((__u16) port->number - (__u16) (port->serial->minor)) + |
324 | 1) << 8; | 324 | 1) << 8; |
325 | dbg("mos7840_get_uart_reg application number is %x\n", Wval); | 325 | dbg("mos7840_get_uart_reg application number is %x", Wval); |
326 | } else { | 326 | } else { |
327 | if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { | 327 | if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { |
328 | Wval = (((__u16) port->number - | 328 | Wval = (((__u16) port->number - |
329 | (__u16) (port->serial->minor)) + 1) << 8; | 329 | (__u16) (port->serial->minor)) + 1) << 8; |
330 | dbg("mos7840_get_uart_reg application number is %x\n", | 330 | dbg("mos7840_get_uart_reg application number is %x", |
331 | Wval); | 331 | Wval); |
332 | } else { | 332 | } else { |
333 | Wval = (((__u16) port->number - | 333 | Wval = (((__u16) port->number - |
334 | (__u16) (port->serial->minor)) + 2) << 8; | 334 | (__u16) (port->serial->minor)) + 2) << 8; |
335 | dbg("mos7840_get_uart_reg application number is %x\n", | 335 | dbg("mos7840_get_uart_reg application number is %x", |
336 | Wval); | 336 | Wval); |
337 | } | 337 | } |
338 | } | 338 | } |
@@ -346,11 +346,11 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg, | |||
346 | static void mos7840_dump_serial_port(struct moschip_port *mos7840_port) | 346 | static void mos7840_dump_serial_port(struct moschip_port *mos7840_port) |
347 | { | 347 | { |
348 | 348 | ||
349 | dbg("***************************************\n"); | 349 | dbg("***************************************"); |
350 | dbg("SpRegOffset is %2x\n", mos7840_port->SpRegOffset); | 350 | dbg("SpRegOffset is %2x", mos7840_port->SpRegOffset); |
351 | dbg("ControlRegOffset is %2x \n", mos7840_port->ControlRegOffset); | 351 | dbg("ControlRegOffset is %2x", mos7840_port->ControlRegOffset); |
352 | dbg("DCRRegOffset is %2x \n", mos7840_port->DcrRegOffset); | 352 | dbg("DCRRegOffset is %2x", mos7840_port->DcrRegOffset); |
353 | dbg("***************************************\n"); | 353 | dbg("***************************************"); |
354 | 354 | ||
355 | } | 355 | } |
356 | 356 | ||
@@ -474,12 +474,12 @@ static void mos7840_control_callback(struct urb *urb) | |||
474 | goto exit; | 474 | goto exit; |
475 | } | 475 | } |
476 | 476 | ||
477 | dbg("%s urb buffer size is %d\n", __func__, urb->actual_length); | 477 | dbg("%s urb buffer size is %d", __func__, urb->actual_length); |
478 | dbg("%s mos7840_port->MsrLsr is %d port %d\n", __func__, | 478 | dbg("%s mos7840_port->MsrLsr is %d port %d", __func__, |
479 | mos7840_port->MsrLsr, mos7840_port->port_num); | 479 | mos7840_port->MsrLsr, mos7840_port->port_num); |
480 | data = urb->transfer_buffer; | 480 | data = urb->transfer_buffer; |
481 | regval = (__u8) data[0]; | 481 | regval = (__u8) data[0]; |
482 | dbg("%s data is %x\n", __func__, regval); | 482 | dbg("%s data is %x", __func__, regval); |
483 | if (mos7840_port->MsrLsr == 0) | 483 | if (mos7840_port->MsrLsr == 0) |
484 | mos7840_handle_new_msr(mos7840_port, regval); | 484 | mos7840_handle_new_msr(mos7840_port, regval); |
485 | else if (mos7840_port->MsrLsr == 1) | 485 | else if (mos7840_port->MsrLsr == 1) |
@@ -538,7 +538,7 @@ static void mos7840_interrupt_callback(struct urb *urb) | |||
538 | __u16 wval, wreg = 0; | 538 | __u16 wval, wreg = 0; |
539 | int status = urb->status; | 539 | int status = urb->status; |
540 | 540 | ||
541 | dbg("%s", " : Entering\n"); | 541 | dbg("%s", " : Entering"); |
542 | 542 | ||
543 | switch (status) { | 543 | switch (status) { |
544 | case 0: | 544 | case 0: |
@@ -570,7 +570,7 @@ static void mos7840_interrupt_callback(struct urb *urb) | |||
570 | * Byte 5 FIFO status for both */ | 570 | * Byte 5 FIFO status for both */ |
571 | 571 | ||
572 | if (length && length > 5) { | 572 | if (length && length > 5) { |
573 | dbg("%s \n", "Wrong data !!!"); | 573 | dbg("%s", "Wrong data !!!"); |
574 | return; | 574 | return; |
575 | } | 575 | } |
576 | 576 | ||
@@ -587,17 +587,17 @@ static void mos7840_interrupt_callback(struct urb *urb) | |||
587 | (__u16) (serial->minor)) + 1) << 8; | 587 | (__u16) (serial->minor)) + 1) << 8; |
588 | if (mos7840_port->open) { | 588 | if (mos7840_port->open) { |
589 | if (sp[i] & 0x01) { | 589 | if (sp[i] & 0x01) { |
590 | dbg("SP%d No Interrupt !!!\n", i); | 590 | dbg("SP%d No Interrupt !!!", i); |
591 | } else { | 591 | } else { |
592 | switch (sp[i] & 0x0f) { | 592 | switch (sp[i] & 0x0f) { |
593 | case SERIAL_IIR_RLS: | 593 | case SERIAL_IIR_RLS: |
594 | dbg("Serial Port %d: Receiver status error or ", i); | 594 | dbg("Serial Port %d: Receiver status error or ", i); |
595 | dbg("address bit detected in 9-bit mode\n"); | 595 | dbg("address bit detected in 9-bit mode"); |
596 | mos7840_port->MsrLsr = 1; | 596 | mos7840_port->MsrLsr = 1; |
597 | wreg = LINE_STATUS_REGISTER; | 597 | wreg = LINE_STATUS_REGISTER; |
598 | break; | 598 | break; |
599 | case SERIAL_IIR_MS: | 599 | case SERIAL_IIR_MS: |
600 | dbg("Serial Port %d: Modem status change\n", i); | 600 | dbg("Serial Port %d: Modem status change", i); |
601 | mos7840_port->MsrLsr = 0; | 601 | mos7840_port->MsrLsr = 0; |
602 | wreg = MODEM_STATUS_REGISTER; | 602 | wreg = MODEM_STATUS_REGISTER; |
603 | break; | 603 | break; |
@@ -689,7 +689,7 @@ static void mos7840_bulk_in_callback(struct urb *urb) | |||
689 | 689 | ||
690 | mos7840_port = urb->context; | 690 | mos7840_port = urb->context; |
691 | if (!mos7840_port) { | 691 | if (!mos7840_port) { |
692 | dbg("%s", "NULL mos7840_port pointer \n"); | 692 | dbg("%s", "NULL mos7840_port pointer"); |
693 | mos7840_port->read_urb_busy = false; | 693 | mos7840_port->read_urb_busy = false; |
694 | return; | 694 | return; |
695 | } | 695 | } |
@@ -702,41 +702,41 @@ static void mos7840_bulk_in_callback(struct urb *urb) | |||
702 | 702 | ||
703 | port = (struct usb_serial_port *)mos7840_port->port; | 703 | port = (struct usb_serial_port *)mos7840_port->port; |
704 | if (mos7840_port_paranoia_check(port, __func__)) { | 704 | if (mos7840_port_paranoia_check(port, __func__)) { |
705 | dbg("%s", "Port Paranoia failed \n"); | 705 | dbg("%s", "Port Paranoia failed"); |
706 | mos7840_port->read_urb_busy = false; | 706 | mos7840_port->read_urb_busy = false; |
707 | return; | 707 | return; |
708 | } | 708 | } |
709 | 709 | ||
710 | serial = mos7840_get_usb_serial(port, __func__); | 710 | serial = mos7840_get_usb_serial(port, __func__); |
711 | if (!serial) { | 711 | if (!serial) { |
712 | dbg("%s\n", "Bad serial pointer "); | 712 | dbg("%s", "Bad serial pointer"); |
713 | mos7840_port->read_urb_busy = false; | 713 | mos7840_port->read_urb_busy = false; |
714 | return; | 714 | return; |
715 | } | 715 | } |
716 | 716 | ||
717 | dbg("%s\n", "Entering... \n"); | 717 | dbg("%s", "Entering... "); |
718 | 718 | ||
719 | data = urb->transfer_buffer; | 719 | data = urb->transfer_buffer; |
720 | 720 | ||
721 | dbg("%s", "Entering ........... \n"); | 721 | dbg("%s", "Entering ..........."); |
722 | 722 | ||
723 | if (urb->actual_length) { | 723 | if (urb->actual_length) { |
724 | tty = tty_port_tty_get(&mos7840_port->port->port); | 724 | tty = tty_port_tty_get(&mos7840_port->port->port); |
725 | if (tty) { | 725 | if (tty) { |
726 | tty_buffer_request_room(tty, urb->actual_length); | 726 | tty_buffer_request_room(tty, urb->actual_length); |
727 | tty_insert_flip_string(tty, data, urb->actual_length); | 727 | tty_insert_flip_string(tty, data, urb->actual_length); |
728 | dbg(" %s \n", data); | 728 | dbg(" %s ", data); |
729 | tty_flip_buffer_push(tty); | 729 | tty_flip_buffer_push(tty); |
730 | tty_kref_put(tty); | 730 | tty_kref_put(tty); |
731 | } | 731 | } |
732 | mos7840_port->icount.rx += urb->actual_length; | 732 | mos7840_port->icount.rx += urb->actual_length; |
733 | smp_wmb(); | 733 | smp_wmb(); |
734 | dbg("mos7840_port->icount.rx is %d:\n", | 734 | dbg("mos7840_port->icount.rx is %d:", |
735 | mos7840_port->icount.rx); | 735 | mos7840_port->icount.rx); |
736 | } | 736 | } |
737 | 737 | ||
738 | if (!mos7840_port->read_urb) { | 738 | if (!mos7840_port->read_urb) { |
739 | dbg("%s", "URB KILLED !!!\n"); | 739 | dbg("%s", "URB KILLED !!!"); |
740 | mos7840_port->read_urb_busy = false; | 740 | mos7840_port->read_urb_busy = false; |
741 | return; | 741 | return; |
742 | } | 742 | } |
@@ -777,16 +777,16 @@ static void mos7840_bulk_out_data_callback(struct urb *urb) | |||
777 | spin_unlock(&mos7840_port->pool_lock); | 777 | spin_unlock(&mos7840_port->pool_lock); |
778 | 778 | ||
779 | if (status) { | 779 | if (status) { |
780 | dbg("nonzero write bulk status received:%d\n", status); | 780 | dbg("nonzero write bulk status received:%d", status); |
781 | return; | 781 | return; |
782 | } | 782 | } |
783 | 783 | ||
784 | if (mos7840_port_paranoia_check(mos7840_port->port, __func__)) { | 784 | if (mos7840_port_paranoia_check(mos7840_port->port, __func__)) { |
785 | dbg("%s", "Port Paranoia failed \n"); | 785 | dbg("%s", "Port Paranoia failed"); |
786 | return; | 786 | return; |
787 | } | 787 | } |
788 | 788 | ||
789 | dbg("%s \n", "Entering ........."); | 789 | dbg("%s", "Entering ........."); |
790 | 790 | ||
791 | tty = tty_port_tty_get(&mos7840_port->port->port); | 791 | tty = tty_port_tty_get(&mos7840_port->port->port); |
792 | if (tty && mos7840_port->open) | 792 | if (tty && mos7840_port->open) |
@@ -830,15 +830,17 @@ static int mos7840_open(struct tty_struct *tty, | |||
830 | struct moschip_port *mos7840_port; | 830 | struct moschip_port *mos7840_port; |
831 | struct moschip_port *port0; | 831 | struct moschip_port *port0; |
832 | 832 | ||
833 | dbg ("%s enter", __func__); | ||
834 | |||
833 | if (mos7840_port_paranoia_check(port, __func__)) { | 835 | if (mos7840_port_paranoia_check(port, __func__)) { |
834 | dbg("%s", "Port Paranoia failed \n"); | 836 | dbg("%s", "Port Paranoia failed"); |
835 | return -ENODEV; | 837 | return -ENODEV; |
836 | } | 838 | } |
837 | 839 | ||
838 | serial = port->serial; | 840 | serial = port->serial; |
839 | 841 | ||
840 | if (mos7840_serial_paranoia_check(serial, __func__)) { | 842 | if (mos7840_serial_paranoia_check(serial, __func__)) { |
841 | dbg("%s", "Serial Paranoia failed \n"); | 843 | dbg("%s", "Serial Paranoia failed"); |
842 | return -ENODEV; | 844 | return -ENODEV; |
843 | } | 845 | } |
844 | 846 | ||
@@ -891,20 +893,20 @@ static int mos7840_open(struct tty_struct *tty, | |||
891 | Data = 0x0; | 893 | Data = 0x0; |
892 | status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); | 894 | status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); |
893 | if (status < 0) { | 895 | if (status < 0) { |
894 | dbg("Reading Spreg failed\n"); | 896 | dbg("Reading Spreg failed"); |
895 | return -1; | 897 | return -1; |
896 | } | 898 | } |
897 | Data |= 0x80; | 899 | Data |= 0x80; |
898 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); | 900 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); |
899 | if (status < 0) { | 901 | if (status < 0) { |
900 | dbg("writing Spreg failed\n"); | 902 | dbg("writing Spreg failed"); |
901 | return -1; | 903 | return -1; |
902 | } | 904 | } |
903 | 905 | ||
904 | Data &= ~0x80; | 906 | Data &= ~0x80; |
905 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); | 907 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); |
906 | if (status < 0) { | 908 | if (status < 0) { |
907 | dbg("writing Spreg failed\n"); | 909 | dbg("writing Spreg failed"); |
908 | return -1; | 910 | return -1; |
909 | } | 911 | } |
910 | /* End of block to be checked */ | 912 | /* End of block to be checked */ |
@@ -913,7 +915,7 @@ static int mos7840_open(struct tty_struct *tty, | |||
913 | status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, | 915 | status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, |
914 | &Data); | 916 | &Data); |
915 | if (status < 0) { | 917 | if (status < 0) { |
916 | dbg("Reading Controlreg failed\n"); | 918 | dbg("Reading Controlreg failed"); |
917 | return -1; | 919 | return -1; |
918 | } | 920 | } |
919 | Data |= 0x08; /* Driver done bit */ | 921 | Data |= 0x08; /* Driver done bit */ |
@@ -921,7 +923,7 @@ static int mos7840_open(struct tty_struct *tty, | |||
921 | status = mos7840_set_reg_sync(port, | 923 | status = mos7840_set_reg_sync(port, |
922 | mos7840_port->ControlRegOffset, Data); | 924 | mos7840_port->ControlRegOffset, Data); |
923 | if (status < 0) { | 925 | if (status < 0) { |
924 | dbg("writing Controlreg failed\n"); | 926 | dbg("writing Controlreg failed"); |
925 | return -1; | 927 | return -1; |
926 | } | 928 | } |
927 | /* do register settings here */ | 929 | /* do register settings here */ |
@@ -932,21 +934,21 @@ static int mos7840_open(struct tty_struct *tty, | |||
932 | Data = 0x00; | 934 | Data = 0x00; |
933 | status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); | 935 | status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
934 | if (status < 0) { | 936 | if (status < 0) { |
935 | dbg("disableing interrupts failed\n"); | 937 | dbg("disabling interrupts failed"); |
936 | return -1; | 938 | return -1; |
937 | } | 939 | } |
938 | /* Set FIFO_CONTROL_REGISTER to the default value */ | 940 | /* Set FIFO_CONTROL_REGISTER to the default value */ |
939 | Data = 0x00; | 941 | Data = 0x00; |
940 | status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); | 942 | status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
941 | if (status < 0) { | 943 | if (status < 0) { |
942 | dbg("Writing FIFO_CONTROL_REGISTER failed\n"); | 944 | dbg("Writing FIFO_CONTROL_REGISTER failed"); |
943 | return -1; | 945 | return -1; |
944 | } | 946 | } |
945 | 947 | ||
946 | Data = 0xcf; | 948 | Data = 0xcf; |
947 | status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); | 949 | status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
948 | if (status < 0) { | 950 | if (status < 0) { |
949 | dbg("Writing FIFO_CONTROL_REGISTER failed\n"); | 951 | dbg("Writing FIFO_CONTROL_REGISTER failed"); |
950 | return -1; | 952 | return -1; |
951 | } | 953 | } |
952 | 954 | ||
@@ -1043,12 +1045,12 @@ static int mos7840_open(struct tty_struct *tty, | |||
1043 | * (can't set it up in mos7840_startup as the * | 1045 | * (can't set it up in mos7840_startup as the * |
1044 | * structures were not set up at that time.) */ | 1046 | * structures were not set up at that time.) */ |
1045 | 1047 | ||
1046 | dbg("port number is %d \n", port->number); | 1048 | dbg("port number is %d", port->number); |
1047 | dbg("serial number is %d \n", port->serial->minor); | 1049 | dbg("serial number is %d", port->serial->minor); |
1048 | dbg("Bulkin endpoint is %d \n", port->bulk_in_endpointAddress); | 1050 | dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress); |
1049 | dbg("BulkOut endpoint is %d \n", port->bulk_out_endpointAddress); | 1051 | dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress); |
1050 | dbg("Interrupt endpoint is %d \n", port->interrupt_in_endpointAddress); | 1052 | dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress); |
1051 | dbg("port's number in the device is %d\n", mos7840_port->port_num); | 1053 | dbg("port's number in the device is %d", mos7840_port->port_num); |
1052 | mos7840_port->read_urb = port->read_urb; | 1054 | mos7840_port->read_urb = port->read_urb; |
1053 | 1055 | ||
1054 | /* set up our bulk in urb */ | 1056 | /* set up our bulk in urb */ |
@@ -1061,7 +1063,7 @@ static int mos7840_open(struct tty_struct *tty, | |||
1061 | mos7840_port->read_urb->transfer_buffer_length, | 1063 | mos7840_port->read_urb->transfer_buffer_length, |
1062 | mos7840_bulk_in_callback, mos7840_port); | 1064 | mos7840_bulk_in_callback, mos7840_port); |
1063 | 1065 | ||
1064 | dbg("mos7840_open: bulkin endpoint is %d\n", | 1066 | dbg("mos7840_open: bulkin endpoint is %d", |
1065 | port->bulk_in_endpointAddress); | 1067 | port->bulk_in_endpointAddress); |
1066 | mos7840_port->read_urb_busy = true; | 1068 | mos7840_port->read_urb_busy = true; |
1067 | response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); | 1069 | response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); |
@@ -1087,9 +1089,11 @@ static int mos7840_open(struct tty_struct *tty, | |||
1087 | mos7840_port->icount.tx = 0; | 1089 | mos7840_port->icount.tx = 0; |
1088 | mos7840_port->icount.rx = 0; | 1090 | mos7840_port->icount.rx = 0; |
1089 | 1091 | ||
1090 | dbg("\n\nusb_serial serial:%p mos7840_port:%p\n usb_serial_port port:%p\n\n", | 1092 | dbg("usb_serial serial:%p mos7840_port:%p\n usb_serial_port port:%p", |
1091 | serial, mos7840_port, port); | 1093 | serial, mos7840_port, port); |
1092 | 1094 | ||
1095 | dbg ("%s leave", __func__); | ||
1096 | |||
1093 | return 0; | 1097 | return 0; |
1094 | 1098 | ||
1095 | } | 1099 | } |
@@ -1112,16 +1116,16 @@ static int mos7840_chars_in_buffer(struct tty_struct *tty) | |||
1112 | unsigned long flags; | 1116 | unsigned long flags; |
1113 | struct moschip_port *mos7840_port; | 1117 | struct moschip_port *mos7840_port; |
1114 | 1118 | ||
1115 | dbg("%s \n", " mos7840_chars_in_buffer:entering ..........."); | 1119 | dbg("%s", " mos7840_chars_in_buffer:entering ..........."); |
1116 | 1120 | ||
1117 | if (mos7840_port_paranoia_check(port, __func__)) { | 1121 | if (mos7840_port_paranoia_check(port, __func__)) { |
1118 | dbg("%s", "Invalid port \n"); | 1122 | dbg("%s", "Invalid port"); |
1119 | return 0; | 1123 | return 0; |
1120 | } | 1124 | } |
1121 | 1125 | ||
1122 | mos7840_port = mos7840_get_port_private(port); | 1126 | mos7840_port = mos7840_get_port_private(port); |
1123 | if (mos7840_port == NULL) { | 1127 | if (mos7840_port == NULL) { |
1124 | dbg("%s \n", "mos7840_break:leaving ..........."); | 1128 | dbg("%s", "mos7840_break:leaving ..........."); |
1125 | return 0; | 1129 | return 0; |
1126 | } | 1130 | } |
1127 | 1131 | ||
@@ -1148,16 +1152,16 @@ static void mos7840_close(struct usb_serial_port *port) | |||
1148 | int j; | 1152 | int j; |
1149 | __u16 Data; | 1153 | __u16 Data; |
1150 | 1154 | ||
1151 | dbg("%s\n", "mos7840_close:entering..."); | 1155 | dbg("%s", "mos7840_close:entering..."); |
1152 | 1156 | ||
1153 | if (mos7840_port_paranoia_check(port, __func__)) { | 1157 | if (mos7840_port_paranoia_check(port, __func__)) { |
1154 | dbg("%s", "Port Paranoia failed \n"); | 1158 | dbg("%s", "Port Paranoia failed"); |
1155 | return; | 1159 | return; |
1156 | } | 1160 | } |
1157 | 1161 | ||
1158 | serial = mos7840_get_usb_serial(port, __func__); | 1162 | serial = mos7840_get_usb_serial(port, __func__); |
1159 | if (!serial) { | 1163 | if (!serial) { |
1160 | dbg("%s", "Serial Paranoia failed \n"); | 1164 | dbg("%s", "Serial Paranoia failed"); |
1161 | return; | 1165 | return; |
1162 | } | 1166 | } |
1163 | 1167 | ||
@@ -1185,27 +1189,27 @@ static void mos7840_close(struct usb_serial_port *port) | |||
1185 | * and interrupt read if they exists */ | 1189 | * and interrupt read if they exists */ |
1186 | if (serial->dev) { | 1190 | if (serial->dev) { |
1187 | if (mos7840_port->write_urb) { | 1191 | if (mos7840_port->write_urb) { |
1188 | dbg("%s", "Shutdown bulk write\n"); | 1192 | dbg("%s", "Shutdown bulk write"); |
1189 | usb_kill_urb(mos7840_port->write_urb); | 1193 | usb_kill_urb(mos7840_port->write_urb); |
1190 | } | 1194 | } |
1191 | if (mos7840_port->read_urb) { | 1195 | if (mos7840_port->read_urb) { |
1192 | dbg("%s", "Shutdown bulk read\n"); | 1196 | dbg("%s", "Shutdown bulk read"); |
1193 | usb_kill_urb(mos7840_port->read_urb); | 1197 | usb_kill_urb(mos7840_port->read_urb); |
1194 | mos7840_port->read_urb_busy = false; | 1198 | mos7840_port->read_urb_busy = false; |
1195 | } | 1199 | } |
1196 | if ((&mos7840_port->control_urb)) { | 1200 | if ((&mos7840_port->control_urb)) { |
1197 | dbg("%s", "Shutdown control read\n"); | 1201 | dbg("%s", "Shutdown control read"); |
1198 | /*/ usb_kill_urb (mos7840_port->control_urb); */ | 1202 | /*/ usb_kill_urb (mos7840_port->control_urb); */ |
1199 | } | 1203 | } |
1200 | } | 1204 | } |
1201 | /* if(mos7840_port->ctrl_buf != NULL) */ | 1205 | /* if(mos7840_port->ctrl_buf != NULL) */ |
1202 | /* kfree(mos7840_port->ctrl_buf); */ | 1206 | /* kfree(mos7840_port->ctrl_buf); */ |
1203 | port0->open_ports--; | 1207 | port0->open_ports--; |
1204 | dbg("mos7840_num_open_ports in close%d:in port%d\n", | 1208 | dbg("mos7840_num_open_ports in close%d:in port%d", |
1205 | port0->open_ports, port->number); | 1209 | port0->open_ports, port->number); |
1206 | if (port0->open_ports == 0) { | 1210 | if (port0->open_ports == 0) { |
1207 | if (serial->port[0]->interrupt_in_urb) { | 1211 | if (serial->port[0]->interrupt_in_urb) { |
1208 | dbg("%s", "Shutdown interrupt_in_urb\n"); | 1212 | dbg("%s", "Shutdown interrupt_in_urb"); |
1209 | usb_kill_urb(serial->port[0]->interrupt_in_urb); | 1213 | usb_kill_urb(serial->port[0]->interrupt_in_urb); |
1210 | } | 1214 | } |
1211 | } | 1215 | } |
@@ -1225,7 +1229,7 @@ static void mos7840_close(struct usb_serial_port *port) | |||
1225 | 1229 | ||
1226 | mos7840_port->open = 0; | 1230 | mos7840_port->open = 0; |
1227 | 1231 | ||
1228 | dbg("%s \n", "Leaving ............"); | 1232 | dbg("%s", "Leaving ............"); |
1229 | } | 1233 | } |
1230 | 1234 | ||
1231 | /************************************************************************ | 1235 | /************************************************************************ |
@@ -1280,17 +1284,17 @@ static void mos7840_break(struct tty_struct *tty, int break_state) | |||
1280 | struct usb_serial *serial; | 1284 | struct usb_serial *serial; |
1281 | struct moschip_port *mos7840_port; | 1285 | struct moschip_port *mos7840_port; |
1282 | 1286 | ||
1283 | dbg("%s \n", "Entering ..........."); | 1287 | dbg("%s", "Entering ..........."); |
1284 | dbg("mos7840_break: Start\n"); | 1288 | dbg("mos7840_break: Start"); |
1285 | 1289 | ||
1286 | if (mos7840_port_paranoia_check(port, __func__)) { | 1290 | if (mos7840_port_paranoia_check(port, __func__)) { |
1287 | dbg("%s", "Port Paranoia failed \n"); | 1291 | dbg("%s", "Port Paranoia failed"); |
1288 | return; | 1292 | return; |
1289 | } | 1293 | } |
1290 | 1294 | ||
1291 | serial = mos7840_get_usb_serial(port, __func__); | 1295 | serial = mos7840_get_usb_serial(port, __func__); |
1292 | if (!serial) { | 1296 | if (!serial) { |
1293 | dbg("%s", "Serial Paranoia failed \n"); | 1297 | dbg("%s", "Serial Paranoia failed"); |
1294 | return; | 1298 | return; |
1295 | } | 1299 | } |
1296 | 1300 | ||
@@ -1310,7 +1314,7 @@ static void mos7840_break(struct tty_struct *tty, int break_state) | |||
1310 | 1314 | ||
1311 | /* FIXME: no locking on shadowLCR anywhere in driver */ | 1315 | /* FIXME: no locking on shadowLCR anywhere in driver */ |
1312 | mos7840_port->shadowLCR = data; | 1316 | mos7840_port->shadowLCR = data; |
1313 | dbg("mcs7840_break mos7840_port->shadowLCR is %x\n", | 1317 | dbg("mcs7840_break mos7840_port->shadowLCR is %x", |
1314 | mos7840_port->shadowLCR); | 1318 | mos7840_port->shadowLCR); |
1315 | mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, | 1319 | mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, |
1316 | mos7840_port->shadowLCR); | 1320 | mos7840_port->shadowLCR); |
@@ -1334,17 +1338,17 @@ static int mos7840_write_room(struct tty_struct *tty) | |||
1334 | unsigned long flags; | 1338 | unsigned long flags; |
1335 | struct moschip_port *mos7840_port; | 1339 | struct moschip_port *mos7840_port; |
1336 | 1340 | ||
1337 | dbg("%s \n", " mos7840_write_room:entering ..........."); | 1341 | dbg("%s", " mos7840_write_room:entering ..........."); |
1338 | 1342 | ||
1339 | if (mos7840_port_paranoia_check(port, __func__)) { | 1343 | if (mos7840_port_paranoia_check(port, __func__)) { |
1340 | dbg("%s", "Invalid port \n"); | 1344 | dbg("%s", "Invalid port"); |
1341 | dbg("%s \n", " mos7840_write_room:leaving ..........."); | 1345 | dbg("%s", " mos7840_write_room:leaving ..........."); |
1342 | return -1; | 1346 | return -1; |
1343 | } | 1347 | } |
1344 | 1348 | ||
1345 | mos7840_port = mos7840_get_port_private(port); | 1349 | mos7840_port = mos7840_get_port_private(port); |
1346 | if (mos7840_port == NULL) { | 1350 | if (mos7840_port == NULL) { |
1347 | dbg("%s \n", "mos7840_break:leaving ..........."); | 1351 | dbg("%s", "mos7840_break:leaving ..........."); |
1348 | return -1; | 1352 | return -1; |
1349 | } | 1353 | } |
1350 | 1354 | ||
@@ -1384,16 +1388,16 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1384 | /* __u16 Data; */ | 1388 | /* __u16 Data; */ |
1385 | const unsigned char *current_position = data; | 1389 | const unsigned char *current_position = data; |
1386 | unsigned char *data1; | 1390 | unsigned char *data1; |
1387 | dbg("%s \n", "entering ..........."); | 1391 | dbg("%s", "entering ..........."); |
1388 | /* dbg("mos7840_write: mos7840_port->shadowLCR is %x\n", | 1392 | /* dbg("mos7840_write: mos7840_port->shadowLCR is %x", |
1389 | mos7840_port->shadowLCR); */ | 1393 | mos7840_port->shadowLCR); */ |
1390 | 1394 | ||
1391 | #ifdef NOTMOS7840 | 1395 | #ifdef NOTMOS7840 |
1392 | Data = 0x00; | 1396 | Data = 0x00; |
1393 | status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); | 1397 | status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); |
1394 | mos7840_port->shadowLCR = Data; | 1398 | mos7840_port->shadowLCR = Data; |
1395 | dbg("mos7840_write: LINE_CONTROL_REGISTER is %x\n", Data); | 1399 | dbg("mos7840_write: LINE_CONTROL_REGISTER is %x", Data); |
1396 | dbg("mos7840_write: mos7840_port->shadowLCR is %x\n", | 1400 | dbg("mos7840_write: mos7840_port->shadowLCR is %x", |
1397 | mos7840_port->shadowLCR); | 1401 | mos7840_port->shadowLCR); |
1398 | 1402 | ||
1399 | /* Data = 0x03; */ | 1403 | /* Data = 0x03; */ |
@@ -1407,32 +1411,32 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1407 | /* status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); */ | 1411 | /* status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); */ |
1408 | Data = 0x00; | 1412 | Data = 0x00; |
1409 | status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data); | 1413 | status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data); |
1410 | dbg("mos7840_write:DLL value is %x\n", Data); | 1414 | dbg("mos7840_write:DLL value is %x", Data); |
1411 | 1415 | ||
1412 | Data = 0x0; | 1416 | Data = 0x0; |
1413 | status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data); | 1417 | status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data); |
1414 | dbg("mos7840_write:DLM value is %x\n", Data); | 1418 | dbg("mos7840_write:DLM value is %x", Data); |
1415 | 1419 | ||
1416 | Data = Data & ~SERIAL_LCR_DLAB; | 1420 | Data = Data & ~SERIAL_LCR_DLAB; |
1417 | dbg("mos7840_write: mos7840_port->shadowLCR is %x\n", | 1421 | dbg("mos7840_write: mos7840_port->shadowLCR is %x", |
1418 | mos7840_port->shadowLCR); | 1422 | mos7840_port->shadowLCR); |
1419 | status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); | 1423 | status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
1420 | #endif | 1424 | #endif |
1421 | 1425 | ||
1422 | if (mos7840_port_paranoia_check(port, __func__)) { | 1426 | if (mos7840_port_paranoia_check(port, __func__)) { |
1423 | dbg("%s", "Port Paranoia failed \n"); | 1427 | dbg("%s", "Port Paranoia failed"); |
1424 | return -1; | 1428 | return -1; |
1425 | } | 1429 | } |
1426 | 1430 | ||
1427 | serial = port->serial; | 1431 | serial = port->serial; |
1428 | if (mos7840_serial_paranoia_check(serial, __func__)) { | 1432 | if (mos7840_serial_paranoia_check(serial, __func__)) { |
1429 | dbg("%s", "Serial Paranoia failed \n"); | 1433 | dbg("%s", "Serial Paranoia failed"); |
1430 | return -1; | 1434 | return -1; |
1431 | } | 1435 | } |
1432 | 1436 | ||
1433 | mos7840_port = mos7840_get_port_private(port); | 1437 | mos7840_port = mos7840_get_port_private(port); |
1434 | if (mos7840_port == NULL) { | 1438 | if (mos7840_port == NULL) { |
1435 | dbg("%s", "mos7840_port is NULL\n"); | 1439 | dbg("%s", "mos7840_port is NULL"); |
1436 | return -1; | 1440 | return -1; |
1437 | } | 1441 | } |
1438 | 1442 | ||
@@ -1444,7 +1448,7 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1444 | if (!mos7840_port->busy[i]) { | 1448 | if (!mos7840_port->busy[i]) { |
1445 | mos7840_port->busy[i] = 1; | 1449 | mos7840_port->busy[i] = 1; |
1446 | urb = mos7840_port->write_urb_pool[i]; | 1450 | urb = mos7840_port->write_urb_pool[i]; |
1447 | dbg("\nURB:%d", i); | 1451 | dbg("URB:%d", i); |
1448 | break; | 1452 | break; |
1449 | } | 1453 | } |
1450 | } | 1454 | } |
@@ -1479,7 +1483,7 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1479 | mos7840_bulk_out_data_callback, mos7840_port); | 1483 | mos7840_bulk_out_data_callback, mos7840_port); |
1480 | 1484 | ||
1481 | data1 = urb->transfer_buffer; | 1485 | data1 = urb->transfer_buffer; |
1482 | dbg("\nbulkout endpoint is %d", port->bulk_out_endpointAddress); | 1486 | dbg("bulkout endpoint is %d", port->bulk_out_endpointAddress); |
1483 | 1487 | ||
1484 | /* send it down the pipe */ | 1488 | /* send it down the pipe */ |
1485 | status = usb_submit_urb(urb, GFP_ATOMIC); | 1489 | status = usb_submit_urb(urb, GFP_ATOMIC); |
@@ -1494,7 +1498,7 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
1494 | bytes_sent = transfer_size; | 1498 | bytes_sent = transfer_size; |
1495 | mos7840_port->icount.tx += transfer_size; | 1499 | mos7840_port->icount.tx += transfer_size; |
1496 | smp_wmb(); | 1500 | smp_wmb(); |
1497 | dbg("mos7840_port->icount.tx is %d:\n", mos7840_port->icount.tx); | 1501 | dbg("mos7840_port->icount.tx is %d:", mos7840_port->icount.tx); |
1498 | exit: | 1502 | exit: |
1499 | return bytes_sent; | 1503 | return bytes_sent; |
1500 | 1504 | ||
@@ -1513,11 +1517,11 @@ static void mos7840_throttle(struct tty_struct *tty) | |||
1513 | int status; | 1517 | int status; |
1514 | 1518 | ||
1515 | if (mos7840_port_paranoia_check(port, __func__)) { | 1519 | if (mos7840_port_paranoia_check(port, __func__)) { |
1516 | dbg("%s", "Invalid port \n"); | 1520 | dbg("%s", "Invalid port"); |
1517 | return; | 1521 | return; |
1518 | } | 1522 | } |
1519 | 1523 | ||
1520 | dbg("- port %d\n", port->number); | 1524 | dbg("- port %d", port->number); |
1521 | 1525 | ||
1522 | mos7840_port = mos7840_get_port_private(port); | 1526 | mos7840_port = mos7840_get_port_private(port); |
1523 | 1527 | ||
@@ -1525,11 +1529,11 @@ static void mos7840_throttle(struct tty_struct *tty) | |||
1525 | return; | 1529 | return; |
1526 | 1530 | ||
1527 | if (!mos7840_port->open) { | 1531 | if (!mos7840_port->open) { |
1528 | dbg("%s\n", "port not opened"); | 1532 | dbg("%s", "port not opened"); |
1529 | return; | 1533 | return; |
1530 | } | 1534 | } |
1531 | 1535 | ||
1532 | dbg("%s", "Entering .......... \n"); | 1536 | dbg("%s", "Entering .........."); |
1533 | 1537 | ||
1534 | /* if we are implementing XON/XOFF, send the stop character */ | 1538 | /* if we are implementing XON/XOFF, send the stop character */ |
1535 | if (I_IXOFF(tty)) { | 1539 | if (I_IXOFF(tty)) { |
@@ -1563,7 +1567,7 @@ static void mos7840_unthrottle(struct tty_struct *tty) | |||
1563 | struct moschip_port *mos7840_port = mos7840_get_port_private(port); | 1567 | struct moschip_port *mos7840_port = mos7840_get_port_private(port); |
1564 | 1568 | ||
1565 | if (mos7840_port_paranoia_check(port, __func__)) { | 1569 | if (mos7840_port_paranoia_check(port, __func__)) { |
1566 | dbg("%s", "Invalid port \n"); | 1570 | dbg("%s", "Invalid port"); |
1567 | return; | 1571 | return; |
1568 | } | 1572 | } |
1569 | 1573 | ||
@@ -1575,7 +1579,7 @@ static void mos7840_unthrottle(struct tty_struct *tty) | |||
1575 | return; | 1579 | return; |
1576 | } | 1580 | } |
1577 | 1581 | ||
1578 | dbg("%s", "Entering .......... \n"); | 1582 | dbg("%s", "Entering .........."); |
1579 | 1583 | ||
1580 | /* if we are implementing XON/XOFF, send the start character */ | 1584 | /* if we are implementing XON/XOFF, send the start character */ |
1581 | if (I_IXOFF(tty)) { | 1585 | if (I_IXOFF(tty)) { |
@@ -1660,7 +1664,7 @@ static int mos7840_tiocmset(struct tty_struct *tty, struct file *file, | |||
1660 | 1664 | ||
1661 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr); | 1665 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr); |
1662 | if (status < 0) { | 1666 | if (status < 0) { |
1663 | dbg("setting MODEM_CONTROL_REGISTER Failed\n"); | 1667 | dbg("setting MODEM_CONTROL_REGISTER Failed"); |
1664 | return status; | 1668 | return status; |
1665 | } | 1669 | } |
1666 | 1670 | ||
@@ -1729,11 +1733,11 @@ static int mos7840_calc_baud_rate_divisor(int baudRate, int *divisor, | |||
1729 | custom++; | 1733 | custom++; |
1730 | *divisor = custom; | 1734 | *divisor = custom; |
1731 | 1735 | ||
1732 | dbg(" Baud %d = %d\n", baudrate, custom); | 1736 | dbg(" Baud %d = %d", baudrate, custom); |
1733 | return 0; | 1737 | return 0; |
1734 | } | 1738 | } |
1735 | 1739 | ||
1736 | dbg("%s\n", " Baud calculation Failed..."); | 1740 | dbg("%s", " Baud calculation Failed..."); |
1737 | return -1; | 1741 | return -1; |
1738 | #endif | 1742 | #endif |
1739 | } | 1743 | } |
@@ -1759,16 +1763,16 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, | |||
1759 | 1763 | ||
1760 | port = (struct usb_serial_port *)mos7840_port->port; | 1764 | port = (struct usb_serial_port *)mos7840_port->port; |
1761 | if (mos7840_port_paranoia_check(port, __func__)) { | 1765 | if (mos7840_port_paranoia_check(port, __func__)) { |
1762 | dbg("%s", "Invalid port \n"); | 1766 | dbg("%s", "Invalid port"); |
1763 | return -1; | 1767 | return -1; |
1764 | } | 1768 | } |
1765 | 1769 | ||
1766 | if (mos7840_serial_paranoia_check(port->serial, __func__)) { | 1770 | if (mos7840_serial_paranoia_check(port->serial, __func__)) { |
1767 | dbg("%s", "Invalid Serial \n"); | 1771 | dbg("%s", "Invalid Serial"); |
1768 | return -1; | 1772 | return -1; |
1769 | } | 1773 | } |
1770 | 1774 | ||
1771 | dbg("%s", "Entering .......... \n"); | 1775 | dbg("%s", "Entering .........."); |
1772 | 1776 | ||
1773 | number = mos7840_port->port->number - mos7840_port->port->serial->minor; | 1777 | number = mos7840_port->port->number - mos7840_port->port->serial->minor; |
1774 | 1778 | ||
@@ -1784,7 +1788,7 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, | |||
1784 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, | 1788 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, |
1785 | Data); | 1789 | Data); |
1786 | if (status < 0) { | 1790 | if (status < 0) { |
1787 | dbg("Writing spreg failed in set_serial_baud\n"); | 1791 | dbg("Writing spreg failed in set_serial_baud"); |
1788 | return -1; | 1792 | return -1; |
1789 | } | 1793 | } |
1790 | #endif | 1794 | #endif |
@@ -1797,7 +1801,7 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, | |||
1797 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, | 1801 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, |
1798 | Data); | 1802 | Data); |
1799 | if (status < 0) { | 1803 | if (status < 0) { |
1800 | dbg("Writing spreg failed in set_serial_baud\n"); | 1804 | dbg("Writing spreg failed in set_serial_baud"); |
1801 | return -1; | 1805 | return -1; |
1802 | } | 1806 | } |
1803 | #endif | 1807 | #endif |
@@ -1812,14 +1816,14 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, | |||
1812 | status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, | 1816 | status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, |
1813 | &Data); | 1817 | &Data); |
1814 | if (status < 0) { | 1818 | if (status < 0) { |
1815 | dbg("reading spreg failed in set_serial_baud\n"); | 1819 | dbg("reading spreg failed in set_serial_baud"); |
1816 | return -1; | 1820 | return -1; |
1817 | } | 1821 | } |
1818 | Data = (Data & 0x8f) | clk_sel_val; | 1822 | Data = (Data & 0x8f) | clk_sel_val; |
1819 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, | 1823 | status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, |
1820 | Data); | 1824 | Data); |
1821 | if (status < 0) { | 1825 | if (status < 0) { |
1822 | dbg("Writing spreg failed in set_serial_baud\n"); | 1826 | dbg("Writing spreg failed in set_serial_baud"); |
1823 | return -1; | 1827 | return -1; |
1824 | } | 1828 | } |
1825 | /* Calculate the Divisor */ | 1829 | /* Calculate the Divisor */ |
@@ -1835,11 +1839,11 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, | |||
1835 | 1839 | ||
1836 | /* Write the divisor */ | 1840 | /* Write the divisor */ |
1837 | Data = (unsigned char)(divisor & 0xff); | 1841 | Data = (unsigned char)(divisor & 0xff); |
1838 | dbg("set_serial_baud Value to write DLL is %x\n", Data); | 1842 | dbg("set_serial_baud Value to write DLL is %x", Data); |
1839 | mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); | 1843 | mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); |
1840 | 1844 | ||
1841 | Data = (unsigned char)((divisor & 0xff00) >> 8); | 1845 | Data = (unsigned char)((divisor & 0xff00) >> 8); |
1842 | dbg("set_serial_baud Value to write DLM is %x\n", Data); | 1846 | dbg("set_serial_baud Value to write DLM is %x", Data); |
1843 | mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); | 1847 | mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); |
1844 | 1848 | ||
1845 | /* Disable access to divisor latch */ | 1849 | /* Disable access to divisor latch */ |
@@ -1877,12 +1881,12 @@ static void mos7840_change_port_settings(struct tty_struct *tty, | |||
1877 | port = (struct usb_serial_port *)mos7840_port->port; | 1881 | port = (struct usb_serial_port *)mos7840_port->port; |
1878 | 1882 | ||
1879 | if (mos7840_port_paranoia_check(port, __func__)) { | 1883 | if (mos7840_port_paranoia_check(port, __func__)) { |
1880 | dbg("%s", "Invalid port \n"); | 1884 | dbg("%s", "Invalid port"); |
1881 | return; | 1885 | return; |
1882 | } | 1886 | } |
1883 | 1887 | ||
1884 | if (mos7840_serial_paranoia_check(port->serial, __func__)) { | 1888 | if (mos7840_serial_paranoia_check(port->serial, __func__)) { |
1885 | dbg("%s", "Invalid Serial \n"); | 1889 | dbg("%s", "Invalid Serial"); |
1886 | return; | 1890 | return; |
1887 | } | 1891 | } |
1888 | 1892 | ||
@@ -1895,7 +1899,7 @@ static void mos7840_change_port_settings(struct tty_struct *tty, | |||
1895 | return; | 1899 | return; |
1896 | } | 1900 | } |
1897 | 1901 | ||
1898 | dbg("%s", "Entering .......... \n"); | 1902 | dbg("%s", "Entering .........."); |
1899 | 1903 | ||
1900 | lData = LCR_BITS_8; | 1904 | lData = LCR_BITS_8; |
1901 | lStop = LCR_STOP_1; | 1905 | lStop = LCR_STOP_1; |
@@ -1955,7 +1959,7 @@ static void mos7840_change_port_settings(struct tty_struct *tty, | |||
1955 | ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); | 1959 | ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); |
1956 | mos7840_port->shadowLCR |= (lData | lParity | lStop); | 1960 | mos7840_port->shadowLCR |= (lData | lParity | lStop); |
1957 | 1961 | ||
1958 | dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x\n", | 1962 | dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x", |
1959 | mos7840_port->shadowLCR); | 1963 | mos7840_port->shadowLCR); |
1960 | /* Disable Interrupts */ | 1964 | /* Disable Interrupts */ |
1961 | Data = 0x00; | 1965 | Data = 0x00; |
@@ -1997,7 +2001,7 @@ static void mos7840_change_port_settings(struct tty_struct *tty, | |||
1997 | 2001 | ||
1998 | if (!baud) { | 2002 | if (!baud) { |
1999 | /* pick a default, any default... */ | 2003 | /* pick a default, any default... */ |
2000 | dbg("%s\n", "Picked default baud..."); | 2004 | dbg("%s", "Picked default baud..."); |
2001 | baud = 9600; | 2005 | baud = 9600; |
2002 | } | 2006 | } |
2003 | 2007 | ||
@@ -2020,7 +2024,7 @@ static void mos7840_change_port_settings(struct tty_struct *tty, | |||
2020 | } | 2024 | } |
2021 | wake_up(&mos7840_port->delta_msr_wait); | 2025 | wake_up(&mos7840_port->delta_msr_wait); |
2022 | mos7840_port->delta_msr_cond = 1; | 2026 | mos7840_port->delta_msr_cond = 1; |
2023 | dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x\n", | 2027 | dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x", |
2024 | mos7840_port->shadowLCR); | 2028 | mos7840_port->shadowLCR); |
2025 | 2029 | ||
2026 | return; | 2030 | return; |
@@ -2040,16 +2044,16 @@ static void mos7840_set_termios(struct tty_struct *tty, | |||
2040 | unsigned int cflag; | 2044 | unsigned int cflag; |
2041 | struct usb_serial *serial; | 2045 | struct usb_serial *serial; |
2042 | struct moschip_port *mos7840_port; | 2046 | struct moschip_port *mos7840_port; |
2043 | dbg("mos7840_set_termios: START\n"); | 2047 | dbg("mos7840_set_termios: START"); |
2044 | if (mos7840_port_paranoia_check(port, __func__)) { | 2048 | if (mos7840_port_paranoia_check(port, __func__)) { |
2045 | dbg("%s", "Invalid port \n"); | 2049 | dbg("%s", "Invalid port"); |
2046 | return; | 2050 | return; |
2047 | } | 2051 | } |
2048 | 2052 | ||
2049 | serial = port->serial; | 2053 | serial = port->serial; |
2050 | 2054 | ||
2051 | if (mos7840_serial_paranoia_check(serial, __func__)) { | 2055 | if (mos7840_serial_paranoia_check(serial, __func__)) { |
2052 | dbg("%s", "Invalid Serial \n"); | 2056 | dbg("%s", "Invalid Serial"); |
2053 | return; | 2057 | return; |
2054 | } | 2058 | } |
2055 | 2059 | ||
@@ -2063,7 +2067,7 @@ static void mos7840_set_termios(struct tty_struct *tty, | |||
2063 | return; | 2067 | return; |
2064 | } | 2068 | } |
2065 | 2069 | ||
2066 | dbg("%s\n", "setting termios - "); | 2070 | dbg("%s", "setting termios - "); |
2067 | 2071 | ||
2068 | cflag = tty->termios->c_cflag; | 2072 | cflag = tty->termios->c_cflag; |
2069 | 2073 | ||
@@ -2078,7 +2082,7 @@ static void mos7840_set_termios(struct tty_struct *tty, | |||
2078 | mos7840_change_port_settings(tty, mos7840_port, old_termios); | 2082 | mos7840_change_port_settings(tty, mos7840_port, old_termios); |
2079 | 2083 | ||
2080 | if (!mos7840_port->read_urb) { | 2084 | if (!mos7840_port->read_urb) { |
2081 | dbg("%s", "URB KILLED !!!!!\n"); | 2085 | dbg("%s", "URB KILLED !!!!!"); |
2082 | return; | 2086 | return; |
2083 | } | 2087 | } |
2084 | 2088 | ||
@@ -2144,7 +2148,7 @@ static int mos7840_set_modem_info(struct moschip_port *mos7840_port, | |||
2144 | 2148 | ||
2145 | port = (struct usb_serial_port *)mos7840_port->port; | 2149 | port = (struct usb_serial_port *)mos7840_port->port; |
2146 | if (mos7840_port_paranoia_check(port, __func__)) { | 2150 | if (mos7840_port_paranoia_check(port, __func__)) { |
2147 | dbg("%s", "Invalid port \n"); | 2151 | dbg("%s", "Invalid port"); |
2148 | return -1; | 2152 | return -1; |
2149 | } | 2153 | } |
2150 | 2154 | ||
@@ -2189,7 +2193,7 @@ static int mos7840_set_modem_info(struct moschip_port *mos7840_port, | |||
2189 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); | 2193 | status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
2190 | unlock_kernel(); | 2194 | unlock_kernel(); |
2191 | if (status < 0) { | 2195 | if (status < 0) { |
2192 | dbg("setting MODEM_CONTROL_REGISTER Failed\n"); | 2196 | dbg("setting MODEM_CONTROL_REGISTER Failed"); |
2193 | return -1; | 2197 | return -1; |
2194 | } | 2198 | } |
2195 | 2199 | ||
@@ -2274,7 +2278,7 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file, | |||
2274 | int mosret = 0; | 2278 | int mosret = 0; |
2275 | 2279 | ||
2276 | if (mos7840_port_paranoia_check(port, __func__)) { | 2280 | if (mos7840_port_paranoia_check(port, __func__)) { |
2277 | dbg("%s", "Invalid port \n"); | 2281 | dbg("%s", "Invalid port"); |
2278 | return -1; | 2282 | return -1; |
2279 | } | 2283 | } |
2280 | 2284 | ||
@@ -2374,9 +2378,8 @@ static int mos7840_calc_num_ports(struct usb_serial *serial) | |||
2374 | { | 2378 | { |
2375 | int mos7840_num_ports = 0; | 2379 | int mos7840_num_ports = 0; |
2376 | 2380 | ||
2377 | dbg("numberofendpoints: %d \n", | 2381 | dbg("numberofendpoints: cur %d, alt %d", |
2378 | (int)serial->interface->cur_altsetting->desc.bNumEndpoints); | 2382 | (int)serial->interface->cur_altsetting->desc.bNumEndpoints, |
2379 | dbg("numberofendpoints: %d \n", | ||
2380 | (int)serial->interface->altsetting->desc.bNumEndpoints); | 2383 | (int)serial->interface->altsetting->desc.bNumEndpoints); |
2381 | if (serial->interface->cur_altsetting->desc.bNumEndpoints == 5) { | 2384 | if (serial->interface->cur_altsetting->desc.bNumEndpoints == 5) { |
2382 | mos7840_num_ports = serial->num_ports = 2; | 2385 | mos7840_num_ports = serial->num_ports = 2; |
@@ -2385,7 +2388,7 @@ static int mos7840_calc_num_ports(struct usb_serial *serial) | |||
2385 | serial->num_bulk_out = 4; | 2388 | serial->num_bulk_out = 4; |
2386 | mos7840_num_ports = serial->num_ports = 4; | 2389 | mos7840_num_ports = serial->num_ports = 4; |
2387 | } | 2390 | } |
2388 | 2391 | dbg ("mos7840_num_ports = %d", mos7840_num_ports); | |
2389 | return mos7840_num_ports; | 2392 | return mos7840_num_ports; |
2390 | } | 2393 | } |
2391 | 2394 | ||
@@ -2400,22 +2403,24 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2400 | int i, status; | 2403 | int i, status; |
2401 | 2404 | ||
2402 | __u16 Data; | 2405 | __u16 Data; |
2403 | dbg("%s \n", " mos7840_startup :entering.........."); | 2406 | dbg("%s", "mos7840_startup :Entering.........."); |
2404 | 2407 | ||
2405 | if (!serial) { | 2408 | if (!serial) { |
2406 | dbg("%s\n", "Invalid Handler"); | 2409 | dbg("%s", "Invalid Handler"); |
2407 | return -1; | 2410 | return -1; |
2408 | } | 2411 | } |
2409 | 2412 | ||
2410 | dev = serial->dev; | 2413 | dev = serial->dev; |
2411 | 2414 | ||
2412 | dbg("%s\n", "Entering..."); | 2415 | dbg("%s", "Entering..."); |
2416 | dbg ("mos7840_startup: serial = %p", serial); | ||
2413 | 2417 | ||
2414 | /* we set up the pointers to the endpoints in the mos7840_open * | 2418 | /* we set up the pointers to the endpoints in the mos7840_open * |
2415 | * function, as the structures aren't created yet. */ | 2419 | * function, as the structures aren't created yet. */ |
2416 | 2420 | ||
2417 | /* set up port private structures */ | 2421 | /* set up port private structures */ |
2418 | for (i = 0; i < serial->num_ports; ++i) { | 2422 | for (i = 0; i < serial->num_ports; ++i) { |
2423 | dbg ("mos7840_startup: configuring port %d............", i); | ||
2419 | mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL); | 2424 | mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL); |
2420 | if (mos7840_port == NULL) { | 2425 | if (mos7840_port == NULL) { |
2421 | dev_err(&dev->dev, "%s - Out of memory\n", __func__); | 2426 | dev_err(&dev->dev, "%s - Out of memory\n", __func__); |
@@ -2473,10 +2478,10 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2473 | status = mos7840_get_reg_sync(serial->port[i], | 2478 | status = mos7840_get_reg_sync(serial->port[i], |
2474 | mos7840_port->ControlRegOffset, &Data); | 2479 | mos7840_port->ControlRegOffset, &Data); |
2475 | if (status < 0) { | 2480 | if (status < 0) { |
2476 | dbg("Reading ControlReg failed status-0x%x\n", status); | 2481 | dbg("Reading ControlReg failed status-0x%x", status); |
2477 | break; | 2482 | break; |
2478 | } else | 2483 | } else |
2479 | dbg("ControlReg Reading success val is %x, status%d\n", | 2484 | dbg("ControlReg Reading success val is %x, status%d", |
2480 | Data, status); | 2485 | Data, status); |
2481 | Data |= 0x08; /* setting driver done bit */ | 2486 | Data |= 0x08; /* setting driver done bit */ |
2482 | Data |= 0x04; /* sp1_bit to have cts change reflect in | 2487 | Data |= 0x04; /* sp1_bit to have cts change reflect in |
@@ -2486,10 +2491,10 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2486 | status = mos7840_set_reg_sync(serial->port[i], | 2491 | status = mos7840_set_reg_sync(serial->port[i], |
2487 | mos7840_port->ControlRegOffset, Data); | 2492 | mos7840_port->ControlRegOffset, Data); |
2488 | if (status < 0) { | 2493 | if (status < 0) { |
2489 | dbg("Writing ControlReg failed(rx_disable) status-0x%x\n", status); | 2494 | dbg("Writing ControlReg failed(rx_disable) status-0x%x", status); |
2490 | break; | 2495 | break; |
2491 | } else | 2496 | } else |
2492 | dbg("ControlReg Writing success(rx_disable) status%d\n", | 2497 | dbg("ControlReg Writing success(rx_disable) status%d", |
2493 | status); | 2498 | status); |
2494 | 2499 | ||
2495 | /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 | 2500 | /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 |
@@ -2498,48 +2503,48 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2498 | status = mos7840_set_reg_sync(serial->port[i], | 2503 | status = mos7840_set_reg_sync(serial->port[i], |
2499 | (__u16) (mos7840_port->DcrRegOffset + 0), Data); | 2504 | (__u16) (mos7840_port->DcrRegOffset + 0), Data); |
2500 | if (status < 0) { | 2505 | if (status < 0) { |
2501 | dbg("Writing DCR0 failed status-0x%x\n", status); | 2506 | dbg("Writing DCR0 failed status-0x%x", status); |
2502 | break; | 2507 | break; |
2503 | } else | 2508 | } else |
2504 | dbg("DCR0 Writing success status%d\n", status); | 2509 | dbg("DCR0 Writing success status%d", status); |
2505 | 2510 | ||
2506 | Data = 0x05; | 2511 | Data = 0x05; |
2507 | status = mos7840_set_reg_sync(serial->port[i], | 2512 | status = mos7840_set_reg_sync(serial->port[i], |
2508 | (__u16) (mos7840_port->DcrRegOffset + 1), Data); | 2513 | (__u16) (mos7840_port->DcrRegOffset + 1), Data); |
2509 | if (status < 0) { | 2514 | if (status < 0) { |
2510 | dbg("Writing DCR1 failed status-0x%x\n", status); | 2515 | dbg("Writing DCR1 failed status-0x%x", status); |
2511 | break; | 2516 | break; |
2512 | } else | 2517 | } else |
2513 | dbg("DCR1 Writing success status%d\n", status); | 2518 | dbg("DCR1 Writing success status%d", status); |
2514 | 2519 | ||
2515 | Data = 0x24; | 2520 | Data = 0x24; |
2516 | status = mos7840_set_reg_sync(serial->port[i], | 2521 | status = mos7840_set_reg_sync(serial->port[i], |
2517 | (__u16) (mos7840_port->DcrRegOffset + 2), Data); | 2522 | (__u16) (mos7840_port->DcrRegOffset + 2), Data); |
2518 | if (status < 0) { | 2523 | if (status < 0) { |
2519 | dbg("Writing DCR2 failed status-0x%x\n", status); | 2524 | dbg("Writing DCR2 failed status-0x%x", status); |
2520 | break; | 2525 | break; |
2521 | } else | 2526 | } else |
2522 | dbg("DCR2 Writing success status%d\n", status); | 2527 | dbg("DCR2 Writing success status%d", status); |
2523 | 2528 | ||
2524 | /* write values in clkstart0x0 and clkmulti 0x20 */ | 2529 | /* write values in clkstart0x0 and clkmulti 0x20 */ |
2525 | Data = 0x0; | 2530 | Data = 0x0; |
2526 | status = mos7840_set_reg_sync(serial->port[i], | 2531 | status = mos7840_set_reg_sync(serial->port[i], |
2527 | CLK_START_VALUE_REGISTER, Data); | 2532 | CLK_START_VALUE_REGISTER, Data); |
2528 | if (status < 0) { | 2533 | if (status < 0) { |
2529 | dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status); | 2534 | dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x", status); |
2530 | break; | 2535 | break; |
2531 | } else | 2536 | } else |
2532 | dbg("CLK_START_VALUE_REGISTER Writing success status%d\n", status); | 2537 | dbg("CLK_START_VALUE_REGISTER Writing success status%d", status); |
2533 | 2538 | ||
2534 | Data = 0x20; | 2539 | Data = 0x20; |
2535 | status = mos7840_set_reg_sync(serial->port[i], | 2540 | status = mos7840_set_reg_sync(serial->port[i], |
2536 | CLK_MULTI_REGISTER, Data); | 2541 | CLK_MULTI_REGISTER, Data); |
2537 | if (status < 0) { | 2542 | if (status < 0) { |
2538 | dbg("Writing CLK_MULTI_REGISTER failed status-0x%x\n", | 2543 | dbg("Writing CLK_MULTI_REGISTER failed status-0x%x", |
2539 | status); | 2544 | status); |
2540 | goto error; | 2545 | goto error; |
2541 | } else | 2546 | } else |
2542 | dbg("CLK_MULTI_REGISTER Writing success status%d\n", | 2547 | dbg("CLK_MULTI_REGISTER Writing success status%d", |
2543 | status); | 2548 | status); |
2544 | 2549 | ||
2545 | /* write value 0x0 to scratchpad register */ | 2550 | /* write value 0x0 to scratchpad register */ |
@@ -2547,11 +2552,11 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2547 | status = mos7840_set_uart_reg(serial->port[i], | 2552 | status = mos7840_set_uart_reg(serial->port[i], |
2548 | SCRATCH_PAD_REGISTER, Data); | 2553 | SCRATCH_PAD_REGISTER, Data); |
2549 | if (status < 0) { | 2554 | if (status < 0) { |
2550 | dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", | 2555 | dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x", |
2551 | status); | 2556 | status); |
2552 | break; | 2557 | break; |
2553 | } else | 2558 | } else |
2554 | dbg("SCRATCH_PAD_REGISTER Writing success status%d\n", | 2559 | dbg("SCRATCH_PAD_REGISTER Writing success status%d", |
2555 | status); | 2560 | status); |
2556 | 2561 | ||
2557 | /* Zero Length flag register */ | 2562 | /* Zero Length flag register */ |
@@ -2562,30 +2567,30 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2562 | status = mos7840_set_reg_sync(serial->port[i], | 2567 | status = mos7840_set_reg_sync(serial->port[i], |
2563 | (__u16) (ZLP_REG1 + | 2568 | (__u16) (ZLP_REG1 + |
2564 | ((__u16)mos7840_port->port_num)), Data); | 2569 | ((__u16)mos7840_port->port_num)), Data); |
2565 | dbg("ZLIP offset%x\n", | 2570 | dbg("ZLIP offset %x", |
2566 | (__u16) (ZLP_REG1 + | 2571 | (__u16) (ZLP_REG1 + |
2567 | ((__u16) mos7840_port->port_num))); | 2572 | ((__u16) mos7840_port->port_num))); |
2568 | if (status < 0) { | 2573 | if (status < 0) { |
2569 | dbg("Writing ZLP_REG%d failed status-0x%x\n", | 2574 | dbg("Writing ZLP_REG%d failed status-0x%x", |
2570 | i + 2, status); | 2575 | i + 2, status); |
2571 | break; | 2576 | break; |
2572 | } else | 2577 | } else |
2573 | dbg("ZLP_REG%d Writing success status%d\n", | 2578 | dbg("ZLP_REG%d Writing success status%d", |
2574 | i + 2, status); | 2579 | i + 2, status); |
2575 | } else { | 2580 | } else { |
2576 | Data = 0xff; | 2581 | Data = 0xff; |
2577 | status = mos7840_set_reg_sync(serial->port[i], | 2582 | status = mos7840_set_reg_sync(serial->port[i], |
2578 | (__u16) (ZLP_REG1 + | 2583 | (__u16) (ZLP_REG1 + |
2579 | ((__u16)mos7840_port->port_num) - 0x1), Data); | 2584 | ((__u16)mos7840_port->port_num) - 0x1), Data); |
2580 | dbg("ZLIP offset%x\n", | 2585 | dbg("ZLIP offset %x", |
2581 | (__u16) (ZLP_REG1 + | 2586 | (__u16) (ZLP_REG1 + |
2582 | ((__u16) mos7840_port->port_num) - 0x1)); | 2587 | ((__u16) mos7840_port->port_num) - 0x1)); |
2583 | if (status < 0) { | 2588 | if (status < 0) { |
2584 | dbg("Writing ZLP_REG%d failed status-0x%x\n", | 2589 | dbg("Writing ZLP_REG%d failed status-0x%x", |
2585 | i + 1, status); | 2590 | i + 1, status); |
2586 | break; | 2591 | break; |
2587 | } else | 2592 | } else |
2588 | dbg("ZLP_REG%d Writing success status%d\n", | 2593 | dbg("ZLP_REG%d Writing success status%d", |
2589 | i + 1, status); | 2594 | i + 1, status); |
2590 | 2595 | ||
2591 | } | 2596 | } |
@@ -2599,15 +2604,16 @@ static int mos7840_startup(struct usb_serial *serial) | |||
2599 | goto error; | 2604 | goto error; |
2600 | } | 2605 | } |
2601 | } | 2606 | } |
2607 | dbg ("mos7840_startup: all ports configured..........."); | ||
2602 | 2608 | ||
2603 | /* Zero Length flag enable */ | 2609 | /* Zero Length flag enable */ |
2604 | Data = 0x0f; | 2610 | Data = 0x0f; |
2605 | status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data); | 2611 | status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data); |
2606 | if (status < 0) { | 2612 | if (status < 0) { |
2607 | dbg("Writing ZLP_REG5 failed status-0x%x\n", status); | 2613 | dbg("Writing ZLP_REG5 failed status-0x%x", status); |
2608 | goto error; | 2614 | goto error; |
2609 | } else | 2615 | } else |
2610 | dbg("ZLP_REG5 Writing success status%d\n", status); | 2616 | dbg("ZLP_REG5 Writing success status%d", status); |
2611 | 2617 | ||
2612 | /* setting configuration feature to one */ | 2618 | /* setting configuration feature to one */ |
2613 | usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), | 2619 | usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
@@ -2627,19 +2633,19 @@ error: | |||
2627 | } | 2633 | } |
2628 | 2634 | ||
2629 | /**************************************************************************** | 2635 | /**************************************************************************** |
2630 | * mos7840_shutdown | 2636 | * mos7840_disconnect |
2631 | * This function is called whenever the device is removed from the usb bus. | 2637 | * This function is called whenever the device is removed from the usb bus. |
2632 | ****************************************************************************/ | 2638 | ****************************************************************************/ |
2633 | 2639 | ||
2634 | static void mos7840_shutdown(struct usb_serial *serial) | 2640 | static void mos7840_disconnect(struct usb_serial *serial) |
2635 | { | 2641 | { |
2636 | int i; | 2642 | int i; |
2637 | unsigned long flags; | 2643 | unsigned long flags; |
2638 | struct moschip_port *mos7840_port; | 2644 | struct moschip_port *mos7840_port; |
2639 | dbg("%s \n", " shutdown :entering.........."); | 2645 | dbg("%s", " disconnect :entering.........."); |
2640 | 2646 | ||
2641 | if (!serial) { | 2647 | if (!serial) { |
2642 | dbg("%s", "Invalid Handler \n"); | 2648 | dbg("%s", "Invalid Handler"); |
2643 | return; | 2649 | return; |
2644 | } | 2650 | } |
2645 | 2651 | ||
@@ -2656,14 +2662,45 @@ static void mos7840_shutdown(struct usb_serial *serial) | |||
2656 | mos7840_port->zombie = 1; | 2662 | mos7840_port->zombie = 1; |
2657 | spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); | 2663 | spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); |
2658 | usb_kill_urb(mos7840_port->control_urb); | 2664 | usb_kill_urb(mos7840_port->control_urb); |
2665 | } | ||
2666 | } | ||
2667 | |||
2668 | dbg("%s", "Thank u :: "); | ||
2669 | |||
2670 | } | ||
2671 | |||
2672 | /**************************************************************************** | ||
2673 | * mos7840_release | ||
2674 | * This function is called when the usb_serial structure is freed. | ||
2675 | ****************************************************************************/ | ||
2676 | |||
2677 | static void mos7840_release(struct usb_serial *serial) | ||
2678 | { | ||
2679 | int i; | ||
2680 | struct moschip_port *mos7840_port; | ||
2681 | dbg("%s", " release :entering.........."); | ||
2682 | |||
2683 | if (!serial) { | ||
2684 | dbg("%s", "Invalid Handler"); | ||
2685 | return; | ||
2686 | } | ||
2687 | |||
2688 | /* check for the ports to be closed,close the ports and disconnect */ | ||
2689 | |||
2690 | /* free private structure allocated for serial port * | ||
2691 | * stop reads and writes on all ports */ | ||
2692 | |||
2693 | for (i = 0; i < serial->num_ports; ++i) { | ||
2694 | mos7840_port = mos7840_get_port_private(serial->port[i]); | ||
2695 | dbg("mos7840_port %d = %p", i, mos7840_port); | ||
2696 | if (mos7840_port) { | ||
2659 | kfree(mos7840_port->ctrl_buf); | 2697 | kfree(mos7840_port->ctrl_buf); |
2660 | kfree(mos7840_port->dr); | 2698 | kfree(mos7840_port->dr); |
2661 | kfree(mos7840_port); | 2699 | kfree(mos7840_port); |
2662 | } | 2700 | } |
2663 | mos7840_set_port_private(serial->port[i], NULL); | ||
2664 | } | 2701 | } |
2665 | 2702 | ||
2666 | dbg("%s\n", "Thank u :: "); | 2703 | dbg("%s", "Thank u :: "); |
2667 | 2704 | ||
2668 | } | 2705 | } |
2669 | 2706 | ||
@@ -2701,7 +2738,8 @@ static struct usb_serial_driver moschip7840_4port_device = { | |||
2701 | .tiocmget = mos7840_tiocmget, | 2738 | .tiocmget = mos7840_tiocmget, |
2702 | .tiocmset = mos7840_tiocmset, | 2739 | .tiocmset = mos7840_tiocmset, |
2703 | .attach = mos7840_startup, | 2740 | .attach = mos7840_startup, |
2704 | .shutdown = mos7840_shutdown, | 2741 | .disconnect = mos7840_disconnect, |
2742 | .release = mos7840_release, | ||
2705 | .read_bulk_callback = mos7840_bulk_in_callback, | 2743 | .read_bulk_callback = mos7840_bulk_in_callback, |
2706 | .read_int_callback = mos7840_interrupt_callback, | 2744 | .read_int_callback = mos7840_interrupt_callback, |
2707 | }; | 2745 | }; |
@@ -2714,7 +2752,7 @@ static int __init moschip7840_init(void) | |||
2714 | { | 2752 | { |
2715 | int retval; | 2753 | int retval; |
2716 | 2754 | ||
2717 | dbg("%s \n", " mos7840_init :entering.........."); | 2755 | dbg("%s", " mos7840_init :entering.........."); |
2718 | 2756 | ||
2719 | /* Register with the usb serial */ | 2757 | /* Register with the usb serial */ |
2720 | retval = usb_serial_register(&moschip7840_4port_device); | 2758 | retval = usb_serial_register(&moschip7840_4port_device); |
@@ -2722,14 +2760,14 @@ static int __init moschip7840_init(void) | |||
2722 | if (retval) | 2760 | if (retval) |
2723 | goto failed_port_device_register; | 2761 | goto failed_port_device_register; |
2724 | 2762 | ||
2725 | dbg("%s\n", "Entring..."); | 2763 | dbg("%s", "Entering..."); |
2726 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" | 2764 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" |
2727 | DRIVER_DESC "\n"); | 2765 | DRIVER_DESC "\n"); |
2728 | 2766 | ||
2729 | /* Register with the usb */ | 2767 | /* Register with the usb */ |
2730 | retval = usb_register(&io_driver); | 2768 | retval = usb_register(&io_driver); |
2731 | if (retval == 0) { | 2769 | if (retval == 0) { |
2732 | dbg("%s\n", "Leaving..."); | 2770 | dbg("%s", "Leaving..."); |
2733 | return 0; | 2771 | return 0; |
2734 | } | 2772 | } |
2735 | usb_serial_deregister(&moschip7840_4port_device); | 2773 | usb_serial_deregister(&moschip7840_4port_device); |
@@ -2744,13 +2782,13 @@ failed_port_device_register: | |||
2744 | static void __exit moschip7840_exit(void) | 2782 | static void __exit moschip7840_exit(void) |
2745 | { | 2783 | { |
2746 | 2784 | ||
2747 | dbg("%s \n", " mos7840_exit :entering.........."); | 2785 | dbg("%s", " mos7840_exit :entering.........."); |
2748 | 2786 | ||
2749 | usb_deregister(&io_driver); | 2787 | usb_deregister(&io_driver); |
2750 | 2788 | ||
2751 | usb_serial_deregister(&moschip7840_4port_device); | 2789 | usb_serial_deregister(&moschip7840_4port_device); |
2752 | 2790 | ||
2753 | dbg("%s\n", "Entring..."); | 2791 | dbg("%s", "Entering..."); |
2754 | } | 2792 | } |
2755 | 2793 | ||
2756 | module_init(moschip7840_init); | 2794 | module_init(moschip7840_init); |
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c index 1104617334f5..56857ddbd70b 100644 --- a/drivers/usb/serial/omninet.c +++ b/drivers/usb/serial/omninet.c | |||
@@ -72,7 +72,8 @@ static void omninet_write_bulk_callback(struct urb *urb); | |||
72 | static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port, | 72 | static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port, |
73 | const unsigned char *buf, int count); | 73 | const unsigned char *buf, int count); |
74 | static int omninet_write_room(struct tty_struct *tty); | 74 | static int omninet_write_room(struct tty_struct *tty); |
75 | static void omninet_shutdown(struct usb_serial *serial); | 75 | static void omninet_disconnect(struct usb_serial *serial); |
76 | static void omninet_release(struct usb_serial *serial); | ||
76 | static int omninet_attach(struct usb_serial *serial); | 77 | static int omninet_attach(struct usb_serial *serial); |
77 | 78 | ||
78 | static struct usb_device_id id_table[] = { | 79 | static struct usb_device_id id_table[] = { |
@@ -108,7 +109,8 @@ static struct usb_serial_driver zyxel_omninet_device = { | |||
108 | .write_room = omninet_write_room, | 109 | .write_room = omninet_write_room, |
109 | .read_bulk_callback = omninet_read_bulk_callback, | 110 | .read_bulk_callback = omninet_read_bulk_callback, |
110 | .write_bulk_callback = omninet_write_bulk_callback, | 111 | .write_bulk_callback = omninet_write_bulk_callback, |
111 | .shutdown = omninet_shutdown, | 112 | .disconnect = omninet_disconnect, |
113 | .release = omninet_release, | ||
112 | }; | 114 | }; |
113 | 115 | ||
114 | 116 | ||
@@ -345,13 +347,22 @@ static void omninet_write_bulk_callback(struct urb *urb) | |||
345 | } | 347 | } |
346 | 348 | ||
347 | 349 | ||
348 | static void omninet_shutdown(struct usb_serial *serial) | 350 | static void omninet_disconnect(struct usb_serial *serial) |
349 | { | 351 | { |
350 | struct usb_serial_port *wport = serial->port[1]; | 352 | struct usb_serial_port *wport = serial->port[1]; |
351 | struct usb_serial_port *port = serial->port[0]; | 353 | |
352 | dbg("%s", __func__); | 354 | dbg("%s", __func__); |
353 | 355 | ||
354 | usb_kill_urb(wport->write_urb); | 356 | usb_kill_urb(wport->write_urb); |
357 | } | ||
358 | |||
359 | |||
360 | static void omninet_release(struct usb_serial *serial) | ||
361 | { | ||
362 | struct usb_serial_port *port = serial->port[0]; | ||
363 | |||
364 | dbg("%s", __func__); | ||
365 | |||
355 | kfree(usb_get_serial_port_data(port)); | 366 | kfree(usb_get_serial_port_data(port)); |
356 | } | 367 | } |
357 | 368 | ||
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c index c20480aa9755..336bba79ad32 100644 --- a/drivers/usb/serial/opticon.c +++ b/drivers/usb/serial/opticon.c | |||
@@ -463,7 +463,7 @@ error: | |||
463 | return retval; | 463 | return retval; |
464 | } | 464 | } |
465 | 465 | ||
466 | static void opticon_shutdown(struct usb_serial *serial) | 466 | static void opticon_disconnect(struct usb_serial *serial) |
467 | { | 467 | { |
468 | struct opticon_private *priv = usb_get_serial_data(serial); | 468 | struct opticon_private *priv = usb_get_serial_data(serial); |
469 | 469 | ||
@@ -471,9 +471,16 @@ static void opticon_shutdown(struct usb_serial *serial) | |||
471 | 471 | ||
472 | usb_kill_urb(priv->bulk_read_urb); | 472 | usb_kill_urb(priv->bulk_read_urb); |
473 | usb_free_urb(priv->bulk_read_urb); | 473 | usb_free_urb(priv->bulk_read_urb); |
474 | } | ||
475 | |||
476 | static void opticon_release(struct usb_serial *serial) | ||
477 | { | ||
478 | struct opticon_private *priv = usb_get_serial_data(serial); | ||
479 | |||
480 | dbg("%s", __func__); | ||
481 | |||
474 | kfree(priv->bulk_in_buffer); | 482 | kfree(priv->bulk_in_buffer); |
475 | kfree(priv); | 483 | kfree(priv); |
476 | usb_set_serial_data(serial, NULL); | ||
477 | } | 484 | } |
478 | 485 | ||
479 | static int opticon_suspend(struct usb_interface *intf, pm_message_t message) | 486 | static int opticon_suspend(struct usb_interface *intf, pm_message_t message) |
@@ -524,7 +531,8 @@ static struct usb_serial_driver opticon_device = { | |||
524 | .close = opticon_close, | 531 | .close = opticon_close, |
525 | .write = opticon_write, | 532 | .write = opticon_write, |
526 | .write_room = opticon_write_room, | 533 | .write_room = opticon_write_room, |
527 | .shutdown = opticon_shutdown, | 534 | .disconnect = opticon_disconnect, |
535 | .release = opticon_release, | ||
528 | .throttle = opticon_throttle, | 536 | .throttle = opticon_throttle, |
529 | .unthrottle = opticon_unthrottle, | 537 | .unthrottle = opticon_unthrottle, |
530 | .ioctl = opticon_ioctl, | 538 | .ioctl = opticon_ioctl, |
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c index a16d69fadba1..575816e6ba37 100644 --- a/drivers/usb/serial/option.c +++ b/drivers/usb/serial/option.c | |||
@@ -43,13 +43,16 @@ | |||
43 | #include <linux/usb/serial.h> | 43 | #include <linux/usb/serial.h> |
44 | 44 | ||
45 | /* Function prototypes */ | 45 | /* Function prototypes */ |
46 | static int option_probe(struct usb_serial *serial, | ||
47 | const struct usb_device_id *id); | ||
46 | static int option_open(struct tty_struct *tty, struct usb_serial_port *port, | 48 | static int option_open(struct tty_struct *tty, struct usb_serial_port *port, |
47 | struct file *filp); | 49 | struct file *filp); |
48 | static void option_close(struct usb_serial_port *port); | 50 | static void option_close(struct usb_serial_port *port); |
49 | static void option_dtr_rts(struct usb_serial_port *port, int on); | 51 | static void option_dtr_rts(struct usb_serial_port *port, int on); |
50 | 52 | ||
51 | static int option_startup(struct usb_serial *serial); | 53 | static int option_startup(struct usb_serial *serial); |
52 | static void option_shutdown(struct usb_serial *serial); | 54 | static void option_disconnect(struct usb_serial *serial); |
55 | static void option_release(struct usb_serial *serial); | ||
53 | static int option_write_room(struct tty_struct *tty); | 56 | static int option_write_room(struct tty_struct *tty); |
54 | 57 | ||
55 | static void option_instat_callback(struct urb *urb); | 58 | static void option_instat_callback(struct urb *urb); |
@@ -202,9 +205,9 @@ static int option_resume(struct usb_serial *serial); | |||
202 | #define NOVATELWIRELESS_PRODUCT_MC727 0x4100 | 205 | #define NOVATELWIRELESS_PRODUCT_MC727 0x4100 |
203 | #define NOVATELWIRELESS_PRODUCT_MC950D 0x4400 | 206 | #define NOVATELWIRELESS_PRODUCT_MC950D 0x4400 |
204 | #define NOVATELWIRELESS_PRODUCT_U727 0x5010 | 207 | #define NOVATELWIRELESS_PRODUCT_U727 0x5010 |
208 | #define NOVATELWIRELESS_PRODUCT_MC760 0x6000 | ||
205 | 209 | ||
206 | /* FUTURE NOVATEL PRODUCTS */ | 210 | /* FUTURE NOVATEL PRODUCTS */ |
207 | #define NOVATELWIRELESS_PRODUCT_EVDO_FULLSPEED 0X6000 | ||
208 | #define NOVATELWIRELESS_PRODUCT_EVDO_HIGHSPEED 0X6001 | 211 | #define NOVATELWIRELESS_PRODUCT_EVDO_HIGHSPEED 0X6001 |
209 | #define NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED 0X7000 | 212 | #define NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED 0X7000 |
210 | #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED 0X7001 | 213 | #define NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED 0X7001 |
@@ -305,6 +308,10 @@ static int option_resume(struct usb_serial *serial); | |||
305 | #define DLINK_PRODUCT_DWM_652 0x3e04 | 308 | #define DLINK_PRODUCT_DWM_652 0x3e04 |
306 | 309 | ||
307 | 310 | ||
311 | /* TOSHIBA PRODUCTS */ | ||
312 | #define TOSHIBA_VENDOR_ID 0x0930 | ||
313 | #define TOSHIBA_PRODUCT_HSDPA_MINICARD 0x1302 | ||
314 | |||
308 | static struct usb_device_id option_ids[] = { | 315 | static struct usb_device_id option_ids[] = { |
309 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) }, | 316 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) }, |
310 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) }, | 317 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) }, |
@@ -422,7 +429,7 @@ static struct usb_device_id option_ids[] = { | |||
422 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) }, /* Novatel MC930D/MC950D */ | 429 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) }, /* Novatel MC930D/MC950D */ |
423 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) }, /* Novatel MC727/U727/USB727 */ | 430 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) }, /* Novatel MC727/U727/USB727 */ |
424 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U727) }, /* Novatel MC727/U727/USB727 */ | 431 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U727) }, /* Novatel MC727/U727/USB727 */ |
425 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_FULLSPEED) }, /* Novatel EVDO product */ | 432 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC760) }, /* Novatel MC760/U760/USB760 */ |
426 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED) }, /* Novatel HSPA product */ | 433 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_FULLSPEED) }, /* Novatel HSPA product */ |
427 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_FULLSPEED) }, /* Novatel EVDO Embedded product */ | 434 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_FULLSPEED) }, /* Novatel EVDO Embedded product */ |
428 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED) }, /* Novatel HSPA Embedded product */ | 435 | { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED) }, /* Novatel HSPA Embedded product */ |
@@ -523,6 +530,7 @@ static struct usb_device_id option_ids[] = { | |||
523 | { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) }, | 530 | { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) }, |
524 | { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) }, | 531 | { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) }, |
525 | { USB_DEVICE(0x1da5, 0x4515) }, /* BenQ H20 */ | 532 | { USB_DEVICE(0x1da5, 0x4515) }, /* BenQ H20 */ |
533 | { USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_HSDPA_MINICARD ) }, /* Toshiba 3G HSDPA == Novatel Expedite EU870D MiniCard */ | ||
526 | { } /* Terminating entry */ | 534 | { } /* Terminating entry */ |
527 | }; | 535 | }; |
528 | MODULE_DEVICE_TABLE(usb, option_ids); | 536 | MODULE_DEVICE_TABLE(usb, option_ids); |
@@ -550,6 +558,7 @@ static struct usb_serial_driver option_1port_device = { | |||
550 | .usb_driver = &option_driver, | 558 | .usb_driver = &option_driver, |
551 | .id_table = option_ids, | 559 | .id_table = option_ids, |
552 | .num_ports = 1, | 560 | .num_ports = 1, |
561 | .probe = option_probe, | ||
553 | .open = option_open, | 562 | .open = option_open, |
554 | .close = option_close, | 563 | .close = option_close, |
555 | .dtr_rts = option_dtr_rts, | 564 | .dtr_rts = option_dtr_rts, |
@@ -560,7 +569,8 @@ static struct usb_serial_driver option_1port_device = { | |||
560 | .tiocmget = option_tiocmget, | 569 | .tiocmget = option_tiocmget, |
561 | .tiocmset = option_tiocmset, | 570 | .tiocmset = option_tiocmset, |
562 | .attach = option_startup, | 571 | .attach = option_startup, |
563 | .shutdown = option_shutdown, | 572 | .disconnect = option_disconnect, |
573 | .release = option_release, | ||
564 | .read_int_callback = option_instat_callback, | 574 | .read_int_callback = option_instat_callback, |
565 | .suspend = option_suspend, | 575 | .suspend = option_suspend, |
566 | .resume = option_resume, | 576 | .resume = option_resume, |
@@ -626,6 +636,18 @@ static void __exit option_exit(void) | |||
626 | module_init(option_init); | 636 | module_init(option_init); |
627 | module_exit(option_exit); | 637 | module_exit(option_exit); |
628 | 638 | ||
639 | static int option_probe(struct usb_serial *serial, | ||
640 | const struct usb_device_id *id) | ||
641 | { | ||
642 | /* D-Link DWM 652 still exposes CD-Rom emulation interface in modem mode */ | ||
643 | if (serial->dev->descriptor.idVendor == DLINK_VENDOR_ID && | ||
644 | serial->dev->descriptor.idProduct == DLINK_PRODUCT_DWM_652 && | ||
645 | serial->interface->cur_altsetting->desc.bInterfaceClass == 0x8) | ||
646 | return -ENODEV; | ||
647 | |||
648 | return 0; | ||
649 | } | ||
650 | |||
629 | static void option_set_termios(struct tty_struct *tty, | 651 | static void option_set_termios(struct tty_struct *tty, |
630 | struct usb_serial_port *port, struct ktermios *old_termios) | 652 | struct usb_serial_port *port, struct ktermios *old_termios) |
631 | { | 653 | { |
@@ -1129,7 +1151,14 @@ static void stop_read_write_urbs(struct usb_serial *serial) | |||
1129 | } | 1151 | } |
1130 | } | 1152 | } |
1131 | 1153 | ||
1132 | static void option_shutdown(struct usb_serial *serial) | 1154 | static void option_disconnect(struct usb_serial *serial) |
1155 | { | ||
1156 | dbg("%s", __func__); | ||
1157 | |||
1158 | stop_read_write_urbs(serial); | ||
1159 | } | ||
1160 | |||
1161 | static void option_release(struct usb_serial *serial) | ||
1133 | { | 1162 | { |
1134 | int i, j; | 1163 | int i, j; |
1135 | struct usb_serial_port *port; | 1164 | struct usb_serial_port *port; |
@@ -1137,8 +1166,6 @@ static void option_shutdown(struct usb_serial *serial) | |||
1137 | 1166 | ||
1138 | dbg("%s", __func__); | 1167 | dbg("%s", __func__); |
1139 | 1168 | ||
1140 | stop_read_write_urbs(serial); | ||
1141 | |||
1142 | /* Now free them */ | 1169 | /* Now free them */ |
1143 | for (i = 0; i < serial->num_ports; ++i) { | 1170 | for (i = 0; i < serial->num_ports; ++i) { |
1144 | port = serial->port[i]; | 1171 | port = serial->port[i]; |
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c index 7de54781fe61..3cece27325e7 100644 --- a/drivers/usb/serial/oti6858.c +++ b/drivers/usb/serial/oti6858.c | |||
@@ -159,7 +159,7 @@ static int oti6858_tiocmget(struct tty_struct *tty, struct file *file); | |||
159 | static int oti6858_tiocmset(struct tty_struct *tty, struct file *file, | 159 | static int oti6858_tiocmset(struct tty_struct *tty, struct file *file, |
160 | unsigned int set, unsigned int clear); | 160 | unsigned int set, unsigned int clear); |
161 | static int oti6858_startup(struct usb_serial *serial); | 161 | static int oti6858_startup(struct usb_serial *serial); |
162 | static void oti6858_shutdown(struct usb_serial *serial); | 162 | static void oti6858_release(struct usb_serial *serial); |
163 | 163 | ||
164 | /* functions operating on buffers */ | 164 | /* functions operating on buffers */ |
165 | static struct oti6858_buf *oti6858_buf_alloc(unsigned int size); | 165 | static struct oti6858_buf *oti6858_buf_alloc(unsigned int size); |
@@ -194,7 +194,7 @@ static struct usb_serial_driver oti6858_device = { | |||
194 | .write_room = oti6858_write_room, | 194 | .write_room = oti6858_write_room, |
195 | .chars_in_buffer = oti6858_chars_in_buffer, | 195 | .chars_in_buffer = oti6858_chars_in_buffer, |
196 | .attach = oti6858_startup, | 196 | .attach = oti6858_startup, |
197 | .shutdown = oti6858_shutdown, | 197 | .release = oti6858_release, |
198 | }; | 198 | }; |
199 | 199 | ||
200 | struct oti6858_private { | 200 | struct oti6858_private { |
@@ -782,7 +782,7 @@ static int oti6858_ioctl(struct tty_struct *tty, struct file *file, | |||
782 | } | 782 | } |
783 | 783 | ||
784 | 784 | ||
785 | static void oti6858_shutdown(struct usb_serial *serial) | 785 | static void oti6858_release(struct usb_serial *serial) |
786 | { | 786 | { |
787 | struct oti6858_private *priv; | 787 | struct oti6858_private *priv; |
788 | int i; | 788 | int i; |
@@ -794,7 +794,6 @@ static void oti6858_shutdown(struct usb_serial *serial) | |||
794 | if (priv) { | 794 | if (priv) { |
795 | oti6858_buf_free(priv->buf); | 795 | oti6858_buf_free(priv->buf); |
796 | kfree(priv); | 796 | kfree(priv); |
797 | usb_set_serial_port_data(serial->port[i], NULL); | ||
798 | } | 797 | } |
799 | } | 798 | } |
800 | } | 799 | } |
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c index e02dc3d643c7..ec6c132a25b5 100644 --- a/drivers/usb/serial/pl2303.c +++ b/drivers/usb/serial/pl2303.c | |||
@@ -878,7 +878,7 @@ static void pl2303_break_ctl(struct tty_struct *tty, int break_state) | |||
878 | dbg("%s - error sending break = %d", __func__, result); | 878 | dbg("%s - error sending break = %d", __func__, result); |
879 | } | 879 | } |
880 | 880 | ||
881 | static void pl2303_shutdown(struct usb_serial *serial) | 881 | static void pl2303_release(struct usb_serial *serial) |
882 | { | 882 | { |
883 | int i; | 883 | int i; |
884 | struct pl2303_private *priv; | 884 | struct pl2303_private *priv; |
@@ -890,7 +890,6 @@ static void pl2303_shutdown(struct usb_serial *serial) | |||
890 | if (priv) { | 890 | if (priv) { |
891 | pl2303_buf_free(priv->buf); | 891 | pl2303_buf_free(priv->buf); |
892 | kfree(priv); | 892 | kfree(priv); |
893 | usb_set_serial_port_data(serial->port[i], NULL); | ||
894 | } | 893 | } |
895 | } | 894 | } |
896 | } | 895 | } |
@@ -927,6 +926,8 @@ static void pl2303_update_line_status(struct usb_serial_port *port, | |||
927 | spin_lock_irqsave(&priv->lock, flags); | 926 | spin_lock_irqsave(&priv->lock, flags); |
928 | priv->line_status = data[status_idx]; | 927 | priv->line_status = data[status_idx]; |
929 | spin_unlock_irqrestore(&priv->lock, flags); | 928 | spin_unlock_irqrestore(&priv->lock, flags); |
929 | if (priv->line_status & UART_BREAK_ERROR) | ||
930 | usb_serial_handle_break(port); | ||
930 | wake_up_interruptible(&priv->delta_msr_wait); | 931 | wake_up_interruptible(&priv->delta_msr_wait); |
931 | } | 932 | } |
932 | 933 | ||
@@ -1037,7 +1038,8 @@ static void pl2303_read_bulk_callback(struct urb *urb) | |||
1037 | if (line_status & UART_OVERRUN_ERROR) | 1038 | if (line_status & UART_OVERRUN_ERROR) |
1038 | tty_insert_flip_char(tty, 0, TTY_OVERRUN); | 1039 | tty_insert_flip_char(tty, 0, TTY_OVERRUN); |
1039 | for (i = 0; i < urb->actual_length; ++i) | 1040 | for (i = 0; i < urb->actual_length; ++i) |
1040 | tty_insert_flip_char(tty, data[i], tty_flag); | 1041 | if (!usb_serial_handle_sysrq_char(port, data[i])) |
1042 | tty_insert_flip_char(tty, data[i], tty_flag); | ||
1041 | tty_flip_buffer_push(tty); | 1043 | tty_flip_buffer_push(tty); |
1042 | } | 1044 | } |
1043 | tty_kref_put(tty); | 1045 | tty_kref_put(tty); |
@@ -1120,7 +1122,7 @@ static struct usb_serial_driver pl2303_device = { | |||
1120 | .write_room = pl2303_write_room, | 1122 | .write_room = pl2303_write_room, |
1121 | .chars_in_buffer = pl2303_chars_in_buffer, | 1123 | .chars_in_buffer = pl2303_chars_in_buffer, |
1122 | .attach = pl2303_startup, | 1124 | .attach = pl2303_startup, |
1123 | .shutdown = pl2303_shutdown, | 1125 | .release = pl2303_release, |
1124 | }; | 1126 | }; |
1125 | 1127 | ||
1126 | static int __init pl2303_init(void) | 1128 | static int __init pl2303_init(void) |
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c index 17ac34f4d668..032f7aeb40a4 100644 --- a/drivers/usb/serial/sierra.c +++ b/drivers/usb/serial/sierra.c | |||
@@ -1,7 +1,10 @@ | |||
1 | /* | 1 | /* |
2 | USB Driver for Sierra Wireless | 2 | USB Driver for Sierra Wireless |
3 | 3 | ||
4 | Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com> | 4 | Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com>, |
5 | |||
6 | Copyright (C) 2008, 2009 Elina Pasheva, Matthew Safar, Rory Filer | ||
7 | <linux@sierrawireless.com> | ||
5 | 8 | ||
6 | IMPORTANT DISCLAIMER: This driver is not commercially supported by | 9 | IMPORTANT DISCLAIMER: This driver is not commercially supported by |
7 | Sierra Wireless. Use at your own risk. | 10 | Sierra Wireless. Use at your own risk. |
@@ -14,8 +17,8 @@ | |||
14 | Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org> | 17 | Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org> |
15 | */ | 18 | */ |
16 | 19 | ||
17 | #define DRIVER_VERSION "v.1.3.3" | 20 | #define DRIVER_VERSION "v.1.3.7" |
18 | #define DRIVER_AUTHOR "Kevin Lloyd <klloyd@sierrawireless.com>" | 21 | #define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer" |
19 | #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems" | 22 | #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems" |
20 | 23 | ||
21 | #include <linux/kernel.h> | 24 | #include <linux/kernel.h> |
@@ -30,10 +33,15 @@ | |||
30 | #define SWIMS_USB_REQUEST_SetPower 0x00 | 33 | #define SWIMS_USB_REQUEST_SetPower 0x00 |
31 | #define SWIMS_USB_REQUEST_SetNmea 0x07 | 34 | #define SWIMS_USB_REQUEST_SetNmea 0x07 |
32 | 35 | ||
33 | #define N_IN_URB 4 | 36 | #define N_IN_URB 8 |
34 | #define N_OUT_URB 4 | 37 | #define N_OUT_URB 64 |
35 | #define IN_BUFLEN 4096 | 38 | #define IN_BUFLEN 4096 |
36 | 39 | ||
40 | #define MAX_TRANSFER (PAGE_SIZE - 512) | ||
41 | /* MAX_TRANSFER is chosen so that the VM is not stressed by | ||
42 | allocations > PAGE_SIZE and the number of packets in a page | ||
43 | is an integer 512 is the largest possible packet on EHCI */ | ||
44 | |||
37 | static int debug; | 45 | static int debug; |
38 | static int nmea; | 46 | static int nmea; |
39 | 47 | ||
@@ -46,7 +54,7 @@ struct sierra_iface_info { | |||
46 | static int sierra_set_power_state(struct usb_device *udev, __u16 swiState) | 54 | static int sierra_set_power_state(struct usb_device *udev, __u16 swiState) |
47 | { | 55 | { |
48 | int result; | 56 | int result; |
49 | dev_dbg(&udev->dev, "%s", __func__); | 57 | dev_dbg(&udev->dev, "%s\n", __func__); |
50 | result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), | 58 | result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), |
51 | SWIMS_USB_REQUEST_SetPower, /* __u8 request */ | 59 | SWIMS_USB_REQUEST_SetPower, /* __u8 request */ |
52 | USB_TYPE_VENDOR, /* __u8 request type */ | 60 | USB_TYPE_VENDOR, /* __u8 request type */ |
@@ -61,7 +69,7 @@ static int sierra_set_power_state(struct usb_device *udev, __u16 swiState) | |||
61 | static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable) | 69 | static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable) |
62 | { | 70 | { |
63 | int result; | 71 | int result; |
64 | dev_dbg(&udev->dev, "%s", __func__); | 72 | dev_dbg(&udev->dev, "%s\n", __func__); |
65 | result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), | 73 | result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), |
66 | SWIMS_USB_REQUEST_SetNmea, /* __u8 request */ | 74 | SWIMS_USB_REQUEST_SetNmea, /* __u8 request */ |
67 | USB_TYPE_VENDOR, /* __u8 request type */ | 75 | USB_TYPE_VENDOR, /* __u8 request type */ |
@@ -75,18 +83,22 @@ static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable) | |||
75 | 83 | ||
76 | static int sierra_calc_num_ports(struct usb_serial *serial) | 84 | static int sierra_calc_num_ports(struct usb_serial *serial) |
77 | { | 85 | { |
78 | int result; | 86 | int num_ports = 0; |
79 | int *num_ports = usb_get_serial_data(serial); | 87 | u8 ifnum, numendpoints; |
80 | dev_dbg(&serial->dev->dev, "%s", __func__); | ||
81 | 88 | ||
82 | result = *num_ports; | 89 | dev_dbg(&serial->dev->dev, "%s\n", __func__); |
83 | 90 | ||
84 | if (result) { | 91 | ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; |
85 | kfree(num_ports); | 92 | numendpoints = serial->interface->cur_altsetting->desc.bNumEndpoints; |
86 | usb_set_serial_data(serial, NULL); | ||
87 | } | ||
88 | 93 | ||
89 | return result; | 94 | /* Dummy interface present on some SKUs should be ignored */ |
95 | if (ifnum == 0x99) | ||
96 | num_ports = 0; | ||
97 | else if (numendpoints <= 3) | ||
98 | num_ports = 1; | ||
99 | else | ||
100 | num_ports = (numendpoints-1)/2; | ||
101 | return num_ports; | ||
90 | } | 102 | } |
91 | 103 | ||
92 | static int is_blacklisted(const u8 ifnum, | 104 | static int is_blacklisted(const u8 ifnum, |
@@ -111,7 +123,7 @@ static int sierra_calc_interface(struct usb_serial *serial) | |||
111 | int interface; | 123 | int interface; |
112 | struct usb_interface *p_interface; | 124 | struct usb_interface *p_interface; |
113 | struct usb_host_interface *p_host_interface; | 125 | struct usb_host_interface *p_host_interface; |
114 | dev_dbg(&serial->dev->dev, "%s", __func__); | 126 | dev_dbg(&serial->dev->dev, "%s\n", __func__); |
115 | 127 | ||
116 | /* Get the interface structure pointer from the serial struct */ | 128 | /* Get the interface structure pointer from the serial struct */ |
117 | p_interface = serial->interface; | 129 | p_interface = serial->interface; |
@@ -132,23 +144,12 @@ static int sierra_probe(struct usb_serial *serial, | |||
132 | { | 144 | { |
133 | int result = 0; | 145 | int result = 0; |
134 | struct usb_device *udev; | 146 | struct usb_device *udev; |
135 | int *num_ports; | ||
136 | u8 ifnum; | 147 | u8 ifnum; |
137 | u8 numendpoints; | ||
138 | 148 | ||
139 | dev_dbg(&serial->dev->dev, "%s", __func__); | ||
140 | |||
141 | num_ports = kmalloc(sizeof(*num_ports), GFP_KERNEL); | ||
142 | if (!num_ports) | ||
143 | return -ENOMEM; | ||
144 | |||
145 | ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; | ||
146 | numendpoints = serial->interface->cur_altsetting->desc.bNumEndpoints; | ||
147 | udev = serial->dev; | 149 | udev = serial->dev; |
150 | dev_dbg(&udev->dev, "%s\n", __func__); | ||
148 | 151 | ||
149 | /* Figure out the interface number from the serial structure */ | ||
150 | ifnum = sierra_calc_interface(serial); | 152 | ifnum = sierra_calc_interface(serial); |
151 | |||
152 | /* | 153 | /* |
153 | * If this interface supports more than 1 alternate | 154 | * If this interface supports more than 1 alternate |
154 | * select the 2nd one | 155 | * select the 2nd one |
@@ -160,20 +161,6 @@ static int sierra_probe(struct usb_serial *serial, | |||
160 | usb_set_interface(udev, ifnum, 1); | 161 | usb_set_interface(udev, ifnum, 1); |
161 | } | 162 | } |
162 | 163 | ||
163 | /* Dummy interface present on some SKUs should be ignored */ | ||
164 | if (ifnum == 0x99) | ||
165 | *num_ports = 0; | ||
166 | else if (numendpoints <= 3) | ||
167 | *num_ports = 1; | ||
168 | else | ||
169 | *num_ports = (numendpoints-1)/2; | ||
170 | |||
171 | /* | ||
172 | * save off our num_ports info so that we can use it in the | ||
173 | * calc_num_ports callback | ||
174 | */ | ||
175 | usb_set_serial_data(serial, (void *)num_ports); | ||
176 | |||
177 | /* ifnum could have changed - by calling usb_set_interface */ | 164 | /* ifnum could have changed - by calling usb_set_interface */ |
178 | ifnum = sierra_calc_interface(serial); | 165 | ifnum = sierra_calc_interface(serial); |
179 | 166 | ||
@@ -289,7 +276,7 @@ static int sierra_send_setup(struct usb_serial_port *port) | |||
289 | __u16 interface = 0; | 276 | __u16 interface = 0; |
290 | int val = 0; | 277 | int val = 0; |
291 | 278 | ||
292 | dev_dbg(&port->dev, "%s", __func__); | 279 | dev_dbg(&port->dev, "%s\n", __func__); |
293 | 280 | ||
294 | portdata = usb_get_serial_port_data(port); | 281 | portdata = usb_get_serial_port_data(port); |
295 | 282 | ||
@@ -332,7 +319,7 @@ static int sierra_send_setup(struct usb_serial_port *port) | |||
332 | static void sierra_set_termios(struct tty_struct *tty, | 319 | static void sierra_set_termios(struct tty_struct *tty, |
333 | struct usb_serial_port *port, struct ktermios *old_termios) | 320 | struct usb_serial_port *port, struct ktermios *old_termios) |
334 | { | 321 | { |
335 | dev_dbg(&port->dev, "%s", __func__); | 322 | dev_dbg(&port->dev, "%s\n", __func__); |
336 | tty_termios_copy_hw(tty->termios, old_termios); | 323 | tty_termios_copy_hw(tty->termios, old_termios); |
337 | sierra_send_setup(port); | 324 | sierra_send_setup(port); |
338 | } | 325 | } |
@@ -343,7 +330,7 @@ static int sierra_tiocmget(struct tty_struct *tty, struct file *file) | |||
343 | unsigned int value; | 330 | unsigned int value; |
344 | struct sierra_port_private *portdata; | 331 | struct sierra_port_private *portdata; |
345 | 332 | ||
346 | dev_dbg(&port->dev, "%s", __func__); | 333 | dev_dbg(&port->dev, "%s\n", __func__); |
347 | portdata = usb_get_serial_port_data(port); | 334 | portdata = usb_get_serial_port_data(port); |
348 | 335 | ||
349 | value = ((portdata->rts_state) ? TIOCM_RTS : 0) | | 336 | value = ((portdata->rts_state) ? TIOCM_RTS : 0) | |
@@ -394,14 +381,14 @@ static void sierra_outdat_callback(struct urb *urb) | |||
394 | int status = urb->status; | 381 | int status = urb->status; |
395 | unsigned long flags; | 382 | unsigned long flags; |
396 | 383 | ||
397 | dev_dbg(&port->dev, "%s - port %d", __func__, port->number); | 384 | dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number); |
398 | 385 | ||
399 | /* free up the transfer buffer, as usb_free_urb() does not do this */ | 386 | /* free up the transfer buffer, as usb_free_urb() does not do this */ |
400 | kfree(urb->transfer_buffer); | 387 | kfree(urb->transfer_buffer); |
401 | 388 | ||
402 | if (status) | 389 | if (status) |
403 | dev_dbg(&port->dev, "%s - nonzero write bulk status " | 390 | dev_dbg(&port->dev, "%s - nonzero write bulk status " |
404 | "received: %d", __func__, status); | 391 | "received: %d\n", __func__, status); |
405 | 392 | ||
406 | spin_lock_irqsave(&portdata->lock, flags); | 393 | spin_lock_irqsave(&portdata->lock, flags); |
407 | --portdata->outstanding_urbs; | 394 | --portdata->outstanding_urbs; |
@@ -419,50 +406,61 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
419 | unsigned long flags; | 406 | unsigned long flags; |
420 | unsigned char *buffer; | 407 | unsigned char *buffer; |
421 | struct urb *urb; | 408 | struct urb *urb; |
422 | int status; | 409 | size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER); |
410 | int retval = 0; | ||
411 | |||
412 | /* verify that we actually have some data to write */ | ||
413 | if (count == 0) | ||
414 | return 0; | ||
423 | 415 | ||
424 | portdata = usb_get_serial_port_data(port); | 416 | portdata = usb_get_serial_port_data(port); |
425 | 417 | ||
426 | dev_dbg(&port->dev, "%s: write (%d chars)", __func__, count); | 418 | dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize); |
427 | 419 | ||
428 | spin_lock_irqsave(&portdata->lock, flags); | 420 | spin_lock_irqsave(&portdata->lock, flags); |
421 | dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__, | ||
422 | portdata->outstanding_urbs); | ||
429 | if (portdata->outstanding_urbs > N_OUT_URB) { | 423 | if (portdata->outstanding_urbs > N_OUT_URB) { |
430 | spin_unlock_irqrestore(&portdata->lock, flags); | 424 | spin_unlock_irqrestore(&portdata->lock, flags); |
431 | dev_dbg(&port->dev, "%s - write limit hit\n", __func__); | 425 | dev_dbg(&port->dev, "%s - write limit hit\n", __func__); |
432 | return 0; | 426 | return 0; |
433 | } | 427 | } |
434 | portdata->outstanding_urbs++; | 428 | portdata->outstanding_urbs++; |
429 | dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__, | ||
430 | portdata->outstanding_urbs); | ||
435 | spin_unlock_irqrestore(&portdata->lock, flags); | 431 | spin_unlock_irqrestore(&portdata->lock, flags); |
436 | 432 | ||
437 | buffer = kmalloc(count, GFP_ATOMIC); | 433 | buffer = kmalloc(writesize, GFP_ATOMIC); |
438 | if (!buffer) { | 434 | if (!buffer) { |
439 | dev_err(&port->dev, "out of memory\n"); | 435 | dev_err(&port->dev, "out of memory\n"); |
440 | count = -ENOMEM; | 436 | retval = -ENOMEM; |
441 | goto error_no_buffer; | 437 | goto error_no_buffer; |
442 | } | 438 | } |
443 | 439 | ||
444 | urb = usb_alloc_urb(0, GFP_ATOMIC); | 440 | urb = usb_alloc_urb(0, GFP_ATOMIC); |
445 | if (!urb) { | 441 | if (!urb) { |
446 | dev_err(&port->dev, "no more free urbs\n"); | 442 | dev_err(&port->dev, "no more free urbs\n"); |
447 | count = -ENOMEM; | 443 | retval = -ENOMEM; |
448 | goto error_no_urb; | 444 | goto error_no_urb; |
449 | } | 445 | } |
450 | 446 | ||
451 | memcpy(buffer, buf, count); | 447 | memcpy(buffer, buf, writesize); |
452 | 448 | ||
453 | usb_serial_debug_data(debug, &port->dev, __func__, count, buffer); | 449 | usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer); |
454 | 450 | ||
455 | usb_fill_bulk_urb(urb, serial->dev, | 451 | usb_fill_bulk_urb(urb, serial->dev, |
456 | usb_sndbulkpipe(serial->dev, | 452 | usb_sndbulkpipe(serial->dev, |
457 | port->bulk_out_endpointAddress), | 453 | port->bulk_out_endpointAddress), |
458 | buffer, count, sierra_outdat_callback, port); | 454 | buffer, writesize, sierra_outdat_callback, port); |
455 | |||
456 | /* Handle the need to send a zero length packet */ | ||
457 | urb->transfer_flags |= URB_ZERO_PACKET; | ||
459 | 458 | ||
460 | /* send it down the pipe */ | 459 | /* send it down the pipe */ |
461 | status = usb_submit_urb(urb, GFP_ATOMIC); | 460 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
462 | if (status) { | 461 | if (retval) { |
463 | dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed " | 462 | dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed " |
464 | "with status = %d\n", __func__, status); | 463 | "with status = %d\n", __func__, retval); |
465 | count = status; | ||
466 | goto error; | 464 | goto error; |
467 | } | 465 | } |
468 | 466 | ||
@@ -470,7 +468,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port, | |||
470 | * really free it when it is finished with it */ | 468 | * really free it when it is finished with it */ |
471 | usb_free_urb(urb); | 469 | usb_free_urb(urb); |
472 | 470 | ||
473 | return count; | 471 | return writesize; |
474 | error: | 472 | error: |
475 | usb_free_urb(urb); | 473 | usb_free_urb(urb); |
476 | error_no_urb: | 474 | error_no_urb: |
@@ -478,8 +476,10 @@ error_no_urb: | |||
478 | error_no_buffer: | 476 | error_no_buffer: |
479 | spin_lock_irqsave(&portdata->lock, flags); | 477 | spin_lock_irqsave(&portdata->lock, flags); |
480 | --portdata->outstanding_urbs; | 478 | --portdata->outstanding_urbs; |
479 | dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__, | ||
480 | portdata->outstanding_urbs); | ||
481 | spin_unlock_irqrestore(&portdata->lock, flags); | 481 | spin_unlock_irqrestore(&portdata->lock, flags); |
482 | return count; | 482 | return retval; |
483 | } | 483 | } |
484 | 484 | ||
485 | static void sierra_indat_callback(struct urb *urb) | 485 | static void sierra_indat_callback(struct urb *urb) |
@@ -491,33 +491,39 @@ static void sierra_indat_callback(struct urb *urb) | |||
491 | unsigned char *data = urb->transfer_buffer; | 491 | unsigned char *data = urb->transfer_buffer; |
492 | int status = urb->status; | 492 | int status = urb->status; |
493 | 493 | ||
494 | dbg("%s: %p", __func__, urb); | ||
495 | |||
496 | endpoint = usb_pipeendpoint(urb->pipe); | 494 | endpoint = usb_pipeendpoint(urb->pipe); |
497 | port = urb->context; | 495 | port = urb->context; |
496 | |||
497 | dev_dbg(&port->dev, "%s: %p\n", __func__, urb); | ||
498 | 498 | ||
499 | if (status) { | 499 | if (status) { |
500 | dev_dbg(&port->dev, "%s: nonzero status: %d on" | 500 | dev_dbg(&port->dev, "%s: nonzero status: %d on" |
501 | " endpoint %02x.", __func__, status, endpoint); | 501 | " endpoint %02x\n", __func__, status, endpoint); |
502 | } else { | 502 | } else { |
503 | if (urb->actual_length) { | 503 | if (urb->actual_length) { |
504 | tty = tty_port_tty_get(&port->port); | 504 | tty = tty_port_tty_get(&port->port); |
505 | |||
505 | tty_buffer_request_room(tty, urb->actual_length); | 506 | tty_buffer_request_room(tty, urb->actual_length); |
506 | tty_insert_flip_string(tty, data, urb->actual_length); | 507 | tty_insert_flip_string(tty, data, urb->actual_length); |
507 | tty_flip_buffer_push(tty); | 508 | tty_flip_buffer_push(tty); |
509 | |||
508 | tty_kref_put(tty); | 510 | tty_kref_put(tty); |
509 | } else | 511 | usb_serial_debug_data(debug, &port->dev, __func__, |
512 | urb->actual_length, data); | ||
513 | } else { | ||
510 | dev_dbg(&port->dev, "%s: empty read urb" | 514 | dev_dbg(&port->dev, "%s: empty read urb" |
511 | " received", __func__); | 515 | " received\n", __func__); |
512 | |||
513 | /* Resubmit urb so we continue receiving */ | ||
514 | if (port->port.count && status != -ESHUTDOWN && status != -EPERM) { | ||
515 | err = usb_submit_urb(urb, GFP_ATOMIC); | ||
516 | if (err) | ||
517 | dev_err(&port->dev, "resubmit read urb failed." | ||
518 | "(%d)\n", err); | ||
519 | } | 516 | } |
520 | } | 517 | } |
518 | |||
519 | /* Resubmit urb so we continue receiving */ | ||
520 | if (port->port.count && status != -ESHUTDOWN && status != -EPERM) { | ||
521 | err = usb_submit_urb(urb, GFP_ATOMIC); | ||
522 | if (err) | ||
523 | dev_err(&port->dev, "resubmit read urb failed." | ||
524 | "(%d)\n", err); | ||
525 | } | ||
526 | |||
521 | return; | 527 | return; |
522 | } | 528 | } |
523 | 529 | ||
@@ -529,8 +535,7 @@ static void sierra_instat_callback(struct urb *urb) | |||
529 | struct sierra_port_private *portdata = usb_get_serial_port_data(port); | 535 | struct sierra_port_private *portdata = usb_get_serial_port_data(port); |
530 | struct usb_serial *serial = port->serial; | 536 | struct usb_serial *serial = port->serial; |
531 | 537 | ||
532 | dev_dbg(&port->dev, "%s", __func__); | 538 | dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__, |
533 | dev_dbg(&port->dev, "%s: urb %p port %p has data %p", __func__, | ||
534 | urb, port, portdata); | 539 | urb, port, portdata); |
535 | 540 | ||
536 | if (status == 0) { | 541 | if (status == 0) { |
@@ -550,7 +555,7 @@ static void sierra_instat_callback(struct urb *urb) | |||
550 | sizeof(struct usb_ctrlrequest)); | 555 | sizeof(struct usb_ctrlrequest)); |
551 | struct tty_struct *tty; | 556 | struct tty_struct *tty; |
552 | 557 | ||
553 | dev_dbg(&port->dev, "%s: signal x%x", __func__, | 558 | dev_dbg(&port->dev, "%s: signal x%x\n", __func__, |
554 | signals); | 559 | signals); |
555 | 560 | ||
556 | old_dcd_state = portdata->dcd_state; | 561 | old_dcd_state = portdata->dcd_state; |
@@ -565,20 +570,20 @@ static void sierra_instat_callback(struct urb *urb) | |||
565 | tty_hangup(tty); | 570 | tty_hangup(tty); |
566 | tty_kref_put(tty); | 571 | tty_kref_put(tty); |
567 | } else { | 572 | } else { |
568 | dev_dbg(&port->dev, "%s: type %x req %x", | 573 | dev_dbg(&port->dev, "%s: type %x req %x\n", |
569 | __func__, req_pkt->bRequestType, | 574 | __func__, req_pkt->bRequestType, |
570 | req_pkt->bRequest); | 575 | req_pkt->bRequest); |
571 | } | 576 | } |
572 | } else | 577 | } else |
573 | dev_dbg(&port->dev, "%s: error %d", __func__, status); | 578 | dev_dbg(&port->dev, "%s: error %d\n", __func__, status); |
574 | 579 | ||
575 | /* Resubmit urb so we continue receiving IRQ data */ | 580 | /* Resubmit urb so we continue receiving IRQ data */ |
576 | if (status != -ESHUTDOWN) { | 581 | if (port->port.count && status != -ESHUTDOWN && status != -ENOENT) { |
577 | urb->dev = serial->dev; | 582 | urb->dev = serial->dev; |
578 | err = usb_submit_urb(urb, GFP_ATOMIC); | 583 | err = usb_submit_urb(urb, GFP_ATOMIC); |
579 | if (err) | 584 | if (err) |
580 | dev_dbg(&port->dev, "%s: resubmit intr urb " | 585 | dev_err(&port->dev, "%s: resubmit intr urb " |
581 | "failed. (%d)", __func__, err); | 586 | "failed. (%d)\n", __func__, err); |
582 | } | 587 | } |
583 | } | 588 | } |
584 | 589 | ||
@@ -588,7 +593,7 @@ static int sierra_write_room(struct tty_struct *tty) | |||
588 | struct sierra_port_private *portdata = usb_get_serial_port_data(port); | 593 | struct sierra_port_private *portdata = usb_get_serial_port_data(port); |
589 | unsigned long flags; | 594 | unsigned long flags; |
590 | 595 | ||
591 | dev_dbg(&port->dev, "%s - port %d", __func__, port->number); | 596 | dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number); |
592 | 597 | ||
593 | /* try to give a good number back based on if we have any free urbs at | 598 | /* try to give a good number back based on if we have any free urbs at |
594 | * this point in time */ | 599 | * this point in time */ |
@@ -729,7 +734,7 @@ static int sierra_open(struct tty_struct *tty, | |||
729 | 734 | ||
730 | portdata = usb_get_serial_port_data(port); | 735 | portdata = usb_get_serial_port_data(port); |
731 | 736 | ||
732 | dev_dbg(&port->dev, "%s", __func__); | 737 | dev_dbg(&port->dev, "%s\n", __func__); |
733 | 738 | ||
734 | /* Set some sane defaults */ | 739 | /* Set some sane defaults */ |
735 | portdata->rts_state = 1; | 740 | portdata->rts_state = 1; |
@@ -782,7 +787,7 @@ static int sierra_startup(struct usb_serial *serial) | |||
782 | struct sierra_port_private *portdata; | 787 | struct sierra_port_private *portdata; |
783 | int i; | 788 | int i; |
784 | 789 | ||
785 | dev_dbg(&serial->dev->dev, "%s", __func__); | 790 | dev_dbg(&serial->dev->dev, "%s\n", __func__); |
786 | 791 | ||
787 | /* Set Device mode to D0 */ | 792 | /* Set Device mode to D0 */ |
788 | sierra_set_power_state(serial->dev, 0x0000); | 793 | sierra_set_power_state(serial->dev, 0x0000); |
@@ -797,7 +802,7 @@ static int sierra_startup(struct usb_serial *serial) | |||
797 | portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); | 802 | portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); |
798 | if (!portdata) { | 803 | if (!portdata) { |
799 | dev_dbg(&port->dev, "%s: kmalloc for " | 804 | dev_dbg(&port->dev, "%s: kmalloc for " |
800 | "sierra_port_private (%d) failed!.", | 805 | "sierra_port_private (%d) failed!.\n", |
801 | __func__, i); | 806 | __func__, i); |
802 | return -ENOMEM; | 807 | return -ENOMEM; |
803 | } | 808 | } |
@@ -809,13 +814,13 @@ static int sierra_startup(struct usb_serial *serial) | |||
809 | return 0; | 814 | return 0; |
810 | } | 815 | } |
811 | 816 | ||
812 | static void sierra_shutdown(struct usb_serial *serial) | 817 | static void sierra_disconnect(struct usb_serial *serial) |
813 | { | 818 | { |
814 | int i; | 819 | int i; |
815 | struct usb_serial_port *port; | 820 | struct usb_serial_port *port; |
816 | struct sierra_port_private *portdata; | 821 | struct sierra_port_private *portdata; |
817 | 822 | ||
818 | dev_dbg(&serial->dev->dev, "%s", __func__); | 823 | dev_dbg(&serial->dev->dev, "%s\n", __func__); |
819 | 824 | ||
820 | for (i = 0; i < serial->num_ports; ++i) { | 825 | for (i = 0; i < serial->num_ports; ++i) { |
821 | port = serial->port[i]; | 826 | port = serial->port[i]; |
@@ -848,7 +853,7 @@ static struct usb_serial_driver sierra_device = { | |||
848 | .tiocmget = sierra_tiocmget, | 853 | .tiocmget = sierra_tiocmget, |
849 | .tiocmset = sierra_tiocmset, | 854 | .tiocmset = sierra_tiocmset, |
850 | .attach = sierra_startup, | 855 | .attach = sierra_startup, |
851 | .shutdown = sierra_shutdown, | 856 | .disconnect = sierra_disconnect, |
852 | .read_int_callback = sierra_instat_callback, | 857 | .read_int_callback = sierra_instat_callback, |
853 | }; | 858 | }; |
854 | 859 | ||
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c index 8f7ed8f13996..3c249d8e8b8e 100644 --- a/drivers/usb/serial/spcp8x5.c +++ b/drivers/usb/serial/spcp8x5.c | |||
@@ -356,7 +356,7 @@ cleanup: | |||
356 | } | 356 | } |
357 | 357 | ||
358 | /* call when the device plug out. free all the memory alloced by probe */ | 358 | /* call when the device plug out. free all the memory alloced by probe */ |
359 | static void spcp8x5_shutdown(struct usb_serial *serial) | 359 | static void spcp8x5_release(struct usb_serial *serial) |
360 | { | 360 | { |
361 | int i; | 361 | int i; |
362 | struct spcp8x5_private *priv; | 362 | struct spcp8x5_private *priv; |
@@ -366,7 +366,6 @@ static void spcp8x5_shutdown(struct usb_serial *serial) | |||
366 | if (priv) { | 366 | if (priv) { |
367 | free_ringbuf(priv->buf); | 367 | free_ringbuf(priv->buf); |
368 | kfree(priv); | 368 | kfree(priv); |
369 | usb_set_serial_port_data(serial->port[i] , NULL); | ||
370 | } | 369 | } |
371 | } | 370 | } |
372 | } | 371 | } |
@@ -1020,7 +1019,7 @@ static struct usb_serial_driver spcp8x5_device = { | |||
1020 | .write_bulk_callback = spcp8x5_write_bulk_callback, | 1019 | .write_bulk_callback = spcp8x5_write_bulk_callback, |
1021 | .chars_in_buffer = spcp8x5_chars_in_buffer, | 1020 | .chars_in_buffer = spcp8x5_chars_in_buffer, |
1022 | .attach = spcp8x5_startup, | 1021 | .attach = spcp8x5_startup, |
1023 | .shutdown = spcp8x5_shutdown, | 1022 | .release = spcp8x5_release, |
1024 | }; | 1023 | }; |
1025 | 1024 | ||
1026 | static int __init spcp8x5_init(void) | 1025 | static int __init spcp8x5_init(void) |
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c index 8b07ebc6baeb..6157fac9366b 100644 --- a/drivers/usb/serial/symbolserial.c +++ b/drivers/usb/serial/symbolserial.c | |||
@@ -267,7 +267,7 @@ error: | |||
267 | return retval; | 267 | return retval; |
268 | } | 268 | } |
269 | 269 | ||
270 | static void symbol_shutdown(struct usb_serial *serial) | 270 | static void symbol_disconnect(struct usb_serial *serial) |
271 | { | 271 | { |
272 | struct symbol_private *priv = usb_get_serial_data(serial); | 272 | struct symbol_private *priv = usb_get_serial_data(serial); |
273 | 273 | ||
@@ -275,9 +275,16 @@ static void symbol_shutdown(struct usb_serial *serial) | |||
275 | 275 | ||
276 | usb_kill_urb(priv->int_urb); | 276 | usb_kill_urb(priv->int_urb); |
277 | usb_free_urb(priv->int_urb); | 277 | usb_free_urb(priv->int_urb); |
278 | } | ||
279 | |||
280 | static void symbol_release(struct usb_serial *serial) | ||
281 | { | ||
282 | struct symbol_private *priv = usb_get_serial_data(serial); | ||
283 | |||
284 | dbg("%s", __func__); | ||
285 | |||
278 | kfree(priv->int_buffer); | 286 | kfree(priv->int_buffer); |
279 | kfree(priv); | 287 | kfree(priv); |
280 | usb_set_serial_data(serial, NULL); | ||
281 | } | 288 | } |
282 | 289 | ||
283 | static struct usb_driver symbol_driver = { | 290 | static struct usb_driver symbol_driver = { |
@@ -299,7 +306,8 @@ static struct usb_serial_driver symbol_device = { | |||
299 | .attach = symbol_startup, | 306 | .attach = symbol_startup, |
300 | .open = symbol_open, | 307 | .open = symbol_open, |
301 | .close = symbol_close, | 308 | .close = symbol_close, |
302 | .shutdown = symbol_shutdown, | 309 | .disconnect = symbol_disconnect, |
310 | .release = symbol_release, | ||
303 | .throttle = symbol_throttle, | 311 | .throttle = symbol_throttle, |
304 | .unthrottle = symbol_unthrottle, | 312 | .unthrottle = symbol_unthrottle, |
305 | }; | 313 | }; |
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c index 42cb04c403be..991d8232e376 100644 --- a/drivers/usb/serial/ti_usb_3410_5052.c +++ b/drivers/usb/serial/ti_usb_3410_5052.c | |||
@@ -97,7 +97,7 @@ struct ti_device { | |||
97 | /* Function Declarations */ | 97 | /* Function Declarations */ |
98 | 98 | ||
99 | static int ti_startup(struct usb_serial *serial); | 99 | static int ti_startup(struct usb_serial *serial); |
100 | static void ti_shutdown(struct usb_serial *serial); | 100 | static void ti_release(struct usb_serial *serial); |
101 | static int ti_open(struct tty_struct *tty, struct usb_serial_port *port, | 101 | static int ti_open(struct tty_struct *tty, struct usb_serial_port *port, |
102 | struct file *file); | 102 | struct file *file); |
103 | static void ti_close(struct usb_serial_port *port); | 103 | static void ti_close(struct usb_serial_port *port); |
@@ -230,7 +230,7 @@ static struct usb_serial_driver ti_1port_device = { | |||
230 | .id_table = ti_id_table_3410, | 230 | .id_table = ti_id_table_3410, |
231 | .num_ports = 1, | 231 | .num_ports = 1, |
232 | .attach = ti_startup, | 232 | .attach = ti_startup, |
233 | .shutdown = ti_shutdown, | 233 | .release = ti_release, |
234 | .open = ti_open, | 234 | .open = ti_open, |
235 | .close = ti_close, | 235 | .close = ti_close, |
236 | .write = ti_write, | 236 | .write = ti_write, |
@@ -258,7 +258,7 @@ static struct usb_serial_driver ti_2port_device = { | |||
258 | .id_table = ti_id_table_5052, | 258 | .id_table = ti_id_table_5052, |
259 | .num_ports = 2, | 259 | .num_ports = 2, |
260 | .attach = ti_startup, | 260 | .attach = ti_startup, |
261 | .shutdown = ti_shutdown, | 261 | .release = ti_release, |
262 | .open = ti_open, | 262 | .open = ti_open, |
263 | .close = ti_close, | 263 | .close = ti_close, |
264 | .write = ti_write, | 264 | .write = ti_write, |
@@ -473,7 +473,7 @@ free_tdev: | |||
473 | } | 473 | } |
474 | 474 | ||
475 | 475 | ||
476 | static void ti_shutdown(struct usb_serial *serial) | 476 | static void ti_release(struct usb_serial *serial) |
477 | { | 477 | { |
478 | int i; | 478 | int i; |
479 | struct ti_device *tdev = usb_get_serial_data(serial); | 479 | struct ti_device *tdev = usb_get_serial_data(serial); |
@@ -486,12 +486,10 @@ static void ti_shutdown(struct usb_serial *serial) | |||
486 | if (tport) { | 486 | if (tport) { |
487 | ti_buf_free(tport->tp_write_buf); | 487 | ti_buf_free(tport->tp_write_buf); |
488 | kfree(tport); | 488 | kfree(tport); |
489 | usb_set_serial_port_data(serial->port[i], NULL); | ||
490 | } | 489 | } |
491 | } | 490 | } |
492 | 491 | ||
493 | kfree(tdev); | 492 | kfree(tdev); |
494 | usb_set_serial_data(serial, NULL); | ||
495 | } | 493 | } |
496 | 494 | ||
497 | 495 | ||
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c index 1967a7edc10c..d595aa5586a7 100644 --- a/drivers/usb/serial/usb-serial.c +++ b/drivers/usb/serial/usb-serial.c | |||
@@ -141,6 +141,14 @@ static void destroy_serial(struct kref *kref) | |||
141 | if (serial->minor != SERIAL_TTY_NO_MINOR) | 141 | if (serial->minor != SERIAL_TTY_NO_MINOR) |
142 | return_serial(serial); | 142 | return_serial(serial); |
143 | 143 | ||
144 | serial->type->release(serial); | ||
145 | |||
146 | for (i = 0; i < serial->num_ports; ++i) { | ||
147 | port = serial->port[i]; | ||
148 | if (port) | ||
149 | put_device(&port->dev); | ||
150 | } | ||
151 | |||
144 | /* If this is a "fake" port, we have to clean it up here, as it will | 152 | /* If this is a "fake" port, we have to clean it up here, as it will |
145 | * not get cleaned up in port_release() as it was never registered with | 153 | * not get cleaned up in port_release() as it was never registered with |
146 | * the driver core */ | 154 | * the driver core */ |
@@ -148,9 +156,8 @@ static void destroy_serial(struct kref *kref) | |||
148 | for (i = serial->num_ports; | 156 | for (i = serial->num_ports; |
149 | i < serial->num_port_pointers; ++i) { | 157 | i < serial->num_port_pointers; ++i) { |
150 | port = serial->port[i]; | 158 | port = serial->port[i]; |
151 | if (!port) | 159 | if (port) |
152 | continue; | 160 | port_free(port); |
153 | port_free(port); | ||
154 | } | 161 | } |
155 | } | 162 | } |
156 | 163 | ||
@@ -1046,10 +1053,15 @@ int usb_serial_probe(struct usb_interface *interface, | |||
1046 | 1053 | ||
1047 | dev_set_name(&port->dev, "ttyUSB%d", port->number); | 1054 | dev_set_name(&port->dev, "ttyUSB%d", port->number); |
1048 | dbg ("%s - registering %s", __func__, dev_name(&port->dev)); | 1055 | dbg ("%s - registering %s", __func__, dev_name(&port->dev)); |
1056 | port->dev_state = PORT_REGISTERING; | ||
1049 | retval = device_register(&port->dev); | 1057 | retval = device_register(&port->dev); |
1050 | if (retval) | 1058 | if (retval) { |
1051 | dev_err(&port->dev, "Error registering port device, " | 1059 | dev_err(&port->dev, "Error registering port device, " |
1052 | "continuing\n"); | 1060 | "continuing\n"); |
1061 | port->dev_state = PORT_UNREGISTERED; | ||
1062 | } else { | ||
1063 | port->dev_state = PORT_REGISTERED; | ||
1064 | } | ||
1053 | } | 1065 | } |
1054 | 1066 | ||
1055 | usb_serial_console_init(debug, minor); | 1067 | usb_serial_console_init(debug, minor); |
@@ -1113,10 +1125,6 @@ void usb_serial_disconnect(struct usb_interface *interface) | |||
1113 | serial->disconnected = 1; | 1125 | serial->disconnected = 1; |
1114 | mutex_unlock(&serial->disc_mutex); | 1126 | mutex_unlock(&serial->disc_mutex); |
1115 | 1127 | ||
1116 | /* Unfortunately, many of the sub-drivers expect the port structures | ||
1117 | * to exist when their shutdown method is called, so we have to go | ||
1118 | * through this awkward two-step unregistration procedure. | ||
1119 | */ | ||
1120 | for (i = 0; i < serial->num_ports; ++i) { | 1128 | for (i = 0; i < serial->num_ports; ++i) { |
1121 | port = serial->port[i]; | 1129 | port = serial->port[i]; |
1122 | if (port) { | 1130 | if (port) { |
@@ -1130,17 +1138,25 @@ void usb_serial_disconnect(struct usb_interface *interface) | |||
1130 | } | 1138 | } |
1131 | kill_traffic(port); | 1139 | kill_traffic(port); |
1132 | cancel_work_sync(&port->work); | 1140 | cancel_work_sync(&port->work); |
1133 | device_del(&port->dev); | 1141 | if (port->dev_state == PORT_REGISTERED) { |
1134 | } | 1142 | |
1135 | } | 1143 | /* Make sure the port is bound so that the |
1136 | serial->type->shutdown(serial); | 1144 | * driver's port_remove method is called. |
1137 | for (i = 0; i < serial->num_ports; ++i) { | 1145 | */ |
1138 | port = serial->port[i]; | 1146 | if (!port->dev.driver) { |
1139 | if (port) { | 1147 | int rc; |
1140 | put_device(&port->dev); | 1148 | |
1141 | serial->port[i] = NULL; | 1149 | port->dev.driver = |
1150 | &serial->type->driver; | ||
1151 | rc = device_bind_driver(&port->dev); | ||
1152 | } | ||
1153 | port->dev_state = PORT_UNREGISTERING; | ||
1154 | device_del(&port->dev); | ||
1155 | port->dev_state = PORT_UNREGISTERED; | ||
1156 | } | ||
1142 | } | 1157 | } |
1143 | } | 1158 | } |
1159 | serial->type->disconnect(serial); | ||
1144 | 1160 | ||
1145 | /* let the last holder of this object | 1161 | /* let the last holder of this object |
1146 | * cause it to be cleaned up */ | 1162 | * cause it to be cleaned up */ |
@@ -1318,7 +1334,8 @@ static void fixup_generic(struct usb_serial_driver *device) | |||
1318 | set_to_generic_if_null(device, chars_in_buffer); | 1334 | set_to_generic_if_null(device, chars_in_buffer); |
1319 | set_to_generic_if_null(device, read_bulk_callback); | 1335 | set_to_generic_if_null(device, read_bulk_callback); |
1320 | set_to_generic_if_null(device, write_bulk_callback); | 1336 | set_to_generic_if_null(device, write_bulk_callback); |
1321 | set_to_generic_if_null(device, shutdown); | 1337 | set_to_generic_if_null(device, disconnect); |
1338 | set_to_generic_if_null(device, release); | ||
1322 | } | 1339 | } |
1323 | 1340 | ||
1324 | int usb_serial_register(struct usb_serial_driver *driver) | 1341 | int usb_serial_register(struct usb_serial_driver *driver) |
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c index 6c9cbb59552a..614800972dc3 100644 --- a/drivers/usb/serial/usb_debug.c +++ b/drivers/usb/serial/usb_debug.c | |||
@@ -15,7 +15,19 @@ | |||
15 | #include <linux/usb.h> | 15 | #include <linux/usb.h> |
16 | #include <linux/usb/serial.h> | 16 | #include <linux/usb/serial.h> |
17 | 17 | ||
18 | #define URB_DEBUG_MAX_IN_FLIGHT_URBS 4000 | ||
18 | #define USB_DEBUG_MAX_PACKET_SIZE 8 | 19 | #define USB_DEBUG_MAX_PACKET_SIZE 8 |
20 | #define USB_DEBUG_BRK_SIZE 8 | ||
21 | static char USB_DEBUG_BRK[USB_DEBUG_BRK_SIZE] = { | ||
22 | 0x00, | ||
23 | 0xff, | ||
24 | 0x01, | ||
25 | 0xfe, | ||
26 | 0x00, | ||
27 | 0xfe, | ||
28 | 0x01, | ||
29 | 0xff, | ||
30 | }; | ||
19 | 31 | ||
20 | static struct usb_device_id id_table [] = { | 32 | static struct usb_device_id id_table [] = { |
21 | { USB_DEVICE(0x0525, 0x127a) }, | 33 | { USB_DEVICE(0x0525, 0x127a) }, |
@@ -38,6 +50,32 @@ static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port, | |||
38 | return usb_serial_generic_open(tty, port, filp); | 50 | return usb_serial_generic_open(tty, port, filp); |
39 | } | 51 | } |
40 | 52 | ||
53 | /* This HW really does not support a serial break, so one will be | ||
54 | * emulated when ever the break state is set to true. | ||
55 | */ | ||
56 | static void usb_debug_break_ctl(struct tty_struct *tty, int break_state) | ||
57 | { | ||
58 | struct usb_serial_port *port = tty->driver_data; | ||
59 | if (!break_state) | ||
60 | return; | ||
61 | usb_serial_generic_write(tty, port, USB_DEBUG_BRK, USB_DEBUG_BRK_SIZE); | ||
62 | } | ||
63 | |||
64 | static void usb_debug_read_bulk_callback(struct urb *urb) | ||
65 | { | ||
66 | struct usb_serial_port *port = urb->context; | ||
67 | |||
68 | if (urb->actual_length == USB_DEBUG_BRK_SIZE && | ||
69 | memcmp(urb->transfer_buffer, USB_DEBUG_BRK, | ||
70 | USB_DEBUG_BRK_SIZE) == 0) { | ||
71 | usb_serial_handle_break(port); | ||
72 | usb_serial_generic_resubmit_read_urb(port, GFP_ATOMIC); | ||
73 | return; | ||
74 | } | ||
75 | |||
76 | usb_serial_generic_read_bulk_callback(urb); | ||
77 | } | ||
78 | |||
41 | static struct usb_serial_driver debug_device = { | 79 | static struct usb_serial_driver debug_device = { |
42 | .driver = { | 80 | .driver = { |
43 | .owner = THIS_MODULE, | 81 | .owner = THIS_MODULE, |
@@ -46,6 +84,9 @@ static struct usb_serial_driver debug_device = { | |||
46 | .id_table = id_table, | 84 | .id_table = id_table, |
47 | .num_ports = 1, | 85 | .num_ports = 1, |
48 | .open = usb_debug_open, | 86 | .open = usb_debug_open, |
87 | .max_in_flight_urbs = URB_DEBUG_MAX_IN_FLIGHT_URBS, | ||
88 | .break_ctl = usb_debug_break_ctl, | ||
89 | .read_bulk_callback = usb_debug_read_bulk_callback, | ||
49 | }; | 90 | }; |
50 | 91 | ||
51 | static int __init debug_init(void) | 92 | static int __init debug_init(void) |
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c index b15f1c0e1d4a..f5d0f64dcc52 100644 --- a/drivers/usb/serial/visor.c +++ b/drivers/usb/serial/visor.c | |||
@@ -47,7 +47,7 @@ static void visor_unthrottle(struct tty_struct *tty); | |||
47 | static int visor_probe(struct usb_serial *serial, | 47 | static int visor_probe(struct usb_serial *serial, |
48 | const struct usb_device_id *id); | 48 | const struct usb_device_id *id); |
49 | static int visor_calc_num_ports(struct usb_serial *serial); | 49 | static int visor_calc_num_ports(struct usb_serial *serial); |
50 | static void visor_shutdown(struct usb_serial *serial); | 50 | static void visor_release(struct usb_serial *serial); |
51 | static void visor_write_bulk_callback(struct urb *urb); | 51 | static void visor_write_bulk_callback(struct urb *urb); |
52 | static void visor_read_bulk_callback(struct urb *urb); | 52 | static void visor_read_bulk_callback(struct urb *urb); |
53 | static void visor_read_int_callback(struct urb *urb); | 53 | static void visor_read_int_callback(struct urb *urb); |
@@ -202,7 +202,7 @@ static struct usb_serial_driver handspring_device = { | |||
202 | .attach = treo_attach, | 202 | .attach = treo_attach, |
203 | .probe = visor_probe, | 203 | .probe = visor_probe, |
204 | .calc_num_ports = visor_calc_num_ports, | 204 | .calc_num_ports = visor_calc_num_ports, |
205 | .shutdown = visor_shutdown, | 205 | .release = visor_release, |
206 | .write = visor_write, | 206 | .write = visor_write, |
207 | .write_room = visor_write_room, | 207 | .write_room = visor_write_room, |
208 | .write_bulk_callback = visor_write_bulk_callback, | 208 | .write_bulk_callback = visor_write_bulk_callback, |
@@ -227,7 +227,7 @@ static struct usb_serial_driver clie_5_device = { | |||
227 | .attach = clie_5_attach, | 227 | .attach = clie_5_attach, |
228 | .probe = visor_probe, | 228 | .probe = visor_probe, |
229 | .calc_num_ports = visor_calc_num_ports, | 229 | .calc_num_ports = visor_calc_num_ports, |
230 | .shutdown = visor_shutdown, | 230 | .release = visor_release, |
231 | .write = visor_write, | 231 | .write = visor_write, |
232 | .write_room = visor_write_room, | 232 | .write_room = visor_write_room, |
233 | .write_bulk_callback = visor_write_bulk_callback, | 233 | .write_bulk_callback = visor_write_bulk_callback, |
@@ -918,7 +918,7 @@ static int clie_5_attach(struct usb_serial *serial) | |||
918 | return generic_startup(serial); | 918 | return generic_startup(serial); |
919 | } | 919 | } |
920 | 920 | ||
921 | static void visor_shutdown(struct usb_serial *serial) | 921 | static void visor_release(struct usb_serial *serial) |
922 | { | 922 | { |
923 | struct visor_private *priv; | 923 | struct visor_private *priv; |
924 | int i; | 924 | int i; |
@@ -927,10 +927,7 @@ static void visor_shutdown(struct usb_serial *serial) | |||
927 | 927 | ||
928 | for (i = 0; i < serial->num_ports; i++) { | 928 | for (i = 0; i < serial->num_ports; i++) { |
929 | priv = usb_get_serial_port_data(serial->port[i]); | 929 | priv = usb_get_serial_port_data(serial->port[i]); |
930 | if (priv) { | 930 | kfree(priv); |
931 | usb_set_serial_port_data(serial->port[i], NULL); | ||
932 | kfree(priv); | ||
933 | } | ||
934 | } | 931 | } |
935 | } | 932 | } |
936 | 933 | ||
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c index 7c7295d09f34..8d126dd7a02e 100644 --- a/drivers/usb/serial/whiteheat.c +++ b/drivers/usb/serial/whiteheat.c | |||
@@ -144,7 +144,7 @@ static int whiteheat_firmware_attach(struct usb_serial *serial); | |||
144 | 144 | ||
145 | /* function prototypes for the Connect Tech WhiteHEAT serial converter */ | 145 | /* function prototypes for the Connect Tech WhiteHEAT serial converter */ |
146 | static int whiteheat_attach(struct usb_serial *serial); | 146 | static int whiteheat_attach(struct usb_serial *serial); |
147 | static void whiteheat_shutdown(struct usb_serial *serial); | 147 | static void whiteheat_release(struct usb_serial *serial); |
148 | static int whiteheat_open(struct tty_struct *tty, | 148 | static int whiteheat_open(struct tty_struct *tty, |
149 | struct usb_serial_port *port, struct file *filp); | 149 | struct usb_serial_port *port, struct file *filp); |
150 | static void whiteheat_close(struct usb_serial_port *port); | 150 | static void whiteheat_close(struct usb_serial_port *port); |
@@ -189,7 +189,7 @@ static struct usb_serial_driver whiteheat_device = { | |||
189 | .id_table = id_table_std, | 189 | .id_table = id_table_std, |
190 | .num_ports = 4, | 190 | .num_ports = 4, |
191 | .attach = whiteheat_attach, | 191 | .attach = whiteheat_attach, |
192 | .shutdown = whiteheat_shutdown, | 192 | .release = whiteheat_release, |
193 | .open = whiteheat_open, | 193 | .open = whiteheat_open, |
194 | .close = whiteheat_close, | 194 | .close = whiteheat_close, |
195 | .write = whiteheat_write, | 195 | .write = whiteheat_write, |
@@ -617,7 +617,7 @@ no_command_buffer: | |||
617 | } | 617 | } |
618 | 618 | ||
619 | 619 | ||
620 | static void whiteheat_shutdown(struct usb_serial *serial) | 620 | static void whiteheat_release(struct usb_serial *serial) |
621 | { | 621 | { |
622 | struct usb_serial_port *command_port; | 622 | struct usb_serial_port *command_port; |
623 | struct usb_serial_port *port; | 623 | struct usb_serial_port *port; |
diff --git a/drivers/usb/storage/initializers.c b/drivers/usb/storage/initializers.c index 2dd9bd4bff56..ec17c96371af 100644 --- a/drivers/usb/storage/initializers.c +++ b/drivers/usb/storage/initializers.c | |||
@@ -52,7 +52,7 @@ int usb_stor_euscsi_init(struct us_data *us) | |||
52 | us->iobuf[0] = 0x1; | 52 | us->iobuf[0] = 0x1; |
53 | result = usb_stor_control_msg(us, us->send_ctrl_pipe, | 53 | result = usb_stor_control_msg(us, us->send_ctrl_pipe, |
54 | 0x0C, USB_RECIP_INTERFACE | USB_TYPE_VENDOR, | 54 | 0x0C, USB_RECIP_INTERFACE | USB_TYPE_VENDOR, |
55 | 0x01, 0x0, us->iobuf, 0x1, 5*HZ); | 55 | 0x01, 0x0, us->iobuf, 0x1, 5000); |
56 | US_DEBUGP("-- result is %d\n", result); | 56 | US_DEBUGP("-- result is %d\n", result); |
57 | 57 | ||
58 | return 0; | 58 | return 0; |
@@ -80,14 +80,16 @@ int usb_stor_ucr61s2b_init(struct us_data *us) | |||
80 | 80 | ||
81 | res = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb, | 81 | res = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb, |
82 | US_BULK_CB_WRAP_LEN, &partial); | 82 | US_BULK_CB_WRAP_LEN, &partial); |
83 | if(res) | 83 | if (res) |
84 | return res; | 84 | return -EIO; |
85 | 85 | ||
86 | US_DEBUGP("Getting status packet...\n"); | 86 | US_DEBUGP("Getting status packet...\n"); |
87 | res = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs, | 87 | res = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs, |
88 | US_BULK_CS_WRAP_LEN, &partial); | 88 | US_BULK_CS_WRAP_LEN, &partial); |
89 | if (res) | ||
90 | return -EIO; | ||
89 | 91 | ||
90 | return (res ? -1 : 0); | 92 | return 0; |
91 | } | 93 | } |
92 | 94 | ||
93 | /* This places the HUAWEI E220 devices in multi-port mode */ | 95 | /* This places the HUAWEI E220 devices in multi-port mode */ |
@@ -99,6 +101,6 @@ int usb_stor_huawei_e220_init(struct us_data *us) | |||
99 | USB_REQ_SET_FEATURE, | 101 | USB_REQ_SET_FEATURE, |
100 | USB_TYPE_STANDARD | USB_RECIP_DEVICE, | 102 | USB_TYPE_STANDARD | USB_RECIP_DEVICE, |
101 | 0x01, 0x0, NULL, 0x0, 1000); | 103 | 0x01, 0x0, NULL, 0x0, 1000); |
102 | US_DEBUGP("usb_control_msg performing result is %d\n", result); | 104 | US_DEBUGP("Huawei mode set result is %d\n", result); |
103 | return (result ? 0 : -1); | 105 | return (result ? 0 : -ENODEV); |
104 | } | 106 | } |
diff --git a/drivers/usb/storage/option_ms.c b/drivers/usb/storage/option_ms.c index 353f922939a4..d41cc0a970f7 100644 --- a/drivers/usb/storage/option_ms.c +++ b/drivers/usb/storage/option_ms.c | |||
@@ -37,7 +37,7 @@ MODULE_PARM_DESC(option_zero_cd, "ZeroCD mode (1=Force Modem (default)," | |||
37 | 37 | ||
38 | #define RESPONSE_LEN 1024 | 38 | #define RESPONSE_LEN 1024 |
39 | 39 | ||
40 | static int option_rezero(struct us_data *us, int ep_in, int ep_out) | 40 | static int option_rezero(struct us_data *us) |
41 | { | 41 | { |
42 | const unsigned char rezero_msg[] = { | 42 | const unsigned char rezero_msg[] = { |
43 | 0x55, 0x53, 0x42, 0x43, 0x78, 0x56, 0x34, 0x12, | 43 | 0x55, 0x53, 0x42, 0x43, 0x78, 0x56, 0x34, 0x12, |
@@ -54,10 +54,10 @@ static int option_rezero(struct us_data *us, int ep_in, int ep_out) | |||
54 | if (buffer == NULL) | 54 | if (buffer == NULL) |
55 | return USB_STOR_TRANSPORT_ERROR; | 55 | return USB_STOR_TRANSPORT_ERROR; |
56 | 56 | ||
57 | memcpy(buffer, rezero_msg, sizeof (rezero_msg)); | 57 | memcpy(buffer, rezero_msg, sizeof(rezero_msg)); |
58 | result = usb_stor_bulk_transfer_buf(us, | 58 | result = usb_stor_bulk_transfer_buf(us, |
59 | usb_sndbulkpipe(us->pusb_dev, ep_out), | 59 | us->send_bulk_pipe, |
60 | buffer, sizeof (rezero_msg), NULL); | 60 | buffer, sizeof(rezero_msg), NULL); |
61 | if (result != USB_STOR_XFER_GOOD) { | 61 | if (result != USB_STOR_XFER_GOOD) { |
62 | result = USB_STOR_XFER_ERROR; | 62 | result = USB_STOR_XFER_ERROR; |
63 | goto out; | 63 | goto out; |
@@ -66,9 +66,15 @@ static int option_rezero(struct us_data *us, int ep_in, int ep_out) | |||
66 | /* Some of the devices need to be asked for a response, but we don't | 66 | /* Some of the devices need to be asked for a response, but we don't |
67 | * care what that response is. | 67 | * care what that response is. |
68 | */ | 68 | */ |
69 | result = usb_stor_bulk_transfer_buf(us, | 69 | usb_stor_bulk_transfer_buf(us, |
70 | usb_sndbulkpipe(us->pusb_dev, ep_out), | 70 | us->recv_bulk_pipe, |
71 | buffer, RESPONSE_LEN, NULL); | 71 | buffer, RESPONSE_LEN, NULL); |
72 | |||
73 | /* Read the CSW */ | ||
74 | usb_stor_bulk_transfer_buf(us, | ||
75 | us->recv_bulk_pipe, | ||
76 | buffer, 13, NULL); | ||
77 | |||
72 | result = USB_STOR_XFER_GOOD; | 78 | result = USB_STOR_XFER_GOOD; |
73 | 79 | ||
74 | out: | 80 | out: |
@@ -76,63 +82,75 @@ out: | |||
76 | return result; | 82 | return result; |
77 | } | 83 | } |
78 | 84 | ||
79 | int option_ms_init(struct us_data *us) | 85 | static int option_inquiry(struct us_data *us) |
80 | { | 86 | { |
81 | struct usb_device *udev; | 87 | const unsigned char inquiry_msg[] = { |
82 | struct usb_interface *intf; | 88 | 0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, |
83 | struct usb_host_interface *iface_desc; | 89 | 0x24, 0x00, 0x00, 0x00, 0x80, 0x00, 0x06, 0x12, |
84 | struct usb_endpoint_descriptor *endpoint = NULL; | 90 | 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, |
85 | u8 ep_in = 0, ep_out = 0; | 91 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
86 | int ep_in_size = 0, ep_out_size = 0; | 92 | }; |
87 | int i, result; | 93 | char *buffer; |
88 | 94 | int result; | |
89 | udev = us->pusb_dev; | ||
90 | intf = us->pusb_intf; | ||
91 | |||
92 | /* Ensure it's really a ZeroCD device; devices that are already | ||
93 | * in modem mode return 0xFF for class, subclass, and protocol. | ||
94 | */ | ||
95 | if (udev->descriptor.bDeviceClass != 0 || | ||
96 | udev->descriptor.bDeviceSubClass != 0 || | ||
97 | udev->descriptor.bDeviceProtocol != 0) | ||
98 | return USB_STOR_TRANSPORT_GOOD; | ||
99 | 95 | ||
100 | US_DEBUGP("Option MS: option_ms_init called\n"); | 96 | US_DEBUGP("Option MS: %s", "device inquiry for vendor name\n"); |
101 | 97 | ||
102 | /* Find the right mass storage interface */ | 98 | buffer = kzalloc(0x24, GFP_KERNEL); |
103 | iface_desc = intf->cur_altsetting; | 99 | if (buffer == NULL) |
104 | if (iface_desc->desc.bInterfaceClass != 0x8 || | 100 | return USB_STOR_TRANSPORT_ERROR; |
105 | iface_desc->desc.bInterfaceSubClass != 0x6 || | ||
106 | iface_desc->desc.bInterfaceProtocol != 0x50) { | ||
107 | US_DEBUGP("Option MS: mass storage interface not found, no action " | ||
108 | "required\n"); | ||
109 | return USB_STOR_TRANSPORT_GOOD; | ||
110 | } | ||
111 | 101 | ||
112 | /* Find the mass storage bulk endpoints */ | 102 | memcpy(buffer, inquiry_msg, sizeof(inquiry_msg)); |
113 | for (i = 0; i < iface_desc->desc.bNumEndpoints && (!ep_in_size || !ep_out_size); ++i) { | 103 | result = usb_stor_bulk_transfer_buf(us, |
114 | endpoint = &iface_desc->endpoint[i].desc; | 104 | us->send_bulk_pipe, |
115 | 105 | buffer, sizeof(inquiry_msg), NULL); | |
116 | if (usb_endpoint_is_bulk_in(endpoint)) { | 106 | if (result != USB_STOR_XFER_GOOD) { |
117 | ep_in = usb_endpoint_num(endpoint); | 107 | result = USB_STOR_XFER_ERROR; |
118 | ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize); | 108 | goto out; |
119 | } else if (usb_endpoint_is_bulk_out(endpoint)) { | ||
120 | ep_out = usb_endpoint_num(endpoint); | ||
121 | ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize); | ||
122 | } | ||
123 | } | 109 | } |
124 | 110 | ||
125 | /* Can't find the mass storage endpoints */ | 111 | result = usb_stor_bulk_transfer_buf(us, |
126 | if (!ep_in_size || !ep_out_size) { | 112 | us->recv_bulk_pipe, |
127 | US_DEBUGP("Option MS: mass storage endpoints not found, no action " | 113 | buffer, 0x24, NULL); |
128 | "required\n"); | 114 | if (result != USB_STOR_XFER_GOOD) { |
129 | return USB_STOR_TRANSPORT_GOOD; | 115 | result = USB_STOR_XFER_ERROR; |
116 | goto out; | ||
130 | } | 117 | } |
131 | 118 | ||
119 | result = memcmp(buffer+8, "Option", 6); | ||
120 | |||
121 | /* Read the CSW */ | ||
122 | usb_stor_bulk_transfer_buf(us, | ||
123 | us->recv_bulk_pipe, | ||
124 | buffer, 13, NULL); | ||
125 | |||
126 | out: | ||
127 | kfree(buffer); | ||
128 | return result; | ||
129 | } | ||
130 | |||
131 | |||
132 | int option_ms_init(struct us_data *us) | ||
133 | { | ||
134 | int result; | ||
135 | |||
136 | US_DEBUGP("Option MS: option_ms_init called\n"); | ||
137 | |||
138 | /* Additional test for vendor information via INQUIRY, | ||
139 | * because some vendor/product IDs are ambiguous | ||
140 | */ | ||
141 | result = option_inquiry(us); | ||
142 | if (result != 0) { | ||
143 | US_DEBUGP("Option MS: vendor is not Option or not determinable," | ||
144 | " no action taken\n"); | ||
145 | return 0; | ||
146 | } else | ||
147 | US_DEBUGP("Option MS: this is a genuine Option device," | ||
148 | " proceeding\n"); | ||
149 | |||
132 | /* Force Modem mode */ | 150 | /* Force Modem mode */ |
133 | if (option_zero_cd == ZCD_FORCE_MODEM) { | 151 | if (option_zero_cd == ZCD_FORCE_MODEM) { |
134 | US_DEBUGP("Option MS: %s", "Forcing Modem Mode\n"); | 152 | US_DEBUGP("Option MS: %s", "Forcing Modem Mode\n"); |
135 | result = option_rezero(us, ep_in, ep_out); | 153 | result = option_rezero(us); |
136 | if (result != USB_STOR_XFER_GOOD) | 154 | if (result != USB_STOR_XFER_GOOD) |
137 | US_DEBUGP("Option MS: Failed to switch to modem mode.\n"); | 155 | US_DEBUGP("Option MS: Failed to switch to modem mode.\n"); |
138 | return -EIO; | 156 | return -EIO; |
@@ -142,6 +160,6 @@ int option_ms_init(struct us_data *us) | |||
142 | " requests it\n"); | 160 | " requests it\n"); |
143 | } | 161 | } |
144 | 162 | ||
145 | return USB_STOR_TRANSPORT_GOOD; | 163 | return 0; |
146 | } | 164 | } |
147 | 165 | ||
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c index 4359a2cb42df..4395c4100ec2 100644 --- a/drivers/usb/storage/sierra_ms.c +++ b/drivers/usb/storage/sierra_ms.c | |||
@@ -202,6 +202,6 @@ int sierra_ms_init(struct us_data *us) | |||
202 | complete: | 202 | complete: |
203 | result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); | 203 | result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); |
204 | 204 | ||
205 | return USB_STOR_TRANSPORT_GOOD; | 205 | return 0; |
206 | } | 206 | } |
207 | 207 | ||
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h index 4b8b69045fe6..1b9c5dd0fb27 100644 --- a/drivers/usb/storage/unusual_devs.h +++ b/drivers/usb/storage/unusual_devs.h | |||
@@ -1385,7 +1385,7 @@ UNUSUAL_DEV( 0x10d6, 0x2200, 0x0100, 0x0100, | |||
1385 | UNUSUAL_DEV( 0x1186, 0x3e04, 0x0000, 0x0000, | 1385 | UNUSUAL_DEV( 0x1186, 0x3e04, 0x0000, 0x0000, |
1386 | "D-Link", | 1386 | "D-Link", |
1387 | "USB Mass Storage", | 1387 | "USB Mass Storage", |
1388 | US_SC_DEVICE, US_PR_DEVICE, option_ms_init, 0), | 1388 | US_SC_DEVICE, US_PR_DEVICE, option_ms_init, US_FL_IGNORE_DEVICE), |
1389 | 1389 | ||
1390 | /* Reported by Kevin Lloyd <linux@sierrawireless.com> | 1390 | /* Reported by Kevin Lloyd <linux@sierrawireless.com> |
1391 | * Entry is needed for the initializer function override, | 1391 | * Entry is needed for the initializer function override, |
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c index 9367b6297d84..89cd2deeb4af 100644 --- a/fs/befs/linuxvfs.c +++ b/fs/befs/linuxvfs.c | |||
@@ -513,7 +513,7 @@ befs_utf2nls(struct super_block *sb, const char *in, | |||
513 | { | 513 | { |
514 | struct nls_table *nls = BEFS_SB(sb)->nls; | 514 | struct nls_table *nls = BEFS_SB(sb)->nls; |
515 | int i, o; | 515 | int i, o; |
516 | wchar_t uni; | 516 | unicode_t uni; |
517 | int unilen, utflen; | 517 | int unilen, utflen; |
518 | char *result; | 518 | char *result; |
519 | /* The utf8->nls conversion won't make the final nls string bigger | 519 | /* The utf8->nls conversion won't make the final nls string bigger |
@@ -539,16 +539,16 @@ befs_utf2nls(struct super_block *sb, const char *in, | |||
539 | for (i = o = 0; i < in_len; i += utflen, o += unilen) { | 539 | for (i = o = 0; i < in_len; i += utflen, o += unilen) { |
540 | 540 | ||
541 | /* convert from UTF-8 to Unicode */ | 541 | /* convert from UTF-8 to Unicode */ |
542 | utflen = utf8_mbtowc(&uni, &in[i], in_len - i); | 542 | utflen = utf8_to_utf32(&in[i], in_len - i, &uni); |
543 | if (utflen < 0) { | 543 | if (utflen < 0) |
544 | goto conv_err; | 544 | goto conv_err; |
545 | } | ||
546 | 545 | ||
547 | /* convert from Unicode to nls */ | 546 | /* convert from Unicode to nls */ |
547 | if (uni > MAX_WCHAR_T) | ||
548 | goto conv_err; | ||
548 | unilen = nls->uni2char(uni, &result[o], in_len - o); | 549 | unilen = nls->uni2char(uni, &result[o], in_len - o); |
549 | if (unilen < 0) { | 550 | if (unilen < 0) |
550 | goto conv_err; | 551 | goto conv_err; |
551 | } | ||
552 | } | 552 | } |
553 | result[o] = '\0'; | 553 | result[o] = '\0'; |
554 | *out_len = o; | 554 | *out_len = o; |
@@ -619,15 +619,13 @@ befs_nls2utf(struct super_block *sb, const char *in, | |||
619 | 619 | ||
620 | /* convert from nls to unicode */ | 620 | /* convert from nls to unicode */ |
621 | unilen = nls->char2uni(&in[i], in_len - i, &uni); | 621 | unilen = nls->char2uni(&in[i], in_len - i, &uni); |
622 | if (unilen < 0) { | 622 | if (unilen < 0) |
623 | goto conv_err; | 623 | goto conv_err; |
624 | } | ||
625 | 624 | ||
626 | /* convert from unicode to UTF-8 */ | 625 | /* convert from unicode to UTF-8 */ |
627 | utflen = utf8_wctomb(&result[o], uni, 3); | 626 | utflen = utf32_to_utf8(uni, &result[o], 3); |
628 | if (utflen <= 0) { | 627 | if (utflen <= 0) |
629 | goto conv_err; | 628 | goto conv_err; |
630 | } | ||
631 | } | 629 | } |
632 | 630 | ||
633 | result[o] = '\0'; | 631 | result[o] = '\0'; |
diff --git a/fs/fat/dir.c b/fs/fat/dir.c index 3b8e71b412fd..38ff75a0fe22 100644 --- a/fs/fat/dir.c +++ b/fs/fat/dir.c | |||
@@ -22,6 +22,19 @@ | |||
22 | #include <asm/uaccess.h> | 22 | #include <asm/uaccess.h> |
23 | #include "fat.h" | 23 | #include "fat.h" |
24 | 24 | ||
25 | /* | ||
26 | * Maximum buffer size of short name. | ||
27 | * [(MSDOS_NAME + '.') * max one char + nul] | ||
28 | * For msdos style, ['.' (hidden) + MSDOS_NAME + '.' + nul] | ||
29 | */ | ||
30 | #define FAT_MAX_SHORT_SIZE ((MSDOS_NAME + 1) * NLS_MAX_CHARSET_SIZE + 1) | ||
31 | /* | ||
32 | * Maximum buffer size of unicode chars from slots. | ||
33 | * [(max longname slots * 13 (size in a slot) + nul) * sizeof(wchar_t)] | ||
34 | */ | ||
35 | #define FAT_MAX_UNI_CHARS ((MSDOS_SLOTS - 1) * 13 + 1) | ||
36 | #define FAT_MAX_UNI_SIZE (FAT_MAX_UNI_CHARS * sizeof(wchar_t)) | ||
37 | |||
25 | static inline loff_t fat_make_i_pos(struct super_block *sb, | 38 | static inline loff_t fat_make_i_pos(struct super_block *sb, |
26 | struct buffer_head *bh, | 39 | struct buffer_head *bh, |
27 | struct msdos_dir_entry *de) | 40 | struct msdos_dir_entry *de) |
@@ -171,7 +184,8 @@ static inline int fat_uni_to_x8(struct msdos_sb_info *sbi, const wchar_t *uni, | |||
171 | unsigned char *buf, int size) | 184 | unsigned char *buf, int size) |
172 | { | 185 | { |
173 | if (sbi->options.utf8) | 186 | if (sbi->options.utf8) |
174 | return utf8_wcstombs(buf, uni, size); | 187 | return utf16s_to_utf8s(uni, FAT_MAX_UNI_CHARS, |
188 | UTF16_HOST_ENDIAN, buf, size); | ||
175 | else | 189 | else |
176 | return uni16_to_x8(buf, uni, size, sbi->options.unicode_xlate, | 190 | return uni16_to_x8(buf, uni, size, sbi->options.unicode_xlate, |
177 | sbi->nls_io); | 191 | sbi->nls_io); |
@@ -325,19 +339,6 @@ parse_long: | |||
325 | } | 339 | } |
326 | 340 | ||
327 | /* | 341 | /* |
328 | * Maximum buffer size of short name. | ||
329 | * [(MSDOS_NAME + '.') * max one char + nul] | ||
330 | * For msdos style, ['.' (hidden) + MSDOS_NAME + '.' + nul] | ||
331 | */ | ||
332 | #define FAT_MAX_SHORT_SIZE ((MSDOS_NAME + 1) * NLS_MAX_CHARSET_SIZE + 1) | ||
333 | /* | ||
334 | * Maximum buffer size of unicode chars from slots. | ||
335 | * [(max longname slots * 13 (size in a slot) + nul) * sizeof(wchar_t)] | ||
336 | */ | ||
337 | #define FAT_MAX_UNI_CHARS ((MSDOS_SLOTS - 1) * 13 + 1) | ||
338 | #define FAT_MAX_UNI_SIZE (FAT_MAX_UNI_CHARS * sizeof(wchar_t)) | ||
339 | |||
340 | /* | ||
341 | * Return values: negative -> error, 0 -> not found, positive -> found, | 342 | * Return values: negative -> error, 0 -> not found, positive -> found, |
342 | * value is the total amount of slots, including the shortname entry. | 343 | * value is the total amount of slots, including the shortname entry. |
343 | */ | 344 | */ |
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c index 8d6fdcfd41df..73471b7ecc8c 100644 --- a/fs/fat/namei_vfat.c +++ b/fs/fat/namei_vfat.c | |||
@@ -502,11 +502,11 @@ xlate_to_uni(const unsigned char *name, int len, unsigned char *outname, | |||
502 | if (utf8) { | 502 | if (utf8) { |
503 | int name_len = strlen(name); | 503 | int name_len = strlen(name); |
504 | 504 | ||
505 | *outlen = utf8_mbstowcs((wchar_t *)outname, name, PATH_MAX); | 505 | *outlen = utf8s_to_utf16s(name, PATH_MAX, (wchar_t *) outname); |
506 | 506 | ||
507 | /* | 507 | /* |
508 | * We stripped '.'s before and set len appropriately, | 508 | * We stripped '.'s before and set len appropriately, |
509 | * but utf8_mbstowcs doesn't care about len | 509 | * but utf8s_to_utf16s doesn't care about len |
510 | */ | 510 | */ |
511 | *outlen -= (name_len - len); | 511 | *outlen -= (name_len - len); |
512 | 512 | ||
diff --git a/fs/isofs/joliet.c b/fs/isofs/joliet.c index 92c14b850e9c..a048de81c093 100644 --- a/fs/isofs/joliet.c +++ b/fs/isofs/joliet.c | |||
@@ -37,37 +37,6 @@ uni16_to_x8(unsigned char *ascii, __be16 *uni, int len, struct nls_table *nls) | |||
37 | return (op - ascii); | 37 | return (op - ascii); |
38 | } | 38 | } |
39 | 39 | ||
40 | /* Convert big endian wide character string to utf8 */ | ||
41 | static int | ||
42 | wcsntombs_be(__u8 *s, const __u8 *pwcs, int inlen, int maxlen) | ||
43 | { | ||
44 | const __u8 *ip; | ||
45 | __u8 *op; | ||
46 | int size; | ||
47 | __u16 c; | ||
48 | |||
49 | op = s; | ||
50 | ip = pwcs; | ||
51 | while ((*ip || ip[1]) && (maxlen > 0) && (inlen > 0)) { | ||
52 | c = (*ip << 8) | ip[1]; | ||
53 | if (c > 0x7f) { | ||
54 | size = utf8_wctomb(op, c, maxlen); | ||
55 | if (size == -1) { | ||
56 | /* Ignore character and move on */ | ||
57 | maxlen--; | ||
58 | } else { | ||
59 | op += size; | ||
60 | maxlen -= size; | ||
61 | } | ||
62 | } else { | ||
63 | *op++ = (__u8) c; | ||
64 | } | ||
65 | ip += 2; | ||
66 | inlen--; | ||
67 | } | ||
68 | return (op - s); | ||
69 | } | ||
70 | |||
71 | int | 40 | int |
72 | get_joliet_filename(struct iso_directory_record * de, unsigned char *outname, struct inode * inode) | 41 | get_joliet_filename(struct iso_directory_record * de, unsigned char *outname, struct inode * inode) |
73 | { | 42 | { |
@@ -79,8 +48,9 @@ get_joliet_filename(struct iso_directory_record * de, unsigned char *outname, st | |||
79 | nls = ISOFS_SB(inode->i_sb)->s_nls_iocharset; | 48 | nls = ISOFS_SB(inode->i_sb)->s_nls_iocharset; |
80 | 49 | ||
81 | if (utf8) { | 50 | if (utf8) { |
82 | len = wcsntombs_be(outname, de->name, | 51 | len = utf16s_to_utf8s((const wchar_t *) de->name, |
83 | de->name_len[0] >> 1, PAGE_SIZE); | 52 | de->name_len[0] >> 1, UTF16_BIG_ENDIAN, |
53 | outname, PAGE_SIZE); | ||
84 | } else { | 54 | } else { |
85 | len = uni16_to_x8(outname, (__be16 *) de->name, | 55 | len = uni16_to_x8(outname, (__be16 *) de->name, |
86 | de->name_len[0] >> 1, nls); | 56 | de->name_len[0] >> 1, nls); |
diff --git a/fs/ncpfs/ncplib_kernel.c b/fs/ncpfs/ncplib_kernel.c index 97645f112114..0ec6237a5970 100644 --- a/fs/ncpfs/ncplib_kernel.c +++ b/fs/ncpfs/ncplib_kernel.c | |||
@@ -1113,11 +1113,13 @@ ncp__io2vol(struct ncp_server *server, unsigned char *vname, unsigned int *vlen, | |||
1113 | 1113 | ||
1114 | if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) { | 1114 | if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) { |
1115 | int k; | 1115 | int k; |
1116 | unicode_t u; | ||
1116 | 1117 | ||
1117 | k = utf8_mbtowc(&ec, iname, iname_end - iname); | 1118 | k = utf8_to_utf32(iname, iname_end - iname, &u); |
1118 | if (k < 0) | 1119 | if (k < 0 || u > MAX_WCHAR_T) |
1119 | return -EINVAL; | 1120 | return -EINVAL; |
1120 | iname += k; | 1121 | iname += k; |
1122 | ec = u; | ||
1121 | } else { | 1123 | } else { |
1122 | if (*iname == NCP_ESC) { | 1124 | if (*iname == NCP_ESC) { |
1123 | int k; | 1125 | int k; |
@@ -1214,7 +1216,7 @@ ncp__vol2io(struct ncp_server *server, unsigned char *iname, unsigned int *ilen, | |||
1214 | if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) { | 1216 | if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) { |
1215 | int k; | 1217 | int k; |
1216 | 1218 | ||
1217 | k = utf8_wctomb(iname, ec, iname_end - iname); | 1219 | k = utf32_to_utf8(ec, iname, iname_end - iname); |
1218 | if (k < 0) { | 1220 | if (k < 0) { |
1219 | err = -ENAMETOOLONG; | 1221 | err = -ENAMETOOLONG; |
1220 | goto quit; | 1222 | goto quit; |
diff --git a/fs/nls/nls_base.c b/fs/nls/nls_base.c index 9b0efdad8910..477d37d83b31 100644 --- a/fs/nls/nls_base.c +++ b/fs/nls/nls_base.c | |||
@@ -15,6 +15,7 @@ | |||
15 | #include <linux/errno.h> | 15 | #include <linux/errno.h> |
16 | #include <linux/kmod.h> | 16 | #include <linux/kmod.h> |
17 | #include <linux/spinlock.h> | 17 | #include <linux/spinlock.h> |
18 | #include <asm/byteorder.h> | ||
18 | 19 | ||
19 | static struct nls_table default_table; | 20 | static struct nls_table default_table; |
20 | static struct nls_table *tables = &default_table; | 21 | static struct nls_table *tables = &default_table; |
@@ -43,10 +44,17 @@ static const struct utf8_table utf8_table[] = | |||
43 | {0, /* end of table */} | 44 | {0, /* end of table */} |
44 | }; | 45 | }; |
45 | 46 | ||
46 | int | 47 | #define UNICODE_MAX 0x0010ffff |
47 | utf8_mbtowc(wchar_t *p, const __u8 *s, int n) | 48 | #define PLANE_SIZE 0x00010000 |
49 | |||
50 | #define SURROGATE_MASK 0xfffff800 | ||
51 | #define SURROGATE_PAIR 0x0000d800 | ||
52 | #define SURROGATE_LOW 0x00000400 | ||
53 | #define SURROGATE_BITS 0x000003ff | ||
54 | |||
55 | int utf8_to_utf32(const u8 *s, int len, unicode_t *pu) | ||
48 | { | 56 | { |
49 | long l; | 57 | unsigned long l; |
50 | int c0, c, nc; | 58 | int c0, c, nc; |
51 | const struct utf8_table *t; | 59 | const struct utf8_table *t; |
52 | 60 | ||
@@ -57,12 +65,13 @@ utf8_mbtowc(wchar_t *p, const __u8 *s, int n) | |||
57 | nc++; | 65 | nc++; |
58 | if ((c0 & t->cmask) == t->cval) { | 66 | if ((c0 & t->cmask) == t->cval) { |
59 | l &= t->lmask; | 67 | l &= t->lmask; |
60 | if (l < t->lval) | 68 | if (l < t->lval || l > UNICODE_MAX || |
69 | (l & SURROGATE_MASK) == SURROGATE_PAIR) | ||
61 | return -1; | 70 | return -1; |
62 | *p = l; | 71 | *pu = (unicode_t) l; |
63 | return nc; | 72 | return nc; |
64 | } | 73 | } |
65 | if (n <= nc) | 74 | if (len <= nc) |
66 | return -1; | 75 | return -1; |
67 | s++; | 76 | s++; |
68 | c = (*s ^ 0x80) & 0xFF; | 77 | c = (*s ^ 0x80) & 0xFF; |
@@ -72,90 +81,133 @@ utf8_mbtowc(wchar_t *p, const __u8 *s, int n) | |||
72 | } | 81 | } |
73 | return -1; | 82 | return -1; |
74 | } | 83 | } |
84 | EXPORT_SYMBOL(utf8_to_utf32); | ||
75 | 85 | ||
76 | int | 86 | int utf32_to_utf8(unicode_t u, u8 *s, int maxlen) |
77 | utf8_mbstowcs(wchar_t *pwcs, const __u8 *s, int n) | ||
78 | { | 87 | { |
79 | __u16 *op; | 88 | unsigned long l; |
80 | const __u8 *ip; | ||
81 | int size; | ||
82 | |||
83 | op = pwcs; | ||
84 | ip = s; | ||
85 | while (*ip && n > 0) { | ||
86 | if (*ip & 0x80) { | ||
87 | size = utf8_mbtowc(op, ip, n); | ||
88 | if (size == -1) { | ||
89 | /* Ignore character and move on */ | ||
90 | ip++; | ||
91 | n--; | ||
92 | } else { | ||
93 | op++; | ||
94 | ip += size; | ||
95 | n -= size; | ||
96 | } | ||
97 | } else { | ||
98 | *op++ = *ip++; | ||
99 | n--; | ||
100 | } | ||
101 | } | ||
102 | return (op - pwcs); | ||
103 | } | ||
104 | |||
105 | int | ||
106 | utf8_wctomb(__u8 *s, wchar_t wc, int maxlen) | ||
107 | { | ||
108 | long l; | ||
109 | int c, nc; | 89 | int c, nc; |
110 | const struct utf8_table *t; | 90 | const struct utf8_table *t; |
111 | 91 | ||
112 | if (!s) | 92 | if (!s) |
113 | return 0; | 93 | return 0; |
114 | 94 | ||
115 | l = wc; | 95 | l = u; |
96 | if (l > UNICODE_MAX || (l & SURROGATE_MASK) == SURROGATE_PAIR) | ||
97 | return -1; | ||
98 | |||
116 | nc = 0; | 99 | nc = 0; |
117 | for (t = utf8_table; t->cmask && maxlen; t++, maxlen--) { | 100 | for (t = utf8_table; t->cmask && maxlen; t++, maxlen--) { |
118 | nc++; | 101 | nc++; |
119 | if (l <= t->lmask) { | 102 | if (l <= t->lmask) { |
120 | c = t->shift; | 103 | c = t->shift; |
121 | *s = t->cval | (l >> c); | 104 | *s = (u8) (t->cval | (l >> c)); |
122 | while (c > 0) { | 105 | while (c > 0) { |
123 | c -= 6; | 106 | c -= 6; |
124 | s++; | 107 | s++; |
125 | *s = 0x80 | ((l >> c) & 0x3F); | 108 | *s = (u8) (0x80 | ((l >> c) & 0x3F)); |
126 | } | 109 | } |
127 | return nc; | 110 | return nc; |
128 | } | 111 | } |
129 | } | 112 | } |
130 | return -1; | 113 | return -1; |
131 | } | 114 | } |
115 | EXPORT_SYMBOL(utf32_to_utf8); | ||
132 | 116 | ||
133 | int | 117 | int utf8s_to_utf16s(const u8 *s, int len, wchar_t *pwcs) |
134 | utf8_wcstombs(__u8 *s, const wchar_t *pwcs, int maxlen) | ||
135 | { | 118 | { |
136 | const __u16 *ip; | 119 | u16 *op; |
137 | __u8 *op; | ||
138 | int size; | 120 | int size; |
121 | unicode_t u; | ||
122 | |||
123 | op = pwcs; | ||
124 | while (*s && len > 0) { | ||
125 | if (*s & 0x80) { | ||
126 | size = utf8_to_utf32(s, len, &u); | ||
127 | if (size < 0) { | ||
128 | /* Ignore character and move on */ | ||
129 | size = 1; | ||
130 | } else if (u >= PLANE_SIZE) { | ||
131 | u -= PLANE_SIZE; | ||
132 | *op++ = (wchar_t) (SURROGATE_PAIR | | ||
133 | ((u >> 10) & SURROGATE_BITS)); | ||
134 | *op++ = (wchar_t) (SURROGATE_PAIR | | ||
135 | SURROGATE_LOW | | ||
136 | (u & SURROGATE_BITS)); | ||
137 | } else { | ||
138 | *op++ = (wchar_t) u; | ||
139 | } | ||
140 | s += size; | ||
141 | len -= size; | ||
142 | } else { | ||
143 | *op++ = *s++; | ||
144 | len--; | ||
145 | } | ||
146 | } | ||
147 | return op - pwcs; | ||
148 | } | ||
149 | EXPORT_SYMBOL(utf8s_to_utf16s); | ||
150 | |||
151 | static inline unsigned long get_utf16(unsigned c, enum utf16_endian endian) | ||
152 | { | ||
153 | switch (endian) { | ||
154 | default: | ||
155 | return c; | ||
156 | case UTF16_LITTLE_ENDIAN: | ||
157 | return __le16_to_cpu(c); | ||
158 | case UTF16_BIG_ENDIAN: | ||
159 | return __be16_to_cpu(c); | ||
160 | } | ||
161 | } | ||
162 | |||
163 | int utf16s_to_utf8s(const wchar_t *pwcs, int len, enum utf16_endian endian, | ||
164 | u8 *s, int maxlen) | ||
165 | { | ||
166 | u8 *op; | ||
167 | int size; | ||
168 | unsigned long u, v; | ||
139 | 169 | ||
140 | op = s; | 170 | op = s; |
141 | ip = pwcs; | 171 | while (len > 0 && maxlen > 0) { |
142 | while (*ip && maxlen > 0) { | 172 | u = get_utf16(*pwcs, endian); |
143 | if (*ip > 0x7f) { | 173 | if (!u) |
144 | size = utf8_wctomb(op, *ip, maxlen); | 174 | break; |
175 | pwcs++; | ||
176 | len--; | ||
177 | if (u > 0x7f) { | ||
178 | if ((u & SURROGATE_MASK) == SURROGATE_PAIR) { | ||
179 | if (u & SURROGATE_LOW) { | ||
180 | /* Ignore character and move on */ | ||
181 | continue; | ||
182 | } | ||
183 | if (len <= 0) | ||
184 | break; | ||
185 | v = get_utf16(*pwcs, endian); | ||
186 | if ((v & SURROGATE_MASK) != SURROGATE_PAIR || | ||
187 | !(v & SURROGATE_LOW)) { | ||
188 | /* Ignore character and move on */ | ||
189 | continue; | ||
190 | } | ||
191 | u = PLANE_SIZE + ((u & SURROGATE_BITS) << 10) | ||
192 | + (v & SURROGATE_BITS); | ||
193 | pwcs++; | ||
194 | len--; | ||
195 | } | ||
196 | size = utf32_to_utf8(u, op, maxlen); | ||
145 | if (size == -1) { | 197 | if (size == -1) { |
146 | /* Ignore character and move on */ | 198 | /* Ignore character and move on */ |
147 | maxlen--; | ||
148 | } else { | 199 | } else { |
149 | op += size; | 200 | op += size; |
150 | maxlen -= size; | 201 | maxlen -= size; |
151 | } | 202 | } |
152 | } else { | 203 | } else { |
153 | *op++ = (__u8) *ip; | 204 | *op++ = (u8) u; |
205 | maxlen--; | ||
154 | } | 206 | } |
155 | ip++; | ||
156 | } | 207 | } |
157 | return (op - s); | 208 | return op - s; |
158 | } | 209 | } |
210 | EXPORT_SYMBOL(utf16s_to_utf8s); | ||
159 | 211 | ||
160 | int register_nls(struct nls_table * nls) | 212 | int register_nls(struct nls_table * nls) |
161 | { | 213 | { |
@@ -467,9 +519,5 @@ EXPORT_SYMBOL(unregister_nls); | |||
467 | EXPORT_SYMBOL(unload_nls); | 519 | EXPORT_SYMBOL(unload_nls); |
468 | EXPORT_SYMBOL(load_nls); | 520 | EXPORT_SYMBOL(load_nls); |
469 | EXPORT_SYMBOL(load_nls_default); | 521 | EXPORT_SYMBOL(load_nls_default); |
470 | EXPORT_SYMBOL(utf8_mbtowc); | ||
471 | EXPORT_SYMBOL(utf8_mbstowcs); | ||
472 | EXPORT_SYMBOL(utf8_wctomb); | ||
473 | EXPORT_SYMBOL(utf8_wcstombs); | ||
474 | 522 | ||
475 | MODULE_LICENSE("Dual BSD/GPL"); | 523 | MODULE_LICENSE("Dual BSD/GPL"); |
diff --git a/fs/nls/nls_utf8.c b/fs/nls/nls_utf8.c index aa2c42fdd977..0d60a44acacd 100644 --- a/fs/nls/nls_utf8.c +++ b/fs/nls/nls_utf8.c | |||
@@ -15,7 +15,11 @@ static int uni2char(wchar_t uni, unsigned char *out, int boundlen) | |||
15 | { | 15 | { |
16 | int n; | 16 | int n; |
17 | 17 | ||
18 | if ( (n = utf8_wctomb(out, uni, boundlen)) == -1) { | 18 | if (boundlen <= 0) |
19 | return -ENAMETOOLONG; | ||
20 | |||
21 | n = utf32_to_utf8(uni, out, boundlen); | ||
22 | if (n < 0) { | ||
19 | *out = '?'; | 23 | *out = '?'; |
20 | return -EINVAL; | 24 | return -EINVAL; |
21 | } | 25 | } |
@@ -25,11 +29,14 @@ static int uni2char(wchar_t uni, unsigned char *out, int boundlen) | |||
25 | static int char2uni(const unsigned char *rawstring, int boundlen, wchar_t *uni) | 29 | static int char2uni(const unsigned char *rawstring, int boundlen, wchar_t *uni) |
26 | { | 30 | { |
27 | int n; | 31 | int n; |
32 | unicode_t u; | ||
28 | 33 | ||
29 | if ( (n = utf8_mbtowc(uni, rawstring, boundlen)) == -1) { | 34 | n = utf8_to_utf32(rawstring, boundlen, &u); |
35 | if (n < 0 || u > MAX_WCHAR_T) { | ||
30 | *uni = 0x003f; /* ? */ | 36 | *uni = 0x003f; /* ? */ |
31 | n = -EINVAL; | 37 | return -EINVAL; |
32 | } | 38 | } |
39 | *uni = (wchar_t) u; | ||
33 | return n; | 40 | return n; |
34 | } | 41 | } |
35 | 42 | ||
diff --git a/include/linux/nls.h b/include/linux/nls.h index 52b1a76c1b43..d47beef08dfd 100644 --- a/include/linux/nls.h +++ b/include/linux/nls.h | |||
@@ -3,8 +3,23 @@ | |||
3 | 3 | ||
4 | #include <linux/init.h> | 4 | #include <linux/init.h> |
5 | 5 | ||
6 | /* unicode character */ | 6 | /* Unicode has changed over the years. Unicode code points no longer |
7 | typedef __u16 wchar_t; | 7 | * fit into 16 bits; as of Unicode 5 valid code points range from 0 |
8 | * to 0x10ffff (17 planes, where each plane holds 65536 code points). | ||
9 | * | ||
10 | * The original decision to represent Unicode characters as 16-bit | ||
11 | * wchar_t values is now outdated. But plane 0 still includes the | ||
12 | * most commonly used characters, so we will retain it. The newer | ||
13 | * 32-bit unicode_t type can be used when it is necessary to | ||
14 | * represent the full Unicode character set. | ||
15 | */ | ||
16 | |||
17 | /* Plane-0 Unicode character */ | ||
18 | typedef u16 wchar_t; | ||
19 | #define MAX_WCHAR_T 0xffff | ||
20 | |||
21 | /* Arbitrary Unicode character */ | ||
22 | typedef u32 unicode_t; | ||
8 | 23 | ||
9 | struct nls_table { | 24 | struct nls_table { |
10 | const char *charset; | 25 | const char *charset; |
@@ -21,6 +36,13 @@ struct nls_table { | |||
21 | /* this value hold the maximum octet of charset */ | 36 | /* this value hold the maximum octet of charset */ |
22 | #define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */ | 37 | #define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */ |
23 | 38 | ||
39 | /* Byte order for UTF-16 strings */ | ||
40 | enum utf16_endian { | ||
41 | UTF16_HOST_ENDIAN, | ||
42 | UTF16_LITTLE_ENDIAN, | ||
43 | UTF16_BIG_ENDIAN | ||
44 | }; | ||
45 | |||
24 | /* nls.c */ | 46 | /* nls.c */ |
25 | extern int register_nls(struct nls_table *); | 47 | extern int register_nls(struct nls_table *); |
26 | extern int unregister_nls(struct nls_table *); | 48 | extern int unregister_nls(struct nls_table *); |
@@ -28,10 +50,11 @@ extern struct nls_table *load_nls(char *); | |||
28 | extern void unload_nls(struct nls_table *); | 50 | extern void unload_nls(struct nls_table *); |
29 | extern struct nls_table *load_nls_default(void); | 51 | extern struct nls_table *load_nls_default(void); |
30 | 52 | ||
31 | extern int utf8_mbtowc(wchar_t *, const __u8 *, int); | 53 | extern int utf8_to_utf32(const u8 *s, int len, unicode_t *pu); |
32 | extern int utf8_mbstowcs(wchar_t *, const __u8 *, int); | 54 | extern int utf32_to_utf8(unicode_t u, u8 *s, int maxlen); |
33 | extern int utf8_wctomb(__u8 *, wchar_t, int); | 55 | extern int utf8s_to_utf16s(const u8 *s, int len, wchar_t *pwcs); |
34 | extern int utf8_wcstombs(__u8 *, const wchar_t *, int); | 56 | extern int utf16s_to_utf8s(const wchar_t *pwcs, int len, |
57 | enum utf16_endian endian, u8 *s, int maxlen); | ||
35 | 58 | ||
36 | static inline unsigned char nls_tolower(struct nls_table *t, unsigned char c) | 59 | static inline unsigned char nls_tolower(struct nls_table *t, unsigned char c) |
37 | { | 60 | { |
diff --git a/include/linux/pci.h b/include/linux/pci.h index 72698d89e767..8e366bb0705f 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h | |||
@@ -124,6 +124,14 @@ typedef int __bitwise pci_power_t; | |||
124 | #define PCI_UNKNOWN ((pci_power_t __force) 5) | 124 | #define PCI_UNKNOWN ((pci_power_t __force) 5) |
125 | #define PCI_POWER_ERROR ((pci_power_t __force) -1) | 125 | #define PCI_POWER_ERROR ((pci_power_t __force) -1) |
126 | 126 | ||
127 | /* Remember to update this when the list above changes! */ | ||
128 | extern const char *pci_power_names[]; | ||
129 | |||
130 | static inline const char *pci_power_name(pci_power_t state) | ||
131 | { | ||
132 | return pci_power_names[1 + (int) state]; | ||
133 | } | ||
134 | |||
127 | #define PCI_PM_D2_DELAY 200 | 135 | #define PCI_PM_D2_DELAY 200 |
128 | #define PCI_PM_D3_WAIT 10 | 136 | #define PCI_PM_D3_WAIT 10 |
129 | #define PCI_PM_BUS_WAIT 50 | 137 | #define PCI_PM_BUS_WAIT 50 |
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h index aa01d38c9971..a3b000365795 100644 --- a/include/linux/pci_ids.h +++ b/include/linux/pci_ids.h | |||
@@ -104,6 +104,7 @@ | |||
104 | #define PCI_CLASS_SERIAL_USB_UHCI 0x0c0300 | 104 | #define PCI_CLASS_SERIAL_USB_UHCI 0x0c0300 |
105 | #define PCI_CLASS_SERIAL_USB_OHCI 0x0c0310 | 105 | #define PCI_CLASS_SERIAL_USB_OHCI 0x0c0310 |
106 | #define PCI_CLASS_SERIAL_USB_EHCI 0x0c0320 | 106 | #define PCI_CLASS_SERIAL_USB_EHCI 0x0c0320 |
107 | #define PCI_CLASS_SERIAL_USB_XHCI 0x0c0330 | ||
107 | #define PCI_CLASS_SERIAL_FIBER 0x0c04 | 108 | #define PCI_CLASS_SERIAL_FIBER 0x0c04 |
108 | #define PCI_CLASS_SERIAL_SMBUS 0x0c05 | 109 | #define PCI_CLASS_SERIAL_SMBUS 0x0c05 |
109 | 110 | ||
diff --git a/include/linux/usb.h b/include/linux/usb.h index 34cdfcac4555..84929e914034 100644 --- a/include/linux/usb.h +++ b/include/linux/usb.h | |||
@@ -36,6 +36,7 @@ struct wusb_dev; | |||
36 | * - configs have one (often) or more interfaces; | 36 | * - configs have one (often) or more interfaces; |
37 | * - interfaces have one (usually) or more settings; | 37 | * - interfaces have one (usually) or more settings; |
38 | * - each interface setting has zero or (usually) more endpoints. | 38 | * - each interface setting has zero or (usually) more endpoints. |
39 | * - a SuperSpeed endpoint has a companion descriptor | ||
39 | * | 40 | * |
40 | * And there might be other descriptors mixed in with those. | 41 | * And there might be other descriptors mixed in with those. |
41 | * | 42 | * |
@@ -44,6 +45,19 @@ struct wusb_dev; | |||
44 | 45 | ||
45 | struct ep_device; | 46 | struct ep_device; |
46 | 47 | ||
48 | /* For SS devices */ | ||
49 | /** | ||
50 | * struct usb_host_ss_ep_comp - Valid for SuperSpeed devices only | ||
51 | * @desc: endpoint companion descriptor, wMaxPacketSize in native byteorder | ||
52 | * @extra: descriptors following this endpoint companion descriptor | ||
53 | * @extralen: how many bytes of "extra" are valid | ||
54 | */ | ||
55 | struct usb_host_ss_ep_comp { | ||
56 | struct usb_ss_ep_comp_descriptor desc; | ||
57 | unsigned char *extra; /* Extra descriptors */ | ||
58 | int extralen; | ||
59 | }; | ||
60 | |||
47 | /** | 61 | /** |
48 | * struct usb_host_endpoint - host-side endpoint descriptor and queue | 62 | * struct usb_host_endpoint - host-side endpoint descriptor and queue |
49 | * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder | 63 | * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder |
@@ -51,6 +65,7 @@ struct ep_device; | |||
51 | * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH) | 65 | * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH) |
52 | * with one or more transfer descriptors (TDs) per urb | 66 | * with one or more transfer descriptors (TDs) per urb |
53 | * @ep_dev: ep_device for sysfs info | 67 | * @ep_dev: ep_device for sysfs info |
68 | * @ss_ep_comp: companion descriptor information for this endpoint | ||
54 | * @extra: descriptors following this endpoint in the configuration | 69 | * @extra: descriptors following this endpoint in the configuration |
55 | * @extralen: how many bytes of "extra" are valid | 70 | * @extralen: how many bytes of "extra" are valid |
56 | * @enabled: URBs may be submitted to this endpoint | 71 | * @enabled: URBs may be submitted to this endpoint |
@@ -63,6 +78,7 @@ struct usb_host_endpoint { | |||
63 | struct list_head urb_list; | 78 | struct list_head urb_list; |
64 | void *hcpriv; | 79 | void *hcpriv; |
65 | struct ep_device *ep_dev; /* For sysfs info */ | 80 | struct ep_device *ep_dev; /* For sysfs info */ |
81 | struct usb_host_ss_ep_comp *ss_ep_comp; /* For SS devices */ | ||
66 | 82 | ||
67 | unsigned char *extra; /* Extra descriptors */ | 83 | unsigned char *extra; /* Extra descriptors */ |
68 | int extralen; | 84 | int extralen; |
@@ -336,7 +352,6 @@ struct usb_bus { | |||
336 | #ifdef CONFIG_USB_DEVICEFS | 352 | #ifdef CONFIG_USB_DEVICEFS |
337 | struct dentry *usbfs_dentry; /* usbfs dentry entry for the bus */ | 353 | struct dentry *usbfs_dentry; /* usbfs dentry entry for the bus */ |
338 | #endif | 354 | #endif |
339 | struct device *dev; /* device for this bus */ | ||
340 | 355 | ||
341 | #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE) | 356 | #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE) |
342 | struct mon_bus *mon_bus; /* non-null when associated */ | 357 | struct mon_bus *mon_bus; /* non-null when associated */ |
@@ -363,6 +378,7 @@ struct usb_tt; | |||
363 | * struct usb_device - kernel's representation of a USB device | 378 | * struct usb_device - kernel's representation of a USB device |
364 | * @devnum: device number; address on a USB bus | 379 | * @devnum: device number; address on a USB bus |
365 | * @devpath: device ID string for use in messages (e.g., /port/...) | 380 | * @devpath: device ID string for use in messages (e.g., /port/...) |
381 | * @route: tree topology hex string for use with xHCI | ||
366 | * @state: device state: configured, not attached, etc. | 382 | * @state: device state: configured, not attached, etc. |
367 | * @speed: device speed: high/full/low (or error) | 383 | * @speed: device speed: high/full/low (or error) |
368 | * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub | 384 | * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub |
@@ -420,6 +436,7 @@ struct usb_tt; | |||
420 | * @skip_sys_resume: skip the next system resume | 436 | * @skip_sys_resume: skip the next system resume |
421 | * @wusb_dev: if this is a Wireless USB device, link to the WUSB | 437 | * @wusb_dev: if this is a Wireless USB device, link to the WUSB |
422 | * specific data for the device. | 438 | * specific data for the device. |
439 | * @slot_id: Slot ID assigned by xHCI | ||
423 | * | 440 | * |
424 | * Notes: | 441 | * Notes: |
425 | * Usbcore drivers should not set usbdev->state directly. Instead use | 442 | * Usbcore drivers should not set usbdev->state directly. Instead use |
@@ -428,6 +445,7 @@ struct usb_tt; | |||
428 | struct usb_device { | 445 | struct usb_device { |
429 | int devnum; | 446 | int devnum; |
430 | char devpath [16]; | 447 | char devpath [16]; |
448 | u32 route; | ||
431 | enum usb_device_state state; | 449 | enum usb_device_state state; |
432 | enum usb_device_speed speed; | 450 | enum usb_device_speed speed; |
433 | 451 | ||
@@ -503,6 +521,7 @@ struct usb_device { | |||
503 | unsigned skip_sys_resume:1; | 521 | unsigned skip_sys_resume:1; |
504 | #endif | 522 | #endif |
505 | struct wusb_dev *wusb_dev; | 523 | struct wusb_dev *wusb_dev; |
524 | int slot_id; | ||
506 | }; | 525 | }; |
507 | #define to_usb_device(d) container_of(d, struct usb_device, dev) | 526 | #define to_usb_device(d) container_of(d, struct usb_device, dev) |
508 | 527 | ||
@@ -1044,7 +1063,9 @@ typedef void (*usb_complete_t)(struct urb *); | |||
1044 | * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the | 1063 | * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the |
1045 | * device driver has provided this DMA address for the setup packet. | 1064 | * device driver has provided this DMA address for the setup packet. |
1046 | * The host controller driver should use this in preference to | 1065 | * The host controller driver should use this in preference to |
1047 | * setup_packet. | 1066 | * setup_packet, but the HCD may chose to ignore the address if it must |
1067 | * copy the setup packet into internal structures. Therefore, setup_packet | ||
1068 | * must always point to a valid buffer. | ||
1048 | * @start_frame: Returns the initial frame for isochronous transfers. | 1069 | * @start_frame: Returns the initial frame for isochronous transfers. |
1049 | * @number_of_packets: Lists the number of ISO transfer buffers. | 1070 | * @number_of_packets: Lists the number of ISO transfer buffers. |
1050 | * @interval: Specifies the polling interval for interrupt or isochronous | 1071 | * @interval: Specifies the polling interval for interrupt or isochronous |
@@ -1180,6 +1201,8 @@ struct urb { | |||
1180 | unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/ | 1201 | unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/ |
1181 | void *transfer_buffer; /* (in) associated data buffer */ | 1202 | void *transfer_buffer; /* (in) associated data buffer */ |
1182 | dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */ | 1203 | dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */ |
1204 | struct usb_sg_request *sg; /* (in) scatter gather buffer list */ | ||
1205 | int num_sgs; /* (in) number of entries in the sg list */ | ||
1183 | u32 transfer_buffer_length; /* (in) data buffer length */ | 1206 | u32 transfer_buffer_length; /* (in) data buffer length */ |
1184 | u32 actual_length; /* (return) actual transfer length */ | 1207 | u32 actual_length; /* (return) actual transfer length */ |
1185 | unsigned char *setup_packet; /* (in) setup packet (control only) */ | 1208 | unsigned char *setup_packet; /* (in) setup packet (control only) */ |
@@ -1425,8 +1448,8 @@ struct usb_sg_request { | |||
1425 | int status; | 1448 | int status; |
1426 | size_t bytes; | 1449 | size_t bytes; |
1427 | 1450 | ||
1428 | /* | 1451 | /* private: |
1429 | * members below are private: to usbcore, | 1452 | * members below are private to usbcore, |
1430 | * and are not provided for driver access! | 1453 | * and are not provided for driver access! |
1431 | */ | 1454 | */ |
1432 | spinlock_t lock; | 1455 | spinlock_t lock; |
@@ -1561,6 +1584,9 @@ extern void usb_unregister_notify(struct notifier_block *nb); | |||
1561 | #define err(format, arg...) printk(KERN_ERR KBUILD_MODNAME ": " \ | 1584 | #define err(format, arg...) printk(KERN_ERR KBUILD_MODNAME ": " \ |
1562 | format "\n" , ## arg) | 1585 | format "\n" , ## arg) |
1563 | 1586 | ||
1587 | /* debugfs stuff */ | ||
1588 | extern struct dentry *usb_debug_root; | ||
1589 | |||
1564 | #endif /* __KERNEL__ */ | 1590 | #endif /* __KERNEL__ */ |
1565 | 1591 | ||
1566 | #endif | 1592 | #endif |
diff --git a/include/linux/usb/audio.h b/include/linux/usb/audio.h index 8cb025fef634..b5744bc218ab 100644 --- a/include/linux/usb/audio.h +++ b/include/linux/usb/audio.h | |||
@@ -24,10 +24,75 @@ | |||
24 | #define USB_SUBCLASS_AUDIOCONTROL 0x01 | 24 | #define USB_SUBCLASS_AUDIOCONTROL 0x01 |
25 | #define USB_SUBCLASS_AUDIOSTREAMING 0x02 | 25 | #define USB_SUBCLASS_AUDIOSTREAMING 0x02 |
26 | #define USB_SUBCLASS_MIDISTREAMING 0x03 | 26 | #define USB_SUBCLASS_MIDISTREAMING 0x03 |
27 | #define USB_SUBCLASS_VENDOR_SPEC 0xff | ||
27 | 28 | ||
29 | /* A.5 Audio Class-Specific AC interface Descriptor Subtypes*/ | ||
30 | #define HEADER 0x01 | ||
31 | #define INPUT_TERMINAL 0x02 | ||
32 | #define OUTPUT_TERMINAL 0x03 | ||
33 | #define MIXER_UNIT 0x04 | ||
34 | #define SELECTOR_UNIT 0x05 | ||
35 | #define FEATURE_UNIT 0x06 | ||
36 | #define PROCESSING_UNIT 0x07 | ||
37 | #define EXTENSION_UNIT 0x08 | ||
38 | |||
39 | #define AS_GENERAL 0x01 | ||
40 | #define FORMAT_TYPE 0x02 | ||
41 | #define FORMAT_SPECIFIC 0x03 | ||
42 | |||
43 | #define EP_GENERAL 0x01 | ||
44 | |||
45 | #define MS_GENERAL 0x01 | ||
46 | #define MIDI_IN_JACK 0x02 | ||
47 | #define MIDI_OUT_JACK 0x03 | ||
48 | |||
49 | /* endpoint attributes */ | ||
50 | #define EP_ATTR_MASK 0x0c | ||
51 | #define EP_ATTR_ASYNC 0x04 | ||
52 | #define EP_ATTR_ADAPTIVE 0x08 | ||
53 | #define EP_ATTR_SYNC 0x0c | ||
54 | |||
55 | /* cs endpoint attributes */ | ||
56 | #define EP_CS_ATTR_SAMPLE_RATE 0x01 | ||
57 | #define EP_CS_ATTR_PITCH_CONTROL 0x02 | ||
58 | #define EP_CS_ATTR_FILL_MAX 0x80 | ||
59 | |||
60 | /* Audio Class specific Request Codes */ | ||
61 | #define USB_AUDIO_SET_INTF 0x21 | ||
62 | #define USB_AUDIO_SET_ENDPOINT 0x22 | ||
63 | #define USB_AUDIO_GET_INTF 0xa1 | ||
64 | #define USB_AUDIO_GET_ENDPOINT 0xa2 | ||
65 | |||
66 | #define SET_ 0x00 | ||
67 | #define GET_ 0x80 | ||
68 | |||
69 | #define _CUR 0x1 | ||
70 | #define _MIN 0x2 | ||
71 | #define _MAX 0x3 | ||
72 | #define _RES 0x4 | ||
73 | #define _MEM 0x5 | ||
74 | |||
75 | #define SET_CUR (SET_ | _CUR) | ||
76 | #define GET_CUR (GET_ | _CUR) | ||
77 | #define SET_MIN (SET_ | _MIN) | ||
78 | #define GET_MIN (GET_ | _MIN) | ||
79 | #define SET_MAX (SET_ | _MAX) | ||
80 | #define GET_MAX (GET_ | _MAX) | ||
81 | #define SET_RES (SET_ | _RES) | ||
82 | #define GET_RES (GET_ | _RES) | ||
83 | #define SET_MEM (SET_ | _MEM) | ||
84 | #define GET_MEM (GET_ | _MEM) | ||
85 | |||
86 | #define GET_STAT 0xff | ||
87 | |||
88 | #define USB_AC_TERMINAL_UNDEFINED 0x100 | ||
89 | #define USB_AC_TERMINAL_STREAMING 0x101 | ||
90 | #define USB_AC_TERMINAL_VENDOR_SPEC 0x1FF | ||
91 | |||
92 | /* Terminal Control Selectors */ | ||
28 | /* 4.3.2 Class-Specific AC Interface Descriptor */ | 93 | /* 4.3.2 Class-Specific AC Interface Descriptor */ |
29 | struct usb_ac_header_descriptor { | 94 | struct usb_ac_header_descriptor { |
30 | __u8 bLength; /* 8+n */ | 95 | __u8 bLength; /* 8 + n */ |
31 | __u8 bDescriptorType; /* USB_DT_CS_INTERFACE */ | 96 | __u8 bDescriptorType; /* USB_DT_CS_INTERFACE */ |
32 | __u8 bDescriptorSubtype; /* USB_MS_HEADER */ | 97 | __u8 bDescriptorSubtype; /* USB_MS_HEADER */ |
33 | __le16 bcdADC; /* 0x0100 */ | 98 | __le16 bcdADC; /* 0x0100 */ |
@@ -36,7 +101,7 @@ struct usb_ac_header_descriptor { | |||
36 | __u8 baInterfaceNr[]; /* [n] */ | 101 | __u8 baInterfaceNr[]; /* [n] */ |
37 | } __attribute__ ((packed)); | 102 | } __attribute__ ((packed)); |
38 | 103 | ||
39 | #define USB_DT_AC_HEADER_SIZE(n) (8+(n)) | 104 | #define USB_DT_AC_HEADER_SIZE(n) (8 + (n)) |
40 | 105 | ||
41 | /* As above, but more useful for defining your own descriptors: */ | 106 | /* As above, but more useful for defining your own descriptors: */ |
42 | #define DECLARE_USB_AC_HEADER_DESCRIPTOR(n) \ | 107 | #define DECLARE_USB_AC_HEADER_DESCRIPTOR(n) \ |
@@ -50,4 +115,200 @@ struct usb_ac_header_descriptor_##n { \ | |||
50 | __u8 baInterfaceNr[n]; \ | 115 | __u8 baInterfaceNr[n]; \ |
51 | } __attribute__ ((packed)) | 116 | } __attribute__ ((packed)) |
52 | 117 | ||
118 | /* 4.3.2.1 Input Terminal Descriptor */ | ||
119 | struct usb_input_terminal_descriptor { | ||
120 | __u8 bLength; /* in bytes: 12 */ | ||
121 | __u8 bDescriptorType; /* CS_INTERFACE descriptor type */ | ||
122 | __u8 bDescriptorSubtype; /* INPUT_TERMINAL descriptor subtype */ | ||
123 | __u8 bTerminalID; /* Constant uniquely terminal ID */ | ||
124 | __le16 wTerminalType; /* USB Audio Terminal Types */ | ||
125 | __u8 bAssocTerminal; /* ID of the Output Terminal associated */ | ||
126 | __u8 bNrChannels; /* Number of logical output channels */ | ||
127 | __le16 wChannelConfig; | ||
128 | __u8 iChannelNames; | ||
129 | __u8 iTerminal; | ||
130 | } __attribute__ ((packed)); | ||
131 | |||
132 | #define USB_DT_AC_INPUT_TERMINAL_SIZE 12 | ||
133 | |||
134 | #define USB_AC_INPUT_TERMINAL_UNDEFINED 0x200 | ||
135 | #define USB_AC_INPUT_TERMINAL_MICROPHONE 0x201 | ||
136 | #define USB_AC_INPUT_TERMINAL_DESKTOP_MICROPHONE 0x202 | ||
137 | #define USB_AC_INPUT_TERMINAL_PERSONAL_MICROPHONE 0x203 | ||
138 | #define USB_AC_INPUT_TERMINAL_OMNI_DIR_MICROPHONE 0x204 | ||
139 | #define USB_AC_INPUT_TERMINAL_MICROPHONE_ARRAY 0x205 | ||
140 | #define USB_AC_INPUT_TERMINAL_PROC_MICROPHONE_ARRAY 0x206 | ||
141 | |||
142 | /* 4.3.2.2 Output Terminal Descriptor */ | ||
143 | struct usb_output_terminal_descriptor { | ||
144 | __u8 bLength; /* in bytes: 9 */ | ||
145 | __u8 bDescriptorType; /* CS_INTERFACE descriptor type */ | ||
146 | __u8 bDescriptorSubtype; /* OUTPUT_TERMINAL descriptor subtype */ | ||
147 | __u8 bTerminalID; /* Constant uniquely terminal ID */ | ||
148 | __le16 wTerminalType; /* USB Audio Terminal Types */ | ||
149 | __u8 bAssocTerminal; /* ID of the Input Terminal associated */ | ||
150 | __u8 bSourceID; /* ID of the connected Unit or Terminal*/ | ||
151 | __u8 iTerminal; | ||
152 | } __attribute__ ((packed)); | ||
153 | |||
154 | #define USB_DT_AC_OUTPUT_TERMINAL_SIZE 9 | ||
155 | |||
156 | #define USB_AC_OUTPUT_TERMINAL_UNDEFINED 0x300 | ||
157 | #define USB_AC_OUTPUT_TERMINAL_SPEAKER 0x301 | ||
158 | #define USB_AC_OUTPUT_TERMINAL_HEADPHONES 0x302 | ||
159 | #define USB_AC_OUTPUT_TERMINAL_HEAD_MOUNTED_DISPLAY_AUDIO 0x303 | ||
160 | #define USB_AC_OUTPUT_TERMINAL_DESKTOP_SPEAKER 0x304 | ||
161 | #define USB_AC_OUTPUT_TERMINAL_ROOM_SPEAKER 0x305 | ||
162 | #define USB_AC_OUTPUT_TERMINAL_COMMUNICATION_SPEAKER 0x306 | ||
163 | #define USB_AC_OUTPUT_TERMINAL_LOW_FREQ_EFFECTS_SPEAKER 0x307 | ||
164 | |||
165 | /* Set bControlSize = 2 as default setting */ | ||
166 | #define USB_DT_AC_FEATURE_UNIT_SIZE(ch) (7 + ((ch) + 1) * 2) | ||
167 | |||
168 | /* As above, but more useful for defining your own descriptors: */ | ||
169 | #define DECLARE_USB_AC_FEATURE_UNIT_DESCRIPTOR(ch) \ | ||
170 | struct usb_ac_feature_unit_descriptor_##ch { \ | ||
171 | __u8 bLength; \ | ||
172 | __u8 bDescriptorType; \ | ||
173 | __u8 bDescriptorSubtype; \ | ||
174 | __u8 bUnitID; \ | ||
175 | __u8 bSourceID; \ | ||
176 | __u8 bControlSize; \ | ||
177 | __le16 bmaControls[ch + 1]; \ | ||
178 | __u8 iFeature; \ | ||
179 | } __attribute__ ((packed)) | ||
180 | |||
181 | /* 4.5.2 Class-Specific AS Interface Descriptor */ | ||
182 | struct usb_as_header_descriptor { | ||
183 | __u8 bLength; /* in bytes: 7 */ | ||
184 | __u8 bDescriptorType; /* USB_DT_CS_INTERFACE */ | ||
185 | __u8 bDescriptorSubtype; /* AS_GENERAL */ | ||
186 | __u8 bTerminalLink; /* Terminal ID of connected Terminal */ | ||
187 | __u8 bDelay; /* Delay introduced by the data path */ | ||
188 | __le16 wFormatTag; /* The Audio Data Format */ | ||
189 | } __attribute__ ((packed)); | ||
190 | |||
191 | #define USB_DT_AS_HEADER_SIZE 7 | ||
192 | |||
193 | #define USB_AS_AUDIO_FORMAT_TYPE_I_UNDEFINED 0x0 | ||
194 | #define USB_AS_AUDIO_FORMAT_TYPE_I_PCM 0x1 | ||
195 | #define USB_AS_AUDIO_FORMAT_TYPE_I_PCM8 0x2 | ||
196 | #define USB_AS_AUDIO_FORMAT_TYPE_I_IEEE_FLOAT 0x3 | ||
197 | #define USB_AS_AUDIO_FORMAT_TYPE_I_ALAW 0x4 | ||
198 | #define USB_AS_AUDIO_FORMAT_TYPE_I_MULAW 0x5 | ||
199 | |||
200 | struct usb_as_format_type_i_continuous_descriptor { | ||
201 | __u8 bLength; /* in bytes: 8 + (ns * 3) */ | ||
202 | __u8 bDescriptorType; /* USB_DT_CS_INTERFACE */ | ||
203 | __u8 bDescriptorSubtype; /* FORMAT_TYPE */ | ||
204 | __u8 bFormatType; /* FORMAT_TYPE_1 */ | ||
205 | __u8 bNrChannels; /* physical channels in the stream */ | ||
206 | __u8 bSubframeSize; /* */ | ||
207 | __u8 bBitResolution; | ||
208 | __u8 bSamFreqType; | ||
209 | __u8 tLowerSamFreq[3]; | ||
210 | __u8 tUpperSamFreq[3]; | ||
211 | } __attribute__ ((packed)); | ||
212 | |||
213 | #define USB_AS_FORMAT_TYPE_I_CONTINUOUS_DESC_SIZE 14 | ||
214 | |||
215 | struct usb_as_formate_type_i_discrete_descriptor { | ||
216 | __u8 bLength; /* in bytes: 8 + (ns * 3) */ | ||
217 | __u8 bDescriptorType; /* USB_DT_CS_INTERFACE */ | ||
218 | __u8 bDescriptorSubtype; /* FORMAT_TYPE */ | ||
219 | __u8 bFormatType; /* FORMAT_TYPE_1 */ | ||
220 | __u8 bNrChannels; /* physical channels in the stream */ | ||
221 | __u8 bSubframeSize; /* */ | ||
222 | __u8 bBitResolution; | ||
223 | __u8 bSamFreqType; | ||
224 | __u8 tSamFreq[][3]; | ||
225 | } __attribute__ ((packed)); | ||
226 | |||
227 | #define DECLARE_USB_AS_FORMAT_TYPE_I_DISCRETE_DESC(n) \ | ||
228 | struct usb_as_formate_type_i_discrete_descriptor_##n { \ | ||
229 | __u8 bLength; \ | ||
230 | __u8 bDescriptorType; \ | ||
231 | __u8 bDescriptorSubtype; \ | ||
232 | __u8 bFormatType; \ | ||
233 | __u8 bNrChannels; \ | ||
234 | __u8 bSubframeSize; \ | ||
235 | __u8 bBitResolution; \ | ||
236 | __u8 bSamFreqType; \ | ||
237 | __u8 tSamFreq[n][3]; \ | ||
238 | } __attribute__ ((packed)) | ||
239 | |||
240 | #define USB_AS_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(n) (8 + (n * 3)) | ||
241 | |||
242 | #define USB_AS_FORMAT_TYPE_UNDEFINED 0x0 | ||
243 | #define USB_AS_FORMAT_TYPE_I 0x1 | ||
244 | #define USB_AS_FORMAT_TYPE_II 0x2 | ||
245 | #define USB_AS_FORMAT_TYPE_III 0x3 | ||
246 | |||
247 | #define USB_AS_ENDPOINT_ASYNC (1 << 2) | ||
248 | #define USB_AS_ENDPOINT_ADAPTIVE (2 << 2) | ||
249 | #define USB_AS_ENDPOINT_SYNC (3 << 2) | ||
250 | |||
251 | struct usb_as_iso_endpoint_descriptor { | ||
252 | __u8 bLength; /* in bytes: 7 */ | ||
253 | __u8 bDescriptorType; /* USB_DT_CS_ENDPOINT */ | ||
254 | __u8 bDescriptorSubtype; /* EP_GENERAL */ | ||
255 | __u8 bmAttributes; | ||
256 | __u8 bLockDelayUnits; | ||
257 | __le16 wLockDelay; | ||
258 | }; | ||
259 | #define USB_AS_ISO_ENDPOINT_DESC_SIZE 7 | ||
260 | |||
261 | #define FU_CONTROL_UNDEFINED 0x00 | ||
262 | #define MUTE_CONTROL 0x01 | ||
263 | #define VOLUME_CONTROL 0x02 | ||
264 | #define BASS_CONTROL 0x03 | ||
265 | #define MID_CONTROL 0x04 | ||
266 | #define TREBLE_CONTROL 0x05 | ||
267 | #define GRAPHIC_EQUALIZER_CONTROL 0x06 | ||
268 | #define AUTOMATIC_GAIN_CONTROL 0x07 | ||
269 | #define DELAY_CONTROL 0x08 | ||
270 | #define BASS_BOOST_CONTROL 0x09 | ||
271 | #define LOUDNESS_CONTROL 0x0a | ||
272 | |||
273 | #define FU_MUTE (1 << (MUTE_CONTROL - 1)) | ||
274 | #define FU_VOLUME (1 << (VOLUME_CONTROL - 1)) | ||
275 | #define FU_BASS (1 << (BASS_CONTROL - 1)) | ||
276 | #define FU_MID (1 << (MID_CONTROL - 1)) | ||
277 | #define FU_TREBLE (1 << (TREBLE_CONTROL - 1)) | ||
278 | #define FU_GRAPHIC_EQ (1 << (GRAPHIC_EQUALIZER_CONTROL - 1)) | ||
279 | #define FU_AUTO_GAIN (1 << (AUTOMATIC_GAIN_CONTROL - 1)) | ||
280 | #define FU_DELAY (1 << (DELAY_CONTROL - 1)) | ||
281 | #define FU_BASS_BOOST (1 << (BASS_BOOST_CONTROL - 1)) | ||
282 | #define FU_LOUDNESS (1 << (LOUDNESS_CONTROL - 1)) | ||
283 | |||
284 | struct usb_audio_control { | ||
285 | struct list_head list; | ||
286 | const char *name; | ||
287 | u8 type; | ||
288 | int data[5]; | ||
289 | int (*set)(struct usb_audio_control *con, u8 cmd, int value); | ||
290 | int (*get)(struct usb_audio_control *con, u8 cmd); | ||
291 | }; | ||
292 | |||
293 | static inline int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value) | ||
294 | { | ||
295 | con->data[cmd] = value; | ||
296 | |||
297 | return 0; | ||
298 | } | ||
299 | |||
300 | static inline int generic_get_cmd(struct usb_audio_control *con, u8 cmd) | ||
301 | { | ||
302 | return con->data[cmd]; | ||
303 | } | ||
304 | |||
305 | struct usb_audio_control_selector { | ||
306 | struct list_head list; | ||
307 | struct list_head control; | ||
308 | u8 id; | ||
309 | const char *name; | ||
310 | u8 type; | ||
311 | struct usb_descriptor_header *desc; | ||
312 | }; | ||
313 | |||
53 | #endif /* __LINUX_USB_AUDIO_H */ | 314 | #endif /* __LINUX_USB_AUDIO_H */ |
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h index b145119a90da..93223638f702 100644 --- a/include/linux/usb/ch9.h +++ b/include/linux/usb/ch9.h | |||
@@ -191,6 +191,8 @@ struct usb_ctrlrequest { | |||
191 | #define USB_DT_WIRE_ADAPTER 0x21 | 191 | #define USB_DT_WIRE_ADAPTER 0x21 |
192 | #define USB_DT_RPIPE 0x22 | 192 | #define USB_DT_RPIPE 0x22 |
193 | #define USB_DT_CS_RADIO_CONTROL 0x23 | 193 | #define USB_DT_CS_RADIO_CONTROL 0x23 |
194 | /* From the USB 3.0 spec */ | ||
195 | #define USB_DT_SS_ENDPOINT_COMP 0x30 | ||
194 | 196 | ||
195 | /* Conventional codes for class-specific descriptors. The convention is | 197 | /* Conventional codes for class-specific descriptors. The convention is |
196 | * defined in the USB "Common Class" Spec (3.11). Individual class specs | 198 | * defined in the USB "Common Class" Spec (3.11). Individual class specs |
@@ -535,6 +537,20 @@ static inline int usb_endpoint_is_isoc_out( | |||
535 | 537 | ||
536 | /*-------------------------------------------------------------------------*/ | 538 | /*-------------------------------------------------------------------------*/ |
537 | 539 | ||
540 | /* USB_DT_SS_ENDPOINT_COMP: SuperSpeed Endpoint Companion descriptor */ | ||
541 | struct usb_ss_ep_comp_descriptor { | ||
542 | __u8 bLength; | ||
543 | __u8 bDescriptorType; | ||
544 | |||
545 | __u8 bMaxBurst; | ||
546 | __u8 bmAttributes; | ||
547 | __u16 wBytesPerInterval; | ||
548 | } __attribute__ ((packed)); | ||
549 | |||
550 | #define USB_DT_SS_EP_COMP_SIZE 6 | ||
551 | |||
552 | /*-------------------------------------------------------------------------*/ | ||
553 | |||
538 | /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */ | 554 | /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */ |
539 | struct usb_qualifier_descriptor { | 555 | struct usb_qualifier_descriptor { |
540 | __u8 bLength; | 556 | __u8 bLength; |
@@ -752,6 +768,7 @@ enum usb_device_speed { | |||
752 | USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */ | 768 | USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */ |
753 | USB_SPEED_HIGH, /* usb 2.0 */ | 769 | USB_SPEED_HIGH, /* usb 2.0 */ |
754 | USB_SPEED_VARIABLE, /* wireless (usb 2.5) */ | 770 | USB_SPEED_VARIABLE, /* wireless (usb 2.5) */ |
771 | USB_SPEED_SUPER, /* usb 3.0 */ | ||
755 | }; | 772 | }; |
756 | 773 | ||
757 | enum usb_device_state { | 774 | enum usb_device_state { |
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h index acd7b0f06c8a..4f6bb3d2160e 100644 --- a/include/linux/usb/composite.h +++ b/include/linux/usb/composite.h | |||
@@ -124,6 +124,7 @@ struct usb_function { | |||
124 | void (*suspend)(struct usb_function *); | 124 | void (*suspend)(struct usb_function *); |
125 | void (*resume)(struct usb_function *); | 125 | void (*resume)(struct usb_function *); |
126 | 126 | ||
127 | /* private: */ | ||
127 | /* internals */ | 128 | /* internals */ |
128 | struct list_head list; | 129 | struct list_head list; |
129 | }; | 130 | }; |
@@ -219,6 +220,7 @@ struct usb_configuration { | |||
219 | 220 | ||
220 | struct usb_composite_dev *cdev; | 221 | struct usb_composite_dev *cdev; |
221 | 222 | ||
223 | /* private: */ | ||
222 | /* internals */ | 224 | /* internals */ |
223 | struct list_head list; | 225 | struct list_head list; |
224 | struct list_head functions; | 226 | struct list_head functions; |
@@ -321,6 +323,7 @@ struct usb_composite_dev { | |||
321 | 323 | ||
322 | struct usb_configuration *config; | 324 | struct usb_configuration *config; |
323 | 325 | ||
326 | /* private: */ | ||
324 | /* internals */ | 327 | /* internals */ |
325 | struct usb_device_descriptor desc; | 328 | struct usb_device_descriptor desc; |
326 | struct list_head configs; | 329 | struct list_head configs; |
diff --git a/include/linux/usb/langwell_otg.h b/include/linux/usb/langwell_otg.h new file mode 100644 index 000000000000..e115ae6df1da --- /dev/null +++ b/include/linux/usb/langwell_otg.h | |||
@@ -0,0 +1,177 @@ | |||
1 | /* | ||
2 | * Intel Langwell USB OTG transceiver driver | ||
3 | * Copyright (C) 2008, Intel Corporation. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms and conditions of the GNU General Public License, | ||
7 | * version 2, as published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., | ||
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | #ifndef __LANGWELL_OTG_H__ | ||
21 | #define __LANGWELL_OTG_H__ | ||
22 | |||
23 | /* notify transceiver driver about OTG events */ | ||
24 | extern void langwell_update_transceiver(void); | ||
25 | /* HCD register bus driver */ | ||
26 | extern int langwell_register_host(struct pci_driver *host_driver); | ||
27 | /* HCD unregister bus driver */ | ||
28 | extern void langwell_unregister_host(struct pci_driver *host_driver); | ||
29 | /* DCD register bus driver */ | ||
30 | extern int langwell_register_peripheral(struct pci_driver *client_driver); | ||
31 | /* DCD unregister bus driver */ | ||
32 | extern void langwell_unregister_peripheral(struct pci_driver *client_driver); | ||
33 | /* No silent failure, output warning message */ | ||
34 | extern void langwell_otg_nsf_msg(unsigned long message); | ||
35 | |||
36 | #define CI_USBCMD 0x30 | ||
37 | # define USBCMD_RST BIT(1) | ||
38 | # define USBCMD_RS BIT(0) | ||
39 | #define CI_USBSTS 0x34 | ||
40 | # define USBSTS_SLI BIT(8) | ||
41 | # define USBSTS_URI BIT(6) | ||
42 | # define USBSTS_PCI BIT(2) | ||
43 | #define CI_PORTSC1 0x74 | ||
44 | # define PORTSC_PP BIT(12) | ||
45 | # define PORTSC_LS (BIT(11) | BIT(10)) | ||
46 | # define PORTSC_SUSP BIT(7) | ||
47 | # define PORTSC_CCS BIT(0) | ||
48 | #define CI_HOSTPC1 0xb4 | ||
49 | # define HOSTPC1_PHCD BIT(22) | ||
50 | #define CI_OTGSC 0xf4 | ||
51 | # define OTGSC_DPIE BIT(30) | ||
52 | # define OTGSC_1MSE BIT(29) | ||
53 | # define OTGSC_BSEIE BIT(28) | ||
54 | # define OTGSC_BSVIE BIT(27) | ||
55 | # define OTGSC_ASVIE BIT(26) | ||
56 | # define OTGSC_AVVIE BIT(25) | ||
57 | # define OTGSC_IDIE BIT(24) | ||
58 | # define OTGSC_DPIS BIT(22) | ||
59 | # define OTGSC_1MSS BIT(21) | ||
60 | # define OTGSC_BSEIS BIT(20) | ||
61 | # define OTGSC_BSVIS BIT(19) | ||
62 | # define OTGSC_ASVIS BIT(18) | ||
63 | # define OTGSC_AVVIS BIT(17) | ||
64 | # define OTGSC_IDIS BIT(16) | ||
65 | # define OTGSC_DPS BIT(14) | ||
66 | # define OTGSC_1MST BIT(13) | ||
67 | # define OTGSC_BSE BIT(12) | ||
68 | # define OTGSC_BSV BIT(11) | ||
69 | # define OTGSC_ASV BIT(10) | ||
70 | # define OTGSC_AVV BIT(9) | ||
71 | # define OTGSC_ID BIT(8) | ||
72 | # define OTGSC_HABA BIT(7) | ||
73 | # define OTGSC_HADP BIT(6) | ||
74 | # define OTGSC_IDPU BIT(5) | ||
75 | # define OTGSC_DP BIT(4) | ||
76 | # define OTGSC_OT BIT(3) | ||
77 | # define OTGSC_HAAR BIT(2) | ||
78 | # define OTGSC_VC BIT(1) | ||
79 | # define OTGSC_VD BIT(0) | ||
80 | # define OTGSC_INTEN_MASK (0x7f << 24) | ||
81 | # define OTGSC_INTSTS_MASK (0x7f << 16) | ||
82 | #define CI_USBMODE 0xf8 | ||
83 | # define USBMODE_CM (BIT(1) | BIT(0)) | ||
84 | # define USBMODE_IDLE 0 | ||
85 | # define USBMODE_DEVICE 0x2 | ||
86 | # define USBMODE_HOST 0x3 | ||
87 | |||
88 | #define INTR_DUMMY_MASK (USBSTS_SLI | USBSTS_URI | USBSTS_PCI) | ||
89 | |||
90 | struct otg_hsm { | ||
91 | /* Input */ | ||
92 | int a_bus_resume; | ||
93 | int a_bus_suspend; | ||
94 | int a_conn; | ||
95 | int a_sess_vld; | ||
96 | int a_srp_det; | ||
97 | int a_vbus_vld; | ||
98 | int b_bus_resume; | ||
99 | int b_bus_suspend; | ||
100 | int b_conn; | ||
101 | int b_se0_srp; | ||
102 | int b_sess_end; | ||
103 | int b_sess_vld; | ||
104 | int id; | ||
105 | |||
106 | /* Internal variables */ | ||
107 | int a_set_b_hnp_en; | ||
108 | int b_srp_done; | ||
109 | int b_hnp_enable; | ||
110 | |||
111 | /* Timeout indicator for timers */ | ||
112 | int a_wait_vrise_tmout; | ||
113 | int a_wait_bcon_tmout; | ||
114 | int a_aidl_bdis_tmout; | ||
115 | int b_ase0_brst_tmout; | ||
116 | int b_bus_suspend_tmout; | ||
117 | int b_srp_res_tmout; | ||
118 | |||
119 | /* Informative variables */ | ||
120 | int a_bus_drop; | ||
121 | int a_bus_req; | ||
122 | int a_clr_err; | ||
123 | int a_suspend_req; | ||
124 | int b_bus_req; | ||
125 | |||
126 | /* Output */ | ||
127 | int drv_vbus; | ||
128 | int loc_conn; | ||
129 | int loc_sof; | ||
130 | |||
131 | /* Others */ | ||
132 | int b_bus_suspend_vld; | ||
133 | }; | ||
134 | |||
135 | #define TA_WAIT_VRISE 100 | ||
136 | #define TA_WAIT_BCON 30000 | ||
137 | #define TA_AIDL_BDIS 15000 | ||
138 | #define TB_ASE0_BRST 5000 | ||
139 | #define TB_SE0_SRP 2 | ||
140 | #define TB_SRP_RES 100 | ||
141 | #define TB_BUS_SUSPEND 500 | ||
142 | |||
143 | struct langwell_otg_timer { | ||
144 | unsigned long expires; /* Number of count increase to timeout */ | ||
145 | unsigned long count; /* Tick counter */ | ||
146 | void (*function)(unsigned long); /* Timeout function */ | ||
147 | unsigned long data; /* Data passed to function */ | ||
148 | struct list_head list; | ||
149 | }; | ||
150 | |||
151 | struct langwell_otg { | ||
152 | struct otg_transceiver otg; | ||
153 | struct otg_hsm hsm; | ||
154 | void __iomem *regs; | ||
155 | unsigned region; | ||
156 | struct pci_driver *host_ops; | ||
157 | struct pci_driver *client_ops; | ||
158 | struct pci_dev *pdev; | ||
159 | struct work_struct work; | ||
160 | struct workqueue_struct *qwork; | ||
161 | spinlock_t lock; | ||
162 | spinlock_t wq_lock; | ||
163 | }; | ||
164 | |||
165 | static inline struct langwell_otg *otg_to_langwell(struct otg_transceiver *otg) | ||
166 | { | ||
167 | return container_of(otg, struct langwell_otg, otg); | ||
168 | } | ||
169 | |||
170 | #ifdef DEBUG | ||
171 | #define otg_dbg(fmt, args...) \ | ||
172 | printk(KERN_DEBUG fmt , ## args) | ||
173 | #else | ||
174 | #define otg_dbg(fmt, args...) \ | ||
175 | do { } while (0) | ||
176 | #endif /* DEBUG */ | ||
177 | #endif /* __LANGWELL_OTG_H__ */ | ||
diff --git a/include/linux/usb/langwell_udc.h b/include/linux/usb/langwell_udc.h new file mode 100644 index 000000000000..c949178a6530 --- /dev/null +++ b/include/linux/usb/langwell_udc.h | |||
@@ -0,0 +1,310 @@ | |||
1 | /* | ||
2 | * Intel Langwell USB Device Controller driver | ||
3 | * Copyright (C) 2008-2009, Intel Corporation. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify it | ||
6 | * under the terms and conditions of the GNU General Public License, | ||
7 | * version 2, as published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
12 | * more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License along with | ||
15 | * this program; if not, write to the Free Software Foundation, Inc., | ||
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | #ifndef __LANGWELL_UDC_H | ||
21 | #define __LANGWELL_UDC_H | ||
22 | |||
23 | |||
24 | /* MACRO defines */ | ||
25 | #define CAP_REG_OFFSET 0x0 | ||
26 | #define OP_REG_OFFSET 0x28 | ||
27 | |||
28 | #define DMA_ADDR_INVALID (~(dma_addr_t)0) | ||
29 | |||
30 | #define DQH_ALIGNMENT 2048 | ||
31 | #define DTD_ALIGNMENT 64 | ||
32 | #define DMA_BOUNDARY 4096 | ||
33 | |||
34 | #define EP0_MAX_PKT_SIZE 64 | ||
35 | #define EP_DIR_IN 1 | ||
36 | #define EP_DIR_OUT 0 | ||
37 | |||
38 | #define FLUSH_TIMEOUT 1000 | ||
39 | #define RESET_TIMEOUT 1000 | ||
40 | #define SETUPSTAT_TIMEOUT 100 | ||
41 | #define PRIME_TIMEOUT 100 | ||
42 | |||
43 | |||
44 | /* device memory space registers */ | ||
45 | |||
46 | /* Capability Registers, BAR0 + CAP_REG_OFFSET */ | ||
47 | struct langwell_cap_regs { | ||
48 | /* offset: 0x0 */ | ||
49 | u8 caplength; /* offset of Operational Register */ | ||
50 | u8 _reserved3; | ||
51 | u16 hciversion; /* H: BCD encoding of host version */ | ||
52 | u32 hcsparams; /* H: host port steering logic capability */ | ||
53 | u32 hccparams; /* H: host multiple mode control capability */ | ||
54 | #define HCC_LEN BIT(17) /* Link power management (LPM) capability */ | ||
55 | u8 _reserved4[0x20-0xc]; | ||
56 | /* offset: 0x20 */ | ||
57 | u16 dciversion; /* BCD encoding of device version */ | ||
58 | u8 _reserved5[0x24-0x22]; | ||
59 | u32 dccparams; /* overall device controller capability */ | ||
60 | #define HOSTCAP BIT(8) /* host capable */ | ||
61 | #define DEVCAP BIT(7) /* device capable */ | ||
62 | #define DEN(d) \ | ||
63 | (((d)>>0)&0x1f) /* bits 4:0, device endpoint number */ | ||
64 | } __attribute__ ((packed)); | ||
65 | |||
66 | |||
67 | /* Operational Registers, BAR0 + OP_REG_OFFSET */ | ||
68 | struct langwell_op_regs { | ||
69 | /* offset: 0x28 */ | ||
70 | u32 extsts; | ||
71 | #define EXTS_TI1 BIT(4) /* general purpose timer interrupt 1 */ | ||
72 | #define EXTS_TI1TI0 BIT(3) /* general purpose timer interrupt 0 */ | ||
73 | #define EXTS_TI1UPI BIT(2) /* USB host periodic interrupt */ | ||
74 | #define EXTS_TI1UAI BIT(1) /* USB host asynchronous interrupt */ | ||
75 | #define EXTS_TI1NAKI BIT(0) /* NAK interrupt */ | ||
76 | u32 extintr; | ||
77 | #define EXTI_TIE1 BIT(4) /* general purpose timer interrupt enable 1 */ | ||
78 | #define EXTI_TIE0 BIT(3) /* general purpose timer interrupt enable 0 */ | ||
79 | #define EXTI_UPIE BIT(2) /* USB host periodic interrupt enable */ | ||
80 | #define EXTI_UAIE BIT(1) /* USB host asynchronous interrupt enable */ | ||
81 | #define EXTI_NAKE BIT(0) /* NAK interrupt enable */ | ||
82 | /* offset: 0x30 */ | ||
83 | u32 usbcmd; | ||
84 | #define CMD_HIRD(u) \ | ||
85 | (((u)>>24)&0xf) /* bits 27:24, host init resume duration */ | ||
86 | #define CMD_ITC(u) \ | ||
87 | (((u)>>16)&0xff) /* bits 23:16, interrupt threshold control */ | ||
88 | #define CMD_PPE BIT(15) /* per-port change events enable */ | ||
89 | #define CMD_ATDTW BIT(14) /* add dTD tripwire */ | ||
90 | #define CMD_SUTW BIT(13) /* setup tripwire */ | ||
91 | #define CMD_ASPE BIT(11) /* asynchronous schedule park mode enable */ | ||
92 | #define CMD_FS2 BIT(10) /* frame list size */ | ||
93 | #define CMD_ASP1 BIT(9) /* asynchronous schedule park mode count */ | ||
94 | #define CMD_ASP0 BIT(8) | ||
95 | #define CMD_LR BIT(7) /* light host/device controller reset */ | ||
96 | #define CMD_IAA BIT(6) /* interrupt on async advance doorbell */ | ||
97 | #define CMD_ASE BIT(5) /* asynchronous schedule enable */ | ||
98 | #define CMD_PSE BIT(4) /* periodic schedule enable */ | ||
99 | #define CMD_FS1 BIT(3) | ||
100 | #define CMD_FS0 BIT(2) | ||
101 | #define CMD_RST BIT(1) /* controller reset */ | ||
102 | #define CMD_RUNSTOP BIT(0) /* run/stop */ | ||
103 | u32 usbsts; | ||
104 | #define STS_PPCI(u) \ | ||
105 | (((u)>>16)&0xffff) /* bits 31:16, port-n change detect */ | ||
106 | #define STS_AS BIT(15) /* asynchronous schedule status */ | ||
107 | #define STS_PS BIT(14) /* periodic schedule status */ | ||
108 | #define STS_RCL BIT(13) /* reclamation */ | ||
109 | #define STS_HCH BIT(12) /* HC halted */ | ||
110 | #define STS_ULPII BIT(10) /* ULPI interrupt */ | ||
111 | #define STS_SLI BIT(8) /* DC suspend */ | ||
112 | #define STS_SRI BIT(7) /* SOF received */ | ||
113 | #define STS_URI BIT(6) /* USB reset received */ | ||
114 | #define STS_AAI BIT(5) /* interrupt on async advance */ | ||
115 | #define STS_SEI BIT(4) /* system error */ | ||
116 | #define STS_FRI BIT(3) /* frame list rollover */ | ||
117 | #define STS_PCI BIT(2) /* port change detect */ | ||
118 | #define STS_UEI BIT(1) /* USB error interrupt */ | ||
119 | #define STS_UI BIT(0) /* USB interrupt */ | ||
120 | u32 usbintr; | ||
121 | /* bits 31:16, per-port interrupt enable */ | ||
122 | #define INTR_PPCE(u) (((u)>>16)&0xffff) | ||
123 | #define INTR_ULPIE BIT(10) /* ULPI enable */ | ||
124 | #define INTR_SLE BIT(8) /* DC sleep/suspend enable */ | ||
125 | #define INTR_SRE BIT(7) /* SOF received enable */ | ||
126 | #define INTR_URE BIT(6) /* USB reset enable */ | ||
127 | #define INTR_AAE BIT(5) /* interrupt on async advance enable */ | ||
128 | #define INTR_SEE BIT(4) /* system error enable */ | ||
129 | #define INTR_FRE BIT(3) /* frame list rollover enable */ | ||
130 | #define INTR_PCE BIT(2) /* port change detect enable */ | ||
131 | #define INTR_UEE BIT(1) /* USB error interrupt enable */ | ||
132 | #define INTR_UE BIT(0) /* USB interrupt enable */ | ||
133 | u32 frindex; /* frame index */ | ||
134 | #define FRINDEX_MASK (0x3fff << 0) | ||
135 | u32 ctrldssegment; /* not used */ | ||
136 | u32 deviceaddr; | ||
137 | #define USBADR_SHIFT 25 | ||
138 | #define USBADR(d) \ | ||
139 | (((d)>>25)&0x7f) /* bits 31:25, device address */ | ||
140 | #define USBADR_MASK (0x7f << 25) | ||
141 | #define USBADRA BIT(24) /* device address advance */ | ||
142 | u32 endpointlistaddr;/* endpoint list top memory address */ | ||
143 | /* bits 31:11, endpoint list pointer */ | ||
144 | #define EPBASE(d) (((d)>>11)&0x1fffff) | ||
145 | #define ENDPOINTLISTADDR_MASK (0x1fffff << 11) | ||
146 | u32 ttctrl; /* H: TT operatin, not used */ | ||
147 | /* offset: 0x50 */ | ||
148 | u32 burstsize; /* burst size of data movement */ | ||
149 | #define TXPBURST(b) \ | ||
150 | (((b)>>8)&0xff) /* bits 15:8, TX burst length */ | ||
151 | #define RXPBURST(b) \ | ||
152 | (((b)>>0)&0xff) /* bits 7:0, RX burst length */ | ||
153 | u32 txfilltuning; /* TX tuning */ | ||
154 | u32 txttfilltuning; /* H: TX TT tuning */ | ||
155 | u32 ic_usb; /* control the IC_USB FS/LS transceiver */ | ||
156 | /* offset: 0x60 */ | ||
157 | u32 ulpi_viewport; /* indirect access to ULPI PHY */ | ||
158 | #define ULPIWU BIT(31) /* ULPI wakeup */ | ||
159 | #define ULPIRUN BIT(30) /* ULPI read/write run */ | ||
160 | #define ULPIRW BIT(29) /* ULPI read/write control */ | ||
161 | #define ULPISS BIT(27) /* ULPI sync state */ | ||
162 | #define ULPIPORT(u) \ | ||
163 | (((u)>>24)&7) /* bits 26:24, ULPI port number */ | ||
164 | #define ULPIADDR(u) \ | ||
165 | (((u)>>16)&0xff) /* bits 23:16, ULPI data address */ | ||
166 | #define ULPIDATRD(u) \ | ||
167 | (((u)>>8)&0xff) /* bits 15:8, ULPI data read */ | ||
168 | #define ULPIDATWR(u) \ | ||
169 | (((u)>>0)&0xff) /* bits 7:0, ULPI date write */ | ||
170 | u8 _reserved6[0x70-0x64]; | ||
171 | /* offset: 0x70 */ | ||
172 | u32 configflag; /* H: not used */ | ||
173 | u32 portsc1; /* port status */ | ||
174 | #define DA(p) \ | ||
175 | (((p)>>25)&0x7f) /* bits 31:25, device address */ | ||
176 | #define PORTS_SSTS (BIT(24) | BIT(23)) /* suspend status */ | ||
177 | #define PORTS_WKOC BIT(22) /* wake on over-current enable */ | ||
178 | #define PORTS_WKDS BIT(21) /* wake on disconnect enable */ | ||
179 | #define PORTS_WKCN BIT(20) /* wake on connect enable */ | ||
180 | #define PORTS_PTC(p) (((p)>>16)&0xf) /* bits 19:16, port test control */ | ||
181 | #define PORTS_PIC (BIT(15) | BIT(14)) /* port indicator control */ | ||
182 | #define PORTS_PO BIT(13) /* port owner */ | ||
183 | #define PORTS_PP BIT(12) /* port power */ | ||
184 | #define PORTS_LS (BIT(11) | BIT(10)) /* line status */ | ||
185 | #define PORTS_SLP BIT(9) /* suspend using L1 */ | ||
186 | #define PORTS_PR BIT(8) /* port reset */ | ||
187 | #define PORTS_SUSP BIT(7) /* suspend */ | ||
188 | #define PORTS_FPR BIT(6) /* force port resume */ | ||
189 | #define PORTS_OCC BIT(5) /* over-current change */ | ||
190 | #define PORTS_OCA BIT(4) /* over-current active */ | ||
191 | #define PORTS_PEC BIT(3) /* port enable/disable change */ | ||
192 | #define PORTS_PE BIT(2) /* port enable/disable */ | ||
193 | #define PORTS_CSC BIT(1) /* connect status change */ | ||
194 | #define PORTS_CCS BIT(0) /* current connect status */ | ||
195 | u8 _reserved7[0xb4-0x78]; | ||
196 | /* offset: 0xb4 */ | ||
197 | u32 devlc; /* control LPM and each USB port behavior */ | ||
198 | /* bits 31:29, parallel transceiver select */ | ||
199 | #define LPM_PTS(d) (((d)>>29)&7) | ||
200 | #define LPM_STS BIT(28) /* serial transceiver select */ | ||
201 | #define LPM_PTW BIT(27) /* parallel transceiver width */ | ||
202 | #define LPM_PSPD(d) (((d)>>25)&3) /* bits 26:25, port speed */ | ||
203 | #define LPM_PSPD_MASK (BIT(26) | BIT(25)) | ||
204 | #define LPM_SPEED_FULL 0 | ||
205 | #define LPM_SPEED_LOW 1 | ||
206 | #define LPM_SPEED_HIGH 2 | ||
207 | #define LPM_SRT BIT(24) /* shorten reset time */ | ||
208 | #define LPM_PFSC BIT(23) /* port force full speed connect */ | ||
209 | #define LPM_PHCD BIT(22) /* PHY low power suspend clock disable */ | ||
210 | #define LPM_STL BIT(16) /* STALL reply to LPM token */ | ||
211 | #define LPM_BA(d) \ | ||
212 | (((d)>>1)&0x7ff) /* bits 11:1, BmAttributes */ | ||
213 | #define LPM_NYT_ACK BIT(0) /* NYET/ACK reply to LPM token */ | ||
214 | u8 _reserved8[0xf4-0xb8]; | ||
215 | /* offset: 0xf4 */ | ||
216 | u32 otgsc; /* On-The-Go status and control */ | ||
217 | #define OTGSC_DPIE BIT(30) /* data pulse interrupt enable */ | ||
218 | #define OTGSC_MSE BIT(29) /* 1 ms timer interrupt enable */ | ||
219 | #define OTGSC_BSEIE BIT(28) /* B session end interrupt enable */ | ||
220 | #define OTGSC_BSVIE BIT(27) /* B session valid interrupt enable */ | ||
221 | #define OTGSC_ASVIE BIT(26) /* A session valid interrupt enable */ | ||
222 | #define OTGSC_AVVIE BIT(25) /* A VBUS valid interrupt enable */ | ||
223 | #define OTGSC_IDIE BIT(24) /* USB ID interrupt enable */ | ||
224 | #define OTGSC_DPIS BIT(22) /* data pulse interrupt status */ | ||
225 | #define OTGSC_MSS BIT(21) /* 1 ms timer interrupt status */ | ||
226 | #define OTGSC_BSEIS BIT(20) /* B session end interrupt status */ | ||
227 | #define OTGSC_BSVIS BIT(19) /* B session valid interrupt status */ | ||
228 | #define OTGSC_ASVIS BIT(18) /* A session valid interrupt status */ | ||
229 | #define OTGSC_AVVIS BIT(17) /* A VBUS valid interrupt status */ | ||
230 | #define OTGSC_IDIS BIT(16) /* USB ID interrupt status */ | ||
231 | #define OTGSC_DPS BIT(14) /* data bus pulsing status */ | ||
232 | #define OTGSC_MST BIT(13) /* 1 ms timer toggle */ | ||
233 | #define OTGSC_BSE BIT(12) /* B session end */ | ||
234 | #define OTGSC_BSV BIT(11) /* B session valid */ | ||
235 | #define OTGSC_ASV BIT(10) /* A session valid */ | ||
236 | #define OTGSC_AVV BIT(9) /* A VBUS valid */ | ||
237 | #define OTGSC_USBID BIT(8) /* USB ID */ | ||
238 | #define OTGSC_HABA BIT(7) /* hw assist B-disconnect to A-connect */ | ||
239 | #define OTGSC_HADP BIT(6) /* hw assist data pulse */ | ||
240 | #define OTGSC_IDPU BIT(5) /* ID pullup */ | ||
241 | #define OTGSC_DP BIT(4) /* data pulsing */ | ||
242 | #define OTGSC_OT BIT(3) /* OTG termination */ | ||
243 | #define OTGSC_HAAR BIT(2) /* hw assist auto reset */ | ||
244 | #define OTGSC_VC BIT(1) /* VBUS charge */ | ||
245 | #define OTGSC_VD BIT(0) /* VBUS discharge */ | ||
246 | u32 usbmode; | ||
247 | #define MODE_VBPS BIT(5) /* R/W VBUS power select */ | ||
248 | #define MODE_SDIS BIT(4) /* R/W stream disable mode */ | ||
249 | #define MODE_SLOM BIT(3) /* R/W setup lockout mode */ | ||
250 | #define MODE_ENSE BIT(2) /* endian select */ | ||
251 | #define MODE_CM(u) (((u)>>0)&3) /* bits 1:0, controller mode */ | ||
252 | #define MODE_IDLE 0 | ||
253 | #define MODE_DEVICE 2 | ||
254 | #define MODE_HOST 3 | ||
255 | u8 _reserved9[0x100-0xfc]; | ||
256 | /* offset: 0x100 */ | ||
257 | u32 endptnak; | ||
258 | #define EPTN(e) \ | ||
259 | (((e)>>16)&0xffff) /* bits 31:16, TX endpoint NAK */ | ||
260 | #define EPRN(e) \ | ||
261 | (((e)>>0)&0xffff) /* bits 15:0, RX endpoint NAK */ | ||
262 | u32 endptnaken; | ||
263 | #define EPTNE(e) \ | ||
264 | (((e)>>16)&0xffff) /* bits 31:16, TX endpoint NAK enable */ | ||
265 | #define EPRNE(e) \ | ||
266 | (((e)>>0)&0xffff) /* bits 15:0, RX endpoint NAK enable */ | ||
267 | u32 endptsetupstat; | ||
268 | #define SETUPSTAT_MASK (0xffff << 0) /* bits 15:0 */ | ||
269 | #define EP0SETUPSTAT_MASK 1 | ||
270 | u32 endptprime; | ||
271 | /* bits 31:16, prime endpoint transmit buffer */ | ||
272 | #define PETB(e) (((e)>>16)&0xffff) | ||
273 | /* bits 15:0, prime endpoint receive buffer */ | ||
274 | #define PERB(e) (((e)>>0)&0xffff) | ||
275 | /* offset: 0x110 */ | ||
276 | u32 endptflush; | ||
277 | /* bits 31:16, flush endpoint transmit buffer */ | ||
278 | #define FETB(e) (((e)>>16)&0xffff) | ||
279 | /* bits 15:0, flush endpoint receive buffer */ | ||
280 | #define FERB(e) (((e)>>0)&0xffff) | ||
281 | u32 endptstat; | ||
282 | /* bits 31:16, endpoint transmit buffer ready */ | ||
283 | #define ETBR(e) (((e)>>16)&0xffff) | ||
284 | /* bits 15:0, endpoint receive buffer ready */ | ||
285 | #define ERBR(e) (((e)>>0)&0xffff) | ||
286 | u32 endptcomplete; | ||
287 | /* bits 31:16, endpoint transmit complete event */ | ||
288 | #define ETCE(e) (((e)>>16)&0xffff) | ||
289 | /* bits 15:0, endpoint receive complete event */ | ||
290 | #define ERCE(e) (((e)>>0)&0xffff) | ||
291 | /* offset: 0x11c */ | ||
292 | u32 endptctrl[16]; | ||
293 | #define EPCTRL_TXE BIT(23) /* TX endpoint enable */ | ||
294 | #define EPCTRL_TXR BIT(22) /* TX data toggle reset */ | ||
295 | #define EPCTRL_TXI BIT(21) /* TX data toggle inhibit */ | ||
296 | #define EPCTRL_TXT(e) (((e)>>18)&3) /* bits 19:18, TX endpoint type */ | ||
297 | #define EPCTRL_TXT_SHIFT 18 | ||
298 | #define EPCTRL_TXD BIT(17) /* TX endpoint data source */ | ||
299 | #define EPCTRL_TXS BIT(16) /* TX endpoint STALL */ | ||
300 | #define EPCTRL_RXE BIT(7) /* RX endpoint enable */ | ||
301 | #define EPCTRL_RXR BIT(6) /* RX data toggle reset */ | ||
302 | #define EPCTRL_RXI BIT(5) /* RX data toggle inhibit */ | ||
303 | #define EPCTRL_RXT(e) (((e)>>2)&3) /* bits 3:2, RX endpoint type */ | ||
304 | #define EPCTRL_RXT_SHIFT 2 /* bits 19:18, TX endpoint type */ | ||
305 | #define EPCTRL_RXD BIT(1) /* RX endpoint data sink */ | ||
306 | #define EPCTRL_RXS BIT(0) /* RX endpoint STALL */ | ||
307 | } __attribute__ ((packed)); | ||
308 | |||
309 | #endif /* __LANGWELL_UDC_H */ | ||
310 | |||
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h index 1aaa826396a1..2443c0e7a80c 100644 --- a/include/linux/usb/otg.h +++ b/include/linux/usb/otg.h | |||
@@ -80,10 +80,10 @@ struct otg_transceiver { | |||
80 | 80 | ||
81 | /* for board-specific init logic */ | 81 | /* for board-specific init logic */ |
82 | extern int otg_set_transceiver(struct otg_transceiver *); | 82 | extern int otg_set_transceiver(struct otg_transceiver *); |
83 | #ifdef CONFIG_NOP_USB_XCEIV | 83 | |
84 | /* sometimes transceivers are accessed only through e.g. ULPI */ | ||
84 | extern void usb_nop_xceiv_register(void); | 85 | extern void usb_nop_xceiv_register(void); |
85 | extern void usb_nop_xceiv_unregister(void); | 86 | extern void usb_nop_xceiv_unregister(void); |
86 | #endif | ||
87 | 87 | ||
88 | 88 | ||
89 | /* for usb host and peripheral controller drivers */ | 89 | /* for usb host and peripheral controller drivers */ |
diff --git a/include/linux/usb/r8a66597.h b/include/linux/usb/r8a66597.h new file mode 100644 index 000000000000..e9f0384fa20c --- /dev/null +++ b/include/linux/usb/r8a66597.h | |||
@@ -0,0 +1,44 @@ | |||
1 | /* | ||
2 | * R8A66597 driver platform data | ||
3 | * | ||
4 | * Copyright (C) 2009 Renesas Solutions Corp. | ||
5 | * | ||
6 | * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com> | ||
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 as published by | ||
10 | * the Free Software Foundation; version 2 of the License. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | * | ||
21 | */ | ||
22 | |||
23 | #ifndef __LINUX_USB_R8A66597_H | ||
24 | #define __LINUX_USB_R8A66597_H | ||
25 | |||
26 | #define R8A66597_PLATDATA_XTAL_12MHZ 0x01 | ||
27 | #define R8A66597_PLATDATA_XTAL_24MHZ 0x02 | ||
28 | #define R8A66597_PLATDATA_XTAL_48MHZ 0x03 | ||
29 | |||
30 | struct r8a66597_platdata { | ||
31 | /* This ops can controll port power instead of DVSTCTR register. */ | ||
32 | void (*port_power)(int port, int power); | ||
33 | |||
34 | /* (external controller only) set R8A66597_PLATDATA_XTAL_nnMHZ */ | ||
35 | unsigned xtal:2; | ||
36 | |||
37 | /* set one = 3.3V, set zero = 1.5V */ | ||
38 | unsigned vif:1; | ||
39 | |||
40 | /* set one = big endian, set zero = little endian */ | ||
41 | unsigned endian:1; | ||
42 | }; | ||
43 | #endif | ||
44 | |||
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h index 8cdfed738fe4..44801d26a37a 100644 --- a/include/linux/usb/serial.h +++ b/include/linux/usb/serial.h | |||
@@ -15,6 +15,7 @@ | |||
15 | 15 | ||
16 | #include <linux/kref.h> | 16 | #include <linux/kref.h> |
17 | #include <linux/mutex.h> | 17 | #include <linux/mutex.h> |
18 | #include <linux/sysrq.h> | ||
18 | 19 | ||
19 | #define SERIAL_TTY_MAJOR 188 /* Nice legal number now */ | 20 | #define SERIAL_TTY_MAJOR 188 /* Nice legal number now */ |
20 | #define SERIAL_TTY_MINORS 254 /* loads of devices :) */ | 21 | #define SERIAL_TTY_MINORS 254 /* loads of devices :) */ |
@@ -26,6 +27,13 @@ | |||
26 | /* parity check flag */ | 27 | /* parity check flag */ |
27 | #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) | 28 | #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) |
28 | 29 | ||
30 | enum port_dev_state { | ||
31 | PORT_UNREGISTERED, | ||
32 | PORT_REGISTERING, | ||
33 | PORT_REGISTERED, | ||
34 | PORT_UNREGISTERING, | ||
35 | }; | ||
36 | |||
29 | /** | 37 | /** |
30 | * usb_serial_port: structure for the specific ports of a device. | 38 | * usb_serial_port: structure for the specific ports of a device. |
31 | * @serial: pointer back to the struct usb_serial owner of this port. | 39 | * @serial: pointer back to the struct usb_serial owner of this port. |
@@ -91,12 +99,17 @@ struct usb_serial_port { | |||
91 | int write_urb_busy; | 99 | int write_urb_busy; |
92 | __u8 bulk_out_endpointAddress; | 100 | __u8 bulk_out_endpointAddress; |
93 | 101 | ||
102 | int tx_bytes_flight; | ||
103 | int urbs_in_flight; | ||
104 | |||
94 | wait_queue_head_t write_wait; | 105 | wait_queue_head_t write_wait; |
95 | struct work_struct work; | 106 | struct work_struct work; |
96 | char throttled; | 107 | char throttled; |
97 | char throttle_req; | 108 | char throttle_req; |
98 | char console; | 109 | char console; |
110 | unsigned long sysrq; /* sysrq timeout */ | ||
99 | struct device dev; | 111 | struct device dev; |
112 | enum port_dev_state dev_state; | ||
100 | }; | 113 | }; |
101 | #define to_usb_serial_port(d) container_of(d, struct usb_serial_port, dev) | 114 | #define to_usb_serial_port(d) container_of(d, struct usb_serial_port, dev) |
102 | 115 | ||
@@ -181,8 +194,10 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data) | |||
181 | * This will be called when the struct usb_serial structure is fully set | 194 | * This will be called when the struct usb_serial structure is fully set |
182 | * set up. Do any local initialization of the device, or any private | 195 | * set up. Do any local initialization of the device, or any private |
183 | * memory structure allocation at this point in time. | 196 | * memory structure allocation at this point in time. |
184 | * @shutdown: pointer to the driver's shutdown function. This will be | 197 | * @disconnect: pointer to the driver's disconnect function. This will be |
185 | * called when the device is removed from the system. | 198 | * called when the device is unplugged or unbound from the driver. |
199 | * @release: pointer to the driver's release function. This will be called | ||
200 | * when the usb_serial data structure is about to be destroyed. | ||
186 | * @usb_driver: pointer to the struct usb_driver that controls this | 201 | * @usb_driver: pointer to the struct usb_driver that controls this |
187 | * device. This is necessary to allow dynamic ids to be added to | 202 | * device. This is necessary to allow dynamic ids to be added to |
188 | * the driver from sysfs. | 203 | * the driver from sysfs. |
@@ -207,12 +222,14 @@ struct usb_serial_driver { | |||
207 | struct device_driver driver; | 222 | struct device_driver driver; |
208 | struct usb_driver *usb_driver; | 223 | struct usb_driver *usb_driver; |
209 | struct usb_dynids dynids; | 224 | struct usb_dynids dynids; |
225 | int max_in_flight_urbs; | ||
210 | 226 | ||
211 | int (*probe)(struct usb_serial *serial, const struct usb_device_id *id); | 227 | int (*probe)(struct usb_serial *serial, const struct usb_device_id *id); |
212 | int (*attach)(struct usb_serial *serial); | 228 | int (*attach)(struct usb_serial *serial); |
213 | int (*calc_num_ports) (struct usb_serial *serial); | 229 | int (*calc_num_ports) (struct usb_serial *serial); |
214 | 230 | ||
215 | void (*shutdown)(struct usb_serial *serial); | 231 | void (*disconnect)(struct usb_serial *serial); |
232 | void (*release)(struct usb_serial *serial); | ||
216 | 233 | ||
217 | int (*port_probe)(struct usb_serial_port *port); | 234 | int (*port_probe)(struct usb_serial_port *port); |
218 | int (*port_remove)(struct usb_serial_port *port); | 235 | int (*port_remove)(struct usb_serial_port *port); |
@@ -294,9 +311,16 @@ extern void usb_serial_generic_read_bulk_callback(struct urb *urb); | |||
294 | extern void usb_serial_generic_write_bulk_callback(struct urb *urb); | 311 | extern void usb_serial_generic_write_bulk_callback(struct urb *urb); |
295 | extern void usb_serial_generic_throttle(struct tty_struct *tty); | 312 | extern void usb_serial_generic_throttle(struct tty_struct *tty); |
296 | extern void usb_serial_generic_unthrottle(struct tty_struct *tty); | 313 | extern void usb_serial_generic_unthrottle(struct tty_struct *tty); |
297 | extern void usb_serial_generic_shutdown(struct usb_serial *serial); | 314 | extern void usb_serial_generic_disconnect(struct usb_serial *serial); |
315 | extern void usb_serial_generic_release(struct usb_serial *serial); | ||
298 | extern int usb_serial_generic_register(int debug); | 316 | extern int usb_serial_generic_register(int debug); |
299 | extern void usb_serial_generic_deregister(void); | 317 | extern void usb_serial_generic_deregister(void); |
318 | extern void usb_serial_generic_resubmit_read_urb(struct usb_serial_port *port, | ||
319 | gfp_t mem_flags); | ||
320 | extern int usb_serial_handle_sysrq_char(struct usb_serial_port *port, | ||
321 | unsigned int ch); | ||
322 | extern int usb_serial_handle_break(struct usb_serial_port *port); | ||
323 | |||
300 | 324 | ||
301 | extern int usb_serial_bus_register(struct usb_serial_driver *device); | 325 | extern int usb_serial_bus_register(struct usb_serial_driver *device); |
302 | extern void usb_serial_bus_deregister(struct usb_serial_driver *device); | 326 | extern void usb_serial_bus_deregister(struct usb_serial_driver *device); |