main.c revision e7deced05f15693cca71bfae747b8d57eadeb1b2
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 struct lbs_adapter *adapter = priv->adapter; 261 return snprintf(buf, 5, "0x%X\n", adapter->monitormode); 262} 263 264/** 265 * Set function for sysfs attribute rtap 266 */ 267static ssize_t lbs_rtap_set(struct device *dev, 268 struct device_attribute *attr, const char * buf, size_t count) 269{ 270 int monitor_mode; 271 struct lbs_private *priv = to_net_dev(dev)->priv; 272 struct lbs_adapter *adapter = priv->adapter; 273 274 sscanf(buf, "%x", &monitor_mode); 275 if (monitor_mode != LBS_MONITOR_OFF) { 276 if(adapter->monitormode == monitor_mode) 277 return strlen(buf); 278 if (adapter->monitormode == LBS_MONITOR_OFF) { 279 if (adapter->mode == IW_MODE_INFRA) 280 lbs_send_deauthentication(priv); 281 else if (adapter->mode == IW_MODE_ADHOC) 282 lbs_stop_adhoc_network(priv); 283 lbs_add_rtap(priv); 284 } 285 adapter->monitormode = monitor_mode; 286 } 287 288 else { 289 if (adapter->monitormode == LBS_MONITOR_OFF) 290 return strlen(buf); 291 adapter->monitormode = LBS_MONITOR_OFF; 292 lbs_remove_rtap(priv); 293 netif_wake_queue(priv->dev); 294 netif_wake_queue(priv->mesh_dev); 295 } 296 297 lbs_prepare_and_send_command(priv, 298 CMD_802_11_MONITOR_MODE, CMD_ACT_SET, 299 CMD_OPTION_WAITFORRSP, 0, &adapter->monitormode); 300 return strlen(buf); 301} 302 303/** 304 * lbs_rtap attribute to be exported per mshX interface 305 * through sysfs (/sys/class/net/mshX/libertas-rtap) 306 */ 307static DEVICE_ATTR(lbs_rtap, 0644, lbs_rtap_get, 308 lbs_rtap_set ); 309 310/** 311 * anycast_mask attribute to be exported per mshX interface 312 * through sysfs (/sys/class/net/mshX/anycast_mask) 313 */ 314static DEVICE_ATTR(anycast_mask, 0644, lbs_anycast_get, lbs_anycast_set); 315 316static ssize_t lbs_autostart_enabled_get(struct device *dev, 317 struct device_attribute *attr, char * buf) 318{ 319 struct cmd_ds_mesh_access mesh_access; 320 321 memset(&mesh_access, 0, sizeof(mesh_access)); 322 lbs_prepare_and_send_command(to_net_dev(dev)->priv, 323 CMD_MESH_ACCESS, 324 CMD_ACT_MESH_GET_AUTOSTART_ENABLED, 325 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 326 327 return sprintf(buf, "%d\n", le32_to_cpu(mesh_access.data[0])); 328} 329 330static ssize_t lbs_autostart_enabled_set(struct device *dev, 331 struct device_attribute *attr, const char * buf, size_t count) 332{ 333 struct cmd_ds_mesh_access mesh_access; 334 uint32_t datum; 335 struct lbs_private *priv = (to_net_dev(dev))->priv; 336 int ret; 337 338 memset(&mesh_access, 0, sizeof(mesh_access)); 339 sscanf(buf, "%d", &datum); 340 mesh_access.data[0] = cpu_to_le32(datum); 341 342 ret = lbs_prepare_and_send_command(priv, 343 CMD_MESH_ACCESS, 344 CMD_ACT_MESH_SET_AUTOSTART_ENABLED, 345 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 346 if (ret == 0) 347 priv->mesh_autostart_enabled = datum ? 1 : 0; 348 349 return strlen(buf); 350} 351 352static DEVICE_ATTR(autostart_enabled, 0644, 353 lbs_autostart_enabled_get, lbs_autostart_enabled_set); 354 355static struct attribute *lbs_mesh_sysfs_entries[] = { 356 &dev_attr_anycast_mask.attr, 357 &dev_attr_autostart_enabled.attr, 358 NULL, 359}; 360 361static struct attribute_group lbs_mesh_attr_group = { 362 .attrs = lbs_mesh_sysfs_entries, 363}; 364 365/** 366 * @brief Check if the device can be open and wait if necessary. 367 * 368 * @param dev A pointer to net_device structure 369 * @return 0 370 * 371 * For USB adapter, on some systems the device open handler will be 372 * called before FW ready. Use the following flag check and wait 373 * function to work around the issue. 374 * 375 */ 376static int pre_open_check(struct net_device *dev) 377{ 378 struct lbs_private *priv = (struct lbs_private *) dev->priv; 379 struct lbs_adapter *adapter = priv->adapter; 380 int i = 0; 381 382 while (!adapter->fw_ready && i < 20) { 383 i++; 384 msleep_interruptible(100); 385 } 386 if (!adapter->fw_ready) { 387 lbs_pr_err("firmware not ready\n"); 388 return -1; 389 } 390 391 return 0; 392} 393 394/** 395 * @brief This function opens the device 396 * 397 * @param dev A pointer to net_device structure 398 * @return 0 399 */ 400static int lbs_dev_open(struct net_device *dev) 401{ 402 struct lbs_private *priv = (struct lbs_private *) dev->priv; 403 struct lbs_adapter *adapter = priv->adapter; 404 405 lbs_deb_enter(LBS_DEB_NET); 406 407 priv->open = 1; 408 409 if (adapter->connect_status == LBS_CONNECTED) 410 netif_carrier_on(priv->dev); 411 else 412 netif_carrier_off(priv->dev); 413 414 if (priv->mesh_dev) { 415 if (adapter->mesh_connect_status == LBS_CONNECTED) 416 netif_carrier_on(priv->mesh_dev); 417 else 418 netif_carrier_off(priv->mesh_dev); 419 } 420 421 lbs_deb_leave(LBS_DEB_NET); 422 return 0; 423} 424/** 425 * @brief This function opens the mshX interface 426 * 427 * @param dev A pointer to net_device structure 428 * @return 0 429 */ 430static int lbs_mesh_open(struct net_device *dev) 431{ 432 struct lbs_private *priv = (struct lbs_private *) dev->priv ; 433 434 if (pre_open_check(dev) == -1) 435 return -1; 436 priv->mesh_open = 1 ; 437 netif_wake_queue(priv->mesh_dev); 438 439 priv->adapter->mesh_connect_status = LBS_CONNECTED; 440 441 netif_carrier_on(priv->mesh_dev); 442 netif_wake_queue(priv->mesh_dev); 443 if (priv->infra_open == 0) 444 return lbs_dev_open(priv->dev) ; 445 return 0; 446} 447 448/** 449 * @brief This function opens the ethX interface 450 * 451 * @param dev A pointer to net_device structure 452 * @return 0 453 */ 454static int lbs_open(struct net_device *dev) 455{ 456 struct lbs_private *priv = (struct lbs_private *) dev->priv ; 457 458 if(pre_open_check(dev) == -1) 459 return -1; 460 priv->infra_open = 1 ; 461 netif_wake_queue(priv->dev); 462 if (priv->open == 0) 463 return lbs_dev_open(priv->dev) ; 464 return 0; 465} 466 467static int lbs_dev_close(struct net_device *dev) 468{ 469 struct lbs_private *priv = dev->priv; 470 471 lbs_deb_enter(LBS_DEB_NET); 472 473 netif_carrier_off(priv->dev); 474 priv->open = 0; 475 476 lbs_deb_leave(LBS_DEB_NET); 477 return 0; 478} 479 480/** 481 * @brief This function closes the mshX interface 482 * 483 * @param dev A pointer to net_device structure 484 * @return 0 485 */ 486static int lbs_mesh_close(struct net_device *dev) 487{ 488 struct lbs_private *priv = (struct lbs_private *) (dev->priv); 489 490 priv->mesh_open = 0; 491 netif_stop_queue(priv->mesh_dev); 492 if (priv->infra_open == 0) 493 return lbs_dev_close(dev); 494 else 495 return 0; 496} 497 498/** 499 * @brief This function closes the ethX interface 500 * 501 * @param dev A pointer to net_device structure 502 * @return 0 503 */ 504static int lbs_close(struct net_device *dev) 505{ 506 struct lbs_private *priv = (struct lbs_private *) dev->priv; 507 508 netif_stop_queue(dev); 509 priv->infra_open = 0; 510 if (priv->mesh_open == 0) 511 return lbs_dev_close(dev); 512 else 513 return 0; 514} 515 516 517static int lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 518{ 519 int ret = 0; 520 struct lbs_private *priv = dev->priv; 521 522 lbs_deb_enter(LBS_DEB_TX); 523 524 if (priv->dnld_sent || priv->adapter->TxLockFlag) { 525 priv->stats.tx_dropped++; 526 goto done; 527 } 528 529 netif_stop_queue(priv->dev); 530 if (priv->mesh_dev) 531 netif_stop_queue(priv->mesh_dev); 532 533 if (lbs_process_tx(priv, skb) == 0) 534 dev->trans_start = jiffies; 535done: 536 lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret); 537 return ret; 538} 539 540/** 541 * @brief Mark mesh packets and handover them to lbs_hard_start_xmit 542 * 543 */ 544static int lbs_mesh_pre_start_xmit(struct sk_buff *skb, 545 struct net_device *dev) 546{ 547 struct lbs_private *priv = dev->priv; 548 int ret; 549 550 lbs_deb_enter(LBS_DEB_MESH); 551 if (priv->adapter->monitormode != LBS_MONITOR_OFF) { 552 netif_stop_queue(dev); 553 return -EOPNOTSUPP; 554 } 555 556 SET_MESH_FRAME(skb); 557 558 ret = lbs_hard_start_xmit(skb, priv->mesh_dev); 559 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); 560 return ret; 561} 562 563/** 564 * @brief Mark non-mesh packets and handover them to lbs_hard_start_xmit 565 * 566 */ 567static int lbs_pre_start_xmit(struct sk_buff *skb, struct net_device *dev) 568{ 569 struct lbs_private *priv = dev->priv; 570 int ret; 571 572 lbs_deb_enter(LBS_DEB_TX); 573 574 if (priv->adapter->monitormode != LBS_MONITOR_OFF) { 575 netif_stop_queue(dev); 576 return -EOPNOTSUPP; 577 } 578 579 UNSET_MESH_FRAME(skb); 580 581 ret = lbs_hard_start_xmit(skb, dev); 582 lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret); 583 return ret; 584} 585 586static void lbs_tx_timeout(struct net_device *dev) 587{ 588 struct lbs_private *priv = (struct lbs_private *) dev->priv; 589 590 lbs_deb_enter(LBS_DEB_TX); 591 592 lbs_pr_err("tx watch dog timeout\n"); 593 594 priv->dnld_sent = DNLD_RES_RECEIVED; 595 dev->trans_start = jiffies; 596 597 if (priv->adapter->currenttxskb) { 598 if (priv->adapter->monitormode != LBS_MONITOR_OFF) { 599 /* If we are here, we have not received feedback from 600 the previous packet. Assume TX_FAIL and move on. */ 601 priv->adapter->eventcause = 0x01000000; 602 lbs_send_tx_feedback(priv); 603 } else 604 wake_up_interruptible(&priv->waitq); 605 } else if (dev == priv->dev) { 606 if (priv->adapter->connect_status == LBS_CONNECTED) 607 netif_wake_queue(priv->dev); 608 609 } else if (dev == priv->mesh_dev) { 610 if (priv->adapter->mesh_connect_status == LBS_CONNECTED) 611 netif_wake_queue(priv->mesh_dev); 612 } 613 614 lbs_deb_leave(LBS_DEB_TX); 615} 616 617void lbs_host_to_card_done(struct lbs_private *priv) 618{ 619 struct lbs_adapter *adapter = priv->adapter; 620 621 priv->dnld_sent = DNLD_RES_RECEIVED; 622 623 /* Wake main thread if commands are pending */ 624 if (!adapter->cur_cmd) 625 wake_up_interruptible(&priv->waitq); 626 627 if (priv->dev && adapter->connect_status == LBS_CONNECTED) 628 netif_wake_queue(priv->dev); 629 630 if (priv->mesh_dev && adapter->mesh_connect_status == LBS_CONNECTED) 631 netif_wake_queue(priv->mesh_dev); 632} 633EXPORT_SYMBOL_GPL(lbs_host_to_card_done); 634 635/** 636 * @brief This function returns the network statistics 637 * 638 * @param dev A pointer to struct lbs_private structure 639 * @return A pointer to net_device_stats structure 640 */ 641static struct net_device_stats *lbs_get_stats(struct net_device *dev) 642{ 643 struct lbs_private *priv = (struct lbs_private *) dev->priv; 644 645 return &priv->stats; 646} 647 648static int lbs_set_mac_address(struct net_device *dev, void *addr) 649{ 650 int ret = 0; 651 struct lbs_private *priv = (struct lbs_private *) dev->priv; 652 struct lbs_adapter *adapter = priv->adapter; 653 struct sockaddr *phwaddr = addr; 654 655 lbs_deb_enter(LBS_DEB_NET); 656 657 /* In case it was called from the mesh device */ 658 dev = priv->dev ; 659 660 memset(adapter->current_addr, 0, ETH_ALEN); 661 662 /* dev->dev_addr is 8 bytes */ 663 lbs_deb_hex(LBS_DEB_NET, "dev->dev_addr", dev->dev_addr, ETH_ALEN); 664 665 lbs_deb_hex(LBS_DEB_NET, "addr", phwaddr->sa_data, ETH_ALEN); 666 memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); 667 668 ret = lbs_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, 669 CMD_ACT_SET, 670 CMD_OPTION_WAITFORRSP, 0, NULL); 671 672 if (ret) { 673 lbs_deb_net("set MAC address failed\n"); 674 ret = -1; 675 goto done; 676 } 677 678 lbs_deb_hex(LBS_DEB_NET, "adapter->macaddr", adapter->current_addr, ETH_ALEN); 679 memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN); 680 if (priv->mesh_dev) 681 memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); 682 683done: 684 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); 685 return ret; 686} 687 688static int lbs_copy_multicast_address(struct lbs_adapter *adapter, 689 struct net_device *dev) 690{ 691 int i = 0; 692 struct dev_mc_list *mcptr = dev->mc_list; 693 694 for (i = 0; i < dev->mc_count; i++) { 695 memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); 696 mcptr = mcptr->next; 697 } 698 699 return i; 700 701} 702 703static void lbs_set_multicast_list(struct net_device *dev) 704{ 705 struct lbs_private *priv = dev->priv; 706 struct lbs_adapter *adapter = priv->adapter; 707 int oldpacketfilter; 708 DECLARE_MAC_BUF(mac); 709 710 lbs_deb_enter(LBS_DEB_NET); 711 712 oldpacketfilter = adapter->currentpacketfilter; 713 714 if (dev->flags & IFF_PROMISC) { 715 lbs_deb_net("enable promiscuous mode\n"); 716 adapter->currentpacketfilter |= 717 CMD_ACT_MAC_PROMISCUOUS_ENABLE; 718 adapter->currentpacketfilter &= 719 ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | 720 CMD_ACT_MAC_MULTICAST_ENABLE); 721 } else { 722 /* Multicast */ 723 adapter->currentpacketfilter &= 724 ~CMD_ACT_MAC_PROMISCUOUS_ENABLE; 725 726 if (dev->flags & IFF_ALLMULTI || dev->mc_count > 727 MRVDRV_MAX_MULTICAST_LIST_SIZE) { 728 lbs_deb_net( "enabling all multicast\n"); 729 adapter->currentpacketfilter |= 730 CMD_ACT_MAC_ALL_MULTICAST_ENABLE; 731 adapter->currentpacketfilter &= 732 ~CMD_ACT_MAC_MULTICAST_ENABLE; 733 } else { 734 adapter->currentpacketfilter &= 735 ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE; 736 737 if (!dev->mc_count) { 738 lbs_deb_net("no multicast addresses, " 739 "disabling multicast\n"); 740 adapter->currentpacketfilter &= 741 ~CMD_ACT_MAC_MULTICAST_ENABLE; 742 } else { 743 int i; 744 745 adapter->currentpacketfilter |= 746 CMD_ACT_MAC_MULTICAST_ENABLE; 747 748 adapter->nr_of_multicastmacaddr = 749 lbs_copy_multicast_address(adapter, dev); 750 751 lbs_deb_net("multicast addresses: %d\n", 752 dev->mc_count); 753 754 for (i = 0; i < dev->mc_count; i++) { 755 lbs_deb_net("Multicast address %d:%s\n", 756 i, print_mac(mac, 757 adapter->multicastlist[i])); 758 } 759 /* send multicast addresses to firmware */ 760 lbs_prepare_and_send_command(priv, 761 CMD_MAC_MULTICAST_ADR, 762 CMD_ACT_SET, 0, 0, 763 NULL); 764 } 765 } 766 } 767 768 if (adapter->currentpacketfilter != oldpacketfilter) { 769 lbs_set_mac_packet_filter(priv); 770 } 771 772 lbs_deb_leave(LBS_DEB_NET); 773} 774 775/** 776 * @brief This function handles the major jobs in the LBS driver. 777 * It handles all events generated by firmware, RX data received 778 * from firmware and TX data sent from kernel. 779 * 780 * @param data A pointer to lbs_thread structure 781 * @return 0 782 */ 783static int lbs_thread(void *data) 784{ 785 struct net_device *dev = data; 786 struct lbs_private *priv = dev->priv; 787 struct lbs_adapter *adapter = priv->adapter; 788 wait_queue_t wait; 789 u8 ireg = 0; 790 791 lbs_deb_enter(LBS_DEB_THREAD); 792 793 init_waitqueue_entry(&wait, current); 794 795 set_freezable(); 796 797 for (;;) { 798 lbs_deb_thread( "main-thread 111: intcounter=%d currenttxskb=%p dnld_sent=%d\n", 799 adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); 800 801 add_wait_queue(&priv->waitq, &wait); 802 set_current_state(TASK_INTERRUPTIBLE); 803 spin_lock_irq(&adapter->driver_lock); 804 805 if ((adapter->psstate == PS_STATE_SLEEP) || 806 (!adapter->intcounter && (priv->dnld_sent || adapter->cur_cmd || list_empty(&adapter->cmdpendingq)))) { 807 lbs_deb_thread("main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", 808 adapter->connect_status, adapter->intcounter, 809 adapter->psmode, adapter->psstate); 810 spin_unlock_irq(&adapter->driver_lock); 811 schedule(); 812 } else 813 spin_unlock_irq(&adapter->driver_lock); 814 815 lbs_deb_thread("main-thread 222 (waking up): intcounter=%d currenttxskb=%p dnld_sent=%d\n", 816 adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); 817 818 set_current_state(TASK_RUNNING); 819 remove_wait_queue(&priv->waitq, &wait); 820 try_to_freeze(); 821 822 lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p dnld_sent=%d\n", 823 adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); 824 825 if (kthread_should_stop() || adapter->surpriseremoved) { 826 lbs_deb_thread("main-thread: break from main thread: surpriseremoved=0x%x\n", 827 adapter->surpriseremoved); 828 break; 829 } 830 831 832 spin_lock_irq(&adapter->driver_lock); 833 834 if (adapter->intcounter) { 835 u8 int_status; 836 837 adapter->intcounter = 0; 838 int_status = priv->hw_get_int_status(priv, &ireg); 839 840 if (int_status) { 841 lbs_deb_thread("main-thread: reading HOST_INT_STATUS_REG failed\n"); 842 spin_unlock_irq(&adapter->driver_lock); 843 continue; 844 } 845 adapter->hisregcpy |= ireg; 846 } 847 848 lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p dnld_sent=%d\n", 849 adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); 850 851 /* command response? */ 852 if (adapter->hisregcpy & MRVDRV_CMD_UPLD_RDY) { 853 lbs_deb_thread("main-thread: cmd response ready\n"); 854 855 adapter->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; 856 spin_unlock_irq(&adapter->driver_lock); 857 lbs_process_rx_command(priv); 858 spin_lock_irq(&adapter->driver_lock); 859 } 860 861 /* Any Card Event */ 862 if (adapter->hisregcpy & MRVDRV_CARDEVENT) { 863 lbs_deb_thread("main-thread: Card Event Activity\n"); 864 865 adapter->hisregcpy &= ~MRVDRV_CARDEVENT; 866 867 if (priv->hw_read_event_cause(priv)) { 868 lbs_pr_alert("main-thread: hw_read_event_cause failed\n"); 869 spin_unlock_irq(&adapter->driver_lock); 870 continue; 871 } 872 spin_unlock_irq(&adapter->driver_lock); 873 lbs_process_event(priv); 874 } else 875 spin_unlock_irq(&adapter->driver_lock); 876 877 /* Check if we need to confirm Sleep Request received previously */ 878 if (adapter->psstate == PS_STATE_PRE_SLEEP && 879 !priv->dnld_sent && !adapter->cur_cmd) { 880 if (adapter->connect_status == LBS_CONNECTED) { 881 lbs_deb_thread("main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p dnld_sent=%d cur_cmd=%p, confirm now\n", 882 adapter->intcounter, adapter->currenttxskb, priv->dnld_sent, adapter->cur_cmd); 883 884 lbs_ps_confirm_sleep(priv, (u16) adapter->psmode); 885 } else { 886 /* workaround for firmware sending 887 * deauth/linkloss event immediately 888 * after sleep request; remove this 889 * after firmware fixes it 890 */ 891 adapter->psstate = PS_STATE_AWAKE; 892 lbs_pr_alert("main-thread: ignore PS_SleepConfirm in non-connected state\n"); 893 } 894 } 895 896 /* The PS state is changed during processing of Sleep Request 897 * event above 898 */ 899 if ((priv->adapter->psstate == PS_STATE_SLEEP) || 900 (priv->adapter->psstate == PS_STATE_PRE_SLEEP)) 901 continue; 902 903 /* Execute the next command */ 904 if (!priv->dnld_sent && !priv->adapter->cur_cmd) 905 lbs_execute_next_command(priv); 906 907 /* Wake-up command waiters which can't sleep in 908 * lbs_prepare_and_send_command 909 */ 910 if (!list_empty(&adapter->cmdpendingq)) 911 wake_up_all(&adapter->cmd_pending); 912 913 lbs_tx_runqueue(priv); 914 } 915 916 del_timer(&adapter->command_timer); 917 wake_up_all(&adapter->cmd_pending); 918 919 lbs_deb_leave(LBS_DEB_THREAD); 920 return 0; 921} 922 923/** 924 * @brief This function downloads firmware image, gets 925 * HW spec from firmware and set basic parameters to 926 * firmware. 927 * 928 * @param priv A pointer to struct lbs_private structure 929 * @return 0 or -1 930 */ 931static int lbs_setup_firmware(struct lbs_private *priv) 932{ 933 int ret = -1; 934 struct lbs_adapter *adapter = priv->adapter; 935 struct cmd_ds_mesh_access mesh_access; 936 937 lbs_deb_enter(LBS_DEB_FW); 938 939 /* 940 * Read MAC address from HW 941 */ 942 memset(adapter->current_addr, 0xff, ETH_ALEN); 943 944 ret = lbs_prepare_and_send_command(priv, CMD_GET_HW_SPEC, 945 0, CMD_OPTION_WAITFORRSP, 0, NULL); 946 947 if (ret) { 948 ret = -1; 949 goto done; 950 } 951 952 lbs_set_mac_packet_filter(priv); 953 954 /* Get the supported Data rates */ 955 ret = lbs_prepare_and_send_command(priv, CMD_802_11_DATA_RATE, 956 CMD_ACT_GET_TX_RATE, 957 CMD_OPTION_WAITFORRSP, 0, NULL); 958 959 if (ret) { 960 ret = -1; 961 goto done; 962 } 963 964 /* Disable mesh autostart */ 965 if (priv->mesh_dev) { 966 memset(&mesh_access, 0, sizeof(mesh_access)); 967 mesh_access.data[0] = cpu_to_le32(0); 968 ret = lbs_prepare_and_send_command(priv, 969 CMD_MESH_ACCESS, 970 CMD_ACT_MESH_SET_AUTOSTART_ENABLED, 971 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); 972 if (ret) { 973 ret = -1; 974 goto done; 975 } 976 priv->mesh_autostart_enabled = 0; 977 } 978 979 ret = 0; 980done: 981 lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); 982 return ret; 983} 984 985/** 986 * This function handles the timeout of command sending. 987 * It will re-send the same command again. 988 */ 989static void command_timer_fn(unsigned long data) 990{ 991 struct lbs_private *priv = (struct lbs_private *)data; 992 struct lbs_adapter *adapter = priv->adapter; 993 struct cmd_ctrl_node *ptempnode; 994 struct cmd_ds_command *cmd; 995 unsigned long flags; 996 997 ptempnode = adapter->cur_cmd; 998 if (ptempnode == NULL) { 999 lbs_deb_fw("ptempnode empty\n"); 1000 return; 1001 } 1002 1003 cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr; 1004 if (!cmd) { 1005 lbs_deb_fw("cmd is NULL\n"); 1006 return; 1007 } 1008 1009 lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command); 1010 1011 if (!adapter->fw_ready) 1012 return; 1013 1014 spin_lock_irqsave(&adapter->driver_lock, flags); 1015 adapter->cur_cmd = NULL; 1016 spin_unlock_irqrestore(&adapter->driver_lock, flags); 1017 1018 lbs_deb_fw("re-sending same command because of timeout\n"); 1019 lbs_queue_cmd(adapter, ptempnode, 0); 1020 1021 wake_up_interruptible(&priv->waitq); 1022 1023 return; 1024} 1025 1026static int lbs_init_adapter(struct lbs_private *priv) 1027{ 1028 struct lbs_adapter *adapter = priv->adapter; 1029 size_t bufsize; 1030 int i, ret = 0; 1031 1032 /* Allocate buffer to store the BSSID list */ 1033 bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); 1034 adapter->networks = kzalloc(bufsize, GFP_KERNEL); 1035 if (!adapter->networks) { 1036 lbs_pr_err("Out of memory allocating beacons\n"); 1037 ret = -1; 1038 goto out; 1039 } 1040 1041 /* Initialize scan result lists */ 1042 INIT_LIST_HEAD(&adapter->network_free_list); 1043 INIT_LIST_HEAD(&adapter->network_list); 1044 for (i = 0; i < MAX_NETWORK_COUNT; i++) { 1045 list_add_tail(&adapter->networks[i].list, 1046 &adapter->network_free_list); 1047 } 1048 1049 adapter->lbs_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); 1050 adapter->lbs_ps_confirm_sleep.command = 1051 cpu_to_le16(CMD_802_11_PS_MODE); 1052 adapter->lbs_ps_confirm_sleep.size = 1053 cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); 1054 adapter->lbs_ps_confirm_sleep.action = 1055 cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); 1056 1057 memset(adapter->current_addr, 0xff, ETH_ALEN); 1058 1059 adapter->connect_status = LBS_DISCONNECTED; 1060 adapter->mesh_connect_status = LBS_DISCONNECTED; 1061 adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; 1062 adapter->mode = IW_MODE_INFRA; 1063 adapter->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL; 1064 adapter->currentpacketfilter = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; 1065 adapter->radioon = RADIO_ON; 1066 adapter->auto_rate = 1; 1067 adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 1068 adapter->psmode = LBS802_11POWERMODECAM; 1069 adapter->psstate = PS_STATE_FULL_POWER; 1070 1071 mutex_init(&adapter->lock); 1072 1073 memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*)); 1074 adapter->tx_queue_idx = 0; 1075 spin_lock_init(&adapter->txqueue_lock); 1076 1077 setup_timer(&adapter->command_timer, command_timer_fn, 1078 (unsigned long)priv); 1079 1080 INIT_LIST_HEAD(&adapter->cmdfreeq); 1081 INIT_LIST_HEAD(&adapter->cmdpendingq); 1082 1083 spin_lock_init(&adapter->driver_lock); 1084 init_waitqueue_head(&adapter->cmd_pending); 1085 1086 /* Allocate the command buffers */ 1087 if (lbs_allocate_cmd_buffer(priv)) { 1088 lbs_pr_err("Out of memory allocating command buffers\n"); 1089 ret = -1; 1090 } 1091 1092out: 1093 return ret; 1094} 1095 1096static void lbs_free_adapter(struct lbs_private *priv) 1097{ 1098 struct lbs_adapter *adapter = priv->adapter; 1099 1100 if (!adapter) { 1101 lbs_deb_fw("why double free adapter?\n"); 1102 return; 1103 } 1104 1105 lbs_deb_fw("free command buffer\n"); 1106 lbs_free_cmd_buffer(priv); 1107 1108 lbs_deb_fw("free command_timer\n"); 1109 del_timer(&adapter->command_timer); 1110 1111 lbs_deb_fw("free scan results table\n"); 1112 kfree(adapter->networks); 1113 adapter->networks = NULL; 1114 1115 /* Free the adapter object itself */ 1116 lbs_deb_fw("free adapter\n"); 1117 kfree(adapter); 1118 priv->adapter = NULL; 1119} 1120 1121/** 1122 * @brief This function adds the card. it will probe the 1123 * card, allocate the lbs_priv and initialize the device. 1124 * 1125 * @param card A pointer to card 1126 * @return A pointer to struct lbs_private structure 1127 */ 1128struct lbs_private *lbs_add_card(void *card, struct device *dmdev) 1129{ 1130 struct net_device *dev = NULL; 1131 struct lbs_private *priv = NULL; 1132 1133 lbs_deb_enter(LBS_DEB_NET); 1134 1135 /* Allocate an Ethernet device and register it */ 1136 dev = alloc_etherdev(sizeof(struct lbs_private)); 1137 if (!dev) { 1138 lbs_pr_err("init ethX device failed\n"); 1139 goto done; 1140 } 1141 priv = dev->priv; 1142 1143 /* allocate buffer for struct lbs_adapter */ 1144 priv->adapter = kzalloc(sizeof(struct lbs_adapter), GFP_KERNEL); 1145 if (!priv->adapter) { 1146 lbs_pr_err("allocate buffer for struct lbs_adapter failed\n"); 1147 goto err_kzalloc; 1148 } 1149 1150 if (lbs_init_adapter(priv)) { 1151 lbs_pr_err("failed to initialize adapter structure.\n"); 1152 goto err_init_adapter; 1153 } 1154 1155 priv->dev = dev; 1156 priv->card = card; 1157 priv->mesh_open = 0; 1158 priv->infra_open = 0; 1159 1160 /* Setup the OS Interface to our functions */ 1161 dev->open = lbs_open; 1162 dev->hard_start_xmit = lbs_pre_start_xmit; 1163 dev->stop = lbs_close; 1164 dev->set_mac_address = lbs_set_mac_address; 1165 dev->tx_timeout = lbs_tx_timeout; 1166 dev->get_stats = lbs_get_stats; 1167 dev->watchdog_timeo = 5 * HZ; 1168 dev->ethtool_ops = &lbs_ethtool_ops; 1169#ifdef WIRELESS_EXT 1170 dev->wireless_handlers = (struct iw_handler_def *)&lbs_handler_def; 1171#endif 1172 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 1173 dev->set_multicast_list = lbs_set_multicast_list; 1174 1175 SET_NETDEV_DEV(dev, dmdev); 1176 1177 priv->rtap_net_dev = NULL; 1178 1179 lbs_deb_thread("Starting main thread...\n"); 1180 init_waitqueue_head(&priv->waitq); 1181 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); 1182 if (IS_ERR(priv->main_thread)) { 1183 lbs_deb_thread("Error creating main thread.\n"); 1184 goto err_init_adapter; 1185 } 1186 1187 priv->work_thread = create_singlethread_workqueue("lbs_worker"); 1188 INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); 1189 INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); 1190 INIT_WORK(&priv->sync_channel, lbs_sync_channel); 1191 1192 goto done; 1193 1194err_init_adapter: 1195 lbs_free_adapter(priv); 1196 1197err_kzalloc: 1198 free_netdev(dev); 1199 priv = NULL; 1200 1201done: 1202 lbs_deb_leave_args(LBS_DEB_NET, "priv %p", priv); 1203 return priv; 1204} 1205EXPORT_SYMBOL_GPL(lbs_add_card); 1206 1207 1208int lbs_remove_card(struct lbs_private *priv) 1209{ 1210 struct lbs_adapter *adapter = priv->adapter; 1211 struct net_device *dev = priv->dev; 1212 union iwreq_data wrqu; 1213 1214 lbs_deb_enter(LBS_DEB_MAIN); 1215 1216 lbs_remove_rtap(priv); 1217 1218 dev = priv->dev; 1219 device_remove_file(&dev->dev, &dev_attr_lbs_rtap); 1220 1221 cancel_delayed_work(&priv->scan_work); 1222 cancel_delayed_work(&priv->assoc_work); 1223 destroy_workqueue(priv->work_thread); 1224 1225 if (adapter->psmode == LBS802_11POWERMODEMAX_PSP) { 1226 adapter->psmode = LBS802_11POWERMODECAM; 1227 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); 1228 } 1229 1230 memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); 1231 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 1232 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); 1233 1234 /* Stop the thread servicing the interrupts */ 1235 adapter->surpriseremoved = 1; 1236 kthread_stop(priv->main_thread); 1237 1238 lbs_free_adapter(priv); 1239 1240 priv->dev = NULL; 1241 free_netdev(dev); 1242 1243 lbs_deb_leave(LBS_DEB_MAIN); 1244 return 0; 1245} 1246EXPORT_SYMBOL_GPL(lbs_remove_card); 1247 1248 1249int lbs_start_card(struct lbs_private *priv) 1250{ 1251 struct net_device *dev = priv->dev; 1252 int ret = -1; 1253 1254 lbs_deb_enter(LBS_DEB_MAIN); 1255 1256 /* poke the firmware */ 1257 ret = lbs_setup_firmware(priv); 1258 if (ret) 1259 goto done; 1260 1261 /* init 802.11d */ 1262 lbs_init_11d(priv); 1263 1264 if (register_netdev(dev)) { 1265 lbs_pr_err("cannot register ethX device\n"); 1266 goto done; 1267 } 1268 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) 1269 lbs_pr_err("cannot register lbs_rtap attribute\n"); 1270 1271 lbs_debugfs_init_one(priv, dev); 1272 1273 lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); 1274 1275 ret = 0; 1276 1277done: 1278 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1279 return ret; 1280} 1281EXPORT_SYMBOL_GPL(lbs_start_card); 1282 1283 1284int lbs_stop_card(struct lbs_private *priv) 1285{ 1286 struct net_device *dev = priv->dev; 1287 int ret = -1; 1288 struct cmd_ctrl_node *cmdnode; 1289 unsigned long flags; 1290 1291 lbs_deb_enter(LBS_DEB_MAIN); 1292 1293 netif_stop_queue(priv->dev); 1294 netif_carrier_off(priv->dev); 1295 1296 lbs_debugfs_remove_one(priv); 1297 1298 /* Flush pending command nodes */ 1299 spin_lock_irqsave(&priv->adapter->driver_lock, flags); 1300 list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) { 1301 cmdnode->cmdwaitqwoken = 1; 1302 wake_up_interruptible(&cmdnode->cmdwait_q); 1303 } 1304 spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); 1305 1306 unregister_netdev(dev); 1307 1308 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1309 return ret; 1310} 1311EXPORT_SYMBOL_GPL(lbs_stop_card); 1312 1313 1314/** 1315 * @brief This function adds mshX interface 1316 * 1317 * @param priv A pointer to the struct lbs_private structure 1318 * @return 0 if successful, -X otherwise 1319 */ 1320int lbs_add_mesh(struct lbs_private *priv, struct device *dev) 1321{ 1322 struct net_device *mesh_dev = NULL; 1323 int ret = 0; 1324 1325 lbs_deb_enter(LBS_DEB_MESH); 1326 1327 /* Allocate a virtual mesh device */ 1328 if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) { 1329 lbs_deb_mesh("init mshX device failed\n"); 1330 ret = -ENOMEM; 1331 goto done; 1332 } 1333 mesh_dev->priv = priv; 1334 priv->mesh_dev = mesh_dev; 1335 1336 mesh_dev->open = lbs_mesh_open; 1337 mesh_dev->hard_start_xmit = lbs_mesh_pre_start_xmit; 1338 mesh_dev->stop = lbs_mesh_close; 1339 mesh_dev->get_stats = lbs_get_stats; 1340 mesh_dev->set_mac_address = lbs_set_mac_address; 1341 mesh_dev->ethtool_ops = &lbs_ethtool_ops; 1342 memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, 1343 sizeof(priv->dev->dev_addr)); 1344 1345 SET_NETDEV_DEV(priv->mesh_dev, dev); 1346 1347#ifdef WIRELESS_EXT 1348 mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def; 1349#endif 1350 /* Register virtual mesh interface */ 1351 ret = register_netdev(mesh_dev); 1352 if (ret) { 1353 lbs_pr_err("cannot register mshX virtual interface\n"); 1354 goto err_free; 1355 } 1356 1357 ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group); 1358 if (ret) 1359 goto err_unregister; 1360 1361 /* Everything successful */ 1362 ret = 0; 1363 goto done; 1364 1365err_unregister: 1366 unregister_netdev(mesh_dev); 1367 1368err_free: 1369 free_netdev(mesh_dev); 1370 1371done: 1372 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); 1373 return ret; 1374} 1375EXPORT_SYMBOL_GPL(lbs_add_mesh); 1376 1377 1378void lbs_remove_mesh(struct lbs_private *priv) 1379{ 1380 struct net_device *mesh_dev; 1381 1382 lbs_deb_enter(LBS_DEB_MAIN); 1383 1384 if (!priv) 1385 goto out; 1386 1387 mesh_dev = priv->mesh_dev; 1388 1389 netif_stop_queue(mesh_dev); 1390 netif_carrier_off(priv->mesh_dev); 1391 1392 sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group); 1393 unregister_netdev(mesh_dev); 1394 1395 priv->mesh_dev = NULL ; 1396 free_netdev(mesh_dev); 1397 1398out: 1399 lbs_deb_leave(LBS_DEB_MAIN); 1400} 1401EXPORT_SYMBOL_GPL(lbs_remove_mesh); 1402 1403/** 1404 * @brief This function finds the CFP in 1405 * region_cfp_table based on region and band parameter. 1406 * 1407 * @param region The region code 1408 * @param band The band 1409 * @param cfp_no A pointer to CFP number 1410 * @return A pointer to CFP 1411 */ 1412struct chan_freq_power *lbs_get_region_cfp_table(u8 region, u8 band, int *cfp_no) 1413{ 1414 int i, end; 1415 1416 lbs_deb_enter(LBS_DEB_MAIN); 1417 1418 end = ARRAY_SIZE(region_cfp_table); 1419 1420 for (i = 0; i < end ; i++) { 1421 lbs_deb_main("region_cfp_table[i].region=%d\n", 1422 region_cfp_table[i].region); 1423 if (region_cfp_table[i].region == region) { 1424 *cfp_no = region_cfp_table[i].cfp_no_BG; 1425 lbs_deb_leave(LBS_DEB_MAIN); 1426 return region_cfp_table[i].cfp_BG; 1427 } 1428 } 1429 1430 lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL"); 1431 return NULL; 1432} 1433 1434int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band) 1435{ 1436 struct lbs_adapter *adapter = priv->adapter; 1437 int ret = 0; 1438 int i = 0; 1439 1440 struct chan_freq_power *cfp; 1441 int cfp_no; 1442 1443 lbs_deb_enter(LBS_DEB_MAIN); 1444 1445 memset(adapter->region_channel, 0, sizeof(adapter->region_channel)); 1446 1447 { 1448 cfp = lbs_get_region_cfp_table(region, band, &cfp_no); 1449 if (cfp != NULL) { 1450 adapter->region_channel[i].nrcfp = cfp_no; 1451 adapter->region_channel[i].CFP = cfp; 1452 } else { 1453 lbs_deb_main("wrong region code %#x in band B/G\n", 1454 region); 1455 ret = -1; 1456 goto out; 1457 } 1458 adapter->region_channel[i].valid = 1; 1459 adapter->region_channel[i].region = region; 1460 adapter->region_channel[i].band = band; 1461 i++; 1462 } 1463out: 1464 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1465 return ret; 1466} 1467 1468/** 1469 * @brief This function handles the interrupt. it will change PS 1470 * state if applicable. it will wake up main_thread to handle 1471 * the interrupt event as well. 1472 * 1473 * @param dev A pointer to net_device structure 1474 * @return n/a 1475 */ 1476void lbs_interrupt(struct net_device *dev) 1477{ 1478 struct lbs_private *priv = dev->priv; 1479 1480 lbs_deb_enter(LBS_DEB_THREAD); 1481 1482 lbs_deb_thread("lbs_interrupt: intcounter=%d\n", 1483 priv->adapter->intcounter); 1484 1485 priv->adapter->intcounter++; 1486 1487 if (priv->adapter->psstate == PS_STATE_SLEEP) { 1488 priv->adapter->psstate = PS_STATE_AWAKE; 1489 netif_wake_queue(dev); 1490 if (priv->mesh_dev) 1491 netif_wake_queue(priv->mesh_dev); 1492 } 1493 1494 wake_up_interruptible(&priv->waitq); 1495 1496 lbs_deb_leave(LBS_DEB_THREAD); 1497} 1498EXPORT_SYMBOL_GPL(lbs_interrupt); 1499 1500int lbs_reset_device(struct lbs_private *priv) 1501{ 1502 int ret; 1503 1504 lbs_deb_enter(LBS_DEB_MAIN); 1505 ret = lbs_prepare_and_send_command(priv, CMD_802_11_RESET, 1506 CMD_ACT_HALT, 0, 0, NULL); 1507 msleep_interruptible(10); 1508 1509 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); 1510 return ret; 1511} 1512EXPORT_SYMBOL_GPL(lbs_reset_device); 1513 1514static int __init lbs_init_module(void) 1515{ 1516 lbs_deb_enter(LBS_DEB_MAIN); 1517 lbs_debugfs_init(); 1518 lbs_deb_leave(LBS_DEB_MAIN); 1519 return 0; 1520} 1521 1522static void __exit lbs_exit_module(void) 1523{ 1524 lbs_deb_enter(LBS_DEB_MAIN); 1525 1526 lbs_debugfs_remove(); 1527 1528 lbs_deb_leave(LBS_DEB_MAIN); 1529} 1530 1531/* 1532 * rtap interface support fuctions 1533 */ 1534 1535static int lbs_rtap_open(struct net_device *dev) 1536{ 1537 netif_carrier_off(dev); 1538 netif_stop_queue(dev); 1539 return 0; 1540} 1541 1542static int lbs_rtap_stop(struct net_device *dev) 1543{ 1544 return 0; 1545} 1546 1547static int lbs_rtap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 1548{ 1549 netif_stop_queue(dev); 1550 return -EOPNOTSUPP; 1551} 1552 1553static struct net_device_stats *lbs_rtap_get_stats(struct net_device *dev) 1554{ 1555 struct lbs_private *priv = dev->priv; 1556 return &priv->ieee->stats; 1557} 1558 1559 1560void lbs_remove_rtap(struct lbs_private *priv) 1561{ 1562 if (priv->rtap_net_dev == NULL) 1563 return; 1564 unregister_netdev(priv->rtap_net_dev); 1565 free_ieee80211(priv->rtap_net_dev); 1566 priv->rtap_net_dev = NULL; 1567} 1568 1569int lbs_add_rtap(struct lbs_private *priv) 1570{ 1571 int rc = 0; 1572 1573 if (priv->rtap_net_dev) 1574 return -EPERM; 1575 1576 priv->rtap_net_dev = alloc_ieee80211(0); 1577 if (priv->rtap_net_dev == NULL) 1578 return -ENOMEM; 1579 1580 1581 priv->ieee = netdev_priv(priv->rtap_net_dev); 1582 1583 strcpy(priv->rtap_net_dev->name, "rtap%d"); 1584 1585 priv->rtap_net_dev->type = ARPHRD_IEEE80211_RADIOTAP; 1586 priv->rtap_net_dev->open = lbs_rtap_open; 1587 priv->rtap_net_dev->stop = lbs_rtap_stop; 1588 priv->rtap_net_dev->get_stats = lbs_rtap_get_stats; 1589 priv->rtap_net_dev->hard_start_xmit = lbs_rtap_hard_start_xmit; 1590 priv->rtap_net_dev->set_multicast_list = lbs_set_multicast_list; 1591 priv->rtap_net_dev->priv = priv; 1592 1593 priv->ieee->iw_mode = IW_MODE_MONITOR; 1594 1595 rc = register_netdev(priv->rtap_net_dev); 1596 if (rc) { 1597 free_ieee80211(priv->rtap_net_dev); 1598 priv->rtap_net_dev = NULL; 1599 return rc; 1600 } 1601 1602 return 0; 1603} 1604 1605 1606module_init(lbs_init_module); 1607module_exit(lbs_exit_module); 1608 1609MODULE_DESCRIPTION("Libertas WLAN Driver Library"); 1610MODULE_AUTHOR("Marvell International Ltd."); 1611MODULE_LICENSE("GPL"); 1612