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 | |
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(class: &wpan_phy_class, name: 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(class: &wpan_phy_class, NULL, |
63 | data: &wpid, fn: 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(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 | } |
138 | EXPORT_SYMBOL(wpan_phy_new); |
139 | |
140 | int 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 | } |
162 | EXPORT_SYMBOL(wpan_phy_register); |
163 | |
164 | void 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 | } |
193 | EXPORT_SYMBOL(wpan_phy_unregister); |
194 | |
195 | void wpan_phy_free(struct wpan_phy *phy) |
196 | { |
197 | put_device(dev: &phy->dev); |
198 | } |
199 | EXPORT_SYMBOL(wpan_phy_free); |
200 | |
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(dev: wpan_dev->netdev, net, pat: "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(wpan_phy: &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(dev: wpan_dev->netdev, net, |
228 | pat: "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(wpan_phy: &rdev->wpan_phy, net); |
237 | |
238 | err = device_rename(dev: &rdev->wpan_phy.dev, new_name: dev_name(dev: &rdev->wpan_phy.dev)); |
239 | WARN_ON(err); |
240 | |
241 | return 0; |
242 | } |
243 | |
244 | void cfg802154_dev_free(struct cfg802154_registered_device *rdev) |
245 | { |
246 | kfree(objp: rdev); |
247 | } |
248 | |
249 | static void |
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 | |
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(info: 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_phy: 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(new: &wpan_dev->list, head: &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, iftype: wpan_dev->iftype, num: -1); |
284 | |
285 | rdev->opencount--; |
286 | wake_up(&rdev->dev_wait); |
287 | break; |
288 | case NETDEV_UP: |
289 | cfg802154_update_iface_num(rdev, iftype: wpan_dev->iftype, num: 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(head: &wpan_dev->list)) { |
301 | list_del_rcu(entry: &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(list: &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 | |
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(net1: wpan_phy_net(wpan_phy: &rdev->wpan_phy), net2: 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 | |
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(nb: &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(nb: &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 | |
379 | static void __exit wpan_phy_class_exit(void) |
380 | { |
381 | nl802154_exit(); |
382 | ieee802154_nl_exit(); |
383 | unregister_netdevice_notifier(nb: &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 | |