Commit 31595de2 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'for-davem' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next 



John W. Linville says:

====================
pull request: wireless-next 2014-06-02

Please pull this remaining batch of updates intended for the 3.16 stream...

For the mac80211 bits, Johannes says:

"The remainder for -next right now is mostly fixes, and a handful of
small new things like some CSA infrastructure, the regdb script mW/dBm
conversion change and sending wiphy notifications."

For the bluetooth bits, Gustavo says:

"Some more patches for 3.16. There is nothing really special here, just a
bunch of clean ups, fixes plus some small improvements. Please pull."

For the nfc bits, Samuel says:

"We have:

- Felica (Type3) tags support for trf7970a
- Type 4b tags support for port100
- st21nfca DTS typo fix
- A few sparse warning fixes"

For the atheros bits, Kalle says:

"Ben added support for setting antenna configurations. Michal improved
warm reset so that we would not need to fall back to cold reset that
often, an issue where ath10k stripped protected flag while in monitor
mode and made module initialisation asynchronous to fix the problems
with firmware loading when the driver is linked to the kernel.

Luca removed unused channel_switch_beacon callbacks both from ath9k and
ath10k. Marek fixed Protected Management Frames (PMF) when using Action
Frames. Also we had other small fixes everywhere in the driver."

Along with that, there are a handful of updates to a variety
of drivers.  This includes updates to at76c50x-usb, ath9k, b43,
brcmfmac, mwifiex, rsi, rtlwifi, and wil6210.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 73f156a6 fcb2c0d6

Documentation/devicetree/bindings/net/nfc/st21nfca.txt

+1 −1
Original line number Diff line number Diff line 
* STMicroelectronics SAS. ST21NFCA NFC Controller



Required properties:

- compatible: Should be "st,st21nfca-i2c".

- compatible: Should be "st,st21nfca_i2c".

- clock-frequency: I²C work frequency.

- reg: address on the bus

- interrupt-parent: phandle for the interrupt gpio controller

drivers/bluetooth/btusb.c

+154 −1
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ static struct usb_driver btusb_driver; 
#define BTUSB_WRONG_SCO_MTU	0x40

#define BTUSB_ATH3012		0x80

#define BTUSB_INTEL		0x100

#define BTUSB_BCM_PATCHRAM	0x200



static const struct usb_device_id btusb_table[] = {

	/* Generic Bluetooth USB device */
@@ -111,7 +112,8 @@ static const struct usb_device_id btusb_table[] = { 
	{ USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },



	/* Broadcom devices with vendor specific id */

	{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },

	{ USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01),

	  .driver_info = BTUSB_BCM_PATCHRAM },



	/* Belkin F8065bf - Broadcom based */

	{ USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01) },
@@ -1381,6 +1383,154 @@ exit_mfg_deactivate: 
	return 0;

}



static int btusb_setup_bcm_patchram(struct hci_dev *hdev)

{

	struct btusb_data *data = hci_get_drvdata(hdev);

	struct usb_device *udev = data->udev;

	char fw_name[64];

	const struct firmware *fw;

	const u8 *fw_ptr;

	size_t fw_size;

	const struct hci_command_hdr *cmd;

	const u8 *cmd_param;

	u16 opcode;

	struct sk_buff *skb;

	struct hci_rp_read_local_version *ver;

	long ret;



	snprintf(fw_name, sizeof(fw_name), "brcm/%s-%04x-%04x.hcd",

		 udev->product ? udev->product : "BCM",

		 le16_to_cpu(udev->descriptor.idVendor),

		 le16_to_cpu(udev->descriptor.idProduct));



	ret = request_firmware(&fw, fw_name, &hdev->dev);

	if (ret < 0) {

		BT_INFO("%s: BCM: patch %s not found", hdev->name,

			fw_name);

		return 0;

	}



	/* Reset */

	skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		BT_ERR("%s: HCI_OP_RESET failed (%ld)", hdev->name, ret);

		goto done;

	}

	kfree_skb(skb);



	/* Read Local Version Info */

	skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,

			     HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION failed (%ld)",

			hdev->name, ret);

		goto done;

	}



	if (skb->len != sizeof(*ver)) {

		BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION event length mismatch",

			hdev->name);

		kfree_skb(skb);

		ret = -EIO;

		goto done;

	}



	ver = (struct hci_rp_read_local_version *) skb->data;

	BT_INFO("%s: BCM: patching hci_ver=%02x hci_rev=%04x lmp_ver=%02x "

		"lmp_subver=%04x", hdev->name, ver->hci_ver, ver->hci_rev,

		ver->lmp_ver, ver->lmp_subver);

	kfree_skb(skb);



	/* Start Download */

	skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		BT_ERR("%s: BCM: Download Minidrv command failed (%ld)",

			hdev->name, ret);

		goto reset_fw;

	}

	kfree_skb(skb);



	/* 50 msec delay after Download Minidrv completes */

	msleep(50);



	fw_ptr = fw->data;

	fw_size = fw->size;



	while (fw_size >= sizeof(*cmd)) {

		cmd = (struct hci_command_hdr *) fw_ptr;

		fw_ptr += sizeof(*cmd);

		fw_size -= sizeof(*cmd);



		if (fw_size < cmd->plen) {

			BT_ERR("%s: BCM: patch %s is corrupted",

				hdev->name, fw_name);

			ret = -EINVAL;

			goto reset_fw;

		}



		cmd_param = fw_ptr;

		fw_ptr += cmd->plen;

		fw_size -= cmd->plen;



		opcode = le16_to_cpu(cmd->opcode);



		skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,

				     HCI_INIT_TIMEOUT);

		if (IS_ERR(skb)) {

			ret = PTR_ERR(skb);

			BT_ERR("%s: BCM: patch command %04x failed (%ld)",

				hdev->name, opcode, ret);

			goto reset_fw;

		}

		kfree_skb(skb);

	}



	/* 250 msec delay after Launch Ram completes */

	msleep(250);



