Skip to contentSkip to conversation

mac80211: move mesh sync beacon handler into neighbour_update

PATCH New Marco Porsch 4 participants 9 messages Mar 4, 2013 – Mar 5, 2013

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH v4 1/3 mac80211: move mesh sync beacon handler into neighbour_update

Move the beacon handler into mesh_neighbour_update where the STA pointer is already available. This avoids additional overhead and simplifies the handler.
The repositioning will also benefit mesh PS which uses T_r and the updated T_offset value.
Allow calculating T_offset from probe response frames as mandated in IEEE 802.11-2012.

---

v4:
calculate T_offset from probe response frames (Thomas)

 net/mac80211/ieee80211_i.h |    5 ++---
 net/mac80211/mesh.c        |    7 +------
 net/mac80211/mesh.h        |    4 +++-
 net/mac80211/mesh_plink.c  |   30 +++++++++++++++++++++++------
 net/mac80211/mesh_sync.c   |   45 ++++++++------------------------------------
 5 files changed, 38 insertions(+), 53 deletions(-)
net/mac80211/ieee80211_i.h +2 -3
index 54d09ec..5284ffa 100644
@@ -529,11 +529,10 @@ struct ieee80211_if_ibss {
  */
 struct ieee802_11_elems;
 struct ieee80211_mesh_sync_ops {
-	void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata,
-			     u16 stype,
+	void (*rx_bcn_presp)(struct sta_info *sta,
 			     struct ieee80211_mgmt *mgmt,
 			     struct ieee802_11_elems *elems,
-			     struct ieee80211_rx_status *rx_status);
+			     u64 t_r);
 	void (*adjust_tbtt)(struct ieee80211_sub_if_data *sdata);
 	/* add other framework functions here */
 };
net/mac80211/mesh.c +1 -6
index f5d1afa..bfc5ee6 100644
@@ -885,7 +885,6 @@ static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
 					struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_local *local = sdata->local;
-	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 	struct ieee802_11_elems elems;
 	struct ieee80211_channel *channel;
 	size_t baselen;
@@ -921,11 +920,7 @@ static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
 		return;
 
 	if (mesh_matches_local(sdata, &elems))
-		mesh_neighbour_update(sdata, mgmt->sa, &elems);
-
-	if (ifmsh->sync_ops)
-		ifmsh->sync_ops->rx_bcn_presp(sdata,
-			stype, mgmt, &elems, rx_status);
+		mesh_neighbour_update(sdata, mgmt, &elems, rx_status);
 }
 
 static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata,
net/mac80211/mesh.h +3 -1
index 6ffabbe..594c43a 100644
@@ -283,7 +283,9 @@ int mesh_gate_num(struct ieee80211_sub_if_data *sdata);
 
 /* Mesh plinks */
 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
-			   u8 *hw_addr, struct ieee802_11_elems *ie);
+			   struct ieee80211_mgmt *mgmt,
+			   struct ieee802_11_elems *ie,
+			   struct ieee80211_rx_status *rx_status);
 bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie);
 u32 mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata);
 void mesh_plink_broken(struct sta_info *sta);
net/mac80211/mesh_plink.c +24 -6
index 08df966..91dea29 100644
@@ -12,6 +12,7 @@
 #include "ieee80211_i.h"
 #include "rate.h"
 #include "mesh.h"
+#include "driver-ops.h"
 
 #define PLINK_GET_LLID(p) (p + 2)
 #define PLINK_GET_PLID(p) (p + 4)
