wpa_supplicant/driver_i.h

   1 /*
   2  * wpa_supplicant - Internal driver interface wrappers
   3  * Copyright (c) 2003-2015, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #ifndef DRIVER_I_H
  10 #define DRIVER_I_H
  11
  12 #include "drivers/driver.h"
  13
  14 /* driver_ops */
  15 static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
  16                                   const char *ifname)
  17 {
  18         if (wpa_s->driver->init2)
  19                 return wpa_s->driver->init2(wpa_s, ifname,
  20                                             wpa_s->global_drv_priv);
  21         if (wpa_s->driver->init) {
  22                 return wpa_s->driver->init(wpa_s, ifname);
  23         }
  24         return NULL;
  25 }
  26
  27 static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
  28 {
  29         if (wpa_s->driver->deinit)
  30                 wpa_s->driver->deinit(wpa_s->drv_priv);
  31 }
  32
  33 static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
  34                                     const char *param)
  35 {
  36         if (wpa_s->driver->set_param)
  37                 return wpa_s->driver->set_param(wpa_s->drv_priv, param);
  38         return 0;
  39 }
  40
  41 static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
  42                                               int enabled)
  43 {
  44         if (wpa_s->driver->set_countermeasures) {
  45                 return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
  46                                                           enabled);
  47         }
  48         return -1;
  49 }
  50
  51 static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
  52                                        struct wpa_driver_auth_params *params)
  53 {
  54         if (wpa_s->driver->authenticate)
  55                 return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
  56         return -1;
  57 }
  58
  59 static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
  60                                     struct wpa_driver_associate_params *params)
  61 {
  62         if (wpa_s->driver->associate) {
  63                 return wpa_s->driver->associate(wpa_s->drv_priv, params);
  64         }
  65         return -1;
  66 }
  67
  68 static inline int wpa_drv_init_mesh(struct wpa_supplicant *wpa_s)
  69 {
  70         if (wpa_s->driver->init_mesh)
  71                 return wpa_s->driver->init_mesh(wpa_s->drv_priv);
  72         return -1;
  73 }
  74
  75 static inline int wpa_drv_join_mesh(struct wpa_supplicant *wpa_s,
  76                                     struct wpa_driver_mesh_join_params *params)
  77 {
  78         if (wpa_s->driver->join_mesh)
  79                 return wpa_s->driver->join_mesh(wpa_s->drv_priv, params);
  80         return -1;
  81 }
  82
  83 static inline int wpa_drv_leave_mesh(struct wpa_supplicant *wpa_s)
  84 {
  85         if (wpa_s->driver->leave_mesh)
  86                 return wpa_s->driver->leave_mesh(wpa_s->drv_priv);
  87         return -1;
  88 }
  89
  90 static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
  91                                struct wpa_driver_scan_params *params)
  92 {
  93 #ifdef CONFIG_TESTING_OPTIONS
  94         if (wpa_s->test_failure == WPAS_TEST_FAILURE_SCAN_TRIGGER)
  95                 return -EBUSY;
  96 #endif /* CONFIG_TESTING_OPTIONS */
  97         if (wpa_s->driver->scan2)
  98                 return wpa_s->driver->scan2(wpa_s->drv_priv, params);
  99         return -1;
 100 }
 101
 102 static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
 103                                      struct wpa_driver_scan_params *params)
 104 {
 105         if (wpa_s->driver->sched_scan)
 106                 return wpa_s->driver->sched_scan(wpa_s->drv_priv, params);
 107         return -1;
 108 }
 109
 110 static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
 111 {
 112         if (wpa_s->driver->stop_sched_scan)
 113                 return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
 114         return -1;
 115 }
 116
 117 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
 118         struct wpa_supplicant *wpa_s)
 119 {
 120         if (wpa_s->driver->get_scan_results2)
 121                 return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
 122         return NULL;
 123 }
 124
 125 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
 126 {
 127         if (wpa_s->driver->get_bssid) {
 128                 return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
 129         }
 130         return -1;
 131 }
 132
 133 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
 134 {
 135         if (wpa_s->driver->get_ssid) {
 136                 return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
 137         }
 138         return -1;
 139 }
 140
 141 static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
 142                                   enum wpa_alg alg, const u8 *addr,
 143                                   int key_idx, int set_tx,
 144                                   const u8 *seq, size_t seq_len,
 145                                   const u8 *key, size_t key_len)
 146 {
 147         if (alg != WPA_ALG_NONE) {
 148                 if (key_idx >= 0 && key_idx <= 6)
 149                         wpa_s->keys_cleared &= ~BIT(key_idx);
 150                 else
 151                         wpa_s->keys_cleared = 0;
 152         }
 153         if (wpa_s->driver->set_key) {
 154                 return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
 155                                               alg, addr, key_idx, set_tx,
 156                                               seq, seq_len, key, key_len);
 157         }
 158         return -1;
 159 }
 160
 161 static inline int wpa_drv_get_seqnum(struct wpa_supplicant *wpa_s,
 162                                      const u8 *addr, int idx, u8 *seq)
 163 {
 164         if (wpa_s->driver->get_seqnum)
 165                 return wpa_s->driver->get_seqnum(wpa_s->ifname, wpa_s->drv_priv,
 166                                                  addr, idx, seq);
 167         return -1;
 168 }
 169
 170 static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
 171                                      const u8 *addr, int reason_code)
 172 {
 173         if (wpa_s->driver->sta_deauth) {
 174                 return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
 175                                                  wpa_s->own_addr, addr,
 176                                                  reason_code);
 177         }
 178         return -1;
 179 }
 180
 181 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
 182                                          const u8 *addr, int reason_code)
 183 {
 184         if (wpa_s->driver->deauthenticate) {
 185                 return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
 186                                                      reason_code);
 187         }
 188         return -1;
 189 }
 190
 191 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
 192                                     struct wpa_pmkid_params *params)
 193 {
 194         if (wpa_s->driver->add_pmkid) {
 195                 return wpa_s->driver->add_pmkid(wpa_s->drv_priv, params);
 196         }
 197         return -1;
 198 }
 199
 200 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
 201                                        struct wpa_pmkid_params *params)
 202 {
 203         if (wpa_s->driver->remove_pmkid) {
 204                 return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, params);
 205         }
 206         return -1;
 207 }
 208
 209 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
 210 {
 211         if (wpa_s->driver->flush_pmkid) {
 212                 return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
 213         }
 214         return -1;
 215 }
 216
 217 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
 218                                    struct wpa_driver_capa *capa)
 219 {
 220         if (wpa_s->driver->get_capa) {
 221                 return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
 222         }
 223         return -1;
 224 }
 225
 226 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
 227 {
 228         if (wpa_s->driver->poll) {
 229                 wpa_s->driver->poll(wpa_s->drv_priv);
 230         }
 231 }
 232
 233 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
 234 {
 235         if (wpa_s->driver->get_ifname) {
 236                 return wpa_s->driver->get_ifname(wpa_s->drv_priv);
 237         }
 238         return NULL;
 239 }
 240
 241 static inline const char *
 242 wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
 243 {
 244         if (wpa_s->driver->get_radio_name)
 245                 return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
 246         return NULL;
 247 }
 248
 249 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
 250 {
 251         if (wpa_s->driver->get_mac_addr) {
 252                 return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
 253         }
 254         return NULL;
 255 }
 256
 257 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
 258                                         int state)
 259 {
 260         if (wpa_s->driver->set_operstate)
 261                 return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
 262         return 0;
 263 }
 264
 265 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
 266                                              const u8 *addr, int protect_type,
 267                                              int key_type)
 268 {
 269         if (wpa_s->driver->mlme_setprotection)
 270                 return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
 271                                                          protect_type,
 272                                                          key_type);
 273         return 0;
 274 }
 275
 276 static inline struct hostapd_hw_modes *
 277 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
 278                             u16 *flags, u8 *dfs_domain)
 279 {
 280         if (wpa_s->driver->get_hw_feature_data)
 281                 return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
 282                                                           num_modes, flags,
 283                                                           dfs_domain);
 284         return NULL;
 285 }
 286
 287 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 288                                       const char *alpha2)
 289 {
 290         if (wpa_s->driver->set_country)
 291                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 292         return 0;
 293 }
 294
 295 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 296                                     const u8 *data, size_t data_len, int noack,
 297                                     unsigned int freq)
 298 {
 299         if (wpa_s->driver->send_mlme)
 300                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 301                                                 data, data_len, noack,
 302                                                 freq, NULL, 0);
 303         return -1;
 304 }
 305
 306 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 307                                         const u8 *md,
 308                                         const u8 *ies, size_t ies_len)
 309 {
 310         if (wpa_s->driver->update_ft_ies)
 311                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 312                                                     ies, ies_len);
 313         return -1;
 314 }
 315
 316 static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
 317                                  struct wpa_driver_ap_params *params)
 318 {
 319         if (wpa_s->driver->set_ap)
 320                 return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
 321         return -1;
 322 }
 323
 324 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 325                                   struct hostapd_sta_add_params *params)
 326 {
 327         if (wpa_s->driver->sta_add)
 328                 return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
 329         return -1;
 330 }
 331
 332 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 333                                      const u8 *addr)
 334 {
 335         if (wpa_s->driver->sta_remove)
 336                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 337         return -1;
 338 }
 339
 340 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 341                                           const u8 *addr, const u8 *data,
 342                                           size_t data_len, int encrypt,
 343                                           const u8 *own_addr, u32 flags)
 344 {
 345         if (wpa_s->driver->hapd_send_eapol)
 346                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 347                                                       data, data_len, encrypt,
 348                                                       own_addr, flags);
 349         return -1;
 350 }
 351
 352 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 353                                         const u8 *addr, int total_flags,
 354                                         int flags_or, int flags_and)
 355 {
 356         if (wpa_s->driver->sta_set_flags)
 357                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 358                                                     total_flags, flags_or,
 359                                                     flags_and);
 360         return -1;
 361 }
 362
 363 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 364                                         int authorized)
 365 {
 366         if (wpa_s->driver->set_supp_port) {
 367                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 368                                                     authorized);
 369         }
 370         return 0;
 371 }
 372
 373 static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
 374                                       unsigned int freq,
 375                                       unsigned int wait,
 376                                       const u8 *dst, const u8 *src,
 377                                       const u8 *bssid,
 378                                       const u8 *data, size_t data_len,
 379                                       int no_cck)
 380 {
 381         if (wpa_s->driver->send_action)
 382                 return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
 383                                                   wait, dst, src, bssid,
 384                                                   data, data_len, no_cck);
 385         return -1;
 386 }
 387
 388 static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
 389 {
 390         if (wpa_s->driver->send_action_cancel_wait)
 391                 wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
 392 }
 393
 394 static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
 395                                    struct hostapd_freq_params *freq)
 396 {
 397         if (wpa_s->driver->set_freq)
 398                 return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
 399         return -1;
 400 }
 401
 402 static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
 403                                  enum wpa_driver_if_type type,
 404                                  const char *ifname, const u8 *addr,
 405                                  void *bss_ctx, char *force_ifname,
 406                                  u8 *if_addr, const char *bridge)
 407 {
 408         if (wpa_s->driver->if_add)
 409                 return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
 410                                              addr, bss_ctx, NULL, force_ifname,
 411                                              if_addr, bridge, 0, 0);
 412         return -1;
 413 }
 414
 415 static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
 416                                     enum wpa_driver_if_type type,
 417                                     const char *ifname)
 418 {
 419         if (wpa_s->driver->if_remove)
 420                 return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
 421         return -1;
 422 }
 423
 424 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
 425                                             unsigned int freq,
 426                                             unsigned int duration)
 427 {
 428         if (wpa_s->driver->remain_on_channel)
 429                 return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
 430                                                         duration);
 431         return -1;
 432 }
 433
 434 static inline int wpa_drv_cancel_remain_on_channel(
 435         struct wpa_supplicant *wpa_s)
 436 {
 437         if (wpa_s->driver->cancel_remain_on_channel)
 438                 return wpa_s->driver->cancel_remain_on_channel(
 439                         wpa_s->drv_priv);
 440         return -1;
 441 }
 442
 443 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
 444                                            int report)
 445 {
 446         if (wpa_s->driver->probe_req_report)
 447                 return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
 448                                                        report);
 449         return -1;
 450 }
 451
 452 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
 453 {
 454         if (wpa_s->driver->deinit_ap)
 455                 return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
 456         return 0;
 457 }
 458
 459 static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
 460 {
 461         if (wpa_s->driver->deinit_p2p_cli)
 462                 return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
 463         return 0;
 464 }
 465
 466 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
 467 {
 468         if (wpa_s->driver->suspend)
 469                 wpa_s->driver->suspend(wpa_s->drv_priv);
 470 }
 471
 472 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
 473 {
 474         if (wpa_s->driver->resume)
 475                 wpa_s->driver->resume(wpa_s->drv_priv);
 476 }
 477
 478 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
 479                                          int threshold, int hysteresis)
 480 {
 481         if (wpa_s->driver->signal_monitor)
 482                 return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
 483                                                      threshold, hysteresis);
 484         return -1;
 485 }
 486
 487 static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
 488                                       struct wpa_signal_info *si)
 489 {
 490         if (wpa_s->driver->signal_poll)
 491                 return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
 492         return -1;
 493 }
 494
 495 static inline int wpa_drv_channel_info(struct wpa_supplicant *wpa_s,
 496                                        struct wpa_channel_info *ci)
 497 {
 498         if (wpa_s->driver->channel_info)
 499                 return wpa_s->driver->channel_info(wpa_s->drv_priv, ci);
 500         return -1;
 501 }
 502
 503 static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
 504                                       struct hostap_sta_driver_data *sta)
 505 {
 506         if (wpa_s->driver->read_sta_data)
 507                 return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
 508                                                     wpa_s->bssid);
 509         return -1;
 510 }
 511
 512 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 513                                         const struct wpabuf *beacon,
 514                                         const struct wpabuf *proberesp,
 515                                         const struct wpabuf *assocresp)
 516 {
 517         if (!wpa_s->driver->set_ap_wps_ie)
 518                 return -1;
 519         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 520                                             proberesp, assocresp);
 521 }
 522
 523 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
 524                                   u8 *buf, size_t buf_len)
 525 {
 526         if (!wpa_s->driver->get_noa)
 527                 return -1;
 528         return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
 529 }
 530
 531 static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
 532                                             int legacy_ps, int opp_ps,
 533                                             int ctwindow)
 534 {
 535         if (!wpa_s->driver->set_p2p_powersave)
 536                 return -1;
 537         return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
 538                                                 opp_ps, ctwindow);
 539 }
 540
 541 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
 542 {
 543         if (!wpa_s->driver->ampdu)
 544                 return -1;
 545         return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
 546 }
 547
 548 static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
 549                                          const u8 *dst, u8 action_code,
 550                                          u8 dialog_token, u16 status_code,
 551                                          u32 peer_capab, int initiator,
 552                                          const u8 *buf, size_t len)
 553 {
 554         if (wpa_s->driver->send_tdls_mgmt) {
 555                 return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
 556                                                      action_code, dialog_token,
 557                                                      status_code, peer_capab,
 558                                                      initiator, buf, len);
 559         }
 560         return -1;
 561 }
 562
 563 static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
 564                                     enum tdls_oper oper, const u8 *peer)
 565 {
 566         if (!wpa_s->driver->tdls_oper)
 567                 return -1;
 568         return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
 569 }
 570
 571 #ifdef ANDROID
 572 static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
 573                                      char *cmd, char *buf, size_t buf_len)
 574 {
 575         if (!wpa_s->driver->driver_cmd)
 576                 return -1;
 577         return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
 578 }
 579 #endif /* ANDROID */
 580
 581 static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
 582                                           const u8 *kek, size_t kek_len,
 583                                           const u8 *kck, size_t kck_len,
 584                                           const u8 *replay_ctr)
 585 {
 586         if (!wpa_s->driver->set_rekey_info)
 587                 return;
 588         wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kek_len,
 589                                       kck, kck_len, replay_ctr);
 590 }
 591
 592 static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
 593                                         int disabled)
 594 {
 595         if (!wpa_s->driver->radio_disable)
 596                 return -1;
 597         return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
 598 }
 599
 600 static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
 601                                          struct csa_settings *settings)
 602 {
 603         if (!wpa_s->driver->switch_channel)
 604                 return -1;
 605         return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
 606 }
 607
 608 static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
 609                                  const u8 *address, u8 user_priority,
 610                                  u16 admitted_time)
 611 {
 612         if (!wpa_s->driver->add_tx_ts)
 613                 return -1;
 614         return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
 615                                         user_priority, admitted_time);
 616 }
 617
 618 static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
 619                                  const u8 *address)
 620 {
 621         if (!wpa_s->driver->del_tx_ts)
 622                 return -1;
 623         return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
 624 }
 625
 626 static inline int wpa_drv_tdls_enable_channel_switch(
 627         struct wpa_supplicant *wpa_s, const u8 *addr, u8 oper_class,
 628         const struct hostapd_freq_params *freq_params)
 629 {
 630         if (!wpa_s->driver->tdls_enable_channel_switch)
 631                 return -1;
 632         return wpa_s->driver->tdls_enable_channel_switch(wpa_s->drv_priv, addr,
 633                                                          oper_class,
 634                                                          freq_params);
 635 }
 636
 637 static inline int
 638 wpa_drv_tdls_disable_channel_switch(struct wpa_supplicant *wpa_s,
 639                                     const u8 *addr)
 640 {
 641         if (!wpa_s->driver->tdls_disable_channel_switch)
 642                 return -1;
 643         return wpa_s->driver->tdls_disable_channel_switch(wpa_s->drv_priv,
 644                                                           addr);
 645 }
 646
 647 static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
 648                                    enum wnm_oper oper, const u8 *peer,
 649                                    u8 *buf, u16 *buf_len)
 650 {
 651         if (!wpa_s->driver->wnm_oper)
 652                 return -1;
 653         return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
 654                                        buf_len);
 655 }
 656
 657 static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
 658                                  char *buf, size_t buflen)
 659 {
 660         if (!wpa_s->driver->status)
 661                 return -1;
 662         return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
 663 }
 664
 665 static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
 666                                       const u8 *qos_map_set, u8 qos_map_set_len)
 667 {
 668         if (!wpa_s->driver->set_qos_map)
 669                 return -1;
 670         return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
 671                                           qos_map_set_len);
 672 }
 673
 674 static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
 675                                  const struct wowlan_triggers *triggers)
 676 {
 677         if (!wpa_s->driver->set_wowlan)
 678                 return -1;
 679         return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
 680 }
 681
 682 static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
 683                                      int vendor_id, int subcmd, const u8 *data,
 684                                      size_t data_len, struct wpabuf *buf)
 685 {
 686         if (!wpa_s->driver->vendor_cmd)
 687                 return -1;
 688         return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
 689                                          data, data_len, buf);
 690 }
 691
 692 static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
 693                                   const u8 *bssid)
 694 {
 695         if (!wpa_s->driver->roaming)
 696                 return -1;
 697         return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
 698 }
 699
 700 static inline int wpa_drv_disable_fils(struct wpa_supplicant *wpa_s,
 701                                        int disable)
 702 {
 703         if (!wpa_s->driver->disable_fils)
 704                 return -1;
 705         return wpa_s->driver->disable_fils(wpa_s->drv_priv, disable);
 706 }
 707
 708 static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
 709                                        const u8 *addr)
 710 {
 711         if (!wpa_s->driver->set_mac_addr)
 712                 return -1;
 713         return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
 714 }
 715
 716
 717 #ifdef CONFIG_MACSEC
 718
 719 static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
 720                                       struct macsec_init_params *params)
 721 {
 722         if (!wpa_s->driver->macsec_init)
 723                 return -1;
 724         return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
 725 }
 726
 727 static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
 728 {
 729         if (!wpa_s->driver->macsec_deinit)
 730                 return -1;
 731         return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
 732 }
 733
 734 static inline int wpa_drv_macsec_get_capability(struct wpa_supplicant *wpa_s,
 735                                                 enum macsec_cap *cap)
 736 {
 737         if (!wpa_s->driver->macsec_get_capability)
 738                 return -1;
 739         return wpa_s->driver->macsec_get_capability(wpa_s->drv_priv, cap);
 740 }
 741
 742 static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
 743                                                 Boolean enabled)
 744 {
 745         if (!wpa_s->driver->enable_protect_frames)
 746                 return -1;
 747         return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
 748 }
 749
 750 static inline int wpa_drv_enable_encrypt(struct wpa_supplicant *wpa_s,
 751                                                 Boolean enabled)
 752 {
 753         if (!wpa_s->driver->enable_encrypt)
 754                 return -1;
 755         return wpa_s->driver->enable_encrypt(wpa_s->drv_priv, enabled);
 756 }
 757
 758 static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
 759                                              Boolean enabled, u32 window)
 760 {
 761         if (!wpa_s->driver->set_replay_protect)
 762                 return -1;
 763         return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
 764                                                  window);
 765 }
 766
 767 static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
 768                                                    u64 cs)
 769 {
 770         if (!wpa_s->driver->set_current_cipher_suite)
 771                 return -1;
 772         return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
 773 }
 774
 775 static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
 776                                                  Boolean enabled)
 777 {
 778         if (!wpa_s->driver->enable_controlled_port)
 779                 return -1;
 780         return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
 781 }
 782
 783 static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
 784                                                 struct receive_sa *sa)
 785 {
 786         if (!wpa_s->driver->get_receive_lowest_pn)
 787                 return -1;
 788         return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, sa);
 789 }
 790
 791 static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
 792                                                 struct transmit_sa *sa)
 793 {
 794         if (!wpa_s->driver->get_transmit_next_pn)
 795                 return -1;
 796         return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, sa);
 797 }
 798
 799 static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
 800                                                 struct transmit_sa *sa)
 801 {
 802         if (!wpa_s->driver->set_transmit_next_pn)
 803                 return -1;
 804         return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, sa);
 805 }
 806
 807 static inline int wpa_drv_set_receive_lowest_pn(struct wpa_supplicant *wpa_s,
 808                                                 struct receive_sa *sa)
 809 {
 810         if (!wpa_s->driver->set_receive_lowest_pn)
 811                 return -1;
 812         return wpa_s->driver->set_receive_lowest_pn(wpa_s->drv_priv, sa);
 813 }
 814
 815 static inline int
 816 wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, struct receive_sc *sc,
 817                           unsigned int conf_offset, int validation)
 818 {
 819         if (!wpa_s->driver->create_receive_sc)
 820                 return -1;
 821         return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, sc,
 822                                                 conf_offset, validation);
 823 }
 824
 825 static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
 826                                             struct receive_sc *sc)
 827 {
 828         if (!wpa_s->driver->delete_receive_sc)
 829                 return -1;
 830         return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, sc);
 831 }
 832
 833 static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
 834                                             struct receive_sa *sa)
 835 {
 836         if (!wpa_s->driver->create_receive_sa)
 837                 return -1;
 838         return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, sa);
 839 }
 840
 841 static inline int wpa_drv_delete_receive_sa(struct wpa_supplicant *wpa_s,
 842                                             struct receive_sa *sa)
 843 {
 844         if (!wpa_s->driver->delete_receive_sa)
 845                 return -1;
 846         return wpa_s->driver->delete_receive_sa(wpa_s->drv_priv, sa);
 847 }
 848
 849 static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
 850                                             struct receive_sa *sa)
 851 {
 852         if (!wpa_s->driver->enable_receive_sa)
 853                 return -1;
 854         return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, sa);
 855 }
 856
 857 static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
 858                                              struct receive_sa *sa)
 859 {
 860         if (!wpa_s->driver->disable_receive_sa)
 861                 return -1;
 862         return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, sa);
 863 }
 864
 865 static inline int
 866 wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, struct transmit_sc *sc,
 867                            unsigned int conf_offset)
 868 {
 869         if (!wpa_s->driver->create_transmit_sc)
 870                 return -1;
 871         return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, sc,
 872                                                  conf_offset);
 873 }
 874
 875 static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
 876                                              struct transmit_sc *sc)
 877 {
 878         if (!wpa_s->driver->delete_transmit_sc)
 879                 return -1;
 880         return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, sc);
 881 }
 882
 883 static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
 884                                              struct transmit_sa *sa)
 885 {
 886         if (!wpa_s->driver->create_transmit_sa)
 887                 return -1;
 888         return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, sa);
 889 }
 890
 891 static inline int wpa_drv_delete_transmit_sa(struct wpa_supplicant *wpa_s,
 892                                              struct transmit_sa *sa)
 893 {
 894         if (!wpa_s->driver->delete_transmit_sa)
 895                 return -1;
 896         return wpa_s->driver->delete_transmit_sa(wpa_s->drv_priv, sa);
 897 }
 898
 899 static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
 900                                              struct transmit_sa *sa)
 901 {
 902         if (!wpa_s->driver->enable_transmit_sa)
 903                 return -1;
 904         return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, sa);
 905 }
 906
 907 static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
 908                                               struct transmit_sa *sa)
 909 {
 910         if (!wpa_s->driver->disable_transmit_sa)
 911                 return -1;
 912         return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, sa);
 913 }
 914 #endif /* CONFIG_MACSEC */
 915
 916 static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
 917                                   enum set_band band)
 918 {
 919         if (!wpa_s->driver->set_band)
 920                 return -1;
 921         return wpa_s->driver->set_band(wpa_s->drv_priv, band);
 922 }
 923
 924 static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
 925                                              enum wpa_driver_if_type if_type,
 926                                              unsigned int *num,
 927                                              unsigned int *freq_list)
 928 {
 929 #ifdef CONFIG_TESTING_OPTIONS
 930         if (wpa_s->get_pref_freq_list_override)
 931                 return wpas_ctrl_iface_get_pref_freq_list_override(
 932                         wpa_s, if_type, num, freq_list);
 933 #endif /* CONFIG_TESTING_OPTIONS */
 934         if (!wpa_s->driver->get_pref_freq_list)
 935                 return -1;
 936         return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
 937                                                  num, freq_list);
 938 }
 939
 940 static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
 941                                              unsigned int freq)
 942 {
 943         if (!wpa_s->driver->set_prob_oper_freq)
 944                 return 0;
 945         return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
 946 }
 947
 948 static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s,
 949                                      u64 scan_cookie)
 950 {
 951         if (!wpa_s->driver->abort_scan)
 952                 return -1;
 953         return wpa_s->driver->abort_scan(wpa_s->drv_priv, scan_cookie);
 954 }
 955
 956 static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
 957                                                   u32 filters)
 958 {
 959         if (!wpa_s->driver->configure_data_frame_filters)
 960                 return -1;
 961         return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
 962                                                            filters);
 963 }
 964
 965 static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
 966                                        enum wpa_driver_if_type type)
 967 {
 968         if (!wpa_s->driver->get_ext_capab)
 969                 return -1;
 970         return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
 971                                             &wpa_s->extended_capa,
 972                                             &wpa_s->extended_capa_mask,
 973                                             &wpa_s->extended_capa_len);
 974 }
 975
 976 static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
 977                                        unsigned int channel,
 978                                        unsigned int period,
 979                                        unsigned int interval,
 980                                        unsigned int count,
 981                                        const u8 *device_types,
 982                                        size_t dev_types_len,
 983                                        const u8 *ies, size_t ies_len)
 984 {
 985         if (!wpa_s->driver->p2p_lo_start)
 986                 return -1;
 987         return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
 988                                            interval, count, device_types,
 989                                            dev_types_len, ies, ies_len);
 990 }
 991
 992 static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
 993 {
 994         if (!wpa_s->driver->p2p_lo_stop)
 995                 return -1;
 996         return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
 997 }
 998
 999 static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
