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