drivers/staging/wlan-ng/prism2mib.c

   1 /* src/prism2/driver/prism2mib.c
   2 *
   3 * Management request for mibset/mibget
   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 the mibset/mibget management
  48 * functions.
  49 *
  50 * --------------------------------------------------------------------
  51 */
  52
  53 #include <linux/module.h>
  54 #include <linux/kernel.h>
  55 #include <linux/sched.h>
  56 #include <linux/types.h>
  57 #include <linux/wireless.h>
  58 #include <linux/netdevice.h>
  59 #include <linux/io.h>
  60 #include <linux/delay.h>
  61 #include <asm/byteorder.h>
  62 #include <linux/usb.h>
  63 #include <linux/bitops.h>
  64
  65 #include "p80211types.h"
  66 #include "p80211hdr.h"
  67 #include "p80211mgmt.h"
  68 #include "p80211conv.h"
  69 #include "p80211msg.h"
  70 #include "p80211netdev.h"
  71 #include "p80211metadef.h"
  72 #include "p80211metastruct.h"
  73 #include "hfa384x.h"
  74 #include "prism2mgmt.h"
  75
  76 #define MIB_TMP_MAXLEN    200   /* Max length of RID record (in bytes). */
  77
  78 #define  F_STA        0x1       /* MIB is supported on stations. */
  79 #define  F_READ       0x2       /* MIB may be read. */
  80 #define  F_WRITE      0x4       /* MIB may be written. */
  81
  82 typedef struct mibrec {
  83         u32 did;
  84         u16 flag;
  85         u16 parm1;
  86         u16 parm2;
  87         u16 parm3;
  88         int (*func) (struct mibrec *mib,
  89                      int isget,
  90                      wlandevice_t *wlandev,
  91                      hfa384x_t *hw,
  92                      p80211msg_dot11req_mibset_t *msg, void *data);
  93 } mibrec_t;
  94
  95 static int prism2mib_bytearea2pstr(mibrec_t *mib,
  96                                    int isget,
  97                                    wlandevice_t *wlandev,
  98                                    hfa384x_t *hw,
  99                                    p80211msg_dot11req_mibset_t *msg,
 100                                    void *data);
 101
 102 static int prism2mib_uint32(mibrec_t *mib,
 103                             int isget,
 104                             wlandevice_t *wlandev,
 105                             hfa384x_t *hw,
 106                             p80211msg_dot11req_mibset_t *msg, void *data);
 107
 108 static int prism2mib_flag(mibrec_t *mib,
 109                           int isget,
 110                           wlandevice_t *wlandev,
 111                           hfa384x_t *hw,
 112                           p80211msg_dot11req_mibset_t *msg, void *data);
 113
 114 static int prism2mib_wepdefaultkey(mibrec_t *mib,
 115                                    int isget,
 116                                    wlandevice_t *wlandev,
 117                                    hfa384x_t *hw,
 118                                    p80211msg_dot11req_mibset_t *msg,
 119                                    void *data);
 120
 121 static int prism2mib_privacyinvoked(mibrec_t *mib,
 122                                     int isget,
 123                                     wlandevice_t *wlandev,
 124                                     hfa384x_t *hw,
 125                                     p80211msg_dot11req_mibset_t *msg,
 126                                     void *data);
 127
 128 static int prism2mib_excludeunencrypted(mibrec_t *mib,
 129                                         int isget,
 130                                         wlandevice_t *wlandev,
 131                                         hfa384x_t *hw,
 132                                         p80211msg_dot11req_mibset_t *msg,
 133                                         void *data);
 134
 135 static int prism2mib_fragmentationthreshold(mibrec_t *mib,
 136                                             int isget,
 137                                             wlandevice_t *wlandev,
 138                                             hfa384x_t *hw,
 139                                             p80211msg_dot11req_mibset_t *msg,
 140                                             void *data);
 141
 142 static int prism2mib_priv(mibrec_t *mib,
 143                           int isget,
 144                           wlandevice_t *wlandev,
 145                           hfa384x_t *hw,
 146                           p80211msg_dot11req_mibset_t *msg, void *data);
 147
 148 static mibrec_t mibtab[] = {
 149
 150         /* dot11smt MIB's */
 151         {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0,
 152          F_STA | F_WRITE,
 153          HFA384x_RID_CNFWEPDEFAULTKEY0, 0, 0,
 154          prism2mib_wepdefaultkey},
 155         {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1,
 156          F_STA | F_WRITE,
 157          HFA384x_RID_CNFWEPDEFAULTKEY1, 0, 0,
 158          prism2mib_wepdefaultkey},
 159         {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2,
 160          F_STA | F_WRITE,
 161          HFA384x_RID_CNFWEPDEFAULTKEY2, 0, 0,
 162          prism2mib_wepdefaultkey},
 163         {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3,
 164          F_STA | F_WRITE,
 165          HFA384x_RID_CNFWEPDEFAULTKEY3, 0, 0,
 166          prism2mib_wepdefaultkey},
 167         {DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
 168          F_STA | F_READ | F_WRITE,
 169          HFA384x_RID_CNFWEPFLAGS, HFA384x_WEPFLAGS_PRIVINVOKED, 0,
 170          prism2mib_privacyinvoked},
 171         {DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID,
 172          F_STA | F_READ | F_WRITE,
 173          HFA384x_RID_CNFWEPDEFAULTKEYID, 0, 0,
 174          prism2mib_uint32},
 175         {DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
 176          F_STA | F_READ | F_WRITE,
 177          HFA384x_RID_CNFWEPFLAGS, HFA384x_WEPFLAGS_EXCLUDE, 0,
 178          prism2mib_excludeunencrypted},
 179
 180         /* dot11mac MIB's */
 181
 182         {DIDmib_dot11mac_dot11OperationTable_dot11MACAddress,
 183          F_STA | F_READ | F_WRITE,
 184          HFA384x_RID_CNFOWNMACADDR, HFA384x_RID_CNFOWNMACADDR_LEN, 0,
 185          prism2mib_bytearea2pstr},
 186         {DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold,
 187          F_STA | F_READ | F_WRITE,
 188          HFA384x_RID_RTSTHRESH, 0, 0,
 189          prism2mib_uint32},
 190         {DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit,
 191          F_STA | F_READ,
 192          HFA384x_RID_SHORTRETRYLIMIT, 0, 0,
 193          prism2mib_uint32},
 194         {DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit,
 195          F_STA | F_READ,
 196          HFA384x_RID_LONGRETRYLIMIT, 0, 0,
 197          prism2mib_uint32},
 198         {DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold,
 199          F_STA | F_READ | F_WRITE,
 200          HFA384x_RID_FRAGTHRESH, 0, 0,
 201          prism2mib_fragmentationthreshold},
 202         {DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime,
 203          F_STA | F_READ,
 204          HFA384x_RID_MAXTXLIFETIME, 0, 0,
 205          prism2mib_uint32},
 206
 207         /* dot11phy MIB's */
 208
 209         {DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel,
 210          F_STA | F_READ,
 211          HFA384x_RID_CURRENTCHANNEL, 0, 0,
 212          prism2mib_uint32},
 213         {DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel,
 214          F_STA | F_READ | F_WRITE,
 215          HFA384x_RID_TXPOWERMAX, 0, 0,
 216          prism2mib_uint32},
 217
 218         /* p2Static MIB's */
 219
 220         {DIDmib_p2_p2Static_p2CnfPortType,
 221          F_STA | F_READ | F_WRITE,
 222          HFA384x_RID_CNFPORTTYPE, 0, 0,
 223          prism2mib_uint32},
 224
 225         /* p2MAC MIB's */
 226
 227         {DIDmib_p2_p2MAC_p2CurrentTxRate,
 228          F_STA | F_READ,
 229          HFA384x_RID_CURRENTTXRATE, 0, 0,
 230          prism2mib_uint32},
 231
 232         /* And finally, lnx mibs */
 233         {DIDmib_lnx_lnxConfigTable_lnxRSNAIE,
 234          F_STA | F_READ | F_WRITE,
 235          HFA384x_RID_CNFWPADATA, 0, 0,
 236          prism2mib_priv},
 237         {0, 0, 0, 0, 0, NULL}
 238 };
 239
 240 /*----------------------------------------------------------------
 241 * prism2mgmt_mibset_mibget
 242 *
 243 * Set the value of a mib item.
 244 *
 245 * Arguments:
 246 *       wlandev         wlan device structure
 247 *       msgp            ptr to msg buffer
 248 *
 249 * Returns:
 250 *       0       success and done
 251 *       <0      success, but we're waiting for something to finish.
 252 *       >0      an error occurred while handling the message.
 253 * Side effects:
 254 *
 255 * Call context:
 256 *       process thread  (usually)
 257 *       interrupt
 258 ----------------------------------------------------------------*/
 259
 260 int prism2mgmt_mibset_mibget(wlandevice_t *wlandev, void *msgp)
 261 {
 262         hfa384x_t *hw = wlandev->priv;
 263         int result, isget;
 264         mibrec_t *mib;
 265
 266         u16 which;
 267
 268         p80211msg_dot11req_mibset_t *msg = msgp;
 269         p80211itemd_t *mibitem;
 270
 271         msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
 272         msg->resultcode.data = P80211ENUM_resultcode_success;
 273
 274         /*
 275          ** Determine if this is an Access Point or a station.
 276          */
 277
 278         which = F_STA;
 279
 280         /*
 281          ** Find the MIB in the MIB table.  Note that a MIB may be in the
 282          ** table twice...once for an AP and once for a station.  Make sure
 283          ** to get the correct one.  Note that DID=0 marks the end of the
 284          ** MIB table.
 285          */
 286
 287         mibitem = (p80211itemd_t *) msg->mibattribute.data;
 288
 289         for (mib = mibtab; mib->did != 0; mib++)
 290                 if (mib->did == mibitem->did && (mib->flag & which))
 291                         break;
 292
 293         if (mib->did == 0) {
 294                 msg->resultcode.data = P80211ENUM_resultcode_not_supported;
 295                 goto done;
 296         }
 297
 298         /*
 299          ** Determine if this is a "mibget" or a "mibset".  If this is a
 300          ** "mibget", then make sure that the MIB may be read.  Otherwise,
 301          ** this is a "mibset" so make make sure that the MIB may be written.
 302          */
 303
 304         isget = (msg->msgcode == DIDmsg_dot11req_mibget);
 305
 306         if (isget) {
 307                 if (!(mib->flag & F_READ)) {
 308                         msg->resultcode.data =
 309                             P80211ENUM_resultcode_cant_get_writeonly_mib;
 310                         goto done;
 311                 }
 312         } else {
 313                 if (!(mib->flag & F_WRITE)) {
 314                         msg->resultcode.data =
 315                             P80211ENUM_resultcode_cant_set_readonly_mib;
 316                         goto done;
 317                 }
 318         }
 319
 320         /*
 321          ** Execute the MIB function.  If things worked okay, then make
 322          ** sure that the MIB function also worked okay.  If so, and this
 323          ** is a "mibget", then the status value must be set for both the
 324          ** "mibattribute" parameter and the mib item within the data
 325          ** portion of the "mibattribute".
 326          */
 327
 328         result = mib->func(mib, isget, wlandev, hw, msg, (void *)mibitem->data);
 329
 330         if (msg->resultcode.data == P80211ENUM_resultcode_success) {
 331                 if (result != 0) {
 332                         pr_debug("get/set failure, result=%d\n", result);
 333                         msg->resultcode.data =
 334                             P80211ENUM_resultcode_implementation_failure;
 335                 } else {
 336                         if (isget) {
 337                                 msg->mibattribute.status =
 338                                     P80211ENUM_msgitem_status_data_ok;
 339                                 mibitem->status =
 340                                     P80211ENUM_msgitem_status_data_ok;
 341                         }
 342                 }
 343         }
 344
 345 done:
 346         return 0;
 347 }
 348
 349 /*----------------------------------------------------------------
 350 * prism2mib_bytearea2pstr
 351 *
 352 * Get/set pstr data to/from a byte area.
 353 *
 354 * MIB record parameters:
 355 *       parm1    Prism2 RID value.
 356 *       parm2    Number of bytes of RID data.
 357 *       parm3    Not used.
 358 *
 359 * Arguments:
 360 *       mib      MIB record.
 361 *       isget    MIBGET/MIBSET flag.
 362 *       wlandev  wlan device structure.
 363 *       priv     "priv" structure.
 364 *       hw       "hw" structure.
 365 *       msg      Message structure.
 366 *       data     Data buffer.
 367 *
 368 * Returns:
 369 *       0   - Success.
 370 *       ~0  - Error.
 371 *
 372 ----------------------------------------------------------------*/
 373
 374 static int prism2mib_bytearea2pstr(mibrec_t *mib,
 375                                    int isget,
 376                                    wlandevice_t *wlandev,
 377                                    hfa384x_t *hw,
 378                                    p80211msg_dot11req_mibset_t *msg,
 379                                    void *data)
 380 {
 381         int result;
 382         p80211pstrd_t *pstr = (p80211pstrd_t *) data;
 383         u8 bytebuf[MIB_TMP_MAXLEN];
 384
 385         if (isget) {
 386                 result =
 387                     hfa384x_drvr_getconfig(hw, mib->parm1, bytebuf, mib->parm2);
 388                 prism2mgmt_bytearea2pstr(bytebuf, pstr, mib->parm2);
 389         } else {
 390                 memset(bytebuf, 0, mib->parm2);
 391                 prism2mgmt_pstr2bytearea(bytebuf, pstr);
 392                 result =
 393                     hfa384x_drvr_setconfig(hw, mib->parm1, bytebuf, mib->parm2);
 394         }
 395
 396         return result;
 397 }
 398
 399 /*----------------------------------------------------------------
 400 * prism2mib_uint32
 401 *
 402 * Get/set uint32 data.
 403 *
 404 * MIB record parameters:
 405 *       parm1    Prism2 RID value.
 406 *       parm2    Not used.
 407 *       parm3    Not used.
 408 *
 409 * Arguments:
 410 *       mib      MIB record.
 411 *       isget    MIBGET/MIBSET flag.
 412 *       wlandev  wlan device structure.
 413 *       priv     "priv" structure.
 414 *       hw       "hw" structure.
 415 *       msg      Message structure.
 416 *       data     Data buffer.
 417 *
 418 * Returns:
 419 *       0   - Success.
 420 *       ~0  - Error.
 421 *
 422 ----------------------------------------------------------------*/
 423
 424 static int prism2mib_uint32(mibrec_t *mib,
 425                             int isget,
 426                             wlandevice_t *wlandev,
 427                             hfa384x_t *hw,
 428                             p80211msg_dot11req_mibset_t *msg, void *data)
 429 {
 430         int result;
 431         u32 *uint32 = (u32 *) data;
 432         u8 bytebuf[MIB_TMP_MAXLEN];
 433         u16 *wordbuf = (u16 *) bytebuf;
 434
 435         if (isget) {
 436                 result = hfa384x_drvr_getconfig16(hw, mib->parm1, wordbuf);
 437                 *uint32 = *wordbuf;
 438         } else {
 439                 *wordbuf = *uint32;
 440                 result = hfa384x_drvr_setconfig16(hw, mib->parm1, *wordbuf);
 441         }
 442
 443         return result;
 444 }
 445
 446 /*----------------------------------------------------------------
 447 * prism2mib_flag
 448 *
 449 * Get/set a flag.
 450 *
 451 * MIB record parameters:
 452 *       parm1    Prism2 RID value.
 453 *       parm2    Bit to get/set.
 454 *       parm3    Not used.
 455 *
 456 * Arguments:
 457 *       mib      MIB record.
 458 *       isget    MIBGET/MIBSET flag.
 459 *       wlandev  wlan device structure.
 460 *       priv     "priv" structure.
 461 *       hw       "hw" structure.
 462 *       msg      Message structure.
 463 *       data     Data buffer.
 464 *
 465 * Returns:
 466 *       0   - Success.
 467 *       ~0  - Error.
 468 *
 469 ----------------------------------------------------------------*/
 470
 471 static int prism2mib_flag(mibrec_t *mib,
 472                           int isget,
 473                           wlandevice_t *wlandev,
 474                           hfa384x_t *hw,
 475                           p80211msg_dot11req_mibset_t *msg, void *data)
 476 {
 477         int result;
 478         u32 *uint32 = (u32 *) data;
 479         u8 bytebuf[MIB_TMP_MAXLEN];
 480         u16 *wordbuf = (u16 *) bytebuf;
 481         u32 flags;
 482
 483         result = hfa384x_drvr_getconfig16(hw, mib->parm1, wordbuf);
 484         if (result == 0) {
 485                 flags = *wordbuf;
 486                 if (isget) {
 487                         *uint32 = (flags & mib->parm2) ?
 488                             P80211ENUM_truth_true : P80211ENUM_truth_false;
 489                 } else {
 490                         if ((*uint32) == P80211ENUM_truth_true)
 491                                 flags |= mib->parm2;
 492                         else
 493                                 flags &= ~mib->parm2;
 494                         *wordbuf = flags;
 495                         result =
 496                             hfa384x_drvr_setconfig16(hw, mib->parm1, *wordbuf);
 497                 }
 498         }
 499
 500         return result;
 501 }
 502
 503 /*----------------------------------------------------------------
 504 * prism2mib_wepdefaultkey
 505 *
 506 * Get/set WEP default keys.
 507 *
 508 * MIB record parameters:
 509 *       parm1    Prism2 RID value.
 510 *       parm2    Number of bytes of RID data.
 511 *       parm3    Not used.
 512 *
 513 * Arguments:
 514 *       mib      MIB record.
 515 *       isget    MIBGET/MIBSET flag.
 516 *       wlandev  wlan device structure.
 517 *       priv     "priv" structure.
 518 *       hw       "hw" structure.
 519 *       msg      Message structure.
 520 *       data     Data buffer.
 521 *
 522 * Returns:
 523 *       0   - Success.
 524 *       ~0  - Error.
 525 *
 526 ----------------------------------------------------------------*/
 527
 528 static int prism2mib_wepdefaultkey(mibrec_t *mib,
 529                                    int isget,
 530                                    wlandevice_t *wlandev,
 531                                    hfa384x_t *hw,
 532                                    p80211msg_dot11req_mibset_t *msg,
 533                                    void *data)
 534 {
 535         int result;
 536         p80211pstrd_t *pstr = (p80211pstrd_t *) data;
 537         u8 bytebuf[MIB_TMP_MAXLEN];
 538         u16 len;
 539
 540         if (isget) {
 541                 result = 0;     /* Should never happen. */
 542         } else {
 543                 len = (pstr->len > 5) ? HFA384x_RID_CNFWEP128DEFAULTKEY_LEN :
 544                     HFA384x_RID_CNFWEPDEFAULTKEY_LEN;
 545                 memset(bytebuf, 0, len);
 546                 prism2mgmt_pstr2bytearea(bytebuf, pstr);
 547                 result = hfa384x_drvr_setconfig(hw, mib->parm1, bytebuf, len);
 548         }
 549
 550         return result;
 551 }
 552
 553 /*----------------------------------------------------------------
 554 * prism2mib_privacyinvoked
 555 *
 556 * Get/set the dot11PrivacyInvoked value.
 557 *
 558 * MIB record parameters:
 559 *       parm1    Prism2 RID value.
 560 *       parm2    Bit value for PrivacyInvoked flag.
 561 *       parm3    Not used.
 562 *
 563 * Arguments:
 564 *       mib      MIB record.
 565 *       isget    MIBGET/MIBSET flag.
 566 *       wlandev  wlan device structure.
 567 *       priv     "priv" structure.
 568 *       hw       "hw" structure.
 569 *       msg      Message structure.
 570 *       data     Data buffer.
 571 *
 572 * Returns:
 573 *       0   - Success.
 574 *       ~0  - Error.
 575 *
 576 ----------------------------------------------------------------*/
 577
 578 static int prism2mib_privacyinvoked(mibrec_t *mib,
 579                                     int isget,
 580                                     wlandevice_t *wlandev,
 581                                     hfa384x_t *hw,
 582                                     p80211msg_dot11req_mibset_t *msg,
 583                                     void *data)
 584 {
 585         int result;
 586
 587         if (wlandev->hostwep & HOSTWEP_DECRYPT) {
 588                 if (wlandev->hostwep & HOSTWEP_DECRYPT)
 589                         mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
 590                 if (wlandev->hostwep & HOSTWEP_ENCRYPT)
 591                         mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_TXCRYPT;
 592         }
 593
 594         result = prism2mib_flag(mib, isget, wlandev, hw, msg, data);
 595
 596         return result;
 597 }
 598
 599 /*----------------------------------------------------------------
 600 * prism2mib_excludeunencrypted
 601 *
 602 * Get/set the dot11ExcludeUnencrypted value.
 603 *
 604 * MIB record parameters:
 605 *       parm1    Prism2 RID value.
 606 *       parm2    Bit value for ExcludeUnencrypted flag.
 607 *       parm3    Not used.
 608 *
 609 * Arguments:
 610 *       mib      MIB record.
 611 *       isget    MIBGET/MIBSET flag.
 612 *       wlandev  wlan device structure.
 613 *       priv     "priv" structure.
 614 *       hw       "hw" structure.
 615 *       msg      Message structure.
 616 *       data     Data buffer.
 617 *
 618 * Returns:
 619 *       0   - Success.
 620 *       ~0  - Error.
 621 *
 622 ----------------------------------------------------------------*/
 623
 624 static int prism2mib_excludeunencrypted(mibrec_t *mib,
 625                                         int isget,
 626                                         wlandevice_t *wlandev,
 627                                         hfa384x_t *hw,
 628                                         p80211msg_dot11req_mibset_t *msg,
 629                                         void *data)
 630 {
 631         int result;
 632
 633         result = prism2mib_flag(mib, isget, wlandev, hw, msg, data);
 634
 635         return result;
 636 }
 637
 638 /*----------------------------------------------------------------
 639 * prism2mib_fragmentationthreshold
 640 *
 641 * Get/set the fragmentation threshold.
 642 *
 643 * MIB record parameters:
 644 *       parm1    Prism2 RID value.
 645 *       parm2    Not used.
 646 *       parm3    Not used.
 647 *
 648 * Arguments:
 649 *       mib      MIB record.
 650 *       isget    MIBGET/MIBSET flag.
 651 *       wlandev  wlan device structure.
 652 *       priv     "priv" structure.
 653 *       hw       "hw" structure.
 654 *       msg      Message structure.
 655 *       data     Data buffer.
 656 *
 657 * Returns:
 658 *       0   - Success.
 659 *       ~0  - Error.
 660 *
 661 ----------------------------------------------------------------*/
 662
 663 static int prism2mib_fragmentationthreshold(mibrec_t *mib,
 664                                             int isget,
 665                                             wlandevice_t *wlandev,
 666                                             hfa384x_t *hw,
 667                                             p80211msg_dot11req_mibset_t *msg,
 668                                             void *data)
 669 {
 670         int result;
 671         u32 *uint32 = (u32 *) data;
 672
 673         if (!isget)
 674                 if ((*uint32) % 2) {
 675                         printk(KERN_WARNING "Attempt to set odd number "
 676                                "FragmentationThreshold\n");
 677                         msg->resultcode.data =
 678                             P80211ENUM_resultcode_not_supported;
 679                         return 0;
 680                 }
 681
 682         result = prism2mib_uint32(mib, isget, wlandev, hw, msg, data);
 683
 684         return result;
 685 }
 686
 687 /*----------------------------------------------------------------
 688 * prism2mib_priv
 689 *
 690 * Get/set values in the "priv" data structure.
 691 *
 692 * MIB record parameters:
 693 *       parm1    Not used.
 694 *       parm2    Not used.
 695 *       parm3    Not used.
 696 *
 697 * Arguments:
 698 *       mib      MIB record.
 699 *       isget    MIBGET/MIBSET flag.
 700 *       wlandev  wlan device structure.
 701 *       priv     "priv" structure.
 702 *       hw       "hw" structure.
 703 *       msg      Message structure.
 704 *       data     Data buffer.
 705 *
 706 * Returns:
 707 *       0   - Success.
 708 *       ~0  - Error.
 709 *
 710 ----------------------------------------------------------------*/
 711
 712 static int prism2mib_priv(mibrec_t *mib,
 713                           int isget,
 714                           wlandevice_t *wlandev,
 715                           hfa384x_t *hw,
 716                           p80211msg_dot11req_mibset_t *msg, void *data)
 717 {
 718         p80211pstrd_t *pstr = (p80211pstrd_t *) data;
 719
 720         int result;
 721
 722         switch (mib->did) {
 723         case DIDmib_lnx_lnxConfigTable_lnxRSNAIE:{
 724                         hfa384x_WPAData_t wpa;
 725                         if (isget) {
 726                                 hfa384x_drvr_getconfig(hw,
 727                                                        HFA384x_RID_CNFWPADATA,
 728                                                        (u8 *) &wpa,
 729                                                        sizeof(wpa));
 730                                 pstr->len = le16_to_cpu(wpa.datalen);
 731                                 memcpy(pstr->data, wpa.data, pstr->len);
 732                         } else {
 733                                 wpa.datalen = cpu_to_le16(pstr->len);
 734                                 memcpy(wpa.data, pstr->data, pstr->len);
 735
 736                                 result =
 737                                     hfa384x_drvr_setconfig(hw,
 738                                                    HFA384x_RID_CNFWPADATA,
 739                                                    (u8 *) &wpa,
 740                                                    sizeof(wpa));
 741                         }
 742                         break;
 743                 }
 744         default:
 745                 printk(KERN_ERR "Unhandled DID 0x%08x\n", mib->did);
 746         }
 747
 748         return 0;
 749 }
 750
 751 /*----------------------------------------------------------------
 752 * prism2mgmt_pstr2bytestr
 753 *
 754 * Convert the pstr data in the WLAN message structure into an hfa384x
 755 * byte string format.
 756 *
 757 * Arguments:
 758 *       bytestr         hfa384x byte string data type
 759 *       pstr            wlan message data
 760 *
 761 * Returns:
 762 *       Nothing
 763 *
 764 ----------------------------------------------------------------*/
 765
 766 void prism2mgmt_pstr2bytestr(hfa384x_bytestr_t *bytestr, p80211pstrd_t *pstr)
 767 {
 768         bytestr->len = cpu_to_le16((u16) (pstr->len));
 769         memcpy(bytestr->data, pstr->data, pstr->len);
 770 }
 771
 772 /*----------------------------------------------------------------
 773 * prism2mgmt_pstr2bytearea
 774 *
 775 * Convert the pstr data in the WLAN message structure into an hfa384x
 776 * byte area format.
 777 *
 778 * Arguments:
 779 *       bytearea        hfa384x byte area data type
 780 *       pstr            wlan message data
 781 *
 782 * Returns:
 783 *       Nothing
 784 *
 785 ----------------------------------------------------------------*/
 786
 787 void prism2mgmt_pstr2bytearea(u8 *bytearea, p80211pstrd_t *pstr)
 788 {
 789         memcpy(bytearea, pstr->data, pstr->len);
 790 }
 791
 792 /*----------------------------------------------------------------
 793 * prism2mgmt_bytestr2pstr
 794 *
 795 * Convert the data in an hfa384x byte string format into a
 796 * pstr in the WLAN message.
 797 *
 798 * Arguments:
 799 *       bytestr         hfa384x byte string data type
 800 *       msg             wlan message
 801 *
 802 * Returns:
 803 *       Nothing
 804 *
 805 ----------------------------------------------------------------*/
 806
 807 void prism2mgmt_bytestr2pstr(hfa384x_bytestr_t *bytestr, p80211pstrd_t *pstr)
 808 {
 809         pstr->len = (u8) (le16_to_cpu((u16) (bytestr->len)));
 810         memcpy(pstr->data, bytestr->data, pstr->len);
 811 }
 812
 813 /*----------------------------------------------------------------
 814 * prism2mgmt_bytearea2pstr
 815 *
 816 * Convert the data in an hfa384x byte area format into a pstr
 817 * in the WLAN message.
 818 *
 819 * Arguments:
 820 *       bytearea        hfa384x byte area data type
 821 *       msg             wlan message
 822 *
 823 * Returns:
 824 *       Nothing
 825 *
 826 ----------------------------------------------------------------*/
 827
 828 void prism2mgmt_bytearea2pstr(u8 *bytearea, p80211pstrd_t *pstr, int len)
 829 {
 830         pstr->len = (u8) len;
 831         memcpy(pstr->data, bytearea, len);
 832 }