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