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