3 * Initialization, addition and removal of wimax devices
6 * Copyright (C) 2005-2006 Intel Corporation <linux-wimax@intel.com>
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26 * - basic life cycle of 'struct wimax_dev' [wimax_dev_*()]; on
27 * addition/registration initialize all subfields and allocate
28 * generic netlink resources for user space communication. On
29 * removal/unregistration, undo all that.
31 * - device state machine [wimax_state_change()] and support to send
32 * reports to user space when the state changes
33 * [wimax_gnl_re_state_change*()].
35 * See include/net/wimax.h for rationales and design.
39 * [__]wimax_state_change() Called by drivers to update device's state
40 * wimax_gnl_re_state_change_alloc()
41 * wimax_gnl_re_state_change_send()
43 * wimax_dev_init() Init a device
44 * wimax_dev_add() Register
46 * wimax_gnl_add() Register all the generic netlink resources.
47 * wimax_id_table_add()
48 * wimax_dev_rm() Unregister
53 #include <linux/device.h>
54 #include <linux/gfp.h>
55 #include <net/genetlink.h>
56 #include <linux/netdevice.h>
57 #include <linux/wimax.h>
58 #include <linux/module.h>
59 #include "wimax-internal.h"
62 #define D_SUBMODULE stack
63 #include "debug-levels.h"
65 static char wimax_debug_params[128];
66 module_param_string(debug, wimax_debug_params, sizeof(wimax_debug_params),
68 MODULE_PARM_DESC(debug,
69 "String of space-separated NAME:VALUE pairs, where NAMEs "
70 "are the different debug submodules and VALUE are the "
71 "initial debug value to set.");
74 * Authoritative source for the RE_STATE_CHANGE attribute policy
76 * We don't really use it here, but /me likes to keep the definition
77 * close to where the data is generated.
80 static const struct nla_policy wimax_gnl_re_status_change[WIMAX_GNL_ATTR_MAX + 1] = {
81 [WIMAX_GNL_STCH_STATE_OLD] = { .type = NLA_U8 },
82 [WIMAX_GNL_STCH_STATE_NEW] = { .type = NLA_U8 },
88 * Allocate a Report State Change message
90 * @header: save it, you need it for _send()
92 * Creates and fills a basic state change message; different code
93 * paths can then add more attributes to the message as needed.
95 * Use wimax_gnl_re_state_change_send() to send the returned skb.
97 * Returns: skb with the genl message if ok, IS_ERR() ptr on error
101 struct sk_buff *wimax_gnl_re_state_change_alloc(
102 struct wimax_dev *wimax_dev,
103 enum wimax_st new_state, enum wimax_st old_state,
107 struct device *dev = wimax_dev_to_dev(wimax_dev);
109 struct sk_buff *report_skb;
111 d_fnstart(3, dev, "(wimax_dev %p new_state %u old_state %u)\n",
112 wimax_dev, new_state, old_state);
114 report_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
115 if (report_skb == NULL) {
116 dev_err(dev, "RE_STCH: can't create message\n");
119 data = genlmsg_put(report_skb, 0, wimax_gnl_mcg.id, &wimax_gnl_family,
120 0, WIMAX_GNL_RE_STATE_CHANGE);
122 dev_err(dev, "RE_STCH: can't put data into message\n");
127 result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_OLD, old_state);
129 dev_err(dev, "RE_STCH: Error adding OLD attr: %d\n", result);
132 result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_NEW, new_state);
134 dev_err(dev, "RE_STCH: Error adding NEW attr: %d\n", result);
137 result = nla_put_u32(report_skb, WIMAX_GNL_STCH_IFIDX,
138 wimax_dev->net_dev->ifindex);
140 dev_err(dev, "RE_STCH: Error adding IFINDEX attribute\n");
143 d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %p\n",
144 wimax_dev, new_state, old_state, report_skb);
148 nlmsg_free(report_skb);
150 d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %d\n",
151 wimax_dev, new_state, old_state, result);
152 return ERR_PTR(result);
157 * Send a Report State Change message (as created with _alloc).
159 * @report_skb: as returned by wimax_gnl_re_state_change_alloc()
160 * @header: as returned by wimax_gnl_re_state_change_alloc()
162 * Returns: 0 if ok, < 0 errno code on error.
164 * If the message is NULL, pretend it didn't happen.
167 int wimax_gnl_re_state_change_send(
168 struct wimax_dev *wimax_dev, struct sk_buff *report_skb,
172 struct device *dev = wimax_dev_to_dev(wimax_dev);
173 d_fnstart(3, dev, "(wimax_dev %p report_skb %p)\n",
174 wimax_dev, report_skb);
175 if (report_skb == NULL) {
179 genlmsg_end(report_skb, header);
180 genlmsg_multicast(report_skb, 0, wimax_gnl_mcg.id, GFP_KERNEL);
182 d_fnend(3, dev, "(wimax_dev %p report_skb %p) = %d\n",
183 wimax_dev, report_skb, result);
189 void __check_new_state(enum wimax_st old_state, enum wimax_st new_state,
190 unsigned int allowed_states_bm)
192 if (WARN_ON(((1 << new_state) & allowed_states_bm) == 0)) {
193 printk(KERN_ERR "SW BUG! Forbidden state change %u -> %u\n",
194 old_state, new_state);
200 * Set the current state of a WiMAX device [unlocking version of
201 * wimax_state_change().
203 void __wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state)
205 struct device *dev = wimax_dev_to_dev(wimax_dev);
206 enum wimax_st old_state = wimax_dev->state;
207 struct sk_buff *stch_skb;
210 d_fnstart(3, dev, "(wimax_dev %p new_state %u [old %u])\n",
211 wimax_dev, new_state, old_state);
213 if (WARN_ON(new_state >= __WIMAX_ST_INVALID)) {
214 dev_err(dev, "SW BUG: requesting invalid state %u\n",
218 if (old_state == new_state)
220 header = NULL; /* gcc complains? can't grok why */
221 stch_skb = wimax_gnl_re_state_change_alloc(
222 wimax_dev, new_state, old_state, &header);
224 /* Verify the state transition and do exit-from-state actions */
226 case __WIMAX_ST_NULL:
227 __check_new_state(old_state, new_state,
231 __check_new_state(old_state, new_state,
232 1 << __WIMAX_ST_QUIESCING
233 | 1 << WIMAX_ST_UNINITIALIZED
234 | 1 << WIMAX_ST_RADIO_OFF);
236 case __WIMAX_ST_QUIESCING:
237 __check_new_state(old_state, new_state, 1 << WIMAX_ST_DOWN);
239 case WIMAX_ST_UNINITIALIZED:
240 __check_new_state(old_state, new_state,
241 1 << __WIMAX_ST_QUIESCING
242 | 1 << WIMAX_ST_RADIO_OFF);
244 case WIMAX_ST_RADIO_OFF:
245 __check_new_state(old_state, new_state,
246 1 << __WIMAX_ST_QUIESCING
247 | 1 << WIMAX_ST_READY);
250 __check_new_state(old_state, new_state,
251 1 << __WIMAX_ST_QUIESCING
252 | 1 << WIMAX_ST_RADIO_OFF
253 | 1 << WIMAX_ST_SCANNING
254 | 1 << WIMAX_ST_CONNECTING
255 | 1 << WIMAX_ST_CONNECTED);
257 case WIMAX_ST_SCANNING:
258 __check_new_state(old_state, new_state,
259 1 << __WIMAX_ST_QUIESCING
260 | 1 << WIMAX_ST_RADIO_OFF
261 | 1 << WIMAX_ST_READY
262 | 1 << WIMAX_ST_CONNECTING
263 | 1 << WIMAX_ST_CONNECTED);
265 case WIMAX_ST_CONNECTING:
266 __check_new_state(old_state, new_state,
267 1 << __WIMAX_ST_QUIESCING
268 | 1 << WIMAX_ST_RADIO_OFF
269 | 1 << WIMAX_ST_READY
270 | 1 << WIMAX_ST_SCANNING
271 | 1 << WIMAX_ST_CONNECTED);
273 case WIMAX_ST_CONNECTED:
274 __check_new_state(old_state, new_state,
275 1 << __WIMAX_ST_QUIESCING
276 | 1 << WIMAX_ST_RADIO_OFF
277 | 1 << WIMAX_ST_READY);
278 netif_tx_disable(wimax_dev->net_dev);
279 netif_carrier_off(wimax_dev->net_dev);
281 case __WIMAX_ST_INVALID:
283 dev_err(dev, "SW BUG: wimax_dev %p is in unknown state %u\n",
284 wimax_dev, wimax_dev->state);
289 /* Execute the actions of entry to the new state */
291 case __WIMAX_ST_NULL:
292 dev_err(dev, "SW BUG: wimax_dev %p entering NULL state "
293 "from %u\n", wimax_dev, wimax_dev->state);
294 WARN_ON(1); /* Nobody can enter this state */
298 case __WIMAX_ST_QUIESCING:
300 case WIMAX_ST_UNINITIALIZED:
302 case WIMAX_ST_RADIO_OFF:
306 case WIMAX_ST_SCANNING:
308 case WIMAX_ST_CONNECTING:
310 case WIMAX_ST_CONNECTED:
311 netif_carrier_on(wimax_dev->net_dev);
312 netif_wake_queue(wimax_dev->net_dev);
314 case __WIMAX_ST_INVALID:
318 __wimax_state_set(wimax_dev, new_state);
319 if (!IS_ERR(stch_skb))
320 wimax_gnl_re_state_change_send(wimax_dev, stch_skb, header);
322 d_fnend(3, dev, "(wimax_dev %p new_state %u [old %u]) = void\n",
323 wimax_dev, new_state, old_state);
328 * wimax_state_change - Set the current state of a WiMAX device
330 * @wimax_dev: WiMAX device descriptor (properly referenced)
331 * @new_state: New state to switch to
333 * This implements the state changes for the wimax devices. It will
335 * - verify that the state transition is legal (for now it'll just
336 * print a warning if not) according to the table in
337 * linux/wimax.h's documentation for 'enum wimax_st'.
339 * - perform the actions needed for leaving the current state and
340 * whichever are needed for entering the new state.
342 * - issue a report to user space indicating the new state (and an
343 * optional payload with information about the new state).
345 * NOTE: @wimax_dev must be locked
347 void wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state)
350 * A driver cannot take the wimax_dev out of the
351 * __WIMAX_ST_NULL state unless by calling wimax_dev_add(). If
352 * the wimax_dev's state is still NULL, we ignore any request
353 * to change its state because it means it hasn't been yet
356 * There is no need to complain about it, as routines that
357 * call this might be shared from different code paths that
358 * are called before or after wimax_dev_add() has done its
361 mutex_lock(&wimax_dev->mutex);
362 if (wimax_dev->state > __WIMAX_ST_NULL)
363 __wimax_state_change(wimax_dev, new_state);
364 mutex_unlock(&wimax_dev->mutex);
366 EXPORT_SYMBOL_GPL(wimax_state_change);
370 * wimax_state_get() - Return the current state of a WiMAX device
372 * @wimax_dev: WiMAX device descriptor
374 * Returns: Current state of the device according to its driver.
376 enum wimax_st wimax_state_get(struct wimax_dev *wimax_dev)
379 mutex_lock(&wimax_dev->mutex);
380 state = wimax_dev->state;
381 mutex_unlock(&wimax_dev->mutex);
384 EXPORT_SYMBOL_GPL(wimax_state_get);
388 * wimax_dev_init - initialize a newly allocated instance
390 * @wimax_dev: WiMAX device descriptor to initialize.
392 * Initializes fields of a freshly allocated @wimax_dev instance. This
393 * function assumes that after allocation, the memory occupied by
394 * @wimax_dev was zeroed.
396 void wimax_dev_init(struct wimax_dev *wimax_dev)
398 INIT_LIST_HEAD(&wimax_dev->id_table_node);
399 __wimax_state_set(wimax_dev, __WIMAX_ST_NULL);
400 mutex_init(&wimax_dev->mutex);
401 mutex_init(&wimax_dev->mutex_reset);
403 EXPORT_SYMBOL_GPL(wimax_dev_init);
405 static const struct nla_policy wimax_gnl_policy[WIMAX_GNL_ATTR_MAX + 1] = {
406 [WIMAX_GNL_RESET_IFIDX] = { .type = NLA_U32, },
407 [WIMAX_GNL_RFKILL_IFIDX] = { .type = NLA_U32, },
408 [WIMAX_GNL_RFKILL_STATE] = {
409 .type = NLA_U32 /* enum wimax_rf_state */
411 [WIMAX_GNL_STGET_IFIDX] = { .type = NLA_U32, },
412 [WIMAX_GNL_MSG_IFIDX] = { .type = NLA_U32, },
413 [WIMAX_GNL_MSG_DATA] = {
414 .type = NLA_UNSPEC, /* libnl doesn't grok BINARY yet */
418 static const struct genl_ops wimax_gnl_ops[] = {
420 .cmd = WIMAX_GNL_OP_MSG_FROM_USER,
421 .flags = GENL_ADMIN_PERM,
422 .policy = wimax_gnl_policy,
423 .doit = wimax_gnl_doit_msg_from_user,
426 .cmd = WIMAX_GNL_OP_RESET,
427 .flags = GENL_ADMIN_PERM,
428 .policy = wimax_gnl_policy,
429 .doit = wimax_gnl_doit_reset,
432 .cmd = WIMAX_GNL_OP_RFKILL,
433 .flags = GENL_ADMIN_PERM,
434 .policy = wimax_gnl_policy,
435 .doit = wimax_gnl_doit_rfkill,
438 .cmd = WIMAX_GNL_OP_STATE_GET,
439 .flags = GENL_ADMIN_PERM,
440 .policy = wimax_gnl_policy,
441 .doit = wimax_gnl_doit_state_get,
447 size_t wimax_addr_scnprint(char *addr_str, size_t addr_str_size,
448 unsigned char *addr, size_t addr_len)
450 unsigned int cnt, total;
452 for (total = cnt = 0; cnt < addr_len; cnt++)
453 total += scnprintf(addr_str + total, addr_str_size - total,
455 cnt == addr_len - 1 ? '\0' : ':');
461 * wimax_dev_add - Register a new WiMAX device
463 * @wimax_dev: WiMAX device descriptor (as embedded in your @net_dev's
464 * priv data). You must have called wimax_dev_init() on it before.
466 * @net_dev: net device the @wimax_dev is associated with. The
467 * function expects SET_NETDEV_DEV() and register_netdev() were
468 * already called on it.
470 * Registers the new WiMAX device, sets up the user-kernel control
471 * interface (generic netlink) and common WiMAX infrastructure.
473 * Note that the parts that will allow interaction with user space are
474 * setup at the very end, when the rest is in place, as once that
475 * happens, the driver might get user space control requests via
476 * netlink or from debugfs that might translate into calls into
479 int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev)
482 struct device *dev = net_dev->dev.parent;
485 d_fnstart(3, dev, "(wimax_dev %p net_dev %p)\n", wimax_dev, net_dev);
487 /* Do the RFKILL setup before locking, as RFKILL will call
488 * into our functions. */
489 wimax_dev->net_dev = net_dev;
490 result = wimax_rfkill_add(wimax_dev);
492 goto error_rfkill_add;
494 /* Set up user-space interaction */
495 mutex_lock(&wimax_dev->mutex);
496 wimax_id_table_add(wimax_dev);
497 result = wimax_debugfs_add(wimax_dev);
499 dev_err(dev, "cannot initialize debugfs: %d\n",
501 goto error_debugfs_add;
504 __wimax_state_set(wimax_dev, WIMAX_ST_DOWN);
505 mutex_unlock(&wimax_dev->mutex);
507 wimax_addr_scnprint(addr_str, sizeof(addr_str),
508 net_dev->dev_addr, net_dev->addr_len);
509 dev_err(dev, "WiMAX interface %s (%s) ready\n",
510 net_dev->name, addr_str);
511 d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev);
515 wimax_id_table_rm(wimax_dev);
516 mutex_unlock(&wimax_dev->mutex);
517 wimax_rfkill_rm(wimax_dev);
519 d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n",
520 wimax_dev, net_dev, result);
523 EXPORT_SYMBOL_GPL(wimax_dev_add);
527 * wimax_dev_rm - Unregister an existing WiMAX device
529 * @wimax_dev: WiMAX device descriptor
531 * Unregisters a WiMAX device previously registered for use with
534 * IMPORTANT! Must call before calling unregister_netdev().
536 * After this function returns, you will not get any more user space
537 * control requests (via netlink or debugfs) and thus to wimax_dev->ops.
539 * Reentrancy control is ensured by setting the state to
540 * %__WIMAX_ST_QUIESCING. rfkill operations coming through
541 * wimax_*rfkill*() will be stopped by the quiescing state; ops coming
542 * from the rfkill subsystem will be stopped by the support being
543 * removed by wimax_rfkill_rm().
545 void wimax_dev_rm(struct wimax_dev *wimax_dev)
547 d_fnstart(3, NULL, "(wimax_dev %p)\n", wimax_dev);
549 mutex_lock(&wimax_dev->mutex);
550 __wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING);
551 wimax_debugfs_rm(wimax_dev);
552 wimax_id_table_rm(wimax_dev);
553 __wimax_state_change(wimax_dev, WIMAX_ST_DOWN);
554 mutex_unlock(&wimax_dev->mutex);
555 wimax_rfkill_rm(wimax_dev);
556 d_fnend(3, NULL, "(wimax_dev %p) = void\n", wimax_dev);
558 EXPORT_SYMBOL_GPL(wimax_dev_rm);
561 /* Debug framework control of debug levels */
562 struct d_level D_LEVEL[] = {
563 D_SUBMODULE_DEFINE(debugfs),
564 D_SUBMODULE_DEFINE(id_table),
565 D_SUBMODULE_DEFINE(op_msg),
566 D_SUBMODULE_DEFINE(op_reset),
567 D_SUBMODULE_DEFINE(op_rfkill),
568 D_SUBMODULE_DEFINE(op_state_get),
569 D_SUBMODULE_DEFINE(stack),
571 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
574 struct genl_family wimax_gnl_family = {
575 .id = GENL_ID_GENERATE,
577 .version = WIMAX_GNL_VERSION,
579 .maxattr = WIMAX_GNL_ATTR_MAX,
582 struct genl_multicast_group wimax_gnl_mcg = {
588 /* Shutdown the wimax stack */
590 int __init wimax_subsys_init(void)
594 d_fnstart(4, NULL, "()\n");
595 d_parse_params(D_LEVEL, D_LEVEL_SIZE, wimax_debug_params,
598 snprintf(wimax_gnl_family.name, sizeof(wimax_gnl_family.name),
600 result = genl_register_family_with_ops(&wimax_gnl_family,
602 if (unlikely(result < 0)) {
603 printk(KERN_ERR "cannot register generic netlink family: %d\n",
605 goto error_register_family;
608 result = genl_register_mc_group(&wimax_gnl_family, &wimax_gnl_mcg);
611 d_fnend(4, NULL, "() = 0\n");
615 genl_unregister_family(&wimax_gnl_family);
616 error_register_family:
617 d_fnend(4, NULL, "() = %d\n", result);
621 module_init(wimax_subsys_init);
624 /* Shutdown the wimax stack */
626 void __exit wimax_subsys_exit(void)
628 wimax_id_table_release();
629 genl_unregister_family(&wimax_gnl_family);
631 module_exit(wimax_subsys_exit);
633 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
634 MODULE_DESCRIPTION("Linux WiMAX stack");
635 MODULE_LICENSE("GPL");