1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Intel Wireless WiMAX Connection 2400m 4 * Generic probe/disconnect, reset and message passing 5 * 6 * Copyright (C) 2007-2008 Intel Corporation <linux-wimax@intel.com> 7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> 8 * 9 * See i2400m.h for driver documentation. This contains helpers for 10 * the driver model glue [_setup()/_release()], handling device resets 11 * [_dev_reset_handle()], and the backends for the WiMAX stack ops 12 * reset [_op_reset()] and message from user [_op_msg_from_user()]. 13 * 14 * ROADMAP: 15 * 16 * i2400m_op_msg_from_user() 17 * i2400m_msg_to_dev() 18 * wimax_msg_to_user_send() 19 * 20 * i2400m_op_reset() 21 * i240m->bus_reset() 22 * 23 * i2400m_dev_reset_handle() 24 * __i2400m_dev_reset_handle() 25 * __i2400m_dev_stop() 26 * __i2400m_dev_start() 27 * 28 * i2400m_setup() 29 * i2400m->bus_setup() 30 * i2400m_bootrom_init() 31 * register_netdev() 32 * wimax_dev_add() 33 * i2400m_dev_start() 34 * __i2400m_dev_start() 35 * i2400m_dev_bootstrap() 36 * i2400m_tx_setup() 37 * i2400m->bus_dev_start() 38 * i2400m_firmware_check() 39 * i2400m_check_mac_addr() 40 * 41 * i2400m_release() 42 * i2400m_dev_stop() 43 * __i2400m_dev_stop() 44 * i2400m_dev_shutdown() 45 * i2400m->bus_dev_stop() 46 * i2400m_tx_release() 47 * i2400m->bus_release() 48 * wimax_dev_rm() 49 * unregister_netdev() 50 */ 51#include "i2400m.h" 52#include <linux/etherdevice.h> 53#include <linux/wimax/i2400m.h> 54#include <linux/module.h> 55#include <linux/moduleparam.h> 56#include <linux/suspend.h> 57#include <linux/slab.h> 58 59#define D_SUBMODULE driver 60#include "debug-levels.h" 61 62 63static char i2400m_debug_params[128]; 64module_param_string(debug, i2400m_debug_params, sizeof(i2400m_debug_params), 65 0644); 66MODULE_PARM_DESC(debug, 67 "String of space-separated NAME:VALUE pairs, where NAMEs " 68 "are the different debug submodules and VALUE are the " 69 "initial debug value to set."); 70 71static char i2400m_barkers_params[128]; 72module_param_string(barkers, i2400m_barkers_params, 73 sizeof(i2400m_barkers_params), 0644); 74MODULE_PARM_DESC(barkers, 75 "String of comma-separated 32-bit values; each is " 76 "recognized as the value the device sends as a reboot " 77 "signal; values are appended to a list--setting one value " 78 "as zero cleans the existing list and starts a new one."); 79 80/* 81 * WiMAX stack operation: relay a message from user space 82 * 83 * @wimax_dev: device descriptor 84 * @pipe_name: named pipe the message is for 85 * @msg_buf: pointer to the message bytes 86 * @msg_len: length of the buffer 87 * @genl_info: passed by the generic netlink layer 88 * 89 * The WiMAX stack will call this function when a message was received 90 * from user space. 91 * 92 * For the i2400m, this is an L3L4 message, as specified in 93 * include/linux/wimax/i2400m.h, and thus prefixed with a 'struct 94 * i2400m_l3l4_hdr'. Driver (and device) expect the messages to be 95 * coded in Little Endian. 96 * 97 * This function just verifies that the header declaration and the 98 * payload are consistent and then deals with it, either forwarding it 99 * to the device or procesing it locally. 100 * 101 * In the i2400m, messages are basically commands that will carry an 102 * ack, so we use i2400m_msg_to_dev() and then deliver the ack back to 103 * user space. The rx.c code might intercept the response and use it 104 * to update the driver's state, but then it will pass it on so it can 105 * be relayed back to user space. 106 * 107 * Note that asynchronous events from the device are processed and 108 * sent to user space in rx.c. 109 */ 110static 111int i2400m_op_msg_from_user(struct wimax_dev *wimax_dev, 112 const char *pipe_name, 113 const void *msg_buf, size_t msg_len, 114 const struct genl_info *genl_info) 115{ 116 int result; 117 struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev); 118 struct device *dev = i2400m_dev(i2400m); 119 struct sk_buff *ack_skb; 120 121 d_fnstart(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p " 122 "msg_len %zu genl_info %p)\n", wimax_dev, i2400m, 123 msg_buf, msg_len, genl_info); 124 ack_skb = i2400m_msg_to_dev(i2400m, msg_buf, msg_len); 125 result = PTR_ERR(ack_skb); 126 if (IS_ERR(ack_skb)) 127 goto error_msg_to_dev; 128 result = wimax_msg_send(&i2400m->wimax_dev, ack_skb); 129error_msg_to_dev: 130 d_fnend(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p msg_len %zu " 131 "genl_info %p) = %d\n", wimax_dev, i2400m, msg_buf, msg_len, 132 genl_info, result); 133 return result; 134} 135 136 137/* 138 * Context to wait for a reset to finalize 139 */ 140struct i2400m_reset_ctx { 141 struct completion completion; 142 int result; 143}; 144 145 146/* 147 * WiMAX stack operation: reset a device 148 * 149 * @wimax_dev: device descriptor 150 * 151 * See the documentation for wimax_reset() and wimax_dev->op_reset for 152 * the requirements of this function. The WiMAX stack guarantees 153 * serialization on calls to this function. 154 * 155 * Do a warm reset on the device; if it fails, resort to a cold reset 156 * and return -ENODEV. On successful warm reset, we need to block 157 * until it is complete. 158 * 159 * The bus-driver implementation of reset takes care of falling back 160 * to cold reset if warm fails. 161 */ 162static 163int i2400m_op_reset(struct wimax_dev *wimax_dev) 164{ 165 int result; 166 struct i2400m *i2400m = wimax_dev_to_i2400m(wimax_dev); 167 struct device *dev = i2400m_dev(i2400m); 168 struct i2400m_reset_ctx ctx = { 169 .completion = COMPLETION_INITIALIZER_ONSTACK(ctx.completion), 170 .result = 0, 171 }; 172 173 d_fnstart(4, dev, "(wimax_dev %p)\n", wimax_dev); 174 mutex_lock(&i2400m->init_mutex); 175 i2400m->reset_ctx = &ctx; 176 mutex_unlock(&i2400m->init_mutex); 177 result = i2400m_reset(i2400m, I2400M_RT_WARM); 178 if (result < 0) 179 goto out; 180 result = wait_for_completion_timeout(&ctx.completion, 4*HZ); 181 if (result == 0) 182 result = -ETIMEDOUT; 183 else if (result > 0) 184 result = ctx.result; 185 /* if result < 0, pass it on */ 186 mutex_lock(&i2400m->init_mutex); 187 i2400m->reset_ctx = NULL; 188 mutex_unlock(&i2400m->init_mutex); 189out: 190 d_fnend(4, dev, "(wimax_dev %p) = %d\n", wimax_dev, result); 191 return result; 192} 193 194 195/* 196 * Check the MAC address we got from boot mode is ok 197 * 198 * @i2400m: device descriptor 199 * 200 * Returns: 0 if ok, < 0 errno code on error. 201 */ 202static 203int i2400m_check_mac_addr(struct i2400m *i2400m) 204{ 205 int result; 206 struct device *dev = i2400m_dev(i2400m); 207 struct sk_buff *skb; 208 const struct i2400m_tlv_detailed_device_info *ddi; 209 struct net_device *net_dev = i2400m->wimax_dev.net_dev; 210 211 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 212 skb = i2400m_get_device_info(i2400m); 213 if (IS_ERR(skb)) { 214 result = PTR_ERR(skb); 215 dev_err(dev, "Cannot verify MAC address, error reading: %d\n", 216 result); 217 goto error; 218 } 219 /* Extract MAC address */ 220 ddi = (void *) skb->data; 221 BUILD_BUG_ON(ETH_ALEN != sizeof(ddi->mac_address)); 222 d_printf(2, dev, "GET DEVICE INFO: mac addr %pM\n", 223 ddi->mac_address); 224 if (!memcmp(net_dev->perm_addr, ddi->mac_address, 225 sizeof(ddi->mac_address))) 226 goto ok; 227 dev_warn(dev, "warning: device reports a different MAC address " 228 "to that of boot mode's\n"); 229 dev_warn(dev, "device reports %pM\n", ddi->mac_address); 230 dev_warn(dev, "boot mode reported %pM\n", net_dev->perm_addr); 231 if (is_zero_ether_addr(ddi->mac_address)) 232 dev_err(dev, "device reports an invalid MAC address, " 233 "not updating\n"); 234 else { 235 dev_warn(dev, "updating MAC address\n"); 236 net_dev->addr_len = ETH_ALEN; 237 memcpy(net_dev->perm_addr, ddi->mac_address, ETH_ALEN); 238 memcpy(net_dev->dev_addr, ddi->mac_address, ETH_ALEN); 239 } 240ok: 241 result = 0; 242 kfree_skb(skb); 243error: 244 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 245 return result; 246} 247 248 249/** 250 * __i2400m_dev_start - Bring up driver communication with the device 251 * 252 * @i2400m: device descriptor 253 * @flags: boot mode flags 254 * 255 * Returns: 0 if ok, < 0 errno code on error. 256 * 257 * Uploads firmware and brings up all the resources needed to be able 258 * to communicate with the device. 259 * 260 * The workqueue has to be setup early, at least before RX handling 261 * (it's only real user for now) so it can process reports as they 262 * arrive. We also want to destroy it if we retry, to make sure it is 263 * flushed...easier like this. 264 * 265 * TX needs to be setup before the bus-specific code (otherwise on 266 * shutdown, the bus-tx code could try to access it). 267 */ 268static 269int __i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri flags) 270{ 271 int result; 272 struct wimax_dev *wimax_dev = &i2400m->wimax_dev; 273 struct net_device *net_dev = wimax_dev->net_dev; 274 struct device *dev = i2400m_dev(i2400m); 275 int times = i2400m->bus_bm_retries; 276 277 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 278retry: 279 result = i2400m_dev_bootstrap(i2400m, flags); 280 if (result < 0) { 281 dev_err(dev, "cannot bootstrap device: %d\n", result); 282 goto error_bootstrap; 283 } 284 result = i2400m_tx_setup(i2400m); 285 if (result < 0) 286 goto error_tx_setup; 287 result = i2400m_rx_setup(i2400m); 288 if (result < 0) 289 goto error_rx_setup; 290 i2400m->work_queue = create_singlethread_workqueue(wimax_dev->name); 291 if (i2400m->work_queue == NULL) { 292 result = -ENOMEM; 293 dev_err(dev, "cannot create workqueue\n"); 294 goto error_create_workqueue; 295 } 296 if (i2400m->bus_dev_start) { 297 result = i2400m->bus_dev_start(i2400m); 298 if (result < 0) 299 goto error_bus_dev_start; 300 } 301 i2400m->ready = 1; 302 wmb(); /* see i2400m->ready's documentation */ 303 /* process pending reports from the device */ 304 queue_work(i2400m->work_queue, &i2400m->rx_report_ws); 305 result = i2400m_firmware_check(i2400m); /* fw versions ok? */ 306 if (result < 0) 307 goto error_fw_check; 308 /* At this point is ok to send commands to the device */ 309 result = i2400m_check_mac_addr(i2400m); 310 if (result < 0) 311 goto error_check_mac_addr; 312 result = i2400m_dev_initialize(i2400m); 313 if (result < 0) 314 goto error_dev_initialize; 315 316 /* We don't want any additional unwanted error recovery triggered 317 * from any other context so if anything went wrong before we come 318 * here, let's keep i2400m->error_recovery untouched and leave it to 319 * dev_reset_handle(). See dev_reset_handle(). */ 320 321 atomic_dec(&i2400m->error_recovery); 322 /* Every thing works so far, ok, now we are ready to 323 * take error recovery if it's required. */ 324 325 /* At this point, reports will come for the device and set it 326 * to the right state if it is different than UNINITIALIZED */ 327 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n", 328 net_dev, i2400m, result); 329 return result; 330 331error_dev_initialize: 332error_check_mac_addr: 333error_fw_check: 334 i2400m->ready = 0; 335 wmb(); /* see i2400m->ready's documentation */ 336 flush_workqueue(i2400m->work_queue); 337 if (i2400m->bus_dev_stop) 338 i2400m->bus_dev_stop(i2400m); 339error_bus_dev_start: 340 destroy_workqueue(i2400m->work_queue); 341error_create_workqueue: 342 i2400m_rx_release(i2400m); 343error_rx_setup: 344 i2400m_tx_release(i2400m); 345error_tx_setup: 346error_bootstrap: 347 if (result == -EL3RST && times-- > 0) { 348 flags = I2400M_BRI_SOFT|I2400M_BRI_MAC_REINIT; 349 goto retry; 350 } 351 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n", 352 net_dev, i2400m, result); 353 return result; 354} 355 356 357static 358int i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri bm_flags) 359{ 360 int result = 0; 361 mutex_lock(&i2400m->init_mutex); /* Well, start the device */ 362 if (i2400m->updown == 0) { 363 result = __i2400m_dev_start(i2400m, bm_flags); 364 if (result >= 0) { 365 i2400m->updown = 1; 366 i2400m->alive = 1; 367 wmb();/* see i2400m->updown and i2400m->alive's doc */ 368 } 369 } 370 mutex_unlock(&i2400m->init_mutex); 371 return result; 372} 373 374 375/** 376 * i2400m_dev_stop - Tear down driver communication with the device 377 * 378 * @i2400m: device descriptor 379 * 380 * Returns: 0 if ok, < 0 errno code on error. 381 * 382 * Releases all the resources allocated to communicate with the 383 * device. Note we cannot destroy the workqueue earlier as until RX is 384 * fully destroyed, it could still try to schedule jobs. 385 */ 386static 387void __i2400m_dev_stop(struct i2400m *i2400m) 388{ 389 struct wimax_dev *wimax_dev = &i2400m->wimax_dev; 390 struct device *dev = i2400m_dev(i2400m); 391 392 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 393 wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING); 394 i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST); 395 complete(&i2400m->msg_completion); 396 i2400m_net_wake_stop(i2400m); 397 i2400m_dev_shutdown(i2400m); 398 /* 399 * Make sure no report hooks are running *before* we stop the 400 * communication infrastructure with the device. 401 */ 402 i2400m->ready = 0; /* nobody can queue work anymore */ 403 wmb(); /* see i2400m->ready's documentation */ 404 flush_workqueue(i2400m->work_queue); 405 406 if (i2400m->bus_dev_stop) 407 i2400m->bus_dev_stop(i2400m); 408 destroy_workqueue(i2400m->work_queue); 409 i2400m_rx_release(i2400m); 410 i2400m_tx_release(i2400m); 411 wimax_state_change(wimax_dev, WIMAX_ST_DOWN); 412 d_fnend(3, dev, "(i2400m %p) = 0\n", i2400m); 413} 414 415 416/* 417 * Watch out -- we only need to stop if there is a need for it. The 418 * device could have reset itself and failed to come up again (see 419 * _i2400m_dev_reset_handle()). 420 */ 421static 422void i2400m_dev_stop(struct i2400m *i2400m) 423{ 424 mutex_lock(&i2400m->init_mutex); 425 if (i2400m->updown) { 426 __i2400m_dev_stop(i2400m); 427 i2400m->updown = 0; 428 i2400m->alive = 0; 429 wmb(); /* see i2400m->updown and i2400m->alive's doc */ 430 } 431 mutex_unlock(&i2400m->init_mutex); 432} 433 434 435/* 436 * Listen to PM events to cache the firmware before suspend/hibernation 437 * 438 * When the device comes out of suspend, it might go into reset and 439 * firmware has to be uploaded again. At resume, most of the times, we 440 * can't load firmware images from disk, so we need to cache it. 441 * 442 * i2400m_fw_cache() will allocate a kobject and attach the firmware 443 * to it; that way we don't have to worry too much about the fw loader 444 * hitting a race condition. 445 * 446 * Note: modus operandi stolen from the Orinoco driver; thx. 447 */ 448static 449int i2400m_pm_notifier(struct notifier_block *notifier, 450 unsigned long pm_event, 451 void *unused) 452{ 453 struct i2400m *i2400m = 454 container_of(notifier, struct i2400m, pm_notifier); 455 struct device *dev = i2400m_dev(i2400m); 456 457 d_fnstart(3, dev, "(i2400m %p pm_event %lx)\n", i2400m, pm_event); 458 switch (pm_event) { 459 case PM_HIBERNATION_PREPARE: 460 case PM_SUSPEND_PREPARE: 461 i2400m_fw_cache(i2400m); 462 break; 463 case PM_POST_RESTORE: 464 /* Restore from hibernation failed. We need to clean 465 * up in exactly the same way, so fall through. */ 466 case PM_POST_HIBERNATION: 467 case PM_POST_SUSPEND: 468 i2400m_fw_uncache(i2400m); 469 break; 470 471 case PM_RESTORE_PREPARE: 472 default: 473 break; 474 } 475 d_fnend(3, dev, "(i2400m %p pm_event %lx) = void\n", i2400m, pm_event); 476 return NOTIFY_DONE; 477} 478 479 480/* 481 * pre-reset is called before a device is going on reset 482 * 483 * This has to be followed by a call to i2400m_post_reset(), otherwise 484 * bad things might happen. 485 */ 486int i2400m_pre_reset(struct i2400m *i2400m) 487{ 488 struct device *dev = i2400m_dev(i2400m); 489 490 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 491 d_printf(1, dev, "pre-reset shut down\n"); 492 493 mutex_lock(&i2400m->init_mutex); 494 if (i2400m->updown) { 495 netif_tx_disable(i2400m->wimax_dev.net_dev); 496 __i2400m_dev_stop(i2400m); 497 /* down't set updown to zero -- this way 498 * post_reset can restore properly */ 499 } 500 mutex_unlock(&i2400m->init_mutex); 501 if (i2400m->bus_release) 502 i2400m->bus_release(i2400m); 503 d_fnend(3, dev, "(i2400m %p) = 0\n", i2400m); 504 return 0; 505} 506EXPORT_SYMBOL_GPL(i2400m_pre_reset); 507 508 509/* 510 * Restore device state after a reset 511 * 512 * Do the work needed after a device reset to bring it up to the same 513 * state as it was before the reset. 514 * 515 * NOTE: this requires i2400m->init_mutex taken 516 */ 517int i2400m_post_reset(struct i2400m *i2400m) 518{ 519 int result = 0; 520 struct device *dev = i2400m_dev(i2400m); 521 522 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 523 d_printf(1, dev, "post-reset start\n"); 524 if (i2400m->bus_setup) { 525 result = i2400m->bus_setup(i2400m); 526 if (result < 0) { 527 dev_err(dev, "bus-specific setup failed: %d\n", 528 result); 529 goto error_bus_setup; 530 } 531 } 532 mutex_lock(&i2400m->init_mutex); 533 if (i2400m->updown) { 534 result = __i2400m_dev_start( 535 i2400m, I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT); 536 if (result < 0) 537 goto error_dev_start; 538 } 539 mutex_unlock(&i2400m->init_mutex); 540 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 541 return result; 542 543error_dev_start: 544 if (i2400m->bus_release) 545 i2400m->bus_release(i2400m); 546 /* even if the device was up, it could not be recovered, so we 547 * mark it as down. */ 548 i2400m->updown = 0; 549 wmb(); /* see i2400m->updown's documentation */ 550 mutex_unlock(&i2400m->init_mutex); 551error_bus_setup: 552 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 553 return result; 554} 555EXPORT_SYMBOL_GPL(i2400m_post_reset); 556 557 558/* 559 * The device has rebooted; fix up the device and the driver 560 * 561 * Tear down the driver communication with the device, reload the 562 * firmware and reinitialize the communication with the device. 563 * 564 * If someone calls a reset when the device's firmware is down, in 565 * theory we won't see it because we are not listening. However, just 566 * in case, leave the code to handle it. 567 * 568 * If there is a reset context, use it; this means someone is waiting 569 * for us to tell him when the reset operation is complete and the 570 * device is ready to rock again. 571 * 572 * NOTE: if we are in the process of bringing up or down the 573 * communication with the device [running i2400m_dev_start() or 574 * _stop()], don't do anything, let it fail and handle it. 575 * 576 * This function is ran always in a thread context 577 * 578 * This function gets passed, as payload to i2400m_work() a 'const 579 * char *' ptr with a "reason" why the reset happened (for messages). 580 */ 581static 582void __i2400m_dev_reset_handle(struct work_struct *ws) 583{ 584 struct i2400m *i2400m = container_of(ws, struct i2400m, reset_ws); 585 const char *reason = i2400m->reset_reason; 586 struct device *dev = i2400m_dev(i2400m); 587 struct i2400m_reset_ctx *ctx = i2400m->reset_ctx; 588 int result; 589 590 d_fnstart(3, dev, "(ws %p i2400m %p reason %s)\n", ws, i2400m, reason); 591 592 i2400m->boot_mode = 1; 593 wmb(); /* Make sure i2400m_msg_to_dev() sees boot_mode */ 594 595 result = 0; 596 if (mutex_trylock(&i2400m->init_mutex) == 0) { 597 /* We are still in i2400m_dev_start() [let it fail] or 598 * i2400m_dev_stop() [we are shutting down anyway, so 599 * ignore it] or we are resetting somewhere else. */ 600 dev_err(dev, "device rebooted somewhere else?\n"); 601 i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST); 602 complete(&i2400m->msg_completion); 603 goto out; 604 } 605 606 dev_err(dev, "%s: reinitializing driver\n", reason); 607 rmb(); 608 if (i2400m->updown) { 609 __i2400m_dev_stop(i2400m); 610 i2400m->updown = 0; 611 wmb(); /* see i2400m->updown's documentation */ 612 } 613 614 if (i2400m->alive) { 615 result = __i2400m_dev_start(i2400m, 616 I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT); 617 if (result < 0) { 618 dev_err(dev, "%s: cannot start the device: %d\n", 619 reason, result); 620 result = -EUCLEAN; 621 if (atomic_read(&i2400m->bus_reset_retries) 622 >= I2400M_BUS_RESET_RETRIES) { 623 result = -ENODEV; 624 dev_err(dev, "tried too many times to " 625 "reset the device, giving up\n"); 626 } 627 } 628 } 629 630 if (i2400m->reset_ctx) { 631 ctx->result = result; 632 complete(&ctx->completion); 633 } 634 mutex_unlock(&i2400m->init_mutex); 635 if (result == -EUCLEAN) { 636 /* 637 * We come here because the reset during operational mode 638 * wasn't successfully done and need to proceed to a bus 639 * reset. For the dev_reset_handle() to be able to handle 640 * the reset event later properly, we restore boot_mode back 641 * to the state before previous reset. ie: just like we are 642 * issuing the bus reset for the first time 643 */ 644 i2400m->boot_mode = 0; 645 wmb(); 646 647 atomic_inc(&i2400m->bus_reset_retries); 648 /* ops, need to clean up [w/ init_mutex not held] */ 649 result = i2400m_reset(i2400m, I2400M_RT_BUS); 650 if (result >= 0) 651 result = -ENODEV; 652 } else { 653 rmb(); 654 if (i2400m->alive) { 655 /* great, we expect the device state up and 656 * dev_start() actually brings the device state up */ 657 i2400m->updown = 1; 658 wmb(); 659 atomic_set(&i2400m->bus_reset_retries, 0); 660 } 661 } 662out: 663 d_fnend(3, dev, "(ws %p i2400m %p reason %s) = void\n", 664 ws, i2400m, reason); 665} 666 667 668/** 669 * i2400m_dev_reset_handle - Handle a device's reset in a thread context 670 * 671 * Schedule a device reset handling out on a thread context, so it 672 * is safe to call from atomic context. We can't use the i2400m's 673 * queue as we are going to destroy it and reinitialize it as part of 674 * the driver bringup/bringup process. 675 * 676 * See __i2400m_dev_reset_handle() for details; that takes care of 677 * reinitializing the driver to handle the reset, calling into the 678 * bus-specific functions ops as needed. 679 */ 680int i2400m_dev_reset_handle(struct i2400m *i2400m, const char *reason) 681{ 682 i2400m->reset_reason = reason; 683 return schedule_work(&i2400m->reset_ws); 684} 685EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle); 686 687 688 /* 689 * The actual work of error recovery. 690 * 691 * The current implementation of error recovery is to trigger a bus reset. 692 */ 693static 694void __i2400m_error_recovery(struct work_struct *ws) 695{ 696 struct i2400m *i2400m = container_of(ws, struct i2400m, recovery_ws); 697 698 i2400m_reset(i2400m, I2400M_RT_BUS); 699} 700 701/* 702 * Schedule a work struct for error recovery. 703 * 704 * The intention of error recovery is to bring back the device to some 705 * known state whenever TX sees -110 (-ETIMEOUT) on copying the data to 706 * the device. The TX failure could mean a device bus stuck, so the current 707 * error recovery implementation is to trigger a bus reset to the device 708 * and hopefully it can bring back the device. 709 * 710 * The actual work of error recovery has to be in a thread context because 711 * it is kicked off in the TX thread (i2400ms->tx_workqueue) which is to be 712 * destroyed by the error recovery mechanism (currently a bus reset). 713 * 714 * Also, there may be already a queue of TX works that all hit 715 * the -ETIMEOUT error condition because the device is stuck already. 716 * Since bus reset is used as the error recovery mechanism and we don't 717 * want consecutive bus resets simply because the multiple TX works 718 * in the queue all hit the same device erratum, the flag "error_recovery" 719 * is introduced for preventing unwanted consecutive bus resets. 720 * 721 * Error recovery shall only be invoked again if previous one was completed. 722 * The flag error_recovery is set when error recovery mechanism is scheduled, 723 * and is checked when we need to schedule another error recovery. If it is 724 * in place already, then we shouldn't schedule another one. 725 */ 726void i2400m_error_recovery(struct i2400m *i2400m) 727{ 728 if (atomic_add_return(1, &i2400m->error_recovery) == 1) 729 schedule_work(&i2400m->recovery_ws); 730 else 731 atomic_dec(&i2400m->error_recovery); 732} 733EXPORT_SYMBOL_GPL(i2400m_error_recovery); 734 735/* 736 * Alloc the command and ack buffers for boot mode 737 * 738 * Get the buffers needed to deal with boot mode messages. 739 */ 740static 741int i2400m_bm_buf_alloc(struct i2400m *i2400m) 742{ 743 i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL); 744 if (i2400m->bm_cmd_buf == NULL) 745 goto error_bm_cmd_kzalloc; 746 i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL); 747 if (i2400m->bm_ack_buf == NULL) 748 goto error_bm_ack_buf_kzalloc; 749 return 0; 750 751error_bm_ack_buf_kzalloc: 752 kfree(i2400m->bm_cmd_buf); 753error_bm_cmd_kzalloc: 754 return -ENOMEM; 755} 756 757 758/* 759 * Free boot mode command and ack buffers. 760 */ 761static 762void i2400m_bm_buf_free(struct i2400m *i2400m) 763{ 764 kfree(i2400m->bm_ack_buf); 765 kfree(i2400m->bm_cmd_buf); 766} 767 768 769/** 770 * i2400m_init - Initialize a 'struct i2400m' from all zeroes 771 * 772 * This is a bus-generic API call. 773 */ 774void i2400m_init(struct i2400m *i2400m) 775{ 776 wimax_dev_init(&i2400m->wimax_dev); 777 778 i2400m->boot_mode = 1; 779 i2400m->rx_reorder = 1; 780 init_waitqueue_head(&i2400m->state_wq); 781 782 spin_lock_init(&i2400m->tx_lock); 783 i2400m->tx_pl_min = UINT_MAX; 784 i2400m->tx_size_min = UINT_MAX; 785 786 spin_lock_init(&i2400m->rx_lock); 787 i2400m->rx_pl_min = UINT_MAX; 788 i2400m->rx_size_min = UINT_MAX; 789 INIT_LIST_HEAD(&i2400m->rx_reports); 790 INIT_WORK(&i2400m->rx_report_ws, i2400m_report_hook_work); 791 792 mutex_init(&i2400m->msg_mutex); 793 init_completion(&i2400m->msg_completion); 794 795 mutex_init(&i2400m->init_mutex); 796 /* wake_tx_ws is initialized in i2400m_tx_setup() */ 797 798 INIT_WORK(&i2400m->reset_ws, __i2400m_dev_reset_handle); 799 INIT_WORK(&i2400m->recovery_ws, __i2400m_error_recovery); 800 801 atomic_set(&i2400m->bus_reset_retries, 0); 802 803 i2400m->alive = 0; 804 805 /* initialize error_recovery to 1 for denoting we 806 * are not yet ready to take any error recovery */ 807 atomic_set(&i2400m->error_recovery, 1); 808} 809EXPORT_SYMBOL_GPL(i2400m_init); 810 811 812int i2400m_reset(struct i2400m *i2400m, enum i2400m_reset_type rt) 813{ 814 struct net_device *net_dev = i2400m->wimax_dev.net_dev; 815 816 /* 817 * Make sure we stop TXs and down the carrier before 818 * resetting; this is needed to avoid things like 819 * i2400m_wake_tx() scheduling stuff in parallel. 820 */ 821 if (net_dev->reg_state == NETREG_REGISTERED) { 822 netif_tx_disable(net_dev); 823 netif_carrier_off(net_dev); 824 } 825 return i2400m->bus_reset(i2400m, rt); 826} 827EXPORT_SYMBOL_GPL(i2400m_reset); 828 829 830/** 831 * i2400m_setup - bus-generic setup function for the i2400m device 832 * 833 * @i2400m: device descriptor (bus-specific parts have been initialized) 834 * 835 * Returns: 0 if ok, < 0 errno code on error. 836 * 837 * Sets up basic device comunication infrastructure, boots the ROM to 838 * read the MAC address, registers with the WiMAX and network stacks 839 * and then brings up the device. 840 */ 841int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags) 842{ 843 int result; 844 struct device *dev = i2400m_dev(i2400m); 845 struct wimax_dev *wimax_dev = &i2400m->wimax_dev; 846 struct net_device *net_dev = i2400m->wimax_dev.net_dev; 847 848 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 849 850 snprintf(wimax_dev->name, sizeof(wimax_dev->name), 851 "i2400m-%s:%s", dev->bus->name, dev_name(dev)); 852 853 result = i2400m_bm_buf_alloc(i2400m); 854 if (result < 0) { 855 dev_err(dev, "cannot allocate bootmode scratch buffers\n"); 856 goto error_bm_buf_alloc; 857 } 858 859 if (i2400m->bus_setup) { 860 result = i2400m->bus_setup(i2400m); 861 if (result < 0) { 862 dev_err(dev, "bus-specific setup failed: %d\n", 863 result); 864 goto error_bus_setup; 865 } 866 } 867 868 result = i2400m_bootrom_init(i2400m, bm_flags); 869 if (result < 0) { 870 dev_err(dev, "read mac addr: bootrom init " 871 "failed: %d\n", result); 872 goto error_bootrom_init; 873 } 874 result = i2400m_read_mac_addr(i2400m); 875 if (result < 0) 876 goto error_read_mac_addr; 877 eth_random_addr(i2400m->src_mac_addr); 878 879 i2400m->pm_notifier.notifier_call = i2400m_pm_notifier; 880 register_pm_notifier(&i2400m->pm_notifier); 881 882 result = register_netdev(net_dev); /* Okey dokey, bring it up */ 883 if (result < 0) { 884 dev_err(dev, "cannot register i2400m network device: %d\n", 885 result); 886 goto error_register_netdev; 887 } 888 netif_carrier_off(net_dev); 889 890 i2400m->wimax_dev.op_msg_from_user = i2400m_op_msg_from_user; 891 i2400m->wimax_dev.op_rfkill_sw_toggle = i2400m_op_rfkill_sw_toggle; 892 i2400m->wimax_dev.op_reset = i2400m_op_reset; 893 894 result = wimax_dev_add(&i2400m->wimax_dev, net_dev); 895 if (result < 0) 896 goto error_wimax_dev_add; 897 898 /* Now setup all that requires a registered net and wimax device. */ 899 result = sysfs_create_group(&net_dev->dev.kobj, &i2400m_dev_attr_group); 900 if (result < 0) { 901 dev_err(dev, "cannot setup i2400m's sysfs: %d\n", result); 902 goto error_sysfs_setup; 903 } 904 905 i2400m_debugfs_add(i2400m); 906 907 result = i2400m_dev_start(i2400m, bm_flags); 908 if (result < 0) 909 goto error_dev_start; 910 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 911 return result; 912 913error_dev_start: 914 i2400m_debugfs_rm(i2400m); 915 sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj, 916 &i2400m_dev_attr_group); 917error_sysfs_setup: 918 wimax_dev_rm(&i2400m->wimax_dev); 919error_wimax_dev_add: 920 unregister_netdev(net_dev); 921error_register_netdev: 922 unregister_pm_notifier(&i2400m->pm_notifier); 923error_read_mac_addr: 924error_bootrom_init: 925 if (i2400m->bus_release) 926 i2400m->bus_release(i2400m); 927error_bus_setup: 928 i2400m_bm_buf_free(i2400m); 929error_bm_buf_alloc: 930 d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); 931 return result; 932} 933EXPORT_SYMBOL_GPL(i2400m_setup); 934 935 936/** 937 * i2400m_release - release the bus-generic driver resources 938 * 939 * Sends a disconnect message and undoes any setup done by i2400m_setup() 940 */ 941void i2400m_release(struct i2400m *i2400m) 942{ 943 struct device *dev = i2400m_dev(i2400m); 944 945 d_fnstart(3, dev, "(i2400m %p)\n", i2400m); 946 netif_stop_queue(i2400m->wimax_dev.net_dev); 947 948 i2400m_dev_stop(i2400m); 949 950 cancel_work_sync(&i2400m->reset_ws); 951 cancel_work_sync(&i2400m->recovery_ws); 952 953 i2400m_debugfs_rm(i2400m); 954 sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj, 955 &i2400m_dev_attr_group); 956 wimax_dev_rm(&i2400m->wimax_dev); 957 unregister_netdev(i2400m->wimax_dev.net_dev); 958 unregister_pm_notifier(&i2400m->pm_notifier); 959 if (i2400m->bus_release) 960 i2400m->bus_release(i2400m); 961 i2400m_bm_buf_free(i2400m); 962 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m); 963} 964EXPORT_SYMBOL_GPL(i2400m_release); 965 966 967/* 968 * Debug levels control; see debug.h 969 */ 970struct d_level D_LEVEL[] = { 971 D_SUBMODULE_DEFINE(control), 972 D_SUBMODULE_DEFINE(driver), 973 D_SUBMODULE_DEFINE(debugfs), 974 D_SUBMODULE_DEFINE(fw), 975 D_SUBMODULE_DEFINE(netdev), 976 D_SUBMODULE_DEFINE(rfkill), 977 D_SUBMODULE_DEFINE(rx), 978 D_SUBMODULE_DEFINE(sysfs), 979 D_SUBMODULE_DEFINE(tx), 980}; 981size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); 982 983 984static 985int __init i2400m_driver_init(void) 986{ 987 d_parse_params(D_LEVEL, D_LEVEL_SIZE, i2400m_debug_params, 988 "i2400m.debug"); 989 return i2400m_barker_db_init(i2400m_barkers_params); 990} 991module_init(i2400m_driver_init); 992 993static 994void __exit i2400m_driver_exit(void) 995{ 996 i2400m_barker_db_exit(); 997} 998module_exit(i2400m_driver_exit); 999 1000MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>"); 1001MODULE_DESCRIPTION("Intel 2400M WiMAX networking bus-generic driver"); 1002MODULE_LICENSE("GPL"); 1003