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