Loading...
Note: File does not exist in v6.8.
1/* cfg80211 support
2 *
3 * See copyright notice in main.c
4 */
5#include <linux/ieee80211.h>
6#include <net/cfg80211.h>
7#include "hw.h"
8#include "main.h"
9#include "orinoco.h"
10
11#include "cfg.h"
12
13/* Supported bitrates. Must agree with hw.c */
14static struct ieee80211_rate orinoco_rates[] = {
15 { .bitrate = 10 },
16 { .bitrate = 20 },
17 { .bitrate = 55 },
18 { .bitrate = 110 },
19};
20
21static const void * const orinoco_wiphy_privid = &orinoco_wiphy_privid;
22
23/* Called after orinoco_private is allocated. */
24void orinoco_wiphy_init(struct wiphy *wiphy)
25{
26 struct orinoco_private *priv = wiphy_priv(wiphy);
27
28 wiphy->privid = orinoco_wiphy_privid;
29
30 set_wiphy_dev(wiphy, priv->dev);
31}
32
33/* Called after firmware is initialised */
34int orinoco_wiphy_register(struct wiphy *wiphy)
35{
36 struct orinoco_private *priv = wiphy_priv(wiphy);
37 int i, channels = 0;
38
39 if (priv->firmware_type == FIRMWARE_TYPE_AGERE)
40 wiphy->max_scan_ssids = 1;
41 else
42 wiphy->max_scan_ssids = 0;
43
44 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
45
46 /* TODO: should we set if we only have demo ad-hoc?
47 * (priv->has_port3)
48 */
49 if (priv->has_ibss)
50 wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
51
52 if (!priv->broken_monitor || force_monitor)
53 wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
54
55 priv->band.bitrates = orinoco_rates;
56 priv->band.n_bitrates = ARRAY_SIZE(orinoco_rates);
57
58 /* Only support channels allowed by the card EEPROM */
59 for (i = 0; i < NUM_CHANNELS; i++) {
60 if (priv->channel_mask & (1 << i)) {
61 priv->channels[i].center_freq =
62 ieee80211_channel_to_frequency(i + 1,
63 IEEE80211_BAND_2GHZ);
64 channels++;
65 }
66 }
67 priv->band.channels = priv->channels;
68 priv->band.n_channels = channels;
69
70 wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
71 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
72
73 i = 0;
74 if (priv->has_wep) {
75 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP40;
76 i++;
77
78 if (priv->has_big_wep) {
79 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP104;
80 i++;
81 }
82 }
83 if (priv->has_wpa) {
84 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_TKIP;
85 i++;
86 }
87 wiphy->cipher_suites = priv->cipher_suites;
88 wiphy->n_cipher_suites = i;
89
90 wiphy->rts_threshold = priv->rts_thresh;
91 if (!priv->has_mwo)
92 wiphy->frag_threshold = priv->frag_thresh + 1;
93 wiphy->retry_short = priv->short_retry_limit;
94 wiphy->retry_long = priv->long_retry_limit;
95
96 return wiphy_register(wiphy);
97}
98
99static int orinoco_change_vif(struct wiphy *wiphy, struct net_device *dev,
100 enum nl80211_iftype type, u32 *flags,
101 struct vif_params *params)
102{
103 struct orinoco_private *priv = wiphy_priv(wiphy);
104 int err = 0;
105 unsigned long lock;
106
107 if (orinoco_lock(priv, &lock) != 0)
108 return -EBUSY;
109
110 switch (type) {
111 case NL80211_IFTYPE_ADHOC:
112 if (!priv->has_ibss && !priv->has_port3)
113 err = -EINVAL;
114 break;
115
116 case NL80211_IFTYPE_STATION:
117 break;
118
119 case NL80211_IFTYPE_MONITOR:
120 if (priv->broken_monitor && !force_monitor) {
121 wiphy_warn(wiphy,
122 "Monitor mode support is buggy in this firmware, not enabling\n");
123 err = -EINVAL;
124 }
125 break;
126
127 default:
128 err = -EINVAL;
129 }
130
131 if (!err) {
132 priv->iw_mode = type;
133 set_port_type(priv);
134 err = orinoco_commit(priv);
135 }
136
137 orinoco_unlock(priv, &lock);
138
139 return err;
140}
141
142static int orinoco_scan(struct wiphy *wiphy,
143 struct cfg80211_scan_request *request)
144{
145 struct orinoco_private *priv = wiphy_priv(wiphy);
146 int err;
147
148 if (!request)
149 return -EINVAL;
150
151 if (priv->scan_request && priv->scan_request != request)
152 return -EBUSY;
153
154 priv->scan_request = request;
155
156 err = orinoco_hw_trigger_scan(priv, request->ssids);
157 /* On error the we aren't processing the request */
158 if (err)
159 priv->scan_request = NULL;
160
161 return err;
162}
163
164static int orinoco_set_monitor_channel(struct wiphy *wiphy,
165 struct cfg80211_chan_def *chandef)
166{
167 struct orinoco_private *priv = wiphy_priv(wiphy);
168 int err = 0;
169 unsigned long flags;
170 int channel;
171
172 if (!chandef->chan)
173 return -EINVAL;
174
175 if (cfg80211_get_chandef_type(chandef) != NL80211_CHAN_NO_HT)
176 return -EINVAL;
177
178 if (chandef->chan->band != IEEE80211_BAND_2GHZ)
179 return -EINVAL;
180
181 channel = ieee80211_frequency_to_channel(chandef->chan->center_freq);
182
183 if ((channel < 1) || (channel > NUM_CHANNELS) ||
184 !(priv->channel_mask & (1 << (channel - 1))))
185 return -EINVAL;
186
187 if (orinoco_lock(priv, &flags) != 0)
188 return -EBUSY;
189
190 priv->channel = channel;
191 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
192 /* Fast channel change - no commit if successful */
193 struct hermes *hw = &priv->hw;
194 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
195 HERMES_TEST_SET_CHANNEL,
196 channel, NULL);
197 }
198 orinoco_unlock(priv, &flags);
199
200 return err;
201}
202
203static int orinoco_set_wiphy_params(struct wiphy *wiphy, u32 changed)
204{
205 struct orinoco_private *priv = wiphy_priv(wiphy);
206 int frag_value = -1;
207 int rts_value = -1;
208 int err = 0;
209
210 if (changed & WIPHY_PARAM_RETRY_SHORT) {
211 /* Setting short retry not supported */
212 err = -EINVAL;
213 }
214
215 if (changed & WIPHY_PARAM_RETRY_LONG) {
216 /* Setting long retry not supported */
217 err = -EINVAL;
218 }
219
220 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
221 /* Set fragmentation */
222 if (priv->has_mwo) {
223 if (wiphy->frag_threshold < 0)
224 frag_value = 0;
225 else {
226 printk(KERN_WARNING "%s: Fixed fragmentation "
227 "is not supported on this firmware. "
228 "Using MWO robust instead.\n",
229 priv->ndev->name);
230 frag_value = 1;
231 }
232 } else {
233 if (wiphy->frag_threshold < 0)
234 frag_value = 2346;
235 else if ((wiphy->frag_threshold < 257) ||
236 (wiphy->frag_threshold > 2347))
237 err = -EINVAL;
238 else
239 /* cfg80211 value is 257-2347 (odd only)
240 * orinoco rid has range 256-2346 (even only) */
241 frag_value = wiphy->frag_threshold & ~0x1;
242 }
243 }
244
245 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
246 /* Set RTS.
247 *
248 * Prism documentation suggests default of 2432,
249 * and a range of 0-3000.
250 *
251 * Current implementation uses 2347 as the default and
252 * the upper limit.
253 */
254
255 if (wiphy->rts_threshold < 0)
256 rts_value = 2347;
257 else if (wiphy->rts_threshold > 2347)
258 err = -EINVAL;
259 else
260 rts_value = wiphy->rts_threshold;
261 }
262
263 if (!err) {
264 unsigned long flags;
265
266 if (orinoco_lock(priv, &flags) != 0)
267 return -EBUSY;
268
269 if (frag_value >= 0) {
270 if (priv->has_mwo)
271 priv->mwo_robust = frag_value;
272 else
273 priv->frag_thresh = frag_value;
274 }
275 if (rts_value >= 0)
276 priv->rts_thresh = rts_value;
277
278 err = orinoco_commit(priv);
279
280 orinoco_unlock(priv, &flags);
281 }
282
283 return err;
284}
285
286const struct cfg80211_ops orinoco_cfg_ops = {
287 .change_virtual_intf = orinoco_change_vif,
288 .set_monitor_channel = orinoco_set_monitor_channel,
289 .scan = orinoco_scan,
290 .set_wiphy_params = orinoco_set_wiphy_params,
291};