main.c revision 7acd72eb85f1c7a15e8b5eb554994949241737f1
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 517 kfifo_out(&priv->event_fifo, (unsigned char *) &event, 518 sizeof(event)); 519 spin_unlock_irq(&priv->driver_lock); 520 lbs_process_event(priv, event); 521 spin_lock_irq(&priv->driver_lock); 522 } 523 spin_unlock_irq(&priv->driver_lock); 524 525 if (priv->wakeup_dev_required) { 526 lbs_deb_thread("Waking up device...\n"); 527 /* Wake up device */ 528 if (priv->exit_deep_sleep(priv)) 529 lbs_deb_thread("Wakeup device failed\n"); 530 continue; 531 } 532 533 /* command timeout stuff */ 534 if (priv->cmd_timed_out && priv->cur_cmd) { 535 struct cmd_ctrl_node *cmdnode = priv->cur_cmd; 536 537 if (++priv->nr_retries > 3) { 538 lbs_pr_info("Excessive timeouts submitting " 539 "command 0x%04x\n", 540 le16_to_cpu(cmdnode->cmdbuf->command)); 541 lbs_complete_command(priv, cmdnode, -ETIMEDOUT); 542 priv->nr_retries = 0; 543 if (priv->reset_card) 544 priv->reset_card(priv); 545 } else { 546 priv->cur_cmd = NULL; 547 priv->dnld_sent = DNLD_RES_RECEIVED; 548 lbs_pr_info("requeueing command 0x%04x due " 549 "to timeout (#%d)\n", 550 le16_to_cpu(cmdnode->cmdbuf->command), 551 priv->nr_retries); 552 553 /* Stick it back at the _top_ of the pending queue 554 for immediate resubmission */ 555 list_add(&cmdnode->list, &priv->cmdpendingq); 556 } 557 } 558 priv->cmd_timed_out = 0; 559 560 561 562 if (!priv->fw_ready) 563 continue; 564 565 /* Check if we need to confirm Sleep Request received previously */ 566 if (priv->psstate == PS_STATE_PRE_SLEEP && 567 !priv->dnld_sent && !priv->cur_cmd) { 568 if (priv->connect_status == LBS_CONNECTED) { 569 lbs_deb_thread("pre-sleep, currenttxskb %p, " 570 "dnld_sent %d, cur_cmd %p\n", 571 priv->currenttxskb, priv->dnld_sent, 572 priv->cur_cmd); 573 574 lbs_ps_confirm_sleep(priv); 575 } else { 576 /* workaround for firmware sending 577 * deauth/linkloss event immediately 578 * after sleep request; remove this 579 * after firmware fixes it 580 */ 581 priv->psstate = PS_STATE_AWAKE; 582 lbs_pr_alert("ignore PS_SleepConfirm in " 583 "non-connected state\n"); 584 } 585 } 586 587 /* The PS state is changed during processing of Sleep Request 588 * event above 589 */ 590 if ((priv->psstate == PS_STATE_SLEEP) || 591 (priv->psstate == PS_STATE_PRE_SLEEP)) 592 continue; 593 594 if (priv->is_deep_sleep) 595 continue; 596 597 /* Execute the next command */ 598 if (!priv->dnld_sent && !priv->cur_cmd) 599 lbs_execute_next_command(priv); 600 601 /* Wake-up command waiters which can't sleep in 602 * lbs_prepare_and_send_command 603 */ 604 if (!list_empty(&priv->cmdpendingq)) 605 wake_up_all(&priv->cmd_pending); 606 607 spin_lock_irq(&priv->driver_lock); 608 if (!priv->dnld_sent && priv->tx_pending_len > 0) { 609 int ret = priv->hw_host_to_card(priv, MVMS_DAT, 610 priv->tx_pending_buf, 611 priv->tx_pending_len); 612 if (ret) { 613 lbs_deb_tx("host_to_card failed %d\n", ret); 614 priv->dnld_sent = DNLD_RES_RECEIVED; 615 } 616 priv->tx_pending_len = 0; 617 if (!priv->currenttxskb) { 618 /* We can wake the queues immediately if we aren't 619 waiting for TX feedback */ 620 if (priv->connect_status == LBS_CONNECTED) 621 netif_wake_queue(priv->dev); 622 if (priv->mesh_dev && 623 priv->mesh_connect_status == LBS_CONNECTED) 624 netif_wake_queue(priv->mesh_dev); 625 } 626 } 627 spin_unlock_irq(&priv->driver_lock); 628 } 629 630 del_timer(&priv->command_timer); 631 del_timer(&priv->auto_deepsleep_timer); 632 wake_up_all(&priv->cmd_pending); 633 634 lbs_deb_leave(LBS_DEB_THREAD); 635 return 0; 636} 637 638static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy, 639 struct cmd_header *cmd) 640{ 641 lbs_deb_enter(LBS_DEB_FW); 642 643 netif_device_detach(priv->dev); 644 if (priv->mesh_dev) 645 netif_device_detach(priv->mesh_dev); 646 647 priv->fw_ready = 0; 648 lbs_deb_leave(LBS_DEB_FW); 649 return 0; 650} 651 652int lbs_suspend(struct lbs_private *priv) 653{ 654 struct cmd_header cmd; 655 int ret; 656 657 lbs_deb_enter(LBS_DEB_FW); 658 659 if (priv->wol_criteria == 0xffffffff) { 660 lbs_pr_info("Suspend attempt without configuring wake params!\n"); 661 return -EINVAL; 662 } 663 664 memset(&cmd, 0, sizeof(cmd)); 665 666 ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd, 667 sizeof(cmd), lbs_suspend_callback, 0); 668 if (ret) 669 lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret); 670 671 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 672 return ret; 673} 674EXPORT_SYMBOL_GPL(lbs_suspend); 675 676void lbs_resume(struct lbs_private *priv) 677{ 678 lbs_deb_enter(LBS_DEB_FW); 679 680 priv->fw_ready = 1; 681 682 /* Firmware doesn't seem to give us RX packets any more 683 until we send it some command. Might as well update */ 684 lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, 685 0, 0, NULL); 686 687 netif_device_attach(priv->dev); 688 if (priv->mesh_dev) 689 netif_device_attach(priv->mesh_dev); 690 691 lbs_deb_leave(LBS_DEB_FW); 692} 693EXPORT_SYMBOL_GPL(lbs_resume); 694 695/** 696 * @brief This function gets the HW spec from the firmware and sets 697 * some basic parameters. 698 * 699 * @param priv A pointer to struct lbs_private structure 700 * @return 0 or -1 701 */ 702static int lbs_setup_firmware(struct lbs_private *priv) 703{ 704 int ret = -1; 705 s16 curlevel = 0, minlevel = 0, maxlevel = 0; 706 707 lbs_deb_enter(LBS_DEB_FW); 708 709 /* Read MAC address from firmware */ 710 memset(priv->current_addr, 0xff, ETH_ALEN); 711 ret = lbs_update_hw_spec(priv); 712 if (ret) 713 goto done; 714 715 /* Read power levels if available */ 716 ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel); 717 if (ret == 0) { 718 priv->txpower_cur = curlevel; 719 priv->txpower_min = minlevel; 720 priv->txpower_max = maxlevel; 721 } 722 723 lbs_set_mac_control(priv); 724done: 725 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 726 return ret; 727} 728 729/** 730 * This function handles the timeout of command sending. 731 * It will re-send the same command again. 732 */ 733static void command_timer_fn(unsigned long data) 734{ 735 struct lbs_private *priv = (struct lbs_private *)data; 736 unsigned long flags; 737 738 lbs_deb_enter(LBS_DEB_CMD); 739 spin_lock_irqsave(&priv->driver_lock, flags); 740 741 if (!priv->cur_cmd) 742 goto out; 743 744 lbs_pr_info("command 0x%04x timed out\n", 745 le16_to_cpu(priv->cur_cmd->cmdbuf->command)); 746 747 priv->cmd_timed_out = 1; 748 wake_up_interruptible(&priv->waitq); 749out: 750 spin_unlock_irqrestore(&priv->driver_lock, flags); 751 lbs_deb_leave(LBS_DEB_CMD); 752} 753 754/** 755 * This function put the device back to deep sleep mode when timer expires 756 * and no activity (command, event, data etc.) is detected. 757 */ 758static void auto_deepsleep_timer_fn(unsigned long data) 759{ 760 struct lbs_private *priv = (struct lbs_private *)data; 761 int ret; 762 763 lbs_deb_enter(LBS_DEB_CMD); 764 765 if (priv->is_activity_detected) { 766 priv->is_activity_detected = 0; 767 } else { 768 if (priv->is_auto_deep_sleep_enabled && 769 (!priv->wakeup_dev_required) && 770 (priv->connect_status != LBS_CONNECTED)) { 771 lbs_deb_main("Entering auto deep sleep mode...\n"); 772 ret = lbs_prepare_and_send_command(priv, 773 CMD_802_11_DEEP_SLEEP, 0, 774 0, 0, NULL); 775 if (ret) 776 lbs_pr_err("Enter Deep Sleep command failed\n"); 777 } 778 } 779 mod_timer(&priv->auto_deepsleep_timer , jiffies + 780 (priv->auto_deep_sleep_timeout * HZ)/1000); 781 lbs_deb_leave(LBS_DEB_CMD); 782} 783 784int lbs_enter_auto_deep_sleep(struct lbs_private *priv) 785{ 786 lbs_deb_enter(LBS_DEB_SDIO); 787 788 priv->is_auto_deep_sleep_enabled = 1; 789 if (priv->is_deep_sleep) 790 priv->wakeup_dev_required = 1; 791 mod_timer(&priv->auto_deepsleep_timer , 792 jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000); 793 794 lbs_deb_leave(LBS_DEB_SDIO); 795 return 0; 796} 797 798int lbs_exit_auto_deep_sleep(struct lbs_private *priv) 799{ 800 lbs_deb_enter(LBS_DEB_SDIO); 801 802 priv->is_auto_deep_sleep_enabled = 0; 803 priv->auto_deep_sleep_timeout = 0; 804 del_timer(&priv->auto_deepsleep_timer); 805 806 lbs_deb_leave(LBS_DEB_SDIO); 807 return 0; 808} 809 810static void lbs_sync_channel_worker(struct work_struct *work) 811{ 812 struct lbs_private *priv = container_of(work, struct lbs_private, 813 sync_channel); 814 815 lbs_deb_enter(LBS_DEB_MAIN); 816 if (lbs_update_channel(priv)) 817 lbs_pr_info("Channel synchronization failed."); 818 lbs_deb_leave(LBS_DEB_MAIN); 819} 820 821 822static int lbs_init_adapter(struct lbs_private *priv) 823{ 824 size_t bufsize; 825 int i, ret = 0; 826 827 lbs_deb_enter(LBS_DEB_MAIN); 828 829 /* Allocate buffer to store the BSSID list */ 830 bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); 831 priv->networks = kzalloc(bufsize, GFP_KERNEL); 832 if (!priv->networks) { 833 lbs_pr_err("Out of memory allocating beacons\n"); 834 ret = -1; 835 goto out; 836 } 837 838 /* Initialize scan result lists */ 839 INIT_LIST_HEAD(&priv->network_free_list); 840 INIT_LIST_HEAD(&priv->network_list); 841 for (i = 0; i < MAX_NETWORK_COUNT; i++) { 842 list_add_tail(&priv->networks[i].list, 843 &priv->network_free_list); 844 } 845 846 memset(priv->current_addr, 0xff, ETH_ALEN); 847 848 priv->connect_status = LBS_DISCONNECTED; 849 priv->mesh_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->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 857 priv->psmode = LBS802_11POWERMODECAM; 858 priv->psstate = PS_STATE_FULL_POWER; 859 priv->is_deep_sleep = 0; 860 priv->is_auto_deep_sleep_enabled = 0; 861 priv->wakeup_dev_required = 0; 862 init_waitqueue_head(&priv->ds_awake_q); 863 864 mutex_init(&priv->lock); 865 866 setup_timer(&priv->command_timer, command_timer_fn, 867 (unsigned long)priv); 868 setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, 869 (unsigned long)priv); 870 871 INIT_LIST_HEAD(&priv->cmdfreeq); 872 INIT_LIST_HEAD(&priv->cmdpendingq); 873 874 spin_lock_init(&priv->driver_lock); 875 init_waitqueue_head(&priv->cmd_pending); 876 877 /* Allocate the command buffers */ 878 if (lbs_allocate_cmd_buffer(priv)) { 879 lbs_pr_err("Out of memory allocating command buffers\n"); 880 ret = -ENOMEM; 881 goto out; 882 } 883 priv->resp_idx = 0; 884 priv->resp_len[0] = priv->resp_len[1] = 0; 885 886 /* Create the event FIFO */ 887 ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL); 888 if (ret) { 889 lbs_pr_err("Out of memory allocating event FIFO buffer\n"); 890 goto out; 891 } 892 893out: 894 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 895 896 return ret; 897} 898 899static void lbs_free_adapter(struct lbs_private *priv) 900{ 901 lbs_deb_enter(LBS_DEB_MAIN); 902 903 lbs_free_cmd_buffer(priv); 904 kfifo_free(&priv->event_fifo); 905 del_timer(&priv->command_timer); 906 del_timer(&priv->auto_deepsleep_timer); 907 kfree(priv->networks); 908 priv->networks = NULL; 909 910 lbs_deb_leave(LBS_DEB_MAIN); 911} 912 913static const struct net_device_ops lbs_netdev_ops = { 914 .ndo_open = lbs_dev_open, 915 .ndo_stop = lbs_eth_stop, 916 .ndo_start_xmit = lbs_hard_start_xmit, 917 .ndo_set_mac_address = lbs_set_mac_address, 918 .ndo_tx_timeout = lbs_tx_timeout, 919 .ndo_set_multicast_list = lbs_set_multicast_list, 920 .ndo_change_mtu = eth_change_mtu, 921 .ndo_validate_addr = eth_validate_addr, 922}; 923 924/** 925 * @brief This function adds the card. it will probe the 926 * card, allocate the lbs_priv and initialize the device. 927 * 928 * @param card A pointer to card 929 * @return A pointer to struct lbs_private structure 930 */ 931struct lbs_private *lbs_add_card(void *card, struct device *dmdev) 932{ 933 struct net_device *dev; 934 struct wireless_dev *wdev; 935 struct lbs_private *priv = NULL; 936 937 lbs_deb_enter(LBS_DEB_MAIN); 938 939 /* Allocate an Ethernet device and register it */ 940 wdev = lbs_cfg_alloc(dmdev); 941 if (IS_ERR(wdev)) { 942 lbs_pr_err("cfg80211 init failed\n"); 943 goto done; 944 } 945 /* TODO? */ 946 wdev->iftype = NL80211_IFTYPE_STATION; 947 priv = wdev_priv(wdev); 948 priv->wdev = wdev; 949 950 if (lbs_init_adapter(priv)) { 951 lbs_pr_err("failed to initialize adapter structure.\n"); 952 goto err_wdev; 953 } 954 955 //TODO? dev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES); 956 dev = alloc_netdev(0, "wlan%d", ether_setup); 957 if (!dev) { 958 dev_err(dmdev, "no memory for network device instance\n"); 959 goto err_adapter; 960 } 961 962 dev->ieee80211_ptr = wdev; 963 dev->ml_priv = priv; 964 SET_NETDEV_DEV(dev, dmdev); 965 wdev->netdev = dev; 966 priv->dev = dev; 967 968 dev->netdev_ops = &lbs_netdev_ops; 969 dev->watchdog_timeo = 5 * HZ; 970 dev->ethtool_ops = &lbs_ethtool_ops; 971#ifdef WIRELESS_EXT 972 dev->wireless_handlers = &lbs_handler_def; 973#endif 974 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 975 976 977 // TODO: kzalloc + iwm_init_default_profile(iwm, iwm->umac_profile); ?? 978 979 980 priv->card = card; 981 priv->infra_open = 0; 982 983 984 priv->rtap_net_dev = NULL; 985 strcpy(dev->name, "wlan%d"); 986 987 lbs_deb_thread("Starting main thread...\n"); 988 init_waitqueue_head(&priv->waitq); 989 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); 990 if (IS_ERR(priv->main_thread)) { 991 lbs_deb_thread("Error creating main thread.\n"); 992 goto err_ndev; 993 } 994 995 priv->work_thread = create_singlethread_workqueue("lbs_worker"); 996 INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); 997 INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); 998 INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker); 999 INIT_WORK(&priv->sync_channel, lbs_sync_channel_worker); 1000 1001 priv->mesh_open = 0; 1002 sprintf(priv->mesh_ssid, "mesh"); 1003 priv->mesh_ssid_len = 4; 1004 1005 priv->wol_criteria = 0xffffffff; 1006 priv->wol_gpio = 0xff; 1007 1008 goto done; 1009 1010 err_ndev: 1011 free_netdev(dev); 1012 1013 err_adapter: 1014 lbs_free_adapter(priv); 1015 1016 err_wdev: 1017 lbs_cfg_free(priv); 1018 1019 priv = NULL; 1020 1021done: 1022 lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); 1023 return priv; 1024} 1025EXPORT_SYMBOL_GPL(lbs_add_card); 1026 1027 1028void lbs_remove_card(struct lbs_private *priv) 1029{ 1030 struct net_device *dev = priv->dev; 1031 1032 lbs_deb_enter(LBS_DEB_MAIN); 1033 1034 lbs_remove_mesh(priv); 1035 lbs_remove_rtap(priv); 1036 1037 dev = priv->dev; 1038 1039 cancel_delayed_work_sync(&priv->scan_work); 1040 cancel_delayed_work_sync(&priv->assoc_work); 1041 cancel_work_sync(&priv->mcast_work); 1042 1043 /* worker thread destruction blocks on the in-flight command which 1044 * should have been cleared already in lbs_stop_card(). 1045 */ 1046 lbs_deb_main("destroying worker thread\n"); 1047 destroy_workqueue(priv->work_thread); 1048 lbs_deb_main("done destroying worker thread\n"); 1049 1050 if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { 1051 priv->psmode = LBS802_11POWERMODECAM; 1052 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); 1053 } 1054 1055 lbs_send_disconnect_notification(priv); 1056 1057 if (priv->is_deep_sleep) { 1058 priv->is_deep_sleep = 0; 1059 wake_up_interruptible(&priv->ds_awake_q); 1060 } 1061 1062 /* Stop the thread servicing the interrupts */ 1063 priv->surpriseremoved = 1; 1064 kthread_stop(priv->main_thread); 1065 1066 lbs_free_adapter(priv); 1067 lbs_cfg_free(priv); 1068 1069 priv->dev = NULL; 1070 free_netdev(dev); 1071 1072 lbs_deb_leave(LBS_DEB_MAIN); 1073} 1074EXPORT_SYMBOL_GPL(lbs_remove_card); 1075 1076 1077int lbs_start_card(struct lbs_private *priv) 1078{ 1079 struct net_device *dev = priv->dev; 1080 int ret = -1; 1081 1082 lbs_deb_enter(LBS_DEB_MAIN); 1083 1084 /* poke the firmware */ 1085 ret = lbs_setup_firmware(priv); 1086 if (ret) 1087 goto done; 1088 1089 if (lbs_cfg_register(priv)) { 1090 lbs_pr_err("cannot register device\n"); 1091 goto done; 1092 } 1093 1094 lbs_update_channel(priv); 1095 1096 /* 1097 * While rtap isn't related to mesh, only mesh-enabled 1098 * firmware implements the rtap functionality via 1099 * CMD_802_11_MONITOR_MODE. 1100 */ 1101 if (lbs_init_mesh(priv)) { 1102 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) 1103 lbs_pr_err("cannot register lbs_rtap attribute\n"); 1104 } 1105 1106 lbs_debugfs_init_one(priv, dev); 1107 1108 lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); 1109 1110 ret = 0; 1111 1112done: 1113 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1114 return ret; 1115} 1116EXPORT_SYMBOL_GPL(lbs_start_card); 1117 1118 1119void lbs_stop_card(struct lbs_private *priv) 1120{ 1121 struct net_device *dev; 1122 struct cmd_ctrl_node *cmdnode; 1123 unsigned long flags; 1124 1125 lbs_deb_enter(LBS_DEB_MAIN); 1126 1127 if (!priv) 1128 goto out; 1129 dev = priv->dev; 1130 1131 netif_stop_queue(dev); 1132 netif_carrier_off(dev); 1133 1134 lbs_debugfs_remove_one(priv); 1135 if (lbs_deinit_mesh(priv)) 1136 device_remove_file(&dev->dev, &dev_attr_lbs_rtap); 1137 1138 /* Delete the timeout of the currently processing command */ 1139 del_timer_sync(&priv->command_timer); 1140 del_timer_sync(&priv->auto_deepsleep_timer); 1141 1142 /* Flush pending command nodes */ 1143 spin_lock_irqsave(&priv->driver_lock, flags); 1144 lbs_deb_main("clearing pending commands\n"); 1145 list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { 1146 cmdnode->result = -ENOENT; 1147 cmdnode->cmdwaitqwoken = 1; 1148 wake_up_interruptible(&cmdnode->cmdwait_q); 1149 } 1150 1151 /* Flush the command the card is currently processing */ 1152 if (priv->cur_cmd) { 1153 lbs_deb_main("clearing current command\n"); 1154 priv->cur_cmd->result = -ENOENT; 1155 priv->cur_cmd->cmdwaitqwoken = 1; 1156 wake_up_interruptible(&priv->cur_cmd->cmdwait_q); 1157 } 1158 lbs_deb_main("done clearing commands\n"); 1159 spin_unlock_irqrestore(&priv->driver_lock, flags); 1160 1161 unregister_netdev(dev); 1162 1163out: 1164 lbs_deb_leave(LBS_DEB_MAIN); 1165} 1166EXPORT_SYMBOL_GPL(lbs_stop_card); 1167 1168 1169void lbs_queue_event(struct lbs_private *priv, u32 event) 1170{ 1171 unsigned long flags; 1172 1173 lbs_deb_enter(LBS_DEB_THREAD); 1174 spin_lock_irqsave(&priv->driver_lock, flags); 1175 1176 if (priv->psstate == PS_STATE_SLEEP) 1177 priv->psstate = PS_STATE_AWAKE; 1178 1179 kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32)); 1180 1181 wake_up_interruptible(&priv->waitq); 1182 1183 spin_unlock_irqrestore(&priv->driver_lock, flags); 1184 lbs_deb_leave(LBS_DEB_THREAD); 1185} 1186EXPORT_SYMBOL_GPL(lbs_queue_event); 1187 1188void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx) 1189{ 1190 lbs_deb_enter(LBS_DEB_THREAD); 1191 1192 if (priv->psstate == PS_STATE_SLEEP) 1193 priv->psstate = PS_STATE_AWAKE; 1194 1195 /* Swap buffers by flipping the response index */ 1196 BUG_ON(resp_idx > 1); 1197 priv->resp_idx = resp_idx; 1198 1199 wake_up_interruptible(&priv->waitq); 1200 1201 lbs_deb_leave(LBS_DEB_THREAD); 1202} 1203EXPORT_SYMBOL_GPL(lbs_notify_command_response); 1204 1205static int __init lbs_init_module(void) 1206{ 1207 lbs_deb_enter(LBS_DEB_MAIN); 1208 memset(&confirm_sleep, 0, sizeof(confirm_sleep)); 1209 confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE); 1210 confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep)); 1211 confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); 1212 lbs_debugfs_init(); 1213 lbs_deb_leave(LBS_DEB_MAIN); 1214 return 0; 1215} 1216 1217static void __exit lbs_exit_module(void) 1218{ 1219 lbs_deb_enter(LBS_DEB_MAIN); 1220 lbs_debugfs_remove(); 1221 lbs_deb_leave(LBS_DEB_MAIN); 1222} 1223 1224/* 1225 * rtap interface support fuctions 1226 */ 1227 1228static int lbs_rtap_open(struct net_device *dev) 1229{ 1230 /* Yes, _stop_ the queue. Because we don't support injection */ 1231 lbs_deb_enter(LBS_DEB_MAIN); 1232 netif_carrier_off(dev); 1233 netif_stop_queue(dev); 1234 lbs_deb_leave(LBS_DEB_LEAVE); 1235 return 0; 1236} 1237 1238static int lbs_rtap_stop(struct net_device *dev) 1239{ 1240 lbs_deb_enter(LBS_DEB_MAIN); 1241 lbs_deb_leave(LBS_DEB_MAIN); 1242 return 0; 1243} 1244 1245static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb, 1246 struct net_device *dev) 1247{ 1248 netif_stop_queue(dev); 1249 return NETDEV_TX_BUSY; 1250} 1251 1252static void lbs_remove_rtap(struct lbs_private *priv) 1253{ 1254 lbs_deb_enter(LBS_DEB_MAIN); 1255 if (priv->rtap_net_dev == NULL) 1256 goto out; 1257 unregister_netdev(priv->rtap_net_dev); 1258 free_netdev(priv->rtap_net_dev); 1259 priv->rtap_net_dev = NULL; 1260out: 1261 lbs_deb_leave(LBS_DEB_MAIN); 1262} 1263 1264static const struct net_device_ops rtap_netdev_ops = { 1265 .ndo_open = lbs_rtap_open, 1266 .ndo_stop = lbs_rtap_stop, 1267 .ndo_start_xmit = lbs_rtap_hard_start_xmit, 1268}; 1269 1270static int lbs_add_rtap(struct lbs_private *priv) 1271{ 1272 int ret = 0; 1273 struct net_device *rtap_dev; 1274 1275 lbs_deb_enter(LBS_DEB_MAIN); 1276 if (priv->rtap_net_dev) { 1277 ret = -EPERM; 1278 goto out; 1279 } 1280 1281 rtap_dev = alloc_netdev(0, "rtap%d", ether_setup); 1282 if (rtap_dev == NULL) { 1283 ret = -ENOMEM; 1284 goto out; 1285 } 1286 1287 memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN); 1288 rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP; 1289 rtap_dev->netdev_ops = &rtap_netdev_ops; 1290 rtap_dev->ml_priv = priv; 1291 SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent); 1292 1293 ret = register_netdev(rtap_dev); 1294 if (ret) { 1295 free_netdev(rtap_dev); 1296 goto out; 1297 } 1298 priv->rtap_net_dev = rtap_dev; 1299 1300out: 1301 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1302 return ret; 1303} 1304 1305module_init(lbs_init_module); 1306module_exit(lbs_exit_module); 1307 1308MODULE_DESCRIPTION("Libertas WLAN Driver Library"); 1309MODULE_AUTHOR("Marvell International Ltd."); 1310MODULE_LICENSE("GPL"); 1311