drivers/net/wireless/silabs/wfx/hif_tx_mib.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Implementation of the host-to-chip MIBs of the hardware API.
   4  *
   5  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
   6  * Copyright (c) 2010, ST-Ericsson
   7  * Copyright (C) 2010, ST-Ericsson SA
   8  */
   9
  10 #include <linux/etherdevice.h>
  11
  12 #include "wfx.h"
  13 #include "hif_tx.h"
  14 #include "hif_tx_mib.h"
  15 #include "hif_api_mib.h"
  16
  17 int wfx_hif_set_output_power(struct wfx_vif *wvif, int val)
  18 {
  19         struct wfx_hif_mib_current_tx_power_level arg = {
  20                 .power_level = cpu_to_le32(val * 10),
  21         };
  22
  23         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_CURRENT_TX_POWER_LEVEL,
  24                                  &arg, sizeof(arg));
  25 }
  26
  27 int wfx_hif_set_beacon_wakeup_period(struct wfx_vif *wvif,
  28                                      unsigned int dtim_interval, unsigned int listen_interval)
  29 {
  30         struct wfx_hif_mib_beacon_wake_up_period arg = {
  31                 .wakeup_period_min = dtim_interval,
  32                 .receive_dtim = 0,
  33                 .wakeup_period_max = listen_interval,
  34         };
  35
  36         if (dtim_interval > 0xFF || listen_interval > 0xFFFF)
  37                 return -EINVAL;
  38         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_BEACON_WAKEUP_PERIOD,
  39                                  &arg, sizeof(arg));
  40 }
  41
  42 int wfx_hif_set_rcpi_rssi_threshold(struct wfx_vif *wvif, int rssi_thold, int rssi_hyst)
  43 {
  44         struct wfx_hif_mib_rcpi_rssi_threshold arg = {
  45                 .rolling_average_count = 8,
  46                 .detection = 1,
  47         };
  48
  49         if (!rssi_thold && !rssi_hyst) {
  50                 arg.upperthresh = 1;
  51                 arg.lowerthresh = 1;
  52         } else {
  53                 arg.upper_threshold = rssi_thold + rssi_hyst;
  54                 arg.upper_threshold = (arg.upper_threshold + 110) * 2;
  55                 arg.lower_threshold = rssi_thold;
  56                 arg.lower_threshold = (arg.lower_threshold + 110) * 2;
  57         }
  58
  59         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_RCPI_RSSI_THRESHOLD,
  60                                  &arg, sizeof(arg));
  61 }
  62
  63 int wfx_hif_get_counters_table(struct wfx_dev *wdev, int vif_id,
  64                                struct wfx_hif_mib_extended_count_table *arg)
  65 {
  66         if (wfx_api_older_than(wdev, 1, 3)) {
  67                 /* extended_count_table is wider than count_table */
  68                 memset(arg, 0xFF, sizeof(*arg));
  69                 return wfx_hif_read_mib(wdev, vif_id, HIF_MIB_ID_COUNTERS_TABLE,
  70                                     arg, sizeof(struct wfx_hif_mib_count_table));
  71         } else {
  72                 return wfx_hif_read_mib(wdev, vif_id, HIF_MIB_ID_EXTENDED_COUNTERS_TABLE,
  73                                         arg, sizeof(struct wfx_hif_mib_extended_count_table));
  74         }
  75 }
  76
  77 int wfx_hif_set_macaddr(struct wfx_vif *wvif, u8 *mac)
  78 {
  79         struct wfx_hif_mib_mac_address arg = { };
  80
  81         if (mac)
  82                 ether_addr_copy(arg.mac_addr, mac);
  83         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_DOT11_MAC_ADDRESS,
  84                                  &arg, sizeof(arg));
  85 }
  86
  87 int wfx_hif_set_rx_filter(struct wfx_vif *wvif, bool filter_bssid, bool filter_prbreq)
  88 {
  89         struct wfx_hif_mib_rx_filter arg = { };
  90
  91         if (filter_bssid)
  92                 arg.bssid_filter = 1;
  93         if (!filter_prbreq)
  94                 arg.fwd_probe_req = 1;
  95         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_RX_FILTER, &arg, sizeof(arg));
  96 }
  97
  98 int wfx_hif_set_beacon_filter_table(struct wfx_vif *wvif, int tbl_len,
  99                                     const struct wfx_hif_ie_table_entry *tbl)
 100 {
 101         int ret;
 102         struct wfx_hif_mib_bcn_filter_table *arg;
 103         int buf_len = struct_size(arg, ie_table, tbl_len);
 104
 105         arg = kzalloc(buf_len, GFP_KERNEL);
 106         if (!arg)
 107                 return -ENOMEM;
 108         arg->num_of_info_elmts = cpu_to_le32(tbl_len);
 109         memcpy(arg->ie_table, tbl, flex_array_size(arg, ie_table, tbl_len));
 110         ret = wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_BEACON_FILTER_TABLE,
 111                                 arg, buf_len);
 112         kfree(arg);
 113         return ret;
 114 }
 115
 116 int wfx_hif_beacon_filter_control(struct wfx_vif *wvif, int enable, int beacon_count)
 117 {
 118         struct wfx_hif_mib_bcn_filter_enable arg = {
 119                 .enable = cpu_to_le32(enable),
 120                 .bcn_count = cpu_to_le32(beacon_count),
 121         };
 122         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_BEACON_FILTER_ENABLE,
 123                                  &arg, sizeof(arg));
 124 }
 125
 126 int wfx_hif_set_operational_mode(struct wfx_dev *wdev, enum wfx_hif_op_power_mode mode)
 127 {
 128         struct wfx_hif_mib_gl_operational_power_mode arg = {
 129                 .power_mode = mode,
 130                 .wup_ind_activation = 1,
 131         };
 132
 133         return wfx_hif_write_mib(wdev, -1, HIF_MIB_ID_GL_OPERATIONAL_POWER_MODE,
 134                                  &arg, sizeof(arg));
 135 }
 136
 137 int wfx_hif_set_template_frame(struct wfx_vif *wvif, struct sk_buff *skb,
 138                                u8 frame_type, int init_rate)
 139 {
 140         struct wfx_hif_mib_template_frame *arg;
 141
 142         WARN(skb->len > HIF_API_MAX_TEMPLATE_FRAME_SIZE, "frame is too big");
 143         skb_push(skb, 4);
 144         arg = (struct wfx_hif_mib_template_frame *)skb->data;
 145         skb_pull(skb, 4);
 146         arg->init_rate = init_rate;
 147         arg->frame_type = frame_type;
 148         arg->frame_length = cpu_to_le16(skb->len);
 149         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_TEMPLATE_FRAME,
 150                                  arg, sizeof(*arg) + skb->len);
 151 }
 152
 153 int wfx_hif_set_mfp(struct wfx_vif *wvif, bool capable, bool required)
 154 {
 155         struct wfx_hif_mib_protected_mgmt_policy arg = { };
 156
 157         WARN(required && !capable, "incoherent arguments");
 158         if (capable) {
 159                 arg.pmf_enable = 1;
 160                 arg.host_enc_auth_frames = 1;
 161         }
 162         if (!required)
 163                 arg.unpmf_allowed = 1;
 164         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_PROTECTED_MGMT_POLICY,
 165                                  &arg, sizeof(arg));
 166 }
 167
 168 int wfx_hif_set_block_ack_policy(struct wfx_vif *wvif, u8 tx_tid_policy, u8 rx_tid_policy)
 169 {
 170         struct wfx_hif_mib_block_ack_policy arg = {
 171                 .block_ack_tx_tid_policy = tx_tid_policy,
 172                 .block_ack_rx_tid_policy = rx_tid_policy,
 173         };
 174
 175         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_BLOCK_ACK_POLICY,
 176                                  &arg, sizeof(arg));
 177 }
 178
 179 int wfx_hif_set_association_mode(struct wfx_vif *wvif, int ampdu_density,
 180                                  bool greenfield, bool short_preamble)
 181 {
 182         struct wfx_hif_mib_set_association_mode arg = {
 183                 .preambtype_use = 1,
 184                 .mode = 1,
 185                 .spacing = 1,
 186                 .short_preamble = short_preamble,
 187                 .greenfield = greenfield,
 188                 .mpdu_start_spacing = ampdu_density,
 189         };
 190
 191         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_SET_ASSOCIATION_MODE,
 192                                  &arg, sizeof(arg));
 193 }
 194
 195 int wfx_hif_set_tx_rate_retry_policy(struct wfx_vif *wvif, int policy_index, u8 *rates)
 196 {
 197         struct wfx_hif_mib_set_tx_rate_retry_policy *arg;
 198         size_t size = struct_size(arg, tx_rate_retry_policy, 1);
 199         int ret;
 200
 201         arg = kzalloc(size, GFP_KERNEL);
 202         if (!arg)
 203                 return -ENOMEM;
 204         arg->num_tx_rate_policies = 1;
 205         arg->tx_rate_retry_policy[0].policy_index = policy_index;
 206         arg->tx_rate_retry_policy[0].short_retry_count = 255;
 207         arg->tx_rate_retry_policy[0].long_retry_count = 255;
 208         arg->tx_rate_retry_policy[0].first_rate_sel = 1;
 209         arg->tx_rate_retry_policy[0].terminate = 1;
 210         arg->tx_rate_retry_policy[0].count_init = 1;
 211         memcpy(&arg->tx_rate_retry_policy[0].rates, rates,
 212                sizeof(arg->tx_rate_retry_policy[0].rates));
 213         ret = wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_SET_TX_RATE_RETRY_POLICY,
 214                                 arg, size);
 215         kfree(arg);
 216         return ret;
 217 }
 218
 219 int wfx_hif_keep_alive_period(struct wfx_vif *wvif, int period)
 220 {
 221         struct wfx_hif_mib_keep_alive_period arg = {
 222                 .keep_alive_period = cpu_to_le16(period),
 223         };
 224
 225         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_KEEP_ALIVE_PERIOD,
 226                                  &arg, sizeof(arg));
 227 };
 228
 229 int wfx_hif_set_arp_ipv4_filter(struct wfx_vif *wvif, int idx, __be32 *addr)
 230 {
 231         struct wfx_hif_mib_arp_ip_addr_table arg = {
 232                 .condition_idx = idx,
 233                 .arp_enable = HIF_ARP_NS_FILTERING_DISABLE,
 234         };
 235
 236         if (addr) {
 237                 /* Caution: type of addr is __be32 */
 238                 memcpy(arg.ipv4_address, addr, sizeof(arg.ipv4_address));
 239                 arg.arp_enable = HIF_ARP_NS_FILTERING_ENABLE;
 240         }
 241         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_ARP_IP_ADDRESSES_TABLE,
 242                                  &arg, sizeof(arg));
 243 }
 244
 245 int wfx_hif_use_multi_tx_conf(struct wfx_dev *wdev, bool enable)
 246 {
 247         struct wfx_hif_mib_gl_set_multi_msg arg = {
 248                 .enable_multi_tx_conf = enable,
 249         };
 250
 251         return wfx_hif_write_mib(wdev, -1, HIF_MIB_ID_GL_SET_MULTI_MSG, &arg, sizeof(arg));
 252 }
 253
 254 int wfx_hif_set_uapsd_info(struct wfx_vif *wvif, unsigned long val)
 255 {
 256         struct wfx_hif_mib_set_uapsd_information arg = { };
 257
 258         if (val & BIT(IEEE80211_AC_VO))
 259                 arg.trig_voice = 1;
 260         if (val & BIT(IEEE80211_AC_VI))
 261                 arg.trig_video = 1;
 262         if (val & BIT(IEEE80211_AC_BE))
 263                 arg.trig_be = 1;
 264         if (val & BIT(IEEE80211_AC_BK))
 265                 arg.trig_bckgrnd = 1;
 266         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_SET_UAPSD_INFORMATION,
 267                                  &arg, sizeof(arg));
 268 }
 269
 270 int wfx_hif_erp_use_protection(struct wfx_vif *wvif, bool enable)
 271 {
 272         struct wfx_hif_mib_non_erp_protection arg = {
 273                 .use_cts_to_self = enable,
 274         };
 275
 276         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_NON_ERP_PROTECTION,
 277                                  &arg, sizeof(arg));
 278 }
 279
 280 int wfx_hif_slot_time(struct wfx_vif *wvif, int val)
 281 {
 282         struct wfx_hif_mib_slot_time arg = {
 283                 .slot_time = cpu_to_le32(val),
 284         };
 285
 286         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_SLOT_TIME, &arg, sizeof(arg));
 287 }
 288
 289 int wfx_hif_wep_default_key_id(struct wfx_vif *wvif, int val)
 290 {
 291         struct wfx_hif_mib_wep_default_key_id arg = {
 292                 .wep_default_key_id = val,
 293         };
 294
 295         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_DOT11_WEP_DEFAULT_KEY_ID,
 296                                  &arg, sizeof(arg));
 297 }
 298
 299 int wfx_hif_rts_threshold(struct wfx_vif *wvif, int val)
 300 {
 301         struct wfx_hif_mib_dot11_rts_threshold arg = {
 302                 .threshold = cpu_to_le32(val >= 0 ? val : 0xFFFF),
 303         };
 304
 305         return wfx_hif_write_mib(wvif->wdev, wvif->id, HIF_MIB_ID_DOT11_RTS_THRESHOLD,
 306                                  &arg, sizeof(arg));
 307 }