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