blob: ee5772f00d4269e6eca5c2125a3701360880824a [file] [log] [blame]
Inaky Perez-Gonzalez183b9b52008-09-17 16:34:06 +01001/*
2 * Ultra Wide Band
3 * Life cycle of radio controllers
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 * FIXME: docs
24 *
25 * A UWB radio controller is also a UWB device, so it embeds one...
26 *
27 * List of RCs comes from the 'struct class uwb_rc_class'.
28 */
29
30#include <linux/kernel.h>
31#include <linux/string.h>
32#include <linux/device.h>
33#include <linux/err.h>
34#include <linux/random.h>
35#include <linux/kdev_t.h>
36#include <linux/etherdevice.h>
37#include <linux/usb.h>
38
39#define D_LOCAL 1
40#include <linux/uwb/debug.h>
41#include "uwb-internal.h"
42
43static int uwb_rc_index_match(struct device *dev, void *data)
44{
45 int *index = data;
46 struct uwb_rc *rc = dev_get_drvdata(dev);
47
48 if (rc->index == *index)
49 return 1;
50 return 0;
51}
52
53static struct uwb_rc *uwb_rc_find_by_index(int index)
54{
55 struct device *dev;
56 struct uwb_rc *rc = NULL;
57
58 dev = class_find_device(&uwb_rc_class, NULL, &index, uwb_rc_index_match);
59 if (dev)
60 rc = dev_get_drvdata(dev);
61 return rc;
62}
63
64static int uwb_rc_new_index(void)
65{
66 int index = 0;
67
68 for (;;) {
69 if (!uwb_rc_find_by_index(index))
70 return index;
71 if (++index < 0)
72 index = 0;
73 }
74}
75
76/**
77 * Release the backing device of a uwb_rc that has been dynamically allocated.
78 */
79static void uwb_rc_sys_release(struct device *dev)
80{
81 struct uwb_dev *uwb_dev = container_of(dev, struct uwb_dev, dev);
82 struct uwb_rc *rc = container_of(uwb_dev, struct uwb_rc, uwb_dev);
83
84 uwb_rc_neh_destroy(rc);
85 uwb_rc_ie_release(rc);
86 d_printf(1, dev, "freed uwb_rc %p\n", rc);
87 kfree(rc);
88}
89
90
91void uwb_rc_init(struct uwb_rc *rc)
92{
93 struct uwb_dev *uwb_dev = &rc->uwb_dev;
94
95 uwb_dev_init(uwb_dev);
96 rc->uwb_dev.dev.class = &uwb_rc_class;
97 rc->uwb_dev.dev.release = uwb_rc_sys_release;
98 uwb_rc_neh_create(rc);
99 rc->beaconing = -1;
100 rc->scan_type = UWB_SCAN_DISABLED;
101 INIT_LIST_HEAD(&rc->notifs_chain.list);
102 mutex_init(&rc->notifs_chain.mutex);
103 uwb_drp_avail_init(rc);
104 uwb_rc_ie_init(rc);
105 uwb_rsv_init(rc);
106 uwb_rc_pal_init(rc);
107}
108EXPORT_SYMBOL_GPL(uwb_rc_init);
109
110
111struct uwb_rc *uwb_rc_alloc(void)
112{
113 struct uwb_rc *rc;
114 rc = kzalloc(sizeof(*rc), GFP_KERNEL);
115 if (rc == NULL)
116 return NULL;
117 uwb_rc_init(rc);
118 return rc;
119}
120EXPORT_SYMBOL_GPL(uwb_rc_alloc);
121
122static struct attribute *rc_attrs[] = {
123 &dev_attr_mac_address.attr,
124 &dev_attr_scan.attr,
125 &dev_attr_beacon.attr,
126 NULL,
127};
128
129static struct attribute_group rc_attr_group = {
130 .attrs = rc_attrs,
131};
132
133/*
134 * Registration of sysfs specific stuff
135 */
136static int uwb_rc_sys_add(struct uwb_rc *rc)
137{
138 return sysfs_create_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
139}
140
141
142static void __uwb_rc_sys_rm(struct uwb_rc *rc)
143{
144 sysfs_remove_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
145}
146
147/**
148 * uwb_rc_mac_addr_setup - get an RC's EUI-48 address or set it
149 * @rc: the radio controller.
150 *
151 * If the EUI-48 address is 00:00:00:00:00:00 or FF:FF:FF:FF:FF:FF
152 * then a random locally administered EUI-48 is generated and set on
153 * the device. The probability of address collisions is sufficiently
154 * unlikely (1/2^40 = 9.1e-13) that they're not checked for.
155 */
156static
157int uwb_rc_mac_addr_setup(struct uwb_rc *rc)
158{
159 int result;
160 struct device *dev = &rc->uwb_dev.dev;
161 struct uwb_dev *uwb_dev = &rc->uwb_dev;
162 char devname[UWB_ADDR_STRSIZE];
163 struct uwb_mac_addr addr;
164
165 result = uwb_rc_mac_addr_get(rc, &addr);
166 if (result < 0) {
167 dev_err(dev, "cannot retrieve UWB EUI-48 address: %d\n", result);
168 return result;
169 }
170
171 if (uwb_mac_addr_unset(&addr) || uwb_mac_addr_bcast(&addr)) {
172 addr.data[0] = 0x02; /* locally adminstered and unicast */
173 get_random_bytes(&addr.data[1], sizeof(addr.data)-1);
174
175 result = uwb_rc_mac_addr_set(rc, &addr);
176 if (result < 0) {
177 uwb_mac_addr_print(devname, sizeof(devname), &addr);
178 dev_err(dev, "cannot set EUI-48 address %s: %d\n",
179 devname, result);
180 return result;
181 }
182 }
183 uwb_dev->mac_addr = addr;
184 return 0;
185}
186
187
188
189static int uwb_rc_setup(struct uwb_rc *rc)
190{
191 int result;
192 struct device *dev = &rc->uwb_dev.dev;
193
194 result = uwb_rc_reset(rc);
195 if (result < 0) {
196 dev_err(dev, "cannot reset UWB radio: %d\n", result);
197 goto error;
198 }
199 result = uwb_rc_mac_addr_setup(rc);
200 if (result < 0) {
201 dev_err(dev, "cannot setup UWB MAC address: %d\n", result);
202 goto error;
203 }
204 result = uwb_rc_dev_addr_assign(rc);
205 if (result < 0) {
206 dev_err(dev, "cannot assign UWB DevAddr: %d\n", result);
207 goto error;
208 }
209 result = uwb_rc_ie_setup(rc);
210 if (result < 0) {
211 dev_err(dev, "cannot setup IE subsystem: %d\n", result);
212 goto error_ie_setup;
213 }
Inaky Perez-Gonzalez183b9b52008-09-17 16:34:06 +0100214 result = uwb_rsv_setup(rc);
215 if (result < 0) {
216 dev_err(dev, "cannot setup reservation subsystem: %d\n", result);
217 goto error_rsv_setup;
218 }
219 uwb_dbg_add_rc(rc);
220 return 0;
221
222error_rsv_setup:
223 uwb_rc_ie_release(rc);
224error_ie_setup:
225error:
226 return result;
227}
228
229
230/**
231 * Register a new UWB radio controller
232 *
233 * Did you call uwb_rc_init() on your rc?
234 *
235 * We assume that this is being called with a > 0 refcount on
236 * it [through ops->{get|put}_device(). We'll take our own, though.
237 *
238 * @parent_dev is our real device, the one that provides the actual UWB device
239 */
240int uwb_rc_add(struct uwb_rc *rc, struct device *parent_dev, void *priv)
241{
242 int result;
243 struct device *dev;
244 char macbuf[UWB_ADDR_STRSIZE], devbuf[UWB_ADDR_STRSIZE];
245
246 rc->index = uwb_rc_new_index();
247
248 dev = &rc->uwb_dev.dev;
249 dev_set_name(dev, "uwb%d", rc->index);
250
251 rc->priv = priv;
252
253 result = rc->start(rc);
254 if (result < 0)
255 goto error_rc_start;
256
257 result = uwb_rc_setup(rc);
258 if (result < 0) {
259 dev_err(dev, "cannot setup UWB radio controller: %d\n", result);
260 goto error_rc_setup;
261 }
262
263 result = uwb_dev_add(&rc->uwb_dev, parent_dev, rc);
264 if (result < 0 && result != -EADDRNOTAVAIL)
265 goto error_dev_add;
266
267 result = uwb_rc_sys_add(rc);
268 if (result < 0) {
269 dev_err(parent_dev, "cannot register UWB radio controller "
270 "dev attributes: %d\n", result);
271 goto error_sys_add;
272 }
273
274 uwb_mac_addr_print(macbuf, sizeof(macbuf), &rc->uwb_dev.mac_addr);
275 uwb_dev_addr_print(devbuf, sizeof(devbuf), &rc->uwb_dev.dev_addr);
276 dev_info(dev,
277 "new uwb radio controller (mac %s dev %s) on %s %s\n",
278 macbuf, devbuf, parent_dev->bus->name, dev_name(parent_dev));
279 rc->ready = 1;
280 return 0;
281
282error_sys_add:
283 uwb_dev_rm(&rc->uwb_dev);
284error_dev_add:
285error_rc_setup:
286 rc->stop(rc);
287 uwbd_flush(rc);
288error_rc_start:
289 return result;
290}
291EXPORT_SYMBOL_GPL(uwb_rc_add);
292
293
294static int uwb_dev_offair_helper(struct device *dev, void *priv)
295{
296 struct uwb_dev *uwb_dev = to_uwb_dev(dev);
297
298 return __uwb_dev_offair(uwb_dev, uwb_dev->rc);
299}
300
301/*
302 * Remove a Radio Controller; stop beaconing/scanning, disconnect all children
303 */
304void uwb_rc_rm(struct uwb_rc *rc)
305{
306 rc->ready = 0;
307
308 uwb_dbg_del_rc(rc);
309 uwb_rsv_cleanup(rc);
310 uwb_rc_ie_rm(rc, UWB_IDENTIFICATION_IE);
311 if (rc->beaconing >= 0)
312 uwb_rc_beacon(rc, -1, 0);
313 if (rc->scan_type != UWB_SCAN_DISABLED)
314 uwb_rc_scan(rc, rc->scanning, UWB_SCAN_DISABLED, 0);
315 uwb_rc_reset(rc);
316
317 rc->stop(rc);
318 uwbd_flush(rc);
319
320 uwb_dev_lock(&rc->uwb_dev);
321 rc->priv = NULL;
322 rc->cmd = NULL;
323 uwb_dev_unlock(&rc->uwb_dev);
324 mutex_lock(&uwb_beca.mutex);
325 uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
326 __uwb_rc_sys_rm(rc);
327 mutex_unlock(&uwb_beca.mutex);
328 uwb_dev_rm(&rc->uwb_dev);
329}
330EXPORT_SYMBOL_GPL(uwb_rc_rm);
331
332static int find_rc_try_get(struct device *dev, void *data)
333{
334 struct uwb_rc *target_rc = data;
335 struct uwb_rc *rc = dev_get_drvdata(dev);
336
337 if (rc == NULL) {
338 WARN_ON(1);
339 return 0;
340 }
341 if (rc == target_rc) {
342 if (rc->ready == 0)
343 return 0;
344 else
345 return 1;
346 }
347 return 0;
348}
349
350/**
351 * Given a radio controller descriptor, validate and refcount it
352 *
353 * @returns NULL if the rc does not exist or is quiescing; the ptr to
354 * it otherwise.
355 */
356struct uwb_rc *__uwb_rc_try_get(struct uwb_rc *target_rc)
357{
358 struct device *dev;
359 struct uwb_rc *rc = NULL;
360
361 dev = class_find_device(&uwb_rc_class, NULL, target_rc,
362 find_rc_try_get);
363 if (dev) {
364 rc = dev_get_drvdata(dev);
365 __uwb_rc_get(rc);
366 }
367 return rc;
368}
369EXPORT_SYMBOL_GPL(__uwb_rc_try_get);
370
371/*
372 * RC get for external refcount acquirers...
373 *
374 * Increments the refcount of the device and it's backend modules
375 */
376static inline struct uwb_rc *uwb_rc_get(struct uwb_rc *rc)
377{
378 if (rc->ready == 0)
379 return NULL;
380 uwb_dev_get(&rc->uwb_dev);
381 return rc;
382}
383
384static int find_rc_grandpa(struct device *dev, void *data)
385{
386 struct device *grandpa_dev = data;
387 struct uwb_rc *rc = dev_get_drvdata(dev);
388
389 if (rc->uwb_dev.dev.parent->parent == grandpa_dev) {
390 rc = uwb_rc_get(rc);
391 return 1;
392 }
393 return 0;
394}
395
396/**
397 * Locate and refcount a radio controller given a common grand-parent
398 *
399 * @grandpa_dev Pointer to the 'grandparent' device structure.
400 * @returns NULL If the rc does not exist or is quiescing; the ptr to
401 * it otherwise, properly referenced.
402 *
403 * The Radio Control interface (or the UWB Radio Controller) is always
404 * an interface of a device. The parent is the interface, the
405 * grandparent is the device that encapsulates the interface.
406 *
407 * There is no need to lock around as the "grandpa" would be
408 * refcounted by the target, and to remove the referemes, the
409 * uwb_rc_class->sem would have to be taken--we hold it, ergo we
410 * should be safe.
411 */
412struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *grandpa_dev)
413{
414 struct device *dev;
415 struct uwb_rc *rc = NULL;
416
417 dev = class_find_device(&uwb_rc_class, NULL, (void *)grandpa_dev,
418 find_rc_grandpa);
419 if (dev)
420 rc = dev_get_drvdata(dev);
421 return rc;
422}
423EXPORT_SYMBOL_GPL(uwb_rc_get_by_grandpa);
424
425/**
426 * Find a radio controller by device address
427 *
428 * @returns the pointer to the radio controller, properly referenced
429 */
430static int find_rc_dev(struct device *dev, void *data)
431{
432 struct uwb_dev_addr *addr = data;
433 struct uwb_rc *rc = dev_get_drvdata(dev);
434
435 if (rc == NULL) {
436 WARN_ON(1);
437 return 0;
438 }
439 if (!uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, addr)) {
440 rc = uwb_rc_get(rc);
441 return 1;
442 }
443 return 0;
444}
445
446struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *addr)
447{
448 struct device *dev;
449 struct uwb_rc *rc = NULL;
450
451 dev = class_find_device(&uwb_rc_class, NULL, (void *)addr,
452 find_rc_dev);
453 if (dev)
454 rc = dev_get_drvdata(dev);
455
456 return rc;
457}
458EXPORT_SYMBOL_GPL(uwb_rc_get_by_dev);
459
460/**
461 * Drop a reference on a radio controller
462 *
463 * This is the version that should be done by entities external to the
464 * UWB Radio Control stack (ie: clients of the API).
465 */
466void uwb_rc_put(struct uwb_rc *rc)
467{
468 __uwb_rc_put(rc);
469}
470EXPORT_SYMBOL_GPL(uwb_rc_put);
471
472/*
473 *
474 *
475 */
476ssize_t uwb_rc_print_IEs(struct uwb_rc *uwb_rc, char *buf, size_t size)
477{
478 ssize_t result;
479 struct uwb_rc_evt_get_ie *ie_info;
480 struct uwb_buf_ctx ctx;
481
482 result = uwb_rc_get_ie(uwb_rc, &ie_info);
483 if (result < 0)
484 goto error_get_ie;
485 ctx.buf = buf;
486 ctx.size = size;
487 ctx.bytes = 0;
488 uwb_ie_for_each(&uwb_rc->uwb_dev, uwb_ie_dump_hex, &ctx,
489 ie_info->IEData, result - sizeof(*ie_info));
490 result = ctx.bytes;
491 kfree(ie_info);
492error_get_ie:
493 return result;
494}
495