linux/drivers/net/wireless/prism54/oid_mgt.c
<<
>>
Prefs
   1/*
   2 *  Copyright (C) 2003,2004 Aurelien Alleaume <slts@free.fr>
   3 *
   4 *  This program is free software; you can redistribute it and/or modify
   5 *  it under the terms of the GNU General Public License as published by
   6 *  the Free Software Foundation; either version 2 of the License
   7 *
   8 *  This program is distributed in the hope that it will be useful,
   9 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 *  GNU General Public License for more details.
  12 *
  13 *  You should have received a copy of the GNU General Public License
  14 *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  15 *
  16 */
  17
  18#include <linux/kernel.h>
  19#include <linux/slab.h>
  20
  21#include "prismcompat.h"
  22#include "islpci_dev.h"
  23#include "islpci_mgt.h"
  24#include "isl_oid.h"
  25#include "oid_mgt.h"
  26#include "isl_ioctl.h"
  27
  28/* to convert between channel and freq */
  29static const int frequency_list_bg[] = { 2412, 2417, 2422, 2427, 2432,
  30        2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484
  31};
  32
  33int
  34channel_of_freq(int f)
  35{
  36        int c = 0;
  37
  38        if ((f >= 2412) && (f <= 2484)) {
  39                while ((c < 14) && (f != frequency_list_bg[c]))
  40                        c++;
  41                return (c >= 14) ? 0 : ++c;
  42        } else if ((f >= (int) 5000) && (f <= (int) 6000)) {
  43                return ( (f - 5000) / 5 );
  44        } else
  45                return 0;
  46}
  47
  48#define OID_STRUCT(name,oid,s,t) [name] = {oid, 0, sizeof(s), t}
  49#define OID_STRUCT_C(name,oid,s,t) OID_STRUCT(name,oid,s,t | OID_FLAG_CACHED)
  50#define OID_U32(name,oid) OID_STRUCT(name,oid,u32,OID_TYPE_U32)
  51#define OID_U32_C(name,oid) OID_STRUCT_C(name,oid,u32,OID_TYPE_U32)
  52#define OID_STRUCT_MLME(name,oid) OID_STRUCT(name,oid,struct obj_mlme,OID_TYPE_MLME)
  53#define OID_STRUCT_MLMEEX(name,oid) OID_STRUCT(name,oid,struct obj_mlmeex,OID_TYPE_MLMEEX)
  54
  55#define OID_UNKNOWN(name,oid) OID_STRUCT(name,oid,0,0)
  56
  57struct oid_t isl_oid[] = {
  58        OID_STRUCT(GEN_OID_MACADDRESS, 0x00000000, u8[6], OID_TYPE_ADDR),
  59        OID_U32(GEN_OID_LINKSTATE, 0x00000001),
  60        OID_UNKNOWN(GEN_OID_WATCHDOG, 0x00000002),
  61        OID_UNKNOWN(GEN_OID_MIBOP, 0x00000003),
  62        OID_UNKNOWN(GEN_OID_OPTIONS, 0x00000004),
  63        OID_UNKNOWN(GEN_OID_LEDCONFIG, 0x00000005),
  64
  65        /* 802.11 */
  66        OID_U32_C(DOT11_OID_BSSTYPE, 0x10000000),
  67        OID_STRUCT_C(DOT11_OID_BSSID, 0x10000001, u8[6], OID_TYPE_RAW),
  68        OID_STRUCT_C(DOT11_OID_SSID, 0x10000002, struct obj_ssid,
  69                     OID_TYPE_SSID),
  70        OID_U32(DOT11_OID_STATE, 0x10000003),
  71        OID_U32(DOT11_OID_AID, 0x10000004),
  72        OID_STRUCT(DOT11_OID_COUNTRYSTRING, 0x10000005, u8[4], OID_TYPE_RAW),
  73        OID_STRUCT_C(DOT11_OID_SSIDOVERRIDE, 0x10000006, struct obj_ssid,
  74                     OID_TYPE_SSID),
  75
  76        OID_U32(DOT11_OID_MEDIUMLIMIT, 0x11000000),
  77        OID_U32_C(DOT11_OID_BEACONPERIOD, 0x11000001),
  78        OID_U32(DOT11_OID_DTIMPERIOD, 0x11000002),
  79        OID_U32(DOT11_OID_ATIMWINDOW, 0x11000003),
  80        OID_U32(DOT11_OID_LISTENINTERVAL, 0x11000004),
  81        OID_U32(DOT11_OID_CFPPERIOD, 0x11000005),
  82        OID_U32(DOT11_OID_CFPDURATION, 0x11000006),
  83
  84        OID_U32_C(DOT11_OID_AUTHENABLE, 0x12000000),
  85        OID_U32_C(DOT11_OID_PRIVACYINVOKED, 0x12000001),
  86        OID_U32_C(DOT11_OID_EXUNENCRYPTED, 0x12000002),
  87        OID_U32_C(DOT11_OID_DEFKEYID, 0x12000003),
  88        [DOT11_OID_DEFKEYX] = {0x12000004, 3, sizeof (struct obj_key),
  89                               OID_FLAG_CACHED | OID_TYPE_KEY}, /* DOT11_OID_DEFKEY1,...DOT11_OID_DEFKEY4 */
  90        OID_UNKNOWN(DOT11_OID_STAKEY, 0x12000008),
  91        OID_U32(DOT11_OID_REKEYTHRESHOLD, 0x12000009),
  92        OID_UNKNOWN(DOT11_OID_STASC, 0x1200000a),
  93
  94        OID_U32(DOT11_OID_PRIVTXREJECTED, 0x1a000000),
  95        OID_U32(DOT11_OID_PRIVRXPLAIN, 0x1a000001),
  96        OID_U32(DOT11_OID_PRIVRXFAILED, 0x1a000002),
  97        OID_U32(DOT11_OID_PRIVRXNOKEY, 0x1a000003),
  98
  99        OID_U32_C(DOT11_OID_RTSTHRESH, 0x13000000),
 100        OID_U32_C(DOT11_OID_FRAGTHRESH, 0x13000001),
 101        OID_U32_C(DOT11_OID_SHORTRETRIES, 0x13000002),
 102        OID_U32_C(DOT11_OID_LONGRETRIES, 0x13000003),
 103        OID_U32_C(DOT11_OID_MAXTXLIFETIME, 0x13000004),
 104        OID_U32(DOT11_OID_MAXRXLIFETIME, 0x13000005),
 105        OID_U32(DOT11_OID_AUTHRESPTIMEOUT, 0x13000006),
 106        OID_U32(DOT11_OID_ASSOCRESPTIMEOUT, 0x13000007),
 107
 108        OID_UNKNOWN(DOT11_OID_ALOFT_TABLE, 0x1d000000),
 109        OID_UNKNOWN(DOT11_OID_ALOFT_CTRL_TABLE, 0x1d000001),
 110        OID_UNKNOWN(DOT11_OID_ALOFT_RETREAT, 0x1d000002),
 111        OID_UNKNOWN(DOT11_OID_ALOFT_PROGRESS, 0x1d000003),
 112        OID_U32(DOT11_OID_ALOFT_FIXEDRATE, 0x1d000004),
 113        OID_UNKNOWN(DOT11_OID_ALOFT_RSSIGRAPH, 0x1d000005),
 114        OID_UNKNOWN(DOT11_OID_ALOFT_CONFIG, 0x1d000006),
 115
 116        [DOT11_OID_VDCFX] = {0x1b000000, 7, 0, 0},
 117        OID_U32(DOT11_OID_MAXFRAMEBURST, 0x1b000008),
 118
 119        OID_U32(DOT11_OID_PSM, 0x14000000),
 120        OID_U32(DOT11_OID_CAMTIMEOUT, 0x14000001),
 121        OID_U32(DOT11_OID_RECEIVEDTIMS, 0x14000002),
 122        OID_U32(DOT11_OID_ROAMPREFERENCE, 0x14000003),
 123
 124        OID_U32(DOT11_OID_BRIDGELOCAL, 0x15000000),
 125        OID_U32(DOT11_OID_CLIENTS, 0x15000001),
 126        OID_U32(DOT11_OID_CLIENTSASSOCIATED, 0x15000002),
 127        [DOT11_OID_CLIENTX] = {0x15000003, 2006, 0, 0}, /* DOT11_OID_CLIENTX,...DOT11_OID_CLIENT2007 */
 128
 129        OID_STRUCT(DOT11_OID_CLIENTFIND, 0x150007DB, u8[6], OID_TYPE_ADDR),
 130        OID_STRUCT(DOT11_OID_WDSLINKADD, 0x150007DC, u8[6], OID_TYPE_ADDR),
 131        OID_STRUCT(DOT11_OID_WDSLINKREMOVE, 0x150007DD, u8[6], OID_TYPE_ADDR),
 132        OID_STRUCT(DOT11_OID_EAPAUTHSTA, 0x150007DE, u8[6], OID_TYPE_ADDR),
 133        OID_STRUCT(DOT11_OID_EAPUNAUTHSTA, 0x150007DF, u8[6], OID_TYPE_ADDR),
 134        OID_U32_C(DOT11_OID_DOT1XENABLE, 0x150007E0),
 135        OID_UNKNOWN(DOT11_OID_MICFAILURE, 0x150007E1),
 136        OID_UNKNOWN(DOT11_OID_REKEYINDICATE, 0x150007E2),
 137
 138        OID_U32(DOT11_OID_MPDUTXSUCCESSFUL, 0x16000000),
 139        OID_U32(DOT11_OID_MPDUTXONERETRY, 0x16000001),
 140        OID_U32(DOT11_OID_MPDUTXMULTIPLERETRIES, 0x16000002),
 141        OID_U32(DOT11_OID_MPDUTXFAILED, 0x16000003),
 142        OID_U32(DOT11_OID_MPDURXSUCCESSFUL, 0x16000004),
 143        OID_U32(DOT11_OID_MPDURXDUPS, 0x16000005),
 144        OID_U32(DOT11_OID_RTSSUCCESSFUL, 0x16000006),
 145        OID_U32(DOT11_OID_RTSFAILED, 0x16000007),
 146        OID_U32(DOT11_OID_ACKFAILED, 0x16000008),
 147        OID_U32(DOT11_OID_FRAMERECEIVES, 0x16000009),
 148        OID_U32(DOT11_OID_FRAMEERRORS, 0x1600000A),
 149        OID_U32(DOT11_OID_FRAMEABORTS, 0x1600000B),
 150        OID_U32(DOT11_OID_FRAMEABORTSPHY, 0x1600000C),
 151
 152        OID_U32(DOT11_OID_SLOTTIME, 0x17000000),
 153        OID_U32(DOT11_OID_CWMIN, 0x17000001),
 154        OID_U32(DOT11_OID_CWMAX, 0x17000002),
 155        OID_U32(DOT11_OID_ACKWINDOW, 0x17000003),
 156        OID_U32(DOT11_OID_ANTENNARX, 0x17000004),
 157        OID_U32(DOT11_OID_ANTENNATX, 0x17000005),
 158        OID_U32(DOT11_OID_ANTENNADIVERSITY, 0x17000006),
 159        OID_U32_C(DOT11_OID_CHANNEL, 0x17000007),
 160        OID_U32_C(DOT11_OID_EDTHRESHOLD, 0x17000008),
 161        OID_U32(DOT11_OID_PREAMBLESETTINGS, 0x17000009),
 162        OID_STRUCT(DOT11_OID_RATES, 0x1700000A, u8[IWMAX_BITRATES + 1],
 163                   OID_TYPE_RAW),
 164        OID_U32(DOT11_OID_CCAMODESUPPORTED, 0x1700000B),
 165        OID_U32(DOT11_OID_CCAMODE, 0x1700000C),
 166        OID_UNKNOWN(DOT11_OID_RSSIVECTOR, 0x1700000D),
 167        OID_UNKNOWN(DOT11_OID_OUTPUTPOWERTABLE, 0x1700000E),
 168        OID_U32(DOT11_OID_OUTPUTPOWER, 0x1700000F),
 169        OID_STRUCT(DOT11_OID_SUPPORTEDRATES, 0x17000010,
 170                   u8[IWMAX_BITRATES + 1], OID_TYPE_RAW),
 171        OID_U32_C(DOT11_OID_FREQUENCY, 0x17000011),
 172        [DOT11_OID_SUPPORTEDFREQUENCIES] =
 173            {0x17000012, 0, sizeof (struct obj_frequencies)
 174             + sizeof (u16) * IWMAX_FREQ, OID_TYPE_FREQUENCIES},
 175
 176        OID_U32(DOT11_OID_NOISEFLOOR, 0x17000013),
 177        OID_STRUCT(DOT11_OID_FREQUENCYACTIVITY, 0x17000014, u8[IWMAX_FREQ + 1],
 178                   OID_TYPE_RAW),
 179        OID_UNKNOWN(DOT11_OID_IQCALIBRATIONTABLE, 0x17000015),
 180        OID_U32(DOT11_OID_NONERPPROTECTION, 0x17000016),
 181        OID_U32(DOT11_OID_SLOTSETTINGS, 0x17000017),
 182        OID_U32(DOT11_OID_NONERPTIMEOUT, 0x17000018),
 183        OID_U32(DOT11_OID_PROFILES, 0x17000019),
 184        OID_STRUCT(DOT11_OID_EXTENDEDRATES, 0x17000020,
 185                   u8[IWMAX_BITRATES + 1], OID_TYPE_RAW),
 186
 187        OID_STRUCT_MLME(DOT11_OID_DEAUTHENTICATE, 0x18000000),
 188        OID_STRUCT_MLME(DOT11_OID_AUTHENTICATE, 0x18000001),
 189        OID_STRUCT_MLME(DOT11_OID_DISASSOCIATE, 0x18000002),
 190        OID_STRUCT_MLME(DOT11_OID_ASSOCIATE, 0x18000003),
 191        OID_UNKNOWN(DOT11_OID_SCAN, 0x18000004),
 192        OID_STRUCT_MLMEEX(DOT11_OID_BEACON, 0x18000005),
 193        OID_STRUCT_MLMEEX(DOT11_OID_PROBE, 0x18000006),
 194        OID_STRUCT_MLMEEX(DOT11_OID_DEAUTHENTICATEEX, 0x18000007),
 195        OID_STRUCT_MLMEEX(DOT11_OID_AUTHENTICATEEX, 0x18000008),
 196        OID_STRUCT_MLMEEX(DOT11_OID_DISASSOCIATEEX, 0x18000009),
 197        OID_STRUCT_MLMEEX(DOT11_OID_ASSOCIATEEX, 0x1800000A),
 198        OID_STRUCT_MLMEEX(DOT11_OID_REASSOCIATE, 0x1800000B),
 199        OID_STRUCT_MLMEEX(DOT11_OID_REASSOCIATEEX, 0x1800000C),
 200
 201        OID_U32(DOT11_OID_NONERPSTATUS, 0x1E000000),
 202
 203        OID_U32(DOT11_OID_STATIMEOUT, 0x19000000),
 204        OID_U32_C(DOT11_OID_MLMEAUTOLEVEL, 0x19000001),
 205        OID_U32(DOT11_OID_BSSTIMEOUT, 0x19000002),
 206        [DOT11_OID_ATTACHMENT] = {0x19000003, 0,
 207                sizeof(struct obj_attachment), OID_TYPE_ATTACH},
 208        OID_STRUCT_C(DOT11_OID_PSMBUFFER, 0x19000004, struct obj_buffer,
 209                     OID_TYPE_BUFFER),
 210
 211        OID_U32(DOT11_OID_BSSS, 0x1C000000),
 212        [DOT11_OID_BSSX] = {0x1C000001, 63, sizeof (struct obj_bss),
 213                            OID_TYPE_BSS},      /*DOT11_OID_BSS1,...,DOT11_OID_BSS64 */
 214        OID_STRUCT(DOT11_OID_BSSFIND, 0x1C000042, struct obj_bss, OID_TYPE_BSS),
 215        [DOT11_OID_BSSLIST] = {0x1C000043, 0, sizeof (struct
 216                                                      obj_bsslist) +
 217                               sizeof (struct obj_bss[IWMAX_BSS]),
 218                               OID_TYPE_BSSLIST},
 219
 220        OID_UNKNOWN(OID_INL_TUNNEL, 0xFF020000),
 221        OID_UNKNOWN(OID_INL_MEMADDR, 0xFF020001),
 222        OID_UNKNOWN(OID_INL_MEMORY, 0xFF020002),
 223        OID_U32_C(OID_INL_MODE, 0xFF020003),
 224        OID_UNKNOWN(OID_INL_COMPONENT_NR, 0xFF020004),
 225        OID_STRUCT(OID_INL_VERSION, 0xFF020005, u8[8], OID_TYPE_RAW),
 226        OID_UNKNOWN(OID_INL_INTERFACE_ID, 0xFF020006),
 227        OID_UNKNOWN(OID_INL_COMPONENT_ID, 0xFF020007),
 228        OID_U32_C(OID_INL_CONFIG, 0xFF020008),
 229        OID_U32_C(OID_INL_DOT11D_CONFORMANCE, 0xFF02000C),
 230        OID_U32(OID_INL_PHYCAPABILITIES, 0xFF02000D),
 231        OID_U32_C(OID_INL_OUTPUTPOWER, 0xFF02000F),
 232
 233};
 234
 235int
 236mgt_init(islpci_private *priv)
 237{
 238        int i;
 239
 240        priv->mib = kcalloc(OID_NUM_LAST, sizeof (void *), GFP_KERNEL);
 241        if (!priv->mib)
 242                return -ENOMEM;
 243
 244        /* Alloc the cache */
 245        for (i = 0; i < OID_NUM_LAST; i++) {
 246                if (isl_oid[i].flags & OID_FLAG_CACHED) {
 247                        priv->mib[i] = kzalloc(isl_oid[i].size *
 248                                               (isl_oid[i].range + 1),
 249                                               GFP_KERNEL);
 250                        if (!priv->mib[i])
 251                                return -ENOMEM;
 252                } else
 253                        priv->mib[i] = NULL;
 254        }
 255
 256        init_rwsem(&priv->mib_sem);
 257        prism54_mib_init(priv);
 258
 259        return 0;
 260}
 261
 262void
 263mgt_clean(islpci_private *priv)
 264{
 265        int i;
 266
 267        if (!priv->mib)
 268                return;
 269        for (i = 0; i < OID_NUM_LAST; i++) {
 270                kfree(priv->mib[i]);
 271                priv->mib[i] = NULL;
 272        }
 273        kfree(priv->mib);
 274        priv->mib = NULL;
 275}
 276
 277void
 278mgt_le_to_cpu(int type, void *data)
 279{
 280        switch (type) {
 281        case OID_TYPE_U32:
 282                *(u32 *) data = le32_to_cpu(*(u32 *) data);
 283                break;
 284        case OID_TYPE_BUFFER:{
 285                        struct obj_buffer *buff = data;
 286                        buff->size = le32_to_cpu(buff->size);
 287                        buff->addr = le32_to_cpu(buff->addr);
 288                        break;
 289                }
 290        case OID_TYPE_BSS:{
 291                        struct obj_bss *bss = data;
 292                        bss->age = le16_to_cpu(bss->age);
 293                        bss->channel = le16_to_cpu(bss->channel);
 294                        bss->capinfo = le16_to_cpu(bss->capinfo);
 295                        bss->rates = le16_to_cpu(bss->rates);
 296                        bss->basic_rates = le16_to_cpu(bss->basic_rates);
 297                        break;
 298                }
 299        case OID_TYPE_BSSLIST:{
 300                        struct obj_bsslist *list = data;
 301                        int i;
 302                        list->nr = le32_to_cpu(list->nr);
 303                        for (i = 0; i < list->nr; i++)
 304                                mgt_le_to_cpu(OID_TYPE_BSS, &list->bsslist[i]);
 305                        break;
 306                }
 307        case OID_TYPE_FREQUENCIES:{
 308                        struct obj_frequencies *freq = data;
 309                        int i;
 310                        freq->nr = le16_to_cpu(freq->nr);
 311                        for (i = 0; i < freq->nr; i++)
 312                                freq->mhz[i] = le16_to_cpu(freq->mhz[i]);
 313                        break;
 314                }
 315        case OID_TYPE_MLME:{
 316                        struct obj_mlme *mlme = data;
 317                        mlme->id = le16_to_cpu(mlme->id);
 318                        mlme->state = le16_to_cpu(mlme->state);
 319                        mlme->code = le16_to_cpu(mlme->code);
 320                        break;
 321                }
 322        case OID_TYPE_MLMEEX:{
 323                        struct obj_mlmeex *mlme = data;
 324                        mlme->id = le16_to_cpu(mlme->id);
 325                        mlme->state = le16_to_cpu(mlme->state);
 326                        mlme->code = le16_to_cpu(mlme->code);
 327                        mlme->size = le16_to_cpu(mlme->size);
 328                        break;
 329                }
 330        case OID_TYPE_ATTACH:{
 331                        struct obj_attachment *attach = data;
 332                        attach->id = le16_to_cpu(attach->id);
 333                        attach->size = le16_to_cpu(attach->size);
 334                        break;
 335        }
 336        case OID_TYPE_SSID:
 337        case OID_TYPE_KEY:
 338        case OID_TYPE_ADDR:
 339        case OID_TYPE_RAW:
 340                break;
 341        default:
 342                BUG();
 343        }
 344}
 345
 346static void
 347mgt_cpu_to_le(int type, void *data)
 348{
 349        switch (type) {
 350        case OID_TYPE_U32:
 351                *(u32 *) data = cpu_to_le32(*(u32 *) data);
 352                break;
 353        case OID_TYPE_BUFFER:{
 354                        struct obj_buffer *buff = data;
 355                        buff->size = cpu_to_le32(buff->size);
 356                        buff->addr = cpu_to_le32(buff->addr);
 357                        break;
 358                }
 359        case OID_TYPE_BSS:{
 360                        struct obj_bss *bss = data;
 361                        bss->age = cpu_to_le16(bss->age);
 362                        bss->channel = cpu_to_le16(bss->channel);
 363                        bss->capinfo = cpu_to_le16(bss->capinfo);
 364                        bss->rates = cpu_to_le16(bss->rates);
 365                        bss->basic_rates = cpu_to_le16(bss->basic_rates);
 366                        break;
 367                }
 368        case OID_TYPE_BSSLIST:{
 369                        struct obj_bsslist *list = data;
 370                        int i;
 371                        list->nr = cpu_to_le32(list->nr);
 372                        for (i = 0; i < list->nr; i++)
 373                                mgt_cpu_to_le(OID_TYPE_BSS, &list->bsslist[i]);
 374                        break;
 375                }
 376        case OID_TYPE_FREQUENCIES:{
 377                        struct obj_frequencies *freq = data;
 378                        int i;
 379                        freq->nr = cpu_to_le16(freq->nr);
 380                        for (i = 0; i < freq->nr; i++)
 381                                freq->mhz[i] = cpu_to_le16(freq->mhz[i]);
 382                        break;
 383                }
 384        case OID_TYPE_MLME:{
 385                        struct obj_mlme *mlme = data;
 386                        mlme->id = cpu_to_le16(mlme->id);
 387                        mlme->state = cpu_to_le16(mlme->state);
 388                        mlme->code = cpu_to_le16(mlme->code);
 389                        break;
 390                }
 391        case OID_TYPE_MLMEEX:{
 392                        struct obj_mlmeex *mlme = data;
 393                        mlme->id = cpu_to_le16(mlme->id);
 394                        mlme->state = cpu_to_le16(mlme->state);
 395                        mlme->code = cpu_to_le16(mlme->code);
 396                        mlme->size = cpu_to_le16(mlme->size);
 397                        break;
 398                }
 399        case OID_TYPE_ATTACH:{
 400                        struct obj_attachment *attach = data;
 401                        attach->id = cpu_to_le16(attach->id);
 402                        attach->size = cpu_to_le16(attach->size);
 403                        break;
 404        }
 405        case OID_TYPE_SSID:
 406        case OID_TYPE_KEY:
 407        case OID_TYPE_ADDR:
 408        case OID_TYPE_RAW:
 409                break;
 410        default:
 411                BUG();
 412        }
 413}
 414
 415/* Note : data is modified during this function */
 416
 417int
 418mgt_set_request(islpci_private *priv, enum oid_num_t n, int extra, void *data)
 419{
 420        int ret = 0;
 421        struct islpci_mgmtframe *response = NULL;
 422        int response_op = PIMFOR_OP_ERROR;
 423        int dlen;
 424        void *cache, *_data = data;
 425        u32 oid;
 426
 427        BUG_ON(OID_NUM_LAST <= n);
 428        BUG_ON(extra > isl_oid[n].range);
 429
 430        if (!priv->mib)
 431                /* memory has been freed */
 432                return -1;
 433
 434        dlen = isl_oid[n].size;
 435        cache = priv->mib[n];
 436        cache += (cache ? extra * dlen : 0);
 437        oid = isl_oid[n].oid + extra;
 438
 439        if (_data == NULL)
 440                /* we are requested to re-set a cached value */
 441                _data = cache;
 442        else
 443                mgt_cpu_to_le(isl_oid[n].flags & OID_FLAG_TYPE, _data);
 444        /* If we are going to write to the cache, we don't want anyone to read
 445         * it -> acquire write lock.
 446         * Else we could acquire a read lock to be sure we don't bother the
 447         * commit process (which takes a write lock). But I'm not sure if it's
 448         * needed.
 449         */
 450        if (cache)
 451                down_write(&priv->mib_sem);
 452
 453        if (islpci_get_state(priv) >= PRV_STATE_READY) {
 454                ret = islpci_mgt_transaction(priv->ndev, PIMFOR_OP_SET, oid,
 455                                             _data, dlen, &response);
 456                if (!ret) {
 457                        response_op = response->header->operation;
 458                        islpci_mgt_release(response);
 459                }
 460                if (ret || response_op == PIMFOR_OP_ERROR)
 461                        ret = -EIO;
 462        } else if (!cache)
 463                ret = -EIO;
 464
 465        if (cache) {
 466                if (!ret && data)
 467                        memcpy(cache, _data, dlen);
 468                up_write(&priv->mib_sem);
 469        }
 470
 471        /* re-set given data to what it was */
 472        if (data)
 473                mgt_le_to_cpu(isl_oid[n].flags & OID_FLAG_TYPE, data);
 474
 475        return ret;
 476}
 477
 478/* None of these are cached */
 479int
 480mgt_set_varlen(islpci_private *priv, enum oid_num_t n, void *data, int extra_len)
 481{
 482        int ret = 0;
 483        struct islpci_mgmtframe *response;
 484        int response_op = PIMFOR_OP_ERROR;
 485        int dlen;
 486        u32 oid;
 487
 488        BUG_ON(OID_NUM_LAST <= n);
 489
 490        dlen = isl_oid[n].size;
 491        oid = isl_oid[n].oid;
 492
 493        mgt_cpu_to_le(isl_oid[n].flags & OID_FLAG_TYPE, data);
 494
 495        if (islpci_get_state(priv) >= PRV_STATE_READY) {
 496                ret = islpci_mgt_transaction(priv->ndev, PIMFOR_OP_SET, oid,
 497                                             data, dlen + extra_len, &response);
 498                if (!ret) {
 499                        response_op = response->header->operation;
 500                        islpci_mgt_release(response);
 501                }
 502                if (ret || response_op == PIMFOR_OP_ERROR)
 503                        ret = -EIO;
 504        } else
 505                ret = -EIO;
 506
 507        /* re-set given data to what it was */
 508        if (data)
 509                mgt_le_to_cpu(isl_oid[n].flags & OID_FLAG_TYPE, data);
 510
 511        return ret;
 512}
 513
 514int
 515mgt_get_request(islpci_private *priv, enum oid_num_t n, int extra, void *data,
 516                union oid_res_t *res)
 517{
 518
 519        int ret = -EIO;
 520        int reslen = 0;
 521        struct islpci_mgmtframe *response = NULL;
 522
 523        int dlen;
 524        void *cache, *_res = NULL;
 525        u32 oid;
 526
 527        BUG_ON(OID_NUM_LAST <= n);
 528        BUG_ON(extra > isl_oid[n].range);
 529
 530        res->ptr = NULL;
 531
 532        if (!priv->mib)
 533                /* memory has been freed */
 534                return -1;
 535
 536        dlen = isl_oid[n].size;
 537        cache = priv->mib[n];
 538        cache += cache ? extra * dlen : 0;
 539        oid = isl_oid[n].oid + extra;
 540        reslen = dlen;
 541
 542        if (cache)
 543                down_read(&priv->mib_sem);
 544
 545        if (islpci_get_state(priv) >= PRV_STATE_READY) {
 546                ret = islpci_mgt_transaction(priv->ndev, PIMFOR_OP_GET,
 547                                             oid, data, dlen, &response);
 548                if (ret || !response ||
 549                    response->header->operation == PIMFOR_OP_ERROR) {
 550                        if (response)
 551                                islpci_mgt_release(response);
 552                        ret = -EIO;
 553                }
 554                if (!ret) {
 555                        _res = response->data;
 556                        reslen = response->header->length;
 557                }
 558        } else if (cache) {
 559                _res = cache;
 560                ret = 0;
 561        }
 562        if ((isl_oid[n].flags & OID_FLAG_TYPE) == OID_TYPE_U32)
 563                res->u = ret ? 0 : le32_to_cpu(*(u32 *) _res);
 564        else {
 565                res->ptr = kmalloc(reslen, GFP_KERNEL);
 566                BUG_ON(res->ptr == NULL);
 567                if (ret)
 568                        memset(res->ptr, 0, reslen);
 569                else {
 570                        memcpy(res->ptr, _res, reslen);
 571                        mgt_le_to_cpu(isl_oid[n].flags & OID_FLAG_TYPE,
 572                                      res->ptr);
 573                }
 574        }
 575        if (cache)
 576                up_read(&priv->mib_sem);
 577
 578        if (response && !ret)
 579                islpci_mgt_release(response);
 580
 581        if (reslen > isl_oid[n].size)
 582                printk(KERN_DEBUG
 583                       "mgt_get_request(0x%x): received data length was bigger "
 584                       "than expected (%d > %d). Memory is probably corrupted...",
 585                       oid, reslen, isl_oid[n].size);
 586
 587        return ret;
 588}
 589
 590/* lock outside */
 591int
 592mgt_commit_list(islpci_private *priv, enum oid_num_t *l, int n)
 593{
 594        int i, ret = 0;
 595        struct islpci_mgmtframe *response;
 596
 597        for (i = 0; i < n; i++) {
 598                struct oid_t *t = &(isl_oid[l[i]]);
 599                void *data = priv->mib[l[i]];
 600                int j = 0;
 601                u32 oid = t->oid;
 602                BUG_ON(data == NULL);
 603                while (j <= t->range) {
 604                        int r = islpci_mgt_transaction(priv->ndev, PIMFOR_OP_SET,
 605                                                      oid, data, t->size,
 606                                                      &response);
 607                        if (response) {
 608                                r |= (response->header->operation == PIMFOR_OP_ERROR);
 609                                islpci_mgt_release(response);
 610                        }
 611                        if (r)
 612                                printk(KERN_ERR "%s: mgt_commit_list: failure. "
 613                                        "oid=%08x err=%d\n",
 614                                        priv->ndev->name, oid, r);
 615                        ret |= r;
 616                        j++;
 617                        oid++;
 618                        data += t->size;
 619                }
 620        }
 621        return ret;
 622}
 623
 624/* Lock outside */
 625
 626void
 627mgt_set(islpci_private *priv, enum oid_num_t n, void *data)
 628{
 629        BUG_ON(OID_NUM_LAST <= n);
 630        BUG_ON(priv->mib[n] == NULL);
 631
 632        memcpy(priv->mib[n], data, isl_oid[n].size);
 633        mgt_cpu_to_le(isl_oid[n].flags & OID_FLAG_TYPE, priv->mib[n]);
 634}
 635
 636void
 637mgt_get(islpci_private *priv, enum oid_num_t n, void *res)
 638{
 639        BUG_ON(OID_NUM_LAST <= n);
 640        BUG_ON(priv->mib[n] == NULL);
 641        BUG_ON(res == NULL);
 642
 643        memcpy(res, priv->mib[n], isl_oid[n].size);
 644        mgt_le_to_cpu(isl_oid[n].flags & OID_FLAG_TYPE, res);
 645}
 646
 647/* Commits the cache. Lock outside. */
 648
 649static enum oid_num_t commit_part1[] = {
 650        OID_INL_CONFIG,
 651        OID_INL_MODE,
 652        DOT11_OID_BSSTYPE,
 653        DOT11_OID_CHANNEL,
 654        DOT11_OID_MLMEAUTOLEVEL
 655};
 656
 657static enum oid_num_t commit_part2[] = {
 658        DOT11_OID_SSID,
 659        DOT11_OID_PSMBUFFER,
 660        DOT11_OID_AUTHENABLE,
 661        DOT11_OID_PRIVACYINVOKED,
 662        DOT11_OID_EXUNENCRYPTED,
 663        DOT11_OID_DEFKEYX,      /* MULTIPLE */
 664        DOT11_OID_DEFKEYID,
 665        DOT11_OID_DOT1XENABLE,
 666        OID_INL_DOT11D_CONFORMANCE,
 667        /* Do not initialize this - fw < 1.0.4.3 rejects it
 668        OID_INL_OUTPUTPOWER,
 669        */
 670};
 671
 672/* update the MAC addr. */
 673static int
 674mgt_update_addr(islpci_private *priv)
 675{
 676        struct islpci_mgmtframe *res;
 677        int ret;
 678
 679        ret = islpci_mgt_transaction(priv->ndev, PIMFOR_OP_GET,
 680                                     isl_oid[GEN_OID_MACADDRESS].oid, NULL,
 681                                     isl_oid[GEN_OID_MACADDRESS].size, &res);
 682
 683        if ((ret == 0) && res && (res->header->operation != PIMFOR_OP_ERROR))
 684                memcpy(priv->ndev->dev_addr, res->data, ETH_ALEN);
 685        else
 686                ret = -EIO;
 687        if (res)
 688                islpci_mgt_release(res);
 689
 690        if (ret)
 691                printk(KERN_ERR "%s: mgt_update_addr: failure\n", priv->ndev->name);
 692        return ret;
 693}
 694
 695int
 696mgt_commit(islpci_private *priv)
 697{
 698        int rvalue;
 699        enum oid_num_t u;
 700
 701        if (islpci_get_state(priv) < PRV_STATE_INIT)
 702                return 0;
 703
 704        rvalue = mgt_commit_list(priv, commit_part1, ARRAY_SIZE(commit_part1));
 705
 706        if (priv->iw_mode != IW_MODE_MONITOR)
 707                rvalue |= mgt_commit_list(priv, commit_part2, ARRAY_SIZE(commit_part2));
 708
 709        u = OID_INL_MODE;
 710        rvalue |= mgt_commit_list(priv, &u, 1);
 711        rvalue |= mgt_update_addr(priv);
 712
 713        if (rvalue) {
 714                /* some request have failed. The device might be in an
 715                   incoherent state. We should reset it ! */
 716                printk(KERN_DEBUG "%s: mgt_commit: failure\n", priv->ndev->name);
 717        }
 718        return rvalue;
 719}
 720
 721/* The following OIDs need to be "unlatched":
 722 *
 723 * MEDIUMLIMIT,BEACONPERIOD,DTIMPERIOD,ATIMWINDOW,LISTENINTERVAL
 724 * FREQUENCY,EXTENDEDRATES.
 725 *
 726 * The way to do this is to set ESSID. Note though that they may get
 727 * unlatch before though by setting another OID. */
 728#if 0
 729void
 730mgt_unlatch_all(islpci_private *priv)
 731{
 732        u32 u;
 733        int rvalue = 0;
 734
 735        if (islpci_get_state(priv) < PRV_STATE_INIT)
 736                return;
 737
 738        u = DOT11_OID_SSID;
 739        rvalue = mgt_commit_list(priv, &u, 1);
 740        /* Necessary if in MANUAL RUN mode? */
 741#if 0
 742        u = OID_INL_MODE;
 743        rvalue |= mgt_commit_list(priv, &u, 1);
 744
 745        u = DOT11_OID_MLMEAUTOLEVEL;
 746        rvalue |= mgt_commit_list(priv, &u, 1);
 747
 748        u = OID_INL_MODE;
 749        rvalue |= mgt_commit_list(priv, &u, 1);
 750#endif
 751
 752        if (rvalue)
 753                printk(KERN_DEBUG "%s: Unlatching OIDs failed\n", priv->ndev->name);
 754}
 755#endif
 756
 757/* This will tell you if you are allowed to answer a mlme(ex) request .*/
 758
 759int
 760mgt_mlme_answer(islpci_private *priv)
 761{
 762        u32 mlmeautolevel;
 763        /* Acquire a read lock because if we are in a mode change, it's
 764         * possible to answer true, while the card is leaving master to managed
 765         * mode. Answering to a mlme in this situation could hang the card.
 766         */
 767        down_read(&priv->mib_sem);
 768        mlmeautolevel =
 769            le32_to_cpu(*(u32 *) priv->mib[DOT11_OID_MLMEAUTOLEVEL]);
 770        up_read(&priv->mib_sem);
 771
 772        return ((priv->iw_mode == IW_MODE_MASTER) &&
 773                (mlmeautolevel >= DOT11_MLME_INTERMEDIATE));
 774}
 775
 776enum oid_num_t
 777mgt_oidtonum(u32 oid)
 778{
 779        int i;
 780
 781        for (i = 0; i < OID_NUM_LAST; i++)
 782                if (isl_oid[i].oid == oid)
 783                        return i;
 784
 785        printk(KERN_DEBUG "looking for an unknown oid 0x%x", oid);
 786
 787        return OID_NUM_LAST;
 788}
 789
 790int
 791mgt_response_to_str(enum oid_num_t n, union oid_res_t *r, char *str)
 792{
 793        switch (isl_oid[n].flags & OID_FLAG_TYPE) {
 794        case OID_TYPE_U32:
 795                return snprintf(str, PRIV_STR_SIZE, "%u\n", r->u);
 796        case OID_TYPE_BUFFER:{
 797                        struct obj_buffer *buff = r->ptr;
 798                        return snprintf(str, PRIV_STR_SIZE,
 799                                        "size=%u\naddr=0x%X\n", buff->size,
 800                                        buff->addr);
 801                }
 802                break;
 803        case OID_TYPE_BSS:{
 804                        struct obj_bss *bss = r->ptr;
 805                        return snprintf(str, PRIV_STR_SIZE,
 806                                        "age=%u\nchannel=%u\n"
 807                                        "capinfo=0x%X\nrates=0x%X\n"
 808                                        "basic_rates=0x%X\n", bss->age,
 809                                        bss->channel, bss->capinfo,
 810                                        bss->rates, bss->basic_rates);
 811                }
 812                break;
 813        case OID_TYPE_BSSLIST:{
 814                        struct obj_bsslist *list = r->ptr;
 815                        int i, k;
 816                        k = snprintf(str, PRIV_STR_SIZE, "nr=%u\n", list->nr);
 817                        for (i = 0; i < list->nr; i++)
 818                                k += snprintf(str + k, PRIV_STR_SIZE - k,
 819                                              "bss[%u] :\nage=%u\nchannel=%u\n"
 820                                              "capinfo=0x%X\nrates=0x%X\n"
 821                                              "basic_rates=0x%X\n",
 822                                              i, list->bsslist[i].age,
 823                                              list->bsslist[i].channel,
 824                                              list->bsslist[i].capinfo,
 825                                              list->bsslist[i].rates,
 826                                              list->bsslist[i].basic_rates);
 827                        return k;
 828                }
 829                break;
 830        case OID_TYPE_FREQUENCIES:{
 831                        struct obj_frequencies *freq = r->ptr;
 832                        int i, t;
 833                        printk("nr : %u\n", freq->nr);
 834                        t = snprintf(str, PRIV_STR_SIZE, "nr=%u\n", freq->nr);
 835                        for (i = 0; i < freq->nr; i++)
 836                                t += snprintf(str + t, PRIV_STR_SIZE - t,
 837                                              "mhz[%u]=%u\n", i, freq->mhz[i]);
 838                        return t;
 839                }
 840                break;
 841        case OID_TYPE_MLME:{
 842                        struct obj_mlme *mlme = r->ptr;
 843                        return snprintf(str, PRIV_STR_SIZE,
 844                                        "id=0x%X\nstate=0x%X\ncode=0x%X\n",
 845                                        mlme->id, mlme->state, mlme->code);
 846                }
 847                break;
 848        case OID_TYPE_MLMEEX:{
 849                        struct obj_mlmeex *mlme = r->ptr;
 850                        return snprintf(str, PRIV_STR_SIZE,
 851                                        "id=0x%X\nstate=0x%X\n"
 852                                        "code=0x%X\nsize=0x%X\n", mlme->id,
 853                                        mlme->state, mlme->code, mlme->size);
 854                }
 855                break;
 856        case OID_TYPE_ATTACH:{
 857                        struct obj_attachment *attach = r->ptr;
 858                        return snprintf(str, PRIV_STR_SIZE,
 859                                        "id=%d\nsize=%d\n",
 860                                        attach->id,
 861                                        attach->size);
 862                }
 863                break;
 864        case OID_TYPE_SSID:{
 865                        struct obj_ssid *ssid = r->ptr;
 866                        return snprintf(str, PRIV_STR_SIZE,
 867                                        "length=%u\noctets=%.*s\n",
 868                                        ssid->length, ssid->length,
 869                                        ssid->octets);
 870                }
 871                break;
 872        case OID_TYPE_KEY:{
 873                        struct obj_key *key = r->ptr;
 874                        int t, i;
 875                        t = snprintf(str, PRIV_STR_SIZE,
 876                                     "type=0x%X\nlength=0x%X\nkey=0x",
 877                                     key->type, key->length);
 878                        for (i = 0; i < key->length; i++)
 879                                t += snprintf(str + t, PRIV_STR_SIZE - t,
 880                                              "%02X:", key->key[i]);
 881                        t += snprintf(str + t, PRIV_STR_SIZE - t, "\n");
 882                        return t;
 883                }
 884                break;
 885        case OID_TYPE_RAW:
 886        case OID_TYPE_ADDR:{
 887                        unsigned char *buff = r->ptr;
 888                        int t, i;
 889                        t = snprintf(str, PRIV_STR_SIZE, "hex data=");
 890                        for (i = 0; i < isl_oid[n].size; i++)
 891                                t += snprintf(str + t, PRIV_STR_SIZE - t,
 892                                              "%02X:", buff[i]);
 893                        t += snprintf(str + t, PRIV_STR_SIZE - t, "\n");
 894                        return t;
 895                }
 896                break;
 897        default:
 898                BUG();
 899        }
 900        return 0;
 901}
 902