aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless
diff options
context:
space:
mode:
authorDan Williams <dcbw@redhat.com>2007-08-02 11:31:18 -0400
committerDavid S. Miller <davem@sunset.davemloft.net>2007-10-10 19:49:43 -0400
commit0aef64d75851c9f3545d0793f26486ed862306d8 (patch)
tree5cf333e35691636ce1dc728c749679359677cb66 /drivers/net/wireless
parentb44898eb2c917cd397a0d8654f1c249dd3cdc67e (diff)
[PATCH] libertas: re-uppercase command defines and other constants
For readability. Signed-off-by: Dan Williams <dcbw@redhat.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless')
-rw-r--r--drivers/net/wireless/libertas/11d.c22
-rw-r--r--drivers/net/wireless/libertas/assoc.c68
-rw-r--r--drivers/net/wireless/libertas/cmd.c322
-rw-r--r--drivers/net/wireless/libertas/cmdresp.c140
-rw-r--r--drivers/net/wireless/libertas/debugfs.c92
-rw-r--r--drivers/net/wireless/libertas/defs.h50
-rw-r--r--drivers/net/wireless/libertas/ethtool.c8
-rw-r--r--drivers/net/wireless/libertas/fw.c24
-rw-r--r--drivers/net/wireless/libertas/host.h436
-rw-r--r--drivers/net/wireless/libertas/hostcmd.h4
-rw-r--r--drivers/net/wireless/libertas/if_usb.c6
-rw-r--r--drivers/net/wireless/libertas/join.c74
-rw-r--r--drivers/net/wireless/libertas/main.c52
-rw-r--r--drivers/net/wireless/libertas/scan.c20
-rw-r--r--drivers/net/wireless/libertas/tx.c2
-rw-r--r--drivers/net/wireless/libertas/wext.c86
16 files changed, 703 insertions, 703 deletions
diff --git a/drivers/net/wireless/libertas/11d.c b/drivers/net/wireless/libertas/11d.c
index 4cf0ff7b833d..26d85ec37d9e 100644
--- a/drivers/net/wireless/libertas/11d.c
+++ b/drivers/net/wireless/libertas/11d.c
@@ -422,13 +422,13 @@ done:
422u8 libertas_get_scan_type_11d(u8 chan, 422u8 libertas_get_scan_type_11d(u8 chan,
423 struct parsed_region_chan_11d * parsed_region_chan) 423 struct parsed_region_chan_11d * parsed_region_chan)
424{ 424{
425 u8 scan_type = cmd_scan_type_passive; 425 u8 scan_type = CMD_SCAN_TYPE_PASSIVE;
426 426
427 lbs_deb_enter(LBS_DEB_11D); 427 lbs_deb_enter(LBS_DEB_11D);
428 428
429 if (wlan_channel_known_11d(chan, parsed_region_chan)) { 429 if (wlan_channel_known_11d(chan, parsed_region_chan)) {
430 lbs_deb_11d("11D: Found and do Active Scan\n"); 430 lbs_deb_11d("11D: Found and do Active Scan\n");
431 scan_type = cmd_scan_type_active; 431 scan_type = CMD_SCAN_TYPE_ACTIVE;
432 } else { 432 } else {
433 lbs_deb_11d("11D: Not Find and do Passive Scan\n"); 433 lbs_deb_11d("11D: Not Find and do Passive Scan\n");
434 } 434 }
@@ -454,9 +454,9 @@ static int wlan_enable_11d(wlan_private * priv, u8 flag)
454 454
455 /* send cmd to FW to enable/disable 11D function in FW */ 455 /* send cmd to FW to enable/disable 11D function in FW */
456 ret = libertas_prepare_and_send_command(priv, 456 ret = libertas_prepare_and_send_command(priv,
457 cmd_802_11_snmp_mib, 457 CMD_802_11_SNMP_MIB,
458 cmd_act_set, 458 CMD_ACT_SET,
459 cmd_option_waitforrsp, 459 CMD_OPTION_WAITFORRSP,
460 OID_802_11D_ENABLE, 460 OID_802_11D_ENABLE,
461 &priv->adapter->enable11d); 461 &priv->adapter->enable11d);
462 if (ret) 462 if (ret)
@@ -479,9 +479,9 @@ static int set_domain_info_11d(wlan_private * priv)
479 return 0; 479 return 0;
480 } 480 }
481 481
482 ret = libertas_prepare_and_send_command(priv, cmd_802_11d_domain_info, 482 ret = libertas_prepare_and_send_command(priv, CMD_802_11D_DOMAIN_INFO,
483 cmd_act_set, 483 CMD_ACT_SET,
484 cmd_option_waitforrsp, 0, NULL); 484 CMD_OPTION_WAITFORRSP, 0, NULL);
485 if (ret) 485 if (ret)
486 lbs_deb_11d("11D: Fail to dnld domain Info\n"); 486 lbs_deb_11d("11D: Fail to dnld domain Info\n");
487 487
@@ -541,7 +541,7 @@ int libertas_cmd_802_11d_domain_info(wlan_private * priv,
541 541
542 cmd->command = cpu_to_le16(cmdno); 542 cmd->command = cpu_to_le16(cmdno);
543 pdomaininfo->action = cpu_to_le16(cmdoption); 543 pdomaininfo->action = cpu_to_le16(cmdoption);
544 if (cmdoption == cmd_act_get) { 544 if (cmdoption == CMD_ACT_GET) {
545 cmd->size = 545 cmd->size =
546 cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN); 546 cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);
547 lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd, 547 lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd,
@@ -633,10 +633,10 @@ int libertas_ret_802_11d_domain_info(wlan_private * priv,
633 } 633 }
634 634
635 switch (action) { 635 switch (action) {
636 case cmd_act_set: /*Proc Set action */ 636 case CMD_ACT_SET: /*Proc Set action */
637 break; 637 break;
638 638
639 case cmd_act_get: 639 case CMD_ACT_GET:
640 break; 640 break;
641 default: 641 default:
642 lbs_deb_11d("Invalid action:%d\n", domaininfo->action); 642 lbs_deb_11d("Invalid action:%d\n", domaininfo->action);
diff --git a/drivers/net/wireless/libertas/assoc.c b/drivers/net/wireless/libertas/assoc.c
index 36586db3e1f7..5fdc96f289b8 100644
--- a/drivers/net/wireless/libertas/assoc.c
+++ b/drivers/net/wireless/libertas/assoc.c
@@ -175,14 +175,14 @@ static int assoc_helper_mode(wlan_private *priv,
175 175
176 if (assoc_req->mode == IW_MODE_INFRA) { 176 if (assoc_req->mode == IW_MODE_INFRA) {
177 if (adapter->psstate != PS_STATE_FULL_POWER) 177 if (adapter->psstate != PS_STATE_FULL_POWER)
178 libertas_ps_wakeup(priv, cmd_option_waitforrsp); 178 libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
179 adapter->psmode = wlan802_11powermodecam; 179 adapter->psmode = WLAN802_11POWERMODECAM;
180 } 180 }
181 181
182 adapter->mode = assoc_req->mode; 182 adapter->mode = assoc_req->mode;
183 ret = libertas_prepare_and_send_command(priv, 183 ret = libertas_prepare_and_send_command(priv,
184 cmd_802_11_snmp_mib, 184 CMD_802_11_SNMP_MIB,
185 0, cmd_option_waitforrsp, 185 0, CMD_OPTION_WAITFORRSP,
186 OID_802_11_INFRASTRUCTURE_MODE, 186 OID_802_11_INFRASTRUCTURE_MODE,
187 /* Shoot me now */ (void *) (size_t) assoc_req->mode); 187 /* Shoot me now */ (void *) (size_t) assoc_req->mode);
188 188
@@ -195,9 +195,9 @@ done:
195static int update_channel(wlan_private * priv) 195static int update_channel(wlan_private * priv)
196{ 196{
197 /* the channel in f/w could be out of sync, get the current channel */ 197 /* the channel in f/w could be out of sync, get the current channel */
198 return libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel, 198 return libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
199 cmd_opt_802_11_rf_channel_get, 199 CMD_OPT_802_11_RF_CHANNEL_GET,
200 cmd_option_waitforrsp, 0, NULL); 200 CMD_OPTION_WAITFORRSP, 0, NULL);
201} 201}
202 202
203void libertas_sync_channel(struct work_struct *work) 203void libertas_sync_channel(struct work_struct *work)
@@ -227,9 +227,9 @@ static int assoc_helper_channel(wlan_private *priv,
227 lbs_deb_assoc("ASSOC: channel: %d -> %d\n", 227 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
228 adapter->curbssparams.channel, assoc_req->channel); 228 adapter->curbssparams.channel, assoc_req->channel);
229 229
230 ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel, 230 ret = libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
231 cmd_opt_802_11_rf_channel_set, 231 CMD_OPT_802_11_RF_CHANNEL_SET,
232 cmd_option_waitforrsp, 0, &assoc_req->channel); 232 CMD_OPTION_WAITFORRSP, 0, &assoc_req->channel);
233 if (ret < 0) { 233 if (ret < 0) {
234 lbs_deb_assoc("ASSOC: channel: error setting channel."); 234 lbs_deb_assoc("ASSOC: channel: error setting channel.");
235 } 235 }
@@ -278,15 +278,15 @@ static int assoc_helper_wep_keys(wlan_private *priv,
278 || assoc_req->wep_keys[2].len 278 || assoc_req->wep_keys[2].len
279 || assoc_req->wep_keys[3].len) { 279 || assoc_req->wep_keys[3].len) {
280 ret = libertas_prepare_and_send_command(priv, 280 ret = libertas_prepare_and_send_command(priv,
281 cmd_802_11_set_wep, 281 CMD_802_11_SET_WEP,
282 cmd_act_add, 282 CMD_ACT_ADD,
283 cmd_option_waitforrsp, 283 CMD_OPTION_WAITFORRSP,
284 0, assoc_req); 284 0, assoc_req);
285 } else { 285 } else {
286 ret = libertas_prepare_and_send_command(priv, 286 ret = libertas_prepare_and_send_command(priv,
287 cmd_802_11_set_wep, 287 CMD_802_11_SET_WEP,
288 cmd_act_remove, 288 CMD_ACT_REMOVE,
289 cmd_option_waitforrsp, 289 CMD_OPTION_WAITFORRSP,
290 0, NULL); 290 0, NULL);
291 } 291 }
292 292
@@ -295,9 +295,9 @@ static int assoc_helper_wep_keys(wlan_private *priv,
295 295
296 /* enable/disable the MAC's WEP packet filter */ 296 /* enable/disable the MAC's WEP packet filter */
297 if (assoc_req->secinfo.wep_enabled) 297 if (assoc_req->secinfo.wep_enabled)
298 adapter->currentpacketfilter |= cmd_act_mac_wep_enable; 298 adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
299 else 299 else
300 adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable; 300 adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
301 ret = libertas_set_mac_packet_filter(priv); 301 ret = libertas_set_mac_packet_filter(priv);
302 if (ret) 302 if (ret)
303 goto out; 303 goto out;
@@ -342,9 +342,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
342 342
343 /* Get RSN enabled/disabled */ 343 /* Get RSN enabled/disabled */
344 ret = libertas_prepare_and_send_command(priv, 344 ret = libertas_prepare_and_send_command(priv,
345 cmd_802_11_enable_rsn, 345 CMD_802_11_ENABLE_RSN,
346 cmd_act_set, 346 CMD_ACT_GET,
347 cmd_option_waitforrsp, 347 CMD_OPTION_WAITFORRSP,
348 0, &rsn); 348 0, &rsn);
349 if (ret) { 349 if (ret) {
350 lbs_deb_assoc("Failed to get RSN status: %d", ret); 350 lbs_deb_assoc("Failed to get RSN status: %d", ret);
@@ -359,9 +359,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
359 /* Set RSN enabled/disabled */ 359 /* Set RSN enabled/disabled */
360 rsn = do_wpa; 360 rsn = do_wpa;
361 ret = libertas_prepare_and_send_command(priv, 361 ret = libertas_prepare_and_send_command(priv,
362 cmd_802_11_enable_rsn, 362 CMD_802_11_ENABLE_RSN,
363 cmd_act_set, 363 CMD_ACT_SET,
364 cmd_option_waitforrsp, 364 CMD_OPTION_WAITFORRSP,
365 0, &rsn); 365 0, &rsn);
366 366
367out: 367out:
@@ -378,9 +378,9 @@ static int assoc_helper_wpa_keys(wlan_private *priv,
378 lbs_deb_enter(LBS_DEB_ASSOC); 378 lbs_deb_enter(LBS_DEB_ASSOC);
379 379
380 ret = libertas_prepare_and_send_command(priv, 380 ret = libertas_prepare_and_send_command(priv,
381 cmd_802_11_key_material, 381 CMD_802_11_KEY_MATERIAL,
382 cmd_act_set, 382 CMD_ACT_SET,
383 cmd_option_waitforrsp, 383 CMD_OPTION_WAITFORRSP,
384 0, assoc_req); 384 0, assoc_req);
385 385
386 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret); 386 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@@ -412,7 +412,7 @@ static int assoc_helper_wpa_ie(wlan_private *priv,
412static int should_deauth_infrastructure(wlan_adapter *adapter, 412static int should_deauth_infrastructure(wlan_adapter *adapter,
413 struct assoc_request * assoc_req) 413 struct assoc_request * assoc_req)
414{ 414{
415 if (adapter->connect_status != libertas_connected) 415 if (adapter->connect_status != LIBERTAS_CONNECTED)
416 return 0; 416 return 0;
417 417
418 if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) { 418 if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
@@ -453,7 +453,7 @@ static int should_deauth_infrastructure(wlan_adapter *adapter,
453static int should_stop_adhoc(wlan_adapter *adapter, 453static int should_stop_adhoc(wlan_adapter *adapter,
454 struct assoc_request * assoc_req) 454 struct assoc_request * assoc_req)
455{ 455{
456 if (adapter->connect_status != libertas_connected) 456 if (adapter->connect_status != LIBERTAS_CONNECTED)
457 return 0; 457 return 0;
458 458
459 if (libertas_ssid_cmp(adapter->curbssparams.ssid, 459 if (libertas_ssid_cmp(adapter->curbssparams.ssid,
@@ -623,7 +623,7 @@ void libertas_association_worker(struct work_struct *work)
623 success = 0; 623 success = 0;
624 } 624 }
625 625
626 if (adapter->connect_status != libertas_connected) { 626 if (adapter->connect_status != LIBERTAS_CONNECTED) {
627 lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, " 627 lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, "
628 "not connected.\n"); 628 "not connected.\n");
629 success = 0; 629 success = 0;
@@ -636,12 +636,12 @@ void libertas_association_worker(struct work_struct *work)
636 adapter->curbssparams.ssid_len), 636 adapter->curbssparams.ssid_len),
637 MAC_ARG(adapter->curbssparams.bssid)); 637 MAC_ARG(adapter->curbssparams.bssid));
638 libertas_prepare_and_send_command(priv, 638 libertas_prepare_and_send_command(priv,
639 cmd_802_11_rssi, 639 CMD_802_11_RSSI,
640 0, cmd_option_waitforrsp, 0, NULL); 640 0, CMD_OPTION_WAITFORRSP, 0, NULL);
641 641
642 libertas_prepare_and_send_command(priv, 642 libertas_prepare_and_send_command(priv,
643 cmd_802_11_get_log, 643 CMD_802_11_GET_LOG,
644 0, cmd_option_waitforrsp, 0, NULL); 644 0, CMD_OPTION_WAITFORRSP, 0, NULL);
645 } else { 645 } else {
646 ret = -1; 646 ret = -1;
647 } 647 }
diff --git a/drivers/net/wireless/libertas/cmd.c b/drivers/net/wireless/libertas/cmd.c
index 355a3960323b..e0eab6e3a9b0 100644
--- a/drivers/net/wireless/libertas/cmd.c
+++ b/drivers/net/wireless/libertas/cmd.c
@@ -15,7 +15,7 @@
15static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode); 15static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode);
16 16
17static u16 commands_allowed_in_ps[] = { 17static u16 commands_allowed_in_ps[] = {
18 cmd_802_11_rssi, 18 CMD_802_11_RSSI,
19}; 19};
20 20
21/** 21/**
@@ -43,7 +43,7 @@ static int wlan_cmd_hw_spec(wlan_private * priv, struct cmd_ds_command *cmd)
43 43
44 lbs_deb_enter(LBS_DEB_CMD); 44 lbs_deb_enter(LBS_DEB_CMD);
45 45
46 cmd->command = cpu_to_le16(cmd_get_hw_spec); 46 cmd->command = cpu_to_le16(CMD_GET_HW_SPEC);
47 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN); 47 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN);
48 memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN); 48 memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN);
49 49
@@ -60,13 +60,13 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
60 60
61 lbs_deb_enter(LBS_DEB_CMD); 61 lbs_deb_enter(LBS_DEB_CMD);
62 62
63 cmd->command = cpu_to_le16(cmd_802_11_ps_mode); 63 cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
64 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) + 64 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
65 S_DS_GEN); 65 S_DS_GEN);
66 psm->action = cpu_to_le16(cmd_action); 66 psm->action = cpu_to_le16(cmd_action);
67 psm->multipledtim = 0; 67 psm->multipledtim = 0;
68 switch (cmd_action) { 68 switch (cmd_action) {
69 case cmd_subcmd_enter_ps: 69 case CMD_SUBCMD_ENTER_PS:
70 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n"); 70 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
71 lbs_deb_cmd("locallisteninterval = %d\n", 71 lbs_deb_cmd("locallisteninterval = %d\n",
72 adapter->locallisteninterval); 72 adapter->locallisteninterval);
@@ -79,11 +79,11 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
79 cpu_to_le16(priv->adapter->multipledtim); 79 cpu_to_le16(priv->adapter->multipledtim);
80 break; 80 break;
81 81
82 case cmd_subcmd_exit_ps: 82 case CMD_SUBCMD_EXIT_PS:
83 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n"); 83 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
84 break; 84 break;
85 85
86 case cmd_subcmd_sleep_confirmed: 86 case CMD_SUBCMD_SLEEP_CONFIRMED:
87 lbs_deb_cmd("PS command: SubCode- sleep confirm\n"); 87 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
88 break; 88 break;
89 89
@@ -101,7 +101,7 @@ static int wlan_cmd_802_11_inactivity_timeout(wlan_private * priv,
101{ 101{
102 u16 *timeout = pdata_buf; 102 u16 *timeout = pdata_buf;
103 103
104 cmd->command = cpu_to_le16(cmd_802_11_inactivity_timeout); 104 cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
105 cmd->size = 105 cmd->size =
106 cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout) 106 cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout)
107 + S_DS_GEN); 107 + S_DS_GEN);
@@ -127,13 +127,13 @@ static int wlan_cmd_802_11_sleep_params(wlan_private * priv,
127 127
128 cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) + 128 cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) +
129 S_DS_GEN); 129 S_DS_GEN);
130 cmd->command = cpu_to_le16(cmd_802_11_sleep_params); 130 cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS);
131 131
132 if (cmd_action == cmd_act_get) { 132 if (cmd_action == CMD_ACT_GET) {
133 memset(&adapter->sp, 0, sizeof(struct sleep_params)); 133 memset(&adapter->sp, 0, sizeof(struct sleep_params));
134 memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params)); 134 memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params));
135 sp->action = cpu_to_le16(cmd_action); 135 sp->action = cpu_to_le16(cmd_action);
136 } else if (cmd_action == cmd_act_set) { 136 } else if (cmd_action == CMD_ACT_SET) {
137 sp->action = cpu_to_le16(cmd_action); 137 sp->action = cpu_to_le16(cmd_action);
138 sp->error = cpu_to_le16(adapter->sp.sp_error); 138 sp->error = cpu_to_le16(adapter->sp.sp_error);
139 sp->offset = cpu_to_le16(adapter->sp.sp_offset); 139 sp->offset = cpu_to_le16(adapter->sp.sp_offset);
@@ -159,10 +159,10 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
159 159
160 lbs_deb_enter(LBS_DEB_CMD); 160 lbs_deb_enter(LBS_DEB_CMD);
161 161
162 cmd->command = cpu_to_le16(cmd_802_11_set_wep); 162 cmd->command = cpu_to_le16(CMD_802_11_SET_WEP);
163 cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN); 163 cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN);
164 164
165 if (cmd_act == cmd_act_add) { 165 if (cmd_act == CMD_ACT_ADD) {
166 int i; 166 int i;
167 167
168 if (!assoc_req) { 168 if (!assoc_req) {
@@ -171,11 +171,11 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
171 goto done; 171 goto done;
172 } 172 }
173 173
174 wep->action = cpu_to_le16(cmd_act_add); 174 wep->action = cpu_to_le16(CMD_ACT_ADD);
175 175
176 /* default tx key index */ 176 /* default tx key index */
177 wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx & 177 wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx &
178 (u32)cmd_WEP_KEY_INDEX_MASK)); 178 (u32)CMD_WEP_KEY_INDEX_MASK));
179 179
180 lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex)); 180 lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex));
181 181
@@ -186,13 +186,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
186 switch (pkey->len) { 186 switch (pkey->len) {
187 case KEY_LEN_WEP_40: 187 case KEY_LEN_WEP_40:
188 wep->keytype[i] = 188 wep->keytype[i] =
189 cpu_to_le16(cmd_type_wep_40_bit); 189 cpu_to_le16(CMD_TYPE_WEP_40_BIT);
190 memmove(&wep->keymaterial[i], pkey->key, 190 memmove(&wep->keymaterial[i], pkey->key,
191 pkey->len); 191 pkey->len);
192 break; 192 break;
193 case KEY_LEN_WEP_104: 193 case KEY_LEN_WEP_104:
194 wep->keytype[i] = 194 wep->keytype[i] =
195 cpu_to_le16(cmd_type_wep_104_bit); 195 cpu_to_le16(CMD_TYPE_WEP_104_BIT);
196 memmove(&wep->keymaterial[i], pkey->key, 196 memmove(&wep->keymaterial[i], pkey->key,
197 pkey->len); 197 pkey->len);
198 break; 198 break;
@@ -206,13 +206,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
206 break; 206 break;
207 } 207 }
208 } 208 }
209 } else if (cmd_act == cmd_act_remove) { 209 } else if (cmd_act == CMD_ACT_REMOVE) {
210 /* ACT_REMOVE clears _all_ WEP keys */ 210 /* ACT_REMOVE clears _all_ WEP keys */
211 wep->action = cpu_to_le16(cmd_act_remove); 211 wep->action = cpu_to_le16(CMD_ACT_REMOVE);
212 212
213 /* default tx key index */ 213 /* default tx key index */
214 wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx & 214 wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx &
215 (u32)cmd_WEP_KEY_INDEX_MASK)); 215 (u32)CMD_WEP_KEY_INDEX_MASK));
216 } 216 }
217 217
218 ret = 0; 218 ret = 0;
@@ -232,15 +232,15 @@ static int wlan_cmd_802_11_enable_rsn(wlan_private * priv,
232 232
233 lbs_deb_enter(LBS_DEB_CMD); 233 lbs_deb_enter(LBS_DEB_CMD);
234 234
235 cmd->command = cpu_to_le16(cmd_802_11_enable_rsn); 235 cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
236 cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN); 236 cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
237 penableRSN->action = cpu_to_le16(cmd_action); 237 penableRSN->action = cpu_to_le16(cmd_action);
238 238
239 if (cmd_action == cmd_act_set) { 239 if (cmd_action == CMD_ACT_SET) {
240 if (*enable) 240 if (*enable)
241 penableRSN->enable = cpu_to_le16(cmd_enable_rsn); 241 penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
242 else 242 else
243 penableRSN->enable = cpu_to_le16(cmd_disable_rsn); 243 penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
244 } 244 }
245 245
246 lbs_deb_leave(LBS_DEB_CMD); 246 lbs_deb_leave(LBS_DEB_CMD);
@@ -284,10 +284,10 @@ static int wlan_cmd_802_11_key_material(wlan_private * priv,
284 284
285 lbs_deb_enter(LBS_DEB_CMD); 285 lbs_deb_enter(LBS_DEB_CMD);
286 286
287 cmd->command = cpu_to_le16(cmd_802_11_key_material); 287 cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
288 pkeymaterial->action = cpu_to_le16(cmd_action); 288 pkeymaterial->action = cpu_to_le16(cmd_action);
289 289
290 if (cmd_action == cmd_act_get) { 290 if (cmd_action == CMD_ACT_GET) {
291 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action)); 291 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
292 ret = 0; 292 ret = 0;
293 goto done; 293 goto done;
@@ -323,7 +323,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
323{ 323{
324 struct cmd_ds_802_11_reset *reset = &cmd->params.reset; 324 struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
325 325
326 cmd->command = cpu_to_le16(cmd_802_11_reset); 326 cmd->command = cpu_to_le16(CMD_802_11_RESET);
327 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN); 327 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
328 reset->action = cpu_to_le16(cmd_action); 328 reset->action = cpu_to_le16(cmd_action);
329 329
@@ -333,7 +333,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
333static int wlan_cmd_802_11_get_log(wlan_private * priv, 333static int wlan_cmd_802_11_get_log(wlan_private * priv,
334 struct cmd_ds_command *cmd) 334 struct cmd_ds_command *cmd)
335{ 335{
336 cmd->command = cpu_to_le16(cmd_802_11_get_log); 336 cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
337 cmd->size = 337 cmd->size =
338 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN); 338 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
339 339
@@ -343,7 +343,7 @@ static int wlan_cmd_802_11_get_log(wlan_private * priv,
343static int wlan_cmd_802_11_get_stat(wlan_private * priv, 343static int wlan_cmd_802_11_get_stat(wlan_private * priv,
344 struct cmd_ds_command *cmd) 344 struct cmd_ds_command *cmd)
345{ 345{
346 cmd->command = cpu_to_le16(cmd_802_11_get_stat); 346 cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
347 cmd->size = 347 cmd->size =
348 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN); 348 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
349 349
@@ -363,15 +363,15 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
363 363
364 lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid); 364 lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
365 365
366 cmd->command = cpu_to_le16(cmd_802_11_snmp_mib); 366 cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
367 cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN); 367 cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
368 368
369 switch (cmd_oid) { 369 switch (cmd_oid) {
370 case OID_802_11_INFRASTRUCTURE_MODE: 370 case OID_802_11_INFRASTRUCTURE_MODE:
371 { 371 {
372 u8 mode = (u8) (size_t) pdata_buf; 372 u8 mode = (u8) (size_t) pdata_buf;
373 pSNMPMIB->querytype = cpu_to_le16(cmd_act_set); 373 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
374 pSNMPMIB->oid = cpu_to_le16((u16) desired_bsstype_i); 374 pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
375 pSNMPMIB->bufsize = sizeof(u8); 375 pSNMPMIB->bufsize = sizeof(u8);
376 if (mode == IW_MODE_ADHOC) { 376 if (mode == IW_MODE_ADHOC) {
377 ucTemp = SNMP_MIB_VALUE_ADHOC; 377 ucTemp = SNMP_MIB_VALUE_ADHOC;
@@ -389,10 +389,10 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
389 { 389 {
390 u32 ulTemp; 390 u32 ulTemp;
391 391
392 pSNMPMIB->oid = cpu_to_le16((u16) dot11d_i); 392 pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
393 393
394 if (cmd_action == cmd_act_set) { 394 if (cmd_action == CMD_ACT_SET) {
395 pSNMPMIB->querytype = cmd_act_set; 395 pSNMPMIB->querytype = CMD_ACT_SET;
396 pSNMPMIB->bufsize = sizeof(u16); 396 pSNMPMIB->bufsize = sizeof(u16);
397 ulTemp = *(u32 *)pdata_buf; 397 ulTemp = *(u32 *)pdata_buf;
398 *((__le16 *)(pSNMPMIB->value)) = 398 *((__le16 *)(pSNMPMIB->value)) =
@@ -405,12 +405,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
405 { 405 {
406 u32 ulTemp; 406 u32 ulTemp;
407 407
408 pSNMPMIB->oid = cpu_to_le16((u16) fragthresh_i); 408 pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
409 409
410 if (cmd_action == cmd_act_get) { 410 if (cmd_action == CMD_ACT_GET) {
411 pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); 411 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
412 } else if (cmd_action == cmd_act_set) { 412 } else if (cmd_action == CMD_ACT_SET) {
413 pSNMPMIB->querytype = cpu_to_le16(cmd_act_set); 413 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
414 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16)); 414 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
415 ulTemp = *((u32 *) pdata_buf); 415 ulTemp = *((u32 *) pdata_buf);
416 *((__le16 *)(pSNMPMIB->value)) = 416 *((__le16 *)(pSNMPMIB->value)) =
@@ -425,12 +425,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
425 { 425 {
426 426
427 u32 ulTemp; 427 u32 ulTemp;
428 pSNMPMIB->oid = le16_to_cpu((u16) rtsthresh_i); 428 pSNMPMIB->oid = le16_to_cpu((u16) RTSTHRESH_I);
429 429
430 if (cmd_action == cmd_act_get) { 430 if (cmd_action == CMD_ACT_GET) {
431 pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); 431 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
432 } else if (cmd_action == cmd_act_set) { 432 } else if (cmd_action == CMD_ACT_SET) {
433 pSNMPMIB->querytype = cpu_to_le16(cmd_act_set); 433 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
434 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16)); 434 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
435 ulTemp = *((u32 *)pdata_buf); 435 ulTemp = *((u32 *)pdata_buf);
436 *(__le16 *)(pSNMPMIB->value) = 436 *(__le16 *)(pSNMPMIB->value) =
@@ -440,12 +440,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
440 break; 440 break;
441 } 441 }
442 case OID_802_11_TX_RETRYCOUNT: 442 case OID_802_11_TX_RETRYCOUNT:
443 pSNMPMIB->oid = cpu_to_le16((u16) short_retrylim_i); 443 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
444 444
445 if (cmd_action == cmd_act_get) { 445 if (cmd_action == CMD_ACT_GET) {
446 pSNMPMIB->querytype = cpu_to_le16(cmd_act_get); 446 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
447 } else if (cmd_action == cmd_act_set) { 447 } else if (cmd_action == CMD_ACT_SET) {
448 pSNMPMIB->querytype = cpu_to_le16(cmd_act_set); 448 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
449 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16)); 449 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
450 *((__le16 *)(pSNMPMIB->value)) = 450 *((__le16 *)(pSNMPMIB->value)) =
451 cpu_to_le16((u16) adapter->txretrycount); 451 cpu_to_le16((u16) adapter->txretrycount);
@@ -483,20 +483,20 @@ static int wlan_cmd_802_11_radio_control(wlan_private * priv,
483 cmd->size = 483 cmd->size =
484 cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) + 484 cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) +
485 S_DS_GEN); 485 S_DS_GEN);
486 cmd->command = cpu_to_le16(cmd_802_11_radio_control); 486 cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL);
487 487
488 pradiocontrol->action = cpu_to_le16(cmd_action); 488 pradiocontrol->action = cpu_to_le16(cmd_action);
489 489
490 switch (adapter->preamble) { 490 switch (adapter->preamble) {
491 case cmd_type_short_preamble: 491 case CMD_TYPE_SHORT_PREAMBLE:
492 pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE); 492 pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE);
493 break; 493 break;
494 494
495 case cmd_type_long_preamble: 495 case CMD_TYPE_LONG_PREAMBLE:
496 pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE); 496 pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE);
497 break; 497 break;
498 498
499 case cmd_type_auto_preamble: 499 case CMD_TYPE_AUTO_PREAMBLE:
500 default: 500 default:
501 pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE); 501 pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE);
502 break; 502 break;
@@ -522,7 +522,7 @@ static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
522 522
523 cmd->size = 523 cmd->size =
524 cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN); 524 cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
525 cmd->command = cpu_to_le16(cmd_802_11_rf_tx_power); 525 cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
526 prtp->action = cpu_to_le16(cmd_action); 526 prtp->action = cpu_to_le16(cmd_action);
527 527
528 lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n", 528 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,
530 le16_to_cpu(prtp->action)); 530 le16_to_cpu(prtp->action));
531 531
532 switch (cmd_action) { 532 switch (cmd_action) {
533 case cmd_act_tx_power_opt_get: 533 case CMD_ACT_TX_POWER_OPT_GET:
534 prtp->action = cpu_to_le16(cmd_act_get); 534 prtp->action = cpu_to_le16(CMD_ACT_GET);
535 prtp->currentlevel = 0; 535 prtp->currentlevel = 0;
536 break; 536 break;
537 537
538 case cmd_act_tx_power_opt_set_high: 538 case CMD_ACT_TX_POWER_OPT_SET_HIGH:
539 prtp->action = cpu_to_le16(cmd_act_set); 539 prtp->action = cpu_to_le16(CMD_ACT_SET);
540 prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_high); 540 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
541 break; 541 break;
542 542
543 case cmd_act_tx_power_opt_set_mid: 543 case CMD_ACT_TX_POWER_OPT_SET_MID:
544 prtp->action = cpu_to_le16(cmd_act_set); 544 prtp->action = cpu_to_le16(CMD_ACT_SET);
545 prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_mid); 545 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
546 break; 546 break;
547 547
548 case cmd_act_tx_power_opt_set_low: 548 case CMD_ACT_TX_POWER_OPT_SET_LOW:
549 prtp->action = cpu_to_le16(cmd_act_set); 549 prtp->action = cpu_to_le16(CMD_ACT_SET);
550 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf)); 550 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
551 break; 551 break;
552 } 552 }
@@ -561,12 +561,12 @@ static int wlan_cmd_802_11_rf_antenna(wlan_private * priv,
561{ 561{
562 struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant; 562 struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant;
563 563
564 cmd->command = cpu_to_le16(cmd_802_11_rf_antenna); 564 cmd->command = cpu_to_le16(CMD_802_11_RF_ANTENNA);
565 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) + 565 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) +
566 S_DS_GEN); 566 S_DS_GEN);
567 567
568 rant->action = cpu_to_le16(cmd_action); 568 rant->action = cpu_to_le16(cmd_action);
569 if ((cmd_action == cmd_act_set_rx) || (cmd_action == cmd_act_set_tx)) { 569 if ((cmd_action == CMD_ACT_SET_rx) || (cmd_action == CMD_ACT_SET_tx)) {
570 rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf)); 570 rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf));
571 } 571 }
572 572
@@ -584,7 +584,7 @@ static int wlan_cmd_802_11_rate_adapt_rateset(wlan_private * priv,
584 cmd->size = 584 cmd->size =
585 cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset) 585 cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
586 + S_DS_GEN); 586 + S_DS_GEN);
587 cmd->command = cpu_to_le16(cmd_802_11_rate_adapt_rateset); 587 cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
588 588
589 lbs_deb_enter(LBS_DEB_CMD); 589 lbs_deb_enter(LBS_DEB_CMD);
590 590
@@ -608,17 +608,17 @@ static int wlan_cmd_802_11_data_rate(wlan_private * priv,
608 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) + 608 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) +
609 S_DS_GEN); 609 S_DS_GEN);
610 610
611 cmd->command = cpu_to_le16(cmd_802_11_data_rate); 611 cmd->command = cpu_to_le16(CMD_802_11_DATA_RATE);
612 612
613 memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate)); 613 memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate));
614 614
615 pdatarate->action = cpu_to_le16(cmd_action); 615 pdatarate->action = cpu_to_le16(cmd_action);
616 616
617 if (cmd_action == cmd_act_set_tx_fix_rate) { 617 if (cmd_action == CMD_ACT_SET_tx_fix_rate) {
618 pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate); 618 pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate);
619 lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n", 619 lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n",
620 adapter->datarate); 620 adapter->datarate);
621 } else if (cmd_action == cmd_act_set_tx_auto) { 621 } else if (cmd_action == CMD_ACT_SET_tx_auto) {
622 lbs_deb_cmd("Setting FW for AUTO rate\n"); 622 lbs_deb_cmd("Setting FW for AUTO rate\n");
623 } 623 }
624 624
@@ -635,7 +635,7 @@ static int wlan_cmd_mac_multicast_adr(wlan_private * priv,
635 635
636 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) + 636 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
637 S_DS_GEN); 637 S_DS_GEN);
638 cmd->command = cpu_to_le16(cmd_mac_multicast_adr); 638 cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
639 639
640 pMCastAdr->action = cpu_to_le16(cmd_action); 640 pMCastAdr->action = cpu_to_le16(cmd_action);
641 pMCastAdr->nr_of_adrs = 641 pMCastAdr->nr_of_adrs =
@@ -652,11 +652,11 @@ static int wlan_cmd_802_11_rf_channel(wlan_private * priv,
652{ 652{
653 struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel; 653 struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel;
654 654
655 cmd->command = cpu_to_le16(cmd_802_11_rf_channel); 655 cmd->command = cpu_to_le16(CMD_802_11_RF_CHANNEL);
656 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) + 656 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) +
657 S_DS_GEN); 657 S_DS_GEN);
658 658
659 if (option == cmd_opt_802_11_rf_channel_set) { 659 if (option == CMD_OPT_802_11_RF_CHANNEL_SET) {
660 rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf)); 660 rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf));
661 } 661 }
662 662
@@ -670,7 +670,7 @@ static int wlan_cmd_802_11_rssi(wlan_private * priv,
670{ 670{
671 wlan_adapter *adapter = priv->adapter; 671 wlan_adapter *adapter = priv->adapter;
672 672
673 cmd->command = cpu_to_le16(cmd_802_11_rssi); 673 cmd->command = cpu_to_le16(CMD_802_11_RSSI);
674 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN); 674 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
675 cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor); 675 cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor);
676 676
@@ -696,7 +696,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
696 offval = (struct wlan_offset_value *)pdata_buf; 696 offval = (struct wlan_offset_value *)pdata_buf;
697 697
698 switch (cmdptr->command) { 698 switch (cmdptr->command) {
699 case cmd_mac_reg_access: 699 case CMD_MAC_REG_ACCESS:
700 { 700 {
701 struct cmd_ds_mac_reg_access *macreg; 701 struct cmd_ds_mac_reg_access *macreg;
702 702
@@ -714,7 +714,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
714 break; 714 break;
715 } 715 }
716 716
717 case cmd_bbp_reg_access: 717 case CMD_BBP_REG_ACCESS:
718 { 718 {
719 struct cmd_ds_bbp_reg_access *bbpreg; 719 struct cmd_ds_bbp_reg_access *bbpreg;
720 720
@@ -733,7 +733,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
733 break; 733 break;
734 } 734 }
735 735
736 case cmd_rf_reg_access: 736 case CMD_RF_REG_ACCESS:
737 { 737 {
738 struct cmd_ds_rf_reg_access *rfreg; 738 struct cmd_ds_rf_reg_access *rfreg;
739 739
@@ -766,14 +766,14 @@ static int wlan_cmd_802_11_mac_address(wlan_private * priv,
766{ 766{
767 wlan_adapter *adapter = priv->adapter; 767 wlan_adapter *adapter = priv->adapter;
768 768
769 cmd->command = cpu_to_le16(cmd_802_11_mac_address); 769 cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
770 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) + 770 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
771 S_DS_GEN); 771 S_DS_GEN);
772 cmd->result = 0; 772 cmd->result = 0;
773 773
774 cmd->params.macadd.action = cpu_to_le16(cmd_action); 774 cmd->params.macadd.action = cpu_to_le16(cmd_action);
775 775
776 if (cmd_action == cmd_act_set) { 776 if (cmd_action == CMD_ACT_SET) {
777 memcpy(cmd->params.macadd.macadd, 777 memcpy(cmd->params.macadd.macadd,
778 adapter->current_addr, ETH_ALEN); 778 adapter->current_addr, ETH_ALEN);
779 lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6); 779 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,
790 790
791 lbs_deb_enter(LBS_DEB_CMD); 791 lbs_deb_enter(LBS_DEB_CMD);
792 792
793 cmd->command = cpu_to_le16(cmd_802_11_eeprom_access); 793 cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
794 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) + 794 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
795 S_DS_GEN); 795 S_DS_GEN);
796 cmd->result = 0; 796 cmd->result = 0;
@@ -810,29 +810,29 @@ static int wlan_cmd_bt_access(wlan_private * priv,
810 struct cmd_ds_bt_access *bt_access = &cmd->params.bt; 810 struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
811 lbs_deb_cmd("BT CMD(%d)\n", cmd_action); 811 lbs_deb_cmd("BT CMD(%d)\n", cmd_action);
812 812
813 cmd->command = cpu_to_le16(cmd_bt_access); 813 cmd->command = cpu_to_le16(CMD_BT_ACCESS);
814 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN); 814 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
815 cmd->result = 0; 815 cmd->result = 0;
816 bt_access->action = cpu_to_le16(cmd_action); 816 bt_access->action = cpu_to_le16(cmd_action);
817 817
818 switch (cmd_action) { 818 switch (cmd_action) {
819 case cmd_act_bt_access_add: 819 case CMD_ACT_BT_ACCESS_ADD:
820 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN); 820 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
821 lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6); 821 lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6);
822 break; 822 break;
823 case cmd_act_bt_access_del: 823 case CMD_ACT_BT_ACCESS_DEL:
824 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN); 824 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
825 lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6); 825 lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6);
826 break; 826 break;
827 case cmd_act_bt_access_list: 827 case CMD_ACT_BT_ACCESS_LIST:
828 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf); 828 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
829 break; 829 break;
830 case cmd_act_bt_access_reset: 830 case CMD_ACT_BT_ACCESS_RESET:
831 break; 831 break;
832 case cmd_act_bt_access_set_invert: 832 case CMD_ACT_BT_ACCESS_SET_INVERT:
833 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf); 833 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
834 break; 834 break;
835 case cmd_act_bt_access_get_invert: 835 case CMD_ACT_BT_ACCESS_GET_INVERT:
836 break; 836 break;
837 default: 837 default:
838 break; 838 break;
@@ -847,7 +847,7 @@ static int wlan_cmd_fwt_access(wlan_private * priv,
847 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt; 847 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
848 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action); 848 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
849 849
850 cmd->command = cpu_to_le16(cmd_fwt_access); 850 cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
851 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN); 851 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
852 cmd->result = 0; 852 cmd->result = 0;
853 853
@@ -868,7 +868,7 @@ static int wlan_cmd_mesh_access(wlan_private * priv,
868 struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh; 868 struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh;
869 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action); 869 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
870 870
871 cmd->command = cpu_to_le16(cmd_mesh_access); 871 cmd->command = cpu_to_le16(CMD_MESH_ACCESS);
872 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN); 872 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN);
873 cmd->result = 0; 873 cmd->result = 0;
874 874
@@ -901,9 +901,9 @@ void libertas_queue_cmd(wlan_adapter * adapter, struct cmd_ctrl_node *cmdnode, u
901 } 901 }
902 902
903 /* Exit_PS command needs to be queued in the header always. */ 903 /* Exit_PS command needs to be queued in the header always. */
904 if (cmdptr->command == cmd_802_11_ps_mode) { 904 if (cmdptr->command == CMD_802_11_PS_MODE) {
905 struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode; 905 struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode;
906 if (psm->action == cpu_to_le16(cmd_subcmd_exit_ps)) { 906 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
907 if (adapter->psstate != PS_STATE_FULL_POWER) 907 if (adapter->psstate != PS_STATE_FULL_POWER)
908 addtail = 0; 908 addtail = 0;
909 } 909 }
@@ -1000,8 +1000,8 @@ static int DownloadcommandToStation(wlan_private * priv,
1000 lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize); 1000 lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize);
1001 1001
1002 /* Setup the timer after transmit command */ 1002 /* Setup the timer after transmit command */
1003 if (command == cmd_802_11_scan || command == cmd_802_11_authenticate 1003 if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE
1004 || command == cmd_802_11_associate) 1004 || command == CMD_802_11_ASSOCIATE)
1005 mod_timer(&adapter->command_timer, jiffies + (10*HZ)); 1005 mod_timer(&adapter->command_timer, jiffies + (10*HZ));
1006 else 1006 else
1007 mod_timer(&adapter->command_timer, jiffies + (5*HZ)); 1007 mod_timer(&adapter->command_timer, jiffies + (5*HZ));
@@ -1020,7 +1020,7 @@ static int wlan_cmd_mac_control(wlan_private * priv,
1020 1020
1021 lbs_deb_enter(LBS_DEB_CMD); 1021 lbs_deb_enter(LBS_DEB_CMD);
1022 1022
1023 cmd->command = cpu_to_le16(cmd_mac_control); 1023 cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1024 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN); 1024 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1025 mac->action = cpu_to_le16(priv->adapter->currentpacketfilter); 1025 mac->action = cpu_to_le16(priv->adapter->currentpacketfilter);
1026 1026
@@ -1064,9 +1064,9 @@ int libertas_set_radio_control(wlan_private * priv)
1064 lbs_deb_enter(LBS_DEB_CMD); 1064 lbs_deb_enter(LBS_DEB_CMD);
1065 1065
1066 ret = libertas_prepare_and_send_command(priv, 1066 ret = libertas_prepare_and_send_command(priv,
1067 cmd_802_11_radio_control, 1067 CMD_802_11_RADIO_CONTROL,
1068 cmd_act_set, 1068 CMD_ACT_SET,
1069 cmd_option_waitforrsp, 0, NULL); 1069 CMD_OPTION_WAITFORRSP, 0, NULL);
1070 1070
1071 lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n", 1071 lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n",
1072 priv->adapter->radioon, priv->adapter->preamble); 1072 priv->adapter->radioon, priv->adapter->preamble);
@@ -1086,7 +1086,7 @@ int libertas_set_mac_packet_filter(wlan_private * priv)
1086 1086
1087 /* Send MAC control command to station */ 1087 /* Send MAC control command to station */
1088 ret = libertas_prepare_and_send_command(priv, 1088 ret = libertas_prepare_and_send_command(priv,
1089 cmd_mac_control, 0, 0, 0, NULL); 1089 CMD_MAC_CONTROL, 0, 0, 0, NULL);
1090 1090
1091 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 1091 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1092 return ret; 1092 return ret;
@@ -1161,136 +1161,136 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1161 cmdptr->result = 0; 1161 cmdptr->result = 0;
1162 1162
1163 switch (cmd_no) { 1163 switch (cmd_no) {
1164 case cmd_get_hw_spec: 1164 case CMD_GET_HW_SPEC:
1165 ret = wlan_cmd_hw_spec(priv, cmdptr); 1165 ret = wlan_cmd_hw_spec(priv, cmdptr);
1166 break; 1166 break;
1167 case cmd_802_11_ps_mode: 1167 case CMD_802_11_PS_MODE:
1168 ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action); 1168 ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1169 break; 1169 break;
1170 1170
1171 case cmd_802_11_scan: 1171 case CMD_802_11_SCAN:
1172 ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf); 1172 ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf);
1173 break; 1173 break;
1174 1174
1175 case cmd_mac_control: 1175 case CMD_MAC_CONTROL:
1176 ret = wlan_cmd_mac_control(priv, cmdptr); 1176 ret = wlan_cmd_mac_control(priv, cmdptr);
1177 break; 1177 break;
1178 1178
1179 case cmd_802_11_associate: 1179 case CMD_802_11_ASSOCIATE:
1180 case cmd_802_11_reassociate: 1180 case CMD_802_11_REASSOCIATE:
1181 ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf); 1181 ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf);
1182 break; 1182 break;
1183 1183
1184 case cmd_802_11_deauthenticate: 1184 case CMD_802_11_DEAUTHENTICATE:
1185 ret = libertas_cmd_80211_deauthenticate(priv, cmdptr); 1185 ret = libertas_cmd_80211_deauthenticate(priv, cmdptr);
1186 break; 1186 break;
1187 1187
1188 case cmd_802_11_set_wep: 1188 case CMD_802_11_SET_WEP:
1189 ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf); 1189 ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf);
1190 break; 1190 break;
1191 1191
1192 case cmd_802_11_ad_hoc_start: 1192 case CMD_802_11_AD_HOC_START:
1193 ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf); 1193 ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1194 break; 1194 break;
1195 case cmd_code_dnld: 1195 case CMD_CODE_DNLD:
1196 break; 1196 break;
1197 1197
1198 case cmd_802_11_reset: 1198 case CMD_802_11_RESET:
1199 ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action); 1199 ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action);
1200 break; 1200 break;
1201 1201
1202 case cmd_802_11_get_log: 1202 case CMD_802_11_GET_LOG:
1203 ret = wlan_cmd_802_11_get_log(priv, cmdptr); 1203 ret = wlan_cmd_802_11_get_log(priv, cmdptr);
1204 break; 1204 break;
1205 1205
1206 case cmd_802_11_authenticate: 1206 case CMD_802_11_AUTHENTICATE:
1207 ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf); 1207 ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1208 break; 1208 break;
1209 1209
1210 case cmd_802_11_get_stat: 1210 case CMD_802_11_GET_STAT:
1211 ret = wlan_cmd_802_11_get_stat(priv, cmdptr); 1211 ret = wlan_cmd_802_11_get_stat(priv, cmdptr);
1212 break; 1212 break;
1213 1213
1214 case cmd_802_11_snmp_mib: 1214 case CMD_802_11_SNMP_MIB:
1215 ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr, 1215 ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr,
1216 cmd_action, cmd_oid, pdata_buf); 1216 cmd_action, cmd_oid, pdata_buf);
1217 break; 1217 break;
1218 1218
1219 case cmd_mac_reg_access: 1219 case CMD_MAC_REG_ACCESS:
1220 case cmd_bbp_reg_access: 1220 case CMD_BBP_REG_ACCESS:
1221 case cmd_rf_reg_access: 1221 case CMD_RF_REG_ACCESS:
1222 ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf); 1222 ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1223 break; 1223 break;
1224 1224
1225 case cmd_802_11_rf_channel: 1225 case CMD_802_11_RF_CHANNEL:
1226 ret = wlan_cmd_802_11_rf_channel(priv, cmdptr, 1226 ret = wlan_cmd_802_11_rf_channel(priv, cmdptr,
1227 cmd_action, pdata_buf); 1227 cmd_action, pdata_buf);
1228 break; 1228 break;
1229 1229
1230 case cmd_802_11_rf_tx_power: 1230 case CMD_802_11_RF_TX_POWER:
1231 ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr, 1231 ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr,
1232 cmd_action, pdata_buf); 1232 cmd_action, pdata_buf);
1233 break; 1233 break;
1234 1234
1235 case cmd_802_11_radio_control: 1235 case CMD_802_11_RADIO_CONTROL:
1236 ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action); 1236 ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action);
1237 break; 1237 break;
1238 1238
1239 case cmd_802_11_rf_antenna: 1239 case CMD_802_11_RF_ANTENNA:
1240 ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr, 1240 ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr,
1241 cmd_action, pdata_buf); 1241 cmd_action, pdata_buf);
1242 break; 1242 break;
1243 1243
1244 case cmd_802_11_data_rate: 1244 case CMD_802_11_DATA_RATE:
1245 ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action); 1245 ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action);
1246 break; 1246 break;
1247 case cmd_802_11_rate_adapt_rateset: 1247 case CMD_802_11_RATE_ADAPT_RATESET:
1248 ret = wlan_cmd_802_11_rate_adapt_rateset(priv, 1248 ret = wlan_cmd_802_11_rate_adapt_rateset(priv,
1249 cmdptr, cmd_action); 1249 cmdptr, cmd_action);
1250 break; 1250 break;
1251 1251
1252 case cmd_mac_multicast_adr: 1252 case CMD_MAC_MULTICAST_ADR:
1253 ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action); 1253 ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1254 break; 1254 break;
1255 1255
1256 case cmd_802_11_ad_hoc_join: 1256 case CMD_802_11_AD_HOC_JOIN:
1257 ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf); 1257 ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1258 break; 1258 break;
1259 1259
1260 case cmd_802_11_rssi: 1260 case CMD_802_11_RSSI:
1261 ret = wlan_cmd_802_11_rssi(priv, cmdptr); 1261 ret = wlan_cmd_802_11_rssi(priv, cmdptr);
1262 break; 1262 break;
1263 1263
1264 case cmd_802_11_ad_hoc_stop: 1264 case CMD_802_11_AD_HOC_STOP:
1265 ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr); 1265 ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr);
1266 break; 1266 break;
1267 1267
1268 case cmd_802_11_enable_rsn: 1268 case CMD_802_11_ENABLE_RSN:
1269 ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action, 1269 ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
1270 pdata_buf); 1270 pdata_buf);
1271 break; 1271 break;
1272 1272
1273 case cmd_802_11_key_material: 1273 case CMD_802_11_KEY_MATERIAL:
1274 ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action, 1274 ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1275 cmd_oid, pdata_buf); 1275 cmd_oid, pdata_buf);
1276 break; 1276 break;
1277 1277
1278 case cmd_802_11_pairwise_tsc: 1278 case CMD_802_11_PAIRWISE_TSC:
1279 break; 1279 break;
1280 case cmd_802_11_group_tsc: 1280 case CMD_802_11_GROUP_TSC:
1281 break; 1281 break;
1282 1282
1283 case cmd_802_11_mac_address: 1283 case CMD_802_11_MAC_ADDRESS:
1284 ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action); 1284 ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1285 break; 1285 break;
1286 1286
1287 case cmd_802_11_eeprom_access: 1287 case CMD_802_11_EEPROM_ACCESS:
1288 ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr, 1288 ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr,
1289 cmd_action, pdata_buf); 1289 cmd_action, pdata_buf);
1290 break; 1290 break;
1291 1291
1292 case cmd_802_11_set_afc: 1292 case CMD_802_11_SET_AFC:
1293 case cmd_802_11_get_afc: 1293 case CMD_802_11_GET_AFC:
1294 1294
1295 cmdptr->command = cpu_to_le16(cmd_no); 1295 cmdptr->command = cpu_to_le16(cmd_no);
1296 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) + 1296 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,
1302 ret = 0; 1302 ret = 0;
1303 goto done; 1303 goto done;
1304 1304
1305 case cmd_802_11d_domain_info: 1305 case CMD_802_11D_DOMAIN_INFO:
1306 ret = libertas_cmd_802_11d_domain_info(priv, cmdptr, 1306 ret = libertas_cmd_802_11d_domain_info(priv, cmdptr,
1307 cmd_no, cmd_action); 1307 cmd_no, cmd_action);
1308 break; 1308 break;
1309 1309
1310 case cmd_802_11_sleep_params: 1310 case CMD_802_11_SLEEP_PARAMS:
1311 ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action); 1311 ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action);
1312 break; 1312 break;
1313 case cmd_802_11_inactivity_timeout: 1313 case CMD_802_11_INACTIVITY_TIMEOUT:
1314 ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr, 1314 ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr,
1315 cmd_action, pdata_buf); 1315 cmd_action, pdata_buf);
1316 libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf); 1316 libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf);
1317 break; 1317 break;
1318 1318
1319 case cmd_802_11_tpc_cfg: 1319 case CMD_802_11_TPC_CFG:
1320 cmdptr->command = cpu_to_le16(cmd_802_11_tpc_cfg); 1320 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1321 cmdptr->size = 1321 cmdptr->size =
1322 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) + 1322 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1323 S_DS_GEN); 1323 S_DS_GEN);
@@ -1327,7 +1327,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1327 1327
1328 ret = 0; 1328 ret = 0;
1329 break; 1329 break;
1330 case cmd_802_11_led_gpio_ctrl: 1330 case CMD_802_11_LED_GPIO_CTRL:
1331 { 1331 {
1332 struct mrvlietypes_ledgpio *gpio = 1332 struct mrvlietypes_ledgpio *gpio =
1333 (struct mrvlietypes_ledgpio*) 1333 (struct mrvlietypes_ledgpio*)
@@ -1338,7 +1338,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1338 sizeof(struct cmd_ds_802_11_led_ctrl)); 1338 sizeof(struct cmd_ds_802_11_led_ctrl));
1339 1339
1340 cmdptr->command = 1340 cmdptr->command =
1341 cpu_to_le16(cmd_802_11_led_gpio_ctrl); 1341 cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1342 1342
1343#define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8 1343#define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1344 cmdptr->size = 1344 cmdptr->size =
@@ -1349,8 +1349,8 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1349 ret = 0; 1349 ret = 0;
1350 break; 1350 break;
1351 } 1351 }
1352 case cmd_802_11_pwr_cfg: 1352 case CMD_802_11_PWR_CFG:
1353 cmdptr->command = cpu_to_le16(cmd_802_11_pwr_cfg); 1353 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1354 cmdptr->size = 1354 cmdptr->size =
1355 cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) + 1355 cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1356 S_DS_GEN); 1356 S_DS_GEN);
@@ -1359,26 +1359,26 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1359 1359
1360 ret = 0; 1360 ret = 0;
1361 break; 1361 break;
1362 case cmd_bt_access: 1362 case CMD_BT_ACCESS:
1363 ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf); 1363 ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1364 break; 1364 break;
1365 1365
1366 case cmd_fwt_access: 1366 case CMD_FWT_ACCESS:
1367 ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf); 1367 ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1368 break; 1368 break;
1369 1369
1370 case cmd_mesh_access: 1370 case CMD_MESH_ACCESS:
1371 ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf); 1371 ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf);
1372 break; 1372 break;
1373 1373
1374 case cmd_get_tsf: 1374 case CMD_GET_TSF:
1375 cmdptr->command = cpu_to_le16(cmd_get_tsf); 1375 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1376 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) + 1376 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1377 S_DS_GEN); 1377 S_DS_GEN);
1378 ret = 0; 1378 ret = 0;
1379 break; 1379 break;
1380 case cmd_802_11_tx_rate_query: 1380 case CMD_802_11_TX_RATE_QUERY:
1381 cmdptr->command = cpu_to_le16(cmd_802_11_tx_rate_query); 1381 cmdptr->command = cpu_to_le16(CMD_802_11_TX_RATE_QUERY);
1382 cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) + 1382 cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) +
1383 S_DS_GEN); 1383 S_DS_GEN);
1384 adapter->txrate = 0; 1384 adapter->txrate = 0;
@@ -1404,7 +1404,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
1404 adapter->nr_cmd_pending++; 1404 adapter->nr_cmd_pending++;
1405 wake_up_interruptible(&priv->mainthread.waitq); 1405 wake_up_interruptible(&priv->mainthread.waitq);
1406 1406
1407 if (wait_option & cmd_option_waitforrsp) { 1407 if (wait_option & CMD_OPTION_WAITFORRSP) {
1408 lbs_deb_cmd("PREP_CMD: Wait for CMD response\n"); 1408 lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
1409 might_sleep(); 1409 might_sleep();
1410 wait_event_interruptible(cmdnode->cmdwait_q, 1410 wait_event_interruptible(cmdnode->cmdwait_q,
@@ -1680,7 +1680,7 @@ int libertas_execute_next_command(wlan_private * priv)
1680 * immediately. 1680 * immediately.
1681 */ 1681 */
1682 if (cmdptr->command != 1682 if (cmdptr->command !=
1683 cpu_to_le16(cmd_802_11_ps_mode)) { 1683 cpu_to_le16(CMD_802_11_PS_MODE)) {
1684 /* Prepare to send Exit PS, 1684 /* Prepare to send Exit PS,
1685 * this non PS command will be sent later */ 1685 * this non PS command will be sent later */
1686 if ((adapter->psstate == PS_STATE_SLEEP) 1686 if ((adapter->psstate == PS_STATE_SLEEP)
@@ -1706,7 +1706,7 @@ int libertas_execute_next_command(wlan_private * priv)
1706 "EXEC_NEXT_CMD: PS cmd- action=0x%x\n", 1706 "EXEC_NEXT_CMD: PS cmd- action=0x%x\n",
1707 psm->action); 1707 psm->action);
1708 if (psm->action != 1708 if (psm->action !=
1709 cpu_to_le16(cmd_subcmd_exit_ps)) { 1709 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1710 lbs_deb_cmd( 1710 lbs_deb_cmd(
1711 "EXEC_NEXT_CMD: Ignore Enter PS cmd\n"); 1711 "EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
1712 list_del((struct list_head *)cmdnode); 1712 list_del((struct list_head *)cmdnode);
@@ -1741,9 +1741,9 @@ int libertas_execute_next_command(wlan_private * priv)
1741 * check if in power save mode, if yes, put the device back 1741 * check if in power save mode, if yes, put the device back
1742 * to PS mode 1742 * to PS mode
1743 */ 1743 */
1744 if ((adapter->psmode != wlan802_11powermodecam) && 1744 if ((adapter->psmode != WLAN802_11POWERMODECAM) &&
1745 (adapter->psstate == PS_STATE_FULL_POWER) && 1745 (adapter->psstate == PS_STATE_FULL_POWER) &&
1746 (adapter->connect_status == libertas_connected)) { 1746 (adapter->connect_status == LIBERTAS_CONNECTED)) {
1747 if (adapter->secinfo.WPAenabled || 1747 if (adapter->secinfo.WPAenabled ||
1748 adapter->secinfo.WPA2enabled) { 1748 adapter->secinfo.WPA2enabled) {
1749 /* check for valid WPA group keys */ 1749 /* check for valid WPA group keys */
@@ -1845,8 +1845,8 @@ void libertas_ps_sleep(wlan_private * priv, int wait_option)
1845 * Remove this check if it is to be supported in IBSS mode also 1845 * Remove this check if it is to be supported in IBSS mode also
1846 */ 1846 */
1847 1847
1848 libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode, 1848 libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1849 cmd_subcmd_enter_ps, wait_option, 0, NULL); 1849 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1850 1850
1851 lbs_deb_leave(LBS_DEB_CMD); 1851 lbs_deb_leave(LBS_DEB_CMD);
1852} 1852}
@@ -1864,12 +1864,12 @@ void libertas_ps_wakeup(wlan_private * priv, int wait_option)
1864 1864
1865 lbs_deb_enter(LBS_DEB_CMD); 1865 lbs_deb_enter(LBS_DEB_CMD);
1866 1866
1867 Localpsmode = cpu_to_le32(wlan802_11powermodecam); 1867 Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
1868 1868
1869 lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", wlan802_11powermodecam); 1869 lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", WLAN802_11POWERMODECAM);
1870 1870
1871 libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode, 1871 libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1872 cmd_subcmd_exit_ps, 1872 CMD_SUBCMD_EXIT_PS,
1873 wait_option, 0, &Localpsmode); 1873 wait_option, 0, &Localpsmode);
1874 1874
1875 lbs_deb_leave(LBS_DEB_CMD); 1875 lbs_deb_leave(LBS_DEB_CMD);
diff --git a/drivers/net/wireless/libertas/cmdresp.c b/drivers/net/wireless/libertas/cmdresp.c
index 89bd43c2efa3..4c15071984b9 100644
--- a/drivers/net/wireless/libertas/cmdresp.c
+++ b/drivers/net/wireless/libertas/cmdresp.c
@@ -28,7 +28,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
28 wlan_adapter *adapter = priv->adapter; 28 wlan_adapter *adapter = priv->adapter;
29 union iwreq_data wrqu; 29 union iwreq_data wrqu;
30 30
31 if (adapter->connect_status != libertas_connected) 31 if (adapter->connect_status != LIBERTAS_CONNECTED)
32 return; 32 return;
33 33
34 lbs_deb_cmd("Handles disconnect event.\n"); 34 lbs_deb_cmd("Handles disconnect event.\n");
@@ -69,7 +69,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
69 escape_essid(adapter->prev_ssid, adapter->prev_ssid_len), 69 escape_essid(adapter->prev_ssid, adapter->prev_ssid_len),
70 adapter->prev_ssid_len); 70 adapter->prev_ssid_len);
71 71
72 adapter->connect_status = libertas_disconnected; 72 adapter->connect_status = LIBERTAS_DISCONNECTED;
73 73
74 /* Save previous SSID and BSSID for possible reassociation */ 74 /* Save previous SSID and BSSID for possible reassociation */
75 memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid, 75 memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid,
@@ -124,7 +124,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
124 lbs_deb_enter(LBS_DEB_CMD); 124 lbs_deb_enter(LBS_DEB_CMD);
125 125
126 switch (type) { 126 switch (type) {
127 case cmd_ret_mac_reg_access: 127 case CMD_RET_MAC_REG_ACCESS:
128 { 128 {
129 struct cmd_ds_mac_reg_access *reg = &resp->params.macreg; 129 struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
130 130
@@ -133,7 +133,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
133 break; 133 break;
134 } 134 }
135 135
136 case cmd_ret_bbp_reg_access: 136 case CMD_RET_BBP_REG_ACCESS:
137 { 137 {
138 struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg; 138 struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
139 139
@@ -142,7 +142,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
142 break; 142 break;
143 } 143 }
144 144
145 case cmd_ret_rf_reg_access: 145 case CMD_RET_RF_REG_ACCESS:
146 { 146 {
147 struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg; 147 struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
148 148
@@ -274,21 +274,21 @@ static int wlan_ret_802_11_snmp_mib(wlan_private * priv,
274 querytype); 274 querytype);
275 lbs_deb_cmd("SNMP_RESP: Buf size = %x\n", le16_to_cpu(smib->bufsize)); 275 lbs_deb_cmd("SNMP_RESP: Buf size = %x\n", le16_to_cpu(smib->bufsize));
276 276
277 if (querytype == cmd_act_get) { 277 if (querytype == CMD_ACT_GET) {
278 switch (oid) { 278 switch (oid) {
279 case fragthresh_i: 279 case FRAGTHRESH_I:
280 priv->adapter->fragthsd = 280 priv->adapter->fragthsd =
281 le16_to_cpu(*((__le16 *)(smib->value))); 281 le16_to_cpu(*((__le16 *)(smib->value)));
282 lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n", 282 lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n",
283 priv->adapter->fragthsd); 283 priv->adapter->fragthsd);
284 break; 284 break;
285 case rtsthresh_i: 285 case RTSTHRESH_I:
286 priv->adapter->rtsthsd = 286 priv->adapter->rtsthsd =
287 le16_to_cpu(*((__le16 *)(smib->value))); 287 le16_to_cpu(*((__le16 *)(smib->value)));
288 lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n", 288 lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n",
289 priv->adapter->rtsthsd); 289 priv->adapter->rtsthsd);
290 break; 290 break;
291 case short_retrylim_i: 291 case SHORT_RETRYLIM_I:
292 priv->adapter->txretrycount = 292 priv->adapter->txretrycount =
293 le16_to_cpu(*((__le16 *)(smib->value))); 293 le16_to_cpu(*((__le16 *)(smib->value)));
294 lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n", 294 lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n",
@@ -314,7 +314,7 @@ static int wlan_ret_802_11_key_material(wlan_private * priv,
314 lbs_deb_enter(LBS_DEB_CMD); 314 lbs_deb_enter(LBS_DEB_CMD);
315 315
316 /* Copy the returned key to driver private data */ 316 /* Copy the returned key to driver private data */
317 if (action == cmd_act_get) { 317 if (action == CMD_ACT_GET) {
318 u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet; 318 u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;
319 u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size)); 319 u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
320 320
@@ -396,10 +396,10 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
396 wlan_adapter *adapter = priv->adapter; 396 wlan_adapter *adapter = priv->adapter;
397 u16 action = le16_to_cpu(pAntenna->action); 397 u16 action = le16_to_cpu(pAntenna->action);
398 398
399 if (action == cmd_act_get_rx) 399 if (action == CMD_ACT_GET_rx)
400 adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode); 400 adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);
401 401
402 if (action == cmd_act_get_tx) 402 if (action == CMD_ACT_GET_tx)
403 adapter->txantennamode = le16_to_cpu(pAntenna->antennamode); 403 adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);
404 404
405 lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n", 405 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,
416 416
417 lbs_deb_enter(LBS_DEB_CMD); 417 lbs_deb_enter(LBS_DEB_CMD);
418 418
419 if (rates->action == cmd_act_get) { 419 if (rates->action == CMD_ACT_GET) {
420 adapter->enablehwauto = le16_to_cpu(rates->enablehwauto); 420 adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
421 adapter->ratebitmap = le16_to_cpu(rates->bitmap); 421 adapter->ratebitmap = le16_to_cpu(rates->bitmap);
422 } 422 }
@@ -438,7 +438,7 @@ static int wlan_ret_802_11_data_rate(wlan_private * priv,
438 (u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate)); 438 (u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate));
439 439
440 dot11datarate = pdatarate->datarate[0]; 440 dot11datarate = pdatarate->datarate[0];
441 if (pdatarate->action == cpu_to_le16(cmd_act_get_tx_rate)) { 441 if (pdatarate->action == cpu_to_le16(CMD_ACT_GET_tx_rate)) {
442 memcpy(adapter->libertas_supported_rates, pdatarate->datarate, 442 memcpy(adapter->libertas_supported_rates, pdatarate->datarate,
443 sizeof(adapter->libertas_supported_rates)); 443 sizeof(adapter->libertas_supported_rates));
444 } 444 }
@@ -458,7 +458,7 @@ static int wlan_ret_802_11_rf_channel(wlan_private * priv,
458 458
459 lbs_deb_enter(LBS_DEB_CMD); 459 lbs_deb_enter(LBS_DEB_CMD);
460 460
461 if (action == cmd_opt_802_11_rf_channel_get 461 if (action == CMD_OPT_802_11_RF_CHANNEL_GET
462 && adapter->curbssparams.channel != newchannel) { 462 && adapter->curbssparams.channel != newchannel) {
463 lbs_deb_cmd("channel Switch: %d to %d\n", 463 lbs_deb_cmd("channel Switch: %d to %d\n",
464 adapter->curbssparams.channel, newchannel); 464 adapter->curbssparams.channel, newchannel);
@@ -547,7 +547,7 @@ static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
547 547
548 lbs_deb_enter(LBS_DEB_CMD); 548 lbs_deb_enter(LBS_DEB_CMD);
549 549
550 if (enable_rsn->action == cpu_to_le16(cmd_act_get)) { 550 if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
551 if (pdata_buf) 551 if (pdata_buf)
552 *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable); 552 *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
553 } 553 }
@@ -565,134 +565,134 @@ static inline int handle_cmd_response(u16 respcmd,
565 wlan_adapter *adapter = priv->adapter; 565 wlan_adapter *adapter = priv->adapter;
566 566
567 switch (respcmd) { 567 switch (respcmd) {
568 case cmd_ret_mac_reg_access: 568 case CMD_RET_MAC_REG_ACCESS:
569 case cmd_ret_bbp_reg_access: 569 case CMD_RET_BBP_REG_ACCESS:
570 case cmd_ret_rf_reg_access: 570 case CMD_RET_RF_REG_ACCESS:
571 ret = wlan_ret_reg_access(priv, respcmd, resp); 571 ret = wlan_ret_reg_access(priv, respcmd, resp);
572 break; 572 break;
573 573
574 case cmd_ret_hw_spec_info: 574 case CMD_RET_HW_SPEC_INFO:
575 ret = wlan_ret_get_hw_spec(priv, resp); 575 ret = wlan_ret_get_hw_spec(priv, resp);
576 break; 576 break;
577 577
578 case cmd_ret_802_11_scan: 578 case CMD_RET_802_11_SCAN:
579 ret = libertas_ret_80211_scan(priv, resp); 579 ret = libertas_ret_80211_scan(priv, resp);
580 break; 580 break;
581 581
582 case cmd_ret_802_11_get_log: 582 case CMD_RET_802_11_GET_LOG:
583 ret = wlan_ret_get_log(priv, resp); 583 ret = wlan_ret_get_log(priv, resp);
584 break; 584 break;
585 585
586 case cmd_ret_802_11_associate: 586 case CMD_RET_802_11_ASSOCIATE:
587 case cmd_ret_802_11_reassociate: 587 case CMD_RET_802_11_REASSOCIATE:
588 ret = libertas_ret_80211_associate(priv, resp); 588 ret = libertas_ret_80211_associate(priv, resp);
589 break; 589 break;
590 590
591 case cmd_ret_802_11_disassociate: 591 case CMD_RET_802_11_DISASSOCIATE:
592 case cmd_ret_802_11_deauthenticate: 592 case CMD_RET_802_11_DEAUTHENTICATE:
593 ret = libertas_ret_80211_disassociate(priv, resp); 593 ret = libertas_ret_80211_disassociate(priv, resp);
594 break; 594 break;
595 595
596 case cmd_ret_802_11_ad_hoc_start: 596 case CMD_RET_802_11_AD_HOC_START:
597 case cmd_ret_802_11_ad_hoc_join: 597 case CMD_RET_802_11_AD_HOC_JOIN:
598 ret = libertas_ret_80211_ad_hoc_start(priv, resp); 598 ret = libertas_ret_80211_ad_hoc_start(priv, resp);
599 break; 599 break;
600 600
601 case cmd_ret_802_11_stat: 601 case CMD_RET_802_11_STAT:
602 ret = wlan_ret_802_11_stat(priv, resp); 602 ret = wlan_ret_802_11_stat(priv, resp);
603 break; 603 break;
604 604
605 case cmd_ret_802_11_snmp_mib: 605 case CMD_RET_802_11_SNMP_MIB:
606 ret = wlan_ret_802_11_snmp_mib(priv, resp); 606 ret = wlan_ret_802_11_snmp_mib(priv, resp);
607 break; 607 break;
608 608
609 case cmd_ret_802_11_rf_tx_power: 609 case CMD_RET_802_11_RF_TX_POWER:
610 ret = wlan_ret_802_11_rf_tx_power(priv, resp); 610 ret = wlan_ret_802_11_rf_tx_power(priv, resp);
611 break; 611 break;
612 612
613 case cmd_ret_802_11_set_afc: 613 case CMD_RET_802_11_SET_AFC:
614 case cmd_ret_802_11_get_afc: 614 case CMD_RET_802_11_GET_AFC:
615 spin_lock_irqsave(&adapter->driver_lock, flags); 615 spin_lock_irqsave(&adapter->driver_lock, flags);
616 memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc, 616 memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,
617 sizeof(struct cmd_ds_802_11_afc)); 617 sizeof(struct cmd_ds_802_11_afc));
618 spin_unlock_irqrestore(&adapter->driver_lock, flags); 618 spin_unlock_irqrestore(&adapter->driver_lock, flags);
619 619
620 break; 620 break;
621 case cmd_ret_802_11_rf_antenna: 621 case CMD_RET_802_11_RF_ANTENNA:
622 ret = wlan_ret_802_11_rf_antenna(priv, resp); 622 ret = wlan_ret_802_11_rf_antenna(priv, resp);
623 break; 623 break;
624 624
625 case cmd_ret_mac_multicast_adr: 625 case CMD_RET_MAC_MULTICAST_ADR:
626 case cmd_ret_mac_control: 626 case CMD_RET_MAC_CONTROL:
627 case cmd_ret_802_11_set_wep: 627 case CMD_RET_802_11_SET_WEP:
628 case cmd_ret_802_11_reset: 628 case CMD_RET_802_11_RESET:
629 case cmd_ret_802_11_authenticate: 629 case CMD_RET_802_11_AUTHENTICATE:
630 case cmd_ret_802_11_radio_control: 630 case CMD_RET_802_11_RADIO_CONTROL:
631 case cmd_ret_802_11_beacon_stop: 631 case CMD_RET_802_11_BEACON_STOP:
632 break; 632 break;
633 633
634 case cmd_ret_802_11_enable_rsn: 634 case CMD_RET_802_11_ENABLE_RSN:
635 ret = libertas_ret_802_11_enable_rsn(priv, resp); 635 ret = libertas_ret_802_11_enable_rsn(priv, resp);
636 break; 636 break;
637 637
638 case cmd_ret_802_11_data_rate: 638 case CMD_RET_802_11_DATA_RATE:
639 ret = wlan_ret_802_11_data_rate(priv, resp); 639 ret = wlan_ret_802_11_data_rate(priv, resp);
640 break; 640 break;
641 case cmd_ret_802_11_rate_adapt_rateset: 641 case CMD_RET_802_11_RATE_ADAPT_RATESET:
642 ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp); 642 ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
643 break; 643 break;
644 case cmd_ret_802_11_rf_channel: 644 case CMD_RET_802_11_RF_CHANNEL:
645 ret = wlan_ret_802_11_rf_channel(priv, resp); 645 ret = wlan_ret_802_11_rf_channel(priv, resp);
646 break; 646 break;
647 647
648 case cmd_ret_802_11_rssi: 648 case CMD_RET_802_11_RSSI:
649 ret = wlan_ret_802_11_rssi(priv, resp); 649 ret = wlan_ret_802_11_rssi(priv, resp);
650 break; 650 break;
651 651
652 case cmd_ret_802_11_mac_address: 652 case CMD_RET_802_11_MAC_ADDRESS:
653 ret = wlan_ret_802_11_mac_address(priv, resp); 653 ret = wlan_ret_802_11_mac_address(priv, resp);
654 break; 654 break;
655 655
656 case cmd_ret_802_11_ad_hoc_stop: 656 case CMD_RET_802_11_AD_HOC_STOP:
657 ret = libertas_ret_80211_ad_hoc_stop(priv, resp); 657 ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
658 break; 658 break;
659 659
660 case cmd_ret_802_11_key_material: 660 case CMD_RET_802_11_KEY_MATERIAL:
661 lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n"); 661 lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n");
662 ret = wlan_ret_802_11_key_material(priv, resp); 662 ret = wlan_ret_802_11_key_material(priv, resp);
663 break; 663 break;
664 664
665 case cmd_ret_802_11_eeprom_access: 665 case CMD_RET_802_11_EEPROM_ACCESS:
666 ret = wlan_ret_802_11_eeprom_access(priv, resp); 666 ret = wlan_ret_802_11_eeprom_access(priv, resp);
667 break; 667 break;
668 668
669 case cmd_ret_802_11d_domain_info: 669 case CMD_RET_802_11D_DOMAIN_INFO:
670 ret = libertas_ret_802_11d_domain_info(priv, resp); 670 ret = libertas_ret_802_11d_domain_info(priv, resp);
671 break; 671 break;
672 672
673 case cmd_ret_802_11_sleep_params: 673 case CMD_RET_802_11_SLEEP_PARAMS:
674 ret = wlan_ret_802_11_sleep_params(priv, resp); 674 ret = wlan_ret_802_11_sleep_params(priv, resp);
675 break; 675 break;
676 case cmd_ret_802_11_inactivity_timeout: 676 case CMD_RET_802_11_INACTIVITY_TIMEOUT:
677 spin_lock_irqsave(&adapter->driver_lock, flags); 677 spin_lock_irqsave(&adapter->driver_lock, flags);
678 *((u16 *) adapter->cur_cmd->pdata_buf) = 678 *((u16 *) adapter->cur_cmd->pdata_buf) =
679 le16_to_cpu(resp->params.inactivity_timeout.timeout); 679 le16_to_cpu(resp->params.inactivity_timeout.timeout);
680 spin_unlock_irqrestore(&adapter->driver_lock, flags); 680 spin_unlock_irqrestore(&adapter->driver_lock, flags);
681 break; 681 break;
682 682
683 case cmd_ret_802_11_tpc_cfg: 683 case CMD_RET_802_11_TPC_CFG:
684 spin_lock_irqsave(&adapter->driver_lock, flags); 684 spin_lock_irqsave(&adapter->driver_lock, flags);
685 memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg, 685 memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,
686 sizeof(struct cmd_ds_802_11_tpc_cfg)); 686 sizeof(struct cmd_ds_802_11_tpc_cfg));
687 spin_unlock_irqrestore(&adapter->driver_lock, flags); 687 spin_unlock_irqrestore(&adapter->driver_lock, flags);
688 break; 688 break;
689 case cmd_ret_802_11_led_gpio_ctrl: 689 case CMD_RET_802_11_LED_GPIO_CTRL:
690 spin_lock_irqsave(&adapter->driver_lock, flags); 690 spin_lock_irqsave(&adapter->driver_lock, flags);
691 memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio, 691 memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,
692 sizeof(struct cmd_ds_802_11_led_ctrl)); 692 sizeof(struct cmd_ds_802_11_led_ctrl));
693 spin_unlock_irqrestore(&adapter->driver_lock, flags); 693 spin_unlock_irqrestore(&adapter->driver_lock, flags);
694 break; 694 break;
695 case cmd_ret_802_11_pwr_cfg: 695 case CMD_RET_802_11_PWR_CFG:
696 spin_lock_irqsave(&adapter->driver_lock, flags); 696 spin_lock_irqsave(&adapter->driver_lock, flags);
697 memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg, 697 memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
698 sizeof(struct cmd_ds_802_11_pwr_cfg)); 698 sizeof(struct cmd_ds_802_11_pwr_cfg));
@@ -700,32 +700,32 @@ static inline int handle_cmd_response(u16 respcmd,
700 700
701 break; 701 break;
702 702
703 case cmd_ret_get_tsf: 703 case CMD_RET_GET_TSF:
704 spin_lock_irqsave(&adapter->driver_lock, flags); 704 spin_lock_irqsave(&adapter->driver_lock, flags);
705 memcpy(priv->adapter->cur_cmd->pdata_buf, 705 memcpy(priv->adapter->cur_cmd->pdata_buf,
706 &resp->params.gettsf.tsfvalue, sizeof(u64)); 706 &resp->params.gettsf.tsfvalue, sizeof(u64));
707 spin_unlock_irqrestore(&adapter->driver_lock, flags); 707 spin_unlock_irqrestore(&adapter->driver_lock, flags);
708 break; 708 break;
709 case cmd_ret_bt_access: 709 case CMD_RET_BT_ACCESS:
710 spin_lock_irqsave(&adapter->driver_lock, flags); 710 spin_lock_irqsave(&adapter->driver_lock, flags);
711 if (adapter->cur_cmd->pdata_buf) 711 if (adapter->cur_cmd->pdata_buf)
712 memcpy(adapter->cur_cmd->pdata_buf, 712 memcpy(adapter->cur_cmd->pdata_buf,
713 &resp->params.bt.addr1, 2 * ETH_ALEN); 713 &resp->params.bt.addr1, 2 * ETH_ALEN);
714 spin_unlock_irqrestore(&adapter->driver_lock, flags); 714 spin_unlock_irqrestore(&adapter->driver_lock, flags);
715 break; 715 break;
716 case cmd_ret_fwt_access: 716 case CMD_RET_FWT_ACCESS:
717 spin_lock_irqsave(&adapter->driver_lock, flags); 717 spin_lock_irqsave(&adapter->driver_lock, flags);
718 if (adapter->cur_cmd->pdata_buf) 718 if (adapter->cur_cmd->pdata_buf)
719 memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt, 719 memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,
720 sizeof(resp->params.fwt)); 720 sizeof(resp->params.fwt));
721 spin_unlock_irqrestore(&adapter->driver_lock, flags); 721 spin_unlock_irqrestore(&adapter->driver_lock, flags);
722 break; 722 break;
723 case cmd_ret_mesh_access: 723 case CMD_RET_MESH_ACCESS:
724 if (adapter->cur_cmd->pdata_buf) 724 if (adapter->cur_cmd->pdata_buf)
725 memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh, 725 memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
726 sizeof(resp->params.mesh)); 726 sizeof(resp->params.mesh));
727 break; 727 break;
728 case cmd_rte_802_11_tx_rate_query: 728 case CMD_RTE_802_11_TX_RATE_QUERY:
729 priv->adapter->txrate = resp->params.txrate.txrate; 729 priv->adapter->txrate = resp->params.txrate.txrate;
730 break; 730 break;
731 default: 731 default:
@@ -787,7 +787,7 @@ int libertas_process_rx_command(wlan_private * priv)
787 /* Store the response code to cur_cmd_retcode. */ 787 /* Store the response code to cur_cmd_retcode. */
788 adapter->cur_cmd_retcode = result;; 788 adapter->cur_cmd_retcode = result;;
789 789
790 if (respcmd == cmd_ret_802_11_ps_mode) { 790 if (respcmd == CMD_RET_802_11_PS_MODE) {
791 struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode; 791 struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
792 u16 action = le16_to_cpu(psmode->action); 792 u16 action = le16_to_cpu(psmode->action);
793 793
@@ -804,14 +804,14 @@ int libertas_process_rx_command(wlan_private * priv)
804 * libertas_execute_next_command(). 804 * libertas_execute_next_command().
805 */ 805 */
806 if (adapter->mode == IW_MODE_ADHOC && 806 if (adapter->mode == IW_MODE_ADHOC &&
807 action == cmd_subcmd_enter_ps) 807 action == CMD_SUBCMD_ENTER_PS)
808 adapter->psmode = wlan802_11powermodecam; 808 adapter->psmode = WLAN802_11POWERMODECAM;
809 } else if (action == cmd_subcmd_enter_ps) { 809 } else if (action == CMD_SUBCMD_ENTER_PS) {
810 adapter->needtowakeup = 0; 810 adapter->needtowakeup = 0;
811 adapter->psstate = PS_STATE_AWAKE; 811 adapter->psstate = PS_STATE_AWAKE;
812 812
813 lbs_deb_cmd("CMD_RESP: Enter_PS command response\n"); 813 lbs_deb_cmd("CMD_RESP: Enter_PS command response\n");
814 if (adapter->connect_status != libertas_connected) { 814 if (adapter->connect_status != LIBERTAS_CONNECTED) {
815 /* 815 /*
816 * When Deauth Event received before Enter_PS command 816 * When Deauth Event received before Enter_PS command
817 * response, We need to wake up the firmware. 817 * response, We need to wake up the firmware.
@@ -825,7 +825,7 @@ int libertas_process_rx_command(wlan_private * priv)
825 mutex_lock(&adapter->lock); 825 mutex_lock(&adapter->lock);
826 spin_lock_irqsave(&adapter->driver_lock, flags); 826 spin_lock_irqsave(&adapter->driver_lock, flags);
827 } 827 }
828 } else if (action == cmd_subcmd_exit_ps) { 828 } else if (action == CMD_SUBCMD_EXIT_PS) {
829 adapter->needtowakeup = 0; 829 adapter->needtowakeup = 0;
830 adapter->psstate = PS_STATE_FULL_POWER; 830 adapter->psstate = PS_STATE_FULL_POWER;
831 lbs_deb_cmd("CMD_RESP: Exit_PS command response\n"); 831 lbs_deb_cmd("CMD_RESP: Exit_PS command response\n");
@@ -857,8 +857,8 @@ int libertas_process_rx_command(wlan_private * priv)
857 * Handling errors here 857 * Handling errors here
858 */ 858 */
859 switch (respcmd) { 859 switch (respcmd) {
860 case cmd_ret_hw_spec_info: 860 case CMD_RET_HW_SPEC_INFO:
861 case cmd_ret_802_11_reset: 861 case CMD_RET_802_11_RESET:
862 lbs_deb_cmd("CMD_RESP: Reset command failed\n"); 862 lbs_deb_cmd("CMD_RESP: Reset command failed\n");
863 break; 863 break;
864 864
@@ -1003,7 +1003,7 @@ int libertas_process_event(wlan_private * priv)
1003 1003
1004 case MACREG_INT_CODE_MESH_AUTO_STARTED: 1004 case MACREG_INT_CODE_MESH_AUTO_STARTED:
1005 lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n"); 1005 lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n");
1006 adapter->connect_status = libertas_connected ; 1006 adapter->connect_status = LIBERTAS_CONNECTED ;
1007 if (priv->mesh_open == 1) { 1007 if (priv->mesh_open == 1) {
1008 netif_wake_queue(priv->mesh_dev) ; 1008 netif_wake_queue(priv->mesh_dev) ;
1009 netif_carrier_on(priv->mesh_dev) ; 1009 netif_carrier_on(priv->mesh_dev) ;
diff --git a/drivers/net/wireless/libertas/debugfs.c b/drivers/net/wireless/libertas/debugfs.c
index e5cbfa8d6e3f..a206f49f810c 100644
--- a/drivers/net/wireless/libertas/debugfs.c
+++ b/drivers/net/wireless/libertas/debugfs.c
@@ -125,9 +125,9 @@ static ssize_t libertas_sleepparams_write(struct file *file,
125 priv->adapter->sp.sp_reserved = p6; 125 priv->adapter->sp.sp_reserved = p6;
126 126
127 res = libertas_prepare_and_send_command(priv, 127 res = libertas_prepare_and_send_command(priv,
128 cmd_802_11_sleep_params, 128 CMD_802_11_SLEEP_PARAMS,
129 cmd_act_set, 129 CMD_ACT_SET,
130 cmd_option_waitforrsp, 0, NULL); 130 CMD_OPTION_WAITFORRSP, 0, NULL);
131 131
132 if (!res) 132 if (!res)
133 res = count; 133 res = count;
@@ -150,9 +150,9 @@ static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf
150 char *buf = (char *)addr; 150 char *buf = (char *)addr;
151 151
152 res = libertas_prepare_and_send_command(priv, 152 res = libertas_prepare_and_send_command(priv,
153 cmd_802_11_sleep_params, 153 CMD_802_11_SLEEP_PARAMS,
154 cmd_act_get, 154 CMD_ACT_GET,
155 cmd_option_waitforrsp, 0, NULL); 155 CMD_OPTION_WAITFORRSP, 0, NULL);
156 if (res) { 156 if (res) {
157 res = -EFAULT; 157 res = -EFAULT;
158 goto out_unlock; 158 goto out_unlock;
@@ -386,7 +386,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
386 struct cmd_ctrl_node **cmdnode, 386 struct cmd_ctrl_node **cmdnode,
387 struct cmd_ds_command **cmd) 387 struct cmd_ds_command **cmd)
388{ 388{
389 u16 wait_option = cmd_option_waitforrsp; 389 u16 wait_option = CMD_OPTION_WAITFORRSP;
390 390
391 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) { 391 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
392 lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n"); 392 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,
402 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD; 402 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
403 (*cmdnode)->cmdwaitqwoken = 0; 403 (*cmdnode)->cmdwaitqwoken = 0;
404 *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr; 404 *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
405 (*cmd)->command = cpu_to_le16(cmd_802_11_subscribe_event); 405 (*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);
406 (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum); 406 (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
407 (*cmd)->result = 0; 407 (*cmd)->result = 0;
408 return 0; 408 return 0;
@@ -429,7 +429,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
429 } 429 }
430 430
431 event = &pcmdptr->params.subscribe_event; 431 event = &pcmdptr->params.subscribe_event;
432 event->action = cpu_to_le16(cmd_act_get); 432 event->action = cpu_to_le16(CMD_ACT_GET);
433 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 433 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
434 libertas_queue_cmd(adapter, pcmdnode, 1); 434 libertas_queue_cmd(adapter, pcmdnode, 1);
435 wake_up_interruptible(&priv->mainthread.waitq); 435 wake_up_interruptible(&priv->mainthread.waitq);
@@ -447,7 +447,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
447 return 0; 447 return 0;
448 } 448 }
449 449
450 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 450 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
451 lbs_pr_err("command response incorrect!\n"); 451 lbs_pr_err("command response incorrect!\n");
452 kfree(response_buf); 452 kfree(response_buf);
453 free_page(addr); 453 free_page(addr);
@@ -493,7 +493,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
493 return res; 493 return res;
494 494
495 event = &pcmdptr->params.subscribe_event; 495 event = &pcmdptr->params.subscribe_event;
496 event->action = cpu_to_le16(cmd_act_get); 496 event->action = cpu_to_le16(CMD_ACT_GET);
497 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 497 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
498 libertas_queue_cmd(adapter, pcmdnode, 1); 498 libertas_queue_cmd(adapter, pcmdnode, 1);
499 wake_up_interruptible(&priv->mainthread.waitq); 499 wake_up_interruptible(&priv->mainthread.waitq);
@@ -511,7 +511,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
511 return 0; 511 return 0;
512 } 512 }
513 513
514 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) { 514 if (pcmdptr->command != CMD_RET_802_11_SUBSCRIBE_EVENT) {
515 lbs_pr_err("command response incorrect!\n"); 515 lbs_pr_err("command response incorrect!\n");
516 kfree(response_buf); 516 kfree(response_buf);
517 return 0; 517 return 0;
@@ -559,7 +559,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
559 goto out_unlock; 559 goto out_unlock;
560 560
561 event = &pcmdptr->params.subscribe_event; 561 event = &pcmdptr->params.subscribe_event;
562 event->action = cpu_to_le16(cmd_act_set); 562 event->action = cpu_to_le16(CMD_ACT_SET);
563 pcmdptr->size = cpu_to_le16(S_DS_GEN + 563 pcmdptr->size = cpu_to_le16(S_DS_GEN +
564 sizeof(struct cmd_ds_802_11_subscribe_event) + 564 sizeof(struct cmd_ds_802_11_subscribe_event) +
565 sizeof(struct mrvlietypes_rssithreshold)); 565 sizeof(struct mrvlietypes_rssithreshold));
@@ -591,7 +591,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
591 return 0; 591 return 0;
592 } 592 }
593 593
594 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 594 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
595 lbs_pr_err("command response incorrect!\n"); 595 lbs_pr_err("command response incorrect!\n");
596 kfree(response_buf); 596 kfree(response_buf);
597 free_page(addr); 597 free_page(addr);
@@ -625,7 +625,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
625 } 625 }
626 626
627 event = &pcmdptr->params.subscribe_event; 627 event = &pcmdptr->params.subscribe_event;
628 event->action = cpu_to_le16(cmd_act_get); 628 event->action = cpu_to_le16(CMD_ACT_GET);
629 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 629 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
630 libertas_queue_cmd(adapter, pcmdnode, 1); 630 libertas_queue_cmd(adapter, pcmdnode, 1);
631 wake_up_interruptible(&priv->mainthread.waitq); 631 wake_up_interruptible(&priv->mainthread.waitq);
@@ -644,7 +644,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
644 return 0; 644 return 0;
645 } 645 }
646 646
647 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 647 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
648 lbs_pr_err("command response incorrect!\n"); 648 lbs_pr_err("command response incorrect!\n");
649 kfree(response_buf); 649 kfree(response_buf);
650 free_page(addr); 650 free_page(addr);
@@ -712,7 +712,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
712 goto out_unlock; 712 goto out_unlock;
713 713
714 event = &pcmdptr->params.subscribe_event; 714 event = &pcmdptr->params.subscribe_event;
715 event->action = cpu_to_le16(cmd_act_set); 715 event->action = cpu_to_le16(CMD_ACT_SET);
716 pcmdptr->size = cpu_to_le16(S_DS_GEN + 716 pcmdptr->size = cpu_to_le16(S_DS_GEN +
717 sizeof(struct cmd_ds_802_11_subscribe_event) + 717 sizeof(struct cmd_ds_802_11_subscribe_event) +
718 sizeof(struct mrvlietypes_snrthreshold)); 718 sizeof(struct mrvlietypes_snrthreshold));
@@ -743,7 +743,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
743 return 0; 743 return 0;
744 } 744 }
745 745
746 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 746 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
747 lbs_pr_err("command response incorrect!\n"); 747 lbs_pr_err("command response incorrect!\n");
748 kfree(response_buf); 748 kfree(response_buf);
749 free_page(addr); 749 free_page(addr);
@@ -778,7 +778,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
778 } 778 }
779 779
780 event = &pcmdptr->params.subscribe_event; 780 event = &pcmdptr->params.subscribe_event;
781 event->action = cpu_to_le16(cmd_act_get); 781 event->action = cpu_to_le16(CMD_ACT_GET);
782 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 782 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
783 libertas_queue_cmd(adapter, pcmdnode, 1); 783 libertas_queue_cmd(adapter, pcmdnode, 1);
784 wake_up_interruptible(&priv->mainthread.waitq); 784 wake_up_interruptible(&priv->mainthread.waitq);
@@ -797,7 +797,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
797 return 0; 797 return 0;
798 } 798 }
799 799
800 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 800 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
801 lbs_pr_err("command response incorrect!\n"); 801 lbs_pr_err("command response incorrect!\n");
802 kfree(response_buf); 802 kfree(response_buf);
803 free_page(addr); 803 free_page(addr);
@@ -864,7 +864,7 @@ static ssize_t libertas_failcount_write(struct file *file,
864 goto out_unlock; 864 goto out_unlock;
865 865
866 event = &pcmdptr->params.subscribe_event; 866 event = &pcmdptr->params.subscribe_event;
867 event->action = cpu_to_le16(cmd_act_set); 867 event->action = cpu_to_le16(CMD_ACT_SET);
868 pcmdptr->size = cpu_to_le16(S_DS_GEN + 868 pcmdptr->size = cpu_to_le16(S_DS_GEN +
869 sizeof(struct cmd_ds_802_11_subscribe_event) + 869 sizeof(struct cmd_ds_802_11_subscribe_event) +
870 sizeof(struct mrvlietypes_failurecount)); 870 sizeof(struct mrvlietypes_failurecount));
@@ -895,7 +895,7 @@ static ssize_t libertas_failcount_write(struct file *file,
895 return 0; 895 return 0;
896 } 896 }
897 897
898 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 898 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
899 lbs_pr_err("command response incorrect!\n"); 899 lbs_pr_err("command response incorrect!\n");
900 kfree(response_buf); 900 kfree(response_buf);
901 free_page(addr); 901 free_page(addr);
@@ -929,7 +929,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
929 } 929 }
930 930
931 event = &pcmdptr->params.subscribe_event; 931 event = &pcmdptr->params.subscribe_event;
932 event->action = cpu_to_le16(cmd_act_get); 932 event->action = cpu_to_le16(CMD_ACT_GET);
933 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 933 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
934 libertas_queue_cmd(adapter, pcmdnode, 1); 934 libertas_queue_cmd(adapter, pcmdnode, 1);
935 wake_up_interruptible(&priv->mainthread.waitq); 935 wake_up_interruptible(&priv->mainthread.waitq);
@@ -948,7 +948,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
948 return 0; 948 return 0;
949 } 949 }
950 950
951 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 951 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
952 lbs_pr_err("command response incorrect!\n"); 952 lbs_pr_err("command response incorrect!\n");
953 free_page(addr); 953 free_page(addr);
954 kfree(response_buf); 954 kfree(response_buf);
@@ -1015,7 +1015,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
1015 goto out_unlock; 1015 goto out_unlock;
1016 1016
1017 event = &pcmdptr->params.subscribe_event; 1017 event = &pcmdptr->params.subscribe_event;
1018 event->action = cpu_to_le16(cmd_act_set); 1018 event->action = cpu_to_le16(CMD_ACT_SET);
1019 pcmdptr->size = cpu_to_le16(S_DS_GEN + 1019 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1020 sizeof(struct cmd_ds_802_11_subscribe_event) + 1020 sizeof(struct cmd_ds_802_11_subscribe_event) +
1021 sizeof(struct mrvlietypes_beaconsmissed)); 1021 sizeof(struct mrvlietypes_beaconsmissed));
@@ -1045,7 +1045,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
1045 return 0; 1045 return 0;
1046 } 1046 }
1047 1047
1048 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 1048 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
1049 lbs_pr_err("command response incorrect!\n"); 1049 lbs_pr_err("command response incorrect!\n");
1050 free_page(addr); 1050 free_page(addr);
1051 kfree(response_buf); 1051 kfree(response_buf);
@@ -1079,7 +1079,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1079 } 1079 }
1080 1080
1081 event = &pcmdptr->params.subscribe_event; 1081 event = &pcmdptr->params.subscribe_event;
1082 event->action = cpu_to_le16(cmd_act_get); 1082 event->action = cpu_to_le16(CMD_ACT_GET);
1083 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 1083 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1084 libertas_queue_cmd(adapter, pcmdnode, 1); 1084 libertas_queue_cmd(adapter, pcmdnode, 1);
1085 wake_up_interruptible(&priv->mainthread.waitq); 1085 wake_up_interruptible(&priv->mainthread.waitq);
@@ -1098,7 +1098,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1098 return 0; 1098 return 0;
1099 } 1099 }
1100 1100
1101 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 1101 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
1102 lbs_pr_err("command response incorrect!\n"); 1102 lbs_pr_err("command response incorrect!\n");
1103 kfree(response_buf); 1103 kfree(response_buf);
1104 free_page(addr); 1104 free_page(addr);
@@ -1166,7 +1166,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
1166 goto out_unlock; 1166 goto out_unlock;
1167 1167
1168 event = &pcmdptr->params.subscribe_event; 1168 event = &pcmdptr->params.subscribe_event;
1169 event->action = cpu_to_le16(cmd_act_set); 1169 event->action = cpu_to_le16(CMD_ACT_SET);
1170 pcmdptr->size = cpu_to_le16(S_DS_GEN + 1170 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1171 sizeof(struct cmd_ds_802_11_subscribe_event) + 1171 sizeof(struct cmd_ds_802_11_subscribe_event) +
1172 sizeof(struct mrvlietypes_rssithreshold)); 1172 sizeof(struct mrvlietypes_rssithreshold));
@@ -1196,7 +1196,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
1196 return 0; 1196 return 0;
1197 } 1197 }
1198 1198
1199 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 1199 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
1200 lbs_pr_err("command response incorrect!\n"); 1200 lbs_pr_err("command response incorrect!\n");
1201 kfree(response_buf); 1201 kfree(response_buf);
1202 return 0; 1202 return 0;
@@ -1229,7 +1229,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1229 } 1229 }
1230 1230
1231 event = &pcmdptr->params.subscribe_event; 1231 event = &pcmdptr->params.subscribe_event;
1232 event->action = cpu_to_le16(cmd_act_get); 1232 event->action = cpu_to_le16(CMD_ACT_GET);
1233 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 1233 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1234 libertas_queue_cmd(adapter, pcmdnode, 1); 1234 libertas_queue_cmd(adapter, pcmdnode, 1);
1235 wake_up_interruptible(&priv->mainthread.waitq); 1235 wake_up_interruptible(&priv->mainthread.waitq);
@@ -1248,7 +1248,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1248 return 0; 1248 return 0;
1249 } 1249 }
1250 1250
1251 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 1251 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
1252 lbs_pr_err("command response incorrect!\n"); 1252 lbs_pr_err("command response incorrect!\n");
1253 kfree(response_buf); 1253 kfree(response_buf);
1254 free_page(addr); 1254 free_page(addr);
@@ -1316,7 +1316,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
1316 goto out_unlock; 1316 goto out_unlock;
1317 1317
1318 event = &pcmdptr->params.subscribe_event; 1318 event = &pcmdptr->params.subscribe_event;
1319 event->action = cpu_to_le16(cmd_act_set); 1319 event->action = cpu_to_le16(CMD_ACT_SET);
1320 pcmdptr->size = cpu_to_le16(S_DS_GEN + 1320 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1321 sizeof(struct cmd_ds_802_11_subscribe_event) + 1321 sizeof(struct cmd_ds_802_11_subscribe_event) +
1322 sizeof(struct mrvlietypes_snrthreshold)); 1322 sizeof(struct mrvlietypes_snrthreshold));
@@ -1347,7 +1347,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
1347 return 0; 1347 return 0;
1348 } 1348 }
1349 1349
1350 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) { 1350 if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
1351 lbs_pr_err("command response incorrect!\n"); 1351 lbs_pr_err("command response incorrect!\n");
1352 kfree(response_buf); 1352 kfree(response_buf);
1353 free_page(addr); 1353 free_page(addr);
@@ -1375,8 +1375,8 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1375 offval.value = 0; 1375 offval.value = 0;
1376 1376
1377 ret = libertas_prepare_and_send_command(priv, 1377 ret = libertas_prepare_and_send_command(priv,
1378 cmd_mac_reg_access, 0, 1378 CMD_MAC_REG_ACCESS, 0,
1379 cmd_option_waitforrsp, 0, &offval); 1379 CMD_OPTION_WAITFORRSP, 0, &offval);
1380 mdelay(10); 1380 mdelay(10);
1381 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n", 1381 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
1382 priv->mac_offset, adapter->offsetvalue.value); 1382 priv->mac_offset, adapter->offsetvalue.value);
@@ -1433,8 +1433,8 @@ static ssize_t libertas_wrmac_write(struct file *file,
1433 offval.offset = offset; 1433 offval.offset = offset;
1434 offval.value = value; 1434 offval.value = value;
1435 res = libertas_prepare_and_send_command(priv, 1435 res = libertas_prepare_and_send_command(priv,
1436 cmd_mac_reg_access, 1, 1436 CMD_MAC_REG_ACCESS, 1,
1437 cmd_option_waitforrsp, 0, &offval); 1437 CMD_OPTION_WAITFORRSP, 0, &offval);
1438 mdelay(10); 1438 mdelay(10);
1439 1439
1440 res = count; 1440 res = count;
@@ -1458,8 +1458,8 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1458 offval.value = 0; 1458 offval.value = 0;
1459 1459
1460 ret = libertas_prepare_and_send_command(priv, 1460 ret = libertas_prepare_and_send_command(priv,
1461 cmd_bbp_reg_access, 0, 1461 CMD_BBP_REG_ACCESS, 0,
1462 cmd_option_waitforrsp, 0, &offval); 1462 CMD_OPTION_WAITFORRSP, 0, &offval);
1463 mdelay(10); 1463 mdelay(10);
1464 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n", 1464 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
1465 priv->bbp_offset, adapter->offsetvalue.value); 1465 priv->bbp_offset, adapter->offsetvalue.value);
@@ -1517,8 +1517,8 @@ static ssize_t libertas_wrbbp_write(struct file *file,
1517 offval.offset = offset; 1517 offval.offset = offset;
1518 offval.value = value; 1518 offval.value = value;
1519 res = libertas_prepare_and_send_command(priv, 1519 res = libertas_prepare_and_send_command(priv,
1520 cmd_bbp_reg_access, 1, 1520 CMD_BBP_REG_ACCESS, 1,
1521 cmd_option_waitforrsp, 0, &offval); 1521 CMD_OPTION_WAITFORRSP, 0, &offval);
1522 mdelay(10); 1522 mdelay(10);
1523 1523
1524 res = count; 1524 res = count;
@@ -1542,8 +1542,8 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1542 offval.value = 0; 1542 offval.value = 0;
1543 1543
1544 ret = libertas_prepare_and_send_command(priv, 1544 ret = libertas_prepare_and_send_command(priv,
1545 cmd_rf_reg_access, 0, 1545 CMD_RF_REG_ACCESS, 0,
1546 cmd_option_waitforrsp, 0, &offval); 1546 CMD_OPTION_WAITFORRSP, 0, &offval);
1547 mdelay(10); 1547 mdelay(10);
1548 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n", 1548 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
1549 priv->rf_offset, adapter->offsetvalue.value); 1549 priv->rf_offset, adapter->offsetvalue.value);
@@ -1601,8 +1601,8 @@ static ssize_t libertas_wrrf_write(struct file *file,
1601 offval.offset = offset; 1601 offval.offset = offset;
1602 offval.value = value; 1602 offval.value = value;
1603 res = libertas_prepare_and_send_command(priv, 1603 res = libertas_prepare_and_send_command(priv,
1604 cmd_rf_reg_access, 1, 1604 CMD_RF_REG_ACCESS, 1,
1605 cmd_option_waitforrsp, 0, &offval); 1605 CMD_OPTION_WAITFORRSP, 0, &offval);
1606 mdelay(10); 1606 mdelay(10);
1607 1607
1608 res = count; 1608 res = count;
diff --git a/drivers/net/wireless/libertas/defs.h b/drivers/net/wireless/libertas/defs.h
index a5d70c19768b..862292913c2c 100644
--- a/drivers/net/wireless/libertas/defs.h
+++ b/drivers/net/wireless/libertas/defs.h
@@ -286,11 +286,11 @@ enum SNRNF_DATA {
286 286
287/** WLAN_802_11_POWER_MODE */ 287/** WLAN_802_11_POWER_MODE */
288enum WLAN_802_11_POWER_MODE { 288enum WLAN_802_11_POWER_MODE {
289 wlan802_11powermodecam, 289 WLAN802_11POWERMODECAM,
290 wlan802_11powermodemax_psp, 290 WLAN802_11POWERMODEMAX_PSP,
291 wlan802_11Powermodefast_psp, 291 WLAN802_11POWERMODEFAST_PSP,
292 /*not a real mode, defined as an upper bound */ 292 /*not a real mode, defined as an upper bound */
293 wlan802_11powemodemax 293 WLAN802_11POWEMODEMAX
294}; 294};
295 295
296/** PS_STATE */ 296/** PS_STATE */
@@ -310,14 +310,14 @@ enum DNLD_STATE {
310 310
311/** WLAN_MEDIA_STATE */ 311/** WLAN_MEDIA_STATE */
312enum WLAN_MEDIA_STATE { 312enum WLAN_MEDIA_STATE {
313 libertas_connected, 313 LIBERTAS_CONNECTED,
314 libertas_disconnected 314 LIBERTAS_DISCONNECTED
315}; 315};
316 316
317/** WLAN_802_11_PRIVACY_FILTER */ 317/** WLAN_802_11_PRIVACY_FILTER */
318enum WLAN_802_11_PRIVACY_FILTER { 318enum WLAN_802_11_PRIVACY_FILTER {
319 wlan802_11privfilteracceptall, 319 WLAN802_11PRIVFILTERACCEPTALL,
320 wlan802_11privfilter8021xWEP 320 WLAN802_11PRIVFILTER8021XWEP
321}; 321};
322 322
323/** mv_ms_type */ 323/** mv_ms_type */
@@ -330,23 +330,23 @@ enum mv_ms_type {
330 330
331/** SNMP_MIB_INDEX_e */ 331/** SNMP_MIB_INDEX_e */
332enum SNMP_MIB_INDEX_e { 332enum SNMP_MIB_INDEX_e {
333 desired_bsstype_i = 0, 333 DESIRED_BSSTYPE_I = 0,
334 op_rateset_i, 334 OP_RATESET_I,
335 bcnperiod_i, 335 BCNPERIOD_I,
336 dtimperiod_i, 336 DTIMPERIOD_I,
337 assocrsp_timeout_i, 337 ASSOCRSP_TIMEOUT_I,
338 rtsthresh_i, 338 RTSTHRESH_I,
339 short_retrylim_i, 339 SHORT_RETRYLIM_I,
340 long_retrylim_i, 340 LONG_RETRYLIM_I,
341 fragthresh_i, 341 FRAGTHRESH_I,
342 dot11d_i, 342 DOT11D_I,
343 dot11h_i, 343 DOT11H_I,
344 manufid_i, 344 MANUFID_I,
345 prodID_i, 345 PRODID_I,
346 manuf_oui_i, 346 MANUF_OUI_I,
347 manuf_name_i, 347 MANUF_NAME_I,
348 manuf_prodname_i, 348 MANUF_PRODNAME_I,
349 manuf_prodver_i, 349 MANUF_PRODVER_I,
350}; 350};
351 351
352/** KEY_TYPE_ID */ 352/** KEY_TYPE_ID */
diff --git a/drivers/net/wireless/libertas/ethtool.c b/drivers/net/wireless/libertas/ethtool.c
index 96f1974685d4..ec99cb825871 100644
--- a/drivers/net/wireless/libertas/ethtool.c
+++ b/drivers/net/wireless/libertas/ethtool.c
@@ -72,9 +72,9 @@ static int libertas_ethtool_get_eeprom(struct net_device *dev,
72 regctrl.action, regctrl.offset, regctrl.NOB); 72 regctrl.action, regctrl.offset, regctrl.NOB);
73 73
74 ret = libertas_prepare_and_send_command(priv, 74 ret = libertas_prepare_and_send_command(priv,
75 cmd_802_11_eeprom_access, 75 CMD_802_11_EEPROM_ACCESS,
76 regctrl.action, 76 regctrl.action,
77 cmd_option_waitforrsp, 0, 77 CMD_OPTION_WAITFORRSP, 0,
78 &regctrl); 78 &regctrl);
79 79
80 if (ret) { 80 if (ret) {
@@ -138,8 +138,8 @@ static int libertas_ethtool_get_stats_count(struct net_device * dev)
138 138
139 /* Get Mesh Statistics */ 139 /* Get Mesh Statistics */
140 ret = libertas_prepare_and_send_command(priv, 140 ret = libertas_prepare_and_send_command(priv,
141 cmd_mesh_access, cmd_act_mesh_get_stats, 141 CMD_MESH_ACCESS, CMD_ACT_MESH_GET_STATS,
142 cmd_option_waitforrsp, 0, &mesh_access); 142 CMD_OPTION_WAITFORRSP, 0, &mesh_access);
143 143
144 if (ret) { 144 if (ret) {
145 ret = 0; 145 ret = 0;
diff --git a/drivers/net/wireless/libertas/fw.c b/drivers/net/wireless/libertas/fw.c
index 288e47c33555..39b0a094b626 100644
--- a/drivers/net/wireless/libertas/fw.c
+++ b/drivers/net/wireless/libertas/fw.c
@@ -99,8 +99,8 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
99 */ 99 */
100 memset(adapter->current_addr, 0xff, ETH_ALEN); 100 memset(adapter->current_addr, 0xff, ETH_ALEN);
101 101
102 ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec, 102 ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC,
103 0, cmd_option_waitforrsp, 0, NULL); 103 0, CMD_OPTION_WAITFORRSP, 0, NULL);
104 104
105 if (ret) { 105 if (ret) {
106 ret = -1; 106 ret = -1;
@@ -110,9 +110,9 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
110 libertas_set_mac_packet_filter(priv); 110 libertas_set_mac_packet_filter(priv);
111 111
112 /* Get the supported Data rates */ 112 /* Get the supported Data rates */
113 ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate, 113 ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
114 cmd_act_get_tx_rate, 114 CMD_ACT_GET_tx_rate,
115 cmd_option_waitforrsp, 0, NULL); 115 CMD_OPTION_WAITFORRSP, 0, NULL);
116 116
117 if (ret) { 117 if (ret) {
118 ret = -1; 118 ret = -1;
@@ -145,12 +145,12 @@ static int wlan_allocate_adapter(wlan_private * priv)
145 memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep)); 145 memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
146 adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); 146 adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
147 adapter->libertas_ps_confirm_sleep.command = 147 adapter->libertas_ps_confirm_sleep.command =
148 cpu_to_le16(cmd_802_11_ps_mode); 148 cpu_to_le16(CMD_802_11_PS_MODE);
149 adapter->libertas_ps_confirm_sleep.size = 149 adapter->libertas_ps_confirm_sleep.size =
150 cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); 150 cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
151 adapter->libertas_ps_confirm_sleep.result = 0; 151 adapter->libertas_ps_confirm_sleep.result = 0;
152 adapter->libertas_ps_confirm_sleep.action = 152 adapter->libertas_ps_confirm_sleep.action =
153 cpu_to_le16(cmd_subcmd_sleep_confirmed); 153 cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
154 154
155 return 0; 155 return 0;
156} 156}
@@ -168,14 +168,14 @@ static void wlan_init_adapter(wlan_private * priv)
168 /* ATIM params */ 168 /* ATIM params */
169 adapter->atimwindow = 0; 169 adapter->atimwindow = 0;
170 170
171 adapter->connect_status = libertas_disconnected; 171 adapter->connect_status = LIBERTAS_DISCONNECTED;
172 memset(adapter->current_addr, 0xff, ETH_ALEN); 172 memset(adapter->current_addr, 0xff, ETH_ALEN);
173 173
174 /* scan type */ 174 /* scan type */
175 adapter->scantype = cmd_scan_type_active; 175 adapter->scantype = CMD_SCAN_TYPE_ACTIVE;
176 176
177 /* scan mode */ 177 /* scan mode */
178 adapter->scanmode = cmd_bss_type_any; 178 adapter->scanmode = CMD_BSS_TYPE_ANY;
179 179
180 /* 802.11 specific */ 180 /* 802.11 specific */
181 adapter->secinfo.wep_enabled = 0; 181 adapter->secinfo.wep_enabled = 0;
@@ -208,7 +208,7 @@ static void wlan_init_adapter(wlan_private * priv)
208 adapter->surpriseremoved = 0; 208 adapter->surpriseremoved = 0;
209 209
210 adapter->currentpacketfilter = 210 adapter->currentpacketfilter =
211 cmd_act_mac_rx_on | cmd_act_mac_tx_on; 211 CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
212 212
213 adapter->radioon = RADIO_ON; 213 adapter->radioon = RADIO_ON;
214 adapter->txantenna = RF_ANTENNA_2; 214 adapter->txantenna = RF_ANTENNA_2;
@@ -220,7 +220,7 @@ static void wlan_init_adapter(wlan_private * priv)
220 // set default capabilities 220 // set default capabilities
221 adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; 221 adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
222 222
223 adapter->psmode = wlan802_11powermodecam; 223 adapter->psmode = WLAN802_11POWERMODECAM;
224 adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM; 224 adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;
225 225
226 adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL; 226 adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;
diff --git a/drivers/net/wireless/libertas/host.h b/drivers/net/wireless/libertas/host.h
index 7509cc10af3c..4bd2e88116cc 100644
--- a/drivers/net/wireless/libertas/host.h
+++ b/drivers/net/wireless/libertas/host.h
@@ -20,224 +20,224 @@
20#define OID_802_11_TX_RETRYCOUNT 0x0000801D 20#define OID_802_11_TX_RETRYCOUNT 0x0000801D
21#define OID_802_11D_ENABLE 0x00008020 21#define OID_802_11D_ENABLE 0x00008020
22 22
23#define cmd_option_waitforrsp 0x0002 23#define CMD_OPTION_WAITFORRSP 0x0002
24 24
25/** Host command ID */ 25/** Host command ID */
26#define cmd_code_dnld 0x0002 26#define CMD_CODE_DNLD 0x0002
27#define cmd_get_hw_spec 0x0003 27#define CMD_GET_HW_SPEC 0x0003
28#define cmd_eeprom_update 0x0004 28#define CMD_EEPROM_UPDATE 0x0004
29#define cmd_802_11_reset 0x0005 29#define CMD_802_11_RESET 0x0005
30#define cmd_802_11_scan 0x0006 30#define CMD_802_11_SCAN 0x0006
31#define cmd_802_11_get_log 0x000b 31#define CMD_802_11_GET_LOG 0x000b
32#define cmd_mac_multicast_adr 0x0010 32#define CMD_MAC_MULTICAST_ADR 0x0010
33#define cmd_802_11_authenticate 0x0011 33#define CMD_802_11_AUTHENTICATE 0x0011
34#define cmd_802_11_eeprom_access 0x0059 34#define CMD_802_11_EEPROM_ACCESS 0x0059
35#define cmd_802_11_associate 0x0050 35#define CMD_802_11_ASSOCIATE 0x0050
36#define cmd_802_11_set_wep 0x0013 36#define CMD_802_11_SET_WEP 0x0013
37#define cmd_802_11_get_stat 0x0014 37#define CMD_802_11_GET_STAT 0x0014
38#define cmd_802_3_get_stat 0x0015 38#define CMD_802_3_GET_STAT 0x0015
39#define cmd_802_11_snmp_mib 0x0016 39#define CMD_802_11_SNMP_MIB 0x0016
40#define cmd_mac_reg_map 0x0017 40#define CMD_MAC_REG_MAP 0x0017
41#define cmd_bbp_reg_map 0x0018 41#define CMD_BBP_REG_MAP 0x0018
42#define cmd_mac_reg_access 0x0019 42#define CMD_MAC_REG_ACCESS 0x0019
43#define cmd_bbp_reg_access 0x001a 43#define CMD_BBP_REG_ACCESS 0x001a
44#define cmd_rf_reg_access 0x001b 44#define CMD_RF_REG_ACCESS 0x001b
45#define cmd_802_11_radio_control 0x001c 45#define CMD_802_11_RADIO_CONTROL 0x001c
46#define cmd_802_11_rf_channel 0x001d 46#define CMD_802_11_RF_CHANNEL 0x001d
47#define cmd_802_11_rf_tx_power 0x001e 47#define CMD_802_11_RF_TX_POWER 0x001e
48#define cmd_802_11_rssi 0x001f 48#define CMD_802_11_RSSI 0x001f
49#define cmd_802_11_rf_antenna 0x0020 49#define CMD_802_11_RF_ANTENNA 0x0020
50 50
51#define cmd_802_11_ps_mode 0x0021 51#define CMD_802_11_PS_MODE 0x0021
52 52
53#define cmd_802_11_data_rate 0x0022 53#define CMD_802_11_DATA_RATE 0x0022
54#define cmd_rf_reg_map 0x0023 54#define CMD_RF_REG_MAP 0x0023
55#define cmd_802_11_deauthenticate 0x0024 55#define CMD_802_11_DEAUTHENTICATE 0x0024
56#define cmd_802_11_reassociate 0x0025 56#define CMD_802_11_REASSOCIATE 0x0025
57#define cmd_802_11_disassociate 0x0026 57#define CMD_802_11_DISASSOCIATE 0x0026
58#define cmd_mac_control 0x0028 58#define CMD_MAC_CONTROL 0x0028
59#define cmd_802_11_ad_hoc_start 0x002b 59#define CMD_802_11_AD_HOC_START 0x002b
60#define cmd_802_11_ad_hoc_join 0x002c 60#define CMD_802_11_AD_HOC_JOIN 0x002c
61 61
62#define cmd_802_11_query_tkip_reply_cntrs 0x002e 62#define CMD_802_11_QUERY_TKIP_REPLY_CNTRS 0x002e
63#define cmd_802_11_enable_rsn 0x002f 63#define CMD_802_11_ENABLE_RSN 0x002f
64#define cmd_802_11_pairwise_tsc 0x0036 64#define CMD_802_11_PAIRWISE_TSC 0x0036
65#define cmd_802_11_group_tsc 0x0037 65#define CMD_802_11_GROUP_TSC 0x0037
66#define cmd_802_11_key_material 0x005e 66#define CMD_802_11_KEY_MATERIAL 0x005e
67 67
68#define cmd_802_11_set_afc 0x003c 68#define CMD_802_11_SET_AFC 0x003c
69#define cmd_802_11_get_afc 0x003d 69#define CMD_802_11_GET_AFC 0x003d
70 70
71#define cmd_802_11_ad_hoc_stop 0x0040 71#define CMD_802_11_AD_HOC_STOP 0x0040
72 72
73#define cmd_802_11_beacon_stop 0x0049 73#define CMD_802_11_BEACON_STOP 0x0049
74 74
75#define cmd_802_11_mac_address 0x004D 75#define CMD_802_11_MAC_ADDRESS 0x004D
76#define cmd_802_11_eeprom_access 0x0059 76#define CMD_802_11_EEPROM_ACCESS 0x0059
77 77
78#define cmd_802_11_band_config 0x0058 78#define CMD_802_11_BAND_CONFIG 0x0058
79 79
80#define cmd_802_11d_domain_info 0x005b 80#define CMD_802_11D_DOMAIN_INFO 0x005b
81 81
82#define cmd_802_11_sleep_params 0x0066 82#define CMD_802_11_SLEEP_PARAMS 0x0066
83 83
84#define cmd_802_11_inactivity_timeout 0x0067 84#define CMD_802_11_INACTIVITY_TIMEOUT 0x0067
85 85
86#define cmd_802_11_tpc_cfg 0x0072 86#define CMD_802_11_TPC_CFG 0x0072
87#define cmd_802_11_pwr_cfg 0x0073 87#define CMD_802_11_PWR_CFG 0x0073
88 88
89#define cmd_802_11_led_gpio_ctrl 0x004e 89#define CMD_802_11_LED_GPIO_CTRL 0x004e
90 90
91#define cmd_802_11_subscribe_event 0x0075 91#define CMD_802_11_SUBSCRIBE_EVENT 0x0075
92 92
93#define cmd_802_11_rate_adapt_rateset 0x0076 93#define CMD_802_11_RATE_ADAPT_RATESET 0x0076
94 94
95#define cmd_802_11_tx_rate_query 0x007f 95#define CMD_802_11_TX_RATE_QUERY 0x007f
96 96
97#define cmd_get_tsf 0x0080 97#define CMD_GET_TSF 0x0080
98 98
99#define cmd_bt_access 0x0087 99#define CMD_BT_ACCESS 0x0087
100#define cmd_ret_bt_access 0x8087 100#define CMD_RET_BT_ACCESS 0x8087
101 101
102#define cmd_fwt_access 0x0095 102#define CMD_FWT_ACCESS 0x0095
103#define cmd_ret_fwt_access 0x8095 103#define CMD_RET_FWT_ACCESS 0x8095
104 104
105#define cmd_mesh_access 0x009b 105#define CMD_MESH_ACCESS 0x009b
106#define cmd_ret_mesh_access 0x809b 106#define CMD_RET_MESH_ACCESS 0x809b
107 107
108/* For the IEEE Power Save */ 108/* For the IEEE Power Save */
109#define cmd_subcmd_enter_ps 0x0030 109#define CMD_SUBCMD_ENTER_PS 0x0030
110#define cmd_subcmd_exit_ps 0x0031 110#define CMD_SUBCMD_EXIT_PS 0x0031
111#define cmd_subcmd_sleep_confirmed 0x0034 111#define CMD_SUBCMD_SLEEP_CONFIRMED 0x0034
112#define cmd_subcmd_full_powerdown 0x0035 112#define CMD_SUBCMD_FULL_POWERDOWN 0x0035
113#define cmd_subcmd_full_powerup 0x0036 113#define CMD_SUBCMD_FULL_POWERUP 0x0036
114 114
115/* command RET code, MSB is set to 1 */ 115/* command RET code, MSB is set to 1 */
116#define cmd_ret_hw_spec_info 0x8003 116#define CMD_RET_HW_SPEC_INFO 0x8003
117#define cmd_ret_eeprom_update 0x8004 117#define CMD_RET_EEPROM_UPDATE 0x8004
118#define cmd_ret_802_11_reset 0x8005 118#define CMD_RET_802_11_RESET 0x8005
119#define cmd_ret_802_11_scan 0x8006 119#define CMD_RET_802_11_SCAN 0x8006
120#define cmd_ret_802_11_get_log 0x800b 120#define CMD_RET_802_11_GET_LOG 0x800b
121#define cmd_ret_mac_control 0x8028 121#define CMD_RET_MAC_CONTROL 0x8028
122#define cmd_ret_mac_multicast_adr 0x8010 122#define CMD_RET_MAC_MULTICAST_ADR 0x8010
123#define cmd_ret_802_11_authenticate 0x8011 123#define CMD_RET_802_11_AUTHENTICATE 0x8011
124#define cmd_ret_802_11_deauthenticate 0x8024 124#define CMD_RET_802_11_DEAUTHENTICATE 0x8024
125#define cmd_ret_802_11_associate 0x8012 125#define CMD_RET_802_11_ASSOCIATE 0x8012
126#define cmd_ret_802_11_reassociate 0x8025 126#define CMD_RET_802_11_REASSOCIATE 0x8025
127#define cmd_ret_802_11_disassociate 0x8026 127#define CMD_RET_802_11_DISASSOCIATE 0x8026
128#define cmd_ret_802_11_set_wep 0x8013 128#define CMD_RET_802_11_SET_WEP 0x8013
129#define cmd_ret_802_11_stat 0x8014 129#define CMD_RET_802_11_STAT 0x8014
130#define cmd_ret_802_3_stat 0x8015 130#define CMD_RET_802_3_STAT 0x8015
131#define cmd_ret_802_11_snmp_mib 0x8016 131#define CMD_RET_802_11_SNMP_MIB 0x8016
132#define cmd_ret_mac_reg_map 0x8017 132#define CMD_RET_MAC_REG_MAP 0x8017
133#define cmd_ret_bbp_reg_map 0x8018 133#define CMD_RET_BBP_REG_MAP 0x8018
134#define cmd_ret_rf_reg_map 0x8023 134#define CMD_RET_RF_REG_MAP 0x8023
135#define cmd_ret_mac_reg_access 0x8019 135#define CMD_RET_MAC_REG_ACCESS 0x8019
136#define cmd_ret_bbp_reg_access 0x801a 136#define CMD_RET_BBP_REG_ACCESS 0x801a
137#define cmd_ret_rf_reg_access 0x801b 137#define CMD_RET_RF_REG_ACCESS 0x801b
138#define cmd_ret_802_11_radio_control 0x801c 138#define CMD_RET_802_11_RADIO_CONTROL 0x801c
139#define cmd_ret_802_11_rf_channel 0x801d 139#define CMD_RET_802_11_RF_CHANNEL 0x801d
140#define cmd_ret_802_11_rssi 0x801f 140#define CMD_RET_802_11_RSSI 0x801f
141#define cmd_ret_802_11_rf_tx_power 0x801e 141#define CMD_RET_802_11_RF_TX_POWER 0x801e
142#define cmd_ret_802_11_rf_antenna 0x8020 142#define CMD_RET_802_11_RF_ANTENNA 0x8020
143#define cmd_ret_802_11_ps_mode 0x8021 143#define CMD_RET_802_11_PS_MODE 0x8021
144#define cmd_ret_802_11_data_rate 0x8022 144#define CMD_RET_802_11_DATA_RATE 0x8022
145 145
146#define cmd_ret_802_11_ad_hoc_start 0x802B 146#define CMD_RET_802_11_AD_HOC_START 0x802B
147#define cmd_ret_802_11_ad_hoc_join 0x802C 147#define CMD_RET_802_11_AD_HOC_JOIN 0x802C
148 148
149#define cmd_ret_802_11_query_tkip_reply_cntrs 0x802e 149#define CMD_RET_802_11_QUERY_TKIP_REPLY_CNTRS 0x802e
150#define cmd_ret_802_11_enable_rsn 0x802f 150#define CMD_RET_802_11_ENABLE_RSN 0x802f
151#define cmd_ret_802_11_pairwise_tsc 0x8036 151#define CMD_RET_802_11_PAIRWISE_TSC 0x8036
152#define cmd_ret_802_11_group_tsc 0x8037 152#define CMD_RET_802_11_GROUP_TSC 0x8037
153#define cmd_ret_802_11_key_material 0x805e 153#define CMD_RET_802_11_KEY_MATERIAL 0x805e
154 154
155#define cmd_enable_rsn 0x0001 155#define CMD_ENABLE_RSN 0x0001
156#define cmd_disable_rsn 0x0000 156#define CMD_DISABLE_RSN 0x0000
157 157
158#define cmd_act_set 0x0001 158#define CMD_ACT_SET 0x0001
159#define cmd_act_get 0x0000 159#define CMD_ACT_GET 0x0000
160 160
161#define cmd_act_get_AES (cmd_act_get + 2) 161#define CMD_ACT_GET_AES (CMD_ACT_GET + 2)
162#define cmd_act_set_AES (cmd_act_set + 2) 162#define CMD_ACT_SET_AES (CMD_ACT_SET + 2)
163#define cmd_act_remove_aes (cmd_act_set + 3) 163#define CMD_ACT_REMOVE_AES (CMD_ACT_SET + 3)
164 164
165#define cmd_ret_802_11_set_afc 0x803c 165#define CMD_RET_802_11_SET_AFC 0x803c
166#define cmd_ret_802_11_get_afc 0x803d 166#define CMD_RET_802_11_GET_AFC 0x803d
167 167
168#define cmd_ret_802_11_ad_hoc_stop 0x8040 168#define CMD_RET_802_11_AD_HOC_STOP 0x8040
169 169
170#define cmd_ret_802_11_beacon_stop 0x8049 170#define CMD_RET_802_11_BEACON_STOP 0x8049
171 171
172#define cmd_ret_802_11_mac_address 0x804D 172#define CMD_RET_802_11_MAC_ADDRESS 0x804D
173#define cmd_ret_802_11_eeprom_access 0x8059 173#define CMD_RET_802_11_EEPROM_ACCESS 0x8059
174 174
175#define cmd_ret_802_11_band_config 0x8058 175#define CMD_RET_802_11_BAND_CONFIG 0x8058
176 176
177#define cmd_ret_802_11_sleep_params 0x8066 177#define CMD_RET_802_11_SLEEP_PARAMS 0x8066
178 178
179#define cmd_ret_802_11_inactivity_timeout 0x8067 179#define CMD_RET_802_11_INACTIVITY_TIMEOUT 0x8067
180 180
181#define cmd_ret_802_11d_domain_info (0x8000 | \ 181#define CMD_RET_802_11D_DOMAIN_INFO (0x8000 | \
182 cmd_802_11d_domain_info) 182 CMD_802_11D_DOMAIN_INFO)
183 183
184#define cmd_ret_802_11_tpc_cfg (cmd_802_11_tpc_cfg | 0x8000) 184#define CMD_RET_802_11_TPC_CFG (CMD_802_11_TPC_CFG | 0x8000)
185#define cmd_ret_802_11_pwr_cfg (cmd_802_11_pwr_cfg | 0x8000) 185#define CMD_RET_802_11_PWR_CFG (CMD_802_11_PWR_CFG | 0x8000)
186 186
187#define cmd_ret_802_11_led_gpio_ctrl 0x804e 187#define CMD_RET_802_11_LED_GPIO_CTRL 0x804e
188 188
189#define cmd_ret_802_11_subscribe_event (cmd_802_11_subscribe_event | 0x8000) 189#define CMD_RET_802_11_SUBSCRIBE_EVENT (CMD_802_11_SUBSCRIBE_EVENT | 0x8000)
190 190
191#define cmd_ret_802_11_rate_adapt_rateset (cmd_802_11_rate_adapt_rateset | 0x8000) 191#define CMD_RET_802_11_RATE_ADAPT_RATESET (CMD_802_11_RATE_ADAPT_RATESET | 0x8000)
192 192
193#define cmd_rte_802_11_tx_rate_query (cmd_802_11_tx_rate_query | 0x8000) 193#define CMD_RTE_802_11_TX_RATE_QUERY (CMD_802_11_TX_RATE_QUERY | 0x8000)
194 194
195#define cmd_ret_get_tsf 0x8080 195#define CMD_RET_GET_TSF 0x8080
196 196
197/* Define action or option for cmd_802_11_set_wep */ 197/* Define action or option for CMD_802_11_SET_WEP */
198#define cmd_act_add 0x0002 198#define CMD_ACT_ADD 0x0002
199#define cmd_act_remove 0x0004 199#define CMD_ACT_REMOVE 0x0004
200#define cmd_act_use_default 0x0008 200#define CMD_ACT_USE_DEFAULT 0x0008
201 201
202#define cmd_type_wep_40_bit 0x0001 202#define CMD_TYPE_WEP_40_BIT 0x0001
203#define cmd_type_wep_104_bit 0x0002 203#define CMD_TYPE_WEP_104_BIT 0x0002
204 204
205#define cmd_NUM_OF_WEP_KEYS 4 205#define CMD_NUM_OF_WEP_KEYS 4
206 206
207#define cmd_WEP_KEY_INDEX_MASK 0x3fff 207#define CMD_WEP_KEY_INDEX_MASK 0x3fff
208 208
209/* Define action or option for cmd_802_11_reset */ 209/* Define action or option for CMD_802_11_RESET */
210#define cmd_act_halt 0x0003 210#define CMD_ACT_HALT 0x0003
211 211
212/* Define action or option for cmd_802_11_scan */ 212/* Define action or option for CMD_802_11_SCAN */
213#define cmd_bss_type_bss 0x0001 213#define CMD_BSS_TYPE_BSS 0x0001
214#define cmd_bss_type_ibss 0x0002 214#define CMD_BSS_TYPE_IBSS 0x0002
215#define cmd_bss_type_any 0x0003 215#define CMD_BSS_TYPE_ANY 0x0003
216 216
217/* Define action or option for cmd_802_11_scan */ 217/* Define action or option for CMD_802_11_SCAN */
218#define cmd_scan_type_active 0x0000 218#define CMD_SCAN_TYPE_ACTIVE 0x0000
219#define cmd_scan_type_passive 0x0001 219#define CMD_SCAN_TYPE_PASSIVE 0x0001
220 220
221#define cmd_scan_radio_type_bg 0 221#define CMD_SCAN_RADIO_TYPE_BG 0
222 222
223#define cmd_scan_probe_delay_time 0 223#define CMD_SCAN_PROBE_DELAY_TIME 0
224 224
225/* Define action or option for cmd_mac_control */ 225/* Define action or option for CMD_MAC_CONTROL */
226#define cmd_act_mac_rx_on 0x0001 226#define CMD_ACT_MAC_RX_ON 0x0001
227#define cmd_act_mac_tx_on 0x0002 227#define CMD_ACT_MAC_TX_ON 0x0002
228#define cmd_act_mac_loopback_on 0x0004 228#define CMD_ACT_MAC_LOOPBACK_ON 0x0004
229#define cmd_act_mac_wep_enable 0x0008 229#define CMD_ACT_MAC_WEP_ENABLE 0x0008
230#define cmd_act_mac_int_enable 0x0010 230#define CMD_ACT_MAC_INT_ENABLE 0x0010
231#define cmd_act_mac_multicast_enable 0x0020 231#define CMD_ACT_MAC_MULTICAST_ENABLE 0x0020
232#define cmd_act_mac_broadcast_enable 0x0040 232#define CMD_ACT_MAC_BROADCAST_ENABLE 0x0040
233#define cmd_act_mac_promiscuous_enable 0x0080 233#define CMD_ACT_MAC_PROMISCUOUS_ENABLE 0x0080
234#define cmd_act_mac_all_multicast_enable 0x0100 234#define CMD_ACT_MAC_ALL_MULTICAST_ENABLE 0x0100
235#define cmd_act_mac_strict_protection_enable 0x0400 235#define CMD_ACT_MAC_STRICT_PROTECTION_ENABLE 0x0400
236 236
237/* Define action or option for cmd_802_11_radio_control */ 237/* Define action or option for CMD_802_11_RADIO_CONTROL */
238#define cmd_type_auto_preamble 0x0001 238#define CMD_TYPE_AUTO_PREAMBLE 0x0001
239#define cmd_type_short_preamble 0x0002 239#define CMD_TYPE_SHORT_PREAMBLE 0x0002
240#define cmd_type_long_preamble 0x0003 240#define CMD_TYPE_LONG_PREAMBLE 0x0003
241 241
242#define TURN_ON_RF 0x01 242#define TURN_ON_RF 0x01
243#define RADIO_ON 0x01 243#define RADIO_ON 0x01
@@ -248,70 +248,70 @@
248#define SET_LONG_PREAMBLE 0x01 248#define SET_LONG_PREAMBLE 0x01
249 249
250/* Define action or option for CMD_802_11_RF_CHANNEL */ 250/* Define action or option for CMD_802_11_RF_CHANNEL */
251#define cmd_opt_802_11_rf_channel_get 0x00 251#define CMD_OPT_802_11_RF_CHANNEL_GET 0x00
252#define cmd_opt_802_11_rf_channel_set 0x01 252#define CMD_OPT_802_11_RF_CHANNEL_SET 0x01
253 253
254/* Define action or option for cmd_802_11_rf_tx_power */ 254/* Define action or option for CMD_802_11_RF_TX_POWER */
255#define cmd_act_tx_power_opt_get 0x0000 255#define CMD_ACT_TX_POWER_OPT_GET 0x0000
256#define cmd_act_tx_power_opt_set_high 0x8007 256#define CMD_ACT_TX_POWER_OPT_SET_HIGH 0x8007
257#define cmd_act_tx_power_opt_set_mid 0x8004 257#define CMD_ACT_TX_POWER_OPT_SET_MID 0x8004
258#define cmd_act_tx_power_opt_set_low 0x8000 258#define CMD_ACT_TX_POWER_OPT_SET_LOW 0x8000
259 259
260#define cmd_act_tx_power_index_high 0x0007 260#define CMD_ACT_TX_POWER_INDEX_HIGH 0x0007
261#define cmd_act_tx_power_index_mid 0x0004 261#define CMD_ACT_TX_POWER_INDEX_MID 0x0004
262#define cmd_act_tx_power_index_low 0x0000 262#define CMD_ACT_TX_POWER_INDEX_LOW 0x0000
263 263
264/* Define action or option for cmd_802_11_data_rate */ 264/* Define action or option for CMD_802_11_DATA_RATE */
265#define cmd_act_set_tx_auto 0x0000 265#define CMD_ACT_SET_tx_auto 0x0000
266#define cmd_act_set_tx_fix_rate 0x0001 266#define CMD_ACT_SET_tx_fix_rate 0x0001
267#define cmd_act_get_tx_rate 0x0002 267#define CMD_ACT_GET_tx_rate 0x0002
268 268
269#define cmd_act_set_rx 0x0001 269#define CMD_ACT_SET_rx 0x0001
270#define cmd_act_set_tx 0x0002 270#define CMD_ACT_SET_tx 0x0002
271#define cmd_act_set_both 0x0003 271#define CMD_ACT_SET_both 0x0003
272#define cmd_act_get_rx 0x0004 272#define CMD_ACT_GET_rx 0x0004
273#define cmd_act_get_tx 0x0008 273#define CMD_ACT_GET_tx 0x0008
274#define cmd_act_get_both 0x000c 274#define CMD_ACT_GET_both 0x000c
275 275
276/* Define action or option for cmd_802_11_ps_mode */ 276/* Define action or option for CMD_802_11_PS_MODE */
277#define cmd_type_cam 0x0000 277#define CMD_TYPE_CAM 0x0000
278#define cmd_type_max_psp 0x0001 278#define CMD_TYPE_MAX_PSP 0x0001
279#define cmd_type_fast_psp 0x0002 279#define CMD_TYPE_FAST_PSP 0x0002
280 280
281/* Define action or option for cmd_bt_access */ 281/* Define action or option for CMD_BT_ACCESS */
282enum cmd_bt_access_opts { 282enum CMD_BT_ACCESS_opts {
283 /* The bt commands start at 5 instead of 1 because the old dft commands 283 /* The bt commands start at 5 instead of 1 because the old dft commands
284 * are mapped to 1-4. These old commands are no longer maintained and 284 * are mapped to 1-4. These old commands are no longer maintained and
285 * should not be called. 285 * should not be called.
286 */ 286 */
287 cmd_act_bt_access_add = 5, 287 CMD_ACT_BT_ACCESS_ADD = 5,
288 cmd_act_bt_access_del, 288 CMD_ACT_BT_ACCESS_DEL,
289 cmd_act_bt_access_list, 289 CMD_ACT_BT_ACCESS_LIST,
290 cmd_act_bt_access_reset, 290 CMD_ACT_BT_ACCESS_RESET,
291 cmd_act_bt_access_set_invert, 291 CMD_ACT_BT_ACCESS_SET_INVERT,
292 cmd_act_bt_access_get_invert 292 CMD_ACT_BT_ACCESS_GET_INVERT
293}; 293};
294 294
295/* Define action or option for cmd_fwt_access */ 295/* Define action or option for CMD_FWT_ACCESS */
296enum cmd_fwt_access_opts { 296enum CMD_FWT_ACCESS_opts {
297 cmd_act_fwt_access_add = 1, 297 CMD_ACT_FWT_ACCESS_ADD = 1,
298 cmd_act_fwt_access_del, 298 CMD_ACT_FWT_ACCESS_DEL,
299 cmd_act_fwt_access_lookup, 299 CMD_ACT_FWT_ACCESS_LOOKUP,
300 cmd_act_fwt_access_list, 300 CMD_ACT_FWT_ACCESS_LIST,
301 cmd_act_fwt_access_list_route, 301 CMD_ACT_FWT_ACCESS_LIST_route,
302 cmd_act_fwt_access_list_neighbor, 302 CMD_ACT_FWT_ACCESS_LIST_neighbor,
303 cmd_act_fwt_access_reset, 303 CMD_ACT_FWT_ACCESS_RESET,
304 cmd_act_fwt_access_cleanup, 304 CMD_ACT_FWT_ACCESS_CLEANUP,
305 cmd_act_fwt_access_time, 305 CMD_ACT_FWT_ACCESS_TIME,
306}; 306};
307 307
308/* Define action or option for cmd_mesh_access */ 308/* Define action or option for CMD_MESH_ACCESS */
309enum cmd_mesh_access_opts { 309enum CMD_MESH_ACCESS_opts {
310 cmd_act_mesh_get_ttl = 1, 310 CMD_ACT_MESH_GET_TTL = 1,
311 cmd_act_mesh_set_ttl, 311 CMD_ACT_MESH_SET_TTL,
312 cmd_act_mesh_get_stats, 312 CMD_ACT_MESH_GET_STATS,
313 cmd_act_mesh_get_anycast, 313 CMD_ACT_MESH_GET_ANYCAST,
314 cmd_act_mesh_set_anycast, 314 CMD_ACT_MESH_SET_ANYCAST,
315}; 315};
316 316
317/** Card Event definition */ 317/** Card Event definition */
diff --git a/drivers/net/wireless/libertas/hostcmd.h b/drivers/net/wireless/libertas/hostcmd.h
index 23871c0f882a..76c5fdeb256a 100644
--- a/drivers/net/wireless/libertas/hostcmd.h
+++ b/drivers/net/wireless/libertas/hostcmd.h
@@ -108,7 +108,7 @@ struct cmd_ds_gen {
108 108
109#define S_DS_GEN sizeof(struct cmd_ds_gen) 109#define S_DS_GEN sizeof(struct cmd_ds_gen)
110/* 110/*
111 * Define data structure for cmd_get_hw_spec 111 * Define data structure for CMD_GET_HW_SPEC
112 * This structure defines the response for the GET_HW_SPEC command 112 * This structure defines the response for the GET_HW_SPEC command
113 */ 113 */
114struct cmd_ds_get_hw_spec { 114struct cmd_ds_get_hw_spec {
@@ -155,7 +155,7 @@ struct cmd_ds_802_11_subscribe_event {
155 155
156/* 156/*
157 * This scan handle Country Information IE(802.11d compliant) 157 * This scan handle Country Information IE(802.11d compliant)
158 * Define data structure for cmd_802_11_scan 158 * Define data structure for CMD_802_11_SCAN
159 */ 159 */
160struct cmd_ds_802_11_scan { 160struct cmd_ds_802_11_scan {
161 u8 bsstype; 161 u8 bsstype;
diff --git a/drivers/net/wireless/libertas/if_usb.c b/drivers/net/wireless/libertas/if_usb.c
index 11687b84c596..cf522c6ef57a 100644
--- a/drivers/net/wireless/libertas/if_usb.c
+++ b/drivers/net/wireless/libertas/if_usb.c
@@ -78,7 +78,7 @@ static void if_usb_write_bulk_callback(struct urb *urb)
78 /* Wake main thread if commands are pending */ 78 /* Wake main thread if commands are pending */
79 if (!adapter->cur_cmd) 79 if (!adapter->cur_cmd)
80 wake_up_interruptible(&priv->mainthread.waitq); 80 wake_up_interruptible(&priv->mainthread.waitq);
81 if ((adapter->connect_status == libertas_connected)) { 81 if ((adapter->connect_status == LIBERTAS_CONNECTED)) {
82 netif_wake_queue(dev); 82 netif_wake_queue(dev);
83 netif_wake_queue(priv->mesh_dev); 83 netif_wake_queue(priv->mesh_dev);
84 } 84 }
@@ -758,8 +758,8 @@ static int if_usb_reset_device(wlan_private *priv)
758 int ret; 758 int ret;
759 759
760 lbs_deb_enter(LBS_DEB_USB); 760 lbs_deb_enter(LBS_DEB_USB);
761 ret = libertas_prepare_and_send_command(priv, cmd_802_11_reset, 761 ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET,
762 cmd_act_halt, 0, 0, NULL); 762 CMD_ACT_HALT, 0, 0, NULL);
763 msleep_interruptible(10); 763 msleep_interruptible(10);
764 764
765 lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret); 765 lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
diff --git a/drivers/net/wireless/libertas/join.c b/drivers/net/wireless/libertas/join.c
index db467e7876f2..3530c23da798 100644
--- a/drivers/net/wireless/libertas/join.c
+++ b/drivers/net/wireless/libertas/join.c
@@ -88,7 +88,7 @@ int libertas_send_deauth(wlan_private * priv)
88 int ret = 0; 88 int ret = 0;
89 89
90 if (adapter->mode == IW_MODE_INFRA && 90 if (adapter->mode == IW_MODE_INFRA &&
91 adapter->connect_status == libertas_connected) 91 adapter->connect_status == LIBERTAS_CONNECTED)
92 ret = libertas_send_deauthentication(priv); 92 ret = libertas_send_deauthentication(priv);
93 else 93 else
94 ret = -ENOTSUPP; 94 ret = -ENOTSUPP;
@@ -111,8 +111,8 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
111 111
112 lbs_deb_enter(LBS_DEB_JOIN); 112 lbs_deb_enter(LBS_DEB_JOIN);
113 113
114 ret = libertas_prepare_and_send_command(priv, cmd_802_11_authenticate, 114 ret = libertas_prepare_and_send_command(priv, CMD_802_11_AUTHENTICATE,
115 0, cmd_option_waitforrsp, 115 0, CMD_OPTION_WAITFORRSP,
116 0, assoc_req->bss.bssid); 116 0, assoc_req->bss.bssid);
117 117
118 if (ret) 118 if (ret)
@@ -121,14 +121,14 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
121 /* set preamble to firmware */ 121 /* set preamble to firmware */
122 if ( (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) 122 if ( (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
123 && (assoc_req->bss.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) 123 && (assoc_req->bss.capability & WLAN_CAPABILITY_SHORT_PREAMBLE))
124 adapter->preamble = cmd_type_short_preamble; 124 adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
125 else 125 else
126 adapter->preamble = cmd_type_long_preamble; 126 adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
127 127
128 libertas_set_radio_control(priv); 128 libertas_set_radio_control(priv);
129 129
130 ret = libertas_prepare_and_send_command(priv, cmd_802_11_associate, 130 ret = libertas_prepare_and_send_command(priv, CMD_802_11_ASSOCIATE,
131 0, cmd_option_waitforrsp, 0, assoc_req); 131 0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
132 132
133done: 133done:
134 lbs_deb_leave_args(LBS_DEB_JOIN, "ret %d", ret); 134 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
151 151
152 if (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) { 152 if (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) {
153 lbs_deb_join("AdhocStart: Short preamble\n"); 153 lbs_deb_join("AdhocStart: Short preamble\n");
154 adapter->preamble = cmd_type_short_preamble; 154 adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
155 } else { 155 } else {
156 lbs_deb_join("AdhocStart: Long preamble\n"); 156 lbs_deb_join("AdhocStart: Long preamble\n");
157 adapter->preamble = cmd_type_long_preamble; 157 adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
158 } 158 }
159 159
160 libertas_set_radio_control(priv); 160 libertas_set_radio_control(priv);
@@ -162,8 +162,8 @@ int libertas_start_adhoc_network(wlan_private * priv, struct assoc_request * ass
162 lbs_deb_join("AdhocStart: channel = %d\n", assoc_req->channel); 162 lbs_deb_join("AdhocStart: channel = %d\n", assoc_req->channel);
163 lbs_deb_join("AdhocStart: band = %d\n", assoc_req->band); 163 lbs_deb_join("AdhocStart: band = %d\n", assoc_req->band);
164 164
165 ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_start, 165 ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_START,
166 0, cmd_option_waitforrsp, 0, assoc_req); 166 0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
167 167
168 return ret; 168 return ret;
169} 169}
@@ -209,10 +209,10 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
209 if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) 209 if ( !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
210 || !(adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) { 210 || !(adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) {
211 lbs_deb_join("AdhocJoin: Long preamble\n"); 211 lbs_deb_join("AdhocJoin: Long preamble\n");
212 adapter->preamble = cmd_type_long_preamble; 212 adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
213 } else { 213 } else {
214 lbs_deb_join("AdhocJoin: Short preamble\n"); 214 lbs_deb_join("AdhocJoin: Short preamble\n");
215 adapter->preamble = cmd_type_short_preamble; 215 adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
216 } 216 }
217 217
218 libertas_set_radio_control(priv); 218 libertas_set_radio_control(priv);
@@ -222,8 +222,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
222 222
223 adapter->adhoccreate = 0; 223 adapter->adhoccreate = 0;
224 224
225 ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_join, 225 ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_JOIN,
226 0, cmd_option_waitforrsp, 226 0, CMD_OPTION_WAITFORRSP,
227 OID_802_11_SSID, assoc_req); 227 OID_802_11_SSID, assoc_req);
228 228
229 return ret; 229 return ret;
@@ -231,8 +231,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
231 231
232int libertas_stop_adhoc_network(wlan_private * priv) 232int libertas_stop_adhoc_network(wlan_private * priv)
233{ 233{
234 return libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_stop, 234 return libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_STOP,
235 0, cmd_option_waitforrsp, 0, NULL); 235 0, CMD_OPTION_WAITFORRSP, 0, NULL);
236} 236}
237 237
238/** 238/**
@@ -243,8 +243,8 @@ int libertas_stop_adhoc_network(wlan_private * priv)
243 */ 243 */
244int libertas_send_deauthentication(wlan_private * priv) 244int libertas_send_deauthentication(wlan_private * priv)
245{ 245{
246 return libertas_prepare_and_send_command(priv, cmd_802_11_deauthenticate, 246 return libertas_prepare_and_send_command(priv, CMD_802_11_DEAUTHENTICATE,
247 0, cmd_option_waitforrsp, 0, NULL); 247 0, CMD_OPTION_WAITFORRSP, 0, NULL);
248} 248}
249 249
250/** 250/**
@@ -267,7 +267,7 @@ int libertas_cmd_80211_authenticate(wlan_private * priv,
267 267
268 lbs_deb_enter(LBS_DEB_JOIN); 268 lbs_deb_enter(LBS_DEB_JOIN);
269 269
270 cmd->command = cpu_to_le16(cmd_802_11_authenticate); 270 cmd->command = cpu_to_le16(CMD_802_11_AUTHENTICATE);
271 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate) 271 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate)
272 + S_DS_GEN); 272 + S_DS_GEN);
273 273
@@ -307,7 +307,7 @@ int libertas_cmd_80211_deauthenticate(wlan_private * priv,
307 307
308 lbs_deb_enter(LBS_DEB_JOIN); 308 lbs_deb_enter(LBS_DEB_JOIN);
309 309
310 cmd->command = cpu_to_le16(cmd_802_11_deauthenticate); 310 cmd->command = cpu_to_le16(CMD_802_11_DEAUTHENTICATE);
311 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) + 311 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) +
312 S_DS_GEN); 312 S_DS_GEN);
313 313
@@ -349,7 +349,7 @@ int libertas_cmd_80211_associate(wlan_private * priv,
349 goto done; 349 goto done;
350 } 350 }
351 351
352 cmd->command = cpu_to_le16(cmd_802_11_associate); 352 cmd->command = cpu_to_le16(CMD_802_11_ASSOCIATE);
353 353
354 memcpy(passo->peerstaaddr, bss->bssid, sizeof(passo->peerstaaddr)); 354 memcpy(passo->peerstaaddr, bss->bssid, sizeof(passo->peerstaaddr));
355 pos += sizeof(passo->peerstaaddr); 355 pos += sizeof(passo->peerstaaddr);
@@ -465,7 +465,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
465 goto done; 465 goto done;
466 } 466 }
467 467
468 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_start); 468 cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_START);
469 469
470 /* 470 /*
471 * Fill in the parameters for 2 data structures: 471 * Fill in the parameters for 2 data structures:
@@ -487,7 +487,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
487 assoc_req->ssid_len); 487 assoc_req->ssid_len);
488 488
489 /* set the BSS type */ 489 /* set the BSS type */
490 adhs->bsstype = cmd_bss_type_ibss; 490 adhs->bsstype = CMD_BSS_TYPE_IBSS;
491 adapter->mode = IW_MODE_ADHOC; 491 adapter->mode = IW_MODE_ADHOC;
492 adhs->beaconperiod = cpu_to_le16(adapter->beaconperiod); 492 adhs->beaconperiod = cpu_to_le16(adapter->beaconperiod);
493 493
@@ -524,7 +524,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
524 adhs->capability = cpu_to_le16(tmpcap); 524 adhs->capability = cpu_to_le16(tmpcap);
525 525
526 /* probedelay */ 526 /* probedelay */
527 adhs->probedelay = cpu_to_le16(cmd_scan_probe_delay_time); 527 adhs->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
528 528
529 memset(adhs->datarate, 0, sizeof(adhs->datarate)); 529 memset(adhs->datarate, 0, sizeof(adhs->datarate));
530 530
@@ -569,7 +569,7 @@ done:
569int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv, 569int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv,
570 struct cmd_ds_command *cmd) 570 struct cmd_ds_command *cmd)
571{ 571{
572 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_stop); 572 cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_STOP);
573 cmd->size = cpu_to_le16(S_DS_GEN); 573 cmd->size = cpu_to_le16(S_DS_GEN);
574 574
575 return 0; 575 return 0;
@@ -590,9 +590,9 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
590 590
591 lbs_deb_enter(LBS_DEB_JOIN); 591 lbs_deb_enter(LBS_DEB_JOIN);
592 592
593 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_join); 593 cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_JOIN);
594 594
595 join_cmd->bss.type = cmd_bss_type_ibss; 595 join_cmd->bss.type = CMD_BSS_TYPE_IBSS;
596 join_cmd->bss.beaconperiod = cpu_to_le16(bss->beaconperiod); 596 join_cmd->bss.beaconperiod = cpu_to_le16(bss->beaconperiod);
597 597
598 memcpy(&join_cmd->bss.bssid, &bss->bssid, ETH_ALEN); 598 memcpy(&join_cmd->bss.bssid, &bss->bssid, ETH_ALEN);
@@ -617,7 +617,7 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
617 join_cmd->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT); 617 join_cmd->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
618 618
619 /* probedelay */ 619 /* probedelay */
620 join_cmd->probedelay = cpu_to_le16(cmd_scan_probe_delay_time); 620 join_cmd->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
621 621
622 /* Copy Data rates from the rates recorded in scan response */ 622 /* Copy Data rates from the rates recorded in scan response */
623 memset(join_cmd->bss.datarates, 0, sizeof(join_cmd->bss.datarates)); 623 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,
659 join_cmd->bss.capability = cpu_to_le16(tmp); 659 join_cmd->bss.capability = cpu_to_le16(tmp);
660 } 660 }
661 661
662 if (adapter->psmode == wlan802_11powermodemax_psp) { 662 if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
663 /* wake up first */ 663 /* wake up first */
664 __le32 Localpsmode; 664 __le32 Localpsmode;
665 665
666 Localpsmode = cpu_to_le32(wlan802_11powermodecam); 666 Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
667 ret = libertas_prepare_and_send_command(priv, 667 ret = libertas_prepare_and_send_command(priv,
668 cmd_802_11_ps_mode, 668 CMD_802_11_PS_MODE,
669 cmd_act_set, 669 CMD_ACT_SET,
670 0, 0, &Localpsmode); 670 0, 0, &Localpsmode);
671 671
672 if (ret) { 672 if (ret) {
@@ -722,7 +722,7 @@ int libertas_ret_80211_associate(wlan_private * priv,
722 le16_to_cpu(resp->size) - S_DS_GEN); 722 le16_to_cpu(resp->size) - S_DS_GEN);
723 723
724 /* Send a Media Connected event, according to the Spec */ 724 /* Send a Media Connected event, according to the Spec */
725 adapter->connect_status = libertas_connected; 725 adapter->connect_status = LIBERTAS_CONNECTED;
726 726
727 lbs_deb_join("ASSOC_RESP: assocated to '%s'\n", 727 lbs_deb_join("ASSOC_RESP: assocated to '%s'\n",
728 escape_essid(bss->ssid, bss->ssid_len)); 728 escape_essid(bss->ssid, bss->ssid_len));
@@ -802,7 +802,7 @@ int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
802 */ 802 */
803 if (result) { 803 if (result) {
804 lbs_deb_join("ADHOC_RESP: failed\n"); 804 lbs_deb_join("ADHOC_RESP: failed\n");
805 if (adapter->connect_status == libertas_connected) { 805 if (adapter->connect_status == LIBERTAS_CONNECTED) {
806 libertas_mac_event_disconnected(priv); 806 libertas_mac_event_disconnected(priv);
807 } 807 }
808 ret = -1; 808 ret = -1;
@@ -817,9 +817,9 @@ int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
817 escape_essid(bss->ssid, bss->ssid_len)); 817 escape_essid(bss->ssid, bss->ssid_len));
818 818
819 /* Send a Media Connected event, according to the Spec */ 819 /* Send a Media Connected event, according to the Spec */
820 adapter->connect_status = libertas_connected; 820 adapter->connect_status = LIBERTAS_CONNECTED;
821 821
822 if (command == cmd_ret_802_11_ad_hoc_start) { 822 if (command == CMD_RET_802_11_AD_HOC_START) {
823 /* Update the created network descriptor with the new BSSID */ 823 /* Update the created network descriptor with the new BSSID */
824 memcpy(bss->bssid, padhocresult->bssid, ETH_ALEN); 824 memcpy(bss->bssid, padhocresult->bssid, ETH_ALEN);
825 } 825 }
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 9f366242c392..2315eb61836e 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -187,9 +187,9 @@ static ssize_t libertas_anycast_get(struct device * dev,
187 187
188 memset(&mesh_access, 0, sizeof(mesh_access)); 188 memset(&mesh_access, 0, sizeof(mesh_access));
189 libertas_prepare_and_send_command(to_net_dev(dev)->priv, 189 libertas_prepare_and_send_command(to_net_dev(dev)->priv,
190 cmd_mesh_access, 190 CMD_MESH_ACCESS,
191 cmd_act_mesh_get_anycast, 191 CMD_ACT_MESH_GET_ANYCAST,
192 cmd_option_waitforrsp, 0, (void *)&mesh_access); 192 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
193 193
194 return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0])); 194 return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
195} 195}
@@ -208,9 +208,9 @@ static ssize_t libertas_anycast_set(struct device * dev,
208 mesh_access.data[0] = cpu_to_le32(datum); 208 mesh_access.data[0] = cpu_to_le32(datum);
209 209
210 libertas_prepare_and_send_command((to_net_dev(dev))->priv, 210 libertas_prepare_and_send_command((to_net_dev(dev))->priv,
211 cmd_mesh_access, 211 CMD_MESH_ACCESS,
212 cmd_act_mesh_set_anycast, 212 CMD_ACT_MESH_SET_ANYCAST,
213 cmd_option_waitforrsp, 0, (void *)&mesh_access); 213 CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
214 return strlen(buf); 214 return strlen(buf);
215} 215}
216 216
@@ -264,7 +264,7 @@ static int wlan_dev_open(struct net_device *dev)
264 264
265 priv->open = 1; 265 priv->open = 1;
266 266
267 if (adapter->connect_status == libertas_connected) { 267 if (adapter->connect_status == LIBERTAS_CONNECTED) {
268 netif_carrier_on(priv->dev); 268 netif_carrier_on(priv->dev);
269 netif_carrier_on(priv->mesh_dev); 269 netif_carrier_on(priv->mesh_dev);
270 } else { 270 } else {
@@ -439,7 +439,7 @@ static void wlan_tx_timeout(struct net_device *dev)
439 libertas_send_tx_feedback(priv); 439 libertas_send_tx_feedback(priv);
440 } else 440 } else
441 wake_up_interruptible(&priv->mainthread.waitq); 441 wake_up_interruptible(&priv->mainthread.waitq);
442 } else if (priv->adapter->connect_status == libertas_connected) { 442 } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
443 netif_wake_queue(priv->dev); 443 netif_wake_queue(priv->dev);
444 netif_wake_queue(priv->mesh_dev); 444 netif_wake_queue(priv->mesh_dev);
445 } 445 }
@@ -480,9 +480,9 @@ static int wlan_set_mac_address(struct net_device *dev, void *addr)
480 lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN); 480 lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN);
481 memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); 481 memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN);
482 482
483 ret = libertas_prepare_and_send_command(priv, cmd_802_11_mac_address, 483 ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS,
484 cmd_act_set, 484 CMD_ACT_SET,
485 cmd_option_waitforrsp, 0, NULL); 485 CMD_OPTION_WAITFORRSP, 0, NULL);
486 486
487 if (ret) { 487 if (ret) {
488 lbs_deb_net("set MAC address failed\n"); 488 lbs_deb_net("set MAC address failed\n");
@@ -528,36 +528,36 @@ static void wlan_set_multicast_list(struct net_device *dev)
528 if (dev->flags & IFF_PROMISC) { 528 if (dev->flags & IFF_PROMISC) {
529 lbs_deb_net("enable promiscuous mode\n"); 529 lbs_deb_net("enable promiscuous mode\n");
530 adapter->currentpacketfilter |= 530 adapter->currentpacketfilter |=
531 cmd_act_mac_promiscuous_enable; 531 CMD_ACT_MAC_PROMISCUOUS_ENABLE;
532 adapter->currentpacketfilter &= 532 adapter->currentpacketfilter &=
533 ~(cmd_act_mac_all_multicast_enable | 533 ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
534 cmd_act_mac_multicast_enable); 534 CMD_ACT_MAC_MULTICAST_ENABLE);
535 } else { 535 } else {
536 /* Multicast */ 536 /* Multicast */
537 adapter->currentpacketfilter &= 537 adapter->currentpacketfilter &=
538 ~cmd_act_mac_promiscuous_enable; 538 ~CMD_ACT_MAC_PROMISCUOUS_ENABLE;
539 539
540 if (dev->flags & IFF_ALLMULTI || dev->mc_count > 540 if (dev->flags & IFF_ALLMULTI || dev->mc_count >
541 MRVDRV_MAX_MULTICAST_LIST_SIZE) { 541 MRVDRV_MAX_MULTICAST_LIST_SIZE) {
542 lbs_deb_net( "enabling all multicast\n"); 542 lbs_deb_net( "enabling all multicast\n");
543 adapter->currentpacketfilter |= 543 adapter->currentpacketfilter |=
544 cmd_act_mac_all_multicast_enable; 544 CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
545 adapter->currentpacketfilter &= 545 adapter->currentpacketfilter &=
546 ~cmd_act_mac_multicast_enable; 546 ~CMD_ACT_MAC_MULTICAST_ENABLE;
547 } else { 547 } else {
548 adapter->currentpacketfilter &= 548 adapter->currentpacketfilter &=
549 ~cmd_act_mac_all_multicast_enable; 549 ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
550 550
551 if (!dev->mc_count) { 551 if (!dev->mc_count) {
552 lbs_deb_net("no multicast addresses, " 552 lbs_deb_net("no multicast addresses, "
553 "disabling multicast\n"); 553 "disabling multicast\n");
554 adapter->currentpacketfilter &= 554 adapter->currentpacketfilter &=
555 ~cmd_act_mac_multicast_enable; 555 ~CMD_ACT_MAC_MULTICAST_ENABLE;
556 } else { 556 } else {
557 int i; 557 int i;
558 558
559 adapter->currentpacketfilter |= 559 adapter->currentpacketfilter |=
560 cmd_act_mac_multicast_enable; 560 CMD_ACT_MAC_MULTICAST_ENABLE;
561 561
562 adapter->nr_of_multicastmacaddr = 562 adapter->nr_of_multicastmacaddr =
563 wlan_copy_multicast_address(adapter, dev); 563 wlan_copy_multicast_address(adapter, dev);
@@ -577,8 +577,8 @@ static void wlan_set_multicast_list(struct net_device *dev)
577 } 577 }
578 /* send multicast addresses to firmware */ 578 /* send multicast addresses to firmware */
579 libertas_prepare_and_send_command(priv, 579 libertas_prepare_and_send_command(priv,
580 cmd_mac_multicast_adr, 580 CMD_MAC_MULTICAST_ADR,
581 cmd_act_set, 0, 0, 581 CMD_ACT_SET, 0, 0,
582 NULL); 582 NULL);
583 } 583 }
584 } 584 }
@@ -711,7 +711,7 @@ static int wlan_service_main_thread(void *data)
711 if (adapter->psstate == PS_STATE_PRE_SLEEP) { 711 if (adapter->psstate == PS_STATE_PRE_SLEEP) {
712 if (!priv->dnld_sent && !adapter->cur_cmd) { 712 if (!priv->dnld_sent && !adapter->cur_cmd) {
713 if (adapter->connect_status == 713 if (adapter->connect_status ==
714 libertas_connected) { 714 LIBERTAS_CONNECTED) {
715 lbs_deb_thread( 715 lbs_deb_thread(
716 "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p " 716 "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p "
717 "dnld_sent=%d cur_cmd=%p, confirm now\n", 717 "dnld_sent=%d cur_cmd=%p, confirm now\n",
@@ -1005,9 +1005,9 @@ int libertas_remove_card(wlan_private *priv)
1005 cancel_delayed_work(&priv->assoc_work); 1005 cancel_delayed_work(&priv->assoc_work);
1006 destroy_workqueue(priv->assoc_thread); 1006 destroy_workqueue(priv->assoc_thread);
1007 1007
1008 if (adapter->psmode == wlan802_11powermodemax_psp) { 1008 if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
1009 adapter->psmode = wlan802_11powermodecam; 1009 adapter->psmode = WLAN802_11POWERMODECAM;
1010 libertas_ps_wakeup(priv, cmd_option_waitforrsp); 1010 libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
1011 } 1011 }
1012 1012
1013 memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); 1013 memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
diff --git a/drivers/net/wireless/libertas/scan.c b/drivers/net/wireless/libertas/scan.c
index 2937f79c4a01..2cac47fc4cd9 100644
--- a/drivers/net/wireless/libertas/scan.c
+++ b/drivers/net/wireless/libertas/scan.c
@@ -255,7 +255,7 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
255 255
256 for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) { 256 for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) {
257 if (priv->adapter->enable11d && 257 if (priv->adapter->enable11d &&
258 adapter->connect_status != libertas_connected) { 258 adapter->connect_status != LIBERTAS_CONNECTED) {
259 /* Scan all the supported chan for the first scan */ 259 /* Scan all the supported chan for the first scan */
260 if (!adapter->universal_channel[rgnidx].valid) 260 if (!adapter->universal_channel[rgnidx].valid)
261 continue; 261 continue;
@@ -287,11 +287,11 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
287 case BAND_G: 287 case BAND_G:
288 default: 288 default:
289 scanchanlist[chanidx].radiotype = 289 scanchanlist[chanidx].radiotype =
290 cmd_scan_radio_type_bg; 290 CMD_SCAN_RADIO_TYPE_BG;
291 break; 291 break;
292 } 292 }
293 293
294 if (scantype == cmd_scan_type_passive) { 294 if (scantype == CMD_SCAN_TYPE_PASSIVE) {
295 scanchanlist[chanidx].maxscantime = 295 scanchanlist[chanidx].maxscantime =
296 cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME); 296 cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME);
297 scanchanlist[chanidx].chanscanmode.passivescan = 297 scanchanlist[chanidx].chanscanmode.passivescan =
@@ -486,7 +486,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
486 486
487 scantype = puserscanin->chanlist[chanidx].scantype; 487 scantype = puserscanin->chanlist[chanidx].scantype;
488 488
489 if (scantype == cmd_scan_type_passive) { 489 if (scantype == CMD_SCAN_TYPE_PASSIVE) {
490 (pscanchanlist + 490 (pscanchanlist +
491 chanidx)->chanscanmode.passivescan = 1; 491 chanidx)->chanscanmode.passivescan = 1;
492 } else { 492 } else {
@@ -498,7 +498,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
498 scandur = 498 scandur =
499 puserscanin->chanlist[chanidx].scantime; 499 puserscanin->chanlist[chanidx].scantime;
500 } else { 500 } else {
501 if (scantype == cmd_scan_type_passive) { 501 if (scantype == CMD_SCAN_TYPE_PASSIVE) {
502 scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME; 502 scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME;
503 } else { 503 } else {
504 scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME; 504 scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME;
@@ -668,7 +668,7 @@ static int wlan_scan_channel_list(wlan_private * priv,
668 } 668 }
669 669
670 /* Send the scan command to the firmware with the specified cfg */ 670 /* Send the scan command to the firmware with the specified cfg */
671 ret = libertas_prepare_and_send_command(priv, cmd_802_11_scan, 0, 671 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SCAN, 0,
672 0, 0, pscancfgout); 672 0, 0, pscancfgout);
673 if (scanned >= 2 && !full_scan) { 673 if (scanned >= 2 && !full_scan) {
674 ret = 0; 674 ret = 0;
@@ -816,7 +816,7 @@ int wlan_scan_networks(wlan_private * priv,
816 mutex_unlock(&adapter->lock); 816 mutex_unlock(&adapter->lock);
817#endif 817#endif
818 818
819 if (priv->adapter->connect_status == libertas_connected) { 819 if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
820 netif_carrier_on(priv->dev); 820 netif_carrier_on(priv->dev);
821 netif_wake_queue(priv->dev); 821 netif_wake_queue(priv->dev);
822 netif_carrier_on(priv->mesh_dev); 822 netif_carrier_on(priv->mesh_dev);
@@ -1603,8 +1603,8 @@ int libertas_get_scan(struct net_device *dev, struct iw_request_info *info,
1603 1603
1604 /* Update RSSI if current BSS is a locally created ad-hoc BSS */ 1604 /* Update RSSI if current BSS is a locally created ad-hoc BSS */
1605 if ((adapter->mode == IW_MODE_ADHOC) && adapter->adhoccreate) { 1605 if ((adapter->mode == IW_MODE_ADHOC) && adapter->adhoccreate) {
1606 libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0, 1606 libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
1607 cmd_option_waitforrsp, 0, NULL); 1607 CMD_OPTION_WAITFORRSP, 0, NULL);
1608 } 1608 }
1609 1609
1610 mutex_lock(&adapter->lock); 1610 mutex_lock(&adapter->lock);
@@ -1680,7 +1680,7 @@ int libertas_cmd_80211_scan(wlan_private * priv,
1680 memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN); 1680 memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN);
1681 memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen); 1681 memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen);
1682 1682
1683 cmd->command = cpu_to_le16(cmd_802_11_scan); 1683 cmd->command = cpu_to_le16(CMD_802_11_SCAN);
1684 1684
1685 /* size is equal to the sizeof(fixed portions) + the TLV len + header */ 1685 /* size is equal to the sizeof(fixed portions) + the TLV len + header */
1686 cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN 1686 cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN
diff --git a/drivers/net/wireless/libertas/tx.c b/drivers/net/wireless/libertas/tx.c
index 17c437635a00..c2271020aafe 100644
--- a/drivers/net/wireless/libertas/tx.c
+++ b/drivers/net/wireless/libertas/tx.c
@@ -283,7 +283,7 @@ void libertas_send_tx_feedback(wlan_private * priv)
283 libertas_upload_rx_packet(priv, adapter->currenttxskb); 283 libertas_upload_rx_packet(priv, adapter->currenttxskb);
284 adapter->currenttxskb = NULL; 284 adapter->currenttxskb = NULL;
285 priv->adapter->TxLockFlag = 0; 285 priv->adapter->TxLockFlag = 0;
286 if (priv->adapter->connect_status == libertas_connected) { 286 if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
287 netif_wake_queue(priv->dev); 287 netif_wake_queue(priv->dev);
288 netif_wake_queue(priv->mesh_dev); 288 netif_wake_queue(priv->mesh_dev);
289 } 289 }
diff --git a/drivers/net/wireless/libertas/wext.c b/drivers/net/wireless/libertas/wext.c
index f7df8c71a544..7cfca5f3a5ef 100644
--- a/drivers/net/wireless/libertas/wext.c
+++ b/drivers/net/wireless/libertas/wext.c
@@ -177,9 +177,9 @@ int wlan_radio_ioctl(wlan_private * priv, u8 option)
177 adapter->radioon = option; 177 adapter->radioon = option;
178 178
179 ret = libertas_prepare_and_send_command(priv, 179 ret = libertas_prepare_and_send_command(priv,
180 cmd_802_11_radio_control, 180 CMD_802_11_RADIO_CONTROL,
181 cmd_act_set, 181 CMD_ACT_SET,
182 cmd_option_waitforrsp, 0, NULL); 182 CMD_OPTION_WAITFORRSP, 0, NULL);
183 } 183 }
184 184
185 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 185 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -221,7 +221,7 @@ static int get_active_data_rates(wlan_adapter * adapter,
221 221
222 lbs_deb_enter(LBS_DEB_WEXT); 222 lbs_deb_enter(LBS_DEB_WEXT);
223 223
224 if (adapter->connect_status != libertas_connected) { 224 if (adapter->connect_status != LIBERTAS_CONNECTED) {
225 if (adapter->mode == IW_MODE_INFRA) { 225 if (adapter->mode == IW_MODE_INFRA) {
226 lbs_deb_wext("infra\n"); 226 lbs_deb_wext("infra\n");
227 k = copyrates(rates, k, libertas_supported_rates, 227 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,
305 305
306 lbs_deb_enter(LBS_DEB_WEXT); 306 lbs_deb_enter(LBS_DEB_WEXT);
307 307
308 if (adapter->connect_status == libertas_connected) { 308 if (adapter->connect_status == LIBERTAS_CONNECTED) {
309 memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN); 309 memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
310 } else { 310 } else {
311 memset(awrq->sa_data, 0, ETH_ALEN); 311 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,
382 382
383 /* Use nickname to indicate that mesh is on */ 383 /* Use nickname to indicate that mesh is on */
384 384
385 if (adapter->connect_status == libertas_connected) { 385 if (adapter->connect_status == LIBERTAS_CONNECTED) {
386 strncpy(extra, "Mesh", 12); 386 strncpy(extra, "Mesh", 12);
387 extra[12] = '\0'; 387 extra[12] = '\0';
388 dwrq->length = strlen(extra) + 1; 388 dwrq->length = strlen(extra) + 1;
@@ -414,8 +414,8 @@ static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
414 adapter->rtsthsd = rthr; 414 adapter->rtsthsd = rthr;
415 } 415 }
416 416
417 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, 417 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
418 cmd_act_set, cmd_option_waitforrsp, 418 CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
419 OID_802_11_RTS_THRESHOLD, &rthr); 419 OID_802_11_RTS_THRESHOLD, &rthr);
420 420
421 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 421 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,
432 lbs_deb_enter(LBS_DEB_WEXT); 432 lbs_deb_enter(LBS_DEB_WEXT);
433 433
434 adapter->rtsthsd = 0; 434 adapter->rtsthsd = 0;
435 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, 435 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
436 cmd_act_get, cmd_option_waitforrsp, 436 CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
437 OID_802_11_RTS_THRESHOLD, NULL); 437 OID_802_11_RTS_THRESHOLD, NULL);
438 if (ret) 438 if (ret)
439 goto out; 439 goto out;
@@ -467,8 +467,8 @@ static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
467 adapter->fragthsd = fthr; 467 adapter->fragthsd = fthr;
468 } 468 }
469 469
470 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, 470 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
471 cmd_act_set, cmd_option_waitforrsp, 471 CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
472 OID_802_11_FRAGMENTATION_THRESHOLD, &fthr); 472 OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
473 473
474 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 474 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,
486 486
487 adapter->fragthsd = 0; 487 adapter->fragthsd = 0;
488 ret = libertas_prepare_and_send_command(priv, 488 ret = libertas_prepare_and_send_command(priv,
489 cmd_802_11_snmp_mib, 489 CMD_802_11_SNMP_MIB,
490 cmd_act_get, cmd_option_waitforrsp, 490 CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
491 OID_802_11_FRAGMENTATION_THRESHOLD, NULL); 491 OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
492 if (ret) 492 if (ret)
493 goto out; 493 goto out;
@@ -539,9 +539,9 @@ static int wlan_get_txpow(struct net_device *dev,
539 lbs_deb_enter(LBS_DEB_WEXT); 539 lbs_deb_enter(LBS_DEB_WEXT);
540 540
541 ret = libertas_prepare_and_send_command(priv, 541 ret = libertas_prepare_and_send_command(priv,
542 cmd_802_11_rf_tx_power, 542 CMD_802_11_RF_TX_POWER,
543 cmd_act_tx_power_opt_get, 543 CMD_ACT_TX_POWER_OPT_GET,
544 cmd_option_waitforrsp, 0, NULL); 544 CMD_OPTION_WAITFORRSP, 0, NULL);
545 545
546 if (ret) 546 if (ret)
547 goto out; 547 goto out;
@@ -581,9 +581,9 @@ static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
581 /* Adding 1 to convert retry count to try count */ 581 /* Adding 1 to convert retry count to try count */
582 adapter->txretrycount = vwrq->value + 1; 582 adapter->txretrycount = vwrq->value + 1;
583 583
584 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib, 584 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
585 cmd_act_set, 585 CMD_ACT_SET,
586 cmd_option_waitforrsp, 586 CMD_OPTION_WAITFORRSP,
587 OID_802_11_TX_RETRYCOUNT, NULL); 587 OID_802_11_TX_RETRYCOUNT, NULL);
588 588
589 if (ret) 589 if (ret)
@@ -608,8 +608,8 @@ static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
608 608
609 adapter->txretrycount = 0; 609 adapter->txretrycount = 0;
610 ret = libertas_prepare_and_send_command(priv, 610 ret = libertas_prepare_and_send_command(priv,
611 cmd_802_11_snmp_mib, 611 CMD_802_11_SNMP_MIB,
612 cmd_act_get, cmd_option_waitforrsp, 612 CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
613 OID_802_11_TX_RETRYCOUNT, NULL); 613 OID_802_11_TX_RETRYCOUNT, NULL);
614 if (ret) 614 if (ret)
615 goto out; 615 goto out;
@@ -698,7 +698,7 @@ static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
698 698
699 range->num_frequency = 0; 699 range->num_frequency = 0;
700 if (priv->adapter->enable11d && 700 if (priv->adapter->enable11d &&
701 adapter->connect_status == libertas_connected) { 701 adapter->connect_status == LIBERTAS_CONNECTED) {
702 u8 chan_no; 702 u8 chan_no;
703 u8 band; 703 u8 band;
704 704
@@ -858,9 +858,9 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
858 */ 858 */
859 859
860 if (vwrq->disabled) { 860 if (vwrq->disabled) {
861 adapter->psmode = wlan802_11powermodecam; 861 adapter->psmode = WLAN802_11POWERMODECAM;
862 if (adapter->psstate != PS_STATE_FULL_POWER) { 862 if (adapter->psstate != PS_STATE_FULL_POWER) {
863 libertas_ps_wakeup(priv, cmd_option_waitforrsp); 863 libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
864 } 864 }
865 865
866 return 0; 866 return 0;
@@ -875,14 +875,14 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
875 return -EINVAL; 875 return -EINVAL;
876 } 876 }
877 877
878 if (adapter->psmode != wlan802_11powermodecam) { 878 if (adapter->psmode != WLAN802_11POWERMODECAM) {
879 return 0; 879 return 0;
880 } 880 }
881 881
882 adapter->psmode = wlan802_11powermodemax_psp; 882 adapter->psmode = WLAN802_11POWERMODEMAX_PSP;
883 883
884 if (adapter->connect_status == libertas_connected) { 884 if (adapter->connect_status == LIBERTAS_CONNECTED) {
885 libertas_ps_sleep(priv, cmd_option_waitforrsp); 885 libertas_ps_sleep(priv, CMD_OPTION_WAITFORRSP);
886 } 886 }
887 887
888 lbs_deb_leave(LBS_DEB_WEXT); 888 lbs_deb_leave(LBS_DEB_WEXT);
@@ -900,8 +900,8 @@ static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
900 900
901 mode = adapter->psmode; 901 mode = adapter->psmode;
902 902
903 if ((vwrq->disabled = (mode == wlan802_11powermodecam)) 903 if ((vwrq->disabled = (mode == WLAN802_11POWERMODECAM))
904 || adapter->connect_status == libertas_disconnected) 904 || adapter->connect_status == LIBERTAS_DISCONNECTED)
905 { 905 {
906 goto out; 906 goto out;
907 } 907 }
@@ -937,7 +937,7 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
937 priv->wstats.status = adapter->mode; 937 priv->wstats.status = adapter->mode;
938 938
939 /* If we're not associated, all quality values are meaningless */ 939 /* If we're not associated, all quality values are meaningless */
940 if (adapter->connect_status != libertas_connected) 940 if (adapter->connect_status != LIBERTAS_CONNECTED)
941 goto out; 941 goto out;
942 942
943 /* Quality by RSSI */ 943 /* Quality by RSSI */
@@ -1000,9 +1000,9 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
1000 stats_valid = 1; 1000 stats_valid = 1;
1001 1001
1002 /* update stats asynchronously for future calls */ 1002 /* update stats asynchronously for future calls */
1003 libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0, 1003 libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
1004 0, 0, NULL); 1004 0, 0, NULL);
1005 libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0, 1005 libertas_prepare_and_send_command(priv, CMD_802_11_GET_LOG, 0,
1006 0, 0, NULL); 1006 0, 0, NULL);
1007out: 1007out:
1008 if (!stats_valid) { 1008 if (!stats_valid) {
@@ -1128,7 +1128,7 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1128 lbs_deb_wext("vwrq->value %d\n", vwrq->value); 1128 lbs_deb_wext("vwrq->value %d\n", vwrq->value);
1129 1129
1130 if (vwrq->value == -1) { 1130 if (vwrq->value == -1) {
1131 action = cmd_act_set_tx_auto; // Auto 1131 action = CMD_ACT_SET_tx_auto; // Auto
1132 adapter->is_datarate_auto = 1; 1132 adapter->is_datarate_auto = 1;
1133 adapter->datarate = 0; 1133 adapter->datarate = 0;
1134 } else { 1134 } else {
@@ -1155,12 +1155,12 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1155 } 1155 }
1156 1156
1157 adapter->datarate = data_rate; 1157 adapter->datarate = data_rate;
1158 action = cmd_act_set_tx_fix_rate; 1158 action = CMD_ACT_SET_tx_fix_rate;
1159 adapter->is_datarate_auto = 0; 1159 adapter->is_datarate_auto = 0;
1160 } 1160 }
1161 1161
1162 ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate, 1162 ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
1163 action, cmd_option_waitforrsp, 0, NULL); 1163 action, CMD_OPTION_WAITFORRSP, 0, NULL);
1164 1164
1165 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 1165 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1166 return ret; 1166 return ret;
@@ -1976,7 +1976,7 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
1976 return 0; 1976 return 0;
1977 } 1977 }
1978 1978
1979 adapter->preamble = cmd_type_auto_preamble; 1979 adapter->preamble = CMD_TYPE_AUTO_PREAMBLE;
1980 1980
1981 wlan_radio_ioctl(priv, RADIO_ON); 1981 wlan_radio_ioctl(priv, RADIO_ON);
1982 1982
@@ -1993,9 +1993,9 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
1993 lbs_deb_wext("txpower set %d dbm\n", dbm); 1993 lbs_deb_wext("txpower set %d dbm\n", dbm);
1994 1994
1995 ret = libertas_prepare_and_send_command(priv, 1995 ret = libertas_prepare_and_send_command(priv,
1996 cmd_802_11_rf_tx_power, 1996 CMD_802_11_RF_TX_POWER,
1997 cmd_act_tx_power_opt_set_low, 1997 CMD_ACT_TX_POWER_OPT_SET_LOW,
1998 cmd_option_waitforrsp, 0, (void *)&dbm); 1998 CMD_OPTION_WAITFORRSP, 0, (void *)&dbm);
1999 1999
2000 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 2000 lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
2001 return ret; 2001 return ret;
@@ -2017,7 +2017,7 @@ static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
2017 /* 2017 /*
2018 * Get the current SSID 2018 * Get the current SSID
2019 */ 2019 */
2020 if (adapter->connect_status == libertas_connected) { 2020 if (adapter->connect_status == LIBERTAS_CONNECTED) {
2021 memcpy(extra, adapter->curbssparams.ssid, 2021 memcpy(extra, adapter->curbssparams.ssid,
2022 adapter->curbssparams.ssid_len); 2022 adapter->curbssparams.ssid_len);
2023 extra[adapter->curbssparams.ssid_len] = '\0'; 2023 extra[adapter->curbssparams.ssid_len] = '\0';
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-29 01:33:01 -0400