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) */
23LIST_HEAD(cfg802154_rdev_list);
24int cfg802154_rdev_list_generation;
25
26struct 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(class: &wpan_phy_class, name: str);
34 if (!dev)
35 return NULL;
36
37 return container_of(dev, struct wpan_phy, dev);
38}
39EXPORT_SYMBOL(wpan_phy_find);
40
41struct wpan_phy_iter_data {
42 int (*fn)(struct wpan_phy *phy, void *data);
43 void *data;
44};
45
46static 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
54int 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(class: &wpan_phy_class, NULL,
63 data: &wpid, fn: wpan_phy_iter);
64}
65EXPORT_SYMBOL(wpan_phy_for_each);
66
67struct cfg802154_registered_device *
68cfg802154_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
84struct 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
96struct wpan_phy *
97wpan_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(size: alloc_size, GFP_KERNEL);
105 if (!rdev)
106 return NULL;
107
108 rdev->ops = ops;
109
110 rdev->wpan_phy_idx = atomic_inc_return(v: &wpan_phy_counter);
111
112 if (unlikely(rdev->wpan_phy_idx < 0)) {
113 /* ugh, wrapped! */
114 atomic_dec(v: &wpan_phy_counter);
115 kfree(objp: 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(list: &rdev->wpan_dev_list);
123 device_initialize(dev: &rdev->wpan_phy.dev);
124 dev_set_name(dev: &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(wpan_phy: &rdev->wpan_phy, net: &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}
138EXPORT_SYMBOL(wpan_phy_new);
139
140int wpan_phy_register(struct wpan_phy *phy)
141{
142 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(wpan_phy: phy);
143 int ret;
144
145 rtnl_lock();
146 ret = device_add(dev: &phy->dev);
147 if (ret) {
148 rtnl_unlock();
149 return ret;
150 }
151
152 list_add_rcu(new: &rdev->list, head: &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}
162EXPORT_SYMBOL(wpan_phy_register);
163
164void wpan_phy_unregister(struct wpan_phy *phy)
165{
166 struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(wpan_phy: 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(entry: &rdev->list);
185 synchronize_rcu();
186
187 cfg802154_rdev_list_generation++;
188
189 device_del(dev: &phy->dev);
190
191 rtnl_unlock();
192}
193EXPORT_SYMBOL(wpan_phy_unregister);
194
195void wpan_phy_free(struct wpan_phy *phy)
196{
197 put_device(dev: &phy->dev);
198}
199EXPORT_SYMBOL(wpan_phy_free);
200
201static void cfg802154_free_peer_structures(struct wpan_dev *wpan_dev)
202{
203 struct ieee802154_pan_device *child, *tmp;
204
205 mutex_lock(&wpan_dev->association_lock);
206
207 kfree(objp: wpan_dev->parent);
208 wpan_dev->parent = NULL;
209
210 list_for_each_entry_safe(child, tmp, &wpan_dev->children, node) {
211 list_del(entry: &child->node);
212 kfree(objp: child);
213 }
214
215 wpan_dev->nchildren = 0;
216
217 mutex_unlock(lock: &wpan_dev->association_lock);
218}
219
220int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
221 struct net *net)
222{
223 struct wpan_dev *wpan_dev;
224 int err = 0;
225
226 list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
227 if (!wpan_dev->netdev)
228 continue;
229 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
230 err = dev_change_net_namespace(dev: wpan_dev->netdev, net, pat: "wpan%d");
231 if (err)
232 break;
233 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
234 }
235
236 if (err) {
237 /* failed -- clean up to old netns */
238 net = wpan_phy_net(wpan_phy: &rdev->wpan_phy);
239
240 list_for_each_entry_continue_reverse(wpan_dev,
241 &rdev->wpan_dev_list,
242 list) {
243 if (!wpan_dev->netdev)
244 continue;
245 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
246 err = dev_change_net_namespace(dev: wpan_dev->netdev, net,
247 pat: "wpan%d");
248 WARN_ON(err);
249 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
250 }
251
252 return err;
253 }
254
255 wpan_phy_net_set(wpan_phy: &rdev->wpan_phy, net);
256
257 err = device_rename(dev: &rdev->wpan_phy.dev, new_name: dev_name(dev: &rdev->wpan_phy.dev));
258 WARN_ON(err);
259
260 return 0;
261}
262
263void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
264{
265 kfree(objp: rdev);
266}
267
268static void
269cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
270 int iftype, int num)
271{
272 ASSERT_RTNL();
273
274 rdev->num_running_ifaces += num;
275}
276
277static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
278 unsigned long state, void *ptr)
279{
280 struct net_device *dev = netdev_notifier_info_to_dev(info: ptr);
281 struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
282 struct cfg802154_registered_device *rdev;
283
284 if (!wpan_dev)
285 return NOTIFY_DONE;
286
287 rdev = wpan_phy_to_rdev(wpan_phy: wpan_dev->wpan_phy);
288
289 /* TODO WARN_ON unspec type */
290
291 switch (state) {
292 /* TODO NETDEV_DEVTYPE */
293 case NETDEV_REGISTER:
294 dev->features |= NETIF_F_NETNS_LOCAL;
295 wpan_dev->identifier = ++rdev->wpan_dev_id;
296 list_add_rcu(new: &wpan_dev->list, head: &rdev->wpan_dev_list);
297 rdev->devlist_generation++;
298 mutex_init(&wpan_dev->association_lock);
299 INIT_LIST_HEAD(list: &wpan_dev->children);
300 wpan_dev->max_associations = SZ_16K;
301
302 wpan_dev->netdev = dev;
303 break;
304 case NETDEV_DOWN:
305 cfg802154_update_iface_num(rdev, iftype: wpan_dev->iftype, num: -1);
306
307 rdev->opencount--;
308 wake_up(&rdev->dev_wait);
309 break;
310 case NETDEV_UP:
311 cfg802154_update_iface_num(rdev, iftype: wpan_dev->iftype, num: 1);
312
313 rdev->opencount++;
314 break;
315 case NETDEV_UNREGISTER:
316 cfg802154_free_peer_structures(wpan_dev);
317
318 /* It is possible to get NETDEV_UNREGISTER
319 * multiple times. To detect that, check
320 * that the interface is still on the list
321 * of registered interfaces, and only then
322 * remove and clean it up.
323 */
324 if (!list_empty(head: &wpan_dev->list)) {
325 list_del_rcu(entry: &wpan_dev->list);
326 rdev->devlist_generation++;
327 }
328 /* synchronize (so that we won't find this netdev
329 * from other code any more) and then clear the list
330 * head so that the above code can safely check for
331 * !list_empty() to avoid double-cleanup.
332 */
333 synchronize_rcu();
334 INIT_LIST_HEAD(list: &wpan_dev->list);
335 break;
336 default:
337 return NOTIFY_DONE;
338 }
339
340 return NOTIFY_OK;
341}
342
343static struct notifier_block cfg802154_netdev_notifier = {
344 .notifier_call = cfg802154_netdev_notifier_call,
345};
346
347static void __net_exit cfg802154_pernet_exit(struct net *net)
348{
349 struct cfg802154_registered_device *rdev;
350
351 rtnl_lock();
352 list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
353 if (net_eq(net1: wpan_phy_net(wpan_phy: &rdev->wpan_phy), net2: net))
354 WARN_ON(cfg802154_switch_netns(rdev, &init_net));
355 }
356 rtnl_unlock();
357}
358
359static struct pernet_operations cfg802154_pernet_ops = {
360 .exit = cfg802154_pernet_exit,
361};
362
363static int __init wpan_phy_class_init(void)
364{
365 int rc;
366
367 rc = register_pernet_device(&cfg802154_pernet_ops);
368 if (rc)
369 goto err;
370
371 rc = wpan_phy_sysfs_init();
372 if (rc)
373 goto err_sysfs;
374
375 rc = register_netdevice_notifier(nb: &cfg802154_netdev_notifier);
376 if (rc)
377 goto err_nl;
378
379 rc = ieee802154_nl_init();
380 if (rc)
381 goto err_notifier;
382
383 rc = nl802154_init();
384 if (rc)
385 goto err_ieee802154_nl;
386
387 return 0;
388
389err_ieee802154_nl:
390 ieee802154_nl_exit();
391
392err_notifier:
393 unregister_netdevice_notifier(nb: &cfg802154_netdev_notifier);
394err_nl:
395 wpan_phy_sysfs_exit();
396err_sysfs:
397 unregister_pernet_device(&cfg802154_pernet_ops);
398err:
399 return rc;
400}
401subsys_initcall(wpan_phy_class_init);
402
403static void __exit wpan_phy_class_exit(void)
404{
405 nl802154_exit();
406 ieee802154_nl_exit();
407 unregister_netdevice_notifier(nb: &cfg802154_netdev_notifier);
408 wpan_phy_sysfs_exit();
409 unregister_pernet_device(&cfg802154_pernet_ops);
410}
411module_exit(wpan_phy_class_exit);
412
413MODULE_LICENSE("GPL v2");
414MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
415MODULE_AUTHOR("Dmitry Eremin-Solenikov");
416

source code of linux/net/ieee802154/core.c