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