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

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