Lines Matching defs:cmd
447 static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
449 u16 command = le16_to_cpu(cmd);
488 snprintf(buf, bufsize, "0x%x", cmd);
646 struct mwl8k_cmd_pkt *cmd;
650 cmd = kmalloc(sizeof(*cmd) + 256, GFP_KERNEL);
651 if (cmd == NULL)
654 cmd->code = cpu_to_le16(MWL8K_CMD_CODE_DNLD);
655 cmd->seq_num = 0;
656 cmd->macid = 0;
657 cmd->result = 0;
663 memcpy(cmd->payload, data + done, block_size);
664 cmd->length = cpu_to_le16(block_size);
666 rc = mwl8k_send_fw_load_cmd(priv, cmd,
667 sizeof(*cmd) + block_size);
676 cmd->length = 0;
677 rc = mwl8k_send_fw_load_cmd(priv, cmd, sizeof(*cmd));
680 kfree(cmd);
2200 static int mwl8k_post_cmd(struct ieee80211_hw *hw, struct mwl8k_cmd_pkt *cmd)
2213 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)), cmd->macid);
2225 switch (le16_to_cpu(cmd->code)) {
2239 cmd->result = (__force __le16) 0xffff;
2240 dma_size = le16_to_cpu(cmd->length);
2241 dma_addr = pci_map_single(priv->pdev, cmd, dma_size,
2266 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
2274 rc = cmd->result ? -EINVAL : 0;
2277 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
2278 le16_to_cpu(cmd->result));
2281 mwl8k_cmd_name(cmd->code,
2297 struct mwl8k_cmd_pkt *cmd)
2300 cmd->macid = MWL8K_VIF(vif)->macid;
2301 return mwl8k_post_cmd(hw, cmd);
2458 struct mwl8k_cmd_get_hw_spec_sta *cmd;
2462 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2463 if (cmd == NULL)
2466 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC);
2467 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2469 memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr));
2470 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
2471 cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
2472 cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
2474 cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
2475 cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
2476 cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
2478 rc = mwl8k_post_cmd(hw, &cmd->header);
2481 SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr);
2482 priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
2483 priv->fw_rev = le32_to_cpu(cmd->fw_rev);
2484 priv->hw_rev = cmd->hw_rev;
2485 mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2490 kfree(cmd);
2523 struct mwl8k_cmd_get_hw_spec_ap *cmd;
2527 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2528 if (cmd == NULL)
2531 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC);
2532 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2534 memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr));
2535 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
2537 rc = mwl8k_post_cmd(hw, &cmd->header);
2542 api_version = le32_to_cpu(cmd->fw_api_version);
2552 SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr);
2553 priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
2554 priv->fw_rev = le32_to_cpu(cmd->fw_rev);
2555 priv->hw_rev = cmd->hw_rev;
2556 mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2559 priv->num_ampdu_queues = le32_to_cpu(cmd->num_of_ampdu_queues);
2567 off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
2570 off = le32_to_cpu(cmd->rxrdptr) & 0xffff;
2573 priv->txq_offset[0] = le32_to_cpu(cmd->wcbbase0) & 0xffff;
2574 priv->txq_offset[1] = le32_to_cpu(cmd->wcbbase1) & 0xffff;
2575 priv->txq_offset[2] = le32_to_cpu(cmd->wcbbase2) & 0xffff;
2576 priv->txq_offset[3] = le32_to_cpu(cmd->wcbbase3) & 0xffff;
2580 le32_to_cpu(cmd->wcbbase_ampdu[i]) & 0xffff;
2584 kfree(cmd);
2625 struct mwl8k_cmd_set_hw_spec *cmd;
2629 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2630 if (cmd == NULL)
2633 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_HW_SPEC);
2634 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2636 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
2637 cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
2638 cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
2648 cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[j].txd_dma);
2651 cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT |
2656 cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
2657 cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
2659 rc = mwl8k_post_cmd(hw, &cmd->header);
2660 kfree(cmd);
2685 struct mwl8k_cmd_mac_multicast_adr *cmd;
2697 size = sizeof(*cmd) + mc_count * ETH_ALEN;
2699 cmd = kzalloc(size, GFP_ATOMIC);
2700 if (cmd == NULL)
2703 cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
2704 cmd->header.length = cpu_to_le16(size);
2705 cmd->action = cpu_to_le16(MWL8K_ENABLE_RX_DIRECTED |
2709 cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_ALL_MULTICAST);
2714 cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
2715 cmd->numaddr = cpu_to_le16(mc_count);
2717 memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2721 return &cmd->header;
2740 struct mwl8k_cmd_get_stat *cmd;
2743 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2744 if (cmd == NULL)
2747 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_STAT);
2748 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2750 rc = mwl8k_post_cmd(hw, &cmd->header);
2753 le32_to_cpu(cmd->stats[MWL8K_STAT_ACK_FAILURE]);
2755 le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_FAILURE]);
2757 le32_to_cpu(cmd->stats[MWL8K_STAT_FCS_ERROR]);
2759 le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_SUCCESS]);
2761 kfree(cmd);
2780 struct mwl8k_cmd_radio_control *cmd;
2786 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2787 if (cmd == NULL)
2790 cmd->header.code = cpu_to_le16(MWL8K_CMD_RADIO_CONTROL);
2791 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2792 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
2793 cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2794 cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);
2796 rc = mwl8k_post_cmd(hw, &cmd->header);
2797 kfree(cmd);
2841 struct mwl8k_cmd_rf_tx_power *cmd;
2844 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2845 if (cmd == NULL)
2848 cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_TX_POWER);
2849 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2850 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
2851 cmd->support_level = cpu_to_le16(dBm);
2853 rc = mwl8k_post_cmd(hw, &cmd->header);
2854 kfree(cmd);
2881 struct mwl8k_cmd_tx_power *cmd;
2885 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2886 if (cmd == NULL)
2889 cmd->header.code = cpu_to_le16(MWL8K_CMD_TX_POWER);
2890 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2891 cmd->action = cpu_to_le16(MWL8K_CMD_SET_LIST);
2894 cmd->band = cpu_to_le16(0x1);
2896 cmd->band = cpu_to_le16(0x4);
2898 cmd->channel = cpu_to_le16(channel->hw_value);
2902 cmd->bw = cpu_to_le16(0x2);
2904 cmd->bw = cpu_to_le16(0x4);
2906 cmd->sub_ch = cpu_to_le16(0x3);
2908 cmd->sub_ch = cpu_to_le16(0x1);
2912 cmd->power_level_list[i] = cpu_to_le16(pwr);
2914 rc = mwl8k_post_cmd(hw, &cmd->header);
2915 kfree(cmd);
2935 struct mwl8k_cmd_rf_antenna *cmd;
2938 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2939 if (cmd == NULL)
2942 cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_ANTENNA);
2943 cmd->header.length = cpu_to_le16(sizeof(*cmd));
2944 cmd->antenna = cpu_to_le16(antenna);
2945 cmd->mode = cpu_to_le16(mask);
2947 rc = mwl8k_post_cmd(hw, &cmd->header);
2948 kfree(cmd);
2965 struct mwl8k_cmd_set_beacon *cmd;
2968 cmd = kzalloc(sizeof(*cmd) + len, GFP_KERNEL);
2969 if (cmd == NULL)
2972 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_BEACON);
2973 cmd->header.length = cpu_to_le16(sizeof(*cmd) + len);
2974 cmd->beacon_len = cpu_to_le16(len);
2975 memcpy(cmd->beacon, beacon, len);
2977 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2978 kfree(cmd);
2992 struct mwl8k_cmd_set_pre_scan *cmd;
2995 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
2996 if (cmd == NULL)
2999 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_PRE_SCAN);
3000 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3002 rc = mwl8k_post_cmd(hw, &cmd->header);
3003 kfree(cmd);
3025 struct mwl8k_cmd_bbp_reg_access *cmd;
3028 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3029 if (cmd == NULL)
3032 cmd->header.code = cpu_to_le16(MWL8K_CMD_BBP_REG_ACCESS);
3033 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3034 cmd->action = cpu_to_le16(action);
3035 cmd->offset = cpu_to_le16(offset);
3037 rc = mwl8k_post_cmd(hw, &cmd->header);
3040 *value = cmd->value;
3044 kfree(cmd);
3061 struct mwl8k_cmd_set_post_scan *cmd;
3064 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3065 if (cmd == NULL)
3068 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_POST_SCAN);
3069 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3070 cmd->isibss = 0;
3071 memcpy(cmd->bssid, mac, ETH_ALEN);
3073 rc = mwl8k_post_cmd(hw, &cmd->header);
3074 kfree(cmd);
3153 struct mwl8k_cmd_set_rf_channel *cmd;
3157 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3158 if (cmd == NULL)
3161 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RF_CHANNEL);
3162 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3163 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
3164 cmd->current_channel = channel->hw_value;
3167 cmd->channel_flags |= cpu_to_le32(0x00000001);
3169 cmd->channel_flags |= cpu_to_le32(0x00000004);
3174 cmd->channel_flags |= cpu_to_le32(0x00000080);
3176 cmd->channel_flags |= cpu_to_le32(0x000001900);
3178 cmd->channel_flags |= cpu_to_le32(0x000000900);
3180 cmd->channel_flags |= cpu_to_le32(0x00000080);
3195 rc = mwl8k_post_cmd(hw, &cmd->header);
3196 kfree(cmd);
3239 struct mwl8k_cmd_update_set_aid *cmd;
3243 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3244 if (cmd == NULL)
3247 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
3248 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3249 cmd->aid = cpu_to_le16(vif->bss_conf.aid);
3250 memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
3268 cmd->protection_mode = cpu_to_le16(prot_mode);
3270 legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
3272 rc = mwl8k_post_cmd(hw, &cmd->header);
3273 kfree(cmd);
3294 struct mwl8k_cmd_set_rate *cmd;
3297 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3298 if (cmd == NULL)
3301 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
3302 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3303 legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
3304 memcpy(cmd->mcs_set, mcs_rates, 16);
3306 rc = mwl8k_post_cmd(hw, &cmd->header);
3307 kfree(cmd);
3326 struct mwl8k_cmd_finalize_join *cmd;
3331 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3332 if (cmd == NULL)
3335 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
3336 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3337 cmd->sleep_interval = cpu_to_le32(dtim ? dtim : 1);
3345 memcpy(cmd->beacon_data, &payload->u.beacon, payload_len);
3347 rc = mwl8k_post_cmd(hw, &cmd->header);
3348 kfree(cmd);
3365 struct mwl8k_cmd_set_rts_threshold *cmd;
3368 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3369 if (cmd == NULL)
3372 cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
3373 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3374 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
3375 cmd->threshold = cpu_to_le16(rts_thresh);
3377 rc = mwl8k_post_cmd(hw, &cmd->header);
3378 kfree(cmd);
3394 struct mwl8k_cmd_set_slot *cmd;
3397 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3398 if (cmd == NULL)
3401 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
3402 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3403 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
3404 cmd->short_slot = short_slot_time;
3406 rc = mwl8k_post_cmd(hw, &cmd->header);
3407 kfree(cmd);
3468 struct mwl8k_cmd_set_edca_params *cmd;
3471 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3472 if (cmd == NULL)
3475 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_EDCA_PARAMS);
3476 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3477 cmd->action = cpu_to_le16(MWL8K_SET_EDCA_ALL);
3478 cmd->txop = cpu_to_le16(txop);
3480 cmd->ap.log_cw_max = cpu_to_le32(ilog2(cw_max + 1));
3481 cmd->ap.log_cw_min = cpu_to_le32(ilog2(cw_min + 1));
3482 cmd->ap.aifs = aifs;
3483 cmd->ap.txq = qnum;
3485 cmd->sta.log_cw_max = (u8)ilog2(cw_max + 1);
3486 cmd->sta.log_cw_min = (u8)ilog2(cw_min + 1);
3487 cmd->sta.aifs = aifs;
3488 cmd->sta.txq = qnum;
3491 rc = mwl8k_post_cmd(hw, &cmd->header);
3492 kfree(cmd);
3508 struct mwl8k_cmd_set_wmm_mode *cmd;
3511 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3512 if (cmd == NULL)
3515 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
3516 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3517 cmd->action = cpu_to_le16(!!enable);
3519 rc = mwl8k_post_cmd(hw, &cmd->header);
3520 kfree(cmd);
3540 struct mwl8k_cmd_mimo_config *cmd;
3543 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3544 if (cmd == NULL)
3547 cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
3548 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3549 cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
3550 cmd->rx_antenna_map = rx;
3551 cmd->tx_antenna_map = tx;
3553 rc = mwl8k_post_cmd(hw, &cmd->header);
3554 kfree(cmd);
3583 struct mwl8k_cmd_use_fixed_rate_sta *cmd;
3586 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3587 if (cmd == NULL)
3590 cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
3591 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3592 cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
3593 cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
3595 rc = mwl8k_post_cmd(hw, &cmd->header);
3596 kfree(cmd);
3623 struct mwl8k_cmd_use_fixed_rate_ap *cmd;
3626 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3627 if (cmd == NULL)
3630 cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
3631 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3632 cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
3633 cmd->multicast_rate = mcast;
3634 cmd->management_rate = mgmt;
3636 rc = mwl8k_post_cmd(hw, &cmd->header);
3637 kfree(cmd);
3652 struct mwl8k_cmd_enable_sniffer *cmd;
3655 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3656 if (cmd == NULL)
3659 cmd->header.code = cpu_to_le16(MWL8K_CMD_ENABLE_SNIFFER);
3660 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3661 cmd->action = cpu_to_le32(!!enable);
3663 rc = mwl8k_post_cmd(hw, &cmd->header);
3664 kfree(cmd);
3690 struct mwl8k_cmd_update_mac_addr *cmd;
3710 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3711 if (cmd == NULL)
3715 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_MAC_ADDR);
3717 cmd->header.code = cpu_to_le16(MWL8K_CMD_DEL_MAC_ADDR);
3719 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3721 cmd->mbss.mac_type = cpu_to_le16(mac_type);
3722 memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
3724 memcpy(cmd->mac_addr, mac, ETH_ALEN);
3727 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3728 kfree(cmd);
3762 struct mwl8k_cmd_set_rate_adapt_mode *cmd;
3765 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3766 if (cmd == NULL)
3769 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATEADAPT_MODE);
3770 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3771 cmd->action = cpu_to_le16(MWL8K_CMD_SET);
3772 cmd->mode = cpu_to_le16(mode);
3774 rc = mwl8k_post_cmd(hw, &cmd->header);
3775 kfree(cmd);
3790 struct mwl8k_cmd_get_watchdog_bitmap *cmd;
3793 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3794 if (cmd == NULL)
3797 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_WATCHDOG_BITMAP);
3798 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3800 rc = mwl8k_post_cmd(hw, &cmd->header);
3802 *bitmap = cmd->bitmap;
3804 kfree(cmd);
3871 struct mwl8k_cmd_bss_start *cmd;
3882 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3883 if (cmd == NULL)
3886 cmd->header.code = cpu_to_le16(MWL8K_CMD_BSS_START);
3887 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3888 cmd->enable = cpu_to_le32(enable);
3890 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3891 kfree(cmd);
3971 struct mwl8k_cmd_bastream *cmd;
3974 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
3975 if (cmd == NULL)
3978 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM);
3979 cmd->header.length = cpu_to_le16(sizeof(*cmd));
3981 cmd->action = cpu_to_le32(MWL8K_BA_CHECK);
3983 cmd->create_params.queue_id = stream->idx;
3984 memcpy(&cmd->create_params.peer_mac_addr[0], stream->sta->addr,
3986 cmd->create_params.tid = stream->tid;
3988 cmd->create_params.flags =
3992 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3994 kfree(cmd);
4003 struct mwl8k_cmd_bastream *cmd;
4006 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4007 if (cmd == NULL)
4011 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM);
4012 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4014 cmd->action = cpu_to_le32(MWL8K_BA_CREATE);
4016 cmd->create_params.bar_thrs = cpu_to_le32((u32)buf_size);
4017 cmd->create_params.window_size = cpu_to_le32((u32)buf_size);
4018 cmd->create_params.queue_id = stream->idx;
4020 memcpy(cmd->create_params.peer_mac_addr, stream->sta->addr, ETH_ALEN);
4021 cmd->create_params.tid = stream->tid;
4022 cmd->create_params.curr_seq_no = cpu_to_le16(0);
4023 cmd->create_params.reset_seq_no_flag = 1;
4025 cmd->create_params.param_info =
4031 cmd->create_params.flags =
4035 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4039 kfree(cmd);
4047 struct mwl8k_cmd_bastream *cmd;
4049 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4050 if (cmd == NULL)
4053 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM);
4054 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4055 cmd->action = cpu_to_le32(MWL8K_BA_DESTROY);
4057 cmd->destroy_params.ba_context = cpu_to_le32(idx);
4058 mwl8k_post_cmd(hw, &cmd->header);
4062 kfree(cmd);
4097 struct mwl8k_cmd_set_new_stn *cmd;
4101 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4102 if (cmd == NULL)
4105 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
4106 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4107 cmd->aid = cpu_to_le16(sta->aid);
4108 memcpy(cmd->mac_addr, sta->addr, ETH_ALEN);
4109 cmd->stn_id = cpu_to_le16(sta->aid);
4110 cmd->action = cpu_to_le16(MWL8K_STA_ACTION_ADD);
4115 cmd->legacy_rates = cpu_to_le32(rates);
4117 cmd->ht_rates[0] = sta->ht_cap.mcs.rx_mask[0];
4118 cmd->ht_rates[1] = sta->ht_cap.mcs.rx_mask[1];
4119 cmd->ht_rates[2] = sta->ht_cap.mcs.rx_mask[2];
4120 cmd->ht_rates[3] = sta->ht_cap.mcs.rx_mask[3];
4121 cmd->ht_capabilities_info = cpu_to_le16(sta->ht_cap.cap);
4122 cmd->mac_ht_param_info = (sta->ht_cap.ampdu_factor & 3) |
4124 cmd->is_qos_sta = 1;
4127 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4128 kfree(cmd);
4136 struct mwl8k_cmd_set_new_stn *cmd;
4139 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4140 if (cmd == NULL)
4143 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
4144 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4145 memcpy(cmd->mac_addr, vif->addr, ETH_ALEN);
4147 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4148 kfree(cmd);
4156 struct mwl8k_cmd_set_new_stn *cmd;
4182 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4183 if (cmd == NULL)
4186 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
4187 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4188 memcpy(cmd->mac_addr, addr, ETH_ALEN);
4189 cmd->action = cpu_to_le16(MWL8K_STA_ACTION_REMOVE);
4191 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4192 kfree(cmd);
4264 struct mwl8k_cmd_update_encryption *cmd;
4267 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4268 if (cmd == NULL)
4271 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION);
4272 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4273 cmd->action = cpu_to_le32(MWL8K_ENCR_ENABLE);
4274 memcpy(cmd->mac_addr, addr, ETH_ALEN);
4275 cmd->encr_type = encr_type;
4277 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4278 kfree(cmd);
4283 static int mwl8k_encryption_set_cmd_info(struct mwl8k_cmd_set_key *cmd,
4287 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION);
4288 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4289 cmd->length = cpu_to_le16(sizeof(*cmd) -
4291 cmd->key_id = cpu_to_le32(key->keyidx);
4292 cmd->key_len = cpu_to_le16(key->keylen);
4293 memcpy(cmd->mac_addr, addr, ETH_ALEN);
4298 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_WEP);
4300 cmd->key_info = cpu_to_le32(MWL8K_KEY_FLAG_WEP_TXKEY);
4304 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_TKIP);
4305 cmd->key_info = (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4308 cmd->key_info |= cpu_to_le32(MWL8K_KEY_FLAG_MICKEY_VALID
4312 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_CCMP);
4313 cmd->key_info = (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4329 struct mwl8k_cmd_set_key *cmd;
4336 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4337 if (cmd == NULL)
4340 rc = mwl8k_encryption_set_cmd_info(cmd, addr, key);
4374 memcpy(cmd->key_material, key->key, keymlen);
4375 cmd->action = cpu_to_le32(action);
4377 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4379 kfree(cmd);
4389 struct mwl8k_cmd_set_key *cmd;
4393 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4394 if (cmd == NULL)
4397 rc = mwl8k_encryption_set_cmd_info(cmd, addr, key);
4405 cmd->action = cpu_to_le32(MWL8K_ENCR_REMOVE_KEY);
4407 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
4409 kfree(cmd);
4525 struct mwl8k_cmd_update_stadb *cmd;
4530 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4531 if (cmd == NULL)
4534 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
4535 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4536 cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
4537 memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
4539 p = &cmd->peer_info;
4555 rc = mwl8k_post_cmd(hw, &cmd->header);
4558 kfree(cmd);
4566 struct mwl8k_cmd_update_stadb *cmd;
4569 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
4570 if (cmd == NULL)
4573 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
4574 cmd->header.length = cpu_to_le16(sizeof(*cmd));
4575 cmd->action = cpu_to_le32(MWL8K_STA_DB_DEL_ENTRY);
4576 memcpy(cmd->peer_addr, addr, ETH_ALEN);
4578 rc = mwl8k_post_cmd(hw, &cmd->header);
4579 kfree(cmd);
5171 struct mwl8k_cmd_pkt *cmd;
5180 cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
5182 return (unsigned long)cmd;
5231 struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;
5239 kfree(cmd);
5249 kfree(cmd);
5257 kfree(cmd);
5301 kfree(cmd);
5302 cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
5305 if (cmd != NULL) {
5306 mwl8k_post_cmd(hw, cmd);
5307 kfree(cmd);