drivers/net/wireless/ath/ath10k/wmi-ops.h

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
   4  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #ifndef _WMI_OPS_H_
  20 #define _WMI_OPS_H_
  21
  22 struct ath10k;
  23 struct sk_buff;
  24
  25 struct wmi_ops {
  26         void (*rx)(struct ath10k *ar, struct sk_buff *skb);
  27         void (*map_svc)(const __le32 *in, unsigned long *out, size_t len);
  28         void (*map_svc_ext)(const __le32 *in, unsigned long *out, size_t len);
  29
  30         int (*pull_scan)(struct ath10k *ar, struct sk_buff *skb,
  31                          struct wmi_scan_ev_arg *arg);
  32         int (*pull_mgmt_rx)(struct ath10k *ar, struct sk_buff *skb,
  33                             struct wmi_mgmt_rx_ev_arg *arg);
  34         int (*pull_mgmt_tx_compl)(struct ath10k *ar, struct sk_buff *skb,
  35                                   struct wmi_tlv_mgmt_tx_compl_ev_arg *arg);
  36         int (*pull_mgmt_tx_bundle_compl)(
  37                                 struct ath10k *ar, struct sk_buff *skb,
  38                                 struct wmi_tlv_mgmt_tx_bundle_compl_ev_arg *arg);
  39         int (*pull_ch_info)(struct ath10k *ar, struct sk_buff *skb,
  40                             struct wmi_ch_info_ev_arg *arg);
  41         int (*pull_vdev_start)(struct ath10k *ar, struct sk_buff *skb,
  42                                struct wmi_vdev_start_ev_arg *arg);
  43         int (*pull_peer_kick)(struct ath10k *ar, struct sk_buff *skb,
  44                               struct wmi_peer_kick_ev_arg *arg);
  45         int (*pull_swba)(struct ath10k *ar, struct sk_buff *skb,
  46                          struct wmi_swba_ev_arg *arg);
  47         int (*pull_phyerr_hdr)(struct ath10k *ar, struct sk_buff *skb,
  48                                struct wmi_phyerr_hdr_arg *arg);
  49         int (*pull_phyerr)(struct ath10k *ar, const void *phyerr_buf,
  50                            int left_len, struct wmi_phyerr_ev_arg *arg);
  51         int (*pull_svc_rdy)(struct ath10k *ar, struct sk_buff *skb,
  52                             struct wmi_svc_rdy_ev_arg *arg);
  53         int (*pull_rdy)(struct ath10k *ar, struct sk_buff *skb,
  54                         struct wmi_rdy_ev_arg *arg);
  55         int (*pull_fw_stats)(struct ath10k *ar, struct sk_buff *skb,
  56                              struct ath10k_fw_stats *stats);
  57         int (*pull_roam_ev)(struct ath10k *ar, struct sk_buff *skb,
  58                             struct wmi_roam_ev_arg *arg);
  59         int (*pull_wow_event)(struct ath10k *ar, struct sk_buff *skb,
  60                               struct wmi_wow_ev_arg *arg);
  61         int (*pull_echo_ev)(struct ath10k *ar, struct sk_buff *skb,
  62                             struct wmi_echo_ev_arg *arg);
  63         int (*pull_dfs_status_ev)(struct ath10k *ar, struct sk_buff *skb,
  64                                   struct wmi_dfs_status_ev_arg *arg);
  65         int (*pull_svc_avail)(struct ath10k *ar, struct sk_buff *skb,
  66                               struct wmi_svc_avail_ev_arg *arg);
  67
  68         enum wmi_txbf_conf (*get_txbf_conf_scheme)(struct ath10k *ar);
  69
  70         struct sk_buff *(*gen_pdev_suspend)(struct ath10k *ar, u32 suspend_opt);
  71         struct sk_buff *(*gen_pdev_resume)(struct ath10k *ar);
  72         struct sk_buff *(*gen_pdev_set_base_macaddr)(struct ath10k *ar,
  73                                                      const u8 macaddr[ETH_ALEN]);
  74         struct sk_buff *(*gen_pdev_set_rd)(struct ath10k *ar, u16 rd, u16 rd2g,
  75                                            u16 rd5g, u16 ctl2g, u16 ctl5g,
  76                                            enum wmi_dfs_region dfs_reg);
  77         struct sk_buff *(*gen_pdev_set_param)(struct ath10k *ar, u32 id,
  78                                               u32 value);
  79         struct sk_buff *(*gen_init)(struct ath10k *ar);
  80         struct sk_buff *(*gen_start_scan)(struct ath10k *ar,
  81                                           const struct wmi_start_scan_arg *arg);
  82         struct sk_buff *(*gen_stop_scan)(struct ath10k *ar,
  83                                          const struct wmi_stop_scan_arg *arg);
  84         struct sk_buff *(*gen_vdev_create)(struct ath10k *ar, u32 vdev_id,
  85                                            enum wmi_vdev_type type,
  86                                            enum wmi_vdev_subtype subtype,
  87                                            const u8 macaddr[ETH_ALEN]);
  88         struct sk_buff *(*gen_vdev_delete)(struct ath10k *ar, u32 vdev_id);
  89         struct sk_buff *(*gen_vdev_start)(struct ath10k *ar,
  90                                           const struct wmi_vdev_start_request_arg *arg,
  91                                           bool restart);
  92         struct sk_buff *(*gen_vdev_stop)(struct ath10k *ar, u32 vdev_id);
  93         struct sk_buff *(*gen_vdev_up)(struct ath10k *ar, u32 vdev_id, u32 aid,
  94                                        const u8 *bssid);
  95         struct sk_buff *(*gen_vdev_down)(struct ath10k *ar, u32 vdev_id);
  96         struct sk_buff *(*gen_vdev_set_param)(struct ath10k *ar, u32 vdev_id,
  97                                               u32 param_id, u32 param_value);
  98         struct sk_buff *(*gen_vdev_install_key)(struct ath10k *ar,
  99                                                 const struct wmi_vdev_install_key_arg *arg);
 100         struct sk_buff *(*gen_vdev_spectral_conf)(struct ath10k *ar,
 101                                                   const struct wmi_vdev_spectral_conf_arg *arg);
 102         struct sk_buff *(*gen_vdev_spectral_enable)(struct ath10k *ar, u32 vdev_id,
 103                                                     u32 trigger, u32 enable);
 104         struct sk_buff *(*gen_vdev_wmm_conf)(struct ath10k *ar, u32 vdev_id,
 105                                              const struct wmi_wmm_params_all_arg *arg);
 106         struct sk_buff *(*gen_peer_create)(struct ath10k *ar, u32 vdev_id,
 107                                            const u8 peer_addr[ETH_ALEN],
 108                                            enum wmi_peer_type peer_type);
 109         struct sk_buff *(*gen_peer_delete)(struct ath10k *ar, u32 vdev_id,
 110                                            const u8 peer_addr[ETH_ALEN]);
 111         struct sk_buff *(*gen_peer_flush)(struct ath10k *ar, u32 vdev_id,
 112                                           const u8 peer_addr[ETH_ALEN],
 113                                           u32 tid_bitmap);
 114         struct sk_buff *(*gen_peer_set_param)(struct ath10k *ar, u32 vdev_id,
 115                                               const u8 *peer_addr,
 116                                               enum wmi_peer_param param_id,
 117                                               u32 param_value);
 118         struct sk_buff *(*gen_peer_assoc)(struct ath10k *ar,
 119                                           const struct wmi_peer_assoc_complete_arg *arg);
 120         struct sk_buff *(*gen_set_psmode)(struct ath10k *ar, u32 vdev_id,
 121                                           enum wmi_sta_ps_mode psmode);
 122         struct sk_buff *(*gen_set_sta_ps)(struct ath10k *ar, u32 vdev_id,
 123                                           enum wmi_sta_powersave_param param_id,
 124                                           u32 value);
 125         struct sk_buff *(*gen_set_ap_ps)(struct ath10k *ar, u32 vdev_id,
 126                                          const u8 *mac,
 127                                          enum wmi_ap_ps_peer_param param_id,
 128                                          u32 value);
 129         struct sk_buff *(*gen_scan_chan_list)(struct ath10k *ar,
 130                                               const struct wmi_scan_chan_list_arg *arg);
 131         struct sk_buff *(*gen_scan_prob_req_oui)(struct ath10k *ar,
 132                                                  u32 prob_req_oui);
 133         struct sk_buff *(*gen_beacon_dma)(struct ath10k *ar, u32 vdev_id,
 134                                           const void *bcn, size_t bcn_len,
 135                                           u32 bcn_paddr, bool dtim_zero,
 136                                           bool deliver_cab);
 137         struct sk_buff *(*gen_pdev_set_wmm)(struct ath10k *ar,
 138                                             const struct wmi_wmm_params_all_arg *arg);
 139         struct sk_buff *(*gen_request_stats)(struct ath10k *ar, u32 stats_mask);
 140         struct sk_buff *(*gen_force_fw_hang)(struct ath10k *ar,
 141                                              enum wmi_force_fw_hang_type type,
 142                                              u32 delay_ms);
 143         struct sk_buff *(*gen_mgmt_tx)(struct ath10k *ar, struct sk_buff *skb);
 144         struct sk_buff *(*gen_mgmt_tx_send)(struct ath10k *ar,
 145                                             struct sk_buff *skb,
 146                                             dma_addr_t paddr);
 147         struct sk_buff *(*gen_dbglog_cfg)(struct ath10k *ar, u64 module_enable,
 148                                           u32 log_level);
 149         struct sk_buff *(*gen_pktlog_enable)(struct ath10k *ar, u32 filter);
 150         struct sk_buff *(*gen_pktlog_disable)(struct ath10k *ar);
 151         struct sk_buff *(*gen_pdev_set_quiet_mode)(struct ath10k *ar,
 152                                                    u32 period, u32 duration,
 153                                                    u32 next_offset,
 154                                                    u32 enabled);
 155         struct sk_buff *(*gen_pdev_get_temperature)(struct ath10k *ar);
 156         struct sk_buff *(*gen_addba_clear_resp)(struct ath10k *ar, u32 vdev_id,
 157                                                 const u8 *mac);
 158         struct sk_buff *(*gen_addba_send)(struct ath10k *ar, u32 vdev_id,
 159                                           const u8 *mac, u32 tid, u32 buf_size);
 160         struct sk_buff *(*gen_addba_set_resp)(struct ath10k *ar, u32 vdev_id,
 161                                               const u8 *mac, u32 tid,
 162                                               u32 status);
 163         struct sk_buff *(*gen_delba_send)(struct ath10k *ar, u32 vdev_id,
 164                                           const u8 *mac, u32 tid, u32 initiator,
 165                                           u32 reason);
 166         struct sk_buff *(*gen_bcn_tmpl)(struct ath10k *ar, u32 vdev_id,
 167                                         u32 tim_ie_offset, struct sk_buff *bcn,
 168                                         u32 prb_caps, u32 prb_erp,
 169                                         void *prb_ies, size_t prb_ies_len);
 170         struct sk_buff *(*gen_prb_tmpl)(struct ath10k *ar, u32 vdev_id,
 171                                         struct sk_buff *bcn);
 172         struct sk_buff *(*gen_p2p_go_bcn_ie)(struct ath10k *ar, u32 vdev_id,
 173                                              const u8 *p2p_ie);
 174         struct sk_buff *(*gen_vdev_sta_uapsd)(struct ath10k *ar, u32 vdev_id,
 175                                               const u8 peer_addr[ETH_ALEN],
 176                                               const struct wmi_sta_uapsd_auto_trig_arg *args,
 177                                               u32 num_ac);
 178         struct sk_buff *(*gen_sta_keepalive)(struct ath10k *ar,
 179                                              const struct wmi_sta_keepalive_arg *arg);
 180         struct sk_buff *(*gen_wow_enable)(struct ath10k *ar);
 181         struct sk_buff *(*gen_wow_add_wakeup_event)(struct ath10k *ar, u32 vdev_id,
 182                                                     enum wmi_wow_wakeup_event event,
 183                                                     u32 enable);
 184         struct sk_buff *(*gen_wow_host_wakeup_ind)(struct ath10k *ar);
 185         struct sk_buff *(*gen_wow_add_pattern)(struct ath10k *ar, u32 vdev_id,
 186                                                u32 pattern_id,
 187                                                const u8 *pattern,
 188                                                const u8 *mask,
 189                                                int pattern_len,
 190                                                int pattern_offset);
 191         struct sk_buff *(*gen_wow_del_pattern)(struct ath10k *ar, u32 vdev_id,
 192                                                u32 pattern_id);
 193         struct sk_buff *(*gen_update_fw_tdls_state)(struct ath10k *ar,
 194                                                     u32 vdev_id,
 195                                                     enum wmi_tdls_state state);
 196         struct sk_buff *(*gen_tdls_peer_update)(struct ath10k *ar,
 197                                                 const struct wmi_tdls_peer_update_cmd_arg *arg,
 198                                                 const struct wmi_tdls_peer_capab_arg *cap,
 199                                                 const struct wmi_channel_arg *chan);
 200         struct sk_buff *(*gen_radar_found)
 201                         (struct ath10k *ar,
 202                          const struct ath10k_radar_found_info *arg);
 203         struct sk_buff *(*gen_adaptive_qcs)(struct ath10k *ar, bool enable);
 204         struct sk_buff *(*gen_pdev_get_tpc_config)(struct ath10k *ar,
 205                                                    u32 param);
 206         void (*fw_stats_fill)(struct ath10k *ar,
 207                               struct ath10k_fw_stats *fw_stats,
 208                               char *buf);
 209         struct sk_buff *(*gen_pdev_enable_adaptive_cca)(struct ath10k *ar,
 210                                                         u8 enable,
 211                                                         u32 detect_level,
 212                                                         u32 detect_margin);
 213         struct sk_buff *(*ext_resource_config)(struct ath10k *ar,
 214                                                enum wmi_host_platform_type type,
 215                                                u32 fw_feature_bitmap);
 216         int (*get_vdev_subtype)(struct ath10k *ar,
 217                                 enum wmi_vdev_subtype subtype);
 218         struct sk_buff *(*gen_wow_config_pno)(struct ath10k *ar,
 219                                               u32 vdev_id,
 220                                               struct wmi_pno_scan_req *pno_scan);
 221         struct sk_buff *(*gen_pdev_bss_chan_info_req)
 222                                         (struct ath10k *ar,
 223                                          enum wmi_bss_survey_req_type type);
 224         struct sk_buff *(*gen_echo)(struct ath10k *ar, u32 value);
 225         struct sk_buff *(*gen_pdev_get_tpc_table_cmdid)(struct ath10k *ar,
 226                                                         u32 param);
 227         struct sk_buff *(*gen_bb_timing)
 228                         (struct ath10k *ar,
 229                          const struct wmi_bb_timing_cfg_arg *arg);
 230
 231 };
 232
 233 int ath10k_wmi_cmd_send(struct ath10k *ar, struct sk_buff *skb, u32 cmd_id);
 234
 235 static inline int
 236 ath10k_wmi_rx(struct ath10k *ar, struct sk_buff *skb)
 237 {
 238         if (WARN_ON_ONCE(!ar->wmi.ops->rx))
 239                 return -EOPNOTSUPP;
 240
 241         ar->wmi.ops->rx(ar, skb);
 242         return 0;
 243 }
 244
 245 static inline int
 246 ath10k_wmi_map_svc(struct ath10k *ar, const __le32 *in, unsigned long *out,
 247                    size_t len)
 248 {
 249         if (!ar->wmi.ops->map_svc)
 250                 return -EOPNOTSUPP;
 251
 252         ar->wmi.ops->map_svc(in, out, len);
 253         return 0;
 254 }
 255
 256 static inline int
 257 ath10k_wmi_map_svc_ext(struct ath10k *ar, const __le32 *in, unsigned long *out,
 258                        size_t len)
 259 {
 260         if (!ar->wmi.ops->map_svc_ext)
 261                 return -EOPNOTSUPP;
 262
 263         ar->wmi.ops->map_svc_ext(in, out, len);
 264         return 0;
 265 }
 266
 267 static inline int
 268 ath10k_wmi_pull_scan(struct ath10k *ar, struct sk_buff *skb,
 269                      struct wmi_scan_ev_arg *arg)
 270 {
 271         if (!ar->wmi.ops->pull_scan)
 272                 return -EOPNOTSUPP;
 273
 274         return ar->wmi.ops->pull_scan(ar, skb, arg);
 275 }
 276
 277 static inline int
 278 ath10k_wmi_pull_mgmt_tx_compl(struct ath10k *ar, struct sk_buff *skb,
 279                               struct wmi_tlv_mgmt_tx_compl_ev_arg *arg)
 280 {
 281         if (!ar->wmi.ops->pull_mgmt_tx_compl)
 282                 return -EOPNOTSUPP;
 283
 284         return ar->wmi.ops->pull_mgmt_tx_compl(ar, skb, arg);
 285 }
 286
 287 static inline int
 288 ath10k_wmi_pull_mgmt_tx_bundle_compl(struct ath10k *ar, struct sk_buff *skb,
 289                                      struct wmi_tlv_mgmt_tx_bundle_compl_ev_arg *arg)
 290 {
 291         if (!ar->wmi.ops->pull_mgmt_tx_bundle_compl)
 292                 return -EOPNOTSUPP;
 293
 294         return ar->wmi.ops->pull_mgmt_tx_bundle_compl(ar, skb, arg);
 295 }
 296
 297 static inline int
 298 ath10k_wmi_pull_mgmt_rx(struct ath10k *ar, struct sk_buff *skb,
 299                         struct wmi_mgmt_rx_ev_arg *arg)
 300 {
 301         if (!ar->wmi.ops->pull_mgmt_rx)
 302                 return -EOPNOTSUPP;
 303
 304         return ar->wmi.ops->pull_mgmt_rx(ar, skb, arg);
 305 }
 306
 307 static inline int
 308 ath10k_wmi_pull_ch_info(struct ath10k *ar, struct sk_buff *skb,
 309                         struct wmi_ch_info_ev_arg *arg)
 310 {
 311         if (!ar->wmi.ops->pull_ch_info)
 312                 return -EOPNOTSUPP;
 313
 314         return ar->wmi.ops->pull_ch_info(ar, skb, arg);
 315 }
 316
 317 static inline int
 318 ath10k_wmi_pull_vdev_start(struct ath10k *ar, struct sk_buff *skb,
 319                            struct wmi_vdev_start_ev_arg *arg)
 320 {
 321         if (!ar->wmi.ops->pull_vdev_start)
 322                 return -EOPNOTSUPP;
 323
 324         return ar->wmi.ops->pull_vdev_start(ar, skb, arg);
 325 }
 326
 327 static inline int
 328 ath10k_wmi_pull_peer_kick(struct ath10k *ar, struct sk_buff *skb,
 329                           struct wmi_peer_kick_ev_arg *arg)
 330 {
 331         if (!ar->wmi.ops->pull_peer_kick)
 332                 return -EOPNOTSUPP;
 333
 334         return ar->wmi.ops->pull_peer_kick(ar, skb, arg);
 335 }
 336
 337 static inline int
 338 ath10k_wmi_pull_swba(struct ath10k *ar, struct sk_buff *skb,
 339                      struct wmi_swba_ev_arg *arg)
 340 {
 341         if (!ar->wmi.ops->pull_swba)
 342                 return -EOPNOTSUPP;
 343
 344         return ar->wmi.ops->pull_swba(ar, skb, arg);
 345 }
 346
 347 static inline int
 348 ath10k_wmi_pull_phyerr_hdr(struct ath10k *ar, struct sk_buff *skb,
 349                            struct wmi_phyerr_hdr_arg *arg)
 350 {
 351         if (!ar->wmi.ops->pull_phyerr_hdr)
 352                 return -EOPNOTSUPP;
 353
 354         return ar->wmi.ops->pull_phyerr_hdr(ar, skb, arg);
 355 }
 356
 357 static inline int
 358 ath10k_wmi_pull_phyerr(struct ath10k *ar, const void *phyerr_buf,
 359                        int left_len, struct wmi_phyerr_ev_arg *arg)
 360 {
 361         if (!ar->wmi.ops->pull_phyerr)
 362                 return -EOPNOTSUPP;
 363
 364         return ar->wmi.ops->pull_phyerr(ar, phyerr_buf, left_len, arg);
 365 }
 366
 367 static inline int
 368 ath10k_wmi_pull_svc_rdy(struct ath10k *ar, struct sk_buff *skb,
 369                         struct wmi_svc_rdy_ev_arg *arg)
 370 {
 371         if (!ar->wmi.ops->pull_svc_rdy)
 372                 return -EOPNOTSUPP;
 373
 374         return ar->wmi.ops->pull_svc_rdy(ar, skb, arg);
 375 }
 376
 377 static inline int
 378 ath10k_wmi_pull_rdy(struct ath10k *ar, struct sk_buff *skb,
 379                     struct wmi_rdy_ev_arg *arg)
 380 {
 381         if (!ar->wmi.ops->pull_rdy)
 382                 return -EOPNOTSUPP;
 383
 384         return ar->wmi.ops->pull_rdy(ar, skb, arg);
 385 }
 386
 387 static inline int
 388 ath10k_wmi_pull_svc_avail(struct ath10k *ar, struct sk_buff *skb,
 389                           struct wmi_svc_avail_ev_arg *arg)
 390 {
 391         if (!ar->wmi.ops->pull_svc_avail)
 392                 return -EOPNOTSUPP;
 393         return ar->wmi.ops->pull_svc_avail(ar, skb, arg);
 394 }
 395
 396 static inline int
 397 ath10k_wmi_pull_fw_stats(struct ath10k *ar, struct sk_buff *skb,
 398                          struct ath10k_fw_stats *stats)
 399 {
 400         if (!ar->wmi.ops->pull_fw_stats)
 401                 return -EOPNOTSUPP;
 402
 403         return ar->wmi.ops->pull_fw_stats(ar, skb, stats);
 404 }
 405
 406 static inline int
 407 ath10k_wmi_pull_roam_ev(struct ath10k *ar, struct sk_buff *skb,
 408                         struct wmi_roam_ev_arg *arg)
 409 {
 410         if (!ar->wmi.ops->pull_roam_ev)
 411                 return -EOPNOTSUPP;
 412
 413         return ar->wmi.ops->pull_roam_ev(ar, skb, arg);
 414 }
 415
 416 static inline int
 417 ath10k_wmi_pull_wow_event(struct ath10k *ar, struct sk_buff *skb,
 418                           struct wmi_wow_ev_arg *arg)
 419 {
 420         if (!ar->wmi.ops->pull_wow_event)
 421                 return -EOPNOTSUPP;
 422
 423         return ar->wmi.ops->pull_wow_event(ar, skb, arg);
 424 }
 425
 426 static inline int
 427 ath10k_wmi_pull_echo_ev(struct ath10k *ar, struct sk_buff *skb,
 428                         struct wmi_echo_ev_arg *arg)
 429 {
 430         if (!ar->wmi.ops->pull_echo_ev)
 431                 return -EOPNOTSUPP;
 432
 433         return ar->wmi.ops->pull_echo_ev(ar, skb, arg);
 434 }
 435
 436 static inline int
 437 ath10k_wmi_pull_dfs_status(struct ath10k *ar, struct sk_buff *skb,
 438                            struct wmi_dfs_status_ev_arg *arg)
 439 {
 440         if (!ar->wmi.ops->pull_dfs_status_ev)
 441                 return -EOPNOTSUPP;
 442
 443         return ar->wmi.ops->pull_dfs_status_ev(ar, skb, arg);
 444 }
 445
 446 static inline enum wmi_txbf_conf
 447 ath10k_wmi_get_txbf_conf_scheme(struct ath10k *ar)
 448 {
 449         if (!ar->wmi.ops->get_txbf_conf_scheme)
 450                 return WMI_TXBF_CONF_UNSUPPORTED;
 451
 452         return ar->wmi.ops->get_txbf_conf_scheme(ar);
 453 }
 454
 455 static inline int
 456 ath10k_wmi_mgmt_tx_send(struct ath10k *ar, struct sk_buff *msdu,
 457                         dma_addr_t paddr)
 458 {
 459         struct sk_buff *skb;
 460         int ret;
 461
 462         if (!ar->wmi.ops->gen_mgmt_tx_send)
 463                 return -EOPNOTSUPP;
 464
 465         skb = ar->wmi.ops->gen_mgmt_tx_send(ar, msdu, paddr);
 466         if (IS_ERR(skb))
 467                 return PTR_ERR(skb);
 468
 469         ret = ath10k_wmi_cmd_send(ar, skb,
 470                                   ar->wmi.cmd->mgmt_tx_send_cmdid);
 471         if (ret)
 472                 return ret;
 473
 474         return 0;
 475 }
 476
 477 static inline int
 478 ath10k_wmi_mgmt_tx(struct ath10k *ar, struct sk_buff *msdu)
 479 {
 480         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(msdu);
 481         struct sk_buff *skb;
 482         int ret;
 483
 484         if (!ar->wmi.ops->gen_mgmt_tx)
 485                 return -EOPNOTSUPP;
 486
 487         skb = ar->wmi.ops->gen_mgmt_tx(ar, msdu);
 488         if (IS_ERR(skb))
 489                 return PTR_ERR(skb);
 490
 491         ret = ath10k_wmi_cmd_send(ar, skb,
 492                                   ar->wmi.cmd->mgmt_tx_cmdid);
 493         if (ret)
 494                 return ret;
 495
 496         /* FIXME There's no ACK event for Management Tx. This probably
 497          * shouldn't be called here either.
 498          */
 499         info->flags |= IEEE80211_TX_STAT_ACK;
 500         ieee80211_tx_status_irqsafe(ar->hw, msdu);
 501
 502         return 0;
 503 }
 504
 505 static inline int
 506 ath10k_wmi_pdev_set_regdomain(struct ath10k *ar, u16 rd, u16 rd2g, u16 rd5g,
 507                               u16 ctl2g, u16 ctl5g,
 508                               enum wmi_dfs_region dfs_reg)
 509 {
 510         struct sk_buff *skb;
 511
 512         if (!ar->wmi.ops->gen_pdev_set_rd)
 513                 return -EOPNOTSUPP;
 514
 515         skb = ar->wmi.ops->gen_pdev_set_rd(ar, rd, rd2g, rd5g, ctl2g, ctl5g,
 516                                            dfs_reg);
 517         if (IS_ERR(skb))
 518                 return PTR_ERR(skb);
 519
 520         return ath10k_wmi_cmd_send(ar, skb,
 521                                    ar->wmi.cmd->pdev_set_regdomain_cmdid);
 522 }
 523
 524 static inline int
 525 ath10k_wmi_pdev_set_base_macaddr(struct ath10k *ar, const u8 macaddr[ETH_ALEN])
 526 {
 527         struct sk_buff *skb;
 528
 529         if (!ar->wmi.ops->gen_pdev_set_base_macaddr)
 530                 return -EOPNOTSUPP;
 531
 532         skb = ar->wmi.ops->gen_pdev_set_base_macaddr(ar, macaddr);
 533         if (IS_ERR(skb))
 534                 return PTR_ERR(skb);
 535
 536         return ath10k_wmi_cmd_send(ar, skb,
 537                                    ar->wmi.cmd->pdev_set_base_macaddr_cmdid);
 538 }
 539
 540 static inline int
 541 ath10k_wmi_pdev_suspend_target(struct ath10k *ar, u32 suspend_opt)
 542 {
 543         struct sk_buff *skb;
 544
 545         if (!ar->wmi.ops->gen_pdev_suspend)
 546                 return -EOPNOTSUPP;
 547
 548         skb = ar->wmi.ops->gen_pdev_suspend(ar, suspend_opt);
 549         if (IS_ERR(skb))
 550                 return PTR_ERR(skb);
 551
 552         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->pdev_suspend_cmdid);
 553 }
 554
 555 static inline int
 556 ath10k_wmi_pdev_resume_target(struct ath10k *ar)
 557 {
 558         struct sk_buff *skb;
 559
 560         if (!ar->wmi.ops->gen_pdev_resume)
 561                 return -EOPNOTSUPP;
 562
 563         skb = ar->wmi.ops->gen_pdev_resume(ar);
 564         if (IS_ERR(skb))
 565                 return PTR_ERR(skb);
 566
 567         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->pdev_resume_cmdid);
 568 }
 569
 570 static inline int
 571 ath10k_wmi_pdev_set_param(struct ath10k *ar, u32 id, u32 value)
 572 {
 573         struct sk_buff *skb;
 574
 575         if (!ar->wmi.ops->gen_pdev_set_param)
 576                 return -EOPNOTSUPP;
 577
 578         skb = ar->wmi.ops->gen_pdev_set_param(ar, id, value);
 579         if (IS_ERR(skb))
 580                 return PTR_ERR(skb);
 581
 582         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->pdev_set_param_cmdid);
 583 }
 584
 585 static inline int
 586 ath10k_wmi_cmd_init(struct ath10k *ar)
 587 {
 588         struct sk_buff *skb;
 589
 590         if (!ar->wmi.ops->gen_init)
 591                 return -EOPNOTSUPP;
 592
 593         skb = ar->wmi.ops->gen_init(ar);
 594         if (IS_ERR(skb))
 595                 return PTR_ERR(skb);
 596
 597         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->init_cmdid);
 598 }
 599
 600 static inline int
 601 ath10k_wmi_start_scan(struct ath10k *ar,
 602                       const struct wmi_start_scan_arg *arg)
 603 {
 604         struct sk_buff *skb;
 605
 606         if (!ar->wmi.ops->gen_start_scan)
 607                 return -EOPNOTSUPP;
 608
 609         skb = ar->wmi.ops->gen_start_scan(ar, arg);
 610         if (IS_ERR(skb))
 611                 return PTR_ERR(skb);
 612
 613         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->start_scan_cmdid);
 614 }
 615
 616 static inline int
 617 ath10k_wmi_stop_scan(struct ath10k *ar, const struct wmi_stop_scan_arg *arg)
 618 {
 619         struct sk_buff *skb;
 620
 621         if (!ar->wmi.ops->gen_stop_scan)
 622                 return -EOPNOTSUPP;
 623
 624         skb = ar->wmi.ops->gen_stop_scan(ar, arg);
 625         if (IS_ERR(skb))
 626                 return PTR_ERR(skb);
 627
 628         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->stop_scan_cmdid);
 629 }
 630
 631 static inline int
 632 ath10k_wmi_vdev_create(struct ath10k *ar, u32 vdev_id,
 633                        enum wmi_vdev_type type,
 634                        enum wmi_vdev_subtype subtype,
 635                        const u8 macaddr[ETH_ALEN])
 636 {
 637         struct sk_buff *skb;
 638
 639         if (!ar->wmi.ops->gen_vdev_create)
 640                 return -EOPNOTSUPP;
 641
 642         skb = ar->wmi.ops->gen_vdev_create(ar, vdev_id, type, subtype, macaddr);
 643         if (IS_ERR(skb))
 644                 return PTR_ERR(skb);
 645
 646         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_create_cmdid);
 647 }
 648
 649 static inline int
 650 ath10k_wmi_vdev_delete(struct ath10k *ar, u32 vdev_id)
 651 {
 652         struct sk_buff *skb;
 653
 654         if (!ar->wmi.ops->gen_vdev_delete)
 655                 return -EOPNOTSUPP;
 656
 657         skb = ar->wmi.ops->gen_vdev_delete(ar, vdev_id);
 658         if (IS_ERR(skb))
 659                 return PTR_ERR(skb);
 660
 661         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_delete_cmdid);
 662 }
 663
 664 static inline int
 665 ath10k_wmi_vdev_start(struct ath10k *ar,
 666                       const struct wmi_vdev_start_request_arg *arg)
 667 {
 668         struct sk_buff *skb;
 669
 670         if (!ar->wmi.ops->gen_vdev_start)
 671                 return -EOPNOTSUPP;
 672
 673         skb = ar->wmi.ops->gen_vdev_start(ar, arg, false);
 674         if (IS_ERR(skb))
 675                 return PTR_ERR(skb);
 676
 677         return ath10k_wmi_cmd_send(ar, skb,
 678                                    ar->wmi.cmd->vdev_start_request_cmdid);
 679 }
 680
 681 static inline int
 682 ath10k_wmi_vdev_restart(struct ath10k *ar,
 683                         const struct wmi_vdev_start_request_arg *arg)
 684 {
 685         struct sk_buff *skb;
 686
 687         if (!ar->wmi.ops->gen_vdev_start)
 688                 return -EOPNOTSUPP;
 689
 690         skb = ar->wmi.ops->gen_vdev_start(ar, arg, true);
 691         if (IS_ERR(skb))
 692                 return PTR_ERR(skb);
 693
 694         return ath10k_wmi_cmd_send(ar, skb,
 695                                    ar->wmi.cmd->vdev_restart_request_cmdid);
 696 }
 697
 698 static inline int
 699 ath10k_wmi_vdev_stop(struct ath10k *ar, u32 vdev_id)
 700 {
 701         struct sk_buff *skb;
 702
 703         if (!ar->wmi.ops->gen_vdev_stop)
 704                 return -EOPNOTSUPP;
 705
 706         skb = ar->wmi.ops->gen_vdev_stop(ar, vdev_id);
 707         if (IS_ERR(skb))
 708                 return PTR_ERR(skb);
 709
 710         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_stop_cmdid);
 711 }
 712
 713 static inline int
 714 ath10k_wmi_vdev_up(struct ath10k *ar, u32 vdev_id, u32 aid, const u8 *bssid)
 715 {
 716         struct sk_buff *skb;
 717
 718         if (!ar->wmi.ops->gen_vdev_up)
 719                 return -EOPNOTSUPP;
 720
 721         skb = ar->wmi.ops->gen_vdev_up(ar, vdev_id, aid, bssid);
 722         if (IS_ERR(skb))
 723                 return PTR_ERR(skb);
 724
 725         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_up_cmdid);
 726 }
 727
 728 static inline int
 729 ath10k_wmi_vdev_down(struct ath10k *ar, u32 vdev_id)
 730 {
 731         struct sk_buff *skb;
 732
 733         if (!ar->wmi.ops->gen_vdev_down)
 734                 return -EOPNOTSUPP;
 735
 736         skb = ar->wmi.ops->gen_vdev_down(ar, vdev_id);
 737         if (IS_ERR(skb))
 738                 return PTR_ERR(skb);
 739
 740         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_down_cmdid);
 741 }
 742
 743 static inline int
 744 ath10k_wmi_vdev_set_param(struct ath10k *ar, u32 vdev_id, u32 param_id,
 745                           u32 param_value)
 746 {
 747         struct sk_buff *skb;
 748
 749         if (!ar->wmi.ops->gen_vdev_set_param)
 750                 return -EOPNOTSUPP;
 751
 752         skb = ar->wmi.ops->gen_vdev_set_param(ar, vdev_id, param_id,
 753                                               param_value);
 754         if (IS_ERR(skb))
 755                 return PTR_ERR(skb);
 756
 757         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->vdev_set_param_cmdid);
 758 }
 759
 760 static inline int
 761 ath10k_wmi_vdev_install_key(struct ath10k *ar,
 762                             const struct wmi_vdev_install_key_arg *arg)
 763 {
 764         struct sk_buff *skb;
 765
 766         if (!ar->wmi.ops->gen_vdev_install_key)
 767                 return -EOPNOTSUPP;
 768
 769         skb = ar->wmi.ops->gen_vdev_install_key(ar, arg);
 770         if (IS_ERR(skb))
 771                 return PTR_ERR(skb);
 772
 773         return ath10k_wmi_cmd_send(ar, skb,
 774                                    ar->wmi.cmd->vdev_install_key_cmdid);
 775 }
 776
 777 static inline int
 778 ath10k_wmi_vdev_spectral_conf(struct ath10k *ar,
 779                               const struct wmi_vdev_spectral_conf_arg *arg)
 780 {
 781         struct sk_buff *skb;
 782         u32 cmd_id;
 783
 784         if (!ar->wmi.ops->gen_vdev_spectral_conf)
 785                 return -EOPNOTSUPP;
 786
 787         skb = ar->wmi.ops->gen_vdev_spectral_conf(ar, arg);
 788         if (IS_ERR(skb))
 789                 return PTR_ERR(skb);
 790
 791         cmd_id = ar->wmi.cmd->vdev_spectral_scan_configure_cmdid;
 792         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
 793 }
 794
 795 static inline int
 796 ath10k_wmi_vdev_spectral_enable(struct ath10k *ar, u32 vdev_id, u32 trigger,
 797                                 u32 enable)
 798 {
 799         struct sk_buff *skb;
 800         u32 cmd_id;
 801
 802         if (!ar->wmi.ops->gen_vdev_spectral_enable)
 803                 return -EOPNOTSUPP;
 804
 805         skb = ar->wmi.ops->gen_vdev_spectral_enable(ar, vdev_id, trigger,
 806                                                     enable);
 807         if (IS_ERR(skb))
 808                 return PTR_ERR(skb);
 809
 810         cmd_id = ar->wmi.cmd->vdev_spectral_scan_enable_cmdid;
 811         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
 812 }
 813
 814 static inline int
 815 ath10k_wmi_vdev_sta_uapsd(struct ath10k *ar, u32 vdev_id,
 816                           const u8 peer_addr[ETH_ALEN],
 817                           const struct wmi_sta_uapsd_auto_trig_arg *args,
 818                           u32 num_ac)
 819 {
 820         struct sk_buff *skb;
 821         u32 cmd_id;
 822
 823         if (!ar->wmi.ops->gen_vdev_sta_uapsd)
 824                 return -EOPNOTSUPP;
 825
 826         skb = ar->wmi.ops->gen_vdev_sta_uapsd(ar, vdev_id, peer_addr, args,
 827                                               num_ac);
 828         if (IS_ERR(skb))
 829                 return PTR_ERR(skb);
 830
 831         cmd_id = ar->wmi.cmd->sta_uapsd_auto_trig_cmdid;
 832         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
 833 }
 834
 835 static inline int
 836 ath10k_wmi_vdev_wmm_conf(struct ath10k *ar, u32 vdev_id,
 837                          const struct wmi_wmm_params_all_arg *arg)
 838 {
 839         struct sk_buff *skb;
 840         u32 cmd_id;
 841
 842         skb = ar->wmi.ops->gen_vdev_wmm_conf(ar, vdev_id, arg);
 843         if (IS_ERR(skb))
 844                 return PTR_ERR(skb);
 845
 846         cmd_id = ar->wmi.cmd->vdev_set_wmm_params_cmdid;
 847         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
 848 }
 849
 850 static inline int
 851 ath10k_wmi_peer_create(struct ath10k *ar, u32 vdev_id,
 852                        const u8 peer_addr[ETH_ALEN],
 853                        enum wmi_peer_type peer_type)
 854 {
 855         struct sk_buff *skb;
 856
 857         if (!ar->wmi.ops->gen_peer_create)
 858                 return -EOPNOTSUPP;
 859
 860         skb = ar->wmi.ops->gen_peer_create(ar, vdev_id, peer_addr, peer_type);
 861         if (IS_ERR(skb))
 862                 return PTR_ERR(skb);
 863
 864         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->peer_create_cmdid);
 865 }
 866
 867 static inline int
 868 ath10k_wmi_peer_delete(struct ath10k *ar, u32 vdev_id,
 869                        const u8 peer_addr[ETH_ALEN])
 870 {
 871         struct sk_buff *skb;
 872
 873         if (!ar->wmi.ops->gen_peer_delete)
 874                 return -EOPNOTSUPP;
 875
 876         skb = ar->wmi.ops->gen_peer_delete(ar, vdev_id, peer_addr);
 877         if (IS_ERR(skb))
 878                 return PTR_ERR(skb);
 879
 880         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->peer_delete_cmdid);
 881 }
 882
 883 static inline int
 884 ath10k_wmi_peer_flush(struct ath10k *ar, u32 vdev_id,
 885                       const u8 peer_addr[ETH_ALEN], u32 tid_bitmap)
 886 {
 887         struct sk_buff *skb;
 888
 889         if (!ar->wmi.ops->gen_peer_flush)
 890                 return -EOPNOTSUPP;
 891
 892         skb = ar->wmi.ops->gen_peer_flush(ar, vdev_id, peer_addr, tid_bitmap);
 893         if (IS_ERR(skb))
 894                 return PTR_ERR(skb);
 895
 896         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->peer_flush_tids_cmdid);
 897 }
 898
 899 static inline int
 900 ath10k_wmi_peer_set_param(struct ath10k *ar, u32 vdev_id, const u8 *peer_addr,
 901                           enum wmi_peer_param param_id, u32 param_value)
 902 {
 903         struct sk_buff *skb;
 904
 905         if (!ar->wmi.ops->gen_peer_set_param)
 906                 return -EOPNOTSUPP;
 907
 908         skb = ar->wmi.ops->gen_peer_set_param(ar, vdev_id, peer_addr, param_id,
 909                                               param_value);
 910         if (IS_ERR(skb))
 911                 return PTR_ERR(skb);
 912
 913         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->peer_set_param_cmdid);
 914 }
 915
 916 static inline int
 917 ath10k_wmi_set_psmode(struct ath10k *ar, u32 vdev_id,
 918                       enum wmi_sta_ps_mode psmode)
 919 {
 920         struct sk_buff *skb;
 921
 922         if (!ar->wmi.ops->gen_set_psmode)
 923                 return -EOPNOTSUPP;
 924
 925         skb = ar->wmi.ops->gen_set_psmode(ar, vdev_id, psmode);
 926         if (IS_ERR(skb))
 927                 return PTR_ERR(skb);
 928
 929         return ath10k_wmi_cmd_send(ar, skb,
 930                                    ar->wmi.cmd->sta_powersave_mode_cmdid);
 931 }
 932
 933 static inline int
 934 ath10k_wmi_set_sta_ps_param(struct ath10k *ar, u32 vdev_id,
 935                             enum wmi_sta_powersave_param param_id, u32 value)
 936 {
 937         struct sk_buff *skb;
 938
 939         if (!ar->wmi.ops->gen_set_sta_ps)
 940                 return -EOPNOTSUPP;
 941
 942         skb = ar->wmi.ops->gen_set_sta_ps(ar, vdev_id, param_id, value);
 943         if (IS_ERR(skb))
 944                 return PTR_ERR(skb);
 945
 946         return ath10k_wmi_cmd_send(ar, skb,
 947                                    ar->wmi.cmd->sta_powersave_param_cmdid);
 948 }
 949
 950 static inline int
 951 ath10k_wmi_set_ap_ps_param(struct ath10k *ar, u32 vdev_id, const u8 *mac,
 952                            enum wmi_ap_ps_peer_param param_id, u32 value)
 953 {
 954         struct sk_buff *skb;
 955
 956         if (!ar->wmi.ops->gen_set_ap_ps)
 957                 return -EOPNOTSUPP;
 958
 959         skb = ar->wmi.ops->gen_set_ap_ps(ar, vdev_id, mac, param_id, value);
 960         if (IS_ERR(skb))
 961                 return PTR_ERR(skb);
 962
 963         return ath10k_wmi_cmd_send(ar, skb,
 964                                    ar->wmi.cmd->ap_ps_peer_param_cmdid);
 965 }
 966
 967 static inline int
 968 ath10k_wmi_scan_chan_list(struct ath10k *ar,
 969                           const struct wmi_scan_chan_list_arg *arg)
 970 {
 971         struct sk_buff *skb;
 972
 973         if (!ar->wmi.ops->gen_scan_chan_list)
 974                 return -EOPNOTSUPP;
 975
 976         skb = ar->wmi.ops->gen_scan_chan_list(ar, arg);
 977         if (IS_ERR(skb))
 978                 return PTR_ERR(skb);
 979
 980         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->scan_chan_list_cmdid);
 981 }
 982
 983 static inline int
 984 ath10k_wmi_scan_prob_req_oui(struct ath10k *ar, const u8 mac_addr[ETH_ALEN])
 985 {
 986         struct sk_buff *skb;
 987         u32 prob_req_oui;
 988
 989         prob_req_oui = (((u32)mac_addr[0]) << 16) |
 990                        (((u32)mac_addr[1]) << 8) | mac_addr[2];
 991
 992         if (!ar->wmi.ops->gen_scan_prob_req_oui)
 993                 return -EOPNOTSUPP;
 994
 995         skb = ar->wmi.ops->gen_scan_prob_req_oui(ar, prob_req_oui);
 996         if (IS_ERR(skb))
 997                 return PTR_ERR(skb);
 998
 999         return ath10k_wmi_cmd_send(ar, skb,
1000                         ar->wmi.cmd->scan_prob_req_oui_cmdid);
1001 }
1002
1003 static inline int
1004 ath10k_wmi_peer_assoc(struct ath10k *ar,
1005                       const struct wmi_peer_assoc_complete_arg *arg)
1006 {
1007         struct sk_buff *skb;
1008
1009         if (!ar->wmi.ops->gen_peer_assoc)
1010                 return -EOPNOTSUPP;
1011
1012         skb = ar->wmi.ops->gen_peer_assoc(ar, arg);
1013         if (IS_ERR(skb))
1014                 return PTR_ERR(skb);
1015
1016         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->peer_assoc_cmdid);
1017 }
1018
1019 static inline int
1020 ath10k_wmi_beacon_send_ref_nowait(struct ath10k *ar, u32 vdev_id,
1021                                   const void *bcn, size_t bcn_len,
1022                                   u32 bcn_paddr, bool dtim_zero,
1023                                   bool deliver_cab)
1024 {
1025         struct sk_buff *skb;
1026         int ret;
1027
1028         if (!ar->wmi.ops->gen_beacon_dma)
1029                 return -EOPNOTSUPP;
1030
1031         skb = ar->wmi.ops->gen_beacon_dma(ar, vdev_id, bcn, bcn_len, bcn_paddr,
1032                                           dtim_zero, deliver_cab);
1033         if (IS_ERR(skb))
1034                 return PTR_ERR(skb);
1035
1036         ret = ath10k_wmi_cmd_send_nowait(ar, skb,
1037                                          ar->wmi.cmd->pdev_send_bcn_cmdid);
1038         if (ret) {
1039                 dev_kfree_skb(skb);
1040                 return ret;
1041         }
1042
1043         return 0;
1044 }
1045
1046 static inline int
1047 ath10k_wmi_pdev_set_wmm_params(struct ath10k *ar,
1048                                const struct wmi_wmm_params_all_arg *arg)
1049 {
1050         struct sk_buff *skb;
1051
1052         if (!ar->wmi.ops->gen_pdev_set_wmm)
1053                 return -EOPNOTSUPP;
1054
1055         skb = ar->wmi.ops->gen_pdev_set_wmm(ar, arg);
1056         if (IS_ERR(skb))
1057                 return PTR_ERR(skb);
1058
1059         return ath10k_wmi_cmd_send(ar, skb,
1060                                    ar->wmi.cmd->pdev_set_wmm_params_cmdid);
1061 }
1062
1063 static inline int
1064 ath10k_wmi_request_stats(struct ath10k *ar, u32 stats_mask)
1065 {
1066         struct sk_buff *skb;
1067
1068         if (!ar->wmi.ops->gen_request_stats)
1069                 return -EOPNOTSUPP;
1070
1071         skb = ar->wmi.ops->gen_request_stats(ar, stats_mask);
1072         if (IS_ERR(skb))
1073                 return PTR_ERR(skb);
1074
1075         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->request_stats_cmdid);
1076 }
1077
1078 static inline int
1079 ath10k_wmi_force_fw_hang(struct ath10k *ar,
1080                          enum wmi_force_fw_hang_type type, u32 delay_ms)
1081 {
1082         struct sk_buff *skb;
1083
1084         if (!ar->wmi.ops->gen_force_fw_hang)
1085                 return -EOPNOTSUPP;
1086
1087         skb = ar->wmi.ops->gen_force_fw_hang(ar, type, delay_ms);
1088         if (IS_ERR(skb))
1089                 return PTR_ERR(skb);
1090
1091         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->force_fw_hang_cmdid);
1092 }
1093
1094 static inline int
1095 ath10k_wmi_dbglog_cfg(struct ath10k *ar, u64 module_enable, u32 log_level)
1096 {
1097         struct sk_buff *skb;
1098
1099         if (!ar->wmi.ops->gen_dbglog_cfg)
1100                 return -EOPNOTSUPP;
1101
1102         skb = ar->wmi.ops->gen_dbglog_cfg(ar, module_enable, log_level);
1103         if (IS_ERR(skb))
1104                 return PTR_ERR(skb);
1105
1106         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->dbglog_cfg_cmdid);
1107 }
1108
1109 static inline int
1110 ath10k_wmi_pdev_pktlog_enable(struct ath10k *ar, u32 filter)
1111 {
1112         struct sk_buff *skb;
1113
1114         if (!ar->wmi.ops->gen_pktlog_enable)
1115                 return -EOPNOTSUPP;
1116
1117         skb = ar->wmi.ops->gen_pktlog_enable(ar, filter);
1118         if (IS_ERR(skb))
1119                 return PTR_ERR(skb);
1120
1121         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->pdev_pktlog_enable_cmdid);
1122 }
1123
1124 static inline int
1125 ath10k_wmi_pdev_pktlog_disable(struct ath10k *ar)
1126 {
1127         struct sk_buff *skb;
1128
1129         if (!ar->wmi.ops->gen_pktlog_disable)
1130                 return -EOPNOTSUPP;
1131
1132         skb = ar->wmi.ops->gen_pktlog_disable(ar);
1133         if (IS_ERR(skb))
1134                 return PTR_ERR(skb);
1135
1136         return ath10k_wmi_cmd_send(ar, skb,
1137                                    ar->wmi.cmd->pdev_pktlog_disable_cmdid);
1138 }
1139
1140 static inline int
1141 ath10k_wmi_pdev_set_quiet_mode(struct ath10k *ar, u32 period, u32 duration,
1142                                u32 next_offset, u32 enabled)
1143 {
1144         struct sk_buff *skb;
1145
1146         if (!ar->wmi.ops->gen_pdev_set_quiet_mode)
1147                 return -EOPNOTSUPP;
1148
1149         skb = ar->wmi.ops->gen_pdev_set_quiet_mode(ar, period, duration,
1150                                                    next_offset, enabled);
1151         if (IS_ERR(skb))
1152                 return PTR_ERR(skb);
1153
1154         return ath10k_wmi_cmd_send(ar, skb,
1155                                    ar->wmi.cmd->pdev_set_quiet_mode_cmdid);
1156 }
1157
1158 static inline int
1159 ath10k_wmi_pdev_get_temperature(struct ath10k *ar)
1160 {
1161         struct sk_buff *skb;
1162
1163         if (!ar->wmi.ops->gen_pdev_get_temperature)
1164                 return -EOPNOTSUPP;
1165
1166         skb = ar->wmi.ops->gen_pdev_get_temperature(ar);
1167         if (IS_ERR(skb))
1168                 return PTR_ERR(skb);
1169
1170         return ath10k_wmi_cmd_send(ar, skb,
1171                                    ar->wmi.cmd->pdev_get_temperature_cmdid);
1172 }
1173
1174 static inline int
1175 ath10k_wmi_addba_clear_resp(struct ath10k *ar, u32 vdev_id, const u8 *mac)
1176 {
1177         struct sk_buff *skb;
1178
1179         if (!ar->wmi.ops->gen_addba_clear_resp)
1180                 return -EOPNOTSUPP;
1181
1182         skb = ar->wmi.ops->gen_addba_clear_resp(ar, vdev_id, mac);
1183         if (IS_ERR(skb))
1184                 return PTR_ERR(skb);
1185
1186         return ath10k_wmi_cmd_send(ar, skb,
1187                                    ar->wmi.cmd->addba_clear_resp_cmdid);
1188 }
1189
1190 static inline int
1191 ath10k_wmi_addba_send(struct ath10k *ar, u32 vdev_id, const u8 *mac,
1192                       u32 tid, u32 buf_size)
1193 {
1194         struct sk_buff *skb;
1195
1196         if (!ar->wmi.ops->gen_addba_send)
1197                 return -EOPNOTSUPP;
1198
1199         skb = ar->wmi.ops->gen_addba_send(ar, vdev_id, mac, tid, buf_size);
1200         if (IS_ERR(skb))
1201                 return PTR_ERR(skb);
1202
1203         return ath10k_wmi_cmd_send(ar, skb,
1204                                    ar->wmi.cmd->addba_send_cmdid);
1205 }
1206
1207 static inline int
1208 ath10k_wmi_addba_set_resp(struct ath10k *ar, u32 vdev_id, const u8 *mac,
1209                           u32 tid, u32 status)
1210 {
1211         struct sk_buff *skb;
1212
1213         if (!ar->wmi.ops->gen_addba_set_resp)
1214                 return -EOPNOTSUPP;
1215
1216         skb = ar->wmi.ops->gen_addba_set_resp(ar, vdev_id, mac, tid, status);
1217         if (IS_ERR(skb))
1218                 return PTR_ERR(skb);
1219
1220         return ath10k_wmi_cmd_send(ar, skb,
1221                                    ar->wmi.cmd->addba_set_resp_cmdid);
1222 }
1223
1224 static inline int
1225 ath10k_wmi_delba_send(struct ath10k *ar, u32 vdev_id, const u8 *mac,
1226                       u32 tid, u32 initiator, u32 reason)
1227 {
1228         struct sk_buff *skb;
1229
1230         if (!ar->wmi.ops->gen_delba_send)
1231                 return -EOPNOTSUPP;
1232
1233         skb = ar->wmi.ops->gen_delba_send(ar, vdev_id, mac, tid, initiator,
1234                                           reason);
1235         if (IS_ERR(skb))
1236                 return PTR_ERR(skb);
1237
1238         return ath10k_wmi_cmd_send(ar, skb,
1239                                    ar->wmi.cmd->delba_send_cmdid);
1240 }
1241
1242 static inline int
1243 ath10k_wmi_bcn_tmpl(struct ath10k *ar, u32 vdev_id, u32 tim_ie_offset,
1244                     struct sk_buff *bcn, u32 prb_caps, u32 prb_erp,
1245                     void *prb_ies, size_t prb_ies_len)
1246 {
1247         struct sk_buff *skb;
1248
1249         if (!ar->wmi.ops->gen_bcn_tmpl)
1250                 return -EOPNOTSUPP;
1251
1252         skb = ar->wmi.ops->gen_bcn_tmpl(ar, vdev_id, tim_ie_offset, bcn,
1253                                         prb_caps, prb_erp, prb_ies,
1254                                         prb_ies_len);
1255         if (IS_ERR(skb))
1256                 return PTR_ERR(skb);
1257
1258         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->bcn_tmpl_cmdid);
1259 }
1260
1261 static inline int
1262 ath10k_wmi_prb_tmpl(struct ath10k *ar, u32 vdev_id, struct sk_buff *prb)
1263 {
1264         struct sk_buff *skb;
1265
1266         if (!ar->wmi.ops->gen_prb_tmpl)
1267                 return -EOPNOTSUPP;
1268
1269         skb = ar->wmi.ops->gen_prb_tmpl(ar, vdev_id, prb);
1270         if (IS_ERR(skb))
1271                 return PTR_ERR(skb);
1272
1273         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->prb_tmpl_cmdid);
1274 }
1275
1276 static inline int
1277 ath10k_wmi_p2p_go_bcn_ie(struct ath10k *ar, u32 vdev_id, const u8 *p2p_ie)
1278 {
1279         struct sk_buff *skb;
1280
1281         if (!ar->wmi.ops->gen_p2p_go_bcn_ie)
1282                 return -EOPNOTSUPP;
1283
1284         skb = ar->wmi.ops->gen_p2p_go_bcn_ie(ar, vdev_id, p2p_ie);
1285         if (IS_ERR(skb))
1286                 return PTR_ERR(skb);
1287
1288         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->p2p_go_set_beacon_ie);
1289 }
1290
1291 static inline int
1292 ath10k_wmi_sta_keepalive(struct ath10k *ar,
1293                          const struct wmi_sta_keepalive_arg *arg)
1294 {
1295         struct sk_buff *skb;
1296         u32 cmd_id;
1297
1298         if (!ar->wmi.ops->gen_sta_keepalive)
1299                 return -EOPNOTSUPP;
1300
1301         skb = ar->wmi.ops->gen_sta_keepalive(ar, arg);
1302         if (IS_ERR(skb))
1303                 return PTR_ERR(skb);
1304
1305         cmd_id = ar->wmi.cmd->sta_keepalive_cmd;
1306         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1307 }
1308
1309 static inline int
1310 ath10k_wmi_wow_enable(struct ath10k *ar)
1311 {
1312         struct sk_buff *skb;
1313         u32 cmd_id;
1314
1315         if (!ar->wmi.ops->gen_wow_enable)
1316                 return -EOPNOTSUPP;
1317
1318         skb = ar->wmi.ops->gen_wow_enable(ar);
1319         if (IS_ERR(skb))
1320                 return PTR_ERR(skb);
1321
1322         cmd_id = ar->wmi.cmd->wow_enable_cmdid;
1323         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1324 }
1325
1326 static inline int
1327 ath10k_wmi_wow_add_wakeup_event(struct ath10k *ar, u32 vdev_id,
1328                                 enum wmi_wow_wakeup_event event,
1329                                 u32 enable)
1330 {
1331         struct sk_buff *skb;
1332         u32 cmd_id;
1333
1334         if (!ar->wmi.ops->gen_wow_add_wakeup_event)
1335                 return -EOPNOTSUPP;
1336
1337         skb = ar->wmi.ops->gen_wow_add_wakeup_event(ar, vdev_id, event, enable);
1338         if (IS_ERR(skb))
1339                 return PTR_ERR(skb);
1340
1341         cmd_id = ar->wmi.cmd->wow_enable_disable_wake_event_cmdid;
1342         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1343 }
1344
1345 static inline int
1346 ath10k_wmi_wow_host_wakeup_ind(struct ath10k *ar)
1347 {
1348         struct sk_buff *skb;
1349         u32 cmd_id;
1350
1351         if (!ar->wmi.ops->gen_wow_host_wakeup_ind)
1352                 return -EOPNOTSUPP;
1353
1354         skb = ar->wmi.ops->gen_wow_host_wakeup_ind(ar);
1355         if (IS_ERR(skb))
1356                 return PTR_ERR(skb);
1357
1358         cmd_id = ar->wmi.cmd->wow_hostwakeup_from_sleep_cmdid;
1359         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1360 }
1361
1362 static inline int
1363 ath10k_wmi_wow_add_pattern(struct ath10k *ar, u32 vdev_id, u32 pattern_id,
1364                            const u8 *pattern, const u8 *mask,
1365                            int pattern_len, int pattern_offset)
1366 {
1367         struct sk_buff *skb;
1368         u32 cmd_id;
1369
1370         if (!ar->wmi.ops->gen_wow_add_pattern)
1371                 return -EOPNOTSUPP;
1372
1373         skb = ar->wmi.ops->gen_wow_add_pattern(ar, vdev_id, pattern_id,
1374                                                pattern, mask, pattern_len,
1375                                                pattern_offset);
1376         if (IS_ERR(skb))
1377                 return PTR_ERR(skb);
1378
1379         cmd_id = ar->wmi.cmd->wow_add_wake_pattern_cmdid;
1380         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1381 }
1382
1383 static inline int
1384 ath10k_wmi_wow_del_pattern(struct ath10k *ar, u32 vdev_id, u32 pattern_id)
1385 {
1386         struct sk_buff *skb;
1387         u32 cmd_id;
1388
1389         if (!ar->wmi.ops->gen_wow_del_pattern)
1390                 return -EOPNOTSUPP;
1391
1392         skb = ar->wmi.ops->gen_wow_del_pattern(ar, vdev_id, pattern_id);
1393         if (IS_ERR(skb))
1394                 return PTR_ERR(skb);
1395
1396         cmd_id = ar->wmi.cmd->wow_del_wake_pattern_cmdid;
1397         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1398 }
1399
1400 static inline int
1401 ath10k_wmi_wow_config_pno(struct ath10k *ar, u32 vdev_id,
1402                           struct wmi_pno_scan_req  *pno_scan)
1403 {
1404         struct sk_buff *skb;
1405         u32 cmd_id;
1406
1407         if (!ar->wmi.ops->gen_wow_config_pno)
1408                 return -EOPNOTSUPP;
1409
1410         skb = ar->wmi.ops->gen_wow_config_pno(ar, vdev_id, pno_scan);
1411         if (IS_ERR(skb))
1412                 return PTR_ERR(skb);
1413
1414         cmd_id = ar->wmi.cmd->network_list_offload_config_cmdid;
1415         return ath10k_wmi_cmd_send(ar, skb, cmd_id);
1416 }
1417
1418 static inline int
1419 ath10k_wmi_update_fw_tdls_state(struct ath10k *ar, u32 vdev_id,
1420                                 enum wmi_tdls_state state)
1421 {
1422         struct sk_buff *skb;
1423
1424         if (!ar->wmi.ops->gen_update_fw_tdls_state)
1425                 return -EOPNOTSUPP;
1426
1427         skb = ar->wmi.ops->gen_update_fw_tdls_state(ar, vdev_id, state);
1428         if (IS_ERR(skb))
1429                 return PTR_ERR(skb);
1430
1431         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->tdls_set_state_cmdid);
1432 }
1433
1434 static inline int
1435 ath10k_wmi_tdls_peer_update(struct ath10k *ar,
1436                             const struct wmi_tdls_peer_update_cmd_arg *arg,
1437                             const struct wmi_tdls_peer_capab_arg *cap,
1438                             const struct wmi_channel_arg *chan)
1439 {
1440         struct sk_buff *skb;
1441
1442         if (!ar->wmi.ops->gen_tdls_peer_update)
1443                 return -EOPNOTSUPP;
1444
1445         skb = ar->wmi.ops->gen_tdls_peer_update(ar, arg, cap, chan);
1446         if (IS_ERR(skb))
1447                 return PTR_ERR(skb);
1448
1449         return ath10k_wmi_cmd_send(ar, skb,
1450                                    ar->wmi.cmd->tdls_peer_update_cmdid);
1451 }
1452
1453 static inline int
1454 ath10k_wmi_adaptive_qcs(struct ath10k *ar, bool enable)
1455 {
1456         struct sk_buff *skb;
1457
1458         if (!ar->wmi.ops->gen_adaptive_qcs)
1459                 return -EOPNOTSUPP;
1460
1461         skb = ar->wmi.ops->gen_adaptive_qcs(ar, enable);
1462         if (IS_ERR(skb))
1463                 return PTR_ERR(skb);
1464
1465         return ath10k_wmi_cmd_send(ar, skb, ar->wmi.cmd->adaptive_qcs_cmdid);
1466 }
1467
1468 static inline int
1469 ath10k_wmi_pdev_get_tpc_config(struct ath10k *ar, u32 param)
1470 {
1471         struct sk_buff *skb;
1472
1473         if (!ar->wmi.ops->gen_pdev_get_tpc_config)
1474                 return -EOPNOTSUPP;
1475
1476         skb = ar->wmi.ops->gen_pdev_get_tpc_config(ar, param);
1477
1478         if (IS_ERR(skb))
1479                 return PTR_ERR(skb);
1480
1481         return ath10k_wmi_cmd_send(ar, skb,
1482                                    ar->wmi.cmd->pdev_get_tpc_config_cmdid);
1483 }
1484
1485 static inline int
1486 ath10k_wmi_fw_stats_fill(struct ath10k *ar, struct ath10k_fw_stats *fw_stats,
1487                          char *buf)
1488 {
1489         if (!ar->wmi.ops->fw_stats_fill)
1490                 return -EOPNOTSUPP;
1491
1492         ar->wmi.ops->fw_stats_fill(ar, fw_stats, buf);
1493         return 0;
1494 }
1495
1496 static inline int
1497 ath10k_wmi_pdev_enable_adaptive_cca(struct ath10k *ar, u8 enable,
1498                                     u32 detect_level, u32 detect_margin)
1499 {
1500         struct sk_buff *skb;
1501
1502         if (!ar->wmi.ops->gen_pdev_enable_adaptive_cca)
1503                 return -EOPNOTSUPP;
1504
1505         skb = ar->wmi.ops->gen_pdev_enable_adaptive_cca(ar, enable,
1506                                                         detect_level,
1507                                                         detect_margin);
1508
1509         if (IS_ERR(skb))
1510                 return PTR_ERR(skb);
1511
1512         return ath10k_wmi_cmd_send(ar, skb,
1513                                    ar->wmi.cmd->pdev_enable_adaptive_cca_cmdid);
1514 }
1515
1516 static inline int
1517 ath10k_wmi_ext_resource_config(struct ath10k *ar,
1518                                enum wmi_host_platform_type type,
1519                                u32 fw_feature_bitmap)
1520 {
1521         struct sk_buff *skb;
1522
1523         if (!ar->wmi.ops->ext_resource_config)
1524                 return -EOPNOTSUPP;
1525
1526         skb = ar->wmi.ops->ext_resource_config(ar, type,
1527                                                fw_feature_bitmap);
1528
1529         if (IS_ERR(skb))
1530                 return PTR_ERR(skb);
1531
1532         return ath10k_wmi_cmd_send(ar, skb,
1533                                    ar->wmi.cmd->ext_resource_cfg_cmdid);
1534 }
1535
1536 static inline int
1537 ath10k_wmi_get_vdev_subtype(struct ath10k *ar, enum wmi_vdev_subtype subtype)
1538 {
1539         if (!ar->wmi.ops->get_vdev_subtype)
1540                 return -EOPNOTSUPP;
1541
1542         return ar->wmi.ops->get_vdev_subtype(ar, subtype);
1543 }
1544
1545 static inline int
1546 ath10k_wmi_pdev_bss_chan_info_request(struct ath10k *ar,
1547                                       enum wmi_bss_survey_req_type type)
1548 {
1549         struct ath10k_wmi *wmi = &ar->wmi;
1550         struct sk_buff *skb;
1551
1552         if (!wmi->ops->gen_pdev_bss_chan_info_req)
1553                 return -EOPNOTSUPP;
1554
1555         skb = wmi->ops->gen_pdev_bss_chan_info_req(ar, type);
1556         if (IS_ERR(skb))
1557                 return PTR_ERR(skb);
1558
1559         return ath10k_wmi_cmd_send(ar, skb,
1560                                    wmi->cmd->pdev_bss_chan_info_request_cmdid);
1561 }
1562
1563 static inline int
1564 ath10k_wmi_echo(struct ath10k *ar, u32 value)
1565 {
1566         struct ath10k_wmi *wmi = &ar->wmi;
1567         struct sk_buff *skb;
1568
1569         if (!wmi->ops->gen_echo)
1570                 return -EOPNOTSUPP;
1571
1572         skb = wmi->ops->gen_echo(ar, value);
1573         if (IS_ERR(skb))
1574                 return PTR_ERR(skb);
1575
1576         return ath10k_wmi_cmd_send(ar, skb, wmi->cmd->echo_cmdid);
1577 }
1578
1579 static inline int
1580 ath10k_wmi_pdev_get_tpc_table_cmdid(struct ath10k *ar, u32 param)
1581 {
1582         struct sk_buff *skb;
1583
1584         if (!ar->wmi.ops->gen_pdev_get_tpc_table_cmdid)
1585                 return -EOPNOTSUPP;
1586
1587         skb = ar->wmi.ops->gen_pdev_get_tpc_table_cmdid(ar, param);
1588
1589         if (IS_ERR(skb))
1590                 return PTR_ERR(skb);
1591
1592         return ath10k_wmi_cmd_send(ar, skb,
1593                                    ar->wmi.cmd->pdev_get_tpc_table_cmdid);
1594 }
1595
1596 static inline int
1597 ath10k_wmi_report_radar_found(struct ath10k *ar,
1598                               const struct ath10k_radar_found_info *arg)
1599 {
1600         struct sk_buff *skb;
1601
1602         if (!ar->wmi.ops->gen_radar_found)
1603                 return -EOPNOTSUPP;
1604
1605         skb = ar->wmi.ops->gen_radar_found(ar, arg);
1606         if (IS_ERR(skb))
1607                 return PTR_ERR(skb);
1608
1609         return ath10k_wmi_cmd_send(ar, skb,
1610                                    ar->wmi.cmd->radar_found_cmdid);
1611 }
1612
1613 static inline int
1614 ath10k_wmi_pdev_bb_timing(struct ath10k *ar,
1615                           const struct wmi_bb_timing_cfg_arg *arg)
1616 {
1617         struct sk_buff *skb;
1618
1619         if (!ar->wmi.ops->gen_bb_timing)
1620                 return -EOPNOTSUPP;
1621
1622         skb = ar->wmi.ops->gen_bb_timing(ar, arg);
1623
1624         if (IS_ERR(skb))
1625                 return PTR_ERR(skb);
1626
1627         return ath10k_wmi_cmd_send(ar, skb,
1628                                    ar->wmi.cmd->set_bb_timing_cmdid);
1629 }
1630 #endif