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