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