1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2007, 2008, 2009 Siemens AG
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 /* name for sysfs, %d is appended */
20 #define PHY_NAME "phy"
21
22 /* RCU-protected (and RTNL for writers) */
23 LIST_HEAD(cfg802154_rdev_list);
24 int cfg802154_rdev_list_generation;
25
wpan_phy_find(const char * str)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
wpan_phy_iter(struct device * dev,void * _data)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
wpan_phy_for_each(int (* fn)(struct wpan_phy * phy,void * data),void * data)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 *
cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)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
wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)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 *
wpan_phy_new(const struct cfg802154_ops * ops,size_t priv_size)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 /* ugh, wrapped! */
114 atomic_dec(&wpan_phy_counter);
115 kfree(rdev);
116 return NULL;
117 }
118
119 /* atomic_inc_return makes it start at 1, make it start at 0 */
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 init_waitqueue_head(&rdev->wpan_phy.sync_txq);
133
134 spin_lock_init(&rdev->wpan_phy.queue_lock);
135
136 return &rdev->wpan_phy;
137 }
138 EXPORT_SYMBOL(wpan_phy_new);
139
wpan_phy_register(struct wpan_phy * phy)140 int wpan_phy_register(struct wpan_phy *phy)
141 {
142 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
143 int ret;
144
145 rtnl_lock();
146 ret = device_add(&phy->dev);
147 if (ret) {
148 rtnl_unlock();
149 return ret;
150 }
151
152 list_add_rcu(&rdev->list, &cfg802154_rdev_list);
153 cfg802154_rdev_list_generation++;
154
155 /* TODO phy registered lock */
156 rtnl_unlock();
157
158 /* TODO nl802154 phy notify */
159
160 return 0;
161 }
162 EXPORT_SYMBOL(wpan_phy_register);
163
wpan_phy_unregister(struct wpan_phy * phy)164 void wpan_phy_unregister(struct wpan_phy *phy)
165 {
166 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
167
168 wait_event(rdev->dev_wait, ({
169 int __count;
170 rtnl_lock();
171 __count = rdev->opencount;
172 rtnl_unlock();
173 __count == 0; }));
174
175 rtnl_lock();
176 /* TODO nl802154 phy notify */
177 /* TODO phy registered lock */
178
179 WARN_ON(!list_empty(&rdev->wpan_dev_list));
180
181 /* First remove the hardware from everywhere, this makes
182 * it impossible to find from userspace.
183 */
184 list_del_rcu(&rdev->list);
185 synchronize_rcu();
186
187 cfg802154_rdev_list_generation++;
188
189 device_del(&phy->dev);
190
191 rtnl_unlock();
192 }
193 EXPORT_SYMBOL(wpan_phy_unregister);
194
wpan_phy_free(struct wpan_phy * phy)195 void wpan_phy_free(struct wpan_phy *phy)
196 {
197 put_device(&phy->dev);
198 }
199 EXPORT_SYMBOL(wpan_phy_free);
200
cfg802154_switch_netns(struct cfg802154_registered_device * rdev,struct net * net)201 int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
202 struct net *net)
203 {
204 struct wpan_dev *wpan_dev;
205 int err = 0;
206
207 list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
208 if (!wpan_dev->netdev)
209 continue;
210 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
211 err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
212 if (err)
213 break;
214 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
215 }
216
217 if (err) {
218 /* failed -- clean up to old netns */
219 net = wpan_phy_net(&rdev->wpan_phy);
220
221 list_for_each_entry_continue_reverse(wpan_dev,
222 &rdev->wpan_dev_list,
223 list) {
224 if (!wpan_dev->netdev)
225 continue;
226 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
227 err = dev_change_net_namespace(wpan_dev->netdev, net,
228 "wpan%d");
229 WARN_ON(err);
230 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
231 }
232
233 return err;
234 }
235
236 wpan_phy_net_set(&rdev->wpan_phy, net);
237
238 err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
239 WARN_ON(err);
240
241 return 0;
242 }
243
cfg802154_dev_free(struct cfg802154_registered_device * rdev)244 void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
245 {
246 kfree(rdev);
247 }
248
249 static void
cfg802154_update_iface_num(struct cfg802154_registered_device * rdev,int iftype,int num)250 cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
251 int iftype, int num)
252 {
253 ASSERT_RTNL();
254
255 rdev->num_running_ifaces += num;
256 }
257
cfg802154_netdev_notifier_call(struct notifier_block * nb,unsigned long state,void * ptr)258 static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
259 unsigned long state, void *ptr)
260 {
261 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
262 struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
263 struct cfg802154_registered_device *rdev;
264
265 if (!wpan_dev)
266 return NOTIFY_DONE;
267
268 rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
269
270 /* TODO WARN_ON unspec type */
271
272 switch (state) {
273 /* TODO NETDEV_DEVTYPE */
274 case NETDEV_REGISTER:
275 dev->features |= NETIF_F_NETNS_LOCAL;
276 wpan_dev->identifier = ++rdev->wpan_dev_id;
277 list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
278 rdev->devlist_generation++;
279
280 wpan_dev->netdev = dev;
281 break;
282 case NETDEV_DOWN:
283 cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);
284
285 rdev->opencount--;
286 wake_up(&rdev->dev_wait);
287 break;
288 case NETDEV_UP:
289 cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);
290
291 rdev->opencount++;
292 break;
293 case NETDEV_UNREGISTER:
294 /* It is possible to get NETDEV_UNREGISTER
295 * multiple times. To detect that, check
296 * that the interface is still on the list
297 * of registered interfaces, and only then
298 * remove and clean it up.
299 */
300 if (!list_empty(&wpan_dev->list)) {
301 list_del_rcu(&wpan_dev->list);
302 rdev->devlist_generation++;
303 }
304 /* synchronize (so that we won't find this netdev
305 * from other code any more) and then clear the list
306 * head so that the above code can safely check for
307 * !list_empty() to avoid double-cleanup.
308 */
309 synchronize_rcu();
310 INIT_LIST_HEAD(&wpan_dev->list);
311 break;
312 default:
313 return NOTIFY_DONE;
314 }
315
316 return NOTIFY_OK;
317 }
318
319 static struct notifier_block cfg802154_netdev_notifier = {
320 .notifier_call = cfg802154_netdev_notifier_call,
321 };
322
cfg802154_pernet_exit(struct net * net)323 static void __net_exit cfg802154_pernet_exit(struct net *net)
324 {
325 struct cfg802154_registered_device *rdev;
326
327 rtnl_lock();
328 list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
329 if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
330 WARN_ON(cfg802154_switch_netns(rdev, &init_net));
331 }
332 rtnl_unlock();
333 }
334
335 static struct pernet_operations cfg802154_pernet_ops = {
336 .exit = cfg802154_pernet_exit,
337 };
338
wpan_phy_class_init(void)339 static int __init wpan_phy_class_init(void)
340 {
341 int rc;
342
343 rc = register_pernet_device(&cfg802154_pernet_ops);
344 if (rc)
345 goto err;
346
347 rc = wpan_phy_sysfs_init();
348 if (rc)
349 goto err_sysfs;
350
351 rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
352 if (rc)
353 goto err_nl;
354
355 rc = ieee802154_nl_init();
356 if (rc)
357 goto err_notifier;
358
359 rc = nl802154_init();
360 if (rc)
361 goto err_ieee802154_nl;
362
363 return 0;
364
365 err_ieee802154_nl:
366 ieee802154_nl_exit();
367
368 err_notifier:
369 unregister_netdevice_notifier(&cfg802154_netdev_notifier);
370 err_nl:
371 wpan_phy_sysfs_exit();
372 err_sysfs:
373 unregister_pernet_device(&cfg802154_pernet_ops);
374 err:
375 return rc;
376 }
377 subsys_initcall(wpan_phy_class_init);
378
wpan_phy_class_exit(void)379 static void __exit wpan_phy_class_exit(void)
380 {
381 nl802154_exit();
382 ieee802154_nl_exit();
383 unregister_netdevice_notifier(&cfg802154_netdev_notifier);
384 wpan_phy_sysfs_exit();
385 unregister_pernet_device(&cfg802154_pernet_ops);
386 }
387 module_exit(wpan_phy_class_exit);
388
389 MODULE_LICENSE("GPL v2");
390 MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
391 MODULE_AUTHOR("Dmitry Eremin-Solenikov");
392