drivers/net/wireless/prism54/oid_mgt.c

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