]> err.no Git - linux-2.6/commitdiff
[PATCH] libertas: re-uppercase command defines and other constants
authorDan Williams <dcbw@redhat.com>
Thu, 2 Aug 2007 15:31:18 +0000 (11:31 -0400)
committerDavid S. Miller <davem@sunset.davemloft.net>
Wed, 10 Oct 2007 23:49:43 +0000 (16:49 -0700)
For readability.

Signed-off-by: Dan Williams <dcbw@redhat.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
16 files changed:
drivers/net/wireless/libertas/11d.c
drivers/net/wireless/libertas/assoc.c
drivers/net/wireless/libertas/cmd.c
drivers/net/wireless/libertas/cmdresp.c
drivers/net/wireless/libertas/debugfs.c
drivers/net/wireless/libertas/defs.h
drivers/net/wireless/libertas/ethtool.c
drivers/net/wireless/libertas/fw.c
drivers/net/wireless/libertas/host.h
drivers/net/wireless/libertas/hostcmd.h
drivers/net/wireless/libertas/if_usb.c
drivers/net/wireless/libertas/join.c
drivers/net/wireless/libertas/main.c
drivers/net/wireless/libertas/scan.c
drivers/net/wireless/libertas/tx.c
drivers/net/wireless/libertas/wext.c

index 4cf0ff7b833d6e77d6c99e5ba36c066f1b61b037..26d85ec37d9e4eab8e3a575159e41bdd33a3d917 100644 (file)
@@ -422,13 +422,13 @@ done:
 u8 libertas_get_scan_type_11d(u8 chan,
                          struct parsed_region_chan_11d * parsed_region_chan)
 {
-       u8 scan_type = cmd_scan_type_passive;
+       u8 scan_type = CMD_SCAN_TYPE_PASSIVE;
 
        lbs_deb_enter(LBS_DEB_11D);
 
        if (wlan_channel_known_11d(chan, parsed_region_chan)) {
                lbs_deb_11d("11D: Found and do Active Scan\n");
-               scan_type = cmd_scan_type_active;
+               scan_type = CMD_SCAN_TYPE_ACTIVE;
        } else {
                lbs_deb_11d("11D: Not Find and do Passive Scan\n");
        }
@@ -454,9 +454,9 @@ static int wlan_enable_11d(wlan_private * priv, u8 flag)
 
        /* send cmd to FW to enable/disable 11D function in FW */
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_snmp_mib,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp,
+                                   CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP,
                                    OID_802_11D_ENABLE,
                                    &priv->adapter->enable11d);
        if (ret)
@@ -479,9 +479,9 @@ static int set_domain_info_11d(wlan_private * priv)
                return 0;
        }
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11d_domain_info,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11D_DOMAIN_INFO,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
        if (ret)
                lbs_deb_11d("11D: Fail to dnld domain Info\n");
 
@@ -541,7 +541,7 @@ int libertas_cmd_802_11d_domain_info(wlan_private * priv,
 
        cmd->command = cpu_to_le16(cmdno);
        pdomaininfo->action = cpu_to_le16(cmdoption);
-       if (cmdoption == cmd_act_get) {
+       if (cmdoption == CMD_ACT_GET) {
                cmd->size =
                    cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);
                lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd,
@@ -633,10 +633,10 @@ int libertas_ret_802_11d_domain_info(wlan_private * priv,
        }
 
        switch (action) {
-       case cmd_act_set:       /*Proc Set action */
+       case CMD_ACT_SET:       /*Proc Set action */
                break;
 
-       case cmd_act_get:
+       case CMD_ACT_GET:
                break;
        default:
                lbs_deb_11d("Invalid action:%d\n", domaininfo->action);
index 36586db3e1f7cd59ceeb7574c7e713be110f4fed..5fdc96f289b83cfab6ee45d453ff62403f917cf8 100644 (file)
@@ -175,14 +175,14 @@ static int assoc_helper_mode(wlan_private *priv,
 
        if (assoc_req->mode == IW_MODE_INFRA) {
                if (adapter->psstate != PS_STATE_FULL_POWER)
-                       libertas_ps_wakeup(priv, cmd_option_waitforrsp);
-               adapter->psmode = wlan802_11powermodecam;
+                       libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
+               adapter->psmode = WLAN802_11POWERMODECAM;
        }
 
        adapter->mode = assoc_req->mode;
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_snmp_mib,
-                                   0, cmd_option_waitforrsp,
+                                   CMD_802_11_SNMP_MIB,
+                                   0, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_INFRASTRUCTURE_MODE,
                /* Shoot me now */  (void *) (size_t) assoc_req->mode);
 
@@ -195,9 +195,9 @@ done:
 static int update_channel(wlan_private * priv)
 {
        /* the channel in f/w could be out of sync, get the current channel */
-       return libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
-                                   cmd_opt_802_11_rf_channel_get,
-                                   cmd_option_waitforrsp, 0, NULL);
+       return libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
+                                   CMD_OPT_802_11_RF_CHANNEL_GET,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
 }
 
 void libertas_sync_channel(struct work_struct *work)
@@ -227,9 +227,9 @@ static int assoc_helper_channel(wlan_private *priv,
        lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
               adapter->curbssparams.channel, assoc_req->channel);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
-                               cmd_opt_802_11_rf_channel_set,
-                               cmd_option_waitforrsp, 0, &assoc_req->channel);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
+                               CMD_OPT_802_11_RF_CHANNEL_SET,
+                               CMD_OPTION_WAITFORRSP, 0, &assoc_req->channel);
        if (ret < 0) {
                lbs_deb_assoc("ASSOC: channel: error setting channel.");
        }
@@ -278,15 +278,15 @@ static int assoc_helper_wep_keys(wlan_private *priv,
            || assoc_req->wep_keys[2].len
            || assoc_req->wep_keys[3].len) {
                ret = libertas_prepare_and_send_command(priv,
-                                           cmd_802_11_set_wep,
-                                           cmd_act_add,
-                                           cmd_option_waitforrsp,
+                                           CMD_802_11_SET_WEP,
+                                           CMD_ACT_ADD,
+                                           CMD_OPTION_WAITFORRSP,
                                            0, assoc_req);
        } else {
                ret = libertas_prepare_and_send_command(priv,
-                                           cmd_802_11_set_wep,
-                                           cmd_act_remove,
-                                           cmd_option_waitforrsp,
+                                           CMD_802_11_SET_WEP,
+                                           CMD_ACT_REMOVE,
+                                           CMD_OPTION_WAITFORRSP,
                                            0, NULL);
        }
 
@@ -295,9 +295,9 @@ static int assoc_helper_wep_keys(wlan_private *priv,
 
        /* enable/disable the MAC's WEP packet filter */
        if (assoc_req->secinfo.wep_enabled)
-               adapter->currentpacketfilter |= cmd_act_mac_wep_enable;
+               adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
        else
-               adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable;
+               adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
        ret = libertas_set_mac_packet_filter(priv);
        if (ret)
                goto out;
@@ -342,9 +342,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
 
        /* Get RSN enabled/disabled */
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_enable_rsn,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp,
+                                   CMD_802_11_ENABLE_RSN,
+                                   CMD_ACT_GET,
+                                   CMD_OPTION_WAITFORRSP,
                                    0, &rsn);
        if (ret) {
                lbs_deb_assoc("Failed to get RSN status: %d", ret);
@@ -359,9 +359,9 @@ static int assoc_helper_secinfo(wlan_private *priv,
        /* Set RSN enabled/disabled */
        rsn = do_wpa;
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_enable_rsn,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp,
+                                   CMD_802_11_ENABLE_RSN,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP,
                                    0, &rsn);
 
 out:
@@ -378,9 +378,9 @@ static int assoc_helper_wpa_keys(wlan_private *priv,
        lbs_deb_enter(LBS_DEB_ASSOC);
 
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_key_material,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp,
+                                   CMD_802_11_KEY_MATERIAL,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP,
                                    0, assoc_req);
 
        lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@@ -412,7 +412,7 @@ static int assoc_helper_wpa_ie(wlan_private *priv,
 static int should_deauth_infrastructure(wlan_adapter *adapter,
                                         struct assoc_request * assoc_req)
 {
-       if (adapter->connect_status != libertas_connected)
+       if (adapter->connect_status != LIBERTAS_CONNECTED)
                return 0;
 
        if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
@@ -453,7 +453,7 @@ static int should_deauth_infrastructure(wlan_adapter *adapter,
 static int should_stop_adhoc(wlan_adapter *adapter,
                              struct assoc_request * assoc_req)
 {
-       if (adapter->connect_status != libertas_connected)
+       if (adapter->connect_status != LIBERTAS_CONNECTED)
                return 0;
 
        if (libertas_ssid_cmp(adapter->curbssparams.ssid,
@@ -623,7 +623,7 @@ void libertas_association_worker(struct work_struct *work)
                        success = 0;
                }
 
-               if (adapter->connect_status != libertas_connected) {
+               if (adapter->connect_status != LIBERTAS_CONNECTED) {
                        lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, "
                                "not connected.\n");
                        success = 0;
@@ -636,12 +636,12 @@ void libertas_association_worker(struct work_struct *work)
                                             adapter->curbssparams.ssid_len),
                                MAC_ARG(adapter->curbssparams.bssid));
                        libertas_prepare_and_send_command(priv,
-                               cmd_802_11_rssi,
-                               0, cmd_option_waitforrsp, 0, NULL);
+                               CMD_802_11_RSSI,
+                               0, CMD_OPTION_WAITFORRSP, 0, NULL);
 
                        libertas_prepare_and_send_command(priv,
-                               cmd_802_11_get_log,
-                               0, cmd_option_waitforrsp, 0, NULL);
+                               CMD_802_11_GET_LOG,
+                               0, CMD_OPTION_WAITFORRSP, 0, NULL);
                } else {
                        ret = -1;
                }
index 355a3960323b9569759240a0a7943839cd9a827b..e0eab6e3a9b0a30910c4959121d72104d94814af 100644 (file)
@@ -15,7 +15,7 @@
 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode);
 
 static u16 commands_allowed_in_ps[] = {
-       cmd_802_11_rssi,
+       CMD_802_11_RSSI,
 };
 
 /**
@@ -43,7 +43,7 @@ static int wlan_cmd_hw_spec(wlan_private * priv, struct cmd_ds_command *cmd)
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_get_hw_spec);
+       cmd->command = cpu_to_le16(CMD_GET_HW_SPEC);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN);
        memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN);
 
@@ -60,13 +60,13 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_802_11_ps_mode);
+       cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
                                S_DS_GEN);
        psm->action = cpu_to_le16(cmd_action);
        psm->multipledtim = 0;
        switch (cmd_action) {
-       case cmd_subcmd_enter_ps:
+       case CMD_SUBCMD_ENTER_PS:
                lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
                lbs_deb_cmd("locallisteninterval = %d\n",
                       adapter->locallisteninterval);
@@ -79,11 +79,11 @@ static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
                    cpu_to_le16(priv->adapter->multipledtim);
                break;
 
-       case cmd_subcmd_exit_ps:
+       case CMD_SUBCMD_EXIT_PS:
                lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
                break;
 
-       case cmd_subcmd_sleep_confirmed:
+       case CMD_SUBCMD_SLEEP_CONFIRMED:
                lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
                break;
 
@@ -101,7 +101,7 @@ static int wlan_cmd_802_11_inactivity_timeout(wlan_private * priv,
 {
        u16 *timeout = pdata_buf;
 
-       cmd->command = cpu_to_le16(cmd_802_11_inactivity_timeout);
+       cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
        cmd->size =
            cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout)
                             + S_DS_GEN);
@@ -127,13 +127,13 @@ static int wlan_cmd_802_11_sleep_params(wlan_private * priv,
 
        cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) +
                                S_DS_GEN);
-       cmd->command = cpu_to_le16(cmd_802_11_sleep_params);
+       cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS);
 
-       if (cmd_action == cmd_act_get) {
+       if (cmd_action == CMD_ACT_GET) {
                memset(&adapter->sp, 0, sizeof(struct sleep_params));
                memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params));
                sp->action = cpu_to_le16(cmd_action);
-       } else if (cmd_action == cmd_act_set) {
+       } else if (cmd_action == CMD_ACT_SET) {
                sp->action = cpu_to_le16(cmd_action);
                sp->error = cpu_to_le16(adapter->sp.sp_error);
                sp->offset = cpu_to_le16(adapter->sp.sp_offset);
@@ -159,10 +159,10 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_802_11_set_wep);
+       cmd->command = cpu_to_le16(CMD_802_11_SET_WEP);
        cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN);
 
-       if (cmd_act == cmd_act_add) {
+       if (cmd_act == CMD_ACT_ADD) {
                int i;
 
                if (!assoc_req) {
@@ -171,11 +171,11 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
                        goto done;
                }
 
-               wep->action = cpu_to_le16(cmd_act_add);
+               wep->action = cpu_to_le16(CMD_ACT_ADD);
 
                /* default tx key index */
                wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx &
-                                                 (u32)cmd_WEP_KEY_INDEX_MASK));
+                                                 (u32)CMD_WEP_KEY_INDEX_MASK));
 
                lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex));
 
@@ -186,13 +186,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
                        switch (pkey->len) {
                        case KEY_LEN_WEP_40:
                                wep->keytype[i] =
-                                       cpu_to_le16(cmd_type_wep_40_bit);
+                                       cpu_to_le16(CMD_TYPE_WEP_40_BIT);
                                memmove(&wep->keymaterial[i], pkey->key,
                                        pkey->len);
                                break;
                        case KEY_LEN_WEP_104:
                                wep->keytype[i] =
-                                       cpu_to_le16(cmd_type_wep_104_bit);
+                                       cpu_to_le16(CMD_TYPE_WEP_104_BIT);
                                memmove(&wep->keymaterial[i], pkey->key,
                                        pkey->len);
                                break;
@@ -206,13 +206,13 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
                                break;
                        }
                }
-       } else if (cmd_act == cmd_act_remove) {
+       } else if (cmd_act == CMD_ACT_REMOVE) {
                /* ACT_REMOVE clears _all_ WEP keys */
-               wep->action = cpu_to_le16(cmd_act_remove);
+               wep->action = cpu_to_le16(CMD_ACT_REMOVE);
 
                /* default tx key index */
                wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx &
-                                                 (u32)cmd_WEP_KEY_INDEX_MASK));
+                                                 (u32)CMD_WEP_KEY_INDEX_MASK));
        }
 
        ret = 0;
@@ -232,15 +232,15 @@ static int wlan_cmd_802_11_enable_rsn(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_802_11_enable_rsn);
+       cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
        cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
        penableRSN->action = cpu_to_le16(cmd_action);
 
