Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 204dfe17 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'for-upstream' of... 

Merge branch 'for-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next



Johan Hedberg says:

====================
pull request: bluetooth-next 2016-09-19

Here's the main bluetooth-next pull request for the 4.9 kernel.

 - Added new messages for monitor sockets for better mgmt tracing
 - Added local name and appearance support in scan response
 - Added new Qualcomm WCNSS SMD based HCI driver
 - Minor fixes & cleanup to 802.15.4 code
 - New USB ID to btusb driver
 - Added Marvell support to HCI UART driver
 - Add combined LED trigger for controller power
 - Other minor fixes here and there

Please let me know if there are any issues pulling. Thanks.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents ad979896 af4168c5

drivers/bluetooth/Kconfig

+23 −0
Original line number Diff line number Diff line
@@ -180,6 +180,17 @@ config BT_HCIUART_AG6XX 


	  Say Y here to compile support for Intel AG6XX protocol.



config BT_HCIUART_MRVL

	bool "Marvell protocol support"

	depends on BT_HCIUART

	select BT_HCIUART_H4

	help

	  Marvell is serial protocol for communication between Bluetooth

	  device and host. This protocol is required for most Marvell Bluetooth

	  devices with UART interface.



	  Say Y here to compile support for HCI MRVL protocol.



config BT_HCIBCM203X

	tristate "HCI BCM203x USB driver"

	depends on USB
@@ -331,4 +342,16 @@ config BT_WILINK 
	  Say Y here to compile support for Texas Instrument's WiLink7 driver

	  into the kernel or say M to compile it as module (btwilink).



config BT_QCOMSMD

	tristate "Qualcomm SMD based HCI support"

	depends on QCOM_SMD && QCOM_WCNSS_CTRL

	select BT_QCA

	help

	  Qualcomm SMD based HCI driver.

	  This driver is used to bridge HCI data onto the shared memory

	  channels to the WCNSS core.



	  Say Y here to compile support for HCI over Qualcomm SMD into the

	  kernel or say M to compile as a module.



endmenu

drivers/bluetooth/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ obj-$(CONFIG_BT_ATH3K) += ath3k.o 
obj-$(CONFIG_BT_MRVL)		+= btmrvl.o

obj-$(CONFIG_BT_MRVL_SDIO)	+= btmrvl_sdio.o

obj-$(CONFIG_BT_WILINK)		+= btwilink.o

obj-$(CONFIG_BT_QCOMSMD)	+= btqcomsmd.o

obj-$(CONFIG_BT_BCM)		+= btbcm.o

obj-$(CONFIG_BT_RTL)		+= btrtl.o

obj-$(CONFIG_BT_QCA)		+= btqca.o
@@ -37,6 +38,7 @@ hci_uart-$(CONFIG_BT_HCIUART_INTEL) += hci_intel.o 
hci_uart-$(CONFIG_BT_HCIUART_BCM)	+= hci_bcm.o

hci_uart-$(CONFIG_BT_HCIUART_QCA)	+= hci_qca.o

hci_uart-$(CONFIG_BT_HCIUART_AG6XX)	+= hci_ag6xx.o

hci_uart-$(CONFIG_BT_HCIUART_MRVL)	+= hci_mrvl.o

hci_uart-objs				:= $(hci_uart-y)



ccflags-y += -D__CHECK_ENDIAN__

drivers/bluetooth/bcm203x.c