@@ -492,28 +493,45 @@ mesh_sta_info_get(struct ieee80211_sub_if_data *sdata,
  *
  * @sdata: local meshif
  * @addr: peer's address
- * @elems: IEs from beacon or mesh peering frame
+ * @elems: IEs from beacon or mesh probe response
  *
  * Initiates peering if appropriate.
  */
 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
-			   u8 *hw_addr,
-			   struct ieee802_11_elems *elems)
+			   struct ieee80211_mgmt *mgmt,
+			   struct ieee802_11_elems *elems,
+			   struct ieee80211_rx_status *rx_status)
 {
+	struct ieee80211_local *local = sdata->local;
+	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 	struct sta_info *sta;
 	u32 changed = 0;
+	u64 t_r;
+
+	/*
+	 * If available, calculate the time the beacon timestamp field was
+	 * received from the rx_status->mactime field. Otherwise get the
+	 * current TSF as approximation before entering rcu-read section.
+	 */
+	if (ieee80211_have_rx_timestamp(rx_status))
+		t_r = ieee80211_calculate_rx_timestamp(local, rx_status,
+				24 + 12 + elems->total_len + FCS_LEN, 24);
+	else
+		t_r = drv_get_tsf(local, sdata);
 
-	sta = mesh_sta_info_get(sdata, hw_addr, elems);
+	sta = mesh_sta_info_get(sdata, mgmt->sa, elems);
 	if (!sta)
 		goto out;
 
 	if (mesh_peer_accepts_plinks(elems) &&
 	    sta->plink_state == NL80211_PLINK_LISTEN &&
-	    sdata->u.mesh.accepting_plinks &&
-	    sdata->u.mesh.mshcfg.auto_open_plinks &&
+	    ifmsh->accepting_plinks && ifmsh->mshcfg.auto_open_plinks &&
 	    rssi_threshold_check(sta, sdata))
 		changed = mesh_plink_open(sta);
 
+	if (ifmsh->sync_ops)
+		ifmsh->sync_ops->rx_bcn_presp(sta, mgmt, elems, t_r);
+
 	ieee80211_mps_frame_release(sta, elems);
 out:
 	rcu_read_unlock();
net/mac80211/mesh_sync.c +8 -37

76 lines not on this page · raw message

Signature · 1 line
1.7.9.5
#1 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

Configure the device for PS mode if the local mesh PS parameters allow so and the driver supports it.

Add two callbacks to ieee80211_ops for mesh powersave:
- mesh_ps_doze - put the device to sleep now, wake up at given TBTT
- mesh_ps_wakeup - wake the device up now for frame RX These ops may be extended in the future to allow drivers/HW to implement mesh PS themselves. (Current design goal was to concentrate most mesh PS routines in mac80211 to keep driver modifications minimal.)

Track beacon timing information of peers we are in PS mode towards. Calculate the next TBTT per STA. Stay awake to receive multicast traffic after DTIM beacons.

When going to doze state, get the most imminent STA TBTT and configure the device to trigger a wakeup on time to catch that beacon. After successful receipt put the device to doze again. Set a timeout for the case that the beacon is not received on time. In this case calculate the following TBTT and go to doze again.

For mesh Awake Windows wakeup on PreTBTT/SWBA (beacon_get_tim) and start a timer which triggers a doze call on expiry. Similarly, stay awake for the Awake Window duration after sending probe response frames.

---

v4:
Awake Window after sending probe responses

 include/net/mac80211.h     |   10 ++
 net/mac80211/driver-ops.h  |   24 ++++
 net/mac80211/ieee80211_i.h |    6 +-
 net/mac80211/mesh.c        |   12 ++
 net/mac80211/mesh.h        |   13 ++
 net/mac80211/mesh_plink.c  |    5 +
 net/mac80211/mesh_ps.c     |  298 ++++++++++++++++++++++++++++++++++++++++++++
 net/mac80211/sta_info.h    |   10 ++
 net/mac80211/trace.h       |   30 +++++
 net/mac80211/tx.c          |    2 +
 10 files changed, 409 insertions(+), 1 deletion(-)
include/net/mac80211.h +10 -0
index cdd7cea..61f7db6 100644
@@ -2571,6 +2571,11 @@ enum ieee80211_roc_type {
  * @ipv6_addr_change: IPv6 address assignment on the given interface changed.
  *	Currently, this is only called for managed or P2P client interfaces.
  *	This callback is optional; it must not sleep.
+ *
+ * @mesh_ps_doze: Put the device to doze state now; schedule wakeup at given
+ *	TSF value (if non-zero). This callback is optional and may sleep.
+ * @mesh_ps_wakeup: Wake the device up now. This callback is optional and may
+ *	sleep.
  */
 struct ieee80211_ops {
 	void (*tx)(struct ieee80211_hw *hw,
@@ -2760,6 +2765,11 @@ struct ieee80211_ops {
 				 struct ieee80211_vif *vif,
 				 struct inet6_dev *idev);
 #endif
+
+#ifdef CONFIG_MAC80211_MESH
+	void (*mesh_ps_doze)(struct ieee80211_hw *hw, u64 nexttbtt);
+	void (*mesh_ps_wakeup)(struct ieee80211_hw *hw);
+#endif
 };
 
 /**
net/mac80211/driver-ops.h +24 -0
index 832acea..accb0ae 100644
@@ -1091,4 +1091,28 @@ static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
 }
 #endif
 
+#ifdef CONFIG_MAC80211_MESH
+
+static inline void drv_mesh_ps_doze(struct ieee80211_local *local, u64 nexttbtt)
+{
+	might_sleep();
+
+	trace_drv_mesh_ps_doze(local, nexttbtt);
+	if (local->ops->mesh_ps_doze)
+		local->ops->mesh_ps_doze(&local->hw, nexttbtt);
+	trace_drv_return_void(local);
+}
+
+static inline void drv_mesh_ps_wakeup(struct ieee80211_local *local)
+{
+	might_sleep();
+
+	trace_drv_mesh_ps_wakeup(local);
+	if (local->ops->mesh_ps_wakeup)
+		local->ops->mesh_ps_wakeup(&local->hw);
+	trace_drv_return_void(local);
+}
+
+#endif
+
 #endif /* __MAC80211_DRIVER_OPS */
net/mac80211/ieee80211_i.h +5 -1
index 5284ffa..4565b8c 100644
@@ -597,6 +597,7 @@ struct ieee80211_if_mesh {
 	int ps_peers_light_sleep;
 	int ps_peers_deep_sleep;
 	struct ps_data ps;
+	struct timer_list awake_window_end_timer;
 };
 
 #ifdef CONFIG_MAC80211_MESH
@@ -1088,7 +1089,7 @@ struct ieee80211_local {
 	bool pspolling;
 	bool offchannel_ps_enabled;
 	/*
-	 * PS can only be enabled when we have exactly one managed
+	 * managed mode PS can only be enabled when we have exactly one managed
 	 * interface (and monitors) in PS, this then points there.
 	 */
 	struct ieee80211_sub_if_data *ps_sdata;
@@ -1107,6 +1108,9 @@ struct ieee80211_local {
 
 	int user_power_level; /* in dBm, for all interfaces */
 
+	/* mesh power save can be enabled for multiple (but only mesh) vif */
+	bool mps_enabled;
+
 	enum ieee80211_smps_mode smps_mode;
 
 	struct work_struct restart_work;
net/mac80211/mesh.c +12 -0
index bfc5ee6..bdd6208 100644
@@ -159,6 +159,7 @@ void mesh_sta_cleanup(struct sta_info *sta)
 	if (sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
 		changed |= mesh_plink_deactivate(sta);
 		del_timer_sync(&sta->plink_timer);
+		del_timer_sync(&sta->nexttbtt_timer);
 	}
 
 	if (changed)
@@ -874,6 +875,7 @@ ieee80211_mesh_rx_probe_req(struct ieee80211_sub_if_data *sdata,
 	memcpy(hdr->da, mgmt->sa, ETH_ALEN);
 	IEEE80211_SKB_CB(presp)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
 	ieee80211_tx_skb(sdata, presp);
+	ieee80211_mps_awake_window_start(sdata);
 out:
 	rcu_read_unlock();
 }
@@ -973,6 +975,7 @@ void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
 
 void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata)
 {
+	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 
 	if (ifmsh->preq_queue_len &&
@@ -994,6 +997,12 @@ void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata)
 
 	if (test_and_clear_bit(MESH_WORK_DRIFT_ADJUST, &ifmsh->wrkq_flags))
 		mesh_sync_adjust_tbtt(sdata);
+
+	if (test_and_clear_bit(MESH_WORK_PS_HW_CONF, &ifmsh->wrkq_flags))
+		ieee80211_mps_hw_conf(local);
+
+	if (test_and_clear_bit(MESH_WORK_PS_DOZE, &ifmsh->wrkq_flags))
+		ieee80211_mps_doze(local);
 }
 
 void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local)
@@ -1033,6 +1042,9 @@ void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
 	setup_timer(&ifmsh->mesh_path_root_timer,
 		    ieee80211_mesh_path_root_timer,
 		    (unsigned long) sdata);
+	setup_timer(&ifmsh->awake_window_end_timer,
+		    ieee80211_mps_awake_window_end,
+		    (unsigned long) sdata);
 	INIT_LIST_HEAD(&ifmsh->preq_queue.list);
 	skb_queue_head_init(&ifmsh->ps.bc_buf);
 	spin_lock_init(&ifmsh->mesh_preq_queue_lock);
net/mac80211/mesh.h +13 -0
index 594c43a..704144b 100644
@@ -58,6 +58,8 @@ enum mesh_path_flags {
  * @MESH_WORK_ROOT: the mesh root station needs to send a frame
  * @MESH_WORK_DRIFT_ADJUST: time to compensate for clock drift relative to other
  * mesh nodes
+ * @MESH_WORK_PS_HW_CONF: perform checks for PS mode and configure hardware
+ * @MESH_WORK_PS_DOZE: perform checks for doze state and put hardware to doze
  */
 enum mesh_deferred_task_flags {
 	MESH_WORK_HOUSEKEEPING,
@@ -65,6 +67,8 @@ enum mesh_deferred_task_flags {
 	MESH_WORK_GROW_MPP_TABLE,
 	MESH_WORK_ROOT,
 	MESH_WORK_DRIFT_ADJUST,
+	MESH_WORK_PS_HW_CONF,
+	MESH_WORK_PS_DOZE,
 };
 
 /**
@@ -256,6 +260,15 @@ void ieee80211_mpsp_trigger_process(u8 *qc, struct sta_info *sta,
 				    bool tx, bool acked);
 void ieee80211_mps_frame_release(struct sta_info *sta,
 				 struct ieee802_11_elems *elems);
+void ieee80211_mps_hw_conf(struct ieee80211_local *local);
+void ieee80211_mps_sta_tbtt_update(struct sta_info *sta,
+				   struct ieee80211_mgmt *mgmt,
+				   const struct ieee80211_tim_ie *tim,
+				   u64 tsf);
+void ieee80211_mps_sta_tbtt_timeout(unsigned long data);
+void ieee80211_mps_awake_window_start(struct ieee80211_sub_if_data *sdata);
+void ieee80211_mps_awake_window_end(unsigned long data);
+void ieee80211_mps_doze(struct ieee80211_local *local);
 
 /* Mesh paths */
 int mesh_nexthop_lookup(struct ieee80211_sub_if_data *sdata,
net/mac80211/mesh_plink.c +5 -0
index 91dea29..aaa1d85 100644
@@ -422,6 +422,8 @@ __mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *hw_addr)
 
 	sta->plink_state = NL80211_PLINK_LISTEN;
 	init_timer(&sta->plink_timer);
+	setup_timer(&sta->nexttbtt_timer, ieee80211_mps_sta_tbtt_timeout,
+		    (unsigned long) sta);
 
 	sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
 	sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
@@ -533,6 +535,9 @@ void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
 		ifmsh->sync_ops->rx_bcn_presp(sta, mgmt, elems, t_r);
 
 	ieee80211_mps_frame_release(sta, elems);
+
+	if (ieee80211_is_beacon(mgmt->frame_control))
+		ieee80211_mps_sta_tbtt_update(sta, mgmt, elems->tim, t_r);
 out:
 	rcu_read_unlock();
 	ieee80211_mbss_info_change_notify(sdata, changed);
net/mac80211/mesh_ps.c +298 -0

337 lines not on this page · raw message

net/mac80211/sta_info.h +10 -0
index e5868c3..ab43b52 100644
@@ -58,6 +58,7 @@
  * @WLAN_STA_TOFFSET_KNOWN: toffset calculated for this station is valid.
  * @WLAN_STA_MPSP_OWNER: local STA is owner of a mesh Peer Service Period.
  * @WLAN_STA_MPSP_RECIPIENT: local STA is recipient of a MPSP.
+ * @WLAN_STA_MPS_WAIT_FOR_CAB: multicast frames from this STA are imminent.
  */
 enum ieee80211_sta_info_flags {
 	WLAN_STA_AUTH,
@@ -82,6 +83,7 @@ enum ieee80211_sta_info_flags {
 	WLAN_STA_TOFFSET_KNOWN,
 	WLAN_STA_MPSP_OWNER,
 	WLAN_STA_MPSP_RECIPIENT,
+	WLAN_STA_MPS_WAIT_FOR_CAB,
 };
 
 #define ADDBA_RESP_INTERVAL HZ
@@ -287,6 +289,10 @@ struct sta_ampdu_mlme {
  * @local_pm: local link-specific power save mode
  * @peer_pm: peer-specific power save mode towards local STA
  * @nonpeer_pm: STA power save mode towards non-peer neighbors
+ * @beacon_interval: beacon interval of neighbor STA (in us)
+ * @nexttbtt_tsf: next TBTT in local TSF units
+ * @nexttbtt_jiffies: next TBTT in jiffies units
+ * @nexttbtt_timer: timeout for missed beacons
  * @debugfs: debug filesystem info
  * @dead: set to true when sta is unlinked
  * @uploaded: set to true when sta is uploaded to the driver
@@ -387,6 +393,10 @@ struct sta_info {
 	enum nl80211_mesh_power_mode local_pm;
 	enum nl80211_mesh_power_mode peer_pm;
 	enum nl80211_mesh_power_mode nonpeer_pm;
+	u32 beacon_interval;
+	u64 nexttbtt_tsf;
+	unsigned long nexttbtt_jiffies;
+	struct timer_list nexttbtt_timer;
 #endif
 
 #ifdef CONFIG_MAC80211_DEBUGFS
net/mac80211/trace.h +30 -0
index e7db2b8..41fbcbe 100644
@@ -1453,6 +1453,36 @@ DEFINE_EVENT(local_sdata_evt, drv_ipv6_addr_change,
 );
 #endif
 
+#ifdef CONFIG_MAC80211_MESH
+
+TRACE_EVENT(drv_mesh_ps_doze,
+	TP_PROTO(struct ieee80211_local *local, u64 nexttbtt),
+
+	TP_ARGS(local, nexttbtt),
+
+	TP_STRUCT__entry(
+		LOCAL_ENTRY
+		__field(u64, nexttbtt)
+	),
+
+	TP_fast_assign(
+		LOCAL_ASSIGN;
+		__entry->nexttbtt = nexttbtt;
+	),
+
+	TP_printk(
+		LOCAL_PR_FMT " nexttbtt:%llu",
+		LOCAL_PR_ARG, (unsigned long long)__entry->nexttbtt
+	)
+);
+
+DEFINE_EVENT(local_only_evt, drv_mesh_ps_wakeup,
+	TP_PROTO(struct ieee80211_local *local),
+	TP_ARGS(local)
+);
+
+#endif
+
 /*
  * Tracing for API calls that drivers call.
  */
net/mac80211/tx.c +2 -0
index cb4b9ab..c0ab733 100644
@@ -2475,6 +2475,8 @@ struct sk_buff *ieee80211_beacon_get_tim(struct ieee80211_hw *hw,
 		memcpy(skb_put(skb, bcn->head_len), bcn->head, bcn->head_len);
 		ieee80211_beacon_add_tim(sdata, &ifmsh->ps, skb);
 		memcpy(skb_put(skb, bcn->tail_len), bcn->tail, bcn->tail_len);
+
+		ieee80211_mps_awake_window_start(sdata);
 	} else {
 		WARN_ON(1);
 		goto out;
Signature · 1 line
1.7.9.5
#2 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

Quoted 23 lines · Marco Porsch

Configure the device for PS mode if the local mesh PS parameters allow so and the driver supports it.

Add two callbacks to ieee80211_ops for mesh powersave:
- mesh_ps_doze - put the device to sleep now, wake up at given TBTT
- mesh_ps_wakeup - wake the device up now for frame RX These ops may be extended in the future to allow drivers/HW to implement mesh PS themselves. (Current design goal was to concentrate most mesh PS routines in mac80211 to keep driver modifications minimal.)

Track beacon timing information of peers we are in PS mode towards. Calculate the next TBTT per STA. Stay awake to receive multicast traffic after DTIM beacons.

When going to doze state, get the most imminent STA TBTT and configure the device to trigger a wakeup on time to catch that beacon. After successful receipt put the device to doze again. Set a timeout for the case that the beacon is not received on time. In this case calculate the following TBTT and go to doze again.

Quoted 6 lines

For mesh Awake Windows wakeup on PreTBTT/SWBA (beacon_get_tim) and start a timer which triggers a doze call on expiry. Similarly, stay awake for the Awake Window duration after sending probe response frames.

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Anyway, I just wanted to throw this out for discussion.

Thanks,
Seth

[1] http://article.gmane.org/gmane.linux.kernel.wireless.general/104064

#3 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

Quoted 42 lines · Seth Forshee
Quoted 23 lines · Marco Porsch

Configure the device for PS mode if the local mesh PS parameters allow so and the driver supports it.

Add two callbacks to ieee80211_ops for mesh powersave:
- mesh_ps_doze - put the device to sleep now, wake up at given TBTT
- mesh_ps_wakeup - wake the device up now for frame RX These ops may be extended in the future to allow drivers/HW to implement mesh PS themselves. (Current design goal was to concentrate most mesh PS routines in mac80211 to keep driver modifications minimal.)

Track beacon timing information of peers we are in PS mode towards. Calculate the next TBTT per STA. Stay awake to receive multicast traffic after DTIM beacons.

When going to doze state, get the most imminent STA TBTT and configure the device to trigger a wakeup on time to catch that beacon. After successful receipt put the device to doze again. Set a timeout for the case that the beacon is not received on time. In this case calculate the following TBTT and go to doze again.

Quoted 6 lines

For mesh Awake Windows wakeup on PreTBTT/SWBA (beacon_get_tim) and start a timer which triggers a doze call on expiry. Similarly, stay awake for the Awake Window duration after sending probe response frames.

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

Quoted 8 lines

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Anyway, I just wanted to throw this out for discussion.

I would love to see multi-vif (station) power-saving support happen. I'm low on development cycles at the moment, but at the least we can do some testing....

Thanks,
Ben

Quoted 11 lines

Thanks,
Seth

[1] http://article.gmane.org/gmane.linux.kernel.wireless.general/104064

_______________________________________________
ath9k-devel mailing list
ath9k-devel at lists.ath9k.org
https://lists.ath9k.org/mailman/listinfo/ath9k-devel

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
maintainer
#4 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

In reply to Seth Forshee
Quoted 5 lines · Seth Forshee

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

Yeah, this is a concern. I didn't really stand in the way of doing mesh powersave though, and it seemed that the new interface here would actually be somewhat suitable, since for mesh any kind of powersave code needs to know when to wake up/sleep. I would've liked to see less reliance on host timers directly in core mac80211 even for the going to sleep part though... basically I'm not sure for mesh just having PS state will cut it. For managed mode this is easy because it only needs to sync with a single AP, but for mesh that's a bit more complicated and I think the whole sync should stay in mac80211. In the general case, just having the TSF might not be enough, but that can be solved as needed.

Quoted 4 lines

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

Yeah, that about matches what I was thinking. But like I said above, while this is fairly simple for managed mode, at least as required today, it's clearly not as simple for mesh.

For managed mode, we also assume that we can send packets while the device is sleeping, and the device will do the right thing to wake up for beacons from the AP etc. For mesh, there are many more wakeup sources, from what I can tell.

Quoted 6 lines

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Such an interface would probably have to be the interface now defined for mesh, telling the device when to wake up and go to sleep? But this interface is rather inefficient for most chipsets...

johannes

#5 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

Quoted 8 lines · Johannes Berg
Quoted 5 lines · Seth Forshee

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

Quoted 11 lines

Yeah, this is a concern. I didn't really stand in the way of doing mesh powersave though, and it seemed that the new interface here would actually be somewhat suitable, since for mesh any kind of powersave code needs to know when to wake up/sleep. I would've liked to see less reliance on host timers directly in core mac80211 even for the going to sleep part though... basically I'm not sure for mesh just having PS state will cut it. For managed mode this is easy because it only needs to sync with a single AP, but for mesh that's a bit more complicated and I think the whole sync should stay in mac80211. In the general case, just having the TSF might not be enough, but that can be solved as needed.

I read about the basics of mesh PS last week but don't have a firm enough grasp on the details to understand what all would be needed for an implementation. From these patches it looks like at minimum the drivers need the next TBTT. That could be incorporated into something more generic easily enough.

It's not the end of the world if these patches go in, it will just have to be sorted out if/when I make some progress on multi-vif PS. I wasn't planning on trying to lift any of the current restrictions on multiple vifs right away anyhow, so it should be manageable.

Quoted 8 lines
Quoted 4 lines

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

Yeah, that about matches what I was thinking. But like I said above, while this is fairly simple for managed mode, at least as required today, it's clearly not as simple for mesh.

Glad to hear I'm headed down the right path :-)

I've been trying to take all modes into consideration, but I had hoped the implementation details of mesh were something I wouldn't have to be immediately concerned with, since as you point out all of this is easier for managed mode.

Quoted 12 lines

For managed mode, we also assume that we can send packets while the device is sleeping, and the device will do the right thing to wake up for beacons from the AP etc. For mesh, there are many more wakeup sources, from what I can tell.

Quoted 6 lines

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Quoted 3 lines

Such an interface would probably have to be the interface now defined for mesh, telling the device when to wake up and go to sleep? But this interface is rather inefficient for most chipsets...

I was thinking something along those lines as well, either the interfaces would be similar to the ones here or the data would be available in ieee80211_conf. Frankly I find having both the PS callback and IEEE80211_CONF_PS confusing, but maybe if I look at the patches more closely it will make sense.

Seth

#6 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

In reply to Johannes Berg

Am 04.03.2013 21:25, schrieb Johannes Berg:

Quoted 25 lines · Seth Forshee
Quoted 6 lines

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

Yeah, this is a concern. I didn't really stand in the way of doing mesh powersave though, and it seemed that the new interface here would actually be somewhat suitable, since for mesh any kind of powersave code needs to know when to wake up/sleep. I would've liked to see less reliance on host timers directly in core mac80211 even for the going to sleep part though... basically I'm not sure for mesh just having PS state will cut it. For managed mode this is easy because it only needs to sync with a single AP, but for mesh that's a bit more complicated and I think the whole sync should stay in mac80211. In the general case, just having the TSF might not be enough, but that can be solved as needed.

Quoted 4 lines

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

Quoted 8 lines

Yeah, that about matches what I was thinking. But like I said above, while this is fairly simple for managed mode, at least as required today, it's clearly not as simple for mesh.

For managed mode, we also assume that we can send packets while the device is sleeping, and the device will do the right thing to wake up for beacons from the AP etc. For mesh, there are many more wakeup sources, from what I can tell.

I also assume that the device deals with TX while sleeping.

The complete list of wakeup sources for mesh are:
- awake window after beacon and probe response TX
- authentication, peering, scanning procedures
- frame release in mesh peer service periods
- RX peer's beacons and DTIM multicasts (only in mesh light sleep mode)

Quoted 10 lines
Quoted 6 lines

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Such an interface would probably have to be the interface now defined for mesh, telling the device when to wake up and go to sleep? But this interface is rather inefficient for most chipsets...

I guess the case of a single managed mode vif should be handled separately to benefit from the HW support most devices provide.

--Marco

#7 lore raw

PATCH v4 2/3 mac80211: mesh power save doze scheduling

In reply to Seth Forshee

Am 04.03.2013 20:23, schrieb Seth Forshee:

Quoted 49 lines · Marco Porsch
Quoted 23 lines

Configure the device for PS mode if the local mesh PS parameters allow so and the driver supports it.

Add two callbacks to ieee80211_ops for mesh powersave:
- mesh_ps_doze - put the device to sleep now, wake up at given TBTT
- mesh_ps_wakeup - wake the device up now for frame RX These ops may be extended in the future to allow drivers/HW to implement mesh PS themselves. (Current design goal was to concentrate most mesh PS routines in mac80211 to keep driver modifications minimal.)

Track beacon timing information of peers we are in PS mode towards. Calculate the next TBTT per STA. Stay awake to receive multicast traffic after DTIM beacons.

When going to doze state, get the most imminent STA TBTT and configure the device to trigger a wakeup on time to catch that beacon. After successful receipt put the device to doze again. Set a timeout for the case that the beacon is not received on time. In this case calculate the following TBTT and go to doze again.

Quoted 6 lines

For mesh Awake Windows wakeup on PreTBTT/SWBA (beacon_get_tim) and start a timer which triggers a doze call on expiry. Similarly, stay awake for the Awake Window duration after sending probe response frames.

I've been looking at power save in mac80211 over the past few days with an eye towards allowing multiple interface to be supported, as a result of comments Johannes made at [1]. It seems like adding driver callbacks for PS which are specific to the interface type is contrary to this goal.

The basic idea that's been forming on my mind is add PS states to vifs and make the managed, mesh, etc. code manipulate vif PS states rather than hw states. Then a PS module would manage the hw state based on the aggregate of the vif states.

I don't have a lot of the details worked out yet, and my knowledge of PS in mesh networks (and of mesh network operation in general) is pretty rudimentary at this point. But afaict any modes which support PS define the same two hw states, awake and doze. I wonder whether we should instead aim for a single interface into the driver for PS that's capable of supporting all interface types.

Quoted 7 lines

Anyway, I just wanted to throw this out for discussion.

Thanks,
Seth

[1] http://article.gmane.org/gmane.linux.kernel.wireless.general/104064

Please mind that these callbacks are not necessarily bound to mesh mode (although the name suggests so) and may as well be incorporated into a more general interface that also suits managed and ad-hoc mode later. It is just that currently only mesh uses this and I lack the overview of mode and driver combinations to create a one-fits-all solution.

--Marco

#8 lore raw

PATCH v4 3/3 ath9k: mesh powersave support

In reply to Marco Porsch

Add ath9k_ops for .mesh_ps_doze and .mesh_ps_wakeup.

React to doze/wakeup calls issued by mac80211. Add a PS status flag PS_MAC80211_CTL to store last mesh PS command from mac80211.

Initialize HW beacon wakeup registers.
On doze call configure the device to wakeup at the given TSF value.

---
 drivers/net/wireless/ath/ath9k/ath9k.h  |    1 +
 drivers/net/wireless/ath/ath9k/beacon.c |   21 ++++++++++-
 drivers/net/wireless/ath/ath9k/hw.c     |   17 +++++++--
 drivers/net/wireless/ath/ath9k/main.c   |   62 ++++++++++++++++++++++++++++++-
 4 files changed, 94 insertions(+), 7 deletions(-)
drivers/net/wireless/ath/ath9k/ath9k.h +1 -0
index 97c90b2..b82727b 100644
@@ -652,6 +652,7 @@ enum sc_op_flags {
 #define PS_WAIT_FOR_TX_ACK        BIT(3)
 #define PS_BEACON_SYNC            BIT(4)
 #define PS_WAIT_FOR_ANI           BIT(5)
+#define PS_MAC80211_CTL           BIT(6)
 
 struct ath_rate_table;
 
drivers/net/wireless/ath/ath9k/beacon.c +20 -1
index dd37719..7ef698b 100644
@@ -599,6 +599,23 @@ static void ath9k_beacon_config_adhoc(struct ath_softc *sc,
 	ath9k_beacon_init(sc, nexttbtt, intval);
 }
 
+static void ath9k_beacon_config_mesh(struct ath_softc *sc,
+				     struct ath_beacon_config *conf)
+{
+	struct ath9k_beacon_state bs;
+
+	/*
+	 * when PS is enabled, ath9k_hw_setrxabort is set.
+	 * to wake up again to receive peers' beacons, we set an
+	 * arbitrary initial value for sleepduration here
+	 */
+	memset(&bs, 0, sizeof(bs));
+	bs.bs_sleepduration = IEEE80211_MS_TO_TU(100);
+	ath9k_hw_set_sta_beacon_timers(sc->sc_ah, &bs);
+
+	ath9k_beacon_config_adhoc(sc, conf);
+}
+
 bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
 {
 	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
@@ -707,9 +724,11 @@ void ath9k_set_beacon(struct ath_softc *sc)
 		ath9k_beacon_config_ap(sc, cur_conf);
 		break;
 	case NL80211_IFTYPE_ADHOC:
-	case NL80211_IFTYPE_MESH_POINT:
 		ath9k_beacon_config_adhoc(sc, cur_conf);
 		break;
+	case NL80211_IFTYPE_MESH_POINT:
+		ath9k_beacon_config_mesh(sc, cur_conf);
+		break;
 	case NL80211_IFTYPE_STATION:
 		ath9k_beacon_config_sta(sc, cur_conf);
 		break;
drivers/net/wireless/ath/ath9k/hw.c +13 -4
index 42cf3c7..0e0fe03 100644
@@ -2254,16 +2254,24 @@ void ath9k_hw_beaconinit(struct ath_hw *ah, u32 next_beacon, u32 beacon_period)
 }
 EXPORT_SYMBOL(ath9k_hw_beaconinit);
 
+/**
+ * ath9k_hw_set_sta_beacon_timers
+ *
+ * in mesh mode overwriting AR_NEXT_TBTT_TIMER and setting AR_TBTT_TIMER_EN
+ * would shift the own TBTT
+ */
 void ath9k_hw_set_sta_beacon_timers(struct ath_hw *ah,
 				    const struct ath9k_beacon_state *bs)
 {
 	u32 nextTbtt, beaconintval, dtimperiod, beacontimeout;
+	u32 ar_timer_mode = AR_DTIM_TIMER_EN | AR_TIM_TIMER_EN;
 	struct ath9k_hw_capabilities *pCap = &ah->caps;
 	struct ath_common *common = ath9k_hw_common(ah);
 
 	ENABLE_REGWRITE_BUFFER(ah);
 
-	REG_WRITE(ah, AR_NEXT_TBTT_TIMER, TU_TO_USEC(bs->bs_nexttbtt));
+	if (ah->opmode != NL80211_IFTYPE_MESH_POINT)
+		REG_WRITE(ah, AR_NEXT_TBTT_TIMER, TU_TO_USEC(bs->bs_nexttbtt));
 
 	REG_WRITE(ah, AR_BEACON_PERIOD,
 		  TU_TO_USEC(bs->bs_intval));
@@ -2317,9 +2325,10 @@ void ath9k_hw_set_sta_beacon_timers(struct ath_hw *ah,
 
 	REGWRITE_BUFFER_FLUSH(ah);
 
-	REG_SET_BIT(ah, AR_TIMER_MODE,
-		    AR_TBTT_TIMER_EN | AR_TIM_TIMER_EN |
-		    AR_DTIM_TIMER_EN);
+	if (ah->opmode != NL80211_IFTYPE_MESH_POINT)
+		ar_timer_mode |= AR_TBTT_TIMER_EN;
+
+	REG_SET_BIT(ah, AR_TIMER_MODE, ar_timer_mode);
 
 	/* TSF Out of Range Threshold */
 	REG_WRITE(ah, AR_TSFOOR_THRESHOLD, bs->bs_tsfoor_threshold);
drivers/net/wireless/ath/ath9k/main.c +60 -2

84 lines not on this page · raw message

Signature · 1 line
1.7.9.5