2 * Intel Wireless WiMAX Connection 2400m
3 * Generic probe/disconnect, reset and message passing
6 * Copyright (C) 2007-2008 Intel Corporation <linux-wimax@intel.com>
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
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()].
31 * i2400m_op_msg_from_user()
33 * wimax_msg_to_user_send()
38 * i2400m_dev_reset_handle()
39 * __i2400m_dev_reset_handle()
41 * __i2400m_dev_start()
45 * i2400m_bootrom_init()
49 * __i2400m_dev_start()
50 * i2400m_dev_bootstrap()
52 * i2400m->bus_dev_start()
53 * i2400m_firmware_check()
54 * i2400m_check_mac_addr()
59 * i2400m_dev_shutdown()
60 * i2400m->bus_dev_stop()
62 * i2400m->bus_release()
67 #include <linux/etherdevice.h>
68 #include <linux/wimax/i2400m.h>
69 #include <linux/module.h>
70 #include <linux/moduleparam.h>
71 #include <linux/suspend.h>
73 #define D_SUBMODULE driver
74 #include "debug-levels.h"
77 int i2400m_idle_mode_disabled; /* 0 (idle mode enabled) by default */
78 module_param_named(idle_mode_disabled, i2400m_idle_mode_disabled, int, 0644);
79 MODULE_PARM_DESC(idle_mode_disabled,
80 "If true, the device will not enable idle mode negotiation "
81 "with the base station (when connected) to save power.");
83 int i2400m_rx_reorder_disabled; /* 0 (rx reorder enabled) by default */
84 module_param_named(rx_reorder_disabled, i2400m_rx_reorder_disabled, int, 0644);
85 MODULE_PARM_DESC(rx_reorder_disabled,
86 "If true, RX reordering will be disabled.");
88 int i2400m_power_save_disabled; /* 0 (power saving enabled) by default */
89 module_param_named(power_save_disabled, i2400m_power_save_disabled, int, 0644);
90 MODULE_PARM_DESC(power_save_disabled,
91 "If true, the driver will not tell the device to enter "
92 "power saving mode when it reports it is ready for it. "
93 "False by default (so the device is told to do power "
96 static char i2400m_debug_params[128];
97 module_param_string(debug, i2400m_debug_params, sizeof(i2400m_debug_params),
99 MODULE_PARM_DESC(debug,
100 "String of space-separated NAME:VALUE pairs, where NAMEs "
101 "are the different debug submodules and VALUE are the "
102 "initial debug value to set.");
104 static char i2400m_barkers_params[128];
105 module_param_string(barkers, i2400m_barkers_params,
106 sizeof(i2400m_barkers_params), 0644);
107 MODULE_PARM_DESC(barkers,
108 "String of comma-separated 32-bit values; each is "
109 "recognized as the value the device sends as a reboot "
110 "signal; values are appended to a list--setting one value "
111 "as zero cleans the existing list and starts a new one.");
114 struct i2400m_work *__i2400m_work_setup(
115 struct i2400m *i2400m, void (*fn)(struct work_struct *),
116 gfp_t gfp_flags, const void *pl, size_t pl_size)
118 struct i2400m_work *iw;
120 iw = kzalloc(sizeof(*iw) + pl_size, gfp_flags);
123 iw->i2400m = i2400m_get(i2400m);
124 iw->pl_size = pl_size;
125 memcpy(iw->pl, pl, pl_size);
126 INIT_WORK(&iw->ws, fn);
132 * i2400m_queue_work - schedule work on a i2400m's queue
134 * @i2400m: device descriptor
136 * @fn: function to run to execute work. It gets passed a 'struct
137 * work_struct' that is wrapped in a 'struct i2400m_work'. Once
138 * done, you have to (1) i2400m_put(i2400m_work->i2400m) and then
139 * (2) kfree(i2400m_work).
141 * @gfp_flags: GFP flags for memory allocation.
143 * @pl: pointer to a payload buffer that you want to pass to the _work
144 * function. Use this to pack (for example) a struct with extra
147 * @pl_size: size of the payload buffer.
149 * We do this quite often, so this just saves typing; allocate a
150 * wrapper for a i2400m, get a ref to it, pack arguments and launch
153 * A usual workflow is:
155 * struct my_work_args {
161 * struct my_work_args my_args = {
165 * i2400m_queue_work(i2400m, 1, my_work_function, GFP_KERNEL,
166 * &args, sizeof(args))
168 * And now the work function can unpack the arguments and call the
169 * real function (or do the job itself):
172 * void my_work_fn((struct work_struct *ws)
174 * struct i2400m_work *iw =
175 * container_of(ws, struct i2400m_work, ws);
176 * struct my_work_args *my_args = (void *) iw->pl;
178 * my_work(iw->i2400m, my_args->something, my_args->whatevert);
181 int i2400m_queue_work(struct i2400m *i2400m,
182 void (*fn)(struct work_struct *), gfp_t gfp_flags,
183 const void *pl, size_t pl_size)
186 struct i2400m_work *iw;
188 BUG_ON(i2400m->work_queue == NULL);
190 iw = __i2400m_work_setup(i2400m, fn, gfp_flags, pl, pl_size);
192 result = queue_work(i2400m->work_queue, &iw->ws);
193 if (WARN_ON(result == 0))
198 EXPORT_SYMBOL_GPL(i2400m_queue_work);
202 * Schedule i2400m's specific work on the system's queue.
204 * Used for a few cases where we really need it; otherwise, identical
205 * to i2400m_queue_work().
207 * Returns < 0 errno code on error, 1 if ok.
209 * If it returns zero, something really bad happened, as it means the
210 * works struct was already queued, but we have just allocated it, so
211 * it should not happen.
213 int i2400m_schedule_work(struct i2400m *i2400m,
214 void (*fn)(struct work_struct *), gfp_t gfp_flags,
215 const void *pl, size_t pl_size)
218 struct i2400m_work *iw;
221 iw = __i2400m_work_setup(i2400m, fn, gfp_flags, pl, pl_size);
223 result = schedule_work(&iw->ws);
224 if (WARN_ON(result == 0))
232 * WiMAX stack operation: relay a message from user space
234 * @wimax_dev: device descriptor
235 * @pipe_name: named pipe the message is for
236 * @msg_buf: pointer to the message bytes
237 * @msg_len: length of the buffer
238 * @genl_info: passed by the generic netlink layer
240 * The WiMAX stack will call this function when a message was received
243 * For the i2400m, this is an L3L4 message, as specified in
244 * include/linux/wimax/i2400m.h, and thus prefixed with a 'struct
245 * i2400m_l3l4_hdr'. Driver (and device) expect the messages to be
246 * coded in Little Endian.
248 * This function just verifies that the header declaration and the
249 * payload are consistent and then deals with it, either forwarding it
250 * to the device or procesing it locally.
252 * In the i2400m, messages are basically commands that will carry an
253 * ack, so we use i2400m_msg_to_dev() and then deliver the ack back to
254 * user space. The rx.c code might intercept the response and use it
255 * to update the driver's state, but then it will pass it on so it can
256 * be relayed back to user space.
258 * Note that asynchronous events from the device are processed and
259 * sent to user space in rx.c.
262 int i2400m_op_msg_from_user(struct wimax_dev *wimax_dev,
263 const char *pipe_name,
264 const void *msg_buf, size_t msg_len,
265 const struct genl_info *genl_info)
268 struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev);
269 struct device *dev = i2400m_dev(i2400m);
270 struct sk_buff *ack_skb;
272 d_fnstart(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p "
273 "msg_len %zu genl_info %p)\n", wimax_dev, i2400m,
274 msg_buf, msg_len, genl_info);
275 ack_skb = i2400m_msg_to_dev(i2400m, msg_buf, msg_len);
276 result = PTR_ERR(ack_skb);
278 goto error_msg_to_dev;
279 result = wimax_msg_send(&i2400m->wimax_dev, ack_skb);
281 d_fnend(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p msg_len %zu "
282 "genl_info %p) = %d\n", wimax_dev, i2400m, msg_buf, msg_len,
289 * Context to wait for a reset to finalize
291 struct i2400m_reset_ctx {
292 struct completion completion;
298 * WiMAX stack operation: reset a device
300 * @wimax_dev: device descriptor
302 * See the documentation for wimax_reset() and wimax_dev->op_reset for
303 * the requirements of this function. The WiMAX stack guarantees
304 * serialization on calls to this function.
306 * Do a warm reset on the device; if it fails, resort to a cold reset
307 * and return -ENODEV. On successful warm reset, we need to block
308 * until it is complete.
310 * The bus-driver implementation of reset takes care of falling back
311 * to cold reset if warm fails.
314 int i2400m_op_reset(struct wimax_dev *wimax_dev)
317 struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev);
318 struct device *dev = i2400m_dev(i2400m);
319 struct i2400m_reset_ctx ctx = {
320 .completion = COMPLETION_INITIALIZER_ONSTACK(ctx.completion),
324 d_fnstart(4, dev, "(wimax_dev %p)\n", wimax_dev);
325 mutex_lock(&i2400m->init_mutex);
326 i2400m->reset_ctx = &ctx;
327 mutex_unlock(&i2400m->init_mutex);
328 result = i2400m->bus_reset(i2400m, I2400M_RT_WARM);
331 result = wait_for_completion_timeout(&ctx.completion, 4*HZ);
336 /* if result < 0, pass it on */
337 mutex_lock(&i2400m->init_mutex);
338 i2400m->reset_ctx = NULL;
339 mutex_unlock(&i2400m->init_mutex);
341 d_fnend(4, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
347 * Check the MAC address we got from boot mode is ok
349 * @i2400m: device descriptor
351 * Returns: 0 if ok, < 0 errno code on error.
354 int i2400m_check_mac_addr(struct i2400m *i2400m)
357 struct device *dev = i2400m_dev(i2400m);
359 const struct i2400m_tlv_detailed_device_info *ddi;
360 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
361 const unsigned char zeromac[ETH_ALEN] = { 0 };
363 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
364 skb = i2400m_get_device_info(i2400m);
366 result = PTR_ERR(skb);
367 dev_err(dev, "Cannot verify MAC address, error reading: %d\n",
371 /* Extract MAC addresss */
372 ddi = (void *) skb->data;
373 BUILD_BUG_ON(ETH_ALEN != sizeof(ddi->mac_address));
374 d_printf(2, dev, "GET DEVICE INFO: mac addr "
375 "%02x:%02x:%02x:%02x:%02x:%02x\n",
376 ddi->mac_address[0], ddi->mac_address[1],
377 ddi->mac_address[2], ddi->mac_address[3],
378 ddi->mac_address[4], ddi->mac_address[5]);
379 if (!memcmp(net_dev->perm_addr, ddi->mac_address,
380 sizeof(ddi->mac_address)))
382 dev_warn(dev, "warning: device reports a different MAC address "
383 "to that of boot mode's\n");
384 dev_warn(dev, "device reports %02x:%02x:%02x:%02x:%02x:%02x\n",
385 ddi->mac_address[0], ddi->mac_address[1],
386 ddi->mac_address[2], ddi->mac_address[3],
387 ddi->mac_address[4], ddi->mac_address[5]);
388 dev_warn(dev, "boot mode reported %02x:%02x:%02x:%02x:%02x:%02x\n",
389 net_dev->perm_addr[0], net_dev->perm_addr[1],
390 net_dev->perm_addr[2], net_dev->perm_addr[3],
391 net_dev->perm_addr[4], net_dev->perm_addr[5]);
392 if (!memcmp(zeromac, ddi->mac_address, sizeof(zeromac)))
393 dev_err(dev, "device reports an invalid MAC address, "
396 dev_warn(dev, "updating MAC address\n");
397 net_dev->addr_len = ETH_ALEN;
398 memcpy(net_dev->perm_addr, ddi->mac_address, ETH_ALEN);
399 memcpy(net_dev->dev_addr, ddi->mac_address, ETH_ALEN);
405 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
411 * __i2400m_dev_start - Bring up driver communication with the device
413 * @i2400m: device descriptor
414 * @flags: boot mode flags
416 * Returns: 0 if ok, < 0 errno code on error.
418 * Uploads firmware and brings up all the resources needed to be able
419 * to communicate with the device.
421 * The workqueue has to be setup early, at least before RX handling
422 * (it's only real user for now) so it can process reports as they
423 * arrive. We also want to destroy it if we retry, to make sure it is
424 * flushed...easier like this.
426 * TX needs to be setup before the bus-specific code (otherwise on
427 * shutdown, the bus-tx code could try to access it).
430 int __i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri flags)
433 struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
434 struct net_device *net_dev = wimax_dev->net_dev;
435 struct device *dev = i2400m_dev(i2400m);
436 int times = i2400m->bus_bm_retries;
438 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
440 result = i2400m_dev_bootstrap(i2400m, flags);
442 dev_err(dev, "cannot bootstrap device: %d\n", result);
443 goto error_bootstrap;
445 result = i2400m_tx_setup(i2400m);
448 result = i2400m_rx_setup(i2400m);
451 i2400m->work_queue = create_singlethread_workqueue(wimax_dev->name);
452 if (i2400m->work_queue == NULL) {
454 dev_err(dev, "cannot create workqueue\n");
455 goto error_create_workqueue;
457 result = i2400m->bus_dev_start(i2400m);
459 goto error_bus_dev_start;
461 wmb(); /* see i2400m->ready's documentation */
462 result = i2400m_firmware_check(i2400m); /* fw versions ok? */
465 /* At this point is ok to send commands to the device */
466 result = i2400m_check_mac_addr(i2400m);
468 goto error_check_mac_addr;
469 wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED);
470 result = i2400m_dev_initialize(i2400m);
472 goto error_dev_initialize;
473 /* At this point, reports will come for the device and set it
474 * to the right state if it is different than UNINITIALIZED */
475 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
476 net_dev, i2400m, result);
479 error_dev_initialize:
480 error_check_mac_addr:
482 wmb(); /* see i2400m->ready's documentation */
483 flush_workqueue(i2400m->work_queue);
485 i2400m->bus_dev_stop(i2400m);
487 destroy_workqueue(i2400m->work_queue);
488 error_create_workqueue:
489 i2400m_rx_release(i2400m);
491 i2400m_tx_release(i2400m);
494 if (result == -EL3RST && times-- > 0) {
495 flags = I2400M_BRI_SOFT|I2400M_BRI_MAC_REINIT;
498 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
499 net_dev, i2400m, result);
505 int i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri bm_flags)
508 mutex_lock(&i2400m->init_mutex); /* Well, start the device */
509 if (i2400m->updown == 0) {
510 result = __i2400m_dev_start(i2400m, bm_flags);
513 wmb(); /* see i2400m->updown's documentation */
516 mutex_unlock(&i2400m->init_mutex);
522 * i2400m_dev_stop - Tear down driver communication with the device
524 * @i2400m: device descriptor
526 * Returns: 0 if ok, < 0 errno code on error.
528 * Releases all the resources allocated to communicate with the
529 * device. Note we cannot destroy the workqueue earlier as until RX is
530 * fully destroyed, it could still try to schedule jobs.
533 void __i2400m_dev_stop(struct i2400m *i2400m)
535 struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
536 struct device *dev = i2400m_dev(i2400m);
538 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
539 wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING);
540 i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST);
541 complete(&i2400m->msg_completion);
542 i2400m_net_wake_stop(i2400m);
543 i2400m_dev_shutdown(i2400m);
545 * Make sure no report hooks are running *before* we stop the
546 * communication infrastructure with the device.
548 i2400m->ready = 0; /* nobody can queue work anymore */
549 wmb(); /* see i2400m->ready's documentation */
550 flush_workqueue(i2400m->work_queue);
552 i2400m->bus_dev_stop(i2400m);
553 destroy_workqueue(i2400m->work_queue);
554 i2400m_rx_release(i2400m);
555 i2400m_tx_release(i2400m);
556 wimax_state_change(wimax_dev, WIMAX_ST_DOWN);
557 d_fnend(3, dev, "(i2400m %p) = 0\n", i2400m);
562 * Watch out -- we only need to stop if there is a need for it. The
563 * device could have reset itself and failed to come up again (see
564 * _i2400m_dev_reset_handle()).
567 void i2400m_dev_stop(struct i2400m *i2400m)
569 mutex_lock(&i2400m->init_mutex);
570 if (i2400m->updown) {
571 __i2400m_dev_stop(i2400m);
573 wmb(); /* see i2400m->updown's documentation */
575 mutex_unlock(&i2400m->init_mutex);
580 * Listen to PM events to cache the firmware before suspend/hibernation
582 * When the device comes out of suspend, it might go into reset and
583 * firmware has to be uploaded again. At resume, most of the times, we
584 * can't load firmware images from disk, so we need to cache it.
586 * i2400m_fw_cache() will allocate a kobject and attach the firmware
587 * to it; that way we don't have to worry too much about the fw loader
588 * hitting a race condition.
590 * Note: modus operandi stolen from the Orinoco driver; thx.
593 int i2400m_pm_notifier(struct notifier_block *notifier,
594 unsigned long pm_event,
597 struct i2400m *i2400m =
598 container_of(notifier, struct i2400m, pm_notifier);
599 struct device *dev = i2400m_dev(i2400m);
601 d_fnstart(3, dev, "(i2400m %p pm_event %lx)\n", i2400m, pm_event);
603 case PM_HIBERNATION_PREPARE:
604 case PM_SUSPEND_PREPARE:
605 i2400m_fw_cache(i2400m);
607 case PM_POST_RESTORE:
608 /* Restore from hibernation failed. We need to clean
609 * up in exactly the same way, so fall through. */
610 case PM_POST_HIBERNATION:
611 case PM_POST_SUSPEND:
612 i2400m_fw_uncache(i2400m);
615 case PM_RESTORE_PREPARE:
619 d_fnend(3, dev, "(i2400m %p pm_event %lx) = void\n", i2400m, pm_event);
625 * pre-reset is called before a device is going on reset
627 * This has to be followed by a call to i2400m_post_reset(), otherwise
628 * bad things might happen.
630 int i2400m_pre_reset(struct i2400m *i2400m)
633 struct device *dev = i2400m_dev(i2400m);
635 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
636 d_printf(1, dev, "pre-reset shut down\n");
639 mutex_lock(&i2400m->init_mutex);
640 if (i2400m->updown) {
641 netif_tx_disable(i2400m->wimax_dev.net_dev);
642 __i2400m_dev_stop(i2400m);
644 /* down't set updown to zero -- this way
645 * post_reset can restore properly */
647 mutex_unlock(&i2400m->init_mutex);
648 if (i2400m->bus_release)
649 i2400m->bus_release(i2400m);
650 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
653 EXPORT_SYMBOL_GPL(i2400m_pre_reset);
657 * Restore device state after a reset
659 * Do the work needed after a device reset to bring it up to the same
660 * state as it was before the reset.
662 * NOTE: this requires i2400m->init_mutex taken
664 int i2400m_post_reset(struct i2400m *i2400m)
667 struct device *dev = i2400m_dev(i2400m);
669 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
670 d_printf(1, dev, "post-reset start\n");
671 if (i2400m->bus_setup) {
672 result = i2400m->bus_setup(i2400m);
674 dev_err(dev, "bus-specific setup failed: %d\n",
676 goto error_bus_setup;
679 mutex_lock(&i2400m->init_mutex);
680 if (i2400m->updown) {
681 result = __i2400m_dev_start(
682 i2400m, I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT);
684 goto error_dev_start;
686 mutex_unlock(&i2400m->init_mutex);
687 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
691 if (i2400m->bus_release)
692 i2400m->bus_release(i2400m);
694 /* even if the device was up, it could not be recovered, so we
695 * mark it as down. */
697 wmb(); /* see i2400m->updown's documentation */
698 mutex_unlock(&i2400m->init_mutex);
699 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
702 EXPORT_SYMBOL_GPL(i2400m_post_reset);
706 * The device has rebooted; fix up the device and the driver
708 * Tear down the driver communication with the device, reload the
709 * firmware and reinitialize the communication with the device.
711 * If someone calls a reset when the device's firmware is down, in
712 * theory we won't see it because we are not listening. However, just
713 * in case, leave the code to handle it.
715 * If there is a reset context, use it; this means someone is waiting
716 * for us to tell him when the reset operation is complete and the
717 * device is ready to rock again.
719 * NOTE: if we are in the process of bringing up or down the
720 * communication with the device [running i2400m_dev_start() or
721 * _stop()], don't do anything, let it fail and handle it.
723 * This function is ran always in a thread context
725 * This function gets passed, as payload to i2400m_work() a 'const
726 * char *' ptr with a "reason" why the reset happened (for messages).
729 void __i2400m_dev_reset_handle(struct work_struct *ws)
732 struct i2400m_work *iw = container_of(ws, struct i2400m_work, ws);
734 struct i2400m *i2400m = iw->i2400m;
735 struct device *dev = i2400m_dev(i2400m);
736 struct i2400m_reset_ctx *ctx = i2400m->reset_ctx;
738 if (WARN_ON(iw->pl_size != sizeof(reason)))
739 reason = "SW BUG: reason n/a";
741 memcpy(&reason, iw->pl, sizeof(reason));
743 d_fnstart(3, dev, "(ws %p i2400m %p reason %s)\n", ws, i2400m, reason);
746 if (mutex_trylock(&i2400m->init_mutex) == 0) {
747 /* We are still in i2400m_dev_start() [let it fail] or
748 * i2400m_dev_stop() [we are shutting down anyway, so
749 * ignore it] or we are resetting somewhere else. */
750 dev_err(dev, "device rebooted somewhere else?\n");
751 i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST);
752 complete(&i2400m->msg_completion);
755 if (i2400m->updown == 0) {
756 dev_info(dev, "%s: device is down, doing nothing\n", reason);
759 dev_err(dev, "%s: reinitializing driver\n", reason);
760 __i2400m_dev_stop(i2400m);
761 result = __i2400m_dev_start(i2400m,
762 I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT);
765 wmb(); /* see i2400m->updown's documentation */
766 dev_err(dev, "%s: cannot start the device: %d\n",
768 result = i2400m->bus_reset(i2400m, I2400M_RT_BUS);
773 if (i2400m->reset_ctx) {
774 ctx->result = result;
775 complete(&ctx->completion);
777 mutex_unlock(&i2400m->init_mutex);
781 d_fnend(3, dev, "(ws %p i2400m %p reason %s) = void\n",
788 * i2400m_dev_reset_handle - Handle a device's reset in a thread context
790 * Schedule a device reset handling out on a thread context, so it
791 * is safe to call from atomic context. We can't use the i2400m's
792 * queue as we are going to destroy it and reinitialize it as part of
793 * the driver bringup/bringup process.
795 * See __i2400m_dev_reset_handle() for details; that takes care of
796 * reinitializing the driver to handle the reset, calling into the
797 * bus-specific functions ops as needed.
799 int i2400m_dev_reset_handle(struct i2400m *i2400m, const char *reason)
801 i2400m->boot_mode = 1;
802 wmb(); /* Make sure i2400m_msg_to_dev() sees boot_mode */
803 return i2400m_schedule_work(i2400m, __i2400m_dev_reset_handle,
804 GFP_ATOMIC, &reason, sizeof(reason));
806 EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle);
810 * Alloc the command and ack buffers for boot mode
812 * Get the buffers needed to deal with boot mode messages. These
813 * buffers need to be allocated before the sdio recieve irq is setup.
816 int i2400m_bm_buf_alloc(struct i2400m *i2400m)
821 i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
822 if (i2400m->bm_cmd_buf == NULL)
823 goto error_bm_cmd_kzalloc;
824 i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);
825 if (i2400m->bm_ack_buf == NULL)
826 goto error_bm_ack_buf_kzalloc;
829 error_bm_ack_buf_kzalloc:
830 kfree(i2400m->bm_cmd_buf);
831 error_bm_cmd_kzalloc:
837 * Free boot mode command and ack buffers.
840 void i2400m_bm_buf_free(struct i2400m *i2400m)
842 kfree(i2400m->bm_ack_buf);
843 kfree(i2400m->bm_cmd_buf);
848 * i2400m_setup - bus-generic setup function for the i2400m device
850 * @i2400m: device descriptor (bus-specific parts have been initialized)
852 * Returns: 0 if ok, < 0 errno code on error.
854 * Sets up basic device comunication infrastructure, boots the ROM to
855 * read the MAC address, registers with the WiMAX and network stacks
856 * and then brings up the device.
858 int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
860 int result = -ENODEV;
861 struct device *dev = i2400m_dev(i2400m);
862 struct wimax_dev *wimax_dev = &i2400m->wimax_dev;
863 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
865 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
867 snprintf(wimax_dev->name, sizeof(wimax_dev->name),
868 "i2400m-%s:%s", dev->bus->name, dev_name(dev));
870 result = i2400m_bm_buf_alloc(i2400m);
872 dev_err(dev, "cannot allocate bootmode scratch buffers\n");
873 goto error_bm_buf_alloc;
876 if (i2400m->bus_setup) {
877 result = i2400m->bus_setup(i2400m);
879 dev_err(dev, "bus-specific setup failed: %d\n",
881 goto error_bus_setup;
885 result = i2400m_bootrom_init(i2400m, bm_flags);
887 dev_err(dev, "read mac addr: bootrom init "
888 "failed: %d\n", result);
889 goto error_bootrom_init;
891 result = i2400m_read_mac_addr(i2400m);
893 goto error_read_mac_addr;
894 random_ether_addr(i2400m->src_mac_addr);
896 i2400m->pm_notifier.notifier_call = i2400m_pm_notifier;
897 register_pm_notifier(&i2400m->pm_notifier);
899 result = register_netdev(net_dev); /* Okey dokey, bring it up */
901 dev_err(dev, "cannot register i2400m network device: %d\n",
903 goto error_register_netdev;
905 netif_carrier_off(net_dev);
907 i2400m->wimax_dev.op_msg_from_user = i2400m_op_msg_from_user;
908 i2400m->wimax_dev.op_rfkill_sw_toggle = i2400m_op_rfkill_sw_toggle;
909 i2400m->wimax_dev.op_reset = i2400m_op_reset;
911 result = wimax_dev_add(&i2400m->wimax_dev, net_dev);
913 goto error_wimax_dev_add;
915 /* Now setup all that requires a registered net and wimax device. */
916 result = sysfs_create_group(&net_dev->dev.kobj, &i2400m_dev_attr_group);
918 dev_err(dev, "cannot setup i2400m's sysfs: %d\n", result);
919 goto error_sysfs_setup;
922 result = i2400m_debugfs_add(i2400m);
924 dev_err(dev, "cannot setup i2400m's debugfs: %d\n", result);
925 goto error_debugfs_setup;
928 result = i2400m_dev_start(i2400m, bm_flags);
930 goto error_dev_start;
931 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
935 i2400m_debugfs_rm(i2400m);
937 sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj,
938 &i2400m_dev_attr_group);
940 wimax_dev_rm(&i2400m->wimax_dev);
942 unregister_netdev(net_dev);
943 error_register_netdev:
944 unregister_pm_notifier(&i2400m->pm_notifier);
947 if (i2400m->bus_release)
948 i2400m->bus_release(i2400m);
950 i2400m_bm_buf_free(i2400m);
952 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
955 EXPORT_SYMBOL_GPL(i2400m_setup);
959 * i2400m_release - release the bus-generic driver resources
961 * Sends a disconnect message and undoes any setup done by i2400m_setup()
963 void i2400m_release(struct i2400m *i2400m)
965 struct device *dev = i2400m_dev(i2400m);
967 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
968 netif_stop_queue(i2400m->wimax_dev.net_dev);
970 i2400m_dev_stop(i2400m);
972 i2400m_debugfs_rm(i2400m);
973 sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj,
974 &i2400m_dev_attr_group);
975 wimax_dev_rm(&i2400m->wimax_dev);
976 unregister_netdev(i2400m->wimax_dev.net_dev);
977 unregister_pm_notifier(&i2400m->pm_notifier);
978 if (i2400m->bus_release)
979 i2400m->bus_release(i2400m);
980 i2400m_bm_buf_free(i2400m);
981 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
983 EXPORT_SYMBOL_GPL(i2400m_release);
987 * Debug levels control; see debug.h
989 struct d_level D_LEVEL[] = {
990 D_SUBMODULE_DEFINE(control),
991 D_SUBMODULE_DEFINE(driver),
992 D_SUBMODULE_DEFINE(debugfs),
993 D_SUBMODULE_DEFINE(fw),
994 D_SUBMODULE_DEFINE(netdev),
995 D_SUBMODULE_DEFINE(rfkill),
996 D_SUBMODULE_DEFINE(rx),
997 D_SUBMODULE_DEFINE(sysfs),
998 D_SUBMODULE_DEFINE(tx),
1000 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
1004 int __init i2400m_driver_init(void)
1006 d_parse_params(D_LEVEL, D_LEVEL_SIZE, i2400m_debug_params,
1008 return i2400m_barker_db_init(i2400m_barkers_params);
1010 module_init(i2400m_driver_init);
1013 void __exit i2400m_driver_exit(void)
1015 /* for scheds i2400m_dev_reset_handle() */
1016 flush_scheduled_work();
1017 i2400m_barker_db_exit();
1020 module_exit(i2400m_driver_exit);
1022 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
1023 MODULE_DESCRIPTION("Intel 2400M WiMAX networking bus-generic driver");
1024 MODULE_LICENSE("GPL");