korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-30 07:34:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

libertas: kill struct lbs_adapter

Browse Source 
There seems to be no reason for a separate structure; move it all
into struct lbs_private.

Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
David Woodhouse 2007-12-08 20:04:36 +00:00 committed by David S. Miller
parent f86a93e1b2
commit aa21c004f8
19 changed files with 1046 additions and 1204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
drivers/net/wireless/libertas/11d.c
View File

@ -432,8 +432,8 @@ u8 lbs_get_scan_type_11d(u8 chan,
void lbs_init_11d(struct lbs_private *priv) void lbs_init_11d(struct lbs_private *priv)
{ {
priv->adapter->enable11d = 0; priv->enable11d = 0;
memset(&(priv->adapter->parsed_region_chan), 0, memset(&(priv->parsed_region_chan), 0,
sizeof(struct parsed_region_chan_11d)); sizeof(struct parsed_region_chan_11d));
return; return;
} }
@ -447,7 +447,7 @@ static int set_domain_info_11d(struct lbs_private *priv)
{ {
int ret; int ret;
if (!priv->adapter->enable11d) { if (!priv->enable11d) {
lbs_deb_11d("dnld domain Info with 11d disabled\n"); lbs_deb_11d("dnld domain Info with 11d disabled\n");
return 0; return 0;
} }
@ -469,22 +469,21 @@ static int set_domain_info_11d(struct lbs_private *priv)
*/ */
int lbs_set_universaltable(struct lbs_private *priv, u8 band) int lbs_set_universaltable(struct lbs_private *priv, u8 band)
{ {
struct lbs_adapter *adapter = priv->adapter;
u16 size = sizeof(struct chan_freq_power); u16 size = sizeof(struct chan_freq_power);
u16 i = 0; u16 i = 0;
memset(adapter->universal_channel, 0, memset(priv->universal_channel, 0,
sizeof(adapter->universal_channel)); sizeof(priv->universal_channel));
adapter->universal_channel[i].nrcfp = priv->universal_channel[i].nrcfp =
sizeof(channel_freq_power_UN_BG) / size; sizeof(channel_freq_power_UN_BG) / size;
lbs_deb_11d("BG-band nrcfp %d\n", lbs_deb_11d("BG-band nrcfp %d\n",
adapter->universal_channel[i].nrcfp); priv->universal_channel[i].nrcfp);
adapter->universal_channel[i].CFP = channel_freq_power_UN_BG; priv->universal_channel[i].CFP = channel_freq_power_UN_BG;
adapter->universal_channel[i].valid = 1; priv->universal_channel[i].valid = 1;
adapter->universal_channel[i].region = UNIVERSAL_REGION_CODE; priv->universal_channel[i].region = UNIVERSAL_REGION_CODE;
adapter->universal_channel[i].band = band; priv->universal_channel[i].band = band;
i++; i++;
return 0; return 0;
@ -505,8 +504,7 @@ int lbs_cmd_802_11d_domain_info(struct lbs_private *priv,
struct cmd_ds_802_11d_domain_info *pdomaininfo = struct cmd_ds_802_11d_domain_info *pdomaininfo =
&cmd->params.domaininfo; &cmd->params.domaininfo;
struct mrvlietypes_domainparamset *domain = &pdomaininfo->domain; struct mrvlietypes_domainparamset *domain = &pdomaininfo->domain;
struct lbs_adapter *adapter = priv->adapter; u8 nr_subband = priv->domainreg.nr_subband;
u8 nr_subband = adapter->domainreg.nr_subband;
lbs_deb_enter(LBS_DEB_11D); lbs_deb_enter(LBS_DEB_11D);
@ -523,7 +521,7 @@ int lbs_cmd_802_11d_domain_info(struct lbs_private *priv,
} }
domain->header.type = cpu_to_le16(TLV_TYPE_DOMAIN); domain->header.type = cpu_to_le16(TLV_TYPE_DOMAIN);
memcpy(domain->countrycode, adapter->domainreg.countrycode, memcpy(domain->countrycode, priv->domainreg.countrycode,
sizeof(domain->countrycode)); sizeof(domain->countrycode));
domain->header.len = domain->header.len =
@ -531,7 +529,7 @@ int lbs_cmd_802_11d_domain_info(struct lbs_private *priv,
sizeof(domain->countrycode)); sizeof(domain->countrycode));
if (nr_subband) { if (nr_subband) {
memcpy(domain->subband, adapter->domainreg.subband, memcpy(domain->subband, priv->domainreg.subband,
nr_subband * sizeof(struct ieeetypes_subbandset)); nr_subband * sizeof(struct ieeetypes_subbandset));
cmd->size = cpu_to_le16(sizeof(pdomaininfo->action) + cmd->size = cpu_to_le16(sizeof(pdomaininfo->action) +
@ -605,24 +603,23 @@ int lbs_parse_dnld_countryinfo_11d(struct lbs_private *priv,
struct bss_descriptor * bss) struct bss_descriptor * bss)
{ {
int ret; int ret;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_11D); lbs_deb_enter(LBS_DEB_11D);
if (priv->adapter->enable11d) { if (priv->enable11d) {
memset(&adapter->parsed_region_chan, 0, memset(&priv->parsed_region_chan, 0,
sizeof(struct parsed_region_chan_11d)); sizeof(struct parsed_region_chan_11d));
ret = parse_domain_info_11d(&bss->countryinfo, 0, ret = parse_domain_info_11d(&bss->countryinfo, 0,
&adapter->parsed_region_chan); &priv->parsed_region_chan);
if (ret == -1) { if (ret == -1) {
lbs_deb_11d("error parsing domain_info from AP\n"); lbs_deb_11d("error parsing domain_info from AP\n");
goto done; goto done;
} }
memset(&adapter->domainreg, 0, memset(&priv->domainreg, 0,
sizeof(struct lbs_802_11d_domain_reg)); sizeof(struct lbs_802_11d_domain_reg));
generate_domain_info_11d(&adapter->parsed_region_chan, generate_domain_info_11d(&priv->parsed_region_chan,
&adapter->domainreg); &priv->domainreg);
ret = set_domain_info_11d(priv); ret = set_domain_info_11d(priv);
@ -646,18 +643,17 @@ done:
int lbs_create_dnld_countryinfo_11d(struct lbs_private *priv) int lbs_create_dnld_countryinfo_11d(struct lbs_private *priv)
{ {
int ret; int ret;
struct lbs_adapter *adapter = priv->adapter;
struct region_channel *region_chan; struct region_channel *region_chan;
u8 j; u8 j;
lbs_deb_enter(LBS_DEB_11D); lbs_deb_enter(LBS_DEB_11D);
lbs_deb_11d("curbssparams.band %d\n", adapter->curbssparams.band); lbs_deb_11d("curbssparams.band %d\n", priv->curbssparams.band);
if (priv->adapter->enable11d) { if (priv->enable11d) {
/* update parsed_region_chan_11; dnld domaininf to FW */ /* update parsed_region_chan_11; dnld domaininf to FW */
for (j = 0; j < ARRAY_SIZE(adapter->region_channel); j++) { for (j = 0; j < ARRAY_SIZE(priv->region_channel); j++) {
region_chan = &adapter->region_channel[j]; region_chan = &priv->region_channel[j];
lbs_deb_11d("%d region_chan->band %d\n", j, lbs_deb_11d("%d region_chan->band %d\n", j,
region_chan->band); region_chan->band);
@ -665,28 +661,28 @@ int lbs_create_dnld_countryinfo_11d(struct lbs_private *priv)
if (!region_chan || !region_chan->valid if (!region_chan || !region_chan->valid
|| !region_chan->CFP) || !region_chan->CFP)
continue; continue;
if (region_chan->band != adapter->curbssparams.band) if (region_chan->band != priv->curbssparams.band)
continue; continue;
break; break;
} }
if (j >= ARRAY_SIZE(adapter->region_channel)) { if (j >= ARRAY_SIZE(priv->region_channel)) {
lbs_deb_11d("region_chan not found, band %d\n", lbs_deb_11d("region_chan not found, band %d\n",
adapter->curbssparams.band); priv->curbssparams.band);
ret = -1; ret = -1;
goto done; goto done;
} }
memset(&adapter->parsed_region_chan, 0, memset(&priv->parsed_region_chan, 0,
sizeof(struct parsed_region_chan_11d)); sizeof(struct parsed_region_chan_11d));
lbs_generate_parsed_region_chan_11d(region_chan, lbs_generate_parsed_region_chan_11d(region_chan,
&adapter-> &priv->
parsed_region_chan); parsed_region_chan);
memset(&adapter->domainreg, 0, memset(&priv->domainreg, 0,
sizeof(struct lbs_802_11d_domain_reg)); sizeof(struct lbs_802_11d_domain_reg));
generate_domain_info_11d(&adapter->parsed_region_chan, generate_domain_info_11d(&priv->parsed_region_chan,
&adapter->domainreg); &priv->domainreg);
ret = set_domain_info_11d(priv); ret = set_domain_info_11d(priv);

136
drivers/net/wireless/libertas/assoc.c
View File

@ -18,7 +18,6 @@ static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static int assoc_helper_essid(struct lbs_private *priv, static int assoc_helper_essid(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
struct bss_descriptor * bss; struct bss_descriptor * bss;
int channel = -1; int channel = -1;
@ -38,7 +37,7 @@ static int assoc_helper_essid(struct lbs_private *priv,
lbs_send_specific_ssid_scan(priv, assoc_req->ssid, lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
assoc_req->ssid_len, 0); assoc_req->ssid_len, 0);
bss = lbs_find_ssid_in_list(adapter, assoc_req->ssid, bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
assoc_req->ssid_len, NULL, IW_MODE_INFRA, channel); assoc_req->ssid_len, NULL, IW_MODE_INFRA, channel);
if (bss != NULL) { if (bss != NULL) {
memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor)); memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
@ -54,7 +53,7 @@ static int assoc_helper_essid(struct lbs_private *priv,
assoc_req->ssid_len, 1); assoc_req->ssid_len, 1);
/* Search for the requested SSID in the scan table */ /* Search for the requested SSID in the scan table */
bss = lbs_find_ssid_in_list(adapter, assoc_req->ssid, bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
assoc_req->ssid_len, NULL, IW_MODE_ADHOC, channel); assoc_req->ssid_len, NULL, IW_MODE_ADHOC, channel);
if (bss != NULL) { if (bss != NULL) {
lbs_deb_assoc("SSID found, will join\n"); lbs_deb_assoc("SSID found, will join\n");
@ -78,7 +77,6 @@ static int assoc_helper_essid(struct lbs_private *priv,
static int assoc_helper_bssid(struct lbs_private *priv, static int assoc_helper_bssid(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
struct bss_descriptor * bss; struct bss_descriptor * bss;
DECLARE_MAC_BUF(mac); DECLARE_MAC_BUF(mac);
@ -87,7 +85,7 @@ static int assoc_helper_bssid(struct lbs_private *priv,
print_mac(mac, assoc_req->bssid)); print_mac(mac, assoc_req->bssid));
/* Search for index position in list for requested MAC */ /* Search for index position in list for requested MAC */
bss = lbs_find_bssid_in_list(adapter, assoc_req->bssid, bss = lbs_find_bssid_in_list(priv, assoc_req->bssid,
assoc_req->mode); assoc_req->mode);
if (bss == NULL) { if (bss == NULL) {
lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, " lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
@ -138,21 +136,20 @@ static int assoc_helper_associate(struct lbs_private *priv,
static int assoc_helper_mode(struct lbs_private *priv, static int assoc_helper_mode(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (assoc_req->mode == adapter->mode) if (assoc_req->mode == priv->mode)
goto done; goto done;
if (assoc_req->mode == IW_MODE_INFRA) { if (assoc_req->mode == IW_MODE_INFRA) {
if (adapter->psstate != PS_STATE_FULL_POWER) if (priv->psstate != PS_STATE_FULL_POWER)
lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
adapter->psmode = LBS802_11POWERMODECAM; priv->psmode = LBS802_11POWERMODECAM;
} }
adapter->mode = assoc_req->mode; priv->mode = assoc_req->mode;
ret = lbs_prepare_and_send_command(priv, ret = lbs_prepare_and_send_command(priv,
CMD_802_11_SNMP_MIB, CMD_802_11_SNMP_MIB,
0, CMD_OPTION_WAITFORRSP, 0, CMD_OPTION_WAITFORRSP,
@ -191,7 +188,6 @@ void lbs_sync_channel(struct work_struct *work)
static int assoc_helper_channel(struct lbs_private *priv, static int assoc_helper_channel(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
@ -201,11 +197,11 @@ static int assoc_helper_channel(struct lbs_private *priv,
lbs_deb_assoc("ASSOC: channel: error getting channel."); lbs_deb_assoc("ASSOC: channel: error getting channel.");
} }
if (assoc_req->channel == adapter->curbssparams.channel) if (assoc_req->channel == priv->curbssparams.channel)
goto done; goto done;
lbs_deb_assoc("ASSOC: channel: %d -> %d\n", lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
adapter->curbssparams.channel, assoc_req->channel); priv->curbssparams.channel, assoc_req->channel);
ret = lbs_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL, ret = lbs_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
CMD_OPT_802_11_RF_CHANNEL_SET, CMD_OPT_802_11_RF_CHANNEL_SET,
@ -219,7 +215,7 @@ static int assoc_helper_channel(struct lbs_private *priv,
lbs_deb_assoc("ASSOC: channel: error getting channel."); lbs_deb_assoc("ASSOC: channel: error getting channel.");
} }
if (assoc_req->channel != adapter->curbssparams.channel) { if (assoc_req->channel != priv->curbssparams.channel) {
lbs_deb_assoc("ASSOC: channel: failed to update channel to %d", lbs_deb_assoc("ASSOC: channel: failed to update channel to %d",
assoc_req->channel); assoc_req->channel);
goto done; goto done;
@ -246,7 +242,6 @@ done:
static int assoc_helper_wep_keys(struct lbs_private *priv, static int assoc_helper_wep_keys(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int i; int i;
int ret = 0; int ret = 0;
@ -275,23 +270,23 @@ static int assoc_helper_wep_keys(struct lbs_private *priv,
/* enable/disable the MAC's WEP packet filter */ /* enable/disable the MAC's WEP packet filter */
if (assoc_req->secinfo.wep_enabled) if (assoc_req->secinfo.wep_enabled)
adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE; priv->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
else else
adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE; priv->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
ret = lbs_set_mac_packet_filter(priv); ret = lbs_set_mac_packet_filter(priv);
if (ret) if (ret)
goto out; goto out;
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
/* Copy WEP keys into adapter wep key fields */ /* Copy WEP keys into priv wep key fields */
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
memcpy(&adapter->wep_keys[i], &assoc_req->wep_keys[i], memcpy(&priv->wep_keys[i], &assoc_req->wep_keys[i],
sizeof(struct enc_key)); sizeof(struct enc_key));
} }
adapter->wep_tx_keyidx = assoc_req->wep_tx_keyidx; priv->wep_tx_keyidx = assoc_req->wep_tx_keyidx;
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
out: out:
lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@ -301,14 +296,13 @@ out:
static int assoc_helper_secinfo(struct lbs_private *priv, static int assoc_helper_secinfo(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
u32 do_wpa; u32 do_wpa;
u32 rsn = 0; u32 rsn = 0;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
memcpy(&adapter->secinfo, &assoc_req->secinfo, memcpy(&priv->secinfo, &assoc_req->secinfo,
sizeof(struct lbs_802_11_security)); sizeof(struct lbs_802_11_security));
ret = lbs_set_mac_packet_filter(priv); ret = lbs_set_mac_packet_filter(priv);
@ -396,17 +390,16 @@ out:
static int assoc_helper_wpa_ie(struct lbs_private *priv, static int assoc_helper_wpa_ie(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) { if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) {
memcpy(&adapter->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len); memcpy(&priv->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
adapter->wpa_ie_len = assoc_req->wpa_ie_len; priv->wpa_ie_len = assoc_req->wpa_ie_len;
} else { } else {
memset(&adapter->wpa_ie, 0, MAX_WPA_IE_LEN); memset(&priv->wpa_ie, 0, MAX_WPA_IE_LEN);
adapter->wpa_ie_len = 0; priv->wpa_ie_len = 0;
} }
lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@ -414,14 +407,14 @@ static int assoc_helper_wpa_ie(struct lbs_private *priv,
} }
static int should_deauth_infrastructure(struct lbs_adapter *adapter, static int should_deauth_infrastructure(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
int ret = 0; int ret = 0;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (adapter->connect_status != LBS_CONNECTED) if (priv->connect_status != LBS_CONNECTED)
return 0; return 0;
if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) { if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
@ -431,7 +424,7 @@ static int should_deauth_infrastructure(struct lbs_adapter *adapter,
} }
if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) { if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
if (adapter->secinfo.auth_mode != assoc_req->secinfo.auth_mode) { if (priv->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
lbs_deb_assoc("Deauthenticating due to new security\n"); lbs_deb_assoc("Deauthenticating due to new security\n");
ret = 1; ret = 1;
goto out; goto out;
@ -466,16 +459,16 @@ out:
} }
static int should_stop_adhoc(struct lbs_adapter *adapter, static int should_stop_adhoc(struct lbs_private *priv,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (adapter->connect_status != LBS_CONNECTED) if (priv->connect_status != LBS_CONNECTED)
return 0; return 0;
if (lbs_ssid_cmp(adapter->curbssparams.ssid, if (lbs_ssid_cmp(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len, priv->curbssparams.ssid_len,
assoc_req->ssid, assoc_req->ssid_len) != 0) assoc_req->ssid, assoc_req->ssid_len) != 0)
return 1; return 1;
@ -486,7 +479,7 @@ static int should_stop_adhoc(struct lbs_adapter *adapter,
} }
if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) { if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
if (assoc_req->channel != adapter->curbssparams.channel) if (assoc_req->channel != priv->curbssparams.channel)
return 1; return 1;
} }
@ -499,7 +492,6 @@ void lbs_association_worker(struct work_struct *work)
{ {
struct lbs_private *priv = container_of(work, struct lbs_private, struct lbs_private *priv = container_of(work, struct lbs_private,
assoc_work.work); assoc_work.work);
struct lbs_adapter *adapter = priv->adapter;
struct assoc_request * assoc_req = NULL; struct assoc_request * assoc_req = NULL;
int ret = 0; int ret = 0;
int find_any_ssid = 0; int find_any_ssid = 0;
@ -507,11 +499,11 @@ void lbs_association_worker(struct work_struct *work)
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
assoc_req = adapter->pending_assoc_req; assoc_req = priv->pending_assoc_req;
adapter->pending_assoc_req = NULL; priv->pending_assoc_req = NULL;
adapter->in_progress_assoc_req = assoc_req; priv->in_progress_assoc_req = assoc_req;
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
if (!assoc_req) if (!assoc_req)
goto done; goto done;
@ -569,8 +561,8 @@ void lbs_association_worker(struct work_struct *work)
* Check if the attributes being changing require deauthentication * Check if the attributes being changing require deauthentication
* from the currently associated infrastructure access point. * from the currently associated infrastructure access point.
*/ */
if (adapter->mode == IW_MODE_INFRA) { if (priv->mode == IW_MODE_INFRA) {
if (should_deauth_infrastructure(adapter, assoc_req)) { if (should_deauth_infrastructure(priv, assoc_req)) {
ret = lbs_send_deauthentication(priv); ret = lbs_send_deauthentication(priv);
if (ret) { if (ret) {
lbs_deb_assoc("Deauthentication due to new " lbs_deb_assoc("Deauthentication due to new "
@ -578,8 +570,8 @@ void lbs_association_worker(struct work_struct *work)
ret); ret);
} }
} }
} else if (adapter->mode == IW_MODE_ADHOC) { } else if (priv->mode == IW_MODE_ADHOC) {
if (should_stop_adhoc(adapter, assoc_req)) { if (should_stop_adhoc(priv, assoc_req)) {
ret = lbs_stop_adhoc_network(priv); ret = lbs_stop_adhoc_network(priv);
if (ret) { if (ret) {
lbs_deb_assoc("Teardown of AdHoc network due to " lbs_deb_assoc("Teardown of AdHoc network due to "
@ -643,7 +635,7 @@ void lbs_association_worker(struct work_struct *work)
success = 0; success = 0;
} }
if (adapter->connect_status != LBS_CONNECTED) { if (priv->connect_status != LBS_CONNECTED) {
lbs_deb_assoc("ASSOC: association unsuccessful, " lbs_deb_assoc("ASSOC: association unsuccessful, "
"not connected\n"); "not connected\n");
success = 0; success = 0;
@ -651,9 +643,9 @@ void lbs_association_worker(struct work_struct *work)
if (success) { if (success) {
lbs_deb_assoc("ASSOC: associated to '%s', %s\n", lbs_deb_assoc("ASSOC: associated to '%s', %s\n",
escape_essid(adapter->curbssparams.ssid, escape_essid(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len), priv->curbssparams.ssid_len),
print_mac(mac, adapter->curbssparams.bssid)); print_mac(mac, priv->curbssparams.bssid));
lbs_prepare_and_send_command(priv, lbs_prepare_and_send_command(priv,
CMD_802_11_RSSI, CMD_802_11_RSSI,
0, CMD_OPTION_WAITFORRSP, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
@ -672,9 +664,9 @@ out:
ret); ret);
} }
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
adapter->in_progress_assoc_req = NULL; priv->in_progress_assoc_req = NULL;
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
kfree(assoc_req); kfree(assoc_req);
done: done:
@ -685,15 +677,15 @@ done:
/* /*
* Caller MUST hold any necessary locks * Caller MUST hold any necessary locks
*/ */
struct assoc_request *lbs_get_association_request(struct lbs_adapter *adapter) struct assoc_request *lbs_get_association_request(struct lbs_private *priv)
{ {
struct assoc_request * assoc_req; struct assoc_request * assoc_req;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (!adapter->pending_assoc_req) { if (!priv->pending_assoc_req) {
adapter->pending_assoc_req = kzalloc(sizeof(struct assoc_request), priv->pending_assoc_req = kzalloc(sizeof(struct assoc_request),
GFP_KERNEL); GFP_KERNEL);
if (!adapter->pending_assoc_req) { if (!priv->pending_assoc_req) {
lbs_pr_info("Not enough memory to allocate association" lbs_pr_info("Not enough memory to allocate association"
" request!\n"); " request!\n");
return NULL; return NULL;
@ -703,57 +695,57 @@ struct assoc_request *lbs_get_association_request(struct lbs_adapter *adapter)
/* Copy current configuration attributes to the association request, /* Copy current configuration attributes to the association request,
* but don't overwrite any that are already set. * but don't overwrite any that are already set.
*/ */
assoc_req = adapter->pending_assoc_req; assoc_req = priv->pending_assoc_req;
if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
memcpy(&assoc_req->ssid, &adapter->curbssparams.ssid, memcpy(&assoc_req->ssid, &priv->curbssparams.ssid,
IW_ESSID_MAX_SIZE); IW_ESSID_MAX_SIZE);
assoc_req->ssid_len = adapter->curbssparams.ssid_len; assoc_req->ssid_len = priv->curbssparams.ssid_len;
} }
if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
assoc_req->channel = adapter->curbssparams.channel; assoc_req->channel = priv->curbssparams.channel;
if (!test_bit(ASSOC_FLAG_BAND, &assoc_req->flags)) if (!test_bit(ASSOC_FLAG_BAND, &assoc_req->flags))
assoc_req->band = adapter->curbssparams.band; assoc_req->band = priv->curbssparams.band;
if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
assoc_req->mode = adapter->mode; assoc_req->mode = priv->mode;
if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
memcpy(&assoc_req->bssid, adapter->curbssparams.bssid, memcpy(&assoc_req->bssid, priv->curbssparams.bssid,
ETH_ALEN); ETH_ALEN);
} }
if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
memcpy(&assoc_req->wep_keys[i], &adapter->wep_keys[i], memcpy(&assoc_req->wep_keys[i], &priv->wep_keys[i],
sizeof(struct enc_key)); sizeof(struct enc_key));
} }
} }
if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
assoc_req->wep_tx_keyidx = adapter->wep_tx_keyidx; assoc_req->wep_tx_keyidx = priv->wep_tx_keyidx;
if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
memcpy(&assoc_req->wpa_mcast_key, &adapter->wpa_mcast_key, memcpy(&assoc_req->wpa_mcast_key, &priv->wpa_mcast_key,
sizeof(struct enc_key)); sizeof(struct enc_key));
} }
if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
memcpy(&assoc_req->wpa_unicast_key, &adapter->wpa_unicast_key, memcpy(&assoc_req->wpa_unicast_key, &priv->wpa_unicast_key,
sizeof(struct enc_key)); sizeof(struct enc_key));
} }
if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
memcpy(&assoc_req->secinfo, &adapter->secinfo, memcpy(&assoc_req->secinfo, &priv->secinfo,
sizeof(struct lbs_802_11_security)); sizeof(struct lbs_802_11_security));
} }
if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) { if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
memcpy(&assoc_req->wpa_ie, &adapter->wpa_ie, memcpy(&assoc_req->wpa_ie, &priv->wpa_ie,
MAX_WPA_IE_LEN); MAX_WPA_IE_LEN);
assoc_req->wpa_ie_len = adapter->wpa_ie_len; assoc_req->wpa_ie_len = priv->wpa_ie_len;
} }
lbs_deb_leave(LBS_DEB_ASSOC); lbs_deb_leave(LBS_DEB_ASSOC);

2
drivers/net/wireless/libertas/assoc.h
View File

@ -6,7 +6,7 @@
#include "dev.h" #include "dev.h"
void lbs_association_worker(struct work_struct *work); void lbs_association_worker(struct work_struct *work);
struct assoc_request *lbs_get_association_request(struct lbs_adapter *adapter); struct assoc_request *lbs_get_association_request(struct lbs_private *priv);
void lbs_sync_channel(struct work_struct *work); void lbs_sync_channel(struct work_struct *work);
#endif /* _LBS_ASSOC_H */ #endif /* _LBS_ASSOC_H */

278
drivers/net/wireless/libertas/cmd.c
View File

@ -50,7 +50,7 @@ static int lbs_cmd_hw_spec(struct lbs_private *priv, struct cmd_ds_command *cmd)
cmd->command = cpu_to_le16(CMD_GET_HW_SPEC); cmd->command = cpu_to_le16(CMD_GET_HW_SPEC);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN);
memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN); memcpy(hwspec->permanentaddr, priv->current_addr, ETH_ALEN);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -123,7 +123,6 @@ static int lbs_cmd_802_11_sleep_params(struct lbs_private *priv,
struct cmd_ds_command *cmd, struct cmd_ds_command *cmd,
u16 cmd_action) u16 cmd_action)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_sleep_params *sp = &cmd->params.sleep_params; struct cmd_ds_802_11_sleep_params *sp = &cmd->params.sleep_params;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -133,17 +132,17 @@ static int lbs_cmd_802_11_sleep_params(struct lbs_private *priv,
cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS); cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS);
if (cmd_action == CMD_ACT_GET) { if (cmd_action == CMD_ACT_GET) {
memset(&adapter->sp, 0, sizeof(struct sleep_params)); memset(&priv->sp, 0, sizeof(struct sleep_params));
memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params)); memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params));
sp->action = cpu_to_le16(cmd_action); sp->action = cpu_to_le16(cmd_action);
} else if (cmd_action == CMD_ACT_SET) { } else if (cmd_action == CMD_ACT_SET) {
sp->action = cpu_to_le16(cmd_action); sp->action = cpu_to_le16(cmd_action);
sp->error = cpu_to_le16(adapter->sp.sp_error); sp->error = cpu_to_le16(priv->sp.sp_error);
sp->offset = cpu_to_le16(adapter->sp.sp_offset); sp->offset = cpu_to_le16(priv->sp.sp_offset);
sp->stabletime = cpu_to_le16(adapter->sp.sp_stabletime); sp->stabletime = cpu_to_le16(priv->sp.sp_stabletime);
sp->calcontrol = (u8) adapter->sp.sp_calcontrol; sp->calcontrol = (u8) priv->sp.sp_calcontrol;
sp->externalsleepclk = (u8) adapter->sp.sp_extsleepclk; sp->externalsleepclk = (u8) priv->sp.sp_extsleepclk;
sp->reserved = cpu_to_le16(adapter->sp.sp_reserved); sp->reserved = cpu_to_le16(priv->sp.sp_reserved);
} }
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
@ -156,7 +155,6 @@ static int lbs_cmd_802_11_set_wep(struct lbs_private *priv,
void * pdata_buf) void * pdata_buf)
{ {
struct cmd_ds_802_11_set_wep *wep = &cmd->params.wep; struct cmd_ds_802_11_set_wep *wep = &cmd->params.wep;
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
struct assoc_request * assoc_req = pdata_buf; struct assoc_request * assoc_req = pdata_buf;
@ -212,9 +210,9 @@ static int lbs_cmd_802_11_set_wep(struct lbs_private *priv,
wep->action = cpu_to_le16(CMD_ACT_REMOVE); wep->action = cpu_to_le16(CMD_ACT_REMOVE);
/* default tx key index */ /* default tx key index */
wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx & wep->keyindex = cpu_to_le16((u16)(priv->wep_tx_keyidx &
(u32)CMD_WEP_KEY_INDEX_MASK)); (u32)CMD_WEP_KEY_INDEX_MASK));
lbs_deb_cmd("SET_WEP: remove key %d\n", adapter->wep_tx_keyidx); lbs_deb_cmd("SET_WEP: remove key %d\n", priv->wep_tx_keyidx);
} }
ret = 0; ret = 0;
@ -415,7 +413,6 @@ static int lbs_cmd_802_11_snmp_mib(struct lbs_private *priv,
int cmd_oid, void *pdata_buf) int cmd_oid, void *pdata_buf)
{ {
struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib; struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
struct lbs_adapter *adapter = priv->adapter;
u8 ucTemp; u8 ucTemp;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -507,7 +504,7 @@ static int lbs_cmd_802_11_snmp_mib(struct lbs_private *priv,
pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET); pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16)); pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
*((__le16 *)(pSNMPMIB->value)) = *((__le16 *)(pSNMPMIB->value)) =
cpu_to_le16((u16) adapter->txretrycount); cpu_to_le16((u16) priv->txretrycount);
} }
break; break;
@ -534,7 +531,6 @@ static int lbs_cmd_802_11_radio_control(struct lbs_private *priv,
struct cmd_ds_command *cmd, struct cmd_ds_command *cmd,
int cmd_action) int cmd_action)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_radio_control *pradiocontrol = &cmd->params.radio; struct cmd_ds_802_11_radio_control *pradiocontrol = &cmd->params.radio;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -546,7 +542,7 @@ static int lbs_cmd_802_11_radio_control(struct lbs_private *priv,
pradiocontrol->action = cpu_to_le16(cmd_action); pradiocontrol->action = cpu_to_le16(cmd_action);
switch (adapter->preamble) { switch (priv->preamble) {
case CMD_TYPE_SHORT_PREAMBLE: case CMD_TYPE_SHORT_PREAMBLE:
pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE); pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE);
break; break;
@ -561,7 +557,7 @@ static int lbs_cmd_802_11_radio_control(struct lbs_private *priv,
break; break;
} }
if (adapter->radioon) if (priv->radioon)
pradiocontrol->control |= cpu_to_le16(TURN_ON_RF); pradiocontrol->control |= cpu_to_le16(TURN_ON_RF);
else else
pradiocontrol->control &= cpu_to_le16(~TURN_ON_RF); pradiocontrol->control &= cpu_to_le16(~TURN_ON_RF);
@ -640,7 +636,6 @@ static int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private *priv,
{ {
struct cmd_ds_802_11_rate_adapt_rateset struct cmd_ds_802_11_rate_adapt_rateset
*rateadapt = &cmd->params.rateset; *rateadapt = &cmd->params.rateset;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->size = cmd->size =
@ -649,8 +644,8 @@ static int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private *priv,
cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET); cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
rateadapt->action = cpu_to_le16(cmd_action); rateadapt->action = cpu_to_le16(cmd_action);
rateadapt->enablehwauto = cpu_to_le16(adapter->enablehwauto); rateadapt->enablehwauto = cpu_to_le16(priv->enablehwauto);
rateadapt->bitmap = cpu_to_le16(adapter->ratebitmap); rateadapt->bitmap = cpu_to_le16(priv->ratebitmap);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -661,7 +656,6 @@ static int lbs_cmd_802_11_data_rate(struct lbs_private *priv,
u16 cmd_action) u16 cmd_action)
{ {
struct cmd_ds_802_11_data_rate *pdatarate = &cmd->params.drate; struct cmd_ds_802_11_data_rate *pdatarate = &cmd->params.drate;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -672,9 +666,9 @@ static int lbs_cmd_802_11_data_rate(struct lbs_private *priv,
pdatarate->action = cpu_to_le16(cmd_action); pdatarate->action = cpu_to_le16(cmd_action);
if (cmd_action == CMD_ACT_SET_TX_FIX_RATE) { if (cmd_action == CMD_ACT_SET_TX_FIX_RATE) {
pdatarate->rates[0] = lbs_data_rate_to_fw_index(adapter->cur_rate); pdatarate->rates[0] = lbs_data_rate_to_fw_index(priv->cur_rate);
lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n", lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n",
adapter->cur_rate); priv->cur_rate);
} else if (cmd_action == CMD_ACT_SET_TX_AUTO) { } else if (cmd_action == CMD_ACT_SET_TX_AUTO) {
lbs_deb_cmd("DATA_RATE: setting auto\n"); lbs_deb_cmd("DATA_RATE: setting auto\n");
} }
@ -688,7 +682,6 @@ static int lbs_cmd_mac_multicast_adr(struct lbs_private *priv,
u16 cmd_action) u16 cmd_action)
{ {
struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr; struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
@ -698,9 +691,9 @@ static int lbs_cmd_mac_multicast_adr(struct lbs_private *priv,
lbs_deb_cmd("MULTICAST_ADR: setting %d addresses\n", pMCastAdr->nr_of_adrs); lbs_deb_cmd("MULTICAST_ADR: setting %d addresses\n", pMCastAdr->nr_of_adrs);
pMCastAdr->action = cpu_to_le16(cmd_action); pMCastAdr->action = cpu_to_le16(cmd_action);
pMCastAdr->nr_of_adrs = pMCastAdr->nr_of_adrs =
cpu_to_le16((u16) adapter->nr_of_multicastmacaddr); cpu_to_le16((u16) priv->nr_of_multicastmacaddr);
memcpy(pMCastAdr->maclist, adapter->multicastlist, memcpy(pMCastAdr->maclist, priv->multicastlist,
adapter->nr_of_multicastmacaddr * ETH_ALEN); priv->nr_of_multicastmacaddr * ETH_ALEN);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -730,7 +723,6 @@ static int lbs_cmd_802_11_rf_channel(struct lbs_private *priv,
static int lbs_cmd_802_11_rssi(struct lbs_private *priv, static int lbs_cmd_802_11_rssi(struct lbs_private *priv,
struct cmd_ds_command *cmd) struct cmd_ds_command *cmd)
{ {
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(CMD_802_11_RSSI); cmd->command = cpu_to_le16(CMD_802_11_RSSI);
@ -738,12 +730,12 @@ static int lbs_cmd_802_11_rssi(struct lbs_private *priv,
cmd->params.rssi.N = cpu_to_le16(DEFAULT_BCN_AVG_FACTOR); cmd->params.rssi.N = cpu_to_le16(DEFAULT_BCN_AVG_FACTOR);
/* reset Beacon SNR/NF/RSSI values */ /* reset Beacon SNR/NF/RSSI values */
adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = 0; priv->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
adapter->SNR[TYPE_BEACON][TYPE_AVG] = 0; priv->SNR[TYPE_BEACON][TYPE_AVG] = 0;
adapter->NF[TYPE_BEACON][TYPE_NOAVG] = 0; priv->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
adapter->NF[TYPE_BEACON][TYPE_AVG] = 0; priv->NF[TYPE_BEACON][TYPE_AVG] = 0;
adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0; priv->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
adapter->RSSI[TYPE_BEACON][TYPE_AVG] = 0; priv->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -828,7 +820,6 @@ static int lbs_cmd_802_11_mac_address(struct lbs_private *priv,
struct cmd_ds_command *cmd, struct cmd_ds_command *cmd,
u16 cmd_action) u16 cmd_action)
{ {
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS); cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
@ -840,8 +831,8 @@ static int lbs_cmd_802_11_mac_address(struct lbs_private *priv,
if (cmd_action == CMD_ACT_SET) { if (cmd_action == CMD_ACT_SET) {
memcpy(cmd->params.macadd.macadd, memcpy(cmd->params.macadd.macadd,
adapter->current_addr, ETH_ALEN); priv->current_addr, ETH_ALEN);
lbs_deb_hex(LBS_DEB_CMD, "SET_CMD: MAC addr", adapter->current_addr, 6); lbs_deb_hex(LBS_DEB_CMD, "SET_CMD: MAC addr", priv->current_addr, 6);
} }
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
@ -958,7 +949,6 @@ static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
{ {
struct cmd_ds_802_11_beacon_control struct cmd_ds_802_11_beacon_control
*bcn_ctrl = &cmd->params.bcn_ctrl; *bcn_ctrl = &cmd->params.bcn_ctrl;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->size = cmd->size =
@ -967,8 +957,8 @@ static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
cmd->command = cpu_to_le16(CMD_802_11_BEACON_CTRL); cmd->command = cpu_to_le16(CMD_802_11_BEACON_CTRL);
bcn_ctrl->action = cpu_to_le16(cmd_action); bcn_ctrl->action = cpu_to_le16(cmd_action);
bcn_ctrl->beacon_enable = cpu_to_le16(adapter->beacon_enable); bcn_ctrl->beacon_enable = cpu_to_le16(priv->beacon_enable);
bcn_ctrl->beacon_period = cpu_to_le16(adapter->beacon_period); bcn_ctrl->beacon_period = cpu_to_le16(priv->beacon_period);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -978,7 +968,7 @@ static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
* Note: NEVER use lbs_queue_cmd() with addtail==0 other than for * Note: NEVER use lbs_queue_cmd() with addtail==0 other than for
* the command timer, because it does not account for queued commands. * the command timer, because it does not account for queued commands.
*/ */
void lbs_queue_cmd(struct lbs_adapter *adapter, void lbs_queue_cmd(struct lbs_private *priv,
struct cmd_ctrl_node *cmdnode, struct cmd_ctrl_node *cmdnode,
u8 addtail) u8 addtail)
{ {
@ -1002,19 +992,19 @@ void lbs_queue_cmd(struct lbs_adapter *adapter,
if (le16_to_cpu(cmdptr->command) == CMD_802_11_PS_MODE) { if (le16_to_cpu(cmdptr->command) == CMD_802_11_PS_MODE) {
struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode; struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode;
if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) { if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
if (adapter->psstate != PS_STATE_FULL_POWER) if (priv->psstate != PS_STATE_FULL_POWER)
addtail = 0; addtail = 0;
} }
} }
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (addtail) if (addtail)
list_add_tail(&cmdnode->list, &adapter->cmdpendingq); list_add_tail(&cmdnode->list, &priv->cmdpendingq);
else else
list_add(&cmdnode->list, &adapter->cmdpendingq); list_add(&cmdnode->list, &priv->cmdpendingq);
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n", lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
le16_to_cpu(((struct cmd_ds_gen*)cmdnode->bufvirtualaddr)->command)); le16_to_cpu(((struct cmd_ds_gen*)cmdnode->bufvirtualaddr)->command));
@ -1035,31 +1025,30 @@ static int DownloadcommandToStation(struct lbs_private *priv,
{ {
unsigned long flags; unsigned long flags;
struct cmd_ds_command *cmdptr; struct cmd_ds_command *cmdptr;
struct lbs_adapter *adapter = priv->adapter;
int ret = -1; int ret = -1;
u16 cmdsize; u16 cmdsize;
u16 command; u16 command;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
if (!adapter || !cmdnode) { if (!priv || !cmdnode) {
lbs_deb_host("DNLD_CMD: adapter or cmdmode is NULL\n"); lbs_deb_host("DNLD_CMD: priv or cmdmode is NULL\n");
goto done; goto done;
} }
cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr; cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (!cmdptr || !cmdptr->size) { if (!cmdptr || !cmdptr->size) {
lbs_deb_host("DNLD_CMD: cmdptr is NULL or zero\n"); lbs_deb_host("DNLD_CMD: cmdptr is NULL or zero\n");
__lbs_cleanup_and_insert_cmd(priv, cmdnode); __lbs_cleanup_and_insert_cmd(priv, cmdnode);
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
goto done; goto done;
} }
adapter->cur_cmd = cmdnode; priv->cur_cmd = cmdnode;
adapter->cur_cmd_retcode = 0; priv->cur_cmd_retcode = 0;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
cmdsize = le16_to_cpu(cmdptr->size); cmdsize = le16_to_cpu(cmdptr->size);
command = le16_to_cpu(cmdptr->command); command = le16_to_cpu(cmdptr->command);
@ -1074,11 +1063,11 @@ static int DownloadcommandToStation(struct lbs_private *priv,
if (ret != 0) { if (ret != 0) {
lbs_deb_host("DNLD_CMD: hw_host_to_card failed\n"); lbs_deb_host("DNLD_CMD: hw_host_to_card failed\n");
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
adapter->cur_cmd_retcode = ret; priv->cur_cmd_retcode = ret;
__lbs_cleanup_and_insert_cmd(priv, adapter->cur_cmd); __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
goto done; goto done;
} }
@ -1087,9 +1076,9 @@ static int DownloadcommandToStation(struct lbs_private *priv,
/* Setup the timer after transmit command */ /* Setup the timer after transmit command */
if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE
|| command == CMD_802_11_ASSOCIATE) || command == CMD_802_11_ASSOCIATE)
mod_timer(&adapter->command_timer, jiffies + (10*HZ)); mod_timer(&priv->command_timer, jiffies + (10*HZ));
else else
mod_timer(&adapter->command_timer, jiffies + (5*HZ)); mod_timer(&priv->command_timer, jiffies + (5*HZ));
ret = 0; ret = 0;
@ -1107,7 +1096,7 @@ static int lbs_cmd_mac_control(struct lbs_private *priv,
cmd->command = cpu_to_le16(CMD_MAC_CONTROL); cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
mac->action = cpu_to_le16(priv->adapter->currentpacketfilter); mac->action = cpu_to_le16(priv->currentpacketfilter);
lbs_deb_cmd("MAC_CONTROL: action 0x%x, size %d\n", lbs_deb_cmd("MAC_CONTROL: action 0x%x, size %d\n",
le16_to_cpu(mac->action), le16_to_cpu(cmd->size)); le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
@ -1118,18 +1107,17 @@ static int lbs_cmd_mac_control(struct lbs_private *priv,
/** /**
* This function inserts command node to cmdfreeq * This function inserts command node to cmdfreeq
* after cleans it. Requires adapter->driver_lock held. * after cleans it. Requires priv->driver_lock held.
*/ */
void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv, void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
struct cmd_ctrl_node *ptempcmd) struct cmd_ctrl_node *ptempcmd)
{ {
struct lbs_adapter *adapter = priv->adapter;
if (!ptempcmd) if (!ptempcmd)
return; return;
cleanup_cmdnode(ptempcmd); cleanup_cmdnode(ptempcmd);
list_add_tail(&ptempcmd->list, &adapter->cmdfreeq); list_add_tail(&ptempcmd->list, &priv->cmdfreeq);
} }
static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv, static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
@ -1137,9 +1125,9 @@ static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
{ {
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&priv->adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
__lbs_cleanup_and_insert_cmd(priv, ptempcmd); __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
} }
int lbs_set_radio_control(struct lbs_private *priv) int lbs_set_radio_control(struct lbs_private *priv)
@ -1154,7 +1142,7 @@ int lbs_set_radio_control(struct lbs_private *priv)
CMD_OPTION_WAITFORRSP, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n",
priv->adapter->radioon, priv->adapter->preamble); priv->radioon, priv->preamble);
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
return ret; return ret;
@ -1191,20 +1179,19 @@ int lbs_prepare_and_send_command(struct lbs_private *priv,
u16 wait_option, u32 cmd_oid, void *pdata_buf) u16 wait_option, u32 cmd_oid, void *pdata_buf)
{ {
int ret = 0; int ret = 0;
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ctrl_node *cmdnode; struct cmd_ctrl_node *cmdnode;
struct cmd_ds_command *cmdptr; struct cmd_ds_command *cmdptr;
unsigned long flags; unsigned long flags;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
if (!adapter) { if (!priv) {
lbs_deb_host("PREP_CMD: adapter is NULL\n"); lbs_deb_host("PREP_CMD: priv is NULL\n");
ret = -1; ret = -1;
goto done; goto done;
} }
if (adapter->surpriseremoved) { if (priv->surpriseremoved) {
lbs_deb_host("PREP_CMD: card removed\n"); lbs_deb_host("PREP_CMD: card removed\n");
ret = -1; ret = -1;
goto done; goto done;
@ -1235,8 +1222,8 @@ int lbs_prepare_and_send_command(struct lbs_private *priv,
} }
/* Set sequence number, command and INT option */ /* Set sequence number, command and INT option */
adapter->seqnum++; priv->seqnum++;
cmdptr->seqnum = cpu_to_le16(adapter->seqnum); cmdptr->seqnum = cpu_to_le16(priv->seqnum);
cmdptr->command = cpu_to_le16(cmd_no); cmdptr->command = cpu_to_le16(cmd_no);
cmdptr->result = 0; cmdptr->result = 0;
@ -1482,7 +1469,7 @@ int lbs_prepare_and_send_command(struct lbs_private *priv,
cmdnode->cmdwaitqwoken = 0; cmdnode->cmdwaitqwoken = 0;
lbs_queue_cmd(adapter, cmdnode, 1); lbs_queue_cmd(priv, cmdnode, 1);
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);
if (wait_option & CMD_OPTION_WAITFORRSP) { if (wait_option & CMD_OPTION_WAITFORRSP) {
@ -1492,14 +1479,14 @@ int lbs_prepare_and_send_command(struct lbs_private *priv,
cmdnode->cmdwaitqwoken); cmdnode->cmdwaitqwoken);
} }
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd_retcode) { if (priv->cur_cmd_retcode) {
lbs_deb_host("PREP_CMD: command failed with return code %d\n", lbs_deb_host("PREP_CMD: command failed with return code %d\n",
adapter->cur_cmd_retcode); priv->cur_cmd_retcode);
adapter->cur_cmd_retcode = 0; priv->cur_cmd_retcode = 0;
ret = -1; ret = -1;
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
done: done:
lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
@ -1521,7 +1508,6 @@ int lbs_allocate_cmd_buffer(struct lbs_private *priv)
u32 i; u32 i;
struct cmd_ctrl_node *tempcmd_array; struct cmd_ctrl_node *tempcmd_array;
u8 *ptempvirtualaddr; u8 *ptempvirtualaddr;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
@ -1533,7 +1519,7 @@ int lbs_allocate_cmd_buffer(struct lbs_private *priv)
ret = -1; ret = -1;
goto done; goto done;
} }
adapter->cmd_array = tempcmd_array; priv->cmd_array = tempcmd_array;
/* Allocate and initialize command buffers */ /* Allocate and initialize command buffers */
ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER; ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
@ -1571,17 +1557,16 @@ int lbs_free_cmd_buffer(struct lbs_private *priv)
u32 ulbufsize; /* Someone needs to die for this. Slowly and painfully */ u32 ulbufsize; /* Someone needs to die for this. Slowly and painfully */
unsigned int i; unsigned int i;
struct cmd_ctrl_node *tempcmd_array; struct cmd_ctrl_node *tempcmd_array;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
/* need to check if cmd array is allocated or not */ /* need to check if cmd array is allocated or not */
if (adapter->cmd_array == NULL) { if (priv->cmd_array == NULL) {
lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n"); lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
goto done; goto done;
} }
tempcmd_array = adapter->cmd_array; tempcmd_array = priv->cmd_array;
/* Release shared memory buffers */ /* Release shared memory buffers */
ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER; ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
@ -1593,9 +1578,9 @@ int lbs_free_cmd_buffer(struct lbs_private *priv)
} }
/* Release cmd_ctrl_node */ /* Release cmd_ctrl_node */
if (adapter->cmd_array) { if (priv->cmd_array) {
kfree(adapter->cmd_array); kfree(priv->cmd_array);
adapter->cmd_array = NULL; priv->cmd_array = NULL;
} }
done: done:
@ -1613,18 +1598,17 @@ done:
struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv) struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
{ {
struct cmd_ctrl_node *tempnode; struct cmd_ctrl_node *tempnode;
struct lbs_adapter *adapter = priv->adapter;
unsigned long flags; unsigned long flags;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
if (!adapter) if (!priv)
return NULL; return NULL;
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (!list_empty(&adapter->cmdfreeq)) { if (!list_empty(&priv->cmdfreeq)) {
tempnode = list_first_entry(&adapter->cmdfreeq, tempnode = list_first_entry(&priv->cmdfreeq,
struct cmd_ctrl_node, list); struct cmd_ctrl_node, list);
list_del(&tempnode->list); list_del(&tempnode->list);
} else { } else {
@ -1632,7 +1616,7 @@ struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
tempnode = NULL; tempnode = NULL;
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
if (tempnode) if (tempnode)
cleanup_cmdnode(tempnode); cleanup_cmdnode(tempnode);
@ -1700,7 +1684,6 @@ void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
*/ */
int lbs_execute_next_command(struct lbs_private *priv) int lbs_execute_next_command(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ctrl_node *cmdnode = NULL; struct cmd_ctrl_node *cmdnode = NULL;
struct cmd_ds_command *cmdptr; struct cmd_ds_command *cmdptr;
unsigned long flags; unsigned long flags;
@ -1711,40 +1694,40 @@ int lbs_execute_next_command(struct lbs_private *priv)
// data packet is received // data packet is received
lbs_deb_enter(LBS_DEB_THREAD); lbs_deb_enter(LBS_DEB_THREAD);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd) { if (priv->cur_cmd) {
lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n"); lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
ret = -1; ret = -1;
goto done; goto done;
} }
if (!list_empty(&adapter->cmdpendingq)) { if (!list_empty(&priv->cmdpendingq)) {
cmdnode = list_first_entry(&adapter->cmdpendingq, cmdnode = list_first_entry(&priv->cmdpendingq,
struct cmd_ctrl_node, list); struct cmd_ctrl_node, list);
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
if (cmdnode) { if (cmdnode) {
cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr; cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
if (is_command_allowed_in_ps(cmdptr->command)) { if (is_command_allowed_in_ps(cmdptr->command)) {
if ((adapter->psstate == PS_STATE_SLEEP) || if ((priv->psstate == PS_STATE_SLEEP) ||
(adapter->psstate == PS_STATE_PRE_SLEEP)) { (priv->psstate == PS_STATE_PRE_SLEEP)) {
lbs_deb_host( lbs_deb_host(
"EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n", "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
le16_to_cpu(cmdptr->command), le16_to_cpu(cmdptr->command),
adapter->psstate); priv->psstate);
ret = -1; ret = -1;
goto done; goto done;
} }
lbs_deb_host("EXEC_NEXT_CMD: OK to send command " lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
"0x%04x in psstate %d\n", "0x%04x in psstate %d\n",
le16_to_cpu(cmdptr->command), le16_to_cpu(cmdptr->command),
adapter->psstate); priv->psstate);
} else if (adapter->psstate != PS_STATE_FULL_POWER) { } else if (priv->psstate != PS_STATE_FULL_POWER) {
/* /*
* 1. Non-PS command: * 1. Non-PS command:
* Queue it. set needtowakeup to TRUE if current state * Queue it. set needtowakeup to TRUE if current state
@ -1760,12 +1743,12 @@ int lbs_execute_next_command(struct lbs_private *priv)
cpu_to_le16(CMD_802_11_PS_MODE)) { cpu_to_le16(CMD_802_11_PS_MODE)) {
/* Prepare to send Exit PS, /* Prepare to send Exit PS,
* this non PS command will be sent later */ * this non PS command will be sent later */
if ((adapter->psstate == PS_STATE_SLEEP) if ((priv->psstate == PS_STATE_SLEEP)
|| (adapter->psstate == PS_STATE_PRE_SLEEP) || (priv->psstate == PS_STATE_PRE_SLEEP)
) { ) {
/* w/ new scheme, it will not reach here. /* w/ new scheme, it will not reach here.
since it is blocked in main_thread. */ since it is blocked in main_thread. */
adapter->needtowakeup = 1; priv->needtowakeup = 1;
} else } else
lbs_ps_wakeup(priv, 0); lbs_ps_wakeup(priv, 0);
@ -1793,13 +1776,13 @@ int lbs_execute_next_command(struct lbs_private *priv)
goto done; goto done;
} }
if ((adapter->psstate == PS_STATE_SLEEP) || if ((priv->psstate == PS_STATE_SLEEP) ||
(adapter->psstate == PS_STATE_PRE_SLEEP)) { (priv->psstate == PS_STATE_PRE_SLEEP)) {
lbs_deb_host( lbs_deb_host(
"EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n"); "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
list_del(&cmdnode->list); list_del(&cmdnode->list);
lbs_cleanup_and_insert_cmd(priv, cmdnode); lbs_cleanup_and_insert_cmd(priv, cmdnode);
adapter->needtowakeup = 1; priv->needtowakeup = 1;
ret = 0; ret = 0;
goto done; goto done;
@ -1818,15 +1801,15 @@ int lbs_execute_next_command(struct lbs_private *priv)
* check if in power save mode, if yes, put the device back * check if in power save mode, if yes, put the device back
* to PS mode * to PS mode
*/ */
if ((adapter->psmode != LBS802_11POWERMODECAM) && if ((priv->psmode != LBS802_11POWERMODECAM) &&
(adapter->psstate == PS_STATE_FULL_POWER) && (priv->psstate == PS_STATE_FULL_POWER) &&
((adapter->connect_status == LBS_CONNECTED) || ((priv->connect_status == LBS_CONNECTED) ||
(adapter->mesh_connect_status == LBS_CONNECTED))) { (priv->mesh_connect_status == LBS_CONNECTED))) {
if (adapter->secinfo.WPAenabled || if (priv->secinfo.WPAenabled ||
adapter->secinfo.WPA2enabled) { priv->secinfo.WPA2enabled) {
/* check for valid WPA group keys */ /* check for valid WPA group keys */
if (adapter->wpa_mcast_key.len || if (priv->wpa_mcast_key.len ||
adapter->wpa_unicast_key.len) { priv->wpa_unicast_key.len) {
lbs_deb_host( lbs_deb_host(
"EXEC_NEXT_CMD: WPA enabled and GTK_SET" "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
" go back to PS_SLEEP"); " go back to PS_SLEEP");
@ -1874,7 +1857,6 @@ void lbs_send_iwevcustom_event(struct lbs_private *priv, s8 *str)
static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size) static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size)
{ {
unsigned long flags; unsigned long flags;
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
@ -1887,24 +1869,24 @@ static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size)
ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size); ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
priv->dnld_sent = DNLD_RES_RECEIVED; priv->dnld_sent = DNLD_RES_RECEIVED;
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->intcounter || adapter->currenttxskb) if (priv->intcounter || priv->currenttxskb)
lbs_deb_host("SEND_SLEEPC_CMD: intcounter %d, currenttxskb %p\n", lbs_deb_host("SEND_SLEEPC_CMD: intcounter %d, currenttxskb %p\n",
adapter->intcounter, adapter->currenttxskb); priv->intcounter, priv->currenttxskb);
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
if (ret) { if (ret) {
lbs_pr_alert( lbs_pr_alert(
"SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n"); "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
} else { } else {
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (!adapter->intcounter) { if (!priv->intcounter) {
adapter->psstate = PS_STATE_SLEEP; priv->psstate = PS_STATE_SLEEP;
} else { } else {
lbs_deb_host("SEND_SLEEPC_CMD: after sent, intcounter %d\n", lbs_deb_host("SEND_SLEEPC_CMD: after sent, intcounter %d\n",
adapter->intcounter); priv->intcounter);
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
lbs_deb_host("SEND_SLEEPC_CMD: sent confirm sleep\n"); lbs_deb_host("SEND_SLEEPC_CMD: sent confirm sleep\n");
} }
@ -1961,7 +1943,6 @@ void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode) void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
{ {
unsigned long flags =0; unsigned long flags =0;
struct lbs_adapter *adapter = priv->adapter;
u8 allowed = 1; u8 allowed = 1;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
@ -1971,20 +1952,20 @@ void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
lbs_deb_host("dnld_sent was set"); lbs_deb_host("dnld_sent was set");
} }
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd) { if (priv->cur_cmd) {
allowed = 0; allowed = 0;
lbs_deb_host("cur_cmd was set"); lbs_deb_host("cur_cmd was set");
} }
if (adapter->intcounter > 0) { if (priv->intcounter > 0) {
allowed = 0; allowed = 0;
lbs_deb_host("intcounter %d", adapter->intcounter); lbs_deb_host("intcounter %d", priv->intcounter);
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
if (allowed) { if (allowed) {
lbs_deb_host("sending lbs_ps_confirm_sleep\n"); lbs_deb_host("sending lbs_ps_confirm_sleep\n");
sendconfirmsleep(priv, (u8 *) & adapter->lbs_ps_confirm_sleep, sendconfirmsleep(priv, (u8 *) & priv->lbs_ps_confirm_sleep,
sizeof(struct PS_CMD_ConfirmSleep)); sizeof(struct PS_CMD_ConfirmSleep));
} else { } else {
lbs_deb_host("sleep confirm has been delayed\n"); lbs_deb_host("sleep confirm has been delayed\n");
@ -2014,7 +1995,6 @@ void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
int lbs_cmd(struct lbs_private *priv, uint16_t command, void *cmd, int cmd_size, int lbs_cmd(struct lbs_private *priv, uint16_t command, void *cmd, int cmd_size,
int (*callback)(uint16_t, struct cmd_ds_command *, struct lbs_private *)) int (*callback)(uint16_t, struct cmd_ds_command *, struct lbs_private *))
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ctrl_node *cmdnode; struct cmd_ctrl_node *cmdnode;
struct cmd_ds_gen *cmdptr; struct cmd_ds_gen *cmdptr;
unsigned long flags; unsigned long flags;
@ -2022,13 +2002,13 @@ int lbs_cmd(struct lbs_private *priv, uint16_t command, void *cmd, int cmd_size,
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
if (!adapter) { if (!priv) {
lbs_deb_host("PREP_CMD: adapter is NULL\n"); lbs_deb_host("PREP_CMD: priv is NULL\n");
ret = -1; ret = -1;
goto done; goto done;
} }
if (adapter->surpriseremoved) { if (priv->surpriseremoved) {
lbs_deb_host("PREP_CMD: card removed\n"); lbs_deb_host("PREP_CMD: card removed\n");
ret = -1; ret = -1;
goto done; goto done;
@ -2050,10 +2030,10 @@ int lbs_cmd(struct lbs_private *priv, uint16_t command, void *cmd, int cmd_size,
cmdnode->callback = callback; cmdnode->callback = callback;
/* Set sequence number, clean result, move to buffer */ /* Set sequence number, clean result, move to buffer */
adapter->seqnum++; priv->seqnum++;
cmdptr->command = cpu_to_le16(command); cmdptr->command = cpu_to_le16(command);
cmdptr->size = cpu_to_le16(cmd_size + S_DS_GEN); cmdptr->size = cpu_to_le16(cmd_size + S_DS_GEN);
cmdptr->seqnum = cpu_to_le16(adapter->seqnum); cmdptr->seqnum = cpu_to_le16(priv->seqnum);
cmdptr->result = 0; cmdptr->result = 0;
memcpy(cmdptr->cmdresp, cmd, cmd_size); memcpy(cmdptr->cmdresp, cmd, cmd_size);
@ -2063,20 +2043,20 @@ int lbs_cmd(struct lbs_private *priv, uint16_t command, void *cmd, int cmd_size,
* because the caller of lbs_cmd() sets up all of *cmd for us. */ * because the caller of lbs_cmd() sets up all of *cmd for us. */
cmdnode->cmdwaitqwoken = 0; cmdnode->cmdwaitqwoken = 0;
lbs_queue_cmd(adapter, cmdnode, 1); lbs_queue_cmd(priv, cmdnode, 1);
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);
might_sleep(); might_sleep();
wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken); wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd_retcode) { if (priv->cur_cmd_retcode) {
lbs_deb_host("PREP_CMD: command failed with return code %d\n", lbs_deb_host("PREP_CMD: command failed with return code %d\n",
adapter->cur_cmd_retcode); priv->cur_cmd_retcode);
adapter->cur_cmd_retcode = 0; priv->cur_cmd_retcode = 0;
ret = -1; ret = -1;
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
done: done:
lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);

336
drivers/net/wireless/libertas/cmdresp.c
View File

@ -25,10 +25,9 @@
*/ */
void lbs_mac_event_disconnected(struct lbs_private *priv) void lbs_mac_event_disconnected(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
union iwreq_data wrqu; union iwreq_data wrqu;
if (adapter->connect_status != LBS_CONNECTED) if (priv->connect_status != LBS_CONNECTED)
return; return;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
@ -45,31 +44,31 @@ void lbs_mac_event_disconnected(struct lbs_private *priv)
wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
/* Free Tx and Rx packets */ /* Free Tx and Rx packets */
kfree_skb(priv->adapter->currenttxskb); kfree_skb(priv->currenttxskb);
priv->adapter->currenttxskb = NULL; priv->currenttxskb = NULL;
/* report disconnect to upper layer */ /* report disconnect to upper layer */
netif_stop_queue(priv->dev); netif_stop_queue(priv->dev);
netif_carrier_off(priv->dev); netif_carrier_off(priv->dev);
/* reset SNR/NF/RSSI values */ /* reset SNR/NF/RSSI values */
memset(adapter->SNR, 0x00, sizeof(adapter->SNR)); memset(priv->SNR, 0x00, sizeof(priv->SNR));
memset(adapter->NF, 0x00, sizeof(adapter->NF)); memset(priv->NF, 0x00, sizeof(priv->NF));
memset(adapter->RSSI, 0x00, sizeof(adapter->RSSI)); memset(priv->RSSI, 0x00, sizeof(priv->RSSI));
memset(adapter->rawSNR, 0x00, sizeof(adapter->rawSNR)); memset(priv->rawSNR, 0x00, sizeof(priv->rawSNR));
memset(adapter->rawNF, 0x00, sizeof(adapter->rawNF)); memset(priv->rawNF, 0x00, sizeof(priv->rawNF));
adapter->nextSNRNF = 0; priv->nextSNRNF = 0;
adapter->numSNRNF = 0; priv->numSNRNF = 0;
adapter->connect_status = LBS_DISCONNECTED; priv->connect_status = LBS_DISCONNECTED;
/* Clear out associated SSID and BSSID since connection is /* Clear out associated SSID and BSSID since connection is
* no longer valid. * no longer valid.
*/ */
memset(&adapter->curbssparams.bssid, 0, ETH_ALEN); memset(&priv->curbssparams.bssid, 0, ETH_ALEN);
memset(&adapter->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE); memset(&priv->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE);
adapter->curbssparams.ssid_len = 0; priv->curbssparams.ssid_len = 0;
if (adapter->psstate != PS_STATE_FULL_POWER) { if (priv->psstate != PS_STATE_FULL_POWER) {
/* make firmware to exit PS mode */ /* make firmware to exit PS mode */
lbs_deb_cmd("disconnected, so exit PS mode\n"); lbs_deb_cmd("disconnected, so exit PS mode\n");
lbs_ps_wakeup(priv, 0); lbs_ps_wakeup(priv, 0);
@ -107,7 +106,6 @@ static int lbs_ret_reg_access(struct lbs_private *priv,
u16 type, struct cmd_ds_command *resp) u16 type, struct cmd_ds_command *resp)
{ {
int ret = 0; int ret = 0;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -116,8 +114,8 @@ static int lbs_ret_reg_access(struct lbs_private *priv,
{ {
struct cmd_ds_mac_reg_access *reg = &resp->params.macreg; struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset); priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
adapter->offsetvalue.value = le32_to_cpu(reg->value); priv->offsetvalue.value = le32_to_cpu(reg->value);
break; break;
} }
@ -125,8 +123,8 @@ static int lbs_ret_reg_access(struct lbs_private *priv,
{ {
struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg; struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset); priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
adapter->offsetvalue.value = reg->value; priv->offsetvalue.value = reg->value;
break; break;
} }
@ -134,8 +132,8 @@ static int lbs_ret_reg_access(struct lbs_private *priv,
{ {
struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg; struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset); priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
adapter->offsetvalue.value = reg->value; priv->offsetvalue.value = reg->value;
break; break;
} }
@ -152,19 +150,18 @@ static int lbs_ret_get_hw_spec(struct lbs_private *priv,
{ {
u32 i; u32 i;
struct cmd_ds_get_hw_spec *hwspec = &resp->params.hwspec; struct cmd_ds_get_hw_spec *hwspec = &resp->params.hwspec;
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
DECLARE_MAC_BUF(mac); DECLARE_MAC_BUF(mac);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
adapter->fwcapinfo = le32_to_cpu(hwspec->fwcapinfo); priv->fwcapinfo = le32_to_cpu(hwspec->fwcapinfo);
memcpy(adapter->fwreleasenumber, hwspec->fwreleasenumber, 4); memcpy(priv->fwreleasenumber, hwspec->fwreleasenumber, 4);
lbs_deb_cmd("GET_HW_SPEC: firmware release %u.%u.%up%u\n", lbs_deb_cmd("GET_HW_SPEC: firmware release %u.%u.%up%u\n",
adapter->fwreleasenumber[2], adapter->fwreleasenumber[1], priv->fwreleasenumber[2], priv->fwreleasenumber[1],
adapter->fwreleasenumber[0], adapter->fwreleasenumber[3]); priv->fwreleasenumber[0], priv->fwreleasenumber[3]);
lbs_deb_cmd("GET_HW_SPEC: MAC addr %s\n", lbs_deb_cmd("GET_HW_SPEC: MAC addr %s\n",
print_mac(mac, hwspec->permanentaddr)); print_mac(mac, hwspec->permanentaddr));
lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n", lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
@ -174,29 +171,29 @@ static int lbs_ret_get_hw_spec(struct lbs_private *priv,
* only ever be 8-bit, even though the field size is 16-bit. Some firmware * only ever be 8-bit, even though the field size is 16-bit. Some firmware
* returns non-zero high 8 bits here. * returns non-zero high 8 bits here.
*/ */
adapter->regioncode = le16_to_cpu(hwspec->regioncode) & 0xFF; priv->regioncode = le16_to_cpu(hwspec->regioncode) & 0xFF;
for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) { for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
/* use the region code to search for the index */ /* use the region code to search for the index */
if (adapter->regioncode == lbs_region_code_to_index[i]) { if (priv->regioncode == lbs_region_code_to_index[i]) {
break; break;
} }
} }
/* if it's unidentified region code, use the default (USA) */ /* if it's unidentified region code, use the default (USA) */
if (i >= MRVDRV_MAX_REGION_CODE) { if (i >= MRVDRV_MAX_REGION_CODE) {
adapter->regioncode = 0x10; priv->regioncode = 0x10;
lbs_pr_info("unidentified region code; using the default (USA)\n"); lbs_pr_info("unidentified region code; using the default (USA)\n");
} }
if (adapter->current_addr[0] == 0xff) if (priv->current_addr[0] == 0xff)
memmove(adapter->current_addr, hwspec->permanentaddr, ETH_ALEN); memmove(priv->current_addr, hwspec->permanentaddr, ETH_ALEN);
memcpy(priv->dev->dev_addr, adapter->current_addr, ETH_ALEN); memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
if (priv->mesh_dev) if (priv->mesh_dev)
memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
if (lbs_set_regiontable(priv, adapter->regioncode, 0)) { if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
ret = -1; ret = -1;
goto done; goto done;
} }
@ -215,7 +212,6 @@ static int lbs_ret_802_11_sleep_params(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params; struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -224,12 +220,12 @@ static int lbs_ret_802_11_sleep_params(struct lbs_private *priv,
le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime), le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime),
sp->calcontrol, sp->externalsleepclk); sp->calcontrol, sp->externalsleepclk);
adapter->sp.sp_error = le16_to_cpu(sp->error); priv->sp.sp_error = le16_to_cpu(sp->error);
adapter->sp.sp_offset = le16_to_cpu(sp->offset); priv->sp.sp_offset = le16_to_cpu(sp->offset);
adapter->sp.sp_stabletime = le16_to_cpu(sp->stabletime); priv->sp.sp_stabletime = le16_to_cpu(sp->stabletime);
adapter->sp.sp_calcontrol = sp->calcontrol; priv->sp.sp_calcontrol = sp->calcontrol;
adapter->sp.sp_extsleepclk = sp->externalsleepclk; priv->sp.sp_extsleepclk = sp->externalsleepclk;
adapter->sp.sp_reserved = le16_to_cpu(sp->reserved); priv->sp.sp_reserved = le16_to_cpu(sp->reserved);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
return 0; return 0;
@ -239,13 +235,12 @@ static int lbs_ret_802_11_stat(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
/* currently adapter->wlan802_11Stat is unused /* currently priv->wlan802_11Stat is unused
struct cmd_ds_802_11_get_stat *p11Stat = &resp->params.gstat; struct cmd_ds_802_11_get_stat *p11Stat = &resp->params.gstat;
struct lbs_adapter *adapter = priv->adapter;
// TODO Convert it to Big endian befor copy // TODO Convert it to Big endian befor copy
memcpy(&adapter->wlan802_11Stat, memcpy(&priv->wlan802_11Stat,
p11Stat, sizeof(struct cmd_ds_802_11_get_stat)); p11Stat, sizeof(struct cmd_ds_802_11_get_stat));
*/ */
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
@ -268,22 +263,22 @@ static int lbs_ret_802_11_snmp_mib(struct lbs_private *priv,
if (querytype == CMD_ACT_GET) { if (querytype == CMD_ACT_GET) {
switch (oid) { switch (oid) {
case FRAGTHRESH_I: case FRAGTHRESH_I:
priv->adapter->fragthsd = priv->fragthsd =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: frag threshold %u\n", lbs_deb_cmd("SNMP_RESP: frag threshold %u\n",
priv->adapter->fragthsd); priv->fragthsd);
break; break;
case RTSTHRESH_I: case RTSTHRESH_I:
priv->adapter->rtsthsd = priv->rtsthsd =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: rts threshold %u\n", lbs_deb_cmd("SNMP_RESP: rts threshold %u\n",
priv->adapter->rtsthsd); priv->rtsthsd);
break; break;
case SHORT_RETRYLIM_I: case SHORT_RETRYLIM_I:
priv->adapter->txretrycount = priv->txretrycount =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: tx retry count %u\n", lbs_deb_cmd("SNMP_RESP: tx retry count %u\n",
priv->adapter->rtsthsd); priv->rtsthsd);
break; break;
default: default:
break; break;
@ -299,7 +294,6 @@ static int lbs_ret_802_11_key_material(struct lbs_private *priv,
{ {
struct cmd_ds_802_11_key_material *pkeymaterial = struct cmd_ds_802_11_key_material *pkeymaterial =
&resp->params.keymaterial; &resp->params.keymaterial;
struct lbs_adapter *adapter = priv->adapter;
u16 action = le16_to_cpu(pkeymaterial->action); u16 action = le16_to_cpu(pkeymaterial->action);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -327,9 +321,9 @@ static int lbs_ret_802_11_key_material(struct lbs_private *priv,
break; break;
if (key_flags & KEY_INFO_WPA_UNICAST) if (key_flags & KEY_INFO_WPA_UNICAST)
pkey = &adapter->wpa_unicast_key; pkey = &priv->wpa_unicast_key;
else if (key_flags & KEY_INFO_WPA_MCAST) else if (key_flags & KEY_INFO_WPA_MCAST)
pkey = &adapter->wpa_mcast_key; pkey = &priv->wpa_mcast_key;
else else
break; break;
@ -354,11 +348,10 @@ static int lbs_ret_802_11_mac_address(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd; struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
memcpy(adapter->current_addr, macadd->macadd, ETH_ALEN); memcpy(priv->current_addr, macadd->macadd, ETH_ALEN);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
return 0; return 0;
@ -368,13 +361,12 @@ static int lbs_ret_802_11_rf_tx_power(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp; struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
adapter->txpowerlevel = le16_to_cpu(rtp->currentlevel); priv->txpowerlevel = le16_to_cpu(rtp->currentlevel);
lbs_deb_cmd("TX power currently %d\n", adapter->txpowerlevel); lbs_deb_cmd("TX power currently %d\n", priv->txpowerlevel);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -384,13 +376,12 @@ static int lbs_ret_802_11_rate_adapt_rateset(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset; struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
if (rates->action == CMD_ACT_GET) { if (rates->action == CMD_ACT_GET) {
adapter->enablehwauto = le16_to_cpu(rates->enablehwauto); priv->enablehwauto = le16_to_cpu(rates->enablehwauto);
adapter->ratebitmap = le16_to_cpu(rates->bitmap); priv->ratebitmap = le16_to_cpu(rates->bitmap);
} }
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
@ -401,7 +392,6 @@ static int lbs_ret_802_11_data_rate(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_data_rate *pdatarate = &resp->params.drate; struct cmd_ds_802_11_data_rate *pdatarate = &resp->params.drate;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -411,8 +401,8 @@ static int lbs_ret_802_11_data_rate(struct lbs_private *priv,
/* FIXME: get actual rates FW can do if this command actually returns /* FIXME: get actual rates FW can do if this command actually returns
* all data rates supported. * all data rates supported.
*/ */
adapter->cur_rate = lbs_fw_index_to_data_rate(pdatarate->rates[0]); priv->cur_rate = lbs_fw_index_to_data_rate(pdatarate->rates[0]);
lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", adapter->cur_rate); lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", priv->cur_rate);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -422,19 +412,18 @@ static int lbs_ret_802_11_rf_channel(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_rf_channel *rfchannel = &resp->params.rfchannel; struct cmd_ds_802_11_rf_channel *rfchannel = &resp->params.rfchannel;
struct lbs_adapter *adapter = priv->adapter;
u16 action = le16_to_cpu(rfchannel->action); u16 action = le16_to_cpu(rfchannel->action);
u16 newchannel = le16_to_cpu(rfchannel->currentchannel); u16 newchannel = le16_to_cpu(rfchannel->currentchannel);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
if (action == CMD_OPT_802_11_RF_CHANNEL_GET if (action == CMD_OPT_802_11_RF_CHANNEL_GET
&& adapter->curbssparams.channel != newchannel) { && priv->curbssparams.channel != newchannel) {
lbs_deb_cmd("channel switch from %d to %d\n", lbs_deb_cmd("channel switch from %d to %d\n",
adapter->curbssparams.channel, newchannel); priv->curbssparams.channel, newchannel);
/* Update the channel again */ /* Update the channel again */
adapter->curbssparams.channel = newchannel; priv->curbssparams.channel = newchannel;
} }
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -445,28 +434,27 @@ static int lbs_ret_802_11_rssi(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp; struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
/* store the non average value */ /* store the non average value */
adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR); priv->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
adapter->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor); priv->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
adapter->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR); priv->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
adapter->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor); priv->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = priv->RSSI[TYPE_BEACON][TYPE_NOAVG] =
CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG], CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_NOAVG],
adapter->NF[TYPE_BEACON][TYPE_NOAVG]); priv->NF[TYPE_BEACON][TYPE_NOAVG]);
adapter->RSSI[TYPE_BEACON][TYPE_AVG] = priv->RSSI[TYPE_BEACON][TYPE_AVG] =
CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE, CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
adapter->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE); priv->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
lbs_deb_cmd("RSSI: beacon %d, avg %d\n", lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
adapter->RSSI[TYPE_BEACON][TYPE_NOAVG], priv->RSSI[TYPE_BEACON][TYPE_NOAVG],
adapter->RSSI[TYPE_BEACON][TYPE_AVG]); priv->RSSI[TYPE_BEACON][TYPE_AVG]);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -475,9 +463,8 @@ static int lbs_ret_802_11_rssi(struct lbs_private *priv,
static int lbs_ret_802_11_eeprom_access(struct lbs_private *priv, static int lbs_ret_802_11_eeprom_access(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct lbs_ioctl_regrdwr *pbuf; struct lbs_ioctl_regrdwr *pbuf;
pbuf = (struct lbs_ioctl_regrdwr *) adapter->prdeeprom; pbuf = (struct lbs_ioctl_regrdwr *) priv->prdeeprom;
lbs_deb_enter_args(LBS_DEB_CMD, "len %d", lbs_deb_enter_args(LBS_DEB_CMD, "len %d",
le16_to_cpu(resp->params.rdeeprom.bytecount)); le16_to_cpu(resp->params.rdeeprom.bytecount));
@ -502,12 +489,11 @@ static int lbs_ret_get_log(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog; struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
/* Stored little-endian */ /* Stored little-endian */
memcpy(&adapter->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log)); memcpy(&priv->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
return 0; return 0;
@ -517,8 +503,7 @@ static int lbs_ret_802_11_enable_rsn(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn; struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn;
struct lbs_adapter *adapter = priv->adapter; u32 * pdata_buf = priv->cur_cmd->pdata_buf;
u32 * pdata_buf = adapter->cur_cmd->pdata_buf;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -536,13 +521,12 @@ static int lbs_ret_802_11_bcn_ctrl(struct lbs_private * priv,
{ {
struct cmd_ds_802_11_beacon_control *bcn_ctrl = struct cmd_ds_802_11_beacon_control *bcn_ctrl =
&resp->params.bcn_ctrl; &resp->params.bcn_ctrl;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
if (bcn_ctrl->action == CMD_ACT_GET) { if (bcn_ctrl->action == CMD_ACT_GET) {
adapter->beacon_enable = (u8) le16_to_cpu(bcn_ctrl->beacon_enable); priv->beacon_enable = (u8) le16_to_cpu(bcn_ctrl->beacon_enable);
adapter->beacon_period = le16_to_cpu(bcn_ctrl->beacon_period); priv->beacon_period = le16_to_cpu(bcn_ctrl->beacon_period);
} }
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -552,11 +536,10 @@ static int lbs_ret_802_11_bcn_ctrl(struct lbs_private * priv,
static int lbs_ret_802_11_subscribe_event(struct lbs_private *priv, static int lbs_ret_802_11_subscribe_event(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_subscribe_event *cmd_event = struct cmd_ds_802_11_subscribe_event *cmd_event =
&resp->params.subscribe_event; &resp->params.subscribe_event;
struct cmd_ds_802_11_subscribe_event *dst_event = struct cmd_ds_802_11_subscribe_event *dst_event =
adapter->cur_cmd->pdata_buf; priv->cur_cmd->pdata_buf;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@ -575,7 +558,6 @@ static inline int handle_cmd_response(u16 respcmd,
{ {
int ret = 0; int ret = 0;
unsigned long flags; unsigned long flags;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
@ -628,10 +610,10 @@ static inline int handle_cmd_response(u16 respcmd,
case CMD_RET(CMD_802_11_SET_AFC): case CMD_RET(CMD_802_11_SET_AFC):
case CMD_RET(CMD_802_11_GET_AFC): case CMD_RET(CMD_802_11_GET_AFC):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc, memmove(priv->cur_cmd->pdata_buf, &resp->params.afc,
sizeof(struct cmd_ds_802_11_afc)); sizeof(struct cmd_ds_802_11_afc));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
@ -686,59 +668,59 @@ static inline int handle_cmd_response(u16 respcmd,
ret = lbs_ret_802_11_sleep_params(priv, resp); ret = lbs_ret_802_11_sleep_params(priv, resp);
break; break;
case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT): case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
*((u16 *) adapter->cur_cmd->pdata_buf) = *((u16 *) priv->cur_cmd->pdata_buf) =
le16_to_cpu(resp->params.inactivity_timeout.timeout); le16_to_cpu(resp->params.inactivity_timeout.timeout);
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_802_11_TPC_CFG): case CMD_RET(CMD_802_11_TPC_CFG):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg, memmove(priv->cur_cmd->pdata_buf, &resp->params.tpccfg,
sizeof(struct cmd_ds_802_11_tpc_cfg)); sizeof(struct cmd_ds_802_11_tpc_cfg));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_802_11_LED_GPIO_CTRL): case CMD_RET(CMD_802_11_LED_GPIO_CTRL):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio, memmove(priv->cur_cmd->pdata_buf, &resp->params.ledgpio,
sizeof(struct cmd_ds_802_11_led_ctrl)); sizeof(struct cmd_ds_802_11_led_ctrl));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_802_11_SUBSCRIBE_EVENT): case CMD_RET(CMD_802_11_SUBSCRIBE_EVENT):
ret = lbs_ret_802_11_subscribe_event(priv, resp); ret = lbs_ret_802_11_subscribe_event(priv, resp);
break; break;
case CMD_RET(CMD_802_11_PWR_CFG): case CMD_RET(CMD_802_11_PWR_CFG):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg, memmove(priv->cur_cmd->pdata_buf, &resp->params.pwrcfg,
sizeof(struct cmd_ds_802_11_pwr_cfg)); sizeof(struct cmd_ds_802_11_pwr_cfg));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_GET_TSF): case CMD_RET(CMD_GET_TSF):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
memcpy(priv->adapter->cur_cmd->pdata_buf, memcpy(priv->cur_cmd->pdata_buf,
&resp->params.gettsf.tsfvalue, sizeof(u64)); &resp->params.gettsf.tsfvalue, sizeof(u64));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_BT_ACCESS): case CMD_RET(CMD_BT_ACCESS):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd->pdata_buf) if (priv->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, memcpy(priv->cur_cmd->pdata_buf,
&resp->params.bt.addr1, 2 * ETH_ALEN); &resp->params.bt.addr1, 2 * ETH_ALEN);
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_FWT_ACCESS): case CMD_RET(CMD_FWT_ACCESS):
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd->pdata_buf) if (priv->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt, memcpy(priv->cur_cmd->pdata_buf, &resp->params.fwt,
sizeof(resp->params.fwt)); sizeof(resp->params.fwt));
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
break; break;
case CMD_RET(CMD_MESH_ACCESS): case CMD_RET(CMD_MESH_ACCESS):
if (adapter->cur_cmd->pdata_buf) if (priv->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh, memcpy(priv->cur_cmd->pdata_buf, &resp->params.mesh,
sizeof(resp->params.mesh)); sizeof(resp->params.mesh));
break; break;
case CMD_RET(CMD_802_11_BEACON_CTRL): case CMD_RET(CMD_802_11_BEACON_CTRL):
@ -758,7 +740,6 @@ int lbs_process_rx_command(struct lbs_private *priv)
{ {
u16 respcmd; u16 respcmd;
struct cmd_ds_command *resp; struct cmd_ds_command *resp;
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
ulong flags; ulong flags;
u16 result; u16 result;
@ -766,39 +747,39 @@ int lbs_process_rx_command(struct lbs_private *priv)
lbs_deb_enter(LBS_DEB_HOST); lbs_deb_enter(LBS_DEB_HOST);
/* Now we got response from FW, cancel the command timer */ /* Now we got response from FW, cancel the command timer */
del_timer(&adapter->command_timer); del_timer(&priv->command_timer);
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (!adapter->cur_cmd) { if (!priv->cur_cmd) {
lbs_deb_host("CMD_RESP: cur_cmd is NULL\n"); lbs_deb_host("CMD_RESP: cur_cmd is NULL\n");
ret = -1; ret = -1;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
goto done; goto done;
} }
resp = (struct cmd_ds_command *)(adapter->cur_cmd->bufvirtualaddr); resp = (struct cmd_ds_command *)(priv->cur_cmd->bufvirtualaddr);
respcmd = le16_to_cpu(resp->command); respcmd = le16_to_cpu(resp->command);
result = le16_to_cpu(resp->result); result = le16_to_cpu(resp->result);
lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n", lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n",
respcmd, priv->upld_len, jiffies); respcmd, priv->upld_len, jiffies);
lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", adapter->cur_cmd->bufvirtualaddr, lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", priv->cur_cmd->bufvirtualaddr,
priv->upld_len); priv->upld_len);
if (!(respcmd & 0x8000)) { if (!(respcmd & 0x8000)) {
lbs_deb_host("invalid response!\n"); lbs_deb_host("invalid response!\n");
adapter->cur_cmd_retcode = -1; priv->cur_cmd_retcode = -1;
__lbs_cleanup_and_insert_cmd(priv, adapter->cur_cmd); __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
ret = -1; ret = -1;
goto done; goto done;
} }
/* Store the response code to cur_cmd_retcode. */ /* Store the response code to cur_cmd_retcode. */
adapter->cur_cmd_retcode = result; priv->cur_cmd_retcode = result;
if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) { if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode; struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
@ -816,15 +797,15 @@ int lbs_process_rx_command(struct lbs_private *priv)
* ad-hoc mode. It takes place in * ad-hoc mode. It takes place in
* lbs_execute_next_command(). * lbs_execute_next_command().
*/ */
if (adapter->mode == IW_MODE_ADHOC && if (priv->mode == IW_MODE_ADHOC &&
action == CMD_SUBCMD_ENTER_PS) action == CMD_SUBCMD_ENTER_PS)
adapter->psmode = LBS802_11POWERMODECAM; priv->psmode = LBS802_11POWERMODECAM;
} else if (action == CMD_SUBCMD_ENTER_PS) { } else if (action == CMD_SUBCMD_ENTER_PS) {
adapter->needtowakeup = 0; priv->needtowakeup = 0;
adapter->psstate = PS_STATE_AWAKE; priv->psstate = PS_STATE_AWAKE;
lbs_deb_host("CMD_RESP: ENTER_PS command response\n"); lbs_deb_host("CMD_RESP: ENTER_PS command response\n");
if (adapter->connect_status != LBS_CONNECTED) { if (priv->connect_status != LBS_CONNECTED) {
/* /*
* When Deauth Event received before Enter_PS command * When Deauth Event received before Enter_PS command
* response, We need to wake up the firmware. * response, We need to wake up the firmware.
@ -832,23 +813,23 @@ int lbs_process_rx_command(struct lbs_private *priv)
lbs_deb_host( lbs_deb_host(
"disconnected, invoking lbs_ps_wakeup\n"); "disconnected, invoking lbs_ps_wakeup\n");
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
lbs_ps_wakeup(priv, 0); lbs_ps_wakeup(priv, 0);
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
} }
} else if (action == CMD_SUBCMD_EXIT_PS) { } else if (action == CMD_SUBCMD_EXIT_PS) {
adapter->needtowakeup = 0; priv->needtowakeup = 0;
adapter->psstate = PS_STATE_FULL_POWER; priv->psstate = PS_STATE_FULL_POWER;
lbs_deb_host("CMD_RESP: EXIT_PS command response\n"); lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
} else { } else {
lbs_deb_host("CMD_RESP: PS action 0x%X\n", action); lbs_deb_host("CMD_RESP: PS action 0x%X\n", action);
} }
__lbs_cleanup_and_insert_cmd(priv, adapter->cur_cmd); __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
ret = 0; ret = 0;
goto done; goto done;
@ -869,32 +850,32 @@ int lbs_process_rx_command(struct lbs_private *priv)
} }
__lbs_cleanup_and_insert_cmd(priv, adapter->cur_cmd); __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
ret = -1; ret = -1;
goto done; goto done;
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
if (adapter->cur_cmd && adapter->cur_cmd->callback) if (priv->cur_cmd && priv->cur_cmd->callback)
ret = adapter->cur_cmd->callback(respcmd, resp, priv); ret = priv->cur_cmd->callback(respcmd, resp, priv);
else else
ret = handle_cmd_response(respcmd, resp, priv); ret = handle_cmd_response(respcmd, resp, priv);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
if (adapter->cur_cmd) { if (priv->cur_cmd) {
/* Clean up and Put current command back to cmdfreeq */ /* Clean up and Put current command back to cmdfreeq */
__lbs_cleanup_and_insert_cmd(priv, adapter->cur_cmd); __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
} }
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
done: done:
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
return ret; return ret;
} }
@ -902,14 +883,13 @@ done:
int lbs_process_event(struct lbs_private *priv) int lbs_process_event(struct lbs_private *priv)
{ {
int ret = 0; int ret = 0;
struct lbs_adapter *adapter = priv->adapter;
u32 eventcause; u32 eventcause;
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
spin_lock_irq(&adapter->driver_lock); spin_lock_irq(&priv->driver_lock);
eventcause = adapter->eventcause >> SBI_EVENT_CAUSE_SHIFT; eventcause = priv->eventcause >> SBI_EVENT_CAUSE_SHIFT;
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_deb_cmd("event cause %d\n", eventcause); lbs_deb_cmd("event cause %d\n", eventcause);
@ -937,14 +917,14 @@ int lbs_process_event(struct lbs_private *priv)
lbs_deb_cmd("EVENT: sleep\n"); lbs_deb_cmd("EVENT: sleep\n");
/* handle unexpected PS SLEEP event */ /* handle unexpected PS SLEEP event */
if (adapter->psstate == PS_STATE_FULL_POWER) { if (priv->psstate == PS_STATE_FULL_POWER) {
lbs_deb_cmd( lbs_deb_cmd(
"EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n"); "EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n");
break; break;
} }
adapter->psstate = PS_STATE_PRE_SLEEP; priv->psstate = PS_STATE_PRE_SLEEP;
lbs_ps_confirm_sleep(priv, (u16) adapter->psmode); lbs_ps_confirm_sleep(priv, (u16) priv->psmode);
break; break;
@ -952,19 +932,19 @@ int lbs_process_event(struct lbs_private *priv)
lbs_deb_cmd("EVENT: awake\n"); lbs_deb_cmd("EVENT: awake\n");
/* handle unexpected PS AWAKE event */ /* handle unexpected PS AWAKE event */
if (adapter->psstate == PS_STATE_FULL_POWER) { if (priv->psstate == PS_STATE_FULL_POWER) {
lbs_deb_cmd( lbs_deb_cmd(
"EVENT: In FULL POWER mode - ignore PS AWAKE\n"); "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
break; break;
} }
adapter->psstate = PS_STATE_AWAKE; priv->psstate = PS_STATE_AWAKE;
if (adapter->needtowakeup) { if (priv->needtowakeup) {
/* /*
* wait for the command processing to finish * wait for the command processing to finish
* before resuming sending * before resuming sending
* adapter->needtowakeup will be set to FALSE * priv->needtowakeup will be set to FALSE
* in lbs_ps_wakeup() * in lbs_ps_wakeup()
*/ */
lbs_deb_cmd("waking up ...\n"); lbs_deb_cmd("waking up ...\n");
@ -1012,12 +992,12 @@ int lbs_process_event(struct lbs_private *priv)
break; break;
} }
lbs_pr_info("EVENT: MESH_AUTO_STARTED\n"); lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
adapter->mesh_connect_status = LBS_CONNECTED; priv->mesh_connect_status = LBS_CONNECTED;
if (priv->mesh_open == 1) { if (priv->mesh_open == 1) {
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
} }
adapter->mode = IW_MODE_ADHOC; priv->mode = IW_MODE_ADHOC;
schedule_work(&priv->sync_channel); schedule_work(&priv->sync_channel);
break; break;
@ -1026,9 +1006,9 @@ int lbs_process_event(struct lbs_private *priv)
break; break;
} }
spin_lock_irq(&adapter->driver_lock); spin_lock_irq(&priv->driver_lock);
adapter->eventcause = 0; priv->eventcause = 0;
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
return ret; return ret;

56
drivers/net/wireless/libertas/debugfs.c
View File

@ -45,9 +45,9 @@ static ssize_t lbs_dev_info(struct file *file, char __user *userbuf,
ssize_t res; ssize_t res;
pos += snprintf(buf+pos, len-pos, "state = %s\n", pos += snprintf(buf+pos, len-pos, "state = %s\n",
szStates[priv->adapter->connect_status]); szStates[priv->connect_status]);
pos += snprintf(buf+pos, len-pos, "region_code = %02x\n", pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
(u32) priv->adapter->regioncode); (u32) priv->regioncode);
res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
@ -70,8 +70,8 @@ static ssize_t lbs_getscantable(struct file *file, char __user *userbuf,
pos += snprintf(buf+pos, len-pos, pos += snprintf(buf+pos, len-pos,
"# | ch | rssi | bssid | cap | Qual | SSID \n"); "# | ch | rssi | bssid | cap | Qual | SSID \n");
mutex_lock(&priv->adapter->lock); mutex_lock(&priv->lock);
list_for_each_entry (iter_bss, &priv->adapter->network_list, list) { list_for_each_entry (iter_bss, &priv->network_list, list) {
u16 ibss = (iter_bss->capability & WLAN_CAPABILITY_IBSS); u16 ibss = (iter_bss->capability & WLAN_CAPABILITY_IBSS);
u16 privacy = (iter_bss->capability & WLAN_CAPABILITY_PRIVACY); u16 privacy = (iter_bss->capability & WLAN_CAPABILITY_PRIVACY);
u16 spectrum_mgmt = (iter_bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT); u16 spectrum_mgmt = (iter_bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT);
@ -90,7 +90,7 @@ static ssize_t lbs_getscantable(struct file *file, char __user *userbuf,
numscansdone++; numscansdone++;
} }
mutex_unlock(&priv->adapter->lock); mutex_unlock(&priv->lock);
res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
@ -118,12 +118,12 @@ static ssize_t lbs_sleepparams_write(struct file *file,
res = -EFAULT; res = -EFAULT;
goto out_unlock; goto out_unlock;
} }
priv->adapter->sp.sp_error = p1; priv->sp.sp_error = p1;
priv->adapter->sp.sp_offset = p2; priv->sp.sp_offset = p2;
priv->adapter->sp.sp_stabletime = p3; priv->sp.sp_stabletime = p3;
priv->adapter->sp.sp_calcontrol = p4; priv->sp.sp_calcontrol = p4;
priv->adapter->sp.sp_extsleepclk = p5; priv->sp.sp_extsleepclk = p5;
priv->adapter->sp.sp_reserved = p6; priv->sp.sp_reserved = p6;
res = lbs_prepare_and_send_command(priv, res = lbs_prepare_and_send_command(priv,
CMD_802_11_SLEEP_PARAMS, CMD_802_11_SLEEP_PARAMS,
@ -144,7 +144,6 @@ static ssize_t lbs_sleepparams_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct lbs_private *priv = file->private_data; struct lbs_private *priv = file->private_data;
struct lbs_adapter *adapter = priv->adapter;
ssize_t res; ssize_t res;
size_t pos = 0; size_t pos = 0;
unsigned long addr = get_zeroed_page(GFP_KERNEL); unsigned long addr = get_zeroed_page(GFP_KERNEL);
@ -159,10 +158,10 @@ static ssize_t lbs_sleepparams_read(struct file *file, char __user *userbuf,
goto out_unlock; goto out_unlock;
} }
pos += snprintf(buf, len, "%d %d %d %d %d %d\n", adapter->sp.sp_error, pos += snprintf(buf, len, "%d %d %d %d %d %d\n", priv->sp.sp_error,
adapter->sp.sp_offset, adapter->sp.sp_stabletime, priv->sp.sp_offset, priv->sp.sp_stabletime,
adapter->sp.sp_calcontrol, adapter->sp.sp_extsleepclk, priv->sp.sp_calcontrol, priv->sp.sp_extsleepclk,
adapter->sp.sp_reserved); priv->sp.sp_reserved);
res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
@ -321,11 +320,11 @@ static ssize_t lbs_setuserscan(struct file *file,
lbs_parse_type(buf, count, scan_cfg); lbs_parse_type(buf, count, scan_cfg);
lbs_scan_networks(priv, scan_cfg, 1); lbs_scan_networks(priv, scan_cfg, 1);
wait_event_interruptible(priv->adapter->cmd_pending, wait_event_interruptible(priv->cmd_pending,
priv->adapter->surpriseremoved || priv->surpriseremoved ||
(!priv->adapter->cur_cmd && list_empty(&priv->adapter->cmdpendingq))); (!priv->cur_cmd && list_empty(&priv->cmdpendingq)));
if (priv->adapter->surpriseremoved) if (priv->surpriseremoved)
goto out_scan_cfg; goto out_scan_cfg;
memset(&wrqu, 0x00, sizeof(union iwreq_data)); memset(&wrqu, 0x00, sizeof(union iwreq_data));
@ -620,7 +619,6 @@ static ssize_t lbs_rdmac_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct lbs_private *priv = file->private_data; struct lbs_private *priv = file->private_data;
struct lbs_adapter *adapter = priv->adapter;
struct lbs_offset_value offval; struct lbs_offset_value offval;
ssize_t pos = 0; ssize_t pos = 0;
int ret; int ret;
@ -635,7 +633,7 @@ static ssize_t lbs_rdmac_read(struct file *file, char __user *userbuf,
CMD_OPTION_WAITFORRSP, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n", pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
priv->mac_offset, adapter->offsetvalue.value); priv->mac_offset, priv->offsetvalue.value);
ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
free_page(addr); free_page(addr);
@ -703,7 +701,6 @@ static ssize_t lbs_rdbbp_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct lbs_private *priv = file->private_data; struct lbs_private *priv = file->private_data;
struct lbs_adapter *adapter = priv->adapter;
struct lbs_offset_value offval; struct lbs_offset_value offval;
ssize_t pos = 0; ssize_t pos = 0;
int ret; int ret;
@ -718,7 +715,7 @@ static ssize_t lbs_rdbbp_read(struct file *file, char __user *userbuf,
CMD_OPTION_WAITFORRSP, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n", pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
priv->bbp_offset, adapter->offsetvalue.value); priv->bbp_offset, priv->offsetvalue.value);
ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
free_page(addr); free_page(addr);
@ -787,7 +784,6 @@ static ssize_t lbs_rdrf_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct lbs_private *priv = file->private_data; struct lbs_private *priv = file->private_data;
struct lbs_adapter *adapter = priv->adapter;
struct lbs_offset_value offval; struct lbs_offset_value offval;
ssize_t pos = 0; ssize_t pos = 0;
int ret; int ret;
@ -802,7 +798,7 @@ static ssize_t lbs_rdrf_read(struct file *file, char __user *userbuf,
CMD_OPTION_WAITFORRSP, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n", pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
priv->rf_offset, adapter->offsetvalue.value); priv->rf_offset, priv->offsetvalue.value);
ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
free_page(addr); free_page(addr);
@ -1009,8 +1005,8 @@ void lbs_debugfs_remove_one(struct lbs_private *priv)
#ifdef PROC_DEBUG #ifdef PROC_DEBUG
#define item_size(n) (FIELD_SIZEOF(struct lbs_adapter, n)) #define item_size(n) (FIELD_SIZEOF(struct lbs_private, n))
#define item_addr(n) (offsetof(struct lbs_adapter, n)) #define item_addr(n) (offsetof(struct lbs_private, n))
struct debug_data { struct debug_data {
@ -1019,7 +1015,7 @@ struct debug_data {
size_t addr; size_t addr;
}; };
/* To debug any member of struct lbs_adapter, simply add one line here. /* To debug any member of struct lbs_private, simply add one line here.
*/ */
static struct debug_data items[] = { static struct debug_data items[] = {
{"intcounter", item_size(intcounter), item_addr(intcounter)}, {"intcounter", item_size(intcounter), item_addr(intcounter)},
@ -1158,7 +1154,7 @@ static void lbs_debug_init(struct lbs_private *priv, struct net_device *dev)
return; return;
for (i = 0; i < num_of_items; i++) for (i = 0; i < num_of_items; i++)
items[i].addr += (size_t) priv->adapter; items[i].addr += (size_t) priv;
priv->debugfs_debug = debugfs_create_file("debug", 0644, priv->debugfs_debug = debugfs_create_file("debug", 0644,
priv->debugfs_dir, &items[0], priv->debugfs_dir, &items[0],

7
drivers/net/wireless/libertas/decl.h
View File

@ -12,7 +12,6 @@
/** Function Prototype Declaration */ /** Function Prototype Declaration */
struct lbs_private; struct lbs_private;
struct lbs_adapter;
struct sk_buff; struct sk_buff;
struct net_device; struct net_device;
struct cmd_ctrl_node; struct cmd_ctrl_node;
@ -32,7 +31,7 @@ int lbs_prepare_and_send_command(struct lbs_private *priv,
u16 cmd_action, u16 cmd_action,
u16 wait_option, u32 cmd_oid, void *pdata_buf); u16 wait_option, u32 cmd_oid, void *pdata_buf);
void lbs_queue_cmd(struct lbs_adapter *adapter, void lbs_queue_cmd(struct lbs_private *priv,
struct cmd_ctrl_node *cmdnode, struct cmd_ctrl_node *cmdnode,
u8 addtail); u8 addtail);
@ -43,7 +42,7 @@ void lbs_interrupt(struct net_device *);
int lbs_set_radio_control(struct lbs_private *priv); int lbs_set_radio_control(struct lbs_private *priv);
u32 lbs_fw_index_to_data_rate(u8 index); u32 lbs_fw_index_to_data_rate(u8 index);
u8 lbs_data_rate_to_fw_index(u32 rate); u8 lbs_data_rate_to_fw_index(u32 rate);
void lbs_get_fwversion(struct lbs_adapter *adapter, void lbs_get_fwversion(struct lbs_private *priv,
char *fwversion, char *fwversion,
int maxlen); int maxlen);
@ -66,7 +65,7 @@ void lbs_ps_wakeup(struct lbs_private *priv, int wait_option);
void lbs_tx_runqueue(struct lbs_private *priv); void lbs_tx_runqueue(struct lbs_private *priv);
struct chan_freq_power *lbs_find_cfp_by_band_and_channel( struct chan_freq_power *lbs_find_cfp_by_band_and_channel(
struct lbs_adapter *adapter, struct lbs_private *priv,
u8 band, u8 band,
u16 channel); u16 channel);

95
drivers/net/wireless/libertas/dev.h
View File

@ -1,7 +1,7 @@
/** /**
* This file contains definitions and data structures specific * This file contains definitions and data structures specific
* to Marvell 802.11 NIC. It contains the Device Information * to Marvell 802.11 NIC. It contains the Device Information
* structure struct lbs_adapter. * structure struct lbs_private..
*/ */
#ifndef _LBS_DEV_H_ #ifndef _LBS_DEV_H_
#define _LBS_DEV_H_ #define _LBS_DEV_H_
@ -109,7 +109,6 @@ struct lbs_private {
char name[DEV_NAME_LEN]; char name[DEV_NAME_LEN];
void *card; void *card;
struct lbs_adapter *adapter;
struct net_device *dev; struct net_device *dev;
struct net_device_stats stats; struct net_device_stats stats;
@ -156,54 +155,10 @@ struct lbs_private {
int (*hw_host_to_card) (struct lbs_private *priv, u8 type, u8 *payload, u16 nb); int (*hw_host_to_card) (struct lbs_private *priv, u8 type, u8 *payload, u16 nb);
int (*hw_get_int_status) (struct lbs_private *priv, u8 *); int (*hw_get_int_status) (struct lbs_private *priv, u8 *);
int (*hw_read_event_cause) (struct lbs_private *); int (*hw_read_event_cause) (struct lbs_private *);
};
/** Association request /* was struct lbs_adapter from here... */
*
* Encapsulates all the options that describe a specific assocation request
* or configuration of the wireless card's radio, mode, and security settings.
*/
struct assoc_request {
#define ASSOC_FLAG_SSID 1
#define ASSOC_FLAG_CHANNEL 2
#define ASSOC_FLAG_BAND 3
#define ASSOC_FLAG_MODE 4
#define ASSOC_FLAG_BSSID 5
#define ASSOC_FLAG_WEP_KEYS 6
#define ASSOC_FLAG_WEP_TX_KEYIDX 7
#define ASSOC_FLAG_WPA_MCAST_KEY 8
#define ASSOC_FLAG_WPA_UCAST_KEY 9
#define ASSOC_FLAG_SECINFO 10
#define ASSOC_FLAG_WPA_IE 11
unsigned long flags;
u8 ssid[IW_ESSID_MAX_SIZE + 1];
u8 ssid_len;
u8 channel;
u8 band;
u8 mode;
u8 bssid[ETH_ALEN];
/** WEP keys */
struct enc_key wep_keys[4];
u16 wep_tx_keyidx;
/** WPA keys */
struct enc_key wpa_mcast_key;
struct enc_key wpa_unicast_key;
struct lbs_802_11_security secinfo;
/** WPA Information Elements*/
u8 wpa_ie[MAX_WPA_IE_LEN];
u8 wpa_ie_len;
/* BSS to associate with for infrastructure of Ad-Hoc join */
struct bss_descriptor bss;
};
/** Wlan adapter data structure*/ /** Wlan adapter data structure*/
struct lbs_adapter {
/** STATUS variables */ /** STATUS variables */
u8 fwreleasenumber[4]; u8 fwreleasenumber[4];
u32 fwcapinfo; u32 fwcapinfo;
@ -229,7 +184,7 @@ struct lbs_adapter {
struct list_head cmdpendingq; struct list_head cmdpendingq;
wait_queue_head_t cmd_pending; wait_queue_head_t cmd_pending;
/* command related variables protected by adapter->driver_lock */ /* command related variables protected by priv->driver_lock */
/** Async and Sync Event variables */ /** Async and Sync Event variables */
u32 intcounter; u32 intcounter;
@ -366,4 +321,48 @@ struct lbs_adapter {
u8 fw_ready; u8 fw_ready;
}; };
/** Association request
*
* Encapsulates all the options that describe a specific assocation request
* or configuration of the wireless card's radio, mode, and security settings.
*/
struct assoc_request {
#define ASSOC_FLAG_SSID 1
#define ASSOC_FLAG_CHANNEL 2
#define ASSOC_FLAG_BAND 3
#define ASSOC_FLAG_MODE 4
#define ASSOC_FLAG_BSSID 5
#define ASSOC_FLAG_WEP_KEYS 6
#define ASSOC_FLAG_WEP_TX_KEYIDX 7
#define ASSOC_FLAG_WPA_MCAST_KEY 8
#define ASSOC_FLAG_WPA_UCAST_KEY 9
#define ASSOC_FLAG_SECINFO 10
#define ASSOC_FLAG_WPA_IE 11
unsigned long flags;
u8 ssid[IW_ESSID_MAX_SIZE + 1];
u8 ssid_len;
u8 channel;
u8 band;
u8 mode;
u8 bssid[ETH_ALEN];
/** WEP keys */
struct enc_key wep_keys[4];
u16 wep_tx_keyidx;
/** WPA keys */
struct enc_key wpa_mcast_key;
struct enc_key wpa_unicast_key;
struct lbs_802_11_security secinfo;
/** WPA Information Elements*/
u8 wpa_ie[MAX_WPA_IE_LEN];
u8 wpa_ie_len;
/* BSS to associate with for infrastructure of Ad-Hoc join */
struct bss_descriptor bss;
};
#endif #endif

19
drivers/net/wireless/libertas/ethtool.c
View File

@ -25,7 +25,7 @@ static void lbs_ethtool_get_drvinfo(struct net_device *dev,
struct lbs_private *priv = (struct lbs_private *) dev->priv; struct lbs_private *priv = (struct lbs_private *) dev->priv;
char fwver[32]; char fwver[32];
lbs_get_fwversion(priv->adapter, fwver, sizeof(fwver) - 1); lbs_get_fwversion(priv, fwver, sizeof(fwver) - 1);
strcpy(info->driver, "libertas"); strcpy(info->driver, "libertas");
strcpy(info->version, lbs_driver_version); strcpy(info->version, lbs_driver_version);
@ -46,7 +46,6 @@ static int lbs_ethtool_get_eeprom(struct net_device *dev,
struct ethtool_eeprom *eeprom, u8 * bytes) struct ethtool_eeprom *eeprom, u8 * bytes)
{ {
struct lbs_private *priv = (struct lbs_private *) dev->priv; struct lbs_private *priv = (struct lbs_private *) dev->priv;
struct lbs_adapter *adapter = priv->adapter;
struct lbs_ioctl_regrdwr regctrl; struct lbs_ioctl_regrdwr regctrl;
char *ptr; char *ptr;
int ret; int ret;
@ -60,10 +59,10 @@ static int lbs_ethtool_get_eeprom(struct net_device *dev,
// mutex_lock(&priv->mutex); // mutex_lock(&priv->mutex);
adapter->prdeeprom = kmalloc(eeprom->len+sizeof(regctrl), GFP_KERNEL); priv->prdeeprom = kmalloc(eeprom->len+sizeof(regctrl), GFP_KERNEL);
if (!adapter->prdeeprom) if (!priv->prdeeprom)
return -ENOMEM; return -ENOMEM;
memcpy(adapter->prdeeprom, &regctrl, sizeof(regctrl)); memcpy(priv->prdeeprom, &regctrl, sizeof(regctrl));
/* +14 is for action, offset, and NOB in /* +14 is for action, offset, and NOB in
* response */ * response */
@ -77,14 +76,14 @@ static int lbs_ethtool_get_eeprom(struct net_device *dev,
&regctrl); &regctrl);
if (ret) { if (ret) {
if (adapter->prdeeprom) if (priv->prdeeprom)
kfree(adapter->prdeeprom); kfree(priv->prdeeprom);
goto done; goto done;
} }
mdelay(10); mdelay(10);
ptr = (char *)adapter->prdeeprom; ptr = (char *)priv->prdeeprom;
/* skip the command header, but include the "value" u32 variable */ /* skip the command header, but include the "value" u32 variable */
ptr = ptr + sizeof(struct lbs_ioctl_regrdwr) - 4; ptr = ptr + sizeof(struct lbs_ioctl_regrdwr) - 4;
@ -94,8 +93,8 @@ static int lbs_ethtool_get_eeprom(struct net_device *dev,
*/ */
memcpy(bytes, ptr, eeprom->len); memcpy(bytes, ptr, eeprom->len);
if (adapter->prdeeprom) if (priv->prdeeprom)
kfree(adapter->prdeeprom); kfree(priv->prdeeprom);
// mutex_unlock(&priv->mutex); // mutex_unlock(&priv->mutex);
ret = 0; ret = 0;

21
drivers/net/wireless/libertas/if_cs.c
View File

@ -255,7 +255,7 @@ static irqreturn_t if_cs_interrupt(int irq, void *data)
} else if (int_cause == 0xffff) { } else if (int_cause == 0xffff) {
/* Read in junk, the card has probably been removed */ /* Read in junk, the card has probably been removed */
card->priv->adapter->surpriseremoved = 1; card->priv->surpriseremoved = 1;
} else { } else {
if (int_cause & IF_CS_H_IC_TX_OVER) if (int_cause & IF_CS_H_IC_TX_OVER)
@ -644,7 +644,6 @@ static int if_cs_host_to_card(struct lbs_private *priv,
static int if_cs_get_int_status(struct lbs_private *priv, u8 *ireg) static int if_cs_get_int_status(struct lbs_private *priv, u8 *ireg)
{ {
struct if_cs_card *card = (struct if_cs_card *)priv->card; struct if_cs_card *card = (struct if_cs_card *)priv->card;
/* struct lbs_adapter *adapter = priv->adapter; */
int ret = 0; int ret = 0;
u16 int_cause; u16 int_cause;
u8 *cmdbuf; u8 *cmdbuf;
@ -652,7 +651,7 @@ static int if_cs_get_int_status(struct lbs_private *priv, u8 *ireg)
lbs_deb_enter(LBS_DEB_CS); lbs_deb_enter(LBS_DEB_CS);
if (priv->adapter->surpriseremoved) if (priv->surpriseremoved)
goto out; goto out;
int_cause = if_cs_read16(card, IF_CS_C_INT_CAUSE) & IF_CS_C_IC_MASK; int_cause = if_cs_read16(card, IF_CS_C_INT_CAUSE) & IF_CS_C_IC_MASK;
@ -678,22 +677,22 @@ sbi_get_int_status_exit:
/* Card has a command result for us */ /* Card has a command result for us */
if (*ireg & IF_CS_C_S_CMD_UPLD_RDY) { if (*ireg & IF_CS_C_S_CMD_UPLD_RDY) {
spin_lock(&priv->adapter->driver_lock); spin_lock(&priv->driver_lock);
if (!priv->adapter->cur_cmd) { if (!priv->cur_cmd) {
cmdbuf = priv->upld_buf; cmdbuf = priv->upld_buf;
priv->adapter->hisregcpy &= ~IF_CS_C_S_RX_UPLD_RDY; priv->hisregcpy &= ~IF_CS_C_S_RX_UPLD_RDY;
} else { } else {
cmdbuf = priv->adapter->cur_cmd->bufvirtualaddr; cmdbuf = priv->cur_cmd->bufvirtualaddr;
} }
ret = if_cs_receive_cmdres(priv, cmdbuf, &priv->upld_len); ret = if_cs_receive_cmdres(priv, cmdbuf, &priv->upld_len);
spin_unlock(&priv->adapter->driver_lock); spin_unlock(&priv->driver_lock);
if (ret < 0) if (ret < 0)
lbs_pr_err("could not receive cmd from card\n"); lbs_pr_err("could not receive cmd from card\n");
} }
out: out:
lbs_deb_leave_args(LBS_DEB_CS, "ret %d, ireg 0x%x, hisregcpy 0x%x", ret, *ireg, priv->adapter->hisregcpy); lbs_deb_leave_args(LBS_DEB_CS, "ret %d, ireg 0x%x, hisregcpy 0x%x", ret, *ireg, priv->hisregcpy);
return ret; return ret;
} }
@ -702,7 +701,7 @@ static int if_cs_read_event_cause(struct lbs_private *priv)
{ {
lbs_deb_enter(LBS_DEB_CS); lbs_deb_enter(LBS_DEB_CS);
priv->adapter->eventcause = (if_cs_read16(priv->card, IF_CS_C_STATUS) & IF_CS_C_S_STATUS_MASK) >> 5; priv->eventcause = (if_cs_read16(priv->card, IF_CS_C_STATUS) & IF_CS_C_S_STATUS_MASK) >> 5;
if_cs_write16(priv->card, IF_CS_H_INT_CAUSE, IF_CS_H_IC_HOST_EVENT); if_cs_write16(priv->card, IF_CS_H_INT_CAUSE, IF_CS_H_IC_HOST_EVENT);
return 0; return 0;
@ -869,7 +868,7 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
priv->hw_get_int_status = if_cs_get_int_status; priv->hw_get_int_status = if_cs_get_int_status;
priv->hw_read_event_cause = if_cs_read_event_cause; priv->hw_read_event_cause = if_cs_read_event_cause;
priv->adapter->fw_ready = 1; priv->fw_ready = 1;
/* Now actually get the IRQ */ /* Now actually get the IRQ */
ret = request_irq(p_dev->irq.AssignedIRQ, if_cs_interrupt, ret = request_irq(p_dev->irq.AssignedIRQ, if_cs_interrupt,

20
drivers/net/wireless/libertas/if_sdio.c
View File

@ -134,9 +134,9 @@ static int if_sdio_handle_cmd(struct if_sdio_card *card,
lbs_deb_enter(LBS_DEB_SDIO); lbs_deb_enter(LBS_DEB_SDIO);
spin_lock_irqsave(&card->priv->adapter->driver_lock, flags); spin_lock_irqsave(&card->priv->driver_lock, flags);
if (!card->priv->adapter->cur_cmd) { if (!card->priv->cur_cmd) {
lbs_deb_sdio("discarding spurious response\n"); lbs_deb_sdio("discarding spurious response\n");
ret = 0; ret = 0;
goto out; goto out;
@ -149,7 +149,7 @@ static int if_sdio_handle_cmd(struct if_sdio_card *card,
goto out; goto out;
} }
memcpy(card->priv->adapter->cur_cmd->bufvirtualaddr, buffer, size); memcpy(card->priv->cur_cmd->bufvirtualaddr, buffer, size);
card->priv->upld_len = size; card->priv->upld_len = size;
card->int_cause |= MRVDRV_CMD_UPLD_RDY; card->int_cause |= MRVDRV_CMD_UPLD_RDY;
@ -159,7 +159,7 @@ static int if_sdio_handle_cmd(struct if_sdio_card *card,
ret = 0; ret = 0;
out: out:
spin_unlock_irqrestore(&card->priv->adapter->driver_lock, flags); spin_unlock_irqrestore(&card->priv->driver_lock, flags);
lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
@ -231,14 +231,14 @@ static int if_sdio_handle_event(struct if_sdio_card *card,
event <<= SBI_EVENT_CAUSE_SHIFT; event <<= SBI_EVENT_CAUSE_SHIFT;
} }
spin_lock_irqsave(&card->priv->adapter->driver_lock, flags); spin_lock_irqsave(&card->priv->driver_lock, flags);
card->event = event; card->event = event;
card->int_cause |= MRVDRV_CARDEVENT; card->int_cause |= MRVDRV_CARDEVENT;
lbs_interrupt(card->priv->dev); lbs_interrupt(card->priv->dev);
spin_unlock_irqrestore(&card->priv->adapter->driver_lock, flags); spin_unlock_irqrestore(&card->priv->driver_lock, flags);
ret = 0; ret = 0;
@ -800,7 +800,7 @@ static int if_sdio_read_event_cause(struct lbs_private *priv)
card = priv->card; card = priv->card;
priv->adapter->eventcause = card->event; priv->eventcause = card->event;
lbs_deb_leave(LBS_DEB_SDIO); lbs_deb_leave(LBS_DEB_SDIO);
@ -962,7 +962,7 @@ static int if_sdio_probe(struct sdio_func *func,
priv->hw_get_int_status = if_sdio_get_int_status; priv->hw_get_int_status = if_sdio_get_int_status;
priv->hw_read_event_cause = if_sdio_read_event_cause; priv->hw_read_event_cause = if_sdio_read_event_cause;
priv->adapter->fw_ready = 1; priv->fw_ready = 1;
/* /*
* Enable interrupts now that everything is set up * Enable interrupts now that everything is set up
@ -985,7 +985,7 @@ out:
err_activate_card: err_activate_card:
flush_scheduled_work(); flush_scheduled_work();
free_netdev(priv->dev); free_netdev(priv->dev);
kfree(priv->adapter); kfree(priv);
reclaim: reclaim:
sdio_claim_host(func); sdio_claim_host(func);
release_int: release_int:
@ -1015,7 +1015,7 @@ static void if_sdio_remove(struct sdio_func *func)
card = sdio_get_drvdata(func); card = sdio_get_drvdata(func);
card->priv->adapter->surpriseremoved = 1; card->priv->surpriseremoved = 1;
lbs_deb_sdio("call remove card\n"); lbs_deb_sdio("call remove card\n");
lbs_stop_card(card->priv); lbs_stop_card(card->priv);

27
drivers/net/wireless/libertas/if_usb.c
View File

@ -229,7 +229,7 @@ static int if_usb_probe(struct usb_interface *intf,
/* Delay 200 ms to waiting for the FW ready */ /* Delay 200 ms to waiting for the FW ready */
if_usb_submit_rx_urb(cardp); if_usb_submit_rx_urb(cardp);
msleep_interruptible(200); msleep_interruptible(200);
priv->adapter->fw_ready = 1; priv->fw_ready = 1;
if (lbs_start_card(priv)) if (lbs_start_card(priv))
goto err_start_card; goto err_start_card;
@ -270,9 +270,8 @@ static void if_usb_disconnect(struct usb_interface *intf)
cardp->surprise_removed = 1; cardp->surprise_removed = 1;
if (priv) { if (priv) {
struct lbs_adapter *adapter = priv->adapter;
adapter->surpriseremoved = 1; priv->surpriseremoved = 1;
lbs_stop_card(priv); lbs_stop_card(priv);
lbs_remove_mesh(priv); lbs_remove_mesh(priv);
lbs_remove_card(priv); lbs_remove_card(priv);
@ -609,14 +608,14 @@ static inline void process_cmdrequest(int recvlength, u8 *recvbuff,
if (!in_interrupt()) if (!in_interrupt())
BUG(); BUG();
spin_lock(&priv->adapter->driver_lock); spin_lock(&priv->driver_lock);
/* take care of cur_cmd = NULL case by reading the /* take care of cur_cmd = NULL case by reading the
* data to clear the interrupt */ * data to clear the interrupt */
if (!priv->adapter->cur_cmd) { if (!priv->cur_cmd) {
cmdbuf = priv->upld_buf; cmdbuf = priv->upld_buf;
priv->adapter->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; priv->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY;
} else } else
cmdbuf = priv->adapter->cur_cmd->bufvirtualaddr; cmdbuf = priv->cur_cmd->bufvirtualaddr;
cardp->usb_int_cause |= MRVDRV_CMD_UPLD_RDY; cardp->usb_int_cause |= MRVDRV_CMD_UPLD_RDY;
priv->upld_len = (recvlength - MESSAGE_HEADER_LEN); priv->upld_len = (recvlength - MESSAGE_HEADER_LEN);
@ -625,7 +624,7 @@ static inline void process_cmdrequest(int recvlength, u8 *recvbuff,
kfree_skb(skb); kfree_skb(skb);
lbs_interrupt(priv->dev); lbs_interrupt(priv->dev);
spin_unlock(&priv->adapter->driver_lock); spin_unlock(&priv->driver_lock);
lbs_deb_usbd(&cardp->udev->dev, lbs_deb_usbd(&cardp->udev->dev,
"Wake up main thread to handle cmd response\n"); "Wake up main thread to handle cmd response\n");
@ -685,20 +684,20 @@ static void if_usb_receive(struct urb *urb)
case CMD_TYPE_INDICATION: case CMD_TYPE_INDICATION:
/* Event cause handling */ /* Event cause handling */
spin_lock(&priv->adapter->driver_lock); spin_lock(&priv->driver_lock);
cardp->usb_event_cause = le32_to_cpu(*(__le32 *) (recvbuff + MESSAGE_HEADER_LEN)); cardp->usb_event_cause = le32_to_cpu(*(__le32 *) (recvbuff + MESSAGE_HEADER_LEN));
lbs_deb_usbd(&cardp->udev->dev,"**EVENT** 0x%X\n", lbs_deb_usbd(&cardp->udev->dev,"**EVENT** 0x%X\n",
cardp->usb_event_cause); cardp->usb_event_cause);
if (cardp->usb_event_cause & 0xffff0000) { if (cardp->usb_event_cause & 0xffff0000) {
lbs_send_tx_feedback(priv); lbs_send_tx_feedback(priv);
spin_unlock(&priv->adapter->driver_lock); spin_unlock(&priv->driver_lock);
break; break;
} }
cardp->usb_event_cause <<= 3; cardp->usb_event_cause <<= 3;
cardp->usb_int_cause |= MRVDRV_CARDEVENT; cardp->usb_int_cause |= MRVDRV_CARDEVENT;
kfree_skb(skb); kfree_skb(skb);
lbs_interrupt(priv->dev); lbs_interrupt(priv->dev);
spin_unlock(&priv->adapter->driver_lock); spin_unlock(&priv->driver_lock);
goto rx_exit; goto rx_exit;
default: default:
lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n", lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
@ -750,7 +749,7 @@ static int if_usb_host_to_card(struct lbs_private *priv,
nb + MESSAGE_HEADER_LEN); nb + MESSAGE_HEADER_LEN);
} }
/* called with adapter->driver_lock held */ /* called with priv->driver_lock held */
static int if_usb_get_int_status(struct lbs_private *priv, u8 *ireg) static int if_usb_get_int_status(struct lbs_private *priv, u8 *ireg)
{ {
struct usb_card_rec *cardp = priv->card; struct usb_card_rec *cardp = priv->card;
@ -767,7 +766,7 @@ static int if_usb_read_event_cause(struct lbs_private *priv)
{ {
struct usb_card_rec *cardp = priv->card; struct usb_card_rec *cardp = priv->card;
priv->adapter->eventcause = cardp->usb_event_cause; priv->eventcause = cardp->usb_event_cause;
/* Re-submit rx urb here to avoid event lost issue */ /* Re-submit rx urb here to avoid event lost issue */
if_usb_submit_rx_urb(cardp); if_usb_submit_rx_urb(cardp);
return 0; return 0;
@ -942,7 +941,7 @@ static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
lbs_deb_enter(LBS_DEB_USB); lbs_deb_enter(LBS_DEB_USB);
if (priv->adapter->psstate != PS_STATE_FULL_POWER) if (priv->psstate != PS_STATE_FULL_POWER)
return -1; return -1;
if (priv->mesh_dev && !priv->mesh_autostart_enabled) { if (priv->mesh_dev && !priv->mesh_autostart_enabled) {

150
drivers/net/wireless/libertas/join.c
View File

@ -30,13 +30,13 @@
* NOTE: Setting the MSB of the basic rates need to be taken * NOTE: Setting the MSB of the basic rates need to be taken
* care, either before or after calling this function * care, either before or after calling this function
* *
* @param adapter A pointer to struct lbs_adapter structure * @param priv A pointer to struct lbs_private structure
* @param rate1 the buffer which keeps input and output * @param rate1 the buffer which keeps input and output
* @param rate1_size the size of rate1 buffer; new size of buffer on return * @param rate1_size the size of rate1 buffer; new size of buffer on return
* *
* @return 0 or -1 * @return 0 or -1
*/ */
static int get_common_rates(struct lbs_adapter *adapter, static int get_common_rates(struct lbs_private *priv,
u8 *rates, u8 *rates,
u16 *rates_size) u16 *rates_size)
{ {
@ -57,15 +57,15 @@ static int get_common_rates(struct lbs_adapter *adapter,
lbs_deb_hex(LBS_DEB_JOIN, "AP rates ", rates, *rates_size); lbs_deb_hex(LBS_DEB_JOIN, "AP rates ", rates, *rates_size);
lbs_deb_hex(LBS_DEB_JOIN, "card rates ", card_rates, num_card_rates); lbs_deb_hex(LBS_DEB_JOIN, "card rates ", card_rates, num_card_rates);
lbs_deb_hex(LBS_DEB_JOIN, "common rates", tmp, tmp_size); lbs_deb_hex(LBS_DEB_JOIN, "common rates", tmp, tmp_size);
lbs_deb_join("TX data rate 0x%02x\n", adapter->cur_rate); lbs_deb_join("TX data rate 0x%02x\n", priv->cur_rate);
if (!adapter->auto_rate) { if (!priv->auto_rate) {
for (i = 0; i < tmp_size; i++) { for (i = 0; i < tmp_size; i++) {
if (tmp[i] == adapter->cur_rate) if (tmp[i] == priv->cur_rate)
goto done; goto done;
} }
lbs_pr_alert("Previously set fixed data rate %#x isn't " lbs_pr_alert("Previously set fixed data rate %#x isn't "
"compatible with the network.\n", adapter->cur_rate); "compatible with the network.\n", priv->cur_rate);
ret = -1; ret = -1;
goto done; goto done;
} }
@ -125,7 +125,6 @@ void lbs_unset_basic_rate_flags(u8 *rates, size_t len)
*/ */
int lbs_associate(struct lbs_private *priv, struct assoc_request *assoc_req) int lbs_associate(struct lbs_private *priv, struct assoc_request *assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret; int ret;
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
@ -138,11 +137,11 @@ int lbs_associate(struct lbs_private *priv, struct assoc_request *assoc_req)
goto done; goto done;
/* set preamble to firmware */ /* set preamble to firmware */
if ( (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) if ( (priv->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
&& (assoc_req->bss.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) && (assoc_req->bss.capability & WLAN_CAPABILITY_SHORT_PREAMBLE))
adapter->preamble = CMD_TYPE_SHORT_PREAMBLE; priv->preamble = CMD_TYPE_SHORT_PREAMBLE;
else else
adapter->preamble = CMD_TYPE_LONG_PREAMBLE; priv->preamble = CMD_TYPE_LONG_PREAMBLE;
lbs_set_radio_control(priv); lbs_set_radio_control(priv);
@ -164,17 +163,16 @@ done:
int lbs_start_adhoc_network(struct lbs_private *priv, int lbs_start_adhoc_network(struct lbs_private *priv,
struct assoc_request *assoc_req) struct assoc_request *assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
adapter->adhoccreate = 1; priv->adhoccreate = 1;
if (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) { if (priv->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) {
lbs_deb_join("AdhocStart: Short preamble\n"); lbs_deb_join("AdhocStart: Short preamble\n");
adapter->preamble = CMD_TYPE_SHORT_PREAMBLE; priv->preamble = CMD_TYPE_SHORT_PREAMBLE;
} else { } else {
lbs_deb_join("AdhocStart: Long preamble\n"); lbs_deb_join("AdhocStart: Long preamble\n");
adapter->preamble = CMD_TYPE_LONG_PREAMBLE; priv->preamble = CMD_TYPE_LONG_PREAMBLE;
} }
lbs_set_radio_control(priv); lbs_set_radio_control(priv);
@ -200,26 +198,25 @@ int lbs_start_adhoc_network(struct lbs_private *priv,
int lbs_join_adhoc_network(struct lbs_private *priv, int lbs_join_adhoc_network(struct lbs_private *priv,
struct assoc_request *assoc_req) struct assoc_request *assoc_req)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct bss_descriptor * bss = &assoc_req->bss; struct bss_descriptor * bss = &assoc_req->bss;
int ret = 0; int ret = 0;
lbs_deb_join("%s: Current SSID '%s', ssid length %u\n", lbs_deb_join("%s: Current SSID '%s', ssid length %u\n",
__func__, __func__,
escape_essid(adapter->curbssparams.ssid, escape_essid(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len), priv->curbssparams.ssid_len),
adapter->curbssparams.ssid_len); priv->curbssparams.ssid_len);
lbs_deb_join("%s: requested ssid '%s', ssid length %u\n", lbs_deb_join("%s: requested ssid '%s', ssid length %u\n",
__func__, escape_essid(bss->ssid, bss->ssid_len), __func__, escape_essid(bss->ssid, bss->ssid_len),
bss->ssid_len); bss->ssid_len);
/* check if the requested SSID is already joined */ /* check if the requested SSID is already joined */
if ( adapter->curbssparams.ssid_len if ( priv->curbssparams.ssid_len
&& !lbs_ssid_cmp(adapter->curbssparams.ssid, && !lbs_ssid_cmp(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len, priv->curbssparams.ssid_len,
bss->ssid, bss->ssid_len) bss->ssid, bss->ssid_len)
&& (adapter->mode == IW_MODE_ADHOC) && (priv->mode == IW_MODE_ADHOC)
&& (adapter->connect_status == LBS_CONNECTED)) { && (priv->connect_status == LBS_CONNECTED)) {
union iwreq_data wrqu; union iwreq_data wrqu;
lbs_deb_join("ADHOC_J_CMD: New ad-hoc SSID is the same as " lbs_deb_join("ADHOC_J_CMD: New ad-hoc SSID is the same as "
@ -229,7 +226,7 @@ int lbs_join_adhoc_network(struct lbs_private *priv,
* request really was successful, even if just a null-op. * request really was successful, even if just a null-op.
*/ */
memset(&wrqu, 0, sizeof(wrqu)); memset(&wrqu, 0, sizeof(wrqu));
memcpy(wrqu.ap_addr.sa_data, adapter->curbssparams.bssid, memcpy(wrqu.ap_addr.sa_data, priv->curbssparams.bssid,
ETH_ALEN); ETH_ALEN);
wrqu.ap_addr.sa_family = ARPHRD_ETHER; wrqu.ap_addr.sa_family = ARPHRD_ETHER;
wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
@ -239,12 +236,12 @@ int lbs_join_adhoc_network(struct lbs_private *priv,
/* Use shortpreamble only when both creator and card supports /* Use shortpreamble only when both creator and card supports
short preamble */ short preamble */
if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
|| !(adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) { || !(priv->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) {
lbs_deb_join("AdhocJoin: Long preamble\n"); lbs_deb_join("AdhocJoin: Long preamble\n");
adapter->preamble = CMD_TYPE_LONG_PREAMBLE; priv->preamble = CMD_TYPE_LONG_PREAMBLE;
} else { } else {
lbs_deb_join("AdhocJoin: Short preamble\n"); lbs_deb_join("AdhocJoin: Short preamble\n");
adapter->preamble = CMD_TYPE_SHORT_PREAMBLE; priv->preamble = CMD_TYPE_SHORT_PREAMBLE;
} }
lbs_set_radio_control(priv); lbs_set_radio_control(priv);
@ -252,7 +249,7 @@ int lbs_join_adhoc_network(struct lbs_private *priv,
lbs_deb_join("AdhocJoin: channel = %d\n", assoc_req->channel); lbs_deb_join("AdhocJoin: channel = %d\n", assoc_req->channel);
lbs_deb_join("AdhocJoin: band = %c\n", assoc_req->band); lbs_deb_join("AdhocJoin: band = %c\n", assoc_req->band);
adapter->adhoccreate = 0; priv->adhoccreate = 0;
ret = lbs_prepare_and_send_command(priv, CMD_802_11_AD_HOC_JOIN, ret = lbs_prepare_and_send_command(priv, CMD_802_11_AD_HOC_JOIN,
0, CMD_OPTION_WAITFORRSP, 0, CMD_OPTION_WAITFORRSP,
@ -293,7 +290,6 @@ int lbs_cmd_80211_authenticate(struct lbs_private *priv,
struct cmd_ds_command *cmd, struct cmd_ds_command *cmd,
void *pdata_buf) void *pdata_buf)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_authenticate *pauthenticate = &cmd->params.auth; struct cmd_ds_802_11_authenticate *pauthenticate = &cmd->params.auth;
int ret = -1; int ret = -1;
u8 *bssid = pdata_buf; u8 *bssid = pdata_buf;
@ -306,7 +302,7 @@ int lbs_cmd_80211_authenticate(struct lbs_private *priv,
+ S_DS_GEN); + S_DS_GEN);
/* translate auth mode to 802.11 defined wire value */ /* translate auth mode to 802.11 defined wire value */
switch (adapter->secinfo.auth_mode) { switch (priv->secinfo.auth_mode) {
case IW_AUTH_ALG_OPEN_SYSTEM: case IW_AUTH_ALG_OPEN_SYSTEM:
pauthenticate->authtype = 0x00; pauthenticate->authtype = 0x00;
break; break;
@ -318,7 +314,7 @@ int lbs_cmd_80211_authenticate(struct lbs_private *priv,
break; break;
default: default:
lbs_deb_join("AUTH_CMD: invalid auth alg 0x%X\n", lbs_deb_join("AUTH_CMD: invalid auth alg 0x%X\n",
adapter->secinfo.auth_mode); priv->secinfo.auth_mode);
goto out; goto out;
} }
@ -336,7 +332,6 @@ out:
int lbs_cmd_80211_deauthenticate(struct lbs_private *priv, int lbs_cmd_80211_deauthenticate(struct lbs_private *priv,
struct cmd_ds_command *cmd) struct cmd_ds_command *cmd)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_deauthenticate *dauth = &cmd->params.deauth; struct cmd_ds_802_11_deauthenticate *dauth = &cmd->params.deauth;
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
@ -346,7 +341,7 @@ int lbs_cmd_80211_deauthenticate(struct lbs_private *priv,
S_DS_GEN); S_DS_GEN);
/* set AP MAC address */ /* set AP MAC address */
memmove(dauth->macaddr, adapter->curbssparams.bssid, ETH_ALEN); memmove(dauth->macaddr, priv->curbssparams.bssid, ETH_ALEN);
/* Reason code 3 = Station is leaving */ /* Reason code 3 = Station is leaving */
#define REASON_CODE_STA_LEAVING 3 #define REASON_CODE_STA_LEAVING 3
@ -359,7 +354,6 @@ int lbs_cmd_80211_deauthenticate(struct lbs_private *priv,
int lbs_cmd_80211_associate(struct lbs_private *priv, int lbs_cmd_80211_associate(struct lbs_private *priv,
struct cmd_ds_command *cmd, void *pdata_buf) struct cmd_ds_command *cmd, void *pdata_buf)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_associate *passo = &cmd->params.associate; struct cmd_ds_802_11_associate *passo = &cmd->params.associate;
int ret = 0; int ret = 0;
struct assoc_request * assoc_req = pdata_buf; struct assoc_request * assoc_req = pdata_buf;
@ -376,7 +370,7 @@ int lbs_cmd_80211_associate(struct lbs_private *priv,
pos = (u8 *) passo; pos = (u8 *) passo;
if (!adapter) { if (!priv) {
ret = -1; ret = -1;
goto done; goto done;
} }
@ -420,7 +414,7 @@ int lbs_cmd_80211_associate(struct lbs_private *priv,
rates->header.type = cpu_to_le16(TLV_TYPE_RATES); rates->header.type = cpu_to_le16(TLV_TYPE_RATES);
memcpy(&rates->rates, &bss->rates, MAX_RATES); memcpy(&rates->rates, &bss->rates, MAX_RATES);
tmplen = MAX_RATES; tmplen = MAX_RATES;
if (get_common_rates(adapter, rates->rates, &tmplen)) { if (get_common_rates(priv, rates->rates, &tmplen)) {
ret = -1; ret = -1;
goto done; goto done;
} }
@ -429,8 +423,8 @@ int lbs_cmd_80211_associate(struct lbs_private *priv,
lbs_deb_assoc("ASSOC_CMD: num rates %u\n", tmplen); lbs_deb_assoc("ASSOC_CMD: num rates %u\n", tmplen);
/* Copy the infra. association rates into Current BSS state structure */ /* Copy the infra. association rates into Current BSS state structure */
memset(&adapter->curbssparams.rates, 0, sizeof(adapter->curbssparams.rates)); memset(&priv->curbssparams.rates, 0, sizeof(priv->curbssparams.rates));
memcpy(&adapter->curbssparams.rates, &rates->rates, tmplen); memcpy(&priv->curbssparams.rates, &rates->rates, tmplen);
/* Set MSB on basic rates as the firmware requires, but _after_ /* Set MSB on basic rates as the firmware requires, but _after_
* copying to current bss rates. * copying to current bss rates.
@ -450,7 +444,7 @@ int lbs_cmd_80211_associate(struct lbs_private *priv,
} }
/* update curbssparams */ /* update curbssparams */
adapter->curbssparams.channel = bss->phyparamset.dsparamset.currentchan; priv->curbssparams.channel = bss->phyparamset.dsparamset.currentchan;
if (lbs_parse_dnld_countryinfo_11d(priv, bss)) { if (lbs_parse_dnld_countryinfo_11d(priv, bss)) {
ret = -1; ret = -1;
@ -474,7 +468,6 @@ done:
int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv, int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv,
struct cmd_ds_command *cmd, void *pdata_buf) struct cmd_ds_command *cmd, void *pdata_buf)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_ad_hoc_start *adhs = &cmd->params.ads; struct cmd_ds_802_11_ad_hoc_start *adhs = &cmd->params.ads;
int ret = 0; int ret = 0;
int cmdappendsize = 0; int cmdappendsize = 0;
@ -484,7 +477,7 @@ int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv,
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
if (!adapter) { if (!priv) {
ret = -1; ret = -1;
goto done; goto done;
} }
@ -494,7 +487,7 @@ int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv,
/* /*
* Fill in the parameters for 2 data structures: * Fill in the parameters for 2 data structures:
* 1. cmd_ds_802_11_ad_hoc_start command * 1. cmd_ds_802_11_ad_hoc_start command
* 2. adapter->scantable[i] * 2. priv->scantable[i]
* *
* Driver will fill up SSID, bsstype,IBSS param, Physical Param, * Driver will fill up SSID, bsstype,IBSS param, Physical Param,
* probe delay, and cap info. * probe delay, and cap info.
@ -512,10 +505,10 @@ int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv,
/* set the BSS type */ /* set the BSS type */
adhs->bsstype = CMD_BSS_TYPE_IBSS; adhs->bsstype = CMD_BSS_TYPE_IBSS;
adapter->mode = IW_MODE_ADHOC; priv->mode = IW_MODE_ADHOC;
if (adapter->beacon_period == 0) if (priv->beacon_period == 0)
adapter->beacon_period = MRVDRV_BEACON_INTERVAL; priv->beacon_period = MRVDRV_BEACON_INTERVAL;
adhs->beaconperiod = cpu_to_le16(adapter->beacon_period); adhs->beaconperiod = cpu_to_le16(priv->beacon_period);
/* set Physical param set */ /* set Physical param set */
#define DS_PARA_IE_ID 3 #define DS_PARA_IE_ID 3
@ -557,8 +550,8 @@ int lbs_cmd_80211_ad_hoc_start(struct lbs_private *priv,
memcpy(adhs->rates, lbs_bg_rates, ratesize); memcpy(adhs->rates, lbs_bg_rates, ratesize);
/* Copy the ad-hoc creating rates into Current BSS state structure */ /* Copy the ad-hoc creating rates into Current BSS state structure */
memset(&adapter->curbssparams.rates, 0, sizeof(adapter->curbssparams.rates)); memset(&priv->curbssparams.rates, 0, sizeof(priv->curbssparams.rates));
memcpy(&adapter->curbssparams.rates, &adhs->rates, ratesize); memcpy(&priv->curbssparams.rates, &adhs->rates, ratesize);
/* Set MSB on basic rates as the firmware requires, but _after_ /* Set MSB on basic rates as the firmware requires, but _after_
* copying to current bss rates. * copying to current bss rates.
@ -597,7 +590,6 @@ int lbs_cmd_80211_ad_hoc_stop(struct lbs_private *priv,
int lbs_cmd_80211_ad_hoc_join(struct lbs_private *priv, int lbs_cmd_80211_ad_hoc_join(struct lbs_private *priv,
struct cmd_ds_command *cmd, void *pdata_buf) struct cmd_ds_command *cmd, void *pdata_buf)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_ad_hoc_join *join_cmd = &cmd->params.adj; struct cmd_ds_802_11_ad_hoc_join *join_cmd = &cmd->params.adj;
struct assoc_request * assoc_req = pdata_buf; struct assoc_request * assoc_req = pdata_buf;
struct bss_descriptor *bss = &assoc_req->bss; struct bss_descriptor *bss = &assoc_req->bss;
@ -638,21 +630,21 @@ int lbs_cmd_80211_ad_hoc_join(struct lbs_private *priv,
/* probedelay */ /* probedelay */
join_cmd->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME); join_cmd->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
adapter->curbssparams.channel = bss->channel; priv->curbssparams.channel = bss->channel;
/* Copy Data rates from the rates recorded in scan response */ /* Copy Data rates from the rates recorded in scan response */
memset(join_cmd->bss.rates, 0, sizeof(join_cmd->bss.rates)); memset(join_cmd->bss.rates, 0, sizeof(join_cmd->bss.rates));
ratesize = min_t(u16, sizeof(join_cmd->bss.rates), MAX_RATES); ratesize = min_t(u16, sizeof(join_cmd->bss.rates), MAX_RATES);
memcpy(join_cmd->bss.rates, bss->rates, ratesize); memcpy(join_cmd->bss.rates, bss->rates, ratesize);
if (get_common_rates(adapter, join_cmd->bss.rates, &ratesize)) { if (get_common_rates(priv, join_cmd->bss.rates, &ratesize)) {
lbs_deb_join("ADHOC_J_CMD: get_common_rates returns error.\n"); lbs_deb_join("ADHOC_J_CMD: get_common_rates returns error.\n");
ret = -1; ret = -1;
goto done; goto done;
} }
/* Copy the ad-hoc creating rates into Current BSS state structure */ /* Copy the ad-hoc creating rates into Current BSS state structure */
memset(&adapter->curbssparams.rates, 0, sizeof(adapter->curbssparams.rates)); memset(&priv->curbssparams.rates, 0, sizeof(priv->curbssparams.rates));
memcpy(&adapter->curbssparams.rates, join_cmd->bss.rates, ratesize); memcpy(&priv->curbssparams.rates, join_cmd->bss.rates, ratesize);
/* Set MSB on basic rates as the firmware requires, but _after_ /* Set MSB on basic rates as the firmware requires, but _after_
* copying to current bss rates. * copying to current bss rates.
@ -668,7 +660,7 @@ int lbs_cmd_80211_ad_hoc_join(struct lbs_private *priv,
join_cmd->bss.capability = cpu_to_le16(tmp); join_cmd->bss.capability = cpu_to_le16(tmp);
} }
if (adapter->psmode == LBS802_11POWERMODEMAX_PSP) { if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
/* wake up first */ /* wake up first */
__le32 Localpsmode; __le32 Localpsmode;
@ -700,7 +692,6 @@ done:
int lbs_ret_80211_associate(struct lbs_private *priv, int lbs_ret_80211_associate(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
union iwreq_data wrqu; union iwreq_data wrqu;
struct ieeetypes_assocrsp *passocrsp; struct ieeetypes_assocrsp *passocrsp;
@ -709,12 +700,12 @@ int lbs_ret_80211_associate(struct lbs_private *priv,
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
if (!adapter->in_progress_assoc_req) { if (!priv->in_progress_assoc_req) {
lbs_deb_assoc("ASSOC_RESP: no in-progress assoc request\n"); lbs_deb_assoc("ASSOC_RESP: no in-progress assoc request\n");
ret = -1; ret = -1;
goto done; goto done;
} }
bss = &adapter->in_progress_assoc_req->bss; bss = &priv->in_progress_assoc_req->bss;
passocrsp = (struct ieeetypes_assocrsp *) & resp->params; passocrsp = (struct ieeetypes_assocrsp *) & resp->params;
@ -771,29 +762,29 @@ int lbs_ret_80211_associate(struct lbs_private *priv,
le16_to_cpu(resp->size) - S_DS_GEN); le16_to_cpu(resp->size) - S_DS_GEN);
/* Send a Media Connected event, according to the Spec */ /* Send a Media Connected event, according to the Spec */
adapter->connect_status = LBS_CONNECTED; priv->connect_status = LBS_CONNECTED;
/* Update current SSID and BSSID */ /* Update current SSID and BSSID */
memcpy(&adapter->curbssparams.ssid, &bss->ssid, IW_ESSID_MAX_SIZE); memcpy(&priv->curbssparams.ssid, &bss->ssid, IW_ESSID_MAX_SIZE);
adapter->curbssparams.ssid_len = bss->ssid_len; priv->curbssparams.ssid_len = bss->ssid_len;
memcpy(adapter->curbssparams.bssid, bss->bssid, ETH_ALEN); memcpy(priv->curbssparams.bssid, bss->bssid, ETH_ALEN);
lbs_deb_assoc("ASSOC_RESP: currentpacketfilter is 0x%x\n", lbs_deb_assoc("ASSOC_RESP: currentpacketfilter is 0x%x\n",
adapter->currentpacketfilter); priv->currentpacketfilter);
adapter->SNR[TYPE_RXPD][TYPE_AVG] = 0; priv->SNR[TYPE_RXPD][TYPE_AVG] = 0;
adapter->NF[TYPE_RXPD][TYPE_AVG] = 0; priv->NF[TYPE_RXPD][TYPE_AVG] = 0;
memset(adapter->rawSNR, 0x00, sizeof(adapter->rawSNR)); memset(priv->rawSNR, 0x00, sizeof(priv->rawSNR));
memset(adapter->rawNF, 0x00, sizeof(adapter->rawNF)); memset(priv->rawNF, 0x00, sizeof(priv->rawNF));
adapter->nextSNRNF = 0; priv->nextSNRNF = 0;
adapter->numSNRNF = 0; priv->numSNRNF = 0;
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
memcpy(wrqu.ap_addr.sa_data, adapter->curbssparams.bssid, ETH_ALEN); memcpy(wrqu.ap_addr.sa_data, priv->curbssparams.bssid, ETH_ALEN);
wrqu.ap_addr.sa_family = ARPHRD_ETHER; wrqu.ap_addr.sa_family = ARPHRD_ETHER;
wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
@ -816,7 +807,6 @@ int lbs_ret_80211_disassociate(struct lbs_private *priv,
int lbs_ret_80211_ad_hoc_start(struct lbs_private *priv, int lbs_ret_80211_ad_hoc_start(struct lbs_private *priv,
struct cmd_ds_command *resp) struct cmd_ds_command *resp)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
u16 command = le16_to_cpu(resp->command); u16 command = le16_to_cpu(resp->command);
u16 result = le16_to_cpu(resp->result); u16 result = le16_to_cpu(resp->result);
@ -833,19 +823,19 @@ int lbs_ret_80211_ad_hoc_start(struct lbs_private *priv,
lbs_deb_join("ADHOC_RESP: command = %x\n", command); lbs_deb_join("ADHOC_RESP: command = %x\n", command);
lbs_deb_join("ADHOC_RESP: result = %x\n", result); lbs_deb_join("ADHOC_RESP: result = %x\n", result);
if (!adapter->in_progress_assoc_req) { if (!priv->in_progress_assoc_req) {
lbs_deb_join("ADHOC_RESP: no in-progress association request\n"); lbs_deb_join("ADHOC_RESP: no in-progress association request\n");
ret = -1; ret = -1;
goto done; goto done;
} }
bss = &adapter->in_progress_assoc_req->bss; bss = &priv->in_progress_assoc_req->bss;
/* /*
* Join result code 0 --> SUCCESS * Join result code 0 --> SUCCESS
*/ */
if (result) { if (result) {
lbs_deb_join("ADHOC_RESP: failed\n"); lbs_deb_join("ADHOC_RESP: failed\n");
if (adapter->connect_status == LBS_CONNECTED) { if (priv->connect_status == LBS_CONNECTED) {
lbs_mac_event_disconnected(priv); lbs_mac_event_disconnected(priv);
} }
ret = -1; ret = -1;
@ -860,7 +850,7 @@ int lbs_ret_80211_ad_hoc_start(struct lbs_private *priv,
escape_essid(bss->ssid, bss->ssid_len)); escape_essid(bss->ssid, bss->ssid_len));
/* Send a Media Connected event, according to the Spec */ /* Send a Media Connected event, according to the Spec */
adapter->connect_status = LBS_CONNECTED; priv->connect_status = LBS_CONNECTED;
if (command == CMD_RET(CMD_802_11_AD_HOC_START)) { if (command == CMD_RET(CMD_802_11_AD_HOC_START)) {
/* Update the created network descriptor with the new BSSID */ /* Update the created network descriptor with the new BSSID */
@ -868,22 +858,22 @@ int lbs_ret_80211_ad_hoc_start(struct lbs_private *priv,
} }
/* Set the BSSID from the joined/started descriptor */ /* Set the BSSID from the joined/started descriptor */
memcpy(&adapter->curbssparams.bssid, bss->bssid, ETH_ALEN); memcpy(&priv->curbssparams.bssid, bss->bssid, ETH_ALEN);
/* Set the new SSID to current SSID */ /* Set the new SSID to current SSID */
memcpy(&adapter->curbssparams.ssid, &bss->ssid, IW_ESSID_MAX_SIZE); memcpy(&priv->curbssparams.ssid, &bss->ssid, IW_ESSID_MAX_SIZE);
adapter->curbssparams.ssid_len = bss->ssid_len; priv->curbssparams.ssid_len = bss->ssid_len;
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
memset(&wrqu, 0, sizeof(wrqu)); memset(&wrqu, 0, sizeof(wrqu));
memcpy(wrqu.ap_addr.sa_data, adapter->curbssparams.bssid, ETH_ALEN); memcpy(wrqu.ap_addr.sa_data, priv->curbssparams.bssid, ETH_ALEN);
wrqu.ap_addr.sa_family = ARPHRD_ETHER; wrqu.ap_addr.sa_family = ARPHRD_ETHER;
wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
lbs_deb_join("ADHOC_RESP: - Joined/Started Ad Hoc\n"); lbs_deb_join("ADHOC_RESP: - Joined/Started Ad Hoc\n");
lbs_deb_join("ADHOC_RESP: channel = %d\n", adapter->curbssparams.channel); lbs_deb_join("ADHOC_RESP: channel = %d\n", priv->curbssparams.channel);
lbs_deb_join("ADHOC_RESP: BSSID = %s\n", lbs_deb_join("ADHOC_RESP: BSSID = %s\n",
print_mac(mac, padhocresult->bssid)); print_mac(mac, padhocresult->bssid));

326
drivers/net/wireless/libertas/main.c
View File

@ -257,8 +257,7 @@ static ssize_t lbs_rtap_get(struct device *dev,
struct device_attribute *attr, char * buf) struct device_attribute *attr, char * buf)
{ {
struct lbs_private *priv = to_net_dev(dev)->priv; struct lbs_private *priv = to_net_dev(dev)->priv;
struct lbs_adapter *adapter = priv->adapter; return snprintf(buf, 5, "0x%X\n", priv->monitormode);
return snprintf(buf, 5, "0x%X\n", adapter->monitormode);
} }
/** /**
@ -269,31 +268,30 @@ static ssize_t lbs_rtap_set(struct device *dev,
{ {
int monitor_mode; int monitor_mode;
struct lbs_private *priv = to_net_dev(dev)->priv; struct lbs_private *priv = to_net_dev(dev)->priv;
struct lbs_adapter *adapter = priv->adapter;
sscanf(buf, "%x", &monitor_mode); sscanf(buf, "%x", &monitor_mode);
if (monitor_mode != LBS_MONITOR_OFF) { if (monitor_mode != LBS_MONITOR_OFF) {
if(adapter->monitormode == monitor_mode) if(priv->monitormode == monitor_mode)
return strlen(buf); return strlen(buf);
if (adapter->monitormode == LBS_MONITOR_OFF) { if (priv->monitormode == LBS_MONITOR_OFF) {
if (adapter->mode == IW_MODE_INFRA) if (priv->mode == IW_MODE_INFRA)
lbs_send_deauthentication(priv); lbs_send_deauthentication(priv);
else if (adapter->mode == IW_MODE_ADHOC) else if (priv->mode == IW_MODE_ADHOC)
lbs_stop_adhoc_network(priv); lbs_stop_adhoc_network(priv);
lbs_add_rtap(priv); lbs_add_rtap(priv);
} }
adapter->monitormode = monitor_mode; priv->monitormode = monitor_mode;
} }
else { else {
if (adapter->monitormode == LBS_MONITOR_OFF) if (priv->monitormode == LBS_MONITOR_OFF)
return strlen(buf); return strlen(buf);
adapter->monitormode = LBS_MONITOR_OFF; priv->monitormode = LBS_MONITOR_OFF;
lbs_remove_rtap(priv); lbs_remove_rtap(priv);
if (adapter->currenttxskb) { if (priv->currenttxskb) {
dev_kfree_skb_any(adapter->currenttxskb); dev_kfree_skb_any(priv->currenttxskb);
adapter->currenttxskb = NULL; priv->currenttxskb = NULL;
} }
/* Wake queues, command thread, etc. */ /* Wake queues, command thread, etc. */
@ -302,7 +300,7 @@ static ssize_t lbs_rtap_set(struct device *dev,
lbs_prepare_and_send_command(priv, lbs_prepare_and_send_command(priv,
CMD_802_11_MONITOR_MODE, CMD_ACT_SET, CMD_802_11_MONITOR_MODE, CMD_ACT_SET,
CMD_OPTION_WAITFORRSP, 0, &adapter->monitormode); CMD_OPTION_WAITFORRSP, 0, &priv->monitormode);
return strlen(buf); return strlen(buf);
} }
@ -382,14 +380,13 @@ static struct attribute_group lbs_mesh_attr_group = {
static int pre_open_check(struct net_device *dev) static int pre_open_check(struct net_device *dev)
{ {
struct lbs_private *priv = (struct lbs_private *) dev->priv; struct lbs_private *priv = (struct lbs_private *) dev->priv;
struct lbs_adapter *adapter = priv->adapter;
int i = 0; int i = 0;
while (!adapter->fw_ready && i < 20) { while (!priv->fw_ready && i < 20) {
i++; i++;
msleep_interruptible(100); msleep_interruptible(100);
} }
if (!adapter->fw_ready) { if (!priv->fw_ready) {
lbs_pr_err("firmware not ready\n"); lbs_pr_err("firmware not ready\n");
return -1; return -1;
} }
@ -406,19 +403,18 @@ static int pre_open_check(struct net_device *dev)
static int lbs_dev_open(struct net_device *dev) static int lbs_dev_open(struct net_device *dev)
{ {
struct lbs_private *priv = (struct lbs_private *) dev->priv; struct lbs_private *priv = (struct lbs_private *) dev->priv;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_NET); lbs_deb_enter(LBS_DEB_NET);
priv->open = 1; priv->open = 1;
if (adapter->connect_status == LBS_CONNECTED) if (priv->connect_status == LBS_CONNECTED)
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
else else
netif_carrier_off(priv->dev); netif_carrier_off(priv->dev);
if (priv->mesh_dev) { if (priv->mesh_dev) {
if (adapter->mesh_connect_status == LBS_CONNECTED) if (priv->mesh_connect_status == LBS_CONNECTED)
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
else else
netif_carrier_off(priv->mesh_dev); netif_carrier_off(priv->mesh_dev);
@ -442,7 +438,7 @@ static int lbs_mesh_open(struct net_device *dev)
priv->mesh_open = 1 ; priv->mesh_open = 1 ;
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
priv->adapter->mesh_connect_status = LBS_CONNECTED; priv->mesh_connect_status = LBS_CONNECTED;
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
@ -534,7 +530,7 @@ static int lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
priv->stats.tx_dropped++; priv->stats.tx_dropped++;
goto done; goto done;
} }
if (priv->adapter->currenttxskb) { if (priv->currenttxskb) {
lbs_pr_err("%s while TX skb pending\n", __func__); lbs_pr_err("%s while TX skb pending\n", __func__);
priv->stats.tx_dropped++; priv->stats.tx_dropped++;
goto done; goto done;
@ -562,7 +558,7 @@ static int lbs_mesh_pre_start_xmit(struct sk_buff *skb,
int ret; int ret;
lbs_deb_enter(LBS_DEB_MESH); lbs_deb_enter(LBS_DEB_MESH);
if (priv->adapter->monitormode != LBS_MONITOR_OFF) { if (priv->monitormode != LBS_MONITOR_OFF) {
netif_stop_queue(dev); netif_stop_queue(dev);
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
@ -585,7 +581,7 @@ static int lbs_pre_start_xmit(struct sk_buff *skb, struct net_device *dev)
lbs_deb_enter(LBS_DEB_TX); lbs_deb_enter(LBS_DEB_TX);
if (priv->adapter->monitormode != LBS_MONITOR_OFF) { if (priv->monitormode != LBS_MONITOR_OFF) {
netif_stop_queue(dev); netif_stop_queue(dev);
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
@ -608,20 +604,20 @@ static void lbs_tx_timeout(struct net_device *dev)
priv->dnld_sent = DNLD_RES_RECEIVED; priv->dnld_sent = DNLD_RES_RECEIVED;
dev->trans_start = jiffies; dev->trans_start = jiffies;
if (priv->adapter->currenttxskb) { if (priv->currenttxskb) {
if (priv->adapter->monitormode != LBS_MONITOR_OFF) { if (priv->monitormode != LBS_MONITOR_OFF) {
/* If we are here, we have not received feedback from /* If we are here, we have not received feedback from
the previous packet. Assume TX_FAIL and move on. */ the previous packet. Assume TX_FAIL and move on. */
priv->adapter->eventcause = 0x01000000; priv->eventcause = 0x01000000;
lbs_send_tx_feedback(priv); lbs_send_tx_feedback(priv);
} else } else
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);
} else if (dev == priv->dev) { } else if (dev == priv->dev) {
if (priv->adapter->connect_status == LBS_CONNECTED) if (priv->connect_status == LBS_CONNECTED)
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
} else if (dev == priv->mesh_dev) { } else if (dev == priv->mesh_dev) {
if (priv->adapter->mesh_connect_status == LBS_CONNECTED) if (priv->mesh_connect_status == LBS_CONNECTED)
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
@ -630,23 +626,22 @@ static void lbs_tx_timeout(struct net_device *dev)
void lbs_host_to_card_done(struct lbs_private *priv) void lbs_host_to_card_done(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
priv->dnld_sent = DNLD_RES_RECEIVED; priv->dnld_sent = DNLD_RES_RECEIVED;
/* Wake main thread if commands are pending */ /* Wake main thread if commands are pending */
if (!adapter->cur_cmd) if (!priv->cur_cmd)
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);
/* Don't wake netif queues if we're in monitor mode and /* Don't wake netif queues if we're in monitor mode and
a TX packet is already pending. */ a TX packet is already pending. */
if (priv->adapter->currenttxskb) if (priv->currenttxskb)
return; return;
if (priv->dev && adapter->connect_status == LBS_CONNECTED) if (priv->dev && priv->connect_status == LBS_CONNECTED)
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
if (priv->mesh_dev && adapter->mesh_connect_status == LBS_CONNECTED) if (priv->mesh_dev && priv->mesh_connect_status == LBS_CONNECTED)
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
EXPORT_SYMBOL_GPL(lbs_host_to_card_done); EXPORT_SYMBOL_GPL(lbs_host_to_card_done);
@ -668,7 +663,6 @@ static int lbs_set_mac_address(struct net_device *dev, void *addr)
{ {
int ret = 0; int ret = 0;
struct lbs_private *priv = (struct lbs_private *) dev->priv; struct lbs_private *priv = (struct lbs_private *) dev->priv;
struct lbs_adapter *adapter = priv->adapter;
struct sockaddr *phwaddr = addr; struct sockaddr *phwaddr = addr;
lbs_deb_enter(LBS_DEB_NET); lbs_deb_enter(LBS_DEB_NET);
@ -676,13 +670,13 @@ static int lbs_set_mac_address(struct net_device *dev, void *addr)
/* In case it was called from the mesh device */ /* In case it was called from the mesh device */
dev = priv->dev ; dev = priv->dev ;
memset(adapter->current_addr, 0, ETH_ALEN); memset(priv->current_addr, 0, ETH_ALEN);
/* dev->dev_addr is 8 bytes */ /* dev->dev_addr is 8 bytes */
lbs_deb_hex(LBS_DEB_NET, "dev->dev_addr", dev->dev_addr, ETH_ALEN); lbs_deb_hex(LBS_DEB_NET, "dev->dev_addr", dev->dev_addr, ETH_ALEN);
lbs_deb_hex(LBS_DEB_NET, "addr", phwaddr->sa_data, ETH_ALEN); lbs_deb_hex(LBS_DEB_NET, "addr", phwaddr->sa_data, ETH_ALEN);
memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
ret = lbs_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, ret = lbs_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS,
CMD_ACT_SET, CMD_ACT_SET,
@ -694,24 +688,24 @@ static int lbs_set_mac_address(struct net_device *dev, void *addr)
goto done; goto done;
} }
lbs_deb_hex(LBS_DEB_NET, "adapter->macaddr", adapter->current_addr, ETH_ALEN); lbs_deb_hex(LBS_DEB_NET, "priv->macaddr", priv->current_addr, ETH_ALEN);
memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN); memcpy(dev->dev_addr, priv->current_addr, ETH_ALEN);
if (priv->mesh_dev) if (priv->mesh_dev)
memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
done: done:
lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
return ret; return ret;
} }
static int lbs_copy_multicast_address(struct lbs_adapter *adapter, static int lbs_copy_multicast_address(struct lbs_private *priv,
struct net_device *dev) struct net_device *dev)
{ {
int i = 0; int i = 0;
struct dev_mc_list *mcptr = dev->mc_list; struct dev_mc_list *mcptr = dev->mc_list;
for (i = 0; i < dev->mc_count; i++) { for (i = 0; i < dev->mc_count; i++) {
memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); memcpy(&priv->multicastlist[i], mcptr->dmi_addr, ETH_ALEN);
mcptr = mcptr->next; mcptr = mcptr->next;
} }
@ -722,50 +716,49 @@ static int lbs_copy_multicast_address(struct lbs_adapter *adapter,
static void lbs_set_multicast_list(struct net_device *dev) static void lbs_set_multicast_list(struct net_device *dev)
{ {
struct lbs_private *priv = dev->priv; struct lbs_private *priv = dev->priv;
struct lbs_adapter *adapter = priv->adapter;
int oldpacketfilter; int oldpacketfilter;
DECLARE_MAC_BUF(mac); DECLARE_MAC_BUF(mac);
lbs_deb_enter(LBS_DEB_NET); lbs_deb_enter(LBS_DEB_NET);
oldpacketfilter = adapter->currentpacketfilter; oldpacketfilter = priv->currentpacketfilter;
if (dev->flags & IFF_PROMISC) { if (dev->flags & IFF_PROMISC) {
lbs_deb_net("enable promiscuous mode\n"); lbs_deb_net("enable promiscuous mode\n");
adapter->currentpacketfilter |= priv->currentpacketfilter |=
CMD_ACT_MAC_PROMISCUOUS_ENABLE; CMD_ACT_MAC_PROMISCUOUS_ENABLE;
adapter->currentpacketfilter &= priv->currentpacketfilter &=
~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
CMD_ACT_MAC_MULTICAST_ENABLE); CMD_ACT_MAC_MULTICAST_ENABLE);
} else { } else {
/* Multicast */ /* Multicast */
adapter->currentpacketfilter &= priv->currentpacketfilter &=
~CMD_ACT_MAC_PROMISCUOUS_ENABLE; ~CMD_ACT_MAC_PROMISCUOUS_ENABLE;
if (dev->flags & IFF_ALLMULTI || dev->mc_count > if (dev->flags & IFF_ALLMULTI || dev->mc_count >
MRVDRV_MAX_MULTICAST_LIST_SIZE) { MRVDRV_MAX_MULTICAST_LIST_SIZE) {
lbs_deb_net( "enabling all multicast\n"); lbs_deb_net( "enabling all multicast\n");
adapter->currentpacketfilter |= priv->currentpacketfilter |=
CMD_ACT_MAC_ALL_MULTICAST_ENABLE; CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
adapter->currentpacketfilter &= priv->currentpacketfilter &=
~CMD_ACT_MAC_MULTICAST_ENABLE; ~CMD_ACT_MAC_MULTICAST_ENABLE;
} else { } else {
adapter->currentpacketfilter &= priv->currentpacketfilter &=
~CMD_ACT_MAC_ALL_MULTICAST_ENABLE; ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
if (!dev->mc_count) { if (!dev->mc_count) {
lbs_deb_net("no multicast addresses, " lbs_deb_net("no multicast addresses, "
"disabling multicast\n"); "disabling multicast\n");
adapter->currentpacketfilter &= priv->currentpacketfilter &=
~CMD_ACT_MAC_MULTICAST_ENABLE; ~CMD_ACT_MAC_MULTICAST_ENABLE;
} else { } else {
int i; int i;
adapter->currentpacketfilter |= priv->currentpacketfilter |=
CMD_ACT_MAC_MULTICAST_ENABLE; CMD_ACT_MAC_MULTICAST_ENABLE;
adapter->nr_of_multicastmacaddr = priv->nr_of_multicastmacaddr =
lbs_copy_multicast_address(adapter, dev); lbs_copy_multicast_address(priv, dev);
lbs_deb_net("multicast addresses: %d\n", lbs_deb_net("multicast addresses: %d\n",
dev->mc_count); dev->mc_count);
@ -773,7 +766,7 @@ static void lbs_set_multicast_list(struct net_device *dev)
for (i = 0; i < dev->mc_count; i++) { for (i = 0; i < dev->mc_count; i++) {
lbs_deb_net("Multicast address %d:%s\n", lbs_deb_net("Multicast address %d:%s\n",
i, print_mac(mac, i, print_mac(mac,
adapter->multicastlist[i])); priv->multicastlist[i]));
} }
/* send multicast addresses to firmware */ /* send multicast addresses to firmware */
lbs_prepare_and_send_command(priv, lbs_prepare_and_send_command(priv,
@ -784,7 +777,7 @@ static void lbs_set_multicast_list(struct net_device *dev)
} }
} }
if (adapter->currentpacketfilter != oldpacketfilter) { if (priv->currentpacketfilter != oldpacketfilter) {
lbs_set_mac_packet_filter(priv); lbs_set_mac_packet_filter(priv);
} }
@ -803,7 +796,6 @@ static int lbs_thread(void *data)
{ {
struct net_device *dev = data; struct net_device *dev = data;
struct lbs_private *priv = dev->priv; struct lbs_private *priv = dev->priv;
struct lbs_adapter *adapter = priv->adapter;
wait_queue_t wait; wait_queue_t wait;
u8 ireg = 0; u8 ireg = 0;
@ -815,99 +807,99 @@ static int lbs_thread(void *data)
for (;;) { for (;;) {
lbs_deb_thread( "main-thread 111: intcounter=%d currenttxskb=%p dnld_sent=%d\n", lbs_deb_thread( "main-thread 111: intcounter=%d currenttxskb=%p dnld_sent=%d\n",
adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); priv->intcounter, priv->currenttxskb, priv->dnld_sent);
add_wait_queue(&priv->waitq, &wait); add_wait_queue(&priv->waitq, &wait);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
spin_lock_irq(&adapter->driver_lock); spin_lock_irq(&priv->driver_lock);
if ((adapter->psstate == PS_STATE_SLEEP) || if ((priv->psstate == PS_STATE_SLEEP) ||
(!adapter->intcounter && (priv->dnld_sent || adapter->cur_cmd || list_empty(&adapter->cmdpendingq)))) { (!priv->intcounter && (priv->dnld_sent || priv->cur_cmd || list_empty(&priv->cmdpendingq)))) {
lbs_deb_thread("main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", lbs_deb_thread("main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n",
adapter->connect_status, adapter->intcounter, priv->connect_status, priv->intcounter,
adapter->psmode, adapter->psstate); priv->psmode, priv->psstate);
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
schedule(); schedule();
} else } else
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_deb_thread("main-thread 222 (waking up): intcounter=%d currenttxskb=%p dnld_sent=%d\n", lbs_deb_thread("main-thread 222 (waking up): intcounter=%d currenttxskb=%p dnld_sent=%d\n",
adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); priv->intcounter, priv->currenttxskb, priv->dnld_sent);
set_current_state(TASK_RUNNING); set_current_state(TASK_RUNNING);
remove_wait_queue(&priv->waitq, &wait); remove_wait_queue(&priv->waitq, &wait);
try_to_freeze(); try_to_freeze();
lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p dnld_sent=%d\n", lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p dnld_sent=%d\n",
adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); priv->intcounter, priv->currenttxskb, priv->dnld_sent);
if (kthread_should_stop() || adapter->surpriseremoved) { if (kthread_should_stop() || priv->surpriseremoved) {
lbs_deb_thread("main-thread: break from main thread: surpriseremoved=0x%x\n", lbs_deb_thread("main-thread: break from main thread: surpriseremoved=0x%x\n",
adapter->surpriseremoved); priv->surpriseremoved);
break; break;
} }
spin_lock_irq(&adapter->driver_lock); spin_lock_irq(&priv->driver_lock);
if (adapter->intcounter) { if (priv->intcounter) {
u8 int_status; u8 int_status;
adapter->intcounter = 0; priv->intcounter = 0;
int_status = priv->hw_get_int_status(priv, &ireg); int_status = priv->hw_get_int_status(priv, &ireg);
if (int_status) { if (int_status) {
lbs_deb_thread("main-thread: reading HOST_INT_STATUS_REG failed\n"); lbs_deb_thread("main-thread: reading HOST_INT_STATUS_REG failed\n");
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
continue; continue;
} }
adapter->hisregcpy |= ireg; priv->hisregcpy |= ireg;
} }
lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p dnld_sent=%d\n", lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p dnld_sent=%d\n",
adapter->intcounter, adapter->currenttxskb, priv->dnld_sent); priv->intcounter, priv->currenttxskb, priv->dnld_sent);
/* command response? */ /* command response? */
if (adapter->hisregcpy & MRVDRV_CMD_UPLD_RDY) { if (priv->hisregcpy & MRVDRV_CMD_UPLD_RDY) {
lbs_deb_thread("main-thread: cmd response ready\n"); lbs_deb_thread("main-thread: cmd response ready\n");
adapter->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; priv->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY;
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_process_rx_command(priv); lbs_process_rx_command(priv);
spin_lock_irq(&adapter->driver_lock); spin_lock_irq(&priv->driver_lock);
} }
/* Any Card Event */ /* Any Card Event */
if (adapter->hisregcpy & MRVDRV_CARDEVENT) { if (priv->hisregcpy & MRVDRV_CARDEVENT) {
lbs_deb_thread("main-thread: Card Event Activity\n"); lbs_deb_thread("main-thread: Card Event Activity\n");
adapter->hisregcpy &= ~MRVDRV_CARDEVENT; priv->hisregcpy &= ~MRVDRV_CARDEVENT;
if (priv->hw_read_event_cause(priv)) { if (priv->hw_read_event_cause(priv)) {
lbs_pr_alert("main-thread: hw_read_event_cause failed\n"); lbs_pr_alert("main-thread: hw_read_event_cause failed\n");
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
continue; continue;
} }
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_process_event(priv); lbs_process_event(priv);
} else } else
spin_unlock_irq(&adapter->driver_lock); spin_unlock_irq(&priv->driver_lock);
/* Check if we need to confirm Sleep Request received previously */ /* Check if we need to confirm Sleep Request received previously */
if (adapter->psstate == PS_STATE_PRE_SLEEP && if (priv->psstate == PS_STATE_PRE_SLEEP &&
!priv->dnld_sent && !adapter->cur_cmd) { !priv->dnld_sent && !priv->cur_cmd) {
if (adapter->connect_status == LBS_CONNECTED) { if (priv->connect_status == LBS_CONNECTED) {
lbs_deb_thread("main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p dnld_sent=%d cur_cmd=%p, confirm now\n", lbs_deb_thread("main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p dnld_sent=%d cur_cmd=%p, confirm now\n",
adapter->intcounter, adapter->currenttxskb, priv->dnld_sent, adapter->cur_cmd); priv->intcounter, priv->currenttxskb, priv->dnld_sent, priv->cur_cmd);
lbs_ps_confirm_sleep(priv, (u16) adapter->psmode); lbs_ps_confirm_sleep(priv, (u16) priv->psmode);
} else { } else {
/* workaround for firmware sending /* workaround for firmware sending
* deauth/linkloss event immediately * deauth/linkloss event immediately
* after sleep request; remove this * after sleep request; remove this
* after firmware fixes it * after firmware fixes it
*/ */
adapter->psstate = PS_STATE_AWAKE; priv->psstate = PS_STATE_AWAKE;
lbs_pr_alert("main-thread: ignore PS_SleepConfirm in non-connected state\n"); lbs_pr_alert("main-thread: ignore PS_SleepConfirm in non-connected state\n");
} }
} }
@ -915,25 +907,25 @@ static int lbs_thread(void *data)
/* The PS state is changed during processing of Sleep Request /* The PS state is changed during processing of Sleep Request
* event above * event above
*/ */
if ((priv->adapter->psstate == PS_STATE_SLEEP) || if ((priv->psstate == PS_STATE_SLEEP) ||
(priv->adapter->psstate == PS_STATE_PRE_SLEEP)) (priv->psstate == PS_STATE_PRE_SLEEP))
continue; continue;
/* Execute the next command */ /* Execute the next command */
if (!priv->dnld_sent && !priv->adapter->cur_cmd) if (!priv->dnld_sent && !priv->cur_cmd)
lbs_execute_next_command(priv); lbs_execute_next_command(priv);
/* Wake-up command waiters which can't sleep in /* Wake-up command waiters which can't sleep in
* lbs_prepare_and_send_command * lbs_prepare_and_send_command
*/ */
if (!list_empty(&adapter->cmdpendingq)) if (!list_empty(&priv->cmdpendingq))
wake_up_all(&adapter->cmd_pending); wake_up_all(&priv->cmd_pending);
lbs_tx_runqueue(priv); lbs_tx_runqueue(priv);
} }
del_timer(&adapter->command_timer); del_timer(&priv->command_timer);
wake_up_all(&adapter->cmd_pending); wake_up_all(&priv->cmd_pending);
lbs_deb_leave(LBS_DEB_THREAD); lbs_deb_leave(LBS_DEB_THREAD);
return 0; return 0;
@ -950,7 +942,6 @@ static int lbs_thread(void *data)
static int lbs_setup_firmware(struct lbs_private *priv) static int lbs_setup_firmware(struct lbs_private *priv)
{ {
int ret = -1; int ret = -1;
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_mesh_access mesh_access; struct cmd_ds_mesh_access mesh_access;
lbs_deb_enter(LBS_DEB_FW); lbs_deb_enter(LBS_DEB_FW);
@ -958,7 +949,7 @@ static int lbs_setup_firmware(struct lbs_private *priv)
/* /*
* Read MAC address from HW * Read MAC address from HW
*/ */
memset(adapter->current_addr, 0xff, ETH_ALEN); memset(priv->current_addr, 0xff, ETH_ALEN);
ret = lbs_prepare_and_send_command(priv, CMD_GET_HW_SPEC, ret = lbs_prepare_and_send_command(priv, CMD_GET_HW_SPEC,
0, CMD_OPTION_WAITFORRSP, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
@ -1008,12 +999,11 @@ done:
static void command_timer_fn(unsigned long data) static void command_timer_fn(unsigned long data)
{ {
struct lbs_private *priv = (struct lbs_private *)data; struct lbs_private *priv = (struct lbs_private *)data;
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ctrl_node *ptempnode; struct cmd_ctrl_node *ptempnode;
struct cmd_ds_command *cmd; struct cmd_ds_command *cmd;
unsigned long flags; unsigned long flags;
ptempnode = adapter->cur_cmd; ptempnode = priv->cur_cmd;
if (ptempnode == NULL) { if (ptempnode == NULL) {
lbs_deb_fw("ptempnode empty\n"); lbs_deb_fw("ptempnode empty\n");
return; return;
@ -1027,15 +1017,15 @@ static void command_timer_fn(unsigned long data)
lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command); lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command);
if (!adapter->fw_ready) if (!priv->fw_ready)
return; return;
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
adapter->cur_cmd = NULL; priv->cur_cmd = NULL;
spin_unlock_irqrestore(&adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
lbs_deb_fw("re-sending same command because of timeout\n"); lbs_deb_fw("re-sending same command because of timeout\n");
lbs_queue_cmd(adapter, ptempnode, 0); lbs_queue_cmd(priv, ptempnode, 0);
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);
@ -1044,63 +1034,62 @@ static void command_timer_fn(unsigned long data)
static int lbs_init_adapter(struct lbs_private *priv) static int lbs_init_adapter(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
size_t bufsize; size_t bufsize;
int i, ret = 0; int i, ret = 0;
/* Allocate buffer to store the BSSID list */ /* Allocate buffer to store the BSSID list */
bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor);
adapter->networks = kzalloc(bufsize, GFP_KERNEL); priv->networks = kzalloc(bufsize, GFP_KERNEL);
if (!adapter->networks) { if (!priv->networks) {
lbs_pr_err("Out of memory allocating beacons\n"); lbs_pr_err("Out of memory allocating beacons\n");
ret = -1; ret = -1;
goto out; goto out;
} }
/* Initialize scan result lists */ /* Initialize scan result lists */
INIT_LIST_HEAD(&adapter->network_free_list); INIT_LIST_HEAD(&priv->network_free_list);
INIT_LIST_HEAD(&adapter->network_list); INIT_LIST_HEAD(&priv->network_list);
for (i = 0; i < MAX_NETWORK_COUNT; i++) { for (i = 0; i < MAX_NETWORK_COUNT; i++) {
list_add_tail(&adapter->networks[i].list, list_add_tail(&priv->networks[i].list,
&adapter->network_free_list); &priv->network_free_list);
} }
adapter->lbs_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); priv->lbs_ps_confirm_sleep.seqnum = cpu_to_le16(++priv->seqnum);
adapter->lbs_ps_confirm_sleep.command = priv->lbs_ps_confirm_sleep.command =
cpu_to_le16(CMD_802_11_PS_MODE); cpu_to_le16(CMD_802_11_PS_MODE);
adapter->lbs_ps_confirm_sleep.size = priv->lbs_ps_confirm_sleep.size =
cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
adapter->lbs_ps_confirm_sleep.action = priv->lbs_ps_confirm_sleep.action =
cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
memset(adapter->current_addr, 0xff, ETH_ALEN); memset(priv->current_addr, 0xff, ETH_ALEN);
adapter->connect_status = LBS_DISCONNECTED; priv->connect_status = LBS_DISCONNECTED;
adapter->mesh_connect_status = LBS_DISCONNECTED; priv->mesh_connect_status = LBS_DISCONNECTED;
adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
adapter->mode = IW_MODE_INFRA; priv->mode = IW_MODE_INFRA;
adapter->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL; priv->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL;
adapter->currentpacketfilter = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; priv->currentpacketfilter = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
adapter->radioon = RADIO_ON; priv->radioon = RADIO_ON;
adapter->auto_rate = 1; priv->auto_rate = 1;
adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
adapter->psmode = LBS802_11POWERMODECAM; priv->psmode = LBS802_11POWERMODECAM;
adapter->psstate = PS_STATE_FULL_POWER; priv->psstate = PS_STATE_FULL_POWER;
mutex_init(&adapter->lock); mutex_init(&priv->lock);
memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*)); memset(&priv->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*));
adapter->tx_queue_idx = 0; priv->tx_queue_idx = 0;
spin_lock_init(&adapter->txqueue_lock); spin_lock_init(&priv->txqueue_lock);
setup_timer(&adapter->command_timer, command_timer_fn, setup_timer(&priv->command_timer, command_timer_fn,
(unsigned long)priv); (unsigned long)priv);
INIT_LIST_HEAD(&adapter->cmdfreeq); INIT_LIST_HEAD(&priv->cmdfreeq);
INIT_LIST_HEAD(&adapter->cmdpendingq); INIT_LIST_HEAD(&priv->cmdpendingq);
spin_lock_init(&adapter->driver_lock); spin_lock_init(&priv->driver_lock);
init_waitqueue_head(&adapter->cmd_pending); init_waitqueue_head(&priv->cmd_pending);
/* Allocate the command buffers */ /* Allocate the command buffers */
if (lbs_allocate_cmd_buffer(priv)) { if (lbs_allocate_cmd_buffer(priv)) {
@ -1114,27 +1103,15 @@ out:
static void lbs_free_adapter(struct lbs_private *priv) static void lbs_free_adapter(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
if (!adapter) {
lbs_deb_fw("why double free adapter?\n");
return;
}
lbs_deb_fw("free command buffer\n"); lbs_deb_fw("free command buffer\n");
lbs_free_cmd_buffer(priv); lbs_free_cmd_buffer(priv);
lbs_deb_fw("free command_timer\n"); lbs_deb_fw("free command_timer\n");
del_timer(&adapter->command_timer); del_timer(&priv->command_timer);
lbs_deb_fw("free scan results table\n"); lbs_deb_fw("free scan results table\n");
kfree(adapter->networks); kfree(priv->networks);
adapter->networks = NULL; priv->networks = NULL;
/* Free the adapter object itself */
lbs_deb_fw("free adapter\n");
kfree(adapter);
priv->adapter = NULL;
} }
/** /**
@ -1159,13 +1136,6 @@ struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
} }
priv = dev->priv; priv = dev->priv;
/* allocate buffer for struct lbs_adapter */
priv->adapter = kzalloc(sizeof(struct lbs_adapter), GFP_KERNEL);
if (!priv->adapter) {
lbs_pr_err("allocate buffer for struct lbs_adapter failed\n");
goto err_kzalloc;
}
if (lbs_init_adapter(priv)) { if (lbs_init_adapter(priv)) {
lbs_pr_err("failed to initialize adapter structure.\n"); lbs_pr_err("failed to initialize adapter structure.\n");
goto err_init_adapter; goto err_init_adapter;
@ -1212,8 +1182,6 @@ struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
err_init_adapter: err_init_adapter:
lbs_free_adapter(priv); lbs_free_adapter(priv);
err_kzalloc:
free_netdev(dev); free_netdev(dev);
priv = NULL; priv = NULL;
@ -1226,7 +1194,6 @@ EXPORT_SYMBOL_GPL(lbs_add_card);
int lbs_remove_card(struct lbs_private *priv) int lbs_remove_card(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct net_device *dev = priv->dev; struct net_device *dev = priv->dev;
union iwreq_data wrqu; union iwreq_data wrqu;
@ -1241,8 +1208,8 @@ int lbs_remove_card(struct lbs_private *priv)
cancel_delayed_work(&priv->assoc_work); cancel_delayed_work(&priv->assoc_work);
destroy_workqueue(priv->work_thread); destroy_workqueue(priv->work_thread);
if (adapter->psmode == LBS802_11POWERMODEMAX_PSP) { if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
adapter->psmode = LBS802_11POWERMODECAM; priv->psmode = LBS802_11POWERMODECAM;
lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
} }
@ -1251,7 +1218,7 @@ int lbs_remove_card(struct lbs_private *priv)
wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
/* Stop the thread servicing the interrupts */ /* Stop the thread servicing the interrupts */
adapter->surpriseremoved = 1; priv->surpriseremoved = 1;
kthread_stop(priv->main_thread); kthread_stop(priv->main_thread);
lbs_free_adapter(priv); lbs_free_adapter(priv);
@ -1315,12 +1282,12 @@ int lbs_stop_card(struct lbs_private *priv)
lbs_debugfs_remove_one(priv); lbs_debugfs_remove_one(priv);
/* Flush pending command nodes */ /* Flush pending command nodes */
spin_lock_irqsave(&priv->adapter->driver_lock, flags); spin_lock_irqsave(&priv->driver_lock, flags);
list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) { list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
cmdnode->cmdwaitqwoken = 1; cmdnode->cmdwaitqwoken = 1;
wake_up_interruptible(&cmdnode->cmdwait_q); wake_up_interruptible(&cmdnode->cmdwait_q);
} }
spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); spin_unlock_irqrestore(&priv->driver_lock, flags);
unregister_netdev(dev); unregister_netdev(dev);
@ -1452,7 +1419,6 @@ struct chan_freq_power *lbs_get_region_cfp_table(u8 region, u8 band, int *cfp_no
int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band) int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
int i = 0; int i = 0;
@ -1461,22 +1427,22 @@ int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band)
lbs_deb_enter(LBS_DEB_MAIN); lbs_deb_enter(LBS_DEB_MAIN);
memset(adapter->region_channel, 0, sizeof(adapter->region_channel)); memset(priv->region_channel, 0, sizeof(priv->region_channel));
{ {
cfp = lbs_get_region_cfp_table(region, band, &cfp_no); cfp = lbs_get_region_cfp_table(region, band, &cfp_no);
if (cfp != NULL) { if (cfp != NULL) {
adapter->region_channel[i].nrcfp = cfp_no; priv->region_channel[i].nrcfp = cfp_no;
adapter->region_channel[i].CFP = cfp; priv->region_channel[i].CFP = cfp;
} else { } else {
lbs_deb_main("wrong region code %#x in band B/G\n", lbs_deb_main("wrong region code %#x in band B/G\n",
region); region);
ret = -1; ret = -1;
goto out; goto out;
} }
adapter->region_channel[i].valid = 1; priv->region_channel[i].valid = 1;
adapter->region_channel[i].region = region; priv->region_channel[i].region = region;
adapter->region_channel[i].band = band; priv->region_channel[i].band = band;
i++; i++;
} }
out: out:
@ -1499,12 +1465,12 @@ void lbs_interrupt(struct net_device *dev)
lbs_deb_enter(LBS_DEB_THREAD); lbs_deb_enter(LBS_DEB_THREAD);
lbs_deb_thread("lbs_interrupt: intcounter=%d\n", lbs_deb_thread("lbs_interrupt: intcounter=%d\n",
priv->adapter->intcounter); priv->intcounter);
priv->adapter->intcounter++; priv->intcounter++;
if (priv->adapter->psstate == PS_STATE_SLEEP) { if (priv->psstate == PS_STATE_SLEEP) {
priv->adapter->psstate = PS_STATE_AWAKE; priv->psstate = PS_STATE_AWAKE;
netif_wake_queue(dev); netif_wake_queue(dev);
if (priv->mesh_dev) if (priv->mesh_dev)
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);

78
drivers/net/wireless/libertas/rx.c
View File

@ -48,12 +48,11 @@ static u8 lbs_getavgsnr(struct lbs_private *priv)
{ {
u8 i; u8 i;
u16 temp = 0; u16 temp = 0;
struct lbs_adapter *adapter = priv->adapter; if (priv->numSNRNF == 0)
if (adapter->numSNRNF == 0)
return 0; return 0;
for (i = 0; i < adapter->numSNRNF; i++) for (i = 0; i < priv->numSNRNF; i++)
temp += adapter->rawSNR[i]; temp += priv->rawSNR[i];
return (u8) (temp / adapter->numSNRNF); return (u8) (temp / priv->numSNRNF);
} }
@ -67,12 +66,11 @@ static u8 lbs_getavgnf(struct lbs_private *priv)
{ {
u8 i; u8 i;
u16 temp = 0; u16 temp = 0;
struct lbs_adapter *adapter = priv->adapter; if (priv->numSNRNF == 0)
if (adapter->numSNRNF == 0)
return 0; return 0;
for (i = 0; i < adapter->numSNRNF; i++) for (i = 0; i < priv->numSNRNF; i++)
temp += adapter->rawNF[i]; temp += priv->rawNF[i];
return (u8) (temp / adapter->numSNRNF); return (u8) (temp / priv->numSNRNF);
} }
@ -85,14 +83,13 @@ static u8 lbs_getavgnf(struct lbs_private *priv)
*/ */
static void lbs_save_rawSNRNF(struct lbs_private *priv, struct rxpd *p_rx_pd) static void lbs_save_rawSNRNF(struct lbs_private *priv, struct rxpd *p_rx_pd)
{ {
struct lbs_adapter *adapter = priv->adapter; if (priv->numSNRNF < DEFAULT_DATA_AVG_FACTOR)
if (adapter->numSNRNF < DEFAULT_DATA_AVG_FACTOR) priv->numSNRNF++;
adapter->numSNRNF++; priv->rawSNR[priv->nextSNRNF] = p_rx_pd->snr;
adapter->rawSNR[adapter->nextSNRNF] = p_rx_pd->snr; priv->rawNF[priv->nextSNRNF] = p_rx_pd->nf;
adapter->rawNF[adapter->nextSNRNF] = p_rx_pd->nf; priv->nextSNRNF++;
adapter->nextSNRNF++; if (priv->nextSNRNF >= DEFAULT_DATA_AVG_FACTOR)
if (adapter->nextSNRNF >= DEFAULT_DATA_AVG_FACTOR) priv->nextSNRNF = 0;
adapter->nextSNRNF = 0;
return; return;
} }
@ -105,32 +102,31 @@ static void lbs_save_rawSNRNF(struct lbs_private *priv, struct rxpd *p_rx_pd)
*/ */
static void lbs_compute_rssi(struct lbs_private *priv, struct rxpd *p_rx_pd) static void lbs_compute_rssi(struct lbs_private *priv, struct rxpd *p_rx_pd)
{ {
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_RX); lbs_deb_enter(LBS_DEB_RX);
lbs_deb_rx("rxpd: SNR %d, NF %d\n", p_rx_pd->snr, p_rx_pd->nf); lbs_deb_rx("rxpd: SNR %d, NF %d\n", p_rx_pd->snr, p_rx_pd->nf);
lbs_deb_rx("before computing SNR: SNR-avg = %d, NF-avg = %d\n", lbs_deb_rx("before computing SNR: SNR-avg = %d, NF-avg = %d\n",
adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE, priv->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE,
adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE); priv->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
adapter->SNR[TYPE_RXPD][TYPE_NOAVG] = p_rx_pd->snr; priv->SNR[TYPE_RXPD][TYPE_NOAVG] = p_rx_pd->snr;
adapter->NF[TYPE_RXPD][TYPE_NOAVG] = p_rx_pd->nf; priv->NF[TYPE_RXPD][TYPE_NOAVG] = p_rx_pd->nf;
lbs_save_rawSNRNF(priv, p_rx_pd); lbs_save_rawSNRNF(priv, p_rx_pd);
adapter->SNR[TYPE_RXPD][TYPE_AVG] = lbs_getavgsnr(priv) * AVG_SCALE; priv->SNR[TYPE_RXPD][TYPE_AVG] = lbs_getavgsnr(priv) * AVG_SCALE;
adapter->NF[TYPE_RXPD][TYPE_AVG] = lbs_getavgnf(priv) * AVG_SCALE; priv->NF[TYPE_RXPD][TYPE_AVG] = lbs_getavgnf(priv) * AVG_SCALE;
lbs_deb_rx("after computing SNR: SNR-avg = %d, NF-avg = %d\n", lbs_deb_rx("after computing SNR: SNR-avg = %d, NF-avg = %d\n",
adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE, priv->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE,
adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE); priv->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
adapter->RSSI[TYPE_RXPD][TYPE_NOAVG] = priv->RSSI[TYPE_RXPD][TYPE_NOAVG] =
CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_NOAVG], CAL_RSSI(priv->SNR[TYPE_RXPD][TYPE_NOAVG],
adapter->NF[TYPE_RXPD][TYPE_NOAVG]); priv->NF[TYPE_RXPD][TYPE_NOAVG]);
adapter->RSSI[TYPE_RXPD][TYPE_AVG] = priv->RSSI[TYPE_RXPD][TYPE_AVG] =
CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE, CAL_RSSI(priv->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE,
adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE); priv->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
lbs_deb_leave(LBS_DEB_RX); lbs_deb_leave(LBS_DEB_RX);
} }
@ -139,7 +135,7 @@ void lbs_upload_rx_packet(struct lbs_private *priv, struct sk_buff *skb)
{ {
lbs_deb_rx("skb->data %p\n", skb->data); lbs_deb_rx("skb->data %p\n", skb->data);
if (priv->adapter->monitormode != LBS_MONITOR_OFF) { if (priv->monitormode != LBS_MONITOR_OFF) {
skb->protocol = eth_type_trans(skb, priv->rtap_net_dev); skb->protocol = eth_type_trans(skb, priv->rtap_net_dev);
} else { } else {
if (priv->mesh_dev && IS_MESH_FRAME(skb)) if (priv->mesh_dev && IS_MESH_FRAME(skb))
@ -161,7 +157,6 @@ void lbs_upload_rx_packet(struct lbs_private *priv, struct sk_buff *skb)
*/ */
int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *skb) int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *skb)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
struct rxpackethdr *p_rx_pkt; struct rxpackethdr *p_rx_pkt;
@ -174,7 +169,7 @@ int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *skb)
lbs_deb_enter(LBS_DEB_RX); lbs_deb_enter(LBS_DEB_RX);
if (priv->adapter->monitormode != LBS_MONITOR_OFF) if (priv->monitormode != LBS_MONITOR_OFF)
return process_rxed_802_11_packet(priv, skb); return process_rxed_802_11_packet(priv, skb);
p_rx_pkt = (struct rxpackethdr *) skb->data; p_rx_pkt = (struct rxpackethdr *) skb->data;
@ -258,8 +253,8 @@ int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *skb)
/* Take the data rate from the rxpd structure /* Take the data rate from the rxpd structure
* only if the rate is auto * only if the rate is auto
*/ */
if (adapter->auto_rate) if (priv->auto_rate)
adapter->cur_rate = lbs_fw_index_to_data_rate(p_rx_pd->rx_rate); priv->cur_rate = lbs_fw_index_to_data_rate(p_rx_pd->rx_rate);
lbs_compute_rssi(priv, p_rx_pd); lbs_compute_rssi(priv, p_rx_pd);
@ -327,7 +322,6 @@ static u8 convert_mv_rate_to_radiotap(u8 rate)
static int process_rxed_802_11_packet(struct lbs_private *priv, static int process_rxed_802_11_packet(struct lbs_private *priv,
struct sk_buff *skb) struct sk_buff *skb)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = 0; int ret = 0;
struct rx80211packethdr *p_rx_pkt; struct rx80211packethdr *p_rx_pkt;
@ -361,7 +355,7 @@ static int process_rxed_802_11_packet(struct lbs_private *priv,
skb->len, sizeof(struct rxpd), skb->len - sizeof(struct rxpd)); skb->len, sizeof(struct rxpd), skb->len - sizeof(struct rxpd));
/* create the exported radio header */ /* create the exported radio header */
if (priv->adapter->monitormode == LBS_MONITOR_OFF) { if (priv->monitormode == LBS_MONITOR_OFF) {
/* no radio header */ /* no radio header */
/* chop the rxpd */ /* chop the rxpd */
skb_pull(skb, sizeof(struct rxpd)); skb_pull(skb, sizeof(struct rxpd));
@ -410,8 +404,8 @@ static int process_rxed_802_11_packet(struct lbs_private *priv,
/* Take the data rate from the rxpd structure /* Take the data rate from the rxpd structure
* only if the rate is auto * only if the rate is auto
*/ */
if (adapter->auto_rate) if (priv->auto_rate)
adapter->cur_rate = lbs_fw_index_to_data_rate(prxpd->rx_rate); priv->cur_rate = lbs_fw_index_to_data_rate(prxpd->rx_rate);
lbs_compute_rssi(priv, prxpd); lbs_compute_rssi(priv, prxpd);

188
drivers/net/wireless/libertas/scan.c
View File

@ -190,13 +190,13 @@ static inline int is_same_network(struct bss_descriptor *src,
* 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP * 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP
* *
* *
* @param adapter A pointer to struct lbs_adapter * @param priv A pointer to struct lbs_private
* @param index Index in scantable to check against current driver settings * @param index Index in scantable to check against current driver settings
* @param mode Network mode: Infrastructure or IBSS * @param mode Network mode: Infrastructure or IBSS
* *
* @return Index in scantable, or error code if negative * @return Index in scantable, or error code if negative
*/ */
static int is_network_compatible(struct lbs_adapter *adapter, static int is_network_compatible(struct lbs_private *priv,
struct bss_descriptor * bss, u8 mode) struct bss_descriptor * bss, u8 mode)
{ {
int matched = 0; int matched = 0;
@ -206,31 +206,31 @@ static int is_network_compatible(struct lbs_adapter *adapter,
if (bss->mode != mode) if (bss->mode != mode)
goto done; goto done;
if ((matched = match_bss_no_security(&adapter->secinfo, bss))) { if ((matched = match_bss_no_security(&priv->secinfo, bss))) {
goto done; goto done;
} else if ((matched = match_bss_static_wep(&adapter->secinfo, bss))) { } else if ((matched = match_bss_static_wep(&priv->secinfo, bss))) {
goto done; goto done;
} else if ((matched = match_bss_wpa(&adapter->secinfo, bss))) { } else if ((matched = match_bss_wpa(&priv->secinfo, bss))) {
lbs_deb_scan( lbs_deb_scan(
"is_network_compatible() WPA: wpa_ie 0x%x " "is_network_compatible() WPA: wpa_ie 0x%x "
"wpa2_ie 0x%x WEP %s WPA %s WPA2 %s " "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
"privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0], "privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0],
adapter->secinfo.wep_enabled ? "e" : "d", priv->secinfo.wep_enabled ? "e" : "d",
adapter->secinfo.WPAenabled ? "e" : "d", priv->secinfo.WPAenabled ? "e" : "d",
adapter->secinfo.WPA2enabled ? "e" : "d", priv->secinfo.WPA2enabled ? "e" : "d",
(bss->capability & WLAN_CAPABILITY_PRIVACY)); (bss->capability & WLAN_CAPABILITY_PRIVACY));
goto done; goto done;
} else if ((matched = match_bss_wpa2(&adapter->secinfo, bss))) { } else if ((matched = match_bss_wpa2(&priv->secinfo, bss))) {
lbs_deb_scan( lbs_deb_scan(
"is_network_compatible() WPA2: wpa_ie 0x%x " "is_network_compatible() WPA2: wpa_ie 0x%x "
"wpa2_ie 0x%x WEP %s WPA %s WPA2 %s " "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
"privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0], "privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0],
adapter->secinfo.wep_enabled ? "e" : "d", priv->secinfo.wep_enabled ? "e" : "d",
adapter->secinfo.WPAenabled ? "e" : "d", priv->secinfo.WPAenabled ? "e" : "d",
adapter->secinfo.WPA2enabled ? "e" : "d", priv->secinfo.WPA2enabled ? "e" : "d",
(bss->capability & WLAN_CAPABILITY_PRIVACY)); (bss->capability & WLAN_CAPABILITY_PRIVACY));
goto done; goto done;
} else if ((matched = match_bss_dynamic_wep(&adapter->secinfo, bss))) { } else if ((matched = match_bss_dynamic_wep(&priv->secinfo, bss))) {
lbs_deb_scan( lbs_deb_scan(
"is_network_compatible() dynamic WEP: " "is_network_compatible() dynamic WEP: "
"wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n", "wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n",
@ -244,9 +244,9 @@ static int is_network_compatible(struct lbs_adapter *adapter,
"is_network_compatible() FAILED: wpa_ie 0x%x " "is_network_compatible() FAILED: wpa_ie 0x%x "
"wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n", "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n",
bss->wpa_ie[0], bss->rsn_ie[0], bss->wpa_ie[0], bss->rsn_ie[0],
adapter->secinfo.wep_enabled ? "e" : "d", priv->secinfo.wep_enabled ? "e" : "d",
adapter->secinfo.WPAenabled ? "e" : "d", priv->secinfo.WPAenabled ? "e" : "d",
adapter->secinfo.WPA2enabled ? "e" : "d", priv->secinfo.WPA2enabled ? "e" : "d",
(bss->capability & WLAN_CAPABILITY_PRIVACY)); (bss->capability & WLAN_CAPABILITY_PRIVACY));
done: done:
@ -298,7 +298,6 @@ static int lbs_scan_create_channel_list(struct lbs_private *priv,
u8 filteredscan) u8 filteredscan)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct region_channel *scanregion; struct region_channel *scanregion;
struct chan_freq_power *cfp; struct chan_freq_power *cfp;
int rgnidx; int rgnidx;
@ -314,22 +313,22 @@ static int lbs_scan_create_channel_list(struct lbs_private *priv,
*/ */
scantype = CMD_SCAN_TYPE_ACTIVE; scantype = CMD_SCAN_TYPE_ACTIVE;
for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) { for (rgnidx = 0; rgnidx < ARRAY_SIZE(priv->region_channel); rgnidx++) {
if (priv->adapter->enable11d && if (priv->enable11d &&
(adapter->connect_status != LBS_CONNECTED) && (priv->connect_status != LBS_CONNECTED) &&
(adapter->mesh_connect_status != LBS_CONNECTED)) { (priv->mesh_connect_status != LBS_CONNECTED)) {
/* Scan all the supported chan for the first scan */ /* Scan all the supported chan for the first scan */
if (!adapter->universal_channel[rgnidx].valid) if (!priv->universal_channel[rgnidx].valid)
continue; continue;
scanregion = &adapter->universal_channel[rgnidx]; scanregion = &priv->universal_channel[rgnidx];
/* clear the parsed_region_chan for the first scan */ /* clear the parsed_region_chan for the first scan */
memset(&adapter->parsed_region_chan, 0x00, memset(&priv->parsed_region_chan, 0x00,
sizeof(adapter->parsed_region_chan)); sizeof(priv->parsed_region_chan));
} else { } else {
if (!adapter->region_channel[rgnidx].valid) if (!priv->region_channel[rgnidx].valid)
continue; continue;
scanregion = &adapter->region_channel[rgnidx]; scanregion = &priv->region_channel[rgnidx];
} }
for (nextchan = 0; for (nextchan = 0;
@ -337,10 +336,10 @@ static int lbs_scan_create_channel_list(struct lbs_private *priv,
cfp = scanregion->CFP + nextchan; cfp = scanregion->CFP + nextchan;
if (priv->adapter->enable11d) { if (priv->enable11d) {
scantype = scantype =
lbs_get_scan_type_11d(cfp->channel, lbs_get_scan_type_11d(cfp->channel,
&adapter-> &priv->
parsed_region_chan); parsed_region_chan);
} }
@ -540,7 +539,6 @@ int lbs_scan_networks(struct lbs_private *priv,
const struct lbs_ioctl_user_scan_cfg *user_cfg, const struct lbs_ioctl_user_scan_cfg *user_cfg,
int full_scan) int full_scan)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = -ENOMEM; int ret = -ENOMEM;
struct chanscanparamset *chan_list; struct chanscanparamset *chan_list;
struct chanscanparamset *curr_chans; struct chanscanparamset *curr_chans;
@ -598,12 +596,12 @@ int lbs_scan_networks(struct lbs_private *priv,
/* Prepare to continue an interrupted scan */ /* Prepare to continue an interrupted scan */
lbs_deb_scan("chan_count %d, last_scanned_channel %d\n", lbs_deb_scan("chan_count %d, last_scanned_channel %d\n",
chan_count, adapter->last_scanned_channel); chan_count, priv->last_scanned_channel);
curr_chans = chan_list; curr_chans = chan_list;
/* advance channel list by already-scanned-channels */ /* advance channel list by already-scanned-channels */
if (adapter->last_scanned_channel > 0) { if (priv->last_scanned_channel > 0) {
curr_chans += adapter->last_scanned_channel; curr_chans += priv->last_scanned_channel;
chan_count -= adapter->last_scanned_channel; chan_count -= priv->last_scanned_channel;
} }
/* Send scan command(s) /* Send scan command(s)
@ -627,12 +625,12 @@ int lbs_scan_networks(struct lbs_private *priv,
/* somehow schedule the next part of the scan */ /* somehow schedule the next part of the scan */
if (chan_count && if (chan_count &&
!full_scan && !full_scan &&
!priv->adapter->surpriseremoved) { !priv->surpriseremoved) {
/* -1 marks just that we're currently scanning */ /* -1 marks just that we're currently scanning */
if (adapter->last_scanned_channel < 0) if (priv->last_scanned_channel < 0)
adapter->last_scanned_channel = to_scan; priv->last_scanned_channel = to_scan;
else else
adapter->last_scanned_channel += to_scan; priv->last_scanned_channel += to_scan;
cancel_delayed_work(&priv->scan_work); cancel_delayed_work(&priv->scan_work);
queue_delayed_work(priv->work_thread, &priv->scan_work, queue_delayed_work(priv->work_thread, &priv->scan_work,
msecs_to_jiffies(300)); msecs_to_jiffies(300));
@ -646,24 +644,24 @@ int lbs_scan_networks(struct lbs_private *priv,
#ifdef CONFIG_LIBERTAS_DEBUG #ifdef CONFIG_LIBERTAS_DEBUG
/* Dump the scan table */ /* Dump the scan table */
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
lbs_deb_scan("scan table:\n"); lbs_deb_scan("scan table:\n");
list_for_each_entry(iter, &adapter->network_list, list) list_for_each_entry(iter, &priv->network_list, list)
lbs_deb_scan("%02d: BSSID %s, RSSI %d, SSID '%s'\n", lbs_deb_scan("%02d: BSSID %s, RSSI %d, SSID '%s'\n",
i++, print_mac(mac, iter->bssid), (s32) iter->rssi, i++, print_mac(mac, iter->bssid), (s32) iter->rssi,
escape_essid(iter->ssid, iter->ssid_len)); escape_essid(iter->ssid, iter->ssid_len));
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
#endif #endif
out2: out2:
adapter->last_scanned_channel = 0; priv->last_scanned_channel = 0;
out: out:
if (adapter->connect_status == LBS_CONNECTED) { if (priv->connect_status == LBS_CONNECTED) {
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
} }
if (priv->mesh_dev && (adapter->mesh_connect_status == LBS_CONNECTED)) { if (priv->mesh_dev && (priv->mesh_connect_status == LBS_CONNECTED)) {
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
@ -931,13 +929,13 @@ done:
* *
* Used in association code * Used in association code
* *
* @param adapter A pointer to struct lbs_adapter * @param priv A pointer to struct lbs_private
* @param bssid BSSID to find in the scan list * @param bssid BSSID to find in the scan list
* @param mode Network mode: Infrastructure or IBSS * @param mode Network mode: Infrastructure or IBSS
* *
* @return index in BSSID list, or error return code (< 0) * @return index in BSSID list, or error return code (< 0)
*/ */
struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_adapter *adapter, struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_private *priv,
u8 * bssid, u8 mode) u8 * bssid, u8 mode)
{ {
struct bss_descriptor * iter_bss; struct bss_descriptor * iter_bss;
@ -955,14 +953,14 @@ struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_adapter *adapter,
* continue past a matched bssid that is not compatible in case there * continue past a matched bssid that is not compatible in case there
* is an AP with multiple SSIDs assigned to the same BSSID * is an AP with multiple SSIDs assigned to the same BSSID
*/ */
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
list_for_each_entry (iter_bss, &adapter->network_list, list) { list_for_each_entry (iter_bss, &priv->network_list, list) {
if (compare_ether_addr(iter_bss->bssid, bssid)) if (compare_ether_addr(iter_bss->bssid, bssid))
continue; /* bssid doesn't match */ continue; /* bssid doesn't match */
switch (mode) { switch (mode) {
case IW_MODE_INFRA: case IW_MODE_INFRA:
case IW_MODE_ADHOC: case IW_MODE_ADHOC:
if (!is_network_compatible(adapter, iter_bss, mode)) if (!is_network_compatible(priv, iter_bss, mode))
break; break;
found_bss = iter_bss; found_bss = iter_bss;
break; break;
@ -971,7 +969,7 @@ struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_adapter *adapter,
break; break;
} }
} }
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
out: out:
lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss); lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss);
@ -983,14 +981,14 @@ out:
* *
* Used in association code * Used in association code
* *
* @param adapter A pointer to struct lbs_adapter * @param priv A pointer to struct lbs_private
* @param ssid SSID to find in the list * @param ssid SSID to find in the list
* @param bssid BSSID to qualify the SSID selection (if provided) * @param bssid BSSID to qualify the SSID selection (if provided)
* @param mode Network mode: Infrastructure or IBSS * @param mode Network mode: Infrastructure or IBSS
* *
* @return index in BSSID list * @return index in BSSID list
*/ */
struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_adapter *adapter, struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_private *priv,
u8 *ssid, u8 ssid_len, u8 * bssid, u8 mode, u8 *ssid, u8 ssid_len, u8 * bssid, u8 mode,
int channel) int channel)
{ {
@ -1001,9 +999,9 @@ struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_adapter *adapter,
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
list_for_each_entry (iter_bss, &adapter->network_list, list) { list_for_each_entry (iter_bss, &priv->network_list, list) {
if ( !tmp_oldest if ( !tmp_oldest
|| (iter_bss->last_scanned < tmp_oldest->last_scanned)) || (iter_bss->last_scanned < tmp_oldest->last_scanned))
tmp_oldest = iter_bss; tmp_oldest = iter_bss;
@ -1019,7 +1017,7 @@ struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_adapter *adapter,
switch (mode) { switch (mode) {
case IW_MODE_INFRA: case IW_MODE_INFRA:
case IW_MODE_ADHOC: case IW_MODE_ADHOC:
if (!is_network_compatible(adapter, iter_bss, mode)) if (!is_network_compatible(priv, iter_bss, mode))
break; break;
if (bssid) { if (bssid) {
@ -1044,7 +1042,7 @@ struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_adapter *adapter,
} }
out: out:
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss); lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss);
return found_bss; return found_bss;
} }
@ -1055,12 +1053,12 @@ out:
* Search the scan table for the best SSID that also matches the current * Search the scan table for the best SSID that also matches the current
* adapter network preference (infrastructure or adhoc) * adapter network preference (infrastructure or adhoc)
* *
* @param adapter A pointer to struct lbs_adapter * @param priv A pointer to struct lbs_private
* *
* @return index in BSSID list * @return index in BSSID list
*/ */
static struct bss_descriptor *lbs_find_best_ssid_in_list( static struct bss_descriptor *lbs_find_best_ssid_in_list(
struct lbs_adapter *adapter, struct lbs_private *priv,
u8 mode) u8 mode)
{ {
u8 bestrssi = 0; u8 bestrssi = 0;
@ -1069,13 +1067,13 @@ static struct bss_descriptor *lbs_find_best_ssid_in_list(
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
list_for_each_entry (iter_bss, &adapter->network_list, list) { list_for_each_entry (iter_bss, &priv->network_list, list) {
switch (mode) { switch (mode) {
case IW_MODE_INFRA: case IW_MODE_INFRA:
case IW_MODE_ADHOC: case IW_MODE_ADHOC:
if (!is_network_compatible(adapter, iter_bss, mode)) if (!is_network_compatible(priv, iter_bss, mode))
break; break;
if (SCAN_RSSI(iter_bss->rssi) <= bestrssi) if (SCAN_RSSI(iter_bss->rssi) <= bestrssi)
break; break;
@ -1092,7 +1090,7 @@ static struct bss_descriptor *lbs_find_best_ssid_in_list(
} }
} }
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
lbs_deb_leave_args(LBS_DEB_SCAN, "best_bss %p", best_bss); lbs_deb_leave_args(LBS_DEB_SCAN, "best_bss %p", best_bss);
return best_bss; return best_bss;
} }
@ -1110,17 +1108,16 @@ static struct bss_descriptor *lbs_find_best_ssid_in_list(
int lbs_find_best_network_ssid(struct lbs_private *priv, int lbs_find_best_network_ssid(struct lbs_private *priv,
u8 *out_ssid, u8 *out_ssid_len, u8 preferred_mode, u8 *out_mode) u8 *out_ssid, u8 *out_ssid_len, u8 preferred_mode, u8 *out_mode)
{ {
struct lbs_adapter *adapter = priv->adapter;
int ret = -1; int ret = -1;
struct bss_descriptor * found; struct bss_descriptor * found;
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
lbs_scan_networks(priv, NULL, 1); lbs_scan_networks(priv, NULL, 1);
if (adapter->surpriseremoved) if (priv->surpriseremoved)
goto out; goto out;
found = lbs_find_best_ssid_in_list(adapter, preferred_mode); found = lbs_find_best_ssid_in_list(priv, preferred_mode);
if (found && (found->ssid_len > 0)) { if (found && (found->ssid_len > 0)) {
memcpy(out_ssid, &found->ssid, IW_ESSID_MAX_SIZE); memcpy(out_ssid, &found->ssid, IW_ESSID_MAX_SIZE);
*out_ssid_len = found->ssid_len; *out_ssid_len = found->ssid_len;
@ -1150,7 +1147,6 @@ out:
int lbs_send_specific_ssid_scan(struct lbs_private *priv, int lbs_send_specific_ssid_scan(struct lbs_private *priv,
u8 *ssid, u8 ssid_len, u8 clear_ssid) u8 *ssid, u8 ssid_len, u8 clear_ssid)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct lbs_ioctl_user_scan_cfg scancfg; struct lbs_ioctl_user_scan_cfg scancfg;
int ret = 0; int ret = 0;
@ -1166,7 +1162,7 @@ int lbs_send_specific_ssid_scan(struct lbs_private *priv,
scancfg.clear_ssid = clear_ssid; scancfg.clear_ssid = clear_ssid;
lbs_scan_networks(priv, &scancfg, 1); lbs_scan_networks(priv, &scancfg, 1);
if (adapter->surpriseremoved) { if (priv->surpriseremoved) {
ret = -1; ret = -1;
goto out; goto out;
} }
@ -1192,7 +1188,6 @@ static inline char *lbs_translate_scan(struct lbs_private *priv,
char *start, char *stop, char *start, char *stop,
struct bss_descriptor *bss) struct bss_descriptor *bss)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct chan_freq_power *cfp; struct chan_freq_power *cfp;
char *current_val; /* For rates */ char *current_val; /* For rates */
struct iw_event iwe; /* Temporary buffer */ struct iw_event iwe; /* Temporary buffer */
@ -1204,7 +1199,7 @@ static inline char *lbs_translate_scan(struct lbs_private *priv,
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
cfp = lbs_find_cfp_by_band_and_channel(adapter, 0, bss->channel); cfp = lbs_find_cfp_by_band_and_channel(priv, 0, bss->channel);
if (!cfp) { if (!cfp) {
lbs_deb_scan("Invalid channel number %d\n", bss->channel); lbs_deb_scan("Invalid channel number %d\n", bss->channel);
start = NULL; start = NULL;
@ -1247,25 +1242,25 @@ static inline char *lbs_translate_scan(struct lbs_private *priv,
if (iwe.u.qual.qual > 100) if (iwe.u.qual.qual > 100)
iwe.u.qual.qual = 100; iwe.u.qual.qual = 100;
if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) { if (priv->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
iwe.u.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE; iwe.u.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
} else { } else {
iwe.u.qual.noise = iwe.u.qual.noise =
CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]); CAL_NF(priv->NF[TYPE_BEACON][TYPE_NOAVG]);
} }
/* Locally created ad-hoc BSSs won't have beacons if this is the /* Locally created ad-hoc BSSs won't have beacons if this is the
* only station in the adhoc network; so get signal strength * only station in the adhoc network; so get signal strength
* from receive statistics. * from receive statistics.
*/ */
if ((adapter->mode == IW_MODE_ADHOC) if ((priv->mode == IW_MODE_ADHOC)
&& adapter->adhoccreate && priv->adhoccreate
&& !lbs_ssid_cmp(adapter->curbssparams.ssid, && !lbs_ssid_cmp(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len, priv->curbssparams.ssid_len,
bss->ssid, bss->ssid_len)) { bss->ssid, bss->ssid_len)) {
int snr, nf; int snr, nf;
snr = adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE; snr = priv->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
nf = adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE; nf = priv->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
iwe.u.qual.level = CAL_RSSI(snr, nf); iwe.u.qual.level = CAL_RSSI(snr, nf);
} }
start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN); start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
@ -1294,10 +1289,10 @@ static inline char *lbs_translate_scan(struct lbs_private *priv,
stop, &iwe, IW_EV_PARAM_LEN); stop, &iwe, IW_EV_PARAM_LEN);
} }
if ((bss->mode == IW_MODE_ADHOC) if ((bss->mode == IW_MODE_ADHOC)
&& !lbs_ssid_cmp(adapter->curbssparams.ssid, && !lbs_ssid_cmp(priv->curbssparams.ssid,
adapter->curbssparams.ssid_len, priv->curbssparams.ssid_len,
bss->ssid, bss->ssid_len) bss->ssid, bss->ssid_len)
&& adapter->adhoccreate) { && priv->adhoccreate) {
iwe.u.bitrate.value = 22 * 500000; iwe.u.bitrate.value = 22 * 500000;
current_val = iwe_stream_add_value(start, current_val, current_val = iwe_stream_add_value(start, current_val,
stop, &iwe, IW_EV_PARAM_LEN); stop, &iwe, IW_EV_PARAM_LEN);
@ -1356,7 +1351,6 @@ int lbs_set_scan(struct net_device *dev, struct iw_request_info *info,
struct iw_param *wrqu, char *extra) struct iw_param *wrqu, char *extra)
{ {
struct lbs_private *priv = dev->priv; struct lbs_private *priv = dev->priv;
struct lbs_adapter *adapter = priv->adapter;
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
@ -1380,9 +1374,9 @@ int lbs_set_scan(struct net_device *dev, struct iw_request_info *info,
queue_delayed_work(priv->work_thread, &priv->scan_work, queue_delayed_work(priv->work_thread, &priv->scan_work,
msecs_to_jiffies(50)); msecs_to_jiffies(50));
/* set marker that currently a scan is taking place */ /* set marker that currently a scan is taking place */
adapter->last_scanned_channel = -1; priv->last_scanned_channel = -1;
if (adapter->surpriseremoved) if (priv->surpriseremoved)
return -EIO; return -EIO;
lbs_deb_leave(LBS_DEB_SCAN); lbs_deb_leave(LBS_DEB_SCAN);
@ -1405,7 +1399,6 @@ int lbs_get_scan(struct net_device *dev, struct iw_request_info *info,
{ {
#define SCAN_ITEM_SIZE 128 #define SCAN_ITEM_SIZE 128
struct lbs_private *priv = dev->priv; struct lbs_private *priv = dev->priv;
struct lbs_adapter *adapter = priv->adapter;
int err = 0; int err = 0;
char *ev = extra; char *ev = extra;
char *stop = ev + dwrq->length; char *stop = ev + dwrq->length;
@ -1415,17 +1408,17 @@ int lbs_get_scan(struct net_device *dev, struct iw_request_info *info,
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
/* iwlist should wait until the current scan is finished */ /* iwlist should wait until the current scan is finished */
if (adapter->last_scanned_channel) if (priv->last_scanned_channel)
return -EAGAIN; return -EAGAIN;
/* Update RSSI if current BSS is a locally created ad-hoc BSS */ /* Update RSSI if current BSS is a locally created ad-hoc BSS */
if ((adapter->mode == IW_MODE_ADHOC) && adapter->adhoccreate) { if ((priv->mode == IW_MODE_ADHOC) && priv->adhoccreate) {
lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
CMD_OPTION_WAITFORRSP, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
} }
mutex_lock(&adapter->lock); mutex_lock(&priv->lock);
list_for_each_entry_safe (iter_bss, safe, &adapter->network_list, list) { list_for_each_entry_safe (iter_bss, safe, &priv->network_list, list) {
char * next_ev; char * next_ev;
unsigned long stale_time; unsigned long stale_time;
@ -1442,7 +1435,7 @@ int lbs_get_scan(struct net_device *dev, struct iw_request_info *info,
stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE; stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE;
if (time_after(jiffies, stale_time)) { if (time_after(jiffies, stale_time)) {
list_move_tail (&iter_bss->list, list_move_tail (&iter_bss->list,
&adapter->network_free_list); &priv->network_free_list);
clear_bss_descriptor(iter_bss); clear_bss_descriptor(iter_bss);
continue; continue;
} }
@ -1453,7 +1446,7 @@ int lbs_get_scan(struct net_device *dev, struct iw_request_info *info,
continue; continue;
ev = next_ev; ev = next_ev;
} }
mutex_unlock(&adapter->lock); mutex_unlock(&priv->lock);
dwrq->length = (ev - extra); dwrq->length = (ev - extra);
dwrq->flags = 0; dwrq->flags = 0;
@ -1538,7 +1531,6 @@ int lbs_cmd_80211_scan(struct lbs_private *priv,
*/ */
int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp) int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct cmd_ds_802_11_scan_rsp *pscan; struct cmd_ds_802_11_scan_rsp *pscan;
struct bss_descriptor * iter_bss; struct bss_descriptor * iter_bss;
struct bss_descriptor * safe; struct bss_descriptor * safe;
@ -1552,11 +1544,11 @@ int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp)
lbs_deb_enter(LBS_DEB_SCAN); lbs_deb_enter(LBS_DEB_SCAN);
/* Prune old entries from scan table */ /* Prune old entries from scan table */
list_for_each_entry_safe (iter_bss, safe, &adapter->network_list, list) { list_for_each_entry_safe (iter_bss, safe, &priv->network_list, list) {
unsigned long stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE; unsigned long stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE;
if (time_before(jiffies, stale_time)) if (time_before(jiffies, stale_time))
continue; continue;
list_move_tail (&iter_bss->list, &adapter->network_free_list); list_move_tail (&iter_bss->list, &priv->network_free_list);
clear_bss_descriptor(iter_bss); clear_bss_descriptor(iter_bss);
} }
@ -1609,7 +1601,7 @@ int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp)
} }
/* Try to find this bss in the scan table */ /* Try to find this bss in the scan table */
list_for_each_entry (iter_bss, &adapter->network_list, list) { list_for_each_entry (iter_bss, &priv->network_list, list) {
if (is_same_network(iter_bss, &new)) { if (is_same_network(iter_bss, &new)) {
found = iter_bss; found = iter_bss;
break; break;
@ -1623,16 +1615,16 @@ int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp)
if (found) { if (found) {
/* found, clear it */ /* found, clear it */
clear_bss_descriptor(found); clear_bss_descriptor(found);
} else if (!list_empty(&adapter->network_free_list)) { } else if (!list_empty(&priv->network_free_list)) {
/* Pull one from the free list */ /* Pull one from the free list */
found = list_entry(adapter->network_free_list.next, found = list_entry(priv->network_free_list.next,
struct bss_descriptor, list); struct bss_descriptor, list);
list_move_tail(&found->list, &adapter->network_list); list_move_tail(&found->list, &priv->network_list);
} else if (oldest) { } else if (oldest) {
/* If there are no more slots, expire the oldest */ /* If there are no more slots, expire the oldest */
found = oldest; found = oldest;
clear_bss_descriptor(found); clear_bss_descriptor(found);
list_move_tail(&found->list, &adapter->network_list); list_move_tail(&found->list, &priv->network_list);
} else { } else {
continue; continue;
} }

6
drivers/net/wireless/libertas/scan.h
View File

@ -10,8 +10,6 @@
#include <net/ieee80211.h> #include <net/ieee80211.h>
#include "hostcmd.h" #include "hostcmd.h"
struct lbs_adapter;
/** /**
* @brief Maximum number of channels that can be sent in a setuserscan ioctl * @brief Maximum number of channels that can be sent in a setuserscan ioctl
* *
@ -168,11 +166,11 @@ struct bss_descriptor {
int lbs_ssid_cmp(u8 *ssid1, u8 ssid1_len, u8 *ssid2, u8 ssid2_len); int lbs_ssid_cmp(u8 *ssid1, u8 ssid1_len, u8 *ssid2, u8 ssid2_len);
struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_adapter *adapter, struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_private *priv,
u8 *ssid, u8 ssid_len, u8 *bssid, u8 mode, u8 *ssid, u8 ssid_len, u8 *bssid, u8 mode,
int channel); int channel);
struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_adapter *adapter, struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_private *priv,
u8 *bssid, u8 mode); u8 *bssid, u8 mode);
int lbs_find_best_network_ssid(struct lbs_private *priv, u8 *out_ssid, int lbs_find_best_network_ssid(struct lbs_private *priv, u8 *out_ssid,

63
drivers/net/wireless/libertas/tx.c
View File

@ -64,11 +64,11 @@ static int SendSinglePacket(struct lbs_private *priv, struct sk_buff *skb)
u8 *p802x_hdr; u8 *p802x_hdr;
struct tx_radiotap_hdr *pradiotap_hdr; struct tx_radiotap_hdr *pradiotap_hdr;
u32 new_rate; u32 new_rate;
u8 *ptr = priv->adapter->tmptxbuf; u8 *ptr = priv->tmptxbuf;
lbs_deb_enter(LBS_DEB_TX); lbs_deb_enter(LBS_DEB_TX);
if (priv->adapter->surpriseremoved) if (priv->surpriseremoved)
return -1; return -1;
if (!skb->len || (skb->len > MRVDRV_ETH_TX_PACKET_BUFFER_SIZE)) { if (!skb->len || (skb->len > MRVDRV_ETH_TX_PACKET_BUFFER_SIZE)) {
@ -86,7 +86,7 @@ static int SendSinglePacket(struct lbs_private *priv, struct sk_buff *skb)
plocaltxpd->tx_packet_location = cpu_to_le32(sizeof(struct txpd)); plocaltxpd->tx_packet_location = cpu_to_le32(sizeof(struct txpd));
p802x_hdr = skb->data; p802x_hdr = skb->data;
if (priv->adapter->monitormode != LBS_MONITOR_OFF) { if (priv->monitormode != LBS_MONITOR_OFF) {
/* locate radiotap header */ /* locate radiotap header */
pradiotap_hdr = (struct tx_radiotap_hdr *)skb->data; pradiotap_hdr = (struct tx_radiotap_hdr *)skb->data;
@ -106,7 +106,7 @@ static int SendSinglePacket(struct lbs_private *priv, struct sk_buff *skb)
} }
/* copy destination address from 802.3 or 802.11 header */ /* copy destination address from 802.3 or 802.11 header */
if (priv->adapter->monitormode != LBS_MONITOR_OFF) if (priv->monitormode != LBS_MONITOR_OFF)
memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr + 4, ETH_ALEN); memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr + 4, ETH_ALEN);
else else
memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr, ETH_ALEN); memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr, ETH_ALEN);
@ -124,7 +124,7 @@ static int SendSinglePacket(struct lbs_private *priv, struct sk_buff *skb)
lbs_deb_hex(LBS_DEB_TX, "Tx Data", (u8 *) p802x_hdr, le16_to_cpu(plocaltxpd->tx_packet_length)); lbs_deb_hex(LBS_DEB_TX, "Tx Data", (u8 *) p802x_hdr, le16_to_cpu(plocaltxpd->tx_packet_length));
memcpy(ptr, p802x_hdr, le16_to_cpu(plocaltxpd->tx_packet_length)); memcpy(ptr, p802x_hdr, le16_to_cpu(plocaltxpd->tx_packet_length));
ret = priv->hw_host_to_card(priv, MVMS_DAT, ret = priv->hw_host_to_card(priv, MVMS_DAT,
priv->adapter->tmptxbuf, priv->tmptxbuf,
le16_to_cpu(plocaltxpd->tx_packet_length) + le16_to_cpu(plocaltxpd->tx_packet_length) +
sizeof(struct txpd)); sizeof(struct txpd));
@ -144,7 +144,7 @@ done:
priv->stats.tx_errors++; priv->stats.tx_errors++;
} }
if (!ret && priv->adapter->monitormode != LBS_MONITOR_OFF) { if (!ret && priv->monitormode != LBS_MONITOR_OFF) {
/* Keep the skb to echo it back once Tx feedback is /* Keep the skb to echo it back once Tx feedback is
received from FW */ received from FW */
skb_orphan(skb); skb_orphan(skb);
@ -154,7 +154,7 @@ done:
netif_stop_queue(priv->mesh_dev); netif_stop_queue(priv->mesh_dev);
/* Keep the skb around for when we get feedback */ /* Keep the skb around for when we get feedback */
priv->adapter->currenttxskb = skb; priv->currenttxskb = skb;
} else { } else {
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
} }
@ -166,29 +166,27 @@ done:
void lbs_tx_runqueue(struct lbs_private *priv) void lbs_tx_runqueue(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
int i; int i;
spin_lock(&adapter->txqueue_lock); spin_lock(&priv->txqueue_lock);
for (i = 0; i < adapter->tx_queue_idx; i++) { for (i = 0; i < priv->tx_queue_idx; i++) {
struct sk_buff *skb = adapter->tx_queue_ps[i]; struct sk_buff *skb = priv->tx_queue_ps[i];
spin_unlock(&adapter->txqueue_lock); spin_unlock(&priv->txqueue_lock);
SendSinglePacket(priv, skb); SendSinglePacket(priv, skb);
spin_lock(&adapter->txqueue_lock); spin_lock(&priv->txqueue_lock);
} }
adapter->tx_queue_idx = 0; priv->tx_queue_idx = 0;
spin_unlock(&adapter->txqueue_lock); spin_unlock(&priv->txqueue_lock);
} }
static void lbs_tx_queue(struct lbs_private *priv, struct sk_buff *skb) static void lbs_tx_queue(struct lbs_private *priv, struct sk_buff *skb)
{ {
struct lbs_adapter *adapter = priv->adapter;
spin_lock(&adapter->txqueue_lock); spin_lock(&priv->txqueue_lock);
WARN_ON(priv->adapter->tx_queue_idx >= NR_TX_QUEUE); WARN_ON(priv->tx_queue_idx >= NR_TX_QUEUE);
adapter->tx_queue_ps[adapter->tx_queue_idx++] = skb; priv->tx_queue_ps[priv->tx_queue_idx++] = skb;
if (adapter->tx_queue_idx == NR_TX_QUEUE) { if (priv->tx_queue_idx == NR_TX_QUEUE) {
netif_stop_queue(priv->dev); netif_stop_queue(priv->dev);
if (priv->mesh_dev) if (priv->mesh_dev)
netif_stop_queue(priv->mesh_dev); netif_stop_queue(priv->mesh_dev);
@ -198,7 +196,7 @@ static void lbs_tx_queue(struct lbs_private *priv, struct sk_buff *skb)
netif_start_queue(priv->mesh_dev); netif_start_queue(priv->mesh_dev);
} }
spin_unlock(&adapter->txqueue_lock); spin_unlock(&priv->txqueue_lock);
} }
/** /**
@ -221,8 +219,8 @@ int lbs_process_tx(struct lbs_private *priv, struct sk_buff *skb)
goto done; goto done;
} }
if ((priv->adapter->psstate == PS_STATE_SLEEP) || if ((priv->psstate == PS_STATE_SLEEP) ||
(priv->adapter->psstate == PS_STATE_PRE_SLEEP)) { (priv->psstate == PS_STATE_PRE_SLEEP)) {
lbs_tx_queue(priv, skb); lbs_tx_queue(priv, skb);
return ret; return ret;
} }
@ -244,17 +242,16 @@ done:
*/ */
void lbs_send_tx_feedback(struct lbs_private *priv) void lbs_send_tx_feedback(struct lbs_private *priv)
{ {
struct lbs_adapter *adapter = priv->adapter;
struct tx_radiotap_hdr *radiotap_hdr; struct tx_radiotap_hdr *radiotap_hdr;
u32 status = adapter->eventcause; u32 status = priv->eventcause;
int txfail; int txfail;
int try_count; int try_count;
if (adapter->monitormode == LBS_MONITOR_OFF || if (priv->monitormode == LBS_MONITOR_OFF ||
adapter->currenttxskb == NULL) priv->currenttxskb == NULL)
return; return;
radiotap_hdr = (struct tx_radiotap_hdr *)adapter->currenttxskb->data; radiotap_hdr = (struct tx_radiotap_hdr *)priv->currenttxskb->data;
txfail = (status >> 24); txfail = (status >> 24);
@ -267,14 +264,14 @@ void lbs_send_tx_feedback(struct lbs_private *priv)
#endif #endif
try_count = (status >> 16) & 0xff; try_count = (status >> 16) & 0xff;
radiotap_hdr->data_retries = (try_count) ? radiotap_hdr->data_retries = (try_count) ?
(1 + adapter->txretrycount - try_count) : 0; (1 + priv->txretrycount - try_count) : 0;
lbs_upload_rx_packet(priv, adapter->currenttxskb); lbs_upload_rx_packet(priv, priv->currenttxskb);
adapter->currenttxskb = NULL; priv->currenttxskb = NULL;
if (adapter->connect_status == LBS_CONNECTED) if (priv->connect_status == LBS_CONNECTED)
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
if (priv->mesh_dev && (adapter->mesh_connect_status == LBS_CONNECTED)) if (priv->mesh_dev && (priv->mesh_connect_status == LBS_CONNECTED))
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
EXPORT_SYMBOL_GPL(lbs_send_tx_feedback); EXPORT_SYMBOL_GPL(lbs_send_tx_feedback);

372
drivers/net/wireless/libertas/wext.c
View File

File diff suppressed because it is too large Load Diff