2 * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
3 * MMC (Microscheduled Management Command) handling
5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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
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].
28 * This is a simple subsystem to keep track of which IEs are being
29 * sent by the host in the MMC period.
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.
37 * - add timers that autoremove intervalled IEs?
39 #include <linux/usb/wusb.h>
42 /* Initialize the MMCIEs handling mechanism */
43 int wusbhc_mmcie_create(struct wusbhc *wusbhc)
45 u8 mmcies = wusbhc->mmcies_max;
46 wusbhc->mmcie = kzalloc(mmcies * sizeof(wusbhc->mmcie[0]), GFP_KERNEL);
47 if (wusbhc->mmcie == NULL)
49 mutex_init(&wusbhc->mmcie_mutex);
53 /* Release resources used by the MMCIEs handling mechanism */
54 void wusbhc_mmcie_destroy(struct wusbhc *wusbhc)
60 * Add or replace an MMC Wireless USB IE.
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
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.
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.
76 * If present, we "overwrite it" (update).
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.
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.
89 * NOTE: we can access wusbhc->wa_descr without locking because it is
92 int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
93 struct wuie_hdr *wuie)
95 int result = -ENOBUFS;
96 struct device *dev = wusbhc->dev;
99 /* Search a handle, taking into account the ordering */
100 mutex_lock(&wusbhc->mmcie_mutex);
101 switch (wuie->bIEIdentifier) {
102 case WUIE_ID_HOST_INFO:
104 handle = wusbhc->mmcies_max - 1;
106 case WUIE_ID_ISOCH_DISCARD:
107 dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x "
108 "unimplemented\n", wuie->bIEIdentifier);
112 /* search for it or find the last empty slot */
114 for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) {
115 if (wusbhc->mmcie[itr] == wuie) {
119 if (wusbhc->mmcie[itr] == NULL)
123 if (printk_ratelimit())
124 dev_err(dev, "MMC handle space exhausted\n");
128 result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,
131 wusbhc->mmcie[handle] = wuie;
133 mutex_unlock(&wusbhc->mmcie_mutex);
136 EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);
139 * Remove an MMC IE previously added with wusbhc_mmcie_set()
141 * @wuie Pointer used to add the WUIE
143 void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)
146 struct device *dev = wusbhc->dev;
147 unsigned handle, itr;
149 mutex_lock(&wusbhc->mmcie_mutex);
150 for (itr = 0; itr < wusbhc->mmcies_max; itr++)
151 if (wusbhc->mmcie[itr] == wuie) {
155 mutex_unlock(&wusbhc->mmcie_mutex);
159 result = (wusbhc->mmcie_rm)(wusbhc, handle);
161 wusbhc->mmcie[itr] = NULL;
162 else if (printk_ratelimit())
163 dev_err(dev, "MMC: Failed to remove IE %p (0x%02x)\n",
164 wuie, wuie->bIEIdentifier);
165 mutex_unlock(&wusbhc->mmcie_mutex);
168 EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);
171 * wusbhc_start - start transmitting MMCs and accepting connections
172 * @wusbhc: the HC to start
173 * @chid: the CHID to use for this host
175 * Establishes a cluster reservation, enables device connections, and
176 * starts MMCs with appropriate DNTS parameters.
178 int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
181 struct device *dev = wusbhc->dev;
183 WARN_ON(wusbhc->wuie_host_info != NULL);
185 result = wusbhc_rsv_establish(wusbhc);
187 dev_err(dev, "cannot establish cluster reservation: %d\n",
189 goto error_rsv_establish;
192 result = wusbhc_devconnect_start(wusbhc, chid);
194 dev_err(dev, "error enabling device connections: %d\n", result);
195 goto error_devconnect_start;
198 result = wusbhc_sec_start(wusbhc);
200 dev_err(dev, "error starting security in the HC: %d\n", result);
201 goto error_sec_start;
203 /* FIXME: the choice of the DNTS parameters is somewhat
205 result = wusbhc->set_num_dnts(wusbhc, 0, 15);
207 dev_err(dev, "Cannot set DNTS parameters: %d\n", result);
208 goto error_set_num_dnts;
210 result = wusbhc->start(wusbhc);
212 dev_err(dev, "error starting wusbch: %d\n", result);
213 goto error_wusbhc_start;
219 wusbhc_sec_stop(wusbhc);
222 wusbhc_devconnect_stop(wusbhc);
223 error_devconnect_start:
224 wusbhc_rsv_terminate(wusbhc);
230 * Disconnect all from the WUSB Channel
232 * Send a Host Disconnect IE in the MMC, wait, don't send it any more
234 static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc)
236 int result = -ENOMEM;
237 struct wuie_host_disconnect *host_disconnect_ie;
239 host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL);
240 if (host_disconnect_ie == NULL)
242 host_disconnect_ie->hdr.bLength = sizeof(*host_disconnect_ie);
243 host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT;
244 result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr);
246 goto error_mmcie_set;
248 /* WUSB1.0[8.5.3.1 & 7.5.2] */
250 wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr);
252 kfree(host_disconnect_ie);
258 * wusbhc_stop - stop transmitting MMCs
259 * @wusbhc: the HC to stop
261 * Send a Host Disconnect IE, wait, remove all the MMCs (stop sending MMCs).
263 * If we can't allocate a Host Stop IE, screw it, we don't notify the
264 * devices we are disconnecting...
266 void wusbhc_stop(struct wusbhc *wusbhc)
268 if (wusbhc->active) {
270 wusbhc->stop(wusbhc);
271 wusbhc_sec_stop(wusbhc);
272 __wusbhc_host_disconnect_ie(wusbhc);
273 wusbhc_devconnect_stop(wusbhc);
274 wusbhc_rsv_terminate(wusbhc);
277 EXPORT_SYMBOL_GPL(wusbhc_stop);
280 * Change the CHID in a WUSB Channel
282 * If it is just a new CHID, send a Host Disconnect IE and then change
285 static int __wusbhc_chid_change(struct wusbhc *wusbhc,
286 const struct wusb_ckhdid *chid)
288 int result = -ENOSYS;
289 struct device *dev = wusbhc->dev;
290 dev_err(dev, "%s() not implemented yet\n", __func__);
293 BUG_ON(wusbhc->wuie_host_info == NULL);
294 __wusbhc_host_disconnect_ie(wusbhc);
295 wusbhc->wuie_host_info->CHID = *chid;
296 result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr);
298 dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result);
303 * Set/reset/update a new CHID
305 * Depending on the previous state of the MMCs, start, stop or change
306 * the sent MMC. This effectively switches the host controller on and
309 int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
313 if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0)
316 mutex_lock(&wusbhc->mutex);
317 if (wusbhc->active) {
319 result = __wusbhc_chid_change(wusbhc, chid);
324 wusbhc_start(wusbhc, chid);
326 mutex_unlock(&wusbhc->mutex);
329 EXPORT_SYMBOL_GPL(wusbhc_chid_set);