SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/wimax/stack.c

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