0a57ff0a0b0c6df4b802f5ff5316ceb77ae7a2a1
[linux-2.6.git] / drivers / usb / wusbcore / mmc.c
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 <linux/slab.h>
41 #include "wusbhc.h"
42
43 /* Initialize the MMCIEs handling mechanism */
44 int wusbhc_mmcie_create(struct wusbhc *wusbhc)
45 {
46         u8 mmcies = wusbhc->mmcies_max;
47         wusbhc->mmcie = kcalloc(mmcies, sizeof(wusbhc->mmcie[0]), GFP_KERNEL);
48         if (wusbhc->mmcie == NULL)
49                 return -ENOMEM;
50         mutex_init(&wusbhc->mmcie_mutex);
51         return 0;
52 }
53
54 /* Release resources used by the MMCIEs handling mechanism */
55 void wusbhc_mmcie_destroy(struct wusbhc *wusbhc)
56 {
57         kfree(wusbhc->mmcie);
58 }
59
60 /*
61  * Add or replace an MMC Wireless USB IE.
62  *
63  * @interval:    See WUSB1.0[8.5.3.1]
64  * @repeat_cnt:  See WUSB1.0[8.5.3.1]
65  * @handle:      See WUSB1.0[8.5.3.1]
66  * @wuie:        Pointer to the header of the WUSB IE data to add.
67  *               MUST BE allocated in a kmalloc buffer (no stack or
68  *               vmalloc).
69  *               THE CALLER ALWAYS OWNS THE POINTER (we don't free it
70  *               on remove, we just forget about it).
71  * @returns:     0 if ok, < 0 errno code on error.
72  *
73  * Goes over the *whole* @wusbhc->mmcie array looking for (a) the
74  * first free spot and (b) if @wuie is already in the array (aka:
75  * transmitted in the MMCs) the spot were it is.
76  *
77  * If present, we "overwrite it" (update).
78  *
79  *
80  * NOTE: Need special ordering rules -- see below WUSB1.0 Table 7-38.
81  *       The host uses the handle as the 'sort' index. We
82  *       allocate the last one always for the WUIE_ID_HOST_INFO, and
83  *       the rest, first come first serve in inverse order.
84  *
85  *       Host software must make sure that it adds the other IEs in
86  *       the right order... the host hardware is responsible for
87  *       placing the WCTA IEs in the right place with the other IEs
88  *       set by host software.
89  *
90  * NOTE: we can access wusbhc->wa_descr without locking because it is
91  *       read only.
92  */
93 int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
94                      struct wuie_hdr *wuie)
95 {
96         int result = -ENOBUFS;
97         unsigned handle, itr;
98
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:
103                 /* Always last */
104                 handle = wusbhc->mmcies_max - 1;
105                 break;
106         case WUIE_ID_ISOCH_DISCARD:
107                 dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x "
108                         "unimplemented\n", wuie->bIEIdentifier);
109                 result = -ENOSYS;
110                 goto error_unlock;
111         default:
112                 /* search for it or find the last empty slot */
113                 handle = ~0;
114                 for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) {
115                         if (wusbhc->mmcie[itr] == wuie) {
116                                 handle = itr;
117                                 break;
118                         }
119                         if (wusbhc->mmcie[itr] == NULL)
120                                 handle = itr;
121                 }
122                 if (handle == ~0)
123                         goto error_unlock;
124         }
125         result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,
126                                      wuie);
127         if (result >= 0)
128                 wusbhc->mmcie[handle] = wuie;
129 error_unlock:
130         mutex_unlock(&wusbhc->mmcie_mutex);
131         return result;
132 }
133 EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);
134
135 /*
136  * Remove an MMC IE previously added with wusbhc_mmcie_set()
137  *
138  * @wuie        Pointer used to add the WUIE
139  */
140 void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)
141 {
142         int result;
143         unsigned handle, itr;
144
145         mutex_lock(&wusbhc->mmcie_mutex);
146         for (itr = 0; itr < wusbhc->mmcies_max; itr++) {
147                 if (wusbhc->mmcie[itr] == wuie) {
148                         handle = itr;
149                         goto found;
150                 }
151         }
152         mutex_unlock(&wusbhc->mmcie_mutex);
153         return;
154
155 found:
156         result = (wusbhc->mmcie_rm)(wusbhc, handle);
157         if (result == 0)
158                 wusbhc->mmcie[itr] = NULL;
159         mutex_unlock(&wusbhc->mmcie_mutex);
160 }
161 EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);
162
163 static int wusbhc_mmc_start(struct wusbhc *wusbhc)
164 {
165         int ret;
166
167         mutex_lock(&wusbhc->mutex);
168         ret = wusbhc->start(wusbhc);
169         if (ret >= 0)
170                 wusbhc->active = 1;
171         mutex_unlock(&wusbhc->mutex);
172
173         return ret;
174 }
175
176 static void wusbhc_mmc_stop(struct wusbhc *wusbhc)
177 {
178         mutex_lock(&wusbhc->mutex);
179         wusbhc->active = 0;
180         wusbhc->stop(wusbhc, WUSB_CHANNEL_STOP_DELAY_MS);
181         mutex_unlock(&wusbhc->mutex);
182 }
183
184 /*
185  * wusbhc_start - start transmitting MMCs and accepting connections
186  * @wusbhc: the HC to start
187  *
188  * Establishes a cluster reservation, enables device connections, and
189  * starts MMCs with appropriate DNTS parameters.
190  */
191 int wusbhc_start(struct wusbhc *wusbhc)
192 {
193         int result;
194         struct device *dev = wusbhc->dev;
195
196         WARN_ON(wusbhc->wuie_host_info != NULL);
197
198         result = wusbhc_rsv_establish(wusbhc);
199         if (result < 0) {
200                 dev_err(dev, "cannot establish cluster reservation: %d\n",
201                         result);
202                 goto error_rsv_establish;
203         }
204
205         result = wusbhc_devconnect_start(wusbhc);
206         if (result < 0) {
207                 dev_err(dev, "error enabling device connections: %d\n", result);
208                 goto error_devconnect_start;
209         }
210
211         result = wusbhc_sec_start(wusbhc);
212         if (result < 0) {
213                 dev_err(dev, "error starting security in the HC: %d\n", result);
214                 goto error_sec_start;
215         }
216         /* FIXME: the choice of the DNTS parameters is somewhat
217          * arbitrary */
218         result = wusbhc->set_num_dnts(wusbhc, 0, 15);
219         if (result < 0) {
220                 dev_err(dev, "Cannot set DNTS parameters: %d\n", result);
221                 goto error_set_num_dnts;
222         }
223         result = wusbhc_mmc_start(wusbhc);
224         if (result < 0) {
225                 dev_err(dev, "error starting wusbch: %d\n", result);
226                 goto error_wusbhc_start;
227         }
228
229         return 0;
230
231 error_wusbhc_start:
232         wusbhc_sec_stop(wusbhc);
233 error_set_num_dnts:
234 error_sec_start:
235         wusbhc_devconnect_stop(wusbhc);
236 error_devconnect_start:
237         wusbhc_rsv_terminate(wusbhc);
238 error_rsv_establish:
239         return result;
240 }
241
242 /*
243  * wusbhc_stop - stop transmitting MMCs
244  * @wusbhc: the HC to stop
245  *
246  * Stops the WUSB channel and removes the cluster reservation.
247  */
248 void wusbhc_stop(struct wusbhc *wusbhc)
249 {
250         wusbhc_mmc_stop(wusbhc);
251         wusbhc_sec_stop(wusbhc);
252         wusbhc_devconnect_stop(wusbhc);
253         wusbhc_rsv_terminate(wusbhc);
254 }
255
256 /*
257  * Set/reset/update a new CHID
258  *
259  * Depending on the previous state of the MMCs, start, stop or change
260  * the sent MMC. This effectively switches the host controller on and
261  * off (radio wise).
262  */
263 int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
264 {
265         int result = 0;
266
267         if (memcmp(chid, &wusb_ckhdid_zero, sizeof(*chid)) == 0)
268                 chid = NULL;
269
270         mutex_lock(&wusbhc->mutex);
271         if (chid) {
272                 if (wusbhc->active) {
273                         mutex_unlock(&wusbhc->mutex);
274                         return -EBUSY;
275                 }
276                 wusbhc->chid = *chid;
277         }
278         mutex_unlock(&wusbhc->mutex);
279
280         if (chid)
281                 result = uwb_radio_start(&wusbhc->pal);
282         else
283                 uwb_radio_stop(&wusbhc->pal);
284         return result;
285 }
286 EXPORT_SYMBOL_GPL(wusbhc_chid_set);