2 * Intel Wireless WiMAX Connection 2400m
3 * Linux driver model glue for USB device, reset & fw upload
6 * Copyright (C) 2007-2008 Intel Corporation <linux-wimax@intel.com>
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 * Yanir Lubetkin <yanirx.lubetkin@intel.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License version
12 * 2 as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 * See i2400m-usb.h for a general description of this driver.
27 * This file implements driver model glue, and hook ups for the
28 * generic driver to implement the bus-specific functions (device
29 * communication setup/tear down, firmware upload and resetting).
35 * i2400mu_netdev_setup()
37 * i2400m_netdev_setup()
45 * i2400m_cmd_enter_powersave()
46 * i2400mu_notification_release()
49 * i2400mu_notification_setup()
51 * i2400mu_bus_dev_start() Called by i2400m_dev_start() [who is
52 * i2400mu_tx_setup() called by i2400m_setup()]
54 * i2400mu_notification_setup()
56 * i2400mu_bus_dev_stop() Called by i2400m_dev_stop() [who is
57 * i2400mu_notification_release() called by i2400m_release()]
58 * i2400mu_rx_release()
59 * i2400mu_tx_release()
61 * i2400mu_bus_reset() Called by i2400m->bus_reset
63 * __i2400mu_send_barker()
66 #include "i2400m-usb.h"
67 #include <linux/wimax/i2400m.h>
68 #include <linux/debugfs.h>
71 #define D_SUBMODULE usb
72 #include "usb-debug-levels.h"
75 /* Our firmware file name */
76 static const char *i2400mu_bus_fw_names
[] = {
77 #define I2400MU_FW_FILE_NAME_v1_4 "i2400m-fw-usb-1.4.sbcf"
78 I2400MU_FW_FILE_NAME_v1_4
,
79 #define I2400MU_FW_FILE_NAME_v1_3 "i2400m-fw-usb-1.3.sbcf"
80 I2400MU_FW_FILE_NAME_v1_3
,
86 int i2400mu_bus_dev_start(struct i2400m
*i2400m
)
89 struct i2400mu
*i2400mu
= container_of(i2400m
, struct i2400mu
, i2400m
);
90 struct device
*dev
= &i2400mu
->usb_iface
->dev
;
92 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
93 result
= i2400mu_tx_setup(i2400mu
);
95 goto error_usb_tx_setup
;
96 result
= i2400mu_rx_setup(i2400mu
);
98 goto error_usb_rx_setup
;
99 result
= i2400mu_notification_setup(i2400mu
);
101 goto error_notif_setup
;
102 d_fnend(3, dev
, "(i2400m %p) = %d\n", i2400m
, result
);
106 i2400mu_rx_release(i2400mu
);
108 i2400mu_tx_release(i2400mu
);
110 d_fnend(3, dev
, "(i2400m %p) = void\n", i2400m
);
116 void i2400mu_bus_dev_stop(struct i2400m
*i2400m
)
118 struct i2400mu
*i2400mu
= container_of(i2400m
, struct i2400mu
, i2400m
);
119 struct device
*dev
= &i2400mu
->usb_iface
->dev
;
121 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
122 i2400mu_notification_release(i2400mu
);
123 i2400mu_rx_release(i2400mu
);
124 i2400mu_tx_release(i2400mu
);
125 d_fnend(3, dev
, "(i2400m %p) = void\n", i2400m
);
130 * Sends a barker buffer to the device
132 * This helper will allocate a kmalloced buffer and use it to transmit
133 * (then free it). Reason for this is that other arches cannot use
134 * stack/vmalloc/text areas for DMA transfers.
136 * Error recovery here is simpler: anything is considered a hard error
137 * and will move the reset code to use a last-resort bus-based reset.
140 int __i2400mu_send_barker(struct i2400mu
*i2400mu
,
141 const __le32
*barker
,
145 struct usb_endpoint_descriptor
*epd
= NULL
;
146 int pipe
, actual_len
, ret
;
147 struct device
*dev
= &i2400mu
->usb_iface
->dev
;
151 ret
= usb_autopm_get_interface(i2400mu
->usb_iface
);
153 dev_err(dev
, "RESET: can't get autopm: %d\n", ret
);
157 buffer
= kmalloc(barker_size
, GFP_KERNEL
);
160 epd
= usb_get_epd(i2400mu
->usb_iface
, endpoint
);
161 pipe
= usb_sndbulkpipe(i2400mu
->usb_dev
, epd
->bEndpointAddress
);
162 memcpy(buffer
, barker
, barker_size
);
163 ret
= usb_bulk_msg(i2400mu
->usb_dev
, pipe
, buffer
, barker_size
,
167 dev_err(dev
, "E: barker error: %d\n", ret
);
168 } else if (actual_len
!= barker_size
) {
169 dev_err(dev
, "E: only %d bytes transmitted\n", actual_len
);
175 usb_autopm_put_interface(i2400mu
->usb_iface
);
181 * Reset a device at different levels (warm, cold or bus)
183 * @i2400m: device descriptor
184 * @reset_type: soft, warm or bus reset (I2400M_RT_WARM/SOFT/BUS)
186 * Warm and cold resets get a USB reset if they fail.
190 * The device will be fully reset internally, but won't be
191 * disconnected from the USB bus (so no reenumeration will
192 * happen). Firmware upload will be neccessary.
194 * The device will send a reboot barker in the notification endpoint
195 * that will trigger the driver to reinitialize the state
196 * automatically from notif.c:i2400m_notification_grok() into
197 * i2400m_dev_bootstrap_delayed().
199 * Cold and bus (USB) reset:
201 * The device will be fully reset internally, disconnected from the
202 * USB bus an a reenumeration will happen. Firmware upload will be
203 * neccessary. Thus, we don't do any locking or struct
204 * reinitialization, as we are going to be fully disconnected and
207 * Note we need to return -ENODEV if a warm reset was requested and we
208 * had to resort to a bus reset. See i2400m_op_reset(), wimax_reset()
209 * and wimax_dev->op_reset.
211 * WARNING: no driver state saved/fixed
214 int i2400mu_bus_reset(struct i2400m
*i2400m
, enum i2400m_reset_type rt
)
217 struct i2400mu
*i2400mu
=
218 container_of(i2400m
, struct i2400mu
, i2400m
);
219 struct device
*dev
= i2400m_dev(i2400m
);
220 static const __le32 i2400m_WARM_BOOT_BARKER
[4] = {
221 cpu_to_le32(I2400M_WARM_RESET_BARKER
),
222 cpu_to_le32(I2400M_WARM_RESET_BARKER
),
223 cpu_to_le32(I2400M_WARM_RESET_BARKER
),
224 cpu_to_le32(I2400M_WARM_RESET_BARKER
),
226 static const __le32 i2400m_COLD_BOOT_BARKER
[4] = {
227 cpu_to_le32(I2400M_COLD_RESET_BARKER
),
228 cpu_to_le32(I2400M_COLD_RESET_BARKER
),
229 cpu_to_le32(I2400M_COLD_RESET_BARKER
),
230 cpu_to_le32(I2400M_COLD_RESET_BARKER
),
233 d_fnstart(3, dev
, "(i2400m %p rt %u)\n", i2400m
, rt
);
234 if (rt
== I2400M_RT_WARM
)
235 result
= __i2400mu_send_barker(i2400mu
, i2400m_WARM_BOOT_BARKER
,
236 sizeof(i2400m_WARM_BOOT_BARKER
),
237 I2400MU_EP_BULK_OUT
);
238 else if (rt
== I2400M_RT_COLD
)
239 result
= __i2400mu_send_barker(i2400mu
, i2400m_COLD_BOOT_BARKER
,
240 sizeof(i2400m_COLD_BOOT_BARKER
),
241 I2400MU_EP_RESET_COLD
);
242 else if (rt
== I2400M_RT_BUS
) {
244 result
= usb_reset_device(i2400mu
->usb_dev
);
247 case -EINVAL
: /* device is gone */
251 result
= rt
== I2400M_RT_WARM
? -ENODEV
: 0;
252 break; /* We assume the device is disconnected */
254 dev_err(dev
, "USB reset failed (%d), giving up!\n",
260 && result
!= -EINVAL
/* device is gone */
261 && rt
!= I2400M_RT_BUS
) {
262 dev_err(dev
, "%s reset failed (%d); trying USB reset\n",
263 rt
== I2400M_RT_WARM
? "warm" : "cold", result
);
267 d_fnend(3, dev
, "(i2400m %p rt %u) = %d\n", i2400m
, rt
, result
);
273 void i2400mu_netdev_setup(struct net_device
*net_dev
)
275 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
276 struct i2400mu
*i2400mu
= container_of(i2400m
, struct i2400mu
, i2400m
);
277 i2400mu_init(i2400mu
);
278 i2400m_netdev_setup(net_dev
);
283 * Debug levels control; see debug.h
285 struct d_level D_LEVEL
[] = {
286 D_SUBMODULE_DEFINE(usb
),
287 D_SUBMODULE_DEFINE(fw
),
288 D_SUBMODULE_DEFINE(notif
),
289 D_SUBMODULE_DEFINE(rx
),
290 D_SUBMODULE_DEFINE(tx
),
292 size_t D_LEVEL_SIZE
= ARRAY_SIZE(D_LEVEL
);
295 #define __debugfs_register(prefix, name, parent) \
297 result = d_level_register_debugfs(prefix, name, parent); \
304 int i2400mu_debugfs_add(struct i2400mu
*i2400mu
)
307 struct device
*dev
= &i2400mu
->usb_iface
->dev
;
308 struct dentry
*dentry
= i2400mu
->i2400m
.wimax_dev
.debugfs_dentry
;
311 dentry
= debugfs_create_dir("i2400m-usb", dentry
);
312 result
= PTR_ERR(dentry
);
313 if (IS_ERR(dentry
)) {
314 if (result
== -ENODEV
)
315 result
= 0; /* No debugfs support */
318 i2400mu
->debugfs_dentry
= dentry
;
319 __debugfs_register("dl_", usb
, dentry
);
320 __debugfs_register("dl_", fw
, dentry
);
321 __debugfs_register("dl_", notif
, dentry
);
322 __debugfs_register("dl_", rx
, dentry
);
323 __debugfs_register("dl_", tx
, dentry
);
325 /* Don't touch these if you don't know what you are doing */
326 fd
= debugfs_create_u8("rx_size_auto_shrink", 0600, dentry
,
327 &i2400mu
->rx_size_auto_shrink
);
328 result
= PTR_ERR(fd
);
329 if (IS_ERR(fd
) && result
!= -ENODEV
) {
330 dev_err(dev
, "Can't create debugfs entry "
331 "rx_size_auto_shrink: %d\n", result
);
335 fd
= debugfs_create_size_t("rx_size", 0600, dentry
,
337 result
= PTR_ERR(fd
);
338 if (IS_ERR(fd
) && result
!= -ENODEV
) {
339 dev_err(dev
, "Can't create debugfs entry "
340 "rx_size: %d\n", result
);
347 debugfs_remove_recursive(i2400mu
->debugfs_dentry
);
353 * Probe a i2400m interface and register it
355 * @iface: USB interface to link to
356 * @id: USB class/subclass/protocol id
357 * @returns: 0 if ok, < 0 errno code on error.
359 * Alloc a net device, initialize the bus-specific details and then
360 * calls the bus-generic initialization routine. That will register
361 * the wimax and netdev devices, upload the firmware [using
362 * _bus_bm_*()], call _bus_dev_start() to finalize the setup of the
363 * communication with the device and then will start to talk to it to
364 * finnish setting it up.
367 int i2400mu_probe(struct usb_interface
*iface
,
368 const struct usb_device_id
*id
)
371 struct net_device
*net_dev
;
372 struct device
*dev
= &iface
->dev
;
373 struct i2400m
*i2400m
;
374 struct i2400mu
*i2400mu
;
375 struct usb_device
*usb_dev
= interface_to_usbdev(iface
);
377 if (usb_dev
->speed
!= USB_SPEED_HIGH
)
378 dev_err(dev
, "device not connected as high speed\n");
380 /* Allocate instance [calls i2400m_netdev_setup() on it]. */
382 net_dev
= alloc_netdev(sizeof(*i2400mu
), "wmx%d",
383 i2400mu_netdev_setup
);
384 if (net_dev
== NULL
) {
385 dev_err(dev
, "no memory for network device instance\n");
386 goto error_alloc_netdev
;
388 SET_NETDEV_DEV(net_dev
, dev
);
389 i2400m
= net_dev_to_i2400m(net_dev
);
390 i2400mu
= container_of(i2400m
, struct i2400mu
, i2400m
);
391 i2400m
->wimax_dev
.net_dev
= net_dev
;
392 i2400mu
->usb_dev
= usb_get_dev(usb_dev
);
393 i2400mu
->usb_iface
= iface
;
394 usb_set_intfdata(iface
, i2400mu
);
396 i2400m
->bus_tx_block_size
= I2400MU_BLK_SIZE
;
397 i2400m
->bus_pl_size_max
= I2400MU_PL_SIZE_MAX
;
398 i2400m
->bus_dev_start
= i2400mu_bus_dev_start
;
399 i2400m
->bus_dev_stop
= i2400mu_bus_dev_stop
;
400 i2400m
->bus_tx_kick
= i2400mu_bus_tx_kick
;
401 i2400m
->bus_reset
= i2400mu_bus_reset
;
402 i2400m
->bus_bm_cmd_send
= i2400mu_bus_bm_cmd_send
;
403 i2400m
->bus_bm_wait_for_ack
= i2400mu_bus_bm_wait_for_ack
;
404 i2400m
->bus_fw_names
= i2400mu_bus_fw_names
;
405 i2400m
->bus_bm_mac_addr_impaired
= 0;
408 iface
->needs_remote_wakeup
= 1; /* autosuspend (15s delay) */
409 device_init_wakeup(dev
, 1);
410 usb_autopm_enable(i2400mu
->usb_iface
);
411 usb_dev
->autosuspend_delay
= 15 * HZ
;
412 usb_dev
->autosuspend_disabled
= 0;
415 result
= i2400m_setup(i2400m
, I2400M_BRI_MAC_REINIT
);
417 dev_err(dev
, "cannot setup device: %d\n", result
);
420 result
= i2400mu_debugfs_add(i2400mu
);
422 dev_err(dev
, "Can't register i2400mu's debugfs: %d\n", result
);
423 goto error_debugfs_add
;
428 i2400m_release(i2400m
);
430 usb_set_intfdata(iface
, NULL
);
431 usb_put_dev(i2400mu
->usb_dev
);
432 free_netdev(net_dev
);
439 * Disconect a i2400m from the system.
441 * i2400m_stop() has been called before, so al the rx and tx contexts
442 * have been taken down already. Make sure the queue is stopped,
443 * unregister netdev and i2400m, free and kill.
446 void i2400mu_disconnect(struct usb_interface
*iface
)
448 struct i2400mu
*i2400mu
= usb_get_intfdata(iface
);
449 struct i2400m
*i2400m
= &i2400mu
->i2400m
;
450 struct net_device
*net_dev
= i2400m
->wimax_dev
.net_dev
;
451 struct device
*dev
= &iface
->dev
;
453 d_fnstart(3, dev
, "(iface %p i2400m %p)\n", iface
, i2400m
);
455 debugfs_remove_recursive(i2400mu
->debugfs_dentry
);
456 i2400m_release(i2400m
);
457 usb_set_intfdata(iface
, NULL
);
458 usb_put_dev(i2400mu
->usb_dev
);
459 free_netdev(net_dev
);
460 d_fnend(3, dev
, "(iface %p i2400m %p) = void\n", iface
, i2400m
);
465 * Get the device ready for USB port or system standby and hibernation
467 * USB port and system standby are handled the same.
469 * When the system hibernates, the USB device is powered down and then
470 * up, so we don't really have to do much here, as it will be seen as
471 * a reconnect. Still for simplicity we consider this case the same as
472 * suspend, so that the device has a chance to do notify the base
473 * station (if connected).
475 * So at the end, the three cases require common handling.
477 * If at the time of this call the device's firmware is not loaded,
478 * nothing has to be done.
480 * If the firmware is loaded, we need to:
482 * - tell the device to go into host interface power save mode, wait
485 * This is quite more interesting than it is; we need to execute a
486 * command, but this time, we don't want the code in usb-{tx,rx}.c
487 * to call the usb_autopm_get/put_interface() barriers as it'd
488 * deadlock, so we need to decrement i2400mu->do_autopm, that acts
489 * as a poor man's semaphore. Ugly, but it works.
491 * As well, the device might refuse going to sleep for whichever
492 * reason. In this case we just fail. For system suspend/hibernate,
493 * we *can't* fail. We look at usb_dev->auto_pm to see if the
494 * suspend call comes from the USB stack or from the system and act
497 * - stop the notification endpoint polling
500 int i2400mu_suspend(struct usb_interface
*iface
, pm_message_t pm_msg
)
503 struct device
*dev
= &iface
->dev
;
504 struct i2400mu
*i2400mu
= usb_get_intfdata(iface
);
506 struct usb_device
*usb_dev
= i2400mu
->usb_dev
;
508 unsigned is_autosuspend
= 0;
509 struct i2400m
*i2400m
= &i2400mu
->i2400m
;
512 if (usb_dev
->auto_pm
> 0)
516 d_fnstart(3, dev
, "(iface %p pm_msg %u)\n", iface
, pm_msg
.event
);
517 if (i2400m
->updown
== 0)
519 if (i2400m
->state
== I2400M_SS_DATA_PATH_CONNECTED
&& is_autosuspend
) {
520 /* ugh -- the device is connected and this suspend
521 * request is an autosuspend one (not a system standby
524 * The only way the device can go to standby is if the
525 * link with the base station is in IDLE mode; that
526 * were the case, we'd be in status
527 * I2400M_SS_CONNECTED_IDLE. But we are not.
529 * If we *tell* him to go power save now, it'll reset
530 * as a precautionary measure, so if this is an
531 * autosuspend thing, say no and it'll come back
532 * later, when the link is IDLE
535 d_printf(1, dev
, "fw up, link up, not-idle, autosuspend: "
536 "not entering powersave\n");
539 d_printf(1, dev
, "fw up: entering powersave\n");
540 atomic_dec(&i2400mu
->do_autopm
);
541 result
= i2400m_cmd_enter_powersave(i2400m
);
542 atomic_inc(&i2400mu
->do_autopm
);
543 if (result
< 0 && !is_autosuspend
) {
544 /* System suspend, can't fail */
545 dev_err(dev
, "failed to suspend, will reset on resume\n");
549 goto error_enter_powersave
;
550 i2400mu_notification_release(i2400mu
);
551 d_printf(1, dev
, "powersave requested\n");
552 error_enter_powersave
:
555 d_fnend(3, dev
, "(iface %p pm_msg %u) = %d\n",
556 iface
, pm_msg
.event
, result
);
562 int i2400mu_resume(struct usb_interface
*iface
)
565 struct device
*dev
= &iface
->dev
;
566 struct i2400mu
*i2400mu
= usb_get_intfdata(iface
);
567 struct i2400m
*i2400m
= &i2400mu
->i2400m
;
569 d_fnstart(3, dev
, "(iface %p)\n", iface
);
570 if (i2400m
->updown
== 0) {
571 d_printf(1, dev
, "fw was down, no resume neeed\n");
574 d_printf(1, dev
, "fw was up, resuming\n");
575 i2400mu_notification_setup(i2400mu
);
576 /* USB has flow control, so we don't need to give it time to
577 * come back; otherwise, we'd use something like a get-state
580 d_fnend(3, dev
, "(iface %p) = %d\n", iface
, ret
);
586 struct usb_device_id i2400mu_id_table
[] = {
587 { USB_DEVICE(0x8086, 0x0181) },
588 { USB_DEVICE(0x8086, 0x1403) },
589 { USB_DEVICE(0x8086, 0x1405) },
590 { USB_DEVICE(0x8086, 0x0180) },
591 { USB_DEVICE(0x8086, 0x0182) },
592 { USB_DEVICE(0x8086, 0x1406) },
593 { USB_DEVICE(0x8086, 0x1403) },
596 MODULE_DEVICE_TABLE(usb
, i2400mu_id_table
);
600 struct usb_driver i2400mu_driver
= {
601 .name
= KBUILD_MODNAME
,
602 .suspend
= i2400mu_suspend
,
603 .resume
= i2400mu_resume
,
604 .probe
= i2400mu_probe
,
605 .disconnect
= i2400mu_disconnect
,
606 .id_table
= i2400mu_id_table
,
607 .supports_autosuspend
= 1,
611 int __init
i2400mu_driver_init(void)
613 return usb_register(&i2400mu_driver
);
615 module_init(i2400mu_driver_init
);
619 void __exit
i2400mu_driver_exit(void)
621 flush_scheduled_work(); /* for the stuff we schedule from sysfs.c */
622 usb_deregister(&i2400mu_driver
);
624 module_exit(i2400mu_driver_exit
);
626 MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>");
627 MODULE_DESCRIPTION("Intel 2400M WiMAX networking for USB");
628 MODULE_LICENSE("GPL");
629 MODULE_FIRMWARE(I2400MU_FW_FILE_NAME_v1_4
);
630 MODULE_FIRMWARE(I2400MU_FW_FILE_NAME_v1_3
);