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