reset_fw:

	/* Reset */

	skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		BT_ERR("%s: HCI_OP_RESET failed (%ld)", hdev->name, ret);

		goto done;

	}

	kfree_skb(skb);



	/* Read Local Version Info */

	skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,

			     HCI_INIT_TIMEOUT);

	if (IS_ERR(skb)) {

		ret = PTR_ERR(skb);

		BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION failed (%ld)",

			hdev->name, ret);

		goto done;

	}



	if (skb->len != sizeof(*ver)) {

		BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION event length mismatch",

			hdev->name);

		kfree_skb(skb);

		ret = -EIO;

		goto done;

	}



	ver = (struct hci_rp_read_local_version *) skb->data;

	BT_INFO("%s: BCM: firmware hci_ver=%02x hci_rev=%04x lmp_ver=%02x "

		"lmp_subver=%04x", hdev->name, ver->hci_ver, ver->hci_rev,

		ver->lmp_ver, ver->lmp_subver);

	kfree_skb(skb);



done:

	release_firmware(fw);



	return ret;

}



static int btusb_probe(struct usb_interface *intf,

				const struct usb_device_id *id)

{
@@ -1486,6 +1636,9 @@ static int btusb_probe(struct usb_interface *intf, 
	if (id->driver_info & BTUSB_BCM92035)

		hdev->setup = btusb_setup_bcm92035;



	if (id->driver_info & BTUSB_BCM_PATCHRAM)

		hdev->setup = btusb_setup_bcm_patchram;



	if (id->driver_info & BTUSB_INTEL)

		hdev->setup = btusb_setup_intel;

drivers/net/wireless/at76c50x-usb.c

+95 −32
Original line number Diff line number Diff line
@@ -365,15 +365,15 @@ static inline unsigned long at76_get_timeout(struct dfu_status *s) 
static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size,

				int manifest_sync_timeout)

{

	u8 *block;

	struct dfu_status dfu_stat_buf;

	int ret = 0;

	int need_dfu_state = 1;

	int is_done = 0;

	u8 dfu_state = 0;

	u32 dfu_timeout = 0;

	int bsize = 0;

	int blockno = 0;

	struct dfu_status *dfu_stat_buf = NULL;

	u8 *dfu_state = NULL;

	u8 *block = NULL;



	at76_dbg(DBG_DFU, "%s( %p, %u, %d)", __func__, buf, size,

		 manifest_sync_timeout);
@@ -383,13 +383,28 @@ static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size, 
		return -EINVAL;

	}



	dfu_stat_buf = kmalloc(sizeof(struct dfu_status), GFP_KERNEL);

	if (!dfu_stat_buf) {

		ret = -ENOMEM;

		goto exit;

	}



	block = kmalloc(FW_BLOCK_SIZE, GFP_KERNEL);

	if (!block)

		return -ENOMEM;

	if (!block) {

		ret = -ENOMEM;

		goto exit;

	}



	dfu_state = kmalloc(sizeof(u8), GFP_KERNEL);

	if (!dfu_state) {

		ret = -ENOMEM;

		goto exit;

	}

	*dfu_state = 0;



	do {

		if (need_dfu_state) {

			ret = at76_dfu_get_state(udev, &dfu_state);

			ret = at76_dfu_get_state(udev, dfu_state);

			if (ret < 0) {

				dev_err(&udev->dev,

					"cannot get DFU state: %d\n", ret);
@@ -398,13 +413,13 @@ static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size, 
			need_dfu_state = 0;

		}



		switch (dfu_state) {

		switch (*dfu_state) {

		case STATE_DFU_DOWNLOAD_SYNC:

			at76_dbg(DBG_DFU, "STATE_DFU_DOWNLOAD_SYNC");

			ret = at76_dfu_get_status(udev, &dfu_stat_buf);

			ret = at76_dfu_get_status(udev, dfu_stat_buf);

			if (ret >= 0) {

				dfu_state = dfu_stat_buf.state;

				dfu_timeout = at76_get_timeout(&dfu_stat_buf);

				*dfu_state = dfu_stat_buf->state;

				dfu_timeout = at76_get_timeout(dfu_stat_buf);

				need_dfu_state = 0;

			} else

				dev_err(&udev->dev,
@@ -447,12 +462,12 @@ static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size, 
		case STATE_DFU_MANIFEST_SYNC:

			at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST_SYNC");



			ret = at76_dfu_get_status(udev, &dfu_stat_buf);

			ret = at76_dfu_get_status(udev, dfu_stat_buf);

			if (ret < 0)

				break;



			dfu_state = dfu_stat_buf.state;

			dfu_timeout = at76_get_timeout(&dfu_stat_buf);

			*dfu_state = dfu_stat_buf->state;

			dfu_timeout = at76_get_timeout(dfu_stat_buf);

			need_dfu_state = 0;



			/* override the timeout from the status response,
@@ -484,14 +499,17 @@ static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size, 
			break;



		default:

			at76_dbg(DBG_DFU, "DFU UNKNOWN STATE (%d)", dfu_state);

			at76_dbg(DBG_DFU, "DFU UNKNOWN STATE (%d)", *dfu_state);

			ret = -EINVAL;

			break;

		}

	} while (!is_done && (ret >= 0));



exit:

	kfree(dfu_state);

	kfree(block);

	kfree(dfu_stat_buf);



	if (ret >= 0)

		ret = 0;
@@ -1277,6 +1295,7 @@ static int at76_load_external_fw(struct usb_device *udev, struct fwentry *fwe) 
			dev_err(&udev->dev,

				"loading %dth firmware block failed: %d\n",

				blockno, ret);

			ret = -EIO;

			goto exit;

		}

		buf += bsize;
@@ -2020,6 +2039,44 @@ static void at76_configure_filter(struct ieee80211_hw *hw, 
	ieee80211_queue_work(hw, &priv->work_set_promisc);

}



static int at76_set_wep(struct at76_priv *priv)

{

	int ret = 0;

	struct mib_mac_wep *mib_data = &priv->mib_buf.data.wep_mib;



	priv->mib_buf.type = MIB_MAC_WEP;

	priv->mib_buf.size = sizeof(struct mib_mac_wep);

	priv->mib_buf.index = 0;



	memset(mib_data, 0, sizeof(*mib_data));



	if (priv->wep_enabled) {

		if (priv->wep_keys_len[priv->wep_key_id] > WEP_SMALL_KEY_LEN)

			mib_data->encryption_level = 2;

		else

			mib_data->encryption_level = 1;



		/* always exclude unencrypted if WEP is active */

		mib_data->exclude_unencrypted = 1;

	} else {

		mib_data->exclude_unencrypted = 0;

		mib_data->encryption_level = 0;

	}



	mib_data->privacy_invoked = priv->wep_enabled;

	mib_data->wep_default_key_id = priv->wep_key_id;

	memcpy(mib_data->wep_default_keyvalue, priv->wep_keys,

	       sizeof(priv->wep_keys));



	ret = at76_set_mib(priv, &priv->mib_buf);



	if (ret < 0)

		wiphy_err(priv->hw->wiphy,

			  "set_mib (wep) failed: %d\n", ret);



	return ret;

}



static int at76_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,

			struct ieee80211_vif *vif, struct ieee80211_sta *sta,

			struct ieee80211_key_conf *key)
@@ -2062,7 +2119,7 @@ static int at76_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 
			priv->wep_enabled = 1;

	}



	at76_startup_device(priv);

	at76_set_wep(priv);



	mutex_unlock(&priv->mtx);
@@ -2330,16 +2387,22 @@ static int at76_probe(struct usb_interface *interface, 
	struct usb_device *udev;

	int op_mode;

	int need_ext_fw = 0;

	struct mib_fw_version fwv;

	struct mib_fw_version *fwv = NULL;

	int board_type = (int)id->driver_info;



	udev = usb_get_dev(interface_to_usbdev(interface));



	fwv = kmalloc(sizeof(*fwv), GFP_KERNEL);

	if (!fwv) {

		ret = -ENOMEM;

		goto exit;

	}



	/* Load firmware into kernel memory */

	fwe = at76_load_firmware(udev, board_type);

	if (!fwe) {

		ret = -ENOENT;

		goto error;

		goto exit;

	}



	op_mode = at76_get_op_mode(udev);
@@ -2353,7 +2416,7 @@ static int at76_probe(struct usb_interface *interface, 
		dev_err(&interface->dev,

			"cannot handle a device in HW_CONFIG_MODE\n");

		ret = -EBUSY;

		goto error;

		goto exit;

	}



	if (op_mode != OPMODE_NORMAL_NIC_WITH_FLASH
@@ -2366,10 +2429,10 @@ static int at76_probe(struct usb_interface *interface, 
			dev_err(&interface->dev,

				"error %d downloading internal firmware\n",

				ret);

			goto error;

			goto exit;

		}

		usb_put_dev(udev);

		return ret;

		goto exit;

	}



	/* Internal firmware already inside the device.  Get firmware
@@ -2382,8 +2445,8 @@ static int at76_probe(struct usb_interface *interface, 
	 * query the device for the fw version */

	if ((fwe->fw_version.major > 0 || fwe->fw_version.minor >= 100)

	    || (op_mode == OPMODE_NORMAL_NIC_WITH_FLASH)) {

		ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));

		if (ret < 0 || (fwv.major | fwv.minor) == 0)

		ret = at76_get_mib(udev, MIB_FW_VERSION, fwv, sizeof(*fwv));

		if (ret < 0 || (fwv->major | fwv->minor) == 0)

			need_ext_fw = 1;

	} else

		/* No way to check firmware version, reload to be sure */
@@ -2394,36 +2457,36 @@ static int at76_probe(struct usb_interface *interface, 
			   "downloading external firmware\n");



		ret = at76_load_external_fw(udev, fwe);

		if (ret)

			goto error;

		if (ret < 0)

			goto exit;



		/* Re-check firmware version */

		ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));

		ret = at76_get_mib(udev, MIB_FW_VERSION, fwv, sizeof(*fwv));

		if (ret < 0) {

			dev_err(&interface->dev,

				"error %d getting firmware version\n", ret);

			goto error;

			goto exit;

		}

	}



	priv = at76_alloc_new_device(udev);

	if (!priv) {

		ret = -ENOMEM;

		goto error;

		goto exit;

	}



	usb_set_intfdata(interface, priv);



	memcpy(&priv->fw_version, &fwv, sizeof(struct mib_fw_version));

	memcpy(&priv->fw_version, fwv, sizeof(struct mib_fw_version));

	priv->board_type = board_type;



	ret = at76_init_new_device(priv, interface);

	if (ret < 0)

		at76_delete_device(priv);



	return ret;



