main.c revision d6ede678c138061f5202b519f8f8d6372e2cb5bb
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 int lbs_init_adapter(struct lbs_private *priv) 810{ 811 size_t bufsize; 812 int i, ret = 0; 813 814 lbs_deb_enter(LBS_DEB_MAIN); 815 816 /* Allocate buffer to store the BSSID list */ 817 bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); 818 priv->networks = kzalloc(bufsize, GFP_KERNEL); 819 if (!priv->networks) { 820 lbs_pr_err("Out of memory allocating beacons\n"); 821 ret = -1; 822 goto out; 823 } 824 825 /* Initialize scan result lists */ 826 INIT_LIST_HEAD(&priv->network_free_list); 827 INIT_LIST_HEAD(&priv->network_list); 828 for (i = 0; i < MAX_NETWORK_COUNT; i++) { 829 list_add_tail(&priv->networks[i].list, 830 &priv->network_free_list); 831 } 832 833 memset(priv->current_addr, 0xff, ETH_ALEN); 834 835 priv->connect_status = LBS_DISCONNECTED; 836 priv->mesh_connect_status = LBS_DISCONNECTED; 837 priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; 838 priv->mode = IW_MODE_INFRA; 839 priv->channel = DEFAULT_AD_HOC_CHANNEL; 840 priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; 841 priv->radio_on = 1; 842 priv->enablehwauto = 1; 843 priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 844 priv->psmode = LBS802_11POWERMODECAM; 845 priv->psstate = PS_STATE_FULL_POWER; 846 priv->is_deep_sleep = 0; 847 priv->is_auto_deep_sleep_enabled = 0; 848 priv->wakeup_dev_required = 0; 849 init_waitqueue_head(&priv->ds_awake_q); 850 851 mutex_init(&priv->lock); 852 853 setup_timer(&priv->command_timer, command_timer_fn, 854 (unsigned long)priv); 855 setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, 856 (unsigned long)priv); 857 858 INIT_LIST_HEAD(&priv->cmdfreeq); 859 INIT_LIST_HEAD(&priv->cmdpendingq); 860 861 spin_lock_init(&priv->driver_lock); 862 init_waitqueue_head(&priv->cmd_pending); 863 864 /* Allocate the command buffers */ 865 if (lbs_allocate_cmd_buffer(priv)) { 866 lbs_pr_err("Out of memory allocating command buffers\n"); 867 ret = -ENOMEM; 868 goto out; 869 } 870 priv->resp_idx = 0; 871 priv->resp_len[0] = priv->resp_len[1] = 0; 872 873 /* Create the event FIFO */ 874 priv->event_fifo = kfifo_alloc(sizeof(u32) * 16, GFP_KERNEL, NULL); 875 if (IS_ERR(priv->event_fifo)) { 876 lbs_pr_err("Out of memory allocating event FIFO buffer\n"); 877 ret = -ENOMEM; 878 goto out; 879 } 880 881out: 882 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 883 884 return ret; 885} 886 887static void lbs_free_adapter(struct lbs_private *priv) 888{ 889 lbs_deb_enter(LBS_DEB_MAIN); 890 891 lbs_free_cmd_buffer(priv); 892 if (priv->event_fifo) 893 kfifo_free(priv->event_fifo); 894 del_timer(&priv->command_timer); 895 del_timer(&priv->auto_deepsleep_timer); 896 kfree(priv->networks); 897 priv->networks = NULL; 898 899 lbs_deb_leave(LBS_DEB_MAIN); 900} 901 902static const struct net_device_ops lbs_netdev_ops = { 903 .ndo_open = lbs_dev_open, 904 .ndo_stop = lbs_eth_stop, 905 .ndo_start_xmit = lbs_hard_start_xmit, 906 .ndo_set_mac_address = lbs_set_mac_address, 907 .ndo_tx_timeout = lbs_tx_timeout, 908 .ndo_set_multicast_list = lbs_set_multicast_list, 909 .ndo_change_mtu = eth_change_mtu, 910 .ndo_validate_addr = eth_validate_addr, 911}; 912 913/** 914 * @brief This function adds the card. it will probe the 915 * card, allocate the lbs_priv and initialize the device. 916 * 917 * @param card A pointer to card 918 * @return A pointer to struct lbs_private structure 919 */ 920struct lbs_private *lbs_add_card(void *card, struct device *dmdev) 921{ 922 struct net_device *dev; 923 struct wireless_dev *wdev; 924 struct lbs_private *priv = NULL; 925 926 lbs_deb_enter(LBS_DEB_MAIN); 927 928 /* Allocate an Ethernet device and register it */ 929 wdev = lbs_cfg_alloc(dmdev); 930 if (IS_ERR(wdev)) { 931 lbs_pr_err("cfg80211 init failed\n"); 932 goto done; 933 } 934 /* TODO? */ 935 wdev->iftype = NL80211_IFTYPE_STATION; 936 priv = wdev_priv(wdev); 937 priv->wdev = wdev; 938 939 if (lbs_init_adapter(priv)) { 940 lbs_pr_err("failed to initialize adapter structure.\n"); 941 goto err_wdev; 942 } 943 944 //TODO? dev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES); 945 dev = alloc_netdev(0, "wlan%d", ether_setup); 946 if (!dev) { 947 dev_err(dmdev, "no memory for network device instance\n"); 948 goto err_adapter; 949 } 950 951 dev->ieee80211_ptr = wdev; 952 dev->ml_priv = priv; 953 SET_NETDEV_DEV(dev, dmdev); 954 wdev->netdev = dev; 955 priv->dev = dev; 956 957 dev->netdev_ops = &lbs_netdev_ops; 958 dev->watchdog_timeo = 5 * HZ; 959 dev->ethtool_ops = &lbs_ethtool_ops; 960#ifdef WIRELESS_EXT 961 dev->wireless_handlers = &lbs_handler_def; 962#endif 963 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 964 965 966 // TODO: kzalloc + iwm_init_default_profile(iwm, iwm->umac_profile); ?? 967 968 969 priv->card = card; 970 priv->infra_open = 0; 971 972 973 priv->rtap_net_dev = NULL; 974 strcpy(dev->name, "wlan%d"); 975 976 lbs_deb_thread("Starting main thread...\n"); 977 init_waitqueue_head(&priv->waitq); 978 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); 979 if (IS_ERR(priv->main_thread)) { 980 lbs_deb_thread("Error creating main thread.\n"); 981 goto err_ndev; 982 } 983 984 priv->work_thread = create_singlethread_workqueue("lbs_worker"); 985 INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); 986 INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); 987 INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker); 988 989 priv->mesh_open = 0; 990 sprintf(priv->mesh_ssid, "mesh"); 991 priv->mesh_ssid_len = 4; 992 993 priv->wol_criteria = 0xffffffff; 994 priv->wol_gpio = 0xff; 995 996 goto done; 997 998 err_ndev: 999 free_netdev(dev); 1000 1001 err_adapter: 1002 lbs_free_adapter(priv); 1003 1004 err_wdev: 1005 lbs_cfg_free(priv); 1006 1007 priv = NULL; 1008 1009done: 1010 lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); 1011 return priv; 1012} 1013EXPORT_SYMBOL_GPL(lbs_add_card); 1014 1015 1016void lbs_remove_card(struct lbs_private *priv) 1017{ 1018 struct net_device *dev = priv->dev; 1019 1020 lbs_deb_enter(LBS_DEB_MAIN); 1021 1022 lbs_remove_mesh(priv); 1023 lbs_remove_rtap(priv); 1024 1025 dev = priv->dev; 1026 1027 cancel_delayed_work_sync(&priv->scan_work); 1028 cancel_delayed_work_sync(&priv->assoc_work); 1029 cancel_work_sync(&priv->mcast_work); 1030 1031 /* worker thread destruction blocks on the in-flight command which 1032 * should have been cleared already in lbs_stop_card(). 1033 */ 1034 lbs_deb_main("destroying worker thread\n"); 1035 destroy_workqueue(priv->work_thread); 1036 lbs_deb_main("done destroying worker thread\n"); 1037 1038 if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { 1039 priv->psmode = LBS802_11POWERMODECAM; 1040 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); 1041 } 1042 1043 lbs_send_disconnect_notification(priv); 1044 1045 if (priv->is_deep_sleep) { 1046 priv->is_deep_sleep = 0; 1047 wake_up_interruptible(&priv->ds_awake_q); 1048 } 1049 1050 /* Stop the thread servicing the interrupts */ 1051 priv->surpriseremoved = 1; 1052 kthread_stop(priv->main_thread); 1053 1054 lbs_free_adapter(priv); 1055 lbs_cfg_free(priv); 1056 1057 priv->dev = NULL; 1058 free_netdev(dev); 1059 1060 lbs_deb_leave(LBS_DEB_MAIN); 1061} 1062EXPORT_SYMBOL_GPL(lbs_remove_card); 1063 1064 1065int lbs_start_card(struct lbs_private *priv) 1066{ 1067 struct net_device *dev = priv->dev; 1068 int ret = -1; 1069 1070 lbs_deb_enter(LBS_DEB_MAIN); 1071 1072 /* poke the firmware */ 1073 ret = lbs_setup_firmware(priv); 1074 if (ret) 1075 goto done; 1076 1077 if (lbs_cfg_register(priv)) { 1078 lbs_pr_err("cannot register device\n"); 1079 goto done; 1080 } 1081 1082 lbs_update_channel(priv); 1083 1084 /* 1085 * While rtap isn't related to mesh, only mesh-enabled 1086 * firmware implements the rtap functionality via 1087 * CMD_802_11_MONITOR_MODE. 1088 */ 1089 if (lbs_init_mesh(priv)) { 1090 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) 1091 lbs_pr_err("cannot register lbs_rtap attribute\n"); 1092 } 1093 1094 lbs_debugfs_init_one(priv, dev); 1095 1096 lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); 1097 1098 ret = 0; 1099 1100done: 1101 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1102 return ret; 1103} 1104EXPORT_SYMBOL_GPL(lbs_start_card); 1105 1106 1107void lbs_stop_card(struct lbs_private *priv) 1108{ 1109 struct net_device *dev; 1110 struct cmd_ctrl_node *cmdnode; 1111 unsigned long flags; 1112 1113 lbs_deb_enter(LBS_DEB_MAIN); 1114 1115 if (!priv) 1116 goto out; 1117 dev = priv->dev; 1118 1119 netif_stop_queue(dev); 1120 netif_carrier_off(dev); 1121 1122 lbs_debugfs_remove_one(priv); 1123 if (lbs_deinit_mesh(priv)) 1124 device_remove_file(&dev->dev, &dev_attr_lbs_rtap); 1125 1126 /* Delete the timeout of the currently processing command */ 1127 del_timer_sync(&priv->command_timer); 1128 del_timer_sync(&priv->auto_deepsleep_timer); 1129 1130 /* Flush pending command nodes */ 1131 spin_lock_irqsave(&priv->driver_lock, flags); 1132 lbs_deb_main("clearing pending commands\n"); 1133 list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { 1134 cmdnode->result = -ENOENT; 1135 cmdnode->cmdwaitqwoken = 1; 1136 wake_up_interruptible(&cmdnode->cmdwait_q); 1137 } 1138 1139 /* Flush the command the card is currently processing */ 1140 if (priv->cur_cmd) { 1141 lbs_deb_main("clearing current command\n"); 1142 priv->cur_cmd->result = -ENOENT; 1143 priv->cur_cmd->cmdwaitqwoken = 1; 1144 wake_up_interruptible(&priv->cur_cmd->cmdwait_q); 1145 } 1146 lbs_deb_main("done clearing commands\n"); 1147 spin_unlock_irqrestore(&priv->driver_lock, flags); 1148 1149 unregister_netdev(dev); 1150 1151out: 1152 lbs_deb_leave(LBS_DEB_MAIN); 1153} 1154EXPORT_SYMBOL_GPL(lbs_stop_card); 1155 1156 1157void lbs_queue_event(struct lbs_private *priv, u32 event) 1158{ 1159 unsigned long flags; 1160 1161 lbs_deb_enter(LBS_DEB_THREAD); 1162 spin_lock_irqsave(&priv->driver_lock, flags); 1163 1164 if (priv->psstate == PS_STATE_SLEEP) 1165 priv->psstate = PS_STATE_AWAKE; 1166 1167 __kfifo_put(priv->event_fifo, (unsigned char *) &event, sizeof(u32)); 1168 1169 wake_up_interruptible(&priv->waitq); 1170 1171 spin_unlock_irqrestore(&priv->driver_lock, flags); 1172 lbs_deb_leave(LBS_DEB_THREAD); 1173} 1174EXPORT_SYMBOL_GPL(lbs_queue_event); 1175 1176void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx) 1177{ 1178 lbs_deb_enter(LBS_DEB_THREAD); 1179 1180 if (priv->psstate == PS_STATE_SLEEP) 1181 priv->psstate = PS_STATE_AWAKE; 1182 1183 /* Swap buffers by flipping the response index */ 1184 BUG_ON(resp_idx > 1); 1185 priv->resp_idx = resp_idx; 1186 1187 wake_up_interruptible(&priv->waitq); 1188 1189 lbs_deb_leave(LBS_DEB_THREAD); 1190} 1191EXPORT_SYMBOL_GPL(lbs_notify_command_response); 1192 1193static int __init lbs_init_module(void) 1194{ 1195 lbs_deb_enter(LBS_DEB_MAIN); 1196 memset(&confirm_sleep, 0, sizeof(confirm_sleep)); 1197 confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE); 1198 confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep)); 1199 confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); 1200 lbs_debugfs_init(); 1201 lbs_deb_leave(LBS_DEB_MAIN); 1202 return 0; 1203} 1204 1205static void __exit lbs_exit_module(void) 1206{ 1207 lbs_deb_enter(LBS_DEB_MAIN); 1208 lbs_debugfs_remove(); 1209 lbs_deb_leave(LBS_DEB_MAIN); 1210} 1211 1212/* 1213 * rtap interface support fuctions 1214 */ 1215 1216static int lbs_rtap_open(struct net_device *dev) 1217{ 1218 /* Yes, _stop_ the queue. Because we don't support injection */ 1219 lbs_deb_enter(LBS_DEB_MAIN); 1220 netif_carrier_off(dev); 1221 netif_stop_queue(dev); 1222 lbs_deb_leave(LBS_DEB_LEAVE); 1223 return 0; 1224} 1225 1226static int lbs_rtap_stop(struct net_device *dev) 1227{ 1228 lbs_deb_enter(LBS_DEB_MAIN); 1229 lbs_deb_leave(LBS_DEB_MAIN); 1230 return 0; 1231} 1232 1233static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb, 1234 struct net_device *dev) 1235{ 1236 netif_stop_queue(dev); 1237 return NETDEV_TX_BUSY; 1238} 1239 1240static void lbs_remove_rtap(struct lbs_private *priv) 1241{ 1242 lbs_deb_enter(LBS_DEB_MAIN); 1243 if (priv->rtap_net_dev == NULL) 1244 goto out; 1245 unregister_netdev(priv->rtap_net_dev); 1246 free_netdev(priv->rtap_net_dev); 1247 priv->rtap_net_dev = NULL; 1248out: 1249 lbs_deb_leave(LBS_DEB_MAIN); 1250} 1251 1252static const struct net_device_ops rtap_netdev_ops = { 1253 .ndo_open = lbs_rtap_open, 1254 .ndo_stop = lbs_rtap_stop, 1255 .ndo_start_xmit = lbs_rtap_hard_start_xmit, 1256}; 1257 1258static int lbs_add_rtap(struct lbs_private *priv) 1259{ 1260 int ret = 0; 1261 struct net_device *rtap_dev; 1262 1263 lbs_deb_enter(LBS_DEB_MAIN); 1264 if (priv->rtap_net_dev) { 1265 ret = -EPERM; 1266 goto out; 1267 } 1268 1269 rtap_dev = alloc_netdev(0, "rtap%d", ether_setup); 1270 if (rtap_dev == NULL) { 1271 ret = -ENOMEM; 1272 goto out; 1273 } 1274 1275 memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN); 1276 rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP; 1277 rtap_dev->netdev_ops = &rtap_netdev_ops; 1278 rtap_dev->ml_priv = priv; 1279 SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent); 1280 1281 ret = register_netdev(rtap_dev); 1282 if (ret) { 1283 free_netdev(rtap_dev); 1284 goto out; 1285 } 1286 priv->rtap_net_dev = rtap_dev; 1287 1288out: 1289 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1290 return ret; 1291} 1292 1293module_init(lbs_init_module); 1294module_exit(lbs_exit_module); 1295 1296MODULE_DESCRIPTION("Libertas WLAN Driver Library"); 1297MODULE_AUTHOR("Marvell International Ltd."); 1298MODULE_LICENSE("GPL"); 1299