?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
orinoco: clear countermeasure setting on commit
[orinoco_usb.git] / drivers / net / wireless / orinoco / hw.c
blobb0187b2e4b7c1f7fc47da5566b7d1078f6a012ac
1 /* Encapsulate basic setting changes and retrieval on Hermes hardware
2 *
3 * See copyright notice in main.c
4 */
5 #include <linux/kernel.h>
6 #include <linux/device.h>
7 #include <linux/if_arp.h>
8 #include <linux/ieee80211.h>
9 #include <linux/wireless.h>
10 #include <net/cfg80211.h>
11 #include "hermes.h"
12 #include "hermes_rid.h"
13 #include "orinoco.h"
14
15 #include "hw.h"
16
17 #define SYMBOL_MAX_VER_LEN (14)
18
19 /* Symbol firmware has a bug allocating buffers larger than this */
20 #define TX_NICBUF_SIZE_BUG 1585
21
22 /********************************************************************/
23 /* Data tables */
24 /********************************************************************/
25
26 /* This tables gives the actual meanings of the bitrate IDs returned
27 * by the firmware. */
28 static const struct {
29 int bitrate; /* in 100s of kilobits */
30 int automatic;
31 u16 agere_txratectrl;
32 u16 intersil_txratectrl;
33 } bitrate_table[] = {
34 {110, 1, 3, 15}, /* Entry 0 is the default */
35 {10, 0, 1, 1},
36 {10, 1, 1, 1},
37 {20, 0, 2, 2},
38 {20, 1, 6, 3},
39 {55, 0, 4, 4},
40 {55, 1, 7, 7},
41 {110, 0, 5, 8},
42 };
43 #define BITRATE_TABLE_SIZE ARRAY_SIZE(bitrate_table)
44
45 /* Firmware version encoding */
46 struct comp_id {
47 u16 id, variant, major, minor;
48 } __attribute__ ((packed));
49
50 static inline fwtype_t determine_firmware_type(struct comp_id *nic_id)
51 {
52 if (nic_id->id < 0x8000)
53 return FIRMWARE_TYPE_AGERE;
54 else if (nic_id->id == 0x8000 && nic_id->major == 0)
55 return FIRMWARE_TYPE_SYMBOL;
56 else
57 return FIRMWARE_TYPE_INTERSIL;
58 }
59
60 /* Set priv->firmware type, determine firmware properties
61 * This function can be called before we have registerred with netdev,
62 * so all errors go out with dev_* rather than printk
63 */
64 int determine_fw_capabilities(struct orinoco_private *priv)
65 {
66 struct device *dev = priv->dev;
67 hermes_t *hw = &priv->hw;
68 int err;
69 struct comp_id nic_id, sta_id;
70 unsigned int firmver;
71 char tmp[SYMBOL_MAX_VER_LEN+1] __attribute__((aligned(2)));
72
73 /* Get the hardware version */
74 err = HERMES_READ_RECORD(hw, USER_BAP, HERMES_RID_NICID, &nic_id);
75 if (err) {
76 dev_err(dev, "Cannot read hardware identity: error %d\n",
77 err);
78 return err;
79 }
80
81 le16_to_cpus(&nic_id.id);
82 le16_to_cpus(&nic_id.variant);
83 le16_to_cpus(&nic_id.major);
84 le16_to_cpus(&nic_id.minor);
85 dev_info(dev, "Hardware identity %04x:%04x:%04x:%04x\n",
86 nic_id.id, nic_id.variant, nic_id.major, nic_id.minor);
87
88 priv->firmware_type = determine_firmware_type(&nic_id);
89
90 /* Get the firmware version */
91 err = HERMES_READ_RECORD(hw, USER_BAP, HERMES_RID_STAID, &sta_id);
92 if (err) {
93 dev_err(dev, "Cannot read station identity: error %d\n",
94 err);
95 return err;
96 }
97
98 le16_to_cpus(&sta_id.id);
99 le16_to_cpus(&sta_id.variant);
100 le16_to_cpus(&sta_id.major);
101 le16_to_cpus(&sta_id.minor);
102 dev_info(dev, "Station identity %04x:%04x:%04x:%04x\n",
103 sta_id.id, sta_id.variant, sta_id.major, sta_id.minor);
104
105 switch (sta_id.id) {
106 case 0x15:
107 dev_err(dev, "Primary firmware is active\n");
108 return -ENODEV;
109 case 0x14b:
110 dev_err(dev, "Tertiary firmware is active\n");
111 return -ENODEV;
112 case 0x1f: /* Intersil, Agere, Symbol Spectrum24 */
113 case 0x21: /* Symbol Spectrum24 Trilogy */
114 break;
115 default:
116 dev_notice(dev, "Unknown station ID, please report\n");
117 break;
118 }
119
120 /* Default capabilities */
121 priv->has_sensitivity = 1;
122 priv->has_mwo = 0;
123 priv->has_preamble = 0;
124 priv->has_port3 = 1;
125 priv->has_ibss = 1;
126 priv->has_wep = 0;
127 priv->has_big_wep = 0;
128 priv->has_alt_txcntl = 0;
129 priv->has_ext_scan = 0;
130 priv->has_wpa = 0;
131 priv->do_fw_download = 0;
132
133 /* Determine capabilities from the firmware version */
134 switch (priv->firmware_type) {
135 case FIRMWARE_TYPE_AGERE:
136 /* Lucent Wavelan IEEE, Lucent Orinoco, Cabletron RoamAbout,
137 ELSA, Melco, HP, IBM, Dell 1150, Compaq 110/210 */
138 snprintf(priv->fw_name, sizeof(priv->fw_name) - 1,
139 "Lucent/Agere %d.%02d", sta_id.major, sta_id.minor);
140
141 firmver = ((unsigned long)sta_id.major << 16) | sta_id.minor;
142
143 priv->has_ibss = (firmver >= 0x60006);
144 priv->has_wep = (firmver >= 0x40020);
145 priv->has_big_wep = 1; /* FIXME: this is wrong - how do we tell
146 Gold cards from the others? */
147 priv->has_mwo = (firmver >= 0x60000);
148 priv->has_pm = (firmver >= 0x40020); /* Don't work in 7.52 ? */
149 priv->ibss_port = 1;
150 priv->has_hostscan = (firmver >= 0x8000a);
151 priv->do_fw_download = 1;
152 priv->broken_monitor = (firmver >= 0x80000);
153 priv->has_alt_txcntl = (firmver >= 0x90000); /* All 9.x ? */
154 priv->has_ext_scan = (firmver >= 0x90000); /* All 9.x ? */
155 priv->has_wpa = (firmver >= 0x9002a);
156 /* Tested with Agere firmware :
157 * 1.16 ; 4.08 ; 4.52 ; 6.04 ; 6.16 ; 7.28 => Jean II
158 * Tested CableTron firmware : 4.32 => Anton */
159 break;
160 case FIRMWARE_TYPE_SYMBOL:
161 /* Symbol , 3Com AirConnect, Intel, Ericsson WLAN */
162 /* Intel MAC : 00:02:B3:* */
163 /* 3Com MAC : 00:50:DA:* */
164 memset(tmp, 0, sizeof(tmp));
165 /* Get the Symbol firmware version */
166 err = hw->ops->read_ltv(hw, USER_BAP,
167 HERMES_RID_SECONDARYVERSION_SYMBOL,
168 SYMBOL_MAX_VER_LEN, NULL, &tmp);
169 if (err) {
170 dev_warn(dev, "Error %d reading Symbol firmware info. "
171 "Wildly guessing capabilities...\n", err);
172 firmver = 0;
173 tmp[0] = '\0';
174 } else {
175 /* The firmware revision is a string, the format is
176 * something like : "V2.20-01".
177 * Quick and dirty parsing... - Jean II
178 */
179 firmver = ((tmp[1] - '0') << 16)
180 | ((tmp[3] - '0') << 12)
181 | ((tmp[4] - '0') << 8)
182 | ((tmp[6] - '0') << 4)
183 | (tmp[7] - '0');
184
185 tmp[SYMBOL_MAX_VER_LEN] = '\0';
186 }
187
188 snprintf(priv->fw_name, sizeof(priv->fw_name) - 1,
189 "Symbol %s", tmp);
190
191 priv->has_ibss = (firmver >= 0x20000);
192 priv->has_wep = (firmver >= 0x15012);
193 priv->has_big_wep = (firmver >= 0x20000);
194 priv->has_pm = (firmver >= 0x20000 && firmver < 0x22000) ||
195 (firmver >= 0x29000 && firmver < 0x30000) ||
196 firmver >= 0x31000;
197 priv->has_preamble = (firmver >= 0x20000);
198 priv->ibss_port = 4;
199
200 /* Symbol firmware is found on various cards, but
201 * there has been no attempt to check firmware
202 * download on non-spectrum_cs based cards.
203 *
204 * Given that the Agere firmware download works
205 * differently, we should avoid doing a firmware
206 * download with the Symbol algorithm on non-spectrum
207 * cards.
208 *
209 * For now we can identify a spectrum_cs based card
210 * because it has a firmware reset function.
211 */
212 priv->do_fw_download = (priv->stop_fw != NULL);
213
214 priv->broken_disableport = (firmver == 0x25013) ||
215 (firmver >= 0x30000 && firmver <= 0x31000);
216 priv->has_hostscan = (firmver >= 0x31001) ||
217 (firmver >= 0x29057 && firmver < 0x30000);
218 /* Tested with Intel firmware : 0x20015 => Jean II */
219 /* Tested with 3Com firmware : 0x15012 & 0x22001 => Jean II */
220 break;
221 case FIRMWARE_TYPE_INTERSIL:
222 /* D-Link, Linksys, Adtron, ZoomAir, and many others...
223 * Samsung, Compaq 100/200 and Proxim are slightly
224 * different and less well tested */
225 /* D-Link MAC : 00:40:05:* */
226 /* Addtron MAC : 00:90:D1:* */
227 snprintf(priv->fw_name, sizeof(priv->fw_name) - 1,
228 "Intersil %d.%d.%d", sta_id.major, sta_id.minor,
229 sta_id.variant);
230
231 firmver = ((unsigned long)sta_id.major << 16) |
232 ((unsigned long)sta_id.minor << 8) | sta_id.variant;
233
234 priv->has_ibss = (firmver >= 0x000700); /* FIXME */
235 priv->has_big_wep = priv->has_wep = (firmver >= 0x000800);
236 priv->has_pm = (firmver >= 0x000700);
237 priv->has_hostscan = (firmver >= 0x010301);
238
239 if (firmver >= 0x000800)
240 priv->ibss_port = 0;
241 else {
242 dev_notice(dev, "Intersil firmware earlier than v0.8.x"
243 " - several features not supported\n");
244 priv->ibss_port = 1;
245 }
246 break;
247 }
248 dev_info(dev, "Firmware determined as %s\n", priv->fw_name);
249
250 return 0;
251 }
252
253 /* Read settings from EEPROM into our private structure.
254 * MAC address gets dropped into callers buffer
255 * Can be called before netdev registration.
256 */
257 int orinoco_hw_read_card_settings(struct orinoco_private *priv, u8 *dev_addr)
258 {
259 struct device *dev = priv->dev;
260 struct hermes_idstring nickbuf;
261 hermes_t *hw = &priv->hw;
262 int len;
263 int err;
264 u16 reclen;
265
266 /* Get the MAC address */
267 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
268 ETH_ALEN, NULL, dev_addr);
269 if (err) {
270 dev_warn(dev, "Failed to read MAC address!\n");
271 goto out;
272 }
273
274 dev_dbg(dev, "MAC address %pM\n", dev_addr);
275
276 /* Get the station name */
277 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
278 sizeof(nickbuf), &reclen, &nickbuf);
279 if (err) {
280 dev_err(dev, "failed to read station name\n");
281 goto out;
282 }
283 if (nickbuf.len)
284 len = min(IW_ESSID_MAX_SIZE, (int)le16_to_cpu(nickbuf.len));
285 else
286 len = min(IW_ESSID_MAX_SIZE, 2 * reclen);
287 memcpy(priv->nick, &nickbuf.val, len);
288 priv->nick[len] = '\0';
289
290 dev_dbg(dev, "Station name \"%s\"\n", priv->nick);
291
292 /* Get allowed channels */
293 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CHANNELLIST,
294 &priv->channel_mask);
295 if (err) {
296 dev_err(dev, "Failed to read channel list!\n");
297 goto out;
298 }
299
300 /* Get initial AP density */
301 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFSYSTEMSCALE,
302 &priv->ap_density);
303 if (err || priv->ap_density < 1 || priv->ap_density > 3)
304 priv->has_sensitivity = 0;
305
306 /* Get initial RTS threshold */
307 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
308 &priv->rts_thresh);
309 if (err) {
310 dev_err(dev, "Failed to read RTS threshold!\n");
311 goto out;
312 }
313
314 /* Get initial fragmentation settings */
315 if (priv->has_mwo)
316 err = hermes_read_wordrec(hw, USER_BAP,
317 HERMES_RID_CNFMWOROBUST_AGERE,
318 &priv->mwo_robust);
319 else
320 err = hermes_read_wordrec(hw, USER_BAP,
321 HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
322 &priv->frag_thresh);
323 if (err) {
324 dev_err(dev, "Failed to read fragmentation settings!\n");
325 goto out;
326 }
327
328 /* Power management setup */
329 if (priv->has_pm) {
330 priv->pm_on = 0;
331 priv->pm_mcast = 1;
332 err = hermes_read_wordrec(hw, USER_BAP,
333 HERMES_RID_CNFMAXSLEEPDURATION,
334 &priv->pm_period);
335 if (err) {
336 dev_err(dev, "Failed to read power management "
337 "period!\n");
338 goto out;
339 }
340 err = hermes_read_wordrec(hw, USER_BAP,
341 HERMES_RID_CNFPMHOLDOVERDURATION,
342 &priv->pm_timeout);
343 if (err) {
344 dev_err(dev, "Failed to read power management "
345 "timeout!\n");
346 goto out;
347 }
348 }
349
350 /* Preamble setup */
351 if (priv->has_preamble) {
352 err = hermes_read_wordrec(hw, USER_BAP,
353 HERMES_RID_CNFPREAMBLE_SYMBOL,
354 &priv->preamble);
355 }
356
357 out:
358 return err;
359 }
360
361 /* Can be called before netdev registration */
362 int orinoco_hw_allocate_fid(struct orinoco_private *priv)
363 {
364 struct device *dev = priv->dev;
365 struct hermes *hw = &priv->hw;
366 int err;
367
368 err = hw->ops->allocate(hw, priv->nicbuf_size, &priv->txfid);
369 if (err == -EIO && priv->nicbuf_size > TX_NICBUF_SIZE_BUG) {
370 /* Try workaround for old Symbol firmware bug */
371 priv->nicbuf_size = TX_NICBUF_SIZE_BUG;
372 err = hw->ops->allocate(hw, priv->nicbuf_size, &priv->txfid);
373
374 dev_warn(dev, "Firmware ALLOC bug detected "
375 "(old Symbol firmware?). Work around %s\n",
376 err ? "failed!" : "ok.");
377 }
378
379 return err;
380 }
381
382 int orinoco_get_bitratemode(int bitrate, int automatic)
383 {
384 int ratemode = -1;
385 int i;
386
387 if ((bitrate != 10) && (bitrate != 20) &&
388 (bitrate != 55) && (bitrate != 110))
389 return ratemode;
390
391 for (i = 0; i < BITRATE_TABLE_SIZE; i++) {
392 if ((bitrate_table[i].bitrate == bitrate) &&
393 (bitrate_table[i].automatic == automatic)) {
394 ratemode = i;
395 break;
396 }
397 }
398 return ratemode;
399 }
400
401 void orinoco_get_ratemode_cfg(int ratemode, int *bitrate, int *automatic)
402 {
403 BUG_ON((ratemode < 0) || (ratemode >= BITRATE_TABLE_SIZE));
404
405 *bitrate = bitrate_table[ratemode].bitrate * 100000;
406 *automatic = bitrate_table[ratemode].automatic;
407 }
408
409 int orinoco_hw_program_rids(struct orinoco_private *priv)
410 {
411 struct net_device *dev = priv->ndev;
412 struct wireless_dev *wdev = netdev_priv(dev);
413 hermes_t *hw = &priv->hw;
414 int err;
415 struct hermes_idstring idbuf;
416
417 /* Set the MAC address */
418 err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
419 HERMES_BYTES_TO_RECLEN(ETH_ALEN),
420 dev->dev_addr);
421 if (err) {
422 printk(KERN_ERR "%s: Error %d setting MAC address\n",
423 dev->name, err);
424 return err;
425 }
426
427 /* Set up the link mode */
428 err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFPORTTYPE,
429 priv->port_type);
430 if (err) {
431 printk(KERN_ERR "%s: Error %d setting port type\n",
432 dev->name, err);
433 return err;
434 }
435 /* Set the channel/frequency */
436 if (priv->channel != 0 && priv->iw_mode != NL80211_IFTYPE_STATION) {
437 err = hermes_write_wordrec(hw, USER_BAP,
438 HERMES_RID_CNFOWNCHANNEL,
439 priv->channel);
440 if (err) {
441 printk(KERN_ERR "%s: Error %d setting channel %d\n",
442 dev->name, err, priv->channel);
443 return err;
444 }
445 }
446
447 if (priv->has_ibss) {
448 u16 createibss;
449
450 if ((strlen(priv->desired_essid) == 0) && (priv->createibss)) {
451 printk(KERN_WARNING "%s: This firmware requires an "
452 "ESSID in IBSS-Ad-Hoc mode.\n", dev->name);
453 /* With wvlan_cs, in this case, we would crash.
454 * hopefully, this driver will behave better...
455 * Jean II */
456 createibss = 0;
457 } else {
458 createibss = priv->createibss;
459 }
460
461 err = hermes_write_wordrec(hw, USER_BAP,
462 HERMES_RID_CNFCREATEIBSS,
463 createibss);
464 if (err) {
465 printk(KERN_ERR "%s: Error %d setting CREATEIBSS\n",
466 dev->name, err);
467 return err;
468 }
469 }
470
471 /* Set the desired BSSID */
472 err = __orinoco_hw_set_wap(priv);
473 if (err) {
474 printk(KERN_ERR "%s: Error %d setting AP address\n",
475 dev->name, err);
476 return err;
477 }
478
479 /* Set the desired ESSID */
480 idbuf.len = cpu_to_le16(strlen(priv->desired_essid));
481 memcpy(&idbuf.val, priv->desired_essid, sizeof(idbuf.val));
482 /* WinXP wants partner to configure OWNSSID even in IBSS mode. (jimc) */
483 err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNSSID,
484 HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
485 &idbuf);
486 if (err) {
487 printk(KERN_ERR "%s: Error %d setting OWNSSID\n",
488 dev->name, err);
489 return err;
490 }
491 err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFDESIREDSSID,
492 HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
493 &idbuf);
494 if (err) {
495 printk(KERN_ERR "%s: Error %d setting DESIREDSSID\n",
496 dev->name, err);
497 return err;
498 }
499
500 /* Set the station name */
501 idbuf.len = cpu_to_le16(strlen(priv->nick));
502 memcpy(&idbuf.val, priv->nick, sizeof(idbuf.val));
503 err = hw->ops->write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
504 HERMES_BYTES_TO_RECLEN(strlen(priv->nick)+2),
505 &idbuf);
506 if (err) {
507 printk(KERN_ERR "%s: Error %d setting nickname\n",
508 dev->name, err);
509 return err;
510 }
511
512 /* Set AP density */
513 if (priv->has_sensitivity) {
514 err = hermes_write_wordrec(hw, USER_BAP,
515 HERMES_RID_CNFSYSTEMSCALE,
516 priv->ap_density);
517 if (err) {
518 printk(KERN_WARNING "%s: Error %d setting SYSTEMSCALE. "
519 "Disabling sensitivity control\n",
520 dev->name, err);
521
522 priv->has_sensitivity = 0;
523 }
524 }
525
526 /* Set RTS threshold */
527 err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
528 priv->rts_thresh);
529 if (err) {
530 printk(KERN_ERR "%s: Error %d setting RTS threshold\n",
531 dev->name, err);
532 return err;
533 }
534
535 /* Set fragmentation threshold or MWO robustness */
536 if (priv->has_mwo)
537 err = hermes_write_wordrec(hw, USER_BAP,
538 HERMES_RID_CNFMWOROBUST_AGERE,
539 priv->mwo_robust);
540 else
541 err = hermes_write_wordrec(hw, USER_BAP,
542 HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
543 priv->frag_thresh);
544 if (err) {
545 printk(KERN_ERR "%s: Error %d setting fragmentation\n",
546 dev->name, err);
547 return err;
548 }
549
550 /* Set bitrate */
551 err = __orinoco_hw_set_bitrate(priv);
552 if (err) {
553 printk(KERN_ERR "%s: Error %d setting bitrate\n",
554 dev->name, err);
555 return err;
556 }
557
558 /* Set power management */
559 if (priv->has_pm) {
560 err = hermes_write_wordrec(hw, USER_BAP,
561 HERMES_RID_CNFPMENABLED,
562 priv->pm_on);
563 if (err) {
564 printk(KERN_ERR "%s: Error %d setting up PM\n",
565 dev->name, err);
566 return err;
567 }
568
569 err = hermes_write_wordrec(hw, USER_BAP,
570 HERMES_RID_CNFMULTICASTRECEIVE,
571 priv->pm_mcast);
572 if (err) {
573 printk(KERN_ERR "%s: Error %d setting up PM\n",
574 dev->name, err);
575 return err;
576 }
577 err = hermes_write_wordrec(hw, USER_BAP,
578 HERMES_RID_CNFMAXSLEEPDURATION,
579 priv->pm_period);
580 if (err) {
581 printk(KERN_ERR "%s: Error %d setting up PM\n",
582 dev->name, err);
583 return err;
584 }
585 err = hermes_write_wordrec(hw, USER_BAP,
586 HERMES_RID_CNFPMHOLDOVERDURATION,
587 priv->pm_timeout);
588 if (err) {
589 printk(KERN_ERR "%s: Error %d setting up PM\n",
590 dev->name, err);
591 return err;
592 }
593 }
594
595 /* Set preamble - only for Symbol so far... */
596 if (priv->has_preamble) {
597 err = hermes_write_wordrec(hw, USER_BAP,
598 HERMES_RID_CNFPREAMBLE_SYMBOL,
599 priv->preamble);
600 if (err) {
601 printk(KERN_ERR "%s: Error %d setting preamble\n",
602 dev->name, err);
603 return err;
604 }
605 }
606
607 /* Set up encryption */
608 if (priv->has_wep || priv->has_wpa) {
609 err = __orinoco_hw_setup_enc(priv);
610 if (err) {
611 printk(KERN_ERR "%s: Error %d activating encryption\n",
612 dev->name, err);
613 return err;
614 }
615 }
616
617 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
618 /* Enable monitor mode */
619 dev->type = ARPHRD_IEEE80211;
620 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
621 HERMES_TEST_MONITOR, 0, NULL);
622 } else {
623 /* Disable monitor mode */
624 dev->type = ARPHRD_ETHER;
625 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
626 HERMES_TEST_STOP, 0, NULL);
627 }
628 if (err)
629 return err;
630
631 /* Reset promiscuity / multicast*/
632 priv->promiscuous = 0;
633 priv->mc_count = 0;
634
635 /* Record mode change */
636 wdev->iftype = priv->iw_mode;
637
638 return 0;
639 }
640
641 /* Get tsc from the firmware */
642 int orinoco_hw_get_tkip_iv(struct orinoco_private *priv, int key, u8 *tsc)
643 {
644 hermes_t *hw = &priv->hw;
645 int err = 0;
646 u8 tsc_arr[4][ORINOCO_SEQ_LEN];
647
648 if ((key < 0) || (key >= 4))
649 return -EINVAL;
650
651 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_TKIP_IV,
652 sizeof(tsc_arr), NULL, &tsc_arr);
653 if (!err)
654 memcpy(tsc, &tsc_arr[key][0], sizeof(tsc_arr[0]));
655
656 return err;
657 }
658
659 int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
660 {
661 hermes_t *hw = &priv->hw;
662 int ratemode = priv->bitratemode;
663 int err = 0;
664
665 if (ratemode >= BITRATE_TABLE_SIZE) {
666 printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
667 priv->ndev->name, ratemode);
668 return -EINVAL;
669 }
670
671 switch (priv->firmware_type) {
672 case FIRMWARE_TYPE_AGERE:
673 err = hermes_write_wordrec(hw, USER_BAP,
674 HERMES_RID_CNFTXRATECONTROL,
675 bitrate_table[ratemode].agere_txratectrl);
676 break;
677 case FIRMWARE_TYPE_INTERSIL:
678 case FIRMWARE_TYPE_SYMBOL:
679 err = hermes_write_wordrec(hw, USER_BAP,
680 HERMES_RID_CNFTXRATECONTROL,
681 bitrate_table[ratemode].intersil_txratectrl);
682 break;
683 default:
684 BUG();
685 }
686
687 return err;
688 }
689
690 int orinoco_hw_get_act_bitrate(struct orinoco_private *priv, int *bitrate)
691 {
692 hermes_t *hw = &priv->hw;
693 int i;
694 int err = 0;
695 u16 val;
696
697 err = hermes_read_wordrec(hw, USER_BAP,
698 HERMES_RID_CURRENTTXRATE, &val);
699 if (err)
700 return err;
701
702 switch (priv->firmware_type) {
703 case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
704 /* Note : in Lucent firmware, the return value of
705 * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
706 * and therefore is totally different from the
707 * encoding of HERMES_RID_CNFTXRATECONTROL.
708 * Don't forget that 6Mb/s is really 5.5Mb/s */
709 if (val == 6)
710 *bitrate = 5500000;
711 else
712 *bitrate = val * 1000000;
713 break;
714 case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
715 case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
716 for (i = 0; i < BITRATE_TABLE_SIZE; i++)
717 if (bitrate_table[i].intersil_txratectrl == val)
718 break;
719
720 if (i >= BITRATE_TABLE_SIZE)
721 printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
722 priv->ndev->name, val);
723
724 *bitrate = bitrate_table[i].bitrate * 100000;
725 break;
726 default:
727 BUG();
728 }
729
730 return err;
731 }
732
733 /* Set fixed AP address */
734 int __orinoco_hw_set_wap(struct orinoco_private *priv)
735 {
736 int roaming_flag;
737 int err = 0;
738 hermes_t *hw = &priv->hw;
739
740 switch (priv->firmware_type) {
741 case FIRMWARE_TYPE_AGERE:
742 /* not supported */
743 break;
744 case FIRMWARE_TYPE_INTERSIL:
745 if (priv->bssid_fixed)
746 roaming_flag = 2;
747 else
748 roaming_flag = 1;
749
750 err = hermes_write_wordrec(hw, USER_BAP,
751 HERMES_RID_CNFROAMINGMODE,
752 roaming_flag);
753 break;
754 case FIRMWARE_TYPE_SYMBOL:
755 err = HERMES_WRITE_RECORD(hw, USER_BAP,
756 HERMES_RID_CNFMANDATORYBSSID_SYMBOL,
757 &priv->desired_bssid);
758 break;
759 }
760 return err;
761 }
762
763 /* Change the WEP keys and/or the current keys. Can be called
764 * either from __orinoco_hw_setup_enc() or directly from
765 * orinoco_ioctl_setiwencode(). In the later case the association
766 * with the AP is not broken (if the firmware can handle it),
767 * which is needed for 802.1x implementations. */
768 int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv)
769 {
770 hermes_t *hw = &priv->hw;
771 int err = 0;
772 int i;
773
774 switch (priv->firmware_type) {
775 case FIRMWARE_TYPE_AGERE:
776 {
777 struct orinoco_key keys[ORINOCO_MAX_KEYS];
778
779 memset(&keys, 0, sizeof(keys));
780 for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
781 int len = min(priv->keys[i].key_len,
782 ORINOCO_MAX_KEY_SIZE);
783 memcpy(&keys[i].data, priv->keys[i].key, len);
784 if (len > SMALL_KEY_SIZE)
785 keys[i].len = cpu_to_le16(LARGE_KEY_SIZE);
786 else if (len > 0)
787 keys[i].len = cpu_to_le16(SMALL_KEY_SIZE);
788 else
789 keys[i].len = cpu_to_le16(0);
790 }
791
792 err = HERMES_WRITE_RECORD(hw, USER_BAP,
793 HERMES_RID_CNFWEPKEYS_AGERE,
794 &keys);
795 if (err)
796 return err;
797 err = hermes_write_wordrec(hw, USER_BAP,
798 HERMES_RID_CNFTXKEY_AGERE,
799 priv->tx_key);
800 if (err)
801 return err;
802 break;
803 }
804 case FIRMWARE_TYPE_INTERSIL:
805 case FIRMWARE_TYPE_SYMBOL:
806 {
807 int keylen;
808
809 /* Force uniform key length to work around
810 * firmware bugs */
811 keylen = priv->keys[priv->tx_key].key_len;
812
813 if (keylen > LARGE_KEY_SIZE) {
814 printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
815 priv->ndev->name, priv->tx_key, keylen);
816 return -E2BIG;
817 } else if (keylen > SMALL_KEY_SIZE)
818 keylen = LARGE_KEY_SIZE;
819 else if (keylen > 0)
820 keylen = SMALL_KEY_SIZE;
821 else
822 keylen = 0;
823
824 /* Write all 4 keys */
825 for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
826 u8 key[LARGE_KEY_SIZE] = { 0 };
827
828 memcpy(key, priv->keys[i].key,
829 priv->keys[i].key_len);
830
831 err = hw->ops->write_ltv(hw, USER_BAP,
832 HERMES_RID_CNFDEFAULTKEY0 + i,
833 HERMES_BYTES_TO_RECLEN(keylen),
834 key);
835 if (err)
836 return err;
837 }
838
839 /* Write the index of the key used in transmission */
840 err = hermes_write_wordrec(hw, USER_BAP,
841 HERMES_RID_CNFWEPDEFAULTKEYID,
842 priv->tx_key);
843 if (err)
844 return err;
845 }
846 break;
847 }
848
849 return 0;
850 }
851
852 int __orinoco_hw_setup_enc(struct orinoco_private *priv)
853 {
854 hermes_t *hw = &priv->hw;
855 int err = 0;
856 int master_wep_flag;
857 int auth_flag;
858 int enc_flag;
859
860 /* Setup WEP keys */
861 if (priv->encode_alg == ORINOCO_ALG_WEP)
862 __orinoco_hw_setup_wepkeys(priv);
863
864 if (priv->wep_restrict)
865 auth_flag = HERMES_AUTH_SHARED_KEY;
866 else
867 auth_flag = HERMES_AUTH_OPEN;
868
869 if (priv->wpa_enabled)
870 enc_flag = 2;
871 else if (priv->encode_alg == ORINOCO_ALG_WEP)
872 enc_flag = 1;
873 else
874 enc_flag = 0;
875
876 switch (priv->firmware_type) {
877 case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
878 if (priv->encode_alg == ORINOCO_ALG_WEP) {
879 /* Enable the shared-key authentication. */
880 err = hermes_write_wordrec(hw, USER_BAP,
881 HERMES_RID_CNFAUTHENTICATION_AGERE,
882 auth_flag);
883 }
884 err = hermes_write_wordrec(hw, USER_BAP,
885 HERMES_RID_CNFWEPENABLED_AGERE,
886 enc_flag);
887 if (err)
888 return err;
889
890 if (priv->has_wpa) {
891 /* Set WPA key management */
892 err = hermes_write_wordrec(hw, USER_BAP,
893 HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE,
894 priv->key_mgmt);
895 if (err)
896 return err;
897 }
898
899 break;
900
901 case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
902 case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
903 if (priv->encode_alg == ORINOCO_ALG_WEP) {
904 if (priv->wep_restrict ||
905 (priv->firmware_type == FIRMWARE_TYPE_SYMBOL))
906 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED |
907 HERMES_WEP_EXCL_UNENCRYPTED;
908 else
909 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED;
910
911 err = hermes_write_wordrec(hw, USER_BAP,
912 HERMES_RID_CNFAUTHENTICATION,
913 auth_flag);
914 if (err)
915 return err;
916 } else
917 master_wep_flag = 0;
918
919 if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
920 master_wep_flag |= HERMES_WEP_HOST_DECRYPT;
921
922 /* Master WEP setting : on/off */
923 err = hermes_write_wordrec(hw, USER_BAP,
924 HERMES_RID_CNFWEPFLAGS_INTERSIL,
925 master_wep_flag);
926 if (err)
927 return err;
928
929 break;
930 }
931
932 return 0;
933 }
934
935 /* key must be 32 bytes, including the tx and rx MIC keys.
936 * rsc must be NULL or up to 8 bytes
937 * tsc must be NULL or up to 8 bytes
938 */
939 int __orinoco_hw_set_tkip_key(struct orinoco_private *priv, int key_idx,
940 int set_tx, u8 *key, u8 *rsc, size_t rsc_len,
941 u8 *tsc, size_t tsc_len)
942 {
943 struct {
944 __le16 idx;
945 u8 rsc[ORINOCO_SEQ_LEN];
946 u8 key[TKIP_KEYLEN];
947 u8 tx_mic[MIC_KEYLEN];
948 u8 rx_mic[MIC_KEYLEN];
949 u8 tsc[ORINOCO_SEQ_LEN];
950 } __attribute__ ((packed)) buf;
951 hermes_t *hw = &priv->hw;
952 int ret;
953 int err;
954 int k;
955 u16 xmitting;
956
957 key_idx &= 0x3;
958
959 if (set_tx)
960 key_idx |= 0x8000;
961
962 buf.idx = cpu_to_le16(key_idx);
963 memcpy(buf.key, key,
964 sizeof(buf.key) + sizeof(buf.tx_mic) + sizeof(buf.rx_mic));
965
966 if (rsc_len > sizeof(buf.rsc))
967 rsc_len = sizeof(buf.rsc);
968
969 if (tsc_len > sizeof(buf.tsc))
970 tsc_len = sizeof(buf.tsc);
971
972 memset(buf.rsc, 0, sizeof(buf.rsc));
973 memset(buf.tsc, 0, sizeof(buf.tsc));
974
975 if (rsc != NULL)
976 memcpy(buf.rsc, rsc, rsc_len);
977
978 if (tsc != NULL)
979 memcpy(buf.tsc, tsc, tsc_len);
980 else
981 buf.tsc[4] = 0x10;
982
983 /* Wait upto 100ms for tx queue to empty */
984 for (k = 100; k > 0; k--) {
985 udelay(1000);
986 ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
987 &xmitting);
988 if (ret || !xmitting)
989 break;
990 }
991
992 if (k == 0)
993 ret = -ETIMEDOUT;
994
995 err = HERMES_WRITE_RECORD(hw, USER_BAP,
996 HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE,
997 &buf);
998
999 return ret ? ret : err;
1000 }
1001
1002 int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx)
1003 {
1004 hermes_t *hw = &priv->hw;
1005 int err;
1006
1007 err = hermes_write_wordrec(hw, USER_BAP,
1008 HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE,
1009 key_idx);
1010 if (err)
1011 printk(KERN_WARNING "%s: Error %d clearing TKIP key %d\n",
1012 priv->ndev->name, err, key_idx);
1013 return err;
1014 }
1015
1016 int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
1017 struct dev_addr_list *mc_list,
1018 int mc_count, int promisc)
1019 {
1020 hermes_t *hw = &priv->hw;
1021 int err = 0;
1022
1023 if (promisc != priv->promiscuous) {
1024 err = hermes_write_wordrec(hw, USER_BAP,
1025 HERMES_RID_CNFPROMISCUOUSMODE,
1026 promisc);
1027 if (err) {
1028 printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
1029 priv->ndev->name, err);
1030 } else
1031 priv->promiscuous = promisc;
1032 }
1033
1034 /* If we're not in promiscuous mode, then we need to set the
1035 * group address if either we want to multicast, or if we were
1036 * multicasting and want to stop */
1037 if (!promisc && (mc_count || priv->mc_count)) {
1038 struct dev_mc_list *p = mc_list;
1039 struct hermes_multicast mclist;
1040 int i;
1041
1042 for (i = 0; i < mc_count; i++) {
1043 /* paranoia: is list shorter than mc_count? */
1044 BUG_ON(!p);
1045 /* paranoia: bad address size in list? */
1046 BUG_ON(p->dmi_addrlen != ETH_ALEN);
1047
1048 memcpy(mclist.addr[i], p->dmi_addr, ETH_ALEN);
1049 p = p->next;
1050 }
1051
1052 if (p)
1053 printk(KERN_WARNING "%s: Multicast list is "
1054 "longer than mc_count\n", priv->ndev->name);
1055
1056 err = hw->ops->write_ltv(hw, USER_BAP,
1057 HERMES_RID_CNFGROUPADDRESSES,
1058 HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
1059 &mclist);
1060 if (err)
1061 printk(KERN_ERR "%s: Error %d setting multicast list.\n",
1062 priv->ndev->name, err);
1063 else
1064 priv->mc_count = mc_count;
1065 }
1066 return err;
1067 }
1068
1069 /* Return : < 0 -> error code ; >= 0 -> length */
1070 int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
1071 char buf[IW_ESSID_MAX_SIZE+1])
1072 {
1073 hermes_t *hw = &priv->hw;
1074 int err = 0;
1075 struct hermes_idstring essidbuf;
1076 char *p = (char *)(&essidbuf.val);
1077 int len;
1078 unsigned long flags;
1079
1080 if (orinoco_lock(priv, &flags) != 0)
1081 return -EBUSY;
1082
1083 if (strlen(priv->desired_essid) > 0) {
1084 /* We read the desired SSID from the hardware rather
1085 than from priv->desired_essid, just in case the
1086 firmware is allowed to change it on us. I'm not
1087 sure about this */
1088 /* My guess is that the OWNSSID should always be whatever
1089 * we set to the card, whereas CURRENT_SSID is the one that
1090 * may change... - Jean II */
1091 u16 rid;
1092
1093 *active = 1;
1094
1095 rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
1096 HERMES_RID_CNFDESIREDSSID;
1097
1098 err = hw->ops->read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
1099 NULL, &essidbuf);
1100 if (err)
1101 goto fail_unlock;
1102 } else {
1103 *active = 0;
1104
1105 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
1106 sizeof(essidbuf), NULL, &essidbuf);
1107 if (err)
1108 goto fail_unlock;
1109 }
1110
1111 len = le16_to_cpu(essidbuf.len);
1112 BUG_ON(len > IW_ESSID_MAX_SIZE);
1113
1114 memset(buf, 0, IW_ESSID_MAX_SIZE);
1115 memcpy(buf, p, len);
1116 err = len;
1117
1118 fail_unlock:
1119 orinoco_unlock(priv, &flags);
1120
1121 return err;
1122 }
1123
1124 int orinoco_hw_get_freq(struct orinoco_private *priv)
1125 {
1126 hermes_t *hw = &priv->hw;
1127 int err = 0;
1128 u16 channel;
1129 int freq = 0;
1130 unsigned long flags;
1131
1132 if (orinoco_lock(priv, &flags) != 0)
1133 return -EBUSY;
1134
1135 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL,
1136 &channel);
1137 if (err)
1138 goto out;
1139
1140 /* Intersil firmware 1.3.5 returns 0 when the interface is down */
1141 if (channel == 0) {
1142 err = -EBUSY;
1143 goto out;
1144 }
1145
1146 if ((channel < 1) || (channel > NUM_CHANNELS)) {
1147 printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
1148 priv->ndev->name, channel);
1149 err = -EBUSY;
1150 goto out;
1151
1152 }
1153 freq = ieee80211_dsss_chan_to_freq(channel);
1154
1155 out:
1156 orinoco_unlock(priv, &flags);
1157
1158 if (err > 0)
1159 err = -EBUSY;
1160 return err ? err : freq;
1161 }
1162
1163 int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
1164 int *numrates, s32 *rates, int max)
1165 {
1166 hermes_t *hw = &priv->hw;
1167 struct hermes_idstring list;
1168 unsigned char *p = (unsigned char *)&list.val;
1169 int err = 0;
1170 int num;
1171 int i;
1172 unsigned long flags;
1173
1174 if (orinoco_lock(priv, &flags) != 0)
1175 return -EBUSY;
1176
1177 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
1178 sizeof(list), NULL, &list);
1179 orinoco_unlock(priv, &flags);
1180
1181 if (err)
1182 return err;
1183
1184 num = le16_to_cpu(list.len);
1185 *numrates = num;
1186 num = min(num, max);
1187
1188 for (i = 0; i < num; i++)
1189 rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */
1190
1191 return 0;
1192 }
1193
1194 int orinoco_hw_trigger_scan(struct orinoco_private *priv,
1195 const struct cfg80211_ssid *ssid)
1196 {
1197 struct net_device *dev = priv->ndev;
1198 hermes_t *hw = &priv->hw;
1199 unsigned long flags;
1200 int err = 0;
1201
1202 if (orinoco_lock(priv, &flags) != 0)
1203 return -EBUSY;
1204
1205 /* Scanning with port 0 disabled would fail */
1206 if (!netif_running(dev)) {
1207 err = -ENETDOWN;
1208 goto out;
1209 }
1210
1211 /* In monitor mode, the scan results are always empty.
1212 * Probe responses are passed to the driver as received
1213 * frames and could be processed in software. */
1214 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
1215 err = -EOPNOTSUPP;
1216 goto out;
1217 }
1218
1219 if (priv->has_hostscan) {
1220 switch (priv->firmware_type) {
1221 case FIRMWARE_TYPE_SYMBOL:
1222 err = hermes_write_wordrec(hw, USER_BAP,
1223 HERMES_RID_CNFHOSTSCAN_SYMBOL,
1224 HERMES_HOSTSCAN_SYMBOL_ONCE |
1225 HERMES_HOSTSCAN_SYMBOL_BCAST);
1226 break;
1227 case FIRMWARE_TYPE_INTERSIL: {
1228 __le16 req[3];
1229
1230 req[0] = cpu_to_le16(0x3fff); /* All channels */
1231 req[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */
1232 req[2] = 0; /* Any ESSID */
1233 err = HERMES_WRITE_RECORD(hw, USER_BAP,
1234 HERMES_RID_CNFHOSTSCAN, &req);
1235 break;
1236 }
1237 case FIRMWARE_TYPE_AGERE:
1238 if (ssid->ssid_len > 0) {
1239 struct hermes_idstring idbuf;
1240 size_t len = ssid->ssid_len;
1241
1242 idbuf.len = cpu_to_le16(len);
1243 memcpy(idbuf.val, ssid->ssid, len);
1244
1245 err = hw->ops->write_ltv(hw, USER_BAP,
1246 HERMES_RID_CNFSCANSSID_AGERE,
1247 HERMES_BYTES_TO_RECLEN(len + 2),
1248 &idbuf);
1249 } else
1250 err = hermes_write_wordrec(hw, USER_BAP,
1251 HERMES_RID_CNFSCANSSID_AGERE,
1252 0); /* Any ESSID */
1253 if (err)
1254 break;
1255
1256 if (priv->has_ext_scan) {
1257 err = hermes_write_wordrec(hw, USER_BAP,
1258 HERMES_RID_CNFSCANCHANNELS2GHZ,
1259 0x7FFF);
1260 if (err)
1261 goto out;
1262
1263 err = hermes_inquire(hw,
1264 HERMES_INQ_CHANNELINFO);
1265 } else
1266 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1267
1268 break;
1269 }
1270 } else
1271 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1272
1273 out:
1274 orinoco_unlock(priv, &flags);
1275
1276 return err;
1277 }
1278
1279 /* Disassociate from node with BSSID addr */
1280 int orinoco_hw_disassociate(struct orinoco_private *priv,
1281 u8 *addr, u16 reason_code)
1282 {
1283 hermes_t *hw = &priv->hw;
1284 int err;
1285
1286 struct {
1287 u8 addr[ETH_ALEN];
1288 __le16 reason_code;
1289 } __attribute__ ((packed)) buf;
1290
1291 /* Currently only supported by WPA enabled Agere fw */
1292 if (!priv->has_wpa)
1293 return -EOPNOTSUPP;
1294
1295 memcpy(buf.addr, addr, ETH_ALEN);
1296 buf.reason_code = cpu_to_le16(reason_code);
1297 err = HERMES_WRITE_RECORD(hw, USER_BAP,
1298 HERMES_RID_CNFDISASSOCIATE,
1299 &buf);
1300 return err;
1301 }
1302
1303 int orinoco_hw_get_current_bssid(struct orinoco_private *priv,
1304 u8 *addr)
1305 {
1306 hermes_t *hw = &priv->hw;
1307 int err;
1308
1309 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
1310 ETH_ALEN, NULL, addr);
1311
1312 return err;
1313 }
orinoco usb branch