net/mac80211/driver-ops.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License version 2 as
   4  * published by the Free Software Foundation.
   5  */
   6 #include <net/mac80211.h>
   7 #include "ieee80211_i.h"
   8 #include "trace.h"
   9 #include "driver-ops.h"
  10
  11 int drv_add_interface(struct ieee80211_local *local,
  12                       struct ieee80211_sub_if_data *sdata)
  13 {
  14         int ret;
  15
  16         might_sleep();
  17
  18         if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
  19                     (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
  20                      !ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF) &&
  21                      !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))))
  22                 return -EINVAL;
  23
  24         trace_drv_add_interface(local, sdata);
  25         ret = local->ops->add_interface(&local->hw, &sdata->vif);
  26         trace_drv_return_int(local, ret);
  27
  28         if (ret == 0)
  29                 sdata->flags |= IEEE80211_SDATA_IN_DRIVER;
  30
  31         return ret;
  32 }
  33
  34 int drv_change_interface(struct ieee80211_local *local,
  35                          struct ieee80211_sub_if_data *sdata,
  36                          enum nl80211_iftype type, bool p2p)
  37 {
  38         int ret;
  39
  40         might_sleep();
  41
  42         if (!check_sdata_in_driver(sdata))
  43                 return -EIO;
  44
  45         trace_drv_change_interface(local, sdata, type, p2p);
  46         ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p);
  47         trace_drv_return_int(local, ret);
  48         return ret;
  49 }
  50
  51 void drv_remove_interface(struct ieee80211_local *local,
  52                           struct ieee80211_sub_if_data *sdata)
  53 {
  54         might_sleep();
  55
  56         if (!check_sdata_in_driver(sdata))
  57                 return;
  58
  59         trace_drv_remove_interface(local, sdata);
  60         local->ops->remove_interface(&local->hw, &sdata->vif);
  61         sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
  62         trace_drv_return_void(local);
  63 }
  64
  65 __must_check
  66 int drv_sta_state(struct ieee80211_local *local,
  67                   struct ieee80211_sub_if_data *sdata,
  68                   struct sta_info *sta,
  69                   enum ieee80211_sta_state old_state,
  70                   enum ieee80211_sta_state new_state)
  71 {
  72         int ret = 0;
  73
  74         might_sleep();
  75
  76         sdata = get_bss_sdata(sdata);
  77         if (!check_sdata_in_driver(sdata))
  78                 return -EIO;
  79
  80         trace_drv_sta_state(local, sdata, &sta->sta, old_state, new_state);
  81         if (local->ops->sta_state) {
  82                 ret = local->ops->sta_state(&local->hw, &sdata->vif, &sta->sta,
  83                                             old_state, new_state);
  84         } else if (old_state == IEEE80211_STA_AUTH &&
  85                    new_state == IEEE80211_STA_ASSOC) {
  86                 ret = drv_sta_add(local, sdata, &sta->sta);
  87                 if (ret == 0)
  88                         sta->uploaded = true;
  89         } else if (old_state == IEEE80211_STA_ASSOC &&
  90                    new_state == IEEE80211_STA_AUTH) {
  91                 drv_sta_remove(local, sdata, &sta->sta);
  92         }
  93         trace_drv_return_int(local, ret);
  94         return ret;
  95 }
  96
  97 void drv_sta_rc_update(struct ieee80211_local *local,
  98                        struct ieee80211_sub_if_data *sdata,
  99                        struct ieee80211_sta *sta, u32 changed)
 100 {
 101         sdata = get_bss_sdata(sdata);
 102         if (!check_sdata_in_driver(sdata))
 103                 return;
 104
 105         WARN_ON(changed & IEEE80211_RC_SUPP_RATES_CHANGED &&
 106                 (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 107                  sdata->vif.type != NL80211_IFTYPE_MESH_POINT));
 108
 109         trace_drv_sta_rc_update(local, sdata, sta, changed);
 110         if (local->ops->sta_rc_update)
 111                 local->ops->sta_rc_update(&local->hw, &sdata->vif,
 112                                           sta, changed);
 113
 114         trace_drv_return_void(local);
 115 }
 116
 117 int drv_conf_tx(struct ieee80211_local *local,
 118                 struct ieee80211_sub_if_data *sdata, u16 ac,
 119                 const struct ieee80211_tx_queue_params *params)
 120 {
 121         int ret = -EOPNOTSUPP;
 122
 123         might_sleep();
 124
 125         if (!check_sdata_in_driver(sdata))
 126                 return -EIO;
 127
 128         if (WARN_ONCE(params->cw_min == 0 ||
 129                       params->cw_min > params->cw_max,
 130                       "%s: invalid CW_min/CW_max: %d/%d\n",
 131                       sdata->name, params->cw_min, params->cw_max))
 132                 return -EINVAL;
 133
 134         trace_drv_conf_tx(local, sdata, ac, params);
 135         if (local->ops->conf_tx)
 136                 ret = local->ops->conf_tx(&local->hw, &sdata->vif,
 137                                           ac, params);
 138         trace_drv_return_int(local, ret);
 139         return ret;
 140 }
 141
 142 u64 drv_get_tsf(struct ieee80211_local *local,
 143                 struct ieee80211_sub_if_data *sdata)
 144 {
 145         u64 ret = -1ULL;
 146
 147         might_sleep();
 148
 149         if (!check_sdata_in_driver(sdata))
 150                 return ret;
 151
 152         trace_drv_get_tsf(local, sdata);
 153         if (local->ops->get_tsf)
 154                 ret = local->ops->get_tsf(&local->hw, &sdata->vif);
 155         trace_drv_return_u64(local, ret);
 156         return ret;
 157 }
 158
 159 void drv_set_tsf(struct ieee80211_local *local,
 160                  struct ieee80211_sub_if_data *sdata,
 161                  u64 tsf)
 162 {
 163         might_sleep();
 164
 165         if (!check_sdata_in_driver(sdata))
 166                 return;
 167
 168         trace_drv_set_tsf(local, sdata, tsf);
 169         if (local->ops->set_tsf)
 170                 local->ops->set_tsf(&local->hw, &sdata->vif, tsf);
 171         trace_drv_return_void(local);
 172 }
 173
 174 void drv_reset_tsf(struct ieee80211_local *local,
 175                    struct ieee80211_sub_if_data *sdata)
 176 {
 177         might_sleep();
 178
 179         if (!check_sdata_in_driver(sdata))
 180                 return;
 181
 182         trace_drv_reset_tsf(local, sdata);
 183         if (local->ops->reset_tsf)
 184                 local->ops->reset_tsf(&local->hw, &sdata->vif);
 185         trace_drv_return_void(local);
 186 }
 187
 188 int drv_switch_vif_chanctx(struct ieee80211_local *local,
 189                            struct ieee80211_vif_chanctx_switch *vifs,
 190                            int n_vifs, enum ieee80211_chanctx_switch_mode mode)
 191 {
 192         int ret = 0;
 193         int i;
 194
 195         if (!local->ops->switch_vif_chanctx)
 196                 return -EOPNOTSUPP;
 197
 198         for (i = 0; i < n_vifs; i++) {
 199                 struct ieee80211_chanctx *new_ctx =
 200                         container_of(vifs[i].new_ctx,
 201                                      struct ieee80211_chanctx,
 202                                      conf);
 203                 struct ieee80211_chanctx *old_ctx =
 204                         container_of(vifs[i].old_ctx,
 205                                      struct ieee80211_chanctx,
 206                                      conf);
 207
 208                 WARN_ON_ONCE(!old_ctx->driver_present);
 209                 WARN_ON_ONCE((mode == CHANCTX_SWMODE_SWAP_CONTEXTS &&
 210                               new_ctx->driver_present) ||
 211                              (mode == CHANCTX_SWMODE_REASSIGN_VIF &&
 212                               !new_ctx->driver_present));
 213         }
 214
 215         trace_drv_switch_vif_chanctx(local, vifs, n_vifs, mode);
 216         ret = local->ops->switch_vif_chanctx(&local->hw,
 217                                              vifs, n_vifs, mode);
 218         trace_drv_return_int(local, ret);
 219
 220         if (!ret && mode == CHANCTX_SWMODE_SWAP_CONTEXTS) {
 221                 for (i = 0; i < n_vifs; i++) {
 222                         struct ieee80211_chanctx *new_ctx =
 223                                 container_of(vifs[i].new_ctx,
 224                                              struct ieee80211_chanctx,
 225                                              conf);
 226                         struct ieee80211_chanctx *old_ctx =
 227                                 container_of(vifs[i].old_ctx,
 228                                              struct ieee80211_chanctx,
 229                                              conf);
 230
 231                         new_ctx->driver_present = true;
 232                         old_ctx->driver_present = false;
 233                 }
 234         }
 235
 236         return ret;
 237 }
 238
 239 int drv_ampdu_action(struct ieee80211_local *local,
 240                      struct ieee80211_sub_if_data *sdata,
 241                      enum ieee80211_ampdu_mlme_action action,
 242                      struct ieee80211_sta *sta, u16 tid,
 243                      u16 *ssn, u8 buf_size, bool amsdu)
 244 {
 245         int ret = -EOPNOTSUPP;
 246
 247         might_sleep();
 248
 249         sdata = get_bss_sdata(sdata);
 250         if (!check_sdata_in_driver(sdata))
 251                 return -EIO;
 252
 253         trace_drv_ampdu_action(local, sdata, action, sta, tid,
 254                                ssn, buf_size, amsdu);
 255
 256         if (local->ops->ampdu_action)
 257                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
 258                                                sta, tid, ssn, buf_size, amsdu);
 259
 260         trace_drv_return_int(local, ret);
 261
 262         return ret;
 263 }