linux/drivers/staging/wlan-ng/prism2mib.c
<<
>>
Prefs
   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
  82struct 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                     struct p80211msg_dot11req_mibset *msg, void *data);
  93};
  94
  95static int prism2mib_bytearea2pstr(struct mibrec *mib,
  96                                   int isget,
  97                                   wlandevice_t *wlandev,
  98                                   hfa384x_t *hw,
  99                                   struct p80211msg_dot11req_mibset *msg,
 100                                   void *data);
 101
 102static int prism2mib_uint32(struct mibrec *mib,
 103                            int isget,
 104                            wlandevice_t *wlandev,
 105                            hfa384x_t *hw,
 106                            struct p80211msg_dot11req_mibset *msg, void *data);
 107
 108static int prism2mib_flag(struct mibrec *mib,
 109                          int isget,
 110                          wlandevice_t *wlandev,
 111                          hfa384x_t *hw,
 112                          struct p80211msg_dot11req_mibset *msg, void *data);
 113
 114static int prism2mib_wepdefaultkey(struct mibrec *mib,
 115                                   int isget,
 116                                   wlandevice_t *wlandev,
 117                                   hfa384x_t *hw,
 118                                   struct p80211msg_dot11req_mibset *msg,
 119                                   void *data);
 120
 121static int prism2mib_privacyinvoked(struct mibrec *mib,
 122                                    int isget,
 123                                    wlandevice_t *wlandev,
 124                                    hfa384x_t *hw,
 125                                    struct p80211msg_dot11req_mibset *msg,
 126                                    void *data);
 127
 128static int prism2mib_excludeunencrypted(struct mibrec *mib,
 129                                        int isget,
 130                                        wlandevice_t *wlandev,
 131                                        hfa384x_t *hw,
 132                                        struct p80211msg_dot11req_mibset *msg,
 133                                        void *data);
 134
 135static int prism2mib_fragmentationthreshold(struct mibrec *mib,
 136                                            int isget,
 137                                            wlandevice_t *wlandev,
 138                                            hfa384x_t *hw,
 139                                            struct p80211msg_dot11req_mibset *msg,
 140                                            void *data);
 141
 142static int prism2mib_priv(struct mibrec *mib,
 143                          int isget,
 144                          wlandevice_t *wlandev,
 145                          hfa384x_t *hw,
 146                          struct p80211msg_dot11req_mibset *msg, void *data);
 147
 148static struct mibrec 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
 260int prism2mgmt_mibset_mibget(wlandevice_t *wlandev, void *msgp)
 261{
 262        hfa384x_t *hw = wlandev->priv;
 263        int result, isget;
 264        struct mibrec *mib;
 265
 266        u16 which;
 267
 268        struct p80211msg_dot11req_mibset *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
 345done:
 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
 374static int prism2mib_bytearea2pstr(struct mibrec *mib,
 375                                   int isget,
 376                                   wlandevice_t *wlandev,
 377                                   hfa384x_t *hw,
 378                                   struct p80211msg_dot11req_mibset *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
 424static int prism2mib_uint32(struct mibrec *mib,
 425                            int isget,
 426                            wlandevice_t *wlandev,
 427                            hfa384x_t *hw,
 428                            struct p80211msg_dot11req_mibset *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
 471static int prism2mib_flag(struct mibrec *mib,
 472                          int isget,
 473                          wlandevice_t *wlandev,
 474                          hfa384x_t *hw,
 475                          struct p80211msg_dot11req_mibset *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
 528static int prism2mib_wepdefaultkey(struct mibrec *mib,
 529                                   int isget,
 530                                   wlandevice_t *wlandev,
 531                                   hfa384x_t *hw,
 532                                   struct p80211msg_dot11req_mibset *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
 578static int prism2mib_privacyinvoked(struct mibrec *mib,
 579                                    int isget,
 580                                    wlandevice_t *wlandev,
 581                                    hfa384x_t *hw,
 582                                    struct p80211msg_dot11req_mibset *msg,
 583                                    void *data)
 584{
 585        if (wlandev->hostwep & HOSTWEP_DECRYPT) {
 586                if (wlandev->hostwep & HOSTWEP_DECRYPT)
 587                        mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
 588                if (wlandev->hostwep & HOSTWEP_ENCRYPT)
 589                        mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_TXCRYPT;
 590        }
 591
 592        return prism2mib_flag(mib, isget, wlandev, hw, msg, data);
 593}
 594
 595/*----------------------------------------------------------------
 596* prism2mib_excludeunencrypted
 597*
 598* Get/set the dot11ExcludeUnencrypted value.
 599*
 600* MIB record parameters:
 601*       parm1    Prism2 RID value.
 602*       parm2    Bit value for ExcludeUnencrypted flag.
 603*       parm3    Not used.
 604*
 605* Arguments:
 606*       mib      MIB record.
 607*       isget    MIBGET/MIBSET flag.
 608*       wlandev  wlan device structure.
 609*       priv     "priv" structure.
 610*       hw       "hw" structure.
 611*       msg      Message structure.
 612*       data     Data buffer.
 613*
 614* Returns:
 615*       0   - Success.
 616*       ~0  - Error.
 617*
 618----------------------------------------------------------------*/
 619
 620static int prism2mib_excludeunencrypted(struct mibrec *mib,
 621                                        int isget,
 622                                        wlandevice_t *wlandev,
 623                                        hfa384x_t *hw,
 624                                        struct p80211msg_dot11req_mibset *msg,
 625                                        void *data)
 626{
 627
 628        return prism2mib_flag(mib, isget, wlandev, hw, msg, data);
 629}
 630
 631/*----------------------------------------------------------------
 632* prism2mib_fragmentationthreshold
 633*
 634* Get/set the fragmentation threshold.
 635*
 636* MIB record parameters:
 637*       parm1    Prism2 RID value.
 638*       parm2    Not used.
 639*       parm3    Not used.
 640*
 641* Arguments:
 642*       mib      MIB record.
 643*       isget    MIBGET/MIBSET flag.
 644*       wlandev  wlan device structure.
 645*       priv     "priv" structure.
 646*       hw       "hw" structure.
 647*       msg      Message structure.
 648*       data     Data buffer.
 649*
 650* Returns:
 651*       0   - Success.
 652*       ~0  - Error.
 653*
 654----------------------------------------------------------------*/
 655
 656static int prism2mib_fragmentationthreshold(struct mibrec *mib,
 657                                            int isget,
 658                                            wlandevice_t *wlandev,
 659                                            hfa384x_t *hw,
 660                                            struct p80211msg_dot11req_mibset *msg,
 661                                            void *data)
 662{
 663        int result;
 664        u32 *uint32 = (u32 *) data;
 665
 666        if (!isget)
 667                if ((*uint32) % 2) {
 668                        netdev_warn(wlandev->netdev,
 669                                    "Attempt to set odd number FragmentationThreshold\n");
 670                        msg->resultcode.data =
 671                            P80211ENUM_resultcode_not_supported;
 672                        return 0;
 673                }
 674
 675        result = prism2mib_uint32(mib, isget, wlandev, hw, msg, data);
 676
 677        return result;
 678}
 679
 680/*----------------------------------------------------------------
 681* prism2mib_priv
 682*
 683* Get/set values in the "priv" data structure.
 684*
 685* MIB record parameters:
 686*       parm1    Not used.
 687*       parm2    Not used.
 688*       parm3    Not used.
 689*
 690* Arguments:
 691*       mib      MIB record.
 692*       isget    MIBGET/MIBSET flag.
 693*       wlandev  wlan device structure.
 694*       priv     "priv" structure.
 695*       hw       "hw" structure.
 696*       msg      Message structure.
 697*       data     Data buffer.
 698*
 699* Returns:
 700*       0   - Success.
 701*       ~0  - Error.
 702*
 703----------------------------------------------------------------*/
 704
 705static int prism2mib_priv(struct mibrec *mib,
 706                          int isget,
 707                          wlandevice_t *wlandev,
 708                          hfa384x_t *hw,
 709                          struct p80211msg_dot11req_mibset *msg, void *data)
 710{
 711        p80211pstrd_t *pstr = (p80211pstrd_t *) data;
 712
 713        switch (mib->did) {
 714        case DIDmib_lnx_lnxConfigTable_lnxRSNAIE:{
 715                        hfa384x_WPAData_t wpa;
 716
 717                        if (isget) {
 718                                hfa384x_drvr_getconfig(hw,
 719                                                       HFA384x_RID_CNFWPADATA,
 720                                                       (u8 *) &wpa,
 721                                                       sizeof(wpa));
 722                                pstr->len = le16_to_cpu(wpa.datalen);
 723                                memcpy(pstr->data, wpa.data, pstr->len);
 724                        } else {
 725                                wpa.datalen = cpu_to_le16(pstr->len);
 726                                memcpy(wpa.data, pstr->data, pstr->len);
 727
 728                                hfa384x_drvr_setconfig(hw,
 729                                                       HFA384x_RID_CNFWPADATA,
 730                                                       (u8 *) &wpa,
 731                                                       sizeof(wpa));
 732                        }
 733                        break;
 734                }
 735        default:
 736                netdev_err(wlandev->netdev, "Unhandled DID 0x%08x\n", mib->did);
 737        }
 738
 739        return 0;
 740}
 741
 742/*----------------------------------------------------------------
 743* prism2mgmt_pstr2bytestr
 744*
 745* Convert the pstr data in the WLAN message structure into an hfa384x
 746* byte string format.
 747*
 748* Arguments:
 749*       bytestr         hfa384x byte string data type
 750*       pstr            wlan message data
 751*
 752* Returns:
 753*       Nothing
 754*
 755----------------------------------------------------------------*/
 756
 757void prism2mgmt_pstr2bytestr(struct hfa384x_bytestr *bytestr,
 758                             p80211pstrd_t *pstr)
 759{
 760        bytestr->len = cpu_to_le16((u16) (pstr->len));
 761        memcpy(bytestr->data, pstr->data, pstr->len);
 762}
 763
 764/*----------------------------------------------------------------
 765* prism2mgmt_pstr2bytearea
 766*
 767* Convert the pstr data in the WLAN message structure into an hfa384x
 768* byte area format.
 769*
 770* Arguments:
 771*       bytearea        hfa384x byte area data type
 772*       pstr            wlan message data
 773*
 774* Returns:
 775*       Nothing
 776*
 777----------------------------------------------------------------*/
 778
 779void prism2mgmt_pstr2bytearea(u8 *bytearea, p80211pstrd_t *pstr)
 780{
 781        memcpy(bytearea, pstr->data, pstr->len);
 782}
 783
 784/*----------------------------------------------------------------
 785* prism2mgmt_bytestr2pstr
 786*
 787* Convert the data in an hfa384x byte string format into a
 788* pstr in the WLAN message.
 789*
 790* Arguments:
 791*       bytestr         hfa384x byte string data type
 792*       msg             wlan message
 793*
 794* Returns:
 795*       Nothing
 796*
 797----------------------------------------------------------------*/
 798
 799void prism2mgmt_bytestr2pstr(struct hfa384x_bytestr *bytestr,
 800                             p80211pstrd_t *pstr)
 801{
 802        pstr->len = (u8) (le16_to_cpu((u16) (bytestr->len)));
 803        memcpy(pstr->data, bytestr->data, pstr->len);
 804}
 805
 806/*----------------------------------------------------------------
 807* prism2mgmt_bytearea2pstr
 808*
 809* Convert the data in an hfa384x byte area format into a pstr
 810* in the WLAN message.
 811*
 812* Arguments:
 813*       bytearea        hfa384x byte area data type
 814*       msg             wlan message
 815*
 816* Returns:
 817*       Nothing
 818*
 819----------------------------------------------------------------*/
 820
 821void prism2mgmt_bytearea2pstr(u8 *bytearea, p80211pstrd_t *pstr, int len)
 822{
 823        pstr->len = (u8) len;
 824        memcpy(pstr->data, bytearea, len);
 825}
 826