1 /*
2 * Linux WiMAX
3 * Initialization, addition and removal of wimax devices
4 *
5 *
6 * Copyright (C) 2005-2006 Intel Corporation <linux-wimax@intel.com>
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 *
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.
12 *
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.
17 *
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
21 * 02110-1301, USA.
22 *
23 *
24 * This implements:
25 *
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.
30 *
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*()].
34 *
35 * See include/net/wimax.h for rationales and design.
36 *
37 * ROADMAP
38 *
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()
42 *
43 * wimax_dev_init() Init a device
44 * wimax_dev_add() Register
45 * wimax_rfkill_add()
46 * wimax_gnl_add() Register all the generic netlink resources.
47 * wimax_id_table_add()
48 * wimax_dev_rm() Unregister
49 * wimax_id_table_rm()
50 * wimax_gnl_rm()
51 * wimax_rfkill_rm()
52 */
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 "wimax-internal.h"
59
60
61 #define D_SUBMODULE stack
62 #include "debug-levels.h"
63
64 static char wimax_debug_params[128];
65 module_param_string(debug, wimax_debug_params, sizeof(wimax_debug_params),
66 0644);
67 MODULE_PARM_DESC(debug,
68 "String of space-separated NAME:VALUE pairs, where NAMEs "
69 "are the different debug submodules and VALUE are the "
70 "initial debug value to set.");
71
72 /*
73 * Authoritative source for the RE_STATE_CHANGE attribute policy
74 *
75 * We don't really use it here, but /me likes to keep the definition
76 * close to where the data is generated.
77 */
78 /*
79 static const struct nla_policy wimax_gnl_re_status_change[WIMAX_GNL_ATTR_MAX + 1] = {
80 [WIMAX_GNL_STCH_STATE_OLD] = { .type = NLA_U8 },
81 [WIMAX_GNL_STCH_STATE_NEW] = { .type = NLA_U8 },
82 };
83 */
84
85
86 /*
87 * Allocate a Report State Change message
88 *
89 * @header: save it, you need it for _send()
90 *
91 * Creates and fills a basic state change message; different code
92 * paths can then add more attributes to the message as needed.
93 *
94 * Use wimax_gnl_re_state_change_send() to send the returned skb.
95 *
96 * Returns: skb with the genl message if ok, IS_ERR() ptr on error
97 * with an errno code.
98 */
99 static
wimax_gnl_re_state_change_alloc(struct wimax_dev * wimax_dev,enum wimax_st new_state,enum wimax_st old_state,void ** header)100 struct sk_buff *wimax_gnl_re_state_change_alloc(
101 struct wimax_dev *wimax_dev,
102 enum wimax_st new_state, enum wimax_st old_state,
103 void **header)
104 {
105 int result;
106 struct device *dev = wimax_dev_to_dev(wimax_dev);
107 void *data;
108 struct sk_buff *report_skb;
109
110 d_fnstart(3, dev, "(wimax_dev %p new_state %u old_state %u)\n",
111 wimax_dev, new_state, old_state);
112 result = -ENOMEM;
113 report_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
114 if (report_skb == NULL) {
115 dev_err(dev, "RE_STCH: can't create message\n");
116 goto error_new;
117 }
118 data = genlmsg_put(report_skb, 0, wimax_gnl_mcg.id, &wimax_gnl_family,
119 0, WIMAX_GNL_RE_STATE_CHANGE);
120 if (data == NULL) {
121 dev_err(dev, "RE_STCH: can't put data into message\n");
122 goto error_put;
123 }
124 *header = data;
125
126 result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_OLD, old_state);
127 if (result < 0) {
128 dev_err(dev, "RE_STCH: Error adding OLD attr: %d\n", result);
129 goto error_put;
130 }
131 result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_NEW, new_state);
132 if (result < 0) {
133 dev_err(dev, "RE_STCH: Error adding NEW attr: %d\n", result);
134 goto error_put;
135 }
136 result = nla_put_u32(report_skb, WIMAX_GNL_STCH_IFIDX,
137 wimax_dev->net_dev->ifindex);
138 if (result < 0) {
139 dev_err(dev, "RE_STCH: Error adding IFINDEX attribute\n");
140 goto error_put;
141 }
142 d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %p\n",
143 wimax_dev, new_state, old_state, report_skb);
144 return report_skb;
145
146 error_put:
147 nlmsg_free(report_skb);
148 error_new:
149 d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %d\n",
150 wimax_dev, new_state, old_state, result);
151 return ERR_PTR(result);
152 }
153
154
155 /*
156 * Send a Report State Change message (as created with _alloc).
157 *
158 * @report_skb: as returned by wimax_gnl_re_state_change_alloc()
159 * @header: as returned by wimax_gnl_re_state_change_alloc()
160 *
161 * Returns: 0 if ok, < 0 errno code on error.
162 *
163 * If the message is NULL, pretend it didn't happen.
164 */
165 static
wimax_gnl_re_state_change_send(struct wimax_dev * wimax_dev,struct sk_buff * report_skb,void * header)166 int wimax_gnl_re_state_change_send(
167 struct wimax_dev *wimax_dev, struct sk_buff *report_skb,
168 void *header)
169 {
170 int result = 0;
171 struct device *dev = wimax_dev_to_dev(wimax_dev);
172 d_fnstart(3, dev, "(wimax_dev %p report_skb %p)\n",
173 wimax_dev, report_skb);
174 if (report_skb == NULL) {
175 result = -ENOMEM;
176 goto out;
177 }
178 genlmsg_end(report_skb, header);
179 genlmsg_multicast(report_skb, 0, wimax_gnl_mcg.id, GFP_KERNEL);
180 out:
181 d_fnend(3, dev, "(wimax_dev %p report_skb %p) = %d\n",
182 wimax_dev, report_skb, result);
183 return result;
184 }
185
186
187 static
__check_new_state(enum wimax_st old_state,enum wimax_st new_state,unsigned allowed_states_bm)188 void __check_new_state(enum wimax_st old_state, enum wimax_st new_state,
189 unsigned allowed_states_bm)
190 {
191 if (WARN_ON(((1 << new_state) & allowed_states_bm) == 0)) {
192 printk(KERN_ERR "SW BUG! Forbidden state change %u -> %u\n",
193 old_state, new_state);
194 }
195 }
196
197
198 /*
199 * Set the current state of a WiMAX device [unlocking version of
200 * wimax_state_change().
201 */
__wimax_state_change(struct wimax_dev * wimax_dev,enum wimax_st new_state)202 void __wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state)
203 {
204 struct device *dev = wimax_dev_to_dev(wimax_dev);
205 enum wimax_st old_state = wimax_dev->state;
206 struct sk_buff *stch_skb;
207 void *header;
208
209 d_fnstart(3, dev, "(wimax_dev %p new_state %u [old %u])\n",
210 wimax_dev, new_state, old_state);
211
212 if (WARN_ON(new_state >= __WIMAX_ST_INVALID)) {
213 dev_err(dev, "SW BUG: requesting invalid state %u\n",
214 new_state);
215 goto out;
216 }
217 if (old_state == new_state)
218 goto out;
219 header = NULL; /* gcc complains? can't grok why */
220 stch_skb = wimax_gnl_re_state_change_alloc(
221 wimax_dev, new_state, old_state, &header);
222
223 /* Verify the state transition and do exit-from-state actions */
224 switch (old_state) {
225 case __WIMAX_ST_NULL:
226 __check_new_state(old_state, new_state,
227 1 << WIMAX_ST_DOWN);
228 break;
229 case WIMAX_ST_DOWN:
230 __check_new_state(old_state, new_state,
231 1 << __WIMAX_ST_QUIESCING
232 | 1 << WIMAX_ST_UNINITIALIZED
233 | 1 << WIMAX_ST_RADIO_OFF);
234 break;
235 case __WIMAX_ST_QUIESCING:
236 __check_new_state(old_state, new_state, 1 << WIMAX_ST_DOWN);
237 break;
238 case WIMAX_ST_UNINITIALIZED:
239 __check_new_state(old_state, new_state,
240 1 << __WIMAX_ST_QUIESCING
241 | 1 << WIMAX_ST_RADIO_OFF);
242 break;
243 case WIMAX_ST_RADIO_OFF:
244 __check_new_state(old_state, new_state,
245 1 << __WIMAX_ST_QUIESCING
246 | 1 << WIMAX_ST_READY);
247 break;
248 case WIMAX_ST_READY:
249 __check_new_state(old_state, new_state,
250 1 << __WIMAX_ST_QUIESCING
251 | 1 << WIMAX_ST_RADIO_OFF
252 | 1 << WIMAX_ST_SCANNING
253 | 1 << WIMAX_ST_CONNECTING
254 | 1 << WIMAX_ST_CONNECTED);
255 break;
256 case WIMAX_ST_SCANNING:
257 __check_new_state(old_state, new_state,
258 1 << __WIMAX_ST_QUIESCING
259 | 1 << WIMAX_ST_RADIO_OFF
260 | 1 << WIMAX_ST_READY
261 | 1 << WIMAX_ST_CONNECTING
262 | 1 << WIMAX_ST_CONNECTED);
263 break;
264 case WIMAX_ST_CONNECTING:
265 __check_new_state(old_state, new_state,
266 1 << __WIMAX_ST_QUIESCING
267 | 1 << WIMAX_ST_RADIO_OFF
268 | 1 << WIMAX_ST_READY
269 | 1 << WIMAX_ST_SCANNING
270 | 1 << WIMAX_ST_CONNECTED);
271 break;
272 case WIMAX_ST_CONNECTED:
273 __check_new_state(old_state, new_state,
274 1 << __WIMAX_ST_QUIESCING
275 | 1 << WIMAX_ST_RADIO_OFF
276 | 1 << WIMAX_ST_READY);
277 netif_tx_disable(wimax_dev->net_dev);
278 netif_carrier_off(wimax_dev->net_dev);
279 break;
280 case __WIMAX_ST_INVALID:
281 default:
282 dev_err(dev, "SW BUG: wimax_dev %p is in unknown state %u\n",
283 wimax_dev, wimax_dev->state);
284 WARN_ON(1);
285 goto out;
286 }
287
288 /* Execute the actions of entry to the new state */
289 switch (new_state) {
290 case __WIMAX_ST_NULL:
291 dev_err(dev, "SW BUG: wimax_dev %p entering NULL state "
292 "from %u\n", wimax_dev, wimax_dev->state);
293 WARN_ON(1); /* Nobody can enter this state */
294 break;
295 case WIMAX_ST_DOWN:
296 break;
297 case __WIMAX_ST_QUIESCING:
298 break;
299 case WIMAX_ST_UNINITIALIZED:
300 break;
301 case WIMAX_ST_RADIO_OFF:
302 break;
303 case WIMAX_ST_READY:
304 break;
305 case WIMAX_ST_SCANNING:
306 break;
307 case WIMAX_ST_CONNECTING:
308 break;
309 case WIMAX_ST_CONNECTED:
310 netif_carrier_on(wimax_dev->net_dev);
311 netif_wake_queue(wimax_dev->net_dev);
312 break;
313 case __WIMAX_ST_INVALID:
314 default:
315 BUG();
316 }
317 __wimax_state_set(wimax_dev, new_state);
318 if (!IS_ERR(stch_skb))
319 wimax_gnl_re_state_change_send(wimax_dev, stch_skb, header);
320 out:
321 d_fnend(3, dev, "(wimax_dev %p new_state %u [old %u]) = void\n",
322 wimax_dev, new_state, old_state);
323 }
324
325
326 /**
327 * wimax_state_change - Set the current state of a WiMAX device
328 *
329 * @wimax_dev: WiMAX device descriptor (properly referenced)
330 * @new_state: New state to switch to
331 *
332 * This implements the state changes for the wimax devices. It will
333 *
334 * - verify that the state transition is legal (for now it'll just
335 * print a warning if not) according to the table in
336 * linux/wimax.h's documentation for 'enum wimax_st'.
337 *
338 * - perform the actions needed for leaving the current state and
339 * whichever are needed for entering the new state.
340 *
341 * - issue a report to user space indicating the new state (and an
342 * optional payload with information about the new state).
343 *
344 * NOTE: @wimax_dev must be locked
345 */
wimax_state_change(struct wimax_dev * wimax_dev,enum wimax_st new_state)346 void wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state)
347 {
348 /*
349 * A driver cannot take the wimax_dev out of the
350 * __WIMAX_ST_NULL state unless by calling wimax_dev_add(). If
351 * the wimax_dev's state is still NULL, we ignore any request
352 * to change its state because it means it hasn't been yet
353 * registered.
354 *
355 * There is no need to complain about it, as routines that
356 * call this might be shared from different code paths that
357 * are called before or after wimax_dev_add() has done its
358 * job.
359 */
360 mutex_lock(&wimax_dev->mutex);
361 if (wimax_dev->state > __WIMAX_ST_NULL)
362 __wimax_state_change(wimax_dev, new_state);
363 mutex_unlock(&wimax_dev->mutex);
364 }
365 EXPORT_SYMBOL_GPL(wimax_state_change);
366
367
368 /**
369 * wimax_state_get() - Return the current state of a WiMAX device
370 *
371 * @wimax_dev: WiMAX device descriptor
372 *
373 * Returns: Current state of the device according to its driver.
374 */
wimax_state_get(struct wimax_dev * wimax_dev)375 enum wimax_st wimax_state_get(struct wimax_dev *wimax_dev)
376 {
377 enum wimax_st state;
378 mutex_lock(&wimax_dev->mutex);
379 state = wimax_dev->state;
380 mutex_unlock(&wimax_dev->mutex);
381 return state;
382 }
383 EXPORT_SYMBOL_GPL(wimax_state_get);
384
385
386 /**
387 * wimax_dev_init - initialize a newly allocated instance
388 *
389 * @wimax_dev: WiMAX device descriptor to initialize.
390 *
391 * Initializes fields of a freshly allocated @wimax_dev instance. This
392 * function assumes that after allocation, the memory occupied by
393 * @wimax_dev was zeroed.
394 */
wimax_dev_init(struct wimax_dev * wimax_dev)395 void wimax_dev_init(struct wimax_dev *wimax_dev)
396 {
397 INIT_LIST_HEAD(&wimax_dev->id_table_node);
398 __wimax_state_set(wimax_dev, __WIMAX_ST_NULL);
399 mutex_init(&wimax_dev->mutex);
400 mutex_init(&wimax_dev->mutex_reset);
401 }
402 EXPORT_SYMBOL_GPL(wimax_dev_init);
403
404 /*
405 * This extern is declared here because it's easier to keep track --
406 * both declarations are a list of the same
407 */
408 extern struct genl_ops
409 wimax_gnl_msg_from_user,
410 wimax_gnl_reset,
411 wimax_gnl_rfkill,
412 wimax_gnl_state_get;
413
414 static
415 struct genl_ops *wimax_gnl_ops[] = {
416 &wimax_gnl_msg_from_user,
417 &wimax_gnl_reset,
418 &wimax_gnl_rfkill,
419 &wimax_gnl_state_get,
420 };
421
422
423 static
wimax_addr_scnprint(char * addr_str,size_t addr_str_size,unsigned char * addr,size_t addr_len)424 size_t wimax_addr_scnprint(char *addr_str, size_t addr_str_size,
425 unsigned char *addr, size_t addr_len)
426 {
427 unsigned cnt, total;
428 for (total = cnt = 0; cnt < addr_len; cnt++)
429 total += scnprintf(addr_str + total, addr_str_size - total,
430 "%02x%c", addr[cnt],
431 cnt == addr_len - 1 ? '\0' : ':');
432 return total;
433 }
434
435
436 /**
437 * wimax_dev_add - Register a new WiMAX device
438 *
439 * @wimax_dev: WiMAX device descriptor (as embedded in your @net_dev's
440 * priv data). You must have called wimax_dev_init() on it before.
441 *
442 * @net_dev: net device the @wimax_dev is associated with. The
443 * function expects SET_NETDEV_DEV() and register_netdev() were
444 * already called on it.
445 *
446 * Registers the new WiMAX device, sets up the user-kernel control
447 * interface (generic netlink) and common WiMAX infrastructure.
448 *
449 * Note that the parts that will allow interaction with user space are
450 * setup at the very end, when the rest is in place, as once that
451 * happens, the driver might get user space control requests via
452 * netlink or from debugfs that might translate into calls into
453 * wimax_dev->op_*().
454 */
wimax_dev_add(struct wimax_dev * wimax_dev,struct net_device * net_dev)455 int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev)
456 {
457 int result;
458 struct device *dev = net_dev->dev.parent;
459 char addr_str[32];
460
461 d_fnstart(3, dev, "(wimax_dev %p net_dev %p)\n", wimax_dev, net_dev);
462
463 /* Do the RFKILL setup before locking, as RFKILL will call
464 * into our functions. */
465 wimax_dev->net_dev = net_dev;
466 result = wimax_rfkill_add(wimax_dev);
467 if (result < 0)
468 goto error_rfkill_add;
469
470 /* Set up user-space interaction */
471 mutex_lock(&wimax_dev->mutex);
472 wimax_id_table_add(wimax_dev);
473 result = wimax_debugfs_add(wimax_dev);
474 if (result < 0) {
475 dev_err(dev, "cannot initialize debugfs: %d\n",
476 result);
477 goto error_debugfs_add;
478 }
479
480 __wimax_state_set(wimax_dev, WIMAX_ST_DOWN);
481 mutex_unlock(&wimax_dev->mutex);
482
483 wimax_addr_scnprint(addr_str, sizeof(addr_str),
484 net_dev->dev_addr, net_dev->addr_len);
485 dev_err(dev, "WiMAX interface %s (%s) ready\n",
486 net_dev->name, addr_str);
487 d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev);
488 return 0;
489
490 error_debugfs_add:
491 wimax_id_table_rm(wimax_dev);
492 mutex_unlock(&wimax_dev->mutex);
493 wimax_rfkill_rm(wimax_dev);
494 error_rfkill_add:
495 d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n",
496 wimax_dev, net_dev, result);
497 return result;
498 }
499 EXPORT_SYMBOL_GPL(wimax_dev_add);
500
501
502 /**
503 * wimax_dev_rm - Unregister an existing WiMAX device
504 *
505 * @wimax_dev: WiMAX device descriptor
506 *
507 * Unregisters a WiMAX device previously registered for use with
508 * wimax_add_rm().
509 *
510 * IMPORTANT! Must call before calling unregister_netdev().
511 *
512 * After this function returns, you will not get any more user space
513 * control requests (via netlink or debugfs) and thus to wimax_dev->ops.
514 *
515 * Reentrancy control is ensured by setting the state to
516 * %__WIMAX_ST_QUIESCING. rfkill operations coming through
517 * wimax_*rfkill*() will be stopped by the quiescing state; ops coming
518 * from the rfkill subsystem will be stopped by the support being
519 * removed by wimax_rfkill_rm().
520 */
wimax_dev_rm(struct wimax_dev * wimax_dev)521 void wimax_dev_rm(struct wimax_dev *wimax_dev)
522 {
523 d_fnstart(3, NULL, "(wimax_dev %p)\n", wimax_dev);
524
525 mutex_lock(&wimax_dev->mutex);
526 __wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING);
527 wimax_debugfs_rm(wimax_dev);
528 wimax_id_table_rm(wimax_dev);
529 __wimax_state_change(wimax_dev, WIMAX_ST_DOWN);
530 mutex_unlock(&wimax_dev->mutex);
531 wimax_rfkill_rm(wimax_dev);
532 d_fnend(3, NULL, "(wimax_dev %p) = void\n", wimax_dev);
533 }
534 EXPORT_SYMBOL_GPL(wimax_dev_rm);
535
536
537 /* Debug framework control of debug levels */
538 struct d_level D_LEVEL[] = {
539 D_SUBMODULE_DEFINE(debugfs),
540 D_SUBMODULE_DEFINE(id_table),
541 D_SUBMODULE_DEFINE(op_msg),
542 D_SUBMODULE_DEFINE(op_reset),
543 D_SUBMODULE_DEFINE(op_rfkill),
544 D_SUBMODULE_DEFINE(op_state_get),
545 D_SUBMODULE_DEFINE(stack),
546 };
547 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
548
549
550 struct genl_family wimax_gnl_family = {
551 .id = GENL_ID_GENERATE,
552 .name = "WiMAX",
553 .version = WIMAX_GNL_VERSION,
554 .hdrsize = 0,
555 .maxattr = WIMAX_GNL_ATTR_MAX,
556 };
557
558 struct genl_multicast_group wimax_gnl_mcg = {
559 .name = "msg",
560 };
561
562
563
564 /* Shutdown the wimax stack */
565 static
wimax_subsys_init(void)566 int __init wimax_subsys_init(void)
567 {
568 int result, cnt;
569
570 d_fnstart(4, NULL, "()\n");
571 d_parse_params(D_LEVEL, D_LEVEL_SIZE, wimax_debug_params,
572 "wimax.debug");
573
574 snprintf(wimax_gnl_family.name, sizeof(wimax_gnl_family.name),
575 "WiMAX");
576 result = genl_register_family(&wimax_gnl_family);
577 if (unlikely(result < 0)) {
578 printk(KERN_ERR "cannot register generic netlink family: %d\n",
579 result);
580 goto error_register_family;
581 }
582
583 for (cnt = 0; cnt < ARRAY_SIZE(wimax_gnl_ops); cnt++) {
584 result = genl_register_ops(&wimax_gnl_family,
585 wimax_gnl_ops[cnt]);
586 d_printf(4, NULL, "registering generic netlink op code "
587 "%u: %d\n", wimax_gnl_ops[cnt]->cmd, result);
588 if (unlikely(result < 0)) {
589 printk(KERN_ERR "cannot register generic netlink op "
590 "code %u: %d\n",
591 wimax_gnl_ops[cnt]->cmd, result);
592 goto error_register_ops;
593 }
594 }
595
596 result = genl_register_mc_group(&wimax_gnl_family, &wimax_gnl_mcg);
597 if (result < 0)
598 goto error_mc_group;
599 d_fnend(4, NULL, "() = 0\n");
600 return 0;
601
602 error_mc_group:
603 error_register_ops:
604 for (cnt--; cnt >= 0; cnt--)
605 genl_unregister_ops(&wimax_gnl_family,
606 wimax_gnl_ops[cnt]);
607 genl_unregister_family(&wimax_gnl_family);
608 error_register_family:
609 d_fnend(4, NULL, "() = %d\n", result);
610 return result;
611
612 }
613 module_init(wimax_subsys_init);
614
615
616 /* Shutdown the wimax stack */
617 static
wimax_subsys_exit(void)618 void __exit wimax_subsys_exit(void)
619 {
620 int cnt;
621 wimax_id_table_release();
622 genl_unregister_mc_group(&wimax_gnl_family, &wimax_gnl_mcg);
623 for (cnt = ARRAY_SIZE(wimax_gnl_ops) - 1; cnt >= 0; cnt--)
624 genl_unregister_ops(&wimax_gnl_family,
625 wimax_gnl_ops[cnt]);
626 genl_unregister_family(&wimax_gnl_family);
627 }
628 module_exit(wimax_subsys_exit);
629
630 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
631 MODULE_DESCRIPTION("Linux WiMAX stack");
632 MODULE_LICENSE("GPL");
633
634