[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / orinoco / hw.c

/* Encapsulate basic setting changes and retrieval on Hermes hardware
 *
 * See copyright notice in main.c
 */
#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/ieee80211.h>
#include <linux/wireless.h>

#include "hermes.h"
#include "hermes_rid.h"
#include "orinoco.h"

#include "hw.h"

/********************************************************************/
/* Data tables                                                      */
/********************************************************************/

/* This tables gives the actual meanings of the bitrate IDs returned
 * by the firmware. */
static const struct {
	int bitrate; /* in 100s of kilobits */
	int automatic;
	u16 agere_txratectrl;
	u16 intersil_txratectrl;
} bitrate_table[] = {
	{110, 1,  3, 15}, /* Entry 0 is the default */
	{10,  0,  1,  1},
	{10,  1,  1,  1},
	{20,  0,  2,  2},
	{20,  1,  6,  3},
	{55,  0,  4,  4},
	{55,  1,  7,  7},
	{110, 0,  5,  8},
};
#define BITRATE_TABLE_SIZE ARRAY_SIZE(bitrate_table)

int orinoco_get_bitratemode(int bitrate, int automatic)
{
	int ratemode = -1;
	int i;

	if ((bitrate != 10) && (bitrate != 20) &&
	    (bitrate != 55) && (bitrate != 110))
		return ratemode;

	for (i = 0; i < BITRATE_TABLE_SIZE; i++) {
		if ((bitrate_table[i].bitrate == bitrate) &&
		    (bitrate_table[i].automatic == automatic)) {
			ratemode = i;
			break;
		}
	}
	return ratemode;
}

void orinoco_get_ratemode_cfg(int ratemode, int *bitrate, int *automatic)
{
	BUG_ON((ratemode < 0) || (ratemode >= BITRATE_TABLE_SIZE));

	*bitrate = bitrate_table[ratemode].bitrate * 100000;
	*automatic = bitrate_table[ratemode].automatic;
}

/* Get tsc from the firmware */
int orinoco_hw_get_tkip_iv(struct orinoco_private *priv, int key, u8 *tsc)
{
	hermes_t *hw = &priv->hw;
	int err = 0;
	u8 tsc_arr[4][IW_ENCODE_SEQ_MAX_SIZE];

	if ((key < 0) || (key > 4))
		return -EINVAL;

	err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_TKIP_IV,
			      sizeof(tsc_arr), NULL, &tsc_arr);
	if (!err)
		memcpy(tsc, &tsc_arr[key][0], sizeof(tsc_arr[0]));

	return err;
}

int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
{
	hermes_t *hw = &priv->hw;
	int ratemode = priv->bitratemode;
	int err = 0;

	if (ratemode >= BITRATE_TABLE_SIZE) {
		printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
		       priv->ndev->name, ratemode);
		return -EINVAL;
	}

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE:
		err = hermes_write_wordrec(hw, USER_BAP,
				HERMES_RID_CNFTXRATECONTROL,
				bitrate_table[ratemode].agere_txratectrl);
		break;
	case FIRMWARE_TYPE_INTERSIL:
	case FIRMWARE_TYPE_SYMBOL:
		err = hermes_write_wordrec(hw, USER_BAP,
				HERMES_RID_CNFTXRATECONTROL,
				bitrate_table[ratemode].intersil_txratectrl);
		break;
	default:
		BUG();
	}

	return err;
}

int orinoco_hw_get_act_bitrate(struct orinoco_private *priv, int *bitrate)
{
	hermes_t *hw = &priv->hw;
	int i;
	int err = 0;
	u16 val;

	err = hermes_read_wordrec(hw, USER_BAP,
				  HERMES_RID_CURRENTTXRATE, &val);
	if (err)
		return err;

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
		/* Note : in Lucent firmware, the return value of
		 * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
		 * and therefore is totally different from the
		 * encoding of HERMES_RID_CNFTXRATECONTROL.
		 * Don't forget that 6Mb/s is really 5.5Mb/s */
		if (val == 6)
			*bitrate = 5500000;
		else
			*bitrate = val * 1000000;
		break;
	case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
	case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
		for (i = 0; i < BITRATE_TABLE_SIZE; i++)
			if (bitrate_table[i].intersil_txratectrl == val)
				break;

		if (i >= BITRATE_TABLE_SIZE)
			printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
			       priv->ndev->name, val);

		*bitrate = bitrate_table[i].bitrate * 100000;
		break;
	default:
		BUG();
	}

	return err;
}

