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_pktcnt_poll(struct wpa_supplicant *wpa_s,
 496                                       struct hostap_sta_driver_data *sta)
 497 {
 498         if (wpa_s->driver->read_sta_data)
 499                 return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
 500                                                     wpa_s->bssid);
 501         return -1;
 502 }
 503
 504 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 505                                         const struct wpabuf *beacon,
 506                                         const struct wpabuf *proberesp,
 507                                         const struct wpabuf *assocresp)
 508 {
 509         if (!wpa_s->driver->set_ap_wps_ie)
 510                 return -1;
 511         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 512                                             proberesp, assocresp);
 513 }
 514
 515 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
 516                                   u8 *buf, size_t buf_len)
 517 {
 518         if (!wpa_s->driver->get_noa)
 519                 return -1;
 520         return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
 521 }
 522
 523 static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
 524                                             int legacy_ps, int opp_ps,
 525                                             int ctwindow)
 526 {
 527         if (!wpa_s->driver->set_p2p_powersave)
 528                 return -1;
 529         return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
 530                                                 opp_ps, ctwindow);
 531 }
 532
 533 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
 534 {
 535         if (!wpa_s->driver->ampdu)
 536                 return -1;
 537         return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
 538 }
 539
 540 static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
 541                                          const u8 *dst, u8 action_code,
 542                                          u8 dialog_token, u16 status_code,
 543                                          u32 peer_capab, int initiator,
 544                                          const u8 *buf, size_t len)
 545 {
 546         if (wpa_s->driver->send_tdls_mgmt) {
 547                 return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
 548                                                      action_code, dialog_token,
 549                                                      status_code, peer_capab,
 550                                                      initiator, buf, len);
 551         }
 552         return -1;
 553 }
 554
 555 static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
 556                                     enum tdls_oper oper, const u8 *peer)
 557 {
 558         if (!wpa_s->driver->tdls_oper)
 559                 return -1;
 560         return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
 561 }
 562
 563 #ifdef ANDROID
 564 static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
 565                                      char *cmd, char *buf, size_t buf_len)
 566 {
 567         if (!wpa_s->driver->driver_cmd)
 568                 return -1;
 569         return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
 570 }
 571 #endif /* ANDROID */
 572
 573 static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
 574                                           const u8 *kek, size_t kek_len,
 575                                           const u8 *kck, size_t kck_len,
 576                                           const u8 *replay_ctr)
 577 {
 578         if (!wpa_s->driver->set_rekey_info)
 579                 return;
 580         wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kek_len,
 581                                       kck, kck_len, replay_ctr);
 582 }
 583
 584 static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
 585                                         int disabled)
 586 {
 587         if (!wpa_s->driver->radio_disable)
 588                 return -1;
 589         return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
 590 }
 591
 592 static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
 593                                          struct csa_settings *settings)
 594 {
 595         if (!wpa_s->driver->switch_channel)
 596                 return -1;
 597         return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
 598 }
 599
 600 static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
 601                                  const u8 *address, u8 user_priority,
 602                                  u16 admitted_time)
 603 {
 604         if (!wpa_s->driver->add_tx_ts)
 605                 return -1;
 606         return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
 607                                         user_priority, admitted_time);
 608 }
 609
 610 static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
 611                                  const u8 *address)
 612 {
 613         if (!wpa_s->driver->del_tx_ts)
 614                 return -1;
 615         return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
 616 }
 617
 618 static inline int wpa_drv_tdls_enable_channel_switch(
 619         struct wpa_supplicant *wpa_s, const u8 *addr, u8 oper_class,
 620         const struct hostapd_freq_params *freq_params)
 621 {
 622         if (!wpa_s->driver->tdls_enable_channel_switch)
 623                 return -1;
 624         return wpa_s->driver->tdls_enable_channel_switch(wpa_s->drv_priv, addr,
 625                                                          oper_class,
 626                                                          freq_params);
 627 }
 628
 629 static inline int
 630 wpa_drv_tdls_disable_channel_switch(struct wpa_supplicant *wpa_s,
 631                                     const u8 *addr)
 632 {
 633         if (!wpa_s->driver->tdls_disable_channel_switch)
 634                 return -1;
 635         return wpa_s->driver->tdls_disable_channel_switch(wpa_s->drv_priv,
 636                                                           addr);
 637 }
 638
 639 static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
 640                                    enum wnm_oper oper, const u8 *peer,
 641                                    u8 *buf, u16 *buf_len)
 642 {
 643         if (!wpa_s->driver->wnm_oper)
 644                 return -1;
 645         return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
 646                                        buf_len);
 647 }
 648
 649 static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
 650                                  char *buf, size_t buflen)
 651 {
 652         if (!wpa_s->driver->status)
 653                 return -1;
 654         return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
 655 }
 656
 657 static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
 658                                       const u8 *qos_map_set, u8 qos_map_set_len)
 659 {
 660         if (!wpa_s->driver->set_qos_map)
 661                 return -1;
 662         return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
 663                                           qos_map_set_len);
 664 }
 665
 666 static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
 667                                  const struct wowlan_triggers *triggers)
 668 {
 669         if (!wpa_s->driver->set_wowlan)
 670                 return -1;
 671         return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
 672 }
 673
 674 static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
 675                                      int vendor_id, int subcmd, const u8 *data,
 676                                      size_t data_len, struct wpabuf *buf)
 677 {
 678         if (!wpa_s->driver->vendor_cmd)
 679                 return -1;
 680         return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
 681                                          data, data_len, buf);
 682 }
 683
 684 static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
 685                                   const u8 *bssid)
 686 {
 687         if (!wpa_s->driver->roaming)
 688                 return -1;
 689         return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
 690 }
 691
 692 static inline int wpa_drv_disable_fils(struct wpa_supplicant *wpa_s,
 693                                        int disable)
 694 {
 695         if (!wpa_s->driver->disable_fils)
 696                 return -1;
 697         return wpa_s->driver->disable_fils(wpa_s->drv_priv, disable);
 698 }
 699
 700 static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
 701                                        const u8 *addr)
 702 {
 703         if (!wpa_s->driver->set_mac_addr)
 704                 return -1;
 705         return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
 706 }
 707
 708
 709 #ifdef CONFIG_MACSEC
 710
 711 static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
 712                                       struct macsec_init_params *params)
 713 {
 714         if (!wpa_s->driver->macsec_init)
 715                 return -1;
 716         return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
 717 }
 718
 719 static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
 720 {
 721         if (!wpa_s->driver->macsec_deinit)
 722                 return -1;
 723         return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
 724 }
 725
 726 static inline int wpa_drv_macsec_get_capability(struct wpa_supplicant *wpa_s,
 727                                                 enum macsec_cap *cap)
 728 {
 729         if (!wpa_s->driver->macsec_get_capability)
 730                 return -1;
 731         return wpa_s->driver->macsec_get_capability(wpa_s->drv_priv, cap);
 732 }
 733
 734 static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
 735                                                 Boolean enabled)
 736 {
 737         if (!wpa_s->driver->enable_protect_frames)
 738                 return -1;
 739         return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
 740 }
 741
 742 static inline int wpa_drv_enable_encrypt(struct wpa_supplicant *wpa_s,
 743                                                 Boolean enabled)
 744 {
 745         if (!wpa_s->driver->enable_encrypt)
 746                 return -1;
 747         return wpa_s->driver->enable_encrypt(wpa_s->drv_priv, enabled);
 748 }
 749
 750 static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
 751                                              Boolean enabled, u32 window)
 752 {
 753         if (!wpa_s->driver->set_replay_protect)
 754                 return -1;
 755         return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
 756                                                  window);
 757 }
 758
 759 static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
 760                                                    u64 cs)
 761 {
 762         if (!wpa_s->driver->set_current_cipher_suite)
 763                 return -1;
 764         return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
 765 }
 766
 767 static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
 768                                                  Boolean enabled)
 769 {
 770         if (!wpa_s->driver->enable_controlled_port)
 771                 return -1;
 772         return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
 773 }
 774
 775 static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
 776                                                 struct receive_sa *sa)
 777 {
 778         if (!wpa_s->driver->get_receive_lowest_pn)
 779                 return -1;
 780         return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, sa);
 781 }
 782
 783 static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
 784                                                 struct transmit_sa *sa)
 785 {
 786         if (!wpa_s->driver->get_transmit_next_pn)
 787                 return -1;
 788         return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, sa);
 789 }
 790
 791 static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
 792                                                 struct transmit_sa *sa)
 793 {
 794         if (!wpa_s->driver->set_transmit_next_pn)
 795                 return -1;
 796         return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, sa);
 797 }
 798
 799 static inline int
 800 wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, struct receive_sc *sc,
 801                           unsigned int conf_offset, int validation)
 802 {
 803         if (!wpa_s->driver->create_receive_sc)
 804                 return -1;
 805         return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, sc,
 806                                                 conf_offset, validation);
 807 }
 808
 809 static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
 810                                             struct receive_sc *sc)
 811 {
 812         if (!wpa_s->driver->delete_receive_sc)
 813                 return -1;
 814         return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, sc);
 815 }
 816
 817 static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
 818                                             struct receive_sa *sa)
 819 {
 820         if (!wpa_s->driver->create_receive_sa)
 821                 return -1;
 822         return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, sa);
 823 }
 824
 825 static inline int wpa_drv_delete_receive_sa(struct wpa_supplicant *wpa_s,
 826                                             struct receive_sa *sa)
 827 {
 828         if (!wpa_s->driver->delete_receive_sa)
 829                 return -1;
 830         return wpa_s->driver->delete_receive_sa(wpa_s->drv_priv, sa);
 831 }
 832
 833 static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
 834                                             struct receive_sa *sa)
 835 {
 836         if (!wpa_s->driver->enable_receive_sa)
 837                 return -1;
 838         return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, sa);
 839 }
 840
 841 static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
 842                                              struct receive_sa *sa)
 843 {
 844         if (!wpa_s->driver->disable_receive_sa)
 845                 return -1;
 846         return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, sa);
 847 }
 848
 849 static inline int
 850 wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, struct transmit_sc *sc,
 851                            unsigned int conf_offset)
 852 {
 853         if (!wpa_s->driver->create_transmit_sc)
 854                 return -1;
 855         return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, sc,
 856                                                  conf_offset);
 857 }
 858
 859 static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
 860                                              struct transmit_sc *sc)
 861 {
 862         if (!wpa_s->driver->delete_transmit_sc)
 863                 return -1;
 864         return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, sc);
 865 }
 866
 867 static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
 868                                              struct transmit_sa *sa)
 869 {
 870         if (!wpa_s->driver->create_transmit_sa)
 871                 return -1;
 872         return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, sa);
 873 }
 874
 875 static inline int wpa_drv_delete_transmit_sa(struct wpa_supplicant *wpa_s,
 876                                              struct transmit_sa *sa)
 877 {
 878         if (!wpa_s->driver->delete_transmit_sa)
 879                 return -1;
 880         return wpa_s->driver->delete_transmit_sa(wpa_s->drv_priv, sa);
 881 }
 882
 883 static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
 884                                              struct transmit_sa *sa)
 885 {
 886         if (!wpa_s->driver->enable_transmit_sa)
 887                 return -1;
 888         return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, sa);
 889 }
 890
 891 static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
 892                                               struct transmit_sa *sa)
 893 {
 894         if (!wpa_s->driver->disable_transmit_sa)
 895                 return -1;
 896         return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, sa);
 897 }
 898 #endif /* CONFIG_MACSEC */
 899
 900 static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
 901                                   enum set_band band)
 902 {
 903         if (!wpa_s->driver->set_band)
 904                 return -1;
 905         return wpa_s->driver->set_band(wpa_s->drv_priv, band);
 906 }
 907
 908 static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
 909                                              enum wpa_driver_if_type if_type,
 910                                              unsigned int *num,
 911                                              unsigned int *freq_list)
 912 {
 913 #ifdef CONFIG_TESTING_OPTIONS
 914         if (wpa_s->get_pref_freq_list_override)
 915                 return wpas_ctrl_iface_get_pref_freq_list_override(
 916                         wpa_s, if_type, num, freq_list);
 917 #endif /* CONFIG_TESTING_OPTIONS */
 918         if (!wpa_s->driver->get_pref_freq_list)
 919                 return -1;
 920         return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
 921                                                  num, freq_list);
 922 }
 923
 924 static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
 925                                              unsigned int freq)
 926 {
 927         if (!wpa_s->driver->set_prob_oper_freq)
 928                 return 0;
 929         return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
 930 }
 931
 932 static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s,
 933                                      u64 scan_cookie)
 934 {
 935         if (!wpa_s->driver->abort_scan)
 936                 return -1;
 937         return wpa_s->driver->abort_scan(wpa_s->drv_priv, scan_cookie);
 938 }
 939
 940 static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
 941                                                   u32 filters)
 942 {
 943         if (!wpa_s->driver->configure_data_frame_filters)
 944                 return -1;
 945         return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
 946                                                            filters);
 947 }
 948
 949 static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
 950                                        enum wpa_driver_if_type type)
 951 {
 952         if (!wpa_s->driver->get_ext_capab)
 953                 return -1;
 954         return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
 955                                             &wpa_s->extended_capa,
 956                                             &wpa_s->extended_capa_mask,
 957                                             &wpa_s->extended_capa_len);
 958 }
 959
 960 static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
 961                                        unsigned int channel,
 962                                        unsigned int period,
 963                                        unsigned int interval,
 964                                        unsigned int count,
 965                                        const u8 *device_types,
 966                                        size_t dev_types_len,
 967                                        const u8 *ies, size_t ies_len)
 968 {
 969         if (!wpa_s->driver->p2p_lo_start)
 970                 return -1;
 971         return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
 972                                            interval, count, device_types,
 973                                            dev_types_len, ies, ies_len);
 974 }
 975
 976 static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
 977 {
 978         if (!wpa_s->driver->p2p_lo_stop)
 979                 return -1;
 980         return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
 981 }
 982
 983 static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
 984                                                const u8 *ies, size_t len)
 985 {
 986         if (!wpa_s->driver->set_default_scan_ies)
 987                 return -1;
 988         return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
 989 }
 990
 991 static inline int wpa_drv_set_tdls_mode(struct wpa_supplicant *wpa_s,
 992                                         int tdls_external_control)
 993 {
 994         if (!wpa_s->driver->set_tdls_mode)
 995                 return -1;
 996         return wpa_s->driver->set_tdls_mode(wpa_s->drv_priv,
 997                                             tdls_external_control);
 998 }
 999