+1 −3
Original line number Diff line number Diff line
@@ -185,10 +185,8 @@ static int bcm203x_probe(struct usb_interface *intf, const struct usb_device_id 
	data->state = BCM203X_LOAD_MINIDRV;



	data->urb = usb_alloc_urb(0, GFP_KERNEL);

	if (!data->urb) {

		BT_ERR("Can't allocate URB");

	if (!data->urb)

		return -ENOMEM;

	}



	if (request_firmware(&firmware, "BCM2033-MD.hex", &udev->dev) < 0) {

		BT_ERR("Mini driver request failed");

drivers/bluetooth/btqca.c

+4 −4
Original line number Diff line number Diff line
@@ -55,8 +55,8 @@ static int rome_patch_ver_req(struct hci_dev *hdev, u32 *rome_version) 
	}



	edl = (struct edl_event_hdr *)(skb->data);

	if (!edl || !edl->data) {

		BT_ERR("%s: TLV with no header or no data", hdev->name);

	if (!edl) {

		BT_ERR("%s: TLV with no header", hdev->name);

		err = -EILSEQ;

		goto out;

	}
@@ -224,8 +224,8 @@ static int rome_tlv_send_segment(struct hci_dev *hdev, int idx, int seg_size, 
	}



	edl = (struct edl_event_hdr *)(skb->data);

	if (!edl || !edl->data) {

		BT_ERR("%s: TLV with no header or no data", hdev->name);

	if (!edl) {

		BT_ERR("%s: TLV with no header", hdev->name);

		err = -EILSEQ;

		goto out;

	}

drivers/bluetooth/btqcomsmd.c

0 → 100644
+182 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2016, Linaro Ltd.

 * Copyright (c) 2015, Sony Mobile Communications Inc.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/module.h>

#include <linux/slab.h>

#include <linux/soc/qcom/smd.h>

#include <linux/soc/qcom/wcnss_ctrl.h>

#include <linux/platform_device.h>



#include <net/bluetooth/bluetooth.h>

#include <net/bluetooth/hci_core.h>



#include "btqca.h"



struct btqcomsmd {

	struct hci_dev *hdev;



	struct qcom_smd_channel *acl_channel;

	struct qcom_smd_channel *cmd_channel;

};



static int btqcomsmd_recv(struct hci_dev *hdev, unsigned int type,

			   const void *data, size_t count)

{

	struct sk_buff *skb;



	/* Use GFP_ATOMIC as we're in IRQ context */

	skb = bt_skb_alloc(count, GFP_ATOMIC);

	if (!skb) {

		hdev->stat.err_rx++;

		return -ENOMEM;

	}



	hci_skb_pkt_type(skb) = type;

	memcpy(skb_put(skb, count), data, count);



	return hci_recv_frame(hdev, skb);

}



static int btqcomsmd_acl_callback(struct qcom_smd_channel *channel,

				  const void *data, size_t count)

{

	struct btqcomsmd *btq = qcom_smd_get_drvdata(channel);



	btq->hdev->stat.byte_rx += count;

	return btqcomsmd_recv(btq->hdev, HCI_ACLDATA_PKT, data, count);

}



static int btqcomsmd_cmd_callback(struct qcom_smd_channel *channel,

				  const void *data, size_t count)

{

	struct btqcomsmd *btq = qcom_smd_get_drvdata(channel);



	return btqcomsmd_recv(btq->hdev, HCI_EVENT_PKT, data, count);

}



static int btqcomsmd_send(struct hci_dev *hdev, struct sk_buff *skb)

{

	struct btqcomsmd *btq = hci_get_drvdata(hdev);

	int ret;



	switch (hci_skb_pkt_type(skb)) {

	case HCI_ACLDATA_PKT:

		ret = qcom_smd_send(btq->acl_channel, skb->data, skb->len);

		hdev->stat.acl_tx++;

		hdev->stat.byte_tx += skb->len;

		break;

	case HCI_COMMAND_PKT:

		ret = qcom_smd_send(btq->cmd_channel, skb->data, skb->len);

		hdev->stat.cmd_tx++;

		break;

	default:

		ret = -EILSEQ;

		break;

	}



	kfree_skb(skb);



	return ret;

}



static int btqcomsmd_open(struct hci_dev *hdev)

{

	return 0;

}



static int btqcomsmd_close(struct hci_dev *hdev)

{

	return 0;

}



static int btqcomsmd_probe(struct platform_device *pdev)

{

	struct btqcomsmd *btq;

	struct hci_dev *hdev;

	void *wcnss;

	int ret;



	btq = devm_kzalloc(&pdev->dev, sizeof(*btq), GFP_KERNEL);

	if (!btq)

		return -ENOMEM;



	wcnss = dev_get_drvdata(pdev->dev.parent);



	btq->acl_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_ACL",

						   btqcomsmd_acl_callback);

	if (IS_ERR(btq->acl_channel))

		return PTR_ERR(btq->acl_channel);



	btq->cmd_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_CMD",

						   btqcomsmd_cmd_callback);

	if (IS_ERR(btq->cmd_channel))

		return PTR_ERR(btq->cmd_channel);



	qcom_smd_set_drvdata(btq->acl_channel, btq);

	qcom_smd_set_drvdata(btq->cmd_channel, btq);



	hdev = hci_alloc_dev();

	if (!hdev)

		return -ENOMEM;



	hci_set_drvdata(hdev, btq);

	btq->hdev = hdev;

	SET_HCIDEV_DEV(hdev, &pdev->dev);



	hdev->bus = HCI_SMD;

	hdev->open = btqcomsmd_open;

	hdev->close = btqcomsmd_close;

	hdev->send = btqcomsmd_send;

	hdev->set_bdaddr = qca_set_bdaddr_rome;



	ret = hci_register_dev(hdev);

	if (ret < 0) {

		hci_free_dev(hdev);

		return ret;

	}



	platform_set_drvdata(pdev, btq);



	return 0;

}



static int btqcomsmd_remove(struct platform_device *pdev)

{

	struct btqcomsmd *btq = platform_get_drvdata(pdev);



	hci_unregister_dev(btq->hdev);

	hci_free_dev(btq->hdev);



	return 0;

}



static const struct of_device_id btqcomsmd_of_match[] = {

	{ .compatible = "qcom,wcnss-bt", },

	{ },

};



static struct platform_driver btqcomsmd_driver = {

	.probe = btqcomsmd_probe,

	.remove = btqcomsmd_remove,

	.driver  = {

		.name  = "btqcomsmd",

		.of_match_table = btqcomsmd_of_match,

	},

};



module_platform_driver(btqcomsmd_driver);



MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");

MODULE_DESCRIPTION("Qualcomm SMD HCI driver");

MODULE_LICENSE("GPL v2");