-       if (cmd_action == cmd_act_set) {
+       if (cmd_action == CMD_ACT_SET) {
                if (*enable)
-                       penableRSN->enable = cpu_to_le16(cmd_enable_rsn);
+                       penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
                else
-                       penableRSN->enable = cpu_to_le16(cmd_disable_rsn);
+                       penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
        }
 
        lbs_deb_leave(LBS_DEB_CMD);
@@ -284,10 +284,10 @@ static int wlan_cmd_802_11_key_material(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_802_11_key_material);
+       cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
        pkeymaterial->action = cpu_to_le16(cmd_action);
 
-       if (cmd_action == cmd_act_get) {
+       if (cmd_action == CMD_ACT_GET) {
                cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
                ret = 0;
                goto done;
@@ -323,7 +323,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
 {
        struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
 
-       cmd->command = cpu_to_le16(cmd_802_11_reset);
+       cmd->command = cpu_to_le16(CMD_802_11_RESET);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
        reset->action = cpu_to_le16(cmd_action);
 
@@ -333,7 +333,7 @@ static int wlan_cmd_802_11_reset(wlan_private * priv,
 static int wlan_cmd_802_11_get_log(wlan_private * priv,
                                   struct cmd_ds_command *cmd)
 {
-       cmd->command = cpu_to_le16(cmd_802_11_get_log);
+       cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
        cmd->size =
                cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
 
@@ -343,7 +343,7 @@ static int wlan_cmd_802_11_get_log(wlan_private * priv,
 static int wlan_cmd_802_11_get_stat(wlan_private * priv,
                                    struct cmd_ds_command *cmd)
 {
-       cmd->command = cpu_to_le16(cmd_802_11_get_stat);
+       cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
        cmd->size =
            cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
 
@@ -363,15 +363,15 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
 
        lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
 
-       cmd->command = cpu_to_le16(cmd_802_11_snmp_mib);
+       cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
        cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
 
        switch (cmd_oid) {
        case OID_802_11_INFRASTRUCTURE_MODE:
        {
                u8 mode = (u8) (size_t) pdata_buf;
-               pSNMPMIB->querytype = cpu_to_le16(cmd_act_set);
-               pSNMPMIB->oid = cpu_to_le16((u16) desired_bsstype_i);
+               pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
+               pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
                pSNMPMIB->bufsize = sizeof(u8);
                if (mode == IW_MODE_ADHOC) {
                        ucTemp = SNMP_MIB_VALUE_ADHOC;
@@ -389,10 +389,10 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
                {
                        u32 ulTemp;
 
-                       pSNMPMIB->oid = cpu_to_le16((u16) dot11d_i);
+                       pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
 
-                       if (cmd_action == cmd_act_set) {
-                               pSNMPMIB->querytype = cmd_act_set;
+                       if (cmd_action == CMD_ACT_SET) {
+                               pSNMPMIB->querytype = CMD_ACT_SET;
                                pSNMPMIB->bufsize = sizeof(u16);
                                ulTemp = *(u32 *)pdata_buf;
                                *((__le16 *)(pSNMPMIB->value)) =
@@ -405,12 +405,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
                {
                        u32 ulTemp;
 
-                       pSNMPMIB->oid = cpu_to_le16((u16) fragthresh_i);
+                       pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
 
-                       if (cmd_action == cmd_act_get) {
-                               pSNMPMIB->querytype = cpu_to_le16(cmd_act_get);
-                       } else if (cmd_action == cmd_act_set) {
-                               pSNMPMIB->querytype = cpu_to_le16(cmd_act_set);
+                       if (cmd_action == CMD_ACT_GET) {
+                               pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
+                       } else if (cmd_action == CMD_ACT_SET) {
+                               pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
                                pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
                                ulTemp = *((u32 *) pdata_buf);
                                *((__le16 *)(pSNMPMIB->value)) =
@@ -425,12 +425,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
                {
 
                        u32 ulTemp;
-                       pSNMPMIB->oid = le16_to_cpu((u16) rtsthresh_i);
+                       pSNMPMIB->oid = le16_to_cpu((u16) RTSTHRESH_I);
 
-                       if (cmd_action == cmd_act_get) {
-                               pSNMPMIB->querytype = cpu_to_le16(cmd_act_get);
-                       } else if (cmd_action == cmd_act_set) {
-                               pSNMPMIB->querytype = cpu_to_le16(cmd_act_set);
+                       if (cmd_action == CMD_ACT_GET) {
+                               pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
+                       } else if (cmd_action == CMD_ACT_SET) {
+                               pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
                                pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
                                ulTemp = *((u32 *)pdata_buf);
                                *(__le16 *)(pSNMPMIB->value) =
@@ -440,12 +440,12 @@ static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
                        break;
                }
        case OID_802_11_TX_RETRYCOUNT:
-               pSNMPMIB->oid = cpu_to_le16((u16) short_retrylim_i);
+               pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
 
-               if (cmd_action == cmd_act_get) {
-                       pSNMPMIB->querytype = cpu_to_le16(cmd_act_get);
-               } else if (cmd_action == cmd_act_set) {
-                       pSNMPMIB->querytype = cpu_to_le16(cmd_act_set);
+               if (cmd_action == CMD_ACT_GET) {
+                       pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
+               } else if (cmd_action == CMD_ACT_SET) {
+                       pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
                        pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
                        *((__le16 *)(pSNMPMIB->value)) =
                            cpu_to_le16((u16) adapter->txretrycount);
@@ -483,20 +483,20 @@ static int wlan_cmd_802_11_radio_control(wlan_private * priv,
        cmd->size =
            cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) +
                             S_DS_GEN);
-       cmd->command = cpu_to_le16(cmd_802_11_radio_control);
+       cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL);
 
        pradiocontrol->action = cpu_to_le16(cmd_action);
 
        switch (adapter->preamble) {
-       case cmd_type_short_preamble:
+       case CMD_TYPE_SHORT_PREAMBLE:
                pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE);
                break;
 
-       case cmd_type_long_preamble:
+       case CMD_TYPE_LONG_PREAMBLE:
                pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE);
                break;
 
-       case cmd_type_auto_preamble:
+       case CMD_TYPE_AUTO_PREAMBLE:
        default:
                pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE);
                break;
@@ -522,7 +522,7 @@ static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
 
        cmd->size =
            cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
-       cmd->command = cpu_to_le16(cmd_802_11_rf_tx_power);
+       cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
        prtp->action = cpu_to_le16(cmd_action);
 
        lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
@@ -530,23 +530,23 @@ static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
                    le16_to_cpu(prtp->action));
 
        switch (cmd_action) {
-       case cmd_act_tx_power_opt_get:
-               prtp->action = cpu_to_le16(cmd_act_get);
+       case CMD_ACT_TX_POWER_OPT_GET:
+               prtp->action = cpu_to_le16(CMD_ACT_GET);
                prtp->currentlevel = 0;
                break;
 
-       case cmd_act_tx_power_opt_set_high:
-               prtp->action = cpu_to_le16(cmd_act_set);
-               prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_high);
+       case CMD_ACT_TX_POWER_OPT_SET_HIGH:
+               prtp->action = cpu_to_le16(CMD_ACT_SET);
+               prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
                break;
 
-       case cmd_act_tx_power_opt_set_mid:
-               prtp->action = cpu_to_le16(cmd_act_set);
-               prtp->currentlevel = cpu_to_le16(cmd_act_tx_power_index_mid);
+       case CMD_ACT_TX_POWER_OPT_SET_MID:
+               prtp->action = cpu_to_le16(CMD_ACT_SET);
+               prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
                break;
 
-       case cmd_act_tx_power_opt_set_low:
-               prtp->action = cpu_to_le16(cmd_act_set);
+       case CMD_ACT_TX_POWER_OPT_SET_LOW:
+               prtp->action = cpu_to_le16(CMD_ACT_SET);
                prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
                break;
        }
@@ -561,12 +561,12 @@ static int wlan_cmd_802_11_rf_antenna(wlan_private * priv,
 {
        struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant;
 
-       cmd->command = cpu_to_le16(cmd_802_11_rf_antenna);
+       cmd->command = cpu_to_le16(CMD_802_11_RF_ANTENNA);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) +
                                S_DS_GEN);
 
        rant->action = cpu_to_le16(cmd_action);
-       if ((cmd_action == cmd_act_set_rx) || (cmd_action == cmd_act_set_tx)) {
+       if ((cmd_action == CMD_ACT_SET_rx) || (cmd_action == CMD_ACT_SET_tx)) {
                rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf));
        }
 
@@ -584,7 +584,7 @@ static int wlan_cmd_802_11_rate_adapt_rateset(wlan_private * priv,
        cmd->size =
            cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
                             + S_DS_GEN);
-       cmd->command = cpu_to_le16(cmd_802_11_rate_adapt_rateset);
+       cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
 
        lbs_deb_enter(LBS_DEB_CMD);
 
@@ -608,17 +608,17 @@ static int wlan_cmd_802_11_data_rate(wlan_private * priv,
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) +
                             S_DS_GEN);
 
-       cmd->command = cpu_to_le16(cmd_802_11_data_rate);
+       cmd->command = cpu_to_le16(CMD_802_11_DATA_RATE);
 
        memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate));
 
        pdatarate->action = cpu_to_le16(cmd_action);
 
-       if (cmd_action == cmd_act_set_tx_fix_rate) {
+       if (cmd_action == CMD_ACT_SET_tx_fix_rate) {
                pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate);
                lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n",
                       adapter->datarate);
-       } else if (cmd_action == cmd_act_set_tx_auto) {
+       } else if (cmd_action == CMD_ACT_SET_tx_auto) {
                lbs_deb_cmd("Setting FW for AUTO rate\n");
        }
 
@@ -635,7 +635,7 @@ static int wlan_cmd_mac_multicast_adr(wlan_private * priv,
 
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
                             S_DS_GEN);
-       cmd->command = cpu_to_le16(cmd_mac_multicast_adr);
+       cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
 
        pMCastAdr->action = cpu_to_le16(cmd_action);
        pMCastAdr->nr_of_adrs =
@@ -652,11 +652,11 @@ static int wlan_cmd_802_11_rf_channel(wlan_private * priv,
 {
        struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel;
 
-       cmd->command = cpu_to_le16(cmd_802_11_rf_channel);
+       cmd->command = cpu_to_le16(CMD_802_11_RF_CHANNEL);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) +
                                S_DS_GEN);
 
-       if (option == cmd_opt_802_11_rf_channel_set) {
+       if (option == CMD_OPT_802_11_RF_CHANNEL_SET) {
                rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf));
        }
 
@@ -670,7 +670,7 @@ static int wlan_cmd_802_11_rssi(wlan_private * priv,
 {
        wlan_adapter *adapter = priv->adapter;
 
-       cmd->command = cpu_to_le16(cmd_802_11_rssi);
+       cmd->command = cpu_to_le16(CMD_802_11_RSSI);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
        cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor);
 
@@ -696,7 +696,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
        offval = (struct wlan_offset_value *)pdata_buf;
 
        switch (cmdptr->command) {
-       case cmd_mac_reg_access:
+       case CMD_MAC_REG_ACCESS:
                {
                        struct cmd_ds_mac_reg_access *macreg;
 
@@ -714,7 +714,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
                        break;
                }
 
-       case cmd_bbp_reg_access:
+       case CMD_BBP_REG_ACCESS:
                {
                        struct cmd_ds_bbp_reg_access *bbpreg;
 
@@ -733,7 +733,7 @@ static int wlan_cmd_reg_access(wlan_private * priv,
                        break;
                }
 
-       case cmd_rf_reg_access:
+       case CMD_RF_REG_ACCESS:
                {
                        struct cmd_ds_rf_reg_access *rfreg;
 
@@ -766,14 +766,14 @@ static int wlan_cmd_802_11_mac_address(wlan_private * priv,
 {
        wlan_adapter *adapter = priv->adapter;
 
-       cmd->command = cpu_to_le16(cmd_802_11_mac_address);
+       cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
                             S_DS_GEN);
        cmd->result = 0;
 
        cmd->params.macadd.action = cpu_to_le16(cmd_action);
 
-       if (cmd_action == cmd_act_set) {
+       if (cmd_action == CMD_ACT_SET) {
                memcpy(cmd->params.macadd.macadd,
                       adapter->current_addr, ETH_ALEN);
                lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6);
@@ -790,7 +790,7 @@ static int wlan_cmd_802_11_eeprom_access(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_802_11_eeprom_access);
+       cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
                                S_DS_GEN);
        cmd->result = 0;
@@ -810,29 +810,29 @@ static int wlan_cmd_bt_access(wlan_private * priv,
        struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
        lbs_deb_cmd("BT CMD(%d)\n", cmd_action);
 
-       cmd->command = cpu_to_le16(cmd_bt_access);
+       cmd->command = cpu_to_le16(CMD_BT_ACCESS);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
        cmd->result = 0;
        bt_access->action = cpu_to_le16(cmd_action);
 
        switch (cmd_action) {
-       case cmd_act_bt_access_add:
+       case CMD_ACT_BT_ACCESS_ADD:
                memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
                lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6);
                break;
-       case cmd_act_bt_access_del:
+       case CMD_ACT_BT_ACCESS_DEL:
                memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
                lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6);
                break;
-       case cmd_act_bt_access_list:
+       case CMD_ACT_BT_ACCESS_LIST:
                bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
                break;
-       case cmd_act_bt_access_reset:
+       case CMD_ACT_BT_ACCESS_RESET:
                break;
-       case cmd_act_bt_access_set_invert:
+       case CMD_ACT_BT_ACCESS_SET_INVERT:
                bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
                break;
-       case cmd_act_bt_access_get_invert:
+       case CMD_ACT_BT_ACCESS_GET_INVERT:
                break;
        default:
                break;
@@ -847,7 +847,7 @@ static int wlan_cmd_fwt_access(wlan_private * priv,
        struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
        lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
 
-       cmd->command = cpu_to_le16(cmd_fwt_access);
+       cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
        cmd->result = 0;
 
@@ -868,7 +868,7 @@ static int wlan_cmd_mesh_access(wlan_private * priv,
        struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh;
        lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
 
-       cmd->command = cpu_to_le16(cmd_mesh_access);
+       cmd->command = cpu_to_le16(CMD_MESH_ACCESS);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN);
        cmd->result = 0;
 
@@ -901,9 +901,9 @@ void libertas_queue_cmd(wlan_adapter * adapter, struct cmd_ctrl_node *cmdnode, u
        }
 
        /* Exit_PS command needs to be queued in the header always. */
-       if (cmdptr->command == cmd_802_11_ps_mode) {
+       if (cmdptr->command == CMD_802_11_PS_MODE) {
                struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode;
-               if (psm->action == cpu_to_le16(cmd_subcmd_exit_ps)) {
+               if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
                        if (adapter->psstate != PS_STATE_FULL_POWER)
                                addtail = 0;
                }
@@ -1000,8 +1000,8 @@ static int DownloadcommandToStation(wlan_private * priv,
        lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize);
 
        /* Setup the timer after transmit command */
-       if (command == cmd_802_11_scan || command == cmd_802_11_authenticate
-           || command == cmd_802_11_associate)
+       if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE
+           || command == CMD_802_11_ASSOCIATE)
                mod_timer(&adapter->command_timer, jiffies + (10*HZ));
        else
                mod_timer(&adapter->command_timer, jiffies + (5*HZ));
@@ -1020,7 +1020,7 @@ static int wlan_cmd_mac_control(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       cmd->command = cpu_to_le16(cmd_mac_control);
+       cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
        mac->action = cpu_to_le16(priv->adapter->currentpacketfilter);
 
@@ -1064,9 +1064,9 @@ int libertas_set_radio_control(wlan_private * priv)
        lbs_deb_enter(LBS_DEB_CMD);
 
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_radio_control,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp, 0, NULL);
+                                   CMD_802_11_RADIO_CONTROL,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
 
        lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n",
               priv->adapter->radioon, priv->adapter->preamble);
@@ -1086,7 +1086,7 @@ int libertas_set_mac_packet_filter(wlan_private * priv)
 
        /* Send MAC control command to station */
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_mac_control, 0, 0, 0, NULL);
+                                   CMD_MAC_CONTROL, 0, 0, 0, NULL);
 
        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
        return ret;
@@ -1161,136 +1161,136 @@ int libertas_prepare_and_send_command(wlan_private * priv,
        cmdptr->result = 0;
 
        switch (cmd_no) {
-       case cmd_get_hw_spec:
+       case CMD_GET_HW_SPEC:
                ret = wlan_cmd_hw_spec(priv, cmdptr);
                break;
-       case cmd_802_11_ps_mode:
+       case CMD_802_11_PS_MODE:
                ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
                break;
 
-       case cmd_802_11_scan:
+       case CMD_802_11_SCAN:
                ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf);
                break;
 
-       case cmd_mac_control:
+       case CMD_MAC_CONTROL:
                ret = wlan_cmd_mac_control(priv, cmdptr);
                break;
 
-       case cmd_802_11_associate:
-       case cmd_802_11_reassociate:
+       case CMD_802_11_ASSOCIATE:
+       case CMD_802_11_REASSOCIATE:
                ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf);
                break;
 
-       case cmd_802_11_deauthenticate:
+       case CMD_802_11_DEAUTHENTICATE:
                ret = libertas_cmd_80211_deauthenticate(priv, cmdptr);
                break;
 
-       case cmd_802_11_set_wep:
+       case CMD_802_11_SET_WEP:
                ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_ad_hoc_start:
+       case CMD_802_11_AD_HOC_START:
                ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
                break;
-       case cmd_code_dnld:
+       case CMD_CODE_DNLD:
                break;
 
-       case cmd_802_11_reset:
+       case CMD_802_11_RESET:
                ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action);
                break;
 
-       case cmd_802_11_get_log:
+       case CMD_802_11_GET_LOG:
                ret = wlan_cmd_802_11_get_log(priv, cmdptr);
                break;
 
-       case cmd_802_11_authenticate:
+       case CMD_802_11_AUTHENTICATE:
                ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
                break;
 
-       case cmd_802_11_get_stat:
+       case CMD_802_11_GET_STAT:
                ret = wlan_cmd_802_11_get_stat(priv, cmdptr);
                break;
 
-       case cmd_802_11_snmp_mib:
+       case CMD_802_11_SNMP_MIB:
                ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr,
                                               cmd_action, cmd_oid, pdata_buf);
                break;
 
-       case cmd_mac_reg_access:
-       case cmd_bbp_reg_access:
-       case cmd_rf_reg_access:
+       case CMD_MAC_REG_ACCESS:
+       case CMD_BBP_REG_ACCESS:
+       case CMD_RF_REG_ACCESS:
                ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_rf_channel:
+       case CMD_802_11_RF_CHANNEL:
                ret = wlan_cmd_802_11_rf_channel(priv, cmdptr,
                                                 cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_rf_tx_power:
+       case CMD_802_11_RF_TX_POWER:
                ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr,
                                                  cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_radio_control:
+       case CMD_802_11_RADIO_CONTROL:
                ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action);
                break;
 
-       case cmd_802_11_rf_antenna:
+       case CMD_802_11_RF_ANTENNA:
                ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr,
                                                 cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_data_rate:
+       case CMD_802_11_DATA_RATE:
                ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action);
                break;
-       case cmd_802_11_rate_adapt_rateset:
+       case CMD_802_11_RATE_ADAPT_RATESET:
                ret = wlan_cmd_802_11_rate_adapt_rateset(priv,
                                                         cmdptr, cmd_action);
                break;
 
-       case cmd_mac_multicast_adr:
+       case CMD_MAC_MULTICAST_ADR:
                ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
                break;
 
-       case cmd_802_11_ad_hoc_join:
+       case CMD_802_11_AD_HOC_JOIN:
                ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
                break;
 
-       case cmd_802_11_rssi:
+       case CMD_802_11_RSSI:
                ret = wlan_cmd_802_11_rssi(priv, cmdptr);
                break;
 
-       case cmd_802_11_ad_hoc_stop:
+       case CMD_802_11_AD_HOC_STOP:
                ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr);
                break;
 
-       case cmd_802_11_enable_rsn:
+       case CMD_802_11_ENABLE_RSN:
                ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
                                pdata_buf);
                break;
 
-       case cmd_802_11_key_material:
+       case CMD_802_11_KEY_MATERIAL:
                ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action,
                                cmd_oid, pdata_buf);
                break;
 
-       case cmd_802_11_pairwise_tsc:
+       case CMD_802_11_PAIRWISE_TSC:
                break;
-       case cmd_802_11_group_tsc:
+       case CMD_802_11_GROUP_TSC:
                break;
 
-       case cmd_802_11_mac_address:
+       case CMD_802_11_MAC_ADDRESS:
                ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
                break;
 
-       case cmd_802_11_eeprom_access:
+       case CMD_802_11_EEPROM_ACCESS:
                ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr,
                                                    cmd_action, pdata_buf);
                break;
 
-       case cmd_802_11_set_afc:
-       case cmd_802_11_get_afc:
+       case CMD_802_11_SET_AFC:
+       case CMD_802_11_GET_AFC:
 
                cmdptr->command = cpu_to_le16(cmd_no);
                cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
@@ -1302,22 +1302,22 @@ int libertas_prepare_and_send_command(wlan_private * priv,
                ret = 0;
                goto done;
 
-       case cmd_802_11d_domain_info:
+       case CMD_802_11D_DOMAIN_INFO:
                ret = libertas_cmd_802_11d_domain_info(priv, cmdptr,
                                                   cmd_no, cmd_action);
                break;
 
-       case cmd_802_11_sleep_params:
+       case CMD_802_11_SLEEP_PARAMS:
                ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action);
                break;
-       case cmd_802_11_inactivity_timeout:
+       case CMD_802_11_INACTIVITY_TIMEOUT:
                ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr,
                                                         cmd_action, pdata_buf);
                libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf);
                break;
 
-       case cmd_802_11_tpc_cfg:
-               cmdptr->command = cpu_to_le16(cmd_802_11_tpc_cfg);
+       case CMD_802_11_TPC_CFG:
+               cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
                cmdptr->size =
                    cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
                                     S_DS_GEN);
@@ -1327,7 +1327,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
 
                ret = 0;
                break;
-       case cmd_802_11_led_gpio_ctrl:
+       case CMD_802_11_LED_GPIO_CTRL:
                {
                        struct mrvlietypes_ledgpio *gpio =
                            (struct mrvlietypes_ledgpio*)
@@ -1338,7 +1338,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
                                sizeof(struct cmd_ds_802_11_led_ctrl));
 
                        cmdptr->command =
-                           cpu_to_le16(cmd_802_11_led_gpio_ctrl);
+                           cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
 
 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
                        cmdptr->size =
@@ -1349,8 +1349,8 @@ int libertas_prepare_and_send_command(wlan_private * priv,
                        ret = 0;
                        break;
                }
-       case cmd_802_11_pwr_cfg:
-               cmdptr->command = cpu_to_le16(cmd_802_11_pwr_cfg);
+       case CMD_802_11_PWR_CFG:
+               cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
                cmdptr->size =
                    cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
                                     S_DS_GEN);
@@ -1359,26 +1359,26 @@ int libertas_prepare_and_send_command(wlan_private * priv,
 
                ret = 0;
                break;
-       case cmd_bt_access:
+       case CMD_BT_ACCESS:
                ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
                break;
 
-       case cmd_fwt_access:
+       case CMD_FWT_ACCESS:
                ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
                break;
 
-       case cmd_mesh_access:
+       case CMD_MESH_ACCESS:
                ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf);
                break;
 
-       case cmd_get_tsf:
-               cmdptr->command = cpu_to_le16(cmd_get_tsf);
+       case CMD_GET_TSF:
+               cmdptr->command = cpu_to_le16(CMD_GET_TSF);
                cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
                                           S_DS_GEN);
                ret = 0;
                break;
-       case cmd_802_11_tx_rate_query:
-               cmdptr->command = cpu_to_le16(cmd_802_11_tx_rate_query);
+       case CMD_802_11_TX_RATE_QUERY:
+               cmdptr->command = cpu_to_le16(CMD_802_11_TX_RATE_QUERY);
                cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) +
                                           S_DS_GEN);
                adapter->txrate = 0;
