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()
44 * i2400m_bootrom_init()
47 * __i2400m_dev_start()
48 * i2400m_dev_bootstrap()
50 * i2400m->bus_dev_start()
51 * i2400m_check_mac_addr()
58 * i2400m_dev_shutdown()
59 * i2400m->bus_dev_stop()
64 #include <linux/wimax/i2400m.h>
65 #include <linux/module.h>
66 #include <linux/moduleparam.h>
68 #define D_SUBMODULE driver
69 #include "debug-levels.h"
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.");
79 * i2400m_queue_work - schedule work on a i2400m's queue
81 * @i2400m: device descriptor
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).
88 * @gfp_flags: GFP flags for memory allocation.
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
94 * @pl_size: size of the payload buffer.
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
100 * A usual workflow is:
102 * struct my_work_args {
108 * struct my_work_args my_args = {
112 * i2400m_queue_work(i2400m, 1, my_work_function, GFP_KERNEL,
113 * &args, sizeof(args))
115 * And now the work function can unpack the arguments and call the
116 * real function (or do the job itself):
119 * void my_work_fn((struct work_struct *ws)
121 * struct i2400m_work *iw =
122 * container_of(ws, struct i2400m_work, ws);
123 * struct my_work_args *my_args = (void *) iw->pl;
125 * my_work(iw->i2400m, my_args->something, my_args->whatevert);
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
)
133 struct i2400m_work
*iw
;
135 BUG_ON(i2400m
->work_queue
== NULL
);
137 iw
= kzalloc(sizeof(*iw
) + pl_size
, gfp_flags
);
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
);
147 EXPORT_SYMBOL_GPL(i2400m_queue_work
);
151 * Schedule i2400m's specific work on the system's queue.
153 * Used for a few cases where we really need it; otherwise, identical
154 * to i2400m_queue_work().
156 * Returns < 0 errno code on error, 1 if ok.
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.
162 int i2400m_schedule_work(struct i2400m
*i2400m
,
163 void (*fn
)(struct work_struct
*), gfp_t gfp_flags
)
166 struct i2400m_work
*iw
;
168 BUG_ON(i2400m
->work_queue
== NULL
);
170 iw
= kzalloc(sizeof(*iw
), gfp_flags
);
173 iw
->i2400m
= i2400m_get(i2400m
);
174 INIT_WORK(&iw
->ws
, fn
);
175 result
= schedule_work(&iw
->ws
);
184 * WiMAX stack operation: relay a message from user space
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
192 * The WiMAX stack will call this function when a message was received
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.
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.
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.
210 * Note that asynchronous events from the device are processed and
211 * sent to user space in rx.c.
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
)
220 struct i2400m
*i2400m
= wimax_dev_to_i2400m(wimax_dev
);
221 struct device
*dev
= i2400m_dev(i2400m
);
222 struct sk_buff
*ack_skb
;
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
);
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
);
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
,
244 * Context to wait for a reset to finalize
246 struct i2400m_reset_ctx
{
247 struct completion completion
;
253 * WiMAX stack operation: reset a device
255 * @wimax_dev: device descriptor
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.
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.
265 * The bus-driver implementation of reset takes care of falling back
266 * to cold reset if warm fails.
269 int i2400m_op_reset(struct wimax_dev
*wimax_dev
)
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
),
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
);
286 result
= wait_for_completion_timeout(&ctx
.completion
, 4*HZ
);
291 /* if result < 0, pass it on */
292 mutex_lock(&i2400m
->init_mutex
);
293 i2400m
->reset_ctx
= NULL
;
294 mutex_unlock(&i2400m
->init_mutex
);
296 d_fnend(4, dev
, "(wimax_dev %p) = %d\n", wimax_dev
, result
);
302 * Check the MAC address we got from boot mode is ok
304 * @i2400m: device descriptor
306 * Returns: 0 if ok, < 0 errno code on error.
309 int i2400m_check_mac_addr(struct i2400m
*i2400m
)
312 struct device
*dev
= i2400m_dev(i2400m
);
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 };
318 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
319 skb
= i2400m_get_device_info(i2400m
);
321 result
= PTR_ERR(skb
);
322 dev_err(dev
, "Cannot verify MAC address, error reading: %d\n",
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
)))
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, "
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
);
360 d_fnend(3, dev
, "(i2400m %p) = %d\n", i2400m
, result
);
366 * __i2400m_dev_start - Bring up driver communication with the device
368 * @i2400m: device descriptor
369 * @flags: boot mode flags
371 * Returns: 0 if ok, < 0 errno code on error.
373 * Uploads firmware and brings up all the resources needed to be able
374 * to communicate with the device.
376 * TX needs to be setup before the bus-specific code (otherwise on
377 * shutdown, the bus-tx code could try to access it).
380 int __i2400m_dev_start(struct i2400m
*i2400m
, enum i2400m_bri flags
)
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
);
388 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
390 result
= i2400m_dev_bootstrap(i2400m
, flags
);
392 dev_err(dev
, "cannot bootstrap device: %d\n", result
);
393 goto error_bootstrap
;
395 result
= i2400m_tx_setup(i2400m
);
398 result
= i2400m
->bus_dev_start(i2400m
);
400 goto error_bus_dev_start
;
401 i2400m
->work_queue
= create_singlethread_workqueue(wimax_dev
->name
);
402 if (i2400m
->work_queue
== NULL
) {
404 dev_err(dev
, "cannot create workqueue\n");
405 goto error_create_workqueue
;
407 /* At this point is ok to send commands to the device */
408 result
= i2400m_check_mac_addr(i2400m
);
410 goto error_check_mac_addr
;
412 wimax_state_change(wimax_dev
, WIMAX_ST_UNINITIALIZED
);
413 result
= i2400m_dev_initialize(i2400m
);
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
);
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
);
428 i2400m_tx_release(i2400m
);
431 if (result
== -ERESTARTSYS
&& times
-- > 0) {
432 flags
= I2400M_BRI_SOFT
;
435 d_fnend(3, dev
, "(net_dev %p [i2400m %p]) = %d\n",
436 net_dev
, i2400m
, result
);
442 int i2400m_dev_start(struct i2400m
*i2400m
, enum i2400m_bri bm_flags
)
445 mutex_lock(&i2400m
->init_mutex
); /* Well, start the device */
446 result
= __i2400m_dev_start(i2400m
, bm_flags
);
449 mutex_unlock(&i2400m
->init_mutex
);
455 * i2400m_dev_stop - Tear down driver communication with the device
457 * @i2400m: device descriptor
459 * Returns: 0 if ok, < 0 errno code on error.
461 * Releases all the resources allocated to communicate with the device.
464 void __i2400m_dev_stop(struct i2400m
*i2400m
)
466 struct wimax_dev
*wimax_dev
= &i2400m
->wimax_dev
;
467 struct device
*dev
= i2400m_dev(i2400m
);
469 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
470 wimax_state_change(wimax_dev
, __WIMAX_ST_QUIESCING
);
471 i2400m_dev_shutdown(i2400m
);
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
);
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()).
487 void i2400m_dev_stop(struct i2400m
*i2400m
)
489 mutex_lock(&i2400m
->init_mutex
);
490 if (i2400m
->updown
) {
491 __i2400m_dev_stop(i2400m
);
494 mutex_unlock(&i2400m
->init_mutex
);
499 * The device has rebooted; fix up the device and the driver
501 * Tear down the driver communication with the device, reload the
502 * firmware and reinitialize the communication with the device.
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.
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.
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.
516 * This function is ran always in a thread context
519 void __i2400m_dev_reset_handle(struct work_struct
*ws
)
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
;
528 d_fnstart(3, dev
, "(ws %p i2400m %p)\n", ws
, i2400m
);
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
);
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 */
544 dev_err(dev
, "device rebooted: reinitializing driver\n");
545 __i2400m_dev_stop(i2400m
);
547 result
= __i2400m_dev_start(i2400m
,
548 I2400M_BRI_SOFT
| I2400M_BRI_MAC_REINIT
);
550 dev_err(dev
, "device reboot: cannot start the device: %d\n",
552 result
= i2400m
->bus_reset(i2400m
, I2400M_RT_BUS
);
558 if (i2400m
->reset_ctx
) {
559 ctx
->result
= result
;
560 complete(&ctx
->completion
);
562 mutex_unlock(&i2400m
->init_mutex
);
566 d_fnend(3, dev
, "(ws %p i2400m %p) = void\n", ws
, i2400m
);
572 * i2400m_dev_reset_handle - Handle a device's reset in a thread context
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.
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.
583 int i2400m_dev_reset_handle(struct i2400m
*i2400m
)
585 return i2400m_schedule_work(i2400m
, __i2400m_dev_reset_handle
,
588 EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle
);
592 * i2400m_setup - bus-generic setup function for the i2400m device
594 * @i2400m: device descriptor (bus-specific parts have been initialized)
596 * Returns: 0 if ok, < 0 errno code on error.
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.
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.
606 int i2400m_setup(struct i2400m
*i2400m
, enum i2400m_bri bm_flags
)
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
;
613 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
615 snprintf(wimax_dev
->name
, sizeof(wimax_dev
->name
),
616 "i2400m-%s:%s", dev
->bus
->name
, dev
->bus_id
);
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
;
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
;
628 result
= i2400m_bootrom_init(i2400m
, bm_flags
);
630 dev_err(dev
, "read mac addr: bootrom init "
631 "failed: %d\n", result
);
632 goto error_bootrom_init
;
634 result
= i2400m_read_mac_addr(i2400m
);
636 goto error_read_mac_addr
;
638 result
= register_netdev(net_dev
); /* Okey dokey, bring it up */
640 dev_err(dev
, "cannot register i2400m network device: %d\n",
642 goto error_register_netdev
;
644 netif_carrier_off(net_dev
);
646 result
= i2400m_dev_start(i2400m
, bm_flags
);
648 goto error_dev_start
;
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
);
655 goto error_wimax_dev_add
;
656 /* User space needs to do some init stuff */
657 wimax_state_change(wimax_dev
, WIMAX_ST_UNINITIALIZED
);
659 /* Now setup all that requires a registered net and wimax device. */
660 result
= i2400m_debugfs_add(i2400m
);
662 dev_err(dev
, "cannot setup i2400m's debugfs: %d\n", result
);
663 goto error_debugfs_setup
;
665 d_fnend(3, dev
, "(i2400m %p) = %d\n", i2400m
, result
);
669 wimax_dev_rm(&i2400m
->wimax_dev
);
671 i2400m_dev_stop(i2400m
);
673 unregister_netdev(net_dev
);
674 error_register_netdev
:
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
);
684 EXPORT_SYMBOL_GPL(i2400m_setup
);
688 * i2400m_release - release the bus-generic driver resources
690 * Sends a disconnect message and undoes any setup done by i2400m_setup()
692 void i2400m_release(struct i2400m
*i2400m
)
694 struct device
*dev
= i2400m_dev(i2400m
);
696 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
697 netif_stop_queue(i2400m
->wimax_dev
.net_dev
);
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
);
707 EXPORT_SYMBOL_GPL(i2400m_release
);
711 * Debug levels control; see debug.h
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
),
723 size_t D_LEVEL_SIZE
= ARRAY_SIZE(D_LEVEL
);
727 int __init
i2400m_driver_init(void)
731 module_init(i2400m_driver_init
);
734 void __exit
i2400m_driver_exit(void)
736 /* for scheds i2400m_dev_reset_handle() */
737 flush_scheduled_work();
740 module_exit(i2400m_driver_exit
);
742 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
743 MODULE_DESCRIPTION("Intel 2400M WiMAX networking bus-generic driver");
744 MODULE_LICENSE("GPL");