xref: /openbmc/linux/net/mac80211/rate.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
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 <linux/kernel.h>
12 #include <linux/rtnetlink.h>
13 #include "rate.h"
14 #include "ieee80211_i.h"
15 #include "debugfs.h"
16 
17 struct rate_control_alg {
18 	struct list_head list;
19 	struct rate_control_ops *ops;
20 };
21 
22 static LIST_HEAD(rate_ctrl_algs);
23 static DEFINE_MUTEX(rate_ctrl_mutex);
24 
25 static char *ieee80211_default_rc_algo = CONFIG_MAC80211_RC_DEFAULT;
26 module_param(ieee80211_default_rc_algo, charp, 0644);
27 MODULE_PARM_DESC(ieee80211_default_rc_algo,
28 		 "Default rate control algorithm for mac80211 to use");
29 
30 int ieee80211_rate_control_register(struct rate_control_ops *ops)
31 {
32 	struct rate_control_alg *alg;
33 
34 	if (!ops->name)
35 		return -EINVAL;
36 
37 	mutex_lock(&rate_ctrl_mutex);
38 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
39 		if (!strcmp(alg->ops->name, ops->name)) {
40 			/* don't register an algorithm twice */
41 			WARN_ON(1);
42 			mutex_unlock(&rate_ctrl_mutex);
43 			return -EALREADY;
44 		}
45 	}
46 
47 	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
48 	if (alg == NULL) {
49 		mutex_unlock(&rate_ctrl_mutex);
50 		return -ENOMEM;
51 	}
52 	alg->ops = ops;
53 
54 	list_add_tail(&alg->list, &rate_ctrl_algs);
55 	mutex_unlock(&rate_ctrl_mutex);
56 
57 	return 0;
58 }
59 EXPORT_SYMBOL(ieee80211_rate_control_register);
60 
61 void ieee80211_rate_control_unregister(struct rate_control_ops *ops)
62 {
63 	struct rate_control_alg *alg;
64 
65 	mutex_lock(&rate_ctrl_mutex);
66 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
67 		if (alg->ops == ops) {
68 			list_del(&alg->list);
69 			kfree(alg);
70 			break;
71 		}
72 	}
73 	mutex_unlock(&rate_ctrl_mutex);
74 }
75 EXPORT_SYMBOL(ieee80211_rate_control_unregister);
76 
77 static struct rate_control_ops *
78 ieee80211_try_rate_control_ops_get(const char *name)
79 {
80 	struct rate_control_alg *alg;
81 	struct rate_control_ops *ops = NULL;
82 
83 	if (!name)
84 		return NULL;
85 
86 	mutex_lock(&rate_ctrl_mutex);
87 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
88 		if (!strcmp(alg->ops->name, name))
89 			if (try_module_get(alg->ops->module)) {
90 				ops = alg->ops;
91 				break;
92 			}
93 	}
94 	mutex_unlock(&rate_ctrl_mutex);
95 	return ops;
96 }
97 
98 /* Get the rate control algorithm. */
99 static struct rate_control_ops *
100 ieee80211_rate_control_ops_get(const char *name)
101 {
102 	struct rate_control_ops *ops;
103 	const char *alg_name;
104 
105 	if (!name)
106 		alg_name = ieee80211_default_rc_algo;
107 	else
108 		alg_name = name;
109 
110 	ops = ieee80211_try_rate_control_ops_get(alg_name);
111 	if (!ops) {
112 		request_module("rc80211_%s", alg_name);
113 		ops = ieee80211_try_rate_control_ops_get(alg_name);
114 	}
115 	if (!ops && name)
116 		/* try default if specific alg requested but not found */
117 		ops = ieee80211_try_rate_control_ops_get(ieee80211_default_rc_algo);
118 
119 	/* try built-in one if specific alg requested but not found */
120 	if (!ops && strlen(CONFIG_MAC80211_RC_DEFAULT))
121 		ops = ieee80211_try_rate_control_ops_get(CONFIG_MAC80211_RC_DEFAULT);
122 
123 	return ops;
124 }
125 
126 static void ieee80211_rate_control_ops_put(struct rate_control_ops *ops)
127 {
128 	module_put(ops->module);
129 }
130 
131 #ifdef CONFIG_MAC80211_DEBUGFS
132 static ssize_t rcname_read(struct file *file, char __user *userbuf,
133 			   size_t count, loff_t *ppos)
134 {
135 	struct rate_control_ref *ref = file->private_data;
136 	int len = strlen(ref->ops->name);
137 
138 	return simple_read_from_buffer(userbuf, count, ppos,
139 				       ref->ops->name, len);
140 }
141 
142 static const struct file_operations rcname_ops = {
143 	.read = rcname_read,
144 	.open = mac80211_open_file_generic,
145 };
146 #endif
147 
148 struct rate_control_ref *rate_control_alloc(const char *name,
149 					    struct ieee80211_local *local)
150 {
151 	struct dentry *debugfsdir = NULL;
152 	struct rate_control_ref *ref;
153 
154 	ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL);
155 	if (!ref)
156 		goto fail_ref;
157 	kref_init(&ref->kref);
158 	ref->local = local;
159 	ref->ops = ieee80211_rate_control_ops_get(name);
160 	if (!ref->ops)
161 		goto fail_ops;
162 
163 #ifdef CONFIG_MAC80211_DEBUGFS
164 	debugfsdir = debugfs_create_dir("rc", local->hw.wiphy->debugfsdir);
165 	local->debugfs.rcdir = debugfsdir;
166 	debugfs_create_file("name", 0400, debugfsdir, ref, &rcname_ops);
167 #endif
168 
169 	ref->priv = ref->ops->alloc(&local->hw, debugfsdir);
170 	if (!ref->priv)
171 		goto fail_priv;
172 	return ref;
173 
174 fail_priv:
175 	ieee80211_rate_control_ops_put(ref->ops);
176 fail_ops:
177 	kfree(ref);
178 fail_ref:
179 	return NULL;
180 }
181 
182 static void rate_control_release(struct kref *kref)
183 {
184 	struct rate_control_ref *ctrl_ref;
185 
186 	ctrl_ref = container_of(kref, struct rate_control_ref, kref);
187 	ctrl_ref->ops->free(ctrl_ref->priv);
188 
189 #ifdef CONFIG_MAC80211_DEBUGFS
190 	debugfs_remove_recursive(ctrl_ref->local->debugfs.rcdir);
191 	ctrl_ref->local->debugfs.rcdir = NULL;
192 #endif
193 
194 	ieee80211_rate_control_ops_put(ctrl_ref->ops);
195 	kfree(ctrl_ref);
196 }
197 
198 static bool rc_no_data_or_no_ack(struct ieee80211_tx_rate_control *txrc)
199 {
200 	struct sk_buff *skb = txrc->skb;
201 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
202 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
203 	__le16 fc;
204 
205 	fc = hdr->frame_control;
206 
207 	return ((info->flags & IEEE80211_TX_CTL_NO_ACK) || !ieee80211_is_data(fc));
208 }
209 
210 bool rate_control_send_low(struct ieee80211_sta *sta,
211 			   void *priv_sta,
212 			   struct ieee80211_tx_rate_control *txrc)
213 {
214 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
215 
216 	if (!sta || !priv_sta || rc_no_data_or_no_ack(txrc)) {
217 		info->control.rates[0].idx = rate_lowest_index(txrc->sband, sta);
218 		info->control.rates[0].count =
219 			(info->flags & IEEE80211_TX_CTL_NO_ACK) ?
220 			1 : txrc->hw->max_rate_tries;
221 		return true;
222 	}
223 	return false;
224 }
225 EXPORT_SYMBOL(rate_control_send_low);
226 
227 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
228 			   struct sta_info *sta,
229 			   struct ieee80211_tx_rate_control *txrc)
230 {
231 	struct rate_control_ref *ref = sdata->local->rate_ctrl;
232 	void *priv_sta = NULL;
233 	struct ieee80211_sta *ista = NULL;
234 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
235 	int i;
236 
237 	if (sta) {
238 		ista = &sta->sta;
239 		priv_sta = sta->rate_ctrl_priv;
240 	}
241 
242 	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
243 		info->control.rates[i].idx = -1;
244 		info->control.rates[i].flags = 0;
245 		info->control.rates[i].count = 1;
246 	}
247 
248 	if (sta && sdata->force_unicast_rateidx > -1) {
249 		info->control.rates[0].idx = sdata->force_unicast_rateidx;
250 	} else {
251 		ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
252 		info->flags |= IEEE80211_TX_INTFL_RCALGO;
253 	}
254 
255 	/*
256 	 * try to enforce the maximum rate the user wanted
257 	 */
258 	if (sdata->max_ratectrl_rateidx > -1)
259 		for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
260 			if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
261 				continue;
262 			info->control.rates[i].idx =
263 				min_t(s8, info->control.rates[i].idx,
264 				      sdata->max_ratectrl_rateidx);
265 	}
266 
267 	BUG_ON(info->control.rates[0].idx < 0);
268 }
269 
270 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
271 {
272 	kref_get(&ref->kref);
273 	return ref;
274 }
275 
276 void rate_control_put(struct rate_control_ref *ref)
277 {
278 	kref_put(&ref->kref, rate_control_release);
279 }
280 
281 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
282 				 const char *name)
283 {
284 	struct rate_control_ref *ref, *old;
285 
286 	ASSERT_RTNL();
287 
288 	if (local->open_count)
289 		return -EBUSY;
290 
291 	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
292 		if (WARN_ON(!local->ops->set_rts_threshold))
293 			return -EINVAL;
294 		return 0;
295 	}
296 
297 	ref = rate_control_alloc(name, local);
298 	if (!ref) {
299 		printk(KERN_WARNING "%s: Failed to select rate control "
300 		       "algorithm\n", wiphy_name(local->hw.wiphy));
301 		return -ENOENT;
302 	}
303 
304 	old = local->rate_ctrl;
305 	local->rate_ctrl = ref;
306 	if (old) {
307 		rate_control_put(old);
308 		sta_info_flush(local, NULL);
309 	}
310 
311 	printk(KERN_DEBUG "%s: Selected rate control "
312 	       "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
313 	       ref->ops->name);
314 
315 	return 0;
316 }
317 
318 void rate_control_deinitialize(struct ieee80211_local *local)
319 {
320 	struct rate_control_ref *ref;
321 
322 	ref = local->rate_ctrl;
323 
324 	if (!ref)
325 		return;
326 
327 	local->rate_ctrl = NULL;
328 	rate_control_put(ref);
329 }
330 
331