/* Set fixed AP address */
int __orinoco_hw_set_wap(struct orinoco_private *priv)
{
	int roaming_flag;
	int err = 0;
	hermes_t *hw = &priv->hw;

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE:
		/* not supported */
		break;
	case FIRMWARE_TYPE_INTERSIL:
		if (priv->bssid_fixed)
			roaming_flag = 2;
		else
			roaming_flag = 1;

		err = hermes_write_wordrec(hw, USER_BAP,
					   HERMES_RID_CNFROAMINGMODE,
					   roaming_flag);
		break;
	case FIRMWARE_TYPE_SYMBOL:
		err = HERMES_WRITE_RECORD(hw, USER_BAP,
					  HERMES_RID_CNFMANDATORYBSSID_SYMBOL,
					  &priv->desired_bssid);
		break;
	}
	return err;
}

/* Change the WEP keys and/or the current keys.  Can be called
 * either from __orinoco_hw_setup_enc() or directly from
 * orinoco_ioctl_setiwencode().  In the later case the association
 * with the AP is not broken (if the firmware can handle it),
 * which is needed for 802.1x implementations. */
int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv)
{
	hermes_t *hw = &priv->hw;
	int err = 0;

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE:
		err = HERMES_WRITE_RECORD(hw, USER_BAP,
					  HERMES_RID_CNFWEPKEYS_AGERE,
					  &priv->keys);
		if (err)
			return err;
		err = hermes_write_wordrec(hw, USER_BAP,
					   HERMES_RID_CNFTXKEY_AGERE,
					   priv->tx_key);
		if (err)
			return err;
		break;
	case FIRMWARE_TYPE_INTERSIL:
	case FIRMWARE_TYPE_SYMBOL:
		{
			int keylen;
			int i;

			/* Force uniform key length to work around
			 * firmware bugs */
			keylen = le16_to_cpu(priv->keys[priv->tx_key].len);

			if (keylen > LARGE_KEY_SIZE) {
				printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
				       priv->ndev->name, priv->tx_key, keylen);
				return -E2BIG;
			}

			/* Write all 4 keys */
			for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
				err = hermes_write_ltv(hw, USER_BAP,
						HERMES_RID_CNFDEFAULTKEY0 + i,
						HERMES_BYTES_TO_RECLEN(keylen),
						priv->keys[i].data);
				if (err)
					return err;
			}

			/* Write the index of the key used in transmission */
			err = hermes_write_wordrec(hw, USER_BAP,
						HERMES_RID_CNFWEPDEFAULTKEYID,
						priv->tx_key);
			if (err)
				return err;
		}
		break;
	}

	return 0;
}

int __orinoco_hw_setup_enc(struct orinoco_private *priv)
{
	hermes_t *hw = &priv->hw;
	int err = 0;
	int master_wep_flag;
	int auth_flag;
	int enc_flag;

	/* Setup WEP keys for WEP and WPA */
	if (priv->encode_alg)
		__orinoco_hw_setup_wepkeys(priv);

	if (priv->wep_restrict)
		auth_flag = HERMES_AUTH_SHARED_KEY;
	else
		auth_flag = HERMES_AUTH_OPEN;

	if (priv->wpa_enabled)
		enc_flag = 2;
	else if (priv->encode_alg == IW_ENCODE_ALG_WEP)
		enc_flag = 1;
	else
		enc_flag = 0;

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
		if (priv->encode_alg == IW_ENCODE_ALG_WEP) {
			/* Enable the shared-key authentication. */
			err = hermes_write_wordrec(hw, USER_BAP,
					HERMES_RID_CNFAUTHENTICATION_AGERE,
					auth_flag);
		}
		err = hermes_write_wordrec(hw, USER_BAP,
					   HERMES_RID_CNFWEPENABLED_AGERE,
					   enc_flag);
		if (err)
			return err;

		if (priv->has_wpa) {
			/* Set WPA key management */
			err = hermes_write_wordrec(hw, USER_BAP,
				  HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE,
				  priv->key_mgmt);
			if (err)
				return err;
		}

		break;

	case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
	case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
		if (priv->encode_alg == IW_ENCODE_ALG_WEP) {
			if (priv->wep_restrict ||
			    (priv->firmware_type == FIRMWARE_TYPE_SYMBOL))
				master_wep_flag = HERMES_WEP_PRIVACY_INVOKED |
						  HERMES_WEP_EXCL_UNENCRYPTED;
			else
				master_wep_flag = HERMES_WEP_PRIVACY_INVOKED;

			err = hermes_write_wordrec(hw, USER_BAP,
						   HERMES_RID_CNFAUTHENTICATION,
						   auth_flag);
			if (err)
				return err;
		} else
			master_wep_flag = 0;

		if (priv->iw_mode == IW_MODE_MONITOR)
			master_wep_flag |= HERMES_WEP_HOST_DECRYPT;

		/* Master WEP setting : on/off */
		err = hermes_write_wordrec(hw, USER_BAP,
					   HERMES_RID_CNFWEPFLAGS_INTERSIL,
					   master_wep_flag);
		if (err)
			return err;

		break;
	}

	return 0;
}

