static int rx_helper(struct wfx_dev *wdev, size_t read_len, int *is_cnf)
{
struct sk_buff *skb;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
size_t alloc_len;
size_t computed_len;
int release_count;
piggyback = le16_to_cpup((__le16 *)(skb->data + alloc_len - 2));
_trace_piggyback(piggyback, false);
- hif = (struct hif_msg *)skb->data;
+ hif = (struct wfx_hif_msg *)skb->data;
WARN(hif->encrypted & 0x3, "encryption is unsupported");
- if (WARN(read_len < sizeof(struct hif_msg), "corrupted read"))
+ if (WARN(read_len < sizeof(struct wfx_hif_msg), "corrupted read"))
goto err;
computed_len = le16_to_cpu(hif->len);
computed_len = round_up(computed_len, 2);
if (!(hif->id & HIF_ID_IS_INDICATION)) {
(*is_cnf)++;
if (hif->id == HIF_CNF_ID_MULTI_TRANSMIT)
- release_count = ((struct hif_cnf_multi_transmit *)hif->body)->num_tx_confs;
+ release_count = ((struct wfx_hif_cnf_multi_transmit *)hif->body)->num_tx_confs;
else
release_count = 1;
WARN(wdev->hif.tx_buffers_used < release_count, "corrupted buffer counter");
return i;
}
-static void tx_helper(struct wfx_dev *wdev, struct hif_msg *hif)
+static void tx_helper(struct wfx_dev *wdev, struct wfx_hif_msg *hif)
{
int ret;
void *data;
static int bh_work_tx(struct wfx_dev *wdev, int max_msg)
{
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
int i;
for (i = 0; i < max_msg; i++) {
}
void wfx_rx_cb(struct wfx_vif *wvif,
- const struct hif_ind_rx *arg, struct sk_buff *skb)
+ const struct wfx_hif_ind_rx *arg, struct sk_buff *skb)
{
struct ieee80211_rx_status *hdr = IEEE80211_SKB_RXCB(skb);
struct ieee80211_hdr *frame = (struct ieee80211_hdr *)skb->data;
struct wfx_vif;
struct sk_buff;
-struct hif_ind_rx;
+struct wfx_hif_ind_rx;
void wfx_rx_cb(struct wfx_vif *wvif,
- const struct hif_ind_rx *arg, struct sk_buff *skb);
+ const struct wfx_hif_ind_rx *arg, struct sk_buff *skb);
#endif
static int wfx_tx_inner(struct wfx_vif *wvif, struct ieee80211_sta *sta,
struct sk_buff *skb)
{
- struct hif_msg *hif_msg;
- struct hif_req_tx *req;
+ struct wfx_hif_msg *hif_msg;
+ struct wfx_hif_req_tx *req;
struct wfx_tx_priv *tx_priv;
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
struct ieee80211_key_conf *hw_key = tx_info->control.hw_key;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
int queue_id = skb_get_queue_mapping(skb);
size_t offset = (size_t)skb->data & 3;
- int wmsg_len = sizeof(struct hif_msg) +
- sizeof(struct hif_req_tx) + offset;
+ int wmsg_len = sizeof(struct wfx_hif_msg) +
+ sizeof(struct wfx_hif_req_tx) + offset;
WARN(queue_id >= IEEE80211_NUM_ACS, "unsupported queue_id");
wfx_tx_fixup_rates(tx_info->driver_rates);
skb_put(skb, tx_priv->icv_size);
skb_push(skb, wmsg_len);
memset(skb->data, 0, wmsg_len);
- hif_msg = (struct hif_msg *)skb->data;
+ hif_msg = (struct wfx_hif_msg *)skb->data;
hif_msg->len = cpu_to_le16(skb->len);
hif_msg->id = HIF_REQ_ID_TX;
hif_msg->interface = wvif->id;
}
/* Fill tx request */
- req = (struct hif_req_tx *)hif_msg->body;
+ req = (struct wfx_hif_req_tx *)hif_msg->body;
/* packet_id just need to be unique on device. 32bits are more than
* necessary for that task, so we tae advantage of it to add some extra
* data for debug.
static void wfx_skb_dtor(struct wfx_vif *wvif, struct sk_buff *skb)
{
- struct hif_msg *hif = (struct hif_msg *)skb->data;
- struct hif_req_tx *req = (struct hif_req_tx *)hif->body;
- unsigned int offset = sizeof(struct hif_msg) +
- sizeof(struct hif_req_tx) +
+ struct wfx_hif_msg *hif = (struct hif_msg *)skb->data;
+ struct wfx_hif_req_tx *req = (struct hif_req_tx *)hif->body;
+ unsigned int offset = sizeof(struct wfx_hif_msg) +
+ sizeof(struct wfx_hif_req_tx) +
req->fc_offset;
if (!wvif) {
static void wfx_tx_fill_rates(struct wfx_dev *wdev,
struct ieee80211_tx_info *tx_info,
- const struct hif_cnf_tx *arg)
+ const struct wfx_hif_cnf_tx *arg)
{
struct ieee80211_tx_rate *rate;
int tx_count;
dev_dbg(wdev->dev, "%d more retries than expected\n", tx_count);
}
-void wfx_tx_confirm_cb(struct wfx_dev *wdev, const struct hif_cnf_tx *arg)
+void wfx_tx_confirm_cb(struct wfx_dev *wdev, const struct wfx_hif_cnf_tx *arg)
{
const struct wfx_tx_priv *tx_priv;
struct ieee80211_tx_info *tx_info;
}
tx_info = IEEE80211_SKB_CB(skb);
tx_priv = wfx_skb_tx_priv(skb);
- wvif = wdev_to_wvif(wdev, ((struct hif_msg *)skb->data)->interface);
+ wvif = wdev_to_wvif(wdev, ((struct wfx_hif_msg *)skb->data)->interface);
WARN_ON(!wvif);
if (!wvif)
return;
struct wfx_dev *wdev = hw->priv;
struct sk_buff_head dropped;
struct wfx_vif *wvif;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
struct sk_buff *skb;
skb_queue_head_init(&dropped);
if (wdev->chip_frozen)
wfx_pending_drop(wdev, &dropped);
while ((skb = skb_dequeue(&dropped)) != NULL) {
- hif = (struct hif_msg *)skb->data;
+ hif = (struct wfx_hif_msg *)skb->data;
wvif = wdev_to_wvif(wdev, hif->interface);
ieee80211_tx_info_clear_status(IEEE80211_SKB_CB(skb));
wfx_skb_dtor(wvif, skb);
void wfx_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *control,
struct sk_buff *skb);
-void wfx_tx_confirm_cb(struct wfx_dev *wdev, const struct hif_cnf_tx *arg);
+void wfx_tx_confirm_cb(struct wfx_dev *wdev, const struct wfx_hif_cnf_tx *arg);
void wfx_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
u32 queues, bool drop);
return (struct wfx_tx_priv *)tx_info->rate_driver_data;
}
-static inline struct hif_req_tx *wfx_skb_txreq(struct sk_buff *skb)
+static inline struct wfx_hif_req_tx *wfx_skb_txreq(struct sk_buff *skb)
{
- struct hif_msg *hif = (struct hif_msg *)skb->data;
- struct hif_req_tx *req = (struct hif_req_tx *)hif->body;
+ struct wfx_hif_msg *hif = (struct hif_msg *)skb->data;
+ struct wfx_hif_req_tx *req = (struct hif_req_tx *)hif->body;
return req;
}
{
int ret, i;
struct wfx_dev *wdev = seq->private;
- struct hif_mib_extended_count_table counters[3];
+ struct wfx_hif_mib_extended_count_table counters[3];
for (i = 0; i < ARRAY_SIZE(counters); i++) {
ret = wfx_hif_get_counters_table(wdev, i, counters + i);
static int wfx_rx_stats_show(struct seq_file *seq, void *v)
{
struct wfx_dev *wdev = seq->private;
- struct hif_rx_stats *st = &wdev->rx_stats;
+ struct wfx_hif_rx_stats *st = &wdev->rx_stats;
int i;
mutex_lock(&wdev->rx_stats_lock);
static int wfx_tx_power_loop_show(struct seq_file *seq, void *v)
{
struct wfx_dev *wdev = seq->private;
- struct hif_tx_power_loop_info *st = &wdev->tx_power_loop_info;
+ struct wfx_hif_tx_power_loop_info *st = &wdev->tx_power_loop_info;
int tmp;
mutex_lock(&wdev->tx_power_loop_info_lock);
{
struct dbgfs_hif_msg *context = file->private_data;
struct wfx_dev *wdev = context->wdev;
- struct hif_msg *request;
+ struct wfx_hif_msg *request;
if (completion_done(&context->complete)) {
dev_dbg(wdev->dev, "read previous result before start a new one\n");
return -EBUSY;
}
- if (count < sizeof(struct hif_msg))
+ if (count < sizeof(struct wfx_hif_msg))
return -EINVAL;
/* wfx_cmd_send() checks that reply buffer is wide enough, but does not
#include "hif_api_general.h"
-enum hif_requests_ids {
+enum wfx_hif_requests_ids {
HIF_REQ_ID_RESET = 0x0a,
HIF_REQ_ID_READ_MIB = 0x05,
HIF_REQ_ID_WRITE_MIB = 0x06,
HIF_REQ_ID_MAP_LINK = 0x1c,
};
-enum hif_confirmations_ids {
+enum wfx_hif_confirmations_ids {
HIF_CNF_ID_RESET = 0x0a,
HIF_CNF_ID_READ_MIB = 0x05,
HIF_CNF_ID_WRITE_MIB = 0x06,
HIF_CNF_ID_MAP_LINK = 0x1c,
};
-enum hif_indications_ids {
+enum wfx_hif_indications_ids {
HIF_IND_ID_RX = 0x84,
HIF_IND_ID_SCAN_CMPL = 0x86,
HIF_IND_ID_JOIN_COMPLETE = 0x8f,
HIF_IND_ID_EVENT = 0x85
};
-struct hif_req_reset {
+struct wfx_hif_req_reset {
u8 reset_stat:1;
u8 reset_all_int:1;
u8 reserved1:6;
u8 reserved2[3];
} __packed;
-struct hif_cnf_reset {
+struct wfx_hif_cnf_reset {
__le32 status;
} __packed;
-struct hif_req_read_mib {
+struct wfx_hif_req_read_mib {
__le16 mib_id;
__le16 reserved;
} __packed;
-struct hif_cnf_read_mib {
+struct wfx_hif_cnf_read_mib {
__le32 status;
__le16 mib_id;
__le16 length;
u8 mib_data[];
} __packed;
-struct hif_req_write_mib {
+struct wfx_hif_req_write_mib {
__le16 mib_id;
__le16 length;
u8 mib_data[];
} __packed;
-struct hif_cnf_write_mib {
+struct wfx_hif_cnf_write_mib {
__le32 status;
} __packed;
-struct hif_req_update_ie {
+struct wfx_hif_req_update_ie {
u8 beacon:1;
u8 probe_resp:1;
u8 probe_req:1;
u8 ie[];
} __packed;
-struct hif_cnf_update_ie {
+struct wfx_hif_cnf_update_ie {
__le32 status;
} __packed;
-struct hif_ssid_def {
+struct wfx_hif_ssid_def {
__le32 ssid_length;
u8 ssid[IEEE80211_MAX_SSID_LEN];
} __packed;
#define HIF_API_MAX_NB_SSIDS 2
#define HIF_API_MAX_NB_CHANNELS 14
-struct hif_req_start_scan_alt {
+struct wfx_hif_req_start_scan_alt {
u8 band;
u8 maintain_current_bss:1;
u8 periodic:1;
__le32 min_channel_time;
__le32 max_channel_time;
__le32 tx_power_level; /* signed value */
- struct hif_ssid_def ssid_def[HIF_API_MAX_NB_SSIDS];
+ struct wfx_hif_ssid_def ssid_def[HIF_API_MAX_NB_SSIDS];
u8 channel_list[];
} __packed;
-struct hif_cnf_start_scan {
+struct wfx_hif_cnf_start_scan {
__le32 status;
} __packed;
-struct hif_cnf_stop_scan {
+struct wfx_hif_cnf_stop_scan {
__le32 status;
} __packed;
-enum hif_pm_mode_status {
+enum wfx_hif_pm_mode_status {
HIF_PM_MODE_ACTIVE = 0x0,
HIF_PM_MODE_PS = 0x1,
HIF_PM_MODE_UNDETERMINED = 0x2
};
-struct hif_ind_scan_cmpl {
+struct wfx_hif_ind_scan_cmpl {
__le32 status;
u8 pm_mode;
u8 num_channels_completed;
__le16 reserved;
} __packed;
-enum hif_queue_id {
+enum wfx_hif_queue_id {
HIF_QUEUE_ID_BACKGROUND = 0x0,
HIF_QUEUE_ID_BESTEFFORT = 0x1,
HIF_QUEUE_ID_VIDEO = 0x2,
HIF_QUEUE_ID_VOICE = 0x3
};
-enum hif_frame_format {
+enum wfx_hif_frame_format {
HIF_FRAME_FORMAT_NON_HT = 0x0,
HIF_FRAME_FORMAT_MIXED_FORMAT_HT = 0x1,
HIF_FRAME_FORMAT_GF_HT_11N = 0x2
};
-struct hif_req_tx {
+struct wfx_hif_req_tx {
/* packet_id is not interpreted by the device, so it is not necessary to
* declare it little endian
*/
u8 frame[];
} __packed;
-enum hif_qos_ackplcy {
+enum wfx_hif_qos_ackplcy {
HIF_QOS_ACKPLCY_NORMAL = 0x0,
HIF_QOS_ACKPLCY_TXNOACK = 0x1,
HIF_QOS_ACKPLCY_NOEXPACK = 0x2,
HIF_QOS_ACKPLCY_BLCKACK = 0x3
};
-struct hif_cnf_tx {
+struct wfx_hif_cnf_tx {
__le32 status;
- /* packet_id is copied from struct hif_req_tx without been interpreted
+ /* packet_id is copied from struct wfx_hif_req_tx without been interpreted
* by the device, so it is not necessary to declare it little endian
*/
u32 packet_id;
__le32 tx_queue_delay;
} __packed;
-struct hif_cnf_multi_transmit {
+struct wfx_hif_cnf_multi_transmit {
u8 num_tx_confs;
u8 reserved[3];
- struct hif_cnf_tx tx_conf_payload[];
+ struct wfx_hif_cnf_tx tx_conf_payload[];
} __packed;
-enum hif_ri_flags_encrypt {
+enum wfx_hif_ri_flags_encrypt {
HIF_RI_FLAGS_UNENCRYPTED = 0x0,
HIF_RI_FLAGS_WEP_ENCRYPTED = 0x1,
HIF_RI_FLAGS_TKIP_ENCRYPTED = 0x2,
HIF_RI_FLAGS_WAPI_ENCRYPTED = 0x4
};
-struct hif_ind_rx {
+struct wfx_hif_ind_rx {
__le32 status;
u8 channel_number;
u8 reserved1;
u8 frame[];
} __packed;
-struct hif_req_edca_queue_params {
+struct wfx_hif_req_edca_queue_params {
u8 queue_id;
u8 reserved1;
u8 aifsn;
__le32 reserved3;
} __packed;
-struct hif_cnf_edca_queue_params {
+struct wfx_hif_cnf_edca_queue_params {
__le32 status;
} __packed;
-struct hif_req_join {
+struct wfx_hif_req_join {
u8 infrastructure_bss_mode:1;
u8 reserved1:7;
u8 band;
__le32 basic_rate_set;
} __packed;
-struct hif_cnf_join {
+struct wfx_hif_cnf_join {
__le32 status;
} __packed;
-struct hif_ind_join_complete {
+struct wfx_hif_ind_join_complete {
__le32 status;
} __packed;
-struct hif_req_set_bss_params {
+struct wfx_hif_req_set_bss_params {
u8 lost_count_only:1;
u8 reserved:7;
u8 beacon_lost_count;
__le32 operational_rate_set;
} __packed;
-struct hif_cnf_set_bss_params {
+struct wfx_hif_cnf_set_bss_params {
__le32 status;
} __packed;
-struct hif_req_set_pm_mode {
+struct wfx_hif_req_set_pm_mode {
u8 enter_psm:1;
u8 reserved:6;
u8 fast_psm:1;
u8 min_auto_ps_poll_period;
} __packed;
-struct hif_cnf_set_pm_mode {
+struct wfx_hif_cnf_set_pm_mode {
__le32 status;
} __packed;
-struct hif_ind_set_pm_mode_cmpl {
+struct wfx_hif_ind_set_pm_mode_cmpl {
__le32 status;
u8 pm_mode;
u8 reserved[3];
} __packed;
-struct hif_req_start {
+struct wfx_hif_req_start {
u8 mode;
u8 band;
u8 channel_number;
__le32 basic_rate_set;
} __packed;
-struct hif_cnf_start {
+struct wfx_hif_cnf_start {
__le32 status;
} __packed;
-struct hif_req_beacon_transmit {
+struct wfx_hif_req_beacon_transmit {
u8 enable_beaconing;
u8 reserved[3];
} __packed;
-struct hif_cnf_beacon_transmit {
+struct wfx_hif_cnf_beacon_transmit {
__le32 status;
} __packed;
#define HIF_LINK_ID_MAX 14
#define HIF_LINK_ID_NOT_ASSOCIATED (HIF_LINK_ID_MAX + 1)
-struct hif_req_map_link {
+struct wfx_hif_req_map_link {
u8 mac_addr[ETH_ALEN];
u8 unmap:1;
u8 mfpc:1;
u8 peer_sta_id;
} __packed;
-struct hif_cnf_map_link {
+struct wfx_hif_cnf_map_link {
__le32 status;
} __packed;
-struct hif_ind_suspend_resume_tx {
+struct wfx_hif_ind_suspend_resume_tx {
u8 resume:1;
u8 reserved1:2;
u8 bc_mc_only:1;
#define HIF_API_RX_SEQUENCE_COUNTER_SIZE 8
#define HIF_API_IPN_SIZE 8
-enum hif_key_type {
+enum wfx_hif_key_type {
HIF_KEY_TYPE_WEP_DEFAULT = 0x0,
HIF_KEY_TYPE_WEP_PAIRWISE = 0x1,
HIF_KEY_TYPE_TKIP_GROUP = 0x2,
HIF_KEY_TYPE_NONE = 0x9
};
-struct hif_wep_pairwise_key {
+struct wfx_hif_wep_pairwise_key {
u8 peer_address[ETH_ALEN];
u8 reserved;
u8 key_length;
u8 key_data[HIF_API_WEP_KEY_DATA_SIZE];
} __packed;
-struct hif_wep_group_key {
+struct wfx_hif_wep_group_key {
u8 key_id;
u8 key_length;
u8 reserved[2];
u8 key_data[HIF_API_WEP_KEY_DATA_SIZE];
} __packed;
-struct hif_tkip_pairwise_key {
+struct wfx_hif_tkip_pairwise_key {
u8 peer_address[ETH_ALEN];
u8 reserved[2];
u8 tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
u8 tx_mic_key[HIF_API_TX_MIC_KEY_SIZE];
} __packed;
-struct hif_tkip_group_key {
+struct wfx_hif_tkip_group_key {
u8 tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
u8 rx_mic_key[HIF_API_RX_MIC_KEY_SIZE];
u8 key_id;
u8 rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
} __packed;
-struct hif_aes_pairwise_key {
+struct wfx_hif_aes_pairwise_key {
u8 peer_address[ETH_ALEN];
u8 reserved[2];
u8 aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
} __packed;
-struct hif_aes_group_key {
+struct wfx_hif_aes_group_key {
u8 aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
u8 key_id;
u8 reserved[3];
u8 rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
} __packed;
-struct hif_wapi_pairwise_key {
+struct wfx_hif_wapi_pairwise_key {
u8 peer_address[ETH_ALEN];
u8 key_id;
u8 reserved;
u8 mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
} __packed;
-struct hif_wapi_group_key {
+struct wfx_hif_wapi_group_key {
u8 wapi_key_data[HIF_API_WAPI_KEY_DATA_SIZE];
u8 mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
u8 key_id;
u8 reserved[3];
} __packed;
-struct hif_igtk_group_key {
+struct wfx_hif_igtk_group_key {
u8 igtk_key_data[HIF_API_IGTK_KEY_DATA_SIZE];
u8 key_id;
u8 reserved[3];
u8 ipn[HIF_API_IPN_SIZE];
} __packed;
-struct hif_req_add_key {
+struct wfx_hif_req_add_key {
u8 type;
u8 entry_index;
u8 int_id:2;
u8 reserved1:6;
u8 reserved2;
union {
- struct hif_wep_pairwise_key wep_pairwise_key;
- struct hif_wep_group_key wep_group_key;
- struct hif_tkip_pairwise_key tkip_pairwise_key;
- struct hif_tkip_group_key tkip_group_key;
- struct hif_aes_pairwise_key aes_pairwise_key;
- struct hif_aes_group_key aes_group_key;
- struct hif_wapi_pairwise_key wapi_pairwise_key;
- struct hif_wapi_group_key wapi_group_key;
- struct hif_igtk_group_key igtk_group_key;
+ struct wfx_hif_wep_pairwise_key wep_pairwise_key;
+ struct wfx_hif_wep_group_key wep_group_key;
+ struct wfx_hif_tkip_pairwise_key tkip_pairwise_key;
+ struct wfx_hif_tkip_group_key tkip_group_key;
+ struct wfx_hif_aes_pairwise_key aes_pairwise_key;
+ struct wfx_hif_aes_group_key aes_group_key;
+ struct wfx_hif_wapi_pairwise_key wapi_pairwise_key;
+ struct wfx_hif_wapi_group_key wapi_group_key;
+ struct wfx_hif_igtk_group_key igtk_group_key;
} key;
} __packed;
-struct hif_cnf_add_key {
+struct wfx_hif_cnf_add_key {
__le32 status;
} __packed;
-struct hif_req_remove_key {
+struct wfx_hif_req_remove_key {
u8 entry_index;
u8 reserved[3];
} __packed;
-struct hif_cnf_remove_key {
+struct wfx_hif_cnf_remove_key {
__le32 status;
} __packed;
-enum hif_event_ind {
+enum wfx_hif_event_ind {
HIF_EVENT_IND_BSSLOST = 0x1,
HIF_EVENT_IND_BSSREGAINED = 0x2,
HIF_EVENT_IND_RCPI_RSSI = 0x3,
HIF_EVENT_IND_INACTIVITY = 0x5
};
-enum hif_ps_mode_error {
+enum wfx_hif_ps_mode_error {
HIF_PS_ERROR_NO_ERROR = 0,
HIF_PS_ERROR_AP_NOT_RESP_TO_POLL = 1,
HIF_PS_ERROR_AP_NOT_RESP_TO_UAPSD_TRIGGER = 2,
HIF_PS_ERROR_AP_NO_DATA_AFTER_TIM = 4
};
-struct hif_ind_event {
+struct wfx_hif_ind_event {
__le32 event_id;
union {
u8 rcpi_rssi;
#define HIF_ID_IS_INDICATION 0x80
#define HIF_COUNTER_MAX 7
-struct hif_msg {
+struct wfx_hif_msg {
__le16 len;
u8 id;
u8 reserved:1;
u8 body[];
} __packed;
-enum hif_general_requests_ids {
+enum wfx_hif_general_requests_ids {
HIF_REQ_ID_CONFIGURATION = 0x09,
HIF_REQ_ID_CONTROL_GPIO = 0x26,
HIF_REQ_ID_SET_SL_MAC_KEY = 0x27,
HIF_REQ_ID_SHUT_DOWN = 0x32,
};
-enum hif_general_confirmations_ids {
+enum wfx_hif_general_confirmations_ids {
HIF_CNF_ID_CONFIGURATION = 0x09,
HIF_CNF_ID_CONTROL_GPIO = 0x26,
HIF_CNF_ID_SET_SL_MAC_KEY = 0x27,
HIF_CNF_ID_SHUT_DOWN = 0x32,
};
-enum hif_general_indications_ids {
+enum wfx_hif_general_indications_ids {
HIF_IND_ID_EXCEPTION = 0xe0,
HIF_IND_ID_STARTUP = 0xe1,
HIF_IND_ID_WAKEUP = 0xe2,
#define HIF_STATUS_ROLLBACK_SUCCESS (cpu_to_le32(0x1234))
#define HIF_STATUS_ROLLBACK_FAIL (cpu_to_le32(0x1256))
-enum hif_api_rate_index {
+enum wfx_hif_api_rate_index {
API_RATE_INDEX_B_1MBPS = 0,
API_RATE_INDEX_B_2MBPS = 1,
API_RATE_INDEX_B_5P5MBPS = 2,
API_RATE_NUM_ENTRIES = 22
};
-struct hif_ind_startup {
+struct wfx_hif_ind_startup {
__le32 status;
__le16 hardware_id;
u8 opn[14];
u8 firmware_label[128];
} __packed;
-struct hif_ind_wakeup {
+struct wfx_hif_ind_wakeup {
} __packed;
-struct hif_req_configuration {
+struct wfx_hif_req_configuration {
__le16 length;
u8 pds_data[];
} __packed;
-struct hif_cnf_configuration {
+struct wfx_hif_cnf_configuration {
__le32 status;
} __packed;
-enum hif_gpio_mode {
+enum wfx_hif_gpio_mode {
HIF_GPIO_MODE_D0 = 0x0,
HIF_GPIO_MODE_D1 = 0x1,
HIF_GPIO_MODE_OD0 = 0x2,
HIF_GPIO_MODE_READ = 0x6
};
-struct hif_req_control_gpio {
+struct wfx_hif_req_control_gpio {
u8 gpio_label;
u8 gpio_mode;
} __packed;
-struct hif_cnf_control_gpio {
+struct wfx_hif_cnf_control_gpio {
__le32 status;
__le32 value;
} __packed;
-enum hif_generic_indication_type {
+enum wfx_hif_generic_indication_type {
HIF_GENERIC_INDICATION_TYPE_RAW = 0x0,
HIF_GENERIC_INDICATION_TYPE_STRING = 0x1,
HIF_GENERIC_INDICATION_TYPE_RX_STATS = 0x2,
HIF_GENERIC_INDICATION_TYPE_TX_POWER_LOOP_INFO = 0x3,
};
-struct hif_rx_stats {
+struct wfx_hif_rx_stats {
__le32 nb_rx_frame;
__le32 nb_crc_frame;
__le32 per_total;
s8 current_temp;
} __packed;
-struct hif_tx_power_loop_info {
+struct wfx_hif_tx_power_loop_info {
__le16 tx_gain_dig;
__le16 tx_gain_pa;
__le16 target_pout; /* signed value */
u8 reserved;
} __packed;
-struct hif_ind_generic {
+struct wfx_hif_ind_generic {
__le32 type;
union {
- struct hif_rx_stats rx_stats;
- struct hif_tx_power_loop_info tx_power_loop_info;
+ struct wfx_hif_rx_stats rx_stats;
+ struct wfx_hif_tx_power_loop_info tx_power_loop_info;
} data;
} __packed;
-enum hif_error {
+enum wfx_hif_error {
HIF_ERROR_FIRMWARE_ROLLBACK = 0x00,
HIF_ERROR_FIRMWARE_DEBUG_ENABLED = 0x01,
HIF_ERROR_SLK_OUTDATED_SESSION_KEY = 0x02,
HIF_ERROR_SLK_UNCONFIGURED = 0x11,
};
-struct hif_ind_error {
+struct wfx_hif_ind_error {
__le32 type;
u8 data[];
} __packed;
-struct hif_ind_exception {
+struct wfx_hif_ind_exception {
__le32 type;
u8 data[];
} __packed;
-enum hif_secure_link_state {
+enum wfx_hif_secure_link_state {
SEC_LINK_UNAVAILABLE = 0x0,
SEC_LINK_RESERVED = 0x1,
SEC_LINK_EVAL = 0x2,
#define HIF_API_IPV4_ADDRESS_SIZE 4
#define HIF_API_IPV6_ADDRESS_SIZE 16
-enum hif_mib_ids {
+enum wfx_hif_mib_ids {
HIF_MIB_ID_GL_OPERATIONAL_POWER_MODE = 0x2000,
HIF_MIB_ID_GL_BLOCK_ACK_INFO = 0x2001,
HIF_MIB_ID_GL_SET_MULTI_MSG = 0x2002,
HIF_MIB_ID_BEACON_STATS = 0x2056,
};
-enum hif_op_power_mode {
+enum wfx_hif_op_power_mode {
HIF_OP_POWER_MODE_ACTIVE = 0x0,
HIF_OP_POWER_MODE_DOZE = 0x1,
HIF_OP_POWER_MODE_QUIESCENT = 0x2
};
-struct hif_mib_gl_operational_power_mode {
+struct wfx_hif_mib_gl_operational_power_mode {
u8 power_mode:4;
u8 reserved1:3;
u8 wup_ind_activation:1;
u8 reserved2[3];
} __packed;
-struct hif_mib_gl_set_multi_msg {
+struct wfx_hif_mib_gl_set_multi_msg {
u8 enable_multi_tx_conf:1;
u8 reserved1:7;
u8 reserved2[3];
} __packed;
-enum hif_arp_ns_frame_treatment {
+enum wfx_hif_arp_ns_frame_treatment {
HIF_ARP_NS_FILTERING_DISABLE = 0x0,
HIF_ARP_NS_FILTERING_ENABLE = 0x1,
HIF_ARP_NS_REPLY_ENABLE = 0x2
};
-struct hif_mib_arp_ip_addr_table {
+struct wfx_hif_mib_arp_ip_addr_table {
u8 condition_idx;
u8 arp_enable;
u8 reserved[2];
u8 ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
} __packed;
-struct hif_mib_rx_filter {
+struct wfx_hif_mib_rx_filter {
u8 reserved1:1;
u8 bssid_filter:1;
u8 reserved2:1;
u8 reserved4[3];
} __packed;
-struct hif_ie_table_entry {
+struct wfx_hif_ie_table_entry {
u8 ie_id;
u8 has_changed:1;
u8 no_longer:1;
u8 match_data[3];
} __packed;
-struct hif_mib_bcn_filter_table {
+struct wfx_hif_mib_bcn_filter_table {
__le32 num_of_info_elmts;
- struct hif_ie_table_entry ie_table[];
+ struct wfx_hif_ie_table_entry ie_table[];
} __packed;
-enum hif_beacon_filter {
+enum wfx_hif_beacon_filter {
HIF_BEACON_FILTER_DISABLE = 0x0,
HIF_BEACON_FILTER_ENABLE = 0x1,
HIF_BEACON_FILTER_AUTO_ERP = 0x2
};
-struct hif_mib_bcn_filter_enable {
+struct wfx_hif_mib_bcn_filter_enable {
__le32 enable;
__le32 bcn_count;
} __packed;
-struct hif_mib_extended_count_table {
+struct wfx_hif_mib_extended_count_table {
__le32 count_drop_plcp;
__le32 count_drop_fcs;
__le32 count_tx_frames;
__le32 reserved[12];
} __packed;
-struct hif_mib_count_table {
+struct wfx_hif_mib_count_table {
__le32 count_drop_plcp;
__le32 count_drop_fcs;
__le32 count_tx_frames;
__le32 count_drop_bip_mic;
} __packed;
-struct hif_mib_mac_address {
+struct wfx_hif_mib_mac_address {
u8 mac_addr[ETH_ALEN];
__le16 reserved;
} __packed;
-struct hif_mib_wep_default_key_id {
+struct wfx_hif_mib_wep_default_key_id {
u8 wep_default_key_id;
u8 reserved[3];
} __packed;
-struct hif_mib_dot11_rts_threshold {
+struct wfx_hif_mib_dot11_rts_threshold {
__le32 threshold;
} __packed;
-struct hif_mib_slot_time {
+struct wfx_hif_mib_slot_time {
__le32 slot_time;
} __packed;
-struct hif_mib_current_tx_power_level {
+struct wfx_hif_mib_current_tx_power_level {
__le32 power_level; /* signed value */
} __packed;
-struct hif_mib_non_erp_protection {
+struct wfx_hif_mib_non_erp_protection {
u8 use_cts_to_self:1;
u8 reserved1:7;
u8 reserved2[3];
} __packed;
-enum hif_tmplt {
+enum wfx_hif_tmplt {
HIF_TMPLT_PRBREQ = 0x0,
HIF_TMPLT_BCN = 0x1,
HIF_TMPLT_NULL = 0x2,
#define HIF_API_MAX_TEMPLATE_FRAME_SIZE 700
-struct hif_mib_template_frame {
+struct wfx_hif_mib_template_frame {
u8 frame_type;
u8 init_rate:7;
u8 mode:1;
u8 frame[];
} __packed;
-struct hif_mib_beacon_wake_up_period {
+struct wfx_hif_mib_beacon_wake_up_period {
u8 wakeup_period_min;
u8 receive_dtim:1;
u8 reserved1:7;
u8 reserved2;
} __packed;
-struct hif_mib_rcpi_rssi_threshold {
+struct wfx_hif_mib_rcpi_rssi_threshold {
u8 detection:1;
u8 rcpi_rssi:1;
u8 upperthresh:1;
#define DEFAULT_BA_MAX_RX_BUFFER_SIZE 16
-struct hif_mib_block_ack_policy {
+struct wfx_hif_mib_block_ack_policy {
u8 block_ack_tx_tid_policy;
u8 reserved1;
u8 block_ack_rx_tid_policy;
u8 block_ack_rx_max_buffer_size;
} __packed;
-enum hif_mpdu_start_spacing {
+enum wfx_hif_mpdu_start_spacing {
HIF_MPDU_START_SPACING_NO_RESTRIC = 0x0,
HIF_MPDU_START_SPACING_QUARTER = 0x1,
HIF_MPDU_START_SPACING_HALF = 0x2,
HIF_MPDU_START_SPACING_SIXTEEN = 0x7
};
-struct hif_mib_set_association_mode {
+struct wfx_hif_mib_set_association_mode {
u8 preambtype_use:1;
u8 mode:1;
u8 rateset:1;
__le32 basic_rate_set;
} __packed;
-struct hif_mib_set_uapsd_information {
+struct wfx_hif_mib_set_uapsd_information {
u8 trig_bckgrnd:1;
u8 trig_be:1;
u8 trig_video:1;
__le16 auto_trigger_step;
} __packed;
-struct hif_tx_rate_retry_policy {
+struct wfx_hif_tx_rate_retry_policy {
u8 policy_index;
u8 short_retry_count;
u8 long_retry_count;
#define HIF_TX_RETRY_POLICY_MAX 15
#define HIF_TX_RETRY_POLICY_INVALID HIF_TX_RETRY_POLICY_MAX
-struct hif_mib_set_tx_rate_retry_policy {
+struct wfx_hif_mib_set_tx_rate_retry_policy {
u8 num_tx_rate_policies;
u8 reserved[3];
- struct hif_tx_rate_retry_policy tx_rate_retry_policy[];
+ struct wfx_hif_tx_rate_retry_policy tx_rate_retry_policy[];
} __packed;
-struct hif_mib_protected_mgmt_policy {
+struct wfx_hif_mib_protected_mgmt_policy {
u8 pmf_enable:1;
u8 unpmf_allowed:1;
u8 host_enc_auth_frames:1;
u8 reserved2[3];
} __packed;
-struct hif_mib_keep_alive_period {
+struct wfx_hif_mib_keep_alive_period {
__le16 keep_alive_period;
u8 reserved[2];
} __packed;
#include "hif_api_cmd.h"
static int wfx_hif_generic_confirm(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif, const void *buf)
{
/* All confirm messages start with status */
int status = le32_to_cpup((__le32 *)buf);
}
static int wfx_hif_tx_confirm(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif, const void *buf)
{
- const struct hif_cnf_tx *body = buf;
+ const struct wfx_hif_cnf_tx *body = buf;
wfx_tx_confirm_cb(wdev, body);
return 0;
}
static int wfx_hif_multi_tx_confirm(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif, const void *buf)
{
- const struct hif_cnf_multi_transmit *body = buf;
+ const struct wfx_hif_cnf_multi_transmit *body = buf;
int i;
WARN(body->num_tx_confs <= 0, "corrupted message");
}
static int wfx_hif_startup_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
- const struct hif_ind_startup *body = buf;
+ const struct wfx_hif_ind_startup *body = buf;
if (body->status || body->firmware_type > 4) {
dev_err(wdev->dev, "received invalid startup indication");
return -EINVAL;
}
- memcpy(&wdev->hw_caps, body, sizeof(struct hif_ind_startup));
+ memcpy(&wdev->hw_caps, body, sizeof(struct wfx_hif_ind_startup));
complete(&wdev->firmware_ready);
return 0;
}
static int wfx_hif_wakeup_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif,
+ const void *buf)
{
if (!wdev->pdata.gpio_wakeup ||
gpiod_get_value(wdev->pdata.gpio_wakeup) == 0) {
}
static int wfx_hif_receive_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf, struct sk_buff *skb)
{
struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
- const struct hif_ind_rx *body = buf;
+ const struct wfx_hif_ind_rx *body = buf;
if (!wvif) {
dev_warn(wdev->dev, "%s: ignore rx data for non-existent vif %d\n",
__func__, hif->interface);
return -EIO;
}
- skb_pull(skb, sizeof(struct hif_msg) + sizeof(struct hif_ind_rx));
+ skb_pull(skb, sizeof(struct wfx_hif_msg) + sizeof(struct hif_ind_rx));
wfx_rx_cb(wvif, body, skb);
return 0;
}
static int wfx_hif_event_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif, const void *buf)
{
struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
- const struct hif_ind_event *body = buf;
+ const struct wfx_hif_ind_event *body = buf;
int type = le32_to_cpu(body->event_id);
if (!wvif) {
}
static int wfx_hif_pm_mode_complete_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
}
static int wfx_hif_scan_complete_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
- const struct hif_ind_scan_cmpl *body = buf;
+ const struct wfx_hif_ind_scan_cmpl *body = buf;
if (!wvif) {
dev_warn(wdev->dev, "%s: received event for non-existent vif\n", __func__);
}
static int wfx_hif_join_complete_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
}
static int wfx_hif_suspend_resume_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
- const struct hif_ind_suspend_resume_tx *body = buf;
+ const struct wfx_hif_ind_suspend_resume_tx *body = buf;
struct wfx_vif *wvif;
if (body->bc_mc_only) {
}
static int wfx_hif_generic_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
- const struct hif_ind_generic *body = buf;
+ const struct wfx_hif_ind_generic *body = buf;
int type = le32_to_cpu(body->type);
switch (type) {
};
static int wfx_hif_error_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf)
+ const struct wfx_hif_msg *hif, const void *buf)
{
- const struct hif_ind_error *body = buf;
+ const struct wfx_hif_ind_error *body = buf;
int type = le32_to_cpu(body->type);
int param = (s8)body->data[0];
int i;
};
static int wfx_hif_exception_indication(struct wfx_dev *wdev,
- const struct hif_msg *hif,
+ const struct wfx_hif_msg *hif,
const void *buf)
{
- const struct hif_ind_exception *body = buf;
+ const struct wfx_hif_ind_exception *body = buf;
int type = le32_to_cpu(body->type);
if (type == 4)
static const struct {
int msg_id;
int (*handler)(struct wfx_dev *wdev,
- const struct hif_msg *hif, const void *buf);
+ const struct wfx_hif_msg *hif, const void *buf);
} hif_handlers[] = {
/* Confirmations */
{ HIF_CNF_ID_TX, wfx_hif_tx_confirm },
void wfx_handle_rx(struct wfx_dev *wdev, struct sk_buff *skb)
{
int i;
- const struct hif_msg *hif = (const struct hif_msg *)skb->data;
+ const struct wfx_hif_msg *hif = (const struct hif_msg *)skb->data;
int hif_id = hif->id;
if (hif_id == HIF_IND_ID_RX) {
mutex_init(&hif_cmd->lock);
}
-static void wfx_fill_header(struct hif_msg *hif, int if_id,
+static void wfx_fill_header(struct wfx_hif_msg *hif, int if_id,
unsigned int cmd, size_t size)
{
if (if_id == -1)
hif->interface = if_id;
}
-static void *wfx_alloc_hif(size_t body_len, struct hif_msg **hif)
+static void *wfx_alloc_hif(size_t body_len, struct wfx_hif_msg **hif)
{
- *hif = kzalloc(sizeof(struct hif_msg) + body_len, GFP_KERNEL);
+ *hif = kzalloc(sizeof(struct wfx_hif_msg) + body_len, GFP_KERNEL);
if (*hif)
return (*hif)->body;
else
return NULL;
}
-int wfx_cmd_send(struct wfx_dev *wdev, struct hif_msg *request,
+int wfx_cmd_send(struct wfx_dev *wdev, struct wfx_hif_msg *request,
void *reply, size_t reply_len, bool no_reply)
{
const char *mib_name = "";
int wfx_hif_shutdown(struct wfx_dev *wdev)
{
int ret;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
wfx_alloc_hif(0, &hif);
if (!hif)
int wfx_hif_configuration(struct wfx_dev *wdev, const u8 *conf, size_t len)
{
int ret;
- size_t buf_len = sizeof(struct hif_req_configuration) + len;
- struct hif_msg *hif;
- struct hif_req_configuration *body = wfx_alloc_hif(buf_len, &hif);
+ size_t buf_len = sizeof(struct wfx_hif_req_configuration) + len;
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_configuration *body = wfx_alloc_hif(buf_len, &hif);
if (!hif)
return -ENOMEM;
int wfx_hif_reset(struct wfx_vif *wvif, bool reset_stat)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_reset *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_reset *body = wfx_alloc_hif(sizeof(*body), &hif);
if (!hif)
return -ENOMEM;
void *val, size_t val_len)
{
int ret;
- struct hif_msg *hif;
- int buf_len = sizeof(struct hif_cnf_read_mib) + val_len;
- struct hif_req_read_mib *body = wfx_alloc_hif(sizeof(*body), &hif);
- struct hif_cnf_read_mib *reply = kmalloc(buf_len, GFP_KERNEL);
+ struct wfx_hif_msg *hif;
+ int buf_len = sizeof(struct wfx_hif_cnf_read_mib) + val_len;
+ struct wfx_hif_req_read_mib *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_cnf_read_mib *reply = kmalloc(buf_len, GFP_KERNEL);
if (!body || !reply) {
ret = -ENOMEM;
void *val, size_t val_len)
{
int ret;
- struct hif_msg *hif;
- int buf_len = sizeof(struct hif_req_write_mib) + val_len;
- struct hif_req_write_mib *body = wfx_alloc_hif(buf_len, &hif);
+ struct wfx_hif_msg *hif;
+ int buf_len = sizeof(struct wfx_hif_req_write_mib) + val_len;
+ struct wfx_hif_req_write_mib *body = wfx_alloc_hif(buf_len, &hif);
if (!hif)
return -ENOMEM;
int chan_start_idx, int chan_num)
{
int ret, i;
- struct hif_msg *hif;
- size_t buf_len =
- sizeof(struct hif_req_start_scan_alt) + chan_num * sizeof(u8);
- struct hif_req_start_scan_alt *body = wfx_alloc_hif(buf_len, &hif);
+ struct wfx_hif_msg *hif;
+ size_t buf_len = sizeof(struct wfx_hif_req_start_scan_alt) +
+ chan_num * sizeof(u8);
+ struct wfx_hif_req_start_scan_alt *body = wfx_alloc_hif(buf_len, &hif);
WARN(chan_num > HIF_API_MAX_NB_CHANNELS, "invalid params");
WARN(req->n_ssids > HIF_API_MAX_NB_SSIDS, "invalid params");
int wfx_hif_stop_scan(struct wfx_vif *wvif)
{
int ret;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
/* body associated to HIF_REQ_ID_STOP_SCAN is empty */
wfx_alloc_hif(0, &hif);
struct ieee80211_channel *channel, const u8 *ssid, int ssidlen)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_join *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_join *body = wfx_alloc_hif(sizeof(*body), &hif);
WARN_ON(!conf->beacon_int);
WARN_ON(!conf->basic_rates);
int wfx_hif_set_bss_params(struct wfx_vif *wvif, int aid, int beacon_lost_count)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_set_bss_params *body =
- wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_set_bss_params *body = wfx_alloc_hif(sizeof(*body),
+ &hif);
if (!hif)
return -ENOMEM;
return ret;
}
-int wfx_hif_add_key(struct wfx_dev *wdev, const struct hif_req_add_key *arg)
+int wfx_hif_add_key(struct wfx_dev *wdev, const struct wfx_hif_req_add_key *arg)
{
int ret;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
/* FIXME: only send necessary bits */
- struct hif_req_add_key *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_req_add_key *body = wfx_alloc_hif(sizeof(*body), &hif);
if (!hif)
return -ENOMEM;
int wfx_hif_remove_key(struct wfx_dev *wdev, int idx)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_remove_key *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_remove_key *body = wfx_alloc_hif(sizeof(*body), &hif);
if (!hif)
return -ENOMEM;
const struct ieee80211_tx_queue_params *arg)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_edca_queue_params *body = wfx_alloc_hif(sizeof(*body),
- &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_edca_queue_params *body = wfx_alloc_hif(sizeof(*body),
+ &hif);
if (!body)
return -ENOMEM;
int wfx_hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_set_pm_mode *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_set_pm_mode *body = wfx_alloc_hif(sizeof(*body),
+ &hif);
if (!body)
return -ENOMEM;
const struct ieee80211_channel *channel)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_start *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_start *body = wfx_alloc_hif(sizeof(*body), &hif);
WARN_ON(!conf->beacon_int);
if (!hif)
int wfx_hif_beacon_transmit(struct wfx_vif *wvif, bool enable)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_beacon_transmit *body = wfx_alloc_hif(sizeof(*body),
- &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_beacon_transmit *body = wfx_alloc_hif(sizeof(*body),
+ &hif);
if (!hif)
return -ENOMEM;
bool mfp)
{
int ret;
- struct hif_msg *hif;
- struct hif_req_map_link *body = wfx_alloc_hif(sizeof(*body), &hif);
+ struct wfx_hif_msg *hif;
+ struct wfx_hif_req_map_link *body = wfx_alloc_hif(sizeof(*body), &hif);
if (!hif)
return -ENOMEM;
const u8 *ies, size_t ies_len)
{
int ret;
- struct hif_msg *hif;
- int buf_len = sizeof(struct hif_req_update_ie) + ies_len;
- struct hif_req_update_ie *body = wfx_alloc_hif(buf_len, &hif);
+ struct wfx_hif_msg *hif;
+ int buf_len = sizeof(struct wfx_hif_req_update_ie) + ies_len;
+ struct wfx_hif_req_update_ie *body = wfx_alloc_hif(buf_len, &hif);
if (!hif)
return -ENOMEM;
struct ieee80211_bss_conf;
struct ieee80211_tx_queue_params;
struct cfg80211_scan_request;
-struct hif_req_add_key;
+struct wfx_hif_req_add_key;
struct wfx_dev;
struct wfx_vif;
struct wfx_hif_cmd {
- struct mutex lock;
- struct completion ready;
- struct completion done;
- struct hif_msg *buf_send;
- void *buf_recv;
- size_t len_recv;
- int ret;
+ struct mutex lock;
+ struct completion ready;
+ struct completion done;
+ struct wfx_hif_msg *buf_send;
+ void *buf_recv;
+ size_t len_recv;
+ int ret;
};
void wfx_init_hif_cmd(struct wfx_hif_cmd *wfx_hif_cmd);
-int wfx_cmd_send(struct wfx_dev *wdev, struct hif_msg *request,
+int wfx_cmd_send(struct wfx_dev *wdev, struct wfx_hif_msg *request,
void *reply, size_t reply_len, bool async);
int wfx_hif_read_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id,
struct ieee80211_channel *channel, const u8 *ssid, int ssidlen);
int wfx_hif_map_link(struct wfx_vif *wvif,
bool unmap, u8 *mac_addr, int sta_id, bool mfp);
-int wfx_hif_add_key(struct wfx_dev *wdev, const struct hif_req_add_key *arg);
+int wfx_hif_add_key(struct wfx_dev *wdev, const struct wfx_hif_req_add_key *arg);
int wfx_hif_remove_key(struct wfx_dev *wdev, int idx);
int wfx_hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);
int wfx_hif_set_bss_params(struct wfx_vif *wvif, int aid, int beacon_lost_count);
int wfx_hif_set_output_power(struct wfx_vif *wvif, int val)
{
- struct hif_mib_current_tx_power_level arg = {
+ struct wfx_hif_mib_current_tx_power_level arg = {
.power_level = cpu_to_le32(val * 10),
};
unsigned int dtim_interval,
unsigned int listen_interval)
{
- struct hif_mib_beacon_wake_up_period arg = {
+ struct wfx_hif_mib_beacon_wake_up_period arg = {
.wakeup_period_min = dtim_interval,
.receive_dtim = 0,
.wakeup_period_max = listen_interval,
int wfx_hif_set_rcpi_rssi_threshold(struct wfx_vif *wvif,
int rssi_thold, int rssi_hyst)
{
- struct hif_mib_rcpi_rssi_threshold arg = {
+ struct wfx_hif_mib_rcpi_rssi_threshold arg = {
.rolling_average_count = 8,
.detection = 1,
};
}
int wfx_hif_get_counters_table(struct wfx_dev *wdev, int vif_id,
- struct hif_mib_extended_count_table *arg)
+ struct wfx_hif_mib_extended_count_table *arg)
{
if (wfx_api_older_than(wdev, 1, 3)) {
/* extended_count_table is wider than count_table */
memset(arg, 0xFF, sizeof(*arg));
return wfx_hif_read_mib(wdev, vif_id, HIF_MIB_ID_COUNTERS_TABLE,
- arg, sizeof(struct hif_mib_count_table));
+ arg, sizeof(struct wfx_hif_mib_count_table));
} else {
return wfx_hif_read_mib(wdev, vif_id,
HIF_MIB_ID_EXTENDED_COUNTERS_TABLE, arg,
- sizeof(struct hif_mib_extended_count_table));
+ sizeof(struct wfx_hif_mib_extended_count_table));
}
}
int wfx_hif_set_macaddr(struct wfx_vif *wvif, u8 *mac)
{
- struct hif_mib_mac_address arg = { };
+ struct wfx_hif_mib_mac_address arg = { };
if (mac)
ether_addr_copy(arg.mac_addr, mac);
int wfx_hif_set_rx_filter(struct wfx_vif *wvif,
bool filter_bssid, bool filter_prbreq)
{
- struct hif_mib_rx_filter arg = { };
+ struct wfx_hif_mib_rx_filter arg = { };
if (filter_bssid)
arg.bssid_filter = 1;
}
int wfx_hif_set_beacon_filter_table(struct wfx_vif *wvif, int tbl_len,
- const struct hif_ie_table_entry *tbl)
+ const struct wfx_hif_ie_table_entry *tbl)
{
int ret;
- struct hif_mib_bcn_filter_table *arg;
+ struct wfx_hif_mib_bcn_filter_table *arg;
int buf_len = struct_size(arg, ie_table, tbl_len);
arg = kzalloc(buf_len, GFP_KERNEL);
int wfx_hif_beacon_filter_control(struct wfx_vif *wvif,
int enable, int beacon_count)
{
- struct hif_mib_bcn_filter_enable arg = {
+ struct wfx_hif_mib_bcn_filter_enable arg = {
.enable = cpu_to_le32(enable),
.bcn_count = cpu_to_le32(beacon_count),
};
}
int wfx_hif_set_operational_mode(struct wfx_dev *wdev,
- enum hif_op_power_mode mode)
+ enum wfx_hif_op_power_mode mode)
{
- struct hif_mib_gl_operational_power_mode arg = {
+ struct wfx_hif_mib_gl_operational_power_mode arg = {
.power_mode = mode,
.wup_ind_activation = 1,
};
int wfx_hif_set_template_frame(struct wfx_vif *wvif, struct sk_buff *skb,
u8 frame_type, int init_rate)
{
- struct hif_mib_template_frame *arg;
+ struct wfx_hif_mib_template_frame *arg;
WARN(skb->len > HIF_API_MAX_TEMPLATE_FRAME_SIZE, "frame is too big");
skb_push(skb, 4);
- arg = (struct hif_mib_template_frame *)skb->data;
+ arg = (struct wfx_hif_mib_template_frame *)skb->data;
skb_pull(skb, 4);
arg->init_rate = init_rate;
arg->frame_type = frame_type;
int wfx_hif_set_mfp(struct wfx_vif *wvif, bool capable, bool required)
{
- struct hif_mib_protected_mgmt_policy arg = { };
+ struct wfx_hif_mib_protected_mgmt_policy arg = { };
WARN(required && !capable, "incoherent arguments");
if (capable) {
int wfx_hif_set_block_ack_policy(struct wfx_vif *wvif,
u8 tx_tid_policy, u8 rx_tid_policy)
{
- struct hif_mib_block_ack_policy arg = {
+ struct wfx_hif_mib_block_ack_policy arg = {
.block_ack_tx_tid_policy = tx_tid_policy,
.block_ack_rx_tid_policy = rx_tid_policy,
};
int wfx_hif_set_association_mode(struct wfx_vif *wvif, int ampdu_density,
bool greenfield, bool short_preamble)
{
- struct hif_mib_set_association_mode arg = {
+ struct wfx_hif_mib_set_association_mode arg = {
.preambtype_use = 1,
.mode = 1,
.spacing = 1,
int wfx_hif_set_tx_rate_retry_policy(struct wfx_vif *wvif,
int policy_index, u8 *rates)
{
- struct hif_mib_set_tx_rate_retry_policy *arg;
+ struct wfx_hif_mib_set_tx_rate_retry_policy *arg;
size_t size = struct_size(arg, tx_rate_retry_policy, 1);
int ret;
int wfx_hif_keep_alive_period(struct wfx_vif *wvif, int period)
{
- struct hif_mib_keep_alive_period arg = {
+ struct wfx_hif_mib_keep_alive_period arg = {
.keep_alive_period = cpu_to_le16(period),
};
int wfx_hif_set_arp_ipv4_filter(struct wfx_vif *wvif, int idx, __be32 *addr)
{
- struct hif_mib_arp_ip_addr_table arg = {
+ struct wfx_hif_mib_arp_ip_addr_table arg = {
.condition_idx = idx,
.arp_enable = HIF_ARP_NS_FILTERING_DISABLE,
};
int wfx_hif_use_multi_tx_conf(struct wfx_dev *wdev, bool enable)
{
- struct hif_mib_gl_set_multi_msg arg = {
+ struct wfx_hif_mib_gl_set_multi_msg arg = {
.enable_multi_tx_conf = enable,
};
int wfx_hif_set_uapsd_info(struct wfx_vif *wvif, unsigned long val)
{
- struct hif_mib_set_uapsd_information arg = { };
+ struct wfx_hif_mib_set_uapsd_information arg = { };
if (val & BIT(IEEE80211_AC_VO))
arg.trig_voice = 1;
int wfx_hif_erp_use_protection(struct wfx_vif *wvif, bool enable)
{
- struct hif_mib_non_erp_protection arg = {
+ struct wfx_hif_mib_non_erp_protection arg = {
.use_cts_to_self = enable,
};
int wfx_hif_slot_time(struct wfx_vif *wvif, int val)
{
- struct hif_mib_slot_time arg = {
+ struct wfx_hif_mib_slot_time arg = {
.slot_time = cpu_to_le32(val),
};
int wfx_hif_wep_default_key_id(struct wfx_vif *wvif, int val)
{
- struct hif_mib_wep_default_key_id arg = {
+ struct wfx_hif_mib_wep_default_key_id arg = {
.wep_default_key_id = val,
};
int wfx_hif_rts_threshold(struct wfx_vif *wvif, int val)
{
- struct hif_mib_dot11_rts_threshold arg = {
+ struct wfx_hif_mib_dot11_rts_threshold arg = {
.threshold = cpu_to_le32(val >= 0 ? val : 0xFFFF),
};
struct sk_buff;
struct wfx_vif;
struct wfx_dev;
-struct hif_ie_table_entry;
-struct hif_mib_extended_count_table;
+struct wfx_hif_ie_table_entry;
+struct wfx_hif_mib_extended_count_table;
int wfx_hif_set_output_power(struct wfx_vif *wvif, int val);
int wfx_hif_set_beacon_wakeup_period(struct wfx_vif *wvif,
int wfx_hif_set_rcpi_rssi_threshold(struct wfx_vif *wvif,
int rssi_thold, int rssi_hyst);
int wfx_hif_get_counters_table(struct wfx_dev *wdev, int vif_id,
- struct hif_mib_extended_count_table *arg);
+ struct wfx_hif_mib_extended_count_table *arg);
int wfx_hif_set_macaddr(struct wfx_vif *wvif, u8 *mac);
int wfx_hif_set_rx_filter(struct wfx_vif *wvif,
bool filter_bssid, bool fwd_probe_req);
int wfx_hif_set_beacon_filter_table(struct wfx_vif *wvif, int tbl_len,
- const struct hif_ie_table_entry *tbl);
+ const struct wfx_hif_ie_table_entry *tbl);
int wfx_hif_beacon_filter_control(struct wfx_vif *wvif,
int enable, int beacon_count);
int wfx_hif_set_operational_mode(struct wfx_dev *wdev,
- enum hif_op_power_mode mode);
+ enum wfx_hif_op_power_mode mode);
int wfx_hif_set_template_frame(struct wfx_vif *wvif, struct sk_buff *skb,
u8 frame_type, int init_rate);
int wfx_hif_set_mfp(struct wfx_vif *wvif, bool capable, bool required);
wdev->key_map &= ~BIT(idx);
}
-static u8 fill_wep_pair(struct hif_wep_pairwise_key *msg,
+static u8 fill_wep_pair(struct wfx_hif_wep_pairwise_key *msg,
struct ieee80211_key_conf *key, u8 *peer_addr)
{
WARN(key->keylen > sizeof(msg->key_data), "inconsistent data");
return HIF_KEY_TYPE_WEP_PAIRWISE;
}
-static u8 fill_wep_group(struct hif_wep_group_key *msg,
+static u8 fill_wep_group(struct wfx_hif_wep_group_key *msg,
struct ieee80211_key_conf *key)
{
WARN(key->keylen > sizeof(msg->key_data), "inconsistent data");
return HIF_KEY_TYPE_WEP_DEFAULT;
}
-static u8 fill_tkip_pair(struct hif_tkip_pairwise_key *msg,
+static u8 fill_tkip_pair(struct wfx_hif_tkip_pairwise_key *msg,
struct ieee80211_key_conf *key, u8 *peer_addr)
{
u8 *keybuf = key->key;
return HIF_KEY_TYPE_TKIP_PAIRWISE;
}
-static u8 fill_tkip_group(struct hif_tkip_group_key *msg,
+static u8 fill_tkip_group(struct wfx_hif_tkip_group_key *msg,
struct ieee80211_key_conf *key,
struct ieee80211_key_seq *seq,
enum nl80211_iftype iftype)
return HIF_KEY_TYPE_TKIP_GROUP;
}
-static u8 fill_ccmp_pair(struct hif_aes_pairwise_key *msg,
+static u8 fill_ccmp_pair(struct wfx_hif_aes_pairwise_key *msg,
struct ieee80211_key_conf *key, u8 *peer_addr)
{
WARN(key->keylen != sizeof(msg->aes_key_data), "inconsistent data");
return HIF_KEY_TYPE_AES_PAIRWISE;
}
-static u8 fill_ccmp_group(struct hif_aes_group_key *msg,
+static u8 fill_ccmp_group(struct wfx_hif_aes_group_key *msg,
struct ieee80211_key_conf *key,
struct ieee80211_key_seq *seq)
{
return HIF_KEY_TYPE_AES_GROUP;
}
-static u8 fill_sms4_pair(struct hif_wapi_pairwise_key *msg,
+static u8 fill_sms4_pair(struct wfx_hif_wapi_pairwise_key *msg,
struct ieee80211_key_conf *key, u8 *peer_addr)
{
u8 *keybuf = key->key;
return HIF_KEY_TYPE_WAPI_PAIRWISE;
}
-static u8 fill_sms4_group(struct hif_wapi_group_key *msg,
+static u8 fill_sms4_group(struct wfx_hif_wapi_group_key *msg,
struct ieee80211_key_conf *key)
{
u8 *keybuf = key->key;
return HIF_KEY_TYPE_WAPI_GROUP;
}
-static u8 fill_aes_cmac_group(struct hif_igtk_group_key *msg,
+static u8 fill_aes_cmac_group(struct wfx_hif_igtk_group_key *msg,
struct ieee80211_key_conf *key,
struct ieee80211_key_seq *seq)
{
struct ieee80211_key_conf *key)
{
int ret;
- struct hif_req_add_key k = { };
+ struct wfx_hif_req_add_key k = { };
struct ieee80211_key_seq seq;
struct wfx_dev *wdev = wvif->wdev;
int idx = wfx_alloc_key(wvif->wdev);
hw->queues = 4;
hw->max_rates = 8;
hw->max_rate_tries = 8;
- hw->extra_tx_headroom = sizeof(struct hif_msg)
- + sizeof(struct hif_req_tx)
+ hw->extra_tx_headroom = sizeof(struct wfx_hif_msg)
+ + sizeof(struct wfx_hif_req_tx)
+ 4 /* alignment */ + 8 /* TKIP IV */;
hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
BIT(NL80211_IFTYPE_ADHOC) |
{
struct wfx_queue *queue;
struct wfx_vif *wvif;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
struct sk_buff *skb;
WARN(!wdev->chip_frozen, "%s should only be used to recover a frozen device",
__func__);
while ((skb = skb_dequeue(&wdev->tx_pending)) != NULL) {
- hif = (struct hif_msg *)skb->data;
+ hif = (struct wfx_hif_msg *)skb->data;
wvif = wdev_to_wvif(wdev, hif->interface);
if (wvif) {
queue = &wvif->tx_queue[skb_get_queue_mapping(skb)];
struct sk_buff *wfx_pending_get(struct wfx_dev *wdev, u32 packet_id)
{
struct wfx_queue *queue;
- struct hif_req_tx *req;
+ struct wfx_hif_req_tx *req;
struct wfx_vif *wvif;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
struct sk_buff *skb;
spin_lock_bh(&wdev->tx_pending.lock);
skb_queue_walk(&wdev->tx_pending, skb) {
- hif = (struct hif_msg *)skb->data;
- req = (struct hif_req_tx *)hif->body;
+ hif = (struct wfx_hif_msg *)skb->data;
+ req = (struct wfx_hif_req_tx *)hif->body;
if (req->packet_id != packet_id)
continue;
spin_unlock_bh(&wdev->tx_pending.lock);
{
ktime_t now = ktime_get();
struct wfx_tx_priv *tx_priv;
- struct hif_req_tx *req;
+ struct wfx_hif_req_tx *req;
struct sk_buff *skb;
bool first = true;
struct wfx_queue *queues[IEEE80211_NUM_ACS * ARRAY_SIZE(wdev->vif)];
int i, j, num_queues = 0;
struct wfx_vif *wvif;
- struct hif_msg *hif;
+ struct wfx_hif_msg *hif;
struct sk_buff *skb;
/* sort the queues */
* and only one vif can be AP, all queued frames has
* same interface id
*/
- hif = (struct hif_msg *)skb->data;
+ hif = (struct wfx_hif_msg *)skb->data;
WARN_ON(hif->interface != wvif->id);
WARN_ON(queues[i] !=
&wvif->tx_queue[skb_get_queue_mapping(skb)]);
return NULL;
}
-struct hif_msg *wfx_tx_queues_get(struct wfx_dev *wdev)
+struct wfx_hif_msg *wfx_tx_queues_get(struct wfx_dev *wdev)
{
struct wfx_tx_priv *tx_priv;
struct sk_buff *skb;
wake_up(&wdev->tx_dequeue);
tx_priv = wfx_skb_tx_priv(skb);
tx_priv->xmit_timestamp = ktime_get();
- return (struct hif_msg *)skb->data;
+ return (struct wfx_hif_msg *)skb->data;
}
void wfx_tx_queues_check_empty(struct wfx_vif *wvif);
bool wfx_tx_queues_has_cab(struct wfx_vif *wvif);
void wfx_tx_queues_put(struct wfx_vif *wvif, struct sk_buff *skb);
-struct hif_msg *wfx_tx_queues_get(struct wfx_dev *wdev);
+struct wfx_hif_msg *wfx_tx_queues_get(struct wfx_dev *wdev);
bool wfx_tx_queue_empty(struct wfx_vif *wvif, struct wfx_queue *queue);
void wfx_tx_queue_drop(struct wfx_vif *wvif, struct wfx_queue *queue,
static void wfx_filter_beacon(struct wfx_vif *wvif, bool filter_beacon)
{
- static const struct hif_ie_table_entry filter_ies[] = {
+ static const struct wfx_hif_ie_table_entry filter_ies[] = {
{
.ie_id = WLAN_EID_VENDOR_SPECIFIC,
.has_changed = 1,
#define hif_mib_list hif_mib_list_enum { -1, NULL }
DECLARE_EVENT_CLASS(hif_data,
- TP_PROTO(const struct hif_msg *hif, int tx_fill_level, bool is_recv),
+ TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
TP_ARGS(hif, tx_fill_level, is_recv),
TP_STRUCT__entry(
__field(int, tx_fill_level)
}
__entry->buf_len = min_t(int, __entry->msg_len,
sizeof(__entry->buf))
- - sizeof(struct hif_msg) - header_len;
+ - sizeof(struct wfx_hif_msg) - header_len;
memcpy(__entry->buf, hif->body + header_len, __entry->buf_len);
),
TP_printk("%d:%d:%s_%s%s%s: %s%s (%d bytes)",
)
);
DEFINE_EVENT(hif_data, hif_send,
- TP_PROTO(const struct hif_msg *hif, int tx_fill_level, bool is_recv),
+ TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
TP_ARGS(hif, tx_fill_level, is_recv));
#define _trace_hif_send(hif, tx_fill_level)\
trace_hif_send(hif, tx_fill_level, false)
DEFINE_EVENT(hif_data, hif_recv,
- TP_PROTO(const struct hif_msg *hif, int tx_fill_level, bool is_recv),
+ TP_PROTO(const struct wfx_hif_msg *hif, int tx_fill_level, bool is_recv),
TP_ARGS(hif, tx_fill_level, is_recv));
#define _trace_hif_recv(hif, tx_fill_level)\
trace_hif_recv(hif, tx_fill_level, true)
trace_bh_stats(ind, req, cnf, busy, release)
TRACE_EVENT(tx_stats,
- TP_PROTO(const struct hif_cnf_tx *tx_cnf, const struct sk_buff *skb,
+ TP_PROTO(const struct wfx_hif_cnf_tx *tx_cnf, const struct sk_buff *skb,
int delay),
TP_ARGS(tx_cnf, skb, delay),
TP_STRUCT__entry(
u8 keyset;
struct completion firmware_ready;
- struct hif_ind_startup hw_caps;
+ struct wfx_hif_ind_startup hw_caps;
struct wfx_hif hif;
struct delayed_work cooling_timeout_work;
bool poll_irq;
atomic_t packet_id;
u32 key_map;
- struct hif_rx_stats rx_stats;
+ struct wfx_hif_rx_stats rx_stats;
struct mutex rx_stats_lock;
- struct hif_tx_power_loop_info tx_power_loop_info;
+ struct wfx_hif_tx_power_loop_info tx_power_loop_info;
struct mutex tx_power_loop_info_lock;
int force_ps_timeout;
};
projects / platform / kernel / linux-starfive.git / commitdiff