Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011-2012, Pavel Zubarev <pavel.zubarev@gmail.com> |
| 3 | * Copyright 2011-2012, Marco Porsch <marco.porsch@s2005.tu-chemnitz.de> |
| 4 | * Copyright 2011-2012, cozybit Inc. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License version 2 as |
| 8 | * published by the Free Software Foundation. |
| 9 | */ |
| 10 | |
| 11 | #include "ieee80211_i.h" |
| 12 | #include "mesh.h" |
| 13 | #include "driver-ops.h" |
| 14 | |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 15 | /* This is not in the standard. It represents a tolerable tbtt drift below |
| 16 | * which we do no TSF adjustment. |
| 17 | */ |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 18 | #define TOFFSET_MINIMUM_ADJUSTMENT 10 |
| 19 | |
Javier Cardona | ec14bcd | 2012-04-12 14:32:23 -0700 | [diff] [blame] | 20 | /* This is not in the standard. It is a margin added to the |
| 21 | * Toffset setpoint to mitigate TSF overcorrection |
| 22 | * introduced by TSF adjustment latency. |
| 23 | */ |
| 24 | #define TOFFSET_SET_MARGIN 20 |
| 25 | |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 26 | /* This is not in the standard. It represents the maximum Toffset jump above |
| 27 | * which we'll invalidate the Toffset setpoint and choose a new setpoint. This |
| 28 | * could be, for instance, in case a neighbor is restarted and its TSF counter |
| 29 | * reset. |
Javier Cardona | ec14bcd | 2012-04-12 14:32:23 -0700 | [diff] [blame] | 30 | */ |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 31 | #define TOFFSET_MAXIMUM_ADJUSTMENT 30000 /* 30 ms */ |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 32 | |
| 33 | struct sync_method { |
| 34 | u8 method; |
| 35 | struct ieee80211_mesh_sync_ops ops; |
| 36 | }; |
| 37 | |
| 38 | /** |
| 39 | * mesh_peer_tbtt_adjusting - check if an mp is currently adjusting its TBTT |
| 40 | * |
| 41 | * @ie: information elements of a management frame from the mesh peer |
| 42 | */ |
| 43 | static bool mesh_peer_tbtt_adjusting(struct ieee802_11_elems *ie) |
| 44 | { |
| 45 | return (ie->mesh_config->meshconf_cap & |
Marco Porsch | 6582163 | 2012-11-21 18:40:30 -0800 | [diff] [blame] | 46 | IEEE80211_MESHCONF_CAPAB_TBTT_ADJUSTING) != 0; |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | void mesh_sync_adjust_tbtt(struct ieee80211_sub_if_data *sdata) |
| 50 | { |
| 51 | struct ieee80211_local *local = sdata->local; |
| 52 | struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; |
| 53 | /* sdata->vif.bss_conf.beacon_int in 1024us units, 0.04% */ |
| 54 | u64 beacon_int_fraction = sdata->vif.bss_conf.beacon_int * 1024 / 2500; |
| 55 | u64 tsf; |
| 56 | u64 tsfdelta; |
| 57 | |
| 58 | spin_lock_bh(&ifmsh->sync_offset_lock); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 59 | if (ifmsh->sync_offset_clockdrift_max < beacon_int_fraction) { |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 60 | msync_dbg(sdata, "TBTT : max clockdrift=%lld; adjusting\n", |
| 61 | (long long) ifmsh->sync_offset_clockdrift_max); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 62 | tsfdelta = -ifmsh->sync_offset_clockdrift_max; |
| 63 | ifmsh->sync_offset_clockdrift_max = 0; |
| 64 | } else { |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 65 | msync_dbg(sdata, "TBTT : max clockdrift=%lld; adjusting by %llu\n", |
| 66 | (long long) ifmsh->sync_offset_clockdrift_max, |
| 67 | (unsigned long long) beacon_int_fraction); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 68 | tsfdelta = -beacon_int_fraction; |
| 69 | ifmsh->sync_offset_clockdrift_max -= beacon_int_fraction; |
| 70 | } |
Thomas Pedersen | 55fabef | 2012-10-05 17:57:39 -0700 | [diff] [blame] | 71 | spin_unlock_bh(&ifmsh->sync_offset_lock); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 72 | |
| 73 | tsf = drv_get_tsf(local, sdata); |
| 74 | if (tsf != -1ULL) |
| 75 | drv_set_tsf(local, sdata, tsf + tsfdelta); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | static void mesh_sync_offset_rx_bcn_presp(struct ieee80211_sub_if_data *sdata, |
| 79 | u16 stype, |
| 80 | struct ieee80211_mgmt *mgmt, |
| 81 | struct ieee802_11_elems *elems, |
| 82 | struct ieee80211_rx_status *rx_status) |
| 83 | { |
| 84 | struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; |
| 85 | struct ieee80211_local *local = sdata->local; |
| 86 | struct sta_info *sta; |
| 87 | u64 t_t, t_r; |
| 88 | |
| 89 | WARN_ON(ifmsh->mesh_sp_id != IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET); |
| 90 | |
| 91 | /* standard mentions only beacons */ |
| 92 | if (stype != IEEE80211_STYPE_BEACON) |
| 93 | return; |
| 94 | |
| 95 | /* The current tsf is a first approximation for the timestamp |
| 96 | * for the received beacon. Further down we try to get a |
| 97 | * better value from the rx_status->mactime field if |
| 98 | * available. Also we have to call drv_get_tsf() before |
| 99 | * entering the rcu-read section.*/ |
| 100 | t_r = drv_get_tsf(local, sdata); |
| 101 | |
| 102 | rcu_read_lock(); |
| 103 | sta = sta_info_get(sdata, mgmt->sa); |
| 104 | if (!sta) |
| 105 | goto no_sync; |
| 106 | |
| 107 | /* check offset sync conditions (13.13.2.2.1) |
| 108 | * |
| 109 | * TODO also sync to |
| 110 | * dot11MeshNbrOffsetMaxNeighbor non-peer non-MBSS neighbors |
| 111 | */ |
| 112 | |
| 113 | if (elems->mesh_config && mesh_peer_tbtt_adjusting(elems)) { |
| 114 | clear_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN); |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 115 | msync_dbg(sdata, "STA %pM : is adjusting TBTT\n", sta->sta.addr); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 116 | goto no_sync; |
| 117 | } |
| 118 | |
Thomas Pedersen | f4bda33 | 2012-11-13 10:46:27 -0800 | [diff] [blame] | 119 | if (ieee80211_have_rx_timestamp(rx_status)) |
| 120 | /* time when timestamp field was received */ |
| 121 | t_r = ieee80211_calculate_rx_timestamp(local, rx_status, |
| 122 | 24 + 12 + |
| 123 | elems->total_len + |
| 124 | FCS_LEN, |
| 125 | 24); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 126 | |
| 127 | /* Timing offset calculation (see 13.13.2.2.2) */ |
| 128 | t_t = le64_to_cpu(mgmt->u.beacon.timestamp); |
| 129 | sta->t_offset = t_t - t_r; |
| 130 | |
| 131 | if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) { |
| 132 | s64 t_clockdrift = sta->t_offset_setpoint |
| 133 | - sta->t_offset; |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 134 | msync_dbg(sdata, |
| 135 | "STA %pM : sta->t_offset=%lld, sta->t_offset_setpoint=%lld, t_clockdrift=%lld\n", |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 136 | sta->sta.addr, |
| 137 | (long long) sta->t_offset, |
| 138 | (long long) |
| 139 | sta->t_offset_setpoint, |
| 140 | (long long) t_clockdrift); |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 141 | |
| 142 | if (t_clockdrift > TOFFSET_MAXIMUM_ADJUSTMENT || |
| 143 | t_clockdrift < -TOFFSET_MAXIMUM_ADJUSTMENT) { |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 144 | msync_dbg(sdata, |
| 145 | "STA %pM : t_clockdrift=%lld too large, setpoint reset\n", |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 146 | sta->sta.addr, |
| 147 | (long long) t_clockdrift); |
| 148 | clear_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN); |
| 149 | goto no_sync; |
| 150 | } |
| 151 | |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 152 | rcu_read_unlock(); |
| 153 | |
| 154 | spin_lock_bh(&ifmsh->sync_offset_lock); |
| 155 | if (t_clockdrift > |
| 156 | ifmsh->sync_offset_clockdrift_max) |
| 157 | ifmsh->sync_offset_clockdrift_max |
| 158 | = t_clockdrift; |
| 159 | spin_unlock_bh(&ifmsh->sync_offset_lock); |
| 160 | |
| 161 | } else { |
Javier Cardona | 6ac95b5 | 2012-04-20 09:52:56 -0700 | [diff] [blame] | 162 | sta->t_offset_setpoint = sta->t_offset - TOFFSET_SET_MARGIN; |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 163 | set_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN); |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 164 | msync_dbg(sdata, |
| 165 | "STA %pM : offset was invalid, sta->t_offset=%lld\n", |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 166 | sta->sta.addr, |
| 167 | (long long) sta->t_offset); |
| 168 | rcu_read_unlock(); |
| 169 | } |
| 170 | return; |
| 171 | |
| 172 | no_sync: |
| 173 | rcu_read_unlock(); |
| 174 | } |
| 175 | |
| 176 | static void mesh_sync_offset_adjust_tbtt(struct ieee80211_sub_if_data *sdata) |
| 177 | { |
| 178 | struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; |
| 179 | |
| 180 | WARN_ON(ifmsh->mesh_sp_id |
| 181 | != IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET); |
| 182 | BUG_ON(!rcu_read_lock_held()); |
| 183 | |
| 184 | spin_lock_bh(&ifmsh->sync_offset_lock); |
| 185 | |
| 186 | if (ifmsh->sync_offset_clockdrift_max > |
Javier Cardona | a802a6e | 2012-04-12 14:32:22 -0700 | [diff] [blame] | 187 | TOFFSET_MINIMUM_ADJUSTMENT) { |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 188 | /* Since ajusting the tsf here would |
| 189 | * require a possibly blocking call |
| 190 | * to the driver tsf setter, we punt |
| 191 | * the tsf adjustment to the mesh tasklet |
| 192 | */ |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 193 | msync_dbg(sdata, |
| 194 | "TBTT : kicking off TBTT adjustment with clockdrift_max=%lld\n", |
| 195 | ifmsh->sync_offset_clockdrift_max); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 196 | set_bit(MESH_WORK_DRIFT_ADJUST, |
| 197 | &ifmsh->wrkq_flags); |
Marco Porsch | 3720390 | 2012-11-23 12:23:18 -0800 | [diff] [blame] | 198 | |
| 199 | ifmsh->adjusting_tbtt = true; |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 200 | } else { |
Johannes Berg | bdcbd8e | 2012-06-22 11:29:50 +0200 | [diff] [blame] | 201 | msync_dbg(sdata, |
| 202 | "TBTT : max clockdrift=%lld; too small to adjust\n", |
| 203 | (long long)ifmsh->sync_offset_clockdrift_max); |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 204 | ifmsh->sync_offset_clockdrift_max = 0; |
Marco Porsch | 3720390 | 2012-11-23 12:23:18 -0800 | [diff] [blame] | 205 | |
| 206 | ifmsh->adjusting_tbtt = false; |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 207 | } |
| 208 | spin_unlock_bh(&ifmsh->sync_offset_lock); |
| 209 | } |
| 210 | |
Johannes Berg | 8ba7acf | 2012-09-30 17:07:19 +0200 | [diff] [blame] | 211 | static const struct sync_method sync_methods[] = { |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 212 | { |
| 213 | .method = IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET, |
| 214 | .ops = { |
| 215 | .rx_bcn_presp = &mesh_sync_offset_rx_bcn_presp, |
| 216 | .adjust_tbtt = &mesh_sync_offset_adjust_tbtt, |
| 217 | } |
| 218 | }, |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 219 | }; |
| 220 | |
Johannes Berg | 8ba7acf | 2012-09-30 17:07:19 +0200 | [diff] [blame] | 221 | const struct ieee80211_mesh_sync_ops *ieee80211_mesh_sync_ops_get(u8 method) |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 222 | { |
Johannes Berg | 8ba7acf | 2012-09-30 17:07:19 +0200 | [diff] [blame] | 223 | const struct ieee80211_mesh_sync_ops *ops = NULL; |
Javier Cardona | dbf498f | 2012-03-31 11:31:32 -0700 | [diff] [blame] | 224 | u8 i; |
| 225 | |
| 226 | for (i = 0 ; i < ARRAY_SIZE(sync_methods); ++i) { |
| 227 | if (sync_methods[i].method == method) { |
| 228 | ops = &sync_methods[i].ops; |
| 229 | break; |
| 230 | } |
| 231 | } |
| 232 | return ops; |
| 233 | } |