/* key must be 32 bytes, including the tx and rx MIC keys.
 * rsc must be 8 bytes
 * tsc must be 8 bytes or NULL
 */
int __orinoco_hw_set_tkip_key(hermes_t *hw, int key_idx, int set_tx,
			      u8 *key, u8 *rsc, u8 *tsc)
{
	struct {
		__le16 idx;
		u8 rsc[IW_ENCODE_SEQ_MAX_SIZE];
		u8 key[TKIP_KEYLEN];
		u8 tx_mic[MIC_KEYLEN];
		u8 rx_mic[MIC_KEYLEN];
		u8 tsc[IW_ENCODE_SEQ_MAX_SIZE];
	} __attribute__ ((packed)) buf;
	int ret;
	int err;
	int k;
	u16 xmitting;

	key_idx &= 0x3;

	if (set_tx)
		key_idx |= 0x8000;

	buf.idx = cpu_to_le16(key_idx);
	memcpy(buf.key, key,
	       sizeof(buf.key) + sizeof(buf.tx_mic) + sizeof(buf.rx_mic));

	if (rsc == NULL)
		memset(buf.rsc, 0, sizeof(buf.rsc));
	else
		memcpy(buf.rsc, rsc, sizeof(buf.rsc));

	if (tsc == NULL) {
		memset(buf.tsc, 0, sizeof(buf.tsc));
		buf.tsc[4] = 0x10;
	} else {
		memcpy(buf.tsc, tsc, sizeof(buf.tsc));
	}

	/* Wait upto 100ms for tx queue to empty */
	for (k = 100; k > 0; k--) {
		udelay(1000);
		ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
					  &xmitting);
		if (ret || !xmitting)
			break;
	}

	if (k == 0)
		ret = -ETIMEDOUT;

	err = HERMES_WRITE_RECORD(hw, USER_BAP,
				  HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE,
				  &buf);

	return ret ? ret : err;
}

int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx)
{
	hermes_t *hw = &priv->hw;
	int err;

	memset(&priv->tkip_key[key_idx], 0, sizeof(priv->tkip_key[key_idx]));
	err = hermes_write_wordrec(hw, USER_BAP,
				   HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE,
				   key_idx);
	if (err)
		printk(KERN_WARNING "%s: Error %d clearing TKIP key %d\n",
		       priv->ndev->name, err, key_idx);
	return err;
}

int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
				    struct dev_addr_list *mc_list,
				    int mc_count, int promisc)
{
	hermes_t *hw = &priv->hw;
	int err = 0;

	if (promisc != priv->promiscuous) {
		err = hermes_write_wordrec(hw, USER_BAP,
					   HERMES_RID_CNFPROMISCUOUSMODE,
					   promisc);
		if (err) {
			printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
			       priv->ndev->name, err);
		} else
			priv->promiscuous = promisc;
	}

	/* If we're not in promiscuous mode, then we need to set the
	 * group address if either we want to multicast, or if we were
	 * multicasting and want to stop */
	if (!promisc && (mc_count || priv->mc_count)) {
		struct dev_mc_list *p = mc_list;
		struct hermes_multicast mclist;
		int i;

		for (i = 0; i < mc_count; i++) {
			/* paranoia: is list shorter than mc_count? */
			BUG_ON(!p);
			/* paranoia: bad address size in list? */
			BUG_ON(p->dmi_addrlen != ETH_ALEN);

			memcpy(mclist.addr[i], p->dmi_addr, ETH_ALEN);
			p = p->next;
		}

		if (p)
			printk(KERN_WARNING "%s: Multicast list is "
			       "longer than mc_count\n", priv->ndev->name);

		err = hermes_write_ltv(hw, USER_BAP,
				   HERMES_RID_CNFGROUPADDRESSES,
				   HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
				   &mclist);
		if (err)
			printk(KERN_ERR "%s: Error %d setting multicast list.\n",
			       priv->ndev->name, err);
		else
			priv->mc_count = mc_count;
	}
	return err;
}