1000                                                const u8 *ies, size_t len)
1001 {
1002         if (!wpa_s->driver->set_default_scan_ies)
1003                 return -1;
1004         return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
1005 }
1006
1007 static inline int wpa_drv_set_tdls_mode(struct wpa_supplicant *wpa_s,
1008                                         int tdls_external_control)
1009 {
1010         if (!wpa_s->driver->set_tdls_mode)
1011                 return -1;
1012         return wpa_s->driver->set_tdls_mode(wpa_s->drv_priv,
1013                                             tdls_external_control);
1014 }
1015
1016 static inline struct wpa_bss_candidate_info *
1017 wpa_drv_get_bss_trans_status(struct wpa_supplicant *wpa_s,
1018                              struct wpa_bss_trans_info *params)
1019 {
1020         if (!wpa_s->driver->get_bss_transition_status)
1021                 return NULL;
1022         return wpa_s->driver->get_bss_transition_status(wpa_s->drv_priv,
1023                                                         params);
1024 }
1025
1026 static inline int wpa_drv_ignore_assoc_disallow(struct wpa_supplicant *wpa_s,
1027                                                 int val)
1028 {
1029         if (!wpa_s->driver->ignore_assoc_disallow)
1030                 return -1;
1031         return wpa_s->driver->ignore_assoc_disallow(wpa_s->drv_priv, val);
1032 }
1033
1034 static inline int wpa_drv_set_bssid_blacklist(struct wpa_supplicant *wpa_s,
1035                                               unsigned int num_bssid,
1036                                               const u8 *bssids)
1037 {
1038         if (!wpa_s->driver->set_bssid_blacklist)
1039                 return -1;
1040         return wpa_s->driver->set_bssid_blacklist(wpa_s->drv_priv, num_bssid,
1041                                                   bssids);
1042 }
1043
1044 static inline int wpa_drv_update_connect_params(
1045         struct wpa_supplicant *wpa_s,
1046         struct wpa_driver_associate_params *params,
1047         enum wpa_drv_update_connect_params_mask mask)
1048 {
1049         if (!wpa_s->driver->update_connect_params)
1050                 return -1;
1051         return wpa_s->driver->update_connect_params(wpa_s->drv_priv, params,
1052                                                     mask);
1053 }
1054
1055 static inline int
1056 wpa_drv_send_external_auth_status(struct wpa_supplicant *wpa_s,
1057                                   struct external_auth *params)
1058 {
1059         if (!wpa_s->driver->send_external_auth_status)
1060                 return -1;
1061         return wpa_s->driver->send_external_auth_status(wpa_s->drv_priv,
1062                                                         params);
1063 }
1064
1065 static inline int wpa_drv_set_4addr_mode(struct wpa_supplicant *wpa_s, int val)
1066 {
1067         if (!wpa_s->driver->set_4addr_mode)
1068                 return -1;
1069         return wpa_s->driver->set_4addr_mode(wpa_s->drv_priv,
1070                                              wpa_s->bridge_ifname, val);
1071 }
1072
1073 #endif /* DRIVER_I_H */