1 // SPDX-License-Identifier: (GPL-2.0 OR MPL-1.1) 2 /* 3 * 4 * Implements the station functionality for prism2 5 * 6 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved. 7 * -------------------------------------------------------------------- 8 * 9 * linux-wlan 10 * 11 * The contents of this file are subject to the Mozilla Public 12 * License Version 1.1 (the "License"); you may not use this file 13 * except in compliance with the License. You may obtain a copy of 14 * the License at http://www.mozilla.org/MPL/ 15 * 16 * Software distributed under the License is distributed on an "AS 17 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 18 * implied. See the License for the specific language governing 19 * rights and limitations under the License. 20 * 21 * Alternatively, the contents of this file may be used under the 22 * terms of the GNU Public License version 2 (the "GPL"), in which 23 * case the provisions of the GPL are applicable instead of the 24 * above. If you wish to allow the use of your version of this file 25 * only under the terms of the GPL and not to allow others to use 26 * your version of this file under the MPL, indicate your decision 27 * by deleting the provisions above and replace them with the notice 28 * and other provisions required by the GPL. If you do not delete 29 * the provisions above, a recipient may use your version of this 30 * file under either the MPL or the GPL. 31 * 32 * -------------------------------------------------------------------- 33 * 34 * Inquiries regarding the linux-wlan Open Source project can be 35 * made directly to: 36 * 37 * AbsoluteValue Systems Inc. 38 * info@linux-wlan.com 39 * http://www.linux-wlan.com 40 * 41 * -------------------------------------------------------------------- 42 * 43 * Portions of the development of this software were funded by 44 * Intersil Corporation as part of PRISM(R) chipset product development. 45 * 46 * -------------------------------------------------------------------- 47 * 48 * This file implements the module and linux pcmcia routines for the 49 * prism2 driver. 50 * 51 * -------------------------------------------------------------------- 52 */ 53 54 #include <linux/module.h> 55 #include <linux/kernel.h> 56 #include <linux/sched.h> 57 #include <linux/types.h> 58 #include <linux/slab.h> 59 #include <linux/wireless.h> 60 #include <linux/netdevice.h> 61 #include <linux/workqueue.h> 62 #include <linux/byteorder/generic.h> 63 #include <linux/etherdevice.h> 64 65 #include <linux/io.h> 66 #include <linux/delay.h> 67 #include <asm/byteorder.h> 68 #include <linux/if_arp.h> 69 #include <linux/if_ether.h> 70 #include <linux/bitops.h> 71 72 #include "p80211types.h" 73 #include "p80211hdr.h" 74 #include "p80211mgmt.h" 75 #include "p80211conv.h" 76 #include "p80211msg.h" 77 #include "p80211netdev.h" 78 #include "p80211req.h" 79 #include "p80211metadef.h" 80 #include "p80211metastruct.h" 81 #include "hfa384x.h" 82 #include "prism2mgmt.h" 83 84 static char *dev_info = "prism2_usb"; 85 static struct wlandevice *create_wlan(void); 86 87 int prism2_reset_holdtime = 30; /* Reset hold time in ms */ 88 int prism2_reset_settletime = 100; /* Reset settle time in ms */ 89 90 static int prism2_doreset; /* Do a reset at init? */ 91 92 module_param(prism2_doreset, int, 0644); 93 MODULE_PARM_DESC(prism2_doreset, "Issue a reset on initialization"); 94 95 module_param(prism2_reset_holdtime, int, 0644); 96 MODULE_PARM_DESC(prism2_reset_holdtime, "reset hold time in ms"); 97 module_param(prism2_reset_settletime, int, 0644); 98 MODULE_PARM_DESC(prism2_reset_settletime, "reset settle time in ms"); 99 100 MODULE_LICENSE("Dual MPL/GPL"); 101 102 static int prism2sta_open(struct wlandevice *wlandev); 103 static int prism2sta_close(struct wlandevice *wlandev); 104 static void prism2sta_reset(struct wlandevice *wlandev); 105 static int prism2sta_txframe(struct wlandevice *wlandev, struct sk_buff *skb, 106 struct p80211_hdr *p80211_hdr, 107 struct p80211_metawep *p80211_wep); 108 static int prism2sta_mlmerequest(struct wlandevice *wlandev, 109 struct p80211msg *msg); 110 static int prism2sta_getcardinfo(struct wlandevice *wlandev); 111 static int prism2sta_globalsetup(struct wlandevice *wlandev); 112 static int prism2sta_setmulticast(struct wlandevice *wlandev, 113 struct net_device *dev); 114 115 static void prism2sta_inf_handover(struct wlandevice *wlandev, 116 struct hfa384x_inf_frame *inf); 117 static void prism2sta_inf_tallies(struct wlandevice *wlandev, 118 struct hfa384x_inf_frame *inf); 119 static void prism2sta_inf_hostscanresults(struct wlandevice *wlandev, 120 struct hfa384x_inf_frame *inf); 121 static void prism2sta_inf_scanresults(struct wlandevice *wlandev, 122 struct hfa384x_inf_frame *inf); 123 static void prism2sta_inf_chinforesults(struct wlandevice *wlandev, 124 struct hfa384x_inf_frame *inf); 125 static void prism2sta_inf_linkstatus(struct wlandevice *wlandev, 126 struct hfa384x_inf_frame *inf); 127 static void prism2sta_inf_assocstatus(struct wlandevice *wlandev, 128 struct hfa384x_inf_frame *inf); 129 static void prism2sta_inf_authreq(struct wlandevice *wlandev, 130 struct hfa384x_inf_frame *inf); 131 static void prism2sta_inf_authreq_defer(struct wlandevice *wlandev, 132 struct hfa384x_inf_frame *inf); 133 static void prism2sta_inf_psusercnt(struct wlandevice *wlandev, 134 struct hfa384x_inf_frame *inf); 135 136 /* 137 * prism2sta_open 138 * 139 * WLAN device open method. Called from p80211netdev when kernel 140 * device open (start) method is called in response to the 141 * SIOCSIIFFLAGS ioctl changing the flags bit IFF_UP 142 * from clear to set. 143 * 144 * Arguments: 145 * wlandev wlan device structure 146 * 147 * Returns: 148 * 0 success 149 * >0 f/w reported error 150 * <0 driver reported error 151 * 152 * Side effects: 153 * 154 * Call context: 155 * process thread 156 */ 157 static int prism2sta_open(struct wlandevice *wlandev) 158 { 159 /* We don't currently have to do anything else. 160 * The setup of the MAC should be subsequently completed via 161 * the mlme commands. 162 * Higher layers know we're ready from dev->start==1 and 163 * dev->tbusy==0. Our rx path knows to pass up received/ 164 * frames because of dev->flags&IFF_UP is true. 165 */ 166 167 return 0; 168 } 169 170 /* 171 * prism2sta_close 172 * 173 * WLAN device close method. Called from p80211netdev when kernel 174 * device close method is called in response to the 175 * SIOCSIIFFLAGS ioctl changing the flags bit IFF_UP 176 * from set to clear. 177 * 178 * Arguments: 179 * wlandev wlan device structure 180 * 181 * Returns: 182 * 0 success 183 * >0 f/w reported error 184 * <0 driver reported error 185 * 186 * Side effects: 187 * 188 * Call context: 189 * process thread 190 */ 191 static int prism2sta_close(struct wlandevice *wlandev) 192 { 193 /* We don't currently have to do anything else. 194 * Higher layers know we're not ready from dev->start==0 and 195 * dev->tbusy==1. Our rx path knows to not pass up received 196 * frames because of dev->flags&IFF_UP is false. 197 */ 198 199 return 0; 200 } 201 202 /* 203 * prism2sta_reset 204 * 205 * Currently not implemented. 206 * 207 * Arguments: 208 * wlandev wlan device structure 209 * none 210 * 211 * Returns: 212 * nothing 213 * 214 * Side effects: 215 * 216 * Call context: 217 * process thread 218 */ 219 static void prism2sta_reset(struct wlandevice *wlandev) 220 { 221 } 222 223 /* 224 * prism2sta_txframe 225 * 226 * Takes a frame from p80211 and queues it for transmission. 227 * 228 * Arguments: 229 * wlandev wlan device structure 230 * pb packet buffer struct. Contains an 802.11 231 * data frame. 232 * p80211_hdr points to the 802.11 header for the packet. 233 * Returns: 234 * 0 Success and more buffs available 235 * 1 Success but no more buffs 236 * 2 Allocation failure 237 * 4 Buffer full or queue busy 238 * 239 * Side effects: 240 * 241 * Call context: 242 * process thread 243 */ 244 static int prism2sta_txframe(struct wlandevice *wlandev, struct sk_buff *skb, 245 struct p80211_hdr *p80211_hdr, 246 struct p80211_metawep *p80211_wep) 247 { 248 struct hfa384x *hw = wlandev->priv; 249 250 /* If necessary, set the 802.11 WEP bit */ 251 if ((wlandev->hostwep & (HOSTWEP_PRIVACYINVOKED | HOSTWEP_ENCRYPT)) == 252 HOSTWEP_PRIVACYINVOKED) { 253 p80211_hdr->frame_control |= cpu_to_le16(WLAN_SET_FC_ISWEP(1)); 254 } 255 256 return hfa384x_drvr_txframe(hw, skb, p80211_hdr, p80211_wep); 257 } 258 259 /* 260 * prism2sta_mlmerequest 261 * 262 * wlan command message handler. All we do here is pass the message 263 * over to the prism2sta_mgmt_handler. 264 * 265 * Arguments: 266 * wlandev wlan device structure 267 * msg wlan command message 268 * Returns: 269 * 0 success 270 * <0 successful acceptance of message, but we're 271 * waiting for an async process to finish before 272 * we're done with the msg. When the asynch 273 * process is done, we'll call the p80211 274 * function p80211req_confirm() . 275 * >0 An error occurred while we were handling 276 * the message. 277 * 278 * Side effects: 279 * 280 * Call context: 281 * process thread 282 */ 283 static int prism2sta_mlmerequest(struct wlandevice *wlandev, 284 struct p80211msg *msg) 285 { 286 struct hfa384x *hw = wlandev->priv; 287 288 int result = 0; 289 290 switch (msg->msgcode) { 291 case DIDMSG_DOT11REQ_MIBGET: 292 pr_debug("Received mibget request\n"); 293 result = prism2mgmt_mibset_mibget(wlandev, msg); 294 break; 295 case DIDMSG_DOT11REQ_MIBSET: 296 pr_debug("Received mibset request\n"); 297 result = prism2mgmt_mibset_mibget(wlandev, msg); 298 break; 299 case DIDMSG_DOT11REQ_SCAN: 300 pr_debug("Received scan request\n"); 301 result = prism2mgmt_scan(wlandev, msg); 302 break; 303 case DIDMSG_DOT11REQ_SCAN_RESULTS: 304 pr_debug("Received scan_results request\n"); 305 result = prism2mgmt_scan_results(wlandev, msg); 306 break; 307 case DIDMSG_DOT11REQ_START: 308 pr_debug("Received mlme start request\n"); 309 result = prism2mgmt_start(wlandev, msg); 310 break; 311 /* 312 * Prism2 specific messages 313 */ 314 case DIDMSG_P2REQ_READPDA: 315 pr_debug("Received mlme readpda request\n"); 316 result = prism2mgmt_readpda(wlandev, msg); 317 break; 318 case DIDMSG_P2REQ_RAMDL_STATE: 319 pr_debug("Received mlme ramdl_state request\n"); 320 result = prism2mgmt_ramdl_state(wlandev, msg); 321 break; 322 case DIDMSG_P2REQ_RAMDL_WRITE: 323 pr_debug("Received mlme ramdl_write request\n"); 324 result = prism2mgmt_ramdl_write(wlandev, msg); 325 break; 326 case DIDMSG_P2REQ_FLASHDL_STATE: 327 pr_debug("Received mlme flashdl_state request\n"); 328 result = prism2mgmt_flashdl_state(wlandev, msg); 329 break; 330 case DIDMSG_P2REQ_FLASHDL_WRITE: 331 pr_debug("Received mlme flashdl_write request\n"); 332 result = prism2mgmt_flashdl_write(wlandev, msg); 333 break; 334 /* 335 * Linux specific messages 336 */ 337 case DIDMSG_LNXREQ_HOSTWEP: 338 break; /* ignore me. */ 339 case DIDMSG_LNXREQ_IFSTATE: { 340 struct p80211msg_lnxreq_ifstate *ifstatemsg; 341 342 pr_debug("Received mlme ifstate request\n"); 343 ifstatemsg = (struct p80211msg_lnxreq_ifstate *)msg; 344 result = prism2sta_ifstate(wlandev, 345 ifstatemsg->ifstate.data); 346 ifstatemsg->resultcode.status = 347 P80211ENUM_msgitem_status_data_ok; 348 ifstatemsg->resultcode.data = result; 349 result = 0; 350 break; 351 } 352 case DIDMSG_LNXREQ_WLANSNIFF: 353 pr_debug("Received mlme wlansniff request\n"); 354 result = prism2mgmt_wlansniff(wlandev, msg); 355 break; 356 case DIDMSG_LNXREQ_AUTOJOIN: 357 pr_debug("Received mlme autojoin request\n"); 358 result = prism2mgmt_autojoin(wlandev, msg); 359 break; 360 case DIDMSG_LNXREQ_COMMSQUALITY: { 361 struct p80211msg_lnxreq_commsquality *qualmsg; 362 363 pr_debug("Received commsquality request\n"); 364 365 qualmsg = (struct p80211msg_lnxreq_commsquality *)msg; 366 367 qualmsg->link.status = P80211ENUM_msgitem_status_data_ok; 368 qualmsg->level.status = P80211ENUM_msgitem_status_data_ok; 369 qualmsg->noise.status = P80211ENUM_msgitem_status_data_ok; 370 371 qualmsg->link.data = le16_to_cpu(hw->qual.cq_curr_bss); 372 qualmsg->level.data = le16_to_cpu(hw->qual.asl_curr_bss); 373 qualmsg->noise.data = le16_to_cpu(hw->qual.anl_curr_fc); 374 qualmsg->txrate.data = hw->txrate; 375 376 break; 377 } 378 default: 379 netdev_warn(wlandev->netdev, 380 "Unknown mgmt request message 0x%08x", 381 msg->msgcode); 382 break; 383 } 384 385 return result; 386 } 387 388 /* 389 * prism2sta_ifstate 390 * 391 * Interface state. This is the primary WLAN interface enable/disable 392 * handler. Following the driver/load/deviceprobe sequence, this 393 * function must be called with a state of "enable" before any other 394 * commands will be accepted. 395 * 396 * Arguments: 397 * wlandev wlan device structure 398 * msgp ptr to msg buffer 399 * 400 * Returns: 401 * A p80211 message resultcode value. 402 * 403 * Side effects: 404 * 405 * Call context: 406 * process thread (usually) 407 * interrupt 408 */ 409 u32 prism2sta_ifstate(struct wlandevice *wlandev, u32 ifstate) 410 { 411 struct hfa384x *hw = wlandev->priv; 412 u32 result; 413 414 result = P80211ENUM_resultcode_implementation_failure; 415 416 pr_debug("Current MSD state(%d), requesting(%d)\n", 417 wlandev->msdstate, ifstate); 418 switch (ifstate) { 419 case P80211ENUM_ifstate_fwload: 420 switch (wlandev->msdstate) { 421 case WLAN_MSD_HWPRESENT: 422 wlandev->msdstate = WLAN_MSD_FWLOAD_PENDING; 423 /* 424 * Initialize the device+driver sufficiently 425 * for firmware loading. 426 */ 427 result = hfa384x_drvr_start(hw); 428 if (result) { 429 netdev_err(wlandev->netdev, 430 "hfa384x_drvr_start() failed,result=%d\n", 431 (int)result); 432 result = 433 P80211ENUM_resultcode_implementation_failure; 434 wlandev->msdstate = WLAN_MSD_HWPRESENT; 435 break; 436 } 437 wlandev->msdstate = WLAN_MSD_FWLOAD; 438 result = P80211ENUM_resultcode_success; 439 break; 440 case WLAN_MSD_FWLOAD: 441 hfa384x_cmd_initialize(hw); 442 result = P80211ENUM_resultcode_success; 443 break; 444 case WLAN_MSD_RUNNING: 445 netdev_warn(wlandev->netdev, 446 "Cannot enter fwload state from enable state, you must disable first.\n"); 447 result = P80211ENUM_resultcode_invalid_parameters; 448 break; 449 case WLAN_MSD_HWFAIL: 450 default: 451 /* probe() had a problem or the msdstate contains 452 * an unrecognized value, there's nothing we can do. 453 */ 454 result = P80211ENUM_resultcode_implementation_failure; 455 break; 456 } 457 break; 458 case P80211ENUM_ifstate_enable: 459 switch (wlandev->msdstate) { 460 case WLAN_MSD_HWPRESENT: 461 case WLAN_MSD_FWLOAD: 462 wlandev->msdstate = WLAN_MSD_RUNNING_PENDING; 463 /* Initialize the device+driver for full 464 * operation. Note that this might me an FWLOAD 465 * to RUNNING transition so we must not do a chip 466 * or board level reset. Note that on failure, 467 * the MSD state is set to HWPRESENT because we 468 * can't make any assumptions about the state 469 * of the hardware or a previous firmware load. 470 */ 471 result = hfa384x_drvr_start(hw); 472 if (result) { 473 netdev_err(wlandev->netdev, 474 "hfa384x_drvr_start() failed,result=%d\n", 475 (int)result); 476 result = 477 P80211ENUM_resultcode_implementation_failure; 478 wlandev->msdstate = WLAN_MSD_HWPRESENT; 479 break; 480 } 481 482 result = prism2sta_getcardinfo(wlandev); 483 if (result) { 484 netdev_err(wlandev->netdev, 485 "prism2sta_getcardinfo() failed,result=%d\n", 486 (int)result); 487 result = 488 P80211ENUM_resultcode_implementation_failure; 489 hfa384x_drvr_stop(hw); 490 wlandev->msdstate = WLAN_MSD_HWPRESENT; 491 break; 492 } 493 result = prism2sta_globalsetup(wlandev); 494 if (result) { 495 netdev_err(wlandev->netdev, 496 "prism2sta_globalsetup() failed,result=%d\n", 497 (int)result); 498 result = 499 P80211ENUM_resultcode_implementation_failure; 500 hfa384x_drvr_stop(hw); 501 wlandev->msdstate = WLAN_MSD_HWPRESENT; 502 break; 503 } 504 wlandev->msdstate = WLAN_MSD_RUNNING; 505 hw->join_ap = 0; 506 hw->join_retries = 60; 507 result = P80211ENUM_resultcode_success; 508 break; 509 case WLAN_MSD_RUNNING: 510 /* Do nothing, we're already in this state. */ 511 result = P80211ENUM_resultcode_success; 512 break; 513 case WLAN_MSD_HWFAIL: 514 default: 515 /* probe() had a problem or the msdstate contains 516 * an unrecognized value, there's nothing we can do. 517 */ 518 result = P80211ENUM_resultcode_implementation_failure; 519 break; 520 } 521 break; 522 case P80211ENUM_ifstate_disable: 523 switch (wlandev->msdstate) { 524 case WLAN_MSD_HWPRESENT: 525 /* Do nothing, we're already in this state. */ 526 result = P80211ENUM_resultcode_success; 527 break; 528 case WLAN_MSD_FWLOAD: 529 case WLAN_MSD_RUNNING: 530 wlandev->msdstate = WLAN_MSD_HWPRESENT_PENDING; 531 /* 532 * TODO: Shut down the MAC completely. Here a chip 533 * or board level reset is probably called for. 534 * After a "disable" _all_ results are lost, even 535 * those from a fwload. 536 */ 537 if (!wlandev->hwremoved) 538 netif_carrier_off(wlandev->netdev); 539 540 hfa384x_drvr_stop(hw); 541 542 wlandev->macmode = WLAN_MACMODE_NONE; 543 wlandev->msdstate = WLAN_MSD_HWPRESENT; 544 result = P80211ENUM_resultcode_success; 545 break; 546 case WLAN_MSD_HWFAIL: 547 default: 548 /* probe() had a problem or the msdstate contains 549 * an unrecognized value, there's nothing we can do. 550 */ 551 result = P80211ENUM_resultcode_implementation_failure; 552 break; 553 } 554 break; 555 default: 556 result = P80211ENUM_resultcode_invalid_parameters; 557 break; 558 } 559 560 return result; 561 } 562 563 /* 564 * prism2sta_getcardinfo 565 * 566 * Collect the NICID, firmware version and any other identifiers 567 * we'd like to have in host-side data structures. 568 * 569 * Arguments: 570 * wlandev wlan device structure 571 * 572 * Returns: 573 * 0 success 574 * >0 f/w reported error 575 * <0 driver reported error 576 * 577 * Side effects: 578 * 579 * Call context: 580 * Either. 581 */ 582 static int prism2sta_getcardinfo(struct wlandevice *wlandev) 583 { 584 int result = 0; 585 struct hfa384x *hw = wlandev->priv; 586 u16 temp; 587 u8 snum[HFA384x_RID_NICSERIALNUMBER_LEN]; 588 u8 addr[ETH_ALEN]; 589 590 /* Collect version and compatibility info */ 591 /* Some are critical, some are not */ 592 /* NIC identity */ 593 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_NICIDENTITY, 594 &hw->ident_nic, 595 sizeof(struct hfa384x_compident)); 596 if (result) { 597 netdev_err(wlandev->netdev, "Failed to retrieve NICIDENTITY\n"); 598 goto failed; 599 } 600 601 /* get all the nic id fields in host byte order */ 602 le16_to_cpus(&hw->ident_nic.id); 603 le16_to_cpus(&hw->ident_nic.variant); 604 le16_to_cpus(&hw->ident_nic.major); 605 le16_to_cpus(&hw->ident_nic.minor); 606 607 netdev_info(wlandev->netdev, "ident: nic h/w: id=0x%02x %d.%d.%d\n", 608 hw->ident_nic.id, hw->ident_nic.major, 609 hw->ident_nic.minor, hw->ident_nic.variant); 610 611 /* Primary f/w identity */ 612 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_PRIIDENTITY, 613 &hw->ident_pri_fw, 614 sizeof(struct hfa384x_compident)); 615 if (result) { 616 netdev_err(wlandev->netdev, "Failed to retrieve PRIIDENTITY\n"); 617 goto failed; 618 } 619 620 /* get all the private fw id fields in host byte order */ 621 le16_to_cpus(&hw->ident_pri_fw.id); 622 le16_to_cpus(&hw->ident_pri_fw.variant); 623 le16_to_cpus(&hw->ident_pri_fw.major); 624 le16_to_cpus(&hw->ident_pri_fw.minor); 625 626 netdev_info(wlandev->netdev, "ident: pri f/w: id=0x%02x %d.%d.%d\n", 627 hw->ident_pri_fw.id, hw->ident_pri_fw.major, 628 hw->ident_pri_fw.minor, hw->ident_pri_fw.variant); 629 630 /* Station (Secondary?) f/w identity */ 631 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_STAIDENTITY, 632 &hw->ident_sta_fw, 633 sizeof(struct hfa384x_compident)); 634 if (result) { 635 netdev_err(wlandev->netdev, "Failed to retrieve STAIDENTITY\n"); 636 goto failed; 637 } 638 639 if (hw->ident_nic.id < 0x8000) { 640 netdev_err(wlandev->netdev, 641 "FATAL: Card is not an Intersil Prism2/2.5/3\n"); 642 result = -1; 643 goto failed; 644 } 645 646 /* get all the station fw id fields in host byte order */ 647 le16_to_cpus(&hw->ident_sta_fw.id); 648 le16_to_cpus(&hw->ident_sta_fw.variant); 649 le16_to_cpus(&hw->ident_sta_fw.major); 650 le16_to_cpus(&hw->ident_sta_fw.minor); 651 652 /* strip out the 'special' variant bits */ 653 hw->mm_mods = hw->ident_sta_fw.variant & GENMASK(15, 14); 654 hw->ident_sta_fw.variant &= ~((u16)GENMASK(15, 14)); 655 656 if (hw->ident_sta_fw.id == 0x1f) { 657 netdev_info(wlandev->netdev, 658 "ident: sta f/w: id=0x%02x %d.%d.%d\n", 659 hw->ident_sta_fw.id, hw->ident_sta_fw.major, 660 hw->ident_sta_fw.minor, hw->ident_sta_fw.variant); 661 } else { 662 netdev_info(wlandev->netdev, 663 "ident: ap f/w: id=0x%02x %d.%d.%d\n", 664 hw->ident_sta_fw.id, hw->ident_sta_fw.major, 665 hw->ident_sta_fw.minor, hw->ident_sta_fw.variant); 666 netdev_err(wlandev->netdev, "Unsupported Tertiary AP firmware loaded!\n"); 667 goto failed; 668 } 669 670 /* Compatibility range, Modem supplier */ 671 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_MFISUPRANGE, 672 &hw->cap_sup_mfi, 673 sizeof(struct hfa384x_caplevel)); 674 if (result) { 675 netdev_err(wlandev->netdev, "Failed to retrieve MFISUPRANGE\n"); 676 goto failed; 677 } 678 679 /* get all the Compatibility range, modem interface supplier 680 * fields in byte order 681 */ 682 le16_to_cpus(&hw->cap_sup_mfi.role); 683 le16_to_cpus(&hw->cap_sup_mfi.id); 684 le16_to_cpus(&hw->cap_sup_mfi.variant); 685 le16_to_cpus(&hw->cap_sup_mfi.bottom); 686 le16_to_cpus(&hw->cap_sup_mfi.top); 687 688 netdev_info(wlandev->netdev, 689 "MFI:SUP:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 690 hw->cap_sup_mfi.role, hw->cap_sup_mfi.id, 691 hw->cap_sup_mfi.variant, hw->cap_sup_mfi.bottom, 692 hw->cap_sup_mfi.top); 693 694 /* Compatibility range, Controller supplier */ 695 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_CFISUPRANGE, 696 &hw->cap_sup_cfi, 697 sizeof(struct hfa384x_caplevel)); 698 if (result) { 699 netdev_err(wlandev->netdev, "Failed to retrieve CFISUPRANGE\n"); 700 goto failed; 701 } 702 703 /* get all the Compatibility range, controller interface supplier 704 * fields in byte order 705 */ 706 le16_to_cpus(&hw->cap_sup_cfi.role); 707 le16_to_cpus(&hw->cap_sup_cfi.id); 708 le16_to_cpus(&hw->cap_sup_cfi.variant); 709 le16_to_cpus(&hw->cap_sup_cfi.bottom); 710 le16_to_cpus(&hw->cap_sup_cfi.top); 711 712 netdev_info(wlandev->netdev, 713 "CFI:SUP:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 714 hw->cap_sup_cfi.role, hw->cap_sup_cfi.id, 715 hw->cap_sup_cfi.variant, hw->cap_sup_cfi.bottom, 716 hw->cap_sup_cfi.top); 717 718 /* Compatibility range, Primary f/w supplier */ 719 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_PRISUPRANGE, 720 &hw->cap_sup_pri, 721 sizeof(struct hfa384x_caplevel)); 722 if (result) { 723 netdev_err(wlandev->netdev, "Failed to retrieve PRISUPRANGE\n"); 724 goto failed; 725 } 726 727 /* get all the Compatibility range, primary firmware supplier 728 * fields in byte order 729 */ 730 le16_to_cpus(&hw->cap_sup_pri.role); 731 le16_to_cpus(&hw->cap_sup_pri.id); 732 le16_to_cpus(&hw->cap_sup_pri.variant); 733 le16_to_cpus(&hw->cap_sup_pri.bottom); 734 le16_to_cpus(&hw->cap_sup_pri.top); 735 736 netdev_info(wlandev->netdev, 737 "PRI:SUP:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 738 hw->cap_sup_pri.role, hw->cap_sup_pri.id, 739 hw->cap_sup_pri.variant, hw->cap_sup_pri.bottom, 740 hw->cap_sup_pri.top); 741 742 /* Compatibility range, Station f/w supplier */ 743 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_STASUPRANGE, 744 &hw->cap_sup_sta, 745 sizeof(struct hfa384x_caplevel)); 746 if (result) { 747 netdev_err(wlandev->netdev, "Failed to retrieve STASUPRANGE\n"); 748 goto failed; 749 } 750 751 /* get all the Compatibility range, station firmware supplier 752 * fields in byte order 753 */ 754 le16_to_cpus(&hw->cap_sup_sta.role); 755 le16_to_cpus(&hw->cap_sup_sta.id); 756 le16_to_cpus(&hw->cap_sup_sta.variant); 757 le16_to_cpus(&hw->cap_sup_sta.bottom); 758 le16_to_cpus(&hw->cap_sup_sta.top); 759 760 if (hw->cap_sup_sta.id == 0x04) { 761 netdev_info(wlandev->netdev, 762 "STA:SUP:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 763 hw->cap_sup_sta.role, hw->cap_sup_sta.id, 764 hw->cap_sup_sta.variant, hw->cap_sup_sta.bottom, 765 hw->cap_sup_sta.top); 766 } else { 767 netdev_info(wlandev->netdev, 768 "AP:SUP:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 769 hw->cap_sup_sta.role, hw->cap_sup_sta.id, 770 hw->cap_sup_sta.variant, hw->cap_sup_sta.bottom, 771 hw->cap_sup_sta.top); 772 } 773 774 /* Compatibility range, primary f/w actor, CFI supplier */ 775 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_PRI_CFIACTRANGES, 776 &hw->cap_act_pri_cfi, 777 sizeof(struct hfa384x_caplevel)); 778 if (result) { 779 netdev_err(wlandev->netdev, "Failed to retrieve PRI_CFIACTRANGES\n"); 780 goto failed; 781 } 782 783 /* get all the Compatibility range, primary f/w actor, CFI supplier 784 * fields in byte order 785 */ 786 le16_to_cpus(&hw->cap_act_pri_cfi.role); 787 le16_to_cpus(&hw->cap_act_pri_cfi.id); 788 le16_to_cpus(&hw->cap_act_pri_cfi.variant); 789 le16_to_cpus(&hw->cap_act_pri_cfi.bottom); 790 le16_to_cpus(&hw->cap_act_pri_cfi.top); 791 792 netdev_info(wlandev->netdev, 793 "PRI-CFI:ACT:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 794 hw->cap_act_pri_cfi.role, hw->cap_act_pri_cfi.id, 795 hw->cap_act_pri_cfi.variant, hw->cap_act_pri_cfi.bottom, 796 hw->cap_act_pri_cfi.top); 797 798 /* Compatibility range, sta f/w actor, CFI supplier */ 799 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_STA_CFIACTRANGES, 800 &hw->cap_act_sta_cfi, 801 sizeof(struct hfa384x_caplevel)); 802 if (result) { 803 netdev_err(wlandev->netdev, "Failed to retrieve STA_CFIACTRANGES\n"); 804 goto failed; 805 } 806 807 /* get all the Compatibility range, station f/w actor, CFI supplier 808 * fields in byte order 809 */ 810 le16_to_cpus(&hw->cap_act_sta_cfi.role); 811 le16_to_cpus(&hw->cap_act_sta_cfi.id); 812 le16_to_cpus(&hw->cap_act_sta_cfi.variant); 813 le16_to_cpus(&hw->cap_act_sta_cfi.bottom); 814 le16_to_cpus(&hw->cap_act_sta_cfi.top); 815 816 netdev_info(wlandev->netdev, 817 "STA-CFI:ACT:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 818 hw->cap_act_sta_cfi.role, hw->cap_act_sta_cfi.id, 819 hw->cap_act_sta_cfi.variant, hw->cap_act_sta_cfi.bottom, 820 hw->cap_act_sta_cfi.top); 821 822 /* Compatibility range, sta f/w actor, MFI supplier */ 823 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_STA_MFIACTRANGES, 824 &hw->cap_act_sta_mfi, 825 sizeof(struct hfa384x_caplevel)); 826 if (result) { 827 netdev_err(wlandev->netdev, "Failed to retrieve STA_MFIACTRANGES\n"); 828 goto failed; 829 } 830 831 /* get all the Compatibility range, station f/w actor, MFI supplier 832 * fields in byte order 833 */ 834 le16_to_cpus(&hw->cap_act_sta_mfi.role); 835 le16_to_cpus(&hw->cap_act_sta_mfi.id); 836 le16_to_cpus(&hw->cap_act_sta_mfi.variant); 837 le16_to_cpus(&hw->cap_act_sta_mfi.bottom); 838 le16_to_cpus(&hw->cap_act_sta_mfi.top); 839 840 netdev_info(wlandev->netdev, 841 "STA-MFI:ACT:role=0x%02x:id=0x%02x:var=0x%02x:b/t=%d/%d\n", 842 hw->cap_act_sta_mfi.role, hw->cap_act_sta_mfi.id, 843 hw->cap_act_sta_mfi.variant, hw->cap_act_sta_mfi.bottom, 844 hw->cap_act_sta_mfi.top); 845 846 /* Serial Number */ 847 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_NICSERIALNUMBER, 848 snum, HFA384x_RID_NICSERIALNUMBER_LEN); 849 if (!result) { 850 netdev_info(wlandev->netdev, "Prism2 card SN: %*pE\n", 851 HFA384x_RID_NICSERIALNUMBER_LEN, snum); 852 } else { 853 netdev_err(wlandev->netdev, "Failed to retrieve Prism2 Card SN\n"); 854 goto failed; 855 } 856 857 /* Collect the MAC address */ 858 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_CNFOWNMACADDR, 859 addr, ETH_ALEN); 860 if (result != 0) { 861 netdev_err(wlandev->netdev, "Failed to retrieve mac address\n"); 862 goto failed; 863 } 864 eth_hw_addr_set(wlandev->netdev, addr); 865 866 /* short preamble is always implemented */ 867 wlandev->nsdcaps |= P80211_NSDCAP_SHORT_PREAMBLE; 868 869 /* find out if hardware wep is implemented */ 870 hfa384x_drvr_getconfig16(hw, HFA384x_RID_PRIVACYOPTIMP, &temp); 871 if (temp) 872 wlandev->nsdcaps |= P80211_NSDCAP_HARDWAREWEP; 873 874 /* get the dBm Scaling constant */ 875 hfa384x_drvr_getconfig16(hw, HFA384x_RID_CNFDBMADJUST, &temp); 876 hw->dbmadjust = temp; 877 878 /* Only enable scan by default on newer firmware */ 879 if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major, 880 hw->ident_sta_fw.minor, 881 hw->ident_sta_fw.variant) < 882 HFA384x_FIRMWARE_VERSION(1, 5, 5)) { 883 wlandev->nsdcaps |= P80211_NSDCAP_NOSCAN; 884 } 885 886 /* TODO: Set any internally managed config items */ 887 888 goto done; 889 failed: 890 netdev_err(wlandev->netdev, "Failed, result=%d\n", result); 891 done: 892 return result; 893 } 894 895 /* 896 * prism2sta_globalsetup 897 * 898 * Set any global RIDs that we want to set at device activation. 899 * 900 * Arguments: 901 * wlandev wlan device structure 902 * 903 * Returns: 904 * 0 success 905 * >0 f/w reported error 906 * <0 driver reported error 907 * 908 * Side effects: 909 * 910 * Call context: 911 * process thread 912 */ 913 static int prism2sta_globalsetup(struct wlandevice *wlandev) 914 { 915 struct hfa384x *hw = wlandev->priv; 916 917 /* Set the maximum frame size */ 918 return hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFMAXDATALEN, 919 WLAN_DATA_MAXLEN); 920 } 921 922 static int prism2sta_setmulticast(struct wlandevice *wlandev, 923 struct net_device *dev) 924 { 925 int result = 0; 926 struct hfa384x *hw = wlandev->priv; 927 928 u16 promisc; 929 930 /* If we're not ready, what's the point? */ 931 if (hw->state != HFA384x_STATE_RUNNING) 932 goto exit; 933 934 if ((dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 935 promisc = P80211ENUM_truth_true; 936 else 937 promisc = P80211ENUM_truth_false; 938 939 result = 940 hfa384x_drvr_setconfig16_async(hw, HFA384x_RID_PROMISCMODE, 941 promisc); 942 exit: 943 return result; 944 } 945 946 /* 947 * prism2sta_inf_handover 948 * 949 * Handles the receipt of a Handover info frame. Should only be present 950 * in APs only. 951 * 952 * Arguments: 953 * wlandev wlan device structure 954 * inf ptr to info frame (contents in hfa384x order) 955 * 956 * Returns: 957 * nothing 958 * 959 * Side effects: 960 * 961 * Call context: 962 * interrupt 963 */ 964 static void prism2sta_inf_handover(struct wlandevice *wlandev, 965 struct hfa384x_inf_frame *inf) 966 { 967 pr_debug("received infoframe:HANDOVER (unhandled)\n"); 968 } 969 970 /* 971 * prism2sta_inf_tallies 972 * 973 * Handles the receipt of a CommTallies info frame. 974 * 975 * Arguments: 976 * wlandev wlan device structure 977 * inf ptr to info frame (contents in hfa384x order) 978 * 979 * Returns: 980 * nothing 981 * 982 * Side effects: 983 * 984 * Call context: 985 * interrupt 986 */ 987 static void prism2sta_inf_tallies(struct wlandevice *wlandev, 988 struct hfa384x_inf_frame *inf) 989 { 990 struct hfa384x *hw = wlandev->priv; 991 __le16 *src16; 992 u32 *dst; 993 __le32 *src32; 994 int i; 995 int cnt; 996 997 /* 998 * Determine if these are 16-bit or 32-bit tallies, based on the 999 * record length of the info record. 1000 */ 1001 1002 cnt = sizeof(struct hfa384x_comm_tallies_32) / sizeof(u32); 1003 if (inf->framelen > 22) { 1004 dst = (u32 *)&hw->tallies; 1005 src32 = (__le32 *)&inf->info.commtallies32; 1006 for (i = 0; i < cnt; i++, dst++, src32++) 1007 *dst += le32_to_cpu(*src32); 1008 } else { 1009 dst = (u32 *)&hw->tallies; 1010 src16 = (__le16 *)&inf->info.commtallies16; 1011 for (i = 0; i < cnt; i++, dst++, src16++) 1012 *dst += le16_to_cpu(*src16); 1013 } 1014 } 1015 1016 /* 1017 * prism2sta_inf_scanresults 1018 * 1019 * Handles the receipt of a Scan Results info frame. 1020 * 1021 * Arguments: 1022 * wlandev wlan device structure 1023 * inf ptr to info frame (contents in hfa384x order) 1024 * 1025 * Returns: 1026 * nothing 1027 * 1028 * Side effects: 1029 * 1030 * Call context: 1031 * interrupt 1032 */ 1033 static void prism2sta_inf_scanresults(struct wlandevice *wlandev, 1034 struct hfa384x_inf_frame *inf) 1035 { 1036 struct hfa384x *hw = wlandev->priv; 1037 int nbss; 1038 struct hfa384x_scan_result *sr = &inf->info.scanresult; 1039 int i; 1040 struct hfa384x_join_request_data joinreq; 1041 int result; 1042 1043 /* Get the number of results, first in bytes, then in results */ 1044 nbss = (inf->framelen * sizeof(u16)) - 1045 sizeof(inf->infotype) - sizeof(inf->info.scanresult.scanreason); 1046 nbss /= sizeof(struct hfa384x_scan_result_sub); 1047 1048 /* Print em */ 1049 pr_debug("rx scanresults, reason=%d, nbss=%d:\n", 1050 inf->info.scanresult.scanreason, nbss); 1051 for (i = 0; i < nbss; i++) { 1052 pr_debug("chid=%d anl=%d sl=%d bcnint=%d\n", 1053 sr->result[i].chid, 1054 sr->result[i].anl, 1055 sr->result[i].sl, sr->result[i].bcnint); 1056 pr_debug(" capinfo=0x%04x proberesp_rate=%d\n", 1057 sr->result[i].capinfo, sr->result[i].proberesp_rate); 1058 } 1059 /* issue a join request */ 1060 joinreq.channel = sr->result[0].chid; 1061 memcpy(joinreq.bssid, sr->result[0].bssid, WLAN_BSSID_LEN); 1062 result = hfa384x_drvr_setconfig(hw, 1063 HFA384x_RID_JOINREQUEST, 1064 &joinreq, HFA384x_RID_JOINREQUEST_LEN); 1065 if (result) { 1066 netdev_err(wlandev->netdev, "setconfig(joinreq) failed, result=%d\n", 1067 result); 1068 } 1069 } 1070 1071 /* 1072 * prism2sta_inf_hostscanresults 1073 * 1074 * Handles the receipt of a Scan Results info frame. 1075 * 1076 * Arguments: 1077 * wlandev wlan device structure 1078 * inf ptr to info frame (contents in hfa384x order) 1079 * 1080 * Returns: 1081 * nothing 1082 * 1083 * Side effects: 1084 * 1085 * Call context: 1086 * interrupt 1087 */ 1088 static void prism2sta_inf_hostscanresults(struct wlandevice *wlandev, 1089 struct hfa384x_inf_frame *inf) 1090 { 1091 struct hfa384x *hw = wlandev->priv; 1092 int nbss; 1093 1094 nbss = (inf->framelen - 3) / 32; 1095 pr_debug("Received %d hostscan results\n", nbss); 1096 1097 if (nbss > 32) 1098 nbss = 32; 1099 1100 kfree(hw->scanresults); 1101 1102 hw->scanresults = kmemdup(inf, sizeof(*inf), GFP_ATOMIC); 1103 1104 if (nbss == 0) 1105 nbss = -1; 1106 1107 /* Notify/wake the sleeping caller. */ 1108 hw->scanflag = nbss; 1109 wake_up_interruptible(&hw->cmdq); 1110 }; 1111 1112 /* 1113 * prism2sta_inf_chinforesults 1114 * 1115 * Handles the receipt of a Channel Info Results info frame. 1116 * 1117 * Arguments: 1118 * wlandev wlan device structure 1119 * inf ptr to info frame (contents in hfa384x order) 1120 * 1121 * Returns: 1122 * nothing 1123 * 1124 * Side effects: 1125 * 1126 * Call context: 1127 * interrupt 1128 */ 1129 static void prism2sta_inf_chinforesults(struct wlandevice *wlandev, 1130 struct hfa384x_inf_frame *inf) 1131 { 1132 struct hfa384x *hw = wlandev->priv; 1133 unsigned int i, n; 1134 1135 hw->channel_info.results.scanchannels = 1136 inf->info.chinforesult.scanchannels; 1137 1138 for (i = 0, n = 0; i < HFA384x_CHINFORESULT_MAX; i++) { 1139 struct hfa384x_ch_info_result_sub *result; 1140 struct hfa384x_ch_info_result_sub *chinforesult; 1141 int chan; 1142 1143 if (!(hw->channel_info.results.scanchannels & (1 << i))) 1144 continue; 1145 1146 result = &inf->info.chinforesult.result[n]; 1147 chan = result->chid - 1; 1148 1149 if (chan < 0 || chan >= HFA384x_CHINFORESULT_MAX) 1150 continue; 1151 1152 chinforesult = &hw->channel_info.results.result[chan]; 1153 chinforesult->chid = chan; 1154 chinforesult->anl = result->anl; 1155 chinforesult->pnl = result->pnl; 1156 chinforesult->active = result->active; 1157 1158 pr_debug("chinfo: channel %d, %s level (avg/peak)=%d/%d dB, pcf %d\n", 1159 chan + 1, 1160 (chinforesult->active & HFA384x_CHINFORESULT_BSSACTIVE) 1161 ? "signal" : "noise", 1162 chinforesult->anl, chinforesult->pnl, 1163 (chinforesult->active & HFA384x_CHINFORESULT_PCFACTIVE) 1164 ? 1 : 0); 1165 n++; 1166 } 1167 atomic_set(&hw->channel_info.done, 2); 1168 1169 hw->channel_info.count = n; 1170 } 1171 1172 void prism2sta_processing_defer(struct work_struct *data) 1173 { 1174 struct hfa384x *hw = container_of(data, struct hfa384x, link_bh); 1175 struct wlandevice *wlandev = hw->wlandev; 1176 struct hfa384x_bytestr32 ssid; 1177 int result; 1178 1179 /* First let's process the auth frames */ 1180 { 1181 struct sk_buff *skb; 1182 struct hfa384x_inf_frame *inf; 1183 1184 while ((skb = skb_dequeue(&hw->authq))) { 1185 inf = (struct hfa384x_inf_frame *)skb->data; 1186 prism2sta_inf_authreq_defer(wlandev, inf); 1187 } 1188 } 1189 1190 /* Now let's handle the linkstatus stuff */ 1191 if (hw->link_status == hw->link_status_new) 1192 return; 1193 1194 hw->link_status = hw->link_status_new; 1195 1196 switch (hw->link_status) { 1197 case HFA384x_LINK_NOTCONNECTED: 1198 /* I'm currently assuming that this is the initial link 1199 * state. It should only be possible immediately 1200 * following an Enable command. 1201 * Response: 1202 * Block Transmits, Ignore receives of data frames 1203 */ 1204 netif_carrier_off(wlandev->netdev); 1205 1206 netdev_info(wlandev->netdev, "linkstatus=NOTCONNECTED (unhandled)\n"); 1207 break; 1208 1209 case HFA384x_LINK_CONNECTED: 1210 /* This one indicates a successful scan/join/auth/assoc. 1211 * When we have the full MLME complement, this event will 1212 * signify successful completion of both mlme_authenticate 1213 * and mlme_associate. State management will get a little 1214 * ugly here. 1215 * Response: 1216 * Indicate authentication and/or association 1217 * Enable Transmits, Receives and pass up data frames 1218 */ 1219 1220 netif_carrier_on(wlandev->netdev); 1221 1222 /* If we are joining a specific AP, set our 1223 * state and reset retries 1224 */ 1225 if (hw->join_ap == 1) 1226 hw->join_ap = 2; 1227 hw->join_retries = 60; 1228 1229 /* Don't call this in monitor mode */ 1230 if (wlandev->netdev->type == ARPHRD_ETHER) { 1231 u16 portstatus; 1232 1233 netdev_info(wlandev->netdev, "linkstatus=CONNECTED\n"); 1234 1235 /* For non-usb devices, we can use the sync versions */ 1236 /* Collect the BSSID, and set state to allow tx */ 1237 1238 result = hfa384x_drvr_getconfig(hw, 1239 HFA384x_RID_CURRENTBSSID, 1240 wlandev->bssid, 1241 WLAN_BSSID_LEN); 1242 if (result) { 1243 pr_debug 1244 ("getconfig(0x%02x) failed, result = %d\n", 1245 HFA384x_RID_CURRENTBSSID, result); 1246 return; 1247 } 1248 1249 result = hfa384x_drvr_getconfig(hw, 1250 HFA384x_RID_CURRENTSSID, 1251 &ssid, sizeof(ssid)); 1252 if (result) { 1253 pr_debug 1254 ("getconfig(0x%02x) failed, result = %d\n", 1255 HFA384x_RID_CURRENTSSID, result); 1256 return; 1257 } 1258 prism2mgmt_bytestr2pstr((struct hfa384x_bytestr *)&ssid, 1259 (struct p80211pstrd *)&wlandev->ssid); 1260 1261 /* Collect the port status */ 1262 result = hfa384x_drvr_getconfig16(hw, 1263 HFA384x_RID_PORTSTATUS, 1264 &portstatus); 1265 if (result) { 1266 pr_debug 1267 ("getconfig(0x%02x) failed, result = %d\n", 1268 HFA384x_RID_PORTSTATUS, result); 1269 return; 1270 } 1271 wlandev->macmode = 1272 (portstatus == HFA384x_PSTATUS_CONN_IBSS) ? 1273 WLAN_MACMODE_IBSS_STA : WLAN_MACMODE_ESS_STA; 1274 1275 /* signal back up to cfg80211 layer */ 1276 prism2_connect_result(wlandev, P80211ENUM_truth_false); 1277 1278 /* Get the ball rolling on the comms quality stuff */ 1279 prism2sta_commsqual_defer(&hw->commsqual_bh); 1280 } 1281 break; 1282 1283 case HFA384x_LINK_DISCONNECTED: 1284 /* This one indicates that our association is gone. We've 1285 * lost connection with the AP and/or been disassociated. 1286 * This indicates that the MAC has completely cleared it's 1287 * associated state. We * should send a deauth indication 1288 * (implying disassoc) up * to the MLME. 1289 * Response: 1290 * Indicate Deauthentication 1291 * Block Transmits, Ignore receives of data frames 1292 */ 1293 if (wlandev->netdev->type == ARPHRD_ETHER) 1294 netdev_info(wlandev->netdev, 1295 "linkstatus=DISCONNECTED (unhandled)\n"); 1296 wlandev->macmode = WLAN_MACMODE_NONE; 1297 1298 netif_carrier_off(wlandev->netdev); 1299 1300 /* signal back up to cfg80211 layer */ 1301 prism2_disconnected(wlandev); 1302 1303 break; 1304 1305 case HFA384x_LINK_AP_CHANGE: 1306 /* This one indicates that the MAC has decided to and 1307 * successfully completed a change to another AP. We 1308 * should probably implement a reassociation indication 1309 * in response to this one. I'm thinking that the 1310 * p80211 layer needs to be notified in case of 1311 * buffering/queueing issues. User mode also needs to be 1312 * notified so that any BSS dependent elements can be 1313 * updated. 1314 * associated state. We * should send a deauth indication 1315 * (implying disassoc) up * to the MLME. 1316 * Response: 1317 * Indicate Reassociation 1318 * Enable Transmits, Receives and pass up data frames 1319 */ 1320 netdev_info(wlandev->netdev, "linkstatus=AP_CHANGE\n"); 1321 1322 result = hfa384x_drvr_getconfig(hw, 1323 HFA384x_RID_CURRENTBSSID, 1324 wlandev->bssid, WLAN_BSSID_LEN); 1325 if (result) { 1326 pr_debug("getconfig(0x%02x) failed, result = %d\n", 1327 HFA384x_RID_CURRENTBSSID, result); 1328 return; 1329 } 1330 1331 result = hfa384x_drvr_getconfig(hw, 1332 HFA384x_RID_CURRENTSSID, 1333 &ssid, sizeof(ssid)); 1334 if (result) { 1335 pr_debug("getconfig(0x%02x) failed, result = %d\n", 1336 HFA384x_RID_CURRENTSSID, result); 1337 return; 1338 } 1339 prism2mgmt_bytestr2pstr((struct hfa384x_bytestr *)&ssid, 1340 (struct p80211pstrd *)&wlandev->ssid); 1341 1342 hw->link_status = HFA384x_LINK_CONNECTED; 1343 netif_carrier_on(wlandev->netdev); 1344 1345 /* signal back up to cfg80211 layer */ 1346 prism2_roamed(wlandev); 1347 1348 break; 1349 1350 case HFA384x_LINK_AP_OUTOFRANGE: 1351 /* This one indicates that the MAC has decided that the 1352 * AP is out of range, but hasn't found a better candidate 1353 * so the MAC maintains its "associated" state in case 1354 * we get back in range. We should block transmits and 1355 * receives in this state. Do we need an indication here? 1356 * Probably not since a polling user-mode element would 1357 * get this status from p2PortStatus(FD40). What about 1358 * p80211? 1359 * Response: 1360 * Block Transmits, Ignore receives of data frames 1361 */ 1362 netdev_info(wlandev->netdev, "linkstatus=AP_OUTOFRANGE (unhandled)\n"); 1363 1364 netif_carrier_off(wlandev->netdev); 1365 1366 break; 1367 1368 case HFA384x_LINK_AP_INRANGE: 1369 /* This one indicates that the MAC has decided that the 1370 * AP is back in range. We continue working with our 1371 * existing association. 1372 * Response: 1373 * Enable Transmits, Receives and pass up data frames 1374 */ 1375 netdev_info(wlandev->netdev, "linkstatus=AP_INRANGE\n"); 1376 1377 hw->link_status = HFA384x_LINK_CONNECTED; 1378 netif_carrier_on(wlandev->netdev); 1379 1380 break; 1381 1382 case HFA384x_LINK_ASSOCFAIL: 1383 /* This one is actually a peer to CONNECTED. We've 1384 * requested a join for a given SSID and optionally BSSID. 1385 * We can use this one to indicate authentication and 1386 * association failures. The trick is going to be 1387 * 1) identifying the failure, and 2) state management. 1388 * Response: 1389 * Disable Transmits, Ignore receives of data frames 1390 */ 1391 if (hw->join_ap && --hw->join_retries > 0) { 1392 struct hfa384x_join_request_data joinreq; 1393 1394 joinreq = hw->joinreq; 1395 /* Send the join request */ 1396 hfa384x_drvr_setconfig(hw, 1397 HFA384x_RID_JOINREQUEST, 1398 &joinreq, 1399 HFA384x_RID_JOINREQUEST_LEN); 1400 netdev_info(wlandev->netdev, 1401 "linkstatus=ASSOCFAIL (re-submitting join)\n"); 1402 } else { 1403 netdev_info(wlandev->netdev, "linkstatus=ASSOCFAIL (unhandled)\n"); 1404 } 1405 1406 netif_carrier_off(wlandev->netdev); 1407 1408 /* signal back up to cfg80211 layer */ 1409 prism2_connect_result(wlandev, P80211ENUM_truth_true); 1410 1411 break; 1412 1413 default: 1414 /* This is bad, IO port problems? */ 1415 netdev_warn(wlandev->netdev, 1416 "unknown linkstatus=0x%02x\n", hw->link_status); 1417 return; 1418 } 1419 1420 wlandev->linkstatus = (hw->link_status == HFA384x_LINK_CONNECTED); 1421 } 1422 1423 /* 1424 * prism2sta_inf_linkstatus 1425 * 1426 * Handles the receipt of a Link Status info frame. 1427 * 1428 * Arguments: 1429 * wlandev wlan device structure 1430 * inf ptr to info frame (contents in hfa384x order) 1431 * 1432 * Returns: 1433 * nothing 1434 * 1435 * Side effects: 1436 * 1437 * Call context: 1438 * interrupt 1439 */ 1440 static void prism2sta_inf_linkstatus(struct wlandevice *wlandev, 1441 struct hfa384x_inf_frame *inf) 1442 { 1443 struct hfa384x *hw = wlandev->priv; 1444 1445 hw->link_status_new = le16_to_cpu(inf->info.linkstatus.linkstatus); 1446 1447 schedule_work(&hw->link_bh); 1448 } 1449 1450 /* 1451 * prism2sta_inf_assocstatus 1452 * 1453 * Handles the receipt of an Association Status info frame. Should 1454 * be present in APs only. 1455 * 1456 * Arguments: 1457 * wlandev wlan device structure 1458 * inf ptr to info frame (contents in hfa384x order) 1459 * 1460 * Returns: 1461 * nothing 1462 * 1463 * Side effects: 1464 * 1465 * Call context: 1466 * interrupt 1467 */ 1468 static void prism2sta_inf_assocstatus(struct wlandevice *wlandev, 1469 struct hfa384x_inf_frame *inf) 1470 { 1471 struct hfa384x *hw = wlandev->priv; 1472 struct hfa384x_assoc_status rec; 1473 int i; 1474 1475 memcpy(&rec, &inf->info.assocstatus, sizeof(rec)); 1476 le16_to_cpus(&rec.assocstatus); 1477 le16_to_cpus(&rec.reason); 1478 1479 /* 1480 * Find the address in the list of authenticated stations. 1481 * If it wasn't found, then this address has not been previously 1482 * authenticated and something weird has happened if this is 1483 * anything other than an "authentication failed" message. 1484 * If the address was found, then set the "associated" flag for 1485 * that station, based on whether the station is associating or 1486 * losing its association. Something weird has also happened 1487 * if we find the address in the list of authenticated stations 1488 * but we are getting an "authentication failed" message. 1489 */ 1490 1491 for (i = 0; i < hw->authlist.cnt; i++) 1492 if (ether_addr_equal(rec.sta_addr, hw->authlist.addr[i])) 1493 break; 1494 1495 if (i >= hw->authlist.cnt) { 1496 if (rec.assocstatus != HFA384x_ASSOCSTATUS_AUTHFAIL) 1497 netdev_warn(wlandev->netdev, 1498 "assocstatus info frame received for non-authenticated station.\n"); 1499 } else { 1500 hw->authlist.assoc[i] = 1501 (rec.assocstatus == HFA384x_ASSOCSTATUS_STAASSOC || 1502 rec.assocstatus == HFA384x_ASSOCSTATUS_REASSOC); 1503 1504 if (rec.assocstatus == HFA384x_ASSOCSTATUS_AUTHFAIL) 1505 netdev_warn(wlandev->netdev, 1506 "authfail assocstatus info frame received for authenticated station.\n"); 1507 } 1508 } 1509 1510 /* 1511 * prism2sta_inf_authreq 1512 * 1513 * Handles the receipt of an Authentication Request info frame. Should 1514 * be present in APs only. 1515 * 1516 * Arguments: 1517 * wlandev wlan device structure 1518 * inf ptr to info frame (contents in hfa384x order) 1519 * 1520 * Returns: 1521 * nothing 1522 * 1523 * Side effects: 1524 * 1525 * Call context: 1526 * interrupt 1527 * 1528 */ 1529 static void prism2sta_inf_authreq(struct wlandevice *wlandev, 1530 struct hfa384x_inf_frame *inf) 1531 { 1532 struct hfa384x *hw = wlandev->priv; 1533 struct sk_buff *skb; 1534 1535 skb = dev_alloc_skb(sizeof(*inf)); 1536 if (skb) { 1537 skb_put(skb, sizeof(*inf)); 1538 memcpy(skb->data, inf, sizeof(*inf)); 1539 skb_queue_tail(&hw->authq, skb); 1540 schedule_work(&hw->link_bh); 1541 } 1542 } 1543 1544 static void prism2sta_inf_authreq_defer(struct wlandevice *wlandev, 1545 struct hfa384x_inf_frame *inf) 1546 { 1547 struct hfa384x *hw = wlandev->priv; 1548 struct hfa384x_authenticate_station_data rec; 1549 1550 int i, added, result, cnt; 1551 u8 *addr; 1552 1553 /* 1554 * Build the AuthenticateStation record. Initialize it for denying 1555 * authentication. 1556 */ 1557 1558 ether_addr_copy(rec.address, inf->info.authreq.sta_addr); 1559 rec.status = cpu_to_le16(P80211ENUM_status_unspec_failure); 1560 1561 /* 1562 * Authenticate based on the access mode. 1563 */ 1564 1565 switch (hw->accessmode) { 1566 case WLAN_ACCESS_NONE: 1567 1568 /* 1569 * Deny all new authentications. However, if a station 1570 * is ALREADY authenticated, then accept it. 1571 */ 1572 1573 for (i = 0; i < hw->authlist.cnt; i++) 1574 if (ether_addr_equal(rec.address, 1575 hw->authlist.addr[i])) { 1576 rec.status = cpu_to_le16(P80211ENUM_status_successful); 1577 break; 1578 } 1579 1580 break; 1581 1582 case WLAN_ACCESS_ALL: 1583 1584 /* 1585 * Allow all authentications. 1586 */ 1587 1588 rec.status = cpu_to_le16(P80211ENUM_status_successful); 1589 break; 1590 1591 case WLAN_ACCESS_ALLOW: 1592 1593 /* 1594 * Only allow the authentication if the MAC address 1595 * is in the list of allowed addresses. 1596 * 1597 * Since this is the interrupt handler, we may be here 1598 * while the access list is in the middle of being 1599 * updated. Choose the list which is currently okay. 1600 * See "prism2mib_priv_accessallow()" for details. 1601 */ 1602 1603 if (hw->allow.modify == 0) { 1604 cnt = hw->allow.cnt; 1605 addr = hw->allow.addr[0]; 1606 } else { 1607 cnt = hw->allow.cnt1; 1608 addr = hw->allow.addr1[0]; 1609 } 1610 1611 for (i = 0; i < cnt; i++, addr += ETH_ALEN) 1612 if (ether_addr_equal(rec.address, addr)) { 1613 rec.status = cpu_to_le16(P80211ENUM_status_successful); 1614 break; 1615 } 1616 1617 break; 1618 1619 case WLAN_ACCESS_DENY: 1620 1621 /* 1622 * Allow the authentication UNLESS the MAC address is 1623 * in the list of denied addresses. 1624 * 1625 * Since this is the interrupt handler, we may be here 1626 * while the access list is in the middle of being 1627 * updated. Choose the list which is currently okay. 1628 * See "prism2mib_priv_accessdeny()" for details. 1629 */ 1630 1631 if (hw->deny.modify == 0) { 1632 cnt = hw->deny.cnt; 1633 addr = hw->deny.addr[0]; 1634 } else { 1635 cnt = hw->deny.cnt1; 1636 addr = hw->deny.addr1[0]; 1637 } 1638 1639 rec.status = cpu_to_le16(P80211ENUM_status_successful); 1640 1641 for (i = 0; i < cnt; i++, addr += ETH_ALEN) 1642 if (ether_addr_equal(rec.address, addr)) { 1643 rec.status = cpu_to_le16(P80211ENUM_status_unspec_failure); 1644 break; 1645 } 1646 1647 break; 1648 } 1649 1650 /* 1651 * If the authentication is okay, then add the MAC address to the 1652 * list of authenticated stations. Don't add the address if it 1653 * is already in the list. (802.11b does not seem to disallow 1654 * a station from issuing an authentication request when the 1655 * station is already authenticated. Does this sort of thing 1656 * ever happen? We might as well do the check just in case.) 1657 */ 1658 1659 added = 0; 1660 1661 if (rec.status == cpu_to_le16(P80211ENUM_status_successful)) { 1662 for (i = 0; i < hw->authlist.cnt; i++) 1663 if (ether_addr_equal(rec.address, 1664 hw->authlist.addr[i])) 1665 break; 1666 1667 if (i >= hw->authlist.cnt) { 1668 if (hw->authlist.cnt >= WLAN_AUTH_MAX) { 1669 rec.status = cpu_to_le16(P80211ENUM_status_ap_full); 1670 } else { 1671 ether_addr_copy(hw->authlist.addr[hw->authlist.cnt], 1672 rec.address); 1673 hw->authlist.cnt++; 1674 added = 1; 1675 } 1676 } 1677 } 1678 1679 /* 1680 * Send back the results of the authentication. If this doesn't work, 1681 * then make sure to remove the address from the authenticated list if 1682 * it was added. 1683 */ 1684 1685 rec.algorithm = inf->info.authreq.algorithm; 1686 1687 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_AUTHENTICATESTA, 1688 &rec, sizeof(rec)); 1689 if (result) { 1690 if (added) 1691 hw->authlist.cnt--; 1692 netdev_err(wlandev->netdev, 1693 "setconfig(authenticatestation) failed, result=%d\n", 1694 result); 1695 } 1696 } 1697 1698 /* 1699 * prism2sta_inf_psusercnt 1700 * 1701 * Handles the receipt of a PowerSaveUserCount info frame. Should 1702 * be present in APs only. 1703 * 1704 * Arguments: 1705 * wlandev wlan device structure 1706 * inf ptr to info frame (contents in hfa384x order) 1707 * 1708 * Returns: 1709 * nothing 1710 * 1711 * Side effects: 1712 * 1713 * Call context: 1714 * interrupt 1715 */ 1716 static void prism2sta_inf_psusercnt(struct wlandevice *wlandev, 1717 struct hfa384x_inf_frame *inf) 1718 { 1719 struct hfa384x *hw = wlandev->priv; 1720 1721 hw->psusercount = le16_to_cpu(inf->info.psusercnt.usercnt); 1722 } 1723 1724 /* 1725 * prism2sta_ev_info 1726 * 1727 * Handles the Info event. 1728 * 1729 * Arguments: 1730 * wlandev wlan device structure 1731 * inf ptr to a generic info frame 1732 * 1733 * Returns: 1734 * nothing 1735 * 1736 * Side effects: 1737 * 1738 * Call context: 1739 * interrupt 1740 */ 1741 void prism2sta_ev_info(struct wlandevice *wlandev, 1742 struct hfa384x_inf_frame *inf) 1743 { 1744 le16_to_cpus(&inf->infotype); 1745 /* Dispatch */ 1746 switch (inf->infotype) { 1747 case HFA384x_IT_HANDOVERADDR: 1748 prism2sta_inf_handover(wlandev, inf); 1749 break; 1750 case HFA384x_IT_COMMTALLIES: 1751 prism2sta_inf_tallies(wlandev, inf); 1752 break; 1753 case HFA384x_IT_HOSTSCANRESULTS: 1754 prism2sta_inf_hostscanresults(wlandev, inf); 1755 break; 1756 case HFA384x_IT_SCANRESULTS: 1757 prism2sta_inf_scanresults(wlandev, inf); 1758 break; 1759 case HFA384x_IT_CHINFORESULTS: 1760 prism2sta_inf_chinforesults(wlandev, inf); 1761 break; 1762 case HFA384x_IT_LINKSTATUS: 1763 prism2sta_inf_linkstatus(wlandev, inf); 1764 break; 1765 case HFA384x_IT_ASSOCSTATUS: 1766 prism2sta_inf_assocstatus(wlandev, inf); 1767 break; 1768 case HFA384x_IT_AUTHREQ: 1769 prism2sta_inf_authreq(wlandev, inf); 1770 break; 1771 case HFA384x_IT_PSUSERCNT: 1772 prism2sta_inf_psusercnt(wlandev, inf); 1773 break; 1774 case HFA384x_IT_KEYIDCHANGED: 1775 netdev_warn(wlandev->netdev, "Unhandled IT_KEYIDCHANGED\n"); 1776 break; 1777 case HFA384x_IT_ASSOCREQ: 1778 netdev_warn(wlandev->netdev, "Unhandled IT_ASSOCREQ\n"); 1779 break; 1780 case HFA384x_IT_MICFAILURE: 1781 netdev_warn(wlandev->netdev, "Unhandled IT_MICFAILURE\n"); 1782 break; 1783 default: 1784 netdev_warn(wlandev->netdev, 1785 "Unknown info type=0x%02x\n", inf->infotype); 1786 break; 1787 } 1788 } 1789 1790 /* 1791 * prism2sta_ev_txexc 1792 * 1793 * Handles the TxExc event. A Transmit Exception event indicates 1794 * that the MAC's TX process was unsuccessful - so the packet did 1795 * not get transmitted. 1796 * 1797 * Arguments: 1798 * wlandev wlan device structure 1799 * status tx frame status word 1800 * 1801 * Returns: 1802 * nothing 1803 * 1804 * Side effects: 1805 * 1806 * Call context: 1807 * interrupt 1808 */ 1809 void prism2sta_ev_txexc(struct wlandevice *wlandev, u16 status) 1810 { 1811 pr_debug("TxExc status=0x%x.\n", status); 1812 } 1813 1814 /* 1815 * prism2sta_ev_tx 1816 * 1817 * Handles the Tx event. 1818 * 1819 * Arguments: 1820 * wlandev wlan device structure 1821 * status tx frame status word 1822 * Returns: 1823 * nothing 1824 * 1825 * Side effects: 1826 * 1827 * Call context: 1828 * interrupt 1829 */ 1830 void prism2sta_ev_tx(struct wlandevice *wlandev, u16 status) 1831 { 1832 pr_debug("Tx Complete, status=0x%04x\n", status); 1833 /* update linux network stats */ 1834 wlandev->netdev->stats.tx_packets++; 1835 } 1836 1837 /* 1838 * prism2sta_ev_alloc 1839 * 1840 * Handles the Alloc event. 1841 * 1842 * Arguments: 1843 * wlandev wlan device structure 1844 * 1845 * Returns: 1846 * nothing 1847 * 1848 * Side effects: 1849 * 1850 * Call context: 1851 * interrupt 1852 */ 1853 void prism2sta_ev_alloc(struct wlandevice *wlandev) 1854 { 1855 netif_wake_queue(wlandev->netdev); 1856 } 1857 1858 /* 1859 * create_wlan 1860 * 1861 * Called at module init time. This creates the struct wlandevice structure 1862 * and initializes it with relevant bits. 1863 * 1864 * Arguments: 1865 * none 1866 * 1867 * Returns: 1868 * the created struct wlandevice structure. 1869 * 1870 * Side effects: 1871 * also allocates the priv/hw structures. 1872 * 1873 * Call context: 1874 * process thread 1875 * 1876 */ 1877 static struct wlandevice *create_wlan(void) 1878 { 1879 struct wlandevice *wlandev = NULL; 1880 struct hfa384x *hw = NULL; 1881 1882 /* Alloc our structures */ 1883 wlandev = kzalloc(sizeof(*wlandev), GFP_KERNEL); 1884 hw = kzalloc(sizeof(*hw), GFP_KERNEL); 1885 1886 if (!wlandev || !hw) { 1887 kfree(wlandev); 1888 kfree(hw); 1889 return NULL; 1890 } 1891 1892 /* Initialize the network device object. */ 1893 wlandev->nsdname = dev_info; 1894 wlandev->msdstate = WLAN_MSD_HWPRESENT_PENDING; 1895 wlandev->priv = hw; 1896 wlandev->open = prism2sta_open; 1897 wlandev->close = prism2sta_close; 1898 wlandev->reset = prism2sta_reset; 1899 wlandev->txframe = prism2sta_txframe; 1900 wlandev->mlmerequest = prism2sta_mlmerequest; 1901 wlandev->set_multicast_list = prism2sta_setmulticast; 1902 wlandev->tx_timeout = hfa384x_tx_timeout; 1903 1904 wlandev->nsdcaps = P80211_NSDCAP_HWFRAGMENT | P80211_NSDCAP_AUTOJOIN; 1905 1906 /* Initialize the device private data structure. */ 1907 hw->dot11_desired_bss_type = 1; 1908 1909 return wlandev; 1910 } 1911 1912 void prism2sta_commsqual_defer(struct work_struct *data) 1913 { 1914 struct hfa384x *hw = container_of(data, struct hfa384x, commsqual_bh); 1915 struct wlandevice *wlandev = hw->wlandev; 1916 struct hfa384x_bytestr32 ssid; 1917 struct p80211msg_dot11req_mibget msg; 1918 struct p80211item_uint32 *mibitem = (struct p80211item_uint32 *) 1919 &msg.mibattribute.data; 1920 int result = 0; 1921 1922 if (hw->wlandev->hwremoved) 1923 return; 1924 1925 /* we don't care if we're in AP mode */ 1926 if ((wlandev->macmode == WLAN_MACMODE_NONE) || 1927 (wlandev->macmode == WLAN_MACMODE_ESS_AP)) { 1928 return; 1929 } 1930 1931 /* It only makes sense to poll these in non-IBSS */ 1932 if (wlandev->macmode != WLAN_MACMODE_IBSS_STA) { 1933 result = hfa384x_drvr_getconfig(hw, HFA384x_RID_DBMCOMMSQUALITY, 1934 &hw->qual, HFA384x_RID_DBMCOMMSQUALITY_LEN); 1935 1936 if (result) { 1937 netdev_err(wlandev->netdev, "error fetching commsqual\n"); 1938 return; 1939 } 1940 1941 pr_debug("commsqual %d %d %d\n", 1942 le16_to_cpu(hw->qual.cq_curr_bss), 1943 le16_to_cpu(hw->qual.asl_curr_bss), 1944 le16_to_cpu(hw->qual.anl_curr_fc)); 1945 } 1946 1947 /* Get the signal rate */ 1948 msg.msgcode = DIDMSG_DOT11REQ_MIBGET; 1949 mibitem->did = DIDMIB_P2_MAC_CURRENTTXRATE; 1950 result = p80211req_dorequest(wlandev, (u8 *)&msg); 1951 1952 if (result) { 1953 pr_debug("get signal rate failed, result = %d\n", 1954 result); 1955 return; 1956 } 1957 1958 switch (mibitem->data) { 1959 case HFA384x_RATEBIT_1: 1960 hw->txrate = 10; 1961 break; 1962 case HFA384x_RATEBIT_2: 1963 hw->txrate = 20; 1964 break; 1965 case HFA384x_RATEBIT_5dot5: 1966 hw->txrate = 55; 1967 break; 1968 case HFA384x_RATEBIT_11: 1969 hw->txrate = 110; 1970 break; 1971 default: 1972 pr_debug("Bad ratebit (%d)\n", mibitem->data); 1973 } 1974 1975 /* Lastly, we need to make sure the BSSID didn't change on us */ 1976 result = hfa384x_drvr_getconfig(hw, 1977 HFA384x_RID_CURRENTBSSID, 1978 wlandev->bssid, WLAN_BSSID_LEN); 1979 if (result) { 1980 pr_debug("getconfig(0x%02x) failed, result = %d\n", 1981 HFA384x_RID_CURRENTBSSID, result); 1982 return; 1983 } 1984 1985 result = hfa384x_drvr_getconfig(hw, 1986 HFA384x_RID_CURRENTSSID, 1987 &ssid, sizeof(ssid)); 1988 if (result) { 1989 pr_debug("getconfig(0x%02x) failed, result = %d\n", 1990 HFA384x_RID_CURRENTSSID, result); 1991 return; 1992 } 1993 prism2mgmt_bytestr2pstr((struct hfa384x_bytestr *)&ssid, 1994 (struct p80211pstrd *)&wlandev->ssid); 1995 1996 /* Reschedule timer */ 1997 mod_timer(&hw->commsqual_timer, jiffies + HZ); 1998 } 1999 2000 void prism2sta_commsqual_timer(struct timer_list *t) 2001 { 2002 struct hfa384x *hw = from_timer(hw, t, commsqual_timer); 2003 2004 schedule_work(&hw->commsqual_bh); 2005 } 2006