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