Changeset 10235


Ignore:
Timestamp:
2008-01-24T04:03:04+01:00 (10 years ago)
Author:
ryd
Message:

Updating libertas wireless driver to latest version.

Location:
trunk/package/libertas
Files:
2 added
1 deleted
22 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/libertas/Makefile

    r9768 r10235  
    11#  
    2 # Copyright (C) 2007 OpenWrt.org 
     2# Copyright (C) 2007 - 2008 OpenWrt.org 
    33# 
    44# This is free software, licensed under the GNU General Public License v2. 
     
    3434        mkdir -p $(PKG_BUILD_DIR) 
    3535        $(CP) ./src/* $(PKG_BUILD_DIR)/ 
     36        $(Build/Patch) 
     37        $(if $(QUILT),touch $(PKG_BUILD_DIR)/.quilt_used) 
    3638endef 
    3739 
     
    4345                CONFIG_LIBERTAS=m \ 
    4446                CONFIG_LIBERTAS_USB=m \ 
    45                 EXTRA_CFLAGS="-I$(PKG_BUILD_DIR) -include compat.h -I$(STAGING_DIR)/usr/include/mac80211" \ 
     47                EXTRA_CFLAGS="-I$(PKG_BUILD_DIR) -DCONFIG_LIBERTAS_DEBUG -include compat.h -I$(STAGING_DIR)/usr/include/mac80211" \ 
    4648                modules  
    4749endef 
  • trunk/package/libertas/src/11d.c

    r9768 r10235  
    4747{ 
    4848        u8 i; 
     49        u8 size = sizeof(region_code_mapping)/ 
     50                  sizeof(struct region_code_mapping); 
    4951 
    5052        for (i = 0; region[i] && i < COUNTRY_CODE_LEN; i++) 
    5153                region[i] = toupper(region[i]); 
    5254 
    53         for (i = 0; i < ARRAY_SIZE(region_code_mapping); i++) { 
     55        for (i = 0; i < size; i++) { 
    5456                if (!memcmp(region, region_code_mapping[i].region, 
    5557                            COUNTRY_CODE_LEN)) 
     
    6466{ 
    6567        u8 i; 
    66  
    67         for (i = 0; i < ARRAY_SIZE(region_code_mapping); i++) { 
     68        u8 size = sizeof(region_code_mapping) 
     69                  / sizeof(struct region_code_mapping); 
     70        for (i = 0; i < size; i++) { 
    6871                if (region_code_mapping[i].code == code) 
    6972                        return (region_code_mapping[i].region); 
     
    8891 
    8992        cfp = channel_freq_power_UN_BG; 
    90         cfp_no = ARRAY_SIZE(channel_freq_power_UN_BG); 
     93        cfp_no = sizeof(channel_freq_power_UN_BG) / 
     94            sizeof(struct chan_freq_power); 
    9195 
    9296        for (i = 0; i < cfp_no; i++) { 
     
    138142{ 
    139143        struct chan_freq_power *cf; 
     144        u16 cnt; 
    140145        u16 i; 
    141146        u32 freq = 0; 
    142147 
    143148        cf = channel_freq_power_UN_BG; 
    144  
    145         for (i = 0; i < ARRAY_SIZE(channel_freq_power_UN_BG); i++) { 
     149        cnt = 
     150            sizeof(channel_freq_power_UN_BG) / 
     151            sizeof(struct chan_freq_power); 
     152 
     153        for (i = 0; i < cnt; i++) { 
    146154                if (chan == cf[i].channel) 
    147155                        freq = cf[i].freq; 
  • trunk/package/libertas/src/assoc.c

    r9768 r10235  
    164164 
    165165 
    166 static int update_channel(struct lbs_private *priv) 
     166int lbs_update_channel(struct lbs_private *priv) 
    167167{ 
    168168        int ret; 
    169169 
    170         /* the channel in f/w could be out of sync, get the current channel */ 
     170        /* the channel in f/w could be out of sync; get the current channel */ 
    171171        lbs_deb_enter(LBS_DEB_ASSOC); 
    172172 
    173173        ret = lbs_get_channel(priv); 
    174         if (ret > 0) 
    175                 priv->curbssparams.channel = (u8) ret; 
    176  
     174        if (ret > 0) { 
     175                priv->curbssparams.channel = ret; 
     176                ret = 0; 
     177        } 
    177178        lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret); 
    178179        return ret; 
     
    185186 
    186187        lbs_deb_enter(LBS_DEB_ASSOC); 
    187         if (update_channel(priv) != 0) 
     188        if (lbs_update_channel(priv)) 
    188189                lbs_pr_info("Channel synchronization failed."); 
    189190        lbs_deb_leave(LBS_DEB_ASSOC); 
     
    197198        lbs_deb_enter(LBS_DEB_ASSOC); 
    198199 
    199         ret = update_channel(priv); 
    200         if (ret < 0) { 
    201                 lbs_deb_assoc("ASSOC: channel: error getting channel."); 
     200        ret = lbs_update_channel(priv); 
     201        if (ret) { 
     202                lbs_deb_assoc("ASSOC: channel: error getting channel.\n"); 
     203                goto done; 
    202204        } 
    203205 
     
    206208 
    207209        if (priv->mesh_dev) { 
    208                 /* Disconnect mesh while associating -- otherwise it 
    209                    won't let us change channels */ 
    210                 lbs_mesh_config(priv, 0); 
     210                /* Change mesh channel first; 21.p21 firmware won't let 
     211                   you change channel otherwise (even though it'll return 
     212                   an error to this */ 
     213                lbs_mesh_config(priv, 0, assoc_req->channel); 
    211214        } 
    212215 
    213216        lbs_deb_assoc("ASSOC: channel: %d -> %d\n", 
    214                priv->curbssparams.channel, assoc_req->channel); 
     217                      priv->curbssparams.channel, assoc_req->channel); 
    215218 
    216219        ret = lbs_set_channel(priv, assoc_req->channel); 
    217220        if (ret < 0) 
    218                 lbs_deb_assoc("ASSOC: channel: error setting channel."); 
     221                lbs_deb_assoc("ASSOC: channel: error setting channel.\n"); 
    219222 
    220223        /* FIXME: shouldn't need to grab the channel _again_ after setting 
    221224         * it since the firmware is supposed to return the new channel, but 
    222225         * whatever... */ 
    223         ret = update_channel(priv); 
    224         if (ret < 0) 
    225                 lbs_deb_assoc("ASSOC: channel: error getting channel."); 
     226        ret = lbs_update_channel(priv); 
     227        if (ret) { 
     228                lbs_deb_assoc("ASSOC: channel: error getting channel.\n"); 
     229                goto done; 
     230        } 
    226231 
    227232        if (assoc_req->channel != priv->curbssparams.channel) { 
     
    241246 
    242247        /* Must restart/rejoin adhoc networks after channel change */ 
    243         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags); 
     248        set_bit(ASSOC_FLAG_SSID, &assoc_req->flags); 
    244249 
    245250 restore_mesh: 
    246251        if (priv->mesh_dev) 
    247                 lbs_mesh_config(priv, 1); 
     252                lbs_mesh_config(priv, 1, priv->curbssparams.channel); 
    248253 
    249254 done: 
     
    254259 
    255260static int assoc_helper_wep_keys(struct lbs_private *priv, 
    256                                  struct assoc_request * assoc_req) 
     261                                 struct assoc_request *assoc_req) 
    257262{ 
    258263        int i; 
     
    262267 
    263268        /* Set or remove WEP keys */ 
    264         if (   assoc_req->wep_keys[0].len 
    265             || assoc_req->wep_keys[1].len 
    266             || assoc_req->wep_keys[2].len 
    267             || assoc_req->wep_keys[3].len) { 
    268                 ret = lbs_prepare_and_send_command(priv, 
    269                                             CMD_802_11_SET_WEP, 
    270                                             CMD_ACT_ADD, 
    271                                             CMD_OPTION_WAITFORRSP, 
    272                                             0, assoc_req); 
    273         } else { 
    274                 ret = lbs_prepare_and_send_command(priv, 
    275                                             CMD_802_11_SET_WEP, 
    276                                             CMD_ACT_REMOVE, 
    277                                             CMD_OPTION_WAITFORRSP, 
    278                                             0, NULL); 
    279         } 
     269        if (assoc_req->wep_keys[0].len || assoc_req->wep_keys[1].len || 
     270            assoc_req->wep_keys[2].len || assoc_req->wep_keys[3].len) 
     271                ret = lbs_cmd_802_11_set_wep(priv, CMD_ACT_ADD, assoc_req); 
     272        else 
     273                ret = lbs_cmd_802_11_set_wep(priv, CMD_ACT_REMOVE, assoc_req); 
    280274 
    281275        if (ret) 
     
    287281        else 
    288282                priv->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE; 
     283 
    289284        ret = lbs_set_mac_packet_filter(priv); 
    290285        if (ret) 
     
    296291        for (i = 0; i < 4; i++) { 
    297292                memcpy(&priv->wep_keys[i], &assoc_req->wep_keys[i], 
    298                         sizeof(struct enc_key)); 
     293                       sizeof(struct enc_key)); 
    299294        } 
    300295        priv->wep_tx_keyidx = assoc_req->wep_tx_keyidx; 
     
    311306{ 
    312307        int ret = 0; 
    313         u32 do_wpa; 
    314         u32 rsn = 0; 
     308        uint16_t do_wpa; 
     309        uint16_t rsn = 0; 
    315310 
    316311        lbs_deb_enter(LBS_DEB_ASSOC); 
     
    329324 
    330325        /* Get RSN enabled/disabled */ 
    331         ret = lbs_prepare_and_send_command(priv, 
    332                                     CMD_802_11_ENABLE_RSN, 
    333                                     CMD_ACT_GET, 
    334                                     CMD_OPTION_WAITFORRSP, 
    335                                     0, &rsn); 
     326        ret = lbs_cmd_802_11_enable_rsn(priv, CMD_ACT_GET, &rsn); 
    336327        if (ret) { 
    337                 lbs_deb_assoc("Failed to get RSN status: %d", ret); 
     328                lbs_deb_assoc("Failed to get RSN status: %d\n", ret); 
    338329                goto out; 
    339330        } 
    340331 
    341332        /* Don't re-enable RSN if it's already enabled */ 
    342         do_wpa = (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled); 
     333        do_wpa = assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled; 
    343334        if (do_wpa == rsn) 
    344335                goto out; 
    345336 
    346337        /* Set RSN enabled/disabled */ 
    347         rsn = do_wpa; 
    348         ret = lbs_prepare_and_send_command(priv, 
    349                                     CMD_802_11_ENABLE_RSN, 
    350                                     CMD_ACT_SET, 
    351                                     CMD_OPTION_WAITFORRSP, 
    352                                     0, &rsn); 
     338        ret = lbs_cmd_802_11_enable_rsn(priv, CMD_ACT_SET, &do_wpa); 
    353339 
    354340out: 
  • trunk/package/libertas/src/cmd.c

    r9768 r10235  
    1414#include "cmd.h" 
    1515 
    16 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode); 
    1716static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv); 
    1817static void lbs_set_cmd_ctrl_node(struct lbs_private *priv, 
    1918                    struct cmd_ctrl_node *ptempnode, 
    20                     u16 wait_option, void *pdata_buf); 
     19                    void *pdata_buf); 
    2120 
    2221 
     
    5756        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
    5857        memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN); 
    59         ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, cmd); 
     58        ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd); 
    6059        if (ret) 
    6160                goto out; 
     
    111110        return ret; 
    112111} 
     112 
     113int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria) 
     114{ 
     115        struct cmd_ds_host_sleep cmd_config; 
     116        int ret; 
     117 
     118        cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config)); 
     119        cmd_config.criteria = cpu_to_le32(criteria); 
     120        cmd_config.gpio = priv->wol_gpio; 
     121        cmd_config.gap = priv->wol_gap; 
     122 
     123        ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config); 
     124        if (!ret) { 
     125                lbs_deb_cmd("Set WOL criteria to %x\n", criteria); 
     126                priv->wol_criteria = criteria; 
     127        } else { 
     128                lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret); 
     129        } 
     130 
     131        return ret; 
     132} 
     133EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg); 
    113134 
    114135static int lbs_cmd_802_11_ps_mode(struct lbs_private *priv, 
     
    151172} 
    152173 
    153 static int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv, 
    154                                               struct cmd_ds_command *cmd, 
    155                                               u16 cmd_action, void *pdata_buf) 
    156 { 
    157         u16 *timeout = pdata_buf; 
    158  
    159         lbs_deb_enter(LBS_DEB_CMD); 
    160  
    161         cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT); 
    162         cmd->size = 
    163             cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout) 
    164                              + S_DS_GEN); 
    165  
    166         cmd->params.inactivity_timeout.action = cpu_to_le16(cmd_action); 
    167  
    168         if (cmd_action) 
    169                 cmd->params.inactivity_timeout.timeout = cpu_to_le16(*timeout); 
     174int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv, 
     175                                      uint16_t cmd_action, uint16_t *timeout) 
     176{ 
     177        struct cmd_ds_802_11_inactivity_timeout cmd; 
     178        int ret; 
     179 
     180        lbs_deb_enter(LBS_DEB_CMD); 
     181 
     182        cmd.hdr.command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT); 
     183        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     184 
     185        cmd.action = cpu_to_le16(cmd_action); 
     186 
     187        if (cmd_action == CMD_ACT_SET) 
     188                cmd.timeout = cpu_to_le16(*timeout); 
    170189        else 
    171                 cmd->params.inactivity_timeout.timeout = 0; 
    172  
    173         lbs_deb_leave(LBS_DEB_CMD); 
     190                cmd.timeout = 0; 
     191 
     192        ret = lbs_cmd_with_response(priv, CMD_802_11_INACTIVITY_TIMEOUT, &cmd); 
     193 
     194        if (!ret) 
     195                *timeout = le16_to_cpu(cmd.timeout); 
     196 
     197        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 
    174198        return 0; 
    175199} 
    176200 
    177 static int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, 
    178                                         struct cmd_ds_command *cmd, 
    179                                         u16 cmd_action) 
    180 { 
    181         struct cmd_ds_802_11_sleep_params *sp = &cmd->params.sleep_params; 
    182  
    183         lbs_deb_enter(LBS_DEB_CMD); 
    184  
    185         cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) + 
    186                                 S_DS_GEN); 
    187         cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS); 
     201int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action, 
     202                                struct sleep_params *sp) 
     203{ 
     204        struct cmd_ds_802_11_sleep_params cmd; 
     205        int ret; 
     206 
     207        lbs_deb_enter(LBS_DEB_CMD); 
    188208 
    189209        if (cmd_action == CMD_ACT_GET) { 
    190                 memset(&priv->sp, 0, sizeof(struct sleep_params)); 
    191                 memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params)); 
    192                 sp->action = cpu_to_le16(cmd_action); 
    193         } else if (cmd_action == CMD_ACT_SET) { 
    194                 sp->action = cpu_to_le16(cmd_action); 
    195                 sp->error = cpu_to_le16(priv->sp.sp_error); 
    196                 sp->offset = cpu_to_le16(priv->sp.sp_offset); 
    197                 sp->stabletime = cpu_to_le16(priv->sp.sp_stabletime); 
    198                 sp->calcontrol = (u8) priv->sp.sp_calcontrol; 
    199                 sp->externalsleepclk = (u8) priv->sp.sp_extsleepclk; 
    200                 sp->reserved = cpu_to_le16(priv->sp.sp_reserved); 
    201         } 
    202  
    203         lbs_deb_leave(LBS_DEB_CMD); 
     210                memset(&cmd, 0, sizeof(cmd)); 
     211        } else { 
     212                cmd.error = cpu_to_le16(sp->sp_error); 
     213                cmd.offset = cpu_to_le16(sp->sp_offset); 
     214                cmd.stabletime = cpu_to_le16(sp->sp_stabletime); 
     215                cmd.calcontrol = sp->sp_calcontrol; 
     216                cmd.externalsleepclk = sp->sp_extsleepclk; 
     217                cmd.reserved = cpu_to_le16(sp->sp_reserved); 
     218        } 
     219        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     220        cmd.action = cpu_to_le16(cmd_action); 
     221 
     222        ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd); 
     223 
     224        if (!ret) { 
     225                lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, " 
     226                            "calcontrol 0x%x extsleepclk 0x%x\n", 
     227                            le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset), 
     228                            le16_to_cpu(cmd.stabletime), cmd.calcontrol, 
     229                            cmd.externalsleepclk); 
     230 
     231                sp->sp_error = le16_to_cpu(cmd.error); 
     232                sp->sp_offset = le16_to_cpu(cmd.offset); 
     233                sp->sp_stabletime = le16_to_cpu(cmd.stabletime); 
     234                sp->sp_calcontrol = cmd.calcontrol; 
     235                sp->sp_extsleepclk = cmd.externalsleepclk; 
     236                sp->sp_reserved = le16_to_cpu(cmd.reserved); 
     237        } 
     238 
     239        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 
    204240        return 0; 
    205241} 
    206242 
    207 static int lbs_cmd_802_11_set_wep(struct lbs_private *priv, 
    208                                    struct cmd_ds_command *cmd, 
    209                                    u32 cmd_act, 
    210                                    void * pdata_buf) 
    211 { 
    212         struct cmd_ds_802_11_set_wep *wep = &cmd->params.wep; 
     243int lbs_cmd_802_11_set_wep(struct lbs_private *priv, uint16_t cmd_action, 
     244                           struct assoc_request *assoc) 
     245{ 
     246        struct cmd_ds_802_11_set_wep cmd; 
    213247        int ret = 0; 
    214         struct assoc_request * assoc_req = pdata_buf; 
    215  
    216         lbs_deb_enter(LBS_DEB_CMD); 
    217  
    218         cmd->command = cpu_to_le16(CMD_802_11_SET_WEP); 
    219         cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN); 
    220  
    221         if (cmd_act == CMD_ACT_ADD) { 
     248 
     249        lbs_deb_enter(LBS_DEB_CMD); 
     250 
     251        cmd.hdr.command = cpu_to_le16(CMD_802_11_SET_WEP); 
     252        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     253 
     254        cmd.action = cpu_to_le16(cmd_action); 
     255 
     256        if (cmd_action == CMD_ACT_ADD) { 
    222257                int i; 
    223258 
    224                 if (!assoc_req) { 
    225                         lbs_deb_cmd("Invalid association request!"); 
    226                         ret = -1; 
    227                         goto done; 
    228                 } 
    229  
    230                 wep->action = cpu_to_le16(CMD_ACT_ADD); 
    231  
    232259                /* default tx key index */ 
    233                 wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx & 
    234                                                   (u32)CMD_WEP_KEY_INDEX_MASK)); 
     260                cmd.keyindex = cpu_to_le16(assoc->wep_tx_keyidx & 
     261                                           CMD_WEP_KEY_INDEX_MASK); 
    235262 
    236263                /* Copy key types and material to host command structure */ 
    237264                for (i = 0; i < 4; i++) { 
    238                         struct enc_key * pkey = &assoc_req->wep_keys[i]; 
     265                        struct enc_key *pkey = &assoc->wep_keys[i]; 
    239266 
    240267                        switch (pkey->len) { 
    241268                        case KEY_LEN_WEP_40: 
    242                                 wep->keytype[i] = CMD_TYPE_WEP_40_BIT; 
    243                                 memmove(&wep->keymaterial[i], pkey->key, 
    244                                         pkey->len); 
     269                                cmd.keytype[i] = CMD_TYPE_WEP_40_BIT; 
     270                                memmove(cmd.keymaterial[i], pkey->key, pkey->len); 
    245271                                lbs_deb_cmd("SET_WEP: add key %d (40 bit)\n", i); 
    246272                                break; 
    247273                        case KEY_LEN_WEP_104: 
    248                                 wep->keytype[i] = CMD_TYPE_WEP_104_BIT; 
    249                                 memmove(&wep->keymaterial[i], pkey->key, 
    250                                         pkey->len); 
     274                                cmd.keytype[i] = CMD_TYPE_WEP_104_BIT; 
     275                                memmove(cmd.keymaterial[i], pkey->key, pkey->len); 
    251276                                lbs_deb_cmd("SET_WEP: add key %d (104 bit)\n", i); 
    252277                                break; 
     
    255280                        default: 
    256281                                lbs_deb_cmd("SET_WEP: invalid key %d, length %d\n", 
    257                                        i, pkey->len); 
     282                                            i, pkey->len); 
    258283                                ret = -1; 
    259284                                goto done; 
     
    261286                        } 
    262287                } 
    263         } else if (cmd_act == CMD_ACT_REMOVE) { 
     288        } else if (cmd_action == CMD_ACT_REMOVE) { 
    264289                /* ACT_REMOVE clears _all_ WEP keys */ 
    265                 wep->action = cpu_to_le16(CMD_ACT_REMOVE); 
    266290 
    267291                /* default tx key index */ 
    268                 wep->keyindex = cpu_to_le16((u16)(priv->wep_tx_keyidx & 
    269                                                   (u32)CMD_WEP_KEY_INDEX_MASK)); 
     292                cmd.keyindex = cpu_to_le16(priv->wep_tx_keyidx & 
     293                                           CMD_WEP_KEY_INDEX_MASK); 
    270294                lbs_deb_cmd("SET_WEP: remove key %d\n", priv->wep_tx_keyidx); 
    271295        } 
    272296 
    273         ret = 0; 
    274  
     297        ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd); 
    275298done: 
    276299        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 
     
    278301} 
    279302 
    280 static int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv, 
    281                                       struct cmd_ds_command *cmd, 
    282                                       u16 cmd_action, 
    283                                       void * pdata_buf) 
    284 { 
    285         struct cmd_ds_802_11_enable_rsn *penableRSN = &cmd->params.enbrsn; 
    286         u32 * enable = pdata_buf; 
    287  
    288         lbs_deb_enter(LBS_DEB_CMD); 
    289  
    290         cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN); 
    291         cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN); 
    292         penableRSN->action = cpu_to_le16(cmd_action); 
     303int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv, uint16_t cmd_action, 
     304                              uint16_t *enable) 
     305{ 
     306        struct cmd_ds_802_11_enable_rsn cmd; 
     307        int ret; 
     308 
     309        lbs_deb_enter(LBS_DEB_CMD); 
     310 
     311        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     312        cmd.action = cpu_to_le16(cmd_action); 
    293313 
    294314        if (cmd_action == CMD_ACT_SET) { 
    295315                if (*enable) 
    296                         penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN); 
     316                        cmd.enable = cpu_to_le16(CMD_ENABLE_RSN); 
    297317                else 
    298                         penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN); 
     318                        cmd.enable = cpu_to_le16(CMD_DISABLE_RSN); 
    299319                lbs_deb_cmd("ENABLE_RSN: %d\n", *enable); 
    300320        } 
    301321 
    302         lbs_deb_leave(LBS_DEB_CMD); 
    303         return 0; 
    304 } 
    305  
    306  
    307 static ssize_t lbs_tlv_size(const u8 *tlv, u16 size) 
    308 { 
    309         ssize_t pos = 0; 
    310         struct mrvlietypesheader *tlv_h; 
    311         while (pos < size) { 
    312                 u16 length; 
    313                 tlv_h = (struct mrvlietypesheader *) tlv; 
    314                 if (tlv_h->len == 0) 
    315                         return pos; 
    316                 length = le16_to_cpu(tlv_h->len) + 
    317                         sizeof(struct mrvlietypesheader); 
    318                 pos += length; 
    319                 tlv += length; 
    320         } 
    321         return pos; 
    322 } 
    323  
    324  
    325 static void lbs_cmd_802_11_subscribe_event(struct lbs_private *priv, 
    326         struct cmd_ds_command *cmd, u16 cmd_action, 
    327         void *pdata_buf) 
    328 { 
    329         struct cmd_ds_802_11_subscribe_event *events = 
    330                 (struct cmd_ds_802_11_subscribe_event *) pdata_buf; 
    331  
    332         /* pdata_buf points to a struct cmd_ds_802_11_subscribe_event and room 
    333          * for various Marvell TLVs */ 
    334  
    335         lbs_deb_enter(LBS_DEB_CMD); 
    336  
    337         cmd->size = cpu_to_le16(sizeof(*events) 
    338                         - sizeof(events->tlv) 
    339                         + S_DS_GEN); 
    340         cmd->params.subscribe_event.action = cpu_to_le16(cmd_action); 
    341         if (cmd_action == CMD_ACT_GET) { 
    342                 cmd->params.subscribe_event.events = 0; 
    343         } else { 
    344                 ssize_t sz = lbs_tlv_size(events->tlv, sizeof(events->tlv)); 
    345                 cmd->size = cpu_to_le16(le16_to_cpu(cmd->size) + sz); 
    346                 cmd->params.subscribe_event.events = events->events; 
    347                 memcpy(cmd->params.subscribe_event.tlv, events->tlv, sz); 
    348         } 
    349  
    350         lbs_deb_leave(LBS_DEB_CMD); 
     322        ret = lbs_cmd_with_response(priv, CMD_802_11_ENABLE_RSN, &cmd); 
     323        if (!ret && cmd_action == CMD_ACT_GET) 
     324                *enable = le16_to_cpu(cmd.enable); 
     325 
     326        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 
     327        return ret; 
    351328} 
    352329 
     
    583560} 
    584561 
    585 static int lbs_cmd_802_11_radio_control(struct lbs_private *priv, 
    586                                          struct cmd_ds_command *cmd, 
    587                                          int cmd_action) 
    588 { 
    589         struct cmd_ds_802_11_radio_control *pradiocontrol = &cmd->params.radio; 
    590  
    591         lbs_deb_enter(LBS_DEB_CMD); 
    592  
    593         cmd->size = 
    594             cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) + 
    595                              S_DS_GEN); 
    596         cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL); 
    597  
    598         pradiocontrol->action = cpu_to_le16(cmd_action); 
    599  
    600         switch (priv->preamble) { 
    601         case CMD_TYPE_SHORT_PREAMBLE: 
    602                 pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE); 
    603                 break; 
    604  
    605         case CMD_TYPE_LONG_PREAMBLE: 
    606                 pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE); 
    607                 break; 
    608  
    609         case CMD_TYPE_AUTO_PREAMBLE: 
    610         default: 
    611                 pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE); 
    612                 break; 
    613         } 
    614  
    615         if (priv->radioon) 
    616                 pradiocontrol->control |= cpu_to_le16(TURN_ON_RF); 
    617         else 
    618                 pradiocontrol->control &= cpu_to_le16(~TURN_ON_RF); 
    619  
    620         lbs_deb_leave(LBS_DEB_CMD); 
    621         return 0; 
    622 } 
    623  
    624562static int lbs_cmd_802_11_rf_tx_power(struct lbs_private *priv, 
    625563                                       struct cmd_ds_command *cmd, 
     
    725663        cmd.action = cpu_to_le16(CMD_ACT_GET_TX_RATE); 
    726664 
    727         ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, cmd); 
     665        ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd); 
    728666        if (ret) 
    729667                goto out; 
     
    772710        } 
    773711 
    774         ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, cmd); 
     712        ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd); 
    775713        if (ret) 
    776714                goto out; 
     
    828766        cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET); 
    829767 
    830         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, cmd); 
     768        ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd); 
    831769        if (ret) 
    832770                goto out; 
     
    860798        cmd.channel = cpu_to_le16(channel); 
    861799 
    862         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, cmd); 
     800        ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd); 
    863801        if (ret) 
    864802                goto out; 
     
    10821020 
    10831021        cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS); 
    1084         cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN); 
     1022        cmd->hdr.size = cpu_to_le16(sizeof(*cmd)); 
    10851023        cmd->hdr.result = 0; 
    10861024 
    10871025        cmd->action = cpu_to_le16(cmd_action); 
    10881026 
    1089         ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, (*cmd)); 
     1027        ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd); 
    10901028 
    10911029        lbs_deb_leave(LBS_DEB_CMD); 
     
    10941032EXPORT_SYMBOL_GPL(lbs_mesh_access); 
    10951033 
    1096 int lbs_mesh_config(struct lbs_private *priv, int enable) 
     1034int lbs_mesh_config(struct lbs_private *priv, uint16_t enable, uint16_t chan) 
    10971035{ 
    10981036        struct cmd_ds_mesh_config cmd; 
     
    11001038        memset(&cmd, 0, sizeof(cmd)); 
    11011039        cmd.action = cpu_to_le16(enable); 
    1102         cmd.channel = cpu_to_le16(priv->curbssparams.channel); 
    1103         cmd.type = cpu_to_le16(0x100 + 37); 
    1104          
     1040        cmd.channel = cpu_to_le16(chan); 
     1041        cmd.type = cpu_to_le16(priv->mesh_tlv); 
     1042        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     1043 
    11051044        if (enable) { 
    11061045                cmd.length = cpu_to_le16(priv->mesh_ssid_len); 
    11071046                memcpy(cmd.data, priv->mesh_ssid, priv->mesh_ssid_len); 
    11081047        } 
    1109  
    1110         return lbs_cmd_with_response(priv, CMD_MESH_CONFIG, cmd); 
     1048        lbs_deb_cmd("mesh config enable %d TLV %x channel %d SSID %s\n", 
     1049                    enable, priv->mesh_tlv, chan, 
     1050                    escape_essid(priv->mesh_ssid, priv->mesh_ssid_len)); 
     1051        return lbs_cmd_with_response(priv, CMD_MESH_CONFIG, &cmd); 
    11111052} 
    11121053 
     
    11321073} 
    11331074 
    1134 /* 
    1135  * Note: NEVER use lbs_queue_cmd() with addtail==0 other than for 
    1136  * the command timer, because it does not account for queued commands. 
    1137  */ 
    1138 void lbs_queue_cmd(struct lbs_private *priv, 
    1139         struct cmd_ctrl_node *cmdnode, 
    1140         u8 addtail) 
     1075static void lbs_queue_cmd(struct lbs_private *priv, 
     1076                          struct cmd_ctrl_node *cmdnode) 
    11411077{ 
    11421078        unsigned long flags; 
     1079        int addtail = 1; 
    11431080 
    11441081        lbs_deb_enter(LBS_DEB_HOST); 
    11451082 
    1146         if (!cmdnode || !cmdnode->cmdbuf) { 
    1147                 lbs_deb_host("QUEUE_CMD: cmdnode or cmdbuf is NULL\n"); 
     1083        if (!cmdnode) { 
     1084                lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n"); 
    11481085                goto done; 
    11491086        } 
     1087        if (!cmdnode->cmdbuf->size) { 
     1088                lbs_deb_host("DNLD_CMD: cmd size is zero\n"); 
     1089                goto done; 
     1090        } 
     1091        cmdnode->result = 0; 
    11501092 
    11511093        /* Exit_PS command needs to be queued in the header always. */ 
    11521094        if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) { 
    1153                 struct cmd_ds_802_11_ps_mode *psm = (void *) cmdnode->cmdbuf; 
     1095                struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1]; 
    11541096 
    11551097                if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) { 
     
    11691111 
    11701112        lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n", 
    1171                le16_to_cpu(cmdnode->cmdbuf->command)); 
     1113                     le16_to_cpu(cmdnode->cmdbuf->command)); 
    11721114 
    11731115done: 
     
    11751117} 
    11761118 
    1177 /* 
    1178  * TODO: Fix the issue when DownloadcommandToStation is being called the 
    1179  * second time when the command times out. All the cmdptr->xxx are in little 
    1180  * endian and therefore all the comparissions will fail. 
    1181  * For now - we are not performing the endian conversion the second time - but 
    1182  * for PS and DEEP_SLEEP we need to worry 
    1183  */ 
    1184 static int DownloadcommandToStation(struct lbs_private *priv, 
    1185                                     struct cmd_ctrl_node *cmdnode) 
     1119static void lbs_submit_command(struct lbs_private *priv, 
     1120                               struct cmd_ctrl_node *cmdnode) 
    11861121{ 
    11871122        unsigned long flags; 
    11881123        struct cmd_header *cmd; 
    1189         int ret = -1; 
    1190         u16 cmdsize; 
    1191         u16 command; 
     1124        uint16_t cmdsize; 
     1125        uint16_t command; 
     1126        int timeo = 5 * HZ; 
     1127        int ret; 
    11921128 
    11931129        lbs_deb_enter(LBS_DEB_HOST); 
    11941130 
    1195         if (!priv || !cmdnode) { 
    1196                 lbs_deb_host("DNLD_CMD: priv or cmdmode is NULL\n"); 
    1197                 goto done; 
    1198         } 
    1199  
    12001131        cmd = cmdnode->cmdbuf; 
    12011132 
    12021133        spin_lock_irqsave(&priv->driver_lock, flags); 
    1203         if (!cmd || !cmd->size) { 
    1204                 lbs_deb_host("DNLD_CMD: cmdptr is NULL or zero\n"); 
    1205                 __lbs_cleanup_and_insert_cmd(priv, cmdnode); 
    1206                 spin_unlock_irqrestore(&priv->driver_lock, flags); 
    1207                 goto done; 
    1208         } 
    1209  
    12101134        priv->cur_cmd = cmdnode; 
    12111135        priv->cur_cmd_retcode = 0; 
     
    12151139        command = le16_to_cpu(cmd->command); 
    12161140 
    1217         lbs_deb_host("DNLD_CMD: command 0x%04x, size %d, jiffies %lu\n", 
    1218                     command, cmdsize, jiffies); 
     1141        /* These commands take longer */ 
     1142        if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE || 
     1143            command == CMD_802_11_AUTHENTICATE) 
     1144                timeo = 10 * HZ; 
     1145 
     1146        lbs_deb_host("DNLD_CMD: command 0x%04x, seq %d, size %d, jiffies %lu\n", 
     1147                     command, le16_to_cpu(cmd->seqnum), cmdsize, jiffies); 
    12191148        lbs_deb_hex(LBS_DEB_HOST, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize); 
    12201149 
    1221         cmdnode->cmdwaitqwoken = 0; 
    1222  
    12231150        ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize); 
    12241151 
    1225         if (ret != 0) { 
    1226                 lbs_deb_host("DNLD_CMD: hw_host_to_card failed\n"); 
    1227                 spin_lock_irqsave(&priv->driver_lock, flags); 
    1228                 priv->cur_cmd_retcode = ret; 
    1229                 __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd); 
    1230                 priv->cur_cmd = NULL; 
    1231                 spin_unlock_irqrestore(&priv->driver_lock, flags); 
    1232                 goto done; 
    1233         } 
    1234  
    1235         lbs_deb_cmd("DNLD_CMD: sent command 0x%04x, jiffies %lu\n", command, jiffies); 
     1152        if (ret) { 
     1153                lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret); 
     1154                /* Let the timer kick in and retry, and potentially reset 
     1155                   the whole thing if the condition persists */ 
     1156                timeo = HZ; 
     1157        } else 
     1158                lbs_deb_cmd("DNLD_CMD: sent command 0x%04x, jiffies %lu\n", 
     1159                            command, jiffies); 
    12361160 
    12371161        /* Setup the timer after transmit command */ 
    1238         if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE 
    1239             || command == CMD_802_11_ASSOCIATE) 
    1240                 mod_timer(&priv->command_timer, jiffies + (10*HZ)); 
    1241         else 
    1242                 mod_timer(&priv->command_timer, jiffies + (5*HZ)); 
    1243  
    1244         ret = 0; 
    1245  
    1246 done: 
    1247         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); 
    1248         return ret; 
     1162        mod_timer(&priv->command_timer, jiffies + timeo); 
     1163 
     1164        lbs_deb_leave(LBS_DEB_HOST); 
    12491165} 
    12501166 
     
    12711187 *  after cleans it. Requires priv->driver_lock held. 
    12721188 */ 
    1273 void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv, 
    1274         struct cmd_ctrl_node *ptempcmd) 
    1275 { 
    1276  
    1277         if (!ptempcmd) 
    1278                 return; 
    1279  
    1280         cleanup_cmdnode(ptempcmd); 
    1281         list_add_tail(&ptempcmd->list, &priv->cmdfreeq); 
     1189static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv, 
     1190                                         struct cmd_ctrl_node *cmdnode) 
     1191{ 
     1192        lbs_deb_enter(LBS_DEB_HOST); 
     1193 
     1194        if (!cmdnode) 
     1195                goto out; 
     1196 
     1197        cmdnode->callback = NULL; 
     1198        cmdnode->callback_arg = 0; 
     1199 
     1200        memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE); 
     1201 
     1202        list_add_tail(&cmdnode->list, &priv->cmdfreeq); 
     1203 out: 
     1204        lbs_deb_leave(LBS_DEB_HOST); 
    12821205} 
    12831206 
     
    12921215} 
    12931216 
     1217void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd, 
     1218                          int result) 
     1219{ 
     1220        if (cmd == priv->cur_cmd) 
     1221                priv->cur_cmd_retcode = result; 
     1222 
     1223        cmd->result = result; 
     1224        cmd->cmdwaitqwoken = 1; 
     1225        wake_up_interruptible(&cmd->cmdwait_q); 
     1226 
     1227        if (!cmd->callback) 
     1228                __lbs_cleanup_and_insert_cmd(priv, cmd); 
     1229        priv->cur_cmd = NULL; 
     1230} 
     1231 
    12941232int lbs_set_radio_control(struct lbs_private *priv) 
    12951233{ 
    12961234        int ret = 0; 
    1297  
    1298         lbs_deb_enter(LBS_DEB_CMD); 
    1299  
    1300         ret = lbs_prepare_and_send_command(priv, 
    1301                                     CMD_802_11_RADIO_CONTROL, 
    1302                                     CMD_ACT_SET, 
    1303                                     CMD_OPTION_WAITFORRSP, 0, NULL); 
    1304  
    1305         lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", 
    1306                priv->radioon, priv->preamble); 
     1235        struct cmd_ds_802_11_radio_control cmd; 
     1236 
     1237        lbs_deb_enter(LBS_DEB_CMD); 
     1238 
     1239        cmd.hdr.size = cpu_to_le16(sizeof(cmd)); 
     1240        cmd.action = cpu_to_le16(CMD_ACT_SET); 
     1241 
     1242        switch (priv->preamble) { 
     1243        case CMD_TYPE_SHORT_PREAMBLE: 
     1244                cmd.control = cpu_to_le16(SET_SHORT_PREAMBLE); 
     1245                break; 
     1246 
     1247        case CMD_TYPE_LONG_PREAMBLE: 
     1248                cmd.control = cpu_to_le16(SET_LONG_PREAMBLE); 
     1249                break; 
     1250 
     1251        case CMD_TYPE_AUTO_PREAMBLE: 
     1252        default: 
     1253                cmd.control = cpu_to_le16(SET_AUTO_PREAMBLE); 
     1254                break; 
     1255        } 
     1256 
     1257        if (priv->radioon) 
     1258                cmd.control |= cpu_to_le16(TURN_ON_RF); 
     1259        else 
     1260                cmd.control &= cpu_to_le16(~TURN_ON_RF); 
     1261 
     1262        lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", priv->radioon, 
     1263                    priv->preamble); 
     1264 
     1265        ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd); 
    13071266 
    13081267        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 
     
    13701329        } 
    13711330 
    1372         lbs_set_cmd_ctrl_node(priv, cmdnode, wait_option, pdata_buf); 
     1331        lbs_set_cmd_ctrl_node(priv, cmdnode, pdata_buf); 
    13731332 
    13741333        cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf; 
    13751334 
    13761335        lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no); 
    1377  
    1378         if (!cmdptr) { 
    1379                 lbs_deb_host("PREP_CMD: cmdptr is NULL\n"); 
    1380                 lbs_cleanup_and_insert_cmd(priv, cmdnode); 
    1381                 ret = -1; 
    1382                 goto done; 
    1383         } 
    13841336 
    13851337        /* Set sequence number, command and INT option */ 
     
    14101362        case CMD_802_11_DEAUTHENTICATE: 
    14111363                ret = lbs_cmd_80211_deauthenticate(priv, cmdptr); 
    1412                 break; 
    1413  
    1414         case CMD_802_11_SET_WEP: 
    1415                 ret = lbs_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf); 
    14161364                break; 
    14171365 
     
    14541402                break; 
    14551403 
    1456         case CMD_802_11_RADIO_CONTROL: 
    1457                 ret = lbs_cmd_802_11_radio_control(priv, cmdptr, cmd_action); 
    1458                 break; 
    1459  
    14601404        case CMD_802_11_RATE_ADAPT_RATESET: 
    14611405                ret = lbs_cmd_802_11_rate_adapt_rateset(priv, 
     
    14841428                break; 
    14851429 
    1486         case CMD_802_11_ENABLE_RSN: 
    1487                 ret = lbs_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action, 
    1488                                 pdata_buf); 
    1489                 break; 
    1490  
    14911430        case CMD_802_11_KEY_MATERIAL: 
    14921431                ret = lbs_cmd_802_11_key_material(priv, cmdptr, cmd_action, 
     
    15241463                ret = lbs_cmd_802_11d_domain_info(priv, cmdptr, 
    15251464                                                   cmd_no, cmd_action); 
    1526                 break; 
    1527  
    1528         case CMD_802_11_SLEEP_PARAMS: 
    1529                 ret = lbs_cmd_802_11_sleep_params(priv, cmdptr, cmd_action); 
    1530                 break; 
    1531         case CMD_802_11_INACTIVITY_TIMEOUT: 
    1532                 ret = lbs_cmd_802_11_inactivity_timeout(priv, cmdptr, 
    1533                                                          cmd_action, pdata_buf); 
    1534                 lbs_set_cmd_ctrl_node(priv, cmdnode, 0, pdata_buf); 
    15351465                break; 
    15361466 
     
    15691499                        break; 
    15701500                } 
    1571         case CMD_802_11_SUBSCRIBE_EVENT: 
    1572                 lbs_cmd_802_11_subscribe_event(priv, cmdptr, 
    1573                         cmd_action, pdata_buf); 
    1574                 break; 
     1501 
    15751502        case CMD_802_11_PWR_CFG: 
    15761503                cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG); 
     
    16161543        cmdnode->cmdwaitqwoken = 0; 
    16171544 
    1618         lbs_queue_cmd(priv, cmdnode, 1); 
     1545        lbs_queue_cmd(priv, cmdnode); 
    16191546        wake_up_interruptible(&priv->waitq); 
    16201547 
     
    17571684        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    17581685 
    1759         if (tempnode) 
    1760                 cleanup_cmdnode(tempnode); 
    1761  
    17621686        lbs_deb_leave(LBS_DEB_HOST); 
    17631687        return tempnode; 
     
    17701694 *  @return             n/a 
    17711695 */ 
    1772 static void cleanup_cmdnode(struct cmd_ctrl_node *cmdnode) 
    1773 { 
    1774         lbs_deb_enter(LBS_DEB_HOST); 
    1775  
    1776         if (!cmdnode) 
    1777                 return; 
    1778         cmdnode->cmdwaitqwoken = 1; 
    1779         wake_up_interruptible(&cmdnode->cmdwait_q); 
    1780         cmdnode->wait_option = 0; 
    1781         cmdnode->pdata_buf = NULL; 
    1782         cmdnode->callback = NULL; 
    1783         cmdnode->callback_arg = 0; 
    1784  
    1785         if (cmdnode->cmdbuf != NULL) 
    1786                 memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE); 
    1787  
    1788         lbs_deb_leave(LBS_DEB_HOST); 
    1789 } 
    17901696 
    17911697/** 
     
    17941700 *  @param priv         A pointer to struct lbs_private structure 
    17951701 *  @param ptempnode    A pointer to cmd_ctrl_node structure 
    1796  *  @param wait_option  wait option: wait response or not 
    17971702 *  @param pdata_buf    A pointer to informaion buffer 
    17981703 *  @return             0 or -1 
     
    18001705static void lbs_set_cmd_ctrl_node(struct lbs_private *priv, 
    18011706                                  struct cmd_ctrl_node *ptempnode, 
    1802                                   u16 wait_option, void *pdata_buf) 
     1707                                  void *pdata_buf) 
    18031708{ 
    18041709        lbs_deb_enter(LBS_DEB_HOST); 
     
    18071712                return; 
    18081713 
    1809         ptempnode->wait_option = wait_option; 
    1810         ptempnode->pdata_buf = pdata_buf; 
    18111714        ptempnode->callback = NULL; 
    1812         ptempnode->callback_arg = 0; 
     1715        ptempnode->callback_arg = (unsigned long)pdata_buf; 
    18131716 
    18141717        lbs_deb_leave(LBS_DEB_HOST); 
     
    18981801                                 * otherwise send it down immediately. 
    18991802                                 */ 
    1900                                 struct cmd_ds_802_11_ps_mode *psm = (void *)cmd; 
     1803                                struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1]; 
    19011804 
    19021805                                lbs_deb_host( 
     
    19081811                                               "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n"); 
    19091812                                        list_del(&cmdnode->list); 
    1910                                         lbs_cleanup_and_insert_cmd(priv, cmdnode); 
     1813                                        spin_lock_irqsave(&priv->driver_lock, flags); 
     1814                                        lbs_complete_command(priv, cmdnode, 0); 
     1815                                        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    19111816 
    19121817                                        ret = 0; 
     
    19191824                                               "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n"); 
    19201825                                        list_del(&cmdnode->list); 
    1921                                         lbs_cleanup_and_insert_cmd(priv, cmdnode); 
     1826                                        spin_lock_irqsave(&priv->driver_lock, flags); 
     1827                                        lbs_complete_command(priv, cmdnode, 0); 
     1828                                        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    19221829                                        priv->needtowakeup = 1; 
    19231830 
     
    19331840                lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n", 
    19341841                            le16_to_cpu(cmd->command)); 
    1935                 DownloadcommandToStation(priv, cmdnode); 
     1842                lbs_submit_command(priv, cmdnode); 
    19361843        } else { 
    19371844                /* 
     
    20051912 
    20061913        ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size); 
    2007         priv->dnld_sent = DNLD_RES_RECEIVED; 
    20081914 
    20091915        spin_lock_irqsave(&priv->driver_lock, flags); 
     
    20871993        if (priv->dnld_sent) { 
    20881994                allowed = 0; 
    2089                 lbs_deb_host("dnld_sent was set"); 
     1995                lbs_deb_host("dnld_sent was set\n"); 
    20901996        } 
    20911997 
     
    20931999        if (priv->cur_cmd) { 
    20942000                allowed = 0; 
    2095                 lbs_deb_host("cur_cmd was set"); 
     2001                lbs_deb_host("cur_cmd was set\n"); 
    20962002        } 
    20972003        if (priv->intcounter > 0) { 
    20982004                allowed = 0; 
    2099                 lbs_deb_host("intcounter %d", priv->intcounter); 
     2005                lbs_deb_host("intcounter %d\n", priv->intcounter); 
    21002006        } 
    21012007        spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    21402046        return 0; 
    21412047} 
    2142  
    2143 /** 
    2144  *  @brief Simple way to call firmware functions 
    2145  * 
    2146  *  @param priv         A pointer to struct lbs_private structure 
    2147  *  @param psmode       one of the many CMD_802_11_xxxx 
    2148  *  @param cmd          pointer to the parameters structure for above command 
    2149  *                      (this should not include the command, size, sequence 
    2150  *                      and result fields from struct cmd_ds_gen) 
    2151  *  @param cmd_size     size structure pointed to by cmd 
    2152  *  @param rsp          pointer to an area where the result should be placed 
    2153  *  @param rsp_size     pointer to the size of the rsp area. If the firmware 
    2154  *                      returns fewer bytes, then this *rsp_size will be 
    2155  *                      changed to the actual size. 
    2156  *  @return             -1 in case of a higher level error, otherwise 
    2157  *                      the result code from the firmware 
    2158  */ 
    2159 int __lbs_cmd(struct lbs_private *priv, uint16_t command, 
    2160               struct cmd_header *in_cmd, int in_cmd_size, 
    2161               int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *), 
    2162               unsigned long callback_arg) 
     2048EXPORT_SYMBOL_GPL(lbs_cmd_copyback); 
     2049 
     2050struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv, uint16_t command, 
     2051                                      struct cmd_header *in_cmd, int in_cmd_size, 
     2052                                      int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *), 
     2053                                      unsigned long callback_arg) 
    21632054{ 
    21642055        struct cmd_ctrl_node *cmdnode; 
    2165         unsigned long flags; 
    2166         int ret = 0; 
    21672056 
    21682057        lbs_deb_enter(LBS_DEB_HOST); 
    2169  
    2170         if (!priv) { 
    2171                 lbs_deb_host("PREP_CMD: priv is NULL\n"); 
    2172                 ret = -1; 
    2173                 goto done; 
    2174         } 
    21752058 
    21762059        if (priv->surpriseremoved) { 
    21772060                lbs_deb_host("PREP_CMD: card removed\n"); 
    2178                 ret = -1; 
     2061                cmdnode = ERR_PTR(-ENOENT); 
    21792062                goto done; 
    21802063        } 
     
    21862069                /* Wake up main thread to execute next command */ 
    21872070                wake_up_interruptible(&priv->waitq); 
    2188                 ret = -1; 
     2071                cmdnode = ERR_PTR(-ENOBUFS); 
    21892072                goto done; 
    21902073        } 
    21912074 
    2192         cmdnode->wait_option = CMD_OPTION_WAITFORRSP; 
    21932075        cmdnode->callback = callback; 
    21942076        cmdnode->callback_arg = callback_arg; 
     
    22102092 
    22112093        cmdnode->cmdwaitqwoken = 0; 
    2212         lbs_queue_cmd(priv, cmdnode, 1); 
     2094        lbs_queue_cmd(priv, cmdnode); 
    22132095        wake_up_interruptible(&priv->waitq); 
     2096 
     2097 done: 
     2098        lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode); 
     2099        return cmdnode; 
     2100} 
     2101 
     2102int __lbs_cmd(struct lbs_private *priv, uint16_t command, 
     2103              struct cmd_header *in_cmd, int in_cmd_size, 
     2104              int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *), 
     2105              unsigned long callback_arg) 
     2106{ 
     2107        struct cmd_ctrl_node *cmdnode; 
     2108        unsigned long flags; 
     2109        int ret = 0; 
     2110 
     2111        lbs_deb_enter(LBS_DEB_HOST); 
     2112 
     2113        cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size, 
     2114                                  callback, callback_arg); 
     2115        if (IS_ERR(cmdnode)) { 
     2116                ret = PTR_ERR(cmdnode); 
     2117                goto done; 
     2118        } 
    22142119 
    22152120        might_sleep(); 
     
    22172122 
    22182123        spin_lock_irqsave(&priv->driver_lock, flags); 
    2219         if (priv->cur_cmd_retcode) { 
    2220                 lbs_deb_host("PREP_CMD: command failed with return code %d\n", 
    2221                        priv->cur_cmd_retcode); 
    2222                 priv->cur_cmd_retcode = 0; 
    2223                 ret = -1; 
    2224         } 
     2124        ret = cmdnode->result; 
     2125        if (ret) 
     2126                lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n", 
     2127                            command, ret); 
     2128 
     2129        __lbs_cleanup_and_insert_cmd(priv, cmdnode); 
    22252130        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    22262131 
  • trunk/package/libertas/src/cmd.h

    r9768 r10235  
    77#include "dev.h" 
    88 
    9 #define lbs_cmd(priv, cmdnr, cmd, callback, callback_arg) \ 
    10         __lbs_cmd(priv, cmdnr, &(cmd).hdr, sizeof(cmd),   \ 
    11                         callback, callback_arg) 
     9/* lbs_cmd() infers the size of the buffer to copy data back into, from 
     10   the size of the target of the pointer. Since the command to be sent  
     11   may often be smaller, that size is set in cmd->size by the caller.*/ 
     12#define lbs_cmd(priv, cmdnr, cmd, cb, cb_arg)   ({              \ 
     13        uint16_t __sz = le16_to_cpu((cmd)->hdr.size);           \ 
     14        (cmd)->hdr.size = cpu_to_le16(sizeof(*(cmd)));          \ 
     15        __lbs_cmd(priv, cmdnr, &(cmd)->hdr, __sz, cb, cb_arg);  \ 
     16}) 
    1217 
    13 #define lbs_cmd_with_response(priv, cmdnr, cmd) \ 
    14         __lbs_cmd(priv, cmdnr, &(cmd).hdr, sizeof(cmd), \ 
    15                   lbs_cmd_copyback, (unsigned long) &cmd) 
    16   
     18#define lbs_cmd_with_response(priv, cmdnr, cmd) \ 
     19        lbs_cmd(priv, cmdnr, cmd, lbs_cmd_copyback, (unsigned long) (cmd)) 
     20 
     21/* __lbs_cmd() will free the cmdnode and return success/failure. 
     22   __lbs_cmd_async() requires that the callback free the cmdnode */ 
     23struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv, uint16_t command, 
     24                                      struct cmd_header *in_cmd, int in_cmd_size, 
     25                                      int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *), 
     26                                      unsigned long callback_arg); 
    1727int __lbs_cmd(struct lbs_private *priv, uint16_t command, 
    18               struct cmd_header *in_cmd, int in_cmd_size,  
     28              struct cmd_header *in_cmd, int in_cmd_size, 
    1929              int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *), 
    2030              unsigned long callback_arg); 
     
    3444int lbs_set_channel(struct lbs_private *priv, u8 channel); 
    3545 
    36 int lbs_mesh_config(struct lbs_private *priv, int enable); 
     46int lbs_mesh_config(struct lbs_private *priv, uint16_t enable, uint16_t chan); 
     47 
     48int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria); 
     49int lbs_suspend(struct lbs_private *priv); 
     50int lbs_resume(struct lbs_private *priv); 
     51 
     52int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv, 
     53                                      uint16_t cmd_action, uint16_t *timeout); 
     54int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action, 
     55                                struct sleep_params *sp); 
     56int lbs_cmd_802_11_set_wep(struct lbs_private *priv, uint16_t cmd_action, 
     57                           struct assoc_request *assoc); 
     58int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv, uint16_t cmd_action, 
     59                              uint16_t *enable); 
    3760 
    3861#endif /* _LBS_CMD_H */ 
  • trunk/package/libertas/src/cmdresp.c

    r9768 r10235  
    4444        wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); 
    4545 
     46        /* report disconnect to upper layer */ 
     47        netif_stop_queue(priv->dev); 
     48        netif_carrier_off(priv->dev); 
     49 
    4650        /* Free Tx and Rx packets */ 
    4751        kfree_skb(priv->currenttxskb); 
    4852        priv->currenttxskb = NULL; 
    49  
    50         /* report disconnect to upper layer */ 
    51         netif_stop_queue(priv->dev); 
    52         netif_carrier_off(priv->dev); 
     53        priv->tx_pending_len = 0; 
    5354 
    5455        /* reset SNR/NF/RSSI values */ 
     
    146147} 
    147148 
    148 static int lbs_ret_802_11_sleep_params(struct lbs_private *priv, 
    149                                         struct cmd_ds_command *resp) 
    150 { 
    151         struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params; 
    152  
    153         lbs_deb_enter(LBS_DEB_CMD); 
    154  
    155         lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, calcontrol 0x%x " 
    156                     "extsleepclk 0x%x\n", le16_to_cpu(sp->error), 
    157                     le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime), 
    158                     sp->calcontrol, sp->externalsleepclk); 
    159  
    160         priv->sp.sp_error = le16_to_cpu(sp->error); 
    161         priv->sp.sp_offset = le16_to_cpu(sp->offset); 
    162         priv->sp.sp_stabletime = le16_to_cpu(sp->stabletime); 
    163         priv->sp.sp_calcontrol = sp->calcontrol; 
    164         priv->sp.sp_extsleepclk = sp->externalsleepclk; 
    165         priv->sp.sp_reserved = le16_to_cpu(sp->reserved); 
    166  
    167         lbs_deb_enter(LBS_DEB_CMD); 
    168         return 0; 
    169 } 
    170  
    171149static int lbs_ret_802_11_stat(struct lbs_private *priv, 
    172150                                struct cmd_ds_command *resp) 
     
    395373} 
    396374 
    397 static int lbs_ret_802_11_enable_rsn(struct lbs_private *priv, 
    398                                           struct cmd_ds_command *resp) 
    399 { 
    400         struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn; 
    401         u32 * pdata_buf = priv->cur_cmd->pdata_buf; 
    402  
    403         lbs_deb_enter(LBS_DEB_CMD); 
    404  
    405         if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) { 
    406                 if (pdata_buf) 
    407                         *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable); 
    408         } 
    409  
    410         lbs_deb_leave(LBS_DEB_CMD); 
    411         return 0; 
    412 } 
    413  
    414375static int lbs_ret_802_11_bcn_ctrl(struct lbs_private * priv, 
    415376                                        struct cmd_ds_command *resp) 
     
    426387 
    427388        lbs_deb_enter(LBS_DEB_CMD); 
    428         return 0; 
    429 } 
    430  
    431 static int lbs_ret_802_11_subscribe_event(struct lbs_private *priv, 
    432         struct cmd_ds_command *resp) 
    433 { 
    434         struct cmd_ds_802_11_subscribe_event *cmd_event = 
    435                 &resp->params.subscribe_event; 
    436         struct cmd_ds_802_11_subscribe_event *dst_event = 
    437                 priv->cur_cmd->pdata_buf; 
    438  
    439         lbs_deb_enter(LBS_DEB_CMD); 
    440  
    441         if (dst_event->action == cpu_to_le16(CMD_ACT_GET)) { 
    442                 dst_event->events = cmd_event->events; 
    443                 memcpy(dst_event->tlv, cmd_event->tlv, sizeof(dst_event->tlv)); 
    444         } 
    445  
    446         lbs_deb_leave(LBS_DEB_CMD); 
    447389        return 0; 
    448390} 
     
    505447        case CMD_RET(CMD_802_11_GET_AFC): 
    506448                spin_lock_irqsave(&priv->driver_lock, flags); 
    507                 memmove(priv->cur_cmd->pdata_buf, &resp->params.afc, 
     449                memmove((void *)priv->cur_cmd->callback_arg, &resp->params.afc, 
    508450                        sizeof(struct cmd_ds_802_11_afc)); 
    509451                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    513455        case CMD_RET(CMD_MAC_MULTICAST_ADR): 
    514456        case CMD_RET(CMD_MAC_CONTROL): 
    515         case CMD_RET(CMD_802_11_SET_WEP): 
    516457        case CMD_RET(CMD_802_11_RESET): 
    517458        case CMD_RET(CMD_802_11_AUTHENTICATE): 
    518         case CMD_RET(CMD_802_11_RADIO_CONTROL): 
    519459        case CMD_RET(CMD_802_11_BEACON_STOP): 
    520                 break; 
    521  
    522         case CMD_RET(CMD_802_11_ENABLE_RSN): 
    523                 ret = lbs_ret_802_11_enable_rsn(priv, resp); 
    524460                break; 
    525461 
     
    552488                break; 
    553489 
    554         case CMD_RET(CMD_802_11_SLEEP_PARAMS): 
    555                 ret = lbs_ret_802_11_sleep_params(priv, resp); 
    556                 break; 
    557         case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT): 
    558                 spin_lock_irqsave(&priv->driver_lock, flags); 
    559                 *((u16 *) priv->cur_cmd->pdata_buf) = 
    560                     le16_to_cpu(resp->params.inactivity_timeout.timeout); 
    561                 spin_unlock_irqrestore(&priv->driver_lock, flags); 
    562                 break; 
    563  
    564490        case CMD_RET(CMD_802_11_TPC_CFG): 
    565491                spin_lock_irqsave(&priv->driver_lock, flags); 
    566                 memmove(priv->cur_cmd->pdata_buf, &resp->params.tpccfg, 
     492                memmove((void *)priv->cur_cmd->callback_arg, &resp->params.tpccfg, 
    567493                        sizeof(struct cmd_ds_802_11_tpc_cfg)); 
    568494                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    570496        case CMD_RET(CMD_802_11_LED_GPIO_CTRL): 
    571497                spin_lock_irqsave(&priv->driver_lock, flags); 
    572                 memmove(priv->cur_cmd->pdata_buf, &resp->params.ledgpio, 
     498                memmove((void *)priv->cur_cmd->callback_arg, &resp->params.ledgpio, 
    573499                        sizeof(struct cmd_ds_802_11_led_ctrl)); 
    574500                spin_unlock_irqrestore(&priv->driver_lock, flags); 
    575                 break; 
    576         case CMD_RET(CMD_802_11_SUBSCRIBE_EVENT): 
    577                 ret = lbs_ret_802_11_subscribe_event(priv, resp); 
    578501                break; 
    579502 
    580503        case CMD_RET(CMD_802_11_PWR_CFG): 
    581504                spin_lock_irqsave(&priv->driver_lock, flags); 
    582                 memmove(priv->cur_cmd->pdata_buf, &resp->params.pwrcfg, 
     505                memmove((void *)priv->cur_cmd->callback_arg, &resp->params.pwrcfg, 
    583506                        sizeof(struct cmd_ds_802_11_pwr_cfg)); 
    584507                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    588511        case CMD_RET(CMD_GET_TSF): 
    589512                spin_lock_irqsave(&priv->driver_lock, flags); 
    590                 memcpy(priv->cur_cmd->pdata_buf, 
     513                memcpy((void *)priv->cur_cmd->callback_arg, 
    591514                       &resp->params.gettsf.tsfvalue, sizeof(u64)); 
    592515                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    594517        case CMD_RET(CMD_BT_ACCESS): 
    595518                spin_lock_irqsave(&priv->driver_lock, flags); 
    596                 if (priv->cur_cmd->pdata_buf) 
    597                         memcpy(priv->cur_cmd->pdata_buf, 
     519                if (priv->cur_cmd->callback_arg) 
     520                        memcpy((void *)priv->cur_cmd->callback_arg, 
    598521                               &resp->params.bt.addr1, 2 * ETH_ALEN); 
    599522                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    601524        case CMD_RET(CMD_FWT_ACCESS): 
    602525                spin_lock_irqsave(&priv->driver_lock, flags); 
    603                 if (priv->cur_cmd->pdata_buf) 
    604                         memcpy(priv->cur_cmd->pdata_buf, &resp->params.fwt, 
     526                if (priv->cur_cmd->callback_arg) 
     527                        memcpy((void *)priv->cur_cmd->callback_arg, &resp->params.fwt, 
    605528                               sizeof(resp->params.fwt)); 
    606529                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    612535        default: 
    613536                lbs_deb_host("CMD_RESP: unknown cmd response 0x%04x\n", 
    614                             resp->command); 
     537                             le16_to_cpu(resp->command)); 
    615538                break; 
    616539        } 
     
    621544int lbs_process_rx_command(struct lbs_private *priv) 
    622545{ 
    623         u16 respcmd; 
     546        uint16_t respcmd, curcmd; 
    624547        struct cmd_header *resp; 
    625548        int ret = 0; 
    626         ulong flags; 
    627         u16 result; 
     549        unsigned long flags; 
     550        uint16_t result; 
    628551 
    629552        lbs_deb_enter(LBS_DEB_HOST); 
    630  
    631         /* Now we got response from FW, cancel the command timer */ 
    632         del_timer(&priv->command_timer); 
    633553 
    634554        mutex_lock(&priv->lock); 
     
    641561                goto done; 
    642562        } 
    643         resp = priv->cur_cmd->cmdbuf; 
     563 
     564        resp = (void *)priv->upld_buf; 
     565 
     566        curcmd = le16_to_cpu(resp->command); 
    644567 
    645568        respcmd = le16_to_cpu(resp->command); 
    646569        result = le16_to_cpu(resp->result); 
    647570 
    648         lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n", 
    649                 respcmd, priv->upld_len, jiffies); 
     571        lbs_deb_host("CMD_RESP: response 0x%04x, seq %d, size %d, jiffies %lu\n", 
     572                     respcmd, le16_to_cpu(resp->seqnum), priv->upld_len, jiffies); 
    650573        lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", (void *) resp, priv->upld_len); 
    651574 
    652         if (!(respcmd & 0x8000)) { 
    653                 lbs_deb_host("invalid response!\n"); 
    654                 priv->cur_cmd_retcode = -1; 
    655                 __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd); 
    656                 priv->cur_cmd = NULL; 
     575        if (resp->seqnum != resp->seqnum) { 
     576                lbs_pr_info("Received CMD_RESP with invalid sequence %d (expected %d)\n", 
     577                            le16_to_cpu(resp->seqnum), le16_to_cpu(resp->seqnum)); 
    657578                spin_unlock_irqrestore(&priv->driver_lock, flags); 
    658579                ret = -1; 
    659580                goto done; 
    660581        } 
     582        if (respcmd != CMD_RET(curcmd) && 
     583            respcmd != CMD_802_11_ASSOCIATE && curcmd != CMD_RET_802_11_ASSOCIATE) { 
     584                lbs_pr_info("Invalid CMD_RESP %x to command %x!\n", respcmd, curcmd); 
     585                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     586                ret = -1; 
     587                goto done; 
     588        } 
     589 
     590        if (resp->result == cpu_to_le16(0x0004)) { 
     591                /* 0x0004 means -EAGAIN. Drop the response, let it time out 
     592                   and be resubmitted */ 
     593                lbs_pr_info("Firmware returns DEFER to command %x. Will let it time out...\n", 
     594                            le16_to_cpu(resp->command)); 
     595                spin_unlock_irqrestore(&priv->driver_lock, flags); 
     596                ret = -1; 
     597                goto done; 
     598        } 
     599 
     600        /* Now we got response from FW, cancel the command timer */ 
     601        del_timer(&priv->command_timer); 
     602        priv->cmd_timed_out = 0; 
     603        if (priv->nr_retries) { 
     604                lbs_pr_info("Received result %x to command %x after %d retries\n", 
     605                            result, curcmd, priv->nr_retries); 
     606                priv->nr_retries = 0; 
     607        } 
    661608 
    662609        /* Store the response code to cur_cmd_retcode. */ 
     
    664611 
    665612        if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) { 
    666                 struct cmd_ds_802_11_ps_mode *psmode = (void *) resp; 
     613                struct cmd_ds_802_11_ps_mode *psmode = (void *) &resp[1]; 
    667614                u16 action = le16_to_cpu(psmode->action); 
    668615 
     
    709656                } 
    710657 
    711                 __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd); 
    712                 priv->cur_cmd = NULL; 
     658                lbs_complete_command(priv, priv->cur_cmd, result); 
    713659                spin_unlock_irqrestore(&priv->driver_lock, flags); 
    714660 
     
    731677 
    732678                } 
    733  
    734                 __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd); 
    735                 priv->cur_cmd = NULL; 
     679                lbs_complete_command(priv, priv->cur_cmd, result); 
    736680                spin_unlock_irqrestore(&priv->driver_lock, flags); 
    737681 
     
    752696        if (priv->cur_cmd) { 
    753697                /* Clean up and Put current command back to cmdfreeq */ 
    754                 __lbs_cleanup_and_insert_cmd(priv, priv->cur_cmd); 
    755                 priv->cur_cmd = NULL; 
     698                lbs_complete_command(priv, priv->cur_cmd, result); 
    756699        } 
    757700        spin_unlock_irqrestore(&priv->driver_lock, flags); 
     
    763706} 
    764707 
     708static int lbs_send_confirmwake(struct lbs_private *priv) 
     709{ 
     710        struct cmd_header *cmd = &priv->lbs_ps_confirm_wake; 
     711        int ret = 0; 
     712 
     713        lbs_deb_enter(LBS_DEB_HOST); 
     714 
     715        cmd->command = cpu_to_le16(CMD_802_11_WAKEUP_CONFIRM); 
     716        cmd->size = cpu_to_le16(sizeof(*cmd)); 
     717        cmd->seqnum = cpu_to_le16(++priv->seqnum); 
     718        cmd->result = 0; 
     719 
     720        lbs_deb_host("SEND_WAKEC_CMD: before download\n"); 
     721 
     722        lbs_deb_hex(LBS_DEB_HOST, "wake confirm command", (void *)cmd, sizeof(*cmd)); 
     723 
     724        ret = priv->hw_host_to_card(priv, MVMS_CMD, (void *)cmd, sizeof(*cmd)); 
     725        if (ret) 
     726                lbs_pr_alert("SEND_WAKEC_CMD: Host to Card failed for Confirm Wake\n"); 
     727 
     728        lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); 
     729        return ret; 
     730} 
     731 
    765732int lbs_process_event(struct lbs_private *priv) 
    766733{ 
     
    811778                break; 
    812779 
     780        case MACREG_INT_CODE_HOST_AWAKE: 
     781                lbs_deb_cmd("EVENT: HOST_AWAKE\n"); 
     782                lbs_send_confirmwake(priv); 
     783                break; 
     784 
    813785        case MACREG_INT_CODE_PS_AWAKE: 
    814786                lbs_deb_cmd("EVENT: awake\n"); 
    815  
    816787                /* handle unexpected PS AWAKE event */ 
    817788                if (priv->psstate == PS_STATE_FULL_POWER) { 
     
    876847                lbs_pr_info("EVENT: MESH_AUTO_STARTED\n"); 
    877848                priv->mesh_connect_status = LBS_CONNECTED; 
    878                 if (priv->mesh_open == 1) { 
    879                         netif_wake_queue(priv->mesh_dev); 
     849                if (priv->mesh_open) { 
    880850                        netif_carrier_on(priv->mesh_dev); 
     851                        if (!priv->tx_pending_len) 
     852                                netif_wake_queue(priv->mesh_dev); 
    881853                } 
    882854                priv->mode = IW_MODE_ADHOC; 
  • trunk/package/libertas/src/debugfs.c

    r9768 r10235  
    1111#include "host.h" 
    1212#include "debugfs.h" 
     13#include "cmd.h" 
    1314 
    1415static struct dentry *lbs_dir; 
     
    104105{ 
    105106        struct lbs_private *priv = file->private_data; 
    106         ssize_t buf_size, res; 
     107        ssize_t buf_size, ret; 
     108        struct sleep_params sp; 
    107109        int p1, p2, p3, p4, p5, p6; 
    108110        unsigned long addr = get_zeroed_page(GFP_KERNEL); 
     
    111113        buf_size = min(count, len - 1); 
    112114        if (copy_from_user(buf, user_buf, buf_size)) { 
    113                 res = -EFAULT; 
    114                 goto out_unlock; 
    115         } 
    116         res = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6); 
    117         if (res != 6) { 
    118                 res = -EFAULT; 
    119                 goto out_unlock; 
    120         } 
    121         priv->sp.sp_error = p1; 
    122         priv->sp.sp_offset = p2; 
    123         priv->sp.sp_stabletime = p3; 
    124         priv->sp.sp_calcontrol = p4; 
    125         priv->sp.sp_extsleepclk = p5; 
    126         priv->sp.sp_reserved = p6; 
    127  
    128         res = lbs_prepare_and_send_command(priv, 
    129                                 CMD_802_11_SLEEP_PARAMS, 
    130                                 CMD_ACT_SET, 
    131                                 CMD_OPTION_WAITFORRSP, 0, NULL); 
    132  
    133         if (!res) 
    134                 res = count; 
    135         else 
    136                 res = -EINVAL; 
     115                ret = -EFAULT; 
     116                goto out_unlock; 
     117        } 
     118        ret = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6); 
     119        if (ret != 6) { 
     120                ret = -EINVAL; 
     121                goto out_unlock; 
     122        } 
     123        sp.sp_error = p1; 
     124        sp.sp_offset = p2; 
     125        sp.sp_stabletime = p3; 
     126        sp.sp_calcontrol = p4; 
     127        sp.sp_extsleepclk = p5; 
     128        sp.sp_reserved = p6; 
     129 
     130        ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_SET, &sp); 
     131        if (!ret) 
     132                ret = count; 
     133        else if (ret > 0) 
     134                ret = -EINVAL; 
    137135 
    138136out_unlock: 
    139137        free_page(addr); 
    140         return res; 
     138        return ret; 
    141139} 
    142140 
     
    145143{ 
    146144        struct lbs_private *priv = file->private_data; 
    147         ssize_t res; 
     145        ssize_t ret; 
    148146        size_t pos = 0; 
    149         unsigned long addr = get_zeroed_page(GFP_KERNEL); 
    150         char *buf = (char *)addr; 
    151  
    152         res = lbs_prepare_and_send_command(priv, 
    153                                 CMD_802_11_SLEEP_PARAMS, 
    154                                 CMD_ACT_GET, 
    155                                 CMD_OPTION_WAITFORRSP, 0, NULL); 
    156         if (res) { 
    157                 res = -EFAULT; 
    158                 goto out_unlock; 
    159         } 
    160  
    161         pos += snprintf(buf, len, "%d %d %d %d %d %d\n", priv->sp.sp_error, 
    162                         priv->sp.sp_offset, priv->sp.sp_stabletime, 
    163                         priv->sp.sp_calcontrol, priv->sp.sp_extsleepclk, 
    164                         priv->sp.sp_reserved); 
    165  
    166         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); 
     147        struct sleep_params sp; 
     148        unsigned long addr = get_zeroed_page(GFP_KERNEL); 
     149        char *buf = (char *)addr; 
     150 
     151        ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_GET, &sp); 
     152        if (ret) 
     153                goto out_unlock; 
     154 
     155        pos += snprintf(buf, len, "%d %d %d %d %d %d\n", sp.sp_error, 
     156                        sp.sp_offset, sp.sp_stabletime, 
     157                        sp.sp_calcontrol, sp.sp_extsleepclk, 
     158                        sp.sp_reserved); 
     159 
     160        ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); 
    167161 
    168162out_unlock: 
    169163        free_page(addr); 
    170         return res; 
     164        return ret; 
    171165} 
    172166 
     
    296290        if (!buf) 
    297291                return -ENOMEM; 
    298                  
     292 
    299293        buf_size = min(count, len - 1); 
    300294        if (copy_from_user(buf, userbuf, buf_size)) { 
     
    353347 * if the TLV hasn't been found. 
    354348 */ 
    355 static void *lbs_tlv_find(u16 tlv_type, const u8 *tlv, u16 size) 
    356 { 
    357         __le16 le_type = cpu_to_le16(tlv_type); 
     349static void *lbs_tlv_find(uint16_t tlv_type, const uint8_t *tlv, uint16_t size) 
     350{ 
     351        struct mrvlietypesheader *tlv_h; 
     352        uint16_t length; 
    358353        ssize_t pos = 0; 
    359         struct mrvlietypesheader *tlv_h; 
     354 
    360355        while (pos < size) { 
    361                 u16 length; 
    362356                tlv_h = (struct mrvlietypesheader *) tlv; 
    363                 if (tlv_h->type == le_type) 
     357                if (!tlv_h->len) 
     358                        return NULL; 
     359                if (tlv_h->type == cpu_to_le16(tlv_type)) 
    364360                        return tlv_h; 
    365                 if (tlv_h->len == 0) 
    366                         return NULL; 
    367                 length = le16_to_cpu(tlv_h->len) + 
    368                         sizeof(struct mrvlietypesheader); 
     361                length = le16_to_cpu(tlv_h->len) + sizeof(*tlv_h); 
    369362                pos += length; 
    370363                tlv += length; 
     
    374367 
    375368 
    376 /* 
    377  * This just gets the bitmap of currently subscribed events. Used when 
    378  * adding an additonal event subscription. 
    379  */ 
    380 static u16 lbs_get_events_bitmap(struct lbs_private *priv) 
    381 { 
    382         ssize_t res; 
    383  
    384         struct cmd_ds_802_11_subscribe_event *events = kzalloc( 
    385                 sizeof(struct cmd_ds_802_11_subscribe_event), 
    386                 GFP_KERNEL); 
    387  
    388         res = lbs_prepare_and_send_command(priv, 
    389                         CMD_802_11_SUBSCRIBE_EVENT, CMD_ACT_GET, 
    390                         CMD_OPTION_WAITFORRSP, 0, events); 
    391  
    392         if (res) { 
    393                 kfree(events); 
    394                 return 0; 
    395         } 
    396         return le16_to_cpu(events->events); 
    397 } 
    398  
    399  
    400 static ssize_t lbs_threshold_read( 
    401         u16 tlv_type, u16 event_mask, 
    402         struct file *file, char __user *userbuf, 
    403         size_t count, loff_t *ppos) 
    404 { 
    405         struct lbs_private *priv = file->private_data; 
    406         ssize_t res = 0; 
     369static ssize_t lbs_threshold_read(uint16_t tlv_type, uint16_t event_mask, 
     370                                  struct file *file, char __user *userbuf, 
     371                                  size_t count, loff_t *ppos) 
     372{ 
     373        struct cmd_ds_802_11_subscribe_event *subscribed; 
     374        struct mrvlietypes_thresholds *got; 
     375        struct lbs_private *priv = file->private_data; 
     376        ssize_t ret = 0; 
    407377        size_t pos = 0; 
    408         unsigned long addr = get_zeroed_page(GFP_KERNEL); 
    409         char *buf = (char *)addr; 
     378        char *buf; 
    410379        u8 value; 
    411380        u8 freq; 
    412381        int events = 0; 
    413382 
    414         struct cmd_ds_802_11_subscribe_event *subscribed = kzalloc( 
    415                 sizeof(struct cmd_ds_802_11_subscribe_event), 
    416                 GFP_KERNEL); 
    417         struct mrvlietypes_thresholds *got; 
    418  
    419         res = lbs_prepare_and_send_command(priv, 
    420                         CMD_802_11_SUBSCRIBE_EVENT, CMD_ACT_GET, 
    421                         CMD_OPTION_WAITFORRSP, 0, subscribed); 
    422         if (res) { 
    423                 kfree(subscribed); 
    424                 return res; 
    425         } 
     383        buf = (char *)get_zeroed_page(GFP_KERNEL); 
     384        if (!buf) 
     385                return -ENOMEM; 
     386 
     387        subscribed = kzalloc(sizeof(*subscribed), GFP_KERNEL); 
     388        if (!subscribed) { 
     389                ret = -ENOMEM; 
     390                goto out_page; 
     391        } 
     392 
     393        subscribed->hdr.size = cpu_to_le16(sizeof(*subscribed)); 
     394        subscribed->action = cpu_to_le16(CMD_ACT_GET); 
     395 
     396        ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, subscribed); 
     397        if (ret) 
     398                goto out_cmd; 
    426399 
    427400        got = lbs_tlv_find(tlv_type, subscribed->tlv, sizeof(subscribed->tlv)); 
     
    430403                freq  = got->freq; 
    431404                events = le16_to_cpu(subscribed->events); 
    432         } 
     405 
     406                pos += snprintf(buf, len, "%d %d %d\n", value, freq, 
     407                                !!(events & event_mask)); 
     408        } 
     409 
     410        ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); 
     411 
     412 out_cmd: 
    433413        kfree(subscribed); 
    434414 
    435         if (got) 
    436                 pos += snprintf(buf, len, "%d %d %d\n", value, freq, 
    437                         !!(events & event_mask)); 
    438  
    439         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); 
    440  
    441         free_page(addr); 
    442         return res; 
    443 } 
    444  
    445  
    446 static ssize_t lbs_threshold_write( 
    447         u16 tlv_type, u16 event_mask, 
    448         struct file *file, 
    449         const char __user *userbuf, 
    450         size_t count, loff_t *ppos) 
    451 { 
    452         struct lbs_private *priv = file->private_data; 
    453         ssize_t res, buf_size; 
    454         int value, freq, curr_mask, new_mask; 
    455         unsigned long addr = get_zeroed_page(GFP_KERNEL); 
    456         char *buf = (char *)addr; 
     415 out_page: 
     416        free_page((unsigned long)buf); 
     417        return ret; 
     418} 
     419 
     420 
     421static ssize_t lbs_threshold_write(uint16_t tlv_type, uint16_t event_mask, 
     422                                   struct file *file, 
     423                                   const char __user *userbuf, size_t count, 
     424                                   loff_t *ppos) 
     425{ 
    457426        struct cmd_ds_802_11_subscribe_event *events; 
     427        struct mrvlietypes_thresholds *tlv; 
     428        struct lbs_private *priv = file->private_data; 
     429        ssize_t buf_size; 
     430        int value, freq, new_mask; 
     431        uint16_t curr_mask; 
     432        char *buf; 
     433        int ret; 
     434 
     435        buf = (char *)get_zeroed_page(GFP_KERNEL); 
     436        if (!buf) 
     437                return -ENOMEM; 
    458438 
    459439        buf_size = min(count, len - 1); 
    460440        if (copy_from_user(buf, userbuf, buf_size)) { 
    461                 res = -EFAULT; 
    462                 goto out_unlock; 
    463         } 
    464         res = sscanf(buf, "%d %d %d", &value, &freq, &new_mask); 
    465         if (res != 3) { 
    466                 res = -EFAULT; 
    467                 goto out_unlock; 
    468         } 
    469         curr_mask = lbs_get_events_bitmap(priv); 
     441                ret = -EFAULT; 
     442                goto out_page; 
     443        } 
     444        ret = sscanf(buf, "%d %d %d", &value, &freq, &new_mask); 
     445        if (ret != 3) { 
     446                ret = -EINVAL; 
     447                goto out_page; 
     448        } 
     449        events = kzalloc(sizeof(*events), GFP_KERNEL); 
     450        if (!events) { 
     451                ret = -ENOMEM; 
     452                goto out_page; 
     453        } 
     454 
     455        events->hdr.size = cpu_to_le16(sizeof(*events)); 
     456        events->action = cpu_to_le16(CMD_ACT_GET); 
     457 
     458        ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events); 
     459        if (ret) 
     460                goto out_events; 
     461 
     462        curr_mask = le16_to_cpu(events->events); 
    470463 
    471464        if (new_mask) 
     
    475468 
    476469        /* Now everything is set and we can send stuff down to the firmware */ 
    477         events = kzalloc( 
    478                 sizeof(struct cmd_ds_802_11_subscribe_event), 
    479                 GFP_KERNEL); 
    480         if (events) { 
    481                 struct mrvlietypes_thresholds *tlv = 
    482                         (struct mrvlietypes_thresholds *) events->tlv; 
    483                 events->action = cpu_to_le16(CMD_ACT_SET); 
    484                 events->events = cpu_to_le16(new_mask); 
    485                 tlv->header.type = cpu_to_le16(tlv_type); 
    486                 tlv->header.len = cpu_to_le16( 
    487                         sizeof(struct mrvlietypes_thresholds) - 
    488                         sizeof(struct mrvlietypesheader)); 
    489                 tlv->value = value; 
    490                 if (tlv_type != TLV_TYPE_BCNMISS) 
    491                         tlv->freq = freq; 
    492                 lbs_prepare_and_send_command(priv, 
    493                         CMD_802_11_SUBSCRIBE_EVENT, CMD_ACT_SET, 
    494                         CMD_OPTION_WAITFORRSP, 0, events); 
    495                 kfree(events); 
    496         } 
    497  
    498         res = count; 
    499 out_unlock: 
    500         free_page(addr); 
    501         return res; 
    502 } 
    503  
    504  
    505 static ssize_t lbs_lowrssi_read( 
    506         struct file *file, char __user *userbuf, 
    507         size_t count, loff_t *ppos) 
     470 
     471        tlv = (void *)events->tlv; 
     472 
     473        events->action = cpu_to_le16(CMD_ACT_SET); 
     474        events->events = cpu_to_le16(new_mask); 
     475        tlv->header.type = cpu_to_le16(tlv_type); 
     476        tlv->header.len = cpu_to_le16(sizeof(*tlv) - sizeof(tlv->header)); 
     477        tlv->value = value; 
     478        if (tlv_type != TLV_TYPE_BCNMISS) 
     479                tlv->freq = freq; 
     480 
     481        /* The command header, the event mask, and the one TLV */ 
     482        events->hdr.size = cpu_to_le16(sizeof(events->hdr) + 2 + sizeof(*tlv)); 
     483 
     484        ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events); 
     485 
     486        if (!ret) 
     487                ret = count; 
     488 out_events: 
     489        kfree(events); 
     490 out_page: 
     491        free_page((unsigned long)buf); 
     492        return ret; 
     493} 
     494 
     495 
     496static ssize_t lbs_lowrssi_read(struct file *file, char __user *userbuf, 
     497                                size_t count, loff_t *ppos) 
    508498{ 
    509499        return lbs_threshold_read(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW, 
    510                 file, userbuf, count, ppos); 
    511 } 
    512  
    513  
    514 static ssize_t lbs_lowrssi_write( 
    515         struct file *file, const char __user *userbuf, 
    516         size_t count, loff_t *ppos) 
     500                                  file, userbuf, count, ppos); 
     501} 
     502 
     503 
     504static ssize_t lbs_lowrssi_write(struct file *file, const char __user *userbuf, 
     505                                 size_t count, loff_t *ppos) 
    517506{ 
    518507        return lbs_threshold_write(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW, 
    519                 file, userbuf, count, ppos); 
    520 } 
    521  
    522  
    523 static ssize_t lbs_lowsnr_read( 
    524         struct file *file, char __user *userbuf, 
    525         size_t count, loff_t *ppos) 
     508                                   file, userbuf, count, ppos); 
     509} 
     510 
     511 
     512static ssize_t lbs_lowsnr_read(struct file *file, char __user *userbuf, 
     513                               size_t count, loff_t *ppos) 
    526514{ 
    527515        return lbs_threshold_read(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW, 
    528                 file, userbuf, count, ppos); 
    529 } 
    530  
    531  
    532 static ssize_t lbs_lowsnr_write( 
    533         struct file *file, const char __user *userbuf, 
    534         size_t count, loff_t *ppos) 
     516                                  file, userbuf, count, ppos); 
     517} 
     518 
     519 
     520static ssize_t lbs_lowsnr_write(struct file *file, const char __user *userbuf, 
     521                                size_t count, loff_t *ppos) 
    535522{ 
    536523        return lbs_threshold_write(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW, 
    537                 file, userbuf, count, ppos); 
    538 } 
    539  
    540  
    541 static ssize_t lbs_failcount_read( 
    542         struct file *file, char __user *userbuf, 
    543         size_t count, loff_t *ppos) 
     524                                   file, userbuf, count, ppos); 
     525} 
     526 
     527 
     528static ssize_t lbs_failcount_read(struct file *file, char __user *userbuf, 
     529                                  size_t count, loff_t *ppos) 
    544530{ 
    545531        return lbs_threshold_read(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT, 
    546                 file, userbuf, count, ppos); 
    547 } 
    548  
    549  
    550 static ssize_t lbs_failcount_write( 
    551         struct file *file, const char __user *userbuf, 
    552         size_t count, loff_t *ppos) 
     532                                  file, userbuf, count, ppos); 
     533} 
     534 
     535 
     536static ssize_t lbs_failcount_write(struct file *file, const char __user *userbuf, 
     537                                   size_t count, loff_t *ppos) 
    553538{ 
    554539        return lbs_threshold_write(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT, 
    555                 file, userbuf, count, ppos); 
    556 } 
    557  
    558  
    559 static ssize_t lbs_highrssi_read( 
    560         struct file *file, char __user *userbuf, 
    561         size_t count, loff_t *ppos) 
     540                                   file, userbuf, count, ppos); 
     541} 
     542 
     543 
     544static ssize_t lbs_highrssi_read(struct file *file, char __user *userbuf, 
     545                                 size_t count, loff_t *ppos) 
    562546{ 
    563547        return lbs_threshold_read(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH, 
    564                 file, userbuf, count, ppos); 
    565 } 
    566  
    567  
    568 static ssize_t lbs_highrssi_write( 
    569         struct file *file, const char __user *userbuf, 
    570         size_t count, loff_t *ppos) 
     548                                  file, userbuf, count, ppos); 
     549} 
     550 
     551 
     552static ssize_t lbs_highrssi_write(struct file *file, const char __user *userbuf, 
     553                                  size_t count, loff_t *ppos) 
    571554{ 
    572555        return lbs_threshold_write(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH, 
    573                 file, userbuf, count, ppos); 
    574 } 
    575  
    576  
    577 static ssize_t lbs_highsnr_read( 
    578         struct file *file, char __user *userbuf, 
    579         size_t count, loff_t *ppos) 
     556                                   file, userbuf, count, ppos); 
     557} 
     558 
     559 
     560static ssize_t lbs_highsnr_read(struct file *file, char __user *userbuf, 
     561                                size_t count, loff_t *ppos) 
    580562{ 
    581563        return lbs_threshold_read(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH, 
    582                 file, userbuf, count, ppos); 
    583 } 
    584  
    585  
    586 static ssize_t lbs_highsnr_write( 
    587         struct file *file, const char __user *userbuf, 
    588         size_t count, loff_t *ppos) 
     564                                  file, userbuf, count, ppos); 
     565} 
     566 
     567 
     568static ssize_t lbs_highsnr_write(struct file *file, const char __user *userbuf, 
     569                                 size_t count, loff_t *ppos) 
    589570{ 
    590571        return lbs_threshold_write(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH, 
    591                 file, userbuf, count, ppos); 
    592 } 
    593  
    594 static ssize_t lbs_bcnmiss_read( 
    595         struct file *file, char __user *userbuf, 
    596         size_t count, loff_t *ppos) 
     572                                   file, userbuf, count, ppos); 
     573} 
     574 
     575static ssize_t lbs_bcnmiss_read(struct file *file, char __user *userbuf, 
     576                                size_t count, loff_t *ppos) 
    597577{ 
    598578        return lbs_threshold_read(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS, 
    599                 file, userbuf, count, ppos); 
    600 } 
    601  
    602  
    603 static ssize_t lbs_bcnmiss_write( 
    604         struct file *file, const char __user *userbuf, 
    605         size_t count, loff_t *ppos) 
     579                                  file, userbuf, count, ppos); 
     580} 
     581 
     582 
     583static ssize_t lbs_bcnmiss_write(struct file *file, const char __user *userbuf, 
     584                                 size_t count, loff_t *ppos) 
    606585{ 
    607586        return lbs_threshold_write(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS, 
    608                 file, userbuf, count, ppos); 
    609 } 
    610  
    611  
    612  
    613  
    614  
     587                                   file, userbuf, count, ppos); 
     588} 
    615589 
    616590 
  • trunk/package/libertas/src/decl.h

    r9768 r10235  
    2929        u16 wait_option, u32 cmd_oid, void *pdata_buf); 
    3030 
    31 void lbs_queue_cmd(struct lbs_private *priv, 
    32         struct cmd_ctrl_node *cmdnode, 
    33         u8 addtail); 
    34  
    3531int lbs_allocate_cmd_buffer(struct lbs_private *priv); 
    3632int lbs_execute_next_command(struct lbs_private *priv); 
     
    4642/** The proc fs interface */ 
    4743int lbs_process_rx_command(struct lbs_private *priv); 
    48 void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv, 
    49         struct cmd_ctrl_node *ptempcmd); 
    50  
     44void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd, 
     45                          int result); 
    5146int lbs_hard_start_xmit(struct sk_buff *skb, struct net_device *dev); 
    5247int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band); 
     
    7873void lbs_host_to_card_done(struct lbs_private *priv); 
    7974 
     75int lbs_update_channel(struct lbs_private *priv); 
    8076#endif 
  • trunk/package/libertas/src/defs.h

    r9768 r10235  
    142142#define DEV_NAME_LEN                    32 
    143143 
     144/* Wake criteria for HOST_SLEEP_CFG command */ 
     145#define EHS_WAKE_ON_BROADCAST_DATA      0x0001 
     146#define EHS_WAKE_ON_UNICAST_DATA        0x0002 
     147#define EHS_WAKE_ON_MAC_EVENT           0x0004 
     148#define EHS_WAKE_ON_MULTICAST_DATA      0x0008 
     149#define EHS_REMOVE_WAKEUP               0xFFFFFFFF 
     150 
    144151/** Misc constants */ 
    145152/* This section defines 802.11 specific contants */ 
  • trunk/package/libertas/src/dev.h

    r9768 r10235  
    7878/** sleep_params */ 
    7979struct sleep_params { 
    80         u16 sp_error; 
    81         u16 sp_offset; 
    82         u16 sp_stabletime; 
    83         u8 sp_calcontrol; 
    84         u8 sp_extsleepclk; 
    85         u16 sp_reserved; 
     80        uint16_t sp_error; 
     81        uint16_t sp_offset; 
     82        uint16_t sp_stabletime; 
     83        uint8_t sp_calcontrol; 
     84        uint8_t sp_extsleepclk; 
     85        uint16_t sp_reserved; 
    8686}; 
    8787 
     
    154154        int (*hw_read_event_cause) (struct lbs_private *); 
    155155 
     156        /* Wake On LAN */ 
     157        uint32_t wol_criteria; 
     158        uint8_t wol_gpio; 
     159        uint8_t wol_gap; 
     160 
    156161        /* was struct lbs_adapter from here... */ 
    157162 
     
    197202        /** Timers */ 
    198203        struct timer_list command_timer; 
     204        int nr_retries; 
     205        int cmd_timed_out; 
    199206 
    200207        u8 hisregcpy; 
     
    202209        /** current ssid/bssid related parameters*/ 
    203210        struct current_bss_params curbssparams; 
     211 
     212        uint16_t mesh_tlv; 
    204213        u8 mesh_ssid[IW_ESSID_MAX_SIZE + 1]; 
    205214        u8 mesh_ssid_len; 
     
    252261                                   Wlan802_11PowermodeMAX_PSP=enable */ 
    253262        u32 psstate; 
     263        char ps_supported; 
    254264        u8 needtowakeup; 
    255265 
    256266        struct PS_CMD_ConfirmSleep lbs_ps_confirm_sleep; 
     267        struct cmd_header lbs_ps_confirm_wake; 
    257268 
    258269        struct assoc_request * pending_assoc_req; 
     
    289300        u8 cur_rate; 
    290301        u8 auto_rate; 
    291  
    292         /** sleep_params */ 
    293         struct sleep_params sp; 
    294302 
    295303        /** RF calibration data */ 
  • trunk/package/libertas/src/ethtool.c

    r9768 r10235  
    99#include "join.h" 
    1010#include "wext.h" 
     11#include "cmd.h" 
     12 
    1113static const char * mesh_stat_strings[]= { 
    1214                        "drop_duplicate_bcast", 
     
    143145} 
    144146 
     147static int lbs_ethtool_get_sset_count(struct net_device * dev, int sset) 
     148{ 
     149        switch (sset) { 
     150        case ETH_SS_STATS: 
     151                return MESH_STATS_NUM; 
     152        default: 
     153                return -EOPNOTSUPP; 
     154        } 
     155} 
     156 
    145157static void lbs_ethtool_get_strings(struct net_device *dev, 
    146158                                          u32 stringset, 
     
    163175} 
    164176 
     177static void lbs_ethtool_get_wol(struct net_device *dev, 
     178                                struct ethtool_wolinfo *wol) 
     179{ 
     180        struct lbs_private *priv = dev->priv; 
     181 
     182        if (priv->wol_criteria == 0xffffffff) { 
     183                /* Interface driver didn't configure wake */ 
     184                wol->supported = wol->wolopts = 0; 
     185                return; 
     186        } 
     187 
     188        wol->supported = WAKE_UCAST|WAKE_MCAST|WAKE_BCAST|WAKE_PHY; 
     189 
     190        if (priv->wol_criteria & EHS_WAKE_ON_UNICAST_DATA) 
     191                wol->wolopts |= WAKE_UCAST; 
     192        if (priv->wol_criteria & EHS_WAKE_ON_MULTICAST_DATA) 
     193                wol->wolopts |= WAKE_MCAST; 
     194        if (priv->wol_criteria & EHS_WAKE_ON_BROADCAST_DATA) 
     195                wol->wolopts |= WAKE_BCAST; 
     196        if (priv->wol_criteria & EHS_WAKE_ON_MAC_EVENT) 
     197                wol->wolopts |= WAKE_PHY; 
     198} 
     199 
     200static int lbs_ethtool_set_wol(struct net_device *dev, 
     201                               struct ethtool_wolinfo *wol) 
     202{ 
     203        struct lbs_private *priv = dev->priv; 
     204        uint32_t criteria = 0; 
     205 
     206        if (priv->wol_criteria == 0xffffffff && wol->wolopts) 
     207                return -EOPNOTSUPP; 
     208 
     209        if (wol->wolopts & ~(WAKE_UCAST|WAKE_MCAST|WAKE_BCAST|WAKE_PHY)) 
     210                return -EOPNOTSUPP; 
     211 
     212        if (wol->wolopts & WAKE_UCAST) criteria |= EHS_WAKE_ON_UNICAST_DATA; 
     213        if (wol->wolopts & WAKE_MCAST) criteria |= EHS_WAKE_ON_MULTICAST_DATA; 
     214        if (wol->wolopts & WAKE_BCAST) criteria |= EHS_WAKE_ON_BROADCAST_DATA; 
     215        if (wol->wolopts & WAKE_PHY)   criteria |= EHS_WAKE_ON_MAC_EVENT; 
     216 
     217        return lbs_host_sleep_cfg(priv, criteria); 
     218} 
     219 
    165220struct ethtool_ops lbs_ethtool_ops = { 
    166221        .get_drvinfo = lbs_ethtool_get_drvinfo, 
    167222        .get_eeprom =  lbs_ethtool_get_eeprom, 
    168223        .get_eeprom_len = lbs_ethtool_get_eeprom_len, 
     224        .get_sset_count = lbs_ethtool_get_sset_count, 
    169225        .get_ethtool_stats = lbs_ethtool_get_stats, 
    170226        .get_strings = lbs_ethtool_get_strings, 
     227        .get_wol = lbs_ethtool_get_wol, 
     228        .set_wol = lbs_ethtool_set_wol, 
    171229}; 
    172230 
  • trunk/package/libertas/src/host.h

    r9768 r10235  
    7474#define CMD_802_11_GET_AFC                      0x003d 
    7575#define CMD_802_11_AD_HOC_STOP                  0x0040 
     76#define CMD_802_11_HOST_SLEEP_CFG               0x0043 
     77#define CMD_802_11_WAKEUP_CONFIRM               0x0044 
     78#define CMD_802_11_HOST_SLEEP_ACTIVATE          0x0045 
    7679#define CMD_802_11_BEACON_STOP                  0x0049 
    7780#define CMD_802_11_MAC_ADDRESS                  0x004d 
     
    8386#define CMD_802_11_SLEEP_PARAMS                 0x0066 
    8487#define CMD_802_11_INACTIVITY_TIMEOUT           0x0067 
     88#define CMD_802_11_SLEEP_PERIOD                 0x0068 
    8589#define CMD_802_11_TPC_CFG                      0x0072 
    8690#define CMD_802_11_PWR_CFG                      0x0073 
     91#define CMD_802_11_FW_WAKE_METHOD               0x0074 
    8792#define CMD_802_11_SUBSCRIBE_EVENT              0x0075 
    8893#define CMD_802_11_RATE_ADAPT_RATESET           0x0076 
     
    204209#define CMD_TYPE_MAX_PSP                0x0001 
    205210#define CMD_TYPE_FAST_PSP               0x0002 
     211 
     212/* Options for CMD_802_11_FW_WAKE_METHOD */ 
     213#define CMD_WAKE_METHOD_UNCHANGED       0x0000 
     214#define CMD_WAKE_METHOD_COMMAND_INT     0x0001 
     215#define CMD_WAKE_METHOD_GPIO            0x0002 
    206216 
    207217/* Define action or option for CMD_BT_ACCESS */ 
  • trunk/package/libertas/src/hostcmd.h

    r9768 r10235  
    7575struct cmd_ctrl_node { 
    7676        struct list_head list; 
    77         /* wait for finish or not */ 
    78         u16 wait_option; 
     77        int result; 
    7978        /* command response */ 
    80         void *pdata_buf; 
    8179        int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *); 
    8280        unsigned long callback_arg; 
     
    159157 
    160158struct cmd_ds_802_11_subscribe_event { 
     159        struct cmd_header hdr; 
     160 
    161161        __le16 action; 
    162162        __le16 events; 
     
    167167         * bump this up a bit. 
    168168         */ 
    169         u8 tlv[128]; 
     169        uint8_t tlv[128]; 
    170170}; 
    171171 
     
    259259 
    260260struct cmd_ds_802_11_set_wep { 
     261        struct cmd_header hdr; 
     262 
    261263        /* ACT_ADD, ACT_REMOVE or ACT_ENABLE */ 
    262264        __le16 action; 
     
    266268 
    267269        /* 40, 128bit or TXWEP */ 
    268         u8 keytype[4]; 
    269         u8 keymaterial[4][16]; 
     270        uint8_t keytype[4]; 
     271        uint8_t keymaterial[4][16]; 
    270272}; 
    271273 
     
    345347 
    346348struct cmd_ds_802_11_radio_control { 
     349        struct cmd_header hdr; 
     350 
    347351        __le16 action; 
    348352        __le16 control; 
     
    356360 
    357361struct cmd_ds_802_11_sleep_params { 
     362        struct cmd_header hdr; 
     363 
    358364        /* ACT_GET/ACT_SET */ 
    359365        __le16 action; 
     
    369375 
    370376        /* control periodic calibration */ 
    371         u8 calcontrol; 
     377        uint8_t calcontrol; 
    372378 
    373379        /* control the use of external sleep clock */ 
    374         u8 externalsleepclk; 
     380        uint8_t externalsleepclk; 
    375381 
    376382        /* reserved field, should be set to zero */ 
     
    379385 
    380386struct cmd_ds_802_11_inactivity_timeout { 
     387        struct cmd_header hdr; 
     388 
    381389        /* ACT_GET/ACT_SET */ 
    382390        __le16 action; 
     
    440448        __le16 action; 
    441449        __le16 version; 
     450}; 
     451 
     452struct cmd_ds_802_11_fw_wake_method { 
     453        struct cmd_header hdr; 
     454 
     455        __le16 action; 
     456        __le16 method; 
     457}; 
     458 
     459struct cmd_ds_802_11_sleep_period { 
     460        struct cmd_header hdr; 
     461 
     462        __le16 action; 
     463        __le16 period; 
    442464}; 
    443465 
     
    517539 
    518540struct cmd_ds_802_11_enable_rsn { 
     541        struct cmd_header hdr; 
     542 
    519543        __le16 action; 
    520544        __le16 enable; 
     
    540564        u8 key[32]; 
    541565}; 
     566 
     567struct cmd_ds_host_sleep { 
     568        struct cmd_header hdr; 
     569        __le32 criteria; 
     570        uint8_t gpio; 
     571        uint8_t gap; 
     572} __attribute__ ((packed)); 
    542573 
    543574struct cmd_ds_802_11_key_material { 
     
    664695                struct cmd_ds_802_11_associate associate; 
    665696                struct cmd_ds_802_11_deauthenticate deauth; 
    666                 struct cmd_ds_802_11_set_wep wep; 
    667697                struct cmd_ds_802_11_ad_hoc_start ads; 
    668698                struct cmd_ds_802_11_reset reset; 
     
    679709                struct cmd_ds_mac_multicast_adr madr; 
    680710                struct cmd_ds_802_11_ad_hoc_join adj; 
    681                 struct cmd_ds_802_11_radio_control radio; 
    682                 struct cmd_ds_802_11_rf_channel rfchannel; 
    683711                struct cmd_ds_802_11_rssi rssi; 
    684712                struct cmd_ds_802_11_rssi_rsp rssirsp; 
    685713                struct cmd_ds_802_11_disassociate dassociate; 
    686714                struct cmd_ds_802_11_mac_address macadd; 
    687                 struct cmd_ds_802_11_enable_rsn enbrsn; 
    688715                struct cmd_ds_802_11_key_material keymaterial; 
    689716                struct cmd_ds_mac_reg_access macreg; 
     
    695722                struct cmd_ds_802_11d_domain_info domaininforesp; 
    696723 
    697                 struct cmd_ds_802_11_sleep_params sleep_params; 
    698                 struct cmd_ds_802_11_inactivity_timeout inactivity_timeout; 
    699724                struct cmd_ds_802_11_tpc_cfg tpccfg; 
    700725                struct cmd_ds_802_11_pwr_cfg pwrcfg; 
     
    706731                struct cmd_ds_fwt_access fwt; 
    707732                struct cmd_ds_get_tsf gettsf; 
    708                 struct cmd_ds_802_11_subscribe_event subscribe_event; 
    709733                struct cmd_ds_802_11_beacon_control bcn_ctrl; 
    710734        } params; 
  • trunk/package/libertas/src/if_cs.c

    r9768 r10235  
    244244static irqreturn_t if_cs_interrupt(int irq, void *data) 
    245245{ 
    246         struct if_cs_card *card = data; 
     246        struct if_cs_card *card = (struct if_cs_card *)data; 
    247247        u16 int_cause; 
    248248 
     
    648648        int ret = 0; 
    649649        u16 int_cause; 
    650         u8 *cmdbuf; 
    651650        *ireg = 0; 
    652651 
     
    680679        if (*ireg & IF_CS_C_S_CMD_UPLD_RDY) { 
    681680                spin_lock(&priv->driver_lock); 
    682                 if (!priv->cur_cmd) { 
    683                         cmdbuf = priv->upld_buf; 
    684                         priv->hisregcpy &= ~IF_CS_C_S_RX_UPLD_RDY; 
    685                 } else { 
    686                         cmdbuf = (u8 *) priv->cur_cmd->cmdbuf; 
    687                 } 
    688  
    689                 ret = if_cs_receive_cmdres(priv, cmdbuf, &priv->upld_len); 
     681                ret = if_cs_receive_cmdres(priv, priv->upld_buf, &priv->upld_len); 
    690682                spin_unlock(&priv->driver_lock); 
    691683                if (ret < 0) 
  • trunk/package/libertas/src/if_sdio.c

    r9768 r10235  
    2020 * 
    2121 * As SDIO is still new to the kernel, it is unfortunately common with 
    22  * bugs in the host controllers related to that. One such bug is that  
     22 * bugs in the host controllers related to that. One such bug is that 
    2323 * controllers cannot do transfers that aren't a multiple of 4 bytes. 
    2424 * If you don't have time to fix the host controller driver, you can 
     
    137137        spin_lock_irqsave(&card->priv->driver_lock, flags); 
    138138 
    139         if (!card->priv->cur_cmd) { 
    140                 lbs_deb_sdio("discarding spurious response\n"); 
    141                 ret = 0; 
    142                 goto out; 
    143         } 
    144  
    145139        if (size > LBS_CMD_BUFFER_SIZE) { 
    146140                lbs_deb_sdio("response packet too large (%d bytes)\n", 
     
    150144        } 
    151145 
    152         memcpy(card->priv->cur_cmd->cmdbuf, buffer, size); 
     146        memcpy(card->priv->upld_buf, buffer, size); 
    153147        card->priv->upld_len = size; 
    154148 
  • trunk/package/libertas/src/if_usb.c

    r9768 r10235  
    1717#include "if_usb.h" 
    1818 
     19#define INSANEDEBUG     0 
     20#define lbs_deb_usb2(...) do { if (INSANEDEBUG) lbs_deb_usbd(__VA_ARGS__); } while (0) 
     21 
    1922#define MESSAGE_HEADER_LEN      4 
    2023 
     
    3336static void if_usb_receive(struct urb *urb); 
    3437static void if_usb_receive_fwload(struct urb *urb); 
    35 static int if_usb_prog_firmware(struct usb_card_rec *cardp); 
    36 static int if_usb_host_to_card(struct lbs_private *priv, 
    37         u8 type, 
    38         u8 *payload, 
    39         u16 nb); 
    40 static int if_usb_get_int_status(struct lbs_private *priv, u8 *); 
     38static int if_usb_prog_firmware(struct if_usb_card *cardp); 
     39static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type, 
     40                               uint8_t *payload, uint16_t nb); 
     41static int if_usb_get_int_status(struct lbs_private *priv, uint8_t *); 
    4142static int if_usb_read_event_cause(struct lbs_private *); 
    42 static int usb_tx_block(struct usb_card_rec *cardp, u8 *payload, u16 nb); 
    43 static void if_usb_free(struct usb_card_rec *cardp); 
    44 static int if_usb_submit_rx_urb(struct usb_card_rec *cardp); 
    45 static int if_usb_reset_device(struct usb_card_rec *cardp); 
     43static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, 
     44                        uint16_t nb); 
     45static void if_usb_free(struct if_usb_card *cardp); 
     46static int if_usb_submit_rx_urb(struct if_usb_card *cardp); 
     47static int if_usb_reset_device(struct if_usb_card *cardp); 
    4648 
    4749/** 
     
    5254static void if_usb_write_bulk_callback(struct urb *urb) 
    5355{ 
    54         struct usb_card_rec *cardp = (struct usb_card_rec *) urb->context; 
     56        struct if_usb_card *cardp = (struct if_usb_card *) urb->context; 
    5557 
    5658        /* handle the transmission complete validations */ 
     
    5961                struct lbs_private *priv = cardp->priv; 
    6062 
    61                 /* 
    62                 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n"); 
    63                 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n", 
    64                        urb->actual_length); 
    65                 */ 
     63                lbs_deb_usb2(&urb->dev->dev, "URB status is successful\n"); 
     64                lbs_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n", 
     65                             urb->actual_length); 
    6666 
    6767                /* Used for both firmware TX and regular TX.  priv isn't 
     
    8080/** 
    8181 *  @brief  free tx/rx urb, skb and rx buffer 
    82  *  @param cardp        pointer usb_card_rec 
     82 *  @param cardp        pointer if_usb_card 
    8383 *  @return             N/A 
    8484 */ 
    85 static void if_usb_free(struct usb_card_rec *cardp) 
     85static void if_usb_free(struct if_usb_card *cardp) 
    8686{ 
    8787        lbs_deb_enter(LBS_DEB_USB); 
     
    9797        cardp->rx_urb = NULL; 
    9898 
    99         kfree(cardp->bulk_out_buffer); 
    100         cardp->bulk_out_buffer = NULL; 
     99        kfree(cardp->ep_out_buf); 
     100        cardp->ep_out_buf = NULL; 
    101101 
    102102        lbs_deb_leave(LBS_DEB_USB); 
    103103} 
    104104 
    105 static void if_usb_set_boot2_ver(struct lbs_private *priv) 
     105static void if_usb_setup_firmware(struct lbs_private *priv) 
    106106{ 
    107107        struct cmd_ds_set_boot2_ver b2_cmd; 
    108  
     108        struct cmd_ds_802_11_fw_wake_method wake_method; 
     109 
     110        b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd)); 
    109111        b2_cmd.action = 0; 
    110112        b2_cmd.version = priv->boot2_version; 
    111113 
    112         if (lbs_cmd(priv, CMD_SET_BOOT2_VER, b2_cmd, NULL, 0)) 
     114        if (lbs_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd)) 
    113115                lbs_deb_usb("Setting boot2 version failed\n"); 
     116 
     117        priv->wol_gpio = 2; /* Wake via GPIO2... */ 
     118        priv->wol_gap = 20; /* ... after 20ms    */ 
     119        lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA); 
     120 
     121        wake_method.hdr.size = cpu_to_le16(sizeof(wake_method)); 
     122        wake_method.action = cpu_to_le16(CMD_ACT_GET); 
     123        if (lbs_cmd_with_response(priv, CMD_802_11_FW_WAKE_METHOD, &wake_method)) { 
     124                lbs_pr_info("Firmware does not seem to support PS mode\n"); 
     125        } else { 
     126                if (le16_to_cpu(wake_method.method) == CMD_WAKE_METHOD_COMMAND_INT) { 
     127                        lbs_deb_usb("Firmware seems to support PS with wake-via-command\n"); 
     128                        priv->ps_supported = 1; 
     129                } else { 
     130                        /* The versions which boot up this way don't seem to 
     131                           work even if we set it to the command interrupt */ 
     132                        lbs_pr_info("Firmware doesn't wake via command interrupt; disabling PS mode\n"); 
     133                } 
     134        } 
    114135} 
    115136 
    116137static void if_usb_fw_timeo(unsigned long priv) 
    117138{ 
    118         struct usb_card_rec *cardp = (void *)priv; 
     139        struct if_usb_card *cardp = (void *)priv; 
    119140 
    120141        if (cardp->fwdnldover) { 
     
    126147        wake_up(&cardp->fw_wq); 
    127148} 
     149 
    128150/** 
    129151 *  @brief sets the configuration values 
     
    139161        struct usb_endpoint_descriptor *endpoint; 
    140162        struct lbs_private *priv; 
    141         struct usb_card_rec *cardp; 
     163        struct if_usb_card *cardp; 
    142164        int i; 
    143165 
    144166        udev = interface_to_usbdev(intf); 
    145167 
    146         cardp = kzalloc(sizeof(struct usb_card_rec), GFP_KERNEL); 
     168        cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL); 
    147169        if (!cardp) { 
    148170                lbs_pr_err("Out of memory allocating private data.\n"); 
     
    152174        setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp); 
    153175        init_waitqueue_head(&cardp->fw_wq); 
    154                                                                       
     176 
    155177        cardp->udev = udev; 
    156178        iface_desc = intf->cur_altsetting; 
    157179 
    158180        lbs_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X" 
    159                " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n", 
     181                     " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n", 
    160182                     le16_to_cpu(udev->descriptor.bcdUSB), 
    161183                     udev->descriptor.bDeviceClass, 
     
    165187        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 
    166188                endpoint = &iface_desc->endpoint[i].desc; 
    167                 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) 
    168                     && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 
    169                         USB_ENDPOINT_XFER_BULK)) { 
    170                         /* we found a bulk in endpoint */ 
    171                         lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", 
    172                                      le16_to_cpu(endpoint->wMaxPacketSize)); 
    173                         if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) { 
    174                                 lbs_deb_usbd(&udev->dev, 
    175                                        "Rx URB allocation failed\n"); 
    176                                 goto dealloc; 
    177                         } 
    178                         cardp->bulk_in_size = 
    179                                 le16_to_cpu(endpoint->wMaxPacketSize); 
    180                         cardp->bulk_in_endpointAddr = 
    181                             (endpoint-> 
    182                              bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 
    183                         lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", 
    184                                endpoint->bEndpointAddress); 
     189                if (usb_endpoint_is_bulk_in(endpoint)) { 
     190                        cardp->ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize); 
     191                        cardp->ep_in = usb_endpoint_num(endpoint); 
     192 
     193                        lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in); 
     194                        lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size); 
     195 
     196                } else if (usb_endpoint_is_bulk_out(endpoint)) { 
     197                        cardp->ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize); 
     198                        cardp->ep_out = usb_endpoint_num(endpoint); 
     199 
     200                        lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out); 
     201                        lbs_deb_usbd(&udev->dev, "Bulk out size is %d\n", cardp->ep_out_size); 
    185202                } 
    186  
    187                 if (((endpoint-> 
    188                       bEndpointAddress & USB_ENDPOINT_DIR_MASK) == 
    189                      USB_DIR_OUT) 
    190                     && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 
    191                         USB_ENDPOINT_XFER_BULK)) { 
    192                         /* We found bulk out endpoint */ 
    193                         if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) { 
    194                                 lbs_deb_usbd(&udev->dev, 
    195                                        "Tx URB allocation failed\n"); 
    196                                 goto dealloc; 
    197                         } 
    198  
    199                         cardp->bulk_out_size = 
    200                                 le16_to_cpu(endpoint->wMaxPacketSize); 
    201                         lbs_deb_usbd(&udev->dev, 
    202                                      "Bulk out size is %d\n", 
    203                                      le16_to_cpu(endpoint->wMaxPacketSize)); 
    204                         cardp->bulk_out_endpointAddr = 
    205                             endpoint->bEndpointAddress; 
    206                         lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", 
    207                                     endpoint->bEndpointAddress); 
    208                         cardp->bulk_out_buffer = 
    209                             kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, 
    210                                     GFP_KERNEL); 
    211  
    212                         if (!cardp->bulk_out_buffer) { 
    213                                 lbs_deb_usbd(&udev->dev, 
    214                                        "Could not allocate buffer\n"); 
    215                                 goto dealloc; 
    216                         } 
    217                 } 
     203        } 
     204        if (!cardp->ep_out_size || !cardp->ep_in_size) { 
     205                lbs_deb_usbd(&udev->dev, "Endpoints not found\n"); 
     206                goto dealloc; 
     207        } 
     208        if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) { 
     209                lbs_deb_usbd(&udev->dev, "Rx URB allocation failed\n"); 
     210                goto dealloc; 
     211        } 
     212        if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) { 
     213                lbs_deb_usbd(&udev->dev, "Tx URB allocation failed\n"); 
     214                goto dealloc; 
     215        } 
     216        cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL); 
     217        if (!cardp->ep_out_buf) { 
     218                lbs_deb_usbd(&udev->dev, "Could not allocate buffer\n"); 
     219                goto dealloc; 
    218220        } 
    219221 
    220222        /* Upload firmware */ 
    221         cardp->rinfo.cardp = cardp; 
    222223        if (if_usb_prog_firmware(cardp)) { 
    223                 lbs_deb_usbd(&udev->dev, "FW upload failed"); 
     224                lbs_deb_usbd(&udev->dev, "FW upload failed\n"); 
    224225                goto err_prog_firmware; 
    225226        } 
     
    241242                goto err_start_card; 
    242243 
    243         if_usb_set_boot2_ver(priv); 
     244        if_usb_setup_firmware(priv); 
    244245 
    245246        usb_get_dev(udev); 
     
    266267static void if_usb_disconnect(struct usb_interface *intf) 
    267268{ 
    268         struct usb_card_rec *cardp = usb_get_intfdata(intf); 
     269        struct if_usb_card *cardp = usb_get_intfdata(intf); 
    269270        struct lbs_private *priv = (struct lbs_private *) cardp->priv; 
    270271 
    271272        lbs_deb_enter(LBS_DEB_MAIN); 
    272273 
    273         /* Update Surprise removed to TRUE */ 
    274274        cardp->surprise_removed = 1; 
    275275 
    276276        if (priv) { 
    277  
    278277                priv->surpriseremoved = 1; 
    279278                lbs_stop_card(priv); 
    280279                lbs_remove_card(priv); 
    281280        } 
    282  
    283         /* this is (apparently?) necessary for future usage of the device */ 
    284         lbs_prepare_and_send_command(priv, CMD_802_11_RESET, CMD_ACT_HALT, 
    285                         0, 0, NULL); 
    286281 
    287282        /* Unlink and free urb */ 
     
    299294 *  @return             0 
    300295 */ 
    301 static int if_usb_send_fw_pkt(struct usb_card_rec *cardp) 
    302 { 
    303         struct FWData *fwdata; 
    304         struct fwheader *fwheader; 
    305         u8 *firmware = cardp->fw->data; 
    306  
    307         fwdata = kmalloc(sizeof(struct FWData), GFP_ATOMIC); 
    308  
    309         if (!fwdata) 
    310                 return -1; 
    311  
    312         fwheader = &fwdata->fwheader; 
    313  
     296static int if_usb_send_fw_pkt(struct if_usb_card *cardp) 
     297{ 
     298        struct fwdata *fwdata = cardp->ep_out_buf; 
     299        uint8_t *firmware = cardp->fw->data; 
     300 
     301        /* If we got a CRC failure on the last block, back 
     302           up and retry it */ 
    314303        if (!cardp->CRC_OK) { 
    315304                cardp->totalbytes = cardp->fwlastblksent; 
    316                 cardp->fwseqnum = cardp->lastseqnum - 1; 
    317         } 
    318  
    319         /* 
    320         lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n", 
    321                     cardp->totalbytes); 
    322         */ 
    323  
    324         memcpy(fwheader, &firmware[cardp->totalbytes], 
     305                cardp->fwseqnum--; 
     306        } 
     307 
     308        lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n", 
     309                     cardp->totalbytes); 
     310 
     311        /* struct fwdata (which we sent to the card) has an 
     312           extra __le32 field in between the header and the data, 
     313           which is not in the struct fwheader in the actual 
     314           firmware binary. Insert the seqnum in the middle... */ 
     315        memcpy(&fwdata->hdr, &firmware[cardp->totalbytes], 
    325316               sizeof(struct fwheader)); 
    326317 
     
    328319        cardp->totalbytes += sizeof(struct fwheader); 
    329320 
    330         /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */ 
    331321        memcpy(fwdata->data, &firmware[cardp->totalbytes], 
    332                le32_to_cpu(fwdata->fwheader.datalength)); 
    333  
    334         /* 
    335         lbs_deb_usbd(&cardp->udev->dev, 
    336                     "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength)); 
    337         */ 
    338  
    339         cardp->fwseqnum = cardp->fwseqnum + 1; 
    340  
    341         fwdata->seqnum = cpu_to_le32(cardp->fwseqnum); 
    342         cardp->lastseqnum = cardp->fwseqnum; 
    343         cardp->totalbytes += le32_to_cpu(fwdata->fwheader.datalength); 
    344  
    345         if (fwheader->dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) { 
    346                 /* 
    347                 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n"); 
    348                 lbs_deb_usbd(&cardp->udev->dev, 
    349                             "seqnum = %d totalbytes = %d\n", cardp->fwseqnum, 
    350                             cardp->totalbytes); 
    351                 */ 
    352                 memcpy(cardp->bulk_out_buffer, fwheader, FW_DATA_XMIT_SIZE); 
    353                 usb_tx_block(cardp, cardp->bulk_out_buffer, FW_DATA_XMIT_SIZE); 
    354  
    355         } else if (fwdata->fwheader.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) { 
    356                 /* 
    357                 lbs_deb_usbd(&cardp->udev->dev, 
    358                             "Host has finished FW downloading\n"); 
    359                 lbs_deb_usbd(&cardp->udev->dev, 
    360                             "Donwloading FW JUMP BLOCK\n"); 
    361                 */ 
    362                 memcpy(cardp->bulk_out_buffer, fwheader, FW_DATA_XMIT_SIZE); 
    363                 usb_tx_block(cardp, cardp->bulk_out_buffer, FW_DATA_XMIT_SIZE); 
     322               le32_to_cpu(fwdata->hdr.datalength)); 
     323 
     324        lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n", 
     325                     le32_to_cpu(fwdata->hdr.datalength)); 
     326 
     327        fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum); 
     328        cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength); 
     329 
     330        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) + 
     331                     le32_to_cpu(fwdata->hdr.datalength)); 
     332 
     333        if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) { 
     334                lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n"); 
     335                lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n", 
     336                             cardp->fwseqnum, cardp->totalbytes); 
     337        } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) { 
     338                lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n"); 
     339                lbs_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n"); 
     340 
    364341                cardp->fwfinalblk = 1; 
    365342        } 
    366343 
    367         /* 
    368         lbs_deb_usbd(&cardp->udev->dev, 
    369                     "The firmware download is done size is %d\n", 
    370                     cardp->totalbytes); 
    371         */ 
    372  
    373         kfree(fwdata); 
     344        lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n", 
     345                     cardp->totalbytes); 
    374346 
    375347        return 0; 
    376348} 
    377349 
    378 static int if_usb_reset_device(struct usb_card_rec *cardp) 
    379 { 
    380         struct cmd_ds_command *cmd = (void *)&cardp->bulk_out_buffer[4]; 
     350static int if_usb_reset_device(struct if_usb_card *cardp) 
     351{ 
     352        struct cmd_ds_command *cmd = cardp->ep_out_buf + 4; 
    381353        int ret; 
    382354 
    383355        lbs_deb_enter(LBS_DEB_USB); 
    384356 
    385         *(__le32 *)cardp->bulk_out_buffer = cpu_to_le32(CMD_TYPE_REQUEST); 
     357        *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 
    386358 
    387359        cmd->command = cpu_to_le16(CMD_802_11_RESET); 
     
    390362        cmd->seqnum = cpu_to_le16(0x5a5a); 
    391363        cmd->params.reset.action = cpu_to_le16(CMD_ACT_HALT); 
    392         usb_tx_block(cardp, cardp->bulk_out_buffer, 4 + S_DS_GEN + sizeof(struct cmd_ds_802_11_reset)); 
     364        usb_tx_block(cardp, cardp->ep_out_buf, 4 + S_DS_GEN + sizeof(struct cmd_ds_802_11_reset)); 
    393365 
    394366        msleep(100); 
     
    408380 *  @return             0 or -1 
    409381 */ 
    410 static int usb_tx_block(struct usb_card_rec *cardp, u8 * payload, u16 nb) 
     382static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb) 
    411383{ 
    412384        int ret = -1; 
     
    420392        usb_fill_bulk_urb(cardp->tx_urb, cardp->udev, 
    421393                          usb_sndbulkpipe(cardp->udev, 
    422                                           cardp->bulk_out_endpointAddr), 
     394                                          cardp->ep_out), 
    423395                          payload, nb, if_usb_write_bulk_callback, cardp); 
    424396 
     
    426398 
    427399        if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) { 
    428                 /*  transfer failed */ 
    429400                lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret); 
    430401                ret = -1; 
    431402        } else { 
    432                 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */ 
     403                lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n"); 
    433404                ret = 0; 
    434405        } 
     
    438409} 
    439410 
    440 static int __if_usb_submit_rx_urb(struct usb_card_rec *cardp, 
     411static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, 
    441412                                  void (*callbackfn)(struct urb *urb)) 
    442413{ 
    443414        struct sk_buff *skb; 
    444         struct read_cb_info *rinfo = &cardp->rinfo; 
    445415        int ret = -1; 
    446416 
     
    450420        } 
    451421 
    452         rinfo->skb = skb; 
     422        cardp->rx_skb = skb; 
    453423 
    454424        /* Fill the receive configuration URB and initialise the Rx call back */ 
    455425        usb_fill_bulk_urb(cardp->rx_urb, cardp->udev, 
    456                           usb_rcvbulkpipe(cardp->udev, 
    457                                           cardp->bulk_in_endpointAddr), 
     426                          usb_rcvbulkpipe(cardp->udev, cardp->ep_in), 
    458427                          (void *) (skb->tail + (size_t) IPFIELD_ALIGN_OFFSET), 
    459428                          MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, 
    460                           rinfo); 
     429                          cardp); 
    461430 
    462431        cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET; 
    463432 
    464         /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */ 
     433        lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); 
    465434        if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) { 
    466                 /* handle failure conditions */ 
    467435                lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret); 
    468436                kfree_skb(skb); 
    469                 rinfo->skb = NULL; 
     437                cardp->rx_skb = NULL; 
    470438                ret = -1; 
    471439        } else { 
    472                 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */ 
     440                lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n"); 
    473441                ret = 0; 
    474442        } 
     
    478446} 
    479447 
    480 static int if_usb_submit_rx_urb_fwload(struct usb_card_rec *cardp) 
     448static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp) 
    481449{ 
    482450        return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload); 
    483451} 
    484452 
    485 static int if_usb_submit_rx_urb(struct usb_card_rec *cardp) 
     453static int if_usb_submit_rx_urb(struct if_usb_card *cardp) 
    486454{ 
    487455        return __if_usb_submit_rx_urb(cardp, &if_usb_receive); 
     
    490458static void if_usb_receive_fwload(struct urb *urb) 
    491459{ 
    492         struct read_cb_info *rinfo = (struct read_cb_info *)urb->context; 
    493         struct sk_buff *skb = rinfo->skb; 
    494         struct usb_card_rec *cardp = (struct usb_card_rec *)rinfo->cardp; 
     460        struct if_usb_card *cardp = urb->context; 
     461        struct sk_buff *skb = cardp->rx_skb; 
    495462        struct fwsyncheader *syncfwheader; 
    496         struct bootcmdrespStr bootcmdresp; 
     463        struct bootcmdresp bootcmdresp; 
    497464 
    498465        if (urb->status) { 
    499466                lbs_deb_usbd(&cardp->udev->dev, 
    500                             "URB status is failed during fw load\n"); 
     467                             "URB status is failed during fw load\n"); 
    501468                kfree_skb(skb); 
    502469                return; 
     
    511478                        wake_up(&cardp->fw_wq); 
    512479                } else { 
    513                         lbs_deb_usb("Waiting for confirmation; got %x %x\n", le32_to_cpu(tmp[0]), 
    514                                     le32_to_cpu(tmp[1])); 
     480                        lbs_deb_usb("Waiting for confirmation; got %x %x\n", 
     481                                    le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1])); 
    515482                        if_usb_submit_rx_urb_fwload(cardp); 
    516483                } 
     
    521488                memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET, 
    522489                        sizeof(bootcmdresp)); 
     490 
    523491                if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) { 
    524492                        kfree_skb(skb); 
     
    526494                        cardp->bootcmdresp = 1; 
    527495                        lbs_deb_usbd(&cardp->udev->dev, 
    528                                     "Received valid boot command response\n"); 
     496                                     "Received valid boot command response\n"); 
    529497                        return; 
    530498                } 
    531                 if (bootcmdresp.u32magicnumber != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { 
    532                         if (bootcmdresp.u32magicnumber == cpu_to_le32(CMD_TYPE_REQUEST) || 
    533                             bootcmdresp.u32magicnumber == cpu_to_le32(CMD_TYPE_DATA) || 
    534                             bootcmdresp.u32magicnumber == cpu_to_le32(CMD_TYPE_INDICATION)) { 
     499                if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { 
     500                        if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) || 
     501                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) || 
     502                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) { 
    535503                                if (!cardp->bootcmdresp) 
    536504                                        lbs_pr_info("Firmware already seems alive; resetting\n"); 
     
    538506                        } else { 
    539507                                lbs_pr_info("boot cmd response wrong magic number (0x%x)\n", 
    540                                             le32_to_cpu(bootcmdresp.u32magicnumber)); 
     508                                            le32_to_cpu(bootcmdresp.magic)); 
    541509                        } 
    542                 } else if (bootcmdresp.u8cmd_tag != BOOT_CMD_FW_BY_USB) { 
    543                         lbs_pr_info( 
    544                                 "boot cmd response cmd_tag error (%d)\n", 
    545                                 bootcmdresp.u8cmd_tag); 
    546                 } else if (bootcmdresp.u8result != BOOT_CMD_RESP_OK) { 
    547                         lbs_pr_info( 
    548                                 "boot cmd response result error (%d)\n", 
    549                                 bootcmdresp.u8result); 
     510                } else if (bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) { 
     511                        lbs_pr_info("boot cmd response cmd_tag error (%d)\n", 
     512                                    bootcmdresp.cmd); 
     513                } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) { 
     514                        lbs_pr_info("boot cmd response result error (%d)\n", 
     515                                    bootcmdresp.result); 
    550516                } else { 
    551517                        cardp->bootcmdresp = 1; 
    552518                        lbs_deb_usbd(&cardp->udev->dev, 
    553                                     "Received valid boot command response\n"); 
     519                                     "Received valid boot command response\n"); 
    554520                } 
    555521                kfree_skb(skb); 
     
    566532 
    567533        memcpy(syncfwheader, skb->data + IPFIELD_ALIGN_OFFSET, 
    568                         sizeof(struct fwsyncheader)); 
     534               sizeof(struct fwsyncheader)); 
    569535 
    570536        if (!syncfwheader->cmd) { 
    571                 /* 
    572                 lbs_deb_usbd(&cardp->udev->dev, 
    573                             "FW received Blk with correct CRC\n"); 
    574                 lbs_deb_usbd(&cardp->udev->dev, 
    575                             "FW received Blk seqnum = %d\n", 
    576                        syncfwheader->seqnum); 
    577                 */ 
     537                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n"); 
     538                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n", 
     539                             le32_to_cpu(syncfwheader->seqnum)); 
    578540                cardp->CRC_OK = 1; 
    579541        } else { 
    580                 lbs_deb_usbd(&cardp->udev->dev, 
    581                             "FW received Blk with CRC error\n"); 
     542                lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n"); 
    582543                cardp->CRC_OK = 0; 
    583544        } 
     
    606567 
    607568static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb, 
    608                                        struct usb_card_rec *cardp, 
     569                                       struct if_usb_card *cardp, 
    609570                                       struct lbs_private *priv) 
    610571{ 
    611         if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + 
    612             MESSAGE_HEADER_LEN || recvlength < MRVDRV_MIN_PKT_LEN) { 
    613                 lbs_deb_usbd(&cardp->udev->dev, 
    614                             "Packet length is Invalid\n"); 
     572        if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN 
     573            || recvlength < MRVDRV_MIN_PKT_LEN) { 
     574                lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n"); 
    615575                kfree_skb(skb); 
    616576                return; 
     
    620580        skb_put(skb, recvlength); 
    621581        skb_pull(skb, MESSAGE_HEADER_LEN); 
     582 
    622583        lbs_process_rxed_packet(priv, skb); 
    623584        priv->upld_len = (recvlength - MESSAGE_HEADER_LEN); 
    624585} 
    625586 
    626 static inline void process_cmdrequest(int recvlength, u8 *recvbuff, 
     587static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff, 
    627588                                      struct sk_buff *skb, 
    628                                       struct usb_card_rec *cardp, 
     589                                      struct if_usb_card *cardp, 
    629590                                      struct lbs_private *priv) 
    630591{ 
    631         u8 *cmdbuf; 
    632592        if (recvlength > LBS_CMD_BUFFER_SIZE) { 
    633593                lbs_deb_usbd(&cardp->udev->dev, 
    634                             "The receive buffer is too large\n"); 
     594                             "The receive buffer is too large\n"); 
    635595                kfree_skb(skb); 
    636596                return; 
     
    641601 
    642602        spin_lock(&priv->driver_lock); 
    643         /* take care of cur_cmd = NULL case by reading the 
    644          * data to clear the interrupt */ 
    645         if (!priv->cur_cmd) { 
    646                 cmdbuf = priv->upld_buf; 
    647                 priv->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; 
    648         } else 
    649                 cmdbuf = (u8 *) priv->cur_cmd->cmdbuf; 
    650  
    651603        cardp->usb_int_cause |= MRVDRV_CMD_UPLD_RDY; 
    652604        priv->upld_len = (recvlength - MESSAGE_HEADER_LEN); 
    653         memcpy(cmdbuf, recvbuff + MESSAGE_HEADER_LEN, 
    654                priv->upld_len); 
     605        memcpy(priv->upld_buf, recvbuff + MESSAGE_HEADER_LEN, priv->upld_len); 
    655606 
    656607        kfree_skb(skb); 
     
    660611        lbs_deb_usbd(&cardp->udev->dev, 
    661612                    "Wake up main thread to handle cmd response\n"); 
    662  
    663         return; 
    664613} 
    665614 
     
    673622static void if_usb_receive(struct urb *urb) 
    674623{ 
    675         struct read_cb_info *rinfo = (struct read_cb_info *)urb->context; 
    676         struct sk_buff *skb = rinfo->skb; 
    677         struct usb_card_rec *cardp = (struct usb_card_rec *) rinfo->cardp; 
     624        struct if_usb_card *cardp = urb->context; 
     625        struct sk_buff *skb = cardp->rx_skb; 
    678626        struct lbs_private *priv = cardp->priv; 
    679  
    680627        int recvlength = urb->actual_length; 
    681         u8 *recvbuff = NULL; 
    682         u32 recvtype = 0; 
     628        uint8_t *recvbuff = NULL; 
     629        uint32_t recvtype = 0; 
     630        __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET); 
    683631 
    684632        lbs_deb_enter(LBS_DEB_USB); 
    685633 
    686634        if (recvlength) { 
    687                 __le32 tmp; 
    688  
    689635                if (urb->status) { 
    690                         lbs_deb_usbd(&cardp->udev->dev, 
    691                                     "URB status is failed\n"); 
     636                        lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n", 
     637                                     urb->status); 
    692638                        kfree_skb(skb); 
    693639                        goto setup_for_next; 
     
    695641 
    696642                recvbuff = skb->data + IPFIELD_ALIGN_OFFSET; 
    697                 memcpy(&tmp, recvbuff, sizeof(u32)); 
    698                 recvtype = le32_to_cpu(tmp); 
     643                recvtype = le32_to_cpu(pkt[0]); 
    699644                lbs_deb_usbd(&cardp->udev->dev, 
    700645                            "Recv length = 0x%x, Recv type = 0x%X\n", 
     
    717662                /* Event cause handling */ 
    718663                spin_lock(&priv->driver_lock); 
    719                 cardp->usb_event_cause = le32_to_cpu(*(__le32 *) (recvbuff + MESSAGE_HEADER_LEN)); 
     664 
     665                cardp->usb_event_cause = le32_to_cpu(pkt[1]); 
     666 
    720667                lbs_deb_usbd(&cardp->udev->dev,"**EVENT** 0x%X\n", 
    721                             cardp->usb_event_cause); 
     668                             cardp->usb_event_cause); 
     669 
     670                /* Icky undocumented magic special case */ 
    722671                if (cardp->usb_event_cause & 0xffff0000) { 
    723672                        lbs_send_tx_feedback(priv); 
     
    733682        default: 
    734683                lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n", 
    735                              recvtype); 
     684                             recvtype); 
    736685                kfree_skb(skb); 
    737686                break; 
     
    752701 *  @return             0 or -1 
    753702 */ 
    754 static int if_usb_host_to_card(struct lbs_private *priv, 
    755         u8 type, 
    756         u8 *payload, 
    757         u16 nb) 
    758 { 
    759         struct usb_card_rec *cardp = (struct usb_card_rec *)priv->card; 
     703static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type, 
     704                               uint8_t *payload, uint16_t nb) 
     705{ 
     706        struct if_usb_card *cardp = priv->card; 
    760707 
    761708        lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type); 
     
    763710 
    764711        if (type == MVMS_CMD) { 
    765                 __le32 tmp = cpu_to_le32(CMD_TYPE_REQUEST); 
     712                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 
    766713                priv->dnld_sent = DNLD_CMD_SENT; 
    767                 memcpy(cardp->bulk_out_buffer, (u8 *) & tmp, 
    768                        MESSAGE_HEADER_LEN); 
    769  
    770714        } else { 
    771                 __le32 tmp = cpu_to_le32(CMD_TYPE_DATA); 
     715                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA); 
    772716                priv->dnld_sent = DNLD_DATA_SENT; 
    773                 memcpy(cardp->bulk_out_buffer, (u8 *) & tmp, 
    774                        MESSAGE_HEADER_LEN); 
    775         } 
    776  
    777         memcpy((cardp->bulk_out_buffer + MESSAGE_HEADER_LEN), payload, nb); 
    778  
    779         return usb_tx_block(cardp, cardp->bulk_out_buffer, 
    780                             nb + MESSAGE_HEADER_LEN); 
     717        } 
     718 
     719        memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb); 
     720 
     721        return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN); 
    781722} 
    782723 
    783724/* called with priv->driver_lock held */ 
    784 static int if_usb_get_int_status(struct lbs_private *priv, u8 *ireg) 
    785 { 
    786         struct usb_card_rec *cardp = priv->card; 
     725static int if_usb_get_int_status(struct lbs_private *priv, uint8_t *ireg) 
     726{ 
     727        struct if_usb_card *cardp = priv->card; 
    787728 
    788729        *ireg = cardp->usb_int_cause; 
    789730        cardp->usb_int_cause = 0; 
    790731 
    791         lbs_deb_usbd(&cardp->udev->dev,"Int cause is 0x%X\n", *ireg); 
     732        lbs_deb_usbd(&cardp->udev->dev, "Int cause is 0x%X\n", *ireg); 
    792733 
    793734        return 0; 
     
    796737static int if_usb_read_event_cause(struct lbs_private *priv) 
    797738{ 
    798         struct usb_card_rec *cardp = priv->card; 
     739        struct if_usb_card *cardp = priv->card; 
    799740 
    800741        priv->eventcause = cardp->usb_event_cause; 
    801742        /* Re-submit rx urb here to avoid event lost issue */ 
    802743        if_usb_submit_rx_urb(cardp); 
     744 
    803745        return 0; 
    804746} 
     
    810752 *  @return             0 
    811753 */ 
    812 static int if_usb_issue_boot_command(struct usb_card_rec *cardp, int ivalue) 
    813 { 
    814         struct bootcmdstr sbootcmd; 
    815         int i; 
     754static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue) 
     755{ 
     756        struct bootcmd *bootcmd = cardp->ep_out_buf; 
    816757 
    817758        /* Prepare command */ 
    818         sbootcmd.u32magicnumber = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER); 
    819         sbootcmd.u8cmd_tag = ivalue; 
    820         for (i=0; i<11; i++) 
    821                 sbootcmd.au8dumy[i]=0x00; 
    822         memcpy(cardp->bulk_out_buffer, &sbootcmd, sizeof(struct bootcmdstr)); 
     759        bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER); 
     760        bootcmd->cmd = ivalue; 
     761        memset(bootcmd->pad, 0, sizeof(bootcmd->pad)); 
    823762 
    824763        /* Issue command */ 
    825         usb_tx_block(cardp, cardp->bulk_out_buffer, sizeof(struct bootcmdstr)); 
     764        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd)); 
    826765 
    827766        return 0; 
     
    836775 *  @return     0 or -1 
    837776 */ 
    838 static int check_fwfile_format(u8 *data, u32 totlen) 
    839 { 
    840         u32 bincmd, exit; 
    841         u32 blksize, offset, len; 
     777static int check_fwfile_format(uint8_t *data, uint32_t totlen) 
     778{ 
     779        uint32_t bincmd, exit; 
     780        uint32_t blksize, offset, len; 
    842781        int ret; 
    843782 
     
    877816 
    878817 
    879 static int if_usb_prog_firmware(struct usb_card_rec *cardp) 
     818static int if_usb_prog_firmware(struct if_usb_card *cardp) 
    880819{ 
    881820        int i = 0; 
     
    938877        /* ... and wait for the process to complete */ 
    939878        wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover); 
    940          
     879 
    941880        del_timer_sync(&cardp->fw_timeout); 
    942881        usb_kill_urb(cardp->rx_urb); 
     
    954893        } 
    955894 
    956 release_fw: 
     895 release_fw: 
    957896        release_firmware(cardp->fw); 
    958897        cardp->fw = NULL; 
    959898 
    960 done: 
     899 done: 
    961900        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret); 
    962901        return ret; 
     
    967906static int if_usb_suspend(struct usb_interface *intf, pm_message_t message) 
    968907{ 
    969         struct usb_card_rec *cardp = usb_get_intfdata(intf); 
     908        struct if_usb_card *cardp = usb_get_intfdata(intf); 
    970909        struct lbs_private *priv = cardp->priv; 
     910        int ret; 
    971911 
    972912        lbs_deb_enter(LBS_DEB_USB); 
     
    975915                return -1; 
    976916 
    977         netif_device_detach(priv->dev); 
    978         netif_device_detach(priv->mesh_dev); 
     917        ret = lbs_suspend(priv); 
     918        if (ret) 
     919                goto out; 
    979920 
    980921        /* Unlink tx & rx urb */ 
     
    982923        usb_kill_urb(cardp->rx_urb); 
    983924 
     925 out: 
    984926        lbs_deb_leave(LBS_DEB_USB); 
    985         return 0; 
     927        return ret; 
    986928} 
    987929 
    988930static int if_usb_resume(struct usb_interface *intf) 
    989931{ 
    990         struct usb_card_rec *cardp = usb_get_intfdata(intf); 
     932        struct if_usb_card *cardp = usb_get_intfdata(intf); 
    991933        struct lbs_private *priv = cardp->priv; 
    992934 
     
    995937        if_usb_submit_rx_urb(cardp); 
    996938 
    997         netif_device_attach(priv->dev); 
    998         netif_device_attach(priv->mesh_dev); 
     939        lbs_resume(priv); 
    999940 
    1000941        lbs_deb_leave(LBS_DEB_USB); 
     
    1040981 
    1041982MODULE_DESCRIPTION("8388 USB WLAN Driver"); 
    1042 MODULE_AUTHOR("Marvell International Ltd."); 
     983MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc."); 
    1043984MODULE_LICENSE("GPL"); 
  • trunk/package/libertas/src/if_usb.h

    r9768 r10235  
    1010  * This file contains definition for USB interface. 
    1111  */ 
    12 #define CMD_TYPE_REQUEST                0xF00DFACE 
    13 #define CMD_TYPE_DATA                   0xBEADC0DE 
    14 #define CMD_TYPE_INDICATION             0xBEEFFACE 
     12#define CMD_TYPE_REQUEST                0xF00DFACE 
     13#define CMD_TYPE_DATA                   0xBEADC0DE 
     14#define CMD_TYPE_INDICATION             0xBEEFFACE 
    1515 
    16 #define IPFIELD_ALIGN_OFFSET    2 
     16#define IPFIELD_ALIGN_OFFSET            2 
    1717 
    18 #define BOOT_CMD_FW_BY_USB     0x01 
    19 #define BOOT_CMD_FW_IN_EEPROM  0x02 
    20 #define BOOT_CMD_UPDATE_BOOT2  0x03 
    21 #define BOOT_CMD_UPDATE_FW     0x04 
    22 #define BOOT_CMD_MAGIC_NUMBER  0x4C56524D   /* M=>0x4D,R=>0x52,V=>0x56,L=>0x4C */ 
     18#define BOOT_CMD_FW_BY_USB              0x01 
     19#define BOOT_CMD_FW_IN_EEPROM           0x02 
     20#define BOOT_CMD_UPDATE_BOOT2           0x03 
     21#define BOOT_CMD_UPDATE_FW              0x04 
     22#define BOOT_CMD_MAGIC_NUMBER           0x4C56524D   /* LVRM */ 
    2323 
    24 struct bootcmdstr 
     24struct bootcmd 
    2525{ 
    26         __le32 u32magicnumber; 
    27         u8  u8cmd_tag; 
    28         u8  au8dumy[11]; 
     26        __le32  magic; 
     27        uint8_t cmd; 
     28        uint8_t pad[11]; 
    2929}; 
    3030 
    31 #define BOOT_CMD_RESP_OK     0x0001 
    32 #define BOOT_CMD_RESP_FAIL   0x0000 
     31#define BOOT_CMD_RESP_OK                0x0001 
     32#define BOOT_CMD_RESP_FAIL              0x0000 
    3333 
    34 struct bootcmdrespStr 
     34struct bootcmdresp 
    3535{ 
    36         __le32 u32magicnumber; 
    37         u8  u8cmd_tag; 
    38         u8  u8result; 
    39         u8  au8dumy[2]; 
    40 }; 
    41  
    42 /* read callback private data */ 
    43 struct read_cb_info { 
    44         struct usb_card_rec *cardp; 
    45         struct sk_buff *skb; 
     36        __le32  magic; 
     37        uint8_t cmd; 
     38        uint8_t result; 
     39        uint8_t pad[2]; 
    4640}; 
    4741 
    4842/** USB card description structure*/ 
    49 struct usb_card_rec { 
     43struct if_usb_card { 
    5044        struct usb_device *udev; 
    5145        struct urb *rx_urb, *tx_urb; 
    5246        struct lbs_private *priv; 
    53         struct read_cb_info rinfo; 
    5447 
    55         int bulk_in_size; 
    56         u8 bulk_in_endpointAddr; 
     48        struct sk_buff *rx_skb; 
     49        uint32_t usb_event_cause; 
     50        uint8_t usb_int_cause; 
    5751 
    58         u8 *bulk_out_buffer; 
    59         int bulk_out_size; 
    60         u8 bulk_out_endpointAddr; 
     52        uint8_t ep_in; 
     53        uint8_t ep_out; 
     54 
     55        int8_t bootcmdresp; 
     56 
     57        int ep_in_size; 
     58 
     59        void *ep_out_buf; 
     60        int ep_out_size; 
    6161 
    6262        const struct firmware *fw; 
    6363        struct timer_list fw_timeout; 
    6464        wait_queue_head_t fw_wq; 
    65         u8 CRC_OK; 
    66         u32 fwseqnum; 
    67         u32 lastseqnum; 
    68         u32 totalbytes; 
    69         u32 fwlastblksent; 
    70         u8 fwdnldover; 
    71         u8 fwfinalblk; 
    72         u8 surprise_removed; 
     65        uint32_t fwseqnum; 
     66        uint32_t totalbytes; 
     67        uint32_t fwlastblksent; 
     68        uint8_t CRC_OK; 
     69        uint8_t fwdnldover; 
     70        uint8_t fwfinalblk; 
     71        uint8_t surprise_removed; 
    7372 
    74         u32 usb_event_cause; 
    75         u8 usb_int_cause; 
    76  
    77         s8 bootcmdresp; 
    7873}; 
    7974 
     
    8883#define FW_MAX_DATA_BLK_SIZE    600 
    8984/** FWData */ 
    90 struct FWData { 
    91         struct fwheader fwheader; 
     85struct fwdata { 
     86        struct fwheader hdr; 
    9287        __le32 seqnum; 
    93         u8 data[FW_MAX_DATA_BLK_SIZE]; 
     88        uint8_t data[0]; 
    9489}; 
    9590 
     
    10398#define FW_HAS_LAST_BLOCK               0x00000004 
    10499 
    105 #define FW_DATA_XMIT_SIZE \ 
    106         sizeof(struct fwheader) + le32_to_cpu(fwdata->fwheader.datalength) + sizeof(u32) 
    107100 
    108101#endif 
  • trunk/package/libertas/src/join.c

    r9768 r10235  
    782782 
    783783        netif_carrier_on(priv->dev); 
    784         netif_wake_queue(priv->dev); 
    785  
     784        if (!priv->tx_pending_len) 
     785                netif_wake_queue(priv->dev); 
    786786 
    787787        memcpy(wrqu.ap_addr.sa_data, priv->curbssparams.bssid, ETH_ALEN); 
     
    866866 
    867867        netif_carrier_on(priv->dev); 
    868         netif_wake_queue(priv->dev); 
     868        if (!priv->tx_pending_len) 
     869                netif_wake_queue(priv->dev); 
    869870 
    870871        memset(&wrqu, 0, sizeof(wrqu)); 
  • trunk/package/libertas/src/main.c

    r9768 r10235  
    77#include <linux/moduleparam.h> 
    88#include <linux/delay.h> 
    9 #include <linux/freezer.h> 
    109#include <linux/etherdevice.h> 
    1110#include <linux/netdevice.h> 
     
    257256static int lbs_add_mesh(struct lbs_private *priv); 
    258257static void lbs_remove_mesh(struct lbs_private *priv); 
    259    
     258 
    260259 
    261260/** 
     
    346345                return count; 
    347346 
    348         ret = lbs_mesh_config(priv, enable); 
     347        ret = lbs_mesh_config(priv, enable, priv->curbssparams.channel); 
    349348        if (ret) 
    350349                return ret; 
    351                  
     350 
    352351        if (enable) 
    353352                lbs_add_mesh(priv); 
     
    403402        } else { 
    404403                priv->infra_open = 1; 
    405                  
     404 
    406405                if (priv->connect_status == LBS_CONNECTED) 
    407406                        netif_carrier_on(dev); 
     
    435434        netif_stop_queue(dev); 
    436435        netif_carrier_off(dev); 
    437          
     436 
    438437        spin_unlock_irq(&priv->driver_lock); 
    439438        return 0; 
     
    455454 
    456455        netif_stop_queue(dev); 
    457          
     456 
    458457        spin_unlock_irq(&priv->driver_lock); 
    459458        return 0; 
     
    478477        lbs_host_to_card_done(priv); 
    479478 
     479        /* More often than not, this actually happens because the 
     480           firmware has crapped itself -- rather than just a very 
     481           busy medium. So send a harmless command, and if/when 
     482           _that_ times out, we'll kick it in the head. */ 
     483        lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, 
     484                                     0, 0, NULL); 
     485 
    480486        lbs_deb_leave(LBS_DEB_TX); 
    481487} 
     
    490496 
    491497        /* Wake main thread if commands are pending */ 
    492         if (!priv->cur_cmd) 
     498        if (!priv->cur_cmd || priv->tx_pending_len > 0) 
    493499                wake_up_interruptible(&priv->waitq); 
    494500 
    495         /* Don't wake netif queues if we're in monitor mode and 
    496            a TX packet is already pending, or if there are commands 
    497            queued to be sent. */ 
    498         if (!priv->currenttxskb && list_empty(&priv->cmdpendingq)) { 
    499                 if (priv->dev && priv->connect_status == LBS_CONNECTED) 
    500                         netif_wake_queue(priv->dev); 
    501  
    502                 if (priv->mesh_dev && priv->mesh_connect_status == LBS_CONNECTED) 
    503                         netif_wake_queue(priv->mesh_dev); 
    504         } 
    505501        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    506502} 
     
    664660        init_waitqueue_entry(&wait, current); 
    665661 
    666         set_freezable(); 
    667  
    668662        for (;;) { 
    669663                int shouldsleep; 
     
    676670                spin_lock_irq(&priv->driver_lock); 
    677671 
    678                 if (priv->surpriseremoved) 
     672                if (kthread_should_stop()) 
    679673                        shouldsleep = 0;        /* Bye */ 
     674                else if (priv->surpriseremoved) 
     675                        shouldsleep = 1;        /* We need to wait until we're _told_ to die */ 
    680676                else if (priv->psstate == PS_STATE_SLEEP) 
    681677                        shouldsleep = 1;        /* Sleep mode. Nothing we can do till it wakes */ 
    682678                else if (priv->intcounter) 
    683679                        shouldsleep = 0;        /* Interrupt pending. Deal with it now */ 
     680                else if (priv->cmd_timed_out) 
     681                        shouldsleep = 0;        /* Command timed out. Recover */ 
    684682                else if (!priv->fw_ready) 
    685683                        shouldsleep = 1;        /* Firmware not ready. We're waiting for it */ 
     
    709707                set_current_state(TASK_RUNNING); 
    710708                remove_wait_queue(&priv->waitq, &wait); 
    711                 try_to_freeze(); 
    712709 
    713710                lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p dnld_sent=%d\n", 
    714711                               priv->intcounter, priv->currenttxskb, priv->dnld_sent); 
    715712 
    716                 if (kthread_should_stop() || priv->surpriseremoved) { 
    717                         lbs_deb_thread("main-thread: break from main thread: surpriseremoved=0x%x\n", 
    718                                        priv->surpriseremoved); 
     713                if (kthread_should_stop()) { 
     714                        lbs_deb_thread("main-thread: break from main thread\n"); 
    719715                        break; 
    720716                } 
    721717 
     718                if (priv->surpriseremoved) { 
     719                        lbs_deb_thread("adapter removed; waiting to die...\n"); 
     720                        continue; 
     721                } 
    722722 
    723723                spin_lock_irq(&priv->driver_lock); 
     
    749749                        spin_lock_irq(&priv->driver_lock); 
    750750                } 
     751 
     752                if (priv->cmd_timed_out && priv->cur_cmd) { 
     753                        struct cmd_ctrl_node *cmdnode = priv->cur_cmd; 
     754 
     755                        if (++priv->nr_retries > 10) { 
     756                                lbs_pr_info("Excessive timeouts submitting command %x\n", 
     757                                            le16_to_cpu(cmdnode->cmdbuf->command)); 
     758                                lbs_complete_command(priv, cmdnode, -ETIMEDOUT); 
     759                                priv->nr_retries = 0; 
     760                        } else { 
     761                                priv->cur_cmd = NULL; 
     762                                lbs_pr_info("requeueing command %x due to timeout (#%d)\n", 
     763                                            le16_to_cpu(cmdnode->cmdbuf->command), priv->nr_retries); 
     764 
     765                                /* Stick it back at the _top_ of the pending queue 
     766                                   for immediate resubmission */ 
     767                                list_add(&cmdnode->list, &priv->cmdpendingq); 
     768                        } 
     769                } 
     770                priv->cmd_timed_out = 0; 
    751771 
    752772                /* Any Card Event */ 
     
    835855} 
    836856 
     857static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy, 
     858                                struct cmd_header *cmd) 
     859{ 
     860        lbs_deb_fw("HOST_SLEEP_ACTIVATE succeeded\n"); 
     861 
     862        netif_device_detach(priv->dev); 
     863        if (priv->mesh_dev) 
     864                netif_device_detach(priv->mesh_dev); 
     865 
     866        priv->fw_ready = 0; 
     867        return 0; 
     868} 
     869 
     870 
     871int lbs_suspend(struct lbs_private *priv) 
     872{ 
     873        struct cmd_header cmd; 
     874        int ret; 
     875 
     876        if (priv->wol_criteria == 0xffffffff) { 
     877                lbs_pr_info("Suspend attempt without configuring wake params!\n"); 
     878                return -EINVAL; 
     879        } 
     880 
     881        memset(&cmd, 0, sizeof(cmd)); 
     882 
     883        ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd, 
     884                        sizeof(cmd), lbs_suspend_callback, 0); 
     885        if (ret) 
     886                lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret); 
     887 
     888        return ret; 
     889} 
     890EXPORT_SYMBOL_GPL(lbs_suspend); 
     891 
     892int lbs_resume(struct lbs_private *priv) 
     893{ 
     894        priv->fw_ready = 1; 
     895 
     896        /* Firmware doesn't seem to give us RX packets any more 
     897           until we send it some command. Might as well update */ 
     898        lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, 
     899                                     0, 0, NULL); 
     900 
     901        netif_device_attach(priv->dev); 
     902        if (priv->mesh_dev) 
     903                netif_device_attach(priv->mesh_dev); 
     904 
     905        return 0; 
     906} 
     907EXPORT_SYMBOL_GPL(lbs_resume); 
     908 
    837909/** 
    838910 *  @brief This function downloads firmware image, gets 
     
    880952{ 
    881953        struct lbs_private *priv = (struct lbs_private *)data; 
    882         struct cmd_ctrl_node *node; 
    883954        unsigned long flags; 
    884955 
    885         node = priv->cur_cmd; 
    886         if (node == NULL) { 
    887                 lbs_deb_fw("ptempnode empty\n"); 
    888                 return; 
    889         } 
    890  
    891         if (!node->cmdbuf) { 
    892                 lbs_deb_fw("cmd is NULL\n"); 
    893                 return; 
    894         } 
    895  
    896         lbs_deb_fw("command_timer_fn fired, cmd %x\n", node->cmdbuf->command); 
    897  
    898         if (!priv->fw_ready) 
    899                 return; 
    900  
    901956        spin_lock_irqsave(&priv->driver_lock, flags); 
    902         priv->cur_cmd = NULL; 
     957 
     958        if (!priv->cur_cmd) { 
     959                lbs_pr_info("Command timer expired; no pending command\n"); 
     960                goto out; 
     961        } 
     962 
     963        lbs_pr_info("Command %x timed out\n", le16_to_cpu(priv->cur_cmd->cmdbuf->command)); 
     964 
     965        priv->cmd_timed_out = 1; 
     966        wake_up_interruptible(&priv->waitq); 
     967 out: 
    903968        spin_unlock_irqrestore(&priv->driver_lock, flags); 
    904  
    905         lbs_deb_fw("re-sending same command because of timeout\n"); 
    906         lbs_queue_cmd(priv, node, 0); 
    907  
    908         wake_up_interruptible(&priv->waitq); 
    909  
    910         return; 
    911969} 
    912970 
     
    10561114        priv->mesh_ssid_len = 4; 
    10571115 
     1116        priv->wol_criteria = 0xffffffff; 
     1117        priv->wol_gpio = 0xff; 
     1118 
    10581119        goto done; 
    10591120 
     
    11311192        if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) 
    11321193                lbs_pr_err("cannot register lbs_rtap attribute\n"); 
    1133         if (device_create_file(&dev->dev, &dev_attr_lbs_mesh)) 
    1134                 lbs_pr_err("cannot register lbs_mesh attribute\n"); 
     1194 
     1195        /* Enable mesh, if supported, and work out which TLV it uses. 
     1196           0x100 + 291 is an unofficial value used in 5.110.20.pXX 
     1197           0x100 + 37 is the official value used in 5.110.21.pXX 
     1198           but we check them in that order because 20.pXX doesn't 
     1199           give an error -- it just silently fails. */ 
     1200 
     1201        /* 5.110.20.pXX firmware will fail the command if the channel 
     1202           doesn't match the existing channel. But only if the TLV 
     1203           is correct. If the channel is wrong, _BOTH_ versions will 
     1204           give an error to 0x100+291, and allow 0x100+37 to succeed. 
     1205           It's just that 5.110.20.pXX will not have done anything 
     1206           useful */ 
     1207 
     1208        lbs_update_channel(priv); 
     1209        priv->mesh_tlv = 0x100 + 291; 
     1210        if (lbs_mesh_config(priv, 1, priv->curbssparams.channel)) { 
     1211                priv->mesh_tlv = 0x100 + 37; 
     1212                if (lbs_mesh_config(priv, 1, priv->curbssparams.channel)) 
     1213                        priv->mesh_tlv = 0; 
     1214        } 
     1215        if (priv->mesh_tlv) { 
     1216                lbs_add_mesh(priv); 
     1217 
     1218                if (device_create_file(&dev->dev, &dev_attr_lbs_mesh)) 
     1219                        lbs_pr_err("cannot register lbs_mesh attribute\n"); 
     1220        } 
    11351221 
    11361222        lbs_debugfs_init_one(priv, dev); 
     
    11611247        lbs_debugfs_remove_one(priv); 
    11621248        device_remove_file(&dev->dev, &dev_attr_lbs_rtap); 
    1163         device_remove_file(&dev->dev, &dev_attr_lbs_mesh); 
     1249        if (priv->mesh_tlv) 
     1250                device_remove_file(&dev->dev, &dev_attr_lbs_mesh); 
    11641251 
    11651252        /* Flush pending command nodes */ 
    11661253        spin_lock_irqsave(&priv->driver_lock, flags); 
    11671254        list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { 
     1255                cmdnode->result = -ENOENT; 
    11681256                cmdnode->cmdwaitqwoken = 1; 
    11691257                wake_up_interruptible(&cmdnode->cmdwait_q); 
     
    13481436        lbs_deb_thread("lbs_interrupt: intcounter=%d\n", priv->intcounter); 
    13491437 
    1350         if (!spin_trylock(&priv->driver_lock)) { 
    1351                 spin_unlock(&priv->driver_lock); 
    1352                 printk(KERN_CRIT "%s called without driver_lock held\n", __func__); 
    1353                 WARN_ON(1); 
    1354         } 
    1355  
    13561438        priv->intcounter++; 
    13571439 
  • trunk/package/libertas/src/scan.c

    r9768 r10235  
    591591        netif_carrier_off(priv->dev); 
    592592        if (priv->mesh_dev) { 
    593                         netif_stop_queue(priv->mesh_dev); 
    594                         netif_carrier_off(priv->mesh_dev); 
     593                netif_stop_queue(priv->mesh_dev); 
     594                netif_carrier_off(priv->mesh_dev); 
    595595        } 
    596596 
    597597        /* Prepare to continue an interrupted scan */ 
    598598        lbs_deb_scan("chan_count %d, last_scanned_channel %d\n", 
    599                 chan_count, priv->last_scanned_channel); 
     599                     chan_count, priv->last_scanned_channel); 
    600600        curr_chans = chan_list; 
    601601        /* advance channel list by already-scanned-channels */ 
     
    660660        if (priv->connect_status == LBS_CONNECTED) { 
    661661                netif_carrier_on(priv->dev); 
    662                 netif_wake_queue(priv->dev); 
     662                if (!priv->tx_pending_len) 
     663                        netif_wake_queue(priv->dev); 
    663664        } 
    664665        if (priv->mesh_dev && (priv->mesh_connect_status == LBS_CONNECTED)) { 
    665666                netif_carrier_on(priv->mesh_dev); 
    666                 netif_wake_queue(priv->mesh_dev); 
     667                if (!priv->tx_pending_len) 
     668                        netif_wake_queue(priv->mesh_dev); 
    667669        } 
    668670        kfree(chan_list); 
  • trunk/package/libertas/src/tx.c

    r9768 r10235  
    9494 
    9595        if (priv->tx_pending_len) { 
    96                 /* This can happen if packets come in on the mesh and eth  
    97                    device simultaneously -- there's no mutual exclusion on  
     96                /* This can happen if packets come in on the mesh and eth 
     97                   device simultaneously -- there's no mutual exclusion on 
    9898                   hard_start_xmit() calls between devices. */ 
    9999                lbs_deb_tx("Packet on %s while busy\n", dev->name); 
  • trunk/package/libertas/src/wext.c

    r9768 r10235  
    735735        lbs_deb_enter(LBS_DEB_WEXT); 
    736736 
     737        if (!priv->ps_supported) { 
     738                if (vwrq->disabled) 
     739                        return 0; 
     740                else 
     741                        return -EINVAL; 
     742        } 
     743 
    737744        /* PS is currently supported only in Infrastructure mode 
    738745         * Remove this check if it is to be supported in IBSS mode also 
     
    10011008                        lbs_stop_adhoc_network(priv); 
    10021009        } 
    1003         priv->curbssparams.channel = fwrq->m; 
    1004         lbs_mesh_config(priv, 0); 
    1005         lbs_mesh_config(priv, 1); 
     1010        lbs_mesh_config(priv, 1, fwrq->m); 
     1011        lbs_update_channel(priv); 
    10061012        ret = 0; 
    10071013 
     
    20112017        } 
    20122018 
    2013         lbs_mesh_config(priv, 1); 
     2019        lbs_mesh_config(priv, 1, priv->curbssparams.channel); 
    20142020 out: 
    20152021        lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret); 
Note: See TracChangeset for help on using the changeset viewer.