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

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