LCOV - code coverage report
Current view: top level - net/wireless - core.h (source / functions) Hit Total Coverage
Test: Real Lines: 0 42 0.0 %
Date: 2020-10-17 15:46:43 Functions: 0 6 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Wireless configuration interface internals.
       4                 :            :  *
       5                 :            :  * Copyright 2006-2010  Johannes Berg <johannes@sipsolutions.net>
       6                 :            :  * Copyright (C) 2018-2019 Intel Corporation
       7                 :            :  */
       8                 :            : #ifndef __NET_WIRELESS_CORE_H
       9                 :            : #define __NET_WIRELESS_CORE_H
      10                 :            : #include <linux/list.h>
      11                 :            : #include <linux/netdevice.h>
      12                 :            : #include <linux/rbtree.h>
      13                 :            : #include <linux/debugfs.h>
      14                 :            : #include <linux/rfkill.h>
      15                 :            : #include <linux/workqueue.h>
      16                 :            : #include <linux/rtnetlink.h>
      17                 :            : #include <net/genetlink.h>
      18                 :            : #include <net/cfg80211.h>
      19                 :            : #include "reg.h"
      20                 :            : 
      21                 :            : 
      22                 :            : #define WIPHY_IDX_INVALID       -1
      23                 :            : 
      24                 :            : struct cfg80211_registered_device {
      25                 :            :         const struct cfg80211_ops *ops;
      26                 :            :         struct list_head list;
      27                 :            : 
      28                 :            :         /* rfkill support */
      29                 :            :         struct rfkill_ops rfkill_ops;
      30                 :            :         struct rfkill *rfkill;
      31                 :            :         struct work_struct rfkill_block;
      32                 :            : 
      33                 :            :         /* ISO / IEC 3166 alpha2 for which this device is receiving
      34                 :            :          * country IEs on, this can help disregard country IEs from APs
      35                 :            :          * on the same alpha2 quickly. The alpha2 may differ from
      36                 :            :          * cfg80211_regdomain's alpha2 when an intersection has occurred.
      37                 :            :          * If the AP is reconfigured this can also be used to tell us if
      38                 :            :          * the country on the country IE changed. */
      39                 :            :         char country_ie_alpha2[2];
      40                 :            : 
      41                 :            :         /*
      42                 :            :          * the driver requests the regulatory core to set this regulatory
      43                 :            :          * domain as the wiphy's. Only used for %REGULATORY_WIPHY_SELF_MANAGED
      44                 :            :          * devices using the regulatory_set_wiphy_regd() API
      45                 :            :          */
      46                 :            :         const struct ieee80211_regdomain *requested_regd;
      47                 :            : 
      48                 :            :         /* If a Country IE has been received this tells us the environment
      49                 :            :          * which its telling us its in. This defaults to ENVIRON_ANY */
      50                 :            :         enum environment_cap env;
      51                 :            : 
      52                 :            :         /* wiphy index, internal only */
      53                 :            :         int wiphy_idx;
      54                 :            : 
      55                 :            :         /* protected by RTNL */
      56                 :            :         int devlist_generation, wdev_id;
      57                 :            :         int opencount;
      58                 :            :         wait_queue_head_t dev_wait;
      59                 :            : 
      60                 :            :         struct list_head beacon_registrations;
      61                 :            :         spinlock_t beacon_registrations_lock;
      62                 :            : 
      63                 :            :         struct list_head mlme_unreg;
      64                 :            :         spinlock_t mlme_unreg_lock;
      65                 :            :         struct work_struct mlme_unreg_wk;
      66                 :            : 
      67                 :            :         /* protected by RTNL only */
      68                 :            :         int num_running_ifaces;
      69                 :            :         int num_running_monitor_ifaces;
      70                 :            :         u64 cookie_counter;
      71                 :            : 
      72                 :            :         /* BSSes/scanning */
      73                 :            :         spinlock_t bss_lock;
      74                 :            :         struct list_head bss_list;
      75                 :            :         struct rb_root bss_tree;
      76                 :            :         u32 bss_generation;
      77                 :            :         u32 bss_entries;
      78                 :            :         struct cfg80211_scan_request *scan_req; /* protected by RTNL */
      79                 :            :         struct sk_buff *scan_msg;
      80                 :            :         struct list_head sched_scan_req_list;
      81                 :            :         time64_t suspend_at;
      82                 :            :         struct work_struct scan_done_wk;
      83                 :            : 
      84                 :            :         struct genl_info *cur_cmd_info;
      85                 :            : 
      86                 :            :         struct work_struct conn_work;
      87                 :            :         struct work_struct event_work;
      88                 :            : 
      89                 :            :         struct delayed_work dfs_update_channels_wk;
      90                 :            : 
      91                 :            :         /* netlink port which started critical protocol (0 means not started) */
      92                 :            :         u32 crit_proto_nlportid;
      93                 :            : 
      94                 :            :         struct cfg80211_coalesce *coalesce;
      95                 :            : 
      96                 :            :         struct work_struct destroy_work;
      97                 :            :         struct work_struct sched_scan_stop_wk;
      98                 :            :         struct work_struct sched_scan_res_wk;
      99                 :            : 
     100                 :            :         struct cfg80211_chan_def radar_chandef;
     101                 :            :         struct work_struct propagate_radar_detect_wk;
     102                 :            : 
     103                 :            :         struct cfg80211_chan_def cac_done_chandef;
     104                 :            :         struct work_struct propagate_cac_done_wk;
     105                 :            : 
     106                 :            :         /* must be last because of the way we do wiphy_priv(),
     107                 :            :          * and it should at least be aligned to NETDEV_ALIGN */
     108                 :            :         struct wiphy wiphy __aligned(NETDEV_ALIGN);
     109                 :            : };
     110                 :            : 
     111                 :            : static inline
     112                 :            : struct cfg80211_registered_device *wiphy_to_rdev(struct wiphy *wiphy)
     113                 :            : {
     114                 :          0 :         BUG_ON(!wiphy);
     115                 :          0 :         return container_of(wiphy, struct cfg80211_registered_device, wiphy);
     116                 :            : }
     117                 :            : 
     118                 :            : static inline void
     119                 :          0 : cfg80211_rdev_free_wowlan(struct cfg80211_registered_device *rdev)
     120                 :            : {
     121                 :            : #ifdef CONFIG_PM
     122                 :            :         int i;
     123                 :            : 
     124                 :          0 :         if (!rdev->wiphy.wowlan_config)
     125                 :          0 :                 return;
     126                 :          0 :         for (i = 0; i < rdev->wiphy.wowlan_config->n_patterns; i++)
     127                 :          0 :                 kfree(rdev->wiphy.wowlan_config->patterns[i].mask);
     128                 :          0 :         kfree(rdev->wiphy.wowlan_config->patterns);
     129                 :          0 :         if (rdev->wiphy.wowlan_config->tcp &&
     130                 :          0 :             rdev->wiphy.wowlan_config->tcp->sock)
     131                 :          0 :                 sock_release(rdev->wiphy.wowlan_config->tcp->sock);
     132                 :          0 :         kfree(rdev->wiphy.wowlan_config->tcp);
     133                 :          0 :         kfree(rdev->wiphy.wowlan_config->nd_config);
     134                 :          0 :         kfree(rdev->wiphy.wowlan_config);
     135                 :            : #endif
     136                 :            : }
     137                 :            : 
     138                 :          0 : static inline u64 cfg80211_assign_cookie(struct cfg80211_registered_device *rdev)
     139                 :            : {
     140                 :          0 :         u64 r = ++rdev->cookie_counter;
     141                 :            : 
     142                 :          0 :         if (WARN_ON(r == 0))
     143                 :          0 :                 r = ++rdev->cookie_counter;
     144                 :            : 
     145                 :          0 :         return r;
     146                 :            : }
     147                 :            : 
     148                 :            : extern struct workqueue_struct *cfg80211_wq;
     149                 :            : extern struct list_head cfg80211_rdev_list;
     150                 :            : extern int cfg80211_rdev_list_generation;
     151                 :            : 
     152                 :            : struct cfg80211_internal_bss {
     153                 :            :         struct list_head list;
     154                 :            :         struct list_head hidden_list;
     155                 :            :         struct rb_node rbn;
     156                 :            :         u64 ts_boottime;
     157                 :            :         unsigned long ts;
     158                 :            :         unsigned long refcount;
     159                 :            :         atomic_t hold;
     160                 :            : 
     161                 :            :         /* time at the start of the reception of the first octet of the
     162                 :            :          * timestamp field of the last beacon/probe received for this BSS.
     163                 :            :          * The time is the TSF of the BSS specified by %parent_bssid.
     164                 :            :          */
     165                 :            :         u64 parent_tsf;
     166                 :            : 
     167                 :            :         /* the BSS according to which %parent_tsf is set. This is set to
     168                 :            :          * the BSS that the interface that requested the scan was connected to
     169                 :            :          * when the beacon/probe was received.
     170                 :            :          */
     171                 :            :         u8 parent_bssid[ETH_ALEN] __aligned(2);
     172                 :            : 
     173                 :            :         /* must be last because of priv member */
     174                 :            :         struct cfg80211_bss pub;
     175                 :            : };
     176                 :            : 
     177                 :            : static inline struct cfg80211_internal_bss *bss_from_pub(struct cfg80211_bss *pub)
     178                 :            : {
     179                 :          0 :         return container_of(pub, struct cfg80211_internal_bss, pub);
     180                 :            : }
     181                 :            : 
     182                 :          0 : static inline void cfg80211_hold_bss(struct cfg80211_internal_bss *bss)
     183                 :            : {
     184                 :          0 :         atomic_inc(&bss->hold);
     185                 :          0 :         if (bss->pub.transmitted_bss) {
     186                 :            :                 bss = container_of(bss->pub.transmitted_bss,
     187                 :            :                                    struct cfg80211_internal_bss, pub);
     188                 :          0 :                 atomic_inc(&bss->hold);
     189                 :            :         }
     190                 :          0 : }
     191                 :            : 
     192                 :          0 : static inline void cfg80211_unhold_bss(struct cfg80211_internal_bss *bss)
     193                 :            : {
     194                 :          0 :         int r = atomic_dec_return(&bss->hold);
     195                 :          0 :         WARN_ON(r < 0);
     196                 :          0 :         if (bss->pub.transmitted_bss) {
     197                 :            :                 bss = container_of(bss->pub.transmitted_bss,
     198                 :            :                                    struct cfg80211_internal_bss, pub);
     199                 :          0 :                 r = atomic_dec_return(&bss->hold);
     200                 :          0 :                 WARN_ON(r < 0);
     201                 :            :         }
     202                 :          0 : }
     203                 :            : 
     204                 :            : 
     205                 :            : struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx);
     206                 :            : int get_wiphy_idx(struct wiphy *wiphy);
     207                 :            : 
     208                 :            : struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx);
     209                 :            : 
     210                 :            : int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
     211                 :            :                           struct net *net);
     212                 :            : 
     213                 :            : void cfg80211_init_wdev(struct cfg80211_registered_device *rdev,
     214                 :            :                         struct wireless_dev *wdev);
     215                 :            : 
     216                 :            : static inline void wdev_lock(struct wireless_dev *wdev)
     217                 :            :         __acquires(wdev)
     218                 :            : {
     219                 :          0 :         mutex_lock(&wdev->mtx);
     220                 :            :         __acquire(wdev->mtx);
     221                 :            : }
     222                 :            : 
     223                 :            : static inline void wdev_unlock(struct wireless_dev *wdev)
     224                 :            :         __releases(wdev)
     225                 :            : {
     226                 :            :         __release(wdev->mtx);
     227                 :          0 :         mutex_unlock(&wdev->mtx);
     228                 :            : }
     229                 :            : 
     230                 :            : #define ASSERT_WDEV_LOCK(wdev) lockdep_assert_held(&(wdev)->mtx)
     231                 :            : 
     232                 :          0 : static inline bool cfg80211_has_monitors_only(struct cfg80211_registered_device *rdev)
     233                 :            : {
     234                 :          0 :         ASSERT_RTNL();
     235                 :            : 
     236                 :          0 :         return rdev->num_running_ifaces == rdev->num_running_monitor_ifaces &&
     237                 :            :                rdev->num_running_ifaces > 0;
     238                 :            : }
     239                 :            : 
     240                 :            : enum cfg80211_event_type {
     241                 :            :         EVENT_CONNECT_RESULT,
     242                 :            :         EVENT_ROAMED,
     243                 :            :         EVENT_DISCONNECTED,
     244                 :            :         EVENT_IBSS_JOINED,
     245                 :            :         EVENT_STOPPED,
     246                 :            :         EVENT_PORT_AUTHORIZED,
     247                 :            : };
     248                 :            : 
     249                 :            : struct cfg80211_event {
     250                 :            :         struct list_head list;
     251                 :            :         enum cfg80211_event_type type;
     252                 :            : 
     253                 :            :         union {
     254                 :            :                 struct cfg80211_connect_resp_params cr;
     255                 :            :                 struct cfg80211_roam_info rm;
     256                 :            :                 struct {
     257                 :            :                         const u8 *ie;
     258                 :            :                         size_t ie_len;
     259                 :            :                         u16 reason;
     260                 :            :                         bool locally_generated;
     261                 :            :                 } dc;
     262                 :            :                 struct {
     263                 :            :                         u8 bssid[ETH_ALEN];
     264                 :            :                         struct ieee80211_channel *channel;
     265                 :            :                 } ij;
     266                 :            :                 struct {
     267                 :            :                         u8 bssid[ETH_ALEN];
     268                 :            :                 } pa;
     269                 :            :         };
     270                 :            : };
     271                 :            : 
     272                 :            : struct cfg80211_cached_keys {
     273                 :            :         struct key_params params[CFG80211_MAX_WEP_KEYS];
     274                 :            :         u8 data[CFG80211_MAX_WEP_KEYS][WLAN_KEY_LEN_WEP104];
     275                 :            :         int def;
     276                 :            : };
     277                 :            : 
     278                 :            : enum cfg80211_chan_mode {
     279                 :            :         CHAN_MODE_UNDEFINED,
     280                 :            :         CHAN_MODE_SHARED,
     281                 :            :         CHAN_MODE_EXCLUSIVE,
     282                 :            : };
     283                 :            : 
     284                 :            : struct cfg80211_beacon_registration {
     285                 :            :         struct list_head list;
     286                 :            :         u32 nlportid;
     287                 :            : };
     288                 :            : 
     289                 :            : struct cfg80211_cqm_config {
     290                 :            :         u32 rssi_hyst;
     291                 :            :         s32 last_rssi_event_value;
     292                 :            :         int n_rssi_thresholds;
     293                 :            :         s32 rssi_thresholds[0];
     294                 :            : };
     295                 :            : 
     296                 :            : void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev);
     297                 :            : 
     298                 :            : /* free object */
     299                 :            : void cfg80211_dev_free(struct cfg80211_registered_device *rdev);
     300                 :            : 
     301                 :            : int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
     302                 :            :                         char *newname);
     303                 :            : 
     304                 :            : void ieee80211_set_bitrate_flags(struct wiphy *wiphy);
     305                 :            : 
     306                 :            : void cfg80211_bss_expire(struct cfg80211_registered_device *rdev);
     307                 :            : void cfg80211_bss_age(struct cfg80211_registered_device *rdev,
     308                 :            :                       unsigned long age_secs);
     309                 :            : void cfg80211_update_assoc_bss_entry(struct wireless_dev *wdev,
     310                 :            :                                      struct ieee80211_channel *channel);
     311                 :            : 
     312                 :            : /* IBSS */
     313                 :            : int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
     314                 :            :                          struct net_device *dev,
     315                 :            :                          struct cfg80211_ibss_params *params,
     316                 :            :                          struct cfg80211_cached_keys *connkeys);
     317                 :            : void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
     318                 :            : int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
     319                 :            :                           struct net_device *dev, bool nowext);
     320                 :            : int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
     321                 :            :                         struct net_device *dev, bool nowext);
     322                 :            : void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
     323                 :            :                             struct ieee80211_channel *channel);
     324                 :            : int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
     325                 :            :                             struct wireless_dev *wdev);
     326                 :            : 
     327                 :            : /* mesh */
     328                 :            : extern const struct mesh_config default_mesh_config;
     329                 :            : extern const struct mesh_setup default_mesh_setup;
     330                 :            : int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
     331                 :            :                          struct net_device *dev,
     332                 :            :                          struct mesh_setup *setup,
     333                 :            :                          const struct mesh_config *conf);
     334                 :            : int __cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
     335                 :            :                           struct net_device *dev);
     336                 :            : int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
     337                 :            :                         struct net_device *dev);
     338                 :            : int cfg80211_set_mesh_channel(struct cfg80211_registered_device *rdev,
     339                 :            :                               struct wireless_dev *wdev,
     340                 :            :                               struct cfg80211_chan_def *chandef);
     341                 :            : 
     342                 :            : /* OCB */
     343                 :            : int __cfg80211_join_ocb(struct cfg80211_registered_device *rdev,
     344                 :            :                         struct net_device *dev,
     345                 :            :                         struct ocb_setup *setup);
     346                 :            : int cfg80211_join_ocb(struct cfg80211_registered_device *rdev,
     347                 :            :                       struct net_device *dev,
     348                 :            :                       struct ocb_setup *setup);
     349                 :            : int __cfg80211_leave_ocb(struct cfg80211_registered_device *rdev,
     350                 :            :                          struct net_device *dev);
     351                 :            : int cfg80211_leave_ocb(struct cfg80211_registered_device *rdev,
     352                 :            :                        struct net_device *dev);
     353                 :            : 
     354                 :            : /* AP */
     355                 :            : int __cfg80211_stop_ap(struct cfg80211_registered_device *rdev,
     356                 :            :                        struct net_device *dev, bool notify);
     357                 :            : int cfg80211_stop_ap(struct cfg80211_registered_device *rdev,
     358                 :            :                      struct net_device *dev, bool notify);
     359                 :            : 
     360                 :            : /* MLME */
     361                 :            : int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
     362                 :            :                        struct net_device *dev,
     363                 :            :                        struct ieee80211_channel *chan,
     364                 :            :                        enum nl80211_auth_type auth_type,
     365                 :            :                        const u8 *bssid,
     366                 :            :                        const u8 *ssid, int ssid_len,
     367                 :            :                        const u8 *ie, int ie_len,
     368                 :            :                        const u8 *key, int key_len, int key_idx,
     369                 :            :                        const u8 *auth_data, int auth_data_len);
     370                 :            : int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
     371                 :            :                         struct net_device *dev,
     372                 :            :                         struct ieee80211_channel *chan,
     373                 :            :                         const u8 *bssid,
     374                 :            :                         const u8 *ssid, int ssid_len,
     375                 :            :                         struct cfg80211_assoc_request *req);
     376                 :            : int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
     377                 :            :                          struct net_device *dev, const u8 *bssid,
     378                 :            :                          const u8 *ie, int ie_len, u16 reason,
     379                 :            :                          bool local_state_change);
     380                 :            : int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
     381                 :            :                            struct net_device *dev, const u8 *bssid,
     382                 :            :                            const u8 *ie, int ie_len, u16 reason,
     383                 :            :                            bool local_state_change);
     384                 :            : void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
     385                 :            :                         struct net_device *dev);
     386                 :            : int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
     387                 :            :                                 u16 frame_type, const u8 *match_data,
     388                 :            :                                 int match_len);
     389                 :            : void cfg80211_mlme_unreg_wk(struct work_struct *wk);
     390                 :            : void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid);
     391                 :            : void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev);
     392                 :            : int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
     393                 :            :                           struct wireless_dev *wdev,
     394                 :            :                           struct cfg80211_mgmt_tx_params *params,
     395                 :            :                           u64 *cookie);
     396                 :            : void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
     397                 :            :                                const struct ieee80211_ht_cap *ht_capa_mask);
     398                 :            : void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa,
     399                 :            :                                 const struct ieee80211_vht_cap *vht_capa_mask);
     400                 :            : 
     401                 :            : /* SME events */
     402                 :            : int cfg80211_connect(struct cfg80211_registered_device *rdev,
     403                 :            :                      struct net_device *dev,
     404                 :            :                      struct cfg80211_connect_params *connect,
     405                 :            :                      struct cfg80211_cached_keys *connkeys,
     406                 :            :                      const u8 *prev_bssid);
     407                 :            : void __cfg80211_connect_result(struct net_device *dev,
     408                 :            :                                struct cfg80211_connect_resp_params *params,
     409                 :            :                                bool wextev);
     410                 :            : void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
     411                 :            :                              size_t ie_len, u16 reason, bool from_ap);
     412                 :            : int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
     413                 :            :                         struct net_device *dev, u16 reason,
     414                 :            :                         bool wextev);
     415                 :            : void __cfg80211_roamed(struct wireless_dev *wdev,
     416                 :            :                        struct cfg80211_roam_info *info);
     417                 :            : void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid);
     418                 :            : int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
     419                 :            :                               struct wireless_dev *wdev);
     420                 :            : void cfg80211_autodisconnect_wk(struct work_struct *work);
     421                 :            : 
     422                 :            : /* SME implementation */
     423                 :            : void cfg80211_conn_work(struct work_struct *work);
     424                 :            : void cfg80211_sme_scan_done(struct net_device *dev);
     425                 :            : bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status);
     426                 :            : void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len);
     427                 :            : void cfg80211_sme_disassoc(struct wireless_dev *wdev);
     428                 :            : void cfg80211_sme_deauth(struct wireless_dev *wdev);
     429                 :            : void cfg80211_sme_auth_timeout(struct wireless_dev *wdev);
     430                 :            : void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev);
     431                 :            : void cfg80211_sme_abandon_assoc(struct wireless_dev *wdev);
     432                 :            : 
     433                 :            : /* internal helpers */
     434                 :            : bool cfg80211_supported_cipher_suite(struct wiphy *wiphy, u32 cipher);
     435                 :            : int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev,
     436                 :            :                                    struct key_params *params, int key_idx,
     437                 :            :                                    bool pairwise, const u8 *mac_addr);
     438                 :            : void __cfg80211_scan_done(struct work_struct *wk);
     439                 :            : void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
     440                 :            :                            bool send_message);
     441                 :            : void cfg80211_add_sched_scan_req(struct cfg80211_registered_device *rdev,
     442                 :            :                                  struct cfg80211_sched_scan_request *req);
     443                 :            : int cfg80211_sched_scan_req_possible(struct cfg80211_registered_device *rdev,
     444                 :            :                                      bool want_multi);
     445                 :            : void cfg80211_sched_scan_results_wk(struct work_struct *work);
     446                 :            : int cfg80211_stop_sched_scan_req(struct cfg80211_registered_device *rdev,
     447                 :            :                                  struct cfg80211_sched_scan_request *req,
     448                 :            :                                  bool driver_initiated);
     449                 :            : int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
     450                 :            :                                u64 reqid, bool driver_initiated);
     451                 :            : void cfg80211_upload_connect_keys(struct wireless_dev *wdev);
     452                 :            : int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
     453                 :            :                           struct net_device *dev, enum nl80211_iftype ntype,
     454                 :            :                           struct vif_params *params);
     455                 :            : void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev);
     456                 :            : void cfg80211_process_wdev_events(struct wireless_dev *wdev);
     457                 :            : 
     458                 :            : bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range,
     459                 :            :                                 u32 center_freq_khz, u32 bw_khz);
     460                 :            : 
     461                 :            : extern struct work_struct cfg80211_disconnect_work;
     462                 :            : 
     463                 :            : /**
     464                 :            :  * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable
     465                 :            :  * @wiphy: the wiphy to validate against
     466                 :            :  * @chandef: the channel definition to check
     467                 :            :  *
     468                 :            :  * Checks if chandef is usable and we can/need start CAC on such channel.
     469                 :            :  *
     470                 :            :  * Return: Return true if all channels available and at least
     471                 :            :  *         one channel require CAC (NL80211_DFS_USABLE)
     472                 :            :  */
     473                 :            : bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
     474                 :            :                                  const struct cfg80211_chan_def *chandef);
     475                 :            : 
     476                 :            : void cfg80211_set_dfs_state(struct wiphy *wiphy,
     477                 :            :                             const struct cfg80211_chan_def *chandef,
     478                 :            :                             enum nl80211_dfs_state dfs_state);
     479                 :            : 
     480                 :            : void cfg80211_dfs_channels_update_work(struct work_struct *work);
     481                 :            : 
     482                 :            : unsigned int
     483                 :            : cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
     484                 :            :                               const struct cfg80211_chan_def *chandef);
     485                 :            : 
     486                 :            : void cfg80211_sched_dfs_chan_update(struct cfg80211_registered_device *rdev);
     487                 :            : 
     488                 :            : bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
     489                 :            :                                   struct ieee80211_channel *chan);
     490                 :            : 
     491                 :            : bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev);
     492                 :            : 
     493                 :            : bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
     494                 :            :                           struct ieee80211_channel *chan);
     495                 :            : 
     496                 :          0 : static inline unsigned int elapsed_jiffies_msecs(unsigned long start)
     497                 :            : {
     498                 :          0 :         unsigned long end = jiffies;
     499                 :            : 
     500                 :          0 :         if (end >= start)
     501                 :          0 :                 return jiffies_to_msecs(end - start);
     502                 :            : 
     503                 :          0 :         return jiffies_to_msecs(end + (ULONG_MAX - start) + 1);
     504                 :            : }
     505                 :            : 
     506                 :            : void
     507                 :            : cfg80211_get_chan_state(struct wireless_dev *wdev,
     508                 :            :                         struct ieee80211_channel **chan,
     509                 :            :                         enum cfg80211_chan_mode *chanmode,
     510                 :            :                         u8 *radar_detect);
     511                 :            : 
     512                 :            : int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
     513                 :            :                                  struct cfg80211_chan_def *chandef);
     514                 :            : 
     515                 :            : int ieee80211_get_ratemask(struct ieee80211_supported_band *sband,
     516                 :            :                            const u8 *rates, unsigned int n_rates,
     517                 :            :                            u32 *mask);
     518                 :            : 
     519                 :            : int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev,
     520                 :            :                                  enum nl80211_iftype iftype, u32 beacon_int);
     521                 :            : 
     522                 :            : void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
     523                 :            :                                enum nl80211_iftype iftype, int num);
     524                 :            : 
     525                 :            : void __cfg80211_leave(struct cfg80211_registered_device *rdev,
     526                 :            :                       struct wireless_dev *wdev);
     527                 :            : void cfg80211_leave(struct cfg80211_registered_device *rdev,
     528                 :            :                     struct wireless_dev *wdev);
     529                 :            : 
     530                 :            : void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
     531                 :            :                               struct wireless_dev *wdev);
     532                 :            : 
     533                 :            : void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
     534                 :            :                        struct wireless_dev *wdev);
     535                 :            : 
     536                 :            : struct cfg80211_internal_bss *
     537                 :            : cfg80211_bss_update(struct cfg80211_registered_device *rdev,
     538                 :            :                     struct cfg80211_internal_bss *tmp,
     539                 :            :                     bool signal_valid, unsigned long ts);
     540                 :            : #ifdef CONFIG_CFG80211_DEVELOPER_WARNINGS
     541                 :            : #define CFG80211_DEV_WARN_ON(cond)      WARN_ON(cond)
     542                 :            : #else
     543                 :            : /*
     544                 :            :  * Trick to enable using it as a condition,
     545                 :            :  * and also not give a warning when it's
     546                 :            :  * not used that way.
     547                 :            :  */
     548                 :            : #define CFG80211_DEV_WARN_ON(cond)      ({bool __r = (cond); __r; })
     549                 :            : #endif
     550                 :            : 
     551                 :            : void cfg80211_cqm_config_free(struct wireless_dev *wdev);
     552                 :            : 
     553                 :            : void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid);
     554                 :            : void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev);
     555                 :            : void cfg80211_pmsr_free_wk(struct work_struct *work);
     556                 :            : 
     557                 :            : #endif /* __NET_WIRELESS_CORE_H */
    

Generated by: LCOV version 1.14