rate.c revision 37eb0b164cf9fa9f70c8500926f5cde7c652f48e 
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
17struct rate_control_alg {
18	struct list_head list;
19	struct rate_control_ops *ops;
20};
21
22static LIST_HEAD(rate_ctrl_algs);
23static DEFINE_MUTEX(rate_ctrl_mutex);
24
25static char *ieee80211_default_rc_algo = CONFIG_MAC80211_RC_DEFAULT;
26module_param(ieee80211_default_rc_algo, charp, 0644);
27MODULE_PARM_DESC(ieee80211_default_rc_algo,
28		 "Default rate control algorithm for mac80211 to use");
29
30int 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}
59EXPORT_SYMBOL(ieee80211_rate_control_register);
60
61void 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}
75EXPORT_SYMBOL(ieee80211_rate_control_unregister);
76
77static struct rate_control_ops *
78ieee80211_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. */
99static struct rate_control_ops *
100ieee80211_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
126static void ieee80211_rate_control_ops_put(struct rate_control_ops *ops)
127{
128	module_put(ops->module);
129}
130
131#ifdef CONFIG_MAC80211_DEBUGFS
132static 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
142static const struct file_operations rcname_ops = {
143	.read = rcname_read,
144	.open = mac80211_open_file_generic,
145};
146#endif
147
148struct 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
174fail_priv:
175	ieee80211_rate_control_ops_put(ref->ops);
176fail_ops:
177	kfree(ref);
178fail_ref:
179	return NULL;
180}
181
182static 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
198static 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
210static void rc_send_low_broadcast(s8 *idx, u32 basic_rates, u8 max_rate_idx)
211{
212	u8 i;
213
214	if (basic_rates == 0)
215		return; /* assume basic rates unknown and accept rate */
216	if (*idx < 0)
217		return;
218	if (basic_rates & (1 << *idx))
219		return; /* selected rate is a basic rate */
220
221	for (i = *idx + 1; i <= max_rate_idx; i++) {
222		if (basic_rates & (1 << i)) {
223			*idx = i;
224			return;
225		}
226	}
227
228	/* could not find a basic rate; use original selection */
229}
230
231bool rate_control_send_low(struct ieee80211_sta *sta,
232			   void *priv_sta,
233			   struct ieee80211_tx_rate_control *txrc)
234{
235	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
236
237	if (!sta || !priv_sta || rc_no_data_or_no_ack(txrc)) {
238		info->control.rates[0].idx = rate_lowest_index(txrc->sband, sta);
239		info->control.rates[0].count =
240			(info->flags & IEEE80211_TX_CTL_NO_ACK) ?
241			1 : txrc->hw->max_rate_tries;
242		if (!sta && txrc->ap)
243			rc_send_low_broadcast(&info->control.rates[0].idx,
244					      txrc->bss_conf->basic_rates,
245					      txrc->sband->n_bitrates);
246		return true;
247	}
248	return false;
249}
250EXPORT_SYMBOL(rate_control_send_low);
251
252static void rate_idx_match_mask(struct ieee80211_tx_rate *rate,
253				int n_bitrates, u32 mask)
254{
255	int j;
256
257	/* See whether the selected rate or anything below it is allowed. */
258	for (j = rate->idx; j >= 0; j--) {
259		if (mask & (1 << j)) {
260			/* Okay, found a suitable rate. Use it. */
261			rate->idx = j;
262			return;
263		}
264	}
265
266	/* Try to find a higher rate that would be allowed */
267	for (j = rate->idx + 1; j < n_bitrates; j++) {
268		if (mask & (1 << j)) {
269			/* Okay, found a suitable rate. Use it. */
270			rate->idx = j;
271			return;
272		}
273	}
274
275	/*
276	 * Uh.. No suitable rate exists. This should not really happen with
277	 * sane TX rate mask configurations. However, should someone manage to
278	 * configure supported rates and TX rate mask in incompatible way,
279	 * allow the frame to be transmitted with whatever the rate control
280	 * selected.
281	 */
282}
283
284void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
285			   struct sta_info *sta,
286			   struct ieee80211_tx_rate_control *txrc)
287{
288	struct rate_control_ref *ref = sdata->local->rate_ctrl;
289	void *priv_sta = NULL;
290	struct ieee80211_sta *ista = NULL;
291	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
292	int i;
293	u32 mask;
294
295	if (sta) {
296		ista = &sta->sta;
297		priv_sta = sta->rate_ctrl_priv;
298	}
299
300	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
301		info->control.rates[i].idx = -1;
302		info->control.rates[i].flags = 0;
303		info->control.rates[i].count = 1;
304	}
305
306	ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
307
308	/*
309	 * Try to enforce the rateidx mask the user wanted. skip this if the
310	 * default mask (allow all rates) is used to save some processing for
311	 * the common case.
312	 */
313	mask = sdata->rc_rateidx_mask[info->band];
314	if (mask != (1 << txrc->sband->n_bitrates) - 1) {
315		if (sta) {
316			/* Filter out rates that the STA does not support */
317			mask &= sta->sta.supp_rates[info->band];
318		}
319		/*
320		 * Make sure the rate index selected for each TX rate is
321		 * included in the configured mask and change the rate indexes
322		 * if needed.
323		 */
324		for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
325			/* Rate masking supports only legacy rates for now */
326			if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
327				continue;
328			rate_idx_match_mask(&info->control.rates[i],
329					    txrc->sband->n_bitrates, mask);
330		}
331	}
332
333	BUG_ON(info->control.rates[0].idx < 0);
334}
335
336struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
337{
338	kref_get(&ref->kref);
339	return ref;
340}
341
342void rate_control_put(struct rate_control_ref *ref)
343{
344	kref_put(&ref->kref, rate_control_release);
345}
346
347int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
348				 const char *name)
349{
350	struct rate_control_ref *ref, *old;
351
352	ASSERT_RTNL();
353
354	if (local->open_count)
355		return -EBUSY;
356
357	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
358		if (WARN_ON(!local->ops->set_rts_threshold))
359			return -EINVAL;
360		return 0;
361	}
362
363	ref = rate_control_alloc(name, local);
364	if (!ref) {
365		printk(KERN_WARNING "%s: Failed to select rate control "
366		       "algorithm\n", wiphy_name(local->hw.wiphy));
367		return -ENOENT;
368	}
369
370	old = local->rate_ctrl;
371	local->rate_ctrl = ref;
372	if (old) {
373		rate_control_put(old);
374		sta_info_flush(local, NULL);
375	}
376
377	printk(KERN_DEBUG "%s: Selected rate control "
378	       "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
379	       ref->ops->name);
380
381	return 0;
382}
383
384void rate_control_deinitialize(struct ieee80211_local *local)
385{
386	struct rate_control_ref *ref;
387
388	ref = local->rate_ctrl;
389
390	if (!ref)
391		return;
392
393	local->rate_ctrl = NULL;
394	rate_control_put(ref);
395}
396
397