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 */
14 static struct ieee80211_rate orinoco_rates[] = {
15 { .bitrate = 10 },
16 { .bitrate = 20 },
17 { .bitrate = 55 },
18 { .bitrate = 110 },
19 };
20
21 static const void * const orinoco_wiphy_privid = &orinoco_wiphy_privid;
22
23 /* Called after orinoco_private is allocated. */
orinoco_wiphy_init(struct wiphy * wiphy)24 void 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 */
orinoco_wiphy_register(struct wiphy * wiphy)34 int 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_dsss_chan_to_freq(i + 1);
63 channels++;
64 }
65 }
66 priv->band.channels = priv->channels;
67 priv->band.n_channels = channels;
68
69 wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
70 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
71
72 i = 0;
73 if (priv->has_wep) {
74 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP40;
75 i++;
76
77 if (priv->has_big_wep) {
78 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP104;
79 i++;
80 }
81 }
82 if (priv->has_wpa) {
83 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_TKIP;
84 i++;
85 }
86 wiphy->cipher_suites = priv->cipher_suites;
87 wiphy->n_cipher_suites = i;
88
89 wiphy->rts_threshold = priv->rts_thresh;
90 if (!priv->has_mwo)
91 wiphy->frag_threshold = priv->frag_thresh + 1;
92 wiphy->retry_short = priv->short_retry_limit;
93 wiphy->retry_long = priv->long_retry_limit;
94
95 return wiphy_register(wiphy);
96 }
97
orinoco_change_vif(struct wiphy * wiphy,struct net_device * dev,enum nl80211_iftype type,u32 * flags,struct vif_params * params)98 static int orinoco_change_vif(struct wiphy *wiphy, struct net_device *dev,
99 enum nl80211_iftype type, u32 *flags,
100 struct vif_params *params)
101 {
102 struct orinoco_private *priv = wiphy_priv(wiphy);
103 int err = 0;
104 unsigned long lock;
105
106 if (orinoco_lock(priv, &lock) != 0)
107 return -EBUSY;
108
109 switch (type) {
110 case NL80211_IFTYPE_ADHOC:
111 if (!priv->has_ibss && !priv->has_port3)
112 err = -EINVAL;
113 break;
114
115 case NL80211_IFTYPE_STATION:
116 break;
117
118 case NL80211_IFTYPE_MONITOR:
119 if (priv->broken_monitor && !force_monitor) {
120 wiphy_warn(wiphy,
121 "Monitor mode support is buggy in this firmware, not enabling\n");
122 err = -EINVAL;
123 }
124 break;
125
126 default:
127 err = -EINVAL;
128 }
129
130 if (!err) {
131 priv->iw_mode = type;
132 set_port_type(priv);
133 err = orinoco_commit(priv);
134 }
135
136 orinoco_unlock(priv, &lock);
137
138 return err;
139 }
140
orinoco_scan(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_scan_request * request)141 static int orinoco_scan(struct wiphy *wiphy, struct net_device *dev,
142 struct cfg80211_scan_request *request)
143 {
144 struct orinoco_private *priv = wiphy_priv(wiphy);
145 int err;
146
147 if (!request)
148 return -EINVAL;
149
150 if (priv->scan_request && priv->scan_request != request)
151 return -EBUSY;
152
153 priv->scan_request = request;
154
155 err = orinoco_hw_trigger_scan(priv, request->ssids);
156 /* On error the we aren't processing the request */
157 if (err)
158 priv->scan_request = NULL;
159
160 return err;
161 }
162
orinoco_set_channel(struct wiphy * wiphy,struct net_device * netdev,struct ieee80211_channel * chan,enum nl80211_channel_type channel_type)163 static int orinoco_set_channel(struct wiphy *wiphy,
164 struct net_device *netdev,
165 struct ieee80211_channel *chan,
166 enum nl80211_channel_type channel_type)
167 {
168 struct orinoco_private *priv = wiphy_priv(wiphy);
169 int err = 0;
170 unsigned long flags;
171 int channel;
172
173 if (!chan)
174 return -EINVAL;
175
176 if (channel_type != NL80211_CHAN_NO_HT)
177 return -EINVAL;
178
179 if (chan->band != IEEE80211_BAND_2GHZ)
180 return -EINVAL;
181
182 channel = ieee80211_freq_to_dsss_chan(chan->center_freq);
183
184 if ((channel < 1) || (channel > NUM_CHANNELS) ||
185 !(priv->channel_mask & (1 << (channel - 1))))
186 return -EINVAL;
187
188 if (orinoco_lock(priv, &flags) != 0)
189 return -EBUSY;
190
191 priv->channel = channel;
192 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
193 /* Fast channel change - no commit if successful */
194 struct hermes *hw = &priv->hw;
195 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
196 HERMES_TEST_SET_CHANNEL,
197 channel, NULL);
198 }
199 orinoco_unlock(priv, &flags);
200
201 return err;
202 }
203
orinoco_set_wiphy_params(struct wiphy * wiphy,u32 changed)204 static int orinoco_set_wiphy_params(struct wiphy *wiphy, u32 changed)
205 {
206 struct orinoco_private *priv = wiphy_priv(wiphy);
207 int frag_value = -1;
208 int rts_value = -1;
209 int err = 0;
210
211 if (changed & WIPHY_PARAM_RETRY_SHORT) {
212 /* Setting short retry not supported */
213 err = -EINVAL;
214 }
215
216 if (changed & WIPHY_PARAM_RETRY_LONG) {
217 /* Setting long retry not supported */
218 err = -EINVAL;
219 }
220
221 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
222 /* Set fragmentation */
223 if (priv->has_mwo) {
224 if (wiphy->frag_threshold < 0)
225 frag_value = 0;
226 else {
227 printk(KERN_WARNING "%s: Fixed fragmentation "
228 "is not supported on this firmware. "
229 "Using MWO robust instead.\n",
230 priv->ndev->name);
231 frag_value = 1;
232 }
233 } else {
234 if (wiphy->frag_threshold < 0)
235 frag_value = 2346;
236 else if ((wiphy->frag_threshold < 257) ||
237 (wiphy->frag_threshold > 2347))
238 err = -EINVAL;
239 else
240 /* cfg80211 value is 257-2347 (odd only)
241 * orinoco rid has range 256-2346 (even only) */
242 frag_value = wiphy->frag_threshold & ~0x1;
243 }
244 }
245
246 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
247 /* Set RTS.
248 *
249 * Prism documentation suggests default of 2432,
250 * and a range of 0-3000.
251 *
252 * Current implementation uses 2347 as the default and
253 * the upper limit.
254 */
255
256 if (wiphy->rts_threshold < 0)
257 rts_value = 2347;
258 else if (wiphy->rts_threshold > 2347)
259 err = -EINVAL;
260 else
261 rts_value = wiphy->rts_threshold;
262 }
263
264 if (!err) {
265 unsigned long flags;
266
267 if (orinoco_lock(priv, &flags) != 0)
268 return -EBUSY;
269
270 if (frag_value >= 0) {
271 if (priv->has_mwo)
272 priv->mwo_robust = frag_value;
273 else
274 priv->frag_thresh = frag_value;
275 }
276 if (rts_value >= 0)
277 priv->rts_thresh = rts_value;
278
279 err = orinoco_commit(priv);
280
281 orinoco_unlock(priv, &flags);
282 }
283
284 return err;
285 }
286
287 const struct cfg80211_ops orinoco_cfg_ops = {
288 .change_virtual_intf = orinoco_change_vif,
289 .set_channel = orinoco_set_channel,
290 .scan = orinoco_scan,
291 .set_wiphy_params = orinoco_set_wiphy_params,
292 };
293