SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/wlan-ng/prism2mgmt.c

   1 /* src/prism2/driver/prism2mgmt.c
   2 *
   3 * Management request handler functions.
   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 * The functions in this file handle management requests sent from
  48 * user mode.
  49 *
  50 * Most of these functions have two separate blocks of code that are
  51 * conditional on whether this is a station or an AP.  This is used
  52 * to separate out the STA and AP responses to these management primitives.
  53 * It's a choice (good, bad, indifferent?) to have the code in the same
  54 * place so it's clear that the same primitive is implemented in both
  55 * cases but has different behavior.
  56 *
  57 * --------------------------------------------------------------------
  58 */
  59
  60 #include <linux/if_arp.h>
  61 #include <linux/module.h>
  62 #include <linux/kernel.h>
  63 #include <linux/wait.h>
  64 #include <linux/sched.h>
  65 #include <linux/types.h>
  66 #include <linux/slab.h>
  67 #include <linux/wireless.h>
  68 #include <linux/netdevice.h>
  69 #include <linux/delay.h>
  70 #include <asm/io.h>
  71 #include <asm/byteorder.h>
  72 #include <linux/random.h>
  73 #include <linux/usb.h>
  74 #include <linux/bitops.h>
  75
  76 /*================================================================*/
  77 /* Project Includes */
  78
  79 #include "p80211types.h"
  80 #include "p80211hdr.h"
  81 #include "p80211mgmt.h"
  82 #include "p80211conv.h"
  83 #include "p80211msg.h"
  84 #include "p80211netdev.h"
  85 #include "p80211metadef.h"
  86 #include "p80211metastruct.h"
  87 #include "hfa384x.h"
  88 #include "prism2mgmt.h"
  89
  90 /* Converts 802.11 format rate specifications to prism2 */
  91 #define p80211rate_to_p2bit(n)  ((((n)&~BIT(7)) == 2) ? BIT(0) :  \
  92                                  (((n)&~BIT(7)) == 4) ? BIT(1) : \
  93                                  (((n)&~BIT(7)) == 11) ? BIT(2) : \
  94                                  (((n)&~BIT(7)) == 22) ? BIT(3) : 0)
  95
  96 /*----------------------------------------------------------------
  97 * prism2mgmt_scan
  98 *
  99 * Initiate a scan for BSSs.
 100 *
 101 * This function corresponds to MLME-scan.request and part of
 102 * MLME-scan.confirm.  As far as I can tell in the standard, there
 103 * are no restrictions on when a scan.request may be issued.  We have
 104 * to handle in whatever state the driver/MAC happen to be.
 105 *
 106 * Arguments:
 107 *       wlandev         wlan device structure
 108 *       msgp            ptr to msg buffer
 109 *
 110 * Returns:
 111 *       0       success and done
 112 *       <0      success, but we're waiting for something to finish.
 113 *       >0      an error occurred while handling the message.
 114 * Side effects:
 115 *
 116 * Call context:
 117 *       process thread  (usually)
 118 *       interrupt
 119 ----------------------------------------------------------------*/
 120 int prism2mgmt_scan(wlandevice_t *wlandev, void *msgp)
 121 {
 122         int result = 0;
 123         hfa384x_t *hw = wlandev->priv;
 124         p80211msg_dot11req_scan_t *msg = msgp;
 125         u16 roamingmode, word;
 126         int i, timeout;
 127         int istmpenable = 0;
 128
 129         hfa384x_HostScanRequest_data_t scanreq;
 130
 131         /* gatekeeper check */
 132         if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
 133                                      hw->ident_sta_fw.minor,
 134                                      hw->ident_sta_fw.variant) <
 135             HFA384x_FIRMWARE_VERSION(1, 3, 2)) {
 136                 printk(KERN_ERR
 137                        "HostScan not supported with current firmware (<1.3.2).\n");
 138                 result = 1;
 139                 msg->resultcode.data = P80211ENUM_resultcode_not_supported;
 140                 goto exit;
 141         }
 142
 143         memset(&scanreq, 0, sizeof(scanreq));
 144
 145         /* save current roaming mode */
 146         result = hfa384x_drvr_getconfig16(hw,
 147                                           HFA384x_RID_CNFROAMINGMODE,
 148                                           &roamingmode);
 149         if (result) {
 150                 printk(KERN_ERR "getconfig(ROAMMODE) failed. result=%d\n",
 151                        result);
 152                 msg->resultcode.data =
 153                     P80211ENUM_resultcode_implementation_failure;
 154                 goto exit;
 155         }
 156
 157         /* drop into mode 3 for the scan */
 158         result = hfa384x_drvr_setconfig16(hw,
 159                                           HFA384x_RID_CNFROAMINGMODE,
 160                                           HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
 161         if (result) {
 162                 printk(KERN_ERR "setconfig(ROAMINGMODE) failed. result=%d\n",
 163                        result);
 164                 msg->resultcode.data =
 165                     P80211ENUM_resultcode_implementation_failure;
 166                 goto exit;
 167         }
 168
 169         /* active or passive? */
 170         if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
 171                                      hw->ident_sta_fw.minor,
 172                                      hw->ident_sta_fw.variant) >
 173             HFA384x_FIRMWARE_VERSION(1, 5, 0)) {
 174                 if (msg->scantype.data != P80211ENUM_scantype_active)
 175                         word = cpu_to_le16(msg->maxchanneltime.data);
 176                 else
 177                         word = 0;
 178
 179                 result =
 180                     hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPASSIVESCANCTRL,
 181                                              word);
 182                 if (result) {
 183                         printk(KERN_WARNING "Passive scan not supported with "
 184                                "current firmware.  (<1.5.1)\n");
 185                 }
 186         }
 187
 188         /* set up the txrate to be 2MBPS. Should be fastest basicrate... */
 189         word = HFA384x_RATEBIT_2;
 190         scanreq.txRate = cpu_to_le16(word);
 191
 192         /* set up the channel list */
 193         word = 0;
 194         for (i = 0; i < msg->channellist.data.len; i++) {
 195                 u8 channel = msg->channellist.data.data[i];
 196                 if (channel > 14)
 197                         continue;
 198                 /* channel 1 is BIT 0 ... channel 14 is BIT 13 */
 199                 word |= (1 << (channel - 1));
 200         }
 201         scanreq.channelList = cpu_to_le16(word);
 202
 203         /* set up the ssid, if present. */
 204         scanreq.ssid.len = cpu_to_le16(msg->ssid.data.len);
 205         memcpy(scanreq.ssid.data, msg->ssid.data.data, msg->ssid.data.len);
 206
 207         /* Enable the MAC port if it's not already enabled  */
 208         result = hfa384x_drvr_getconfig16(hw, HFA384x_RID_PORTSTATUS, &word);
 209         if (result) {
 210                 printk(KERN_ERR "getconfig(PORTSTATUS) failed. "
 211                        "result=%d\n", result);
 212                 msg->resultcode.data =
 213                     P80211ENUM_resultcode_implementation_failure;
 214                 goto exit;
 215         }
 216         if (word == HFA384x_PORTSTATUS_DISABLED) {
 217                 u16 wordbuf[17];
 218
 219                 result = hfa384x_drvr_setconfig16(hw,
 220                                                   HFA384x_RID_CNFROAMINGMODE,
 221                                                   HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
 222                 if (result) {
 223                         printk(KERN_ERR
 224                                "setconfig(ROAMINGMODE) failed. result=%d\n",
 225                                result);
 226                         msg->resultcode.data =
 227                             P80211ENUM_resultcode_implementation_failure;
 228                         goto exit;
 229                 }
 230                 /* Construct a bogus SSID and assign it to OwnSSID and
 231                  * DesiredSSID
 232                  */
 233                 wordbuf[0] = cpu_to_le16(WLAN_SSID_MAXLEN);
 234                 get_random_bytes(&wordbuf[1], WLAN_SSID_MAXLEN);
 235                 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
 236                                                 wordbuf,
 237                                                 HFA384x_RID_CNFOWNSSID_LEN);
 238                 if (result) {
 239                         printk(KERN_ERR "Failed to set OwnSSID.\n");
 240                         msg->resultcode.data =
 241                             P80211ENUM_resultcode_implementation_failure;
 242                         goto exit;
 243                 }
 244                 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
 245                                                 wordbuf,
 246                                                 HFA384x_RID_CNFDESIREDSSID_LEN);
 247                 if (result) {
 248                         printk(KERN_ERR "Failed to set DesiredSSID.\n");
 249                         msg->resultcode.data =
 250                             P80211ENUM_resultcode_implementation_failure;
 251                         goto exit;
 252                 }
 253                 /* bsstype */
 254                 result = hfa384x_drvr_setconfig16(hw,
 255                                                   HFA384x_RID_CNFPORTTYPE,
 256                                                   HFA384x_PORTTYPE_IBSS);
 257                 if (result) {
 258                         printk(KERN_ERR "Failed to set CNFPORTTYPE.\n");
 259                         msg->resultcode.data =
 260                             P80211ENUM_resultcode_implementation_failure;
 261                         goto exit;
 262                 }
 263                 /* ibss options */
 264                 result = hfa384x_drvr_setconfig16(hw,
 265                                                   HFA384x_RID_CREATEIBSS,
 266                                                   HFA384x_CREATEIBSS_JOINCREATEIBSS);
 267                 if (result) {
 268                         printk(KERN_ERR "Failed to set CREATEIBSS.\n");
 269                         msg->resultcode.data =
 270                             P80211ENUM_resultcode_implementation_failure;
 271                         goto exit;
 272                 }
 273                 result = hfa384x_drvr_enable(hw, 0);
 274                 if (result) {
 275                         printk(KERN_ERR "drvr_enable(0) failed. "
 276                                "result=%d\n", result);
 277                         msg->resultcode.data =
 278                             P80211ENUM_resultcode_implementation_failure;
 279                         goto exit;
 280                 }
 281                 istmpenable = 1;
 282         }
 283
 284         /* Figure out our timeout first Kus, then HZ */
 285         timeout = msg->channellist.data.len * msg->maxchanneltime.data;
 286         timeout = (timeout * HZ) / 1000;
 287
 288         /* Issue the scan request */
 289         hw->scanflag = 0;
 290
 291         result = hfa384x_drvr_setconfig(hw,
 292                                         HFA384x_RID_HOSTSCAN, &scanreq,
 293                                         sizeof(hfa384x_HostScanRequest_data_t));
 294         if (result) {
 295                 printk(KERN_ERR "setconfig(SCANREQUEST) failed. result=%d\n",
 296                        result);
 297                 msg->resultcode.data =
 298                     P80211ENUM_resultcode_implementation_failure;
 299                 goto exit;
 300         }
 301
 302         /* sleep until info frame arrives */
 303         wait_event_interruptible_timeout(hw->cmdq, hw->scanflag, timeout);
 304
 305         msg->numbss.status = P80211ENUM_msgitem_status_data_ok;
 306         if (hw->scanflag == -1)
 307                 hw->scanflag = 0;
 308
 309         msg->numbss.data = hw->scanflag;
 310
 311         hw->scanflag = 0;
 312
 313         /* Disable port if we temporarily enabled it. */
 314         if (istmpenable) {
 315                 result = hfa384x_drvr_disable(hw, 0);
 316                 if (result) {
 317                         printk(KERN_ERR "drvr_disable(0) failed. "
 318                                "result=%d\n", result);
 319                         msg->resultcode.data =
 320                             P80211ENUM_resultcode_implementation_failure;
 321                         goto exit;
 322                 }
 323         }
 324
 325         /* restore original roaming mode */
 326         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFROAMINGMODE,
 327                                           roamingmode);
 328         if (result) {
 329                 printk(KERN_ERR "setconfig(ROAMMODE) failed. result=%d\n",
 330                        result);
 331                 msg->resultcode.data =
 332                     P80211ENUM_resultcode_implementation_failure;
 333                 goto exit;
 334         }
 335
 336         result = 0;
 337         msg->resultcode.data = P80211ENUM_resultcode_success;
 338
 339 exit:
 340         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 341
 342         return result;
 343 }
 344
 345 /*----------------------------------------------------------------
 346 * prism2mgmt_scan_results
 347 *
 348 * Retrieve the BSS description for one of the BSSs identified in
 349 * a scan.
 350 *
 351 * Arguments:
 352 *       wlandev         wlan device structure
 353 *       msgp            ptr to msg buffer
 354 *
 355 * Returns:
 356 *       0       success and done
 357 *       <0      success, but we're waiting for something to finish.
 358 *       >0      an error occurred while handling the message.
 359 * Side effects:
 360 *
 361 * Call context:
 362 *       process thread  (usually)
 363 *       interrupt
 364 ----------------------------------------------------------------*/
 365 int prism2mgmt_scan_results(wlandevice_t *wlandev, void *msgp)
 366 {
 367         int result = 0;
 368         p80211msg_dot11req_scan_results_t *req;
 369         hfa384x_t *hw = wlandev->priv;
 370         hfa384x_HScanResultSub_t *item = NULL;
 371
 372         int count;
 373
 374         req = (p80211msg_dot11req_scan_results_t *) msgp;
 375
 376         req->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 377
 378         if (!hw->scanresults) {
 379                 printk(KERN_ERR
 380                        "dot11req_scan_results can only be used after a successful dot11req_scan.\n");
 381                 result = 2;
 382                 req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
 383                 goto exit;
 384         }
 385
 386         count = (hw->scanresults->framelen - 3) / 32;
 387         if (count > 32)
 388                 count = 32;
 389
 390         if (req->bssindex.data >= count) {
 391                 pr_debug("requested index (%d) out of range (%d)\n",
 392                        req->bssindex.data, count);
 393                 result = 2;
 394                 req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
 395                 goto exit;
 396         }
 397
 398         item = &(hw->scanresults->info.hscanresult.result[req->bssindex.data]);
 399         /* signal and noise */
 400         req->signal.status = P80211ENUM_msgitem_status_data_ok;
 401         req->noise.status = P80211ENUM_msgitem_status_data_ok;
 402         req->signal.data = le16_to_cpu(item->sl);
 403         req->noise.data = le16_to_cpu(item->anl);
 404
 405         /* BSSID */
 406         req->bssid.status = P80211ENUM_msgitem_status_data_ok;
 407         req->bssid.data.len = WLAN_BSSID_LEN;
 408         memcpy(req->bssid.data.data, item->bssid, WLAN_BSSID_LEN);
 409
 410         /* SSID */
 411         req->ssid.status = P80211ENUM_msgitem_status_data_ok;
 412         req->ssid.data.len = le16_to_cpu(item->ssid.len);
 413         memcpy(req->ssid.data.data, item->ssid.data, req->ssid.data.len);
 414
 415         /* supported rates */
 416         for (count = 0; count < 10; count++)
 417                 if (item->supprates[count] == 0)
 418                         break;
 419
 420 #define REQBASICRATE(N) \
 421         if ((count >= N) && DOT11_RATE5_ISBASIC_GET(item->supprates[(N)-1])) { \
 422                 req->basicrate ## N .data = item->supprates[(N)-1]; \
 423                 req->basicrate ## N .status = P80211ENUM_msgitem_status_data_ok; \
 424         }
 425
 426         REQBASICRATE(1);
 427         REQBASICRATE(2);
 428         REQBASICRATE(3);
 429         REQBASICRATE(4);
 430         REQBASICRATE(5);
 431         REQBASICRATE(6);
 432         REQBASICRATE(7);
 433         REQBASICRATE(8);
 434
 435 #define REQSUPPRATE(N) \
 436         if (count >= N) { \
 437                 req->supprate ## N .data = item->supprates[(N)-1]; \
 438                 req->supprate ## N .status = P80211ENUM_msgitem_status_data_ok; \
 439         }
 440
 441         REQSUPPRATE(1);
 442         REQSUPPRATE(2);
 443         REQSUPPRATE(3);
 444         REQSUPPRATE(4);
 445         REQSUPPRATE(5);
 446         REQSUPPRATE(6);
 447         REQSUPPRATE(7);
 448         REQSUPPRATE(8);
 449
 450         /* beacon period */
 451         req->beaconperiod.status = P80211ENUM_msgitem_status_data_ok;
 452         req->beaconperiod.data = le16_to_cpu(item->bcnint);
 453
 454         /* timestamps */
 455         req->timestamp.status = P80211ENUM_msgitem_status_data_ok;
 456         req->timestamp.data = jiffies;
 457         req->localtime.status = P80211ENUM_msgitem_status_data_ok;
 458         req->localtime.data = jiffies;
 459
 460         /* atim window */
 461         req->ibssatimwindow.status = P80211ENUM_msgitem_status_data_ok;
 462         req->ibssatimwindow.data = le16_to_cpu(item->atim);
 463
 464         /* Channel */
 465         req->dschannel.status = P80211ENUM_msgitem_status_data_ok;
 466         req->dschannel.data = le16_to_cpu(item->chid);
 467
 468         /* capinfo bits */
 469         count = le16_to_cpu(item->capinfo);
 470
 471         /* privacy flag */
 472         req->privacy.status = P80211ENUM_msgitem_status_data_ok;
 473         req->privacy.data = WLAN_GET_MGMT_CAP_INFO_PRIVACY(count);
 474
 475         /* cfpollable */
 476         req->cfpollable.status = P80211ENUM_msgitem_status_data_ok;
 477         req->cfpollable.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLABLE(count);
 478
 479         /* cfpollreq */
 480         req->cfpollreq.status = P80211ENUM_msgitem_status_data_ok;
 481         req->cfpollreq.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLREQ(count);
 482
 483         /* bsstype */
 484         req->bsstype.status = P80211ENUM_msgitem_status_data_ok;
 485         req->bsstype.data = (WLAN_GET_MGMT_CAP_INFO_ESS(count)) ?
 486             P80211ENUM_bsstype_infrastructure : P80211ENUM_bsstype_independent;
 487
 488         result = 0;
 489         req->resultcode.data = P80211ENUM_resultcode_success;
 490
 491 exit:
 492         return result;
 493 }
 494
 495 /*----------------------------------------------------------------
 496 * prism2mgmt_start
 497 *
 498 * Start a BSS.  Any station can do this for IBSS, only AP for ESS.
 499 *
 500 * Arguments:
 501 *       wlandev         wlan device structure
 502 *       msgp            ptr to msg buffer
 503 *
 504 * Returns:
 505 *       0       success and done
 506 *       <0      success, but we're waiting for something to finish.
 507 *       >0      an error occurred while handling the message.
 508 * Side effects:
 509 *
 510 * Call context:
 511 *       process thread  (usually)
 512 *       interrupt
 513 ----------------------------------------------------------------*/
 514 int prism2mgmt_start(wlandevice_t *wlandev, void *msgp)
 515 {
 516         int result = 0;
 517         hfa384x_t *hw = wlandev->priv;
 518         p80211msg_dot11req_start_t *msg = msgp;
 519
 520         p80211pstrd_t *pstr;
 521         u8 bytebuf[80];
 522         hfa384x_bytestr_t *p2bytestr = (hfa384x_bytestr_t *) bytebuf;
 523         u16 word;
 524
 525         wlandev->macmode = WLAN_MACMODE_NONE;
 526
 527         /* Set the SSID */
 528         memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
 529
 530         /*** ADHOC IBSS ***/
 531         /* see if current f/w is less than 8c3 */
 532         if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
 533                                      hw->ident_sta_fw.minor,
 534                                      hw->ident_sta_fw.variant) <
 535             HFA384x_FIRMWARE_VERSION(0, 8, 3)) {
 536                 /* Ad-Hoc not quite supported on Prism2 */
 537                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 538                 msg->resultcode.data = P80211ENUM_resultcode_not_supported;
 539                 goto done;
 540         }
 541
 542         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 543
 544         /*** STATION ***/
 545         /* Set the REQUIRED config items */
 546         /* SSID */
 547         pstr = (p80211pstrd_t *)&(msg->ssid.data);
 548         prism2mgmt_pstr2bytestr(p2bytestr, pstr);
 549         result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
 550                                         bytebuf, HFA384x_RID_CNFOWNSSID_LEN);
 551         if (result) {
 552                 printk(KERN_ERR "Failed to set CnfOwnSSID\n");
 553                 goto failed;
 554         }
 555         result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
 556                                         bytebuf,
 557                                         HFA384x_RID_CNFDESIREDSSID_LEN);
 558         if (result) {
 559                 printk(KERN_ERR "Failed to set CnfDesiredSSID\n");
 560                 goto failed;
 561         }
 562
 563         /* bsstype - we use the default in the ap firmware */
 564         /* IBSS port */
 565         hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, 0);
 566
 567         /* beacon period */
 568         word = msg->beaconperiod.data;
 569         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAPBCNint, word);
 570         if (result) {
 571                 printk(KERN_ERR "Failed to set beacon period=%d.\n", word);
 572                 goto failed;
 573         }
 574
 575         /* dschannel */
 576         word = msg->dschannel.data;
 577         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFOWNCHANNEL, word);
 578         if (result) {
 579                 printk(KERN_ERR "Failed to set channel=%d.\n", word);
 580                 goto failed;
 581         }
 582         /* Basic rates */
 583         word = p80211rate_to_p2bit(msg->basicrate1.data);
 584         if (msg->basicrate2.status == P80211ENUM_msgitem_status_data_ok)
 585                 word |= p80211rate_to_p2bit(msg->basicrate2.data);
 586
 587         if (msg->basicrate3.status == P80211ENUM_msgitem_status_data_ok)
 588                 word |= p80211rate_to_p2bit(msg->basicrate3.data);
 589
 590         if (msg->basicrate4.status == P80211ENUM_msgitem_status_data_ok)
 591                 word |= p80211rate_to_p2bit(msg->basicrate4.data);
 592
 593         if (msg->basicrate5.status == P80211ENUM_msgitem_status_data_ok)
 594                 word |= p80211rate_to_p2bit(msg->basicrate5.data);
 595
 596         if (msg->basicrate6.status == P80211ENUM_msgitem_status_data_ok)
 597                 word |= p80211rate_to_p2bit(msg->basicrate6.data);
 598
 599         if (msg->basicrate7.status == P80211ENUM_msgitem_status_data_ok)
 600                 word |= p80211rate_to_p2bit(msg->basicrate7.data);
 601
 602         if (msg->basicrate8.status == P80211ENUM_msgitem_status_data_ok)
 603                 word |= p80211rate_to_p2bit(msg->basicrate8.data);
 604
 605         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFBASICRATES, word);
 606         if (result) {
 607                 printk(KERN_ERR "Failed to set basicrates=%d.\n", word);
 608                 goto failed;
 609         }
 610
 611         /* Operational rates (supprates and txratecontrol) */
 612         word = p80211rate_to_p2bit(msg->operationalrate1.data);
 613         if (msg->operationalrate2.status == P80211ENUM_msgitem_status_data_ok)
 614                 word |= p80211rate_to_p2bit(msg->operationalrate2.data);
 615
 616         if (msg->operationalrate3.status == P80211ENUM_msgitem_status_data_ok)
 617                 word |= p80211rate_to_p2bit(msg->operationalrate3.data);
 618
 619         if (msg->operationalrate4.status == P80211ENUM_msgitem_status_data_ok)
 620                 word |= p80211rate_to_p2bit(msg->operationalrate4.data);
 621
 622         if (msg->operationalrate5.status == P80211ENUM_msgitem_status_data_ok)
 623                 word |= p80211rate_to_p2bit(msg->operationalrate5.data);
 624
 625         if (msg->operationalrate6.status == P80211ENUM_msgitem_status_data_ok)
 626                 word |= p80211rate_to_p2bit(msg->operationalrate6.data);
 627
 628         if (msg->operationalrate7.status == P80211ENUM_msgitem_status_data_ok)
 629                 word |= p80211rate_to_p2bit(msg->operationalrate7.data);
 630
 631         if (msg->operationalrate8.status == P80211ENUM_msgitem_status_data_ok)
 632                 word |= p80211rate_to_p2bit(msg->operationalrate8.data);
 633
 634         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFSUPPRATES, word);
 635         if (result) {
 636                 printk(KERN_ERR "Failed to set supprates=%d.\n", word);
 637                 goto failed;
 638         }
 639
 640         result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, word);
 641         if (result) {
 642                 printk(KERN_ERR "Failed to set txrates=%d.\n", word);
 643                 goto failed;
 644         }
 645
 646         /* Set the macmode so the frame setup code knows what to do */
 647         if (msg->bsstype.data == P80211ENUM_bsstype_independent) {
 648                 wlandev->macmode = WLAN_MACMODE_IBSS_STA;
 649                 /* lets extend the data length a bit */
 650                 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFMAXDATALEN, 2304);
 651         }
 652
 653         /* Enable the Port */
 654         result = hfa384x_drvr_enable(hw, 0);
 655         if (result) {
 656                 printk(KERN_ERR "Enable macport failed, result=%d.\n", result);
 657                 goto failed;
 658         }
 659
 660         msg->resultcode.data = P80211ENUM_resultcode_success;
 661
 662         goto done;
 663 failed:
 664         pr_debug("Failed to set a config option, result=%d\n", result);
 665         msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
 666
 667 done:
 668         result = 0;
 669
 670         return result;
 671 }
 672
 673 /*----------------------------------------------------------------
 674 * prism2mgmt_readpda
 675 *
 676 * Collect the PDA data and put it in the message.
 677 *
 678 * Arguments:
 679 *       wlandev         wlan device structure
 680 *       msgp            ptr to msg buffer
 681 *
 682 * Returns:
 683 *       0       success and done
 684 *       <0      success, but we're waiting for something to finish.
 685 *       >0      an error occurred while handling the message.
 686 * Side effects:
 687 *
 688 * Call context:
 689 *       process thread  (usually)
 690 ----------------------------------------------------------------*/
 691 int prism2mgmt_readpda(wlandevice_t *wlandev, void *msgp)
 692 {
 693         hfa384x_t *hw = wlandev->priv;
 694         p80211msg_p2req_readpda_t *msg = msgp;
 695         int result;
 696
 697         /* We only support collecting the PDA when in the FWLOAD
 698          * state.
 699          */
 700         if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
 701                 printk(KERN_ERR
 702                        "PDA may only be read " "in the fwload state.\n");
 703                 msg->resultcode.data =
 704                     P80211ENUM_resultcode_implementation_failure;
 705                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 706         } else {
 707                 /*  Call drvr_readpda(), it handles the auxport enable
 708                  *  and validating the returned PDA.
 709                  */
 710                 result = hfa384x_drvr_readpda(hw,
 711                                               msg->pda.data,
 712                                               HFA384x_PDA_LEN_MAX);
 713                 if (result) {
 714                         printk(KERN_ERR
 715                                "hfa384x_drvr_readpda() failed, "
 716                                "result=%d\n", result);
 717
 718                         msg->resultcode.data =
 719                             P80211ENUM_resultcode_implementation_failure;
 720                         msg->resultcode.status =
 721                             P80211ENUM_msgitem_status_data_ok;
 722                         return 0;
 723                 }
 724                 msg->pda.status = P80211ENUM_msgitem_status_data_ok;
 725                 msg->resultcode.data = P80211ENUM_resultcode_success;
 726                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 727         }
 728
 729         return 0;
 730 }
 731
 732 /*----------------------------------------------------------------
 733 * prism2mgmt_ramdl_state
 734 *
 735 * Establishes the beginning/end of a card RAM download session.
 736 *
 737 * It is expected that the ramdl_write() function will be called
 738 * one or more times between the 'enable' and 'disable' calls to
 739 * this function.
 740 *
 741 * Note: This function should not be called when a mac comm port
 742 *       is active.
 743 *
 744 * Arguments:
 745 *       wlandev         wlan device structure
 746 *       msgp            ptr to msg buffer
 747 *
 748 * Returns:
 749 *       0       success and done
 750 *       <0      success, but we're waiting for something to finish.
 751 *       >0      an error occurred while handling the message.
 752 * Side effects:
 753 *
 754 * Call context:
 755 *       process thread  (usually)
 756 ----------------------------------------------------------------*/
 757 int prism2mgmt_ramdl_state(wlandevice_t *wlandev, void *msgp)
 758 {
 759         hfa384x_t *hw = wlandev->priv;
 760         p80211msg_p2req_ramdl_state_t *msg = msgp;
 761
 762         if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
 763                 printk(KERN_ERR
 764                        "ramdl_state(): may only be called "
 765                        "in the fwload state.\n");
 766                 msg->resultcode.data =
 767                     P80211ENUM_resultcode_implementation_failure;
 768                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 769                 return 0;
 770         }
 771
 772         /*
 773          ** Note: Interrupts are locked out if this is an AP and are NOT
 774          ** locked out if this is a station.
 775          */
 776
 777         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 778         if (msg->enable.data == P80211ENUM_truth_true) {
 779                 if (hfa384x_drvr_ramdl_enable(hw, msg->exeaddr.data)) {
 780                         msg->resultcode.data =
 781                             P80211ENUM_resultcode_implementation_failure;
 782                 } else {
 783                         msg->resultcode.data = P80211ENUM_resultcode_success;
 784                 }
 785         } else {
 786                 hfa384x_drvr_ramdl_disable(hw);
 787                 msg->resultcode.data = P80211ENUM_resultcode_success;
 788         }
 789
 790         return 0;
 791 }
 792
 793 /*----------------------------------------------------------------
 794 * prism2mgmt_ramdl_write
 795 *
 796 * Writes a buffer to the card RAM using the download state.  This
 797 * is for writing code to card RAM.  To just read or write raw data
 798 * use the aux functions.
 799 *
 800 * Arguments:
 801 *       wlandev         wlan device structure
 802 *       msgp            ptr to msg buffer
 803 *
 804 * Returns:
 805 *       0       success and done
 806 *       <0      success, but we're waiting for something to finish.
 807 *       >0      an error occurred while handling the message.
 808 * Side effects:
 809 *
 810 * Call context:
 811 *       process thread  (usually)
 812 ----------------------------------------------------------------*/
 813 int prism2mgmt_ramdl_write(wlandevice_t *wlandev, void *msgp)
 814 {
 815         hfa384x_t *hw = wlandev->priv;
 816         p80211msg_p2req_ramdl_write_t *msg = msgp;
 817         u32 addr;
 818         u32 len;
 819         u8 *buf;
 820
 821         if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
 822                 printk(KERN_ERR
 823                        "ramdl_write(): may only be called "
 824                        "in the fwload state.\n");
 825                 msg->resultcode.data =
 826                     P80211ENUM_resultcode_implementation_failure;
 827                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 828                 return 0;
 829         }
 830
 831         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 832         /* first validate the length */
 833         if (msg->len.data > sizeof(msg->data.data)) {
 834                 msg->resultcode.status =
 835                     P80211ENUM_resultcode_invalid_parameters;
 836                 return 0;
 837         }
 838         /* call the hfa384x function to do the write */
 839         addr = msg->addr.data;
 840         len = msg->len.data;
 841         buf = msg->data.data;
 842         if (hfa384x_drvr_ramdl_write(hw, addr, buf, len))
 843                 msg->resultcode.data = P80211ENUM_resultcode_refused;
 844
 845         msg->resultcode.data = P80211ENUM_resultcode_success;
 846
 847         return 0;
 848 }
 849
 850 /*----------------------------------------------------------------
 851 * prism2mgmt_flashdl_state
 852 *
 853 * Establishes the beginning/end of a card Flash download session.
 854 *
 855 * It is expected that the flashdl_write() function will be called
 856 * one or more times between the 'enable' and 'disable' calls to
 857 * this function.
 858 *
 859 * Note: This function should not be called when a mac comm port
 860 *       is active.
 861 *
 862 * Arguments:
 863 *       wlandev         wlan device structure
 864 *       msgp            ptr to msg buffer
 865 *
 866 * Returns:
 867 *       0       success and done
 868 *       <0      success, but we're waiting for something to finish.
 869 *       >0      an error occurred while handling the message.
 870 * Side effects:
 871 *
 872 * Call context:
 873 *       process thread  (usually)
 874 ----------------------------------------------------------------*/
 875 int prism2mgmt_flashdl_state(wlandevice_t *wlandev, void *msgp)
 876 {
 877         int result = 0;
 878         hfa384x_t *hw = wlandev->priv;
 879         p80211msg_p2req_flashdl_state_t *msg = msgp;
 880
 881         if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
 882                 printk(KERN_ERR
 883                        "flashdl_state(): may only be called "
 884                        "in the fwload state.\n");
 885                 msg->resultcode.data =
 886                     P80211ENUM_resultcode_implementation_failure;
 887                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 888                 return 0;
 889         }
 890
 891         /*
 892          ** Note: Interrupts are locked out if this is an AP and are NOT
 893          ** locked out if this is a station.
 894          */
 895
 896         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 897         if (msg->enable.data == P80211ENUM_truth_true) {
 898                 if (hfa384x_drvr_flashdl_enable(hw)) {
 899                         msg->resultcode.data =
 900                             P80211ENUM_resultcode_implementation_failure;
 901                 } else {
 902                         msg->resultcode.data = P80211ENUM_resultcode_success;
 903                 }
 904         } else {
 905                 hfa384x_drvr_flashdl_disable(hw);
 906                 msg->resultcode.data = P80211ENUM_resultcode_success;
 907                 /* NOTE: At this point, the MAC is in the post-reset
 908                  * state and the driver is in the fwload state.
 909                  * We need to get the MAC back into the fwload
 910                  * state.  To do this, we set the nsdstate to HWPRESENT
 911                  * and then call the ifstate function to redo everything
 912                  * that got us into the fwload state.
 913                  */
 914                 wlandev->msdstate = WLAN_MSD_HWPRESENT;
 915                 result = prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload);
 916                 if (result != P80211ENUM_resultcode_success) {
 917                         printk(KERN_ERR "prism2sta_ifstate(fwload) failed,"
 918                                "P80211ENUM_resultcode=%d\n", result);
 919                         msg->resultcode.data =
 920                             P80211ENUM_resultcode_implementation_failure;
 921                         result = -1;
 922                 }
 923         }
 924
 925         return 0;
 926 }
 927
 928 /*----------------------------------------------------------------
 929 * prism2mgmt_flashdl_write
 930 *
 931 *
 932 *
 933 * Arguments:
 934 *       wlandev         wlan device structure
 935 *       msgp            ptr to msg buffer
 936 *
 937 * Returns:
 938 *       0       success and done
 939 *       <0      success, but we're waiting for something to finish.
 940 *       >0      an error occurred while handling the message.
 941 * Side effects:
 942 *
 943 * Call context:
 944 *       process thread  (usually)
 945 ----------------------------------------------------------------*/
 946 int prism2mgmt_flashdl_write(wlandevice_t *wlandev, void *msgp)
 947 {
 948         hfa384x_t *hw = wlandev->priv;
 949         p80211msg_p2req_flashdl_write_t *msg = msgp;
 950         u32 addr;
 951         u32 len;
 952         u8 *buf;
 953
 954         if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
 955                 printk(KERN_ERR
 956                        "flashdl_write(): may only be called "
 957                        "in the fwload state.\n");
 958                 msg->resultcode.data =
 959                     P80211ENUM_resultcode_implementation_failure;
 960                 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 961                 return 0;
 962         }
 963
 964         /*
 965          ** Note: Interrupts are locked out if this is an AP and are NOT
 966          ** locked out if this is a station.
 967          */
 968
 969         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 970         /* first validate the length */
 971         if (msg->len.data > sizeof(msg->data.data)) {
 972                 msg->resultcode.status =
 973                     P80211ENUM_resultcode_invalid_parameters;
 974                 return 0;
 975         }
 976         /* call the hfa384x function to do the write */
 977         addr = msg->addr.data;
 978         len = msg->len.data;
 979         buf = msg->data.data;
 980         if (hfa384x_drvr_flashdl_write(hw, addr, buf, len))
 981                 msg->resultcode.data = P80211ENUM_resultcode_refused;
 982
 983         msg->resultcode.data = P80211ENUM_resultcode_success;
 984
 985         return 0;
 986 }
 987
 988 /*----------------------------------------------------------------
 989 * prism2mgmt_autojoin
 990 *
 991 * Associate with an ESS.
 992 *
 993 * Arguments:
 994 *       wlandev         wlan device structure
 995 *       msgp            ptr to msg buffer
 996 *
 997 * Returns:
 998 *       0       success and done
 999 *       <0      success, but we're waiting for something to finish.
1000 *       >0      an error occurred while handling the message.
1001 * Side effects:
1002 *
1003 * Call context:
1004 *       process thread  (usually)
1005 *       interrupt
1006 ----------------------------------------------------------------*/
1007 int prism2mgmt_autojoin(wlandevice_t *wlandev, void *msgp)
1008 {
1009         hfa384x_t *hw = wlandev->priv;
1010         int result = 0;
1011         u16 reg;
1012         u16 port_type;
1013         p80211msg_lnxreq_autojoin_t *msg = msgp;
1014         p80211pstrd_t *pstr;
1015         u8 bytebuf[256];
1016         hfa384x_bytestr_t *p2bytestr = (hfa384x_bytestr_t *) bytebuf;
1017
1018         wlandev->macmode = WLAN_MACMODE_NONE;
1019
1020         /* Set the SSID */
1021         memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
1022
1023         /* Disable the Port */
1024         hfa384x_drvr_disable(hw, 0);
1025
1026         /*** STATION ***/
1027         /* Set the TxRates */
1028         hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, 0x000f);
1029
1030         /* Set the auth type */
1031         if (msg->authtype.data == P80211ENUM_authalg_sharedkey)
1032                 reg = HFA384x_CNFAUTHENTICATION_SHAREDKEY;
1033         else
1034                 reg = HFA384x_CNFAUTHENTICATION_OPENSYSTEM;
1035
1036         hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAUTHENTICATION, reg);
1037
1038         /* Set the ssid */
1039         memset(bytebuf, 0, 256);
1040         pstr = (p80211pstrd_t *)&(msg->ssid.data);
1041         prism2mgmt_pstr2bytestr(p2bytestr, pstr);
1042         result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
1043                                         bytebuf,
1044                                         HFA384x_RID_CNFDESIREDSSID_LEN);
1045         port_type = HFA384x_PORTTYPE_BSS;
1046         /* Set the PortType */
1047         hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, port_type);
1048
1049         /* Enable the Port */
1050         hfa384x_drvr_enable(hw, 0);
1051
1052         /* Set the resultcode */
1053         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
1054         msg->resultcode.data = P80211ENUM_resultcode_success;
1055
1056         return result;
1057 }
1058
1059 /*----------------------------------------------------------------
1060 * prism2mgmt_wlansniff
1061 *
1062 * Start or stop sniffing.
1063 *
1064 * Arguments:
1065 *       wlandev         wlan device structure
1066 *       msgp            ptr to msg buffer
1067 *
1068 * Returns:
1069 *       0       success and done
1070 *       <0      success, but we're waiting for something to finish.
1071 *       >0      an error occurred while handling the message.
1072 * Side effects:
1073 *
1074 * Call context:
1075 *       process thread  (usually)
1076 *       interrupt
1077 ----------------------------------------------------------------*/
1078 int prism2mgmt_wlansniff(wlandevice_t *wlandev, void *msgp)
1079 {
1080         int result = 0;
1081         p80211msg_lnxreq_wlansniff_t *msg = msgp;
1082
1083         hfa384x_t *hw = wlandev->priv;
1084         u16 word;
1085
1086         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
1087         switch (msg->enable.data) {
1088         case P80211ENUM_truth_false:
1089                 /* Confirm that we're in monitor mode */
1090                 if (wlandev->netdev->type == ARPHRD_ETHER) {
1091                         msg->resultcode.data =
1092                             P80211ENUM_resultcode_invalid_parameters;
1093                         result = 0;
1094                         goto exit;
1095                 }
1096                 /* Disable monitor mode */
1097                 result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_DISABLE);
1098                 if (result) {
1099                         printk(KERN_DEBUG
1100                                "failed to disable monitor mode, result=%d\n",
1101                                result);
1102                         goto failed;
1103                 }
1104                 /* Disable port 0 */
1105                 result = hfa384x_drvr_disable(hw, 0);
1106                 if (result) {
1107                         printk(KERN_DEBUG
1108                                "failed to disable port 0 after sniffing, result=%d\n",
1109                                result);
1110                         goto failed;
1111                 }
1112                 /* Clear the driver state */
1113                 wlandev->netdev->type = ARPHRD_ETHER;
1114
1115                 /* Restore the wepflags */
1116                 result = hfa384x_drvr_setconfig16(hw,
1117                                                   HFA384x_RID_CNFWEPFLAGS,
1118                                                   hw->presniff_wepflags);
1119                 if (result) {
1120                         printk(KERN_DEBUG
1121                                "failed to restore wepflags=0x%04x, result=%d\n",
1122                                hw->presniff_wepflags, result);
1123                         goto failed;
1124                 }
1125
1126                 /* Set the port to its prior type and enable (if necessary) */
1127                 if (hw->presniff_port_type != 0) {
1128                         word = hw->presniff_port_type;
1129                         result = hfa384x_drvr_setconfig16(hw,
1130                                                           HFA384x_RID_CNFPORTTYPE,
1131                                                           word);
1132                         if (result) {
1133                                 printk(KERN_DEBUG
1134                                        "failed to restore porttype, result=%d\n",
1135                                        result);
1136                                 goto failed;
1137                         }
1138
1139                         /* Enable the port */
1140                         result = hfa384x_drvr_enable(hw, 0);
1141                         if (result) {
1142                                 printk(KERN_DEBUG
1143                                        "failed to enable port to presniff setting, result=%d\n",
1144                                        result);
1145                                 goto failed;
1146                         }
1147                 } else {
1148                         result = hfa384x_drvr_disable(hw, 0);
1149
1150                 }
1151
1152                 printk(KERN_INFO "monitor mode disabled\n");
1153                 msg->resultcode.data = P80211ENUM_resultcode_success;
1154                 result = 0;
1155                 goto exit;
1156                 break;
1157         case P80211ENUM_truth_true:
1158                 /* Disable the port (if enabled), only check Port 0 */
1159                 if (hw->port_enabled[0]) {
1160                         if (wlandev->netdev->type == ARPHRD_ETHER) {
1161                                 /* Save macport 0 state */
1162                                 result = hfa384x_drvr_getconfig16(hw,
1163                                                                   HFA384x_RID_CNFPORTTYPE,
1164                                                                   &(hw->
1165                                                                     presniff_port_type));
1166                                 if (result) {
1167                                         printk(KERN_DEBUG
1168                                                "failed to read porttype, result=%d\n",
1169                                                result);
1170                                         goto failed;
1171                                 }
1172                                 /* Save the wepflags state */
1173                                 result = hfa384x_drvr_getconfig16(hw,
1174                                                                   HFA384x_RID_CNFWEPFLAGS,
1175                                                                   &(hw->
1176                                                                     presniff_wepflags));
1177                                 if (result) {
1178                                         printk(KERN_DEBUG
1179                                                "failed to read wepflags, result=%d\n",
1180                                                result);
1181                                         goto failed;
1182                                 }
1183                                 hfa384x_drvr_stop(hw);
1184                                 result = hfa384x_drvr_start(hw);
1185                                 if (result) {
1186                                         printk(KERN_DEBUG
1187                                                "failed to restart the card for sniffing, result=%d\n",
1188                                                result);
1189                                         goto failed;
1190                                 }
1191                         } else {
1192                                 /* Disable the port */
1193                                 result = hfa384x_drvr_disable(hw, 0);
1194                                 if (result) {
1195                                         printk(KERN_DEBUG
1196                                                "failed to enable port for sniffing, result=%d\n",
1197                                                result);
1198                                         goto failed;
1199                                 }
1200                         }
1201                 } else {
1202                         hw->presniff_port_type = 0;
1203                 }
1204
1205                 /* Set the channel we wish to sniff  */
1206                 word = msg->channel.data;
1207                 result = hfa384x_drvr_setconfig16(hw,
1208                                                   HFA384x_RID_CNFOWNCHANNEL,
1209                                                   word);
1210                 hw->sniff_channel = word;
1211
1212                 if (result) {
1213                         printk(KERN_DEBUG
1214                                "failed to set channel %d, result=%d\n",
1215                                word, result);
1216                         goto failed;
1217                 }
1218
1219                 /* Now if we're already sniffing, we can skip the rest */
1220                 if (wlandev->netdev->type != ARPHRD_ETHER) {
1221                         /* Set the port type to pIbss */
1222                         word = HFA384x_PORTTYPE_PSUEDOIBSS;
1223                         result = hfa384x_drvr_setconfig16(hw,
1224                                                           HFA384x_RID_CNFPORTTYPE,
1225                                                           word);
1226                         if (result) {
1227                                 printk(KERN_DEBUG
1228                                        "failed to set porttype %d, result=%d\n",
1229                                        word, result);
1230                                 goto failed;
1231                         }
1232                         if ((msg->keepwepflags.status ==
1233                              P80211ENUM_msgitem_status_data_ok)
1234                             && (msg->keepwepflags.data !=
1235                                 P80211ENUM_truth_true)) {
1236                                 /* Set the wepflags for no decryption */
1237                                 word = HFA384x_WEPFLAGS_DISABLE_TXCRYPT |
1238                                     HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
1239                                 result =
1240                                     hfa384x_drvr_setconfig16(hw,
1241                                                              HFA384x_RID_CNFWEPFLAGS,
1242                                                              word);
1243                         }
1244
1245                         if (result) {
1246                                 printk(KERN_DEBUG
1247                                        "failed to set wepflags=0x%04x, result=%d\n",
1248                                        word, result);
1249                                 goto failed;
1250                         }
1251                 }
1252
1253                 /* Do we want to strip the FCS in monitor mode? */
1254                 if ((msg->stripfcs.status == P80211ENUM_msgitem_status_data_ok)
1255                     && (msg->stripfcs.data == P80211ENUM_truth_true)) {
1256                         hw->sniff_fcs = 0;
1257                 } else {
1258                         hw->sniff_fcs = 1;
1259                 }
1260
1261                 /* Do we want to truncate the packets? */
1262                 if (msg->packet_trunc.status ==
1263                     P80211ENUM_msgitem_status_data_ok) {
1264                         hw->sniff_truncate = msg->packet_trunc.data;
1265                 } else {
1266                         hw->sniff_truncate = 0;
1267                 }
1268
1269                 /* Enable the port */
1270                 result = hfa384x_drvr_enable(hw, 0);
1271                 if (result) {
1272                         printk(KERN_DEBUG
1273                                "failed to enable port for sniffing, result=%d\n",
1274                                result);
1275                         goto failed;
1276                 }
1277                 /* Enable monitor mode */
1278                 result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_ENABLE);
1279                 if (result) {
1280                         printk(KERN_DEBUG
1281                                "failed to enable monitor mode, result=%d\n",
1282                                result);
1283                         goto failed;
1284                 }
1285
1286                 if (wlandev->netdev->type == ARPHRD_ETHER)
1287                         printk(KERN_INFO "monitor mode enabled\n");
1288
1289                 /* Set the driver state */
1290                 /* Do we want the prism2 header? */
1291                 if ((msg->prismheader.status ==
1292                      P80211ENUM_msgitem_status_data_ok)
1293                     && (msg->prismheader.data == P80211ENUM_truth_true)) {
1294                         hw->sniffhdr = 0;
1295                         wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
1296                 } else
1297                     if ((msg->wlanheader.status ==
1298                          P80211ENUM_msgitem_status_data_ok)
1299                         && (msg->wlanheader.data == P80211ENUM_truth_true)) {
1300                         hw->sniffhdr = 1;
1301                         wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
1302                 } else {
1303                         wlandev->netdev->type = ARPHRD_IEEE80211;
1304                 }
1305
1306                 msg->resultcode.data = P80211ENUM_resultcode_success;
1307                 result = 0;
1308                 goto exit;
1309                 break;
1310         default:
1311                 msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
1312                 result = 0;
1313                 goto exit;
1314                 break;
1315         }
1316
1317 failed:
1318         msg->resultcode.data = P80211ENUM_resultcode_refused;
1319         result = 0;
1320 exit:
1321         return result;
1322 }