1
2
3
4
5
6#include <linux/slab.h>
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/device.h>
10
11#include <net/cfg802154.h>
12#include <net/rtnetlink.h>
13
14#include "ieee802154.h"
15#include "nl802154.h"
16#include "sysfs.h"
17#include "core.h"
18
19
20#define PHY_NAME "phy"
21
22
23LIST_HEAD(cfg802154_rdev_list);
24int cfg802154_rdev_list_generation;
25
26static int wpan_phy_match(struct device *dev, const void *data)
27{
28 return !strcmp(dev_name(dev), (const char *)data);
29}
30
31struct wpan_phy *wpan_phy_find(const char *str)
32{
33 struct device *dev;
34
35 if (WARN_ON(!str))
36 return NULL;
37
38 dev = class_find_device(&wpan_phy_class, NULL, str, wpan_phy_match);
39 if (!dev)
40 return NULL;
41
42 return container_of(dev, struct wpan_phy, dev);
43}
44EXPORT_SYMBOL(wpan_phy_find);
45
46struct wpan_phy_iter_data {
47 int (*fn)(struct wpan_phy *phy, void *data);
48 void *data;
49};
50
51static int wpan_phy_iter(struct device *dev, void *_data)
52{
53 struct wpan_phy_iter_data *wpid = _data;
54 struct wpan_phy *phy = container_of(dev, struct wpan_phy, dev);
55
56 return wpid->fn(phy, wpid->data);
57}
58
59int wpan_phy_for_each(int (*fn)(struct wpan_phy *phy, void *data),
60 void *data)
61{
62 struct wpan_phy_iter_data wpid = {
63 .fn = fn,
64 .data = data,
65 };
66
67 return class_for_each_device(&wpan_phy_class, NULL,
68 &wpid, wpan_phy_iter);
69}
70EXPORT_SYMBOL(wpan_phy_for_each);
71
72struct cfg802154_registered_device *
73cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)
74{
75 struct cfg802154_registered_device *result = NULL, *rdev;
76
77 ASSERT_RTNL();
78
79 list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
80 if (rdev->wpan_phy_idx == wpan_phy_idx) {
81 result = rdev;
82 break;
83 }
84 }
85
86 return result;
87}
88
89struct wpan_phy *wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)
90{
91 struct cfg802154_registered_device *rdev;
92
93 ASSERT_RTNL();
94
95 rdev = cfg802154_rdev_by_wpan_phy_idx(wpan_phy_idx);
96 if (!rdev)
97 return NULL;
98 return &rdev->wpan_phy;
99}
100
101struct wpan_phy *
102wpan_phy_new(const struct cfg802154_ops *ops, size_t priv_size)
103{
104 static atomic_t wpan_phy_counter = ATOMIC_INIT(0);
105 struct cfg802154_registered_device *rdev;
106 size_t alloc_size;
107
108 alloc_size = sizeof(*rdev) + priv_size;
109 rdev = kzalloc(alloc_size, GFP_KERNEL);
110 if (!rdev)
111 return NULL;
112
113 rdev->ops = ops;
114
115 rdev->wpan_phy_idx = atomic_inc_return(&wpan_phy_counter);
116
117 if (unlikely(rdev->wpan_phy_idx < 0)) {
118
119 atomic_dec(&wpan_phy_counter);
120 kfree(rdev);
121 return NULL;
122 }
123
124
125 rdev->wpan_phy_idx--;
126
127 INIT_LIST_HEAD(&rdev->wpan_dev_list);
128 device_initialize(&rdev->wpan_phy.dev);
129 dev_set_name(&rdev->wpan_phy.dev, PHY_NAME "%d", rdev->wpan_phy_idx);
130
131 rdev->wpan_phy.dev.class = &wpan_phy_class;
132 rdev->wpan_phy.dev.platform_data = rdev;
133
134 wpan_phy_net_set(&rdev->wpan_phy, &init_net);
135
136 init_waitqueue_head(&rdev->dev_wait);
137
138 return &rdev->wpan_phy;
139}
140EXPORT_SYMBOL(wpan_phy_new);
141
142int wpan_phy_register(struct wpan_phy *phy)
143{
144 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
145 int ret;
146
147 rtnl_lock();
148 ret = device_add(&phy->dev);
149 if (ret) {
150 rtnl_unlock();
151 return ret;
152 }
153
154 list_add_rcu(&rdev->list, &cfg802154_rdev_list);
155 cfg802154_rdev_list_generation++;
156
157
158 rtnl_unlock();
159
160
161
162 return 0;
163}
164EXPORT_SYMBOL(wpan_phy_register);
165
166void wpan_phy_unregister(struct wpan_phy *phy)
167{
168 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
169
170 wait_event(rdev->dev_wait, ({
171 int __count;
172 rtnl_lock();
173 __count = rdev->opencount;
174 rtnl_unlock();
175 __count == 0; }));
176
177 rtnl_lock();
178
179
180
181 WARN_ON(!list_empty(&rdev->wpan_dev_list));
182
183
184
185
186 list_del_rcu(&rdev->list);
187 synchronize_rcu();
188
189 cfg802154_rdev_list_generation++;
190
191 device_del(&phy->dev);
192
193 rtnl_unlock();
194}
195EXPORT_SYMBOL(wpan_phy_unregister);
196
197void wpan_phy_free(struct wpan_phy *phy)
198{
199 put_device(&phy->dev);
200}
201EXPORT_SYMBOL(wpan_phy_free);
202
203int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
204 struct net *net)
205{
206 struct wpan_dev *wpan_dev;
207 int err = 0;
208
209 list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
210 if (!wpan_dev->netdev)
211 continue;
212 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
213 err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
214 if (err)
215 break;
216 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
217 }
218
219 if (err) {
220
221 net = wpan_phy_net(&rdev->wpan_phy);
222
223 list_for_each_entry_continue_reverse(wpan_dev,
224 &rdev->wpan_dev_list,
225 list) {
226 if (!wpan_dev->netdev)
227 continue;
228 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
229 err = dev_change_net_namespace(wpan_dev->netdev, net,
230 "wpan%d");
231 WARN_ON(err);
232 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
233 }
234
235 return err;
236 }
237
238 wpan_phy_net_set(&rdev->wpan_phy, net);
239
240 err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
241 WARN_ON(err);
242
243 return 0;
244}
245
246void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
247{
248 kfree(rdev);
249}
250
251static void
252cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
253 int iftype, int num)
254{
255 ASSERT_RTNL();
256
257 rdev->num_running_ifaces += num;
258}
259
260static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
261 unsigned long state, void *ptr)
262{
263 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
264 struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
265 struct cfg802154_registered_device *rdev;
266
267 if (!wpan_dev)
268 return NOTIFY_DONE;
269
270 rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
271
272
273
274 switch (state) {
275
276 case NETDEV_REGISTER:
277 dev->features |= NETIF_F_NETNS_LOCAL;
278 wpan_dev->identifier = ++rdev->wpan_dev_id;
279 list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
280 rdev->devlist_generation++;
281
282 wpan_dev->netdev = dev;
283 break;
284 case NETDEV_DOWN:
285 cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);
286
287 rdev->opencount--;
288 wake_up(&rdev->dev_wait);
289 break;
290 case NETDEV_UP:
291 cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);
292
293 rdev->opencount++;
294 break;
295 case NETDEV_UNREGISTER:
296
297
298
299
300
301
302 if (!list_empty(&wpan_dev->list)) {
303 list_del_rcu(&wpan_dev->list);
304 rdev->devlist_generation++;
305 }
306
307
308
309
310
311 synchronize_rcu();
312 INIT_LIST_HEAD(&wpan_dev->list);
313 break;
314 default:
315 return NOTIFY_DONE;
316 }
317
318 return NOTIFY_OK;
319}
320
321static struct notifier_block cfg802154_netdev_notifier = {
322 .notifier_call = cfg802154_netdev_notifier_call,
323};
324
325static void __net_exit cfg802154_pernet_exit(struct net *net)
326{
327 struct cfg802154_registered_device *rdev;
328
329 rtnl_lock();
330 list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
331 if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
332 WARN_ON(cfg802154_switch_netns(rdev, &init_net));
333 }
334 rtnl_unlock();
335}
336
337static struct pernet_operations cfg802154_pernet_ops = {
338 .exit = cfg802154_pernet_exit,
339};
340
341static int __init wpan_phy_class_init(void)
342{
343 int rc;
344
345 rc = register_pernet_device(&cfg802154_pernet_ops);
346 if (rc)
347 goto err;
348
349 rc = wpan_phy_sysfs_init();
350 if (rc)
351 goto err_sysfs;
352
353 rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
354 if (rc)
355 goto err_nl;
356
357 rc = ieee802154_nl_init();
358 if (rc)
359 goto err_notifier;
360
361 rc = nl802154_init();
362 if (rc)
363 goto err_ieee802154_nl;
364
365 return 0;
366
367err_ieee802154_nl:
368 ieee802154_nl_exit();
369
370err_notifier:
371 unregister_netdevice_notifier(&cfg802154_netdev_notifier);
372err_nl:
373 wpan_phy_sysfs_exit();
374err_sysfs:
375 unregister_pernet_device(&cfg802154_pernet_ops);
376err:
377 return rc;
378}
379subsys_initcall(wpan_phy_class_init);
380
381static void __exit wpan_phy_class_exit(void)
382{
383 nl802154_exit();
384 ieee802154_nl_exit();
385 unregister_netdevice_notifier(&cfg802154_netdev_notifier);
386 wpan_phy_sysfs_exit();
387 unregister_pernet_device(&cfg802154_pernet_ops);
388}
389module_exit(wpan_phy_class_exit);
390
391MODULE_LICENSE("GPL v2");
392MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
393MODULE_AUTHOR("Dmitry Eremin-Solenikov");
394