drivers/staging/wlan-ng/prism2sta.c

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