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