/* Return : < 0 -> error code ; >= 0 -> length */
int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
			 char buf[IW_ESSID_MAX_SIZE+1])
{
	hermes_t *hw = &priv->hw;
	int err = 0;
	struct hermes_idstring essidbuf;
	char *p = (char *)(&essidbuf.val);
	int len;
	unsigned long flags;

	if (orinoco_lock(priv, &flags) != 0)
		return -EBUSY;

	if (strlen(priv->desired_essid) > 0) {
		/* We read the desired SSID from the hardware rather
		   than from priv->desired_essid, just in case the
		   firmware is allowed to change it on us. I'm not
		   sure about this */
		/* My guess is that the OWNSSID should always be whatever
		 * we set to the card, whereas CURRENT_SSID is the one that
		 * may change... - Jean II */
		u16 rid;

		*active = 1;

		rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
			HERMES_RID_CNFDESIREDSSID;

		err = hermes_read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
				      NULL, &essidbuf);
		if (err)
			goto fail_unlock;
	} else {
		*active = 0;

		err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
				      sizeof(essidbuf), NULL, &essidbuf);
		if (err)
			goto fail_unlock;
	}

	len = le16_to_cpu(essidbuf.len);
	BUG_ON(len > IW_ESSID_MAX_SIZE);

	memset(buf, 0, IW_ESSID_MAX_SIZE);
	memcpy(buf, p, len);
	err = len;

 fail_unlock:
	orinoco_unlock(priv, &flags);

	return err;
}

int orinoco_hw_get_freq(struct orinoco_private *priv)
{
	hermes_t *hw = &priv->hw;
	int err = 0;
	u16 channel;
	int freq = 0;
	unsigned long flags;

	if (orinoco_lock(priv, &flags) != 0)
		return -EBUSY;

	err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL,
				  &channel);
	if (err)
		goto out;

	/* Intersil firmware 1.3.5 returns 0 when the interface is down */
	if (channel == 0) {
		err = -EBUSY;
		goto out;
	}

	if ((channel < 1) || (channel > NUM_CHANNELS)) {
		printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
		       priv->ndev->name, channel);
		err = -EBUSY;
		goto out;

	}
	freq = ieee80211_dsss_chan_to_freq(channel);

 out:
	orinoco_unlock(priv, &flags);

	if (err > 0)
		err = -EBUSY;
	return err ? err : freq;
}

int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
			       int *numrates, s32 *rates, int max)
{
	hermes_t *hw = &priv->hw;
	struct hermes_idstring list;
	unsigned char *p = (unsigned char *)&list.val;
	int err = 0;
	int num;
	int i;
	unsigned long flags;

	if (orinoco_lock(priv, &flags) != 0)
		return -EBUSY;

	err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
			      sizeof(list), NULL, &list);
	orinoco_unlock(priv, &flags);

	if (err)
		return err;

	num = le16_to_cpu(list.len);
	*numrates = num;
	num = min(num, max);

	for (i = 0; i < num; i++)
		rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */

	return 0;
}
Commit	Line	Data
712a4342 DK	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/if_arp.h>
	7	#include <linux/ieee80211.h>
	8	#include <linux/wireless.h>
	9
	10	#include "hermes.h"
	11	#include "hermes_rid.h"
	12	#include "orinoco.h"
	13
	14	#include "hw.h"
	15
	16	/********************************************************************/
	17	/* Data tables */
	18	/********************************************************************/
	19
	20	/* This tables gives the actual meanings of the bitrate IDs returned
	21	* by the firmware. */
	22	static const struct {
	23	int bitrate; /* in 100s of kilobits */
	24	int automatic;
	25	u16 agere_txratectrl;
	26	u16 intersil_txratectrl;
	27	} bitrate_table[] = {
	28	{110, 1, 3, 15}, /* Entry 0 is the default */
	29	{10, 0, 1, 1},
	30	{10, 1, 1, 1},
	31	{20, 0, 2, 2},
	32	{20, 1, 6, 3},
	33	{55, 0, 4, 4},
	34	{55, 1, 7, 7},
	35	{110, 0, 5, 8},
	36	};
	37	#define BITRATE_TABLE_SIZE ARRAY_SIZE(bitrate_table)
	38
	39	int orinoco_get_bitratemode(int bitrate, int automatic)
	40	{
	41	int ratemode = -1;
	42	int i;
	43
	44	if ((bitrate != 10) && (bitrate != 20) &&
	45	(bitrate != 55) && (bitrate != 110))
	46	return ratemode;
	47
	48	for (i = 0; i < BITRATE_TABLE_SIZE; i++) {
	49	if ((bitrate_table[i].bitrate == bitrate) &&
	50	(bitrate_table[i].automatic == automatic)) {
	51	ratemode = i;
	52	break;
	53	}
	54	}
	55	return ratemode;
	56	}
	57
	58	void orinoco_get_ratemode_cfg(int ratemode, int bitrate, int automatic)
	59	{
	60	BUG_ON((ratemode < 0) \|\| (ratemode >= BITRATE_TABLE_SIZE));
	61
	62	bitrate = bitrate_table[ratemode].bitrate 100000;
	63	*automatic = bitrate_table[ratemode].automatic;
	64	}
