wpa_supplicant/driver_i.h

   1 /*
   2  * wpa_supplicant - Internal driver interface wrappers
   3  * Copyright (c) 2003-2009, 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         if (wpa_s->driver->scan2)
  94                 return wpa_s->driver->scan2(wpa_s->drv_priv, params);
  95         return -1;
  96 }
  97
  98 static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
  99                                      struct wpa_driver_scan_params *params,
 100                                      u32 interval)
 101 {
 102         if (wpa_s->driver->sched_scan)
 103                 return wpa_s->driver->sched_scan(wpa_s->drv_priv,
 104                                                  params, interval);
 105         return -1;
 106 }
 107
 108 static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
 109 {
 110         if (wpa_s->driver->stop_sched_scan)
 111                 return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
 112         return -1;
 113 }
 114
 115 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
 116         struct wpa_supplicant *wpa_s)
 117 {
 118         if (wpa_s->driver->get_scan_results2)
 119                 return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
 120         return NULL;
 121 }
 122
 123 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
 124 {
 125         if (wpa_s->driver->get_bssid) {
 126                 return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
 127         }
 128         return -1;
 129 }
 130
 131 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
 132 {
 133         if (wpa_s->driver->get_ssid) {
 134                 return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
 135         }
 136         return -1;
 137 }
 138
 139 static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
 140                                   enum wpa_alg alg, const u8 *addr,
 141                                   int key_idx, int set_tx,
 142                                   const u8 *seq, size_t seq_len,
 143                                   const u8 *key, size_t key_len)
 144 {
 145         if (alg != WPA_ALG_NONE) {
 146                 if (key_idx >= 0 && key_idx <= 6)
 147                         wpa_s->keys_cleared &= ~BIT(key_idx);
 148                 else
 149                         wpa_s->keys_cleared = 0;
 150         }
 151         if (wpa_s->driver->set_key) {
 152                 return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
 153                                               alg, addr, key_idx, set_tx,
 154                                               seq, seq_len, key, key_len);
 155         }
 156         return -1;
 157 }
 158
 159 static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
 160                                      const u8 *addr, int reason_code)
 161 {
 162         if (wpa_s->driver->sta_deauth) {
 163                 return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
 164                                                  wpa_s->own_addr, addr,
 165                                                  reason_code);
 166         }
 167         return -1;
 168 }
 169
 170 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
 171                                          const u8 *addr, int reason_code)
 172 {
 173         if (wpa_s->driver->deauthenticate) {
 174                 return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
 175                                                      reason_code);
 176         }
 177         return -1;
 178 }
 179
 180 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
 181                                     const u8 *bssid, const u8 *pmkid)
 182 {
 183         if (wpa_s->driver->add_pmkid) {
 184                 return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
 185         }
 186         return -1;
 187 }
 188
 189 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
 190                                        const u8 *bssid, const u8 *pmkid)
 191 {
 192         if (wpa_s->driver->remove_pmkid) {
 193                 return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
 194                                                    pmkid);
 195         }
 196         return -1;
 197 }
 198
 199 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
 200 {
 201         if (wpa_s->driver->flush_pmkid) {
 202                 return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
 203         }
 204         return -1;
 205 }
 206
 207 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
 208                                    struct wpa_driver_capa *capa)
 209 {
 210         if (wpa_s->driver->get_capa) {
 211                 return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
 212         }
 213         return -1;
 214 }
 215
 216 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
 217 {
 218         if (wpa_s->driver->poll) {
 219                 wpa_s->driver->poll(wpa_s->drv_priv);
 220         }
 221 }
 222
 223 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
 224 {
 225         if (wpa_s->driver->get_ifname) {
 226                 return wpa_s->driver->get_ifname(wpa_s->drv_priv);
 227         }
 228         return NULL;
 229 }
 230
 231 static inline const char *
 232 wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
 233 {
 234         if (wpa_s->driver->get_radio_name)
 235                 return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
 236         return NULL;
 237 }
 238
 239 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
 240 {
 241         if (wpa_s->driver->get_mac_addr) {
 242                 return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
 243         }
 244         return NULL;
 245 }
 246
 247 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
 248                                         int state)
 249 {
 250         if (wpa_s->driver->set_operstate)
 251                 return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
 252         return 0;
 253 }
 254
 255 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
 256                                              const u8 *addr, int protect_type,
 257                                              int key_type)
 258 {
 259         if (wpa_s->driver->mlme_setprotection)
 260                 return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
 261                                                          protect_type,
 262                                                          key_type);
 263         return 0;
 264 }
 265
 266 static inline struct hostapd_hw_modes *
 267 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
 268                             u16 *flags)
 269 {
 270         if (wpa_s->driver->get_hw_feature_data)
 271                 return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
 272                                                           num_modes, flags);
 273         return NULL;
 274 }
 275
 276 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 277                                       const char *alpha2)
 278 {
 279         if (wpa_s->driver->set_country)
 280                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 281         return 0;
 282 }
 283
 284 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 285                                     const u8 *data, size_t data_len, int noack)
 286 {
 287         if (wpa_s->driver->send_mlme)
 288                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 289                                                 data, data_len, noack);
 290         return -1;
 291 }
 292
 293 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 294                                         const u8 *md,
 295                                         const u8 *ies, size_t ies_len)
 296 {
 297         if (wpa_s->driver->update_ft_ies)
 298                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 299                                                     ies, ies_len);
 300         return -1;
 301 }
 302
 303 static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
 304                                  struct wpa_driver_ap_params *params)
 305 {
 306         if (wpa_s->driver->set_ap)
 307                 return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
 308         return -1;
 309 }
 310
 311 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 312                                   struct hostapd_sta_add_params *params)
 313 {
 314         if (wpa_s->driver->sta_add)
 315                 return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
 316         return -1;
 317 }
 318
 319 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 320                                      const u8 *addr)
 321 {
 322         if (wpa_s->driver->sta_remove)
 323                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 324         return -1;
 325 }
 326
 327 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 328                                           const u8 *addr, const u8 *data,
 329                                           size_t data_len, int encrypt,
 330                                           const u8 *own_addr, u32 flags)
 331 {
 332         if (wpa_s->driver->hapd_send_eapol)
 333                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 334                                                       data, data_len, encrypt,
 335                                                       own_addr, flags);
 336         return -1;
 337 }
 338
 339 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 340                                         const u8 *addr, int total_flags,
 341                                         int flags_or, int flags_and)
 342 {
 343         if (wpa_s->driver->sta_set_flags)
 344                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 345                                                     total_flags, flags_or,
 346                                                     flags_and);
 347         return -1;
 348 }
 349
 350 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 351                                         int authorized)
 352 {
 353         if (wpa_s->driver->set_supp_port) {
 354                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 355                                                     authorized);
 356         }
 357         return 0;
 358 }
 359
 360 static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
 361                                       unsigned int freq,
 362                                       unsigned int wait,
 363                                       const u8 *dst, const u8 *src,
 364                                       const u8 *bssid,
 365                                       const u8 *data, size_t data_len,
 366                                       int no_cck)
 367 {
 368         if (wpa_s->driver->send_action)
 369                 return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
 370                                                   wait, dst, src, bssid,
 371                                                   data, data_len, no_cck);
 372         return -1;
 373 }
 374
 375 static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
 376 {
 377         if (wpa_s->driver->send_action_cancel_wait)
 378                 wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
 379 }
 380
 381 static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
 382                                    struct hostapd_freq_params *freq)
 383 {
 384         if (wpa_s->driver->set_freq)
 385                 return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
 386         return -1;
 387 }
 388
 389 static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
 390                                  enum wpa_driver_if_type type,
 391                                  const char *ifname, const u8 *addr,
 392                                  void *bss_ctx, char *force_ifname,
 393                                  u8 *if_addr, const char *bridge)
 394 {
 395         if (wpa_s->driver->if_add)
 396                 return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
 397                                              addr, bss_ctx, NULL, force_ifname,
 398                                              if_addr, bridge, 0);
 399         return -1;
 400 }
 401
 402 static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
 403                                     enum wpa_driver_if_type type,
 404                                     const char *ifname)
 405 {
 406         if (wpa_s->driver->if_remove)
 407                 return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
 408         return -1;
 409 }
 410
 411 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
 412                                             unsigned int freq,
 413                                             unsigned int duration)
 414 {
 415         if (wpa_s->driver->remain_on_channel)
 416                 return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
 417                                                         duration);
 418         return -1;
 419 }
 420
 421 static inline int wpa_drv_cancel_remain_on_channel(
 422         struct wpa_supplicant *wpa_s)
 423 {
 424         if (wpa_s->driver->cancel_remain_on_channel)
 425                 return wpa_s->driver->cancel_remain_on_channel(
 426                         wpa_s->drv_priv);
 427         return -1;
 428 }
 429
 430 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
 431                                            int report)
 432 {
 433         if (wpa_s->driver->probe_req_report)
 434                 return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
 435                                                        report);
 436         return -1;
 437 }
 438
 439 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
 440 {
 441         if (wpa_s->driver->deinit_ap)
 442                 return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
 443         return 0;
 444 }
 445
 446 static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
 447 {
 448         if (wpa_s->driver->deinit_p2p_cli)
 449                 return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
 450         return 0;
 451 }
 452
 453 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
 454 {
 455         if (wpa_s->driver->suspend)
 456                 wpa_s->driver->suspend(wpa_s->drv_priv);
 457 }
 458
 459 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
 460 {
 461         if (wpa_s->driver->resume)
 462                 wpa_s->driver->resume(wpa_s->drv_priv);
 463 }
 464
 465 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
 466                                          int threshold, int hysteresis)
 467 {
 468         if (wpa_s->driver->signal_monitor)
 469                 return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
 470                                                      threshold, hysteresis);
 471         return -1;
 472 }
 473
 474 static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
 475                                       struct wpa_signal_info *si)
 476 {
 477         if (wpa_s->driver->signal_poll)
 478                 return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
 479         return -1;
 480 }
 481
 482 static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
 483                                       struct hostap_sta_driver_data *sta)
 484 {
 485         if (wpa_s->driver->read_sta_data)
 486                 return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
 487                                                     wpa_s->bssid);
 488         return -1;
 489 }
 490
 491 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 492                                         const struct wpabuf *beacon,
 493                                         const struct wpabuf *proberesp,
 494                                         const struct wpabuf *assocresp)
 495 {
 496         if (!wpa_s->driver->set_ap_wps_ie)
 497                 return -1;
 498         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 499                                             proberesp, assocresp);
 500 }
 501
 502 static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
 503 {
 504         if (!wpa_s->driver->shared_freq)
 505                 return -1;
 506         return wpa_s->driver->shared_freq(wpa_s->drv_priv);
 507 }
 508
 509 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
 510                                   u8 *buf, size_t buf_len)
 511 {
 512         if (!wpa_s->driver->get_noa)
 513                 return -1;
 514         return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
 515 }
 516
 517 static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
 518                                             int legacy_ps, int opp_ps,
 519                                             int ctwindow)
 520 {
 521         if (!wpa_s->driver->set_p2p_powersave)
 522                 return -1;
 523         return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
 524                                                 opp_ps, ctwindow);
 525 }
 526
 527 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
 528 {
 529         if (!wpa_s->driver->ampdu)
 530                 return -1;
 531         return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
 532 }
 533
 534 static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
 535                                          const u8 *dst, u8 action_code,
 536                                          u8 dialog_token, u16 status_code,
 537                                          u32 peer_capab, int initiator,
 538                                          const u8 *buf, size_t len)
 539 {
 540         if (wpa_s->driver->send_tdls_mgmt) {
 541                 return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
 542                                                      action_code, dialog_token,
 543                                                      status_code, peer_capab,
 544                                                      initiator, buf, len);
 545         }
 546         return -1;
 547 }
 548
 549 static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
 550                                     enum tdls_oper oper, const u8 *peer)
 551 {
 552         if (!wpa_s->driver->tdls_oper)
 553                 return -1;
 554         return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
 555 }
 556
 557 #ifdef ANDROID
 558 static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
 559                                      char *cmd, char *buf, size_t buf_len)
 560 {
 561         if (!wpa_s->driver->driver_cmd)
 562                 return -1;
 563         return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
 564 }
 565 #endif /* ANDROID */
 566
 567 static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
 568                                           const u8 *kek, const u8 *kck,
 569                                           const u8 *replay_ctr)
 570 {
 571         if (!wpa_s->driver->set_rekey_info)
 572                 return;
 573         wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
 574 }
 575
 576 static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
 577                                         int disabled)
 578 {
 579         if (!wpa_s->driver->radio_disable)
 580                 return -1;
 581         return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
 582 }
 583
 584 static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
 585                                          struct csa_settings *settings)
 586 {
 587         if (!wpa_s->driver->switch_channel)
 588                 return -1;
 589         return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
 590 }
 591
 592 static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
 593                                  const u8 *address, u8 user_priority,
 594                                  u16 admitted_time)
 595 {
 596         if (!wpa_s->driver->add_tx_ts)
 597                 return -1;
 598         return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
 599                                         user_priority, admitted_time);
 600 }
 601
 602 static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
 603                                  const u8 *address)
 604 {
 605         if (!wpa_s->driver->del_tx_ts)
 606                 return -1;
 607         return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
 608 }
 609
 610 static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
 611                                    enum wnm_oper oper, const u8 *peer,
 612                                    u8 *buf, u16 *buf_len)
 613 {
 614         if (!wpa_s->driver->wnm_oper)
 615                 return -1;
 616         return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
 617                                        buf_len);
 618 }
 619
 620 static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
 621                                  char *buf, size_t buflen)
 622 {
 623         if (!wpa_s->driver->status)
 624                 return -1;
 625         return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
 626 }
 627
 628 static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
 629                                       const u8 *qos_map_set, u8 qos_map_set_len)
 630 {
 631         if (!wpa_s->driver->set_qos_map)
 632                 return -1;
 633         return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
 634                                           qos_map_set_len);
 635 }
 636
 637 static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
 638                                  const struct wowlan_triggers *triggers)
 639 {
 640         if (!wpa_s->driver->set_wowlan)
 641                 return -1;
 642         return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
 643 }
 644
 645 static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
 646                                      int vendor_id, int subcmd, const u8 *data,
 647                                      size_t data_len, struct wpabuf *buf)
 648 {
 649         if (!wpa_s->driver->vendor_cmd)
 650                 return -1;
 651         return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
 652                                          data, data_len, buf);
 653 }
 654
 655 static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
 656                                   const u8 *bssid)
 657 {
 658         if (!wpa_s->driver->roaming)
 659                 return -1;
 660         return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
 661 }
 662
 663 static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
 664                                        const u8 *addr)
 665 {
 666         if (!wpa_s->driver->set_mac_addr)
 667                 return -1;
 668         return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
 669 }
 670
 671
 672 #ifdef CONFIG_MACSEC
 673
 674 static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
 675                                       struct macsec_init_params *params)
 676 {
 677         if (!wpa_s->driver->macsec_init)
 678                 return -1;
 679         return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
 680 }
 681
 682 static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
 683 {
 684         if (!wpa_s->driver->macsec_deinit)
 685                 return -1;
 686         return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
 687 }
 688
 689 static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
 690                                                 Boolean enabled)
 691 {
 692         if (!wpa_s->driver->enable_protect_frames)
 693                 return -1;
 694         return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
 695 }
 696
 697 static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
 698                                              Boolean enabled, u32 window)
 699 {
 700         if (!wpa_s->driver->set_replay_protect)
 701                 return -1;
 702         return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
 703                                                  window);
 704 }
 705
 706 static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
 707                                                    const u8 *cs, size_t cs_len)
 708 {
 709         if (!wpa_s->driver->set_current_cipher_suite)
 710                 return -1;
 711         return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs,
 712                                                        cs_len);
 713 }
 714
 715 static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
 716                                                  Boolean enabled)
 717 {
 718         if (!wpa_s->driver->enable_controlled_port)
 719                 return -1;
 720         return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
 721 }
 722
 723 static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
 724                                                 u32 channel, u8 an,
 725                                                 u32 *lowest_pn)
 726 {
 727         if (!wpa_s->driver->get_receive_lowest_pn)
 728                 return -1;
 729         return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, channel,
 730                                                     an, lowest_pn);
 731 }
 732
 733 static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
 734                                                 u32 channel, u8 an,
 735                                                 u32 *next_pn)
 736 {
 737         if (!wpa_s->driver->get_transmit_next_pn)
 738                 return -1;
 739         return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, channel,
 740                                                     an, next_pn);
 741 }
 742
 743 static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
 744                                                 u32 channel, u8 an,
 745                                                 u32 next_pn)
 746 {
 747         if (!wpa_s->driver->set_transmit_next_pn)
 748                 return -1;
 749         return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, channel,
 750                                                     an, next_pn);
 751 }
 752
 753 static inline int wpa_drv_get_available_receive_sc(struct wpa_supplicant *wpa_s,
 754                                                    u32 *channel)
 755 {
 756         if (!wpa_s->driver->get_available_receive_sc)
 757                 return -1;
 758         return wpa_s->driver->get_available_receive_sc(wpa_s->drv_priv,
 759                                                        channel);
 760 }
 761
 762 static inline int
 763 wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, u32 channel,
 764                           const u8 *sci_addr, u16 sci_port,
 765                           unsigned int conf_offset, int validation)
 766 {
 767         if (!wpa_s->driver->create_receive_sc)
 768                 return -1;
 769         return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, channel,
 770                                                 sci_addr, sci_port, conf_offset,
 771                                                 validation);
 772 }
 773
 774 static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
 775                                             u32 channel)
 776 {
 777         if (!wpa_s->driver->delete_receive_sc)
 778                 return -1;
 779         return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, channel);
 780 }
 781
 782 static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
 783                                             u32 channel, u8 an,
 784                                             u32 lowest_pn, const u8 *sak)
 785 {
 786         if (!wpa_s->driver->create_receive_sa)
 787                 return -1;
 788         return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, channel, an,
 789                                                 lowest_pn, sak);
 790 }
 791
 792 static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
 793                                             u32 channel, u8 an)
 794 {
 795         if (!wpa_s->driver->enable_receive_sa)
 796                 return -1;
 797         return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, channel, an);
 798 }
 799
 800 static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
 801                                              u32 channel, u8 an)
 802 {
 803         if (!wpa_s->driver->disable_receive_sa)
 804                 return -1;
 805         return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, channel, an);
 806 }
 807
 808 static inline int
 809 wpa_drv_get_available_transmit_sc(struct wpa_supplicant *wpa_s, u32 *channel)
 810 {
 811         if (!wpa_s->driver->get_available_transmit_sc)
 812                 return -1;
 813         return wpa_s->driver->get_available_transmit_sc(wpa_s->drv_priv,
 814                                                         channel);
 815 }
 816
 817 static inline int
 818 wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, u32 channel,
 819                            const u8 *sci_addr, u16 sci_port,
 820                            unsigned int conf_offset)
 821 {
 822         if (!wpa_s->driver->create_transmit_sc)
 823                 return -1;
 824         return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, channel,
 825                                                  sci_addr, sci_port,
 826                                                  conf_offset);
 827 }
 828
 829 static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
 830                                              u32 channel)
 831 {
 832         if (!wpa_s->driver->delete_transmit_sc)
 833                 return -1;
 834         return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, channel);
 835 }
 836
 837 static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
 838                                              u32 channel, u8 an,
 839                                              u32 next_pn,
 840                                              Boolean confidentiality,
 841                                              const u8 *sak)
 842 {
 843         if (!wpa_s->driver->create_transmit_sa)
 844                 return -1;
 845         return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, channel, an,
 846                                                  next_pn, confidentiality, sak);
 847 }
 848
 849 static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
 850                                              u32 channel, u8 an)
 851 {
 852         if (!wpa_s->driver->enable_transmit_sa)
 853                 return -1;
 854         return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, channel, an);
 855 }
 856
 857 static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
 858                                               u32 channel, u8 an)
 859 {
 860         if (!wpa_s->driver->disable_transmit_sa)
 861                 return -1;
 862         return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, channel, an);
 863 }
 864 #endif /* CONFIG_MACSEC */
 865
 866 #endif /* DRIVER_I_H */