1 /* Encapsulate basic setting changes and retrieval on Hermes hardware
3 * See copyright notice in main.c
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>
12 #include "hermes_rid.h"
17 #define SYMBOL_MAX_VER_LEN (14)
19 /* Symbol firmware has a bug allocating buffers larger than this */
20 #define TX_NICBUF_SIZE_BUG 1585
22 /********************************************************************/
24 /********************************************************************/
26 /* This tables gives the actual meanings of the bitrate IDs returned
29 int bitrate
; /* in 100s of kilobits */
32 u16 intersil_txratectrl
;
34 {110, 1, 3, 15}, /* Entry 0 is the default */
43 #define BITRATE_TABLE_SIZE ARRAY_SIZE(bitrate_table)
45 /* Firmware version encoding */
47 u16 id
, variant
, major
, minor
;
48 } __attribute__ ((packed
));
50 static inline fwtype_t
determine_firmware_type(struct comp_id
*nic_id
)
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
;
57 return FIRMWARE_TYPE_INTERSIL
;
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
64 * If non-NULL stores a firmware description in fw_name.
65 * If non-NULL stores a HW version in hw_ver
67 * These are output via generic cfg80211 ethtool support.
69 int determine_fw_capabilities(struct orinoco_private
*priv
,
70 char *fw_name
, size_t fw_name_len
,
73 struct device
*dev
= priv
->dev
;
74 hermes_t
*hw
= &priv
->hw
;
76 struct comp_id nic_id
, sta_id
;
78 char tmp
[SYMBOL_MAX_VER_LEN
+1] __attribute__((aligned(2)));
80 /* Get the hardware version */
81 err
= HERMES_READ_RECORD(hw
, USER_BAP
, HERMES_RID_NICID
, &nic_id
);
83 dev_err(dev
, "Cannot read hardware identity: error %d\n",
88 le16_to_cpus(&nic_id
.id
);
89 le16_to_cpus(&nic_id
.variant
);
90 le16_to_cpus(&nic_id
.major
);
91 le16_to_cpus(&nic_id
.minor
);
92 dev_info(dev
, "Hardware identity %04x:%04x:%04x:%04x\n",
93 nic_id
.id
, nic_id
.variant
, nic_id
.major
, nic_id
.minor
);
96 *hw_ver
= (((nic_id
.id
& 0xff) << 24) |
97 ((nic_id
.variant
& 0xff) << 16) |
98 ((nic_id
.major
& 0xff) << 8) |
99 (nic_id
.minor
& 0xff));
101 priv
->firmware_type
= determine_firmware_type(&nic_id
);
103 /* Get the firmware version */
104 err
= HERMES_READ_RECORD(hw
, USER_BAP
, HERMES_RID_STAID
, &sta_id
);
106 dev_err(dev
, "Cannot read station identity: error %d\n",
111 le16_to_cpus(&sta_id
.id
);
112 le16_to_cpus(&sta_id
.variant
);
113 le16_to_cpus(&sta_id
.major
);
114 le16_to_cpus(&sta_id
.minor
);
115 dev_info(dev
, "Station identity %04x:%04x:%04x:%04x\n",
116 sta_id
.id
, sta_id
.variant
, sta_id
.major
, sta_id
.minor
);
120 dev_err(dev
, "Primary firmware is active\n");
123 dev_err(dev
, "Tertiary firmware is active\n");
125 case 0x1f: /* Intersil, Agere, Symbol Spectrum24 */
126 case 0x21: /* Symbol Spectrum24 Trilogy */
129 dev_notice(dev
, "Unknown station ID, please report\n");
133 /* Default capabilities */
134 priv
->has_sensitivity
= 1;
136 priv
->has_preamble
= 0;
140 priv
->has_big_wep
= 0;
141 priv
->has_alt_txcntl
= 0;
142 priv
->has_ext_scan
= 0;
144 priv
->do_fw_download
= 0;
146 /* Determine capabilities from the firmware version */
147 switch (priv
->firmware_type
) {
148 case FIRMWARE_TYPE_AGERE
:
149 /* Lucent Wavelan IEEE, Lucent Orinoco, Cabletron RoamAbout,
150 ELSA, Melco, HP, IBM, Dell 1150, Compaq 110/210 */
152 snprintf(fw_name
, fw_name_len
, "Lucent/Agere %d.%02d",
153 sta_id
.major
, sta_id
.minor
);
155 firmver
= ((unsigned long)sta_id
.major
<< 16) | sta_id
.minor
;
157 priv
->has_ibss
= (firmver
>= 0x60006);
158 priv
->has_wep
= (firmver
>= 0x40020);
159 priv
->has_big_wep
= 1; /* FIXME: this is wrong - how do we tell
160 Gold cards from the others? */
161 priv
->has_mwo
= (firmver
>= 0x60000);
162 priv
->has_pm
= (firmver
>= 0x40020); /* Don't work in 7.52 ? */
164 priv
->has_hostscan
= (firmver
>= 0x8000a);
165 priv
->do_fw_download
= 1;
166 priv
->broken_monitor
= (firmver
>= 0x80000);
167 priv
->has_alt_txcntl
= (firmver
>= 0x90000); /* All 9.x ? */
168 priv
->has_ext_scan
= (firmver
>= 0x90000); /* All 9.x ? */
169 priv
->has_wpa
= (firmver
>= 0x9002a);
170 /* Tested with Agere firmware :
171 * 1.16 ; 4.08 ; 4.52 ; 6.04 ; 6.16 ; 7.28 => Jean II
172 * Tested CableTron firmware : 4.32 => Anton */
174 case FIRMWARE_TYPE_SYMBOL
:
175 /* Symbol , 3Com AirConnect, Intel, Ericsson WLAN */
176 /* Intel MAC : 00:02:B3:* */
177 /* 3Com MAC : 00:50:DA:* */
178 memset(tmp
, 0, sizeof(tmp
));
179 /* Get the Symbol firmware version */
180 err
= hw
->ops
->read_ltv(hw
, USER_BAP
,
181 HERMES_RID_SECONDARYVERSION_SYMBOL
,
182 SYMBOL_MAX_VER_LEN
, NULL
, &tmp
);
184 dev_warn(dev
, "Error %d reading Symbol firmware info. "
185 "Wildly guessing capabilities...\n", err
);
189 /* The firmware revision is a string, the format is
190 * something like : "V2.20-01".
191 * Quick and dirty parsing... - Jean II
193 firmver
= ((tmp
[1] - '0') << 16)
194 | ((tmp
[3] - '0') << 12)
195 | ((tmp
[4] - '0') << 8)
196 | ((tmp
[6] - '0') << 4)
199 tmp
[SYMBOL_MAX_VER_LEN
] = '\0';
203 snprintf(fw_name
, fw_name_len
, "Symbol %s", tmp
);
205 priv
->has_ibss
= (firmver
>= 0x20000);
206 priv
->has_wep
= (firmver
>= 0x15012);
207 priv
->has_big_wep
= (firmver
>= 0x20000);
208 priv
->has_pm
= (firmver
>= 0x20000 && firmver
< 0x22000) ||
209 (firmver
>= 0x29000 && firmver
< 0x30000) ||
211 priv
->has_preamble
= (firmver
>= 0x20000);
214 /* Symbol firmware is found on various cards, but
215 * there has been no attempt to check firmware
216 * download on non-spectrum_cs based cards.
218 * Given that the Agere firmware download works
219 * differently, we should avoid doing a firmware
220 * download with the Symbol algorithm on non-spectrum
223 * For now we can identify a spectrum_cs based card
224 * because it has a firmware reset function.
226 priv
->do_fw_download
= (priv
->stop_fw
!= NULL
);
228 priv
->broken_disableport
= (firmver
== 0x25013) ||
229 (firmver
>= 0x30000 && firmver
<= 0x31000);
230 priv
->has_hostscan
= (firmver
>= 0x31001) ||
231 (firmver
>= 0x29057 && firmver
< 0x30000);
232 /* Tested with Intel firmware : 0x20015 => Jean II */
233 /* Tested with 3Com firmware : 0x15012 & 0x22001 => Jean II */
235 case FIRMWARE_TYPE_INTERSIL
:
236 /* D-Link, Linksys, Adtron, ZoomAir, and many others...
237 * Samsung, Compaq 100/200 and Proxim are slightly
238 * different and less well tested */
239 /* D-Link MAC : 00:40:05:* */
240 /* Addtron MAC : 00:90:D1:* */
242 snprintf(fw_name
, fw_name_len
, "Intersil %d.%d.%d",
243 sta_id
.major
, sta_id
.minor
, sta_id
.variant
);
245 firmver
= ((unsigned long)sta_id
.major
<< 16) |
246 ((unsigned long)sta_id
.minor
<< 8) | sta_id
.variant
;
248 priv
->has_ibss
= (firmver
>= 0x000700); /* FIXME */
249 priv
->has_big_wep
= priv
->has_wep
= (firmver
>= 0x000800);
250 priv
->has_pm
= (firmver
>= 0x000700);
251 priv
->has_hostscan
= (firmver
>= 0x010301);
253 if (firmver
>= 0x000800)
256 dev_notice(dev
, "Intersil firmware earlier than v0.8.x"
257 " - several features not supported\n");
263 dev_info(dev
, "Firmware determined as %s\n", fw_name
);
265 #ifndef CONFIG_HERMES_PRISM
266 if (priv
->firmware_type
== FIRMWARE_TYPE_INTERSIL
) {
267 dev_err(dev
, "Support for Prism chipset is not enabled\n");
275 /* Read settings from EEPROM into our private structure.
276 * MAC address gets dropped into callers buffer
277 * Can be called before netdev registration.
279 int orinoco_hw_read_card_settings(struct orinoco_private
*priv
, u8
*dev_addr
)
281 struct device
*dev
= priv
->dev
;
282 struct hermes_idstring nickbuf
;
283 hermes_t
*hw
= &priv
->hw
;
288 /* Get the MAC address */
289 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_CNFOWNMACADDR
,
290 ETH_ALEN
, NULL
, dev_addr
);
292 dev_warn(dev
, "Failed to read MAC address!\n");
296 dev_dbg(dev
, "MAC address %pM\n", dev_addr
);
298 /* Get the station name */
299 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_CNFOWNNAME
,
300 sizeof(nickbuf
), &reclen
, &nickbuf
);
302 dev_err(dev
, "failed to read station name\n");
306 len
= min(IW_ESSID_MAX_SIZE
, (int)le16_to_cpu(nickbuf
.len
));
308 len
= min(IW_ESSID_MAX_SIZE
, 2 * reclen
);
309 memcpy(priv
->nick
, &nickbuf
.val
, len
);
310 priv
->nick
[len
] = '\0';
312 dev_dbg(dev
, "Station name \"%s\"\n", priv
->nick
);
314 /* Get allowed channels */
315 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_CHANNELLIST
,
316 &priv
->channel_mask
);
318 dev_err(dev
, "Failed to read channel list!\n");
322 /* Get initial AP density */
323 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_CNFSYSTEMSCALE
,
325 if (err
|| priv
->ap_density
< 1 || priv
->ap_density
> 3)
326 priv
->has_sensitivity
= 0;
328 /* Get initial RTS threshold */
329 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_CNFRTSTHRESHOLD
,
332 dev_err(dev
, "Failed to read RTS threshold!\n");
336 /* Get initial fragmentation settings */
338 err
= hermes_read_wordrec(hw
, USER_BAP
,
339 HERMES_RID_CNFMWOROBUST_AGERE
,
342 err
= hermes_read_wordrec(hw
, USER_BAP
,
343 HERMES_RID_CNFFRAGMENTATIONTHRESHOLD
,
346 dev_err(dev
, "Failed to read fragmentation settings!\n");
350 /* Power management setup */
354 err
= hermes_read_wordrec(hw
, USER_BAP
,
355 HERMES_RID_CNFMAXSLEEPDURATION
,
358 dev_err(dev
, "Failed to read power management "
362 err
= hermes_read_wordrec(hw
, USER_BAP
,
363 HERMES_RID_CNFPMHOLDOVERDURATION
,
366 dev_err(dev
, "Failed to read power management "
373 if (priv
->has_preamble
) {
374 err
= hermes_read_wordrec(hw
, USER_BAP
,
375 HERMES_RID_CNFPREAMBLE_SYMBOL
,
378 dev_err(dev
, "Failed to read preamble setup\n");
384 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_SHORTRETRYLIMIT
,
385 &priv
->short_retry_limit
);
387 dev_err(dev
, "Failed to read short retry limit\n");
391 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_LONGRETRYLIMIT
,
392 &priv
->long_retry_limit
);
394 dev_err(dev
, "Failed to read long retry limit\n");
398 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_MAXTRANSMITLIFETIME
,
399 &priv
->retry_lifetime
);
401 dev_err(dev
, "Failed to read max retry lifetime\n");
409 /* Can be called before netdev registration */
410 int orinoco_hw_allocate_fid(struct orinoco_private
*priv
)
412 struct device
*dev
= priv
->dev
;
413 struct hermes
*hw
= &priv
->hw
;
416 err
= hw
->ops
->allocate(hw
, priv
->nicbuf_size
, &priv
->txfid
);
417 if (err
== -EIO
&& priv
->nicbuf_size
> TX_NICBUF_SIZE_BUG
) {
418 /* Try workaround for old Symbol firmware bug */
419 priv
->nicbuf_size
= TX_NICBUF_SIZE_BUG
;
420 err
= hw
->ops
->allocate(hw
, priv
->nicbuf_size
, &priv
->txfid
);
422 dev_warn(dev
, "Firmware ALLOC bug detected "
423 "(old Symbol firmware?). Work around %s\n",
424 err
? "failed!" : "ok.");
430 int orinoco_get_bitratemode(int bitrate
, int automatic
)
435 if ((bitrate
!= 10) && (bitrate
!= 20) &&
436 (bitrate
!= 55) && (bitrate
!= 110))
439 for (i
= 0; i
< BITRATE_TABLE_SIZE
; i
++) {
440 if ((bitrate_table
[i
].bitrate
== bitrate
) &&
441 (bitrate_table
[i
].automatic
== automatic
)) {
449 void orinoco_get_ratemode_cfg(int ratemode
, int *bitrate
, int *automatic
)
451 BUG_ON((ratemode
< 0) || (ratemode
>= BITRATE_TABLE_SIZE
));
453 *bitrate
= bitrate_table
[ratemode
].bitrate
* 100000;
454 *automatic
= bitrate_table
[ratemode
].automatic
;
457 int orinoco_hw_program_rids(struct orinoco_private
*priv
)
459 struct net_device
*dev
= priv
->ndev
;
460 struct wireless_dev
*wdev
= netdev_priv(dev
);
461 hermes_t
*hw
= &priv
->hw
;
463 struct hermes_idstring idbuf
;
465 /* Set the MAC address */
466 err
= hw
->ops
->write_ltv(hw
, USER_BAP
, HERMES_RID_CNFOWNMACADDR
,
467 HERMES_BYTES_TO_RECLEN(ETH_ALEN
),
470 printk(KERN_ERR
"%s: Error %d setting MAC address\n",
475 /* Set up the link mode */
476 err
= hermes_write_wordrec(hw
, USER_BAP
, HERMES_RID_CNFPORTTYPE
,
479 printk(KERN_ERR
"%s: Error %d setting port type\n",
483 /* Set the channel/frequency */
484 if (priv
->channel
!= 0 && priv
->iw_mode
!= NL80211_IFTYPE_STATION
) {
485 err
= hermes_write_wordrec(hw
, USER_BAP
,
486 HERMES_RID_CNFOWNCHANNEL
,
489 printk(KERN_ERR
"%s: Error %d setting channel %d\n",
490 dev
->name
, err
, priv
->channel
);
495 if (priv
->has_ibss
) {
498 if ((strlen(priv
->desired_essid
) == 0) && (priv
->createibss
)) {
499 printk(KERN_WARNING
"%s: This firmware requires an "
500 "ESSID in IBSS-Ad-Hoc mode.\n", dev
->name
);
501 /* With wvlan_cs, in this case, we would crash.
502 * hopefully, this driver will behave better...
506 createibss
= priv
->createibss
;
509 err
= hermes_write_wordrec(hw
, USER_BAP
,
510 HERMES_RID_CNFCREATEIBSS
,
513 printk(KERN_ERR
"%s: Error %d setting CREATEIBSS\n",
519 /* Set the desired BSSID */
520 err
= __orinoco_hw_set_wap(priv
);
522 printk(KERN_ERR
"%s: Error %d setting AP address\n",
527 /* Set the desired ESSID */
528 idbuf
.len
= cpu_to_le16(strlen(priv
->desired_essid
));
529 memcpy(&idbuf
.val
, priv
->desired_essid
, sizeof(idbuf
.val
));
530 /* WinXP wants partner to configure OWNSSID even in IBSS mode. (jimc) */
531 err
= hw
->ops
->write_ltv(hw
, USER_BAP
, HERMES_RID_CNFOWNSSID
,
532 HERMES_BYTES_TO_RECLEN(strlen(priv
->desired_essid
)+2),
535 printk(KERN_ERR
"%s: Error %d setting OWNSSID\n",
539 err
= hw
->ops
->write_ltv(hw
, USER_BAP
, HERMES_RID_CNFDESIREDSSID
,
540 HERMES_BYTES_TO_RECLEN(strlen(priv
->desired_essid
)+2),
543 printk(KERN_ERR
"%s: Error %d setting DESIREDSSID\n",
548 /* Set the station name */
549 idbuf
.len
= cpu_to_le16(strlen(priv
->nick
));
550 memcpy(&idbuf
.val
, priv
->nick
, sizeof(idbuf
.val
));
551 err
= hw
->ops
->write_ltv(hw
, USER_BAP
, HERMES_RID_CNFOWNNAME
,
552 HERMES_BYTES_TO_RECLEN(strlen(priv
->nick
)+2),
555 printk(KERN_ERR
"%s: Error %d setting nickname\n",
561 if (priv
->has_sensitivity
) {
562 err
= hermes_write_wordrec(hw
, USER_BAP
,
563 HERMES_RID_CNFSYSTEMSCALE
,
566 printk(KERN_WARNING
"%s: Error %d setting SYSTEMSCALE. "
567 "Disabling sensitivity control\n",
570 priv
->has_sensitivity
= 0;
574 /* Set RTS threshold */
575 err
= hermes_write_wordrec(hw
, USER_BAP
, HERMES_RID_CNFRTSTHRESHOLD
,
578 printk(KERN_ERR
"%s: Error %d setting RTS threshold\n",
583 /* Set fragmentation threshold or MWO robustness */
585 err
= hermes_write_wordrec(hw
, USER_BAP
,
586 HERMES_RID_CNFMWOROBUST_AGERE
,
589 err
= hermes_write_wordrec(hw
, USER_BAP
,
590 HERMES_RID_CNFFRAGMENTATIONTHRESHOLD
,
593 printk(KERN_ERR
"%s: Error %d setting fragmentation\n",
599 err
= __orinoco_hw_set_bitrate(priv
);
601 printk(KERN_ERR
"%s: Error %d setting bitrate\n",
606 /* Set power management */
608 err
= hermes_write_wordrec(hw
, USER_BAP
,
609 HERMES_RID_CNFPMENABLED
,
612 printk(KERN_ERR
"%s: Error %d setting up PM\n",
617 err
= hermes_write_wordrec(hw
, USER_BAP
,
618 HERMES_RID_CNFMULTICASTRECEIVE
,
621 printk(KERN_ERR
"%s: Error %d setting up PM\n",
625 err
= hermes_write_wordrec(hw
, USER_BAP
,
626 HERMES_RID_CNFMAXSLEEPDURATION
,
629 printk(KERN_ERR
"%s: Error %d setting up PM\n",
633 err
= hermes_write_wordrec(hw
, USER_BAP
,
634 HERMES_RID_CNFPMHOLDOVERDURATION
,
637 printk(KERN_ERR
"%s: Error %d setting up PM\n",
643 /* Set preamble - only for Symbol so far... */
644 if (priv
->has_preamble
) {
645 err
= hermes_write_wordrec(hw
, USER_BAP
,
646 HERMES_RID_CNFPREAMBLE_SYMBOL
,
649 printk(KERN_ERR
"%s: Error %d setting preamble\n",
655 /* Set up encryption */
656 if (priv
->has_wep
|| priv
->has_wpa
) {
657 err
= __orinoco_hw_setup_enc(priv
);
659 printk(KERN_ERR
"%s: Error %d activating encryption\n",
665 if (priv
->iw_mode
== NL80211_IFTYPE_MONITOR
) {
666 /* Enable monitor mode */
667 dev
->type
= ARPHRD_IEEE80211
;
668 err
= hw
->ops
->cmd_wait(hw
, HERMES_CMD_TEST
|
669 HERMES_TEST_MONITOR
, 0, NULL
);
671 /* Disable monitor mode */
672 dev
->type
= ARPHRD_ETHER
;
673 err
= hw
->ops
->cmd_wait(hw
, HERMES_CMD_TEST
|
674 HERMES_TEST_STOP
, 0, NULL
);
679 /* Reset promiscuity / multicast*/
680 priv
->promiscuous
= 0;
683 /* Record mode change */
684 wdev
->iftype
= priv
->iw_mode
;
689 /* Get tsc from the firmware */
690 int orinoco_hw_get_tkip_iv(struct orinoco_private
*priv
, int key
, u8
*tsc
)
692 hermes_t
*hw
= &priv
->hw
;
694 u8 tsc_arr
[4][ORINOCO_SEQ_LEN
];
696 if ((key
< 0) || (key
>= 4))
699 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_CURRENT_TKIP_IV
,
700 sizeof(tsc_arr
), NULL
, &tsc_arr
);
702 memcpy(tsc
, &tsc_arr
[key
][0], sizeof(tsc_arr
[0]));
707 int __orinoco_hw_set_bitrate(struct orinoco_private
*priv
)
709 hermes_t
*hw
= &priv
->hw
;
710 int ratemode
= priv
->bitratemode
;
713 if (ratemode
>= BITRATE_TABLE_SIZE
) {
714 printk(KERN_ERR
"%s: BUG: Invalid bitrate mode %d\n",
715 priv
->ndev
->name
, ratemode
);
719 switch (priv
->firmware_type
) {
720 case FIRMWARE_TYPE_AGERE
:
721 err
= hermes_write_wordrec(hw
, USER_BAP
,
722 HERMES_RID_CNFTXRATECONTROL
,
723 bitrate_table
[ratemode
].agere_txratectrl
);
725 case FIRMWARE_TYPE_INTERSIL
:
726 case FIRMWARE_TYPE_SYMBOL
:
727 err
= hermes_write_wordrec(hw
, USER_BAP
,
728 HERMES_RID_CNFTXRATECONTROL
,
729 bitrate_table
[ratemode
].intersil_txratectrl
);
738 int orinoco_hw_get_act_bitrate(struct orinoco_private
*priv
, int *bitrate
)
740 hermes_t
*hw
= &priv
->hw
;
745 err
= hermes_read_wordrec(hw
, USER_BAP
,
746 HERMES_RID_CURRENTTXRATE
, &val
);
750 switch (priv
->firmware_type
) {
751 case FIRMWARE_TYPE_AGERE
: /* Lucent style rate */
752 /* Note : in Lucent firmware, the return value of
753 * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
754 * and therefore is totally different from the
755 * encoding of HERMES_RID_CNFTXRATECONTROL.
756 * Don't forget that 6Mb/s is really 5.5Mb/s */
760 *bitrate
= val
* 1000000;
762 case FIRMWARE_TYPE_INTERSIL
: /* Intersil style rate */
763 case FIRMWARE_TYPE_SYMBOL
: /* Symbol style rate */
764 for (i
= 0; i
< BITRATE_TABLE_SIZE
; i
++)
765 if (bitrate_table
[i
].intersil_txratectrl
== val
)
768 if (i
>= BITRATE_TABLE_SIZE
)
769 printk(KERN_INFO
"%s: Unable to determine current bitrate (0x%04hx)\n",
770 priv
->ndev
->name
, val
);
772 *bitrate
= bitrate_table
[i
].bitrate
* 100000;
781 /* Set fixed AP address */
782 int __orinoco_hw_set_wap(struct orinoco_private
*priv
)
786 hermes_t
*hw
= &priv
->hw
;
788 switch (priv
->firmware_type
) {
789 case FIRMWARE_TYPE_AGERE
:
792 case FIRMWARE_TYPE_INTERSIL
:
793 if (priv
->bssid_fixed
)
798 err
= hermes_write_wordrec(hw
, USER_BAP
,
799 HERMES_RID_CNFROAMINGMODE
,
802 case FIRMWARE_TYPE_SYMBOL
:
803 err
= HERMES_WRITE_RECORD(hw
, USER_BAP
,
804 HERMES_RID_CNFMANDATORYBSSID_SYMBOL
,
805 &priv
->desired_bssid
);
811 /* Change the WEP keys and/or the current keys. Can be called
812 * either from __orinoco_hw_setup_enc() or directly from
813 * orinoco_ioctl_setiwencode(). In the later case the association
814 * with the AP is not broken (if the firmware can handle it),
815 * which is needed for 802.1x implementations. */
816 int __orinoco_hw_setup_wepkeys(struct orinoco_private
*priv
)
818 hermes_t
*hw
= &priv
->hw
;
822 switch (priv
->firmware_type
) {
823 case FIRMWARE_TYPE_AGERE
:
825 struct orinoco_key keys
[ORINOCO_MAX_KEYS
];
827 memset(&keys
, 0, sizeof(keys
));
828 for (i
= 0; i
< ORINOCO_MAX_KEYS
; i
++) {
829 int len
= min(priv
->keys
[i
].key_len
,
830 ORINOCO_MAX_KEY_SIZE
);
831 memcpy(&keys
[i
].data
, priv
->keys
[i
].key
, len
);
832 if (len
> SMALL_KEY_SIZE
)
833 keys
[i
].len
= cpu_to_le16(LARGE_KEY_SIZE
);
835 keys
[i
].len
= cpu_to_le16(SMALL_KEY_SIZE
);
837 keys
[i
].len
= cpu_to_le16(0);
840 err
= HERMES_WRITE_RECORD(hw
, USER_BAP
,
841 HERMES_RID_CNFWEPKEYS_AGERE
,
845 err
= hermes_write_wordrec(hw
, USER_BAP
,
846 HERMES_RID_CNFTXKEY_AGERE
,
852 case FIRMWARE_TYPE_INTERSIL
:
853 case FIRMWARE_TYPE_SYMBOL
:
857 /* Force uniform key length to work around
859 keylen
= priv
->keys
[priv
->tx_key
].key_len
;
861 if (keylen
> LARGE_KEY_SIZE
) {
862 printk(KERN_ERR
"%s: BUG: Key %d has oversize length %d.\n",
863 priv
->ndev
->name
, priv
->tx_key
, keylen
);
865 } else if (keylen
> SMALL_KEY_SIZE
)
866 keylen
= LARGE_KEY_SIZE
;
868 keylen
= SMALL_KEY_SIZE
;
872 /* Write all 4 keys */
873 for (i
= 0; i
< ORINOCO_MAX_KEYS
; i
++) {
874 u8 key
[LARGE_KEY_SIZE
] = { 0 };
876 memcpy(key
, priv
->keys
[i
].key
,
877 priv
->keys
[i
].key_len
);
879 err
= hw
->ops
->write_ltv(hw
, USER_BAP
,
880 HERMES_RID_CNFDEFAULTKEY0
+ i
,
881 HERMES_BYTES_TO_RECLEN(keylen
),
887 /* Write the index of the key used in transmission */
888 err
= hermes_write_wordrec(hw
, USER_BAP
,
889 HERMES_RID_CNFWEPDEFAULTKEYID
,
900 int __orinoco_hw_setup_enc(struct orinoco_private
*priv
)
902 hermes_t
*hw
= &priv
->hw
;
909 if (priv
->encode_alg
== ORINOCO_ALG_WEP
)
910 __orinoco_hw_setup_wepkeys(priv
);
912 if (priv
->wep_restrict
)
913 auth_flag
= HERMES_AUTH_SHARED_KEY
;
915 auth_flag
= HERMES_AUTH_OPEN
;
917 if (priv
->wpa_enabled
)
919 else if (priv
->encode_alg
== ORINOCO_ALG_WEP
)
924 switch (priv
->firmware_type
) {
925 case FIRMWARE_TYPE_AGERE
: /* Agere style WEP */
926 if (priv
->encode_alg
== ORINOCO_ALG_WEP
) {
927 /* Enable the shared-key authentication. */
928 err
= hermes_write_wordrec(hw
, USER_BAP
,
929 HERMES_RID_CNFAUTHENTICATION_AGERE
,
932 err
= hermes_write_wordrec(hw
, USER_BAP
,
933 HERMES_RID_CNFWEPENABLED_AGERE
,
939 /* Set WPA key management */
940 err
= hermes_write_wordrec(hw
, USER_BAP
,
941 HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE
,
949 case FIRMWARE_TYPE_INTERSIL
: /* Intersil style WEP */
950 case FIRMWARE_TYPE_SYMBOL
: /* Symbol style WEP */
951 if (priv
->encode_alg
== ORINOCO_ALG_WEP
) {
952 if (priv
->wep_restrict
||
953 (priv
->firmware_type
== FIRMWARE_TYPE_SYMBOL
))
954 master_wep_flag
= HERMES_WEP_PRIVACY_INVOKED
|
955 HERMES_WEP_EXCL_UNENCRYPTED
;
957 master_wep_flag
= HERMES_WEP_PRIVACY_INVOKED
;
959 err
= hermes_write_wordrec(hw
, USER_BAP
,
960 HERMES_RID_CNFAUTHENTICATION
,
967 if (priv
->iw_mode
== NL80211_IFTYPE_MONITOR
)
968 master_wep_flag
|= HERMES_WEP_HOST_DECRYPT
;
970 /* Master WEP setting : on/off */
971 err
= hermes_write_wordrec(hw
, USER_BAP
,
972 HERMES_RID_CNFWEPFLAGS_INTERSIL
,
983 /* key must be 32 bytes, including the tx and rx MIC keys.
984 * rsc must be NULL or up to 8 bytes
985 * tsc must be NULL or up to 8 bytes
987 int __orinoco_hw_set_tkip_key(struct orinoco_private
*priv
, int key_idx
,
988 int set_tx
, u8
*key
, u8
*rsc
, size_t rsc_len
,
989 u8
*tsc
, size_t tsc_len
)
993 u8 rsc
[ORINOCO_SEQ_LEN
];
995 u8 tx_mic
[MIC_KEYLEN
];
996 u8 rx_mic
[MIC_KEYLEN
];
997 u8 tsc
[ORINOCO_SEQ_LEN
];
998 } __attribute__ ((packed
)) buf
;
999 hermes_t
*hw
= &priv
->hw
;
1010 buf
.idx
= cpu_to_le16(key_idx
);
1011 memcpy(buf
.key
, key
,
1012 sizeof(buf
.key
) + sizeof(buf
.tx_mic
) + sizeof(buf
.rx_mic
));
1014 if (rsc_len
> sizeof(buf
.rsc
))
1015 rsc_len
= sizeof(buf
.rsc
);
1017 if (tsc_len
> sizeof(buf
.tsc
))
1018 tsc_len
= sizeof(buf
.tsc
);
1020 memset(buf
.rsc
, 0, sizeof(buf
.rsc
));
1021 memset(buf
.tsc
, 0, sizeof(buf
.tsc
));
1024 memcpy(buf
.rsc
, rsc
, rsc_len
);
1027 memcpy(buf
.tsc
, tsc
, tsc_len
);
1031 /* Wait upto 100ms for tx queue to empty */
1032 for (k
= 100; k
> 0; k
--) {
1034 ret
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_TXQUEUEEMPTY
,
1036 if (ret
|| !xmitting
)
1043 err
= HERMES_WRITE_RECORD(hw
, USER_BAP
,
1044 HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE
,
1047 return ret
? ret
: err
;
1050 int orinoco_clear_tkip_key(struct orinoco_private
*priv
, int key_idx
)
1052 hermes_t
*hw
= &priv
->hw
;
1055 err
= hermes_write_wordrec(hw
, USER_BAP
,
1056 HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE
,
1059 printk(KERN_WARNING
"%s: Error %d clearing TKIP key %d\n",
1060 priv
->ndev
->name
, err
, key_idx
);
1064 int __orinoco_hw_set_multicast_list(struct orinoco_private
*priv
,
1065 struct net_device
*dev
,
1066 int mc_count
, int promisc
)
1068 hermes_t
*hw
= &priv
->hw
;
1071 if (promisc
!= priv
->promiscuous
) {
1072 err
= hermes_write_wordrec(hw
, USER_BAP
,
1073 HERMES_RID_CNFPROMISCUOUSMODE
,
1076 printk(KERN_ERR
"%s: Error %d setting PROMISCUOUSMODE to 1.\n",
1077 priv
->ndev
->name
, err
);
1079 priv
->promiscuous
= promisc
;
1082 /* If we're not in promiscuous mode, then we need to set the
1083 * group address if either we want to multicast, or if we were
1084 * multicasting and want to stop */
1085 if (!promisc
&& (mc_count
|| priv
->mc_count
)) {
1086 struct netdev_hw_addr
*ha
;
1087 struct hermes_multicast mclist
;
1090 netdev_for_each_mc_addr(ha
, dev
) {
1093 memcpy(mclist
.addr
[i
++], ha
->addr
, ETH_ALEN
);
1096 err
= hw
->ops
->write_ltv(hw
, USER_BAP
,
1097 HERMES_RID_CNFGROUPADDRESSES
,
1098 HERMES_BYTES_TO_RECLEN(mc_count
* ETH_ALEN
),
1101 printk(KERN_ERR
"%s: Error %d setting multicast list.\n",
1102 priv
->ndev
->name
, err
);
1104 priv
->mc_count
= mc_count
;
1109 /* Return : < 0 -> error code ; >= 0 -> length */
1110 int orinoco_hw_get_essid(struct orinoco_private
*priv
, int *active
,
1111 char buf
[IW_ESSID_MAX_SIZE
+1])
1113 hermes_t
*hw
= &priv
->hw
;
1115 struct hermes_idstring essidbuf
;
1116 char *p
= (char *)(&essidbuf
.val
);
1118 unsigned long flags
;
1120 if (orinoco_lock(priv
, &flags
) != 0)
1123 if (strlen(priv
->desired_essid
) > 0) {
1124 /* We read the desired SSID from the hardware rather
1125 than from priv->desired_essid, just in case the
1126 firmware is allowed to change it on us. I'm not
1128 /* My guess is that the OWNSSID should always be whatever
1129 * we set to the card, whereas CURRENT_SSID is the one that
1130 * may change... - Jean II */
1135 rid
= (priv
->port_type
== 3) ? HERMES_RID_CNFOWNSSID
:
1136 HERMES_RID_CNFDESIREDSSID
;
1138 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, rid
, sizeof(essidbuf
),
1145 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_CURRENTSSID
,
1146 sizeof(essidbuf
), NULL
, &essidbuf
);
1151 len
= le16_to_cpu(essidbuf
.len
);
1152 BUG_ON(len
> IW_ESSID_MAX_SIZE
);
1154 memset(buf
, 0, IW_ESSID_MAX_SIZE
);
1155 memcpy(buf
, p
, len
);
1159 orinoco_unlock(priv
, &flags
);
1164 int orinoco_hw_get_freq(struct orinoco_private
*priv
)
1166 hermes_t
*hw
= &priv
->hw
;
1170 unsigned long flags
;
1172 if (orinoco_lock(priv
, &flags
) != 0)
1175 err
= hermes_read_wordrec(hw
, USER_BAP
, HERMES_RID_CURRENTCHANNEL
,
1180 /* Intersil firmware 1.3.5 returns 0 when the interface is down */
1186 if ((channel
< 1) || (channel
> NUM_CHANNELS
)) {
1187 printk(KERN_WARNING
"%s: Channel out of range (%d)!\n",
1188 priv
->ndev
->name
, channel
);
1193 freq
= ieee80211_dsss_chan_to_freq(channel
);
1196 orinoco_unlock(priv
, &flags
);
1200 return err
? err
: freq
;
1203 int orinoco_hw_get_bitratelist(struct orinoco_private
*priv
,
1204 int *numrates
, s32
*rates
, int max
)
1206 hermes_t
*hw
= &priv
->hw
;
1207 struct hermes_idstring list
;
1208 unsigned char *p
= (unsigned char *)&list
.val
;
1212 unsigned long flags
;
1214 if (orinoco_lock(priv
, &flags
) != 0)
1217 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_SUPPORTEDDATARATES
,
1218 sizeof(list
), NULL
, &list
);
1219 orinoco_unlock(priv
, &flags
);
1224 num
= le16_to_cpu(list
.len
);
1226 num
= min(num
, max
);
1228 for (i
= 0; i
< num
; i
++)
1229 rates
[i
] = (p
[i
] & 0x7f) * 500000; /* convert to bps */
1234 int orinoco_hw_trigger_scan(struct orinoco_private
*priv
,
1235 const struct cfg80211_ssid
*ssid
)
1237 struct net_device
*dev
= priv
->ndev
;
1238 hermes_t
*hw
= &priv
->hw
;
1239 unsigned long flags
;
1242 if (orinoco_lock(priv
, &flags
) != 0)
1245 /* Scanning with port 0 disabled would fail */
1246 if (!netif_running(dev
)) {
1251 /* In monitor mode, the scan results are always empty.
1252 * Probe responses are passed to the driver as received
1253 * frames and could be processed in software. */
1254 if (priv
->iw_mode
== NL80211_IFTYPE_MONITOR
) {
1259 if (priv
->has_hostscan
) {
1260 switch (priv
->firmware_type
) {
1261 case FIRMWARE_TYPE_SYMBOL
:
1262 err
= hermes_write_wordrec(hw
, USER_BAP
,
1263 HERMES_RID_CNFHOSTSCAN_SYMBOL
,
1264 HERMES_HOSTSCAN_SYMBOL_ONCE
|
1265 HERMES_HOSTSCAN_SYMBOL_BCAST
);
1267 case FIRMWARE_TYPE_INTERSIL
: {
1270 req
[0] = cpu_to_le16(0x3fff); /* All channels */
1271 req
[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */
1272 req
[2] = 0; /* Any ESSID */
1273 err
= HERMES_WRITE_RECORD(hw
, USER_BAP
,
1274 HERMES_RID_CNFHOSTSCAN
, &req
);
1277 case FIRMWARE_TYPE_AGERE
:
1278 if (ssid
->ssid_len
> 0) {
1279 struct hermes_idstring idbuf
;
1280 size_t len
= ssid
->ssid_len
;
1282 idbuf
.len
= cpu_to_le16(len
);
1283 memcpy(idbuf
.val
, ssid
->ssid
, len
);
1285 err
= hw
->ops
->write_ltv(hw
, USER_BAP
,
1286 HERMES_RID_CNFSCANSSID_AGERE
,
1287 HERMES_BYTES_TO_RECLEN(len
+ 2),
1290 err
= hermes_write_wordrec(hw
, USER_BAP
,
1291 HERMES_RID_CNFSCANSSID_AGERE
,
1296 if (priv
->has_ext_scan
) {
1297 err
= hermes_write_wordrec(hw
, USER_BAP
,
1298 HERMES_RID_CNFSCANCHANNELS2GHZ
,
1303 err
= hermes_inquire(hw
,
1304 HERMES_INQ_CHANNELINFO
);
1306 err
= hermes_inquire(hw
, HERMES_INQ_SCAN
);
1311 err
= hermes_inquire(hw
, HERMES_INQ_SCAN
);
1314 orinoco_unlock(priv
, &flags
);
1319 /* Disassociate from node with BSSID addr */
1320 int orinoco_hw_disassociate(struct orinoco_private
*priv
,
1321 u8
*addr
, u16 reason_code
)
1323 hermes_t
*hw
= &priv
->hw
;
1329 } __attribute__ ((packed
)) buf
;
1331 /* Currently only supported by WPA enabled Agere fw */
1335 memcpy(buf
.addr
, addr
, ETH_ALEN
);
1336 buf
.reason_code
= cpu_to_le16(reason_code
);
1337 err
= HERMES_WRITE_RECORD(hw
, USER_BAP
,
1338 HERMES_RID_CNFDISASSOCIATE
,
1343 int orinoco_hw_get_current_bssid(struct orinoco_private
*priv
,
1346 hermes_t
*hw
= &priv
->hw
;
1349 err
= hw
->ops
->read_ltv(hw
, USER_BAP
, HERMES_RID_CURRENTBSSID
,
1350 ETH_ALEN
, NULL
, addr
);