@@ -1404,7 +1404,7 @@ int libertas_prepare_and_send_command(wlan_private * priv,
        adapter->nr_cmd_pending++;
        wake_up_interruptible(&priv->mainthread.waitq);
 
-       if (wait_option & cmd_option_waitforrsp) {
+       if (wait_option & CMD_OPTION_WAITFORRSP) {
                lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
                might_sleep();
                wait_event_interruptible(cmdnode->cmdwait_q,
@@ -1680,7 +1680,7 @@ int libertas_execute_next_command(wlan_private * priv)
                         * immediately.
                         */
                        if (cmdptr->command !=
-                           cpu_to_le16(cmd_802_11_ps_mode)) {
+                           cpu_to_le16(CMD_802_11_PS_MODE)) {
                                /*  Prepare to send Exit PS,
                                 *  this non PS command will be sent later */
                                if ((adapter->psstate == PS_STATE_SLEEP)
@@ -1706,7 +1706,7 @@ int libertas_execute_next_command(wlan_private * priv)
                                       "EXEC_NEXT_CMD: PS cmd- action=0x%x\n",
                                       psm->action);
                                if (psm->action !=
-                                   cpu_to_le16(cmd_subcmd_exit_ps)) {
+                                   cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
                                        lbs_deb_cmd(
                                               "EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
                                        list_del((struct list_head *)cmdnode);
@@ -1741,9 +1741,9 @@ int libertas_execute_next_command(wlan_private * priv)
                 * check if in power save mode, if yes, put the device back
                 * to PS mode
                 */
-               if ((adapter->psmode != wlan802_11powermodecam) &&
+               if ((adapter->psmode != WLAN802_11POWERMODECAM) &&
                    (adapter->psstate == PS_STATE_FULL_POWER) &&
-                   (adapter->connect_status == libertas_connected)) {
+                   (adapter->connect_status == LIBERTAS_CONNECTED)) {
                        if (adapter->secinfo.WPAenabled ||
                            adapter->secinfo.WPA2enabled) {
                                /* check for valid WPA group keys */
@@ -1845,8 +1845,8 @@ void libertas_ps_sleep(wlan_private * priv, int wait_option)
         * Remove this check if it is to be supported in IBSS mode also
         */
 
-       libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode,
-                             cmd_subcmd_enter_ps, wait_option, 0, NULL);
+       libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
+                             CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
 
        lbs_deb_leave(LBS_DEB_CMD);
 }
@@ -1864,12 +1864,12 @@ void libertas_ps_wakeup(wlan_private * priv, int wait_option)
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       Localpsmode = cpu_to_le32(wlan802_11powermodecam);
+       Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
 
-       lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", wlan802_11powermodecam);
+       lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", WLAN802_11POWERMODECAM);
 
-       libertas_prepare_and_send_command(priv, cmd_802_11_ps_mode,
-                             cmd_subcmd_exit_ps,
+       libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
+                             CMD_SUBCMD_EXIT_PS,
                              wait_option, 0, &Localpsmode);
 
        lbs_deb_leave(LBS_DEB_CMD);
index 89bd43c2efa30f339a2587d01117a82715d33b6a..4c15071984b92699a9cacc07658b762c3d069e8c 100644 (file)
@@ -28,7 +28,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
        wlan_adapter *adapter = priv->adapter;
        union iwreq_data wrqu;
 
-       if (adapter->connect_status != libertas_connected)
+       if (adapter->connect_status != LIBERTAS_CONNECTED)
                return;
 
        lbs_deb_cmd("Handles disconnect event.\n");
@@ -69,7 +69,7 @@ void libertas_mac_event_disconnected(wlan_private * priv)
                    escape_essid(adapter->prev_ssid, adapter->prev_ssid_len),
                    adapter->prev_ssid_len);
 
-       adapter->connect_status = libertas_disconnected;
+       adapter->connect_status = LIBERTAS_DISCONNECTED;
 
        /* Save previous SSID and BSSID for possible reassociation */
        memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid,
@@ -124,7 +124,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
        lbs_deb_enter(LBS_DEB_CMD);
 
        switch (type) {
-       case cmd_ret_mac_reg_access:
+       case CMD_RET_MAC_REG_ACCESS:
                {
                        struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
 
@@ -133,7 +133,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
                        break;
                }
 
-       case cmd_ret_bbp_reg_access:
+       case CMD_RET_BBP_REG_ACCESS:
                {
                        struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
 
@@ -142,7 +142,7 @@ static int wlan_ret_reg_access(wlan_private * priv,
                        break;
                }
 
-       case cmd_ret_rf_reg_access:
+       case CMD_RET_RF_REG_ACCESS:
                {
                        struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
 
@@ -274,21 +274,21 @@ static int wlan_ret_802_11_snmp_mib(wlan_private * priv,
               querytype);
        lbs_deb_cmd("SNMP_RESP: Buf size  = %x\n", le16_to_cpu(smib->bufsize));
 
-       if (querytype == cmd_act_get) {
+       if (querytype == CMD_ACT_GET) {
                switch (oid) {
-               case fragthresh_i:
+               case FRAGTHRESH_I:
                        priv->adapter->fragthsd =
                                le16_to_cpu(*((__le16 *)(smib->value)));
                        lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n",
                                    priv->adapter->fragthsd);
                        break;
-               case rtsthresh_i:
+               case RTSTHRESH_I:
                        priv->adapter->rtsthsd =
                                le16_to_cpu(*((__le16 *)(smib->value)));
                        lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n",
                                    priv->adapter->rtsthsd);
                        break;
-               case short_retrylim_i:
+               case SHORT_RETRYLIM_I:
                        priv->adapter->txretrycount =
                                le16_to_cpu(*((__le16 *)(smib->value)));
                        lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n",
@@ -314,7 +314,7 @@ static int wlan_ret_802_11_key_material(wlan_private * priv,
        lbs_deb_enter(LBS_DEB_CMD);
 
        /* Copy the returned key to driver private data */
-       if (action == cmd_act_get) {
+       if (action == CMD_ACT_GET) {
                u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;
                u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
 
@@ -396,10 +396,10 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
        wlan_adapter *adapter = priv->adapter;
        u16 action = le16_to_cpu(pAntenna->action);
 
-       if (action == cmd_act_get_rx)
+       if (action == CMD_ACT_GET_rx)
                adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);
 
-       if (action == cmd_act_get_tx)
+       if (action == CMD_ACT_GET_tx)
                adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);
 
        lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n",
@@ -416,7 +416,7 @@ static int wlan_ret_802_11_rate_adapt_rateset(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       if (rates->action == cmd_act_get) {
+       if (rates->action == CMD_ACT_GET) {
                adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
                adapter->ratebitmap = le16_to_cpu(rates->bitmap);
        }
@@ -438,7 +438,7 @@ static int wlan_ret_802_11_data_rate(wlan_private * priv,
                (u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate));
 
        dot11datarate = pdatarate->datarate[0];
-       if (pdatarate->action == cpu_to_le16(cmd_act_get_tx_rate)) {
+       if (pdatarate->action == cpu_to_le16(CMD_ACT_GET_tx_rate)) {
                memcpy(adapter->libertas_supported_rates, pdatarate->datarate,
                       sizeof(adapter->libertas_supported_rates));
        }
@@ -458,7 +458,7 @@ static int wlan_ret_802_11_rf_channel(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       if (action == cmd_opt_802_11_rf_channel_get
+       if (action == CMD_OPT_802_11_RF_CHANNEL_GET
            && adapter->curbssparams.channel != newchannel) {
                lbs_deb_cmd("channel Switch: %d to %d\n",
                       adapter->curbssparams.channel, newchannel);
@@ -547,7 +547,7 @@ static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       if (enable_rsn->action == cpu_to_le16(cmd_act_get)) {
+       if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
                if (pdata_buf)
                        *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
        }
@@ -565,134 +565,134 @@ static inline int handle_cmd_response(u16 respcmd,
        wlan_adapter *adapter = priv->adapter;
 
        switch (respcmd) {
-       case cmd_ret_mac_reg_access:
-       case cmd_ret_bbp_reg_access:
-       case cmd_ret_rf_reg_access:
+       case CMD_RET_MAC_REG_ACCESS:
+       case CMD_RET_BBP_REG_ACCESS:
+       case CMD_RET_RF_REG_ACCESS:
                ret = wlan_ret_reg_access(priv, respcmd, resp);
                break;
 
-       case cmd_ret_hw_spec_info:
+       case CMD_RET_HW_SPEC_INFO:
                ret = wlan_ret_get_hw_spec(priv, resp);
                break;
 
-       case cmd_ret_802_11_scan:
+       case CMD_RET_802_11_SCAN:
                ret = libertas_ret_80211_scan(priv, resp);
                break;
 
-       case cmd_ret_802_11_get_log:
+       case CMD_RET_802_11_GET_LOG:
                ret = wlan_ret_get_log(priv, resp);
                break;
 
-       case cmd_ret_802_11_associate:
-       case cmd_ret_802_11_reassociate:
+       case CMD_RET_802_11_ASSOCIATE:
+       case CMD_RET_802_11_REASSOCIATE:
                ret = libertas_ret_80211_associate(priv, resp);
                break;
 
-       case cmd_ret_802_11_disassociate:
-       case cmd_ret_802_11_deauthenticate:
+       case CMD_RET_802_11_DISASSOCIATE:
+       case CMD_RET_802_11_DEAUTHENTICATE:
                ret = libertas_ret_80211_disassociate(priv, resp);
                break;
 
-       case cmd_ret_802_11_ad_hoc_start:
-       case cmd_ret_802_11_ad_hoc_join:
+       case CMD_RET_802_11_AD_HOC_START:
+       case CMD_RET_802_11_AD_HOC_JOIN:
                ret = libertas_ret_80211_ad_hoc_start(priv, resp);
                break;
 
-       case cmd_ret_802_11_stat:
+       case CMD_RET_802_11_STAT:
                ret = wlan_ret_802_11_stat(priv, resp);
                break;
 
-       case cmd_ret_802_11_snmp_mib:
+       case CMD_RET_802_11_SNMP_MIB:
                ret = wlan_ret_802_11_snmp_mib(priv, resp);
                break;
 
-       case cmd_ret_802_11_rf_tx_power:
+       case CMD_RET_802_11_RF_TX_POWER:
                ret = wlan_ret_802_11_rf_tx_power(priv, resp);
                break;
 
-       case cmd_ret_802_11_set_afc:
-       case cmd_ret_802_11_get_afc:
+       case CMD_RET_802_11_SET_AFC:
+       case CMD_RET_802_11_GET_AFC:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,
                        sizeof(struct cmd_ds_802_11_afc));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
 
                break;
-       case cmd_ret_802_11_rf_antenna:
+       case CMD_RET_802_11_RF_ANTENNA:
                ret = wlan_ret_802_11_rf_antenna(priv, resp);
                break;
 
-       case cmd_ret_mac_multicast_adr:
-       case cmd_ret_mac_control:
-       case cmd_ret_802_11_set_wep:
-       case cmd_ret_802_11_reset:
-       case cmd_ret_802_11_authenticate:
-       case cmd_ret_802_11_radio_control:
-       case cmd_ret_802_11_beacon_stop:
+       case CMD_RET_MAC_MULTICAST_ADR:
+       case CMD_RET_MAC_CONTROL:
+       case CMD_RET_802_11_SET_WEP:
+       case CMD_RET_802_11_RESET:
+       case CMD_RET_802_11_AUTHENTICATE:
+       case CMD_RET_802_11_RADIO_CONTROL:
+       case CMD_RET_802_11_BEACON_STOP:
                break;
 
-       case cmd_ret_802_11_enable_rsn:
+       case CMD_RET_802_11_ENABLE_RSN:
                ret = libertas_ret_802_11_enable_rsn(priv, resp);
                break;
 
-       case cmd_ret_802_11_data_rate:
+       case CMD_RET_802_11_DATA_RATE:
                ret = wlan_ret_802_11_data_rate(priv, resp);
                break;
-       case cmd_ret_802_11_rate_adapt_rateset:
+       case CMD_RET_802_11_RATE_ADAPT_RATESET:
                ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
                break;
-       case cmd_ret_802_11_rf_channel:
+       case CMD_RET_802_11_RF_CHANNEL:
                ret = wlan_ret_802_11_rf_channel(priv, resp);
                break;
 
-       case cmd_ret_802_11_rssi:
+       case CMD_RET_802_11_RSSI:
                ret = wlan_ret_802_11_rssi(priv, resp);
                break;
 
-       case cmd_ret_802_11_mac_address:
+       case CMD_RET_802_11_MAC_ADDRESS:
                ret = wlan_ret_802_11_mac_address(priv, resp);
                break;
 
-       case cmd_ret_802_11_ad_hoc_stop:
+       case CMD_RET_802_11_AD_HOC_STOP:
                ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
                break;
 
-       case cmd_ret_802_11_key_material:
+       case CMD_RET_802_11_KEY_MATERIAL:
                lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n");
                ret = wlan_ret_802_11_key_material(priv, resp);
                break;
 
-       case cmd_ret_802_11_eeprom_access:
+       case CMD_RET_802_11_EEPROM_ACCESS:
                ret = wlan_ret_802_11_eeprom_access(priv, resp);
                break;
 
-       case cmd_ret_802_11d_domain_info:
+       case CMD_RET_802_11D_DOMAIN_INFO:
                ret = libertas_ret_802_11d_domain_info(priv, resp);
                break;
 
-       case cmd_ret_802_11_sleep_params:
+       case CMD_RET_802_11_SLEEP_PARAMS:
                ret = wlan_ret_802_11_sleep_params(priv, resp);
                break;
-       case cmd_ret_802_11_inactivity_timeout:
+       case CMD_RET_802_11_INACTIVITY_TIMEOUT:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                *((u16 *) adapter->cur_cmd->pdata_buf) =
                    le16_to_cpu(resp->params.inactivity_timeout.timeout);
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
 
-       case cmd_ret_802_11_tpc_cfg:
+       case CMD_RET_802_11_TPC_CFG:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,
                        sizeof(struct cmd_ds_802_11_tpc_cfg));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_802_11_led_gpio_ctrl:
+       case CMD_RET_802_11_LED_GPIO_CTRL:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,
                        sizeof(struct cmd_ds_802_11_led_ctrl));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_802_11_pwr_cfg:
+       case CMD_RET_802_11_PWR_CFG:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
                        sizeof(struct cmd_ds_802_11_pwr_cfg));
@@ -700,32 +700,32 @@ static inline int handle_cmd_response(u16 respcmd,
 
                break;
 
-       case cmd_ret_get_tsf:
+       case CMD_RET_GET_TSF:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memcpy(priv->adapter->cur_cmd->pdata_buf,
                       &resp->params.gettsf.tsfvalue, sizeof(u64));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_bt_access:
+       case CMD_RET_BT_ACCESS:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                if (adapter->cur_cmd->pdata_buf)
                        memcpy(adapter->cur_cmd->pdata_buf,
                               &resp->params.bt.addr1, 2 * ETH_ALEN);
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_fwt_access:
+       case CMD_RET_FWT_ACCESS:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                if (adapter->cur_cmd->pdata_buf)
                        memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,
                               sizeof(resp->params.fwt));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_mesh_access:
+       case CMD_RET_MESH_ACCESS:
                if (adapter->cur_cmd->pdata_buf)
                        memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
                               sizeof(resp->params.mesh));
                break;
-       case cmd_rte_802_11_tx_rate_query:
+       case CMD_RTE_802_11_TX_RATE_QUERY:
                priv->adapter->txrate = resp->params.txrate.txrate;
                break;
        default:
@@ -787,7 +787,7 @@ int libertas_process_rx_command(wlan_private * priv)
        /* Store the response code to cur_cmd_retcode. */
        adapter->cur_cmd_retcode = result;;
 
-       if (respcmd == cmd_ret_802_11_ps_mode) {
+       if (respcmd == CMD_RET_802_11_PS_MODE) {
                struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
                u16 action = le16_to_cpu(psmode->action);
 
@@ -804,14 +804,14 @@ int libertas_process_rx_command(wlan_private * priv)
                         * libertas_execute_next_command().
                         */
                        if (adapter->mode == IW_MODE_ADHOC &&
-                           action == cmd_subcmd_enter_ps)
-                               adapter->psmode = wlan802_11powermodecam;
-               } else if (action == cmd_subcmd_enter_ps) {
+                           action == CMD_SUBCMD_ENTER_PS)
+                               adapter->psmode = WLAN802_11POWERMODECAM;
+               } else if (action == CMD_SUBCMD_ENTER_PS) {
                        adapter->needtowakeup = 0;
                        adapter->psstate = PS_STATE_AWAKE;
 
                        lbs_deb_cmd("CMD_RESP: Enter_PS command response\n");
-                       if (adapter->connect_status != libertas_connected) {
+                       if (adapter->connect_status != LIBERTAS_CONNECTED) {
                                /*
                                 * When Deauth Event received before Enter_PS command
                                 * response, We need to wake up the firmware.
@@ -825,7 +825,7 @@ int libertas_process_rx_command(wlan_private * priv)
                                mutex_lock(&adapter->lock);
                                spin_lock_irqsave(&adapter->driver_lock, flags);
                        }
-               } else if (action == cmd_subcmd_exit_ps) {
+               } else if (action == CMD_SUBCMD_EXIT_PS) {
                        adapter->needtowakeup = 0;
                        adapter->psstate = PS_STATE_FULL_POWER;
                        lbs_deb_cmd("CMD_RESP: Exit_PS command response\n");
@@ -857,8 +857,8 @@ int libertas_process_rx_command(wlan_private * priv)
                 * Handling errors here
                 */
                switch (respcmd) {
-               case cmd_ret_hw_spec_info:
-               case cmd_ret_802_11_reset:
+               case CMD_RET_HW_SPEC_INFO:
+               case CMD_RET_802_11_RESET:
                        lbs_deb_cmd("CMD_RESP: Reset command failed\n");
                        break;
 
@@ -1003,7 +1003,7 @@ int libertas_process_event(wlan_private * priv)
 
        case MACREG_INT_CODE_MESH_AUTO_STARTED:
                lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n");
-               adapter->connect_status = libertas_connected ;
+               adapter->connect_status = LIBERTAS_CONNECTED ;
                if (priv->mesh_open == 1) {
                        netif_wake_queue(priv->mesh_dev) ;
                        netif_carrier_on(priv->mesh_dev) ;
index e5cbfa8d6e3fb5eaee3416bdc528512b8edd5e14..a206f49f810c752ecf1ee3756012430a67d8aa5d 100644 (file)
@@ -125,9 +125,9 @@ static ssize_t libertas_sleepparams_write(struct file *file,
        priv->adapter->sp.sp_reserved = p6;
 
         res = libertas_prepare_and_send_command(priv,
-                               cmd_802_11_sleep_params,
-                               cmd_act_set,
-                               cmd_option_waitforrsp, 0, NULL);
+                               CMD_802_11_SLEEP_PARAMS,
+                               CMD_ACT_SET,
+                               CMD_OPTION_WAITFORRSP, 0, NULL);
 
        if (!res)
                res = count;
@@ -150,9 +150,9 @@ static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf
        char *buf = (char *)addr;
 
         res = libertas_prepare_and_send_command(priv,
-                               cmd_802_11_sleep_params,
-                               cmd_act_get,
-                               cmd_option_waitforrsp, 0, NULL);
+                               CMD_802_11_SLEEP_PARAMS,
+                               CMD_ACT_GET,
+                               CMD_OPTION_WAITFORRSP, 0, NULL);
        if (res) {
                res = -EFAULT;
                goto out_unlock;
@@ -386,7 +386,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
                        struct cmd_ctrl_node **cmdnode,
                        struct cmd_ds_command **cmd)
 {
-       u16 wait_option = cmd_option_waitforrsp;
+       u16 wait_option = CMD_OPTION_WAITFORRSP;
 
        if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
                lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
@@ -402,7 +402,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
        (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
        (*cmdnode)->cmdwaitqwoken = 0;
        *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
-       (*cmd)->command = cpu_to_le16(cmd_802_11_subscribe_event);
+       (*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);
        (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
        (*cmd)->result = 0;
        return 0;
@@ -429,7 +429,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -447,7 +447,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -493,7 +493,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
                return res;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -511,7 +511,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
                return 0;
        }
 
-       if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
+       if (pcmdptr->command != CMD_RET_802_11_SUBSCRIBE_EVENT) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                return 0;
@@ -559,7 +559,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_rssithreshold));
@@ -591,7 +591,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -625,7 +625,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -644,7 +644,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -712,7 +712,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_snrthreshold));
@@ -743,7 +743,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -778,7 +778,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -797,7 +797,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -864,7 +864,7 @@ static ssize_t libertas_failcount_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_failurecount));
@@ -895,7 +895,7 @@ static ssize_t libertas_failcount_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -929,7 +929,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -948,7 +948,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                free_page(addr);
                kfree(response_buf);
@@ -1015,7 +1015,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_beaconsmissed));
@@ -1045,7 +1045,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                free_page(addr);
                kfree(response_buf);
@@ -1079,7 +1079,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -1098,7 +1098,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -1166,7 +1166,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_rssithreshold));
@@ -1196,7 +1196,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                return 0;
@@ -1229,7 +1229,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
        }
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_get);
+       event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
        wake_up_interruptible(&priv->mainthread.waitq);
@@ -1248,7 +1248,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -1316,7 +1316,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
                goto out_unlock;
 
        event = &pcmdptr->params.subscribe_event;
-       event->action = cpu_to_le16(cmd_act_set);
+       event->action = cpu_to_le16(CMD_ACT_SET);
        pcmdptr->size = cpu_to_le16(S_DS_GEN +
                sizeof(struct cmd_ds_802_11_subscribe_event) +
                sizeof(struct mrvlietypes_snrthreshold));
@@ -1347,7 +1347,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
                return 0;
        }
 
-       if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
+       if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {
                lbs_pr_err("command response incorrect!\n");
                kfree(response_buf);
                free_page(addr);
@@ -1375,8 +1375,8 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
        offval.value = 0;
 
        ret = libertas_prepare_and_send_command(priv,
-                               cmd_mac_reg_access, 0,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_MAC_REG_ACCESS, 0,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
        pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
                                priv->mac_offset, adapter->offsetvalue.value);
@@ -1433,8 +1433,8 @@ static ssize_t libertas_wrmac_write(struct file *file,
        offval.offset = offset;
        offval.value = value;
        res = libertas_prepare_and_send_command(priv,
-                               cmd_mac_reg_access, 1,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_MAC_REG_ACCESS, 1,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
 
        res = count;
@@ -1458,8 +1458,8 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
        offval.value = 0;
 
        ret = libertas_prepare_and_send_command(priv,
-                               cmd_bbp_reg_access, 0,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_BBP_REG_ACCESS, 0,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
        pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
                                priv->bbp_offset, adapter->offsetvalue.value);
@@ -1517,8 +1517,8 @@ static ssize_t libertas_wrbbp_write(struct file *file,
        offval.offset = offset;
        offval.value = value;
        res = libertas_prepare_and_send_command(priv,
-                               cmd_bbp_reg_access, 1,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_BBP_REG_ACCESS, 1,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
 
        res = count;
@@ -1542,8 +1542,8 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
        offval.value = 0;
 
        ret = libertas_prepare_and_send_command(priv,
-                               cmd_rf_reg_access, 0,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_RF_REG_ACCESS, 0,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
        pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
                                priv->rf_offset, adapter->offsetvalue.value);
@@ -1601,8 +1601,8 @@ static ssize_t libertas_wrrf_write(struct file *file,
        offval.offset = offset;
        offval.value = value;
        res = libertas_prepare_and_send_command(priv,
-                               cmd_rf_reg_access, 1,
-                               cmd_option_waitforrsp, 0, &offval);
+                               CMD_RF_REG_ACCESS, 1,
+                               CMD_OPTION_WAITFORRSP, 0, &offval);
        mdelay(10);
 
        res = count;
index a5d70c19768bc65522628aff67557062a1cf2a30..862292913c2c887bf958916e98ed6917e7f45929 100644 (file)
@@ -286,11 +286,11 @@ enum SNRNF_DATA {
 
 /** WLAN_802_11_POWER_MODE */
 enum WLAN_802_11_POWER_MODE {
-       wlan802_11powermodecam,
-       wlan802_11powermodemax_psp,
-       wlan802_11Powermodefast_psp,
+       WLAN802_11POWERMODECAM,
+       WLAN802_11POWERMODEMAX_PSP,
+       WLAN802_11POWERMODEFAST_PSP,
        /*not a real mode, defined as an upper bound */
-       wlan802_11powemodemax
+       WLAN802_11POWEMODEMAX
 };
 
 /** PS_STATE */
@@ -310,14 +310,14 @@ enum DNLD_STATE {
 
 /** WLAN_MEDIA_STATE */
 enum WLAN_MEDIA_STATE {
-       libertas_connected,
-       libertas_disconnected
+       LIBERTAS_CONNECTED,
+       LIBERTAS_DISCONNECTED
 };
 
 /** WLAN_802_11_PRIVACY_FILTER */
 enum WLAN_802_11_PRIVACY_FILTER {
-       wlan802_11privfilteracceptall,
-       wlan802_11privfilter8021xWEP
+       WLAN802_11PRIVFILTERACCEPTALL,
+       WLAN802_11PRIVFILTER8021XWEP
 };
 
 /** mv_ms_type */
@@ -330,23 +330,23 @@ enum mv_ms_type {
 
 /** SNMP_MIB_INDEX_e */
 enum SNMP_MIB_INDEX_e {
-       desired_bsstype_i = 0,
-       op_rateset_i,
-       bcnperiod_i,
-       dtimperiod_i,
-       assocrsp_timeout_i,
-       rtsthresh_i,
-       short_retrylim_i,
-       long_retrylim_i,
-       fragthresh_i,
-       dot11d_i,
-       dot11h_i,
-       manufid_i,
-       prodID_i,
-       manuf_oui_i,
-       manuf_name_i,
-       manuf_prodname_i,
-       manuf_prodver_i,
+       DESIRED_BSSTYPE_I = 0,
+       OP_RATESET_I,
+       BCNPERIOD_I,
+       DTIMPERIOD_I,
+       ASSOCRSP_TIMEOUT_I,
+       RTSTHRESH_I,
+       SHORT_RETRYLIM_I,
+       LONG_RETRYLIM_I,
+       FRAGTHRESH_I,
+       DOT11D_I,
+       DOT11H_I,
+       MANUFID_I,
+       PRODID_I,
+       MANUF_OUI_I,
+       MANUF_NAME_I,
+       MANUF_PRODNAME_I,
+       MANUF_PRODVER_I,
 };
 
 /** KEY_TYPE_ID */
index 96f1974685d4f4662fd88bbd185edf359daaf626..ec99cb825871f7ce464863c95f885050a0c731fe 100644 (file)
@@ -72,9 +72,9 @@ static int libertas_ethtool_get_eeprom(struct net_device *dev,
               regctrl.action, regctrl.offset, regctrl.NOB);
 
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_eeprom_access,
+                                   CMD_802_11_EEPROM_ACCESS,
                                    regctrl.action,
-                                   cmd_option_waitforrsp, 0,
+                                   CMD_OPTION_WAITFORRSP, 0,
                                    &regctrl);
 
        if (ret) {
@@ -138,8 +138,8 @@ static int libertas_ethtool_get_stats_count(struct net_device * dev)
 
        /* Get Mesh Statistics */
        ret = libertas_prepare_and_send_command(priv,
-                       cmd_mesh_access, cmd_act_mesh_get_stats,
-                       cmd_option_waitforrsp, 0, &mesh_access);
+                       CMD_MESH_ACCESS, CMD_ACT_MESH_GET_STATS,
+                       CMD_OPTION_WAITFORRSP, 0, &mesh_access);
 
        if (ret) {
                ret = 0;
index 288e47c33555376fc723664eb4b9086c286ea323..39b0a094b62688607cebadf9bdac55bc13d3b982 100644 (file)
@@ -99,8 +99,8 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
         */
        memset(adapter->current_addr, 0xff, ETH_ALEN);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec,
-                                   0, cmd_option_waitforrsp, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC,
+                                   0, CMD_OPTION_WAITFORRSP, 0, NULL);
 
        if (ret) {
                ret = -1;
@@ -110,9 +110,9 @@ static int wlan_setup_station_hw(wlan_private * priv, char *fw_name)
        libertas_set_mac_packet_filter(priv);
 
        /* Get the supported Data rates */
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
-                                   cmd_act_get_tx_rate,
-                                   cmd_option_waitforrsp, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
+                                   CMD_ACT_GET_tx_rate,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
 
        if (ret) {
                ret = -1;
@@ -145,12 +145,12 @@ static int wlan_allocate_adapter(wlan_private * priv)
        memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
        adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
        adapter->libertas_ps_confirm_sleep.command =
-           cpu_to_le16(cmd_802_11_ps_mode);
+           cpu_to_le16(CMD_802_11_PS_MODE);
        adapter->libertas_ps_confirm_sleep.size =
            cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
        adapter->libertas_ps_confirm_sleep.result = 0;
        adapter->libertas_ps_confirm_sleep.action =
-           cpu_to_le16(cmd_subcmd_sleep_confirmed);
+           cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
 
        return 0;
 }
@@ -168,14 +168,14 @@ static void wlan_init_adapter(wlan_private * priv)
        /* ATIM params */
        adapter->atimwindow = 0;
 
-       adapter->connect_status = libertas_disconnected;
+       adapter->connect_status = LIBERTAS_DISCONNECTED;
        memset(adapter->current_addr, 0xff, ETH_ALEN);
 
        /* scan type */
-       adapter->scantype = cmd_scan_type_active;
+       adapter->scantype = CMD_SCAN_TYPE_ACTIVE;
 
        /* scan mode */
-       adapter->scanmode = cmd_bss_type_any;
+       adapter->scanmode = CMD_BSS_TYPE_ANY;
 
        /* 802.11 specific */
        adapter->secinfo.wep_enabled = 0;
@@ -208,7 +208,7 @@ static void wlan_init_adapter(wlan_private * priv)
        adapter->surpriseremoved = 0;
 
        adapter->currentpacketfilter =
-           cmd_act_mac_rx_on | cmd_act_mac_tx_on;
+           CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
 
        adapter->radioon = RADIO_ON;
        adapter->txantenna = RF_ANTENNA_2;
@@ -220,7 +220,7 @@ static void wlan_init_adapter(wlan_private * priv)
        // set default capabilities
        adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
 
-       adapter->psmode = wlan802_11powermodecam;
+       adapter->psmode = WLAN802_11POWERMODECAM;
        adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;
 
        adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;
index 7509cc10af3c376a2f3bdf94f942b9bd7d59b920..4bd2e88116cc014eca7a779c0be213f2ae7f5293 100644 (file)
 #define OID_802_11_TX_RETRYCOUNT              0x0000801D
 #define OID_802_11D_ENABLE                    0x00008020
 
-#define cmd_option_waitforrsp             0x0002
+#define CMD_OPTION_WAITFORRSP             0x0002
 
 /** Host command ID */
-#define cmd_code_dnld                 0x0002
-#define cmd_get_hw_spec               0x0003
-#define cmd_eeprom_update             0x0004
-#define cmd_802_11_reset              0x0005
-#define cmd_802_11_scan               0x0006
-#define cmd_802_11_get_log            0x000b
-#define cmd_mac_multicast_adr         0x0010
-#define cmd_802_11_authenticate       0x0011
-#define cmd_802_11_eeprom_access      0x0059
-#define cmd_802_11_associate          0x0050
-#define cmd_802_11_set_wep            0x0013
-#define cmd_802_11_get_stat           0x0014
-#define cmd_802_3_get_stat            0x0015
-#define cmd_802_11_snmp_mib           0x0016
-#define cmd_mac_reg_map               0x0017
-#define cmd_bbp_reg_map               0x0018
-#define cmd_mac_reg_access            0x0019
-#define cmd_bbp_reg_access            0x001a
-#define cmd_rf_reg_access             0x001b
-#define cmd_802_11_radio_control      0x001c
-#define cmd_802_11_rf_channel         0x001d
-#define cmd_802_11_rf_tx_power        0x001e
-#define cmd_802_11_rssi               0x001f
-#define cmd_802_11_rf_antenna         0x0020
+#define CMD_CODE_DNLD                 0x0002
+#define CMD_GET_HW_SPEC               0x0003
+#define CMD_EEPROM_UPDATE             0x0004
+#define CMD_802_11_RESET              0x0005
+#define CMD_802_11_SCAN               0x0006
+#define CMD_802_11_GET_LOG            0x000b
+#define CMD_MAC_MULTICAST_ADR         0x0010
+#define CMD_802_11_AUTHENTICATE       0x0011
+#define CMD_802_11_EEPROM_ACCESS      0x0059
+#define CMD_802_11_ASSOCIATE          0x0050
+#define CMD_802_11_SET_WEP            0x0013
+#define CMD_802_11_GET_STAT           0x0014
+#define CMD_802_3_GET_STAT            0x0015
+#define CMD_802_11_SNMP_MIB           0x0016
+#define CMD_MAC_REG_MAP               0x0017
+#define CMD_BBP_REG_MAP               0x0018
+#define CMD_MAC_REG_ACCESS            0x0019
+#define CMD_BBP_REG_ACCESS            0x001a
+#define CMD_RF_REG_ACCESS             0x001b
+#define CMD_802_11_RADIO_CONTROL      0x001c
+#define CMD_802_11_RF_CHANNEL         0x001d
+#define CMD_802_11_RF_TX_POWER        0x001e
+#define CMD_802_11_RSSI               0x001f
+#define CMD_802_11_RF_ANTENNA         0x0020
 
-#define cmd_802_11_ps_mode           0x0021
+#define CMD_802_11_PS_MODE           0x0021
 
-#define cmd_802_11_data_rate          0x0022
-#define cmd_rf_reg_map                0x0023
-#define cmd_802_11_deauthenticate     0x0024
-#define cmd_802_11_reassociate        0x0025
-#define cmd_802_11_disassociate       0x0026
-#define cmd_mac_control               0x0028
-#define cmd_802_11_ad_hoc_start       0x002b
-#define cmd_802_11_ad_hoc_join        0x002c
+#define CMD_802_11_DATA_RATE          0x0022
+#define CMD_RF_REG_MAP                0x0023
+#define CMD_802_11_DEAUTHENTICATE     0x0024
+#define CMD_802_11_REASSOCIATE        0x0025
+#define CMD_802_11_DISASSOCIATE       0x0026
+#define CMD_MAC_CONTROL               0x0028
+#define CMD_802_11_AD_HOC_START       0x002b
+#define CMD_802_11_AD_HOC_JOIN        0x002c
 
-#define cmd_802_11_query_tkip_reply_cntrs  0x002e
-#define cmd_802_11_enable_rsn              0x002f
-#define cmd_802_11_pairwise_tsc       0x0036
-#define cmd_802_11_group_tsc          0x0037
-#define cmd_802_11_key_material       0x005e
+#define CMD_802_11_QUERY_TKIP_REPLY_CNTRS  0x002e
+#define CMD_802_11_ENABLE_RSN              0x002f
+#define CMD_802_11_PAIRWISE_TSC       0x0036
+#define CMD_802_11_GROUP_TSC          0x0037
+#define CMD_802_11_KEY_MATERIAL       0x005e
 
-#define cmd_802_11_set_afc            0x003c
-#define cmd_802_11_get_afc            0x003d
+#define CMD_802_11_SET_AFC            0x003c
+#define CMD_802_11_GET_AFC            0x003d
 
-#define cmd_802_11_ad_hoc_stop        0x0040
+#define CMD_802_11_AD_HOC_STOP        0x0040
 
-#define cmd_802_11_beacon_stop        0x0049
+#define CMD_802_11_BEACON_STOP        0x0049
 
-#define cmd_802_11_mac_address        0x004D
-#define cmd_802_11_eeprom_access      0x0059
+#define CMD_802_11_MAC_ADDRESS        0x004D
+#define CMD_802_11_EEPROM_ACCESS      0x0059
 
-#define cmd_802_11_band_config        0x0058
+#define CMD_802_11_BAND_CONFIG        0x0058
 
-#define cmd_802_11d_domain_info       0x005b
+#define CMD_802_11D_DOMAIN_INFO       0x005b
 
-#define cmd_802_11_sleep_params          0x0066
+#define CMD_802_11_SLEEP_PARAMS          0x0066
 
-#define cmd_802_11_inactivity_timeout    0x0067
+#define CMD_802_11_INACTIVITY_TIMEOUT    0x0067
 
-#define cmd_802_11_tpc_cfg               0x0072
-#define cmd_802_11_pwr_cfg               0x0073
+#define CMD_802_11_TPC_CFG               0x0072
+#define CMD_802_11_PWR_CFG               0x0073
 
-#define cmd_802_11_led_gpio_ctrl         0x004e
+#define CMD_802_11_LED_GPIO_CTRL         0x004e
 
-#define cmd_802_11_subscribe_event       0x0075
+#define CMD_802_11_SUBSCRIBE_EVENT       0x0075
 
-#define cmd_802_11_rate_adapt_rateset    0x0076
+#define CMD_802_11_RATE_ADAPT_RATESET    0x0076
 
-#define cmd_802_11_tx_rate_query       0x007f
+#define CMD_802_11_TX_RATE_QUERY       0x007f
 
-#define cmd_get_tsf                      0x0080
+#define CMD_GET_TSF                      0x0080
 
-#define cmd_bt_access                 0x0087
-#define cmd_ret_bt_access                 0x8087
+#define CMD_BT_ACCESS                 0x0087
+#define CMD_RET_BT_ACCESS                 0x8087
 
-#define cmd_fwt_access                0x0095
-#define cmd_ret_fwt_access                0x8095
+#define CMD_FWT_ACCESS                0x0095
+#define CMD_RET_FWT_ACCESS                0x8095
 
-#define cmd_mesh_access               0x009b
-#define cmd_ret_mesh_access               0x809b
+#define CMD_MESH_ACCESS               0x009b
+#define CMD_RET_MESH_ACCESS               0x809b
 
 /* For the IEEE Power Save */
-#define cmd_subcmd_enter_ps               0x0030
-#define cmd_subcmd_exit_ps                0x0031
-#define cmd_subcmd_sleep_confirmed        0x0034
-#define cmd_subcmd_full_powerdown         0x0035
-#define cmd_subcmd_full_powerup           0x0036
+#define CMD_SUBCMD_ENTER_PS               0x0030
+#define CMD_SUBCMD_EXIT_PS                0x0031
+#define CMD_SUBCMD_SLEEP_CONFIRMED        0x0034
+#define CMD_SUBCMD_FULL_POWERDOWN         0x0035
+#define CMD_SUBCMD_FULL_POWERUP           0x0036
 
 /* command RET code, MSB is set to 1 */
-#define cmd_ret_hw_spec_info              0x8003
-#define cmd_ret_eeprom_update             0x8004
-#define cmd_ret_802_11_reset              0x8005
-#define cmd_ret_802_11_scan               0x8006
-#define cmd_ret_802_11_get_log            0x800b
-#define cmd_ret_mac_control               0x8028
-#define cmd_ret_mac_multicast_adr         0x8010
-#define cmd_ret_802_11_authenticate       0x8011
-#define cmd_ret_802_11_deauthenticate     0x8024
-#define cmd_ret_802_11_associate          0x8012
-#define cmd_ret_802_11_reassociate        0x8025
-#define cmd_ret_802_11_disassociate       0x8026
-#define cmd_ret_802_11_set_wep            0x8013
-#define cmd_ret_802_11_stat               0x8014
-#define cmd_ret_802_3_stat                0x8015
-#define cmd_ret_802_11_snmp_mib           0x8016
-#define cmd_ret_mac_reg_map               0x8017
-#define cmd_ret_bbp_reg_map               0x8018
-#define cmd_ret_rf_reg_map                0x8023
-#define cmd_ret_mac_reg_access            0x8019
-#define cmd_ret_bbp_reg_access            0x801a
-#define cmd_ret_rf_reg_access             0x801b
-#define cmd_ret_802_11_radio_control      0x801c
-#define cmd_ret_802_11_rf_channel         0x801d
-#define cmd_ret_802_11_rssi               0x801f
-#define cmd_ret_802_11_rf_tx_power        0x801e
-#define cmd_ret_802_11_rf_antenna         0x8020
-#define cmd_ret_802_11_ps_mode            0x8021
-#define cmd_ret_802_11_data_rate          0x8022
+#define CMD_RET_HW_SPEC_INFO              0x8003
+#define CMD_RET_EEPROM_UPDATE             0x8004
+#define CMD_RET_802_11_RESET              0x8005
+#define CMD_RET_802_11_SCAN               0x8006
+#define CMD_RET_802_11_GET_LOG            0x800b
+#define CMD_RET_MAC_CONTROL               0x8028
+#define CMD_RET_MAC_MULTICAST_ADR         0x8010
+#define CMD_RET_802_11_AUTHENTICATE       0x8011
+#define CMD_RET_802_11_DEAUTHENTICATE     0x8024
+#define CMD_RET_802_11_ASSOCIATE          0x8012
+#define CMD_RET_802_11_REASSOCIATE        0x8025
+#define CMD_RET_802_11_DISASSOCIATE       0x8026
+#define CMD_RET_802_11_SET_WEP            0x8013
+#define CMD_RET_802_11_STAT               0x8014
+#define CMD_RET_802_3_STAT                0x8015
+#define CMD_RET_802_11_SNMP_MIB           0x8016
+#define CMD_RET_MAC_REG_MAP               0x8017
+#define CMD_RET_BBP_REG_MAP               0x8018
+#define CMD_RET_RF_REG_MAP                0x8023
+#define CMD_RET_MAC_REG_ACCESS            0x8019
+#define CMD_RET_BBP_REG_ACCESS            0x801a
+#define CMD_RET_RF_REG_ACCESS             0x801b
+#define CMD_RET_802_11_RADIO_CONTROL      0x801c
+#define CMD_RET_802_11_RF_CHANNEL         0x801d
+#define CMD_RET_802_11_RSSI               0x801f
+#define CMD_RET_802_11_RF_TX_POWER        0x801e
+#define CMD_RET_802_11_RF_ANTENNA         0x8020
+#define CMD_RET_802_11_PS_MODE            0x8021
+#define CMD_RET_802_11_DATA_RATE          0x8022
 
-#define cmd_ret_802_11_ad_hoc_start       0x802B
-#define cmd_ret_802_11_ad_hoc_join        0x802C
+#define CMD_RET_802_11_AD_HOC_START       0x802B
+#define CMD_RET_802_11_AD_HOC_JOIN        0x802C
 
-#define cmd_ret_802_11_query_tkip_reply_cntrs  0x802e
-#define cmd_ret_802_11_enable_rsn              0x802f
-#define cmd_ret_802_11_pairwise_tsc       0x8036
-#define cmd_ret_802_11_group_tsc          0x8037
-#define cmd_ret_802_11_key_material       0x805e
+#define CMD_RET_802_11_QUERY_TKIP_REPLY_CNTRS  0x802e
+#define CMD_RET_802_11_ENABLE_RSN              0x802f
+#define CMD_RET_802_11_PAIRWISE_TSC       0x8036
+#define CMD_RET_802_11_GROUP_TSC          0x8037
+#define CMD_RET_802_11_KEY_MATERIAL       0x805e
 
-#define cmd_enable_rsn                    0x0001
-#define cmd_disable_rsn                   0x0000
+#define CMD_ENABLE_RSN                    0x0001
+#define CMD_DISABLE_RSN                   0x0000
 
-#define cmd_act_set                       0x0001
-#define cmd_act_get                       0x0000
+#define CMD_ACT_SET                       0x0001
+#define CMD_ACT_GET                       0x0000
 
-#define cmd_act_get_AES                   (cmd_act_get + 2)
-#define cmd_act_set_AES                   (cmd_act_set + 2)
-#define cmd_act_remove_aes                (cmd_act_set + 3)
+#define CMD_ACT_GET_AES                   (CMD_ACT_GET + 2)
+#define CMD_ACT_SET_AES                   (CMD_ACT_SET + 2)
+#define CMD_ACT_REMOVE_AES                (CMD_ACT_SET + 3)
 
-#define cmd_ret_802_11_set_afc            0x803c
-#define cmd_ret_802_11_get_afc            0x803d
+#define CMD_RET_802_11_SET_AFC            0x803c
+#define CMD_RET_802_11_GET_AFC            0x803d
 
-#define cmd_ret_802_11_ad_hoc_stop        0x8040
+#define CMD_RET_802_11_AD_HOC_STOP        0x8040
 
-#define cmd_ret_802_11_beacon_stop        0x8049
+#define CMD_RET_802_11_BEACON_STOP        0x8049
 
-#define cmd_ret_802_11_mac_address        0x804D
-#define cmd_ret_802_11_eeprom_access      0x8059
+#define CMD_RET_802_11_MAC_ADDRESS        0x804D
+#define CMD_RET_802_11_EEPROM_ACCESS      0x8059
 
-#define cmd_ret_802_11_band_config        0x8058
+#define CMD_RET_802_11_BAND_CONFIG        0x8058
 
-#define cmd_ret_802_11_sleep_params          0x8066
+#define CMD_RET_802_11_SLEEP_PARAMS          0x8066
 
-#define cmd_ret_802_11_inactivity_timeout    0x8067
+#define CMD_RET_802_11_INACTIVITY_TIMEOUT    0x8067
 
-#define cmd_ret_802_11d_domain_info      (0x8000 |                  \
-                                              cmd_802_11d_domain_info)
+#define CMD_RET_802_11D_DOMAIN_INFO      (0x8000 |                  \
+                                              CMD_802_11D_DOMAIN_INFO)
 
-#define cmd_ret_802_11_tpc_cfg        (cmd_802_11_tpc_cfg | 0x8000)
-#define cmd_ret_802_11_pwr_cfg        (cmd_802_11_pwr_cfg | 0x8000)
+#define CMD_RET_802_11_TPC_CFG        (CMD_802_11_TPC_CFG | 0x8000)
+#define CMD_RET_802_11_PWR_CFG        (CMD_802_11_PWR_CFG | 0x8000)
 
-#define cmd_ret_802_11_led_gpio_ctrl     0x804e
+#define CMD_RET_802_11_LED_GPIO_CTRL     0x804e
 
-#define cmd_ret_802_11_subscribe_event (cmd_802_11_subscribe_event | 0x8000)
+#define CMD_RET_802_11_SUBSCRIBE_EVENT (CMD_802_11_SUBSCRIBE_EVENT | 0x8000)
 
-#define cmd_ret_802_11_rate_adapt_rateset      (cmd_802_11_rate_adapt_rateset | 0x8000)
+#define CMD_RET_802_11_RATE_ADAPT_RATESET      (CMD_802_11_RATE_ADAPT_RATESET | 0x8000)
 
-#define cmd_rte_802_11_tx_rate_query   (cmd_802_11_tx_rate_query | 0x8000)
+#define CMD_RTE_802_11_TX_RATE_QUERY   (CMD_802_11_TX_RATE_QUERY | 0x8000)
 
-#define cmd_ret_get_tsf             0x8080
+#define CMD_RET_GET_TSF             0x8080
 
-/* Define action or option for cmd_802_11_set_wep */
-#define cmd_act_add                         0x0002
-#define cmd_act_remove                      0x0004
-#define cmd_act_use_default                 0x0008
+/* Define action or option for CMD_802_11_SET_WEP */
+#define CMD_ACT_ADD                         0x0002
+#define CMD_ACT_REMOVE                      0x0004
+#define CMD_ACT_USE_DEFAULT                 0x0008
 
-#define cmd_type_wep_40_bit                 0x0001
-#define cmd_type_wep_104_bit                0x0002
+#define CMD_TYPE_WEP_40_BIT                 0x0001
+#define CMD_TYPE_WEP_104_BIT                0x0002
 
-#define cmd_NUM_OF_WEP_KEYS                 4
+#define CMD_NUM_OF_WEP_KEYS                 4
 
-#define cmd_WEP_KEY_INDEX_MASK              0x3fff
+#define CMD_WEP_KEY_INDEX_MASK              0x3fff
 
-/* Define action or option for cmd_802_11_reset */
-#define cmd_act_halt                        0x0003
+/* Define action or option for CMD_802_11_RESET */
+#define CMD_ACT_HALT                        0x0003
 
-/* Define action or option for cmd_802_11_scan */
-#define cmd_bss_type_bss                    0x0001
-#define cmd_bss_type_ibss                   0x0002
-#define cmd_bss_type_any                    0x0003
+/* Define action or option for CMD_802_11_SCAN */
+#define CMD_BSS_TYPE_BSS                    0x0001
+#define CMD_BSS_TYPE_IBSS                   0x0002
+#define CMD_BSS_TYPE_ANY                    0x0003
 
-/* Define action or option for cmd_802_11_scan */
-#define cmd_scan_type_active                0x0000
-#define cmd_scan_type_passive               0x0001
+/* Define action or option for CMD_802_11_SCAN */
+#define CMD_SCAN_TYPE_ACTIVE                0x0000
+#define CMD_SCAN_TYPE_PASSIVE               0x0001
 
-#define cmd_scan_radio_type_bg         0
+#define CMD_SCAN_RADIO_TYPE_BG         0
 
-#define cmd_scan_probe_delay_time           0
+#define CMD_SCAN_PROBE_DELAY_TIME           0
 
-/* Define action or option for cmd_mac_control */
-#define cmd_act_mac_rx_on                   0x0001
-#define cmd_act_mac_tx_on                   0x0002
-#define cmd_act_mac_loopback_on             0x0004
-#define cmd_act_mac_wep_enable              0x0008
-#define cmd_act_mac_int_enable              0x0010
-#define cmd_act_mac_multicast_enable        0x0020
-#define cmd_act_mac_broadcast_enable        0x0040
-#define cmd_act_mac_promiscuous_enable      0x0080
-#define cmd_act_mac_all_multicast_enable    0x0100
-#define cmd_act_mac_strict_protection_enable  0x0400
+/* Define action or option for CMD_MAC_CONTROL */
+#define CMD_ACT_MAC_RX_ON                   0x0001
+#define CMD_ACT_MAC_TX_ON                   0x0002
+#define CMD_ACT_MAC_LOOPBACK_ON             0x0004
+#define CMD_ACT_MAC_WEP_ENABLE              0x0008
+#define CMD_ACT_MAC_INT_ENABLE              0x0010
+#define CMD_ACT_MAC_MULTICAST_ENABLE        0x0020
+#define CMD_ACT_MAC_BROADCAST_ENABLE        0x0040
+#define CMD_ACT_MAC_PROMISCUOUS_ENABLE      0x0080
+#define CMD_ACT_MAC_ALL_MULTICAST_ENABLE    0x0100
+#define CMD_ACT_MAC_STRICT_PROTECTION_ENABLE  0x0400
 
-/* Define action or option for cmd_802_11_radio_control */
-#define cmd_type_auto_preamble              0x0001
-#define cmd_type_short_preamble             0x0002
-#define cmd_type_long_preamble              0x0003
+/* Define action or option for CMD_802_11_RADIO_CONTROL */
+#define CMD_TYPE_AUTO_PREAMBLE              0x0001
+#define CMD_TYPE_SHORT_PREAMBLE             0x0002
+#define CMD_TYPE_LONG_PREAMBLE              0x0003
 
 #define TURN_ON_RF                              0x01
 #define RADIO_ON                                0x01
 #define SET_LONG_PREAMBLE                       0x01
 
 /* Define action or option for CMD_802_11_RF_CHANNEL */
-#define cmd_opt_802_11_rf_channel_get       0x00
-#define cmd_opt_802_11_rf_channel_set       0x01
-
-/* Define action or option for cmd_802_11_rf_tx_power */
-#define cmd_act_tx_power_opt_get            0x0000
-#define cmd_act_tx_power_opt_set_high       0x8007
-#define cmd_act_tx_power_opt_set_mid        0x8004
-#define cmd_act_tx_power_opt_set_low        0x8000
-
-#define cmd_act_tx_power_index_high         0x0007
-#define cmd_act_tx_power_index_mid          0x0004
-#define cmd_act_tx_power_index_low          0x0000
-
-/* Define action or option for cmd_802_11_data_rate */
-#define cmd_act_set_tx_auto                 0x0000
-#define cmd_act_set_tx_fix_rate             0x0001
-#define cmd_act_get_tx_rate                 0x0002
-
-#define cmd_act_set_rx                      0x0001
-#define cmd_act_set_tx                      0x0002
-#define cmd_act_set_both                    0x0003
-#define cmd_act_get_rx                      0x0004
-#define cmd_act_get_tx                      0x0008
-#define cmd_act_get_both                    0x000c
-
-/* Define action or option for cmd_802_11_ps_mode */
-#define cmd_type_cam                        0x0000
-#define cmd_type_max_psp                    0x0001
-#define cmd_type_fast_psp                   0x0002
-
-/* Define action or option for cmd_bt_access */
-enum cmd_bt_access_opts {
+#define CMD_OPT_802_11_RF_CHANNEL_GET       0x00
+#define CMD_OPT_802_11_RF_CHANNEL_SET       0x01
+
+/* Define action or option for CMD_802_11_RF_TX_POWER */
+#define CMD_ACT_TX_POWER_OPT_GET            0x0000
+#define CMD_ACT_TX_POWER_OPT_SET_HIGH       0x8007
+#define CMD_ACT_TX_POWER_OPT_SET_MID        0x8004
+#define CMD_ACT_TX_POWER_OPT_SET_LOW        0x8000
+
+#define CMD_ACT_TX_POWER_INDEX_HIGH         0x0007
+#define CMD_ACT_TX_POWER_INDEX_MID          0x0004
+#define CMD_ACT_TX_POWER_INDEX_LOW          0x0000
+
+/* Define action or option for CMD_802_11_DATA_RATE */
+#define CMD_ACT_SET_tx_auto                 0x0000
+#define CMD_ACT_SET_tx_fix_rate             0x0001
+#define CMD_ACT_GET_tx_rate                 0x0002
+
+#define CMD_ACT_SET_rx                      0x0001
+#define CMD_ACT_SET_tx                      0x0002
+#define CMD_ACT_SET_both                    0x0003
+#define CMD_ACT_GET_rx                      0x0004
+#define CMD_ACT_GET_tx                      0x0008
+#define CMD_ACT_GET_both                    0x000c
+
+/* Define action or option for CMD_802_11_PS_MODE */
+#define CMD_TYPE_CAM                        0x0000
+#define CMD_TYPE_MAX_PSP                    0x0001
+#define CMD_TYPE_FAST_PSP                   0x0002
+
+/* Define action or option for CMD_BT_ACCESS */
+enum CMD_BT_ACCESS_opts {
        /* The bt commands start at 5 instead of 1 because the old dft commands
         * are mapped to 1-4.  These old commands are no longer maintained and
         * should not be called.
         */
-       cmd_act_bt_access_add = 5,
-       cmd_act_bt_access_del,
-       cmd_act_bt_access_list,
-       cmd_act_bt_access_reset,
-       cmd_act_bt_access_set_invert,
-       cmd_act_bt_access_get_invert
+       CMD_ACT_BT_ACCESS_ADD = 5,
+       CMD_ACT_BT_ACCESS_DEL,
+       CMD_ACT_BT_ACCESS_LIST,
+       CMD_ACT_BT_ACCESS_RESET,
+       CMD_ACT_BT_ACCESS_SET_INVERT,
+       CMD_ACT_BT_ACCESS_GET_INVERT
 };
 
-/* Define action or option for cmd_fwt_access */
-enum cmd_fwt_access_opts {
-       cmd_act_fwt_access_add = 1,
-       cmd_act_fwt_access_del,
-       cmd_act_fwt_access_lookup,
-       cmd_act_fwt_access_list,
-       cmd_act_fwt_access_list_route,
-       cmd_act_fwt_access_list_neighbor,
-       cmd_act_fwt_access_reset,
-       cmd_act_fwt_access_cleanup,
-       cmd_act_fwt_access_time,
+/* Define action or option for CMD_FWT_ACCESS */
+enum CMD_FWT_ACCESS_opts {
+       CMD_ACT_FWT_ACCESS_ADD = 1,
+       CMD_ACT_FWT_ACCESS_DEL,
+       CMD_ACT_FWT_ACCESS_LOOKUP,
+       CMD_ACT_FWT_ACCESS_LIST,
+       CMD_ACT_FWT_ACCESS_LIST_route,
+       CMD_ACT_FWT_ACCESS_LIST_neighbor,
+       CMD_ACT_FWT_ACCESS_RESET,
+       CMD_ACT_FWT_ACCESS_CLEANUP,
+       CMD_ACT_FWT_ACCESS_TIME,
 };
 
-/* Define action or option for cmd_mesh_access */
-enum cmd_mesh_access_opts {
-       cmd_act_mesh_get_ttl = 1,
-       cmd_act_mesh_set_ttl,
-       cmd_act_mesh_get_stats,
-       cmd_act_mesh_get_anycast,
-       cmd_act_mesh_set_anycast,
+/* Define action or option for CMD_MESH_ACCESS */
+enum CMD_MESH_ACCESS_opts {
+       CMD_ACT_MESH_GET_TTL = 1,
+       CMD_ACT_MESH_SET_TTL,
+       CMD_ACT_MESH_GET_STATS,
+       CMD_ACT_MESH_GET_ANYCAST,
+       CMD_ACT_MESH_SET_ANYCAST,
 };
 
 /** Card Event definition */
index 23871c0f882a854f6953c4afb53ecc4b24bb838a..76c5fdeb256a91e12ae03c4d052362645305ed6a 100644 (file)
@@ -108,7 +108,7 @@ struct cmd_ds_gen {
 
 #define S_DS_GEN sizeof(struct cmd_ds_gen)
 /*
- * Define data structure for cmd_get_hw_spec
+ * Define data structure for CMD_GET_HW_SPEC
  * This structure defines the response for the GET_HW_SPEC command
  */
 struct cmd_ds_get_hw_spec {
@@ -155,7 +155,7 @@ struct cmd_ds_802_11_subscribe_event {
 
 /*
  * This scan handle Country Information IE(802.11d compliant)
- * Define data structure for cmd_802_11_scan
+ * Define data structure for CMD_802_11_SCAN
  */
 struct cmd_ds_802_11_scan {
        u8 bsstype;
index 11687b84c59662546fd04389701985875507c74d..cf522c6ef57a61b19eba331cc510900960a8478b 100644 (file)
@@ -78,7 +78,7 @@ static void if_usb_write_bulk_callback(struct urb *urb)
                /* Wake main thread if commands are pending */
                if (!adapter->cur_cmd)
                        wake_up_interruptible(&priv->mainthread.waitq);
-               if ((adapter->connect_status == libertas_connected)) {
+               if ((adapter->connect_status == LIBERTAS_CONNECTED)) {
                        netif_wake_queue(dev);
                        netif_wake_queue(priv->mesh_dev);
                }
@@ -758,8 +758,8 @@ static int if_usb_reset_device(wlan_private *priv)
        int ret;
 
        lbs_deb_enter(LBS_DEB_USB);
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_reset,
-                                   cmd_act_halt, 0, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET,
+                                   CMD_ACT_HALT, 0, 0, NULL);
        msleep_interruptible(10);
 
        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
index db467e7876f2977d04d97df06fc2649f0b761e48..3530c23da798bda599ff9ace62ed7e02943fa6b5 100644 (file)
@@ -88,7 +88,7 @@ int libertas_send_deauth(wlan_private * priv)
        int ret = 0;
 
        if (adapter->mode == IW_MODE_INFRA &&
-           adapter->connect_status == libertas_connected)
+           adapter->connect_status == LIBERTAS_CONNECTED)
                ret = libertas_send_deauthentication(priv);
        else
                ret = -ENOTSUPP;
@@ -111,8 +111,8 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
 
        lbs_deb_enter(LBS_DEB_JOIN);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_authenticate,
-                                   0, cmd_option_waitforrsp,
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_AUTHENTICATE,
+                                   0, CMD_OPTION_WAITFORRSP,
                                    0, assoc_req->bss.bssid);
 
        if (ret)
@@ -121,14 +121,14 @@ int wlan_associate(wlan_private * priv, struct assoc_request * assoc_req)
        /* set preamble to firmware */
        if (   (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
            && (assoc_req->bss.capability & WLAN_CAPABILITY_SHORT_PREAMBLE))
-               adapter->preamble = cmd_type_short_preamble;
+               adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
        else
-               adapter->preamble = cmd_type_long_preamble;
+               adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
 
        libertas_set_radio_control(priv);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_associate,
-                                   0, cmd_option_waitforrsp, 0, assoc_req);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_ASSOCIATE,
+                                   0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
 
 done:
        lbs_deb_leave_args(LBS_DEB_JOIN, "ret %d", ret);
@@ -151,10 +151,10 @@ int libertas_start_adhoc_network(wlan_private * priv, struct assoc_request * ass
 
        if (adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) {
                lbs_deb_join("AdhocStart: Short preamble\n");
-               adapter->preamble = cmd_type_short_preamble;
+               adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
        } else {
                lbs_deb_join("AdhocStart: Long preamble\n");
-               adapter->preamble = cmd_type_long_preamble;
+               adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
        }
 
        libertas_set_radio_control(priv);
@@ -162,8 +162,8 @@ int libertas_start_adhoc_network(wlan_private * priv, struct assoc_request * ass
        lbs_deb_join("AdhocStart: channel = %d\n", assoc_req->channel);
        lbs_deb_join("AdhocStart: band = %d\n", assoc_req->band);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_start,
-                                   0, cmd_option_waitforrsp, 0, assoc_req);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_START,
+                                   0, CMD_OPTION_WAITFORRSP, 0, assoc_req);
 
        return ret;
 }
@@ -209,10 +209,10 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
        if (   !(bss->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
            || !(adapter->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)) {
                lbs_deb_join("AdhocJoin: Long preamble\n");
-               adapter->preamble = cmd_type_long_preamble;
+               adapter->preamble = CMD_TYPE_LONG_PREAMBLE;
        } else {
                lbs_deb_join("AdhocJoin: Short preamble\n");
-               adapter->preamble = cmd_type_short_preamble;
+               adapter->preamble = CMD_TYPE_SHORT_PREAMBLE;
        }
 
        libertas_set_radio_control(priv);
@@ -222,8 +222,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
 
        adapter->adhoccreate = 0;
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_join,
-                                   0, cmd_option_waitforrsp,
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_JOIN,
+                                   0, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_SSID, assoc_req);
 
        return ret;
@@ -231,8 +231,8 @@ int libertas_join_adhoc_network(wlan_private * priv, struct assoc_request * asso
 
 int libertas_stop_adhoc_network(wlan_private * priv)
 {
-       return libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_stop,
-                                    0, cmd_option_waitforrsp, 0, NULL);
+       return libertas_prepare_and_send_command(priv, CMD_802_11_AD_HOC_STOP,
+                                    0, CMD_OPTION_WAITFORRSP, 0, NULL);
 }
 
 /**
@@ -243,8 +243,8 @@ int libertas_stop_adhoc_network(wlan_private * priv)
  */
 int libertas_send_deauthentication(wlan_private * priv)
 {
-       return libertas_prepare_and_send_command(priv, cmd_802_11_deauthenticate,
-                                    0, cmd_option_waitforrsp, 0, NULL);
+       return libertas_prepare_and_send_command(priv, CMD_802_11_DEAUTHENTICATE,
+                                    0, CMD_OPTION_WAITFORRSP, 0, NULL);
 }
 
 /**
@@ -267,7 +267,7 @@ int libertas_cmd_80211_authenticate(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_JOIN);
 
-       cmd->command = cpu_to_le16(cmd_802_11_authenticate);
+       cmd->command = cpu_to_le16(CMD_802_11_AUTHENTICATE);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate)
                                + S_DS_GEN);
 
@@ -307,7 +307,7 @@ int libertas_cmd_80211_deauthenticate(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_JOIN);
 
-       cmd->command = cpu_to_le16(cmd_802_11_deauthenticate);
+       cmd->command = cpu_to_le16(CMD_802_11_DEAUTHENTICATE);
        cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) +
                             S_DS_GEN);
 
@@ -349,7 +349,7 @@ int libertas_cmd_80211_associate(wlan_private * priv,
                goto done;
        }
 
-       cmd->command = cpu_to_le16(cmd_802_11_associate);
+       cmd->command = cpu_to_le16(CMD_802_11_ASSOCIATE);
 
        memcpy(passo->peerstaaddr, bss->bssid, sizeof(passo->peerstaaddr));
        pos += sizeof(passo->peerstaaddr);
@@ -465,7 +465,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
                goto done;
        }
 
-       cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_start);
+       cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_START);
 
        /*
         * Fill in the parameters for 2 data structures:
@@ -487,7 +487,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
                     assoc_req->ssid_len);
 
        /* set the BSS type */
-       adhs->bsstype = cmd_bss_type_ibss;
+       adhs->bsstype = CMD_BSS_TYPE_IBSS;
        adapter->mode = IW_MODE_ADHOC;
        adhs->beaconperiod = cpu_to_le16(adapter->beaconperiod);
 
@@ -524,7 +524,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
        adhs->capability = cpu_to_le16(tmpcap);
 
        /* probedelay */
-       adhs->probedelay = cpu_to_le16(cmd_scan_probe_delay_time);
+       adhs->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
 
        memset(adhs->datarate, 0, sizeof(adhs->datarate));
 
@@ -569,7 +569,7 @@ done:
 int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv,
                                struct cmd_ds_command *cmd)
 {
-       cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_stop);
+       cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_STOP);
        cmd->size = cpu_to_le16(S_DS_GEN);
 
        return 0;
@@ -590,9 +590,9 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
 
        lbs_deb_enter(LBS_DEB_JOIN);
 
-       cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_join);
+       cmd->command = cpu_to_le16(CMD_802_11_AD_HOC_JOIN);
 
-       join_cmd->bss.type = cmd_bss_type_ibss;
+       join_cmd->bss.type = CMD_BSS_TYPE_IBSS;
        join_cmd->bss.beaconperiod = cpu_to_le16(bss->beaconperiod);
 
        memcpy(&join_cmd->bss.bssid, &bss->bssid, ETH_ALEN);
@@ -617,7 +617,7 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
        join_cmd->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
 
        /* probedelay */
-       join_cmd->probedelay = cpu_to_le16(cmd_scan_probe_delay_time);
+       join_cmd->probedelay = cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME);
 
        /* Copy Data rates from the rates recorded in scan response */
        memset(join_cmd->bss.datarates, 0, sizeof(join_cmd->bss.datarates));
@@ -659,14 +659,14 @@ int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
                join_cmd->bss.capability = cpu_to_le16(tmp);
        }
 
-       if (adapter->psmode == wlan802_11powermodemax_psp) {
+       if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
                /* wake up first */
                __le32 Localpsmode;
 
-               Localpsmode = cpu_to_le32(wlan802_11powermodecam);
+               Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
                ret = libertas_prepare_and_send_command(priv,
-                                           cmd_802_11_ps_mode,
-                                           cmd_act_set,
+                                           CMD_802_11_PS_MODE,
+                                           CMD_ACT_SET,
                                            0, 0, &Localpsmode);
 
                if (ret) {
@@ -722,7 +722,7 @@ int libertas_ret_80211_associate(wlan_private * priv,
                le16_to_cpu(resp->size) - S_DS_GEN);
 
        /* Send a Media Connected event, according to the Spec */
-       adapter->connect_status = libertas_connected;
+       adapter->connect_status = LIBERTAS_CONNECTED;
 
        lbs_deb_join("ASSOC_RESP: assocated to '%s'\n",
                     escape_essid(bss->ssid, bss->ssid_len));
@@ -802,7 +802,7 @@ int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
         */
        if (result) {
                lbs_deb_join("ADHOC_RESP: failed\n");
-               if (adapter->connect_status == libertas_connected) {
+               if (adapter->connect_status == LIBERTAS_CONNECTED) {
                        libertas_mac_event_disconnected(priv);
                }
                ret = -1;
@@ -817,9 +817,9 @@ int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
                     escape_essid(bss->ssid, bss->ssid_len));
 
        /* Send a Media Connected event, according to the Spec */
-       adapter->connect_status = libertas_connected;
+       adapter->connect_status = LIBERTAS_CONNECTED;
 
-       if (command == cmd_ret_802_11_ad_hoc_start) {
+       if (command == CMD_RET_802_11_AD_HOC_START) {
                /* Update the created network descriptor with the new BSSID */
                memcpy(bss->bssid, padhocresult->bssid, ETH_ALEN);
        }
index 9f366242c392c6afe3e8518129028d89be76a0e4..2315eb61836ee3ea95212d859b31a8b695294ea4 100644 (file)
@@ -187,9 +187,9 @@ static ssize_t libertas_anycast_get(struct device * dev,
 
        memset(&mesh_access, 0, sizeof(mesh_access));
        libertas_prepare_and_send_command(to_net_dev(dev)->priv,
-                       cmd_mesh_access,
-                       cmd_act_mesh_get_anycast,
-                       cmd_option_waitforrsp, 0, (void *)&mesh_access);
+                       CMD_MESH_ACCESS,
+                       CMD_ACT_MESH_GET_ANYCAST,
+                       CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
 
        return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
 }
@@ -208,9 +208,9 @@ static ssize_t libertas_anycast_set(struct device * dev,
        mesh_access.data[0] = cpu_to_le32(datum);
 
        libertas_prepare_and_send_command((to_net_dev(dev))->priv,
-                       cmd_mesh_access,
-                       cmd_act_mesh_set_anycast,
-                       cmd_option_waitforrsp, 0, (void *)&mesh_access);
+                       CMD_MESH_ACCESS,
+                       CMD_ACT_MESH_SET_ANYCAST,
+                       CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
        return strlen(buf);
 }
 
@@ -264,7 +264,7 @@ static int wlan_dev_open(struct net_device *dev)
 
        priv->open = 1;
 
-       if (adapter->connect_status == libertas_connected) {
+       if (adapter->connect_status == LIBERTAS_CONNECTED) {
                netif_carrier_on(priv->dev);
                netif_carrier_on(priv->mesh_dev);
        } else {
@@ -439,7 +439,7 @@ static void wlan_tx_timeout(struct net_device *dev)
                        libertas_send_tx_feedback(priv);
                } else
                        wake_up_interruptible(&priv->mainthread.waitq);
-       } else if (priv->adapter->connect_status == libertas_connected) {
+       } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
                netif_wake_queue(priv->dev);
                netif_wake_queue(priv->mesh_dev);
        }
@@ -480,9 +480,9 @@ static int wlan_set_mac_address(struct net_device *dev, void *addr)
        lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN);
        memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN);
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_mac_address,
-                                   cmd_act_set,
-                                   cmd_option_waitforrsp, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS,
+                                   CMD_ACT_SET,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
 
        if (ret) {
                lbs_deb_net("set MAC address failed\n");
@@ -528,36 +528,36 @@ static void wlan_set_multicast_list(struct net_device *dev)
        if (dev->flags & IFF_PROMISC) {
                lbs_deb_net("enable promiscuous mode\n");
                adapter->currentpacketfilter |=
-                   cmd_act_mac_promiscuous_enable;
+                   CMD_ACT_MAC_PROMISCUOUS_ENABLE;
                adapter->currentpacketfilter &=
-                   ~(cmd_act_mac_all_multicast_enable |
-                     cmd_act_mac_multicast_enable);
+                   ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
+                     CMD_ACT_MAC_MULTICAST_ENABLE);
        } else {
                /* Multicast */
                adapter->currentpacketfilter &=
-                   ~cmd_act_mac_promiscuous_enable;
+                   ~CMD_ACT_MAC_PROMISCUOUS_ENABLE;
 
                if (dev->flags & IFF_ALLMULTI || dev->mc_count >
                    MRVDRV_MAX_MULTICAST_LIST_SIZE) {
                        lbs_deb_net( "enabling all multicast\n");
                        adapter->currentpacketfilter |=
-                           cmd_act_mac_all_multicast_enable;
+                           CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
                        adapter->currentpacketfilter &=
-                           ~cmd_act_mac_multicast_enable;
+                           ~CMD_ACT_MAC_MULTICAST_ENABLE;
                } else {
                        adapter->currentpacketfilter &=
-                           ~cmd_act_mac_all_multicast_enable;
+                           ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
 
                        if (!dev->mc_count) {
                                lbs_deb_net("no multicast addresses, "
                                       "disabling multicast\n");
                                adapter->currentpacketfilter &=
-                                   ~cmd_act_mac_multicast_enable;
+                                   ~CMD_ACT_MAC_MULTICAST_ENABLE;
                        } else {
                                int i;
 
                                adapter->currentpacketfilter |=
-                                   cmd_act_mac_multicast_enable;
+                                   CMD_ACT_MAC_MULTICAST_ENABLE;
 
                                adapter->nr_of_multicastmacaddr =
                                    wlan_copy_multicast_address(adapter, dev);
@@ -577,8 +577,8 @@ static void wlan_set_multicast_list(struct net_device *dev)
                                }
                                /* send multicast addresses to firmware */
                                libertas_prepare_and_send_command(priv,
-                                                     cmd_mac_multicast_adr,
-                                                     cmd_act_set, 0, 0,
+                                                     CMD_MAC_MULTICAST_ADR,
+                                                     CMD_ACT_SET, 0, 0,
                                                      NULL);
                        }
                }
@@ -711,7 +711,7 @@ static int wlan_service_main_thread(void *data)
                if (adapter->psstate == PS_STATE_PRE_SLEEP) {
                        if (!priv->dnld_sent && !adapter->cur_cmd) {
                                if (adapter->connect_status ==
-                                   libertas_connected) {
+                                   LIBERTAS_CONNECTED) {
                                        lbs_deb_thread(
                                               "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p "
                                               "dnld_sent=%d cur_cmd=%p, confirm now\n",
@@ -1005,9 +1005,9 @@ int libertas_remove_card(wlan_private *priv)
        cancel_delayed_work(&priv->assoc_work);
        destroy_workqueue(priv->assoc_thread);
 
-       if (adapter->psmode == wlan802_11powermodemax_psp) {
-               adapter->psmode = wlan802_11powermodecam;
-               libertas_ps_wakeup(priv, cmd_option_waitforrsp);
+       if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
+               adapter->psmode = WLAN802_11POWERMODECAM;
+               libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
        }
 
        memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
index 2937f79c4a015166cfcc545a7490c0aa7381b442..2cac47fc4cd973a465f8c558fe0d8e13a9f84ea9 100644 (file)
@@ -255,7 +255,7 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
 
        for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) {
                if (priv->adapter->enable11d &&
-                   adapter->connect_status != libertas_connected) {
+                   adapter->connect_status != LIBERTAS_CONNECTED) {
                        /* Scan all the supported chan for the first scan */
                        if (!adapter->universal_channel[rgnidx].valid)
                                continue;
@@ -287,11 +287,11 @@ static void wlan_scan_create_channel_list(wlan_private * priv,
                        case BAND_G:
                        default:
                                scanchanlist[chanidx].radiotype =
-                                   cmd_scan_radio_type_bg;
+                                   CMD_SCAN_RADIO_TYPE_BG;
                                break;
                        }
 
-                       if (scantype == cmd_scan_type_passive) {
+                       if (scantype == CMD_SCAN_TYPE_PASSIVE) {
                                scanchanlist[chanidx].maxscantime =
                                    cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME);
                                scanchanlist[chanidx].chanscanmode.passivescan =
@@ -486,7 +486,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
 
                        scantype = puserscanin->chanlist[chanidx].scantype;
 
-                       if (scantype == cmd_scan_type_passive) {
+                       if (scantype == CMD_SCAN_TYPE_PASSIVE) {
                                (pscanchanlist +
                                 chanidx)->chanscanmode.passivescan = 1;
                        } else {
@@ -498,7 +498,7 @@ wlan_scan_setup_scan_config(wlan_private * priv,
                                scandur =
                                    puserscanin->chanlist[chanidx].scantime;
                        } else {
-                               if (scantype == cmd_scan_type_passive) {
+                               if (scantype == CMD_SCAN_TYPE_PASSIVE) {
                                        scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME;
                                } else {
                                        scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME;
@@ -668,7 +668,7 @@ static int wlan_scan_channel_list(wlan_private * priv,
                }
 
                /* Send the scan command to the firmware with the specified cfg */
-               ret = libertas_prepare_and_send_command(priv, cmd_802_11_scan, 0,
+               ret = libertas_prepare_and_send_command(priv, CMD_802_11_SCAN, 0,
                                            0, 0, pscancfgout);
                if (scanned >= 2 && !full_scan) {
                        ret = 0;
@@ -816,7 +816,7 @@ int wlan_scan_networks(wlan_private * priv,
        mutex_unlock(&adapter->lock);
 #endif
 
-       if (priv->adapter->connect_status == libertas_connected) {
+       if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
                netif_carrier_on(priv->dev);
                netif_wake_queue(priv->dev);
                netif_carrier_on(priv->mesh_dev);
@@ -1603,8 +1603,8 @@ int libertas_get_scan(struct net_device *dev, struct iw_request_info *info,
 
        /* Update RSSI if current BSS is a locally created ad-hoc BSS */
        if ((adapter->mode == IW_MODE_ADHOC) && adapter->adhoccreate) {
-               libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0,
-                                       cmd_option_waitforrsp, 0, NULL);
+               libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
+                                       CMD_OPTION_WAITFORRSP, 0, NULL);
        }
 
        mutex_lock(&adapter->lock);
@@ -1680,7 +1680,7 @@ int libertas_cmd_80211_scan(wlan_private * priv,
        memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN);
        memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen);
 
-       cmd->command = cpu_to_le16(cmd_802_11_scan);
+       cmd->command = cpu_to_le16(CMD_802_11_SCAN);
 
        /* size is equal to the sizeof(fixed portions) + the TLV len + header */
        cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN
index 17c437635a00845932231337c5d8aac1a00a89cf..c2271020aafeebd5e7c9ad8edb6a8b580df5ec30 100644 (file)
@@ -283,7 +283,7 @@ void libertas_send_tx_feedback(wlan_private * priv)
        libertas_upload_rx_packet(priv, adapter->currenttxskb);
        adapter->currenttxskb = NULL;
        priv->adapter->TxLockFlag = 0;
-       if (priv->adapter->connect_status == libertas_connected) {
+       if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
                netif_wake_queue(priv->dev);
                netif_wake_queue(priv->mesh_dev);
        }
index f7df8c71a544f3660f93fe8a83b307cb25694065..7cfca5f3a5ef7b705bf1fbcd3ac9176e94e5320d 100644 (file)
@@ -177,9 +177,9 @@ int wlan_radio_ioctl(wlan_private * priv, u8 option)
                adapter->radioon = option;
 
                ret = libertas_prepare_and_send_command(priv,
-                                           cmd_802_11_radio_control,
-                                           cmd_act_set,
-                                           cmd_option_waitforrsp, 0, NULL);
+                                           CMD_802_11_RADIO_CONTROL,
+                                           CMD_ACT_SET,
+                                           CMD_OPTION_WAITFORRSP, 0, NULL);
        }
 
        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -221,7 +221,7 @@ static int get_active_data_rates(wlan_adapter * adapter,
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
-       if (adapter->connect_status != libertas_connected) {
+       if (adapter->connect_status != LIBERTAS_CONNECTED) {
                if (adapter->mode == IW_MODE_INFRA) {
                        lbs_deb_wext("infra\n");
                        k = copyrates(rates, k, libertas_supported_rates,
@@ -305,7 +305,7 @@ static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
 
        lbs_deb_enter(LBS_DEB_WEXT);
 
-       if (adapter->connect_status == libertas_connected) {
+       if (adapter->connect_status == LIBERTAS_CONNECTED) {
                memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
        } else {
                memset(awrq->sa_data, 0, ETH_ALEN);
@@ -382,7 +382,7 @@ static int mesh_get_nick(struct net_device *dev, struct iw_request_info *info,
 
        /* Use nickname to indicate that mesh is on */
 
-       if (adapter->connect_status == libertas_connected) {
+       if (adapter->connect_status == LIBERTAS_CONNECTED) {
                strncpy(extra, "Mesh", 12);
                extra[12] = '\0';
                dwrq->length = strlen(extra) + 1;
@@ -414,8 +414,8 @@ static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
                adapter->rtsthsd = rthr;
        }
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
-                                   cmd_act_set, cmd_option_waitforrsp,
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_RTS_THRESHOLD, &rthr);
 
        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -432,8 +432,8 @@ static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
        lbs_deb_enter(LBS_DEB_WEXT);
 
        adapter->rtsthsd = 0;
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
-                                   cmd_act_get, cmd_option_waitforrsp,
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_RTS_THRESHOLD, NULL);
        if (ret)
                goto out;
@@ -467,8 +467,8 @@ static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
                adapter->fragthsd = fthr;
        }
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
-                                   cmd_act_set, cmd_option_waitforrsp,
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
 
        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
@@ -486,8 +486,8 @@ static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info,
 
        adapter->fragthsd = 0;
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_snmp_mib,
-                                   cmd_act_get, cmd_option_waitforrsp,
+                                   CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
        if (ret)
                goto out;
@@ -539,9 +539,9 @@ static int wlan_get_txpow(struct net_device *dev,
        lbs_deb_enter(LBS_DEB_WEXT);
 
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_rf_tx_power,
-                                   cmd_act_tx_power_opt_get,
-                                   cmd_option_waitforrsp, 0, NULL);
+                                   CMD_802_11_RF_TX_POWER,
+                                   CMD_ACT_TX_POWER_OPT_GET,
+                                   CMD_OPTION_WAITFORRSP, 0, NULL);
 
        if (ret)
                goto out;
@@ -581,9 +581,9 @@ static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
                /* Adding 1 to convert retry count to try count */
                adapter->txretrycount = vwrq->value + 1;
 
-               ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
-                                           cmd_act_set,
-                                           cmd_option_waitforrsp,
+               ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
+                                           CMD_ACT_SET,
+                                           CMD_OPTION_WAITFORRSP,
                                            OID_802_11_TX_RETRYCOUNT, NULL);
 
                if (ret)
@@ -608,8 +608,8 @@ static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
 
        adapter->txretrycount = 0;
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_snmp_mib,
-                                   cmd_act_get, cmd_option_waitforrsp,
+                                   CMD_802_11_SNMP_MIB,
+                                   CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
                                    OID_802_11_TX_RETRYCOUNT, NULL);
        if (ret)
                goto out;
@@ -698,7 +698,7 @@ static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
 
        range->num_frequency = 0;
        if (priv->adapter->enable11d &&
-           adapter->connect_status == libertas_connected) {
+           adapter->connect_status == LIBERTAS_CONNECTED) {
                u8 chan_no;
                u8 band;
 
@@ -858,9 +858,9 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
         */
 
        if (vwrq->disabled) {
-               adapter->psmode = wlan802_11powermodecam;
+               adapter->psmode = WLAN802_11POWERMODECAM;
                if (adapter->psstate != PS_STATE_FULL_POWER) {
-                       libertas_ps_wakeup(priv, cmd_option_waitforrsp);
+                       libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
                }
 
                return 0;
@@ -875,14 +875,14 @@ static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
                return -EINVAL;
        }
 
-       if (adapter->psmode != wlan802_11powermodecam) {
+       if (adapter->psmode != WLAN802_11POWERMODECAM) {
                return 0;
        }
 
-       adapter->psmode = wlan802_11powermodemax_psp;
+       adapter->psmode = WLAN802_11POWERMODEMAX_PSP;
 
-       if (adapter->connect_status == libertas_connected) {
-               libertas_ps_sleep(priv, cmd_option_waitforrsp);
+       if (adapter->connect_status == LIBERTAS_CONNECTED) {
+               libertas_ps_sleep(priv, CMD_OPTION_WAITFORRSP);
        }
 
        lbs_deb_leave(LBS_DEB_WEXT);
@@ -900,8 +900,8 @@ static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
 
        mode = adapter->psmode;
 
-       if ((vwrq->disabled = (mode == wlan802_11powermodecam))
-           || adapter->connect_status == libertas_disconnected)
+       if ((vwrq->disabled = (mode == WLAN802_11POWERMODECAM))
+           || adapter->connect_status == LIBERTAS_DISCONNECTED)
        {
                goto out;
        }
@@ -937,7 +937,7 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
        priv->wstats.status = adapter->mode;
 
        /* If we're not associated, all quality values are meaningless */
-       if (adapter->connect_status != libertas_connected)
+       if (adapter->connect_status != LIBERTAS_CONNECTED)
                goto out;
 
        /* Quality by RSSI */
@@ -1000,9 +1000,9 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
        stats_valid = 1;
 
        /* update stats asynchronously for future calls */
-       libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0,
+       libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
                                        0, 0, NULL);
-       libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0,
+       libertas_prepare_and_send_command(priv, CMD_802_11_GET_LOG, 0,
                                        0, 0, NULL);
 out:
        if (!stats_valid) {
@@ -1128,7 +1128,7 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
        lbs_deb_wext("vwrq->value %d\n", vwrq->value);
 
        if (vwrq->value == -1) {
-               action = cmd_act_set_tx_auto;   // Auto
+               action = CMD_ACT_SET_tx_auto;   // Auto
                adapter->is_datarate_auto = 1;
                adapter->datarate = 0;
        } else {
@@ -1155,12 +1155,12 @@ static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
                }
 
                adapter->datarate = data_rate;
-               action = cmd_act_set_tx_fix_rate;
+               action = CMD_ACT_SET_tx_fix_rate;
                adapter->is_datarate_auto = 0;
        }
 
-       ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
-                                   action, cmd_option_waitforrsp, 0, NULL);
+       ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
+                                   action, CMD_OPTION_WAITFORRSP, 0, NULL);
 
        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
        return ret;
@@ -1976,7 +1976,7 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
                return 0;
        }
 
-       adapter->preamble = cmd_type_auto_preamble;
+       adapter->preamble = CMD_TYPE_AUTO_PREAMBLE;
 
        wlan_radio_ioctl(priv, RADIO_ON);
 
@@ -1993,9 +1993,9 @@ static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
        lbs_deb_wext("txpower set %d dbm\n", dbm);
 
        ret = libertas_prepare_and_send_command(priv,
-                                   cmd_802_11_rf_tx_power,
-                                   cmd_act_tx_power_opt_set_low,
-                                   cmd_option_waitforrsp, 0, (void *)&dbm);
+                                   CMD_802_11_RF_TX_POWER,
+                                   CMD_ACT_TX_POWER_OPT_SET_LOW,
+                                   CMD_OPTION_WAITFORRSP, 0, (void *)&dbm);
 
        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
        return ret;
@@ -2017,7 +2017,7 @@ static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
        /*
         * Get the current SSID
         */
-       if (adapter->connect_status == libertas_connected) {
+       if (adapter->connect_status == LIBERTAS_CONNECTED) {
                memcpy(extra, adapter->curbssparams.ssid,
                       adapter->curbssparams.ssid_len);
                extra[adapter->curbssparams.ssid_len] = '\0';