// SPDX-License-Identifier: (GPL-2.0 OR MPL-1.1)
|
/* src/prism2/driver/prism2mgmt.c
|
*
|
* Management request handler functions.
|
*
|
* Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
|
* --------------------------------------------------------------------
|
*
|
* linux-wlan
|
*
|
* The contents of this file are subject to the Mozilla Public
|
* License Version 1.1 (the "License"); you may not use this file
|
* except in compliance with the License. You may obtain a copy of
|
* the License at http://www.mozilla.org/MPL/
|
*
|
* Software distributed under the License is distributed on an "AS
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
* implied. See the License for the specific language governing
|
* rights and limitations under the License.
|
*
|
* Alternatively, the contents of this file may be used under the
|
* terms of the GNU Public License version 2 (the "GPL"), in which
|
* case the provisions of the GPL are applicable instead of the
|
* above. If you wish to allow the use of your version of this file
|
* only under the terms of the GPL and not to allow others to use
|
* your version of this file under the MPL, indicate your decision
|
* by deleting the provisions above and replace them with the notice
|
* and other provisions required by the GPL. If you do not delete
|
* the provisions above, a recipient may use your version of this
|
* file under either the MPL or the GPL.
|
*
|
* --------------------------------------------------------------------
|
*
|
* Inquiries regarding the linux-wlan Open Source project can be
|
* made directly to:
|
*
|
* AbsoluteValue Systems Inc.
|
* info@linux-wlan.com
|
* http://www.linux-wlan.com
|
*
|
* --------------------------------------------------------------------
|
*
|
* Portions of the development of this software were funded by
|
* Intersil Corporation as part of PRISM(R) chipset product development.
|
*
|
* --------------------------------------------------------------------
|
*
|
* The functions in this file handle management requests sent from
|
* user mode.
|
*
|
* Most of these functions have two separate blocks of code that are
|
* conditional on whether this is a station or an AP. This is used
|
* to separate out the STA and AP responses to these management primitives.
|
* It's a choice (good, bad, indifferent?) to have the code in the same
|
* place so it's clear that the same primitive is implemented in both
|
* cases but has different behavior.
|
*
|
* --------------------------------------------------------------------
|
*/
|
|
#include <linux/if_arp.h>
|
#include <linux/module.h>
|
#include <linux/kernel.h>
|
#include <linux/wait.h>
|
#include <linux/sched.h>
|
#include <linux/types.h>
|
#include <linux/wireless.h>
|
#include <linux/netdevice.h>
|
#include <linux/delay.h>
|
#include <linux/io.h>
|
#include <asm/byteorder.h>
|
#include <linux/random.h>
|
#include <linux/usb.h>
|
#include <linux/bitops.h>
|
|
#include "p80211types.h"
|
#include "p80211hdr.h"
|
#include "p80211mgmt.h"
|
#include "p80211conv.h"
|
#include "p80211msg.h"
|
#include "p80211netdev.h"
|
#include "p80211metadef.h"
|
#include "p80211metastruct.h"
|
#include "hfa384x.h"
|
#include "prism2mgmt.h"
|
|
/* Converts 802.11 format rate specifications to prism2 */
|
static inline u16 p80211rate_to_p2bit(u32 rate)
|
{
|
switch (rate & ~BIT(7)) {
|
case 2:
|
return BIT(0);
|
case 4:
|
return BIT(1);
|
case 11:
|
return BIT(2);
|
case 22:
|
return BIT(3);
|
default:
|
return 0;
|
}
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_scan
|
*
|
* Initiate a scan for BSSs.
|
*
|
* This function corresponds to MLME-scan.request and part of
|
* MLME-scan.confirm. As far as I can tell in the standard, there
|
* are no restrictions on when a scan.request may be issued. We have
|
* to handle in whatever state the driver/MAC happen to be.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
* interrupt
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_scan(struct wlandevice *wlandev, void *msgp)
|
{
|
int result = 0;
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_dot11req_scan *msg = msgp;
|
u16 roamingmode, word;
|
int i, timeout;
|
int istmpenable = 0;
|
|
struct hfa384x_host_scan_request_data scanreq;
|
|
/* gatekeeper check */
|
if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
|
hw->ident_sta_fw.minor,
|
hw->ident_sta_fw.variant) <
|
HFA384x_FIRMWARE_VERSION(1, 3, 2)) {
|
netdev_err(wlandev->netdev,
|
"HostScan not supported with current firmware (<1.3.2).\n");
|
result = 1;
|
msg->resultcode.data = P80211ENUM_resultcode_not_supported;
|
goto exit;
|
}
|
|
memset(&scanreq, 0, sizeof(scanreq));
|
|
/* save current roaming mode */
|
result = hfa384x_drvr_getconfig16(hw,
|
HFA384x_RID_CNFROAMINGMODE,
|
&roamingmode);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"getconfig(ROAMMODE) failed. result=%d\n", result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
|
/* drop into mode 3 for the scan */
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFROAMINGMODE,
|
HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"setconfig(ROAMINGMODE) failed. result=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
|
/* active or passive? */
|
if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
|
hw->ident_sta_fw.minor,
|
hw->ident_sta_fw.variant) >
|
HFA384x_FIRMWARE_VERSION(1, 5, 0)) {
|
if (msg->scantype.data != P80211ENUM_scantype_active)
|
word = msg->maxchanneltime.data;
|
else
|
word = 0;
|
|
result =
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPASSIVESCANCTRL,
|
word);
|
if (result) {
|
netdev_warn(wlandev->netdev,
|
"Passive scan not supported with current firmware. (<1.5.1)\n");
|
}
|
}
|
|
/* set up the txrate to be 2MBPS. Should be fastest basicrate... */
|
word = HFA384x_RATEBIT_2;
|
scanreq.tx_rate = cpu_to_le16(word);
|
|
/* set up the channel list */
|
word = 0;
|
for (i = 0; i < msg->channellist.data.len; i++) {
|
u8 channel = msg->channellist.data.data[i];
|
|
if (channel > 14)
|
continue;
|
/* channel 1 is BIT 0 ... channel 14 is BIT 13 */
|
word |= (1 << (channel - 1));
|
}
|
scanreq.channel_list = cpu_to_le16(word);
|
|
/* set up the ssid, if present. */
|
scanreq.ssid.len = cpu_to_le16(msg->ssid.data.len);
|
memcpy(scanreq.ssid.data, msg->ssid.data.data, msg->ssid.data.len);
|
|
/* Enable the MAC port if it's not already enabled */
|
result = hfa384x_drvr_getconfig16(hw, HFA384x_RID_PORTSTATUS, &word);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"getconfig(PORTSTATUS) failed. result=%d\n", result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
if (word == HFA384x_PORTSTATUS_DISABLED) {
|
__le16 wordbuf[17];
|
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFROAMINGMODE,
|
HFA384x_ROAMMODE_HOSTSCAN_HOSTROAM);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"setconfig(ROAMINGMODE) failed. result=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
/* Construct a bogus SSID and assign it to OwnSSID and
|
* DesiredSSID
|
*/
|
wordbuf[0] = cpu_to_le16(WLAN_SSID_MAXLEN);
|
get_random_bytes(&wordbuf[1], WLAN_SSID_MAXLEN);
|
result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
|
wordbuf,
|
HFA384x_RID_CNFOWNSSID_LEN);
|
if (result) {
|
netdev_err(wlandev->netdev, "Failed to set OwnSSID.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
|
wordbuf,
|
HFA384x_RID_CNFDESIREDSSID_LEN);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set DesiredSSID.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
/* bsstype */
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFPORTTYPE,
|
HFA384x_PORTTYPE_IBSS);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set CNFPORTTYPE.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
/* ibss options */
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CREATEIBSS,
|
HFA384x_CREATEIBSS_JOINCREATEIBSS);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set CREATEIBSS.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
result = hfa384x_drvr_enable(hw, 0);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"drvr_enable(0) failed. result=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
istmpenable = 1;
|
}
|
|
/* Figure out our timeout first Kus, then HZ */
|
timeout = msg->channellist.data.len * msg->maxchanneltime.data;
|
timeout = (timeout * HZ) / 1000;
|
|
/* Issue the scan request */
|
hw->scanflag = 0;
|
|
result = hfa384x_drvr_setconfig(hw,
|
HFA384x_RID_HOSTSCAN, &scanreq,
|
sizeof(scanreq));
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"setconfig(SCANREQUEST) failed. result=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
|
/* sleep until info frame arrives */
|
wait_event_interruptible_timeout(hw->cmdq, hw->scanflag, timeout);
|
|
msg->numbss.status = P80211ENUM_msgitem_status_data_ok;
|
if (hw->scanflag == -1)
|
hw->scanflag = 0;
|
|
msg->numbss.data = hw->scanflag;
|
|
hw->scanflag = 0;
|
|
/* Disable port if we temporarily enabled it. */
|
if (istmpenable) {
|
result = hfa384x_drvr_disable(hw, 0);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"drvr_disable(0) failed. result=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
}
|
|
/* restore original roaming mode */
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFROAMINGMODE,
|
roamingmode);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"setconfig(ROAMMODE) failed. result=%d\n", result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
goto exit;
|
}
|
|
result = 0;
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
|
exit:
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
|
return result;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_scan_results
|
*
|
* Retrieve the BSS description for one of the BSSs identified in
|
* a scan.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
* interrupt
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_scan_results(struct wlandevice *wlandev, void *msgp)
|
{
|
int result = 0;
|
struct p80211msg_dot11req_scan_results *req;
|
struct hfa384x *hw = wlandev->priv;
|
struct hfa384x_hscan_result_sub *item = NULL;
|
|
int count;
|
|
req = msgp;
|
|
req->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
|
if (!hw->scanresults) {
|
netdev_err(wlandev->netdev,
|
"dot11req_scan_results can only be used after a successful dot11req_scan.\n");
|
result = 2;
|
req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
|
goto exit;
|
}
|
|
count = (hw->scanresults->framelen - 3) / 32;
|
if (count > HFA384x_SCANRESULT_MAX)
|
count = HFA384x_SCANRESULT_MAX;
|
|
if (req->bssindex.data >= count) {
|
netdev_dbg(wlandev->netdev,
|
"requested index (%d) out of range (%d)\n",
|
req->bssindex.data, count);
|
result = 2;
|
req->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
|
goto exit;
|
}
|
|
item = &hw->scanresults->info.hscanresult.result[req->bssindex.data];
|
/* signal and noise */
|
req->signal.status = P80211ENUM_msgitem_status_data_ok;
|
req->noise.status = P80211ENUM_msgitem_status_data_ok;
|
req->signal.data = le16_to_cpu(item->sl);
|
req->noise.data = le16_to_cpu(item->anl);
|
|
/* BSSID */
|
req->bssid.status = P80211ENUM_msgitem_status_data_ok;
|
req->bssid.data.len = WLAN_BSSID_LEN;
|
memcpy(req->bssid.data.data, item->bssid, WLAN_BSSID_LEN);
|
|
/* SSID */
|
req->ssid.status = P80211ENUM_msgitem_status_data_ok;
|
req->ssid.data.len = le16_to_cpu(item->ssid.len);
|
req->ssid.data.len = min_t(u16, req->ssid.data.len, WLAN_SSID_MAXLEN);
|
memcpy(req->ssid.data.data, item->ssid.data, req->ssid.data.len);
|
|
/* supported rates */
|
for (count = 0; count < 10; count++)
|
if (item->supprates[count] == 0)
|
break;
|
|
#define REQBASICRATE(N) \
|
do { \
|
if ((count >= (N)) && DOT11_RATE5_ISBASIC_GET( \
|
item->supprates[(N) - 1])) { \
|
req->basicrate ## N .data = item->supprates[(N) - 1]; \
|
req->basicrate ## N .status = \
|
P80211ENUM_msgitem_status_data_ok; \
|
} \
|
} while (0)
|
|
REQBASICRATE(1);
|
REQBASICRATE(2);
|
REQBASICRATE(3);
|
REQBASICRATE(4);
|
REQBASICRATE(5);
|
REQBASICRATE(6);
|
REQBASICRATE(7);
|
REQBASICRATE(8);
|
|
#define REQSUPPRATE(N) \
|
do { \
|
if (count >= (N)) { \
|
req->supprate ## N .data = item->supprates[(N) - 1]; \
|
req->supprate ## N .status = \
|
P80211ENUM_msgitem_status_data_ok; \
|
} \
|
} while (0)
|
|
REQSUPPRATE(1);
|
REQSUPPRATE(2);
|
REQSUPPRATE(3);
|
REQSUPPRATE(4);
|
REQSUPPRATE(5);
|
REQSUPPRATE(6);
|
REQSUPPRATE(7);
|
REQSUPPRATE(8);
|
|
/* beacon period */
|
req->beaconperiod.status = P80211ENUM_msgitem_status_data_ok;
|
req->beaconperiod.data = le16_to_cpu(item->bcnint);
|
|
/* timestamps */
|
req->timestamp.status = P80211ENUM_msgitem_status_data_ok;
|
req->timestamp.data = jiffies;
|
req->localtime.status = P80211ENUM_msgitem_status_data_ok;
|
req->localtime.data = jiffies;
|
|
/* atim window */
|
req->ibssatimwindow.status = P80211ENUM_msgitem_status_data_ok;
|
req->ibssatimwindow.data = le16_to_cpu(item->atim);
|
|
/* Channel */
|
req->dschannel.status = P80211ENUM_msgitem_status_data_ok;
|
req->dschannel.data = le16_to_cpu(item->chid);
|
|
/* capinfo bits */
|
count = le16_to_cpu(item->capinfo);
|
req->capinfo.status = P80211ENUM_msgitem_status_data_ok;
|
req->capinfo.data = count;
|
|
/* privacy flag */
|
req->privacy.status = P80211ENUM_msgitem_status_data_ok;
|
req->privacy.data = WLAN_GET_MGMT_CAP_INFO_PRIVACY(count);
|
|
/* cfpollable */
|
req->cfpollable.status = P80211ENUM_msgitem_status_data_ok;
|
req->cfpollable.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLABLE(count);
|
|
/* cfpollreq */
|
req->cfpollreq.status = P80211ENUM_msgitem_status_data_ok;
|
req->cfpollreq.data = WLAN_GET_MGMT_CAP_INFO_CFPOLLREQ(count);
|
|
/* bsstype */
|
req->bsstype.status = P80211ENUM_msgitem_status_data_ok;
|
req->bsstype.data = (WLAN_GET_MGMT_CAP_INFO_ESS(count)) ?
|
P80211ENUM_bsstype_infrastructure : P80211ENUM_bsstype_independent;
|
|
result = 0;
|
req->resultcode.data = P80211ENUM_resultcode_success;
|
|
exit:
|
return result;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_start
|
*
|
* Start a BSS. Any station can do this for IBSS, only AP for ESS.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
* interrupt
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_start(struct wlandevice *wlandev, void *msgp)
|
{
|
int result = 0;
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_dot11req_start *msg = msgp;
|
|
struct p80211pstrd *pstr;
|
u8 bytebuf[80];
|
struct hfa384x_bytestr *p2bytestr = (struct hfa384x_bytestr *)bytebuf;
|
u16 word;
|
|
wlandev->macmode = WLAN_MACMODE_NONE;
|
|
/* Set the SSID */
|
memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
|
|
/*** ADHOC IBSS ***/
|
/* see if current f/w is less than 8c3 */
|
if (HFA384x_FIRMWARE_VERSION(hw->ident_sta_fw.major,
|
hw->ident_sta_fw.minor,
|
hw->ident_sta_fw.variant) <
|
HFA384x_FIRMWARE_VERSION(0, 8, 3)) {
|
/* Ad-Hoc not quite supported on Prism2 */
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
msg->resultcode.data = P80211ENUM_resultcode_not_supported;
|
goto done;
|
}
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
|
/*** STATION ***/
|
/* Set the REQUIRED config items */
|
/* SSID */
|
pstr = (struct p80211pstrd *)&msg->ssid.data;
|
prism2mgmt_pstr2bytestr(p2bytestr, pstr);
|
result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFOWNSSID,
|
bytebuf, HFA384x_RID_CNFOWNSSID_LEN);
|
if (result) {
|
netdev_err(wlandev->netdev, "Failed to set CnfOwnSSID\n");
|
goto failed;
|
}
|
result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
|
bytebuf,
|
HFA384x_RID_CNFDESIREDSSID_LEN);
|
if (result) {
|
netdev_err(wlandev->netdev, "Failed to set CnfDesiredSSID\n");
|
goto failed;
|
}
|
|
/* bsstype - we use the default in the ap firmware */
|
/* IBSS port */
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, 0);
|
|
/* beacon period */
|
word = msg->beaconperiod.data;
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAPBCNINT, word);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set beacon period=%d.\n", word);
|
goto failed;
|
}
|
|
/* dschannel */
|
word = msg->dschannel.data;
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFOWNCHANNEL, word);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set channel=%d.\n", word);
|
goto failed;
|
}
|
/* Basic rates */
|
word = p80211rate_to_p2bit(msg->basicrate1.data);
|
if (msg->basicrate2.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate2.data);
|
|
if (msg->basicrate3.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate3.data);
|
|
if (msg->basicrate4.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate4.data);
|
|
if (msg->basicrate5.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate5.data);
|
|
if (msg->basicrate6.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate6.data);
|
|
if (msg->basicrate7.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate7.data);
|
|
if (msg->basicrate8.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->basicrate8.data);
|
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFBASICRATES, word);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set basicrates=%d.\n", word);
|
goto failed;
|
}
|
|
/* Operational rates (supprates and txratecontrol) */
|
word = p80211rate_to_p2bit(msg->operationalrate1.data);
|
if (msg->operationalrate2.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate2.data);
|
|
if (msg->operationalrate3.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate3.data);
|
|
if (msg->operationalrate4.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate4.data);
|
|
if (msg->operationalrate5.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate5.data);
|
|
if (msg->operationalrate6.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate6.data);
|
|
if (msg->operationalrate7.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate7.data);
|
|
if (msg->operationalrate8.status == P80211ENUM_msgitem_status_data_ok)
|
word |= p80211rate_to_p2bit(msg->operationalrate8.data);
|
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFSUPPRATES, word);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Failed to set supprates=%d.\n", word);
|
goto failed;
|
}
|
|
result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, word);
|
if (result) {
|
netdev_err(wlandev->netdev, "Failed to set txrates=%d.\n",
|
word);
|
goto failed;
|
}
|
|
/* Set the macmode so the frame setup code knows what to do */
|
if (msg->bsstype.data == P80211ENUM_bsstype_independent) {
|
wlandev->macmode = WLAN_MACMODE_IBSS_STA;
|
/* lets extend the data length a bit */
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFMAXDATALEN, 2304);
|
}
|
|
/* Enable the Port */
|
result = hfa384x_drvr_enable(hw, 0);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"Enable macport failed, result=%d.\n", result);
|
goto failed;
|
}
|
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
|
goto done;
|
failed:
|
netdev_dbg(wlandev->netdev,
|
"Failed to set a config option, result=%d\n", result);
|
msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
|
|
done:
|
return 0;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_readpda
|
*
|
* Collect the PDA data and put it in the message.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_readpda(struct wlandevice *wlandev, void *msgp)
|
{
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_p2req_readpda *msg = msgp;
|
int result;
|
|
/* We only support collecting the PDA when in the FWLOAD
|
* state.
|
*/
|
if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
|
netdev_err(wlandev->netdev,
|
"PDA may only be read in the fwload state.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
} else {
|
/* Call drvr_readpda(), it handles the auxport enable
|
* and validating the returned PDA.
|
*/
|
result = hfa384x_drvr_readpda(hw,
|
msg->pda.data,
|
HFA384x_PDA_LEN_MAX);
|
if (result) {
|
netdev_err(wlandev->netdev,
|
"hfa384x_drvr_readpda() failed, result=%d\n",
|
result);
|
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status =
|
P80211ENUM_msgitem_status_data_ok;
|
return 0;
|
}
|
msg->pda.status = P80211ENUM_msgitem_status_data_ok;
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
}
|
|
return 0;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_ramdl_state
|
*
|
* Establishes the beginning/end of a card RAM download session.
|
*
|
* It is expected that the ramdl_write() function will be called
|
* one or more times between the 'enable' and 'disable' calls to
|
* this function.
|
*
|
* Note: This function should not be called when a mac comm port
|
* is active.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_ramdl_state(struct wlandevice *wlandev, void *msgp)
|
{
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_p2req_ramdl_state *msg = msgp;
|
|
if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
|
netdev_err(wlandev->netdev,
|
"ramdl_state(): may only be called in the fwload state.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
return 0;
|
}
|
|
/*
|
** Note: Interrupts are locked out if this is an AP and are NOT
|
** locked out if this is a station.
|
*/
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
if (msg->enable.data == P80211ENUM_truth_true) {
|
if (hfa384x_drvr_ramdl_enable(hw, msg->exeaddr.data)) {
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
} else {
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
}
|
} else {
|
hfa384x_drvr_ramdl_disable(hw);
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
}
|
|
return 0;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_ramdl_write
|
*
|
* Writes a buffer to the card RAM using the download state. This
|
* is for writing code to card RAM. To just read or write raw data
|
* use the aux functions.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_ramdl_write(struct wlandevice *wlandev, void *msgp)
|
{
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_p2req_ramdl_write *msg = msgp;
|
u32 addr;
|
u32 len;
|
u8 *buf;
|
|
if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
|
netdev_err(wlandev->netdev,
|
"ramdl_write(): may only be called in the fwload state.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
return 0;
|
}
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
/* first validate the length */
|
if (msg->len.data > sizeof(msg->data.data)) {
|
msg->resultcode.status =
|
P80211ENUM_resultcode_invalid_parameters;
|
return 0;
|
}
|
/* call the hfa384x function to do the write */
|
addr = msg->addr.data;
|
len = msg->len.data;
|
buf = msg->data.data;
|
if (hfa384x_drvr_ramdl_write(hw, addr, buf, len))
|
msg->resultcode.data = P80211ENUM_resultcode_refused;
|
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
|
return 0;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_flashdl_state
|
*
|
* Establishes the beginning/end of a card Flash download session.
|
*
|
* It is expected that the flashdl_write() function will be called
|
* one or more times between the 'enable' and 'disable' calls to
|
* this function.
|
*
|
* Note: This function should not be called when a mac comm port
|
* is active.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_flashdl_state(struct wlandevice *wlandev, void *msgp)
|
{
|
int result = 0;
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_p2req_flashdl_state *msg = msgp;
|
|
if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
|
netdev_err(wlandev->netdev,
|
"flashdl_state(): may only be called in the fwload state.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
return 0;
|
}
|
|
/*
|
** Note: Interrupts are locked out if this is an AP and are NOT
|
** locked out if this is a station.
|
*/
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
if (msg->enable.data == P80211ENUM_truth_true) {
|
if (hfa384x_drvr_flashdl_enable(hw)) {
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
} else {
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
}
|
} else {
|
hfa384x_drvr_flashdl_disable(hw);
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
/* NOTE: At this point, the MAC is in the post-reset
|
* state and the driver is in the fwload state.
|
* We need to get the MAC back into the fwload
|
* state. To do this, we set the nsdstate to HWPRESENT
|
* and then call the ifstate function to redo everything
|
* that got us into the fwload state.
|
*/
|
wlandev->msdstate = WLAN_MSD_HWPRESENT;
|
result = prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload);
|
if (result != P80211ENUM_resultcode_success) {
|
netdev_err(wlandev->netdev,
|
"prism2sta_ifstate(fwload) failed, P80211ENUM_resultcode=%d\n",
|
result);
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
result = -1;
|
}
|
}
|
|
return result;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_flashdl_write
|
*
|
*
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_flashdl_write(struct wlandevice *wlandev, void *msgp)
|
{
|
struct hfa384x *hw = wlandev->priv;
|
struct p80211msg_p2req_flashdl_write *msg = msgp;
|
u32 addr;
|
u32 len;
|
u8 *buf;
|
|
if (wlandev->msdstate != WLAN_MSD_FWLOAD) {
|
netdev_err(wlandev->netdev,
|
"flashdl_write(): may only be called in the fwload state.\n");
|
msg->resultcode.data =
|
P80211ENUM_resultcode_implementation_failure;
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
return 0;
|
}
|
|
/*
|
** Note: Interrupts are locked out if this is an AP and are NOT
|
** locked out if this is a station.
|
*/
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
/* first validate the length */
|
if (msg->len.data > sizeof(msg->data.data)) {
|
msg->resultcode.status =
|
P80211ENUM_resultcode_invalid_parameters;
|
return 0;
|
}
|
/* call the hfa384x function to do the write */
|
addr = msg->addr.data;
|
len = msg->len.data;
|
buf = msg->data.data;
|
if (hfa384x_drvr_flashdl_write(hw, addr, buf, len))
|
msg->resultcode.data = P80211ENUM_resultcode_refused;
|
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
|
return 0;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_autojoin
|
*
|
* Associate with an ESS.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
* interrupt
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_autojoin(struct wlandevice *wlandev, void *msgp)
|
{
|
struct hfa384x *hw = wlandev->priv;
|
int result = 0;
|
u16 reg;
|
u16 port_type;
|
struct p80211msg_lnxreq_autojoin *msg = msgp;
|
struct p80211pstrd *pstr;
|
u8 bytebuf[256];
|
struct hfa384x_bytestr *p2bytestr = (struct hfa384x_bytestr *)bytebuf;
|
|
wlandev->macmode = WLAN_MACMODE_NONE;
|
|
/* Set the SSID */
|
memcpy(&wlandev->ssid, &msg->ssid.data, sizeof(msg->ssid.data));
|
|
/* Disable the Port */
|
hfa384x_drvr_disable(hw, 0);
|
|
/*** STATION ***/
|
/* Set the TxRates */
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, 0x000f);
|
|
/* Set the auth type */
|
if (msg->authtype.data == P80211ENUM_authalg_sharedkey)
|
reg = HFA384x_CNFAUTHENTICATION_SHAREDKEY;
|
else
|
reg = HFA384x_CNFAUTHENTICATION_OPENSYSTEM;
|
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAUTHENTICATION, reg);
|
|
/* Set the ssid */
|
memset(bytebuf, 0, 256);
|
pstr = (struct p80211pstrd *)&msg->ssid.data;
|
prism2mgmt_pstr2bytestr(p2bytestr, pstr);
|
result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID,
|
bytebuf,
|
HFA384x_RID_CNFDESIREDSSID_LEN);
|
port_type = HFA384x_PORTTYPE_BSS;
|
/* Set the PortType */
|
hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, port_type);
|
|
/* Enable the Port */
|
hfa384x_drvr_enable(hw, 0);
|
|
/* Set the resultcode */
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
|
return result;
|
}
|
|
/*----------------------------------------------------------------
|
* prism2mgmt_wlansniff
|
*
|
* Start or stop sniffing.
|
*
|
* Arguments:
|
* wlandev wlan device structure
|
* msgp ptr to msg buffer
|
*
|
* Returns:
|
* 0 success and done
|
* <0 success, but we're waiting for something to finish.
|
* >0 an error occurred while handling the message.
|
* Side effects:
|
*
|
* Call context:
|
* process thread (usually)
|
* interrupt
|
*----------------------------------------------------------------
|
*/
|
int prism2mgmt_wlansniff(struct wlandevice *wlandev, void *msgp)
|
{
|
int result = 0;
|
struct p80211msg_lnxreq_wlansniff *msg = msgp;
|
|
struct hfa384x *hw = wlandev->priv;
|
u16 word;
|
|
msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
|
switch (msg->enable.data) {
|
case P80211ENUM_truth_false:
|
/* Confirm that we're in monitor mode */
|
if (wlandev->netdev->type == ARPHRD_ETHER) {
|
msg->resultcode.data =
|
P80211ENUM_resultcode_invalid_parameters;
|
return 0;
|
}
|
/* Disable monitor mode */
|
result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_DISABLE);
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to disable monitor mode, result=%d\n",
|
result);
|
goto failed;
|
}
|
/* Disable port 0 */
|
result = hfa384x_drvr_disable(hw, 0);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to disable port 0 after sniffing, result=%d\n",
|
result);
|
goto failed;
|
}
|
/* Clear the driver state */
|
wlandev->netdev->type = ARPHRD_ETHER;
|
|
/* Restore the wepflags */
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFWEPFLAGS,
|
hw->presniff_wepflags);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to restore wepflags=0x%04x, result=%d\n",
|
hw->presniff_wepflags, result);
|
goto failed;
|
}
|
|
/* Set the port to its prior type and enable (if necessary) */
|
if (hw->presniff_port_type != 0) {
|
word = hw->presniff_port_type;
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFPORTTYPE,
|
word);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to restore porttype, result=%d\n",
|
result);
|
goto failed;
|
}
|
|
/* Enable the port */
|
result = hfa384x_drvr_enable(hw, 0);
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to enable port to presniff setting, result=%d\n",
|
result);
|
goto failed;
|
}
|
} else {
|
result = hfa384x_drvr_disable(hw, 0);
|
}
|
|
netdev_info(wlandev->netdev, "monitor mode disabled\n");
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
return 0;
|
case P80211ENUM_truth_true:
|
/* Disable the port (if enabled), only check Port 0 */
|
if (hw->port_enabled[0]) {
|
if (wlandev->netdev->type == ARPHRD_ETHER) {
|
/* Save macport 0 state */
|
result = hfa384x_drvr_getconfig16(hw,
|
HFA384x_RID_CNFPORTTYPE,
|
&hw->presniff_port_type);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to read porttype, result=%d\n",
|
result);
|
goto failed;
|
}
|
/* Save the wepflags state */
|
result = hfa384x_drvr_getconfig16(hw,
|
HFA384x_RID_CNFWEPFLAGS,
|
&hw->presniff_wepflags);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to read wepflags, result=%d\n",
|
result);
|
goto failed;
|
}
|
hfa384x_drvr_stop(hw);
|
result = hfa384x_drvr_start(hw);
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to restart the card for sniffing, result=%d\n",
|
result);
|
goto failed;
|
}
|
} else {
|
/* Disable the port */
|
result = hfa384x_drvr_disable(hw, 0);
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to enable port for sniffing, result=%d\n",
|
result);
|
goto failed;
|
}
|
}
|
} else {
|
hw->presniff_port_type = 0;
|
}
|
|
/* Set the channel we wish to sniff */
|
word = msg->channel.data;
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFOWNCHANNEL,
|
word);
|
hw->sniff_channel = word;
|
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to set channel %d, result=%d\n",
|
word, result);
|
goto failed;
|
}
|
|
/* Now if we're already sniffing, we can skip the rest */
|
if (wlandev->netdev->type != ARPHRD_ETHER) {
|
/* Set the port type to pIbss */
|
word = HFA384x_PORTTYPE_PSUEDOIBSS;
|
result = hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFPORTTYPE,
|
word);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to set porttype %d, result=%d\n",
|
word, result);
|
goto failed;
|
}
|
if ((msg->keepwepflags.status ==
|
P80211ENUM_msgitem_status_data_ok) &&
|
(msg->keepwepflags.data != P80211ENUM_truth_true)) {
|
/* Set the wepflags for no decryption */
|
word = HFA384x_WEPFLAGS_DISABLE_TXCRYPT |
|
HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
|
result =
|
hfa384x_drvr_setconfig16(hw,
|
HFA384x_RID_CNFWEPFLAGS,
|
word);
|
}
|
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to set wepflags=0x%04x, result=%d\n",
|
word, result);
|
goto failed;
|
}
|
}
|
|
/* Do we want to strip the FCS in monitor mode? */
|
if ((msg->stripfcs.status ==
|
P80211ENUM_msgitem_status_data_ok) &&
|
(msg->stripfcs.data == P80211ENUM_truth_true)) {
|
hw->sniff_fcs = 0;
|
} else {
|
hw->sniff_fcs = 1;
|
}
|
|
/* Do we want to truncate the packets? */
|
if (msg->packet_trunc.status ==
|
P80211ENUM_msgitem_status_data_ok) {
|
hw->sniff_truncate = msg->packet_trunc.data;
|
} else {
|
hw->sniff_truncate = 0;
|
}
|
|
/* Enable the port */
|
result = hfa384x_drvr_enable(hw, 0);
|
if (result) {
|
netdev_dbg
|
(wlandev->netdev,
|
"failed to enable port for sniffing, result=%d\n",
|
result);
|
goto failed;
|
}
|
/* Enable monitor mode */
|
result = hfa384x_cmd_monitor(hw, HFA384x_MONITOR_ENABLE);
|
if (result) {
|
netdev_dbg(wlandev->netdev,
|
"failed to enable monitor mode, result=%d\n",
|
result);
|
goto failed;
|
}
|
|
if (wlandev->netdev->type == ARPHRD_ETHER)
|
netdev_info(wlandev->netdev, "monitor mode enabled\n");
|
|
/* Set the driver state */
|
/* Do we want the prism2 header? */
|
if ((msg->prismheader.status ==
|
P80211ENUM_msgitem_status_data_ok) &&
|
(msg->prismheader.data == P80211ENUM_truth_true)) {
|
hw->sniffhdr = 0;
|
wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
|
} else if ((msg->wlanheader.status ==
|
P80211ENUM_msgitem_status_data_ok) &&
|
(msg->wlanheader.data == P80211ENUM_truth_true)) {
|
hw->sniffhdr = 1;
|
wlandev->netdev->type = ARPHRD_IEEE80211_PRISM;
|
} else {
|
wlandev->netdev->type = ARPHRD_IEEE80211;
|
}
|
|
msg->resultcode.data = P80211ENUM_resultcode_success;
|
return 0;
|
default:
|
msg->resultcode.data = P80211ENUM_resultcode_invalid_parameters;
|
return 0;
|
}
|
|
failed:
|
msg->resultcode.data = P80211ENUM_resultcode_refused;
|
return 0;
|
}
|
