Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / mac80211 / ieee80211_rate.c
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 "ieee80211_rate.h"
14 #include "ieee80211_i.h"
15
16 struct rate_control_alg {
17         struct list_head list;
18         struct rate_control_ops *ops;
19 };
20
21 static LIST_HEAD(rate_ctrl_algs);
22 static DEFINE_MUTEX(rate_ctrl_mutex);
23
24 int ieee80211_rate_control_register(struct rate_control_ops *ops)
25 {
26         struct rate_control_alg *alg;
27
28         if (!ops->name)
29                 return -EINVAL;
30
31         mutex_lock(&rate_ctrl_mutex);
32         list_for_each_entry(alg, &rate_ctrl_algs, list) {
33                 if (!strcmp(alg->ops->name, ops->name)) {
34                         /* don't register an algorithm twice */
35                         WARN_ON(1);
36                         return -EALREADY;
37                 }
38         }
39
40         alg = kzalloc(sizeof(*alg), GFP_KERNEL);
41         if (alg == NULL) {
42                 mutex_unlock(&rate_ctrl_mutex);
43                 return -ENOMEM;
44         }
45         alg->ops = ops;
46
47         list_add_tail(&alg->list, &rate_ctrl_algs);
48         mutex_unlock(&rate_ctrl_mutex);
49
50         return 0;
51 }
52 EXPORT_SYMBOL(ieee80211_rate_control_register);
53
54 void ieee80211_rate_control_unregister(struct rate_control_ops *ops)
55 {
56         struct rate_control_alg *alg;
57
58         mutex_lock(&rate_ctrl_mutex);
59         list_for_each_entry(alg, &rate_ctrl_algs, list) {
60                 if (alg->ops == ops) {
61                         list_del(&alg->list);
62                         break;
63                 }
64         }
65         mutex_unlock(&rate_ctrl_mutex);
66         kfree(alg);
67 }
68 EXPORT_SYMBOL(ieee80211_rate_control_unregister);
69
70 static struct rate_control_ops *
71 ieee80211_try_rate_control_ops_get(const char *name)
72 {
73         struct rate_control_alg *alg;
74         struct rate_control_ops *ops = NULL;
75
76         if (!name)
77                 return NULL;
78
79         mutex_lock(&rate_ctrl_mutex);
80         list_for_each_entry(alg, &rate_ctrl_algs, list) {
81                 if (!strcmp(alg->ops->name, name))
82                         if (try_module_get(alg->ops->module)) {
83                                 ops = alg->ops;
84                                 break;
85                         }
86         }
87         mutex_unlock(&rate_ctrl_mutex);
88         return ops;
89 }
90
91 /* Get the rate control algorithm. If `name' is NULL, get the first
92  * available algorithm. */
93 static struct rate_control_ops *
94 ieee80211_rate_control_ops_get(const char *name)
95 {
96         struct rate_control_ops *ops;
97
98         if (!name)
99                 name = "simple";
100
101         ops = ieee80211_try_rate_control_ops_get(name);
102         if (!ops) {
103                 request_module("rc80211_%s", name);
104                 ops = ieee80211_try_rate_control_ops_get(name);
105         }
106         return ops;
107 }
108
109 static void ieee80211_rate_control_ops_put(struct rate_control_ops *ops)
110 {
111         module_put(ops->module);
112 }
113
114 struct rate_control_ref *rate_control_alloc(const char *name,
115                                             struct ieee80211_local *local)
116 {
117         struct rate_control_ref *ref;
118
119         ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL);
120         if (!ref)
121                 goto fail_ref;
122         kref_init(&ref->kref);
123         ref->ops = ieee80211_rate_control_ops_get(name);
124         if (!ref->ops)
125                 goto fail_ops;
126         ref->priv = ref->ops->alloc(local);
127         if (!ref->priv)
128                 goto fail_priv;
129         return ref;
130
131 fail_priv:
132         ieee80211_rate_control_ops_put(ref->ops);
133 fail_ops:
134         kfree(ref);
135 fail_ref:
136         return NULL;
137 }
138
139 static void rate_control_release(struct kref *kref)
140 {
141         struct rate_control_ref *ctrl_ref;
142
143         ctrl_ref = container_of(kref, struct rate_control_ref, kref);
144         ctrl_ref->ops->free(ctrl_ref->priv);
145         ieee80211_rate_control_ops_put(ctrl_ref->ops);
146         kfree(ctrl_ref);
147 }
148
149 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
150 {
151         kref_get(&ref->kref);
152         return ref;
153 }
154
155 void rate_control_put(struct rate_control_ref *ref)
156 {
157         kref_put(&ref->kref, rate_control_release);
158 }
159
160 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
161                                  const char *name)
162 {
163         struct rate_control_ref *ref, *old;
164
165         ASSERT_RTNL();
166         if (local->open_count || netif_running(local->mdev))
167                 return -EBUSY;
168
169         ref = rate_control_alloc(name, local);
170         if (!ref) {
171                 printk(KERN_WARNING "%s: Failed to select rate control "
172                        "algorithm\n", wiphy_name(local->hw.wiphy));
173                 return -ENOENT;
174         }
175
176         old = local->rate_ctrl;
177         local->rate_ctrl = ref;
178         if (old) {
179                 rate_control_put(old);
180                 sta_info_flush(local, NULL);
181         }
182
183         printk(KERN_DEBUG "%s: Selected rate control "
184                "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
185                ref->ops->name);
186
187
188         return 0;
189 }
190
191 void rate_control_deinitialize(struct ieee80211_local *local)
192 {
193         struct rate_control_ref *ref;
194
195         ref = local->rate_ctrl;
196         local->rate_ctrl = NULL;
197         rate_control_put(ref);
198 }