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 = hermes_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 = hermes_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 = hermes_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 = hermes_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 = hermes_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 = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
467 HERMES_BYTES_TO_RECLEN(ETH_ALEN), dev->dev_addr);
469 printk(KERN_ERR "%s: Error %d setting MAC address\n",
474 /* Set up the link mode */
475 err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFPORTTYPE,
478 printk(KERN_ERR "%s: Error %d setting port type\n",
482 /* Set the channel/frequency */
483 if (priv->channel != 0 && priv->iw_mode != NL80211_IFTYPE_STATION) {
484 err = hermes_write_wordrec(hw, USER_BAP,
485 HERMES_RID_CNFOWNCHANNEL,
488 printk(KERN_ERR "%s: Error %d setting channel %d\n",
489 dev->name, err, priv->channel);
494 if (priv->has_ibss) {
497 if ((strlen(priv->desired_essid) == 0) && (priv->createibss)) {
498 printk(KERN_WARNING "%s: This firmware requires an "
499 "ESSID in IBSS-Ad-Hoc mode.\n", dev->name);
500 /* With wvlan_cs, in this case, we would crash.
501 * hopefully, this driver will behave better...
505 createibss = priv->createibss;
508 err = hermes_write_wordrec(hw, USER_BAP,
509 HERMES_RID_CNFCREATEIBSS,
512 printk(KERN_ERR "%s: Error %d setting CREATEIBSS\n",
518 /* Set the desired BSSID */
519 err = __orinoco_hw_set_wap(priv);
521 printk(KERN_ERR "%s: Error %d setting AP address\n",
526 /* Set the desired ESSID */
527 idbuf.len = cpu_to_le16(strlen(priv->desired_essid));
528 memcpy(&idbuf.val, priv->desired_essid, sizeof(idbuf.val));
529 /* WinXP wants partner to configure OWNSSID even in IBSS mode. (jimc) */
530 err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNSSID,
531 HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
534 printk(KERN_ERR "%s: Error %d setting OWNSSID\n",
538 err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFDESIREDSSID,
539 HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
542 printk(KERN_ERR "%s: Error %d setting DESIREDSSID\n",
547 /* Set the station name */
548 idbuf.len = cpu_to_le16(strlen(priv->nick));
549 memcpy(&idbuf.val, priv->nick, sizeof(idbuf.val));
550 err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
551 HERMES_BYTES_TO_RECLEN(strlen(priv->nick)+2),
554 printk(KERN_ERR "%s: Error %d setting nickname\n",
560 if (priv->has_sensitivity) {
561 err = hermes_write_wordrec(hw, USER_BAP,
562 HERMES_RID_CNFSYSTEMSCALE,
565 printk(KERN_WARNING "%s: Error %d setting SYSTEMSCALE. "
566 "Disabling sensitivity control\n",
569 priv->has_sensitivity = 0;
573 /* Set RTS threshold */
574 err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
577 printk(KERN_ERR "%s: Error %d setting RTS threshold\n",
582 /* Set fragmentation threshold or MWO robustness */
584 err = hermes_write_wordrec(hw, USER_BAP,
585 HERMES_RID_CNFMWOROBUST_AGERE,
588 err = hermes_write_wordrec(hw, USER_BAP,
589 HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
592 printk(KERN_ERR "%s: Error %d setting fragmentation\n",
598 err = __orinoco_hw_set_bitrate(priv);
600 printk(KERN_ERR "%s: Error %d setting bitrate\n",
605 /* Set power management */
607 err = hermes_write_wordrec(hw, USER_BAP,
608 HERMES_RID_CNFPMENABLED,
611 printk(KERN_ERR "%s: Error %d setting up PM\n",
616 err = hermes_write_wordrec(hw, USER_BAP,
617 HERMES_RID_CNFMULTICASTRECEIVE,
620 printk(KERN_ERR "%s: Error %d setting up PM\n",
624 err = hermes_write_wordrec(hw, USER_BAP,
625 HERMES_RID_CNFMAXSLEEPDURATION,
628 printk(KERN_ERR "%s: Error %d setting up PM\n",
632 err = hermes_write_wordrec(hw, USER_BAP,
633 HERMES_RID_CNFPMHOLDOVERDURATION,
636 printk(KERN_ERR "%s: Error %d setting up PM\n",
642 /* Set preamble - only for Symbol so far... */
643 if (priv->has_preamble) {
644 err = hermes_write_wordrec(hw, USER_BAP,
645 HERMES_RID_CNFPREAMBLE_SYMBOL,
648 printk(KERN_ERR "%s: Error %d setting preamble\n",
654 /* Set up encryption */
655 if (priv->has_wep || priv->has_wpa) {
656 err = __orinoco_hw_setup_enc(priv);
658 printk(KERN_ERR "%s: Error %d activating encryption\n",
664 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
665 /* Enable monitor mode */
666 dev->type = ARPHRD_IEEE80211;
667 err = hermes_docmd_wait(hw, HERMES_CMD_TEST |
668 HERMES_TEST_MONITOR, 0, NULL);
670 /* Disable monitor mode */
671 dev->type = ARPHRD_ETHER;
672 err = hermes_docmd_wait(hw, HERMES_CMD_TEST |
673 HERMES_TEST_STOP, 0, NULL);
678 /* Reset promiscuity / multicast*/
679 priv->promiscuous = 0;
682 /* Record mode change */
683 wdev->iftype = priv->iw_mode;
688 /* Get tsc from the firmware */
689 int orinoco_hw_get_tkip_iv(struct orinoco_private *priv, int key, u8 *tsc)
691 hermes_t *hw = &priv->hw;
693 u8 tsc_arr[4][ORINOCO_SEQ_LEN];
695 if ((key < 0) || (key >= 4))
698 err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_TKIP_IV,
699 sizeof(tsc_arr), NULL, &tsc_arr);
701 memcpy(tsc, &tsc_arr[key][0], sizeof(tsc_arr[0]));
706 int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
708 hermes_t *hw = &priv->hw;
709 int ratemode = priv->bitratemode;
712 if (ratemode >= BITRATE_TABLE_SIZE) {
713 printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
714 priv->ndev->name, ratemode);
718 switch (priv->firmware_type) {
719 case FIRMWARE_TYPE_AGERE:
720 err = hermes_write_wordrec(hw, USER_BAP,
721 HERMES_RID_CNFTXRATECONTROL,
722 bitrate_table[ratemode].agere_txratectrl);
724 case FIRMWARE_TYPE_INTERSIL:
725 case FIRMWARE_TYPE_SYMBOL:
726 err = hermes_write_wordrec(hw, USER_BAP,
727 HERMES_RID_CNFTXRATECONTROL,
728 bitrate_table[ratemode].intersil_txratectrl);
737 int orinoco_hw_get_act_bitrate(struct orinoco_private *priv, int *bitrate)
739 hermes_t *hw = &priv->hw;
744 err = hermes_read_wordrec(hw, USER_BAP,
745 HERMES_RID_CURRENTTXRATE, &val);
749 switch (priv->firmware_type) {
750 case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
751 /* Note : in Lucent firmware, the return value of
752 * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
753 * and therefore is totally different from the
754 * encoding of HERMES_RID_CNFTXRATECONTROL.
755 * Don't forget that 6Mb/s is really 5.5Mb/s */
759 *bitrate = val * 1000000;
761 case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
762 case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
763 for (i = 0; i < BITRATE_TABLE_SIZE; i++)
764 if (bitrate_table[i].intersil_txratectrl == val)
767 if (i >= BITRATE_TABLE_SIZE)
768 printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
769 priv->ndev->name, val);
771 *bitrate = bitrate_table[i].bitrate * 100000;
780 /* Set fixed AP address */
781 int __orinoco_hw_set_wap(struct orinoco_private *priv)
785 hermes_t *hw = &priv->hw;
787 switch (priv->firmware_type) {
788 case FIRMWARE_TYPE_AGERE:
791 case FIRMWARE_TYPE_INTERSIL:
792 if (priv->bssid_fixed)
797 err = hermes_write_wordrec(hw, USER_BAP,
798 HERMES_RID_CNFROAMINGMODE,
801 case FIRMWARE_TYPE_SYMBOL:
802 err = HERMES_WRITE_RECORD(hw, USER_BAP,
803 HERMES_RID_CNFMANDATORYBSSID_SYMBOL,
804 &priv->desired_bssid);
810 /* Change the WEP keys and/or the current keys. Can be called
811 * either from __orinoco_hw_setup_enc() or directly from
812 * orinoco_ioctl_setiwencode(). In the later case the association
813 * with the AP is not broken (if the firmware can handle it),
814 * which is needed for 802.1x implementations. */
815 int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv)
817 hermes_t *hw = &priv->hw;
821 switch (priv->firmware_type) {
822 case FIRMWARE_TYPE_AGERE:
824 struct orinoco_key keys[ORINOCO_MAX_KEYS];
826 memset(&keys, 0, sizeof(keys));
827 for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
828 int len = min(priv->keys[i].key_len,
829 ORINOCO_MAX_KEY_SIZE);
830 memcpy(&keys[i].data, priv->keys[i].key, len);
831 if (len > SMALL_KEY_SIZE)
832 keys[i].len = cpu_to_le16(LARGE_KEY_SIZE);
834 keys[i].len = cpu_to_le16(SMALL_KEY_SIZE);
836 keys[i].len = cpu_to_le16(0);
839 err = HERMES_WRITE_RECORD(hw, USER_BAP,
840 HERMES_RID_CNFWEPKEYS_AGERE,
844 err = hermes_write_wordrec(hw, USER_BAP,
845 HERMES_RID_CNFTXKEY_AGERE,
851 case FIRMWARE_TYPE_INTERSIL:
852 case FIRMWARE_TYPE_SYMBOL:
856 /* Force uniform key length to work around
858 keylen = priv->keys[priv->tx_key].key_len;
860 if (keylen > LARGE_KEY_SIZE) {
861 printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
862 priv->ndev->name, priv->tx_key, keylen);
864 } else if (keylen > SMALL_KEY_SIZE)
865 keylen = LARGE_KEY_SIZE;
867 keylen = SMALL_KEY_SIZE;
871 /* Write all 4 keys */
872 for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
873 u8 key[LARGE_KEY_SIZE] = { 0 };
875 memcpy(key, priv->keys[i].key,
876 priv->keys[i].key_len);
878 err = hermes_write_ltv(hw, USER_BAP,
879 HERMES_RID_CNFDEFAULTKEY0 + i,
880 HERMES_BYTES_TO_RECLEN(keylen),
886 /* Write the index of the key used in transmission */
887 err = hermes_write_wordrec(hw, USER_BAP,
888 HERMES_RID_CNFWEPDEFAULTKEYID,
899 int __orinoco_hw_setup_enc(struct orinoco_private *priv)
901 hermes_t *hw = &priv->hw;
908 if (priv->encode_alg == ORINOCO_ALG_WEP)
909 __orinoco_hw_setup_wepkeys(priv);
911 if (priv->wep_restrict)
912 auth_flag = HERMES_AUTH_SHARED_KEY;
914 auth_flag = HERMES_AUTH_OPEN;
916 if (priv->wpa_enabled)
918 else if (priv->encode_alg == ORINOCO_ALG_WEP)
923 switch (priv->firmware_type) {
924 case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
925 if (priv->encode_alg == ORINOCO_ALG_WEP) {
926 /* Enable the shared-key authentication. */
927 err = hermes_write_wordrec(hw, USER_BAP,
928 HERMES_RID_CNFAUTHENTICATION_AGERE,
931 err = hermes_write_wordrec(hw, USER_BAP,
932 HERMES_RID_CNFWEPENABLED_AGERE,
938 /* Set WPA key management */
939 err = hermes_write_wordrec(hw, USER_BAP,
940 HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE,
948 case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
949 case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
950 if (priv->encode_alg == ORINOCO_ALG_WEP) {
951 if (priv->wep_restrict ||
952 (priv->firmware_type == FIRMWARE_TYPE_SYMBOL))
953 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED |
954 HERMES_WEP_EXCL_UNENCRYPTED;
956 master_wep_flag = HERMES_WEP_PRIVACY_INVOKED;
958 err = hermes_write_wordrec(hw, USER_BAP,
959 HERMES_RID_CNFAUTHENTICATION,
966 if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
967 master_wep_flag |= HERMES_WEP_HOST_DECRYPT;
969 /* Master WEP setting : on/off */
970 err = hermes_write_wordrec(hw, USER_BAP,
971 HERMES_RID_CNFWEPFLAGS_INTERSIL,
982 /* key must be 32 bytes, including the tx and rx MIC keys.
983 * rsc must be NULL or up to 8 bytes
984 * tsc must be NULL or up to 8 bytes
986 int __orinoco_hw_set_tkip_key(struct orinoco_private *priv, int key_idx,
987 int set_tx, u8 *key, u8 *rsc, size_t rsc_len,
988 u8 *tsc, size_t tsc_len)
992 u8 rsc[ORINOCO_SEQ_LEN];
994 u8 tx_mic[MIC_KEYLEN];
995 u8 rx_mic[MIC_KEYLEN];
996 u8 tsc[ORINOCO_SEQ_LEN];
997 } __attribute__ ((packed)) buf;
998 hermes_t *hw = &priv->hw;
1009 buf.idx = cpu_to_le16(key_idx);
1010 memcpy(buf.key, key,
1011 sizeof(buf.key) + sizeof(buf.tx_mic) + sizeof(buf.rx_mic));
1013 if (rsc_len > sizeof(buf.rsc))
1014 rsc_len = sizeof(buf.rsc);
1016 if (tsc_len > sizeof(buf.tsc))
1017 tsc_len = sizeof(buf.tsc);
1019 memset(buf.rsc, 0, sizeof(buf.rsc));
1020 memset(buf.tsc, 0, sizeof(buf.tsc));
1023 memcpy(buf.rsc, rsc, rsc_len);
1026 memcpy(buf.tsc, tsc, tsc_len);
1030 /* Wait upto 100ms for tx queue to empty */
1031 for (k = 100; k > 0; k--) {
1033 ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
1035 if (ret || !xmitting)
1042 err = HERMES_WRITE_RECORD(hw, USER_BAP,
1043 HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE,
1046 return ret ? ret : err;
1049 int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx)
1051 hermes_t *hw = &priv->hw;
1054 err = hermes_write_wordrec(hw, USER_BAP,
1055 HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE,
1058 printk(KERN_WARNING "%s: Error %d clearing TKIP key %d\n",
1059 priv->ndev->name, err, key_idx);
1063 int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
1064 struct net_device *dev,
1065 int mc_count, int promisc)
1067 hermes_t *hw = &priv->hw;
1070 if (promisc != priv->promiscuous) {
1071 err = hermes_write_wordrec(hw, USER_BAP,
1072 HERMES_RID_CNFPROMISCUOUSMODE,
1075 printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
1076 priv->ndev->name, err);
1078 priv->promiscuous = promisc;
1081 /* If we're not in promiscuous mode, then we need to set the
1082 * group address if either we want to multicast, or if we were
1083 * multicasting and want to stop */
1084 if (!promisc && (mc_count || priv->mc_count)) {
1085 struct netdev_hw_addr *ha;
1086 struct hermes_multicast mclist;
1089 netdev_for_each_mc_addr(ha, dev) {
1092 memcpy(mclist.addr[i++], ha->addr, ETH_ALEN);
1095 err = hermes_write_ltv(hw, USER_BAP,
1096 HERMES_RID_CNFGROUPADDRESSES,
1097 HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
1100 printk(KERN_ERR "%s: Error %d setting multicast list.\n",
1101 priv->ndev->name, err);
1103 priv->mc_count = mc_count;
1108 /* Return : < 0 -> error code ; >= 0 -> length */
1109 int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
1110 char buf[IW_ESSID_MAX_SIZE+1])
1112 hermes_t *hw = &priv->hw;
1114 struct hermes_idstring essidbuf;
1115 char *p = (char *)(&essidbuf.val);
1117 unsigned long flags;
1119 if (orinoco_lock(priv, &flags) != 0)
1122 if (strlen(priv->desired_essid) > 0) {
1123 /* We read the desired SSID from the hardware rather
1124 than from priv->desired_essid, just in case the
1125 firmware is allowed to change it on us. I'm not
1127 /* My guess is that the OWNSSID should always be whatever
1128 * we set to the card, whereas CURRENT_SSID is the one that
1129 * may change... - Jean II */
1134 rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
1135 HERMES_RID_CNFDESIREDSSID;
1137 err = hermes_read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
1144 err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
1145 sizeof(essidbuf), NULL, &essidbuf);
1150 len = le16_to_cpu(essidbuf.len);
1151 BUG_ON(len > IW_ESSID_MAX_SIZE);
1153 memset(buf, 0, IW_ESSID_MAX_SIZE);
1154 memcpy(buf, p, len);
1158 orinoco_unlock(priv, &flags);
1163 int orinoco_hw_get_freq(struct orinoco_private *priv)
1165 hermes_t *hw = &priv->hw;
1169 unsigned long flags;
1171 if (orinoco_lock(priv, &flags) != 0)
1174 err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL,
1179 /* Intersil firmware 1.3.5 returns 0 when the interface is down */
1185 if ((channel < 1) || (channel > NUM_CHANNELS)) {
1186 printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
1187 priv->ndev->name, channel);
1192 freq = ieee80211_dsss_chan_to_freq(channel);
1195 orinoco_unlock(priv, &flags);
1199 return err ? err : freq;
1202 int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
1203 int *numrates, s32 *rates, int max)
1205 hermes_t *hw = &priv->hw;
1206 struct hermes_idstring list;
1207 unsigned char *p = (unsigned char *)&list.val;
1211 unsigned long flags;
1213 if (orinoco_lock(priv, &flags) != 0)
1216 err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
1217 sizeof(list), NULL, &list);
1218 orinoco_unlock(priv, &flags);
1223 num = le16_to_cpu(list.len);
1225 num = min(num, max);
1227 for (i = 0; i < num; i++)
1228 rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */
1233 int orinoco_hw_trigger_scan(struct orinoco_private *priv,
1234 const struct cfg80211_ssid *ssid)
1236 struct net_device *dev = priv->ndev;
1237 hermes_t *hw = &priv->hw;
1238 unsigned long flags;
1241 if (orinoco_lock(priv, &flags) != 0)
1244 /* Scanning with port 0 disabled would fail */
1245 if (!netif_running(dev)) {
1250 /* In monitor mode, the scan results are always empty.
1251 * Probe responses are passed to the driver as received
1252 * frames and could be processed in software. */
1253 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
1258 if (priv->has_hostscan) {
1259 switch (priv->firmware_type) {
1260 case FIRMWARE_TYPE_SYMBOL:
1261 err = hermes_write_wordrec(hw, USER_BAP,
1262 HERMES_RID_CNFHOSTSCAN_SYMBOL,
1263 HERMES_HOSTSCAN_SYMBOL_ONCE |
1264 HERMES_HOSTSCAN_SYMBOL_BCAST);
1266 case FIRMWARE_TYPE_INTERSIL: {
1269 req[0] = cpu_to_le16(0x3fff); /* All channels */
1270 req[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */
1271 req[2] = 0; /* Any ESSID */
1272 err = HERMES_WRITE_RECORD(hw, USER_BAP,
1273 HERMES_RID_CNFHOSTSCAN, &req);
1276 case FIRMWARE_TYPE_AGERE:
1277 if (ssid->ssid_len > 0) {
1278 struct hermes_idstring idbuf;
1279 size_t len = ssid->ssid_len;
1281 idbuf.len = cpu_to_le16(len);
1282 memcpy(idbuf.val, ssid->ssid, len);
1284 err = hermes_write_ltv(hw, USER_BAP,
1285 HERMES_RID_CNFSCANSSID_AGERE,
1286 HERMES_BYTES_TO_RECLEN(len + 2),
1289 err = hermes_write_wordrec(hw, USER_BAP,
1290 HERMES_RID_CNFSCANSSID_AGERE,
1295 if (priv->has_ext_scan) {
1296 err = hermes_write_wordrec(hw, USER_BAP,
1297 HERMES_RID_CNFSCANCHANNELS2GHZ,
1302 err = hermes_inquire(hw,
1303 HERMES_INQ_CHANNELINFO);
1305 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1310 err = hermes_inquire(hw, HERMES_INQ_SCAN);
1313 orinoco_unlock(priv, &flags);
1318 /* Disassociate from node with BSSID addr */
1319 int orinoco_hw_disassociate(struct orinoco_private *priv,
1320 u8 *addr, u16 reason_code)
1322 hermes_t *hw = &priv->hw;
1328 } __attribute__ ((packed)) buf;
1330 /* Currently only supported by WPA enabled Agere fw */
1334 memcpy(buf.addr, addr, ETH_ALEN);
1335 buf.reason_code = cpu_to_le16(reason_code);
1336 err = HERMES_WRITE_RECORD(hw, USER_BAP,
1337 HERMES_RID_CNFDISASSOCIATE,
1342 int orinoco_hw_get_current_bssid(struct orinoco_private *priv,
1345 hermes_t *hw = &priv->hw;
1348 err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
1349 ETH_ALEN, NULL, addr);