main.c revision e64c026dd09b73faf20707711402fc5ed55a8e70
1/** 2 * This file contains the major functions in WLAN 3 * driver. It includes init, exit, open, close and main 4 * thread etc.. 5 */ 6 7#include <linux/moduleparam.h> 8#include <linux/delay.h> 9#include <linux/etherdevice.h> 10#include <linux/netdevice.h> 11#include <linux/if_arp.h> 12#include <linux/kthread.h> 13#include <linux/kfifo.h> 14#include <linux/stddef.h> 15#include <linux/ieee80211.h> 16#include <net/iw_handler.h> 17#include <net/cfg80211.h> 18 19#include "host.h" 20#include "decl.h" 21#include "dev.h" 22#include "wext.h" 23#include "cfg.h" 24#include "debugfs.h" 25#include "scan.h" 26#include "assoc.h" 27#include "cmd.h" 28 29#define DRIVER_RELEASE_VERSION "323.p0" 30const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION 31#ifdef DEBUG 32 "-dbg" 33#endif 34 ""; 35 36 37/* Module parameters */ 38unsigned int lbs_debug; 39EXPORT_SYMBOL_GPL(lbs_debug); 40module_param_named(libertas_debug, lbs_debug, int, 0644); 41 42 43/* This global structure is used to send the confirm_sleep command as 44 * fast as possible down to the firmware. */ 45struct cmd_confirm_sleep confirm_sleep; 46 47 48/** 49 * the table to keep region code 50 */ 51u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] = 52 { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; 53 54/** 55 * FW rate table. FW refers to rates by their index in this table, not by the 56 * rate value itself. Values of 0x00 are 57 * reserved positions. 58 */ 59static u8 fw_data_rates[MAX_RATES] = 60 { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12, 61 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00 62}; 63 64/** 65 * @brief use index to get the data rate 66 * 67 * @param idx The index of data rate 68 * @return data rate or 0 69 */ 70u32 lbs_fw_index_to_data_rate(u8 idx) 71{ 72 if (idx >= sizeof(fw_data_rates)) 73 idx = 0; 74 return fw_data_rates[idx]; 75} 76 77/** 78 * @brief use rate to get the index 79 * 80 * @param rate data rate 81 * @return index or 0 82 */ 83u8 lbs_data_rate_to_fw_index(u32 rate) 84{ 85 u8 i; 86 87 if (!rate) 88 return 0; 89 90 for (i = 0; i < sizeof(fw_data_rates); i++) { 91 if (rate == fw_data_rates[i]) 92 return i; 93 } 94 return 0; 95} 96 97 98static int lbs_add_rtap(struct lbs_private *priv); 99static void lbs_remove_rtap(struct lbs_private *priv); 100 101 102/** 103 * Get function for sysfs attribute rtap 104 */ 105static ssize_t lbs_rtap_get(struct device *dev, 106 struct device_attribute *attr, char * buf) 107{ 108 struct lbs_private *priv = to_net_dev(dev)->ml_priv; 109 return snprintf(buf, 5, "0x%X\n", priv->monitormode); 110} 111 112/** 113 * Set function for sysfs attribute rtap 114 */ 115static ssize_t lbs_rtap_set(struct device *dev, 116 struct device_attribute *attr, const char * buf, size_t count) 117{ 118 int monitor_mode; 119 struct lbs_private *priv = to_net_dev(dev)->ml_priv; 120 121 sscanf(buf, "%x", &monitor_mode); 122 if (monitor_mode) { 123 if (priv->monitormode == monitor_mode) 124 return strlen(buf); 125 if (!priv->monitormode) { 126 if (priv->infra_open || priv->mesh_open) 127 return -EBUSY; 128 if (priv->mode == IW_MODE_INFRA) 129 lbs_cmd_80211_deauthenticate(priv, 130 priv->curbssparams.bssid, 131 WLAN_REASON_DEAUTH_LEAVING); 132 else if (priv->mode == IW_MODE_ADHOC) 133 lbs_adhoc_stop(priv); 134 lbs_add_rtap(priv); 135 } 136 priv->monitormode = monitor_mode; 137 } else { 138 if (!priv->monitormode) 139 return strlen(buf); 140 priv->monitormode = 0; 141 lbs_remove_rtap(priv); 142 143 if (priv->currenttxskb) { 144 dev_kfree_skb_any(priv->currenttxskb); 145 priv->currenttxskb = NULL; 146 } 147 148 /* Wake queues, command thread, etc. */ 149 lbs_host_to_card_done(priv); 150 } 151 152 lbs_prepare_and_send_command(priv, 153 CMD_802_11_MONITOR_MODE, CMD_ACT_SET, 154 CMD_OPTION_WAITFORRSP, 0, &priv->monitormode); 155 return strlen(buf); 156} 157 158/** 159 * lbs_rtap attribute to be exported per ethX interface 160 * through sysfs (/sys/class/net/ethX/lbs_rtap) 161 */ 162static DEVICE_ATTR(lbs_rtap, 0644, lbs_rtap_get, lbs_rtap_set ); 163 164/** 165 * @brief This function opens the ethX interface 166 * 167 * @param dev A pointer to net_device structure 168 * @return 0 or -EBUSY if monitor mode active 169 */ 170static int lbs_dev_open(struct net_device *dev) 171{ 172 struct lbs_private *priv = dev->ml_priv; 173 int ret = 0; 174 175 lbs_deb_enter(LBS_DEB_NET); 176 177 spin_lock_irq(&priv->driver_lock); 178 179 if (priv->monitormode) { 180 ret = -EBUSY; 181 goto out; 182 } 183 184 priv->infra_open = 1; 185 186 if (priv->connect_status == LBS_CONNECTED) 187 netif_carrier_on(dev); 188 else 189 netif_carrier_off(dev); 190 191 if (!priv->tx_pending_len) 192 netif_wake_queue(dev); 193 out: 194 195 spin_unlock_irq(&priv->driver_lock); 196 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 197 return ret; 198} 199 200/** 201 * @brief This function closes the ethX interface 202 * 203 * @param dev A pointer to net_device structure 204 * @return 0 205 */ 206static int lbs_eth_stop(struct net_device *dev) 207{ 208 struct lbs_private *priv = dev->ml_priv; 209 210 lbs_deb_enter(LBS_DEB_NET); 211 212 spin_lock_irq(&priv->driver_lock); 213 priv->infra_open = 0; 214 netif_stop_queue(dev); 215 spin_unlock_irq(&priv->driver_lock); 216 217 schedule_work(&priv->mcast_work); 218 219 lbs_deb_leave(LBS_DEB_NET); 220 return 0; 221} 222 223static void lbs_tx_timeout(struct net_device *dev) 224{ 225 struct lbs_private *priv = dev->ml_priv; 226 227 lbs_deb_enter(LBS_DEB_TX); 228 229 lbs_pr_err("tx watch dog timeout\n"); 230 231 dev->trans_start = jiffies; 232 233 if (priv->currenttxskb) 234 lbs_send_tx_feedback(priv, 0); 235 236 /* XX: Shouldn't we also call into the hw-specific driver 237 to kick it somehow? */ 238 lbs_host_to_card_done(priv); 239 240 /* More often than not, this actually happens because the 241 firmware has crapped itself -- rather than just a very 242 busy medium. So send a harmless command, and if/when 243 _that_ times out, we'll kick it in the head. */ 244 lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, 245 0, 0, NULL); 246 247 lbs_deb_leave(LBS_DEB_TX); 248} 249 250void lbs_host_to_card_done(struct lbs_private *priv) 251{ 252 unsigned long flags; 253 254 lbs_deb_enter(LBS_DEB_THREAD); 255 256 spin_lock_irqsave(&priv->driver_lock, flags); 257 258 priv->dnld_sent = DNLD_RES_RECEIVED; 259 260 /* Wake main thread if commands are pending */ 261 if (!priv->cur_cmd || priv->tx_pending_len > 0) { 262 if (!priv->wakeup_dev_required) 263 wake_up_interruptible(&priv->waitq); 264 } 265 266 spin_unlock_irqrestore(&priv->driver_lock, flags); 267 lbs_deb_leave(LBS_DEB_THREAD); 268} 269EXPORT_SYMBOL_GPL(lbs_host_to_card_done); 270 271int lbs_set_mac_address(struct net_device *dev, void *addr) 272{ 273 int ret = 0; 274 struct lbs_private *priv = dev->ml_priv; 275 struct sockaddr *phwaddr = addr; 276 struct cmd_ds_802_11_mac_address cmd; 277 278 lbs_deb_enter(LBS_DEB_NET); 279 280 /* In case it was called from the mesh device */ 281 dev = priv->dev; 282 283 cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 284 cmd.action = cpu_to_le16(CMD_ACT_SET); 285 memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN); 286 287 ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd); 288 if (ret) { 289 lbs_deb_net("set MAC address failed\n"); 290 goto done; 291 } 292 293 memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN); 294 memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN); 295 if (priv->mesh_dev) 296 memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN); 297 298done: 299 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 300 return ret; 301} 302 303 304static inline int mac_in_list(unsigned char *list, int list_len, 305 unsigned char *mac) 306{ 307 while (list_len) { 308 if (!memcmp(list, mac, ETH_ALEN)) 309 return 1; 310 list += ETH_ALEN; 311 list_len--; 312 } 313 return 0; 314} 315 316 317static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd, 318 struct net_device *dev, int nr_addrs) 319{ 320 int i = nr_addrs; 321 struct dev_mc_list *mc_list; 322 323 if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST)) 324 return nr_addrs; 325 326 netif_addr_lock_bh(dev); 327 for (mc_list = dev->mc_list; mc_list; mc_list = mc_list->next) { 328 if (mac_in_list(cmd->maclist, nr_addrs, mc_list->dmi_addr)) { 329 lbs_deb_net("mcast address %s:%pM skipped\n", dev->name, 330 mc_list->dmi_addr); 331 continue; 332 } 333 334 if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE) 335 break; 336 memcpy(&cmd->maclist[6*i], mc_list->dmi_addr, ETH_ALEN); 337 lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name, 338 mc_list->dmi_addr); 339 i++; 340 } 341 netif_addr_unlock_bh(dev); 342 if (mc_list) 343 return -EOVERFLOW; 344 345 return i; 346} 347 348static void lbs_set_mcast_worker(struct work_struct *work) 349{ 350 struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work); 351 struct cmd_ds_mac_multicast_adr mcast_cmd; 352 int dev_flags; 353 int nr_addrs; 354 int old_mac_control = priv->mac_control; 355 356 lbs_deb_enter(LBS_DEB_NET); 357 358 dev_flags = priv->dev->flags; 359 if (priv->mesh_dev) 360 dev_flags |= priv->mesh_dev->flags; 361 362 if (dev_flags & IFF_PROMISC) { 363 priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE; 364 priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | 365 CMD_ACT_MAC_MULTICAST_ENABLE); 366 goto out_set_mac_control; 367 } else if (dev_flags & IFF_ALLMULTI) { 368 do_allmulti: 369 priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE; 370 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | 371 CMD_ACT_MAC_MULTICAST_ENABLE); 372 goto out_set_mac_control; 373 } 374 375 /* Once for priv->dev, again for priv->mesh_dev if it exists */ 376 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0); 377 if (nr_addrs >= 0 && priv->mesh_dev) 378 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs); 379 if (nr_addrs < 0) 380 goto do_allmulti; 381 382 if (nr_addrs) { 383 int size = offsetof(struct cmd_ds_mac_multicast_adr, 384 maclist[6*nr_addrs]); 385 386 mcast_cmd.action = cpu_to_le16(CMD_ACT_SET); 387 mcast_cmd.hdr.size = cpu_to_le16(size); 388 mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs); 389 390 lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size); 391 392 priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE; 393 } else 394 priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE; 395 396 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | 397 CMD_ACT_MAC_ALL_MULTICAST_ENABLE); 398 out_set_mac_control: 399 if (priv->mac_control != old_mac_control) 400 lbs_set_mac_control(priv); 401 402 lbs_deb_leave(LBS_DEB_NET); 403} 404 405void lbs_set_multicast_list(struct net_device *dev) 406{ 407 struct lbs_private *priv = dev->ml_priv; 408 409 schedule_work(&priv->mcast_work); 410} 411 412/** 413 * @brief This function handles the major jobs in the LBS driver. 414 * It handles all events generated by firmware, RX data received 415 * from firmware and TX data sent from kernel. 416 * 417 * @param data A pointer to lbs_thread structure 418 * @return 0 419 */ 420static int lbs_thread(void *data) 421{ 422 struct net_device *dev = data; 423 struct lbs_private *priv = dev->ml_priv; 424 wait_queue_t wait; 425 426 lbs_deb_enter(LBS_DEB_THREAD); 427 428 init_waitqueue_entry(&wait, current); 429 430 for (;;) { 431 int shouldsleep; 432 u8 resp_idx; 433 434 lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n", 435 priv->currenttxskb, priv->dnld_sent); 436 437 add_wait_queue(&priv->waitq, &wait); 438 set_current_state(TASK_INTERRUPTIBLE); 439 spin_lock_irq(&priv->driver_lock); 440 441 if (kthread_should_stop()) 442 shouldsleep = 0; /* Bye */ 443 else if (priv->surpriseremoved) 444 shouldsleep = 1; /* We need to wait until we're _told_ to die */ 445 else if (priv->psstate == PS_STATE_SLEEP) 446 shouldsleep = 1; /* Sleep mode. Nothing we can do till it wakes */ 447 else if (priv->cmd_timed_out) 448 shouldsleep = 0; /* Command timed out. Recover */ 449 else if (!priv->fw_ready) 450 shouldsleep = 1; /* Firmware not ready. We're waiting for it */ 451 else if (priv->dnld_sent) 452 shouldsleep = 1; /* Something is en route to the device already */ 453 else if (priv->tx_pending_len > 0) 454 shouldsleep = 0; /* We've a packet to send */ 455 else if (priv->resp_len[priv->resp_idx]) 456 shouldsleep = 0; /* We have a command response */ 457 else if (priv->cur_cmd) 458 shouldsleep = 1; /* Can't send a command; one already running */ 459 else if (!list_empty(&priv->cmdpendingq) && 460 !(priv->wakeup_dev_required)) 461 shouldsleep = 0; /* We have a command to send */ 462 else if (kfifo_len(&priv->event_fifo)) 463 shouldsleep = 0; /* We have an event to process */ 464 else 465 shouldsleep = 1; /* No command */ 466 467 if (shouldsleep) { 468 lbs_deb_thread("sleeping, connect_status %d, " 469 "psmode %d, psstate %d\n", 470 priv->connect_status, 471 priv->psmode, priv->psstate); 472 spin_unlock_irq(&priv->driver_lock); 473 schedule(); 474 } else 475 spin_unlock_irq(&priv->driver_lock); 476 477 lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n", 478 priv->currenttxskb, priv->dnld_sent); 479 480 set_current_state(TASK_RUNNING); 481 remove_wait_queue(&priv->waitq, &wait); 482 483 lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n", 484 priv->currenttxskb, priv->dnld_sent); 485 486 if (kthread_should_stop()) { 487 lbs_deb_thread("break from main thread\n"); 488 break; 489 } 490 491 if (priv->surpriseremoved) { 492 lbs_deb_thread("adapter removed; waiting to die...\n"); 493 continue; 494 } 495 496 lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n", 497 priv->currenttxskb, priv->dnld_sent); 498 499 /* Process any pending command response */ 500 spin_lock_irq(&priv->driver_lock); 501 resp_idx = priv->resp_idx; 502 if (priv->resp_len[resp_idx]) { 503 spin_unlock_irq(&priv->driver_lock); 504 lbs_process_command_response(priv, 505 priv->resp_buf[resp_idx], 506 priv->resp_len[resp_idx]); 507 spin_lock_irq(&priv->driver_lock); 508 priv->resp_len[resp_idx] = 0; 509 } 510 spin_unlock_irq(&priv->driver_lock); 511 512 /* Process hardware events, e.g. card removed, link lost */ 513 spin_lock_irq(&priv->driver_lock); 514 while (kfifo_len(&priv->event_fifo)) { 515 u32 event; 516 kfifo_get(&priv->event_fifo, (unsigned char *) &event, 517 sizeof(event)); 518 spin_unlock_irq(&priv->driver_lock); 519 lbs_process_event(priv, event); 520 spin_lock_irq(&priv->driver_lock); 521 } 522 spin_unlock_irq(&priv->driver_lock); 523 524 if (priv->wakeup_dev_required) { 525 lbs_deb_thread("Waking up device...\n"); 526 /* Wake up device */ 527 if (priv->exit_deep_sleep(priv)) 528 lbs_deb_thread("Wakeup device failed\n"); 529 continue; 530 } 531 532 /* command timeout stuff */ 533 if (priv->cmd_timed_out && priv->cur_cmd) { 534 struct cmd_ctrl_node *cmdnode = priv->cur_cmd; 535 536 if (++priv->nr_retries > 3) { 537 lbs_pr_info("Excessive timeouts submitting " 538 "command 0x%04x\n", 539 le16_to_cpu(cmdnode->cmdbuf->command)); 540 lbs_complete_command(priv, cmdnode, -ETIMEDOUT); 541 priv->nr_retries = 0; 542 if (priv->reset_card) 543 priv->reset_card(priv); 544 } else { 545 priv->cur_cmd = NULL; 546 priv->dnld_sent = DNLD_RES_RECEIVED; 547 lbs_pr_info("requeueing command 0x%04x due " 548 "to timeout (#%d)\n", 549 le16_to_cpu(cmdnode->cmdbuf->command), 550 priv->nr_retries); 551 552 /* Stick it back at the _top_ of the pending queue 553 for immediate resubmission */ 554 list_add(&cmdnode->list, &priv->cmdpendingq); 555 } 556 } 557 priv->cmd_timed_out = 0; 558 559 560 561 if (!priv->fw_ready) 562 continue; 563 564 /* Check if we need to confirm Sleep Request received previously */ 565 if (priv->psstate == PS_STATE_PRE_SLEEP && 566 !priv->dnld_sent && !priv->cur_cmd) { 567 if (priv->connect_status == LBS_CONNECTED) { 568 lbs_deb_thread("pre-sleep, currenttxskb %p, " 569 "dnld_sent %d, cur_cmd %p\n", 570 priv->currenttxskb, priv->dnld_sent, 571 priv->cur_cmd); 572 573 lbs_ps_confirm_sleep(priv); 574 } else { 575 /* workaround for firmware sending 576 * deauth/linkloss event immediately 577 * after sleep request; remove this 578 * after firmware fixes it 579 */ 580 priv->psstate = PS_STATE_AWAKE; 581 lbs_pr_alert("ignore PS_SleepConfirm in " 582 "non-connected state\n"); 583 } 584 } 585 586 /* The PS state is changed during processing of Sleep Request 587 * event above 588 */ 589 if ((priv->psstate == PS_STATE_SLEEP) || 590 (priv->psstate == PS_STATE_PRE_SLEEP)) 591 continue; 592 593 if (priv->is_deep_sleep) 594 continue; 595 596 /* Execute the next command */ 597 if (!priv->dnld_sent && !priv->cur_cmd) 598 lbs_execute_next_command(priv); 599 600 /* Wake-up command waiters which can't sleep in 601 * lbs_prepare_and_send_command 602 */ 603 if (!list_empty(&priv->cmdpendingq)) 604 wake_up_all(&priv->cmd_pending); 605 606 spin_lock_irq(&priv->driver_lock); 607 if (!priv->dnld_sent && priv->tx_pending_len > 0) { 608 int ret = priv->hw_host_to_card(priv, MVMS_DAT, 609 priv->tx_pending_buf, 610 priv->tx_pending_len); 611 if (ret) { 612 lbs_deb_tx("host_to_card failed %d\n", ret); 613 priv->dnld_sent = DNLD_RES_RECEIVED; 614 } 615 priv->tx_pending_len = 0; 616 if (!priv->currenttxskb) { 617 /* We can wake the queues immediately if we aren't 618 waiting for TX feedback */ 619 if (priv->connect_status == LBS_CONNECTED) 620 netif_wake_queue(priv->dev); 621 if (priv->mesh_dev && 622 priv->mesh_connect_status == LBS_CONNECTED) 623 netif_wake_queue(priv->mesh_dev); 624 } 625 } 626 spin_unlock_irq(&priv->driver_lock); 627 } 628 629 del_timer(&priv->command_timer); 630 del_timer(&priv->auto_deepsleep_timer); 631 wake_up_all(&priv->cmd_pending); 632 633 lbs_deb_leave(LBS_DEB_THREAD); 634 return 0; 635} 636 637static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy, 638 struct cmd_header *cmd) 639{ 640 lbs_deb_enter(LBS_DEB_FW); 641 642 netif_device_detach(priv->dev); 643 if (priv->mesh_dev) 644 netif_device_detach(priv->mesh_dev); 645 646 priv->fw_ready = 0; 647 lbs_deb_leave(LBS_DEB_FW); 648 return 0; 649} 650 651int lbs_suspend(struct lbs_private *priv) 652{ 653 struct cmd_header cmd; 654 int ret; 655 656 lbs_deb_enter(LBS_DEB_FW); 657 658 if (priv->wol_criteria == 0xffffffff) { 659 lbs_pr_info("Suspend attempt without configuring wake params!\n"); 660 return -EINVAL; 661 } 662 663 memset(&cmd, 0, sizeof(cmd)); 664 665 ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd, 666 sizeof(cmd), lbs_suspend_callback, 0); 667 if (ret) 668 lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret); 669 670 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 671 return ret; 672} 673EXPORT_SYMBOL_GPL(lbs_suspend); 674 675void lbs_resume(struct lbs_private *priv) 676{ 677 lbs_deb_enter(LBS_DEB_FW); 678 679 priv->fw_ready = 1; 680 681 /* Firmware doesn't seem to give us RX packets any more 682 until we send it some command. Might as well update */ 683 lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, 684 0, 0, NULL); 685 686 netif_device_attach(priv->dev); 687 if (priv->mesh_dev) 688 netif_device_attach(priv->mesh_dev); 689 690 lbs_deb_leave(LBS_DEB_FW); 691} 692EXPORT_SYMBOL_GPL(lbs_resume); 693 694/** 695 * @brief This function gets the HW spec from the firmware and sets 696 * some basic parameters. 697 * 698 * @param priv A pointer to struct lbs_private structure 699 * @return 0 or -1 700 */ 701static int lbs_setup_firmware(struct lbs_private *priv) 702{ 703 int ret = -1; 704 s16 curlevel = 0, minlevel = 0, maxlevel = 0; 705 706 lbs_deb_enter(LBS_DEB_FW); 707 708 /* Read MAC address from firmware */ 709 memset(priv->current_addr, 0xff, ETH_ALEN); 710 ret = lbs_update_hw_spec(priv); 711 if (ret) 712 goto done; 713 714 /* Read power levels if available */ 715 ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel); 716 if (ret == 0) { 717 priv->txpower_cur = curlevel; 718 priv->txpower_min = minlevel; 719 priv->txpower_max = maxlevel; 720 } 721 722 lbs_set_mac_control(priv); 723done: 724 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 725 return ret; 726} 727 728/** 729 * This function handles the timeout of command sending. 730 * It will re-send the same command again. 731 */ 732static void command_timer_fn(unsigned long data) 733{ 734 struct lbs_private *priv = (struct lbs_private *)data; 735 unsigned long flags; 736 737 lbs_deb_enter(LBS_DEB_CMD); 738 spin_lock_irqsave(&priv->driver_lock, flags); 739 740 if (!priv->cur_cmd) 741 goto out; 742 743 lbs_pr_info("command 0x%04x timed out\n", 744 le16_to_cpu(priv->cur_cmd->cmdbuf->command)); 745 746 priv->cmd_timed_out = 1; 747 wake_up_interruptible(&priv->waitq); 748out: 749 spin_unlock_irqrestore(&priv->driver_lock, flags); 750 lbs_deb_leave(LBS_DEB_CMD); 751} 752 753/** 754 * This function put the device back to deep sleep mode when timer expires 755 * and no activity (command, event, data etc.) is detected. 756 */ 757static void auto_deepsleep_timer_fn(unsigned long data) 758{ 759 struct lbs_private *priv = (struct lbs_private *)data; 760 int ret; 761 762 lbs_deb_enter(LBS_DEB_CMD); 763 764 if (priv->is_activity_detected) { 765 priv->is_activity_detected = 0; 766 } else { 767 if (priv->is_auto_deep_sleep_enabled && 768 (!priv->wakeup_dev_required) && 769 (priv->connect_status != LBS_CONNECTED)) { 770 lbs_deb_main("Entering auto deep sleep mode...\n"); 771 ret = lbs_prepare_and_send_command(priv, 772 CMD_802_11_DEEP_SLEEP, 0, 773 0, 0, NULL); 774 if (ret) 775 lbs_pr_err("Enter Deep Sleep command failed\n"); 776 } 777 } 778 mod_timer(&priv->auto_deepsleep_timer , jiffies + 779 (priv->auto_deep_sleep_timeout * HZ)/1000); 780 lbs_deb_leave(LBS_DEB_CMD); 781} 782 783int lbs_enter_auto_deep_sleep(struct lbs_private *priv) 784{ 785 lbs_deb_enter(LBS_DEB_SDIO); 786 787 priv->is_auto_deep_sleep_enabled = 1; 788 if (priv->is_deep_sleep) 789 priv->wakeup_dev_required = 1; 790 mod_timer(&priv->auto_deepsleep_timer , 791 jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000); 792 793 lbs_deb_leave(LBS_DEB_SDIO); 794 return 0; 795} 796 797int lbs_exit_auto_deep_sleep(struct lbs_private *priv) 798{ 799 lbs_deb_enter(LBS_DEB_SDIO); 800 801 priv->is_auto_deep_sleep_enabled = 0; 802 priv->auto_deep_sleep_timeout = 0; 803 del_timer(&priv->auto_deepsleep_timer); 804 805 lbs_deb_leave(LBS_DEB_SDIO); 806 return 0; 807} 808 809static void lbs_sync_channel_worker(struct work_struct *work) 810{ 811 struct lbs_private *priv = container_of(work, struct lbs_private, 812 sync_channel); 813 814 lbs_deb_enter(LBS_DEB_MAIN); 815 if (lbs_update_channel(priv)) 816 lbs_pr_info("Channel synchronization failed."); 817 lbs_deb_leave(LBS_DEB_MAIN); 818} 819 820 821static int lbs_init_adapter(struct lbs_private *priv) 822{ 823 size_t bufsize; 824 int i, ret = 0; 825 826 lbs_deb_enter(LBS_DEB_MAIN); 827 828 /* Allocate buffer to store the BSSID list */ 829 bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); 830 priv->networks = kzalloc(bufsize, GFP_KERNEL); 831 if (!priv->networks) { 832 lbs_pr_err("Out of memory allocating beacons\n"); 833 ret = -1; 834 goto out; 835 } 836 837 /* Initialize scan result lists */ 838 INIT_LIST_HEAD(&priv->network_free_list); 839 INIT_LIST_HEAD(&priv->network_list); 840 for (i = 0; i < MAX_NETWORK_COUNT; i++) { 841 list_add_tail(&priv->networks[i].list, 842 &priv->network_free_list); 843 } 844 845 memset(priv->current_addr, 0xff, ETH_ALEN); 846 847 priv->connect_status = LBS_DISCONNECTED; 848 priv->mesh_connect_status = LBS_DISCONNECTED; 849 priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; 850 priv->mode = IW_MODE_INFRA; 851 priv->channel = DEFAULT_AD_HOC_CHANNEL; 852 priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; 853 priv->radio_on = 1; 854 priv->enablehwauto = 1; 855 priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 856 priv->psmode = LBS802_11POWERMODECAM; 857 priv->psstate = PS_STATE_FULL_POWER; 858 priv->is_deep_sleep = 0; 859 priv->is_auto_deep_sleep_enabled = 0; 860 priv->wakeup_dev_required = 0; 861 init_waitqueue_head(&priv->ds_awake_q); 862 863 mutex_init(&priv->lock); 864 865 setup_timer(&priv->command_timer, command_timer_fn, 866 (unsigned long)priv); 867 setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, 868 (unsigned long)priv); 869 870 INIT_LIST_HEAD(&priv->cmdfreeq); 871 INIT_LIST_HEAD(&priv->cmdpendingq); 872 873 spin_lock_init(&priv->driver_lock); 874 init_waitqueue_head(&priv->cmd_pending); 875 876 /* Allocate the command buffers */ 877 if (lbs_allocate_cmd_buffer(priv)) { 878 lbs_pr_err("Out of memory allocating command buffers\n"); 879 ret = -ENOMEM; 880 goto out; 881 } 882 priv->resp_idx = 0; 883 priv->resp_len[0] = priv->resp_len[1] = 0; 884 885 /* Create the event FIFO */ 886 ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL); 887 if (ret) { 888 lbs_pr_err("Out of memory allocating event FIFO buffer\n"); 889 goto out; 890 } 891 892out: 893 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 894 895 return ret; 896} 897 898static void lbs_free_adapter(struct lbs_private *priv) 899{ 900 lbs_deb_enter(LBS_DEB_MAIN); 901 902 lbs_free_cmd_buffer(priv); 903 kfifo_free(&priv->event_fifo); 904 del_timer(&priv->command_timer); 905 del_timer(&priv->auto_deepsleep_timer); 906 kfree(priv->networks); 907 priv->networks = NULL; 908 909 lbs_deb_leave(LBS_DEB_MAIN); 910} 911 912static const struct net_device_ops lbs_netdev_ops = { 913 .ndo_open = lbs_dev_open, 914 .ndo_stop = lbs_eth_stop, 915 .ndo_start_xmit = lbs_hard_start_xmit, 916 .ndo_set_mac_address = lbs_set_mac_address, 917 .ndo_tx_timeout = lbs_tx_timeout, 918 .ndo_set_multicast_list = lbs_set_multicast_list, 919 .ndo_change_mtu = eth_change_mtu, 920 .ndo_validate_addr = eth_validate_addr, 921}; 922 923/** 924 * @brief This function adds the card. it will probe the 925 * card, allocate the lbs_priv and initialize the device. 926 * 927 * @param card A pointer to card 928 * @return A pointer to struct lbs_private structure 929 */ 930struct lbs_private *lbs_add_card(void *card, struct device *dmdev) 931{ 932 struct net_device *dev; 933 struct wireless_dev *wdev; 934 struct lbs_private *priv = NULL; 935 936 lbs_deb_enter(LBS_DEB_MAIN); 937 938 /* Allocate an Ethernet device and register it */ 939 wdev = lbs_cfg_alloc(dmdev); 940 if (IS_ERR(wdev)) { 941 lbs_pr_err("cfg80211 init failed\n"); 942 goto done; 943 } 944 /* TODO? */ 945 wdev->iftype = NL80211_IFTYPE_STATION; 946 priv = wdev_priv(wdev); 947 priv->wdev = wdev; 948 949 if (lbs_init_adapter(priv)) { 950 lbs_pr_err("failed to initialize adapter structure.\n"); 951 goto err_wdev; 952 } 953 954 //TODO? dev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES); 955 dev = alloc_netdev(0, "wlan%d", ether_setup); 956 if (!dev) { 957 dev_err(dmdev, "no memory for network device instance\n"); 958 goto err_adapter; 959 } 960 961 dev->ieee80211_ptr = wdev; 962 dev->ml_priv = priv; 963 SET_NETDEV_DEV(dev, dmdev); 964 wdev->netdev = dev; 965 priv->dev = dev; 966 967 dev->netdev_ops = &lbs_netdev_ops; 968 dev->watchdog_timeo = 5 * HZ; 969 dev->ethtool_ops = &lbs_ethtool_ops; 970#ifdef WIRELESS_EXT 971 dev->wireless_handlers = &lbs_handler_def; 972#endif 973 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 974 975 976 // TODO: kzalloc + iwm_init_default_profile(iwm, iwm->umac_profile); ?? 977 978 979 priv->card = card; 980 priv->infra_open = 0; 981 982 983 priv->rtap_net_dev = NULL; 984 strcpy(dev->name, "wlan%d"); 985 986 lbs_deb_thread("Starting main thread...\n"); 987 init_waitqueue_head(&priv->waitq); 988 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); 989 if (IS_ERR(priv->main_thread)) { 990 lbs_deb_thread("Error creating main thread.\n"); 991 goto err_ndev; 992 } 993 994 priv->work_thread = create_singlethread_workqueue("lbs_worker"); 995 INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); 996 INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); 997 INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker); 998 INIT_WORK(&priv->sync_channel, lbs_sync_channel_worker); 999 1000 priv->mesh_open = 0; 1001 sprintf(priv->mesh_ssid, "mesh"); 1002 priv->mesh_ssid_len = 4; 1003 1004 priv->wol_criteria = 0xffffffff; 1005 priv->wol_gpio = 0xff; 1006 1007 goto done; 1008 1009 err_ndev: 1010 free_netdev(dev); 1011 1012 err_adapter: 1013 lbs_free_adapter(priv); 1014 1015 err_wdev: 1016 lbs_cfg_free(priv); 1017 1018 priv = NULL; 1019 1020done: 1021 lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); 1022 return priv; 1023} 1024EXPORT_SYMBOL_GPL(lbs_add_card); 1025 1026 1027void lbs_remove_card(struct lbs_private *priv) 1028{ 1029 struct net_device *dev = priv->dev; 1030 1031 lbs_deb_enter(LBS_DEB_MAIN); 1032 1033 lbs_remove_mesh(priv); 1034 lbs_remove_rtap(priv); 1035 1036 dev = priv->dev; 1037 1038 cancel_delayed_work_sync(&priv->scan_work); 1039 cancel_delayed_work_sync(&priv->assoc_work); 1040 cancel_work_sync(&priv->mcast_work); 1041 1042 /* worker thread destruction blocks on the in-flight command which 1043 * should have been cleared already in lbs_stop_card(). 1044 */ 1045 lbs_deb_main("destroying worker thread\n"); 1046 destroy_workqueue(priv->work_thread); 1047 lbs_deb_main("done destroying worker thread\n"); 1048 1049 if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { 1050 priv->psmode = LBS802_11POWERMODECAM; 1051 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); 1052 } 1053 1054 lbs_send_disconnect_notification(priv); 1055 1056 if (priv->is_deep_sleep) { 1057 priv->is_deep_sleep = 0; 1058 wake_up_interruptible(&priv->ds_awake_q); 1059 } 1060 1061 /* Stop the thread servicing the interrupts */ 1062 priv->surpriseremoved = 1; 1063 kthread_stop(priv->main_thread); 1064 1065 lbs_free_adapter(priv); 1066 lbs_cfg_free(priv); 1067 1068 priv->dev = NULL; 1069 free_netdev(dev); 1070 1071 lbs_deb_leave(LBS_DEB_MAIN); 1072} 1073EXPORT_SYMBOL_GPL(lbs_remove_card); 1074 1075 1076int lbs_start_card(struct lbs_private *priv) 1077{ 1078 struct net_device *dev = priv->dev; 1079 int ret = -1; 1080 1081 lbs_deb_enter(LBS_DEB_MAIN); 1082 1083 /* poke the firmware */ 1084 ret = lbs_setup_firmware(priv); 1085 if (ret) 1086 goto done; 1087 1088 if (lbs_cfg_register(priv)) { 1089 lbs_pr_err("cannot register device\n"); 1090 goto done; 1091 } 1092 1093 lbs_update_channel(priv); 1094 1095 /* 1096 * While rtap isn't related to mesh, only mesh-enabled 1097 * firmware implements the rtap functionality via 1098 * CMD_802_11_MONITOR_MODE. 1099 */ 1100 if (lbs_init_mesh(priv)) { 1101 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) 1102 lbs_pr_err("cannot register lbs_rtap attribute\n"); 1103 } 1104 1105 lbs_debugfs_init_one(priv, dev); 1106 1107 lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); 1108 1109 ret = 0; 1110 1111done: 1112 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1113 return ret; 1114} 1115EXPORT_SYMBOL_GPL(lbs_start_card); 1116 1117 1118void lbs_stop_card(struct lbs_private *priv) 1119{ 1120 struct net_device *dev; 1121 struct cmd_ctrl_node *cmdnode; 1122 unsigned long flags; 1123 1124 lbs_deb_enter(LBS_DEB_MAIN); 1125 1126 if (!priv) 1127 goto out; 1128 dev = priv->dev; 1129 1130 netif_stop_queue(dev); 1131 netif_carrier_off(dev); 1132 1133 lbs_debugfs_remove_one(priv); 1134 if (lbs_deinit_mesh(priv)) 1135 device_remove_file(&dev->dev, &dev_attr_lbs_rtap); 1136 1137 /* Delete the timeout of the currently processing command */ 1138 del_timer_sync(&priv->command_timer); 1139 del_timer_sync(&priv->auto_deepsleep_timer); 1140 1141 /* Flush pending command nodes */ 1142 spin_lock_irqsave(&priv->driver_lock, flags); 1143 lbs_deb_main("clearing pending commands\n"); 1144 list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { 1145 cmdnode->result = -ENOENT; 1146 cmdnode->cmdwaitqwoken = 1; 1147 wake_up_interruptible(&cmdnode->cmdwait_q); 1148 } 1149 1150 /* Flush the command the card is currently processing */ 1151 if (priv->cur_cmd) { 1152 lbs_deb_main("clearing current command\n"); 1153 priv->cur_cmd->result = -ENOENT; 1154 priv->cur_cmd->cmdwaitqwoken = 1; 1155 wake_up_interruptible(&priv->cur_cmd->cmdwait_q); 1156 } 1157 lbs_deb_main("done clearing commands\n"); 1158 spin_unlock_irqrestore(&priv->driver_lock, flags); 1159 1160 unregister_netdev(dev); 1161 1162out: 1163 lbs_deb_leave(LBS_DEB_MAIN); 1164} 1165EXPORT_SYMBOL_GPL(lbs_stop_card); 1166 1167 1168void lbs_queue_event(struct lbs_private *priv, u32 event) 1169{ 1170 unsigned long flags; 1171 1172 lbs_deb_enter(LBS_DEB_THREAD); 1173 spin_lock_irqsave(&priv->driver_lock, flags); 1174 1175 if (priv->psstate == PS_STATE_SLEEP) 1176 priv->psstate = PS_STATE_AWAKE; 1177 1178 kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32)); 1179 1180 wake_up_interruptible(&priv->waitq); 1181 1182 spin_unlock_irqrestore(&priv->driver_lock, flags); 1183 lbs_deb_leave(LBS_DEB_THREAD); 1184} 1185EXPORT_SYMBOL_GPL(lbs_queue_event); 1186 1187void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx) 1188{ 1189 lbs_deb_enter(LBS_DEB_THREAD); 1190 1191 if (priv->psstate == PS_STATE_SLEEP) 1192 priv->psstate = PS_STATE_AWAKE; 1193 1194 /* Swap buffers by flipping the response index */ 1195 BUG_ON(resp_idx > 1); 1196 priv->resp_idx = resp_idx; 1197 1198 wake_up_interruptible(&priv->waitq); 1199 1200 lbs_deb_leave(LBS_DEB_THREAD); 1201} 1202EXPORT_SYMBOL_GPL(lbs_notify_command_response); 1203 1204static int __init lbs_init_module(void) 1205{ 1206 lbs_deb_enter(LBS_DEB_MAIN); 1207 memset(&confirm_sleep, 0, sizeof(confirm_sleep)); 1208 confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE); 1209 confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep)); 1210 confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); 1211 lbs_debugfs_init(); 1212 lbs_deb_leave(LBS_DEB_MAIN); 1213 return 0; 1214} 1215 1216static void __exit lbs_exit_module(void) 1217{ 1218 lbs_deb_enter(LBS_DEB_MAIN); 1219 lbs_debugfs_remove(); 1220 lbs_deb_leave(LBS_DEB_MAIN); 1221} 1222 1223/* 1224 * rtap interface support fuctions 1225 */ 1226 1227static int lbs_rtap_open(struct net_device *dev) 1228{ 1229 /* Yes, _stop_ the queue. Because we don't support injection */ 1230 lbs_deb_enter(LBS_DEB_MAIN); 1231 netif_carrier_off(dev); 1232 netif_stop_queue(dev); 1233 lbs_deb_leave(LBS_DEB_LEAVE); 1234 return 0; 1235} 1236 1237static int lbs_rtap_stop(struct net_device *dev) 1238{ 1239 lbs_deb_enter(LBS_DEB_MAIN); 1240 lbs_deb_leave(LBS_DEB_MAIN); 1241 return 0; 1242} 1243 1244static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb, 1245 struct net_device *dev) 1246{ 1247 netif_stop_queue(dev); 1248 return NETDEV_TX_BUSY; 1249} 1250 1251static void lbs_remove_rtap(struct lbs_private *priv) 1252{ 1253 lbs_deb_enter(LBS_DEB_MAIN); 1254 if (priv->rtap_net_dev == NULL) 1255 goto out; 1256 unregister_netdev(priv->rtap_net_dev); 1257 free_netdev(priv->rtap_net_dev); 1258 priv->rtap_net_dev = NULL; 1259out: 1260 lbs_deb_leave(LBS_DEB_MAIN); 1261} 1262 1263static const struct net_device_ops rtap_netdev_ops = { 1264 .ndo_open = lbs_rtap_open, 1265 .ndo_stop = lbs_rtap_stop, 1266 .ndo_start_xmit = lbs_rtap_hard_start_xmit, 1267}; 1268 1269static int lbs_add_rtap(struct lbs_private *priv) 1270{ 1271 int ret = 0; 1272 struct net_device *rtap_dev; 1273 1274 lbs_deb_enter(LBS_DEB_MAIN); 1275 if (priv->rtap_net_dev) { 1276 ret = -EPERM; 1277 goto out; 1278 } 1279 1280 rtap_dev = alloc_netdev(0, "rtap%d", ether_setup); 1281 if (rtap_dev == NULL) { 1282 ret = -ENOMEM; 1283 goto out; 1284 } 1285 1286 memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN); 1287 rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP; 1288 rtap_dev->netdev_ops = &rtap_netdev_ops; 1289 rtap_dev->ml_priv = priv; 1290 SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent); 1291 1292 ret = register_netdev(rtap_dev); 1293 if (ret) { 1294 free_netdev(rtap_dev); 1295 goto out; 1296 } 1297 priv->rtap_net_dev = rtap_dev; 1298 1299out: 1300 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1301 return ret; 1302} 1303 1304module_init(lbs_init_module); 1305module_exit(lbs_exit_module); 1306 1307MODULE_DESCRIPTION("Libertas WLAN Driver Library"); 1308MODULE_AUTHOR("Marvell International Ltd."); 1309MODULE_LICENSE("GPL"); 1310