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