drivers/net/wimax/i2400m/driver.c

   1 /*
   2  * Intel Wireless WiMAX Connection 2400m
   3  * Generic probe/disconnect, reset and message passing
   4  *
   5  *
   6  * Copyright (C) 2007-2008 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  * See i2400m.h for driver documentation. This contains helpers for
  25  * the driver model glue [_setup()/_release()], handling device resets
  26  * [_dev_reset_handle()], and the backends for the WiMAX stack ops
  27  * reset [_op_reset()] and message from user [_op_msg_from_user()].
  28  *
  29  * ROADMAP:
  30  *
  31  * i2400m_op_msg_from_user()
  32  *   i2400m_msg_to_dev()
  33  *   wimax_msg_to_user_send()
  34  *
  35  * i2400m_op_reset()
  36  *   i240m->bus_reset()
  37  *
  38  * i2400m_dev_reset_handle()
  39  *   __i2400m_dev_reset_handle()
  40  *     __i2400m_dev_stop()
  41  *     __i2400m_dev_start()
  42  *
  43  * i2400m_setup()
  44  *   i2400m_bootrom_init()
  45  *   register_netdev()
  46  *   i2400m_dev_start()
  47  *     __i2400m_dev_start()
  48  *       i2400m_dev_bootstrap()
  49  *       i2400m_tx_setup()
  50  *       i2400m->bus_dev_start()
  51  *       i2400m_check_mac_addr()
  52  *   wimax_dev_add()
  53  *
  54  * i2400m_release()
  55  *   wimax_dev_rm()
  56  *   i2400m_dev_stop()
  57  *     __i2400m_dev_stop()
  58  *       i2400m_dev_shutdown()
  59  *       i2400m->bus_dev_stop()
  60  *       i2400m_tx_release()
  61  *   unregister_netdev()
  62  */
  63 #include "i2400m.h"
  64 #include <linux/wimax/i2400m.h>
  65 #include <linux/module.h>
  66 #include <linux/moduleparam.h>
  67
  68 #define D_SUBMODULE driver
  69 #include "debug-levels.h"
  70
  71
  72 int i2400m_idle_mode_disabled;  /* 0 (idle mode enabled) by default */
  73 module_param_named(idle_mode_disabled, i2400m_idle_mode_disabled, int, 0644);
  74 MODULE_PARM_DESC(idle_mode_disabled,
  75                  "If true, the device will not enable idle mode negotiation "
  76                  "with the base station (when connected) to save power.");
  77
  78 /**
  79  * i2400m_queue_work - schedule work on a i2400m's queue
  80  *
  81  * @i2400m: device descriptor
  82  *
  83  * @fn: function to run to execute work. It gets passed a 'struct
  84  *     work_struct' that is wrapped in a 'struct i2400m_work'. Once
  85  *     done, you have to (1) i2400m_put(i2400m_work->i2400m) and then
  86  *     (2) kfree(i2400m_work).
  87  *
  88  * @gfp_flags: GFP flags for memory allocation.
  89  *
  90  * @pl: pointer to a payload buffer that you want to pass to the _work
  91  *     function. Use this to pack (for example) a struct with extra
  92  *     arguments.
  93  *
  94  * @pl_size: size of the payload buffer.
  95  *
  96  * We do this quite often, so this just saves typing; allocate a
  97  * wrapper for a i2400m, get a ref to it, pack arguments and launch
  98  * the work.
  99  *
 100  * A usual workflow is:
 101  *
 102  * struct my_work_args {
 103  *         void *something;
 104  *         int whatever;
 105  * };
 106  * ...
 107  *
 108  * struct my_work_args my_args = {
 109  *         .something = FOO,
 110  *         .whaetever = BLAH
 111  * };
 112  * i2400m_queue_work(i2400m, 1, my_work_function, GFP_KERNEL,
 113  *                   &args, sizeof(args))
 114  *
 115  * And now the work function can unpack the arguments and call the
 116  * real function (or do the job itself):
 117  *
 118  * static
 119  * void my_work_fn((struct work_struct *ws)
 120  * {
 121  *         struct i2400m_work *iw =
 122  *                 container_of(ws, struct i2400m_work, ws);
 123  *         struct my_work_args *my_args = (void *) iw->pl;
 124  *
 125  *         my_work(iw->i2400m, my_args->something, my_args->whatevert);
 126  * }
 127  */
 128 int i2400m_queue_work(struct i2400m *i2400m,
 129                       void (*fn)(struct work_struct *), gfp_t gfp_flags,
 130                       const void *pl, size_t pl_size)
 131 {
 132         int result;
 133         struct i2400m_work *iw;
 134
 135         BUG_ON(i2400m->work_queue == NULL);
 136         result = -ENOMEM;
 137         iw = kzalloc(sizeof(*iw) + pl_size, gfp_flags);
 138         if (iw == NULL)
 139                 goto error_kzalloc;
 140         iw->i2400m = i2400m_get(i2400m);
 141         memcpy(iw->pl, pl, pl_size);
 142         INIT_WORK(&iw->ws, fn);
 143         result = queue_work(i2400m->work_queue, &iw->ws);
 144 error_kzalloc:
 145         return result;
 146 }
 147 EXPORT_SYMBOL_GPL(i2400m_queue_work);
 148
 149
 150 /*
 151  * Schedule i2400m's specific work on the system's queue.
 152  *
 153  * Used for a few cases where we really need it; otherwise, identical
 154  * to i2400m_queue_work().
 155  *
 156  * Returns < 0 errno code on error, 1 if ok.
 157  *
 158  * If it returns zero, something really bad happened, as it means the
 159  * works struct was already queued, but we have just allocated it, so
 160  * it should not happen.
 161  */
 162 int i2400m_schedule_work(struct i2400m *i2400m,
 163                          void (*fn)(struct work_struct *), gfp_t gfp_flags)
 164 {
 165         int result;
 166         struct i2400m_work *iw;
 167
 168         BUG_ON(i2400m->work_queue == NULL);
 169         result = -ENOMEM;
 170         iw = kzalloc(sizeof(*iw), gfp_flags);
 171         if (iw == NULL)
 172                 goto error_kzalloc;
 173         iw->i2400m = i2400m_get(i2400m);
 174         INIT_WORK(&iw->ws, fn);
 175         result = schedule_work(&iw->ws);
 176         if (result == 0)
 177                 result = -ENXIO;
 178 error_kzalloc:
 179         return result;
 180 }
 181
 182
 183 /*
 184  * WiMAX stack operation: relay a message from user space
 185  *
 186  * @wimax_dev: device descriptor
 187  * @pipe_name: named pipe the message is for
 188  * @msg_buf: pointer to the message bytes
 189  * @msg_len: length of the buffer
 190  * @genl_info: passed by the generic netlink layer
 191  *
 192  * The WiMAX stack will call this function when a message was received
 193  * from user space.
 194  *
 195  * For the i2400m, this is an L3L4 message, as specified in
 196  * include/linux/wimax/i2400m.h, and thus prefixed with a 'struct
 197  * i2400m_l3l4_hdr'. Driver (and device) expect the messages to be
 198  * coded in Little Endian.
 199  *
 200  * This function just verifies that the header declaration and the
 201  * payload are consistent and then deals with it, either forwarding it
 202  * to the device or procesing it locally.
 203  *
 204  * In the i2400m, messages are basically commands that will carry an
 205  * ack, so we use i2400m_msg_to_dev() and then deliver the ack back to
 206  * user space. The rx.c code might intercept the response and use it
 207  * to update the driver's state, but then it will pass it on so it can
 208  * be relayed back to user space.
 209  *
 210  * Note that asynchronous events from the device are processed and
 211  * sent to user space in rx.c.
 212  */
 213 static
 214 int i2400m_op_msg_from_user(struct wimax_dev *wimax_dev,
 215                             const char *pipe_name,
 216                             const void *msg_buf, size_t msg_len,
 217                             const struct genl_info *genl_info)
 218 {
 219         int result;
 220         struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev);
 221         struct device *dev = i2400m_dev(i2400m);
 222         struct sk_buff *ack_skb;
 223
 224         d_fnstart(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p "
 225                   "msg_len %zu genl_info %p)\n", wimax_dev, i2400m,
 226                   msg_buf, msg_len, genl_info);
 227         ack_skb = i2400m_msg_to_dev(i2400m, msg_buf, msg_len);
 228         result = PTR_ERR(ack_skb);
 229         if (IS_ERR(ack_skb))
 230                 goto error_msg_to_dev;
 231         if (unlikely(i2400m->trace_msg_from_user))
 232                 wimax_msg(&i2400m->wimax_dev, "trace",
 233                           msg_buf, msg_len, GFP_KERNEL);
 234         result = wimax_msg_send(&i2400m->wimax_dev, ack_skb);
 235 error_msg_to_dev:
 236         d_fnend(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p msg_len %zu "
 237                 "genl_info %p) = %d\n", wimax_dev, i2400m, msg_buf, msg_len,
 238                 genl_info, result);
 239         return result;
 240 }
 241
 242
 243 /*
 244  * Context to wait for a reset to finalize
 245  */
 246 struct i2400m_reset_ctx {
 247         struct completion completion;
 248         int result;
 249 };
 250
 251
 252 /*
 253  * WiMAX stack operation: reset a device
 254  *
 255  * @wimax_dev: device descriptor
 256  *
 257  * See the documentation for wimax_reset() and wimax_dev->op_reset for
 258  * the requirements of this function. The WiMAX stack guarantees
 259  * serialization on calls to this function.
 260  *
 261  * Do a warm reset on the device; if it fails, resort to a cold reset
 262  * and return -ENODEV. On successful warm reset, we need to block
 263  * until it is complete.
 264  *
 265  * The bus-driver implementation of reset takes care of falling back
 266  * to cold reset if warm fails.
 267  */
 268 static
 269 int i2400m_op_reset(struct wimax_dev *wimax_dev)
 270 {
 271         int result;
 272         struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev);
 273         struct device *dev = i2400m_dev(i2400m);
 274         struct i2400m_reset_ctx ctx = {
 275                 .completion = COMPLETION_INITIALIZER_ONSTACK(ctx.completion),
 276                 .result = 0,
 277         };
 278
 279         d_fnstart(4, dev, "(wimax_dev %p)\n", wimax_dev);
 280         mutex_lock(&i2400m->init_mutex);
 281         i2400m->reset_ctx = &ctx;
 282         mutex_unlock(&i2400m->init_mutex);
 283         result = i2400m->bus_reset(i2400m, I2400M_RT_WARM);
 284         if (result < 0)
 285                 goto out;
 286         result = wait_for_completion_timeout(&ctx.completion, 4*HZ);
 287         if (result == 0)
 288                 result = -ETIMEDOUT;
 289         else if (result > 0)
 290                 result = ctx.result;
 291         /* if result < 0, pass it on */
 292         mutex_lock(&i2400m->init_mutex);
 293         i2400m->reset_ctx = NULL;
 294         mutex_unlock(&i2400m->init_mutex);
 295 out:
 296         d_fnend(4, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
 297         return result;
 298 }
 299
 300
 301 /*
 302  * Check the MAC address we got from boot mode is ok
 303  *
 304  * @i2400m: device descriptor
 305  *
 306  * Returns: 0 if ok, < 0 errno code on error.
 307  */
 308 static
 309 int i2400m_check_mac_addr(struct i2400m *i2400m)
 310 {
 311         int result;
 312         struct device *dev = i2400m_dev(i2400m);
 313         struct sk_buff *skb;
 314         const struct i2400m_tlv_detailed_device_info *ddi;
 315         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
 316         const unsigned char zeromac[ETH_ALEN] = { 0 };
 317
 318         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 319         skb = i2400m_get_device_info(i2400m);
 320         if (IS_ERR(skb)) {
 321                 result = PTR_ERR(skb);
 322                 dev_err(dev, "Cannot verify MAC address, error reading: %d\n",
 323                         result);
 324                 goto error;
 325         }
 326         /* Extract MAC addresss */
 327         ddi = (void *) skb->data;
 328         BUILD_BUG_ON(ETH_ALEN != sizeof(ddi->mac_address));
 329         d_printf(2, dev, "GET DEVICE INFO: mac addr "
 330                  "%02x:%02x:%02x:%02x:%02x:%02x\n",
 331                  ddi->mac_address[0], ddi->mac_address[1],
 332                  ddi->mac_address[2], ddi->mac_address[3],
 333                  ddi->mac_address[4], ddi->mac_address[5]);
 334         if (!memcmp(net_dev->perm_addr, ddi->mac_address,
 335                    sizeof(ddi->mac_address)))
 336                 goto ok;
 337         dev_warn(dev, "warning: device reports a different MAC address "
 338                  "to that of boot mode's\n");
 339         dev_warn(dev, "device reports     %02x:%02x:%02x:%02x:%02x:%02x\n",
 340                  ddi->mac_address[0], ddi->mac_address[1],
 341                  ddi->mac_address[2], ddi->mac_address[3],
 342                  ddi->mac_address[4], ddi->mac_address[5]);
 343         dev_warn(dev, "boot mode reported %02x:%02x:%02x:%02x:%02x:%02x\n",
 344                  net_dev->perm_addr[0], net_dev->perm_addr[1],
 345                  net_dev->perm_addr[2], net_dev->perm_addr[3],
 346                  net_dev->perm_addr[4], net_dev->perm_addr[5]);
 347         if (!memcmp(zeromac, ddi->mac_address, sizeof(zeromac)))
 348                 dev_err(dev, "device reports an invalid MAC address, "
 349                         "not updating\n");
 350         else {
 351                 dev_warn(dev, "updating MAC address\n");
 352                 net_dev->addr_len = ETH_ALEN;
 353                 memcpy(net_dev->perm_addr, ddi->mac_address, ETH_ALEN);
 354                 memcpy(net_dev->dev_addr, ddi->mac_address, ETH_ALEN);
 355         }
 356 ok:
 357         result = 0;
 358         kfree_skb(skb);
 359 error:
 360         d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
 361         return result;
 362 }
 363
 364
 365 /**
 366  * __i2400m_dev_start - Bring up driver communication with the device
 367  *
 368  * @i2400m: device descriptor
 369  * @flags: boot mode flags
 370  *
 371  * Returns: 0 if ok, < 0 errno code on error.
 372  *
 373  * Uploads firmware and brings up all the resources needed to be able
 374  * to communicate with the device.
 375  *
 376  * TX needs to be setup before the bus-specific code (otherwise on
 377  * shutdown, the bus-tx code could try to access it).
 378  */
 379 static
 380 int __i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri flags)
 381 {
 382         int result;
 383         struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
 384         struct net_device *net_dev = wimax_dev->net_dev;
 385         struct device *dev = i2400m_dev(i2400m);
 386         int times = 3;
 387
 388         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 389 retry:
 390         result = i2400m_dev_bootstrap(i2400m, flags);
 391         if (result < 0) {
 392                 dev_err(dev, "cannot bootstrap device: %d\n", result);
 393                 goto error_bootstrap;
 394         }
 395         result = i2400m_tx_setup(i2400m);
 396         if (result < 0)
 397                 goto error_tx_setup;
 398         result = i2400m->bus_dev_start(i2400m);
 399         if (result < 0)
 400                 goto error_bus_dev_start;
 401         i2400m->work_queue = create_singlethread_workqueue(wimax_dev->name);
 402         if (i2400m->work_queue == NULL) {
 403                 result = -ENOMEM;
 404                 dev_err(dev, "cannot create workqueue\n");
 405                 goto error_create_workqueue;
 406         }
 407         /* At this point is ok to send commands to the device */
 408         result = i2400m_check_mac_addr(i2400m);
 409         if (result < 0)
 410                 goto error_check_mac_addr;
 411         i2400m->ready = 1;
 412         wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED);
 413         result = i2400m_dev_initialize(i2400m);
 414         if (result < 0)
 415                 goto error_dev_initialize;
 416         /* At this point, reports will come for the device and set it
 417          * to the right state if it is different than UNINITIALIZED */
 418         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
 419                 net_dev, i2400m, result);
 420         return result;
 421
 422 error_dev_initialize:
 423 error_check_mac_addr:
 424         destroy_workqueue(i2400m->work_queue);
 425 error_create_workqueue:
 426         i2400m->bus_dev_stop(i2400m);
 427 error_bus_dev_start:
 428         i2400m_tx_release(i2400m);
 429 error_tx_setup:
 430 error_bootstrap:
 431         if (result == -ERESTARTSYS && times-- > 0) {
 432                 flags = I2400M_BRI_SOFT;
 433                 goto retry;
 434         }
 435         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
 436                 net_dev, i2400m, result);
 437         return result;
 438 }
 439
 440
 441 static
 442 int i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri bm_flags)
 443 {
 444         int result;
 445         mutex_lock(&i2400m->init_mutex);        /* Well, start the device */
 446         result = __i2400m_dev_start(i2400m, bm_flags);
 447         if (result >= 0)
 448                 i2400m->updown = 1;
 449         mutex_unlock(&i2400m->init_mutex);
 450         return result;
 451 }
 452
 453
 454 /**
 455  * i2400m_dev_stop - Tear down driver communication with the device
 456  *
 457  * @i2400m: device descriptor
 458  *
 459  * Returns: 0 if ok, < 0 errno code on error.
 460  *
 461  * Releases all the resources allocated to communicate with the device.
 462  */
 463 static
 464 void __i2400m_dev_stop(struct i2400m *i2400m)
 465 {
 466         struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
 467         struct device *dev = i2400m_dev(i2400m);
 468
 469         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 470         wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING);
 471         i2400m_dev_shutdown(i2400m);
 472         i2400m->ready = 0;
 473         destroy_workqueue(i2400m->work_queue);
 474         i2400m->bus_dev_stop(i2400m);
 475         i2400m_tx_release(i2400m);
 476         wimax_state_change(wimax_dev, WIMAX_ST_DOWN);
 477         d_fnend(3, dev, "(i2400m %p) = 0\n", i2400m);
 478 }
 479
 480
 481 /*
 482  * Watch out -- we only need to stop if there is a need for it. The
 483  * device could have reset itself and failed to come up again (see
 484  * _i2400m_dev_reset_handle()).
 485  */
 486 static
 487 void i2400m_dev_stop(struct i2400m *i2400m)
 488 {
 489         mutex_lock(&i2400m->init_mutex);
 490         if (i2400m->updown) {
 491                 __i2400m_dev_stop(i2400m);
 492                 i2400m->updown = 0;
 493         }
 494         mutex_unlock(&i2400m->init_mutex);
 495 }
 496
 497
 498 /*
 499  * The device has rebooted; fix up the device and the driver
 500  *
 501  * Tear down the driver communication with the device, reload the
 502  * firmware and reinitialize the communication with the device.
 503  *
 504  * If someone calls a reset when the device's firmware is down, in
 505  * theory we won't see it because we are not listening. However, just
 506  * in case, leave the code to handle it.
 507  *
 508  * If there is a reset context, use it; this means someone is waiting
 509  * for us to tell him when the reset operation is complete and the
 510  * device is ready to rock again.
 511  *
 512  * NOTE: if we are in the process of bringing up or down the
 513  *       communication with the device [running i2400m_dev_start() or
 514  *       _stop()], don't do anything, let it fail and handle it.
 515  *
 516  * This function is ran always in a thread context
 517  */
 518 static
 519 void __i2400m_dev_reset_handle(struct work_struct *ws)
 520 {
 521         int result;
 522         struct i2400m_work *iw = container_of(ws, struct i2400m_work, ws);
 523         struct i2400m *i2400m = iw->i2400m;
 524         struct device *dev = i2400m_dev(i2400m);
 525         enum wimax_st wimax_state;
 526         struct i2400m_reset_ctx *ctx = i2400m->reset_ctx;
 527
 528         d_fnstart(3, dev, "(ws %p i2400m %p)\n", ws, i2400m);
 529         result = 0;
 530         if (mutex_trylock(&i2400m->init_mutex) == 0) {
 531                 /* We are still in i2400m_dev_start() [let it fail] or
 532                  * i2400m_dev_stop() [we are shutting down anyway, so
 533                  * ignore it] or we are resetting somewhere else. */
 534                 dev_err(dev, "device rebooted\n");
 535                 i2400m_msg_to_dev_cancel_wait(i2400m, -ERESTARTSYS);
 536                 complete(&i2400m->msg_completion);
 537                 goto out;
 538         }
 539         wimax_state = wimax_state_get(&i2400m->wimax_dev);
 540         if (wimax_state < WIMAX_ST_UNINITIALIZED) {
 541                 dev_info(dev, "device rebooted: it is down, ignoring\n");
 542                 goto out_unlock;        /* ifconfig up/down wasn't called */
 543         }
 544         dev_err(dev, "device rebooted: reinitializing driver\n");
 545         __i2400m_dev_stop(i2400m);
 546         i2400m->updown = 0;
 547         result = __i2400m_dev_start(i2400m,
 548                                     I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT);
 549         if (result < 0) {
 550                 dev_err(dev, "device reboot: cannot start the device: %d\n",
 551                         result);
 552                 result = i2400m->bus_reset(i2400m, I2400M_RT_BUS);
 553                 if (result >= 0)
 554                         result = -ENODEV;
 555         } else
 556                 i2400m->updown = 1;
 557 out_unlock:
 558         if (i2400m->reset_ctx) {
 559                 ctx->result = result;
 560                 complete(&ctx->completion);
 561         }
 562         mutex_unlock(&i2400m->init_mutex);
 563 out:
 564         i2400m_put(i2400m);
 565         kfree(iw);
 566         d_fnend(3, dev, "(ws %p i2400m %p) = void\n", ws, i2400m);
 567         return;
 568 }
 569
 570
 571 /**
 572  * i2400m_dev_reset_handle - Handle a device's reset in a thread context
 573  *
 574  * Schedule a device reset handling out on a thread context, so it
 575  * is safe to call from atomic context. We can't use the i2400m's
 576  * queue as we are going to destroy it and reinitialize it as part of
 577  * the driver bringup/bringup process.
 578  *
 579  * See __i2400m_dev_reset_handle() for details; that takes care of
 580  * reinitializing the driver to handle the reset, calling into the
 581  * bus-specific functions ops as needed.
 582  */
 583 int i2400m_dev_reset_handle(struct i2400m *i2400m)
 584 {
 585         return i2400m_schedule_work(i2400m, __i2400m_dev_reset_handle,
 586                                     GFP_ATOMIC);
 587 }
 588 EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle);
 589
 590
 591 /**
 592  * i2400m_setup - bus-generic setup function for the i2400m device
 593  *
 594  * @i2400m: device descriptor (bus-specific parts have been initialized)
 595  *
 596  * Returns: 0 if ok, < 0 errno code on error.
 597  *
 598  * Initializes the bus-generic parts of the i2400m driver; the
 599  * bus-specific parts have been initialized, function pointers filled
 600  * out by the bus-specific probe function.
 601  *
 602  * As well, this registers the WiMAX and net device nodes. Once this
 603  * function returns, the device is operative and has to be ready to
 604  * receive and send network traffic and WiMAX control operations.
 605  */
 606 int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
 607 {
 608         int result = -ENODEV;
 609         struct device *dev = i2400m_dev(i2400m);
 610         struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
 611         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
 612
 613         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 614
 615         snprintf(wimax_dev->name, sizeof(wimax_dev->name),
 616                  "i2400m-%s:%s", dev->bus->name, dev->bus_id);
 617
 618         i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
 619         if (i2400m->bm_cmd_buf == NULL) {
 620                 dev_err(dev, "cannot allocate USB command buffer\n");
 621                 goto error_bm_cmd_kzalloc;
 622         }
 623         i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);
 624         if (i2400m->bm_ack_buf == NULL) {
 625                 dev_err(dev, "cannot allocate USB ack buffer\n");
 626                 goto error_bm_ack_buf_kzalloc;
 627         }
 628         result = i2400m_bootrom_init(i2400m, bm_flags);
 629         if (result < 0) {
 630                 dev_err(dev, "read mac addr: bootrom init "
 631                         "failed: %d\n", result);
 632                 goto error_bootrom_init;
 633         }
 634         result = i2400m_read_mac_addr(i2400m);
 635         if (result < 0)
 636                 goto error_read_mac_addr;
 637
 638         result = register_netdev(net_dev);      /* Okey dokey, bring it up */
 639         if (result < 0) {
 640                 dev_err(dev, "cannot register i2400m network device: %d\n",
 641                         result);
 642                 goto error_register_netdev;
 643         }
 644         netif_carrier_off(net_dev);
 645
 646         result = i2400m_dev_start(i2400m, bm_flags);
 647         if (result < 0)
 648                 goto error_dev_start;
 649
 650         i2400m->wimax_dev.op_msg_from_user = i2400m_op_msg_from_user;
 651         i2400m->wimax_dev.op_rfkill_sw_toggle = i2400m_op_rfkill_sw_toggle;
 652         i2400m->wimax_dev.op_reset = i2400m_op_reset;
 653         result = wimax_dev_add(&i2400m->wimax_dev, net_dev);
 654         if (result < 0)
 655                 goto error_wimax_dev_add;
 656         /* User space needs to do some init stuff */
 657         wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED);
 658
 659         /* Now setup all that requires a registered net and wimax device. */
 660         result = i2400m_debugfs_add(i2400m);
 661         if (result < 0) {
 662                 dev_err(dev, "cannot setup i2400m's debugfs: %d\n", result);
 663                 goto error_debugfs_setup;
 664         }
 665         d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
 666         return result;
 667
 668 error_debugfs_setup:
 669         wimax_dev_rm(&i2400m->wimax_dev);
 670 error_wimax_dev_add:
 671         i2400m_dev_stop(i2400m);
 672 error_dev_start:
 673         unregister_netdev(net_dev);
 674 error_register_netdev:
 675 error_read_mac_addr:
 676 error_bootrom_init:
 677         kfree(i2400m->bm_ack_buf);
 678 error_bm_ack_buf_kzalloc:
 679         kfree(i2400m->bm_cmd_buf);
 680 error_bm_cmd_kzalloc:
 681         d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
 682         return result;
 683 }
 684 EXPORT_SYMBOL_GPL(i2400m_setup);
 685
 686
 687 /**
 688  * i2400m_release - release the bus-generic driver resources
 689  *
 690  * Sends a disconnect message and undoes any setup done by i2400m_setup()
 691  */
 692 void i2400m_release(struct i2400m *i2400m)
 693 {
 694         struct device *dev = i2400m_dev(i2400m);
 695
 696         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 697         netif_stop_queue(i2400m->wimax_dev.net_dev);
 698
 699         i2400m_debugfs_rm(i2400m);
 700         wimax_dev_rm(&i2400m->wimax_dev);
 701         i2400m_dev_stop(i2400m);
 702         unregister_netdev(i2400m->wimax_dev.net_dev);
 703         kfree(i2400m->bm_ack_buf);
 704         kfree(i2400m->bm_cmd_buf);
 705         d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
 706 }
 707 EXPORT_SYMBOL_GPL(i2400m_release);
 708
 709
 710 /*
 711  * Debug levels control; see debug.h
 712  */
 713 struct d_level D_LEVEL[] = {
 714         D_SUBMODULE_DEFINE(control),
 715         D_SUBMODULE_DEFINE(driver),
 716         D_SUBMODULE_DEFINE(debugfs),
 717         D_SUBMODULE_DEFINE(fw),
 718         D_SUBMODULE_DEFINE(netdev),
 719         D_SUBMODULE_DEFINE(rfkill),
 720         D_SUBMODULE_DEFINE(rx),
 721         D_SUBMODULE_DEFINE(tx),
 722 };
 723 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
 724
 725
 726 static
 727 int __init i2400m_driver_init(void)
 728 {
 729         return 0;
 730 }
 731 module_init(i2400m_driver_init);
 732
 733 static
 734 void __exit i2400m_driver_exit(void)
 735 {
 736         /* for scheds i2400m_dev_reset_handle() */
 737         flush_scheduled_work();
 738         return;
 739 }
 740 module_exit(i2400m_driver_exit);
 741
 742 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
 743 MODULE_DESCRIPTION("Intel 2400M WiMAX networking bus-generic driver");
 744 MODULE_LICENSE("GPL");