65
66	/* Get tsc from the firmware */
67	int orinoco_hw_get_tkip_iv(struct orinoco_private priv, int key, u8 tsc)
68	{
69	hermes_t *hw = &priv->hw;
70	int err = 0;
71	u8 tsc_arr[4][IW_ENCODE_SEQ_MAX_SIZE];
72
73	if ((key < 0) \|\| (key > 4))
74	return -EINVAL;
75
76	err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_TKIP_IV,
77	sizeof(tsc_arr), NULL, &tsc_arr);
78	if (!err)
79	memcpy(tsc, &tsc_arr[key][0], sizeof(tsc_arr[0]));
80
81	return err;
82	}
83
84	int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
85	{
86	hermes_t *hw = &priv->hw;
87	int ratemode = priv->bitratemode;
88	int err = 0;
89
90	if (ratemode >= BITRATE_TABLE_SIZE) {
91	printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
92	priv->ndev->name, ratemode);
93	return -EINVAL;
94	}
95
96	switch (priv->firmware_type) {
97	case FIRMWARE_TYPE_AGERE:
98	err = hermes_write_wordrec(hw, USER_BAP,
99	HERMES_RID_CNFTXRATECONTROL,
100	bitrate_table[ratemode].agere_txratectrl);
101	break;
102	case FIRMWARE_TYPE_INTERSIL:
103	case FIRMWARE_TYPE_SYMBOL:
104	err = hermes_write_wordrec(hw, USER_BAP,
105	HERMES_RID_CNFTXRATECONTROL,
106	bitrate_table[ratemode].intersil_txratectrl);
107	break;
108	default:
109	BUG();
110	}
111
112	return err;
113	}
114
115	int orinoco_hw_get_act_bitrate(struct orinoco_private priv, int bitrate)
116	{
117	hermes_t *hw = &priv->hw;
118	int i;
119	int err = 0;
120	u16 val;
121
122	err = hermes_read_wordrec(hw, USER_BAP,
123	HERMES_RID_CURRENTTXRATE, &val);
124	if (err)
125	return err;
126
127	switch (priv->firmware_type) {
128	case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
129	/* Note : in Lucent firmware, the return value of
130	* HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
131	* and therefore is totally different from the
132	* encoding of HERMES_RID_CNFTXRATECONTROL.
133	* Don't forget that 6Mb/s is really 5.5Mb/s */
134	if (val == 6)
135	*bitrate = 5500000;
136	else
137	bitrate = val 1000000;
138	break;
139	case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
140	case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
141	for (i = 0; i < BITRATE_TABLE_SIZE; i++)
142	if (bitrate_table[i].intersil_txratectrl == val)
143	break;
144
145	if (i >= BITRATE_TABLE_SIZE)
146	printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
147	priv->ndev->name, val);
148
149	bitrate = bitrate_table[i].bitrate 100000;
150	break;
151	default:
152	BUG();
153	}
154
155	return err;
156	}
157
158	/* Set fixed AP address */
159	int __orinoco_hw_set_wap(struct orinoco_private *priv)
160	{
161	int roaming_flag;
162	int err = 0;
163	hermes_t *hw = &priv->hw;
164
165	switch (priv->firmware_type) {
166	case FIRMWARE_TYPE_AGERE:
167	/* not supported */
168	break;
169	case FIRMWARE_TYPE_INTERSIL:
170	if (priv->bssid_fixed)
171	roaming_flag = 2;
172	else
173	roaming_flag = 1;
174
175	err = hermes_write_wordrec(hw, USER_BAP,
176	HERMES_RID_CNFROAMINGMODE,
177	roaming_flag);
178	break;
179	case FIRMWARE_TYPE_SYMBOL:
180	err = HERMES_WRITE_RECORD(hw, USER_BAP,
181	HERMES_RID_CNFMANDATORYBSSID_SYMBOL,
182	&priv->desired_bssid);
183	break;
184	}
185	return err;
186	}
187
188	/* Change the WEP keys and/or the current keys. Can be called
189	* either from __orinoco_hw_setup_enc() or directly from
190	* orinoco_ioctl_setiwencode(). In the later case the association
191	* with the AP is not broken (if the firmware can handle it),
192	* which is needed for 802.1x implementations. */
193	int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv)
194	{
195	hermes_t *hw = &priv->hw;
196	int err = 0;
197
198	switch (priv->firmware_type) {
199	case FIRMWARE_TYPE_AGERE:
200	err = HERMES_WRITE_RECORD(hw, USER_BAP,
201	HERMES_RID_CNFWEPKEYS_AGERE,
202	&priv->keys);
203	if (err)
204	return err;
205	err = hermes_write_wordrec(hw, USER_BAP,
206	HERMES_RID_CNFTXKEY_AGERE,
207	priv->tx_key);
208	if (err)
209	return err;
210	break;
211	case FIRMWARE_TYPE_INTERSIL:
212	case FIRMWARE_TYPE_SYMBOL:
213	{
214	int keylen;
215	int i;
216
217	/* Force uniform key length to work around
218	* firmware bugs */
219	keylen = le16_to_cpu(priv->keys[priv->tx_key].len);
220
221	if (keylen > LARGE_KEY_SIZE) {
222	printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
223	priv->ndev->name, priv->tx_key, keylen);
224	return -E2BIG;
225	}
226
227	/* Write all 4 keys */
228	for (i = 0; i < ORINOCO_MAX_KEYS; i++) {
229	err = hermes_write_ltv(hw, USER_BAP,
230	HERMES_RID_CNFDEFAULTKEY0 + i,
231	HERMES_BYTES_TO_RECLEN(keylen),
232	priv->keys[i].data);
233	if (err)
234	return err;
235	}
236
237	/* Write the index of the key used in transmission */
238	err = hermes_write_wordrec(hw, USER_BAP,
239	HERMES_RID_CNFWEPDEFAULTKEYID,
240	priv->tx_key);
241	if (err)
242	return err;
243	}
244	break;
245	}
246
247	return 0;
248	}
249
250	int __orinoco_hw_setup_enc(struct orinoco_private *priv)
251	{
252	hermes_t *hw = &priv->hw;
253	int err = 0;
254	int master_wep_flag;
255	int auth_flag;
256	int enc_flag;
257
258	/* Setup WEP keys for WEP and WPA */
259	if (priv->encode_alg)
260	__orinoco_hw_setup_wepkeys(priv);
261
262	if (priv->wep_restrict)
263	auth_flag = HERMES_AUTH_SHARED_KEY;
264	else
265	auth_flag = HERMES_AUTH_OPEN;
266
267	if (priv->wpa_enabled)
268	enc_flag = 2;
269	else if (priv->encode_alg == IW_ENCODE_ALG_WEP)
270	enc_flag = 1;
271	else
272	enc_flag = 0;
273
274	switch (priv->firmware_type) {
275	case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
276	if (priv->encode_alg == IW_ENCODE_ALG_WEP) {
277	/* Enable the shared-key authentication. */
278	err = hermes_write_wordrec(hw, USER_BAP,
279	HERMES_RID_CNFAUTHENTICATION_AGERE,
280	auth_flag);
281	}
282	err = hermes_write_wordrec(hw, USER_BAP,
283	HERMES_RID_CNFWEPENABLED_AGERE,
284	enc_flag);
285	if (err)
286	return err;
287
288	if (priv->has_wpa) {
289	/* Set WPA key management */
290	err = hermes_write_wordrec(hw, USER_BAP,
291	HERMES_RID_CNFSETWPAAUTHMGMTSUITE_AGERE,
292	priv->key_mgmt);
293	if (err)
294	return err;
295	}
296
297	break;
298
299	case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
300	case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
301	if (priv->encode_alg == IW_ENCODE_ALG_WEP) {
302	if (priv->wep_restrict \|\|
303	(priv->firmware_type == FIRMWARE_TYPE_SYMBOL))
304	master_wep_flag = HERMES_WEP_PRIVACY_INVOKED \|
305	HERMES_WEP_EXCL_UNENCRYPTED;
306	else
307	master_wep_flag = HERMES_WEP_PRIVACY_INVOKED;
308
309	err = hermes_write_wordrec(hw, USER_BAP,
310	HERMES_RID_CNFAUTHENTICATION,
311	auth_flag);
312	if (err)
313	return err;
314	} else
315	master_wep_flag = 0;
316
317	if (priv->iw_mode == IW_MODE_MONITOR)
318	master_wep_flag \|= HERMES_WEP_HOST_DECRYPT;
319
320	/* Master WEP setting : on/off */
321	err = hermes_write_wordrec(hw, USER_BAP,
322	HERMES_RID_CNFWEPFLAGS_INTERSIL,
323	master_wep_flag);
324	if (err)
325	return err;
326
327	break;
328	}
329
330	return 0;
331	}
332
333	/* key must be 32 bytes, including the tx and rx MIC keys.
334	* rsc must be 8 bytes
335	* tsc must be 8 bytes or NULL
336	*/
337	int __orinoco_hw_set_tkip_key(hermes_t *hw, int key_idx, int set_tx,
338	u8 key, u8 rsc, u8 *tsc)
339	{
340	struct {
341	__le16 idx;
342	u8 rsc[IW_ENCODE_SEQ_MAX_SIZE];
343	u8 key[TKIP_KEYLEN];
344	u8 tx_mic[MIC_KEYLEN];
345	u8 rx_mic[MIC_KEYLEN];
346	u8 tsc[IW_ENCODE_SEQ_MAX_SIZE];
347	} __attribute__ ((packed)) buf;
348	int ret;
349	int err;
350	int k;
351	u16 xmitting;
352
353	key_idx &= 0x3;
354
355	if (set_tx)
356	key_idx \|= 0x8000;
357
358	buf.idx = cpu_to_le16(key_idx);
359	memcpy(buf.key, key,
360	sizeof(buf.key) + sizeof(buf.tx_mic) + sizeof(buf.rx_mic));
361
362	if (rsc == NULL)
363	memset(buf.rsc, 0, sizeof(buf.rsc));
364	else
365	memcpy(buf.rsc, rsc, sizeof(buf.rsc));
366
367	if (tsc == NULL) {
368	memset(buf.tsc, 0, sizeof(buf.tsc));
369	buf.tsc[4] = 0x10;
370	} else {
371	memcpy(buf.tsc, tsc, sizeof(buf.tsc));
372	}
373
374	/* Wait upto 100ms for tx queue to empty */
91fe9ca7	375	for (k = 100; k > 0; k--) {
712a4342 DK	376	udelay(1000);
	377	ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
	378	&xmitting);
91fe9ca7	379	if (ret \|\| !xmitting)
712a4342	380	break;
91fe9ca7	381	}
712a4342 DK	382
	383	if (k == 0)
	384	ret = -ETIMEDOUT;
	385
	386	err = HERMES_WRITE_RECORD(hw, USER_BAP,
	387	HERMES_RID_CNFADDDEFAULTTKIPKEY_AGERE,
	388	&buf);
	389
	390	return ret ? ret : err;
	391	}
	392
	393	int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx)
	394	{
	395	hermes_t *hw = &priv->hw;
	396	int err;
	397
	398	memset(&priv->tkip_key[key_idx], 0, sizeof(priv->tkip_key[key_idx]));
	399	err = hermes_write_wordrec(hw, USER_BAP,
	400	HERMES_RID_CNFREMDEFAULTTKIPKEY_AGERE,
	401	key_idx);
	402	if (err)
	403	printk(KERN_WARNING "%s: Error %d clearing TKIP key %d\n",
	404	priv->ndev->name, err, key_idx);
	405	return err;
	406	}
	407
	408	int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
	409	struct dev_addr_list *mc_list,
	410	int mc_count, int promisc)
	411	{
	412	hermes_t *hw = &priv->hw;
	413	int err = 0;
	414
	415	if (promisc != priv->promiscuous) {
	416	err = hermes_write_wordrec(hw, USER_BAP,
	417	HERMES_RID_CNFPROMISCUOUSMODE,
	418	promisc);
	419	if (err) {
	420	printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
	421	priv->ndev->name, err);
	422	} else
	423	priv->promiscuous = promisc;
	424	}
	425
	426	/* If we're not in promiscuous mode, then we need to set the
	427	* group address if either we want to multicast, or if we were
	428	* multicasting and want to stop */
	429	if (!promisc && (mc_count \|\| priv->mc_count)) {
	430	struct dev_mc_list *p = mc_list;
	431	struct hermes_multicast mclist;
	432	int i;
	433
	434	for (i = 0; i < mc_count; i++) {
	435	/* paranoia: is list shorter than mc_count? */
	436	BUG_ON(!p);
	437	/* paranoia: bad address size in list? */
	438	BUG_ON(p->dmi_addrlen != ETH_ALEN);
	439
	440	memcpy(mclist.addr[i], p->dmi_addr, ETH_ALEN);
	441	p = p->next;
	442	}
	443
	444	if (p)
	445	printk(KERN_WARNING "%s: Multicast list is "
446	"longer than mc_count\n", priv->ndev->name);
447
448	err = hermes_write_ltv(hw, USER_BAP,
449	HERMES_RID_CNFGROUPADDRESSES,
450	HERMES_BYTES_TO_RECLEN(mc_count * ETH_ALEN),
451	&mclist);
452	if (err)
453	printk(KERN_ERR "%s: Error %d setting multicast list.\n",
454	priv->ndev->name, err);
455	else
456	priv->mc_count = mc_count;
457	}
458	return err;
459	}
460
461	/* Return : < 0 -> error code ; >= 0 -> length */
462	int orinoco_hw_get_essid(struct orinoco_private priv, int active,
463	char buf[IW_ESSID_MAX_SIZE+1])
464	{
465	hermes_t *hw = &priv->hw;
466	int err = 0;
467	struct hermes_idstring essidbuf;
468	char p = (char )(&essidbuf.val);
469	int len;
470	unsigned long flags;
471
472	if (orinoco_lock(priv, &flags) != 0)
473	return -EBUSY;
474
475	if (strlen(priv->desired_essid) > 0) {
476	/* We read the desired SSID from the hardware rather
477	than from priv->desired_essid, just in case the
478	firmware is allowed to change it on us. I'm not
479	sure about this */
480	/* My guess is that the OWNSSID should always be whatever
481	* we set to the card, whereas CURRENT_SSID is the one that
482	* may change... - Jean II */
483	u16 rid;
484
485	*active = 1;
486
487	rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
488	HERMES_RID_CNFDESIREDSSID;
489
490	err = hermes_read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
491	NULL, &essidbuf);
492	if (err)
493	goto fail_unlock;
494	} else {
495	*active = 0;
496
497	err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
498	sizeof(essidbuf), NULL, &essidbuf);
499	if (err)
500	goto fail_unlock;
501	}
502
503	len = le16_to_cpu(essidbuf.len);
504	BUG_ON(len > IW_ESSID_MAX_SIZE);
505
506	memset(buf, 0, IW_ESSID_MAX_SIZE);
507	memcpy(buf, p, len);
508	err = len;
509
510	fail_unlock:
511	orinoco_unlock(priv, &flags);
512
513	return err;
514	}
515
516	int orinoco_hw_get_freq(struct orinoco_private *priv)
517	{
518	hermes_t *hw = &priv->hw;
519	int err = 0;
520	u16 channel;
521	int freq = 0;
522	unsigned long flags;
523
524	if (orinoco_lock(priv, &flags) != 0)
525	return -EBUSY;
526
527	err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL,
528	&channel);
529	if (err)
530	goto out;
531
532	/* Intersil firmware 1.3.5 returns 0 when the interface is down */
533	if (channel == 0) {
534	err = -EBUSY;
535	goto out;
536	}
537
538	if ((channel < 1) \|\| (channel > NUM_CHANNELS)) {
539	printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
540	priv->ndev->name, channel);
541	err = -EBUSY;
542	goto out;
543
544	}
545	freq = ieee80211_dsss_chan_to_freq(channel);
546
547	out:
548	orinoco_unlock(priv, &flags);
549
550	if (err > 0)
551	err = -EBUSY;
552	return err ? err : freq;
553	}
554
555	int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
556	int numrates, s32 rates, int max)
557	{
558	hermes_t *hw = &priv->hw;
559	struct hermes_idstring list;
560	unsigned char p = (unsigned char )&list.val;
561	int err = 0;
562	int num;
563	int i;
564	unsigned long flags;
565
566	if (orinoco_lock(priv, &flags) != 0)
567	return -EBUSY;
568
569	err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
570	sizeof(list), NULL, &list);
571	orinoco_unlock(priv, &flags);
572
573	if (err)
574	return err;
575
576	num = le16_to_cpu(list.len);
577	*numrates = num;
578	num = min(num, max);
579
580	for (i = 0; i < num; i++)
581	rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */
582
583	return 0;
584	}