error:

exit:

	kfree(fwv);

	if (ret < 0)

		usb_put_dev(udev);

	return ret;

}

drivers/net/wireless/at76c50x-usb.h

+13 −12
Original line number Diff line number Diff line
@@ -219,18 +219,6 @@ struct at76_req_join { 
	u8 reserved;

} __packed;



struct set_mib_buffer {

	u8 type;

	u8 size;

	u8 index;

	u8 reserved;

	union {

		u8 byte;

		__le16 word;

		u8 addr[ETH_ALEN];

	} data;

} __packed;



struct mib_local {

	u16 reserved0;

	u8 beacon_enable;
@@ -334,6 +322,19 @@ struct mib_mdomain { 
	u8 channel_list[14];	/* 0 for invalid channels */

} __packed;



struct set_mib_buffer {

	u8 type;

	u8 size;

	u8 index;

	u8 reserved;

	union {

		u8 byte;

		__le16 word;

		u8 addr[ETH_ALEN];

		struct mib_mac_wep wep_mib;

	} data;

} __packed;



struct at76_fw_header {

	__le32 crc;		/* CRC32 of the whole image */

	__le32 board_type;	/* firmware compatibility code */

drivers/net/wireless/ath/ath10k/bmi.h

+2 −1
Original line number Diff line number Diff line
@@ -201,6 +201,7 @@ int ath10k_bmi_write_memory(struct ath10k *ar, u32 address, 
									\

		addr = host_interest_item_address(HI_ITEM(item));	\

		ret = ath10k_bmi_read_memory(ar, addr, (u8 *)&tmp, 4); \

		if (!ret)						\

			*val = __le32_to_cpu(tmp);			\

		ret;							\

	 })

CRA Git | Maintained and supported by SUSTech CRA and CCSE