1000 static inline struct wpa_bss_candidate_info *
1001 wpa_drv_get_bss_trans_status(struct wpa_supplicant *wpa_s,
1002                              struct wpa_bss_trans_info *params)
1003 {
1004         if (!wpa_s->driver->get_bss_transition_status)
1005                 return NULL;
1006         return wpa_s->driver->get_bss_transition_status(wpa_s->drv_priv,
1007                                                         params);
1008 }
1009
1010 static inline int wpa_drv_ignore_assoc_disallow(struct wpa_supplicant *wpa_s,
1011                                                 int val)
1012 {
1013         if (!wpa_s->driver->ignore_assoc_disallow)
1014                 return -1;
1015         return wpa_s->driver->ignore_assoc_disallow(wpa_s->drv_priv, val);
1016 }
1017
1018 static inline int wpa_drv_set_bssid_blacklist(struct wpa_supplicant *wpa_s,
1019                                               unsigned int num_bssid,
1020                                               const u8 *bssids)
1021 {
1022         if (!wpa_s->driver->set_bssid_blacklist)
1023                 return -1;
1024         return wpa_s->driver->set_bssid_blacklist(wpa_s->drv_priv, num_bssid,
1025                                                   bssids);
1026 }
1027
1028 static inline int wpa_drv_update_connect_params(
1029         struct wpa_supplicant *wpa_s,
1030         struct wpa_driver_associate_params *params,
1031         enum wpa_drv_update_connect_params_mask mask)
1032 {
1033         if (!wpa_s->driver->update_connect_params)
1034                 return -1;
1035         return wpa_s->driver->update_connect_params(wpa_s->drv_priv, params,
1036                                                     mask);
1037 }
1038
1039 static inline int
1040 wpa_drv_send_external_auth_status(struct wpa_supplicant *wpa_s,
1041                                   struct external_auth *params)
1042 {
1043         if (!wpa_s->driver->send_external_auth_status)
1044                 return -1;
1045         return wpa_s->driver->send_external_auth_status(wpa_s->drv_priv,
1046                                                         params);
1047 }
1048
1049 #endif /* DRIVER_I_H */