?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'ixp4xx' of git://git.kernel.org/pub/scm/linux/kernel/git/chris/linux-2.6
[linux/fpc-iii.git] / drivers / staging / wlan-ng / prism2mgmt.c
blob9f7d96cae8e3dc71f507bb9161b83a0608193940
1 /* src/prism2/driver/prism2mgmt.c
2 *
3 * Management request handler functions.
4 *
5 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
6 * --------------------------------------------------------------------
7 *
8 * linux-wlan
9 *
10 * The contents of this file are subject to the Mozilla Public
11 * License Version 1.1 (the "License"); you may not use this file
12 * except in compliance with the License. You may obtain a copy of
13 * the License at http://www.mozilla.org/MPL/
14 *
15 * Software distributed under the License is distributed on an "AS
16 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17 * implied. See the License for the specific language governing
18 * rights and limitations under the License.
19 *
20 * Alternatively, the contents of this file may be used under the
21 * terms of the GNU Public License version 2 (the "GPL"), in which
22 * case the provisions of the GPL are applicable instead of the
23 * above. If you wish to allow the use of your version of this file
24 * only under the terms of the GPL and not to allow others to use
25 * your version of this file under the MPL, indicate your decision
26 * by deleting the provisions above and replace them with the notice
27 * and other provisions required by the GPL. If you do not delete
28 * the provisions above, a recipient may use your version of this
29 * file under either the MPL or the GPL.
30 *
31 * --------------------------------------------------------------------
32 *
33 * Inquiries regarding the linux-wlan Open Source project can be
34 * made directly to:
35 *
36 * AbsoluteValue Systems Inc.
37 * info@linux-wlan.com
38 * http://www.linux-wlan.com
39 *
40 * --------------------------------------------------------------------
41 *
42 * Portions of the development of this software were funded by
43 * Intersil Corporation as part of PRISM(R) chipset product development.
44 *
45 * --------------------------------------------------------------------
46 *
47 * The functions in this file handle management requests sent from
48 * user mode.
49 *
50 * Most of these functions have two separate blocks of code that are
51 * conditional on whether this is a station or an AP. This is used
52 * to separate out the STA and AP responses to these management primitives.
53 * It's a choice (good, bad, indifferent?) to have the code in the same
54 * place so it's clear that the same primitive is implemented in both
55 * cases but has different behavior.
56 *
57 * --------------------------------------------------------------------
58 */
59
60 #include <linux/if_arp.h>
61 #include <linux/module.h>
62 #include <linux/kernel.h>
63 #include <linux/wait.h>
64 #include <linux/sched.h>
65 #include <linux/types.h>
66 #include <linux/slab.h>
67 #include <linux/wireless.h>
68 #include <linux/netdevice.h>
69 #include <linux/delay.h>
70 #include <asm/io.h>
71 #include <asm/byteorder.h>
72 #include <linux/random.h>
73 #include <linux/usb.h>
74 #include <linux/bitops.h>
75
76 #include "p80211types.h"
77 #include "p80211hdr.h"
78 #include "p80211mgmt.h"
79 #include "p80211conv.h"
80 #include "p80211msg.h"
81 #include "p80211netdev.h"
82 #include "p80211metadef.h"
83 #include "p80211metastruct.h"
84 #include "hfa384x.h"
85 #include "prism2mgmt.h"
86
87 /* Converts 802.11 format rate specifications to prism2 */
88 #define p80211rate_to_p2bit(n) ((((n)&~BIT(7)) == 2) ? BIT(0) : \
89 (((n)&~BIT(7)) == 4) ? BIT(1) : \
90 (((n)&~BIT(7)) == 11) ? BIT(2) : \
91 (((n)&~BIT(7)) == 22) ? BIT(3) : 0)
92
93 /*----------------------------------------------------------------
94 * prism2mgmt_scan
95 *
96 * Initiate a scan for BSSs.
97 *
98 * This function corresponds to MLME-scan.request and part of
99 * MLME-scan.confirm. As far as I can tell in the standard, there
100 * are no restrictions on when a scan.request may be issued. We have
101 * to handle in whatever state the driver/MAC happen to be.
102 *
103 * Arguments:
104 * wlandev wlan device structure
105 * msgp ptr to msg buffer
106 *
107 * Returns:
108 * 0 success and done
109 * <0 success, but we're waiting for something to finish.
110 * >0 an error occurred while handling the message.
111 * Side effects:
112 *
113 * Call context:
114 * process thread (usually)
115 * interrupt
116 ----------------------------------------------------------------*/
117 int prism2mgmt_scan(wlandevice_t *wlandev, void *msgp)
118 {
119 int result = 0;
120 hfa384x_t *hw = wlandev->priv;
121 p80211msg_dot11req_scan_t *msg = msgp;
122 u16 roamingmode, word;
123 int i, timeout;
124 int istmpenable = 0;
125
126 hfa384x_HostScanRequest_data_t scanreq;
127
128 /* gatekeeper check */
129 if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
130 hw->ident_sta_fw.minor,
131 hw->ident_sta_fw.variant) <
132 HFA384x_FIRMWARE_VERSION(1, 3, 2)) {
133 printk(KERN_ERR
134 "HostScan not supported with current firmware (<1.3.2).\n");
135 result = 1;
136 msg->resultcode.data = P80211ENUM_resultcode_not_supported;
137 goto exit;
138 }
139
140 memset(&scanreq, 0, sizeof(scanreq));
141
142 /* save current roaming mode */
143 result = hfa384x_drvr_getconfig16(hw,
144 HFA384x_RID_CNFROAMINGMODE,
145 &roamingmode);
146 if (result) {
147 printk(KERN_ERR "getconfig(ROAMMODE) failed. result=%d\n",
148 result);
149 msg->resultcode.data =
150 P80211ENUM_resultcode_implementation_failure;
151 goto exit;
152 }
153
154 /* drop into mode 3 for the scan */
155 result = hfa384x_drvr_setconfig16(hw,
156 HFA384x_RID_CNFROAMINGMODE,
157 HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
158 if (result) {
159 printk(KERN_ERR "setconfig(ROAMINGMODE) failed. result=%d\n",
160 result);
161 msg->resultcode.data =
162 P80211ENUM_resultcode_implementation_failure;
163 goto exit;
164 }
165
166 /* active or passive? */
167 if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
168 hw->ident_sta_fw.minor,
169 hw->ident_sta_fw.variant) >
170 HFA384x_FIRMWARE_VERSION(1, 5, 0)) {
171 if (msg->scantype.data != P80211ENUM_scantype_active)
172 word = cpu_to_le16(msg->maxchanneltime.data);
173 else
174 word = 0;
175
176 result =
177 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPASSIVESCANCTRL,
178 word);
179 if (result) {
180 printk(KERN_WARNING "Passive scan not supported with "
181 "current firmware. (<1.5.1)\n");
182 }
183 }
184
185 /* set up the txrate to be 2MBPS. Should be fastest basicrate... */
186 word = HFA384x_RATEBIT_2;
187 scanreq.txRate = cpu_to_le16(word);
188
189 /* set up the channel list */
190 word = 0;
191 for (i = 0; i < msg->channellist.data.len; i++) {
192 u8 channel = msg->channellist.data.data[i];
193 if (channel > 14)
194 continue;
195 /* channel 1 is BIT 0 ... channel 14 is BIT 13 */
196 word |= (1 << (channel - 1));
197 }
198 scanreq.channelList = cpu_to_le16(word);
199
200 /* set up the ssid, if present. */
201 scanreq.ssid.len = cpu_to_le16(msg->ssid.data.len);
202 memcpy(scanreq.ssid.data, msg->ssid.data.data, msg->ssid.data.len);
203
204 /* Enable the MAC port if it's not already enabled */
205 result = hfa384x_drvr_getconfig16(hw, HFA384x_RID_PORTSTATUS, &word);
206 if (result) {
207 printk(KERN_ERR "getconfig(PORTSTATUS) failed. "
208 "result=%d\n", result);
209 msg->resultcode.data =
210 P80211ENUM_resultcode_implementation_failure;
211 goto exit;
212 }
213 if (word == HFA384x_PORTSTATUS_DISABLED) {
214 u16 wordbuf[17];
215
216 result = hfa384x_drvr_setconfig16(hw,
217 HFA384x_RID_CNFROAMINGMODE,
218 HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
219 if (result) {
220 printk(KERN_ERR
221 "setconfig(ROAMINGMODE) failed. result=%d\n",
222 result);
223 msg->resultcode.data =
224 P80211ENUM_resultcode_implementation_failure;
225 goto exit;
226 }
227 /* Construct a bogus SSID and assign it to OwnSSID and
228 * DesiredSSID
229 */
230 wordbuf[0] = cpu_to_le16(WLAN_SSID_MAXLEN);
231 get_random_bytes(&wordbuf[1], WLAN_SSID_MAXLEN);
232 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
233 wordbuf,
234 HFA384x_RID_CNFOWNSSID_LEN);
235 if (result) {
236 printk(KERN_ERR "Failed to set OwnSSID.\n");
237 msg->resultcode.data =
238 P80211ENUM_resultcode_implementation_failure;
239 goto exit;
240 }
241 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
242 wordbuf,
243 HFA384x_RID_CNFDESIREDSSID_LEN);
244 if (result) {
245 printk(KERN_ERR "Failed to set DesiredSSID.\n");
246 msg->resultcode.data =
247 P80211ENUM_resultcode_implementation_failure;
248 goto exit;
249 }
250 /* bsstype */
251 result = hfa384x_drvr_setconfig16(hw,
252 HFA384x_RID_CNFPORTTYPE,
253 HFA384x_PORTTYPE_IBSS);
254 if (result) {
255 printk(KERN_ERR "Failed to set CNFPORTTYPE.\n");
256 msg->resultcode.data =
257 P80211ENUM_resultcode_implementation_failure;
258 goto exit;
259 }
260 /* ibss options */
261 result = hfa384x_drvr_setconfig16(hw,
262 HFA384x_RID_CREATEIBSS,
263 HFA384x_CREATEIBSS_JOINCREATEIBSS);
264 if (result) {
265 printk(KERN_ERR "Failed to set CREATEIBSS.\n");
266 msg->resultcode.data =
267 P80211ENUM_resultcode_implementation_failure;
268 goto exit;
269 }
270 result = hfa384x_drvr_enable(hw, 0);
271 if (result) {
272 printk(KERN_ERR "drvr_enable(0) failed. "
273 "result=%d\n", result);
274 msg->resultcode.data =
275 P80211ENUM_resultcode_implementation_failure;
276 goto exit;
277 }
278 istmpenable = 1;
279 }
280
281 /* Figure out our timeout first Kus, then HZ */
282 timeout = msg->channellist.data.len * msg->maxchanneltime.data;
283 timeout = (timeout * HZ) / 1000;
284
285 /* Issue the scan request */
286 hw->scanflag = 0;
287
288 result = hfa384x_drvr_setconfig(hw,
289 HFA384x_RID_HOSTSCAN, &scanreq,
290 sizeof(hfa384x_HostScanRequest_data_t));
291 if (result) {
292 printk(KERN_ERR "setconfig(SCANREQUEST) failed. result=%d\n",
293 result);
294 msg->resultcode.data =
295 P80211ENUM_resultcode_implementation_failure;
296 goto exit;
297 }
298
299 /* sleep until info frame arrives */
300 wait_event_interruptible_timeout(hw->cmdq, hw->scanflag, timeout);
301
302 msg->numbss.status = P80211ENUM_msgitem_status_data_ok;
303 if (hw->scanflag == -1)
304 hw->scanflag = 0;
305
306 msg->numbss.data = hw->scanflag;
307
308 hw->scanflag = 0;
309
310 /* Disable port if we temporarily enabled it. */
311 if (istmpenable) {
312 result = hfa384x_drvr_disable(hw, 0);
313 if (result) {
314 printk(KERN_ERR "drvr_disable(0) failed. "
315 "result=%d\n", result);
316 msg->resultcode.data =
317 P80211ENUM_resultcode_implementation_failure;
318 goto exit;
319 }
320 }
321
322 /* restore original roaming mode */
323 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFROAMINGMODE,
324 roamingmode);
325 if (result) {
326 printk(KERN_ERR "setconfig(ROAMMODE) failed. result=%d\n",
327 result);
328 msg->resultcode.data =
329 P80211ENUM_resultcode_implementation_failure;
330 goto exit;
331 }
332
333 result = 0;
334 msg->resultcode.data = P80211ENUM_resultcode_success;
335
336 exit:
337 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
338
339 return result;
340 }
341
342 /*----------------------------------------------------------------
343 * prism2mgmt_scan_results
344 *
345 * Retrieve the BSS description for one of the BSSs identified in
346 * a scan.
347 *
348 * Arguments:
349 * wlandev wlan device structure
350 * msgp ptr to msg buffer
351 *
352 * Returns:
353 * 0 success and done
354 * <0 success, but we're waiting for something to finish.
355 * >0 an error occurred while handling the message.
356 * Side effects:
357 *
358 * Call context:
359 * process thread (usually)
360 * interrupt
361 ----------------------------------------------------------------*/
362 int prism2mgmt_scan_results(wlandevice_t *wlandev, void *msgp)
363 {
364 int result = 0;
365 p80211msg_dot11req_scan_results_t *req;
366 hfa384x_t *hw = wlandev->priv;
367 hfa384x_HScanResultSub_t *item = NULL;
368
369 int count;
370
371 req = (p80211msg_dot11req_scan_results_t *) msgp;
372
373 req->resultcode.status = P80211ENUM_msgitem_status_data_ok;
374
375 if (!hw->scanresults) {
376 printk(KERN_ERR
377 "dot11req_scan_results can only be used after a successful dot11req_scan.\n");
378 result = 2;
379 req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
380 goto exit;
381 }
382
383 count = (hw->scanresults->framelen - 3) / 32;
384 if (count > 32)
385 count = 32;
386
387 if (req->bssindex.data >= count) {
388 pr_debug("requested index (%d) out of range (%d)\n",
389 req->bssindex.data, count);
390 result = 2;
391 req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
392 goto exit;
393 }
394
395 item = &(hw->scanresults->info.hscanresult.result[req->bssindex.data]);
396 /* signal and noise */
397 req->signal.status = P80211ENUM_msgitem_status_data_ok;
398 req->noise.status = P80211ENUM_msgitem_status_data_ok;
399 req->signal.data = le16_to_cpu(item->sl);
400 req->noise.data = le16_to_cpu(item->anl);
401
402 /* BSSID */
403 req->bssid.status = P80211ENUM_msgitem_status_data_ok;
404 req->bssid.data.len = WLAN_BSSID_LEN;
405 memcpy(req->bssid.data.data, item->bssid, WLAN_BSSID_LEN);
406
407 /* SSID */
408 req->ssid.status = P80211ENUM_msgitem_status_data_ok;
409 req->ssid.data.len = le16_to_cpu(item->ssid.len);
410 memcpy(req->ssid.data.data, item->ssid.data, req->ssid.data.len);
411
412 /* supported rates */
413 for (count = 0; count < 10; count++)
414 if (item->supprates[count] == 0)
415 break;
416
417 #define REQBASICRATE(N) \
418 if ((count >= N) && DOT11_RATE5_ISBASIC_GET(item->supprates[(N)-1])) { \
419 req->basicrate ## N .data = item->supprates[(N)-1]; \
420 req->basicrate ## N .status = P80211ENUM_msgitem_status_data_ok; \
421 }
422
423 REQBASICRATE(1);
424 REQBASICRATE(2);
425 REQBASICRATE(3);
426 REQBASICRATE(4);
427 REQBASICRATE(5);
428 REQBASICRATE(6);
429 REQBASICRATE(7);
430 REQBASICRATE(8);
431
432 #define REQSUPPRATE(N) \
433 if (count >= N) { \
434 req->supprate ## N .data = item->supprates[(N)-1]; \
435 req->supprate ## N .status = P80211ENUM_msgitem_status_data_ok; \
436 }
437
438 REQSUPPRATE(1);
439 REQSUPPRATE(2);
440 REQSUPPRATE(3);
441 REQSUPPRATE(4);
442 REQSUPPRATE(5);
443 REQSUPPRATE(6);
444 REQSUPPRATE(7);
445 REQSUPPRATE(8);
446
447 /* beacon period */
448 req->beaconperiod.status = P80211ENUM_msgitem_status_data_ok;
449 req->beaconperiod.data = le16_to_cpu(item->bcnint);
450
451 /* timestamps */
452 req->timestamp.status = P80211ENUM_msgitem_status_data_ok;
453 req->timestamp.data = jiffies;
454 req->localtime.status = P80211ENUM_msgitem_status_data_ok;
455 req->localtime.data = jiffies;
456
457 /* atim window */
458 req->ibssatimwindow.status = P80211ENUM_msgitem_status_data_ok;
459 req->ibssatimwindow.data = le16_to_cpu(item->atim);
460
461 /* Channel */
462 req->dschannel.status = P80211ENUM_msgitem_status_data_ok;
463 req->dschannel.data = le16_to_cpu(item->chid);
464
465 /* capinfo bits */
466 count = le16_to_cpu(item->capinfo);
467
468 /* privacy flag */
469 req->privacy.status = P80211ENUM_msgitem_status_data_ok;
470 req->privacy.data = WLAN_GET_MGMT_CAP_INFO_PRIVACY(count);
471
472 /* cfpollable */
473 req->cfpollable.status = P80211ENUM_msgitem_status_data_ok;
474 req->cfpollable.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLABLE(count);
475
476 /* cfpollreq */
477 req->cfpollreq.status = P80211ENUM_msgitem_status_data_ok;
478 req->cfpollreq.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLREQ(count);
479
480 /* bsstype */
481 req->bsstype.status = P80211ENUM_msgitem_status_data_ok;
482 req->bsstype.data = (WLAN_GET_MGMT_CAP_INFO_ESS(count)) ?
483 P80211ENUM_bsstype_infrastructure : P80211ENUM_bsstype_independent;
484
485 result = 0;
486 req->resultcode.data = P80211ENUM_resultcode_success;
487
488 exit:
489 return result;
490 }
491
492 /*----------------------------------------------------------------
493 * prism2mgmt_start
494 *
495 * Start a BSS. Any station can do this for IBSS, only AP for ESS.
496 *
497 * Arguments:
498 * wlandev wlan device structure
499 * msgp ptr to msg buffer
500 *
501 * Returns:
502 * 0 success and done
503 * <0 success, but we're waiting for something to finish.
504 * >0 an error occurred while handling the message.
505 * Side effects:
506 *
507 * Call context:
508 * process thread (usually)
509 * interrupt
510 ----------------------------------------------------------------*/
511 int prism2mgmt_start(wlandevice_t *wlandev, void *msgp)
512 {
513 int result = 0;
514 hfa384x_t *hw = wlandev->priv;
515 p80211msg_dot11req_start_t *msg = msgp;
516
517 p80211pstrd_t *pstr;
518 u8 bytebuf[80];
519 hfa384x_bytestr_t *p2bytestr = (hfa384x_bytestr_t *) bytebuf;
520 u16 word;
521
522 wlandev->macmode = WLAN_MACMODE_NONE;
523
524 /* Set the SSID */
525 memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
526
527 /*** ADHOC IBSS ***/
528 /* see if current f/w is less than 8c3 */
529 if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
530 hw->ident_sta_fw.minor,
531 hw->ident_sta_fw.variant) <
532 HFA384x_FIRMWARE_VERSION(0, 8, 3)) {
533 /* Ad-Hoc not quite supported on Prism2 */
534 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
535 msg->resultcode.data = P80211ENUM_resultcode_not_supported;
536 goto done;
537 }
538
539 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
540
541 /*** STATION ***/
542 /* Set the REQUIRED config items */
543 /* SSID */
544 pstr = (p80211pstrd_t *) & (msg->ssid.data);
545 prism2mgmt_pstr2bytestr(p2bytestr, pstr);
546 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
547 bytebuf, HFA384x_RID_CNFOWNSSID_LEN);
548 if (result) {
549 printk(KERN_ERR "Failed to set CnfOwnSSID\n");
550 goto failed;
551 }
552 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
553 bytebuf,
554 HFA384x_RID_CNFDESIREDSSID_LEN);
555 if (result) {
556 printk(KERN_ERR "Failed to set CnfDesiredSSID\n");
557 goto failed;
558 }
559
560 /* bsstype - we use the default in the ap firmware */
561 /* IBSS port */
562 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, 0);
563
564 /* beacon period */
565 word = msg->beaconperiod.data;
566 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAPBCNint, word);
567 if (result) {
568 printk(KERN_ERR "Failed to set beacon period=%d.\n", word);
569 goto failed;
570 }
571
572 /* dschannel */
573 word = msg->dschannel.data;
574 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFOWNCHANNEL, word);
575 if (result) {
576 printk(KERN_ERR "Failed to set channel=%d.\n", word);
577 goto failed;
578 }
579 /* Basic rates */
580 word = p80211rate_to_p2bit(msg->basicrate1.data);
581 if (msg->basicrate2.status == P80211ENUM_msgitem_status_data_ok)
582 word |= p80211rate_to_p2bit(msg->basicrate2.data);
583
584 if (msg->basicrate3.status == P80211ENUM_msgitem_status_data_ok)
585 word |= p80211rate_to_p2bit(msg->basicrate3.data);
586
587 if (msg->basicrate4.status == P80211ENUM_msgitem_status_data_ok)
588 word |= p80211rate_to_p2bit(msg->basicrate4.data);
589
590 if (msg->basicrate5.status == P80211ENUM_msgitem_status_data_ok)
591 word |= p80211rate_to_p2bit(msg->basicrate5.data);
592
593 if (msg->basicrate6.status == P80211ENUM_msgitem_status_data_ok)
594 word |= p80211rate_to_p2bit(msg->basicrate6.data);
595
596 if (msg->basicrate7.status == P80211ENUM_msgitem_status_data_ok)
597 word |= p80211rate_to_p2bit(msg->basicrate7.data);
598
599 if (msg->basicrate8.status == P80211ENUM_msgitem_status_data_ok)
600 word |= p80211rate_to_p2bit(msg->basicrate8.data);
601
602 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFBASICRATES, word);
603 if (result) {
604 printk(KERN_ERR "Failed to set basicrates=%d.\n", word);
605 goto failed;
606 }
607
608 /* Operational rates (supprates and txratecontrol) */
609 word = p80211rate_to_p2bit(msg->operationalrate1.data);
610 if (msg->operationalrate2.status == P80211ENUM_msgitem_status_data_ok)
611 word |= p80211rate_to_p2bit(msg->operationalrate2.data);
612
613 if (msg->operationalrate3.status == P80211ENUM_msgitem_status_data_ok)
614 word |= p80211rate_to_p2bit(msg->operationalrate3.data);
615
616 if (msg->operationalrate4.status == P80211ENUM_msgitem_status_data_ok)
617 word |= p80211rate_to_p2bit(msg->operationalrate4.data);
618
619 if (msg->operationalrate5.status == P80211ENUM_msgitem_status_data_ok)
620 word |= p80211rate_to_p2bit(msg->operationalrate5.data);
621
622 if (msg->operationalrate6.status == P80211ENUM_msgitem_status_data_ok)
623 word |= p80211rate_to_p2bit(msg->operationalrate6.data);
624
625 if (msg->operationalrate7.status == P80211ENUM_msgitem_status_data_ok)
626 word |= p80211rate_to_p2bit(msg->operationalrate7.data);
627
628 if (msg->operationalrate8.status == P80211ENUM_msgitem_status_data_ok)
629 word |= p80211rate_to_p2bit(msg->operationalrate8.data);
630
631 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFSUPPRATES, word);
632 if (result) {
633 printk(KERN_ERR "Failed to set supprates=%d.\n", word);
634 goto failed;
635 }
636
637 result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, word);
638 if (result) {
639 printk(KERN_ERR "Failed to set txrates=%d.\n", word);
640 goto failed;
641 }
642
643 /* Set the macmode so the frame setup code knows what to do */
644 if (msg->bsstype.data == P80211ENUM_bsstype_independent) {
645 wlandev->macmode = WLAN_MACMODE_IBSS_STA;
646 /* lets extend the data length a bit */
647 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFMAXDATALEN, 2304);
648 }
649
650 /* Enable the Port */
651 result = hfa384x_drvr_enable(hw, 0);
652 if (result) {
653 printk(KERN_ERR "Enable macport failed, result=%d.\n", result);
654 goto failed;
655 }
656
657 msg->resultcode.data = P80211ENUM_resultcode_success;
658
659 goto done;
660 failed:
661 pr_debug("Failed to set a config option, result=%d\n", result);
662 msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
663
664 done:
665 result = 0;
666
667 return result;
668 }
669
670 /*----------------------------------------------------------------
671 * prism2mgmt_readpda
672 *
673 * Collect the PDA data and put it in the message.
674 *
675 * Arguments:
676 * wlandev wlan device structure
677 * msgp ptr to msg buffer
678 *
679 * Returns:
680 * 0 success and done
681 * <0 success, but we're waiting for something to finish.
682 * >0 an error occurred while handling the message.
683 * Side effects:
684 *
685 * Call context:
686 * process thread (usually)
687 ----------------------------------------------------------------*/
688 int prism2mgmt_readpda(wlandevice_t *wlandev, void *msgp)
689 {
690 hfa384x_t *hw = wlandev->priv;
691 p80211msg_p2req_readpda_t *msg = msgp;
692 int result;
693
694 /* We only support collecting the PDA when in the FWLOAD
695 * state.
696 */
697 if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
698 printk(KERN_ERR
699 "PDA may only be read " "in the fwload state.\n");
700 msg->resultcode.data =
701 P80211ENUM_resultcode_implementation_failure;
702 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
703 } else {
704 /* Call drvr_readpda(), it handles the auxport enable
705 * and validating the returned PDA.
706 */
707 result = hfa384x_drvr_readpda(hw,
708 msg->pda.data,
709 HFA384x_PDA_LEN_MAX);
710 if (result) {
711 printk(KERN_ERR
712 "hfa384x_drvr_readpda() failed, "
713 "result=%d\n", result);
714
715 msg->resultcode.data =
716 P80211ENUM_resultcode_implementation_failure;
717 msg->resultcode.status =
718 P80211ENUM_msgitem_status_data_ok;
719 return 0;
720 }
721 msg->pda.status = P80211ENUM_msgitem_status_data_ok;
722 msg->resultcode.data = P80211ENUM_resultcode_success;
723 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
724 }
725
726 return 0;
727 }
728
729 /*----------------------------------------------------------------
730 * prism2mgmt_ramdl_state
731 *
732 * Establishes the beginning/end of a card RAM download session.
733 *
734 * It is expected that the ramdl_write() function will be called
735 * one or more times between the 'enable' and 'disable' calls to
736 * this function.
737 *
738 * Note: This function should not be called when a mac comm port
739 * is active.
740 *
741 * Arguments:
742 * wlandev wlan device structure
743 * msgp ptr to msg buffer
744 *
745 * Returns:
746 * 0 success and done
747 * <0 success, but we're waiting for something to finish.
748 * >0 an error occurred while handling the message.
749 * Side effects:
750 *
751 * Call context:
752 * process thread (usually)
753 ----------------------------------------------------------------*/
754 int prism2mgmt_ramdl_state(wlandevice_t *wlandev, void *msgp)
755 {
756 hfa384x_t *hw = wlandev->priv;
757 p80211msg_p2req_ramdl_state_t *msg = msgp;
758
759 if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
760 printk(KERN_ERR
761 "ramdl_state(): may only be called "
762 "in the fwload state.\n");
763 msg->resultcode.data =
764 P80211ENUM_resultcode_implementation_failure;
765 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
766 return 0;
767 }
768
769 /*
770 ** Note: Interrupts are locked out if this is an AP and are NOT
771 ** locked out if this is a station.
772 */
773
774 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
775 if (msg->enable.data == P80211ENUM_truth_true) {
776 if (hfa384x_drvr_ramdl_enable(hw, msg->exeaddr.data)) {
777 msg->resultcode.data =
778 P80211ENUM_resultcode_implementation_failure;
779 } else {
780 msg->resultcode.data = P80211ENUM_resultcode_success;
781 }
782 } else {
783 hfa384x_drvr_ramdl_disable(hw);
784 msg->resultcode.data = P80211ENUM_resultcode_success;
785 }
786
787 return 0;
788 }
789
790 /*----------------------------------------------------------------
791 * prism2mgmt_ramdl_write
792 *
793 * Writes a buffer to the card RAM using the download state. This
794 * is for writing code to card RAM. To just read or write raw data
795 * use the aux functions.
796 *
797 * Arguments:
798 * wlandev wlan device structure
799 * msgp ptr to msg buffer
800 *
801 * Returns:
802 * 0 success and done
803 * <0 success, but we're waiting for something to finish.
804 * >0 an error occurred while handling the message.
805 * Side effects:
806 *
807 * Call context:
808 * process thread (usually)
809 ----------------------------------------------------------------*/
810 int prism2mgmt_ramdl_write(wlandevice_t *wlandev, void *msgp)
811 {
812 hfa384x_t *hw = wlandev->priv;
813 p80211msg_p2req_ramdl_write_t *msg = msgp;
814 u32 addr;
815 u32 len;
816 u8 *buf;
817
818 if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
819 printk(KERN_ERR
820 "ramdl_write(): may only be called "
821 "in the fwload state.\n");
822 msg->resultcode.data =
823 P80211ENUM_resultcode_implementation_failure;
824 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
825 return 0;
826 }
827
828 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
829 /* first validate the length */
830 if (msg->len.data > sizeof(msg->data.data)) {
831 msg->resultcode.status =
832 P80211ENUM_resultcode_invalid_parameters;
833 return 0;
834 }
835 /* call the hfa384x function to do the write */
836 addr = msg->addr.data;
837 len = msg->len.data;
838 buf = msg->data.data;
839 if (hfa384x_drvr_ramdl_write(hw, addr, buf, len))
840 msg->resultcode.data = P80211ENUM_resultcode_refused;
841
842 msg->resultcode.data = P80211ENUM_resultcode_success;
843
844 return 0;
845 }
846
847 /*----------------------------------------------------------------
848 * prism2mgmt_flashdl_state
849 *
850 * Establishes the beginning/end of a card Flash download session.
851 *
852 * It is expected that the flashdl_write() function will be called
853 * one or more times between the 'enable' and 'disable' calls to
854 * this function.
855 *
856 * Note: This function should not be called when a mac comm port
857 * is active.
858 *
859 * Arguments:
860 * wlandev wlan device structure
861 * msgp ptr to msg buffer
862 *
863 * Returns:
864 * 0 success and done
865 * <0 success, but we're waiting for something to finish.
866 * >0 an error occurred while handling the message.
867 * Side effects:
868 *
869 * Call context:
870 * process thread (usually)
871 ----------------------------------------------------------------*/
872 int prism2mgmt_flashdl_state(wlandevice_t *wlandev, void *msgp)
873 {
874 int result = 0;
875 hfa384x_t *hw = wlandev->priv;
876 p80211msg_p2req_flashdl_state_t *msg = msgp;
877
878 if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
879 printk(KERN_ERR
880 "flashdl_state(): may only be called "
881 "in the fwload state.\n");
882 msg->resultcode.data =
883 P80211ENUM_resultcode_implementation_failure;
884 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
885 return 0;
886 }
887
888 /*
889 ** Note: Interrupts are locked out if this is an AP and are NOT
890 ** locked out if this is a station.
891 */
892
893 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
894 if (msg->enable.data == P80211ENUM_truth_true) {
895 if (hfa384x_drvr_flashdl_enable(hw)) {
896 msg->resultcode.data =
897 P80211ENUM_resultcode_implementation_failure;
898 } else {
899 msg->resultcode.data = P80211ENUM_resultcode_success;
900 }
901 } else {
902 hfa384x_drvr_flashdl_disable(hw);
903 msg->resultcode.data = P80211ENUM_resultcode_success;
904 /* NOTE: At this point, the MAC is in the post-reset
905 * state and the driver is in the fwload state.
906 * We need to get the MAC back into the fwload
907 * state. To do this, we set the nsdstate to HWPRESENT
908 * and then call the ifstate function to redo everything
909 * that got us into the fwload state.
910 */
911 wlandev->msdstate = WLAN_MSD_HWPRESENT;
912 result = prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload);
913 if (result != P80211ENUM_resultcode_success) {
914 printk(KERN_ERR "prism2sta_ifstate(fwload) failed,"
915 "P80211ENUM_resultcode=%d\n", result);
916 msg->resultcode.data =
917 P80211ENUM_resultcode_implementation_failure;
918 result = -1;
919 }
920 }
921
922 return 0;
923 }
924
925 /*----------------------------------------------------------------
926 * prism2mgmt_flashdl_write
927 *
928 *
929 *
930 * Arguments:
931 * wlandev wlan device structure
932 * msgp ptr to msg buffer
933 *
934 * Returns:
935 * 0 success and done
936 * <0 success, but we're waiting for something to finish.
937 * >0 an error occurred while handling the message.
938 * Side effects:
939 *
940 * Call context:
941 * process thread (usually)
942 ----------------------------------------------------------------*/
943 int prism2mgmt_flashdl_write(wlandevice_t *wlandev, void *msgp)
944 {
945 hfa384x_t *hw = wlandev->priv;
946 p80211msg_p2req_flashdl_write_t *msg = msgp;
947 u32 addr;
948 u32 len;
949 u8 *buf;
950
951 if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
952 printk(KERN_ERR
953 "flashdl_write(): may only be called "
954 "in the fwload state.\n");
955 msg->resultcode.data =
956 P80211ENUM_resultcode_implementation_failure;
957 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
958 return 0;
959 }
960
961 /*
962 ** Note: Interrupts are locked out if this is an AP and are NOT
963 ** locked out if this is a station.
964 */
965
966 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
967 /* first validate the length */
968 if (msg->len.data > sizeof(msg->data.data)) {
969 msg->resultcode.status =
970 P80211ENUM_resultcode_invalid_parameters;
971 return 0;
972 }
973 /* call the hfa384x function to do the write */
974 addr = msg->addr.data;
975 len = msg->len.data;
976 buf = msg->data.data;
977 if (hfa384x_drvr_flashdl_write(hw, addr, buf, len))
978 msg->resultcode.data = P80211ENUM_resultcode_refused;
979
980 msg->resultcode.data = P80211ENUM_resultcode_success;
981
982 return 0;
983 }
984
985 /*----------------------------------------------------------------
986 * prism2mgmt_autojoin
987 *
988 * Associate with an ESS.
989 *
990 * Arguments:
991 * wlandev wlan device structure
992 * msgp ptr to msg buffer
993 *
994 * Returns:
995 * 0 success and done
996 * <0 success, but we're waiting for something to finish.
997 * >0 an error occurred while handling the message.
998 * Side effects:
999 *
1000 * Call context:
1001 * process thread (usually)
1002 * interrupt
1003 ----------------------------------------------------------------*/
1004 int prism2mgmt_autojoin(wlandevice_t *wlandev, void *msgp)
1005 {
1006 hfa384x_t *hw = wlandev->priv;
1007 int result = 0;
1008 u16 reg;
1009 u16 port_type;
1010 p80211msg_lnxreq_autojoin_t *msg = msgp;
1011 p80211pstrd_t *pstr;
1012 u8 bytebuf[256];
1013 hfa384x_bytestr_t *p2bytestr = (hfa384x_bytestr_t *) bytebuf;
1014
1015 wlandev->macmode = WLAN_MACMODE_NONE;
1016
1017 /* Set the SSID */
1018 memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
1019
1020 /* Disable the Port */
1021 hfa384x_drvr_disable(hw, 0);
1022
1023 /*** STATION ***/
1024 /* Set the TxRates */
1025 hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, 0x000f);
1026
1027 /* Set the auth type */
1028 if (msg->authtype.data == P80211ENUM_authalg_sharedkey)
1029 reg = HFA384x_CNFAUTHENTICATION_SHAREDKEY;
1030 else
1031 reg = HFA384x_CNFAUTHENTICATION_OPENSYSTEM;
1032
1033 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAUTHENTICATION, reg);
1034
1035 /* Set the ssid */
1036 memset(bytebuf, 0, 256);
1037 pstr = (p80211pstrd_t *) & (msg->ssid.data);
1038 prism2mgmt_pstr2bytestr(p2bytestr, pstr);
1039 result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
1040 bytebuf,
1041 HFA384x_RID_CNFDESIREDSSID_LEN);
1042 port_type = HFA384x_PORTTYPE_BSS;
1043 /* Set the PortType */
1044 hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, port_type);
1045
1046 /* Enable the Port */
1047 hfa384x_drvr_enable(hw, 0);
1048
1049 /* Set the resultcode */
1050 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
1051 msg->resultcode.data = P80211ENUM_resultcode_success;
1052
1053 return result;
1054 }
1055
1056 /*----------------------------------------------------------------
1057 * prism2mgmt_wlansniff
1058 *
1059 * Start or stop sniffing.
1060 *
1061 * Arguments:
1062 * wlandev wlan device structure
1063 * msgp ptr to msg buffer
1064 *
1065 * Returns:
1066 * 0 success and done
1067 * <0 success, but we're waiting for something to finish.
1068 * >0 an error occurred while handling the message.
1069 * Side effects:
1070 *
1071 * Call context:
1072 * process thread (usually)
1073 * interrupt
1074 ----------------------------------------------------------------*/
1075 int prism2mgmt_wlansniff(wlandevice_t *wlandev, void *msgp)
1076 {
1077 int result = 0;
1078 p80211msg_lnxreq_wlansniff_t *msg = msgp;
1079
1080 hfa384x_t *hw = wlandev->priv;
1081 u16 word;
1082
1083 msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
1084 switch (msg->enable.data) {
1085 case P80211ENUM_truth_false:
1086 /* Confirm that we're in monitor mode */
1087 if (wlandev->netdev->type == ARPHRD_ETHER) {
1088 msg->resultcode.data =
1089 P80211ENUM_resultcode_invalid_parameters;
1090 result = 0;
1091 goto exit;
1092 }
1093 /* Disable monitor mode */
1094 result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_DISABLE);
1095 if (result) {
1096 pr_debug("failed to disable monitor mode, result=%d\n",
1097 result);
1098 goto failed;
1099 }
1100 /* Disable port 0 */
1101 result = hfa384x_drvr_disable(hw, 0);
1102 if (result) {
1103 pr_debug
1104 ("failed to disable port 0 after sniffing, result=%d\n",
1105 result);
1106 goto failed;
1107 }
1108 /* Clear the driver state */
1109 wlandev->netdev->type = ARPHRD_ETHER;
1110
1111 /* Restore the wepflags */
1112 result = hfa384x_drvr_setconfig16(hw,
1113 HFA384x_RID_CNFWEPFLAGS,
1114 hw->presniff_wepflags);
1115 if (result) {
1116 pr_debug
1117 ("failed to restore wepflags=0x%04x, result=%d\n",
1118 hw->presniff_wepflags, result);
1119 goto failed;
1120 }
1121
1122 /* Set the port to its prior type and enable (if necessary) */
1123 if (hw->presniff_port_type != 0) {
1124 word = hw->presniff_port_type;
1125 result = hfa384x_drvr_setconfig16(hw,
1126 HFA384x_RID_CNFPORTTYPE,
1127 word);
1128 if (result) {
1129 pr_debug
1130 ("failed to restore porttype, result=%d\n",
1131 result);
1132 goto failed;
1133 }
1134
1135 /* Enable the port */
1136 result = hfa384x_drvr_enable(hw, 0);
1137 if (result) {
1138 pr_debug
1139 ("failed to enable port to presniff setting, result=%d\n",
1140 result);
1141 goto failed;
1142 }
1143 } else {
1144 result = hfa384x_drvr_disable(hw, 0);
1145
1146 }
1147
1148 printk(KERN_INFO "monitor mode disabled\n");
1149 msg->resultcode.data = P80211ENUM_resultcode_success;
1150 result = 0;
1151 goto exit;
1152 break;
1153 case P80211ENUM_truth_true:
1154 /* Disable the port (if enabled), only check Port 0 */
1155 if (hw->port_enabled[0]) {
1156 if (wlandev->netdev->type == ARPHRD_ETHER) {
1157 /* Save macport 0 state */
1158 result = hfa384x_drvr_getconfig16(hw,
1159 HFA384x_RID_CNFPORTTYPE,
1160 &
1161 (hw->
1162 presniff_port_type));
1163 if (result) {
1164 pr_debug
1165 ("failed to read porttype, result=%d\n",
1166 result);
1167 goto failed;
1168 }
1169 /* Save the wepflags state */
1170 result = hfa384x_drvr_getconfig16(hw,
1171 HFA384x_RID_CNFWEPFLAGS,
1172 &
1173 (hw->
1174 presniff_wepflags));
1175 if (result) {
1176 pr_debug
1177 ("failed to read wepflags, result=%d\n",
1178 result);
1179 goto failed;
1180 }
1181 hfa384x_drvr_stop(hw);
1182 result = hfa384x_drvr_start(hw);
1183 if (result) {
1184 pr_debug
1185 ("failed to restart the card for sniffing, result=%d\n",
1186 result);
1187 goto failed;
1188 }
1189 } else {
1190 /* Disable the port */
1191 result = hfa384x_drvr_disable(hw, 0);
1192 if (result) {
1193 pr_debug
1194 ("failed to enable port for sniffing, result=%d\n",
1195 result);
1196 goto failed;
1197 }
1198 }
1199 } else {
1200 hw->presniff_port_type = 0;
1201 }
1202
1203 /* Set the channel we wish to sniff */
1204 word = msg->channel.data;
1205 result = hfa384x_drvr_setconfig16(hw,
1206 HFA384x_RID_CNFOWNCHANNEL,
1207 word);
1208 hw->sniff_channel = word;
1209
1210 if (result) {
1211 pr_debug("failed to set channel %d, result=%d\n",
1212 word, result);
1213 goto failed;
1214 }
1215
1216 /* Now if we're already sniffing, we can skip the rest */
1217 if (wlandev->netdev->type != ARPHRD_ETHER) {
1218 /* Set the port type to pIbss */
1219 word = HFA384x_PORTTYPE_PSUEDOIBSS;
1220 result = hfa384x_drvr_setconfig16(hw,
1221 HFA384x_RID_CNFPORTTYPE,
1222 word);
1223 if (result) {
1224 pr_debug
1225 ("failed to set porttype %d, result=%d\n",
1226 word, result);
1227 goto failed;
1228 }
1229 if ((msg->keepwepflags.status ==
1230 P80211ENUM_msgitem_status_data_ok)
1231 && (msg->keepwepflags.data !=
1232 P80211ENUM_truth_true)) {
1233 /* Set the wepflags for no decryption */
1234 word = HFA384x_WEPFLAGS_DISABLE_TXCRYPT |
1235 HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
1236 result =
1237 hfa384x_drvr_setconfig16(hw,
1238 HFA384x_RID_CNFWEPFLAGS,
1239 word);
1240 }
1241
1242 if (result) {
1243 pr_debug
1244 ("failed to set wepflags=0x%04x, result=%d\n",
1245 word, result);
1246 goto failed;
1247 }
1248 }
1249
1250 /* Do we want to strip the FCS in monitor mode? */
1251 if ((msg->stripfcs.status == P80211ENUM_msgitem_status_data_ok)
1252 && (msg->stripfcs.data == P80211ENUM_truth_true)) {
1253 hw->sniff_fcs = 0;
1254 } else {
1255 hw->sniff_fcs = 1;
1256 }
1257
1258 /* Do we want to truncate the packets? */
1259 if (msg->packet_trunc.status ==
1260 P80211ENUM_msgitem_status_data_ok) {
1261 hw->sniff_truncate = msg->packet_trunc.data;
1262 } else {
1263 hw->sniff_truncate = 0;
1264 }
1265
1266 /* Enable the port */
1267 result = hfa384x_drvr_enable(hw, 0);
1268 if (result) {
1269 pr_debug
1270 ("failed to enable port for sniffing, result=%d\n",
1271 result);
1272 goto failed;
1273 }
1274 /* Enable monitor mode */
1275 result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_ENABLE);
1276 if (result) {
1277 pr_debug("failed to enable monitor mode, result=%d\n",
1278 result);
1279 goto failed;
1280 }
1281
1282 if (wlandev->netdev->type == ARPHRD_ETHER)
1283 printk(KERN_INFO "monitor mode enabled\n");
1284
1285 /* Set the driver state */
1286 /* Do we want the prism2 header? */
1287 if ((msg->prismheader.status ==
1288 P80211ENUM_msgitem_status_data_ok)
1289 && (msg->prismheader.data == P80211ENUM_truth_true)) {
1290 hw->sniffhdr = 0;
1291 wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
1292 } else
1293 if ((msg->wlanheader.status ==
1294 P80211ENUM_msgitem_status_data_ok)
1295 && (msg->wlanheader.data == P80211ENUM_truth_true)) {
1296 hw->sniffhdr = 1;
1297 wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
1298 } else {
1299 wlandev->netdev->type = ARPHRD_IEEE80211;
1300 }
1301
1302 msg->resultcode.data = P80211ENUM_resultcode_success;
1303 result = 0;
1304 goto exit;
1305 break;
1306 default:
1307 msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
1308 result = 0;
1309 goto exit;
1310 break;
1311 }
1312
1313 failed:
1314 msg->resultcode.data = P80211ENUM_resultcode_refused;
1315 result = 0;
1316 exit:
1317 return result;
1318 }
Linux with added FPC-III support