lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[PATCH] libertas: re-uppercase command defines and other constants

Browse Source 
For readability.

Signed-off-by: Dan Williams <dcbw@redhat.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Dan Williams
2007-08-02 11:31:18 -04:00
committed by David S. Miller
parent b44898eb2c
commit 0aef64d758
16 changed files with 697 additions and 697 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -422,13 +422,13 @@ done:
u8 libertas_get_scan_type_11d(u8 chan, u8 libertas_get_scan_type_11d(u8 chan,
struct parsed_region_chan_11d * parsed_region_chan) struct parsed_region_chan_11d * parsed_region_chan)
{ {
u8 scan_type = cmd_scan_type_passive; u8 scan_type = CMD_SCAN_TYPE_PASSIVE;
lbs_deb_enter(LBS_DEB_11D); lbs_deb_enter(LBS_DEB_11D);
if (wlan_channel_known_11d(chan, parsed_region_chan)) { if (wlan_channel_known_11d(chan, parsed_region_chan)) {
lbs_deb_11d("11D: Found and do Active Scan\n"); lbs_deb_11d("11D: Found and do Active Scan\n");
scan_type = cmd_scan_type_active; scan_type = CMD_SCAN_TYPE_ACTIVE;
} else { } else {
lbs_deb_11d("11D: Not Find and do Passive Scan\n"); lbs_deb_11d("11D: Not Find and do Passive Scan\n");
} }
@@ -454,9 +454,9 @@ static int wlan_enable_11d(wlan_private * priv, u8 flag)
/* send cmd to FW to enable/disable 11D function in FW */ /* send cmd to FW to enable/disable 11D function in FW */
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_snmp_mib, CMD_802_11_SNMP_MIB,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
OID_802_11D_ENABLE, OID_802_11D_ENABLE,
&priv->adapter->enable11d); &priv->adapter->enable11d);
if (ret) if (ret)
@@ -479,9 +479,9 @@ static int set_domain_info_11d(wlan_private * priv)
return 0; return 0;
} }
ret = libertas_prepare_and_send_command(priv, cmd_802_11d_domain_info, ret = libertas_prepare_and_send_command(priv, CMD_802_11D_DOMAIN_INFO,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (ret) if (ret)
lbs_deb_11d("11D: Fail to dnld domain Info\n"); lbs_deb_11d("11D: Fail to dnld domain Info\n");
@@ -541,7 +541,7 @@ int libertas_cmd_802_11d_domain_info(wlan_private * priv,
cmd->command = cpu_to_le16(cmdno); cmd->command = cpu_to_le16(cmdno);
pdomaininfo->action = cpu_to_le16(cmdoption); pdomaininfo->action = cpu_to_le16(cmdoption);
if (cmdoption == cmd_act_get) { if (cmdoption == CMD_ACT_GET) {
cmd->size = cmd->size =
cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN); cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);
lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd, lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd,
@@ -633,10 +633,10 @@ int libertas_ret_802_11d_domain_info(wlan_private * priv,
} }
switch (action) { switch (action) {
case cmd_act_set: /*Proc Set action */ case CMD_ACT_SET: /*Proc Set action */
break; break;
case cmd_act_get: case CMD_ACT_GET:
break; break;
default: default:
lbs_deb_11d("Invalid action:%d\n", domaininfo->action); lbs_deb_11d("Invalid action:%d\n", domaininfo->action);

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

@@ -175,14 +175,14 @@ static int assoc_helper_mode(wlan_private *priv,
if (assoc_req->mode == IW_MODE_INFRA) { if (assoc_req->mode == IW_MODE_INFRA) {
if (adapter->psstate != PS_STATE_FULL_POWER) if (adapter->psstate != PS_STATE_FULL_POWER)
libertas_ps_wakeup(priv, cmd_option_waitforrsp); libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
adapter->psmode = wlan802_11powermodecam; adapter->psmode = WLAN802_11POWERMODECAM;
} }
adapter->mode = assoc_req->mode; adapter->mode = assoc_req->mode;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_snmp_mib, CMD_802_11_SNMP_MIB,
0, cmd_option_waitforrsp, 0, CMD_OPTION_WAITFORRSP,
OID_802_11_INFRASTRUCTURE_MODE, OID_802_11_INFRASTRUCTURE_MODE,
/* Shoot me now */ (void *) (size_t) assoc_req->mode); /* Shoot me now */ (void *) (size_t) assoc_req->mode);
@@ -195,9 +195,9 @@ done:
static int update_channel(wlan_private * priv) static int update_channel(wlan_private * priv)
{ {
/* the channel in f/w could be out of sync, get the current channel */ /* the channel in f/w could be out of sync, get the current channel */
return libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel, return libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
cmd_opt_802_11_rf_channel_get, CMD_OPT_802_11_RF_CHANNEL_GET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
} }
void libertas_sync_channel(struct work_struct *work) void libertas_sync_channel(struct work_struct *work)
@@ -227,9 +227,9 @@ static int assoc_helper_channel(wlan_private *priv,
lbs_deb_assoc("ASSOC: channel: %d -> %d\n", lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
adapter->curbssparams.channel, assoc_req->channel); adapter->curbssparams.channel, assoc_req->channel);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel, ret = libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
cmd_opt_802_11_rf_channel_set, CMD_OPT_802_11_RF_CHANNEL_SET,
cmd_option_waitforrsp, 0, &assoc_req->channel); CMD_OPTION_WAITFORRSP, 0, &assoc_req->channel);
if (ret < 0) { if (ret < 0) {
lbs_deb_assoc("ASSOC: channel: error setting channel."); lbs_deb_assoc("ASSOC: channel: error setting channel.");
} }
@@ -278,15 +278,15 @@ static int assoc_helper_wep_keys(wlan_private *priv,
|| assoc_req->wep_keys[2].len || assoc_req->wep_keys[2].len
|| assoc_req->wep_keys[3].len) { || assoc_req->wep_keys[3].len) {
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_set_wep, CMD_802_11_SET_WEP,
cmd_act_add, CMD_ACT_ADD,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
0, assoc_req); 0, assoc_req);
} else { } else {
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_set_wep, CMD_802_11_SET_WEP,
cmd_act_remove, CMD_ACT_REMOVE,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
0, NULL); 0, NULL);
} }
@@ -295,9 +295,9 @@ static int assoc_helper_wep_keys(wlan_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; adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
else else
adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable; adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
ret = libertas_set_mac_packet_filter(priv); ret = libertas_set_mac_packet_filter(priv);
if (ret) if (ret)
goto out; goto out;
@@ -342,9 +342,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
/* Get RSN enabled/disabled */ /* Get RSN enabled/disabled */
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_enable_rsn, CMD_802_11_ENABLE_RSN,
cmd_act_set, CMD_ACT_GET,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
0, &rsn); 0, &rsn);
if (ret) { if (ret) {
lbs_deb_assoc("Failed to get RSN status: %d", ret); lbs_deb_assoc("Failed to get RSN status: %d", ret);
@@ -359,9 +359,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
/* Set RSN enabled/disabled */ /* Set RSN enabled/disabled */
rsn = do_wpa; rsn = do_wpa;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_enable_rsn, CMD_802_11_ENABLE_RSN,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
0, &rsn); 0, &rsn);
out: out:
@@ -378,9 +378,9 @@ static int assoc_helper_wpa_keys(wlan_private *priv,
lbs_deb_enter(LBS_DEB_ASSOC); lbs_deb_enter(LBS_DEB_ASSOC);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_key_material, CMD_802_11_KEY_MATERIAL,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
0, assoc_req); 0, assoc_req);
lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@@ -412,7 +412,7 @@ static int assoc_helper_wpa_ie(wlan_private *priv,
static int should_deauth_infrastructure(wlan_adapter *adapter, static int should_deauth_infrastructure(wlan_adapter *adapter,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
if (adapter->connect_status != libertas_connected) if (adapter->connect_status != LIBERTAS_CONNECTED)
return 0; return 0;
if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) { if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
@@ -453,7 +453,7 @@ static int should_deauth_infrastructure(wlan_adapter *adapter,
static int should_stop_adhoc(wlan_adapter *adapter, static int should_stop_adhoc(wlan_adapter *adapter,
struct assoc_request * assoc_req) struct assoc_request * assoc_req)
{ {
if (adapter->connect_status != libertas_connected) if (adapter->connect_status != LIBERTAS_CONNECTED)
return 0; return 0;
if (libertas_ssid_cmp(adapter->curbssparams.ssid, if (libertas_ssid_cmp(adapter->curbssparams.ssid,
@@ -623,7 +623,7 @@ void libertas_association_worker(struct work_struct *work)
success = 0; success = 0;
} }
if (adapter->connect_status != libertas_connected) { if (adapter->connect_status != LIBERTAS_CONNECTED) {
lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, " lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, "
"not connected.\n"); "not connected.\n");
success = 0; success = 0;
@@ -636,12 +636,12 @@ void libertas_association_worker(struct work_struct *work)
adapter->curbssparams.ssid_len), adapter->curbssparams.ssid_len),
MAC_ARG(adapter->curbssparams.bssid)); MAC_ARG(adapter->curbssparams.bssid));
libertas_prepare_and_send_command(priv, libertas_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);
libertas_prepare_and_send_command(priv, libertas_prepare_and_send_command(priv,
cmd_802_11_get_log, CMD_802_11_GET_LOG,
0, cmd_option_waitforrsp, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
} else { } else {
ret = -1; ret = -1;
} }

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

@@ -15,7 +15,7 @@
static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode); static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode);
static u16 commands_allowed_in_ps[] = { static u16 commands_allowed_in_ps[] = {
cmd_802_11_rssi, CMD_802_11_RSSI,
}; };
/** /**
@@ -43,7 +43,7 @@ static int wlan_cmd_hw_spec(wlan_private * priv, struct cmd_ds_command *cmd)
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_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->adapter->current_addr, ETH_ALEN);
@@ -60,13 +60,13 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(cmd_802_11_ps_mode); cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
S_DS_GEN); S_DS_GEN);
psm->action = cpu_to_le16(cmd_action); psm->action = cpu_to_le16(cmd_action);
psm->multipledtim = 0; psm->multipledtim = 0;
switch (cmd_action) { switch (cmd_action) {
case cmd_subcmd_enter_ps: case CMD_SUBCMD_ENTER_PS:
lbs_deb_cmd("PS command:" "SubCode- Enter PS\n"); lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
lbs_deb_cmd("locallisteninterval = %d\n", lbs_deb_cmd("locallisteninterval = %d\n",
adapter->locallisteninterval); adapter->locallisteninterval);
@@ -79,11 +79,11 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
cpu_to_le16(priv->adapter->multipledtim); cpu_to_le16(priv->adapter->multipledtim);
break; break;
case cmd_subcmd_exit_ps: case CMD_SUBCMD_EXIT_PS:
lbs_deb_cmd("PS command:" "SubCode- Exit PS\n"); lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
break; break;
case cmd_subcmd_sleep_confirmed: case CMD_SUBCMD_SLEEP_CONFIRMED:
lbs_deb_cmd("PS command: SubCode- sleep confirm\n"); lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
break; break;
@@ -101,7 +101,7 @@ static int wlan_cmd_802_11_inactivity_timeout(wlan_private * priv,
{ {
u16 *timeout = pdata_buf; u16 *timeout = pdata_buf;
cmd->command = cpu_to_le16(cmd_802_11_inactivity_timeout); cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
cmd->size = cmd->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout) cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout)
+ S_DS_GEN); + S_DS_GEN);
@@ -127,13 +127,13 @@ static int wlan_cmd_802_11_sleep_params(wlan_private * priv,
cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) + cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) +
S_DS_GEN); S_DS_GEN);
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(&adapter->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(adapter->sp.sp_error);
sp->offset = cpu_to_le16(adapter->sp.sp_offset); sp->offset = cpu_to_le16(adapter->sp.sp_offset);
@@ -159,10 +159,10 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(cmd_802_11_set_wep); cmd->command = cpu_to_le16(CMD_802_11_SET_WEP);
cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN);
if (cmd_act == cmd_act_add) { if (cmd_act == CMD_ACT_ADD) {
int i; int i;
if (!assoc_req) { if (!assoc_req) {
@@ -171,11 +171,11 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
goto done; goto done;
} }
wep->action = cpu_to_le16(cmd_act_add); wep->action = cpu_to_le16(CMD_ACT_ADD);
/* default tx key index */ /* default tx key index */
wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx & wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx &
(u32)cmd_WEP_KEY_INDEX_MASK)); (u32)CMD_WEP_KEY_INDEX_MASK));
lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex)); lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex));
@@ -186,13 +186,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
switch (pkey->len) { switch (pkey->len) {
case KEY_LEN_WEP_40: case KEY_LEN_WEP_40:
wep->keytype[i] = wep->keytype[i] =
cpu_to_le16(cmd_type_wep_40_bit); cpu_to_le16(CMD_TYPE_WEP_40_BIT);
memmove(&wep->keymaterial[i], pkey->key, memmove(&wep->keymaterial[i], pkey->key,
pkey->len); pkey->len);
break; break;
case KEY_LEN_WEP_104: case KEY_LEN_WEP_104:
wep->keytype[i] = wep->keytype[i] =
cpu_to_le16(cmd_type_wep_104_bit); cpu_to_le16(CMD_TYPE_WEP_104_BIT);
memmove(&wep->keymaterial[i], pkey->key, memmove(&wep->keymaterial[i], pkey->key,
pkey->len); pkey->len);
break; break;
@@ -206,13 +206,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
break; break;
} }
} }
} else if (cmd_act == cmd_act_remove) { } else if (cmd_act == CMD_ACT_REMOVE) {
/* ACT_REMOVE clears _all_ WEP keys */ /* ACT_REMOVE clears _all_ WEP keys */
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)(adapter->wep_tx_keyidx &
(u32)cmd_WEP_KEY_INDEX_MASK)); (u32)CMD_WEP_KEY_INDEX_MASK));
} }
ret = 0; ret = 0;
@@ -232,15 +232,15 @@ static int wlan_cmd_802_11_enable_rsn(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(cmd_802_11_enable_rsn); cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
penableRSN->action = cpu_to_le16(cmd_action); penableRSN->action = cpu_to_le16(cmd_action);
if (cmd_action == cmd_act_set) { if (cmd_action == CMD_ACT_SET) {
if (*enable) if (*enable)
penableRSN->enable = cpu_to_le16(cmd_enable_rsn); penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
else else
penableRSN->enable = cpu_to_le16(cmd_disable_rsn); penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
} }
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
@@ -284,10 +284,10 @@ static int wlan_cmd_802_11_key_material(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(cmd_802_11_key_material); cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
pkeymaterial->action = cpu_to_le16(cmd_action); pkeymaterial->action = cpu_to_le16(cmd_action);
if (cmd_action == cmd_act_get) { if (cmd_action == CMD_ACT_GET) {
cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action)); cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
ret = 0; ret = 0;
goto done; goto done;
@@ -323,7 +323,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
{ {
struct cmd_ds_802_11_reset *reset = &cmd->params.reset; struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
cmd->command = cpu_to_le16(cmd_802_11_reset); cmd->command = cpu_to_le16(CMD_802_11_RESET);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
reset->action = cpu_to_le16(cmd_action); reset->action = cpu_to_le16(cmd_action);
@@ -333,7 +333,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
static int wlan_cmd_802_11_get_log(wlan_private * priv, static int wlan_cmd_802_11_get_log(wlan_private * priv,
struct cmd_ds_command *cmd) struct cmd_ds_command *cmd)
{ {
cmd->command = cpu_to_le16(cmd_802_11_get_log); cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
cmd->size = cmd->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN); cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
@@ -343,7 +343,7 @@ static int wlan_cmd_802_11_get_log(wlan_private * priv,
static int wlan_cmd_802_11_get_stat(wlan_private * priv, static int wlan_cmd_802_11_get_stat(wlan_private * priv,
struct cmd_ds_command *cmd) struct cmd_ds_command *cmd)
{ {
cmd->command = cpu_to_le16(cmd_802_11_get_stat); cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
cmd->size = cmd->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN); cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
@@ -363,15 +363,15 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid); lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
cmd->command = cpu_to_le16(cmd_802_11_snmp_mib); cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
switch (cmd_oid) { switch (cmd_oid) {
case OID_802_11_INFRASTRUCTURE_MODE: case OID_802_11_INFRASTRUCTURE_MODE:
{ {
u8 mode = (u8) (size_t) pdata_buf; u8 mode = (u8) (size_t) pdata_buf;
pSNMPMIB->querytype = cpu_to_le16(cmd_act_set); pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
pSNMPMIB->oid = cpu_to_le16((u16) desired_bsstype_i); pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
pSNMPMIB->bufsize = sizeof(u8); pSNMPMIB->bufsize = sizeof(u8);
if (mode == IW_MODE_ADHOC) { if (mode == IW_MODE_ADHOC) {
ucTemp = SNMP_MIB_VALUE_ADHOC; ucTemp = SNMP_MIB_VALUE_ADHOC;
@@ -389,10 +389,10 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
{ {
u32 ulTemp; u32 ulTemp;
pSNMPMIB->oid = cpu_to_le16((u16) dot11d_i); pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
if (cmd_action == cmd_act_set) { if (cmd_action == CMD_ACT_SET) {
pSNMPMIB->querytype = cmd_act_set; pSNMPMIB->querytype = CMD_ACT_SET;
pSNMPMIB->bufsize = sizeof(u16); pSNMPMIB->bufsize = sizeof(u16);
ulTemp = *(u32 *)pdata_buf; ulTemp = *(u32 *)pdata_buf;
*((__le16 *)(pSNMPMIB->value)) = *((__le16 *)(pSNMPMIB->value)) =
@@ -405,12 +405,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
{ {
u32 ulTemp; u32 ulTemp;
pSNMPMIB->oid = cpu_to_le16((u16) fragthresh_i); pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
if (cmd_action == cmd_act_get) { if (cmd_action == CMD_ACT_GET) {
pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
} else if (cmd_action == cmd_act_set) { } else if (cmd_action == CMD_ACT_SET) {
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));
ulTemp = *((u32 *) pdata_buf); ulTemp = *((u32 *) pdata_buf);
*((__le16 *)(pSNMPMIB->value)) = *((__le16 *)(pSNMPMIB->value)) =
@@ -425,12 +425,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
{ {
u32 ulTemp; u32 ulTemp;
pSNMPMIB->oid = le16_to_cpu((u16) rtsthresh_i); pSNMPMIB->oid = le16_to_cpu((u16) RTSTHRESH_I);
if (cmd_action == cmd_act_get) { if (cmd_action == CMD_ACT_GET) {
pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
} else if (cmd_action == cmd_act_set) { } else if (cmd_action == CMD_ACT_SET) {
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));
ulTemp = *((u32 *)pdata_buf); ulTemp = *((u32 *)pdata_buf);
*(__le16 *)(pSNMPMIB->value) = *(__le16 *)(pSNMPMIB->value) =
@@ -440,12 +440,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
break; break;
} }
case OID_802_11_TX_RETRYCOUNT: case OID_802_11_TX_RETRYCOUNT:
pSNMPMIB->oid = cpu_to_le16((u16) short_retrylim_i); pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
if (cmd_action == cmd_act_get) { if (cmd_action == CMD_ACT_GET) {
pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
} else if (cmd_action == cmd_act_set) { } else if (cmd_action == CMD_ACT_SET) {
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) adapter->txretrycount);
@@ -483,20 +483,20 @@ static int wlan_cmd_802_11_radio_control(wlan_private * priv,
cmd->size = cmd->size =
cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) + cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) +
S_DS_GEN); S_DS_GEN);
cmd->command = cpu_to_le16(cmd_802_11_radio_control); cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL);
pradiocontrol->action = cpu_to_le16(cmd_action); pradiocontrol->action = cpu_to_le16(cmd_action);
switch (adapter->preamble) { switch (adapter->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;
case cmd_type_long_preamble: case CMD_TYPE_LONG_PREAMBLE:
pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE); pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE);
break; break;
case cmd_type_auto_preamble: case CMD_TYPE_AUTO_PREAMBLE:
default: default:
pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE); pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE);
break; break;
@@ -522,7 +522,7 @@ static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
cmd->size = cmd->size =
cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN); cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
cmd->command = cpu_to_le16(cmd_802_11_rf_tx_power); cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
prtp->action = cpu_to_le16(cmd_action); prtp->action = cpu_to_le16(cmd_action);
lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n", lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
@@ -530,23 +530,23 @@ static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
le16_to_cpu(prtp->action)); le16_to_cpu(prtp->action));
switch (cmd_action) { switch (cmd_action) {
case cmd_act_tx_power_opt_get: case CMD_ACT_TX_POWER_OPT_GET:
prtp->action = cpu_to_le16(cmd_act_get); prtp->action = cpu_to_le16(CMD_ACT_GET);
prtp->currentlevel = 0; prtp->currentlevel = 0;
break; break;
case cmd_act_tx_power_opt_set_high: case CMD_ACT_TX_POWER_OPT_SET_HIGH:
prtp->action = cpu_to_le16(cmd_act_set); prtp->action = cpu_to_le16(CMD_ACT_SET);
prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_high); prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
break; break;
case cmd_act_tx_power_opt_set_mid: case CMD_ACT_TX_POWER_OPT_SET_MID:
prtp->action = cpu_to_le16(cmd_act_set); prtp->action = cpu_to_le16(CMD_ACT_SET);
prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_mid); prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
break; break;
case cmd_act_tx_power_opt_set_low: case CMD_ACT_TX_POWER_OPT_SET_LOW:
prtp->action = cpu_to_le16(cmd_act_set); prtp->action = cpu_to_le16(CMD_ACT_SET);
prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf)); prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
break; break;
} }
@@ -561,12 +561,12 @@ static int wlan_cmd_802_11_rf_antenna(wlan_private * priv,
{ {
struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant; struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant;
cmd->command = cpu_to_le16(cmd_802_11_rf_antenna); cmd->command = cpu_to_le16(CMD_802_11_RF_ANTENNA);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) +
S_DS_GEN); S_DS_GEN);
rant->action = cpu_to_le16(cmd_action); rant->action = cpu_to_le16(cmd_action);
if ((cmd_action == cmd_act_set_rx) || (cmd_action == cmd_act_set_tx)) { if ((cmd_action == CMD_ACT_SET_rx) || (cmd_action == CMD_ACT_SET_tx)) {
rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf)); rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf));
} }
@@ -584,7 +584,7 @@ static int wlan_cmd_802_11_rate_adapt_rateset(wlan_private * priv,
cmd->size = cmd->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset) cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
+ S_DS_GEN); + S_DS_GEN);
cmd->command = cpu_to_le16(cmd_802_11_rate_adapt_rateset); cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
@@ -608,17 +608,17 @@ static int wlan_cmd_802_11_data_rate(wlan_private * priv,
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) +
S_DS_GEN); S_DS_GEN);
cmd->command = cpu_to_le16(cmd_802_11_data_rate); cmd->command = cpu_to_le16(CMD_802_11_DATA_RATE);
memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate)); memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate));
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->datarate[0] = libertas_data_rate_to_index(adapter->datarate); pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate);
lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n", lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n",
adapter->datarate); adapter->datarate);
} else if (cmd_action == cmd_act_set_tx_auto) { } else if (cmd_action == CMD_ACT_SET_tx_auto) {
lbs_deb_cmd("Setting FW for AUTO rate\n"); lbs_deb_cmd("Setting FW for AUTO rate\n");
} }
@@ -635,7 +635,7 @@ static int wlan_cmd_mac_multicast_adr(wlan_private * priv,
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
S_DS_GEN); S_DS_GEN);
cmd->command = cpu_to_le16(cmd_mac_multicast_adr); cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
pMCastAdr->action = cpu_to_le16(cmd_action); pMCastAdr->action = cpu_to_le16(cmd_action);
pMCastAdr->nr_of_adrs = pMCastAdr->nr_of_adrs =
@@ -652,11 +652,11 @@ static int wlan_cmd_802_11_rf_channel(wlan_private * priv,
{ {
struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel; struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel;
cmd->command = cpu_to_le16(cmd_802_11_rf_channel); cmd->command = cpu_to_le16(CMD_802_11_RF_CHANNEL);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) +
S_DS_GEN); S_DS_GEN);
if (option == cmd_opt_802_11_rf_channel_set) { if (option == CMD_OPT_802_11_RF_CHANNEL_SET) {
rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf)); rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf));
} }
@@ -670,7 +670,7 @@ static int wlan_cmd_802_11_rssi(wlan_private * priv,
{ {
wlan_adapter *adapter = priv->adapter; wlan_adapter *adapter = priv->adapter;
cmd->command = cpu_to_le16(cmd_802_11_rssi); cmd->command = cpu_to_le16(CMD_802_11_RSSI);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor); cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor);
@@ -696,7 +696,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
offval = (struct wlan_offset_value *)pdata_buf; offval = (struct wlan_offset_value *)pdata_buf;
switch (cmdptr->command) { switch (cmdptr->command) {
case cmd_mac_reg_access: case CMD_MAC_REG_ACCESS:
{ {
struct cmd_ds_mac_reg_access *macreg; struct cmd_ds_mac_reg_access *macreg;
@@ -714,7 +714,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
break; break;
} }
case cmd_bbp_reg_access: case CMD_BBP_REG_ACCESS:
{ {
struct cmd_ds_bbp_reg_access *bbpreg; struct cmd_ds_bbp_reg_access *bbpreg;
@@ -733,7 +733,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
break; break;
} }
case cmd_rf_reg_access: case CMD_RF_REG_ACCESS:
{ {
struct cmd_ds_rf_reg_access *rfreg; struct cmd_ds_rf_reg_access *rfreg;
@@ -766,14 +766,14 @@ static int wlan_cmd_802_11_mac_address(wlan_private * priv,
{ {
wlan_adapter *adapter = priv->adapter; wlan_adapter *adapter = priv->adapter;
cmd->command = cpu_to_le16(cmd_802_11_mac_address); cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
S_DS_GEN); S_DS_GEN);
cmd->result = 0; cmd->result = 0;
cmd->params.macadd.action = cpu_to_le16(cmd_action); cmd->params.macadd.action = cpu_to_le16(cmd_action);
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); adapter->current_addr, ETH_ALEN);
lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6); lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6);
@@ -790,7 +790,7 @@ static int wlan_cmd_802_11_eeprom_access(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
cmd->command = cpu_to_le16(cmd_802_11_eeprom_access); cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
S_DS_GEN); S_DS_GEN);
cmd->result = 0; cmd->result = 0;
@@ -810,29 +810,29 @@ static int wlan_cmd_bt_access(wlan_private * priv,
struct cmd_ds_bt_access *bt_access = &cmd->params.bt; struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
lbs_deb_cmd("BT CMD(%d)\n", cmd_action); lbs_deb_cmd("BT CMD(%d)\n", cmd_action);
cmd->command = cpu_to_le16(cmd_bt_access); cmd->command = cpu_to_le16(CMD_BT_ACCESS);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
cmd->result = 0; cmd->result = 0;
bt_access->action = cpu_to_le16(cmd_action); bt_access->action = cpu_to_le16(cmd_action);
switch (cmd_action) { switch (cmd_action) {
case cmd_act_bt_access_add: case CMD_ACT_BT_ACCESS_ADD:
memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN); memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6); lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6);
break; break;
case cmd_act_bt_access_del: case CMD_ACT_BT_ACCESS_DEL:
memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN); memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6); lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6);
break; break;
case cmd_act_bt_access_list: case CMD_ACT_BT_ACCESS_LIST:
bt_access->id = cpu_to_le32(*(u32 *) pdata_buf); bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
break; break;
case cmd_act_bt_access_reset: case CMD_ACT_BT_ACCESS_RESET:
break; break;
case cmd_act_bt_access_set_invert: case CMD_ACT_BT_ACCESS_SET_INVERT:
bt_access->id = cpu_to_le32(*(u32 *) pdata_buf); bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
break; break;
case cmd_act_bt_access_get_invert: case CMD_ACT_BT_ACCESS_GET_INVERT:
break; break;
default: default:
break; break;
@@ -847,7 +847,7 @@ static int wlan_cmd_fwt_access(wlan_private * priv,
struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt; struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
lbs_deb_cmd("FWT CMD(%d)\n", cmd_action); lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
cmd->command = cpu_to_le16(cmd_fwt_access); cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
cmd->result = 0; cmd->result = 0;
@@ -868,7 +868,7 @@ static int wlan_cmd_mesh_access(wlan_private * priv,
struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh; struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh;
lbs_deb_cmd("FWT CMD(%d)\n", cmd_action); lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
cmd->command = cpu_to_le16(cmd_mesh_access); cmd->command = cpu_to_le16(CMD_MESH_ACCESS);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN);
cmd->result = 0; cmd->result = 0;
@@ -901,9 +901,9 @@ void libertas_queue_cmd(wlan_adapter * adapter, struct cmd_ctrl_node *cmdnode, u
} }
/* Exit_PS command needs to be queued in the header always. */ /* Exit_PS command needs to be queued in the header always. */
if (cmdptr->command == cmd_802_11_ps_mode) { if (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 (adapter->psstate != PS_STATE_FULL_POWER)
addtail = 0; addtail = 0;
} }
@@ -1000,8 +1000,8 @@ static int DownloadcommandToStation(wlan_private * priv,
lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize); lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize);
/* 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(&adapter->command_timer, jiffies + (10*HZ));
else else
mod_timer(&adapter->command_timer, jiffies + (5*HZ)); mod_timer(&adapter->command_timer, jiffies + (5*HZ));
@@ -1020,7 +1020,7 @@ static int wlan_cmd_mac_control(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
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->adapter->currentpacketfilter);
@@ -1064,9 +1064,9 @@ int libertas_set_radio_control(wlan_private * priv)
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_radio_control, CMD_802_11_RADIO_CONTROL,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n", lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n",
priv->adapter->radioon, priv->adapter->preamble); priv->adapter->radioon, priv->adapter->preamble);
@@ -1086,7 +1086,7 @@ int libertas_set_mac_packet_filter(wlan_private * priv)
/* Send MAC control command to station */ /* Send MAC control command to station */
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_mac_control, 0, 0, 0, NULL); CMD_MAC_CONTROL, 0, 0, 0, NULL);
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
return ret; return ret;
@@ -1161,136 +1161,136 @@ int libertas_prepare_and_send_command(wlan_private * priv,
cmdptr->result = 0; cmdptr->result = 0;
switch (cmd_no) { switch (cmd_no) {
case cmd_get_hw_spec: case CMD_GET_HW_SPEC:
ret = wlan_cmd_hw_spec(priv, cmdptr); ret = wlan_cmd_hw_spec(priv, cmdptr);
break; break;
case cmd_802_11_ps_mode: case CMD_802_11_PS_MODE:
ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_scan: case CMD_802_11_SCAN:
ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf); ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf);
break; break;
case cmd_mac_control: case CMD_MAC_CONTROL:
ret = wlan_cmd_mac_control(priv, cmdptr); ret = wlan_cmd_mac_control(priv, cmdptr);
break; break;
case cmd_802_11_associate: case CMD_802_11_ASSOCIATE:
case cmd_802_11_reassociate: case CMD_802_11_REASSOCIATE:
ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf); ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf);
break; break;
case cmd_802_11_deauthenticate: case CMD_802_11_DEAUTHENTICATE:
ret = libertas_cmd_80211_deauthenticate(priv, cmdptr); ret = libertas_cmd_80211_deauthenticate(priv, cmdptr);
break; break;
case cmd_802_11_set_wep: case CMD_802_11_SET_WEP:
ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf); ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf);
break; break;
case cmd_802_11_ad_hoc_start: case CMD_802_11_AD_HOC_START:
ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf); ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
break; break;
case cmd_code_dnld: case CMD_CODE_DNLD:
break; break;
case cmd_802_11_reset: case CMD_802_11_RESET:
ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_get_log: case CMD_802_11_GET_LOG:
ret = wlan_cmd_802_11_get_log(priv, cmdptr); ret = wlan_cmd_802_11_get_log(priv, cmdptr);
break; break;
case cmd_802_11_authenticate: case CMD_802_11_AUTHENTICATE:
ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf); ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
break; break;
case cmd_802_11_get_stat: case CMD_802_11_GET_STAT:
ret = wlan_cmd_802_11_get_stat(priv, cmdptr); ret = wlan_cmd_802_11_get_stat(priv, cmdptr);
break; break;
case cmd_802_11_snmp_mib: case CMD_802_11_SNMP_MIB:
ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr, ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr,
cmd_action, cmd_oid, pdata_buf); cmd_action, cmd_oid, pdata_buf);
break; break;
case cmd_mac_reg_access: case CMD_MAC_REG_ACCESS:
case cmd_bbp_reg_access: case CMD_BBP_REG_ACCESS:
case cmd_rf_reg_access: case CMD_RF_REG_ACCESS:
ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf); ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
break; break;
case cmd_802_11_rf_channel: case CMD_802_11_RF_CHANNEL:
ret = wlan_cmd_802_11_rf_channel(priv, cmdptr, ret = wlan_cmd_802_11_rf_channel(priv, cmdptr,
cmd_action, pdata_buf); cmd_action, pdata_buf);
break; break;
case cmd_802_11_rf_tx_power: case CMD_802_11_RF_TX_POWER:
ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr, ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr,
cmd_action, pdata_buf); cmd_action, pdata_buf);
break; break;
case cmd_802_11_radio_control: case CMD_802_11_RADIO_CONTROL:
ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_rf_antenna: case CMD_802_11_RF_ANTENNA:
ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr, ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr,
cmd_action, pdata_buf); cmd_action, pdata_buf);
break; break;
case cmd_802_11_data_rate: case CMD_802_11_DATA_RATE:
ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_rate_adapt_rateset: case CMD_802_11_RATE_ADAPT_RATESET:
ret = wlan_cmd_802_11_rate_adapt_rateset(priv, ret = wlan_cmd_802_11_rate_adapt_rateset(priv,
cmdptr, cmd_action); cmdptr, cmd_action);
break; break;
case cmd_mac_multicast_adr: case CMD_MAC_MULTICAST_ADR:
ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action); ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_ad_hoc_join: case CMD_802_11_AD_HOC_JOIN:
ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf); ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
break; break;
case cmd_802_11_rssi: case CMD_802_11_RSSI:
ret = wlan_cmd_802_11_rssi(priv, cmdptr); ret = wlan_cmd_802_11_rssi(priv, cmdptr);
break; break;
case cmd_802_11_ad_hoc_stop: case CMD_802_11_AD_HOC_STOP:
ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr); ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr);
break; break;
case cmd_802_11_enable_rsn: case CMD_802_11_ENABLE_RSN:
ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action, ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
pdata_buf); pdata_buf);
break; break;
case cmd_802_11_key_material: case CMD_802_11_KEY_MATERIAL:
ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action, ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action,
cmd_oid, pdata_buf); cmd_oid, pdata_buf);
break; break;
case cmd_802_11_pairwise_tsc: case CMD_802_11_PAIRWISE_TSC:
break; break;
case cmd_802_11_group_tsc: case CMD_802_11_GROUP_TSC:
break; break;
case cmd_802_11_mac_address: case CMD_802_11_MAC_ADDRESS:
ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_eeprom_access: case CMD_802_11_EEPROM_ACCESS:
ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr, ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr,
cmd_action, pdata_buf); cmd_action, pdata_buf);
break; break;
case cmd_802_11_set_afc: case CMD_802_11_SET_AFC:
case cmd_802_11_get_afc: case CMD_802_11_GET_AFC:
cmdptr->command = cpu_to_le16(cmd_no); cmdptr->command = cpu_to_le16(cmd_no);
cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) + cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
@@ -1302,22 +1302,22 @@ int libertas_prepare_and_send_command(wlan_private * priv,
ret = 0; ret = 0;
goto done; goto done;
case cmd_802_11d_domain_info: case CMD_802_11D_DOMAIN_INFO:
ret = libertas_cmd_802_11d_domain_info(priv, cmdptr, ret = libertas_cmd_802_11d_domain_info(priv, cmdptr,
cmd_no, cmd_action); cmd_no, cmd_action);
break; break;
case cmd_802_11_sleep_params: case CMD_802_11_SLEEP_PARAMS:
ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action); ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action);
break; break;
case cmd_802_11_inactivity_timeout: case CMD_802_11_INACTIVITY_TIMEOUT:
ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr, ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr,
cmd_action, pdata_buf); cmd_action, pdata_buf);
libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf); libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf);
break; break;
case cmd_802_11_tpc_cfg: case CMD_802_11_TPC_CFG:
cmdptr->command = cpu_to_le16(cmd_802_11_tpc_cfg); cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
cmdptr->size = cmdptr->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) + cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
S_DS_GEN); S_DS_GEN);
@@ -1327,7 +1327,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
ret = 0; ret = 0;
break; break;
case cmd_802_11_led_gpio_ctrl: case CMD_802_11_LED_GPIO_CTRL:
{ {
struct mrvlietypes_ledgpio *gpio = struct mrvlietypes_ledgpio *gpio =
(struct mrvlietypes_ledgpio*) (struct mrvlietypes_ledgpio*)
@@ -1338,7 +1338,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
sizeof(struct cmd_ds_802_11_led_ctrl)); sizeof(struct cmd_ds_802_11_led_ctrl));
cmdptr->command = cmdptr->command =
cpu_to_le16(cmd_802_11_led_gpio_ctrl); cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
#define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
cmdptr->size = cmdptr->size =
@@ -1349,8 +1349,8 @@ int libertas_prepare_and_send_command(wlan_private * priv,
ret = 0; ret = 0;
break; break;
} }
case cmd_802_11_pwr_cfg: case CMD_802_11_PWR_CFG:
cmdptr->command = cpu_to_le16(cmd_802_11_pwr_cfg); cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
cmdptr->size = cmdptr->size =
cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) + cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
S_DS_GEN); S_DS_GEN);
@@ -1359,26 +1359,26 @@ int libertas_prepare_and_send_command(wlan_private * priv,
ret = 0; ret = 0;
break; break;
case cmd_bt_access: case CMD_BT_ACCESS:
ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf); ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
break; break;
case cmd_fwt_access: case CMD_FWT_ACCESS:
ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf); ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
break; break;
case cmd_mesh_access: case CMD_MESH_ACCESS:
ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf); ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf);
break; break;
case cmd_get_tsf: case CMD_GET_TSF:
cmdptr->command = cpu_to_le16(cmd_get_tsf); cmdptr->command = cpu_to_le16(CMD_GET_TSF);
cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) + cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
S_DS_GEN); S_DS_GEN);
ret = 0; ret = 0;
break; break;
case cmd_802_11_tx_rate_query: case CMD_802_11_TX_RATE_QUERY:
cmdptr->command = cpu_to_le16(cmd_802_11_tx_rate_query); cmdptr->command = cpu_to_le16(CMD_802_11_TX_RATE_QUERY);
cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) + cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) +
S_DS_GEN); S_DS_GEN);
adapter->txrate = 0; adapter->txrate = 0;
@@ -1404,7 +1404,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
adapter->nr_cmd_pending++; adapter->nr_cmd_pending++;
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
if (wait_option & cmd_option_waitforrsp) { if (wait_option & CMD_OPTION_WAITFORRSP) {
lbs_deb_cmd("PREP_CMD: Wait for CMD response\n"); lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
might_sleep(); might_sleep();
wait_event_interruptible(cmdnode->cmdwait_q, wait_event_interruptible(cmdnode->cmdwait_q,
@@ -1680,7 +1680,7 @@ int libertas_execute_next_command(wlan_private * priv)
* immediately. * immediately.
*/ */
if (cmdptr->command != if (cmdptr->command !=
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 ((adapter->psstate == PS_STATE_SLEEP)
@@ -1706,7 +1706,7 @@ int libertas_execute_next_command(wlan_private * priv)
"EXEC_NEXT_CMD: PS cmd- action=0x%x\n", "EXEC_NEXT_CMD: PS cmd- action=0x%x\n",
psm->action); psm->action);
if (psm->action != if (psm->action !=
cpu_to_le16(cmd_subcmd_exit_ps)) { cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
lbs_deb_cmd( lbs_deb_cmd(
"EXEC_NEXT_CMD: Ignore Enter PS cmd\n"); "EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
list_del((struct list_head *)cmdnode); list_del((struct list_head *)cmdnode);
@@ -1741,9 +1741,9 @@ int libertas_execute_next_command(wlan_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 != wlan802_11powermodecam) && if ((adapter->psmode != WLAN802_11POWERMODECAM) &&
(adapter->psstate == PS_STATE_FULL_POWER) && (adapter->psstate == PS_STATE_FULL_POWER) &&
(adapter->connect_status == libertas_connected)) { (adapter->connect_status == LIBERTAS_CONNECTED)) {
if (adapter->secinfo.WPAenabled || if (adapter->secinfo.WPAenabled ||
adapter->secinfo.WPA2enabled) { adapter->secinfo.WPA2enabled) {
/* check for valid WPA group keys */ /* check for valid WPA group keys */
@@ -1845,8 +1845,8 @@ void libertas_ps_sleep(wlan_private * priv, int wait_option)
* Remove this check if it is to be supported in IBSS mode also * Remove this check if it is to be supported in IBSS mode also
*/ */
libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode, libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
cmd_subcmd_enter_ps, wait_option, 0, NULL); CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);
} }
@@ -1864,12 +1864,12 @@ void libertas_ps_wakeup(wlan_private * priv, int wait_option)
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
Localpsmode = cpu_to_le32(wlan802_11powermodecam); Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", wlan802_11powermodecam); lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", WLAN802_11POWERMODECAM);
libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode, libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
cmd_subcmd_exit_ps, CMD_SUBCMD_EXIT_PS,
wait_option, 0, &Localpsmode); wait_option, 0, &Localpsmode);
lbs_deb_leave(LBS_DEB_CMD); lbs_deb_leave(LBS_DEB_CMD);

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

@@ -28,7 +28,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
wlan_adapter *adapter = priv->adapter; wlan_adapter *adapter = priv->adapter;
union iwreq_data wrqu; union iwreq_data wrqu;
if (adapter->connect_status != libertas_connected) if (adapter->connect_status != LIBERTAS_CONNECTED)
return; return;
lbs_deb_cmd("Handles disconnect event.\n"); lbs_deb_cmd("Handles disconnect event.\n");
@@ -69,7 +69,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
escape_essid(adapter->prev_ssid, adapter->prev_ssid_len), escape_essid(adapter->prev_ssid, adapter->prev_ssid_len),
adapter->prev_ssid_len); adapter->prev_ssid_len);
adapter->connect_status = libertas_disconnected; adapter->connect_status = LIBERTAS_DISCONNECTED;
/* Save previous SSID and BSSID for possible reassociation */ /* Save previous SSID and BSSID for possible reassociation */
memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid, memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid,
@@ -124,7 +124,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
switch (type) { switch (type) {
case cmd_ret_mac_reg_access: case CMD_RET_MAC_REG_ACCESS:
{ {
struct cmd_ds_mac_reg_access *reg = &resp->params.macreg; struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
@@ -133,7 +133,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
break; break;
} }
case cmd_ret_bbp_reg_access: case CMD_RET_BBP_REG_ACCESS:
{ {
struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg; struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
@@ -142,7 +142,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
break; break;
} }
case cmd_ret_rf_reg_access: case CMD_RET_RF_REG_ACCESS:
{ {
struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg; struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
@@ -274,21 +274,21 @@ static int wlan_ret_802_11_snmp_mib(wlan_private * priv,
querytype); querytype);
lbs_deb_cmd("SNMP_RESP: Buf size = %x\n", le16_to_cpu(smib->bufsize)); lbs_deb_cmd("SNMP_RESP: Buf size = %x\n", le16_to_cpu(smib->bufsize));
if (querytype == cmd_act_get) { if (querytype == CMD_ACT_GET) {
switch (oid) { switch (oid) {
case fragthresh_i: case FRAGTHRESH_I:
priv->adapter->fragthsd = priv->adapter->fragthsd =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n", lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n",
priv->adapter->fragthsd); priv->adapter->fragthsd);
break; break;
case rtsthresh_i: case RTSTHRESH_I:
priv->adapter->rtsthsd = priv->adapter->rtsthsd =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n", lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n",
priv->adapter->rtsthsd); priv->adapter->rtsthsd);
break; break;
case short_retrylim_i: case SHORT_RETRYLIM_I:
priv->adapter->txretrycount = priv->adapter->txretrycount =
le16_to_cpu(*((__le16 *)(smib->value))); le16_to_cpu(*((__le16 *)(smib->value)));
lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n", lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n",
@@ -314,7 +314,7 @@ static int wlan_ret_802_11_key_material(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
/* Copy the returned key to driver private data */ /* Copy the returned key to driver private data */
if (action == cmd_act_get) { if (action == CMD_ACT_GET) {
u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet; u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;
u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size)); u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
@@ -396,10 +396,10 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
wlan_adapter *adapter = priv->adapter; wlan_adapter *adapter = priv->adapter;
u16 action = le16_to_cpu(pAntenna->action); u16 action = le16_to_cpu(pAntenna->action);
if (action == cmd_act_get_rx) if (action == CMD_ACT_GET_rx)
adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode); adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);
if (action == cmd_act_get_tx) if (action == CMD_ACT_GET_tx)
adapter->txantennamode = le16_to_cpu(pAntenna->antennamode); adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);
lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n", lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n",
@@ -416,7 +416,7 @@ static int wlan_ret_802_11_rate_adapt_rateset(wlan_private * priv,
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); adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
adapter->ratebitmap = le16_to_cpu(rates->bitmap); adapter->ratebitmap = le16_to_cpu(rates->bitmap);
} }
@@ -438,7 +438,7 @@ static int wlan_ret_802_11_data_rate(wlan_private * priv,
(u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate)); (u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate));
dot11datarate = pdatarate->datarate[0]; dot11datarate = pdatarate->datarate[0];
if (pdatarate->action == cpu_to_le16(cmd_act_get_tx_rate)) { if (pdatarate->action == cpu_to_le16(CMD_ACT_GET_tx_rate)) {
memcpy(adapter->libertas_supported_rates, pdatarate->datarate, memcpy(adapter->libertas_supported_rates, pdatarate->datarate,
sizeof(adapter->libertas_supported_rates)); sizeof(adapter->libertas_supported_rates));
} }
@@ -458,7 +458,7 @@ static int wlan_ret_802_11_rf_channel(wlan_private * priv,
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) { && adapter->curbssparams.channel != newchannel) {
lbs_deb_cmd("channel Switch: %d to %d\n", lbs_deb_cmd("channel Switch: %d to %d\n",
adapter->curbssparams.channel, newchannel); adapter->curbssparams.channel, newchannel);
@@ -547,7 +547,7 @@ static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
lbs_deb_enter(LBS_DEB_CMD); lbs_deb_enter(LBS_DEB_CMD);
if (enable_rsn->action == cpu_to_le16(cmd_act_get)) { if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
if (pdata_buf) if (pdata_buf)
*pdata_buf = (u32) le16_to_cpu(enable_rsn->enable); *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
} }
@@ -565,134 +565,134 @@ static inline int handle_cmd_response(u16 respcmd,
wlan_adapter *adapter = priv->adapter; wlan_adapter *adapter = priv->adapter;
switch (respcmd) { switch (respcmd) {
case cmd_ret_mac_reg_access: case CMD_RET_MAC_REG_ACCESS:
case cmd_ret_bbp_reg_access: case CMD_RET_BBP_REG_ACCESS:
case cmd_ret_rf_reg_access: case CMD_RET_RF_REG_ACCESS:
ret = wlan_ret_reg_access(priv, respcmd, resp); ret = wlan_ret_reg_access(priv, respcmd, resp);
break; break;
case cmd_ret_hw_spec_info: case CMD_RET_HW_SPEC_INFO:
ret = wlan_ret_get_hw_spec(priv, resp); ret = wlan_ret_get_hw_spec(priv, resp);
break; break;
case cmd_ret_802_11_scan: case CMD_RET_802_11_SCAN:
ret = libertas_ret_80211_scan(priv, resp); ret = libertas_ret_80211_scan(priv, resp);
break; break;
case cmd_ret_802_11_get_log: case CMD_RET_802_11_GET_LOG:
ret = wlan_ret_get_log(priv, resp); ret = wlan_ret_get_log(priv, resp);
break; break;
case cmd_ret_802_11_associate: case CMD_RET_802_11_ASSOCIATE:
case cmd_ret_802_11_reassociate: case CMD_RET_802_11_REASSOCIATE:
ret = libertas_ret_80211_associate(priv, resp); ret = libertas_ret_80211_associate(priv, resp);
break; break;
case cmd_ret_802_11_disassociate: case CMD_RET_802_11_DISASSOCIATE:
case cmd_ret_802_11_deauthenticate: case CMD_RET_802_11_DEAUTHENTICATE:
ret = libertas_ret_80211_disassociate(priv, resp); ret = libertas_ret_80211_disassociate(priv, resp);
break; break;
case cmd_ret_802_11_ad_hoc_start: case CMD_RET_802_11_AD_HOC_START:
case cmd_ret_802_11_ad_hoc_join: case CMD_RET_802_11_AD_HOC_JOIN:
ret = libertas_ret_80211_ad_hoc_start(priv, resp); ret = libertas_ret_80211_ad_hoc_start(priv, resp);
break; break;
case cmd_ret_802_11_stat: case CMD_RET_802_11_STAT:
ret = wlan_ret_802_11_stat(priv, resp); ret = wlan_ret_802_11_stat(priv, resp);
break; break;
case cmd_ret_802_11_snmp_mib: case CMD_RET_802_11_SNMP_MIB:
ret = wlan_ret_802_11_snmp_mib(priv, resp); ret = wlan_ret_802_11_snmp_mib(priv, resp);
break; break;
case cmd_ret_802_11_rf_tx_power: case CMD_RET_802_11_RF_TX_POWER:
ret = wlan_ret_802_11_rf_tx_power(priv, resp); ret = wlan_ret_802_11_rf_tx_power(priv, resp);
break; break;
case cmd_ret_802_11_set_afc: case CMD_RET_802_11_SET_AFC:
case cmd_ret_802_11_get_afc: case CMD_RET_802_11_GET_AFC:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc, memmove(adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_802_11_rf_antenna: case CMD_RET_802_11_RF_ANTENNA:
ret = wlan_ret_802_11_rf_antenna(priv, resp); ret = wlan_ret_802_11_rf_antenna(priv, resp);
break; break;
case cmd_ret_mac_multicast_adr: case CMD_RET_MAC_MULTICAST_ADR:
case cmd_ret_mac_control: case CMD_RET_MAC_CONTROL:
case cmd_ret_802_11_set_wep: case CMD_RET_802_11_SET_WEP:
case cmd_ret_802_11_reset: case CMD_RET_802_11_RESET:
case cmd_ret_802_11_authenticate: case CMD_RET_802_11_AUTHENTICATE:
case cmd_ret_802_11_radio_control: case CMD_RET_802_11_RADIO_CONTROL:
case cmd_ret_802_11_beacon_stop: case CMD_RET_802_11_BEACON_STOP:
break; break;
case cmd_ret_802_11_enable_rsn: case CMD_RET_802_11_ENABLE_RSN:
ret = libertas_ret_802_11_enable_rsn(priv, resp); ret = libertas_ret_802_11_enable_rsn(priv, resp);
break; break;
case cmd_ret_802_11_data_rate: case CMD_RET_802_11_DATA_RATE:
ret = wlan_ret_802_11_data_rate(priv, resp); ret = wlan_ret_802_11_data_rate(priv, resp);
break; break;
case cmd_ret_802_11_rate_adapt_rateset: case CMD_RET_802_11_RATE_ADAPT_RATESET:
ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp); ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
break; break;
case cmd_ret_802_11_rf_channel: case CMD_RET_802_11_RF_CHANNEL:
ret = wlan_ret_802_11_rf_channel(priv, resp); ret = wlan_ret_802_11_rf_channel(priv, resp);
break; break;
case cmd_ret_802_11_rssi: case CMD_RET_802_11_RSSI:
ret = wlan_ret_802_11_rssi(priv, resp); ret = wlan_ret_802_11_rssi(priv, resp);
break; break;
case cmd_ret_802_11_mac_address: case CMD_RET_802_11_MAC_ADDRESS:
ret = wlan_ret_802_11_mac_address(priv, resp); ret = wlan_ret_802_11_mac_address(priv, resp);
break; break;
case cmd_ret_802_11_ad_hoc_stop: case CMD_RET_802_11_AD_HOC_STOP:
ret = libertas_ret_80211_ad_hoc_stop(priv, resp); ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
break; break;
case cmd_ret_802_11_key_material: case CMD_RET_802_11_KEY_MATERIAL:
lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n"); lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n");
ret = wlan_ret_802_11_key_material(priv, resp); ret = wlan_ret_802_11_key_material(priv, resp);
break; break;
case cmd_ret_802_11_eeprom_access: case CMD_RET_802_11_EEPROM_ACCESS:
ret = wlan_ret_802_11_eeprom_access(priv, resp); ret = wlan_ret_802_11_eeprom_access(priv, resp);
break; break;
case cmd_ret_802_11d_domain_info: case CMD_RET_802_11D_DOMAIN_INFO:
ret = libertas_ret_802_11d_domain_info(priv, resp); ret = libertas_ret_802_11d_domain_info(priv, resp);
break; break;
case cmd_ret_802_11_sleep_params: case CMD_RET_802_11_SLEEP_PARAMS:
ret = wlan_ret_802_11_sleep_params(priv, resp); ret = wlan_ret_802_11_sleep_params(priv, resp);
break; break;
case cmd_ret_802_11_inactivity_timeout: case CMD_RET_802_11_INACTIVITY_TIMEOUT:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
*((u16 *) adapter->cur_cmd->pdata_buf) = *((u16 *) adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_802_11_tpc_cfg: case CMD_RET_802_11_TPC_CFG:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg, memmove(adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_802_11_led_gpio_ctrl: case CMD_RET_802_11_LED_GPIO_CTRL:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio, memmove(adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_802_11_pwr_cfg: case CMD_RET_802_11_PWR_CFG:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg, memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
sizeof(struct cmd_ds_802_11_pwr_cfg)); sizeof(struct cmd_ds_802_11_pwr_cfg));
@@ -700,32 +700,32 @@ static inline int handle_cmd_response(u16 respcmd,
break; break;
case cmd_ret_get_tsf: case CMD_RET_GET_TSF:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
memcpy(priv->adapter->cur_cmd->pdata_buf, memcpy(priv->adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_bt_access: case CMD_RET_BT_ACCESS:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
if (adapter->cur_cmd->pdata_buf) if (adapter->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, memcpy(adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_fwt_access: case CMD_RET_FWT_ACCESS:
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
if (adapter->cur_cmd->pdata_buf) if (adapter->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt, memcpy(adapter->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(&adapter->driver_lock, flags);
break; break;
case cmd_ret_mesh_access: case CMD_RET_MESH_ACCESS:
if (adapter->cur_cmd->pdata_buf) if (adapter->cur_cmd->pdata_buf)
memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh, memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
sizeof(resp->params.mesh)); sizeof(resp->params.mesh));
break; break;
case cmd_rte_802_11_tx_rate_query: case CMD_RTE_802_11_TX_RATE_QUERY:
priv->adapter->txrate = resp->params.txrate.txrate; priv->adapter->txrate = resp->params.txrate.txrate;
break; break;
default: default:
@@ -787,7 +787,7 @@ int libertas_process_rx_command(wlan_private * priv)
/* Store the response code to cur_cmd_retcode. */ /* Store the response code to cur_cmd_retcode. */
adapter->cur_cmd_retcode = result;; adapter->cur_cmd_retcode = result;;
if (respcmd == cmd_ret_802_11_ps_mode) { if (respcmd == CMD_RET_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;
u16 action = le16_to_cpu(psmode->action); u16 action = le16_to_cpu(psmode->action);
@@ -804,14 +804,14 @@ int libertas_process_rx_command(wlan_private * priv)
* libertas_execute_next_command(). * libertas_execute_next_command().
*/ */
if (adapter->mode == IW_MODE_ADHOC && if (adapter->mode == IW_MODE_ADHOC &&
action == cmd_subcmd_enter_ps) action == CMD_SUBCMD_ENTER_PS)
adapter->psmode = wlan802_11powermodecam; adapter->psmode = WLAN802_11POWERMODECAM;
} else if (action == cmd_subcmd_enter_ps) { } else if (action == CMD_SUBCMD_ENTER_PS) {
adapter->needtowakeup = 0; adapter->needtowakeup = 0;
adapter->psstate = PS_STATE_AWAKE; adapter->psstate = PS_STATE_AWAKE;
lbs_deb_cmd("CMD_RESP: Enter_PS command response\n"); lbs_deb_cmd("CMD_RESP: Enter_PS command response\n");
if (adapter->connect_status != libertas_connected) { if (adapter->connect_status != LIBERTAS_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.
@@ -825,7 +825,7 @@ int libertas_process_rx_command(wlan_private * priv)
mutex_lock(&adapter->lock); mutex_lock(&adapter->lock);
spin_lock_irqsave(&adapter->driver_lock, flags); spin_lock_irqsave(&adapter->driver_lock, flags);
} }
} else if (action == cmd_subcmd_exit_ps) { } else if (action == CMD_SUBCMD_EXIT_PS) {
adapter->needtowakeup = 0; adapter->needtowakeup = 0;
adapter->psstate = PS_STATE_FULL_POWER; adapter->psstate = PS_STATE_FULL_POWER;
lbs_deb_cmd("CMD_RESP: Exit_PS command response\n"); lbs_deb_cmd("CMD_RESP: Exit_PS command response\n");
@@ -857,8 +857,8 @@ int libertas_process_rx_command(wlan_private * priv)
* Handling errors here * Handling errors here
*/ */
switch (respcmd) { switch (respcmd) {
case cmd_ret_hw_spec_info: case CMD_RET_HW_SPEC_INFO:
case cmd_ret_802_11_reset: case CMD_RET_802_11_RESET:
lbs_deb_cmd("CMD_RESP: Reset command failed\n"); lbs_deb_cmd("CMD_RESP: Reset command failed\n");
break; break;
@@ -1003,7 +1003,7 @@ int libertas_process_event(wlan_private * priv)
case MACREG_INT_CODE_MESH_AUTO_STARTED: case MACREG_INT_CODE_MESH_AUTO_STARTED:
lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n"); lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n");
adapter->connect_status = libertas_connected ; adapter->connect_status = LIBERTAS_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) ;

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

@@ -125,9 +125,9 @@ static ssize_t libertas_sleepparams_write(struct file *file,
priv->adapter->sp.sp_reserved = p6; priv->adapter->sp.sp_reserved = p6;
res = libertas_prepare_and_send_command(priv, res = libertas_prepare_and_send_command(priv,
cmd_802_11_sleep_params, CMD_802_11_SLEEP_PARAMS,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (!res) if (!res)
res = count; res = count;
@@ -150,9 +150,9 @@ static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf
char *buf = (char *)addr; char *buf = (char *)addr;
res = libertas_prepare_and_send_command(priv, res = libertas_prepare_and_send_command(priv,
cmd_802_11_sleep_params, CMD_802_11_SLEEP_PARAMS,
cmd_act_get, CMD_ACT_GET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (res) { if (res) {
res = -EFAULT; res = -EFAULT;
goto out_unlock; goto out_unlock;
@@ -386,7 +386,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
struct cmd_ctrl_node **cmdnode, struct cmd_ctrl_node **cmdnode,
struct cmd_ds_command **cmd) struct cmd_ds_command **cmd)
{ {
u16 wait_option = cmd_option_waitforrsp; u16 wait_option = CMD_OPTION_WAITFORRSP;
if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) { if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n"); lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
@@ -402,7 +402,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
(*cmdnode)->cmdflags |= CMD_F_HOSTCMD; (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
(*cmdnode)->cmdwaitqwoken = 0; (*cmdnode)->cmdwaitqwoken = 0;
*cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr; *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
(*cmd)->command = cpu_to_le16(cmd_802_11_subscribe_event); (*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);
(*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum); (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
(*cmd)->result = 0; (*cmd)->result = 0;
return 0; return 0;
@@ -429,7 +429,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -447,7 +447,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -493,7 +493,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
return res; return res;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -511,7 +511,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
return 0; return 0;
} }
if (pcmdptr->command != cmd_ret_802_11_subscribe_event) { if (pcmdptr->command != CMD_RET_802_11_SUBSCRIBE_EVENT) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
return 0; return 0;
@@ -559,7 +559,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_rssithreshold)); sizeof(struct mrvlietypes_rssithreshold));
@@ -591,7 +591,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -625,7 +625,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -644,7 +644,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -712,7 +712,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_snrthreshold)); sizeof(struct mrvlietypes_snrthreshold));
@@ -743,7 +743,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -778,7 +778,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -797,7 +797,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -864,7 +864,7 @@ static ssize_t libertas_failcount_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_failurecount)); sizeof(struct mrvlietypes_failurecount));
@@ -895,7 +895,7 @@ static ssize_t libertas_failcount_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -929,7 +929,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -948,7 +948,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
free_page(addr); free_page(addr);
kfree(response_buf); kfree(response_buf);
@@ -1015,7 +1015,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_beaconsmissed)); sizeof(struct mrvlietypes_beaconsmissed));
@@ -1045,7 +1045,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
free_page(addr); free_page(addr);
kfree(response_buf); kfree(response_buf);
@@ -1079,7 +1079,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -1098,7 +1098,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -1166,7 +1166,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_rssithreshold)); sizeof(struct mrvlietypes_rssithreshold));
@@ -1196,7 +1196,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
return 0; return 0;
@@ -1229,7 +1229,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
} }
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_get); event->action = cpu_to_le16(CMD_ACT_GET);
pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
libertas_queue_cmd(adapter, pcmdnode, 1); libertas_queue_cmd(adapter, pcmdnode, 1);
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
@@ -1248,7 +1248,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -1316,7 +1316,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
goto out_unlock; goto out_unlock;
event = &pcmdptr->params.subscribe_event; event = &pcmdptr->params.subscribe_event;
event->action = cpu_to_le16(cmd_act_set); event->action = cpu_to_le16(CMD_ACT_SET);
pcmdptr->size = cpu_to_le16(S_DS_GEN + pcmdptr->size = cpu_to_le16(S_DS_GEN +
sizeof(struct cmd_ds_802_11_subscribe_event) + sizeof(struct cmd_ds_802_11_subscribe_event) +
sizeof(struct mrvlietypes_snrthreshold)); sizeof(struct mrvlietypes_snrthreshold));
@@ -1347,7 +1347,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
return 0; return 0;
} }
if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
lbs_pr_err("command response incorrect!\n"); lbs_pr_err("command response incorrect!\n");
kfree(response_buf); kfree(response_buf);
free_page(addr); free_page(addr);
@@ -1375,8 +1375,8 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
offval.value = 0; offval.value = 0;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_mac_reg_access, 0, CMD_MAC_REG_ACCESS, 0,
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, adapter->offsetvalue.value);
@@ -1433,8 +1433,8 @@ static ssize_t libertas_wrmac_write(struct file *file,
offval.offset = offset; offval.offset = offset;
offval.value = value; offval.value = value;
res = libertas_prepare_and_send_command(priv, res = libertas_prepare_and_send_command(priv,
cmd_mac_reg_access, 1, CMD_MAC_REG_ACCESS, 1,
cmd_option_waitforrsp, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
res = count; res = count;
@@ -1458,8 +1458,8 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
offval.value = 0; offval.value = 0;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_bbp_reg_access, 0, CMD_BBP_REG_ACCESS, 0,
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, adapter->offsetvalue.value);
@@ -1517,8 +1517,8 @@ static ssize_t libertas_wrbbp_write(struct file *file,
offval.offset = offset; offval.offset = offset;
offval.value = value; offval.value = value;
res = libertas_prepare_and_send_command(priv, res = libertas_prepare_and_send_command(priv,
cmd_bbp_reg_access, 1, CMD_BBP_REG_ACCESS, 1,
cmd_option_waitforrsp, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
res = count; res = count;
@@ -1542,8 +1542,8 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
offval.value = 0; offval.value = 0;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_rf_reg_access, 0, CMD_RF_REG_ACCESS, 0,
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, adapter->offsetvalue.value);
@@ -1601,8 +1601,8 @@ static ssize_t libertas_wrrf_write(struct file *file,
offval.offset = offset; offval.offset = offset;
offval.value = value; offval.value = value;
res = libertas_prepare_and_send_command(priv, res = libertas_prepare_and_send_command(priv,
cmd_rf_reg_access, 1, CMD_RF_REG_ACCESS, 1,
cmd_option_waitforrsp, 0, &offval); CMD_OPTION_WAITFORRSP, 0, &offval);
mdelay(10); mdelay(10);
res = count; res = count;

50
drivers/net/wireless/libertas/defs.h
View File

@@ -286,11 +286,11 @@ enum SNRNF_DATA {
/** WLAN_802_11_POWER_MODE */ /** WLAN_802_11_POWER_MODE */
enum WLAN_802_11_POWER_MODE { enum WLAN_802_11_POWER_MODE {
wlan802_11powermodecam, WLAN802_11POWERMODECAM,
wlan802_11powermodemax_psp, WLAN802_11POWERMODEMAX_PSP,
wlan802_11Powermodefast_psp, WLAN802_11POWERMODEFAST_PSP,
/*not a real mode, defined as an upper bound */ /*not a real mode, defined as an upper bound */
wlan802_11powemodemax WLAN802_11POWEMODEMAX
}; };
/** PS_STATE */ /** PS_STATE */
@@ -310,14 +310,14 @@ enum DNLD_STATE {
/** WLAN_MEDIA_STATE */ /** WLAN_MEDIA_STATE */
enum WLAN_MEDIA_STATE { enum WLAN_MEDIA_STATE {
libertas_connected, LIBERTAS_CONNECTED,
libertas_disconnected LIBERTAS_DISCONNECTED
}; };
/** WLAN_802_11_PRIVACY_FILTER */ /** WLAN_802_11_PRIVACY_FILTER */
enum WLAN_802_11_PRIVACY_FILTER { enum WLAN_802_11_PRIVACY_FILTER {
wlan802_11privfilteracceptall, WLAN802_11PRIVFILTERACCEPTALL,
wlan802_11privfilter8021xWEP WLAN802_11PRIVFILTER8021XWEP
}; };
/** mv_ms_type */ /** mv_ms_type */
@@ -330,23 +330,23 @@ enum mv_ms_type {
/** SNMP_MIB_INDEX_e */ /** SNMP_MIB_INDEX_e */
enum SNMP_MIB_INDEX_e { enum SNMP_MIB_INDEX_e {
desired_bsstype_i = 0, DESIRED_BSSTYPE_I = 0,
op_rateset_i, OP_RATESET_I,
bcnperiod_i, BCNPERIOD_I,
dtimperiod_i, DTIMPERIOD_I,
assocrsp_timeout_i, ASSOCRSP_TIMEOUT_I,
rtsthresh_i, RTSTHRESH_I,
short_retrylim_i, SHORT_RETRYLIM_I,
long_retrylim_i, LONG_RETRYLIM_I,
fragthresh_i, FRAGTHRESH_I,
dot11d_i, DOT11D_I,
dot11h_i, DOT11H_I,
manufid_i, MANUFID_I,
prodID_i, PRODID_I,
manuf_oui_i, MANUF_OUI_I,
manuf_name_i, MANUF_NAME_I,
manuf_prodname_i, MANUF_PRODNAME_I,
manuf_prodver_i, MANUF_PRODVER_I,
}; };
/** KEY_TYPE_ID */ /** KEY_TYPE_ID */

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

@@ -72,9 +72,9 @@ static int libertas_ethtool_get_eeprom(struct net_device *dev,
regctrl.action, regctrl.offset, regctrl.NOB); regctrl.action, regctrl.offset, regctrl.NOB);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_eeprom_access, CMD_802_11_EEPROM_ACCESS,
regctrl.action, regctrl.action,
cmd_option_waitforrsp, 0, CMD_OPTION_WAITFORRSP, 0,
&regctrl); &regctrl);
if (ret) { if (ret) {
@@ -138,8 +138,8 @@ static int libertas_ethtool_get_stats_count(struct net_device * dev)
/* Get Mesh Statistics */ /* Get Mesh Statistics */
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_mesh_access, cmd_act_mesh_get_stats, CMD_MESH_ACCESS, CMD_ACT_MESH_GET_STATS,
cmd_option_waitforrsp, 0, &mesh_access); CMD_OPTION_WAITFORRSP, 0, &mesh_access);
if (ret) { if (ret) {
ret = 0; ret = 0;

24
drivers/net/wireless/libertas/fw.c
View File

@@ -99,8 +99,8 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
*/ */
memset(adapter->current_addr, 0xff, ETH_ALEN); memset(adapter->current_addr, 0xff, ETH_ALEN);
ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec, ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC,
0, cmd_option_waitforrsp, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
if (ret) { if (ret) {
ret = -1; ret = -1;
@@ -110,9 +110,9 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
libertas_set_mac_packet_filter(priv); libertas_set_mac_packet_filter(priv);
/* Get the supported Data rates */ /* Get the supported Data rates */
ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate, ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
cmd_act_get_tx_rate, CMD_ACT_GET_tx_rate,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (ret) { if (ret) {
ret = -1; ret = -1;
@@ -145,12 +145,12 @@ static int wlan_allocate_adapter(wlan_private * priv)
memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep)); memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
adapter->libertas_ps_confirm_sleep.command = adapter->libertas_ps_confirm_sleep.command =
cpu_to_le16(cmd_802_11_ps_mode); cpu_to_le16(CMD_802_11_PS_MODE);
adapter->libertas_ps_confirm_sleep.size = adapter->libertas_ps_confirm_sleep.size =
cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
adapter->libertas_ps_confirm_sleep.result = 0; adapter->libertas_ps_confirm_sleep.result = 0;
adapter->libertas_ps_confirm_sleep.action = adapter->libertas_ps_confirm_sleep.action =
cpu_to_le16(cmd_subcmd_sleep_confirmed); cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
return 0; return 0;
} }
@@ -168,14 +168,14 @@ static void wlan_init_adapter(wlan_private * priv)
/* ATIM params */ /* ATIM params */
adapter->atimwindow = 0; adapter->atimwindow = 0;
adapter->connect_status = libertas_disconnected; adapter->connect_status = LIBERTAS_DISCONNECTED;
memset(adapter->current_addr, 0xff, ETH_ALEN); memset(adapter->current_addr, 0xff, ETH_ALEN);
/* scan type */ /* scan type */
adapter->scantype = cmd_scan_type_active; adapter->scantype = CMD_SCAN_TYPE_ACTIVE;
/* scan mode */ /* scan mode */
adapter->scanmode = cmd_bss_type_any; adapter->scanmode = CMD_BSS_TYPE_ANY;
/* 802.11 specific */ /* 802.11 specific */
adapter->secinfo.wep_enabled = 0; adapter->secinfo.wep_enabled = 0;
@@ -208,7 +208,7 @@ static void wlan_init_adapter(wlan_private * priv)
adapter->surpriseremoved = 0; adapter->surpriseremoved = 0;
adapter->currentpacketfilter = adapter->currentpacketfilter =
cmd_act_mac_rx_on | cmd_act_mac_tx_on; CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
adapter->radioon = RADIO_ON; adapter->radioon = RADIO_ON;
adapter->txantenna = RF_ANTENNA_2; adapter->txantenna = RF_ANTENNA_2;
@@ -220,7 +220,7 @@ static void wlan_init_adapter(wlan_private * priv)
// set default capabilities // set default capabilities
adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
adapter->psmode = wlan802_11powermodecam; adapter->psmode = WLAN802_11POWERMODECAM;
adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM; adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;
adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL; adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;

424
drivers/net/wireless/libertas/host.h
View File

@@ -20,224 +20,224 @@
#define OID_802_11_TX_RETRYCOUNT 0x0000801D #define OID_802_11_TX_RETRYCOUNT 0x0000801D
#define OID_802_11D_ENABLE 0x00008020 #define OID_802_11D_ENABLE 0x00008020
#define cmd_option_waitforrsp 0x0002 #define CMD_OPTION_WAITFORRSP 0x0002
/** Host command ID */ /** Host command ID */
#define cmd_code_dnld 0x0002 #define CMD_CODE_DNLD 0x0002
#define cmd_get_hw_spec 0x0003 #define CMD_GET_HW_SPEC 0x0003
#define cmd_eeprom_update 0x0004 #define CMD_EEPROM_UPDATE 0x0004
#define cmd_802_11_reset 0x0005 #define CMD_802_11_RESET 0x0005
#define cmd_802_11_scan 0x0006 #define CMD_802_11_SCAN 0x0006
#define cmd_802_11_get_log 0x000b #define CMD_802_11_GET_LOG 0x000b
#define cmd_mac_multicast_adr 0x0010 #define CMD_MAC_MULTICAST_ADR 0x0010
#define cmd_802_11_authenticate 0x0011 #define CMD_802_11_AUTHENTICATE 0x0011
#define cmd_802_11_eeprom_access 0x0059 #define CMD_802_11_EEPROM_ACCESS 0x0059
#define cmd_802_11_associate 0x0050 #define CMD_802_11_ASSOCIATE 0x0050
#define cmd_802_11_set_wep 0x0013 #define CMD_802_11_SET_WEP 0x0013
#define cmd_802_11_get_stat 0x0014 #define CMD_802_11_GET_STAT 0x0014
#define cmd_802_3_get_stat 0x0015 #define CMD_802_3_GET_STAT 0x0015
#define cmd_802_11_snmp_mib 0x0016 #define CMD_802_11_SNMP_MIB 0x0016
#define cmd_mac_reg_map 0x0017 #define CMD_MAC_REG_MAP 0x0017
#define cmd_bbp_reg_map 0x0018 #define CMD_BBP_REG_MAP 0x0018
#define cmd_mac_reg_access 0x0019 #define CMD_MAC_REG_ACCESS 0x0019
#define cmd_bbp_reg_access 0x001a #define CMD_BBP_REG_ACCESS 0x001a
#define cmd_rf_reg_access 0x001b #define CMD_RF_REG_ACCESS 0x001b
#define cmd_802_11_radio_control 0x001c #define CMD_802_11_RADIO_CONTROL 0x001c
#define cmd_802_11_rf_channel 0x001d #define CMD_802_11_RF_CHANNEL 0x001d
#define cmd_802_11_rf_tx_power 0x001e #define CMD_802_11_RF_TX_POWER 0x001e
#define cmd_802_11_rssi 0x001f #define CMD_802_11_RSSI 0x001f
#define cmd_802_11_rf_antenna 0x0020 #define CMD_802_11_RF_ANTENNA 0x0020
#define cmd_802_11_ps_mode 0x0021 #define CMD_802_11_PS_MODE 0x0021
#define cmd_802_11_data_rate 0x0022 #define CMD_802_11_DATA_RATE 0x0022
#define cmd_rf_reg_map 0x0023 #define CMD_RF_REG_MAP 0x0023
#define cmd_802_11_deauthenticate 0x0024 #define CMD_802_11_DEAUTHENTICATE 0x0024
#define cmd_802_11_reassociate 0x0025 #define CMD_802_11_REASSOCIATE 0x0025
#define cmd_802_11_disassociate 0x0026 #define CMD_802_11_DISASSOCIATE 0x0026
#define cmd_mac_control 0x0028 #define CMD_MAC_CONTROL 0x0028
#define cmd_802_11_ad_hoc_start 0x002b #define CMD_802_11_AD_HOC_START 0x002b
#define cmd_802_11_ad_hoc_join 0x002c #define CMD_802_11_AD_HOC_JOIN 0x002c
#define cmd_802_11_query_tkip_reply_cntrs 0x002e #define CMD_802_11_QUERY_TKIP_REPLY_CNTRS 0x002e
#define cmd_802_11_enable_rsn 0x002f #define CMD_802_11_ENABLE_RSN 0x002f
#define cmd_802_11_pairwise_tsc 0x0036 #define CMD_802_11_PAIRWISE_TSC 0x0036
#define cmd_802_11_group_tsc 0x0037 #define CMD_802_11_GROUP_TSC 0x0037
#define cmd_802_11_key_material 0x005e #define CMD_802_11_KEY_MATERIAL 0x005e
#define cmd_802_11_set_afc 0x003c #define CMD_802_11_SET_AFC 0x003c
#define cmd_802_11_get_afc 0x003d #define CMD_802_11_GET_AFC 0x003d
#define cmd_802_11_ad_hoc_stop 0x0040 #define CMD_802_11_AD_HOC_STOP 0x0040
#define cmd_802_11_beacon_stop 0x0049 #define CMD_802_11_BEACON_STOP 0x0049
#define cmd_802_11_mac_address 0x004D #define CMD_802_11_MAC_ADDRESS 0x004D
#define cmd_802_11_eeprom_access 0x0059 #define CMD_802_11_EEPROM_ACCESS 0x0059
#define cmd_802_11_band_config 0x0058 #define CMD_802_11_BAND_CONFIG 0x0058
#define cmd_802_11d_domain_info 0x005b #define CMD_802_11D_DOMAIN_INFO 0x005b
#define cmd_802_11_sleep_params 0x0066 #define CMD_802_11_SLEEP_PARAMS 0x0066
#define cmd_802_11_inactivity_timeout 0x0067 #define CMD_802_11_INACTIVITY_TIMEOUT 0x0067
#define cmd_802_11_tpc_cfg 0x0072 #define CMD_802_11_TPC_CFG 0x0072
#define cmd_802_11_pwr_cfg 0x0073 #define CMD_802_11_PWR_CFG 0x0073
#define cmd_802_11_led_gpio_ctrl 0x004e #define CMD_802_11_LED_GPIO_CTRL 0x004e
#define cmd_802_11_subscribe_event 0x0075 #define CMD_802_11_SUBSCRIBE_EVENT 0x0075
#define cmd_802_11_rate_adapt_rateset 0x0076 #define CMD_802_11_RATE_ADAPT_RATESET 0x0076
#define cmd_802_11_tx_rate_query 0x007f #define CMD_802_11_TX_RATE_QUERY 0x007f
#define cmd_get_tsf 0x0080 #define CMD_GET_TSF 0x0080
#define cmd_bt_access 0x0087 #define CMD_BT_ACCESS 0x0087
#define cmd_ret_bt_access 0x8087 #define CMD_RET_BT_ACCESS 0x8087
#define cmd_fwt_access 0x0095 #define CMD_FWT_ACCESS 0x0095
#define cmd_ret_fwt_access 0x8095 #define CMD_RET_FWT_ACCESS 0x8095
#define cmd_mesh_access 0x009b #define CMD_MESH_ACCESS 0x009b
#define cmd_ret_mesh_access 0x809b #define CMD_RET_MESH_ACCESS 0x809b
/* For the IEEE Power Save */ /* For the IEEE Power Save */
#define cmd_subcmd_enter_ps 0x0030 #define CMD_SUBCMD_ENTER_PS 0x0030
#define cmd_subcmd_exit_ps 0x0031 #define CMD_SUBCMD_EXIT_PS 0x0031
#define cmd_subcmd_sleep_confirmed 0x0034 #define CMD_SUBCMD_SLEEP_CONFIRMED 0x0034
#define cmd_subcmd_full_powerdown 0x0035 #define CMD_SUBCMD_FULL_POWERDOWN 0x0035
#define cmd_subcmd_full_powerup 0x0036 #define CMD_SUBCMD_FULL_POWERUP 0x0036
/* command RET code, MSB is set to 1 */ /* command RET code, MSB is set to 1 */
#define cmd_ret_hw_spec_info 0x8003 #define CMD_RET_HW_SPEC_INFO 0x8003
#define cmd_ret_eeprom_update 0x8004 #define CMD_RET_EEPROM_UPDATE 0x8004
#define cmd_ret_802_11_reset 0x8005 #define CMD_RET_802_11_RESET 0x8005
#define cmd_ret_802_11_scan 0x8006 #define CMD_RET_802_11_SCAN 0x8006
#define cmd_ret_802_11_get_log 0x800b #define CMD_RET_802_11_GET_LOG 0x800b
#define cmd_ret_mac_control 0x8028 #define CMD_RET_MAC_CONTROL 0x8028
#define cmd_ret_mac_multicast_adr 0x8010 #define CMD_RET_MAC_MULTICAST_ADR 0x8010
#define cmd_ret_802_11_authenticate 0x8011 #define CMD_RET_802_11_AUTHENTICATE 0x8011
#define cmd_ret_802_11_deauthenticate 0x8024 #define CMD_RET_802_11_DEAUTHENTICATE 0x8024
#define cmd_ret_802_11_associate 0x8012 #define CMD_RET_802_11_ASSOCIATE 0x8012
#define cmd_ret_802_11_reassociate 0x8025 #define CMD_RET_802_11_REASSOCIATE 0x8025
#define cmd_ret_802_11_disassociate 0x8026 #define CMD_RET_802_11_DISASSOCIATE 0x8026
#define cmd_ret_802_11_set_wep 0x8013 #define CMD_RET_802_11_SET_WEP 0x8013
#define cmd_ret_802_11_stat 0x8014 #define CMD_RET_802_11_STAT 0x8014
#define cmd_ret_802_3_stat 0x8015 #define CMD_RET_802_3_STAT 0x8015
#define cmd_ret_802_11_snmp_mib 0x8016 #define CMD_RET_802_11_SNMP_MIB 0x8016
#define cmd_ret_mac_reg_map 0x8017 #define CMD_RET_MAC_REG_MAP 0x8017
#define cmd_ret_bbp_reg_map 0x8018 #define CMD_RET_BBP_REG_MAP 0x8018
#define cmd_ret_rf_reg_map 0x8023 #define CMD_RET_RF_REG_MAP 0x8023
#define cmd_ret_mac_reg_access 0x8019 #define CMD_RET_MAC_REG_ACCESS 0x8019
#define cmd_ret_bbp_reg_access 0x801a #define CMD_RET_BBP_REG_ACCESS 0x801a
#define cmd_ret_rf_reg_access 0x801b #define CMD_RET_RF_REG_ACCESS 0x801b
#define cmd_ret_802_11_radio_control 0x801c #define CMD_RET_802_11_RADIO_CONTROL 0x801c
#define cmd_ret_802_11_rf_channel 0x801d #define CMD_RET_802_11_RF_CHANNEL 0x801d
#define cmd_ret_802_11_rssi 0x801f #define CMD_RET_802_11_RSSI 0x801f
#define cmd_ret_802_11_rf_tx_power 0x801e #define CMD_RET_802_11_RF_TX_POWER 0x801e
#define cmd_ret_802_11_rf_antenna 0x8020 #define CMD_RET_802_11_RF_ANTENNA 0x8020
#define cmd_ret_802_11_ps_mode 0x8021 #define CMD_RET_802_11_PS_MODE 0x8021
#define cmd_ret_802_11_data_rate 0x8022 #define CMD_RET_802_11_DATA_RATE 0x8022
#define cmd_ret_802_11_ad_hoc_start 0x802B #define CMD_RET_802_11_AD_HOC_START 0x802B
#define cmd_ret_802_11_ad_hoc_join 0x802C #define CMD_RET_802_11_AD_HOC_JOIN 0x802C
#define cmd_ret_802_11_query_tkip_reply_cntrs 0x802e #define CMD_RET_802_11_QUERY_TKIP_REPLY_CNTRS 0x802e
#define cmd_ret_802_11_enable_rsn 0x802f #define CMD_RET_802_11_ENABLE_RSN 0x802f
#define cmd_ret_802_11_pairwise_tsc 0x8036 #define CMD_RET_802_11_PAIRWISE_TSC 0x8036
#define cmd_ret_802_11_group_tsc 0x8037 #define CMD_RET_802_11_GROUP_TSC 0x8037
#define cmd_ret_802_11_key_material 0x805e #define CMD_RET_802_11_KEY_MATERIAL 0x805e
#define cmd_enable_rsn 0x0001 #define CMD_ENABLE_RSN 0x0001
#define cmd_disable_rsn 0x0000 #define CMD_DISABLE_RSN 0x0000
#define cmd_act_set 0x0001 #define CMD_ACT_SET 0x0001
#define cmd_act_get 0x0000 #define CMD_ACT_GET 0x0000
#define cmd_act_get_AES (cmd_act_get + 2) #define CMD_ACT_GET_AES (CMD_ACT_GET + 2)
#define cmd_act_set_AES (cmd_act_set + 2) #define CMD_ACT_SET_AES (CMD_ACT_SET + 2)
#define cmd_act_remove_aes (cmd_act_set + 3) #define CMD_ACT_REMOVE_AES (CMD_ACT_SET + 3)
#define cmd_ret_802_11_set_afc 0x803c #define CMD_RET_802_11_SET_AFC 0x803c
#define cmd_ret_802_11_get_afc 0x803d #define CMD_RET_802_11_GET_AFC 0x803d
#define cmd_ret_802_11_ad_hoc_stop 0x8040 #define CMD_RET_802_11_AD_HOC_STOP 0x8040
#define cmd_ret_802_11_beacon_stop 0x8049 #define CMD_RET_802_11_BEACON_STOP 0x8049
#define cmd_ret_802_11_mac_address 0x804D #define CMD_RET_802_11_MAC_ADDRESS 0x804D
#define cmd_ret_802_11_eeprom_access 0x8059 #define CMD_RET_802_11_EEPROM_ACCESS 0x8059
#define cmd_ret_802_11_band_config 0x8058 #define CMD_RET_802_11_BAND_CONFIG 0x8058
#define cmd_ret_802_11_sleep_params 0x8066 #define CMD_RET_802_11_SLEEP_PARAMS 0x8066
#define cmd_ret_802_11_inactivity_timeout 0x8067 #define CMD_RET_802_11_INACTIVITY_TIMEOUT 0x8067
#define cmd_ret_802_11d_domain_info (0x8000 | \ #define CMD_RET_802_11D_DOMAIN_INFO (0x8000 | \
cmd_802_11d_domain_info) CMD_802_11D_DOMAIN_INFO)
#define cmd_ret_802_11_tpc_cfg (cmd_802_11_tpc_cfg | 0x8000) #define CMD_RET_802_11_TPC_CFG (CMD_802_11_TPC_CFG | 0x8000)
#define cmd_ret_802_11_pwr_cfg (cmd_802_11_pwr_cfg | 0x8000) #define CMD_RET_802_11_PWR_CFG (CMD_802_11_PWR_CFG | 0x8000)
#define cmd_ret_802_11_led_gpio_ctrl 0x804e #define CMD_RET_802_11_LED_GPIO_CTRL 0x804e
#define cmd_ret_802_11_subscribe_event (cmd_802_11_subscribe_event | 0x8000) #define CMD_RET_802_11_SUBSCRIBE_EVENT (CMD_802_11_SUBSCRIBE_EVENT | 0x8000)
#define cmd_ret_802_11_rate_adapt_rateset (cmd_802_11_rate_adapt_rateset | 0x8000) #define CMD_RET_802_11_RATE_ADAPT_RATESET (CMD_802_11_RATE_ADAPT_RATESET | 0x8000)
#define cmd_rte_802_11_tx_rate_query (cmd_802_11_tx_rate_query | 0x8000) #define CMD_RTE_802_11_TX_RATE_QUERY (CMD_802_11_TX_RATE_QUERY | 0x8000)
#define cmd_ret_get_tsf 0x8080 #define CMD_RET_GET_TSF 0x8080
/* Define action or option for cmd_802_11_set_wep */ /* Define action or option for CMD_802_11_SET_WEP */
#define cmd_act_add 0x0002 #define CMD_ACT_ADD 0x0002
#define cmd_act_remove 0x0004 #define CMD_ACT_REMOVE 0x0004
#define cmd_act_use_default 0x0008 #define CMD_ACT_USE_DEFAULT 0x0008
#define cmd_type_wep_40_bit 0x0001 #define CMD_TYPE_WEP_40_BIT 0x0001
#define cmd_type_wep_104_bit 0x0002 #define CMD_TYPE_WEP_104_BIT 0x0002
#define cmd_NUM_OF_WEP_KEYS 4 #define CMD_NUM_OF_WEP_KEYS 4
#define cmd_WEP_KEY_INDEX_MASK 0x3fff #define CMD_WEP_KEY_INDEX_MASK 0x3fff
/* Define action or option for cmd_802_11_reset */ /* Define action or option for CMD_802_11_RESET */
#define cmd_act_halt 0x0003 #define CMD_ACT_HALT 0x0003
/* Define action or option for cmd_802_11_scan */ /* Define action or option for CMD_802_11_SCAN */
#define cmd_bss_type_bss 0x0001 #define CMD_BSS_TYPE_BSS 0x0001
#define cmd_bss_type_ibss 0x0002 #define CMD_BSS_TYPE_IBSS 0x0002
#define cmd_bss_type_any 0x0003 #define CMD_BSS_TYPE_ANY 0x0003
/* Define action or option for cmd_802_11_scan */ /* Define action or option for CMD_802_11_SCAN */
#define cmd_scan_type_active 0x0000 #define CMD_SCAN_TYPE_ACTIVE 0x0000
#define cmd_scan_type_passive 0x0001 #define CMD_SCAN_TYPE_PASSIVE 0x0001
#define cmd_scan_radio_type_bg 0 #define CMD_SCAN_RADIO_TYPE_BG 0
#define cmd_scan_probe_delay_time 0 #define CMD_SCAN_PROBE_DELAY_TIME 0
/* Define action or option for cmd_mac_control */ /* Define action or option for CMD_MAC_CONTROL */
#define cmd_act_mac_rx_on 0x0001 #define CMD_ACT_MAC_RX_ON 0x0001
#define cmd_act_mac_tx_on 0x0002 #define CMD_ACT_MAC_TX_ON 0x0002
#define cmd_act_mac_loopback_on 0x0004 #define CMD_ACT_MAC_LOOPBACK_ON 0x0004
#define cmd_act_mac_wep_enable 0x0008 #define CMD_ACT_MAC_WEP_ENABLE 0x0008
#define cmd_act_mac_int_enable 0x0010 #define CMD_ACT_MAC_INT_ENABLE 0x0010
#define cmd_act_mac_multicast_enable 0x0020 #define CMD_ACT_MAC_MULTICAST_ENABLE 0x0020
#define cmd_act_mac_broadcast_enable 0x0040 #define CMD_ACT_MAC_BROADCAST_ENABLE 0x0040
#define cmd_act_mac_promiscuous_enable 0x0080 #define CMD_ACT_MAC_PROMISCUOUS_ENABLE 0x0080
#define cmd_act_mac_all_multicast_enable 0x0100 #define CMD_ACT_MAC_ALL_MULTICAST_ENABLE 0x0100
#define cmd_act_mac_strict_protection_enable 0x0400 #define CMD_ACT_MAC_STRICT_PROTECTION_ENABLE 0x0400
/* Define action or option for cmd_802_11_radio_control */ /* Define action or option for CMD_802_11_RADIO_CONTROL */
#define cmd_type_auto_preamble 0x0001 #define CMD_TYPE_AUTO_PREAMBLE 0x0001
#define cmd_type_short_preamble 0x0002 #define CMD_TYPE_SHORT_PREAMBLE 0x0002
#define cmd_type_long_preamble 0x0003 #define CMD_TYPE_LONG_PREAMBLE 0x0003
#define TURN_ON_RF 0x01 #define TURN_ON_RF 0x01
#define RADIO_ON 0x01 #define RADIO_ON 0x01
@@ -248,70 +248,70 @@
#define SET_LONG_PREAMBLE 0x01 #define SET_LONG_PREAMBLE 0x01
/* Define action or option for CMD_802_11_RF_CHANNEL */ /* Define action or option for CMD_802_11_RF_CHANNEL */
#define cmd_opt_802_11_rf_channel_get 0x00 #define CMD_OPT_802_11_RF_CHANNEL_GET 0x00
#define cmd_opt_802_11_rf_channel_set 0x01 #define CMD_OPT_802_11_RF_CHANNEL_SET 0x01
/* Define action or option for cmd_802_11_rf_tx_power */ /* Define action or option for CMD_802_11_RF_TX_POWER */
#define cmd_act_tx_power_opt_get 0x0000 #define CMD_ACT_TX_POWER_OPT_GET 0x0000
#define cmd_act_tx_power_opt_set_high 0x8007 #define CMD_ACT_TX_POWER_OPT_SET_HIGH 0x8007
#define cmd_act_tx_power_opt_set_mid 0x8004 #define CMD_ACT_TX_POWER_OPT_SET_MID 0x8004
#define cmd_act_tx_power_opt_set_low 0x8000 #define CMD_ACT_TX_POWER_OPT_SET_LOW 0x8000
#define cmd_act_tx_power_index_high 0x0007 #define CMD_ACT_TX_POWER_INDEX_HIGH 0x0007
#define cmd_act_tx_power_index_mid 0x0004 #define CMD_ACT_TX_POWER_INDEX_MID 0x0004
#define cmd_act_tx_power_index_low 0x0000 #define CMD_ACT_TX_POWER_INDEX_LOW 0x0000
/* Define action or option for cmd_802_11_data_rate */ /* Define action or option for CMD_802_11_DATA_RATE */
#define cmd_act_set_tx_auto 0x0000 #define CMD_ACT_SET_tx_auto 0x0000
#define cmd_act_set_tx_fix_rate 0x0001 #define CMD_ACT_SET_tx_fix_rate 0x0001
#define cmd_act_get_tx_rate 0x0002 #define CMD_ACT_GET_tx_rate 0x0002
#define cmd_act_set_rx 0x0001 #define CMD_ACT_SET_rx 0x0001
#define cmd_act_set_tx 0x0002 #define CMD_ACT_SET_tx 0x0002
#define cmd_act_set_both 0x0003 #define CMD_ACT_SET_both 0x0003
#define cmd_act_get_rx 0x0004 #define CMD_ACT_GET_rx 0x0004
#define cmd_act_get_tx 0x0008 #define CMD_ACT_GET_tx 0x0008
#define cmd_act_get_both 0x000c #define CMD_ACT_GET_both 0x000c
/* Define action or option for cmd_802_11_ps_mode */ /* Define action or option for CMD_802_11_PS_MODE */
#define cmd_type_cam 0x0000 #define CMD_TYPE_CAM 0x0000
#define cmd_type_max_psp 0x0001 #define CMD_TYPE_MAX_PSP 0x0001
#define cmd_type_fast_psp 0x0002 #define CMD_TYPE_FAST_PSP 0x0002
/* Define action or option for cmd_bt_access */ /* Define action or option for CMD_BT_ACCESS */
enum cmd_bt_access_opts { enum CMD_BT_ACCESS_opts {
/* The bt commands start at 5 instead of 1 because the old dft commands /* The bt commands start at 5 instead of 1 because the old dft commands
* are mapped to 1-4. These old commands are no longer maintained and * are mapped to 1-4. These old commands are no longer maintained and
* should not be called. * should not be called.
*/ */
cmd_act_bt_access_add = 5, CMD_ACT_BT_ACCESS_ADD = 5,
cmd_act_bt_access_del, CMD_ACT_BT_ACCESS_DEL,
cmd_act_bt_access_list, CMD_ACT_BT_ACCESS_LIST,
cmd_act_bt_access_reset, CMD_ACT_BT_ACCESS_RESET,
cmd_act_bt_access_set_invert, CMD_ACT_BT_ACCESS_SET_INVERT,
cmd_act_bt_access_get_invert CMD_ACT_BT_ACCESS_GET_INVERT
}; };
/* Define action or option for cmd_fwt_access */ /* Define action or option for CMD_FWT_ACCESS */
enum cmd_fwt_access_opts { enum CMD_FWT_ACCESS_opts {
cmd_act_fwt_access_add = 1, CMD_ACT_FWT_ACCESS_ADD = 1,
cmd_act_fwt_access_del, CMD_ACT_FWT_ACCESS_DEL,
cmd_act_fwt_access_lookup, CMD_ACT_FWT_ACCESS_LOOKUP,
cmd_act_fwt_access_list, CMD_ACT_FWT_ACCESS_LIST,
cmd_act_fwt_access_list_route, CMD_ACT_FWT_ACCESS_LIST_route,
cmd_act_fwt_access_list_neighbor, CMD_ACT_FWT_ACCESS_LIST_neighbor,
cmd_act_fwt_access_reset, CMD_ACT_FWT_ACCESS_RESET,
cmd_act_fwt_access_cleanup, CMD_ACT_FWT_ACCESS_CLEANUP,
cmd_act_fwt_access_time, CMD_ACT_FWT_ACCESS_TIME,
}; };
/* Define action or option for cmd_mesh_access */ /* Define action or option for CMD_MESH_ACCESS */
enum cmd_mesh_access_opts { enum CMD_MESH_ACCESS_opts {
cmd_act_mesh_get_ttl = 1, CMD_ACT_MESH_GET_TTL = 1,
cmd_act_mesh_set_ttl, CMD_ACT_MESH_SET_TTL,
cmd_act_mesh_get_stats, CMD_ACT_MESH_GET_STATS,
cmd_act_mesh_get_anycast, CMD_ACT_MESH_GET_ANYCAST,
cmd_act_mesh_set_anycast, CMD_ACT_MESH_SET_ANYCAST,
}; };
/** Card Event definition */ /** Card Event definition */

4
drivers/net/wireless/libertas/hostcmd.h
View File

@@ -108,7 +108,7 @@ struct cmd_ds_gen {
#define S_DS_GEN sizeof(struct cmd_ds_gen) #define S_DS_GEN sizeof(struct cmd_ds_gen)
/* /*
* Define data structure for cmd_get_hw_spec * Define data structure for CMD_GET_HW_SPEC
* This structure defines the response for the GET_HW_SPEC command * This structure defines the response for the GET_HW_SPEC command
*/ */
struct cmd_ds_get_hw_spec { struct cmd_ds_get_hw_spec {
@@ -155,7 +155,7 @@ struct cmd_ds_802_11_subscribe_event {
/* /*
* This scan handle Country Information IE(802.11d compliant) * This scan handle Country Information IE(802.11d compliant)
* Define data structure for cmd_802_11_scan * Define data structure for CMD_802_11_SCAN
*/ */
struct cmd_ds_802_11_scan { struct cmd_ds_802_11_scan {
u8 bsstype; u8 bsstype;

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

@@ -78,7 +78,7 @@ static void if_usb_write_bulk_callback(struct urb *urb)
/* Wake main thread if commands are pending */ /* Wake main thread if commands are pending */
if (!adapter->cur_cmd) if (!adapter->cur_cmd)
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
if ((adapter->connect_status == libertas_connected)) { if ((adapter->connect_status == LIBERTAS_CONNECTED)) {
netif_wake_queue(dev); netif_wake_queue(dev);
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
@@ -758,8 +758,8 @@ static int if_usb_reset_device(wlan_private *priv)
int ret; int ret;
lbs_deb_enter(LBS_DEB_USB); lbs_deb_enter(LBS_DEB_USB);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_reset, ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET,
cmd_act_halt, 0, 0, NULL); CMD_ACT_HALT, 0, 0, NULL);
msleep_interruptible(10); msleep_interruptible(10);
lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);

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

@@ -88,7 +88,7 @@ int libertas_send_deauth(wlan_private * priv)
int ret = 0; int ret = 0;
if (adapter->mode == IW_MODE_INFRA && if (adapter->mode == IW_MODE_INFRA &&
adapter->connect_status == libertas_connected) adapter->connect_status == LIBERTAS_CONNECTED)
ret = libertas_send_deauthentication(priv); ret = libertas_send_deauthentication(priv);
else else
ret = -ENOTSUPP; ret = -ENOTSUPP;
@@ -111,8 +111,8 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_authenticate, ret = libertas_prepare_and_send_command(priv, CMD_802_11_AUTHENTICATE,
0, cmd_option_waitforrsp, 0, CMD_OPTION_WAITFORRSP,
0, assoc_req->bss.bssid); 0, assoc_req->bss.bssid);
if (ret) if (ret)
@@ -121,14 +121,14 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
/* set preamble to firmware */ /* set preamble to firmware */
if ( (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) if ( (adapter->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; adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
else else
adapter->preamble = cmd_type_long_preamble; adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
libertas_set_radio_control(priv); libertas_set_radio_control(priv);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_associate, ret = libertas_prepare_and_send_command(priv, CMD_802_11_ASSOCIATE,
0, cmd_option_waitforrsp, 0, assoc_req); 0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
done: done:
lbs_deb_leave_args(LBS_DEB_JOIN, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_JOIN, "ret %d", ret);
@@ -151,10 +151,10 @@ int libertas_start_adhoc_network(wlan_private * priv, struct assoc_request * ass
if (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) { if (adapter->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; adapter->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; adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
} }
libertas_set_radio_control(priv); libertas_set_radio_control(priv);
@@ -162,8 +162,8 @@ int libertas_start_adhoc_network(wlan_private * priv, struct assoc_request * ass
lbs_deb_join("AdhocStart: channel = %d\n", assoc_req->channel); lbs_deb_join("AdhocStart: channel = %d\n", assoc_req->channel);
lbs_deb_join("AdhocStart: band = %d\n", assoc_req->band); lbs_deb_join("AdhocStart: band = %d\n", assoc_req->band);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_start, ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_START,
0, cmd_option_waitforrsp, 0, assoc_req); 0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
return ret; return ret;
} }
@@ -209,10 +209,10 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
|| !(adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) { || !(adapter->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; adapter->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; adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
} }
libertas_set_radio_control(priv); libertas_set_radio_control(priv);
@@ -222,8 +222,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
adapter->adhoccreate = 0; adapter->adhoccreate = 0;
ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_join, ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_JOIN,
0, cmd_option_waitforrsp, 0, CMD_OPTION_WAITFORRSP,
OID_802_11_SSID, assoc_req); OID_802_11_SSID, assoc_req);
return ret; return ret;
@@ -231,8 +231,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
int libertas_stop_adhoc_network(wlan_private * priv) int libertas_stop_adhoc_network(wlan_private * priv)
{ {
return libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_stop, return libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_STOP,
0, cmd_option_waitforrsp, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
} }
/** /**
@@ -243,8 +243,8 @@ int libertas_stop_adhoc_network(wlan_private * priv)
*/ */
int libertas_send_deauthentication(wlan_private * priv) int libertas_send_deauthentication(wlan_private * priv)
{ {
return libertas_prepare_and_send_command(priv, cmd_802_11_deauthenticate, return libertas_prepare_and_send_command(priv, CMD_802_11_DEAUTHENTICATE,
0, cmd_option_waitforrsp, 0, NULL); 0, CMD_OPTION_WAITFORRSP, 0, NULL);
} }
/** /**
@@ -267,7 +267,7 @@ int libertas_cmd_80211_authenticate(wlan_private * priv,
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
cmd->command = cpu_to_le16(cmd_802_11_authenticate); cmd->command = cpu_to_le16(CMD_802_11_AUTHENTICATE);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate) cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate)
+ S_DS_GEN); + S_DS_GEN);
@@ -307,7 +307,7 @@ int libertas_cmd_80211_deauthenticate(wlan_private * priv,
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
cmd->command = cpu_to_le16(cmd_802_11_deauthenticate); cmd->command = cpu_to_le16(CMD_802_11_DEAUTHENTICATE);
cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) + cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) +
S_DS_GEN); S_DS_GEN);
@@ -349,7 +349,7 @@ int libertas_cmd_80211_associate(wlan_private * priv,
goto done; goto done;
} }
cmd->command = cpu_to_le16(cmd_802_11_associate); cmd->command = cpu_to_le16(CMD_802_11_ASSOCIATE);
memcpy(passo->peerstaaddr, bss->bssid, sizeof(passo->peerstaaddr)); memcpy(passo->peerstaaddr, bss->bssid, sizeof(passo->peerstaaddr));
pos += sizeof(passo->peerstaaddr); pos += sizeof(passo->peerstaaddr);
@@ -465,7 +465,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
goto done; goto done;
} }
cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_start); cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_START);
/* /*
* Fill in the parameters for 2 data structures: * Fill in the parameters for 2 data structures:
@@ -487,7 +487,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
assoc_req->ssid_len); assoc_req->ssid_len);
/* 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; adapter->mode = IW_MODE_ADHOC;
adhs->beaconperiod = cpu_to_le16(adapter->beaconperiod); adhs->beaconperiod = cpu_to_le16(adapter->beaconperiod);
@@ -524,7 +524,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
adhs->capability = cpu_to_le16(tmpcap); adhs->capability = cpu_to_le16(tmpcap);
/* probedelay */ /* probedelay */
adhs->probedelay = cpu_to_le16(cmd_scan_probe_delay_time); adhs->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
memset(adhs->datarate, 0, sizeof(adhs->datarate)); memset(adhs->datarate, 0, sizeof(adhs->datarate));
@@ -569,7 +569,7 @@ done:
int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv, int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv,
struct cmd_ds_command *cmd) struct cmd_ds_command *cmd)
{ {
cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_stop); cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_STOP);
cmd->size = cpu_to_le16(S_DS_GEN); cmd->size = cpu_to_le16(S_DS_GEN);
return 0; return 0;
@@ -590,9 +590,9 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
lbs_deb_enter(LBS_DEB_JOIN); lbs_deb_enter(LBS_DEB_JOIN);
cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_join); cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_JOIN);
join_cmd->bss.type = cmd_bss_type_ibss; join_cmd->bss.type = CMD_BSS_TYPE_IBSS;
join_cmd->bss.beaconperiod = cpu_to_le16(bss->beaconperiod); join_cmd->bss.beaconperiod = cpu_to_le16(bss->beaconperiod);
memcpy(&join_cmd->bss.bssid, &bss->bssid, ETH_ALEN); memcpy(&join_cmd->bss.bssid, &bss->bssid, ETH_ALEN);
@@ -617,7 +617,7 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
join_cmd->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT); join_cmd->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
/* probedelay */ /* probedelay */
join_cmd->probedelay = cpu_to_le16(cmd_scan_probe_delay_time); join_cmd->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
/* Copy Data rates from the rates recorded in scan response */ /* Copy Data rates from the rates recorded in scan response */
memset(join_cmd->bss.datarates, 0, sizeof(join_cmd->bss.datarates)); memset(join_cmd->bss.datarates, 0, sizeof(join_cmd->bss.datarates));
@@ -659,14 +659,14 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
join_cmd->bss.capability = cpu_to_le16(tmp); join_cmd->bss.capability = cpu_to_le16(tmp);
} }
if (adapter->psmode == wlan802_11powermodemax_psp) { if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
/* wake up first */ /* wake up first */
__le32 Localpsmode; __le32 Localpsmode;
Localpsmode = cpu_to_le32(wlan802_11powermodecam); Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_ps_mode, CMD_802_11_PS_MODE,
cmd_act_set, CMD_ACT_SET,
0, 0, &Localpsmode); 0, 0, &Localpsmode);
if (ret) { if (ret) {
@@ -722,7 +722,7 @@ int libertas_ret_80211_associate(wlan_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 = libertas_connected; adapter->connect_status = LIBERTAS_CONNECTED;
lbs_deb_join("ASSOC_RESP: assocated to '%s'\n", lbs_deb_join("ASSOC_RESP: assocated to '%s'\n",
escape_essid(bss->ssid, bss->ssid_len)); escape_essid(bss->ssid, bss->ssid_len));
@@ -802,7 +802,7 @@ int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
*/ */
if (result) { if (result) {
lbs_deb_join("ADHOC_RESP: failed\n"); lbs_deb_join("ADHOC_RESP: failed\n");
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
libertas_mac_event_disconnected(priv); libertas_mac_event_disconnected(priv);
} }
ret = -1; ret = -1;
@@ -817,9 +817,9 @@ int libertas_ret_80211_ad_hoc_start(wlan_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 = libertas_connected; adapter->connect_status = LIBERTAS_CONNECTED;
if (command == cmd_ret_802_11_ad_hoc_start) { if (command == CMD_RET_802_11_AD_HOC_START) {
/* Update the created network descriptor with the new BSSID */ /* Update the created network descriptor with the new BSSID */
memcpy(bss->bssid, padhocresult->bssid, ETH_ALEN); memcpy(bss->bssid, padhocresult->bssid, ETH_ALEN);
} }

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

@@ -187,9 +187,9 @@ static ssize_t libertas_anycast_get(struct device * dev,
memset(&mesh_access, 0, sizeof(mesh_access)); memset(&mesh_access, 0, sizeof(mesh_access));
libertas_prepare_and_send_command(to_net_dev(dev)->priv, libertas_prepare_and_send_command(to_net_dev(dev)->priv,
cmd_mesh_access, CMD_MESH_ACCESS,
cmd_act_mesh_get_anycast, CMD_ACT_MESH_GET_ANYCAST,
cmd_option_waitforrsp, 0, (void *)&mesh_access); CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0])); return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
} }
@@ -208,9 +208,9 @@ static ssize_t libertas_anycast_set(struct device * dev,
mesh_access.data[0] = cpu_to_le32(datum); mesh_access.data[0] = cpu_to_le32(datum);
libertas_prepare_and_send_command((to_net_dev(dev))->priv, libertas_prepare_and_send_command((to_net_dev(dev))->priv,
cmd_mesh_access, CMD_MESH_ACCESS,
cmd_act_mesh_set_anycast, CMD_ACT_MESH_SET_ANYCAST,
cmd_option_waitforrsp, 0, (void *)&mesh_access); CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
return strlen(buf); return strlen(buf);
} }
@@ -264,7 +264,7 @@ static int wlan_dev_open(struct net_device *dev)
priv->open = 1; priv->open = 1;
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
} else { } else {
@@ -439,7 +439,7 @@ static void wlan_tx_timeout(struct net_device *dev)
libertas_send_tx_feedback(priv); libertas_send_tx_feedback(priv);
} else } else
wake_up_interruptible(&priv->mainthread.waitq); wake_up_interruptible(&priv->mainthread.waitq);
} else if (priv->adapter->connect_status == libertas_connected) { } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }
@@ -480,9 +480,9 @@ static int wlan_set_mac_address(struct net_device *dev, void *addr)
lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN); lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN);
memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN);
ret = libertas_prepare_and_send_command(priv, cmd_802_11_mac_address, ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (ret) { if (ret) {
lbs_deb_net("set MAC address failed\n"); lbs_deb_net("set MAC address failed\n");
@@ -528,36 +528,36 @@ static void wlan_set_multicast_list(struct net_device *dev)
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 |= adapter->currentpacketfilter |=
cmd_act_mac_promiscuous_enable; CMD_ACT_MAC_PROMISCUOUS_ENABLE;
adapter->currentpacketfilter &= adapter->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 &= adapter->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 |= adapter->currentpacketfilter |=
cmd_act_mac_all_multicast_enable; CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
adapter->currentpacketfilter &= adapter->currentpacketfilter &=
~cmd_act_mac_multicast_enable; ~CMD_ACT_MAC_MULTICAST_ENABLE;
} else { } else {
adapter->currentpacketfilter &= adapter->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 &= adapter->currentpacketfilter &=
~cmd_act_mac_multicast_enable; ~CMD_ACT_MAC_MULTICAST_ENABLE;
} else { } else {
int i; int i;
adapter->currentpacketfilter |= adapter->currentpacketfilter |=
cmd_act_mac_multicast_enable; CMD_ACT_MAC_MULTICAST_ENABLE;
adapter->nr_of_multicastmacaddr = adapter->nr_of_multicastmacaddr =
wlan_copy_multicast_address(adapter, dev); wlan_copy_multicast_address(adapter, dev);
@@ -577,8 +577,8 @@ static void wlan_set_multicast_list(struct net_device *dev)
} }
/* send multicast addresses to firmware */ /* send multicast addresses to firmware */
libertas_prepare_and_send_command(priv, libertas_prepare_and_send_command(priv,
cmd_mac_multicast_adr, CMD_MAC_MULTICAST_ADR,
cmd_act_set, 0, 0, CMD_ACT_SET, 0, 0,
NULL); NULL);
} }
} }
@@ -711,7 +711,7 @@ static int wlan_service_main_thread(void *data)
if (adapter->psstate == PS_STATE_PRE_SLEEP) { if (adapter->psstate == PS_STATE_PRE_SLEEP) {
if (!priv->dnld_sent && !adapter->cur_cmd) { if (!priv->dnld_sent && !adapter->cur_cmd) {
if (adapter->connect_status == if (adapter->connect_status ==
libertas_connected) { LIBERTAS_CONNECTED) {
lbs_deb_thread( lbs_deb_thread(
"main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p " "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p "
"dnld_sent=%d cur_cmd=%p, confirm now\n", "dnld_sent=%d cur_cmd=%p, confirm now\n",
@@ -1005,9 +1005,9 @@ int libertas_remove_card(wlan_private *priv)
cancel_delayed_work(&priv->assoc_work); cancel_delayed_work(&priv->assoc_work);
destroy_workqueue(priv->assoc_thread); destroy_workqueue(priv->assoc_thread);
if (adapter->psmode == wlan802_11powermodemax_psp) { if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
adapter->psmode = wlan802_11powermodecam; adapter->psmode = WLAN802_11POWERMODECAM;
libertas_ps_wakeup(priv, cmd_option_waitforrsp); libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
} }
memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);

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

@@ -255,7 +255,7 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) { for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) {
if (priv->adapter->enable11d && if (priv->adapter->enable11d &&
adapter->connect_status != libertas_connected) { adapter->connect_status != LIBERTAS_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 (!adapter->universal_channel[rgnidx].valid)
continue; continue;
@@ -287,11 +287,11 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
case BAND_G: case BAND_G:
default: default:
scanchanlist[chanidx].radiotype = scanchanlist[chanidx].radiotype =
cmd_scan_radio_type_bg; CMD_SCAN_RADIO_TYPE_BG;
break; break;
} }
if (scantype == cmd_scan_type_passive) { if (scantype == CMD_SCAN_TYPE_PASSIVE) {
scanchanlist[chanidx].maxscantime = scanchanlist[chanidx].maxscantime =
cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME); cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME);
scanchanlist[chanidx].chanscanmode.passivescan = scanchanlist[chanidx].chanscanmode.passivescan =
@@ -486,7 +486,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
scantype = puserscanin->chanlist[chanidx].scantype; scantype = puserscanin->chanlist[chanidx].scantype;
if (scantype == cmd_scan_type_passive) { if (scantype == CMD_SCAN_TYPE_PASSIVE) {
(pscanchanlist + (pscanchanlist +
chanidx)->chanscanmode.passivescan = 1; chanidx)->chanscanmode.passivescan = 1;
} else { } else {
@@ -498,7 +498,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
scandur = scandur =
puserscanin->chanlist[chanidx].scantime; puserscanin->chanlist[chanidx].scantime;
} else { } else {
if (scantype == cmd_scan_type_passive) { if (scantype == CMD_SCAN_TYPE_PASSIVE) {
scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME; scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME;
} else { } else {
scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME; scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME;
@@ -668,7 +668,7 @@ static int wlan_scan_channel_list(wlan_private * priv,
} }
/* Send the scan command to the firmware with the specified cfg */ /* Send the scan command to the firmware with the specified cfg */
ret = libertas_prepare_and_send_command(priv, cmd_802_11_scan, 0, ret = libertas_prepare_and_send_command(priv, CMD_802_11_SCAN, 0,
0, 0, pscancfgout); 0, 0, pscancfgout);
if (scanned >= 2 && !full_scan) { if (scanned >= 2 && !full_scan) {
ret = 0; ret = 0;
@@ -816,7 +816,7 @@ int wlan_scan_networks(wlan_private * priv,
mutex_unlock(&adapter->lock); mutex_unlock(&adapter->lock);
#endif #endif
if (priv->adapter->connect_status == libertas_connected) { if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
netif_carrier_on(priv->dev); netif_carrier_on(priv->dev);
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
netif_carrier_on(priv->mesh_dev); netif_carrier_on(priv->mesh_dev);
@@ -1603,8 +1603,8 @@ int libertas_get_scan(struct net_device *dev, struct iw_request_info *info,
/* 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 ((adapter->mode == IW_MODE_ADHOC) && adapter->adhoccreate) {
libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0, libertas_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(&adapter->lock);
@@ -1680,7 +1680,7 @@ int libertas_cmd_80211_scan(wlan_private * priv,
memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN); memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN);
memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen); memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen);
cmd->command = cpu_to_le16(cmd_802_11_scan); cmd->command = cpu_to_le16(CMD_802_11_SCAN);
/* size is equal to the sizeof(fixed portions) + the TLV len + header */ /* size is equal to the sizeof(fixed portions) + the TLV len + header */
cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN

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

@@ -283,7 +283,7 @@ void libertas_send_tx_feedback(wlan_private * priv)
libertas_upload_rx_packet(priv, adapter->currenttxskb); libertas_upload_rx_packet(priv, adapter->currenttxskb);
adapter->currenttxskb = NULL; adapter->currenttxskb = NULL;
priv->adapter->TxLockFlag = 0; priv->adapter->TxLockFlag = 0;
if (priv->adapter->connect_status == libertas_connected) { if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
netif_wake_queue(priv->dev); netif_wake_queue(priv->dev);
netif_wake_queue(priv->mesh_dev); netif_wake_queue(priv->mesh_dev);
} }

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

@@ -177,9 +177,9 @@ int wlan_radio_ioctl(wlan_private * priv, u8 option)
adapter->radioon = option; adapter->radioon = option;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_radio_control, CMD_802_11_RADIO_CONTROL,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
} }
lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -221,7 +221,7 @@ static int get_active_data_rates(wlan_adapter * adapter,
lbs_deb_enter(LBS_DEB_WEXT); lbs_deb_enter(LBS_DEB_WEXT);
if (adapter->connect_status != libertas_connected) { if (adapter->connect_status != LIBERTAS_CONNECTED) {
if (adapter->mode == IW_MODE_INFRA) { if (adapter->mode == IW_MODE_INFRA) {
lbs_deb_wext("infra\n"); lbs_deb_wext("infra\n");
k = copyrates(rates, k, libertas_supported_rates, k = copyrates(rates, k, libertas_supported_rates,
@@ -305,7 +305,7 @@ static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
lbs_deb_enter(LBS_DEB_WEXT); lbs_deb_enter(LBS_DEB_WEXT);
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN); memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
} else { } else {
memset(awrq->sa_data, 0, ETH_ALEN); memset(awrq->sa_data, 0, ETH_ALEN);
@@ -382,7 +382,7 @@ static int mesh_get_nick(struct net_device *dev, struct iw_request_info *info,
/* Use nickname to indicate that mesh is on */ /* Use nickname to indicate that mesh is on */
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
strncpy(extra, "Mesh", 12); strncpy(extra, "Mesh", 12);
extra[12] = '\0'; extra[12] = '\0';
dwrq->length = strlen(extra) + 1; dwrq->length = strlen(extra) + 1;
@@ -414,8 +414,8 @@ static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
adapter->rtsthsd = rthr; adapter->rtsthsd = rthr;
} }
ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
cmd_act_set, cmd_option_waitforrsp, CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
OID_802_11_RTS_THRESHOLD, &rthr); OID_802_11_RTS_THRESHOLD, &rthr);
lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -432,8 +432,8 @@ static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
lbs_deb_enter(LBS_DEB_WEXT); lbs_deb_enter(LBS_DEB_WEXT);
adapter->rtsthsd = 0; adapter->rtsthsd = 0;
ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
cmd_act_get, cmd_option_waitforrsp, CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
OID_802_11_RTS_THRESHOLD, NULL); OID_802_11_RTS_THRESHOLD, NULL);
if (ret) if (ret)
goto out; goto out;
@@ -467,8 +467,8 @@ static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
adapter->fragthsd = fthr; adapter->fragthsd = fthr;
} }
ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
cmd_act_set, cmd_option_waitforrsp, CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
OID_802_11_FRAGMENTATION_THRESHOLD, &fthr); OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -486,8 +486,8 @@ static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info,
adapter->fragthsd = 0; adapter->fragthsd = 0;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_snmp_mib, CMD_802_11_SNMP_MIB,
cmd_act_get, cmd_option_waitforrsp, CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
OID_802_11_FRAGMENTATION_THRESHOLD, NULL); OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
if (ret) if (ret)
goto out; goto out;
@@ -539,9 +539,9 @@ static int wlan_get_txpow(struct net_device *dev,
lbs_deb_enter(LBS_DEB_WEXT); lbs_deb_enter(LBS_DEB_WEXT);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_rf_tx_power, CMD_802_11_RF_TX_POWER,
cmd_act_tx_power_opt_get, CMD_ACT_TX_POWER_OPT_GET,
cmd_option_waitforrsp, 0, NULL); CMD_OPTION_WAITFORRSP, 0, NULL);
if (ret) if (ret)
goto out; goto out;
@@ -581,9 +581,9 @@ static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
/* Adding 1 to convert retry count to try count */ /* Adding 1 to convert retry count to try count */
adapter->txretrycount = vwrq->value + 1; adapter->txretrycount = vwrq->value + 1;
ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
cmd_act_set, CMD_ACT_SET,
cmd_option_waitforrsp, CMD_OPTION_WAITFORRSP,
OID_802_11_TX_RETRYCOUNT, NULL); OID_802_11_TX_RETRYCOUNT, NULL);
if (ret) if (ret)
@@ -608,8 +608,8 @@ static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
adapter->txretrycount = 0; adapter->txretrycount = 0;
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_snmp_mib, CMD_802_11_SNMP_MIB,
cmd_act_get, cmd_option_waitforrsp, CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
OID_802_11_TX_RETRYCOUNT, NULL); OID_802_11_TX_RETRYCOUNT, NULL);
if (ret) if (ret)
goto out; goto out;
@@ -698,7 +698,7 @@ static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
range->num_frequency = 0; range->num_frequency = 0;
if (priv->adapter->enable11d && if (priv->adapter->enable11d &&
adapter->connect_status == libertas_connected) { adapter->connect_status == LIBERTAS_CONNECTED) {
u8 chan_no; u8 chan_no;
u8 band; u8 band;
@@ -858,9 +858,9 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
*/ */
if (vwrq->disabled) { if (vwrq->disabled) {
adapter->psmode = wlan802_11powermodecam; adapter->psmode = WLAN802_11POWERMODECAM;
if (adapter->psstate != PS_STATE_FULL_POWER) { if (adapter->psstate != PS_STATE_FULL_POWER) {
libertas_ps_wakeup(priv, cmd_option_waitforrsp); libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
} }
return 0; return 0;
@@ -875,14 +875,14 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
return -EINVAL; return -EINVAL;
} }
if (adapter->psmode != wlan802_11powermodecam) { if (adapter->psmode != WLAN802_11POWERMODECAM) {
return 0; return 0;
} }
adapter->psmode = wlan802_11powermodemax_psp; adapter->psmode = WLAN802_11POWERMODEMAX_PSP;
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
libertas_ps_sleep(priv, cmd_option_waitforrsp); libertas_ps_sleep(priv, CMD_OPTION_WAITFORRSP);
} }
lbs_deb_leave(LBS_DEB_WEXT); lbs_deb_leave(LBS_DEB_WEXT);
@@ -900,8 +900,8 @@ static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
mode = adapter->psmode; mode = adapter->psmode;
if ((vwrq->disabled = (mode == wlan802_11powermodecam)) if ((vwrq->disabled = (mode == WLAN802_11POWERMODECAM))
|| adapter->connect_status == libertas_disconnected) || adapter->connect_status == LIBERTAS_DISCONNECTED)
{ {
goto out; goto out;
} }
@@ -937,7 +937,7 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
priv->wstats.status = adapter->mode; priv->wstats.status = adapter->mode;
/* If we're not associated, all quality values are meaningless */ /* If we're not associated, all quality values are meaningless */
if (adapter->connect_status != libertas_connected) if (adapter->connect_status != LIBERTAS_CONNECTED)
goto out; goto out;
/* Quality by RSSI */ /* Quality by RSSI */
@@ -1000,9 +1000,9 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
stats_valid = 1; stats_valid = 1;
/* update stats asynchronously for future calls */ /* update stats asynchronously for future calls */
libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0, libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
0, 0, NULL); 0, 0, NULL);
libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0, libertas_prepare_and_send_command(priv, CMD_802_11_GET_LOG, 0,
0, 0, NULL); 0, 0, NULL);
out: out:
if (!stats_valid) { if (!stats_valid) {
@@ -1128,7 +1128,7 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
lbs_deb_wext("vwrq->value %d\n", vwrq->value); lbs_deb_wext("vwrq->value %d\n", vwrq->value);
if (vwrq->value == -1) { if (vwrq->value == -1) {
action = cmd_act_set_tx_auto; // Auto action = CMD_ACT_SET_tx_auto; // Auto
adapter->is_datarate_auto = 1; adapter->is_datarate_auto = 1;
adapter->datarate = 0; adapter->datarate = 0;
} else { } else {
@@ -1155,12 +1155,12 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
} }
adapter->datarate = data_rate; adapter->datarate = data_rate;
action = cmd_act_set_tx_fix_rate; action = CMD_ACT_SET_tx_fix_rate;
adapter->is_datarate_auto = 0; adapter->is_datarate_auto = 0;
} }
ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate, ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
action, cmd_option_waitforrsp, 0, NULL); action, CMD_OPTION_WAITFORRSP, 0, NULL);
lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
return ret; return ret;
@@ -1976,7 +1976,7 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
return 0; return 0;
} }
adapter->preamble = cmd_type_auto_preamble; adapter->preamble = CMD_TYPE_AUTO_PREAMBLE;
wlan_radio_ioctl(priv, RADIO_ON); wlan_radio_ioctl(priv, RADIO_ON);
@@ -1993,9 +1993,9 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
lbs_deb_wext("txpower set %d dbm\n", dbm); lbs_deb_wext("txpower set %d dbm\n", dbm);
ret = libertas_prepare_and_send_command(priv, ret = libertas_prepare_and_send_command(priv,
cmd_802_11_rf_tx_power, CMD_802_11_RF_TX_POWER,
cmd_act_tx_power_opt_set_low, CMD_ACT_TX_POWER_OPT_SET_LOW,
cmd_option_waitforrsp, 0, (void *)&dbm); CMD_OPTION_WAITFORRSP, 0, (void *)&dbm);
lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
return ret; return ret;
@@ -2017,7 +2017,7 @@ static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
/* /*
* Get the current SSID * Get the current SSID
*/ */
if (adapter->connect_status == libertas_connected) { if (adapter->connect_status == LIBERTAS_CONNECTED) {
memcpy(extra, adapter->curbssparams.ssid, memcpy(extra, adapter->curbssparams.ssid,
adapter->curbssparams.ssid_len); adapter->curbssparams.ssid_len);
extra[adapter->curbssparams.ssid_len] = '\0'; extra[adapter->curbssparams.ssid_len] = '\0';