orinoco: Move hardware functions into separate file (712a4342) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/net/wireless/orinoco/Makefile

+1 −1

Original line number	Diff line number	Diff line
		#
		# Makefile for the orinoco wireless device drivers.
		#
		orinoco-objs := main.o fw.o mic.o scan.o
		orinoco-objs := main.o fw.o hw.o mic.o scan.o

		obj-$(CONFIG_HERMES) += orinoco.o hermes.o hermes_dld.o
		obj-$(CONFIG_PCMCIA_HERMES) += orinoco_cs.o

drivers/net/wireless/orinoco/hw.c

0 → 100644

+586 −0

Original line number	Diff line number	Diff line
		/* 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 */
		k = 100;
		do {
		k--;
		udelay(1000);
		ret = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_TXQUEUEEMPTY,
		&xmitting);
		if (ret)
		break;
		} while ((k > 0) && xmitting);

		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;
		}

drivers/net/wireless/orinoco/hw.h

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		/* Encapsulate basic setting changes on Hermes hardware
		*
		* See copyright notice in main.c
		*/
		#ifndef _ORINOCO_HW_H_
		#define _ORINOCO_HW_H_

		#include <linux/types.h>
		#include <linux/wireless.h>

		/* Hardware BAPs */
		#define USER_BAP 0
		#define IRQ_BAP 1

		/* WEP key sizes */
		#define SMALL_KEY_SIZE 5
		#define LARGE_KEY_SIZE 13

		/* Number of supported channels */
		#define NUM_CHANNELS 14

		/* Forward declarations */
		struct orinoco_private;
		struct dev_addr_list;

		int orinoco_get_bitratemode(int bitrate, int automatic);
		void orinoco_get_ratemode_cfg(int ratemode, int bitrate, int automatic);

		int orinoco_hw_get_tkip_iv(struct orinoco_private priv, int key, u8 tsc);
		int __orinoco_hw_set_bitrate(struct orinoco_private *priv);
		int orinoco_hw_get_act_bitrate(struct orinoco_private priv, int bitrate);
		int __orinoco_hw_set_wap(struct orinoco_private *priv);
		int __orinoco_hw_setup_wepkeys(struct orinoco_private *priv);
		int __orinoco_hw_setup_enc(struct orinoco_private *priv);
		int __orinoco_hw_set_tkip_key(hermes_t *hw, int key_idx, int set_tx,
		u8 key, u8 rsc, u8 *tsc);
		int orinoco_clear_tkip_key(struct orinoco_private *priv, int key_idx);
		int __orinoco_hw_set_multicast_list(struct orinoco_private *priv,
		struct dev_addr_list *mc_list,
		int mc_count, int promisc);
		int orinoco_hw_get_essid(struct orinoco_private priv, int active,
		char buf[IW_ESSID_MAX_SIZE+1]);
		int orinoco_hw_get_freq(struct orinoco_private *priv);
		int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
		int numrates, s32 rates, int max);

		#endif /* _ORINOCO_HW_H_ */

drivers/net/wireless/orinoco/main.c

+1 −582

File changed.

Preview size limit exceeded, changes collapsed.