1/* 2 * Intel Wireless WiMAX Connection 2400m 3 * Linux driver model glue for USB device, reset & fw upload 4 * 5 * 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> 9 * 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. 13 * 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. 18 * 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 22 * 02110-1301, USA. 23 * 24 * 25 * See i2400m-usb.h for a general description of this driver. 26 * 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). 30 * 31 * ROADMAP 32 * 33 * i2400mu_probe() 34 * alloc_netdev()... 35 * i2400mu_netdev_setup() 36 * i2400mu_init() 37 * i2400m_netdev_setup() 38 * i2400m_setup()... 39 * 40 * i2400mu_disconnect 41 * i2400m_release() 42 * free_netdev() 43 * 44 * i2400mu_suspend() 45 * i2400m_cmd_enter_powersave() 46 * i2400mu_notification_release() 47 * 48 * i2400mu_resume() 49 * i2400mu_notification_setup() 50 * 51 * i2400mu_bus_dev_start() Called by i2400m_dev_start() [who is 52 * i2400mu_tx_setup() called by i2400m_setup()] 53 * i2400mu_rx_setup() 54 * i2400mu_notification_setup() 55 * 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() 60 * 61 * i2400mu_bus_reset() Called by i2400m_reset 62 * __i2400mu_reset() 63 * __i2400mu_send_barker() 64 * usb_reset_device() 65 */ 66#include "i2400m-usb.h" 67#include <linux/wimax/i2400m.h> 68#include <linux/debugfs.h> 69#include <linux/slab.h> 70#include <linux/module.h> 71 72 73#define D_SUBMODULE usb 74#include "usb-debug-levels.h" 75 76static char i2400mu_debug_params[128]; 77module_param_string(debug, i2400mu_debug_params, sizeof(i2400mu_debug_params), 78 0644); 79MODULE_PARM_DESC(debug, 80 "String of space-separated NAME:VALUE pairs, where NAMEs " 81 "are the different debug submodules and VALUE are the " 82 "initial debug value to set."); 83 84/* Our firmware file name */ 85static const char *i2400mu_bus_fw_names_5x50[] = { 86#define I2400MU_FW_FILE_NAME_v1_5 "i2400m-fw-usb-1.5.sbcf" 87 I2400MU_FW_FILE_NAME_v1_5, 88#define I2400MU_FW_FILE_NAME_v1_4 "i2400m-fw-usb-1.4.sbcf" 89 I2400MU_FW_FILE_NAME_v1_4, 90 NULL, 91}; 92 93 94static const char *i2400mu_bus_fw_names_6050[] = { 95#define I6050U_FW_FILE_NAME_v1_5 "i6050-fw-usb-1.5.sbcf" 96 I6050U_FW_FILE_NAME_v1_5, 97 NULL, 98}; 99 100 101static 102int i2400mu_bus_dev_start(struct i2400m *i2400m) 103{ 104 int result; 105 struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); 106 struct device *dev = &i2400mu->usb_iface->dev; 107 108 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 109 result = i2400mu_tx_setup(i2400mu); 110 if (result < 0) 111 goto error_usb_tx_setup; 112 result = i2400mu_rx_setup(i2400mu); 113 if (result < 0) 114 goto error_usb_rx_setup; 115 result = i2400mu_notification_setup(i2400mu); 116 if (result < 0) 117 goto error_notif_setup; 118 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 119 return result; 120 121error_notif_setup: 122 i2400mu_rx_release(i2400mu); 123error_usb_rx_setup: 124 i2400mu_tx_release(i2400mu); 125error_usb_tx_setup: 126 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m); 127 return result; 128} 129 130 131static 132void i2400mu_bus_dev_stop(struct i2400m *i2400m) 133{ 134 struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); 135 struct device *dev = &i2400mu->usb_iface->dev; 136 137 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 138 i2400mu_notification_release(i2400mu); 139 i2400mu_rx_release(i2400mu); 140 i2400mu_tx_release(i2400mu); 141 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m); 142} 143 144 145/* 146 * Sends a barker buffer to the device 147 * 148 * This helper will allocate a kmalloced buffer and use it to transmit 149 * (then free it). Reason for this is that other arches cannot use 150 * stack/vmalloc/text areas for DMA transfers. 151 * 152 * Error recovery here is simpler: anything is considered a hard error 153 * and will move the reset code to use a last-resort bus-based reset. 154 */ 155static 156int __i2400mu_send_barker(struct i2400mu *i2400mu, 157 const __le32 *barker, 158 size_t barker_size, 159 unsigned endpoint) 160{ 161 struct usb_endpoint_descriptor *epd = NULL; 162 int pipe, actual_len, ret; 163 struct device *dev = &i2400mu->usb_iface->dev; 164 void *buffer; 165 int do_autopm = 1; 166 167 ret = usb_autopm_get_interface(i2400mu->usb_iface); 168 if (ret < 0) { 169 dev_err(dev, "RESET: can't get autopm: %d\n", ret); 170 do_autopm = 0; 171 } 172 ret = -ENOMEM; 173 buffer = kmalloc(barker_size, GFP_KERNEL); 174 if (buffer == NULL) 175 goto error_kzalloc; 176 epd = usb_get_epd(i2400mu->usb_iface, endpoint); 177 pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); 178 memcpy(buffer, barker, barker_size); 179retry: 180 ret = usb_bulk_msg(i2400mu->usb_dev, pipe, buffer, barker_size, 181 &actual_len, 200); 182 switch (ret) { 183 case 0: 184 if (actual_len != barker_size) { /* Too short? drop it */ 185 dev_err(dev, "E: %s: short write (%d B vs %zu " 186 "expected)\n", 187 __func__, actual_len, barker_size); 188 ret = -EIO; 189 } 190 break; 191 case -EPIPE: 192 /* 193 * Stall -- maybe the device is choking with our 194 * requests. Clear it and give it some time. If they 195 * happen to often, it might be another symptom, so we 196 * reset. 197 * 198 * No error handling for usb_clear_halt(0; if it 199 * works, the retry works; if it fails, this switch 200 * does the error handling for us. 201 */ 202 if (edc_inc(&i2400mu->urb_edc, 203 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { 204 dev_err(dev, "E: %s: too many stalls in " 205 "URB; resetting device\n", __func__); 206 usb_queue_reset_device(i2400mu->usb_iface); 207 /* fallthrough */ 208 } else { 209 usb_clear_halt(i2400mu->usb_dev, pipe); 210 msleep(10); /* give the device some time */ 211 goto retry; 212 } 213 case -EINVAL: /* while removing driver */ 214 case -ENODEV: /* dev disconnect ... */ 215 case -ENOENT: /* just ignore it */ 216 case -ESHUTDOWN: /* and exit */ 217 case -ECONNRESET: 218 ret = -ESHUTDOWN; 219 break; 220 default: /* Some error? */ 221 if (edc_inc(&i2400mu->urb_edc, 222 EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { 223 dev_err(dev, "E: %s: maximum errors in URB " 224 "exceeded; resetting device\n", 225 __func__); 226 usb_queue_reset_device(i2400mu->usb_iface); 227 } else { 228 dev_warn(dev, "W: %s: cannot send URB: %d\n", 229 __func__, ret); 230 goto retry; 231 } 232 } 233 kfree(buffer); 234error_kzalloc: 235 if (do_autopm) 236 usb_autopm_put_interface(i2400mu->usb_iface); 237 return ret; 238} 239 240 241/* 242 * Reset a device at different levels (warm, cold or bus) 243 * 244 * @i2400m: device descriptor 245 * @reset_type: soft, warm or bus reset (I2400M_RT_WARM/SOFT/BUS) 246 * 247 * Warm and cold resets get a USB reset if they fail. 248 * 249 * Warm reset: 250 * 251 * The device will be fully reset internally, but won't be 252 * disconnected from the USB bus (so no reenumeration will 253 * happen). Firmware upload will be necessary. 254 * 255 * The device will send a reboot barker in the notification endpoint 256 * that will trigger the driver to reinitialize the state 257 * automatically from notif.c:i2400m_notification_grok() into 258 * i2400m_dev_bootstrap_delayed(). 259 * 260 * Cold and bus (USB) reset: 261 * 262 * The device will be fully reset internally, disconnected from the 263 * USB bus an a reenumeration will happen. Firmware upload will be 264 * necessary. Thus, we don't do any locking or struct 265 * reinitialization, as we are going to be fully disconnected and 266 * reenumerated. 267 * 268 * Note we need to return -ENODEV if a warm reset was requested and we 269 * had to resort to a bus reset. See i2400m_op_reset(), wimax_reset() 270 * and wimax_dev->op_reset. 271 * 272 * WARNING: no driver state saved/fixed 273 */ 274static 275int i2400mu_bus_reset(struct i2400m *i2400m, enum i2400m_reset_type rt) 276{ 277 int result; 278 struct i2400mu *i2400mu = 279 container_of(i2400m, struct i2400mu, i2400m); 280 struct device *dev = i2400m_dev(i2400m); 281 static const __le32 i2400m_WARM_BOOT_BARKER[4] = { 282 cpu_to_le32(I2400M_WARM_RESET_BARKER), 283 cpu_to_le32(I2400M_WARM_RESET_BARKER), 284 cpu_to_le32(I2400M_WARM_RESET_BARKER), 285 cpu_to_le32(I2400M_WARM_RESET_BARKER), 286 }; 287 static const __le32 i2400m_COLD_BOOT_BARKER[4] = { 288 cpu_to_le32(I2400M_COLD_RESET_BARKER), 289 cpu_to_le32(I2400M_COLD_RESET_BARKER), 290 cpu_to_le32(I2400M_COLD_RESET_BARKER), 291 cpu_to_le32(I2400M_COLD_RESET_BARKER), 292 }; 293 294 d_fnstart(3, dev, "(i2400m %p rt %u)\n", i2400m, rt); 295 if (rt == I2400M_RT_WARM) 296 result = __i2400mu_send_barker( 297 i2400mu, i2400m_WARM_BOOT_BARKER, 298 sizeof(i2400m_WARM_BOOT_BARKER), 299 i2400mu->endpoint_cfg.bulk_out); 300 else if (rt == I2400M_RT_COLD) 301 result = __i2400mu_send_barker( 302 i2400mu, i2400m_COLD_BOOT_BARKER, 303 sizeof(i2400m_COLD_BOOT_BARKER), 304 i2400mu->endpoint_cfg.reset_cold); 305 else if (rt == I2400M_RT_BUS) { 306 result = usb_reset_device(i2400mu->usb_dev); 307 switch (result) { 308 case 0: 309 case -EINVAL: /* device is gone */ 310 case -ENODEV: 311 case -ENOENT: 312 case -ESHUTDOWN: 313 result = 0; 314 break; /* We assume the device is disconnected */ 315 default: 316 dev_err(dev, "USB reset failed (%d), giving up!\n", 317 result); 318 } 319 } else { 320 result = -EINVAL; /* shut gcc up in certain arches */ 321 BUG(); 322 } 323 if (result < 0 324 && result != -EINVAL /* device is gone */ 325 && rt != I2400M_RT_BUS) { 326 /* 327 * Things failed -- resort to lower level reset, that 328 * we queue in another context; the reason for this is 329 * that the pre and post reset functionality requires 330 * the i2400m->init_mutex; RT_WARM and RT_COLD can 331 * come from areas where i2400m->init_mutex is taken. 332 */ 333 dev_err(dev, "%s reset failed (%d); trying USB reset\n", 334 rt == I2400M_RT_WARM ? "warm" : "cold", result); 335 usb_queue_reset_device(i2400mu->usb_iface); 336 result = -ENODEV; 337 } 338 d_fnend(3, dev, "(i2400m %p rt %u) = %d\n", i2400m, rt, result); 339 return result; 340} 341 342static void i2400mu_get_drvinfo(struct net_device *net_dev, 343 struct ethtool_drvinfo *info) 344{ 345 struct i2400m *i2400m = net_dev_to_i2400m(net_dev); 346 struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); 347 struct usb_device *udev = i2400mu->usb_dev; 348 349 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver)); 350 strlcpy(info->fw_version, i2400m->fw_name ? : "", 351 sizeof(info->fw_version)); 352 usb_make_path(udev, info->bus_info, sizeof(info->bus_info)); 353} 354 355static const struct ethtool_ops i2400mu_ethtool_ops = { 356 .get_drvinfo = i2400mu_get_drvinfo, 357 .get_link = ethtool_op_get_link, 358}; 359 360static 361void i2400mu_netdev_setup(struct net_device *net_dev) 362{ 363 struct i2400m *i2400m = net_dev_to_i2400m(net_dev); 364 struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); 365 i2400mu_init(i2400mu); 366 i2400m_netdev_setup(net_dev); 367 net_dev->ethtool_ops = &i2400mu_ethtool_ops; 368} 369 370 371/* 372 * Debug levels control; see debug.h 373 */ 374struct d_level D_LEVEL[] = { 375 D_SUBMODULE_DEFINE(usb), 376 D_SUBMODULE_DEFINE(fw), 377 D_SUBMODULE_DEFINE(notif), 378 D_SUBMODULE_DEFINE(rx), 379 D_SUBMODULE_DEFINE(tx), 380}; 381size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); 382 383 384#define __debugfs_register(prefix, name, parent) \ 385do { \ 386 result = d_level_register_debugfs(prefix, name, parent); \ 387 if (result < 0) \ 388 goto error; \ 389} while (0) 390 391 392static 393int i2400mu_debugfs_add(struct i2400mu *i2400mu) 394{ 395 int result; 396 struct device *dev = &i2400mu->usb_iface->dev; 397 struct dentry *dentry = i2400mu->i2400m.wimax_dev.debugfs_dentry; 398 struct dentry *fd; 399 400 dentry = debugfs_create_dir("i2400m-usb", dentry); 401 result = PTR_ERR(dentry); 402 if (IS_ERR(dentry)) { 403 if (result == -ENODEV) 404 result = 0; /* No debugfs support */ 405 goto error; 406 } 407 i2400mu->debugfs_dentry = dentry; 408 __debugfs_register("dl_", usb, dentry); 409 __debugfs_register("dl_", fw, dentry); 410 __debugfs_register("dl_", notif, dentry); 411 __debugfs_register("dl_", rx, dentry); 412 __debugfs_register("dl_", tx, dentry); 413 414 /* Don't touch these if you don't know what you are doing */ 415 fd = debugfs_create_u8("rx_size_auto_shrink", 0600, dentry, 416 &i2400mu->rx_size_auto_shrink); 417 result = PTR_ERR(fd); 418 if (IS_ERR(fd) && result != -ENODEV) { 419 dev_err(dev, "Can't create debugfs entry " 420 "rx_size_auto_shrink: %d\n", result); 421 goto error; 422 } 423 424 fd = debugfs_create_size_t("rx_size", 0600, dentry, 425 &i2400mu->rx_size); 426 result = PTR_ERR(fd); 427 if (IS_ERR(fd) && result != -ENODEV) { 428 dev_err(dev, "Can't create debugfs entry " 429 "rx_size: %d\n", result); 430 goto error; 431 } 432 433 return 0; 434 435error: 436 debugfs_remove_recursive(i2400mu->debugfs_dentry); 437 return result; 438} 439 440 441static struct device_type i2400mu_type = { 442 .name = "wimax", 443}; 444 445/* 446 * Probe a i2400m interface and register it 447 * 448 * @iface: USB interface to link to 449 * @id: USB class/subclass/protocol id 450 * @returns: 0 if ok, < 0 errno code on error. 451 * 452 * Alloc a net device, initialize the bus-specific details and then 453 * calls the bus-generic initialization routine. That will register 454 * the wimax and netdev devices, upload the firmware [using 455 * _bus_bm_*()], call _bus_dev_start() to finalize the setup of the 456 * communication with the device and then will start to talk to it to 457 * finnish setting it up. 458 */ 459static 460int i2400mu_probe(struct usb_interface *iface, 461 const struct usb_device_id *id) 462{ 463 int result; 464 struct net_device *net_dev; 465 struct device *dev = &iface->dev; 466 struct i2400m *i2400m; 467 struct i2400mu *i2400mu; 468 struct usb_device *usb_dev = interface_to_usbdev(iface); 469 470 if (usb_dev->speed != USB_SPEED_HIGH) 471 dev_err(dev, "device not connected as high speed\n"); 472 473 /* Allocate instance [calls i2400m_netdev_setup() on it]. */ 474 result = -ENOMEM; 475 net_dev = alloc_netdev(sizeof(*i2400mu), "wmx%d", NET_NAME_UNKNOWN, 476 i2400mu_netdev_setup); 477 if (net_dev == NULL) { 478 dev_err(dev, "no memory for network device instance\n"); 479 goto error_alloc_netdev; 480 } 481 SET_NETDEV_DEV(net_dev, dev); 482 SET_NETDEV_DEVTYPE(net_dev, &i2400mu_type); 483 i2400m = net_dev_to_i2400m(net_dev); 484 i2400mu = container_of(i2400m, struct i2400mu, i2400m); 485 i2400m->wimax_dev.net_dev = net_dev; 486 i2400mu->usb_dev = usb_get_dev(usb_dev); 487 i2400mu->usb_iface = iface; 488 usb_set_intfdata(iface, i2400mu); 489 490 i2400m->bus_tx_block_size = I2400MU_BLK_SIZE; 491 /* 492 * Room required in the Tx queue for USB message to accommodate 493 * a smallest payload while allocating header space is 16 bytes. 494 * Adding this room for the new tx message increases the 495 * possibilities of including any payload with size <= 16 bytes. 496 */ 497 i2400m->bus_tx_room_min = I2400MU_BLK_SIZE; 498 i2400m->bus_pl_size_max = I2400MU_PL_SIZE_MAX; 499 i2400m->bus_setup = NULL; 500 i2400m->bus_dev_start = i2400mu_bus_dev_start; 501 i2400m->bus_dev_stop = i2400mu_bus_dev_stop; 502 i2400m->bus_release = NULL; 503 i2400m->bus_tx_kick = i2400mu_bus_tx_kick; 504 i2400m->bus_reset = i2400mu_bus_reset; 505 i2400m->bus_bm_retries = I2400M_USB_BOOT_RETRIES; 506 i2400m->bus_bm_cmd_send = i2400mu_bus_bm_cmd_send; 507 i2400m->bus_bm_wait_for_ack = i2400mu_bus_bm_wait_for_ack; 508 i2400m->bus_bm_mac_addr_impaired = 0; 509 510 switch (id->idProduct) { 511 case USB_DEVICE_ID_I6050: 512 case USB_DEVICE_ID_I6050_2: 513 case USB_DEVICE_ID_I6150: 514 case USB_DEVICE_ID_I6150_2: 515 case USB_DEVICE_ID_I6150_3: 516 case USB_DEVICE_ID_I6250: 517 i2400mu->i6050 = 1; 518 break; 519 default: 520 break; 521 } 522 523 if (i2400mu->i6050) { 524 i2400m->bus_fw_names = i2400mu_bus_fw_names_6050; 525 i2400mu->endpoint_cfg.bulk_out = 0; 526 i2400mu->endpoint_cfg.notification = 3; 527 i2400mu->endpoint_cfg.reset_cold = 2; 528 i2400mu->endpoint_cfg.bulk_in = 1; 529 } else { 530 i2400m->bus_fw_names = i2400mu_bus_fw_names_5x50; 531 i2400mu->endpoint_cfg.bulk_out = 0; 532 i2400mu->endpoint_cfg.notification = 1; 533 i2400mu->endpoint_cfg.reset_cold = 2; 534 i2400mu->endpoint_cfg.bulk_in = 3; 535 } 536#ifdef CONFIG_PM 537 iface->needs_remote_wakeup = 1; /* autosuspend (15s delay) */ 538 device_init_wakeup(dev, 1); 539 pm_runtime_set_autosuspend_delay(&usb_dev->dev, 15000); 540 usb_enable_autosuspend(usb_dev); 541#endif 542 543 result = i2400m_setup(i2400m, I2400M_BRI_MAC_REINIT); 544 if (result < 0) { 545 dev_err(dev, "cannot setup device: %d\n", result); 546 goto error_setup; 547 } 548 result = i2400mu_debugfs_add(i2400mu); 549 if (result < 0) { 550 dev_err(dev, "Can't register i2400mu's debugfs: %d\n", result); 551 goto error_debugfs_add; 552 } 553 return 0; 554 555error_debugfs_add: 556 i2400m_release(i2400m); 557error_setup: 558 usb_set_intfdata(iface, NULL); 559 usb_put_dev(i2400mu->usb_dev); 560 free_netdev(net_dev); 561error_alloc_netdev: 562 return result; 563} 564 565 566/* 567 * Disconect a i2400m from the system. 568 * 569 * i2400m_stop() has been called before, so al the rx and tx contexts 570 * have been taken down already. Make sure the queue is stopped, 571 * unregister netdev and i2400m, free and kill. 572 */ 573static 574void i2400mu_disconnect(struct usb_interface *iface) 575{ 576 struct i2400mu *i2400mu = usb_get_intfdata(iface); 577 struct i2400m *i2400m = &i2400mu->i2400m; 578 struct net_device *net_dev = i2400m->wimax_dev.net_dev; 579 struct device *dev = &iface->dev; 580 581 d_fnstart(3, dev, "(iface %p i2400m %p)\n", iface, i2400m); 582 583 debugfs_remove_recursive(i2400mu->debugfs_dentry); 584 i2400m_release(i2400m); 585 usb_set_intfdata(iface, NULL); 586 usb_put_dev(i2400mu->usb_dev); 587 free_netdev(net_dev); 588 d_fnend(3, dev, "(iface %p i2400m %p) = void\n", iface, i2400m); 589} 590 591 592/* 593 * Get the device ready for USB port or system standby and hibernation 594 * 595 * USB port and system standby are handled the same. 596 * 597 * When the system hibernates, the USB device is powered down and then 598 * up, so we don't really have to do much here, as it will be seen as 599 * a reconnect. Still for simplicity we consider this case the same as 600 * suspend, so that the device has a chance to do notify the base 601 * station (if connected). 602 * 603 * So at the end, the three cases require common handling. 604 * 605 * If at the time of this call the device's firmware is not loaded, 606 * nothing has to be done. Note we can be "loose" about not reading 607 * i2400m->updown under i2400m->init_mutex. If it happens to change 608 * inmediately, other parts of the call flow will fail and effectively 609 * catch it. 610 * 611 * If the firmware is loaded, we need to: 612 * 613 * - tell the device to go into host interface power save mode, wait 614 * for it to ack 615 * 616 * This is quite more interesting than it is; we need to execute a 617 * command, but this time, we don't want the code in usb-{tx,rx}.c 618 * to call the usb_autopm_get/put_interface() barriers as it'd 619 * deadlock, so we need to decrement i2400mu->do_autopm, that acts 620 * as a poor man's semaphore. Ugly, but it works. 621 * 622 * As well, the device might refuse going to sleep for whichever 623 * reason. In this case we just fail. For system suspend/hibernate, 624 * we *can't* fail. We check PMSG_IS_AUTO to see if the 625 * suspend call comes from the USB stack or from the system and act 626 * in consequence. 627 * 628 * - stop the notification endpoint polling 629 */ 630static 631int i2400mu_suspend(struct usb_interface *iface, pm_message_t pm_msg) 632{ 633 int result = 0; 634 struct device *dev = &iface->dev; 635 struct i2400mu *i2400mu = usb_get_intfdata(iface); 636 unsigned is_autosuspend = 0; 637 struct i2400m *i2400m = &i2400mu->i2400m; 638 639#ifdef CONFIG_PM 640 if (PMSG_IS_AUTO(pm_msg)) 641 is_autosuspend = 1; 642#endif 643 644 d_fnstart(3, dev, "(iface %p pm_msg %u)\n", iface, pm_msg.event); 645 rmb(); /* see i2400m->updown's documentation */ 646 if (i2400m->updown == 0) 647 goto no_firmware; 648 if (i2400m->state == I2400M_SS_DATA_PATH_CONNECTED && is_autosuspend) { 649 /* ugh -- the device is connected and this suspend 650 * request is an autosuspend one (not a system standby 651 * / hibernate). 652 * 653 * The only way the device can go to standby is if the 654 * link with the base station is in IDLE mode; that 655 * were the case, we'd be in status 656 * I2400M_SS_CONNECTED_IDLE. But we are not. 657 * 658 * If we *tell* him to go power save now, it'll reset 659 * as a precautionary measure, so if this is an 660 * autosuspend thing, say no and it'll come back 661 * later, when the link is IDLE 662 */ 663 result = -EBADF; 664 d_printf(1, dev, "fw up, link up, not-idle, autosuspend: " 665 "not entering powersave\n"); 666 goto error_not_now; 667 } 668 d_printf(1, dev, "fw up: entering powersave\n"); 669 atomic_dec(&i2400mu->do_autopm); 670 result = i2400m_cmd_enter_powersave(i2400m); 671 atomic_inc(&i2400mu->do_autopm); 672 if (result < 0 && !is_autosuspend) { 673 /* System suspend, can't fail */ 674 dev_err(dev, "failed to suspend, will reset on resume\n"); 675 result = 0; 676 } 677 if (result < 0) 678 goto error_enter_powersave; 679 i2400mu_notification_release(i2400mu); 680 d_printf(1, dev, "powersave requested\n"); 681error_enter_powersave: 682error_not_now: 683no_firmware: 684 d_fnend(3, dev, "(iface %p pm_msg %u) = %d\n", 685 iface, pm_msg.event, result); 686 return result; 687} 688 689 690static 691int i2400mu_resume(struct usb_interface *iface) 692{ 693 int ret = 0; 694 struct device *dev = &iface->dev; 695 struct i2400mu *i2400mu = usb_get_intfdata(iface); 696 struct i2400m *i2400m = &i2400mu->i2400m; 697 698 d_fnstart(3, dev, "(iface %p)\n", iface); 699 rmb(); /* see i2400m->updown's documentation */ 700 if (i2400m->updown == 0) { 701 d_printf(1, dev, "fw was down, no resume needed\n"); 702 goto out; 703 } 704 d_printf(1, dev, "fw was up, resuming\n"); 705 i2400mu_notification_setup(i2400mu); 706 /* USB has flow control, so we don't need to give it time to 707 * come back; otherwise, we'd use something like a get-state 708 * command... */ 709out: 710 d_fnend(3, dev, "(iface %p) = %d\n", iface, ret); 711 return ret; 712} 713 714 715static 716int i2400mu_reset_resume(struct usb_interface *iface) 717{ 718 int result; 719 struct device *dev = &iface->dev; 720 struct i2400mu *i2400mu = usb_get_intfdata(iface); 721 struct i2400m *i2400m = &i2400mu->i2400m; 722 723 d_fnstart(3, dev, "(iface %p)\n", iface); 724 result = i2400m_dev_reset_handle(i2400m, "device reset on resume"); 725 d_fnend(3, dev, "(iface %p) = %d\n", iface, result); 726 return result < 0 ? result : 0; 727} 728 729 730/* 731 * Another driver or user space is triggering a reset on the device 732 * which contains the interface passed as an argument. Cease IO and 733 * save any device state you need to restore. 734 * 735 * If you need to allocate memory here, use GFP_NOIO or GFP_ATOMIC, if 736 * you are in atomic context. 737 */ 738static 739int i2400mu_pre_reset(struct usb_interface *iface) 740{ 741 struct i2400mu *i2400mu = usb_get_intfdata(iface); 742 return i2400m_pre_reset(&i2400mu->i2400m); 743} 744 745 746/* 747 * The reset has completed. Restore any saved device state and begin 748 * using the device again. 749 * 750 * If you need to allocate memory here, use GFP_NOIO or GFP_ATOMIC, if 751 * you are in atomic context. 752 */ 753static 754int i2400mu_post_reset(struct usb_interface *iface) 755{ 756 struct i2400mu *i2400mu = usb_get_intfdata(iface); 757 return i2400m_post_reset(&i2400mu->i2400m); 758} 759 760 761static 762struct usb_device_id i2400mu_id_table[] = { 763 { USB_DEVICE(0x8086, USB_DEVICE_ID_I6050) }, 764 { USB_DEVICE(0x8086, USB_DEVICE_ID_I6050_2) }, 765 { USB_DEVICE(0x8087, USB_DEVICE_ID_I6150) }, 766 { USB_DEVICE(0x8087, USB_DEVICE_ID_I6150_2) }, 767 { USB_DEVICE(0x8087, USB_DEVICE_ID_I6150_3) }, 768 { USB_DEVICE(0x8086, USB_DEVICE_ID_I6250) }, 769 { USB_DEVICE(0x8086, 0x0181) }, 770 { USB_DEVICE(0x8086, 0x1403) }, 771 { USB_DEVICE(0x8086, 0x1405) }, 772 { USB_DEVICE(0x8086, 0x0180) }, 773 { USB_DEVICE(0x8086, 0x0182) }, 774 { USB_DEVICE(0x8086, 0x1406) }, 775 { USB_DEVICE(0x8086, 0x1403) }, 776 { }, 777}; 778MODULE_DEVICE_TABLE(usb, i2400mu_id_table); 779 780 781static 782struct usb_driver i2400mu_driver = { 783 .name = KBUILD_MODNAME, 784 .suspend = i2400mu_suspend, 785 .resume = i2400mu_resume, 786 .reset_resume = i2400mu_reset_resume, 787 .probe = i2400mu_probe, 788 .disconnect = i2400mu_disconnect, 789 .pre_reset = i2400mu_pre_reset, 790 .post_reset = i2400mu_post_reset, 791 .id_table = i2400mu_id_table, 792 .supports_autosuspend = 1, 793}; 794 795static 796int __init i2400mu_driver_init(void) 797{ 798 d_parse_params(D_LEVEL, D_LEVEL_SIZE, i2400mu_debug_params, 799 "i2400m_usb.debug"); 800 return usb_register(&i2400mu_driver); 801} 802module_init(i2400mu_driver_init); 803 804 805static 806void __exit i2400mu_driver_exit(void) 807{ 808 usb_deregister(&i2400mu_driver); 809} 810module_exit(i2400mu_driver_exit); 811 812MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>"); 813MODULE_DESCRIPTION("Driver for USB based Intel Wireless WiMAX Connection 2400M " 814 "(5x50 & 6050)"); 815MODULE_LICENSE("GPL"); 816MODULE_FIRMWARE(I2400MU_FW_FILE_NAME_v1_5); 817MODULE_FIRMWARE(I6050U_FW_FILE_NAME_v1_5); 818