]>
Commit | Line | Data |
---|---|---|
b69fada6 IPG |
1 | /* |
2 | * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8]) | |
3 | * MMC (Microscheduled Management Command) handling | |
4 | * | |
5 | * Copyright (C) 2005-2006 Intel Corporation | |
6 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License version | |
10 | * 2 as published by the Free Software Foundation. | |
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 Street, Fifth Floor, Boston, MA | |
20 | * 02110-1301, USA. | |
21 | * | |
22 | * | |
23 | * WUIEs and MMC IEs...well, they are almost the same at the end. MMC | |
24 | * IEs are Wireless USB IEs that go into the MMC period...[what is | |
25 | * that? look in Design-overview.txt]. | |
26 | * | |
27 | * | |
28 | * This is a simple subsystem to keep track of which IEs are being | |
29 | * sent by the host in the MMC period. | |
30 | * | |
31 | * For each WUIE we ask to send, we keep it in an array, so we can | |
32 | * request its removal later, or replace the content. They are tracked | |
33 | * by pointer, so be sure to use the same pointer if you want to | |
34 | * remove it or update the contents. | |
35 | * | |
36 | * FIXME: | |
37 | * - add timers that autoremove intervalled IEs? | |
38 | */ | |
39 | #include <linux/usb/wusb.h> | |
40 | #include "wusbhc.h" | |
41 | ||
42 | /* Initialize the MMCIEs handling mechanism */ | |
43 | int wusbhc_mmcie_create(struct wusbhc *wusbhc) | |
44 | { | |
45 | u8 mmcies = wusbhc->mmcies_max; | |
92c4d9bd | 46 | wusbhc->mmcie = kcalloc(mmcies, sizeof(wusbhc->mmcie[0]), GFP_KERNEL); |
b69fada6 IPG |
47 | if (wusbhc->mmcie == NULL) |
48 | return -ENOMEM; | |
49 | mutex_init(&wusbhc->mmcie_mutex); | |
50 | return 0; | |
51 | } | |
52 | ||
53 | /* Release resources used by the MMCIEs handling mechanism */ | |
54 | void wusbhc_mmcie_destroy(struct wusbhc *wusbhc) | |
55 | { | |
56 | kfree(wusbhc->mmcie); | |
57 | } | |
58 | ||
59 | /* | |
60 | * Add or replace an MMC Wireless USB IE. | |
61 | * | |
62 | * @interval: See WUSB1.0[8.5.3.1] | |
63 | * @repeat_cnt: See WUSB1.0[8.5.3.1] | |
64 | * @handle: See WUSB1.0[8.5.3.1] | |
65 | * @wuie: Pointer to the header of the WUSB IE data to add. | |
66 | * MUST BE allocated in a kmalloc buffer (no stack or | |
67 | * vmalloc). | |
68 | * THE CALLER ALWAYS OWNS THE POINTER (we don't free it | |
69 | * on remove, we just forget about it). | |
70 | * @returns: 0 if ok, < 0 errno code on error. | |
71 | * | |
72 | * Goes over the *whole* @wusbhc->mmcie array looking for (a) the | |
73 | * first free spot and (b) if @wuie is already in the array (aka: | |
74 | * transmitted in the MMCs) the spot were it is. | |
75 | * | |
76 | * If present, we "overwrite it" (update). | |
77 | * | |
78 | * | |
79 | * NOTE: Need special ordering rules -- see below WUSB1.0 Table 7-38. | |
80 | * The host uses the handle as the 'sort' index. We | |
81 | * allocate the last one always for the WUIE_ID_HOST_INFO, and | |
82 | * the rest, first come first serve in inverse order. | |
83 | * | |
84 | * Host software must make sure that it adds the other IEs in | |
85 | * the right order... the host hardware is responsible for | |
86 | * placing the WCTA IEs in the right place with the other IEs | |
87 | * set by host software. | |
88 | * | |
89 | * NOTE: we can access wusbhc->wa_descr without locking because it is | |
90 | * read only. | |
91 | */ | |
92 | int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt, | |
93 | struct wuie_hdr *wuie) | |
94 | { | |
95 | int result = -ENOBUFS; | |
b69fada6 IPG |
96 | unsigned handle, itr; |
97 | ||
98 | /* Search a handle, taking into account the ordering */ | |
99 | mutex_lock(&wusbhc->mmcie_mutex); | |
100 | switch (wuie->bIEIdentifier) { | |
101 | case WUIE_ID_HOST_INFO: | |
102 | /* Always last */ | |
103 | handle = wusbhc->mmcies_max - 1; | |
104 | break; | |
105 | case WUIE_ID_ISOCH_DISCARD: | |
106 | dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x " | |
107 | "unimplemented\n", wuie->bIEIdentifier); | |
108 | result = -ENOSYS; | |
109 | goto error_unlock; | |
110 | default: | |
111 | /* search for it or find the last empty slot */ | |
112 | handle = ~0; | |
113 | for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) { | |
114 | if (wusbhc->mmcie[itr] == wuie) { | |
115 | handle = itr; | |
116 | break; | |
117 | } | |
118 | if (wusbhc->mmcie[itr] == NULL) | |
119 | handle = itr; | |
120 | } | |
8092d7c9 | 121 | if (handle == ~0) |
b69fada6 | 122 | goto error_unlock; |
b69fada6 IPG |
123 | } |
124 | result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle, | |
125 | wuie); | |
126 | if (result >= 0) | |
127 | wusbhc->mmcie[handle] = wuie; | |
128 | error_unlock: | |
129 | mutex_unlock(&wusbhc->mmcie_mutex); | |
130 | return result; | |
131 | } | |
132 | EXPORT_SYMBOL_GPL(wusbhc_mmcie_set); | |
133 | ||
134 | /* | |
135 | * Remove an MMC IE previously added with wusbhc_mmcie_set() | |
136 | * | |
137 | * @wuie Pointer used to add the WUIE | |
138 | */ | |
139 | void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie) | |
140 | { | |
141 | int result; | |
b69fada6 IPG |
142 | unsigned handle, itr; |
143 | ||
144 | mutex_lock(&wusbhc->mmcie_mutex); | |
8092d7c9 | 145 | for (itr = 0; itr < wusbhc->mmcies_max; itr++) { |
b69fada6 IPG |
146 | if (wusbhc->mmcie[itr] == wuie) { |
147 | handle = itr; | |
148 | goto found; | |
149 | } | |
8092d7c9 | 150 | } |
b69fada6 IPG |
151 | mutex_unlock(&wusbhc->mmcie_mutex); |
152 | return; | |
153 | ||
154 | found: | |
155 | result = (wusbhc->mmcie_rm)(wusbhc, handle); | |
156 | if (result == 0) | |
157 | wusbhc->mmcie[itr] = NULL; | |
b69fada6 | 158 | mutex_unlock(&wusbhc->mmcie_mutex); |
b69fada6 IPG |
159 | } |
160 | EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm); | |
161 | ||
162 | /* | |
163 | * wusbhc_start - start transmitting MMCs and accepting connections | |
164 | * @wusbhc: the HC to start | |
165 | * @chid: the CHID to use for this host | |
166 | * | |
167 | * Establishes a cluster reservation, enables device connections, and | |
168 | * starts MMCs with appropriate DNTS parameters. | |
169 | */ | |
170 | int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid) | |
171 | { | |
172 | int result; | |
173 | struct device *dev = wusbhc->dev; | |
174 | ||
175 | WARN_ON(wusbhc->wuie_host_info != NULL); | |
176 | ||
177 | result = wusbhc_rsv_establish(wusbhc); | |
178 | if (result < 0) { | |
179 | dev_err(dev, "cannot establish cluster reservation: %d\n", | |
180 | result); | |
181 | goto error_rsv_establish; | |
182 | } | |
183 | ||
184 | result = wusbhc_devconnect_start(wusbhc, chid); | |
185 | if (result < 0) { | |
186 | dev_err(dev, "error enabling device connections: %d\n", result); | |
187 | goto error_devconnect_start; | |
188 | } | |
189 | ||
190 | result = wusbhc_sec_start(wusbhc); | |
191 | if (result < 0) { | |
192 | dev_err(dev, "error starting security in the HC: %d\n", result); | |
193 | goto error_sec_start; | |
194 | } | |
195 | /* FIXME: the choice of the DNTS parameters is somewhat | |
196 | * arbitrary */ | |
197 | result = wusbhc->set_num_dnts(wusbhc, 0, 15); | |
198 | if (result < 0) { | |
199 | dev_err(dev, "Cannot set DNTS parameters: %d\n", result); | |
200 | goto error_set_num_dnts; | |
201 | } | |
202 | result = wusbhc->start(wusbhc); | |
203 | if (result < 0) { | |
204 | dev_err(dev, "error starting wusbch: %d\n", result); | |
205 | goto error_wusbhc_start; | |
206 | } | |
207 | wusbhc->active = 1; | |
208 | return 0; | |
209 | ||
210 | error_wusbhc_start: | |
211 | wusbhc_sec_stop(wusbhc); | |
212 | error_set_num_dnts: | |
213 | error_sec_start: | |
214 | wusbhc_devconnect_stop(wusbhc); | |
215 | error_devconnect_start: | |
216 | wusbhc_rsv_terminate(wusbhc); | |
217 | error_rsv_establish: | |
218 | return result; | |
219 | } | |
220 | ||
221 | /* | |
222 | * Disconnect all from the WUSB Channel | |
223 | * | |
224 | * Send a Host Disconnect IE in the MMC, wait, don't send it any more | |
225 | */ | |
226 | static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc) | |
227 | { | |
228 | int result = -ENOMEM; | |
229 | struct wuie_host_disconnect *host_disconnect_ie; | |
230 | might_sleep(); | |
231 | host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL); | |
232 | if (host_disconnect_ie == NULL) | |
233 | goto error_alloc; | |
234 | host_disconnect_ie->hdr.bLength = sizeof(*host_disconnect_ie); | |
235 | host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT; | |
236 | result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr); | |
237 | if (result < 0) | |
238 | goto error_mmcie_set; | |
239 | ||
240 | /* WUSB1.0[8.5.3.1 & 7.5.2] */ | |
241 | msleep(100); | |
242 | wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr); | |
243 | error_mmcie_set: | |
244 | kfree(host_disconnect_ie); | |
245 | error_alloc: | |
246 | return result; | |
247 | } | |
248 | ||
249 | /* | |
250 | * wusbhc_stop - stop transmitting MMCs | |
251 | * @wusbhc: the HC to stop | |
252 | * | |
4d2bea4c | 253 | * Stops the WUSB channel and removes the cluster reservation. |
b69fada6 IPG |
254 | */ |
255 | void wusbhc_stop(struct wusbhc *wusbhc) | |
256 | { | |
257 | if (wusbhc->active) { | |
258 | wusbhc->active = 0; | |
4d2bea4c | 259 | wusbhc->stop(wusbhc, WUSB_CHANNEL_STOP_DELAY_MS); |
b69fada6 | 260 | wusbhc_sec_stop(wusbhc); |
b69fada6 IPG |
261 | wusbhc_devconnect_stop(wusbhc); |
262 | wusbhc_rsv_terminate(wusbhc); | |
263 | } | |
264 | } | |
265 | EXPORT_SYMBOL_GPL(wusbhc_stop); | |
266 | ||
267 | /* | |
268 | * Change the CHID in a WUSB Channel | |
269 | * | |
270 | * If it is just a new CHID, send a Host Disconnect IE and then change | |
271 | * the CHID IE. | |
272 | */ | |
273 | static int __wusbhc_chid_change(struct wusbhc *wusbhc, | |
274 | const struct wusb_ckhdid *chid) | |
275 | { | |
276 | int result = -ENOSYS; | |
277 | struct device *dev = wusbhc->dev; | |
278 | dev_err(dev, "%s() not implemented yet\n", __func__); | |
279 | return result; | |
280 | ||
281 | BUG_ON(wusbhc->wuie_host_info == NULL); | |
282 | __wusbhc_host_disconnect_ie(wusbhc); | |
283 | wusbhc->wuie_host_info->CHID = *chid; | |
284 | result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr); | |
285 | if (result < 0) | |
286 | dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result); | |
287 | return result; | |
288 | } | |
289 | ||
290 | /* | |
291 | * Set/reset/update a new CHID | |
292 | * | |
293 | * Depending on the previous state of the MMCs, start, stop or change | |
294 | * the sent MMC. This effectively switches the host controller on and | |
295 | * off (radio wise). | |
296 | */ | |
297 | int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid) | |
298 | { | |
299 | int result = 0; | |
300 | ||
301 | if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0) | |
302 | chid = NULL; | |
303 | ||
304 | mutex_lock(&wusbhc->mutex); | |
305 | if (wusbhc->active) { | |
306 | if (chid) | |
307 | result = __wusbhc_chid_change(wusbhc, chid); | |
308 | else | |
309 | wusbhc_stop(wusbhc); | |
310 | } else { | |
311 | if (chid) | |
312 | wusbhc_start(wusbhc, chid); | |
313 | } | |
314 | mutex_unlock(&wusbhc->mutex); | |
315 | return result; | |
316 | } | |
317 | EXPORT_SYMBOL_GPL(wusbhc_chid_set); |