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