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