1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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#include <linux/export.h>
40
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
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_ie_release(rc);
85 kfree(rc);
86}
87
88
89void uwb_rc_init(struct uwb_rc *rc)
90{
91 struct uwb_dev *uwb_dev = &rc->uwb_dev;
92
93 uwb_dev_init(uwb_dev);
94 rc->uwb_dev.dev.class = &uwb_rc_class;
95 rc->uwb_dev.dev.release = uwb_rc_sys_release;
96 uwb_rc_neh_create(rc);
97 rc->beaconing = -1;
98 rc->scan_type = UWB_SCAN_DISABLED;
99 INIT_LIST_HEAD(&rc->notifs_chain.list);
100 mutex_init(&rc->notifs_chain.mutex);
101 INIT_LIST_HEAD(&rc->uwb_beca.list);
102 mutex_init(&rc->uwb_beca.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
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
149
150
151
152
153
154
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;
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_radio_setup(rc);
195 if (result < 0) {
196 dev_err(dev, "cannot setup 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 }
214 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
232
233
234
235
236
237
238
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 init_waitqueue_head(&rc->uwbd.wq);
254 INIT_LIST_HEAD(&rc->uwbd.event_list);
255 spin_lock_init(&rc->uwbd.event_list_lock);
256
257 uwbd_start(rc);
258
259 result = rc->start(rc);
260 if (result < 0)
261 goto error_rc_start;
262
263 result = uwb_rc_setup(rc);
264 if (result < 0) {
265 dev_err(dev, "cannot setup UWB radio controller: %d\n", result);
266 goto error_rc_setup;
267 }
268
269 result = uwb_dev_add(&rc->uwb_dev, parent_dev, rc);
270 if (result < 0 && result != -EADDRNOTAVAIL)
271 goto error_dev_add;
272
273 result = uwb_rc_sys_add(rc);
274 if (result < 0) {
275 dev_err(parent_dev, "cannot register UWB radio controller "
276 "dev attributes: %d\n", result);
277 goto error_sys_add;
278 }
279
280 uwb_mac_addr_print(macbuf, sizeof(macbuf), &rc->uwb_dev.mac_addr);
281 uwb_dev_addr_print(devbuf, sizeof(devbuf), &rc->uwb_dev.dev_addr);
282 dev_info(dev,
283 "new uwb radio controller (mac %s dev %s) on %s %s\n",
284 macbuf, devbuf, parent_dev->bus->name, dev_name(parent_dev));
285 rc->ready = 1;
286 return 0;
287
288error_sys_add:
289 uwb_dev_rm(&rc->uwb_dev);
290error_dev_add:
291error_rc_setup:
292 rc->stop(rc);
293error_rc_start:
294 uwbd_stop(rc);
295 return result;
296}
297EXPORT_SYMBOL_GPL(uwb_rc_add);
298
299
300static int uwb_dev_offair_helper(struct device *dev, void *priv)
301{
302 struct uwb_dev *uwb_dev = to_uwb_dev(dev);
303
304 return __uwb_dev_offair(uwb_dev, uwb_dev->rc);
305}
306
307
308
309
310void uwb_rc_rm(struct uwb_rc *rc)
311{
312 rc->ready = 0;
313
314 uwb_dbg_del_rc(rc);
315 uwb_rsv_remove_all(rc);
316 uwb_radio_shutdown(rc);
317
318 rc->stop(rc);
319
320 uwbd_stop(rc);
321 uwb_rc_neh_destroy(rc);
322
323 uwb_dev_lock(&rc->uwb_dev);
324 rc->priv = NULL;
325 rc->cmd = NULL;
326 uwb_dev_unlock(&rc->uwb_dev);
327 mutex_lock(&rc->uwb_beca.mutex);
328 uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
329 __uwb_rc_sys_rm(rc);
330 mutex_unlock(&rc->uwb_beca.mutex);
331 uwb_rsv_cleanup(rc);
332 uwb_beca_release(rc);
333 uwb_dev_rm(&rc->uwb_dev);
334}
335EXPORT_SYMBOL_GPL(uwb_rc_rm);
336
337static int find_rc_try_get(struct device *dev, void *data)
338{
339 struct uwb_rc *target_rc = data;
340 struct uwb_rc *rc = dev_get_drvdata(dev);
341
342 if (rc == NULL) {
343 WARN_ON(1);
344 return 0;
345 }
346 if (rc == target_rc) {
347 if (rc->ready == 0)
348 return 0;
349 else
350 return 1;
351 }
352 return 0;
353}
354
355
356
357
358
359
360
361struct uwb_rc *__uwb_rc_try_get(struct uwb_rc *target_rc)
362{
363 struct device *dev;
364 struct uwb_rc *rc = NULL;
365
366 dev = class_find_device(&uwb_rc_class, NULL, target_rc,
367 find_rc_try_get);
368 if (dev) {
369 rc = dev_get_drvdata(dev);
370 __uwb_rc_get(rc);
371 }
372 return rc;
373}
374EXPORT_SYMBOL_GPL(__uwb_rc_try_get);
375
376
377
378
379
380
381static inline struct uwb_rc *uwb_rc_get(struct uwb_rc *rc)
382{
383 if (rc->ready == 0)
384 return NULL;
385 uwb_dev_get(&rc->uwb_dev);
386 return rc;
387}
388
389static int find_rc_grandpa(struct device *dev, void *data)
390{
391 struct device *grandpa_dev = data;
392 struct uwb_rc *rc = dev_get_drvdata(dev);
393
394 if (rc->uwb_dev.dev.parent->parent == grandpa_dev) {
395 rc = uwb_rc_get(rc);
396 return 1;
397 }
398 return 0;
399}
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *grandpa_dev)
418{
419 struct device *dev;
420 struct uwb_rc *rc = NULL;
421
422 dev = class_find_device(&uwb_rc_class, NULL, (void *)grandpa_dev,
423 find_rc_grandpa);
424 if (dev)
425 rc = dev_get_drvdata(dev);
426 return rc;
427}
428EXPORT_SYMBOL_GPL(uwb_rc_get_by_grandpa);
429
430
431
432
433
434
435static int find_rc_dev(struct device *dev, void *data)
436{
437 struct uwb_dev_addr *addr = data;
438 struct uwb_rc *rc = dev_get_drvdata(dev);
439
440 if (rc == NULL) {
441 WARN_ON(1);
442 return 0;
443 }
444 if (!uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, addr)) {
445 rc = uwb_rc_get(rc);
446 return 1;
447 }
448 return 0;
449}
450
451struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *addr)
452{
453 struct device *dev;
454 struct uwb_rc *rc = NULL;
455
456 dev = class_find_device(&uwb_rc_class, NULL, (void *)addr,
457 find_rc_dev);
458 if (dev)
459 rc = dev_get_drvdata(dev);
460
461 return rc;
462}
463EXPORT_SYMBOL_GPL(uwb_rc_get_by_dev);
464
465
466
467
468
469
470
471void uwb_rc_put(struct uwb_rc *rc)
472{
473 __uwb_rc_put(rc);
474}
475EXPORT_SYMBOL_GPL(uwb_rc_put);
476