main.c revision 4f2fdaaf0e4209bff3b18dc14c915b61f5fa5cd2
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/freezer.h> 10#include <linux/etherdevice.h> 11#include <linux/netdevice.h> 12#include <linux/if_arp.h> 13#include <linux/kthread.h> 14 15#include <net/iw_handler.h> 16#include <net/ieee80211.h> 17 18#include "host.h" 19#include "decl.h" 20#include "dev.h" 21#include "wext.h" 22#include "debugfs.h" 23#include "assoc.h" 24 25#define DRIVER_RELEASE_VERSION "322.p1" 26const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION 27#ifdef DEBUG 28 "-dbg" 29#endif 30 ""; 31 32 33/* Module parameters */ 34unsigned int libertas_debug = 0; 35module_param(libertas_debug, int, 0644); 36EXPORT_SYMBOL_GPL(libertas_debug); 37 38 39#define WLAN_TX_PWR_DEFAULT 20 /*100mW */ 40#define WLAN_TX_PWR_US_DEFAULT 20 /*100mW */ 41#define WLAN_TX_PWR_JP_DEFAULT 16 /*50mW */ 42#define WLAN_TX_PWR_FR_DEFAULT 20 /*100mW */ 43#define WLAN_TX_PWR_EMEA_DEFAULT 20 /*100mW */ 44 45/* Format { channel, frequency (MHz), maxtxpower } */ 46/* band: 'B/G', region: USA FCC/Canada IC */ 47static struct chan_freq_power channel_freq_power_US_BG[] = { 48 {1, 2412, WLAN_TX_PWR_US_DEFAULT}, 49 {2, 2417, WLAN_TX_PWR_US_DEFAULT}, 50 {3, 2422, WLAN_TX_PWR_US_DEFAULT}, 51 {4, 2427, WLAN_TX_PWR_US_DEFAULT}, 52 {5, 2432, WLAN_TX_PWR_US_DEFAULT}, 53 {6, 2437, WLAN_TX_PWR_US_DEFAULT}, 54 {7, 2442, WLAN_TX_PWR_US_DEFAULT}, 55 {8, 2447, WLAN_TX_PWR_US_DEFAULT}, 56 {9, 2452, WLAN_TX_PWR_US_DEFAULT}, 57 {10, 2457, WLAN_TX_PWR_US_DEFAULT}, 58 {11, 2462, WLAN_TX_PWR_US_DEFAULT} 59}; 60 61/* band: 'B/G', region: Europe ETSI */ 62static struct chan_freq_power channel_freq_power_EU_BG[] = { 63 {1, 2412, WLAN_TX_PWR_EMEA_DEFAULT}, 64 {2, 2417, WLAN_TX_PWR_EMEA_DEFAULT}, 65 {3, 2422, WLAN_TX_PWR_EMEA_DEFAULT}, 66 {4, 2427, WLAN_TX_PWR_EMEA_DEFAULT}, 67 {5, 2432, WLAN_TX_PWR_EMEA_DEFAULT}, 68 {6, 2437, WLAN_TX_PWR_EMEA_DEFAULT}, 69 {7, 2442, WLAN_TX_PWR_EMEA_DEFAULT}, 70 {8, 2447, WLAN_TX_PWR_EMEA_DEFAULT}, 71 {9, 2452, WLAN_TX_PWR_EMEA_DEFAULT}, 72 {10, 2457, WLAN_TX_PWR_EMEA_DEFAULT}, 73 {11, 2462, WLAN_TX_PWR_EMEA_DEFAULT}, 74 {12, 2467, WLAN_TX_PWR_EMEA_DEFAULT}, 75 {13, 2472, WLAN_TX_PWR_EMEA_DEFAULT} 76}; 77 78/* band: 'B/G', region: Spain */ 79static struct chan_freq_power channel_freq_power_SPN_BG[] = { 80 {10, 2457, WLAN_TX_PWR_DEFAULT}, 81 {11, 2462, WLAN_TX_PWR_DEFAULT} 82}; 83 84/* band: 'B/G', region: France */ 85static struct chan_freq_power channel_freq_power_FR_BG[] = { 86 {10, 2457, WLAN_TX_PWR_FR_DEFAULT}, 87 {11, 2462, WLAN_TX_PWR_FR_DEFAULT}, 88 {12, 2467, WLAN_TX_PWR_FR_DEFAULT}, 89 {13, 2472, WLAN_TX_PWR_FR_DEFAULT} 90}; 91 92/* band: 'B/G', region: Japan */ 93static struct chan_freq_power channel_freq_power_JPN_BG[] = { 94 {1, 2412, WLAN_TX_PWR_JP_DEFAULT}, 95 {2, 2417, WLAN_TX_PWR_JP_DEFAULT}, 96 {3, 2422, WLAN_TX_PWR_JP_DEFAULT}, 97 {4, 2427, WLAN_TX_PWR_JP_DEFAULT}, 98 {5, 2432, WLAN_TX_PWR_JP_DEFAULT}, 99 {6, 2437, WLAN_TX_PWR_JP_DEFAULT}, 100 {7, 2442, WLAN_TX_PWR_JP_DEFAULT}, 101 {8, 2447, WLAN_TX_PWR_JP_DEFAULT}, 102 {9, 2452, WLAN_TX_PWR_JP_DEFAULT}, 103 {10, 2457, WLAN_TX_PWR_JP_DEFAULT}, 104 {11, 2462, WLAN_TX_PWR_JP_DEFAULT}, 105 {12, 2467, WLAN_TX_PWR_JP_DEFAULT}, 106 {13, 2472, WLAN_TX_PWR_JP_DEFAULT}, 107 {14, 2484, WLAN_TX_PWR_JP_DEFAULT} 108}; 109 110/** 111 * the structure for channel, frequency and power 112 */ 113struct region_cfp_table { 114 u8 region; 115 struct chan_freq_power *cfp_BG; 116 int cfp_no_BG; 117}; 118 119/** 120 * the structure for the mapping between region and CFP 121 */ 122static struct region_cfp_table region_cfp_table[] = { 123 {0x10, /*US FCC */ 124 channel_freq_power_US_BG, 125 sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power), 126 } 127 , 128 {0x20, /*CANADA IC */ 129 channel_freq_power_US_BG, 130 sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power), 131 } 132 , 133 {0x30, /*EU*/ channel_freq_power_EU_BG, 134 sizeof(channel_freq_power_EU_BG) / sizeof(struct chan_freq_power), 135 } 136 , 137 {0x31, /*SPAIN*/ channel_freq_power_SPN_BG, 138 sizeof(channel_freq_power_SPN_BG) / sizeof(struct chan_freq_power), 139 } 140 , 141 {0x32, /*FRANCE*/ channel_freq_power_FR_BG, 142 sizeof(channel_freq_power_FR_BG) / sizeof(struct chan_freq_power), 143 } 144 , 145 {0x40, /*JAPAN*/ channel_freq_power_JPN_BG, 146 sizeof(channel_freq_power_JPN_BG) / sizeof(struct chan_freq_power), 147 } 148 , 149/*Add new region here */ 150}; 151 152/** 153 * the table to keep region code 154 */ 155u16 libertas_region_code_to_index[MRVDRV_MAX_REGION_CODE] = 156 { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; 157 158/** 159 * 802.11b/g supported bitrates (in 500Kb/s units) 160 */ 161u8 libertas_bg_rates[MAX_RATES] = 162 { 0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c, 1630x00, 0x00 }; 164 165/** 166 * FW rate table. FW refers to rates by their index in this table, not by the 167 * rate value itself. Values of 0x00 are 168 * reserved positions. 169 */ 170static u8 fw_data_rates[MAX_RATES] = 171 { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12, 172 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00 173}; 174 175/** 176 * @brief use index to get the data rate 177 * 178 * @param idx The index of data rate 179 * @return data rate or 0 180 */ 181u32 libertas_fw_index_to_data_rate(u8 idx) 182{ 183 if (idx >= sizeof(fw_data_rates)) 184 idx = 0; 185 return fw_data_rates[idx]; 186} 187 188/** 189 * @brief use rate to get the index 190 * 191 * @param rate data rate 192 * @return index or 0 193 */ 194u8 libertas_data_rate_to_fw_index(u32 rate) 195{ 196 u8 i; 197 198 if (!rate) 199 return 0; 200 201 for (i = 0; i < sizeof(fw_data_rates); i++) { 202 if (rate == fw_data_rates[i]) 203 return i; 204 } 205 return 0; 206} 207 208/** 209 * Attributes exported through sysfs 210 */ 211 212/** 213 * @brief Get function for sysfs attribute anycast_mask 214 */ 215static ssize_t libertas_anycast_get(struct device * dev, 216 struct device_attribute *attr, char * buf) 217{ 218 struct cmd_ds_mesh_access mesh_access; 219 220 memset(&mesh_access, 0, sizeof(mesh_access)); 221 libertas_prepare_and_send_command(to_net_dev(dev)->priv, 222 CMD_MESH_ACCESS, 223 CMD_ACT_MESH_GET_ANYCAST, 224 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 225 226 return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0])); 227} 228 229/** 230 * @brief Set function for sysfs attribute anycast_mask 231 */ 232static ssize_t libertas_anycast_set(struct device * dev, 233 struct device_attribute *attr, const char * buf, size_t count) 234{ 235 struct cmd_ds_mesh_access mesh_access; 236 uint32_t datum; 237 238 memset(&mesh_access, 0, sizeof(mesh_access)); 239 sscanf(buf, "%x", &datum); 240 mesh_access.data[0] = cpu_to_le32(datum); 241 242 libertas_prepare_and_send_command((to_net_dev(dev))->priv, 243 CMD_MESH_ACCESS, 244 CMD_ACT_MESH_SET_ANYCAST, 245 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 246 return strlen(buf); 247} 248 249/** 250 * anycast_mask attribute to be exported per mshX interface 251 * through sysfs (/sys/class/net/mshX/anycast_mask) 252 */ 253static DEVICE_ATTR(anycast_mask, 0644, libertas_anycast_get, libertas_anycast_set); 254 255static ssize_t libertas_autostart_enabled_get(struct device * dev, 256 struct device_attribute *attr, char * buf) 257{ 258 struct cmd_ds_mesh_access mesh_access; 259 260 memset(&mesh_access, 0, sizeof(mesh_access)); 261 libertas_prepare_and_send_command(to_net_dev(dev)->priv, 262 CMD_MESH_ACCESS, 263 CMD_ACT_MESH_GET_AUTOSTART_ENABLED, 264 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 265 266 return sprintf(buf, "%d\n", le32_to_cpu(mesh_access.data[0])); 267} 268 269static ssize_t libertas_autostart_enabled_set(struct device * dev, 270 struct device_attribute *attr, const char * buf, size_t count) 271{ 272 struct cmd_ds_mesh_access mesh_access; 273 uint32_t datum; 274 275 memset(&mesh_access, 0, sizeof(mesh_access)); 276 sscanf(buf, "%d", &datum); 277 mesh_access.data[0] = cpu_to_le32(datum); 278 279 libertas_prepare_and_send_command((to_net_dev(dev))->priv, 280 CMD_MESH_ACCESS, 281 CMD_ACT_MESH_SET_AUTOSTART_ENABLED, 282 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 283 return strlen(buf); 284} 285 286static DEVICE_ATTR(autostart_enabled, 0644, 287 libertas_autostart_enabled_get, libertas_autostart_enabled_set); 288 289static struct attribute *libertas_mesh_sysfs_entries[] = { 290 &dev_attr_anycast_mask.attr, 291 &dev_attr_autostart_enabled.attr, 292 NULL, 293}; 294 295static struct attribute_group libertas_mesh_attr_group = { 296 .attrs = libertas_mesh_sysfs_entries, 297}; 298 299/** 300 * @brief Check if the device can be open and wait if necessary. 301 * 302 * @param dev A pointer to net_device structure 303 * @return 0 304 * 305 * For USB adapter, on some systems the device open handler will be 306 * called before FW ready. Use the following flag check and wait 307 * function to work around the issue. 308 * 309 */ 310static int pre_open_check(struct net_device *dev) 311{ 312 wlan_private *priv = (wlan_private *) dev->priv; 313 wlan_adapter *adapter = priv->adapter; 314 int i = 0; 315 316 while (!adapter->fw_ready && i < 20) { 317 i++; 318 msleep_interruptible(100); 319 } 320 if (!adapter->fw_ready) { 321 lbs_pr_err("firmware not ready\n"); 322 return -1; 323 } 324 325 return 0; 326} 327 328/** 329 * @brief This function opens the device 330 * 331 * @param dev A pointer to net_device structure 332 * @return 0 333 */ 334static int libertas_dev_open(struct net_device *dev) 335{ 336 wlan_private *priv = (wlan_private *) dev->priv; 337 wlan_adapter *adapter = priv->adapter; 338 339 lbs_deb_enter(LBS_DEB_NET); 340 341 priv->open = 1; 342 343 if (adapter->connect_status == LIBERTAS_CONNECTED) { 344 netif_carrier_on(priv->dev); 345 if (priv->mesh_dev) 346 netif_carrier_on(priv->mesh_dev); 347 } else { 348 netif_carrier_off(priv->dev); 349 if (priv->mesh_dev) 350 netif_carrier_off(priv->mesh_dev); 351 } 352 353 lbs_deb_leave(LBS_DEB_NET); 354 return 0; 355} 356/** 357 * @brief This function opens the mshX interface 358 * 359 * @param dev A pointer to net_device structure 360 * @return 0 361 */ 362static int libertas_mesh_open(struct net_device *dev) 363{ 364 wlan_private *priv = (wlan_private *) dev->priv ; 365 366 if (pre_open_check(dev) == -1) 367 return -1; 368 priv->mesh_open = 1 ; 369 netif_wake_queue(priv->mesh_dev); 370 if (priv->infra_open == 0) 371 return libertas_dev_open(priv->dev) ; 372 return 0; 373} 374 375/** 376 * @brief This function opens the ethX interface 377 * 378 * @param dev A pointer to net_device structure 379 * @return 0 380 */ 381static int libertas_open(struct net_device *dev) 382{ 383 wlan_private *priv = (wlan_private *) dev->priv ; 384 385 if(pre_open_check(dev) == -1) 386 return -1; 387 priv->infra_open = 1 ; 388 netif_wake_queue(priv->dev); 389 if (priv->open == 0) 390 return libertas_dev_open(priv->dev) ; 391 return 0; 392} 393 394static int libertas_dev_close(struct net_device *dev) 395{ 396 wlan_private *priv = dev->priv; 397 398 lbs_deb_enter(LBS_DEB_NET); 399 400 netif_carrier_off(priv->dev); 401 priv->open = 0; 402 403 lbs_deb_leave(LBS_DEB_NET); 404 return 0; 405} 406 407/** 408 * @brief This function closes the mshX interface 409 * 410 * @param dev A pointer to net_device structure 411 * @return 0 412 */ 413static int libertas_mesh_close(struct net_device *dev) 414{ 415 wlan_private *priv = (wlan_private *) (dev->priv); 416 417 priv->mesh_open = 0; 418 netif_stop_queue(priv->mesh_dev); 419 if (priv->infra_open == 0) 420 return libertas_dev_close(dev); 421 else 422 return 0; 423} 424 425/** 426 * @brief This function closes the ethX interface 427 * 428 * @param dev A pointer to net_device structure 429 * @return 0 430 */ 431static int libertas_close(struct net_device *dev) 432{ 433 wlan_private *priv = (wlan_private *) dev->priv; 434 435 netif_stop_queue(dev); 436 priv->infra_open = 0; 437 if (priv->mesh_open == 0) 438 return libertas_dev_close(dev); 439 else 440 return 0; 441} 442 443 444static int libertas_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 445{ 446 int ret = 0; 447 wlan_private *priv = dev->priv; 448 449 lbs_deb_enter(LBS_DEB_NET); 450 451 if (priv->dnld_sent || priv->adapter->TxLockFlag) { 452 priv->stats.tx_dropped++; 453 goto done; 454 } 455 456 netif_stop_queue(priv->dev); 457 if (priv->mesh_dev) 458 netif_stop_queue(priv->mesh_dev); 459 460 if (libertas_process_tx(priv, skb) == 0) 461 dev->trans_start = jiffies; 462done: 463 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 464 return ret; 465} 466 467/** 468 * @brief Mark mesh packets and handover them to libertas_hard_start_xmit 469 * 470 */ 471static int libertas_mesh_pre_start_xmit(struct sk_buff *skb, 472 struct net_device *dev) 473{ 474 wlan_private *priv = dev->priv; 475 int ret; 476 477 lbs_deb_enter(LBS_DEB_MESH); 478 479 SET_MESH_FRAME(skb); 480 481 ret = libertas_hard_start_xmit(skb, priv->dev); 482 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); 483 return ret; 484} 485 486/** 487 * @brief Mark non-mesh packets and handover them to libertas_hard_start_xmit 488 * 489 */ 490static int libertas_pre_start_xmit(struct sk_buff *skb, struct net_device *dev) 491{ 492 int ret; 493 494 lbs_deb_enter(LBS_DEB_NET); 495 496 UNSET_MESH_FRAME(skb); 497 498 ret = libertas_hard_start_xmit(skb, dev); 499 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 500 return ret; 501} 502 503static void libertas_tx_timeout(struct net_device *dev) 504{ 505 wlan_private *priv = (wlan_private *) dev->priv; 506 507 lbs_deb_enter(LBS_DEB_TX); 508 509 lbs_pr_err("tx watch dog timeout\n"); 510 511 priv->dnld_sent = DNLD_RES_RECEIVED; 512 dev->trans_start = jiffies; 513 514 if (priv->adapter->currenttxskb) { 515 if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) { 516 /* If we are here, we have not received feedback from 517 the previous packet. Assume TX_FAIL and move on. */ 518 priv->adapter->eventcause = 0x01000000; 519 libertas_send_tx_feedback(priv); 520 } else 521 wake_up_interruptible(&priv->waitq); 522 } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) { 523 netif_wake_queue(priv->dev); 524 if (priv->mesh_dev) 525 netif_wake_queue(priv->mesh_dev); 526 } 527 528 lbs_deb_leave(LBS_DEB_TX); 529} 530 531/** 532 * @brief This function returns the network statistics 533 * 534 * @param dev A pointer to wlan_private structure 535 * @return A pointer to net_device_stats structure 536 */ 537static struct net_device_stats *libertas_get_stats(struct net_device *dev) 538{ 539 wlan_private *priv = (wlan_private *) dev->priv; 540 541 return &priv->stats; 542} 543 544static int libertas_set_mac_address(struct net_device *dev, void *addr) 545{ 546 int ret = 0; 547 wlan_private *priv = (wlan_private *) dev->priv; 548 wlan_adapter *adapter = priv->adapter; 549 struct sockaddr *phwaddr = addr; 550 551 lbs_deb_enter(LBS_DEB_NET); 552 553 /* In case it was called from the mesh device */ 554 dev = priv->dev ; 555 556 memset(adapter->current_addr, 0, ETH_ALEN); 557 558 /* dev->dev_addr is 8 bytes */ 559 lbs_deb_hex(LBS_DEB_NET, "dev->dev_addr", dev->dev_addr, ETH_ALEN); 560 561 lbs_deb_hex(LBS_DEB_NET, "addr", phwaddr->sa_data, ETH_ALEN); 562 memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); 563 564 ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, 565 CMD_ACT_SET, 566 CMD_OPTION_WAITFORRSP, 0, NULL); 567 568 if (ret) { 569 lbs_deb_net("set MAC address failed\n"); 570 ret = -1; 571 goto done; 572 } 573 574 lbs_deb_hex(LBS_DEB_NET, "adapter->macaddr", adapter->current_addr, ETH_ALEN); 575 memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN); 576 if (priv->mesh_dev) 577 memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); 578 579done: 580 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 581 return ret; 582} 583 584static int libertas_copy_multicast_address(wlan_adapter * adapter, 585 struct net_device *dev) 586{ 587 int i = 0; 588 struct dev_mc_list *mcptr = dev->mc_list; 589 590 for (i = 0; i < dev->mc_count; i++) { 591 memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); 592 mcptr = mcptr->next; 593 } 594 595 return i; 596 597} 598 599static void libertas_set_multicast_list(struct net_device *dev) 600{ 601 wlan_private *priv = dev->priv; 602 wlan_adapter *adapter = priv->adapter; 603 int oldpacketfilter; 604 605 lbs_deb_enter(LBS_DEB_NET); 606 607 oldpacketfilter = adapter->currentpacketfilter; 608 609 if (dev->flags & IFF_PROMISC) { 610 lbs_deb_net("enable promiscuous mode\n"); 611 adapter->currentpacketfilter |= 612 CMD_ACT_MAC_PROMISCUOUS_ENABLE; 613 adapter->currentpacketfilter &= 614 ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | 615 CMD_ACT_MAC_MULTICAST_ENABLE); 616 } else { 617 /* Multicast */ 618 adapter->currentpacketfilter &= 619 ~CMD_ACT_MAC_PROMISCUOUS_ENABLE; 620 621 if (dev->flags & IFF_ALLMULTI || dev->mc_count > 622 MRVDRV_MAX_MULTICAST_LIST_SIZE) { 623 lbs_deb_net( "enabling all multicast\n"); 624 adapter->currentpacketfilter |= 625 CMD_ACT_MAC_ALL_MULTICAST_ENABLE; 626 adapter->currentpacketfilter &= 627 ~CMD_ACT_MAC_MULTICAST_ENABLE; 628 } else { 629 adapter->currentpacketfilter &= 630 ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE; 631 632 if (!dev->mc_count) { 633 lbs_deb_net("no multicast addresses, " 634 "disabling multicast\n"); 635 adapter->currentpacketfilter &= 636 ~CMD_ACT_MAC_MULTICAST_ENABLE; 637 } else { 638 int i; 639 640 adapter->currentpacketfilter |= 641 CMD_ACT_MAC_MULTICAST_ENABLE; 642 643 adapter->nr_of_multicastmacaddr = 644 libertas_copy_multicast_address(adapter, dev); 645 646 lbs_deb_net("multicast addresses: %d\n", 647 dev->mc_count); 648 649 for (i = 0; i < dev->mc_count; i++) { 650 lbs_deb_net("Multicast address %d:" 651 MAC_FMT "\n", i, 652 adapter->multicastlist[i][0], 653 adapter->multicastlist[i][1], 654 adapter->multicastlist[i][2], 655 adapter->multicastlist[i][3], 656 adapter->multicastlist[i][4], 657 adapter->multicastlist[i][5]); 658 } 659 /* send multicast addresses to firmware */ 660 libertas_prepare_and_send_command(priv, 661 CMD_MAC_MULTICAST_ADR, 662 CMD_ACT_SET, 0, 0, 663 NULL); 664 } 665 } 666 } 667 668 if (adapter->currentpacketfilter != oldpacketfilter) { 669 libertas_set_mac_packet_filter(priv); 670 } 671 672 lbs_deb_leave(LBS_DEB_NET); 673} 674 675/** 676 * @brief This function handles the major jobs in the WLAN driver. 677 * It handles all events generated by firmware, RX data received 678 * from firmware and TX data sent from kernel. 679 * 680 * @param data A pointer to wlan_thread structure 681 * @return 0 682 */ 683static int libertas_thread(void *data) 684{ 685 struct net_device *dev = data; 686 wlan_private *priv = dev->priv; 687 wlan_adapter *adapter = priv->adapter; 688 wait_queue_t wait; 689 u8 ireg = 0; 690 691 lbs_deb_enter(LBS_DEB_THREAD); 692 693 init_waitqueue_entry(&wait, current); 694 695 for (;;) { 696 lbs_deb_thread( "main-thread 111: intcounter=%d " 697 "currenttxskb=%p dnld_sent=%d\n", 698 adapter->intcounter, 699 adapter->currenttxskb, priv->dnld_sent); 700 701 add_wait_queue(&priv->waitq, &wait); 702 set_current_state(TASK_INTERRUPTIBLE); 703 spin_lock_irq(&adapter->driver_lock); 704 if ((adapter->psstate == PS_STATE_SLEEP) || 705 (!adapter->intcounter 706 && (priv->dnld_sent || adapter->cur_cmd || 707 list_empty(&adapter->cmdpendingq)))) { 708 lbs_deb_thread( 709 "main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", 710 adapter->connect_status, adapter->intcounter, 711 adapter->psmode, adapter->psstate); 712 spin_unlock_irq(&adapter->driver_lock); 713 schedule(); 714 } else 715 spin_unlock_irq(&adapter->driver_lock); 716 717 718 lbs_deb_thread( 719 "main-thread 222 (waking up): intcounter=%d currenttxskb=%p " 720 "dnld_sent=%d\n", adapter->intcounter, 721 adapter->currenttxskb, priv->dnld_sent); 722 723 set_current_state(TASK_RUNNING); 724 remove_wait_queue(&priv->waitq, &wait); 725 try_to_freeze(); 726 727 lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p " 728 "dnld_sent=%d\n", 729 adapter->intcounter, 730 adapter->currenttxskb, priv->dnld_sent); 731 732 if (kthread_should_stop() 733 || adapter->surpriseremoved) { 734 lbs_deb_thread( 735 "main-thread: break from main thread: surpriseremoved=0x%x\n", 736 adapter->surpriseremoved); 737 break; 738 } 739 740 741 spin_lock_irq(&adapter->driver_lock); 742 if (adapter->intcounter) { 743 u8 int_status; 744 adapter->intcounter = 0; 745 int_status = priv->hw_get_int_status(priv, &ireg); 746 747 if (int_status) { 748 lbs_deb_thread( 749 "main-thread: reading HOST_INT_STATUS_REG failed\n"); 750 spin_unlock_irq(&adapter->driver_lock); 751 continue; 752 } 753 adapter->hisregcpy |= ireg; 754 } 755 756 lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p " 757 "dnld_sent=%d\n", 758 adapter->intcounter, 759 adapter->currenttxskb, priv->dnld_sent); 760 761 /* command response? */ 762 if (adapter->hisregcpy & MRVDRV_CMD_UPLD_RDY) { 763 lbs_deb_thread("main-thread: cmd response ready\n"); 764 765 adapter->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; 766 spin_unlock_irq(&adapter->driver_lock); 767 libertas_process_rx_command(priv); 768 spin_lock_irq(&adapter->driver_lock); 769 } 770 771 /* Any Card Event */ 772 if (adapter->hisregcpy & MRVDRV_CARDEVENT) { 773 lbs_deb_thread("main-thread: Card Event Activity\n"); 774 775 adapter->hisregcpy &= ~MRVDRV_CARDEVENT; 776 777 if (priv->hw_read_event_cause(priv)) { 778 lbs_pr_alert( 779 "main-thread: hw_read_event_cause failed\n"); 780 spin_unlock_irq(&adapter->driver_lock); 781 continue; 782 } 783 spin_unlock_irq(&adapter->driver_lock); 784 libertas_process_event(priv); 785 } else 786 spin_unlock_irq(&adapter->driver_lock); 787 788 /* Check if we need to confirm Sleep Request received previously */ 789 if (adapter->psstate == PS_STATE_PRE_SLEEP) { 790 if (!priv->dnld_sent && !adapter->cur_cmd) { 791 if (adapter->connect_status == 792 LIBERTAS_CONNECTED) { 793 lbs_deb_thread( 794 "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p " 795 "dnld_sent=%d cur_cmd=%p, confirm now\n", 796 adapter->intcounter, 797 adapter->currenttxskb, 798 priv->dnld_sent, 799 adapter->cur_cmd); 800 801 libertas_ps_confirm_sleep(priv, 802 (u16) adapter->psmode); 803 } else { 804 /* workaround for firmware sending 805 * deauth/linkloss event immediately 806 * after sleep request, remove this 807 * after firmware fixes it 808 */ 809 adapter->psstate = PS_STATE_AWAKE; 810 lbs_pr_alert( 811 "main-thread: ignore PS_SleepConfirm in non-connected state\n"); 812 } 813 } 814 } 815 816 /* The PS state is changed during processing of Sleep Request 817 * event above 818 */ 819 if ((priv->adapter->psstate == PS_STATE_SLEEP) || 820 (priv->adapter->psstate == PS_STATE_PRE_SLEEP)) 821 continue; 822 823 /* Execute the next command */ 824 if (!priv->dnld_sent && !priv->adapter->cur_cmd) 825 libertas_execute_next_command(priv); 826 827 /* Wake-up command waiters which can't sleep in 828 * libertas_prepare_and_send_command 829 */ 830 if (!adapter->nr_cmd_pending) 831 wake_up_all(&adapter->cmd_pending); 832 833 libertas_tx_runqueue(priv); 834 } 835 836 del_timer(&adapter->command_timer); 837 adapter->nr_cmd_pending = 0; 838 wake_up_all(&adapter->cmd_pending); 839 840 lbs_deb_leave(LBS_DEB_THREAD); 841 return 0; 842} 843 844/** 845 * @brief This function downloads firmware image, gets 846 * HW spec from firmware and set basic parameters to 847 * firmware. 848 * 849 * @param priv A pointer to wlan_private structure 850 * @return 0 or -1 851 */ 852static int wlan_setup_station_hw(wlan_private * priv) 853{ 854 int ret = -1; 855 wlan_adapter *adapter = priv->adapter; 856 857 lbs_deb_enter(LBS_DEB_FW); 858 859 ret = priv->hw_prog_firmware(priv); 860 861 if (ret) { 862 lbs_deb_fw("bootloader in invalid state\n"); 863 ret = -1; 864 goto done; 865 } 866 867 /* 868 * Read MAC address from HW 869 */ 870 memset(adapter->current_addr, 0xff, ETH_ALEN); 871 872 ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC, 873 0, CMD_OPTION_WAITFORRSP, 0, NULL); 874 875 if (ret) { 876 ret = -1; 877 goto done; 878 } 879 880 libertas_set_mac_packet_filter(priv); 881 882 /* Get the supported Data rates */ 883 ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE, 884 CMD_ACT_GET_TX_RATE, 885 CMD_OPTION_WAITFORRSP, 0, NULL); 886 887 if (ret) { 888 ret = -1; 889 goto done; 890 } 891 892 ret = 0; 893done: 894 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 895 return ret; 896} 897 898static void command_timer_fn(unsigned long data); 899 900/** 901 * This function handles the timeout of command sending. 902 * It will re-send the same command again. 903 */ 904static void command_timer_fn(unsigned long data) 905{ 906 wlan_private *priv = (wlan_private *)data; 907 wlan_adapter *adapter = priv->adapter; 908 struct cmd_ctrl_node *ptempnode; 909 struct cmd_ds_command *cmd; 910 unsigned long flags; 911 912 ptempnode = adapter->cur_cmd; 913 if (ptempnode == NULL) { 914 lbs_deb_fw("ptempnode empty\n"); 915 return; 916 } 917 918 cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr; 919 if (!cmd) { 920 lbs_deb_fw("cmd is NULL\n"); 921 return; 922 } 923 924 lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command); 925 926 if (!adapter->fw_ready) 927 return; 928 929 spin_lock_irqsave(&adapter->driver_lock, flags); 930 adapter->cur_cmd = NULL; 931 spin_unlock_irqrestore(&adapter->driver_lock, flags); 932 933 lbs_deb_fw("re-sending same command because of timeout\n"); 934 libertas_queue_cmd(adapter, ptempnode, 0); 935 936 wake_up_interruptible(&priv->waitq); 937 938 return; 939} 940 941static void libertas_free_adapter(wlan_private * priv) 942{ 943 wlan_adapter *adapter = priv->adapter; 944 945 if (!adapter) { 946 lbs_deb_fw("why double free adapter?\n"); 947 return; 948 } 949 950 lbs_deb_fw("free command buffer\n"); 951 libertas_free_cmd_buffer(priv); 952 953 lbs_deb_fw("free command_timer\n"); 954 del_timer(&adapter->command_timer); 955 956 lbs_deb_fw("free scan results table\n"); 957 kfree(adapter->networks); 958 adapter->networks = NULL; 959 960 /* Free the adapter object itself */ 961 lbs_deb_fw("free adapter\n"); 962 kfree(adapter); 963 priv->adapter = NULL; 964} 965 966static int wlan_allocate_adapter(wlan_private * priv) 967{ 968 size_t bufsize; 969 wlan_adapter *adapter = priv->adapter; 970 971 /* Allocate buffer to store the BSSID list */ 972 bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); 973 adapter->networks = kzalloc(bufsize, GFP_KERNEL); 974 if (!adapter->networks) { 975 lbs_pr_err("Out of memory allocating beacons\n"); 976 libertas_free_adapter(priv); 977 return -ENOMEM; 978 } 979 980 /* Allocate the command buffers */ 981 libertas_allocate_cmd_buffer(priv); 982 983 memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep)); 984 adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); 985 adapter->libertas_ps_confirm_sleep.command = 986 cpu_to_le16(CMD_802_11_PS_MODE); 987 adapter->libertas_ps_confirm_sleep.size = 988 cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); 989 adapter->libertas_ps_confirm_sleep.result = 0; 990 adapter->libertas_ps_confirm_sleep.action = 991 cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); 992 993 return 0; 994} 995 996static void wlan_init_adapter(wlan_private * priv) 997{ 998 wlan_adapter *adapter = priv->adapter; 999 int i; 1000 1001 adapter->connect_status = LIBERTAS_DISCONNECTED; 1002 memset(adapter->current_addr, 0xff, ETH_ALEN); 1003 1004 /* 802.11 specific */ 1005 adapter->secinfo.wep_enabled = 0; 1006 for (i = 0; i < sizeof(adapter->wep_keys) / sizeof(adapter->wep_keys[0]); 1007 i++) 1008 memset(&adapter->wep_keys[i], 0, sizeof(struct enc_key)); 1009 adapter->wep_tx_keyidx = 0; 1010 adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; 1011 adapter->mode = IW_MODE_INFRA; 1012 1013 adapter->pending_assoc_req = NULL; 1014 adapter->in_progress_assoc_req = NULL; 1015 1016 /* Initialize scan result lists */ 1017 INIT_LIST_HEAD(&adapter->network_free_list); 1018 INIT_LIST_HEAD(&adapter->network_list); 1019 for (i = 0; i < MAX_NETWORK_COUNT; i++) { 1020 list_add_tail(&adapter->networks[i].list, 1021 &adapter->network_free_list); 1022 } 1023 1024 mutex_init(&adapter->lock); 1025 1026 memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams)); 1027 adapter->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL; 1028 1029 /* PnP and power profile */ 1030 adapter->surpriseremoved = 0; 1031 1032 adapter->currentpacketfilter = 1033 CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; 1034 1035 adapter->radioon = RADIO_ON; 1036 1037 adapter->auto_rate = 1; 1038 adapter->cur_rate = 0; 1039 1040 // set default capabilities 1041 adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 1042 1043 adapter->psmode = WLAN802_11POWERMODECAM; 1044 1045 adapter->psstate = PS_STATE_FULL_POWER; 1046 adapter->needtowakeup = 0; 1047 1048 adapter->intcounter = 0; 1049 1050 adapter->currenttxskb = NULL; 1051 1052 memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*)); 1053 adapter->tx_queue_idx = 0; 1054 spin_lock_init(&adapter->txqueue_lock); 1055 1056 return; 1057} 1058 1059static int libertas_init_fw(wlan_private * priv) 1060{ 1061 int ret = -1; 1062 wlan_adapter *adapter = priv->adapter; 1063 1064 lbs_deb_enter(LBS_DEB_FW); 1065 1066 /* Allocate adapter structure */ 1067 if ((ret = wlan_allocate_adapter(priv)) != 0) 1068 goto done; 1069 1070 /* init adapter structure */ 1071 wlan_init_adapter(priv); 1072 1073 /* init timer etc. */ 1074 setup_timer(&adapter->command_timer, command_timer_fn, 1075 (unsigned long)priv); 1076 1077 /* download fimrware etc. */ 1078 if ((ret = wlan_setup_station_hw(priv)) != 0) { 1079 del_timer_sync(&adapter->command_timer); 1080 goto done; 1081 } 1082 1083 /* init 802.11d */ 1084 libertas_init_11d(priv); 1085 1086 ret = 0; 1087done: 1088 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 1089 return ret; 1090} 1091 1092/** 1093 * @brief This function adds the card. it will probe the 1094 * card, allocate the wlan_priv and initialize the device. 1095 * 1096 * @param card A pointer to card 1097 * @return A pointer to wlan_private structure 1098 */ 1099wlan_private *libertas_add_card(void *card, struct device *dmdev) 1100{ 1101 struct net_device *dev = NULL; 1102 wlan_private *priv = NULL; 1103 1104 lbs_deb_enter(LBS_DEB_NET); 1105 1106 /* Allocate an Ethernet device and register it */ 1107 if (!(dev = alloc_etherdev(sizeof(wlan_private)))) { 1108 lbs_pr_err("init ethX device failed\n"); 1109 return NULL; 1110 } 1111 priv = dev->priv; 1112 1113 /* allocate buffer for wlan_adapter */ 1114 if (!(priv->adapter = kzalloc(sizeof(wlan_adapter), GFP_KERNEL))) { 1115 lbs_pr_err("allocate buffer for wlan_adapter failed\n"); 1116 goto err_kzalloc; 1117 } 1118 1119 priv->dev = dev; 1120 priv->card = card; 1121 priv->mesh_open = 0; 1122 priv->infra_open = 0; 1123 1124 SET_MODULE_OWNER(dev); 1125 1126 /* Setup the OS Interface to our functions */ 1127 dev->open = libertas_open; 1128 dev->hard_start_xmit = libertas_pre_start_xmit; 1129 dev->stop = libertas_close; 1130 dev->set_mac_address = libertas_set_mac_address; 1131 dev->tx_timeout = libertas_tx_timeout; 1132 dev->get_stats = libertas_get_stats; 1133 dev->watchdog_timeo = 5 * HZ; 1134 dev->ethtool_ops = &libertas_ethtool_ops; 1135#ifdef WIRELESS_EXT 1136 dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def; 1137#endif 1138#define NETIF_F_DYNALLOC 16 1139 dev->features |= NETIF_F_DYNALLOC; 1140 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 1141 dev->set_multicast_list = libertas_set_multicast_list; 1142 1143 SET_NETDEV_DEV(dev, dmdev); 1144 1145 INIT_LIST_HEAD(&priv->adapter->cmdfreeq); 1146 INIT_LIST_HEAD(&priv->adapter->cmdpendingq); 1147 1148 spin_lock_init(&priv->adapter->driver_lock); 1149 init_waitqueue_head(&priv->adapter->cmd_pending); 1150 priv->adapter->nr_cmd_pending = 0; 1151 goto done; 1152 1153err_kzalloc: 1154 free_netdev(dev); 1155 priv = NULL; 1156done: 1157 lbs_deb_leave_args(LBS_DEB_NET, "priv %p", priv); 1158 return priv; 1159} 1160EXPORT_SYMBOL_GPL(libertas_add_card); 1161 1162int libertas_activate_card(wlan_private *priv) 1163{ 1164 struct net_device *dev = priv->dev; 1165 int ret = -1; 1166 1167 lbs_deb_enter(LBS_DEB_MAIN); 1168 1169 lbs_deb_thread("Starting main thread...\n"); 1170 init_waitqueue_head(&priv->waitq); 1171 priv->main_thread = kthread_run(libertas_thread, dev, "libertas_main"); 1172 if (IS_ERR(priv->main_thread)) { 1173 lbs_deb_thread("Error creating main thread.\n"); 1174 goto done; 1175 } 1176 1177 priv->assoc_thread = 1178 create_singlethread_workqueue("libertas_assoc"); 1179 INIT_DELAYED_WORK(&priv->assoc_work, libertas_association_worker); 1180 INIT_WORK(&priv->sync_channel, libertas_sync_channel); 1181 1182 /* 1183 * Register the device. Fillup the private data structure with 1184 * relevant information from the card and request for the required 1185 * IRQ. 1186 */ 1187 if (priv->hw_register_dev(priv) < 0) { 1188 lbs_pr_err("failed to register WLAN device\n"); 1189 goto err_registerdev; 1190 } 1191 1192 /* init FW and HW */ 1193 if (libertas_init_fw(priv)) { 1194 lbs_pr_err("firmware init failed\n"); 1195 goto err_registerdev; 1196 } 1197 1198 if (register_netdev(dev)) { 1199 lbs_pr_err("cannot register ethX device\n"); 1200 goto err_init_fw; 1201 } 1202 1203 lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); 1204 1205 libertas_debugfs_init_one(priv, dev); 1206 1207 ret = 0; 1208 goto done; 1209 1210err_init_fw: 1211 priv->hw_unregister_dev(priv); 1212err_registerdev: 1213 destroy_workqueue(priv->assoc_thread); 1214 /* Stop the thread servicing the interrupts */ 1215 wake_up_interruptible(&priv->waitq); 1216 kthread_stop(priv->main_thread); 1217done: 1218 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 1219 return ret; 1220} 1221EXPORT_SYMBOL_GPL(libertas_activate_card); 1222 1223 1224/** 1225 * @brief This function adds mshX interface 1226 * 1227 * @param priv A pointer to the wlan_private structure 1228 * @return 0 if successful, -X otherwise 1229 */ 1230int libertas_add_mesh(wlan_private *priv, struct device *dev) 1231{ 1232 struct net_device *mesh_dev = NULL; 1233 int ret = 0; 1234 1235 lbs_deb_enter(LBS_DEB_MESH); 1236 1237 /* Allocate a virtual mesh device */ 1238 if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) { 1239 lbs_deb_mesh("init mshX device failed\n"); 1240 ret = -ENOMEM; 1241 goto done; 1242 } 1243 mesh_dev->priv = priv; 1244 priv->mesh_dev = mesh_dev; 1245 1246 SET_MODULE_OWNER(mesh_dev); 1247 1248 mesh_dev->open = libertas_mesh_open; 1249 mesh_dev->hard_start_xmit = libertas_mesh_pre_start_xmit; 1250 mesh_dev->stop = libertas_mesh_close; 1251 mesh_dev->get_stats = libertas_get_stats; 1252 mesh_dev->set_mac_address = libertas_set_mac_address; 1253 mesh_dev->ethtool_ops = &libertas_ethtool_ops; 1254 memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, 1255 sizeof(priv->dev->dev_addr)); 1256 1257 SET_NETDEV_DEV(priv->mesh_dev, dev); 1258 1259#ifdef WIRELESS_EXT 1260 mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def; 1261#endif 1262#define NETIF_F_DYNALLOC 16 1263 1264 /* Register virtual mesh interface */ 1265 ret = register_netdev(mesh_dev); 1266 if (ret) { 1267 lbs_pr_err("cannot register mshX virtual interface\n"); 1268 goto err_free; 1269 } 1270 1271 ret = sysfs_create_group(&(mesh_dev->dev.kobj), &libertas_mesh_attr_group); 1272 if (ret) 1273 goto err_unregister; 1274 1275 /* Everything successful */ 1276 ret = 0; 1277 goto done; 1278 1279err_unregister: 1280 unregister_netdev(mesh_dev); 1281 1282err_free: 1283 free_netdev(mesh_dev); 1284 1285done: 1286 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); 1287 return ret; 1288} 1289EXPORT_SYMBOL_GPL(libertas_add_mesh); 1290 1291static void wake_pending_cmdnodes(wlan_private *priv) 1292{ 1293 struct cmd_ctrl_node *cmdnode; 1294 unsigned long flags; 1295 1296 lbs_deb_enter(LBS_DEB_HOST); 1297 1298 spin_lock_irqsave(&priv->adapter->driver_lock, flags); 1299 list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) { 1300 cmdnode->cmdwaitqwoken = 1; 1301 wake_up_interruptible(&cmdnode->cmdwait_q); 1302 } 1303 spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); 1304} 1305 1306 1307int libertas_remove_card(wlan_private *priv) 1308{ 1309 wlan_adapter *adapter; 1310 struct net_device *dev; 1311 union iwreq_data wrqu; 1312 1313 lbs_deb_enter(LBS_DEB_NET); 1314 1315 if (!priv) 1316 goto out; 1317 1318 adapter = priv->adapter; 1319 1320 if (!adapter) 1321 goto out; 1322 1323 dev = priv->dev; 1324 1325 netif_stop_queue(priv->dev); 1326 netif_carrier_off(priv->dev); 1327 1328 wake_pending_cmdnodes(priv); 1329 1330 unregister_netdev(dev); 1331 1332 cancel_delayed_work(&priv->assoc_work); 1333 destroy_workqueue(priv->assoc_thread); 1334 1335 if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) { 1336 adapter->psmode = WLAN802_11POWERMODECAM; 1337 libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); 1338 } 1339 1340 memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); 1341 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 1342 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); 1343 1344 adapter->surpriseremoved = 1; 1345 1346 /* Stop the thread servicing the interrupts */ 1347 kthread_stop(priv->main_thread); 1348 1349 libertas_debugfs_remove_one(priv); 1350 1351 lbs_deb_net("free adapter\n"); 1352 libertas_free_adapter(priv); 1353 1354 lbs_deb_net("unregister finish\n"); 1355 1356 priv->dev = NULL; 1357 free_netdev(dev); 1358 1359out: 1360 lbs_deb_leave(LBS_DEB_NET); 1361 return 0; 1362} 1363EXPORT_SYMBOL_GPL(libertas_remove_card); 1364 1365 1366void libertas_remove_mesh(wlan_private *priv) 1367{ 1368 struct net_device *mesh_dev; 1369 1370 lbs_deb_enter(LBS_DEB_NET); 1371 1372 if (!priv) 1373 goto out; 1374 1375 mesh_dev = priv->mesh_dev; 1376 1377 netif_stop_queue(mesh_dev); 1378 netif_carrier_off(priv->mesh_dev); 1379 1380 sysfs_remove_group(&(mesh_dev->dev.kobj), &libertas_mesh_attr_group); 1381 unregister_netdev(mesh_dev); 1382 1383 priv->mesh_dev = NULL ; 1384 free_netdev(mesh_dev); 1385 1386out: 1387 lbs_deb_leave(LBS_DEB_NET); 1388} 1389EXPORT_SYMBOL_GPL(libertas_remove_mesh); 1390 1391/** 1392 * @brief This function finds the CFP in 1393 * region_cfp_table based on region and band parameter. 1394 * 1395 * @param region The region code 1396 * @param band The band 1397 * @param cfp_no A pointer to CFP number 1398 * @return A pointer to CFP 1399 */ 1400struct chan_freq_power *libertas_get_region_cfp_table(u8 region, u8 band, int *cfp_no) 1401{ 1402 int i, end; 1403 1404 lbs_deb_enter(LBS_DEB_MAIN); 1405 1406 end = sizeof(region_cfp_table)/sizeof(struct region_cfp_table); 1407 1408 for (i = 0; i < end ; i++) { 1409 lbs_deb_main("region_cfp_table[i].region=%d\n", 1410 region_cfp_table[i].region); 1411 if (region_cfp_table[i].region == region) { 1412 *cfp_no = region_cfp_table[i].cfp_no_BG; 1413 lbs_deb_leave(LBS_DEB_MAIN); 1414 return region_cfp_table[i].cfp_BG; 1415 } 1416 } 1417 1418 lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL"); 1419 return NULL; 1420} 1421 1422int libertas_set_regiontable(wlan_private * priv, u8 region, u8 band) 1423{ 1424 wlan_adapter *adapter = priv->adapter; 1425 int ret = 0; 1426 int i = 0; 1427 1428 struct chan_freq_power *cfp; 1429 int cfp_no; 1430 1431 lbs_deb_enter(LBS_DEB_MAIN); 1432 1433 memset(adapter->region_channel, 0, sizeof(adapter->region_channel)); 1434 1435 { 1436 cfp = libertas_get_region_cfp_table(region, band, &cfp_no); 1437 if (cfp != NULL) { 1438 adapter->region_channel[i].nrcfp = cfp_no; 1439 adapter->region_channel[i].CFP = cfp; 1440 } else { 1441 lbs_deb_main("wrong region code %#x in band B/G\n", 1442 region); 1443 ret = -1; 1444 goto out; 1445 } 1446 adapter->region_channel[i].valid = 1; 1447 adapter->region_channel[i].region = region; 1448 adapter->region_channel[i].band = band; 1449 i++; 1450 } 1451out: 1452 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1453 return ret; 1454} 1455 1456/** 1457 * @brief This function handles the interrupt. it will change PS 1458 * state if applicable. it will wake up main_thread to handle 1459 * the interrupt event as well. 1460 * 1461 * @param dev A pointer to net_device structure 1462 * @return n/a 1463 */ 1464void libertas_interrupt(struct net_device *dev) 1465{ 1466 wlan_private *priv = dev->priv; 1467 1468 lbs_deb_enter(LBS_DEB_THREAD); 1469 1470 lbs_deb_thread("libertas_interrupt: intcounter=%d\n", 1471 priv->adapter->intcounter); 1472 1473 priv->adapter->intcounter++; 1474 1475 if (priv->adapter->psstate == PS_STATE_SLEEP) { 1476 priv->adapter->psstate = PS_STATE_AWAKE; 1477 netif_wake_queue(dev); 1478 if (priv->mesh_dev) 1479 netif_wake_queue(priv->mesh_dev); 1480 } 1481 1482 wake_up_interruptible(&priv->waitq); 1483 1484 lbs_deb_leave(LBS_DEB_THREAD); 1485} 1486EXPORT_SYMBOL_GPL(libertas_interrupt); 1487 1488int libertas_reset_device(wlan_private *priv) 1489{ 1490 int ret; 1491 1492 lbs_deb_enter(LBS_DEB_MAIN); 1493 ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET, 1494 CMD_ACT_HALT, 0, 0, NULL); 1495 msleep_interruptible(10); 1496 1497 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1498 return ret; 1499} 1500EXPORT_SYMBOL_GPL(libertas_reset_device); 1501 1502static int libertas_init_module(void) 1503{ 1504 lbs_deb_enter(LBS_DEB_MAIN); 1505 libertas_debugfs_init(); 1506 lbs_deb_leave(LBS_DEB_MAIN); 1507 return 0; 1508} 1509 1510static void libertas_exit_module(void) 1511{ 1512 lbs_deb_enter(LBS_DEB_MAIN); 1513 1514 libertas_debugfs_remove(); 1515 1516 lbs_deb_leave(LBS_DEB_MAIN); 1517} 1518 1519module_init(libertas_init_module); 1520module_exit(libertas_exit_module); 1521 1522MODULE_DESCRIPTION("Libertas WLAN Driver Library"); 1523MODULE_AUTHOR("Marvell International Ltd."); 1524MODULE_LICENSE("GPL"); 1525