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