rt2x00: Implement HW encryption (rt2500usb) (dddfb478) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/rt2x00/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -57,6 +57,7 @@ config RT2500USB
	tristate "Ralink rt2500 (USB) support"		tristate "Ralink rt2500 (USB) support"
	depends on USB		depends on USB
	select RT2X00_LIB_USB		select RT2X00_LIB_USB
			select RT2X00_LIB_CRYPTO
	---help---		---help---
	This adds support for rt2500 wireless chipset family.		This adds support for rt2500 wireless chipset family.
	Supported chips: RT2571 & RT2572.		Supported chips: RT2571 & RT2572.

drivers/net/wireless/rt2x00/rt2500usb.c

+127 −5

Original line number	Original line	Diff line number	Diff line
	@@ -35,6 +35,13 @@
	#include "rt2x00usb.h"		#include "rt2x00usb.h"
	#include "rt2500usb.h"		#include "rt2500usb.h"

			/*
			* Allow hardware encryption to be disabled.
			*/
			static int modparam_nohwcrypt = 1;
			module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
			MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");

	/*		/*
	* Register access.		* Register access.
	* All access to the CSR registers will go through the methods		* All access to the CSR registers will go through the methods
	@@ -323,6 +330,82 @@ static void rt2500usb_init_led(struct rt2x00_dev *rt2x00dev,
	/*		/*
	* Configuration handlers.		* Configuration handlers.
	*/		*/

			/*
			* rt2500usb does not differentiate between shared and pairwise
			* keys, so we should use the same function for both key types.
			*/
			static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
			struct rt2x00lib_crypto *crypto,
			struct ieee80211_key_conf *key)
			{
			int timeout;
			u32 mask;
			u16 reg;

			if (crypto->cmd == SET_KEY) {
			/*
			* Pairwise key will always be entry 0, but this
			* could collide with a shared key on the same
			* position...
			*/
			mask = TXRX_CSR0_KEY_ID.bit_mask;

			rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
			reg &= mask;

			if (reg && reg == mask)
			return -ENOSPC;

			reg = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID);

			key->hw_key_idx += reg ? ffz(reg) : 0;

			/*
			* The encryption key doesn't fit within the CSR cache,
			* this means we should allocate it seperately and use
			* rt2x00usb_vendor_request() to send the key to the hardware.
			*/
			reg = KEY_ENTRY(key->hw_key_idx);
			timeout = REGISTER_TIMEOUT32(sizeof(crypto->key));
			rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE,
			USB_VENDOR_REQUEST_OUT, reg,
			crypto->key,
			sizeof(crypto->key),
			timeout);

			/*
			* The driver does not support the IV/EIV generation
			* in hardware. However it doesn't support the IV/EIV
			* inside the ieee80211 frame either, but requires it
			* to be provided seperately for the descriptor.
			* rt2x00lib will cut the IV/EIV data out of all frames
			* given to us by mac80211, but we must tell mac80211
			* to generate the IV/EIV data.
			*/
			key->flags \|= IEEE80211_KEY_FLAG_GENERATE_IV;
			key->flags \|= IEEE80211_KEY_FLAG_GENERATE_MMIC;
			}

			/*
			* TXRX_CSR0_KEY_ID contains only single-bit fields to indicate
			* a particular key is valid.
			*/
			rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
			rt2x00_set_field16(&reg, TXRX_CSR0_ALGORITHM, crypto->cipher);
			rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER);

			mask = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID);
			if (crypto->cmd == SET_KEY)
			mask \|= 1 << key->hw_key_idx;
			else if (crypto->cmd == DISABLE_KEY)
			mask &= ~(1 << key->hw_key_idx);
			rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, mask);
			rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg);

			return 0;
			}

	static void rt2500usb_config_filter(struct rt2x00_dev *rt2x00dev,		static void rt2500usb_config_filter(struct rt2x00_dev *rt2x00dev,
	const unsigned int filter_flags)		const unsigned int filter_flags)
	{		{
	@@ -844,7 +927,7 @@ static int rt2500usb_init_registers(struct rt2x00_dev *rt2x00dev)

	rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg);		rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
	rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER);		rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER);
	rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, 0xff);		rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, 0);
	rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg);		rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg);

	rt2500usb_register_read(rt2x00dev, MAC_CSR18, &reg);		rt2500usb_register_read(rt2x00dev, MAC_CSR18, &reg);
	@@ -1066,7 +1149,7 @@ static void rt2500usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
	* Start writing the descriptor words.		* Start writing the descriptor words.
	*/		*/
	rt2x00_desc_read(txd, 1, &word);		rt2x00_desc_read(txd, 1, &word);
	rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, IEEE80211_HEADER);		rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, txdesc->iv_offset);
	rt2x00_set_field32(&word, TXD_W1_AIFS, txdesc->aifs);		rt2x00_set_field32(&word, TXD_W1_AIFS, txdesc->aifs);
	rt2x00_set_field32(&word, TXD_W1_CWMIN, txdesc->cw_min);		rt2x00_set_field32(&word, TXD_W1_CWMIN, txdesc->cw_min);
	rt2x00_set_field32(&word, TXD_W1_CWMAX, txdesc->cw_max);		rt2x00_set_field32(&word, TXD_W1_CWMAX, txdesc->cw_max);
	@@ -1079,6 +1162,11 @@ static void rt2500usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
	rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH, txdesc->length_high);		rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH, txdesc->length_high);
	rt2x00_desc_write(txd, 2, word);		rt2x00_desc_write(txd, 2, word);

			if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) {
			_rt2x00_desc_write(txd, 3, skbdesc->iv[0]);
			_rt2x00_desc_write(txd, 4, skbdesc->iv[1]);
			}

	rt2x00_desc_read(txd, 0, &word);		rt2x00_desc_read(txd, 0, &word);
	rt2x00_set_field32(&word, TXD_W0_RETRY_LIMIT, txdesc->retry_limit);		rt2x00_set_field32(&word, TXD_W0_RETRY_LIMIT, txdesc->retry_limit);
	rt2x00_set_field32(&word, TXD_W0_MORE_FRAG,		rt2x00_set_field32(&word, TXD_W0_MORE_FRAG,
	@@ -1093,7 +1181,8 @@ static void rt2500usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
	test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags));		test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags));
	rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);		rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);
	rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, skb->len);		rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, skb->len);
	rt2x00_set_field32(&word, TXD_W0_CIPHER, CIPHER_NONE);		rt2x00_set_field32(&word, TXD_W0_CIPHER, txdesc->cipher);
			rt2x00_set_field32(&word, TXD_W0_KEY_ID, txdesc->key_idx);
	rt2x00_desc_write(txd, 0, word);		rt2x00_desc_write(txd, 0, word);
	}		}

	@@ -1204,6 +1293,7 @@ static void rt2500usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
	static void rt2500usb_fill_rxdone(struct queue_entry *entry,		static void rt2500usb_fill_rxdone(struct queue_entry *entry,
	struct rxdone_entry_desc *rxdesc)		struct rxdone_entry_desc *rxdesc)
	{		{
			struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
	struct queue_entry_priv_usb *entry_priv = entry->priv_data;		struct queue_entry_priv_usb *entry_priv = entry->priv_data;
	struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);		struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
	__le32 *rxd =		__le32 *rxd =
	@@ -1231,6 +1321,31 @@ static void rt2500usb_fill_rxdone(struct queue_entry *entry,
	if (rt2x00_get_field32(word0, RXD_W0_PHYSICAL_ERROR))		if (rt2x00_get_field32(word0, RXD_W0_PHYSICAL_ERROR))
	rxdesc->flags \|= RX_FLAG_FAILED_PLCP_CRC;		rxdesc->flags \|= RX_FLAG_FAILED_PLCP_CRC;

			if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags)) {
			rxdesc->cipher = rt2x00_get_field32(word0, RXD_W0_CIPHER);
			if (rt2x00_get_field32(word0, RXD_W0_CIPHER_ERROR))
			rxdesc->cipher_status = RX_CRYPTO_FAIL_KEY;
			}

			if (rxdesc->cipher != CIPHER_NONE) {
			_rt2x00_desc_read(rxd, 2, &rxdesc->iv[0]);
			_rt2x00_desc_read(rxd, 3, &rxdesc->iv[1]);
			/* ICV is located at the end of frame */

			/*
			* Hardware has stripped IV/EIV data from 802.11 frame during
			* decryption. It has provided the data seperately but rt2x00lib
			* should decide if it should be reinserted.
			*/
			rxdesc->flags \|= RX_FLAG_IV_STRIPPED;
			if (rxdesc->cipher != CIPHER_TKIP)
			rxdesc->flags \|= RX_FLAG_MMIC_STRIPPED;
			if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
			rxdesc->flags \|= RX_FLAG_DECRYPTED;
			else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
			rxdesc->flags \|= RX_FLAG_MMIC_ERROR;
			}

	/*		/*
	* Obtain the status about this packet.		* Obtain the status about this packet.
	* When frame was received with an OFDM bitrate,		* When frame was received with an OFDM bitrate,
	@@ -1238,8 +1353,8 @@ static void rt2500usb_fill_rxdone(struct queue_entry *entry,
	* a CCK bitrate the signal is the rate in 100kbit/s.		* a CCK bitrate the signal is the rate in 100kbit/s.
	*/		*/
	rxdesc->signal = rt2x00_get_field32(word1, RXD_W1_SIGNAL);		rxdesc->signal = rt2x00_get_field32(word1, RXD_W1_SIGNAL);
	rxdesc->rssi = rt2x00_get_field32(word1, RXD_W1_RSSI) -		rxdesc->rssi =
	entry->queue->rt2x00dev->rssi_offset;		rt2x00_get_field32(word1, RXD_W1_RSSI) - rt2x00dev->rssi_offset;
	rxdesc->size = rt2x00_get_field32(word0, RXD_W0_DATABYTE_COUNT);		rxdesc->size = rt2x00_get_field32(word0, RXD_W0_DATABYTE_COUNT);

	if (rt2x00_get_field32(word0, RXD_W0_OFDM))		if (rt2x00_get_field32(word0, RXD_W0_OFDM))
	@@ -1727,6 +1842,10 @@ static int rt2500usb_probe_hw(struct rt2x00_dev *rt2x00dev)
	__set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);		__set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
	__set_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);		__set_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
	__set_bit(DRIVER_REQUIRE_SCHEDULED, &rt2x00dev->flags);		__set_bit(DRIVER_REQUIRE_SCHEDULED, &rt2x00dev->flags);
			if (!modparam_nohwcrypt) {
			__set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
			__set_bit(CONFIG_CRYPTO_COPY_IV, &rt2x00dev->flags);
			}
	__set_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags);		__set_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags);

	/*		/*
	@@ -1746,6 +1865,7 @@ static const struct ieee80211_ops rt2500usb_mac80211_ops = {
	.config = rt2x00mac_config,		.config = rt2x00mac_config,
	.config_interface = rt2x00mac_config_interface,		.config_interface = rt2x00mac_config_interface,
	.configure_filter = rt2x00mac_configure_filter,		.configure_filter = rt2x00mac_configure_filter,
			.set_key = rt2x00mac_set_key,
	.get_stats = rt2x00mac_get_stats,		.get_stats = rt2x00mac_get_stats,
	.bss_info_changed = rt2x00mac_bss_info_changed,		.bss_info_changed = rt2x00mac_bss_info_changed,
	.conf_tx = rt2x00mac_conf_tx,		.conf_tx = rt2x00mac_conf_tx,
	@@ -1767,6 +1887,8 @@ static const struct rt2x00lib_ops rt2500usb_rt2x00_ops = {
	.get_tx_data_len = rt2500usb_get_tx_data_len,		.get_tx_data_len = rt2500usb_get_tx_data_len,
	.kick_tx_queue = rt2500usb_kick_tx_queue,		.kick_tx_queue = rt2500usb_kick_tx_queue,
	.fill_rxdone = rt2500usb_fill_rxdone,		.fill_rxdone = rt2500usb_fill_rxdone,
			.config_shared_key = rt2500usb_config_key,
			.config_pairwise_key = rt2500usb_config_key,
	.config_filter = rt2500usb_config_filter,		.config_filter = rt2500usb_config_filter,
	.config_intf = rt2500usb_config_intf,		.config_intf = rt2500usb_config_intf,
	.config_erp = rt2500usb_config_erp,		.config_erp = rt2500usb_config_erp,

drivers/net/wireless/rt2x00/rt2500usb.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -447,6 +447,9 @@
	#define SEC_CSR30 0x04bc		#define SEC_CSR30 0x04bc
	#define SEC_CSR31 0x04be		#define SEC_CSR31 0x04be

			#define KEY_ENTRY(__idx) \
			( SEC_CSR0 + ((__idx) * 16) )

	/*		/*
	* PHY control registers.		* PHY control registers.
	*/		*/

drivers/net/wireless/rt2x00/rt2x00.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -653,6 +653,7 @@ enum rt2x00_flags {
	CONFIG_EXTERNAL_LNA_BG,		CONFIG_EXTERNAL_LNA_BG,
	CONFIG_DOUBLE_ANTENNA,		CONFIG_DOUBLE_ANTENNA,
	CONFIG_DISABLE_LINK_TUNING,		CONFIG_DISABLE_LINK_TUNING,
			CONFIG_CRYPTO_COPY_IV,
	};		};

	/*		/*

drivers/net/wireless/rt2x00/rt2x00crypto.c

+12 −0

Original line number	Original line	Diff line number	Diff line
	@@ -69,6 +69,18 @@ unsigned int rt2x00crypto_tx_overhead(struct ieee80211_tx_info *tx_info)
	return overhead;		return overhead;
	}		}

			void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, unsigned int iv_len)
			{
			struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
			unsigned int header_length = ieee80211_get_hdrlen_from_skb(skb);

			if (unlikely(!iv_len))
			return;

			/* Copy IV/EIV data */
			memcpy(skbdesc->iv, skb->data + header_length, iv_len);
			}

	void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, unsigned int iv_len)		void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, unsigned int iv_len)
	{		{
	struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);		struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);