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_send_eapol(struct wpa_supplicant *wpa_s,
 248                                      const u8 *dst, u16 proto,
 249                                      const u8 *data, size_t data_len)
 250 {
 251         if (wpa_s->driver->send_eapol)
 252                 return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
 253                                                  data, data_len);
 254         return -1;
 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)
 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         return NULL;
 284 }
 285
 286 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 287                                       const char *alpha2)
 288 {
 289         if (wpa_s->driver->set_country)
 290                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 291         return 0;
 292 }
 293
 294 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 295                                     const u8 *data, size_t data_len, int noack)
 296 {
 297         if (wpa_s->driver->send_mlme)
 298                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 299                                                 data, data_len, noack);
 300         return -1;
 301 }
 302
 303 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 304                                         const u8 *md,
 305                                         const u8 *ies, size_t ies_len)
 306 {
 307         if (wpa_s->driver->update_ft_ies)
 308                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 309                                                     ies, ies_len);
 310         return -1;
 311 }
 312
 313 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
 314                                          u8 action, const u8 *target_ap,
 315                                          const u8 *ies, size_t ies_len)
 316 {
 317         if (wpa_s->driver->send_ft_action)
 318                 return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
 319                                                      target_ap, ies, ies_len);
 320         return -1;
 321 }
 322
 323 static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
 324                                  struct wpa_driver_ap_params *params)
 325 {
 326         if (wpa_s->driver->set_ap)
 327                 return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
 328         return -1;
 329 }
 330
 331 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 332                                   struct hostapd_sta_add_params *params)
 333 {
 334         if (wpa_s->driver->sta_add)
 335                 return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
 336         return -1;
 337 }
 338
 339 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 340                                      const u8 *addr)
 341 {
 342         if (wpa_s->driver->sta_remove)
 343                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 344         return -1;
 345 }
 346
 347 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 348                                           const u8 *addr, const u8 *data,
 349                                           size_t data_len, int encrypt,
 350                                           const u8 *own_addr, u32 flags)
 351 {
 352         if (wpa_s->driver->hapd_send_eapol)
 353                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 354                                                       data, data_len, encrypt,
 355                                                       own_addr, flags);
 356         return -1;
 357 }
 358
 359 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 360                                         const u8 *addr, int total_flags,
 361                                         int flags_or, int flags_and)
 362 {
 363         if (wpa_s->driver->sta_set_flags)
 364                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 365                                                     total_flags, flags_or,
 366                                                     flags_and);
 367         return -1;
 368 }
 369
 370 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 371                                         int authorized)
 372 {
 373         if (wpa_s->driver->set_supp_port) {
 374                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 375                                                     authorized);
 376         }
 377         return 0;
 378 }
 379
 380 static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
 381                                       unsigned int freq,
 382                                       unsigned int wait,
 383                                       const u8 *dst, const u8 *src,
 384                                       const u8 *bssid,
 385                                       const u8 *data, size_t data_len,
 386                                       int no_cck)
 387 {
 388         if (wpa_s->driver->send_action)
 389                 return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
 390                                                   wait, dst, src, bssid,
 391                                                   data, data_len, no_cck);
 392         return -1;
 393 }
 394
 395 static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
 396 {
 397         if (wpa_s->driver->send_action_cancel_wait)
 398                 wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
 399 }
 400
 401 static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
 402                                    struct hostapd_freq_params *freq)
 403 {
 404         if (wpa_s->driver->set_freq)
 405                 return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
 406         return -1;
 407 }
 408
 409 static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
 410                                  enum wpa_driver_if_type type,
 411                                  const char *ifname, const u8 *addr,
 412                                  void *bss_ctx, char *force_ifname,
 413                                  u8 *if_addr, const char *bridge)
 414 {
 415         if (wpa_s->driver->if_add)
 416                 return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
 417                                              addr, bss_ctx, NULL, force_ifname,
 418                                              if_addr, bridge, 0);
 419         return -1;
 420 }
 421
 422 static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
 423                                     enum wpa_driver_if_type type,
 424                                     const char *ifname)
 425 {
 426         if (wpa_s->driver->if_remove)
 427                 return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
 428         return -1;
 429 }
 430
 431 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
 432                                             unsigned int freq,
 433                                             unsigned int duration)
 434 {
 435         if (wpa_s->driver->remain_on_channel)
 436                 return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
 437                                                         duration);
 438         return -1;
 439 }
 440
 441 static inline int wpa_drv_cancel_remain_on_channel(
 442         struct wpa_supplicant *wpa_s)
 443 {
 444         if (wpa_s->driver->cancel_remain_on_channel)
 445                 return wpa_s->driver->cancel_remain_on_channel(
 446                         wpa_s->drv_priv);
 447         return -1;
 448 }
 449
 450 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
 451                                            int report)
 452 {
 453         if (wpa_s->driver->probe_req_report)
 454                 return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
 455                                                        report);
 456         return -1;
 457 }
 458
 459 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
 460 {
 461         if (wpa_s->driver->deinit_ap)
 462                 return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
 463         return 0;
 464 }
 465
 466 static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
 467 {
 468         if (wpa_s->driver->deinit_p2p_cli)
 469                 return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
 470         return 0;
 471 }
 472
 473 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
 474 {
 475         if (wpa_s->driver->suspend)
 476                 wpa_s->driver->suspend(wpa_s->drv_priv);
 477 }
 478
 479 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
 480 {
 481         if (wpa_s->driver->resume)
 482                 wpa_s->driver->resume(wpa_s->drv_priv);
 483 }
 484
 485 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
 486                                          int threshold, int hysteresis)
 487 {
 488         if (wpa_s->driver->signal_monitor)
 489                 return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
 490                                                      threshold, hysteresis);
 491         return -1;
 492 }
 493
 494 static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
 495                                       struct wpa_signal_info *si)
 496 {
 497         if (wpa_s->driver->signal_poll)
 498                 return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
 499         return -1;
 500 }
 501
 502 static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
 503                                       struct hostap_sta_driver_data *sta)
 504 {
 505         if (wpa_s->driver->read_sta_data)
 506                 return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
 507                                                     wpa_s->bssid);
 508         return -1;
 509 }
 510
 511 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 512                                         const struct wpabuf *beacon,
 513                                         const struct wpabuf *proberesp,
 514                                         const struct wpabuf *assocresp)
 515 {
 516         if (!wpa_s->driver->set_ap_wps_ie)
 517                 return -1;
 518         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 519                                             proberesp, assocresp);
 520 }
 521
 522 static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
 523 {
 524         if (!wpa_s->driver->shared_freq)
 525                 return -1;
 526         return wpa_s->driver->shared_freq(wpa_s->drv_priv);
 527 }
 528
 529 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
 530                                   u8 *buf, size_t buf_len)
 531 {
 532         if (!wpa_s->driver->get_noa)
 533                 return -1;
 534         return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
 535 }
 536
 537 static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
 538                                             int legacy_ps, int opp_ps,
 539                                             int ctwindow)
 540 {
 541         if (!wpa_s->driver->set_p2p_powersave)
 542                 return -1;
 543         return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
 544                                                 opp_ps, ctwindow);
 545 }
 546
 547 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
 548 {
 549         if (!wpa_s->driver->ampdu)
 550                 return -1;
 551         return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
 552 }
 553
 554 static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
 555                                          const u8 *dst, u8 action_code,
 556                                          u8 dialog_token, u16 status_code,
 557                                          u32 peer_capab, int initiator,
 558                                          const u8 *buf, size_t len)
 559 {
 560         if (wpa_s->driver->send_tdls_mgmt) {
 561                 return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
 562                                                      action_code, dialog_token,
 563                                                      status_code, peer_capab,
 564                                                      initiator, buf, len);
 565         }
 566         return -1;
 567 }
 568
 569 static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
 570                                     enum tdls_oper oper, const u8 *peer)
 571 {
 572         if (!wpa_s->driver->tdls_oper)
 573                 return -1;
 574         return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
 575 }
 576
 577 #ifdef ANDROID
 578 static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
 579                                      char *cmd, char *buf, size_t buf_len)
 580 {
 581         if (!wpa_s->driver->driver_cmd)
 582                 return -1;
 583         return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
 584 }
 585 #endif /* ANDROID */
 586
 587 static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
 588                                           const u8 *kek, const u8 *kck,
 589                                           const u8 *replay_ctr)
 590 {
 591         if (!wpa_s->driver->set_rekey_info)
 592                 return;
 593         wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
 594 }
 595
 596 static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
 597                                         int disabled)
 598 {
 599         if (!wpa_s->driver->radio_disable)
 600                 return -1;
 601         return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
 602 }
 603
 604 static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
 605                                          struct csa_settings *settings)
 606 {
 607         if (!wpa_s->driver->switch_channel)
 608                 return -1;
 609         return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
 610 }
 611
 612 static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
 613                                  const u8 *address, u8 user_priority,
 614                                  u16 admitted_time)
 615 {
 616         if (!wpa_s->driver->add_tx_ts)
 617                 return -1;
 618         return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
 619                                         user_priority, admitted_time);
 620 }
 621
 622 static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
 623                                  const u8 *address)
 624 {
 625         if (!wpa_s->driver->del_tx_ts)
 626                 return -1;
 627         return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
 628 }
 629
 630 static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
 631                                    enum wnm_oper oper, const u8 *peer,
 632                                    u8 *buf, u16 *buf_len)
 633 {
 634         if (!wpa_s->driver->wnm_oper)
 635                 return -1;
 636         return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
 637                                        buf_len);
 638 }
 639
 640 static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
 641                                  char *buf, size_t buflen)
 642 {
 643         if (!wpa_s->driver->status)
 644                 return -1;
 645         return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
 646 }
 647
 648 static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
 649                                       const u8 *qos_map_set, u8 qos_map_set_len)
 650 {
 651         if (!wpa_s->driver->set_qos_map)
 652                 return -1;
 653         return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
 654                                           qos_map_set_len);
 655 }
 656
 657 static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
 658                                  const struct wowlan_triggers *triggers)
 659 {
 660         if (!wpa_s->driver->set_wowlan)
 661                 return -1;
 662         return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
 663 }
 664
 665 static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
 666                                      int vendor_id, int subcmd, const u8 *data,
 667                                      size_t data_len, struct wpabuf *buf)
 668 {
 669         if (!wpa_s->driver->vendor_cmd)
 670                 return -1;
 671         return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
 672                                          data, data_len, buf);
 673 }
 674
 675 static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
 676                                   const u8 *bssid)
 677 {
 678         if (!wpa_s->driver->roaming)
 679                 return -1;
 680         return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
 681 }
 682
 683 static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
 684                                        const u8 *addr)
 685 {
 686         if (!wpa_s->driver->set_mac_addr)
 687                 return -1;
 688         return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
 689 }
 690
 691
 692 #ifdef CONFIG_MACSEC
 693
 694 static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
 695                                       struct macsec_init_params *params)
 696 {
 697         if (!wpa_s->driver->macsec_init)
 698                 return -1;
 699         return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
 700 }
 701
 702 static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
 703 {
 704         if (!wpa_s->driver->macsec_deinit)
 705                 return -1;
 706         return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
 707 }
 708
 709 static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
 710                                                 Boolean enabled)
 711 {
 712         if (!wpa_s->driver->enable_protect_frames)
 713                 return -1;
 714         return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
 715 }
 716
 717 static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
 718                                              Boolean enabled, u32 window)
 719 {
 720         if (!wpa_s->driver->set_replay_protect)
 721                 return -1;
 722         return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
 723                                                  window);
 724 }
 725
 726 static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
 727                                                    const u8 *cs, size_t cs_len)
 728 {
 729         if (!wpa_s->driver->set_current_cipher_suite)
 730                 return -1;
 731         return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs,
 732                                                        cs_len);
 733 }
 734
 735 static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
 736                                                  Boolean enabled)
 737 {
 738         if (!wpa_s->driver->enable_controlled_port)
 739                 return -1;
 740         return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
 741 }
 742
 743 static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
 744                                                 u32 channel, u8 an,
 745                                                 u32 *lowest_pn)
 746 {
 747         if (!wpa_s->driver->get_receive_lowest_pn)
 748                 return -1;
 749         return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, channel,
 750                                                     an, lowest_pn);
 751 }
 752
 753 static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
 754                                                 u32 channel, u8 an,
 755                                                 u32 *next_pn)
 756 {
 757         if (!wpa_s->driver->get_transmit_next_pn)
 758                 return -1;
 759         return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, channel,
 760                                                     an, next_pn);
 761 }
 762
 763 static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
 764                                                 u32 channel, u8 an,
 765                                                 u32 next_pn)
 766 {
 767         if (!wpa_s->driver->set_transmit_next_pn)
 768                 return -1;
 769         return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, channel,
 770                                                     an, next_pn);
 771 }
 772
 773 static inline int wpa_drv_get_available_receive_sc(struct wpa_supplicant *wpa_s,
 774                                                    u32 *channel)
 775 {
 776         if (!wpa_s->driver->get_available_receive_sc)
 777                 return -1;
 778         return wpa_s->driver->get_available_receive_sc(wpa_s->drv_priv,
 779                                                        channel);
 780 }
 781
 782 static inline int
 783 wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, u32 channel,
 784                           const u8 *sci_addr, u16 sci_port,
 785                           unsigned int conf_offset, int validation)
 786 {
 787         if (!wpa_s->driver->create_receive_sc)
 788                 return -1;
 789         return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, channel,
 790                                                 sci_addr, sci_port, conf_offset,
 791                                                 validation);
 792 }
 793
 794 static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
 795                                             u32 channel)
 796 {
 797         if (!wpa_s->driver->delete_receive_sc)
 798                 return -1;
 799         return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, channel);
 800 }
 801
 802 static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
 803                                             u32 channel, u8 an,
 804                                             u32 lowest_pn, const u8 *sak)
 805 {
 806         if (!wpa_s->driver->create_receive_sa)
 807                 return -1;
 808         return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, channel, an,
 809                                                 lowest_pn, sak);
 810 }
 811
 812 static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
 813                                             u32 channel, u8 an)
 814 {
 815         if (!wpa_s->driver->enable_receive_sa)
 816                 return -1;
 817         return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, channel, an);
 818 }
 819
 820 static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
 821                                              u32 channel, u8 an)
 822 {
 823         if (!wpa_s->driver->disable_receive_sa)
 824                 return -1;
 825         return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, channel, an);
 826 }
 827
 828 static inline int
 829 wpa_drv_get_available_transmit_sc(struct wpa_supplicant *wpa_s, u32 *channel)
 830 {
 831         if (!wpa_s->driver->get_available_transmit_sc)
 832                 return -1;
 833         return wpa_s->driver->get_available_transmit_sc(wpa_s->drv_priv,
 834                                                         channel);
 835 }
 836
 837 static inline int
 838 wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, u32 channel,
 839                            const u8 *sci_addr, u16 sci_port,
 840                            unsigned int conf_offset)
 841 {
 842         if (!wpa_s->driver->create_transmit_sc)
 843                 return -1;
 844         return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, channel,
 845                                                  sci_addr, sci_port,
 846                                                  conf_offset);
 847 }
 848
 849 static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
 850                                              u32 channel)
 851 {
 852         if (!wpa_s->driver->delete_transmit_sc)
 853                 return -1;
 854         return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, channel);
 855 }
 856
 857 static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
 858                                              u32 channel, u8 an,
 859                                              u32 next_pn,
 860                                              Boolean confidentiality,
 861                                              const u8 *sak)
 862 {
 863         if (!wpa_s->driver->create_transmit_sa)
 864                 return -1;
 865         return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, channel, an,
 866                                                  next_pn, confidentiality, sak);
 867 }
 868
 869 static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
 870                                              u32 channel, u8 an)
 871 {
 872         if (!wpa_s->driver->enable_transmit_sa)
 873                 return -1;
 874         return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, channel, an);
 875 }
 876
 877 static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
 878                                               u32 channel, u8 an)
 879 {
 880         if (!wpa_s->driver->disable_transmit_sa)
 881                 return -1;
 882         return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, channel, an);
 883 }
 884 #endif /* CONFIG_MACSEC */
 885
 886 #endif /* DRIVER_I_H */