* Re: [RFC 1/2] Add Broadcom Bluetooth UART device support
2015-05-06 19:08 ` [RFC 1/2] Add Broadcom Bluetooth UART device support Ilya Faenson
@ 2015-05-07 8:48 ` Chan-yeol Park
0 siblings, 0 replies; 4+ messages in thread
From: Chan-yeol Park @ 2015-05-07 8:48 UTC (permalink / raw)
To: Ilya Faenson; +Cc: Marcel Holtmann, linux-bluetooth, Ilya Faenson
Hi, Ilya Faenson
On 05/07/2015 04:08 AM, Ilya Faenson wrote:
> From: Ilya Faenson <Ilya.Faenson@broadcom.com>
>
> Implemented device setup, firmware download and power management.
>
> Signed-off-by: Ilya Faenson <ifaenson@broadcom.com>
> ---
> drivers/bluetooth/Kconfig | 32 +-
> drivers/bluetooth/Makefile | 1 +
> drivers/bluetooth/btbcm.c | 170 +++++++-
> drivers/bluetooth/btbcm.h | 15 +-
> drivers/bluetooth/btbcm_uart.c | 684 ++++++++++++++++++++++++++++++++
> drivers/bluetooth/btbcm_uart.h | 94 +++++
> drivers/bluetooth/hci_bcm.c | 865 ++++++++++++++++++++++++++++++++++++++---
> 7 files changed, 1783 insertions(+), 78 deletions(-)
> create mode 100755 drivers/bluetooth/btbcm_uart.c
> create mode 100755 drivers/bluetooth/btbcm_uart.h
>
> diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
> index ed5c273..7ac9cb8 100644
> --- a/drivers/bluetooth/Kconfig
> +++ b/drivers/bluetooth/Kconfig
> @@ -8,6 +8,12 @@ config BT_INTEL
> config BT_BCM
> tristate
> select FW_LOADER
> + help
> + This feature is required if you want to use Broadcom Bluetooth
> + over both USB and UART.
> +
> + Say Y here to compile support for Broadcom Bluetooth
> + kernel or say M to compile it as module (btusb).
>
> config BT_HCIBTUSB
> tristate "HCI USB driver"
> @@ -22,15 +28,15 @@ config BT_HCIBTUSB
> kernel or say M to compile it as module (btusb).
>
> config BT_HCIBTUSB_BCM
> - bool "Broadcom protocol support"
> + bool "Broadcom USB support"
> depends on BT_HCIBTUSB
> select BT_BCM
> default y
> help
> - The Broadcom protocol support enables firmware and patchram
> - download support for Broadcom Bluetooth controllers.
> + The Broadcom USB support enables firmware and patchram
> + download for Broadcom Bluetooth USB controllers.
>
> - Say Y here to compile support for Broadcom protocol.
> + Say Y here to compile support for Broadcom USB.
>
> config BT_HCIBTSDIO
> tristate "HCI SDIO driver"
> @@ -125,15 +131,23 @@ config BT_HCIUART_INTEL
> Say Y here to compile support for Intel protocol.
>
> config BT_HCIUART_BCM
> - bool "Broadcom protocol support"
> - depends on BT_HCIUART
> + bool "Broadcom BT UART serial support"
> select BT_HCIUART_H4
> + select BT_UART_BCM
> select BT_BCM
> help
> - The Broadcom protocol support enables Bluetooth HCI over serial
> - port interface for Broadcom Bluetooth controllers.
> + HCI_UART_BCM is a protocol for initializing, managing and
> + communicating with Broadcom UART Bluetooth devices.
> + This protocol initializes chips and power-manages them.
> + Enable this if you have serial Broadcom Bluetooth device.
> +
> + Say Y here to compile support for Broadcom UART protocol.
>
> - Say Y here to compile support for Broadcom protocol.
> +config BT_UART_BCM
> + tristate "Broadcom BT UART driver"
> + depends on BT_HCIUART_H4 && TTY
> + help
> + This driver supports the HCI_UART_BT protocol.
>
> config BT_HCIBCM203X
> tristate "HCI BCM203x USB driver"
> diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile
> index dd0d9c4..0e5fd66 100644
> --- a/drivers/bluetooth/Makefile
> +++ b/drivers/bluetooth/Makefile
> @@ -21,6 +21,7 @@ obj-$(CONFIG_BT_MRVL) += btmrvl.o
> obj-$(CONFIG_BT_MRVL_SDIO) += btmrvl_sdio.o
> obj-$(CONFIG_BT_WILINK) += btwilink.o
> obj-$(CONFIG_BT_BCM) += btbcm.o
> +obj-$(CONFIG_BT_UART_BCM) += btbcm_uart.o
>
> btmrvl-y := btmrvl_main.o
> btmrvl-$(CONFIG_DEBUG_FS) += btmrvl_debugfs.o
> diff --git a/drivers/bluetooth/btbcm.c b/drivers/bluetooth/btbcm.c
> index 4bba866..f26bcef 100644
> --- a/drivers/bluetooth/btbcm.c
> +++ b/drivers/bluetooth/btbcm.c
> @@ -2,7 +2,8 @@
> *
> * Bluetooth support for Broadcom devices
> *
> - * Copyright (C) 2015 Intel Corporation
> + * Copyright (C) 2015 Intel Corporation
> + * Copyright (C) 2015 Broadcom Corporation
> *
> *
> * This program is free software; you can redistribute it and/or modify
> @@ -23,16 +24,18 @@
>
> #include <linux/module.h>
> #include <linux/firmware.h>
> +#include <linux/tty.h>
> #include <asm/unaligned.h>
>
> #include <net/bluetooth/bluetooth.h>
> #include <net/bluetooth/hci_core.h>
>
> +#include "hci_uart.h"
> #include "btbcm.h"
>
> -#define VERSION "0.1"
> +#define VERSION "0.2"
>
> -#define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
> +#define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00} })
>
> int btbcm_check_bdaddr(struct hci_dev *hdev)
> {
> @@ -43,6 +46,7 @@ int btbcm_check_bdaddr(struct hci_dev *hdev)
> HCI_INIT_TIMEOUT);
> if (IS_ERR(skb)) {
> int err = PTR_ERR(skb);
> +
> BT_ERR("%s: BCM: Reading device address failed (%d)",
> hdev->name, err);
> return err;
> @@ -159,6 +163,8 @@ int btbcm_patchram(struct hci_dev *hdev, const char *firmware)
> }
>
> /* 250 msec delay after Launch Ram completes */
> + BT_INFO("%s: BCM: Delaying upon the patch download completion...",
> + hdev->name);
> msleep(250);
>
> done:
> @@ -174,6 +180,7 @@ static int btbcm_reset(struct hci_dev *hdev)
> skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
> if (IS_ERR(skb)) {
> int err = PTR_ERR(skb);
> +
> BT_ERR("%s: BCM: Reset failed (%d)", hdev->name, err);
> return err;
> }
> @@ -246,8 +253,10 @@ static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev)
> static const struct {
> u16 subver;
> const char *name;
> + u32 baud_rate; /* operational baud rate */
> } bcm_uart_subver_table[] = {
> - { 0x410e, "BCM43341B0" }, /* 002.001.014 */
> + { 0x410e, "BCM43341B0", 3000000}, /* 002.001.014 */
> + { 0x610c, "BCM4354_003.001.012.0306.0659", 3000000}, /* 003.001.012 */
> { }
> };
>
> @@ -268,6 +277,134 @@ static const struct {
> { }
> };
>
> +/*
> + * Set the UART into the defaults
> + */
> +int btbcm_init_uart(struct hci_uart *hu)
> +{
> + struct ktermios ktermios;
> + struct tty_struct *tty = hu->tty;
> + int status, speed;
> +
> + /* Bring UART into default setting at 115200 */
> + if (tty->ldisc->ops->flush_buffer)
> + tty->ldisc->ops->flush_buffer(tty);
> + tty_driver_flush_buffer(tty);
> + ktermios = tty->termios;
> + BT_DBG("init_uart def flags c_o %x c_l %x c_c %x spd %d/%d",
> + ktermios.c_oflag, ktermios.c_lflag, ktermios.c_cflag,
> + ktermios.c_ispeed, ktermios.c_ospeed);
> + ktermios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
> + | INLCR | IGNCR | ICRNL | IXON);
> + ktermios.c_oflag &= ~OPOST;
> + ktermios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
> + ktermios.c_cflag &= ~(CSIZE | PARENB | CBAUD);
> + ktermios.c_cflag |= CS8;
> + ktermios.c_cflag |= CRTSCTS;
> + ktermios.c_cflag |= B115200;
> + ktermios.c_ispeed = 115200;
> + ktermios.c_ospeed = 115200;
> + status = tty_set_termios(tty, &ktermios);
> + if (status) {
> + BT_DBG("init_uart set_termios failure %d", status);
> + return status;
> + }
> +
> + speed = tty_get_baud_rate(tty);
> + BT_DBG("init_uart set_termios completed, spd %d", speed);
> + ktermios = tty->termios;
> + BT_DBG("init_uart new flags c_o %x c_l %x c_c %x spd %d/%d",
> + ktermios.c_oflag, ktermios.c_lflag, ktermios.c_cflag,
> + ktermios.c_ispeed, ktermios.c_ospeed);
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(btbcm_init_uart);
> +
> +/*
> + * Set the baud rate on the UART and the device
> + */
> +int btbcm_set_baud_rate(struct hci_uart *hu, int baud_rate)
> +{
> + struct ktermios ktermios;
> + struct tty_struct *tty = hu->tty;
> + int status, speed, cflag;
> + struct sk_buff *skb;
> + unsigned char enable = 1;
> + unsigned char baud_rate_vsc_pars[] = {0, 0, 0, 0x10, 0x0e, 0};
> +
> + /* If the baud rate is higher than 3000000, change the clock */
> + if (baud_rate > 3000000) {
> + skb = __hci_cmd_sync(hu->hdev, 0xfc45, 1, &enable,
> + HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + return status;
> + }
> +
> + kfree_skb(skb);
> + BT_DBG("set_baud_rate write UART 48 MHz VSC succeeded");
> + }
> +
> + /* Now let the device know about the rate change */
> + baud_rate_vsc_pars[2] = (unsigned char)(baud_rate & 0xff);
> + baud_rate_vsc_pars[3] = (unsigned char)((baud_rate >> 8) & 0xff);
> + baud_rate_vsc_pars[4] = (unsigned char)((baud_rate >> 16) & 0xff);
> + baud_rate_vsc_pars[5] = (unsigned char)((baud_rate >> 24) & 0xff);
> + skb = __hci_cmd_sync(hu->hdev, 0xfc18, sizeof(baud_rate_vsc_pars),
> + baud_rate_vsc_pars, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("set_baud_rate VSC failed (%d)", status);
> + return status;
> + }
> +
> + kfree_skb(skb);
> + BT_DBG("set_baud_rate VSC succeeded");
> +
> + /* Set UART into this rate as well */
> + ktermios = tty->termios;
> + BT_DBG("set_baud_rate start flags c_o %x c_l %x c_c %x spd %d/%d",
> + ktermios.c_oflag, ktermios.c_lflag, ktermios.c_cflag,
> + ktermios.c_ispeed, ktermios.c_ospeed);
> + switch (baud_rate) {
> + case 115200:
> + cflag |= B115200; break;
> + case 921600:
> + cflag |= B921600; break;
> + case 3000000:
> + cflag |= B3000000; break;
> + case 3500000:
> + cflag |= B3500000; break;
> + case 4000000:
> + cflag |= B4000000; break;
> + default:
> + BT_DBG("set_baud_rate unknown rate %d", baud_rate);
> + return -EINVAL;
> + }
> +
> + ktermios.c_cflag &= ~CBAUD;
> + ktermios.c_cflag |= cflag;
> + ktermios.c_ispeed = baud_rate;
> + ktermios.c_ospeed = baud_rate;
> + status = tty_set_termios(tty, &ktermios);
> + if (status) {
> + BT_DBG("set_baud_rate set_termios failure %d", status);
> + return status;
> + }
> +
> + speed = tty_get_baud_rate(tty);
> + BT_DBG("set_baud_rate set_termios completed, spd %d", speed);
> + ktermios = tty->termios;
> + BT_DBG("set_baud_rate flags c_o %x c_l %x c_c %x spd %d/%d",
> + ktermios.c_oflag, ktermios.c_lflag, ktermios.c_cflag,
> + ktermios.c_ispeed, ktermios.c_ospeed);
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(btbcm_set_baud_rate);
> +
> +
> int btbcm_setup_patchram(struct hci_dev *hdev)
> {
> char fw_name[64];
> @@ -275,7 +412,8 @@ int btbcm_setup_patchram(struct hci_dev *hdev)
> const char *hw_name = NULL;
> struct sk_buff *skb;
> struct hci_rp_read_local_version *ver;
> - int i, err;
> + int i, err, is_uart = false;
> + struct hci_uart *hu = hci_get_drvdata(hdev);
>
> /* Reset */
> err = btbcm_reset(hdev);
> @@ -297,14 +435,18 @@ int btbcm_setup_patchram(struct hci_dev *hdev)
> if (IS_ERR(skb))
> return PTR_ERR(skb);
>
> - BT_INFO("%s: BCM: chip id %u", hdev->name, skb->data[1]);
> + BT_INFO("%s: BCM: chip id %u, rev 0x%x subver 0x%x",
> + hdev->name, skb->data[1], rev, subver);
> kfree_skb(skb);
>
> switch ((rev & 0xf000) >> 12) {
> case 0:
> + case 1:
> for (i = 0; bcm_uart_subver_table[i].name; i++) {
> if (subver == bcm_uart_subver_table[i].subver) {
> hw_name = bcm_uart_subver_table[i].name;
> + BT_INFO("UART firmware found: %s", hw_name);
> + is_uart = true;
> break;
> }
> }
> @@ -312,7 +454,7 @@ int btbcm_setup_patchram(struct hci_dev *hdev)
> snprintf(fw_name, sizeof(fw_name), "brcm/%s.hcd",
> hw_name ? : "BCM");
> break;
> - case 1:
> +
> case 2:
> /* Read USB Product Info */
> skb = btbcm_read_usb_product(hdev);
> @@ -345,11 +487,25 @@ int btbcm_setup_patchram(struct hci_dev *hdev)
> if (err == -ENOENT)
> return 0;
>
> + /* Once the patch is downloaded, the device is back at default rate */
> + if (is_uart) {
> + err = btbcm_init_uart(hu);
> + if (err)
> + return 0;
> + }
> +
> /* Reset */
> err = btbcm_reset(hdev);
> if (err)
> return err;
>
> + if (is_uart) {
> + err = btbcm_set_baud_rate(hu,
> + bcm_uart_subver_table[i].baud_rate);
> + if (err)
> + return 0;
> + }
> +
> /* Read Local Version Info */
> skb = btbcm_read_local_version(hdev);
> if (IS_ERR(skb))
> diff --git a/drivers/bluetooth/btbcm.h b/drivers/bluetooth/btbcm.h
> index eb6ab5f..6c6cf58 100644
> --- a/drivers/bluetooth/btbcm.h
> +++ b/drivers/bluetooth/btbcm.h
> @@ -2,7 +2,8 @@
> *
> * Bluetooth support for Broadcom devices
> *
> - * Copyright (C) 2015 Intel Corporation
> + * Copyright (C) 2015 Intel Corporation
> + * Copyright (C) 2015 Broadcom Corporation
> *
> *
> * This program is free software; you can redistribute it and/or modify
> @@ -30,6 +31,8 @@ int btbcm_patchram(struct hci_dev *hdev, const char *firmware);
> int btbcm_setup_patchram(struct hci_dev *hdev);
> int btbcm_setup_apple(struct hci_dev *hdev);
>
> +int btbcm_init_uart(struct hci_uart *hu);
> +int btbcm_set_baud_rate(struct hci_uart *hu, int baud_rate);
> #else
>
> static inline int btbcm_check_bdaddr(struct hci_dev *hdev)
> @@ -57,4 +60,14 @@ static inline int btbcm_setup_apple(struct hci_dev *hdev)
> return 0;
> }
>
> +static int btbcm_init_uart(void *hu)
> +{
> + return 0;
> +}
> +
> +static int btbcm_set_baud_rate(void *hu, int baud_rate);
> +{
> + return 0;
> +}
> +
> #endif
> diff --git a/drivers/bluetooth/btbcm_uart.c b/drivers/bluetooth/btbcm_uart.c
> new file mode 100755
> index 0000000..cf9c3c7
> --- /dev/null
> +++ b/drivers/bluetooth/btbcm_uart.c
> @@ -0,0 +1,684 @@
> +/*
> + *
> + * Bluetooth BCM UART Driver
> + *
> + * Copyright (c) 2015 Broadcom Corporation
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * 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.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + *
> + */
> +
> +#include <linux/module.h>
> +
> +#include <linux/kernel.h>
> +#include <linux/init.h>
> +#include <linux/types.h>
> +#include <linux/fcntl.h>
> +#include <linux/interrupt.h>
> +#include <linux/ptrace.h>
> +#include <linux/poll.h>
> +
> +#include <linux/slab.h>
> +#include <linux/tty.h>
> +#include <linux/errno.h>
> +#include <linux/string.h>
> +#include <linux/signal.h>
> +#include <linux/ioctl.h>
> +#include <linux/skbuff.h>
> +#include <linux/list.h>
> +
> +#include <net/bluetooth/bluetooth.h>
> +#include <net/bluetooth/hci_core.h>
> +
> +#include <linux/gpio/consumer.h>
> +#include <linux/of.h>
> +#include <linux/of_gpio.h>
> +#include <linux/of_platform.h>
> +
> +#include "btbcm_uart.h"
> +
> +static int idleTimeout = 5;
> +module_param(idleTimeout, int, 0);
> +MODULE_PARM_DESC(idleTimeout, "Bluetooth idle timeout in seconds");
> +
> +/* Device context */
> +struct bcm_device {
> + struct list_head list;
> +
> + struct platform_device *pdev;
> + struct gpio_desc *bt_wake_gpio;
> + struct gpio_desc *dev_wake_gpio;
> + struct gpio_desc *reg_on_gpio;
> + int bt_wake_irq;
> + int dev_wake_active_low;
> + int reg_on_active_low;
> + int bt_wake_active_low;
> + u32 configure_sleep;
> + u32 manual_fc;
> + u32 baud_rate_before_config_download;
> + u32 configure_audio;
> + u32 PCMClockMode;
> + u32 PCMFillMethod;
> + u32 PCMFillNum;
> + u32 PCMFillValue;
> + u32 PCMInCallBitclock;
> + u32 PCMLSBFirst;
> + u32 PCMRightJustify;
> + u32 PCMRouting;
> + u32 PCMShortFrameSync;
> + u32 PCMSyncMode;
> +
> + char tty_name[64];
> +
> + struct btbcm_uart_callbacks protocol_callbacks;
> + struct work_struct wakeup_work;
> +};
> +
> +/* List of BCM BT UART devices */
> +static DEFINE_SPINLOCK(device_list_lock);
> +static LIST_HEAD(device_list);
> +
> +/*
> + * Calling the BCM protocol at lower execution priority
> + */
> +static void bcm_bt_wakeup_task(struct work_struct *ws)
> +{
> + int resume_flag;
> + struct bcm_device *p_bcm_device =
> + container_of(ws, struct bcm_device, wakeup_work);
> +
> + if (!p_bcm_device) {
> + BT_DBG("bcm_bt_wakeup_task - failing, no device");
> + return;
> + }
> +
> + /* Make sure the device is resumed */
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + if (p_bcm_device->dev_wake_gpio) {
> + gpiod_set_value(p_bcm_device->dev_wake_gpio, resume_flag);
> + BT_DBG("bcm_bt_wakeup_task - resume %d written, delaying 15 ms",
> + resume_flag);
> + mdelay(15);
> + }
> +
> + /* Let the protocol know it's time to wake up */
> + if (p_bcm_device->protocol_callbacks.p_wakeup)
> + p_bcm_device->protocol_callbacks.p_wakeup(
> + p_bcm_device->protocol_callbacks.context);
> +}
> +
> +/*
> + * Interrupt routine for the wake from the device
> + */
> +static irqreturn_t bcm_bt_uart_isr(int irq, void *context)
> +{
> + unsigned int bt_wake;
> + struct bcm_device *p = (struct bcm_device *) context;
> +
> + bt_wake = gpiod_get_value(p->bt_wake_gpio);
> + BT_DBG("bcm_bt_uart_isr with bt_wake of %d (active_low %d), req bh",
> + bt_wake, p->bt_wake_active_low);
> +
> + /* Defer the actual processing to the platform work queue */
> + schedule_work(&p->wakeup_work);
> + return IRQ_HANDLED;
> +}
> +
> +/*
> + * Device instance startup
> + */
> +static int bcm_bt_uart_probe(struct platform_device *pdev)
> +{
> + int ret = 0;
> + struct device_node *np = pdev->dev.of_node;
> + const char *tty_name;
> + struct bcm_device *p_bcm_device = NULL;
> +
> + p_bcm_device = devm_kzalloc(&pdev->dev, sizeof(*p_bcm_device),
> + GFP_KERNEL);
> + if (!p_bcm_device) {
> + BT_DBG("bcm_bt_uart_probe - failing due to no memory");
> + return -ENOMEM;
> + }
> + p_bcm_device->pdev = pdev;
> + BT_DBG("bcm_bt_uart_probe %p context", p_bcm_device);
> +
> + /* Get dev wake GPIO */
> + p_bcm_device->dev_wake_gpio = gpiod_get(&pdev->dev, "bt-wake");
> + BT_DBG("bcm_bt_uart_probe - gpiod_get for bt-wake returned %p",
> + p_bcm_device->dev_wake_gpio);
> + if (IS_ERR(p_bcm_device->dev_wake_gpio)) {
> + ret = PTR_ERR(p_bcm_device->dev_wake_gpio);
> + if (ret != -ENOENT) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe - dev_wake GPIO: %d\n", ret);
> + }
> + p_bcm_device->dev_wake_gpio = NULL;
> + } else {
> + int resume_flag;
> +
> + p_bcm_device->dev_wake_active_low = gpiod_is_active_low
> + (p_bcm_device->dev_wake_gpio);
> + BT_DBG("bcm_bt_uart_probe - dev_wake alow is %d (cans %d)",
> + p_bcm_device->dev_wake_active_low,
> + gpiod_cansleep(p_bcm_device->dev_wake_gpio));
> +
> + /* configure dev_wake as output with init resumed state */
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + ret = gpiod_direction_output(p_bcm_device->dev_wake_gpio,
> + resume_flag);
> + if (ret < 0) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe s dev_wake GPIO: %d\n", ret);
> + gpiod_put(p_bcm_device->dev_wake_gpio);
> + p_bcm_device->dev_wake_gpio = NULL;
> + goto end;
> + } else {
> + BT_DBG("bcm_bt_uart_probe - dev_wake set to %d",
> + resume_flag);
> + }
> + }
> +
> + /* Get power on/off GPIO */
> + p_bcm_device->reg_on_gpio = gpiod_get(&pdev->dev, "reg-on");
> + BT_DBG("bcm_bt_uart_probe - gpiod_get for reg-on returned %p",
> + p_bcm_device->reg_on_gpio);
> + if (IS_ERR(p_bcm_device->reg_on_gpio)) {
> + ret = PTR_ERR(p_bcm_device->reg_on_gpio);
> + if (ret != -ENOENT) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe - reg_on GPIO: %d\n", ret);
> + }
> + p_bcm_device->reg_on_gpio = NULL;
> + } else {
> + int poweron_flag;
> +
> + p_bcm_device->reg_on_active_low = gpiod_is_active_low
> + (p_bcm_device->reg_on_gpio);
> + BT_DBG("bcm_bt_uart_probe - reg_on alow is %d (cans %d)",
> + p_bcm_device->reg_on_active_low,
> + gpiod_cansleep(p_bcm_device->reg_on_gpio));
> +
> + /* configure reg_on as output with init on state */
> + poweron_flag = !p_bcm_device->reg_on_active_low;
> + ret = gpiod_direction_output(p_bcm_device->reg_on_gpio,
> + poweron_flag);
> + if (ret < 0) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe s reg_on GPIO: %d\n", ret);
> + gpiod_put(p_bcm_device->reg_on_gpio);
> + p_bcm_device->reg_on_gpio = NULL;
> + } else {
> + BT_DBG("bcm_bt_uart_probe - reg_on initially set to %d",
> + poweron_flag);
> + }
> + }
> +
> + platform_set_drvdata(pdev, p_bcm_device);
> + /* Must be done before interrupt is requested */
> + INIT_WORK(&p_bcm_device->wakeup_work, bcm_bt_wakeup_task);
> +
> + /* Get bt host wake GPIO */
> + p_bcm_device->bt_wake_gpio = gpiod_get(&pdev->dev, "bt-host-wake");
> + BT_DBG("bcm_bt_uart_probe - gpiod_get for bt-host-wake returned %p",
> + p_bcm_device->bt_wake_gpio);
> + if (IS_ERR(p_bcm_device->bt_wake_gpio)) {
> + ret = PTR_ERR(p_bcm_device->bt_wake_gpio);
> + if (ret != -ENOENT) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe - bt_wake GPIO: %d\n", ret);
> + }
> + p_bcm_device->bt_wake_gpio = NULL;
> + } else {
> + /* configure bt_wake as input */
> + ret = gpiod_direction_input(p_bcm_device->bt_wake_gpio);
> + if (ret < 0) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe s bt_wake GPIO: %d\n", ret);
> + gpiod_put(p_bcm_device->bt_wake_gpio);
> + p_bcm_device->bt_wake_gpio = NULL;
> + } else {
> + p_bcm_device->bt_wake_active_low = gpiod_is_active_low
> + (p_bcm_device->bt_wake_gpio);
> + BT_DBG("bcm_bt_uart_probe - bt_wake alow is %d(cans%d)",
> + p_bcm_device->bt_wake_active_low,
> + gpiod_cansleep(p_bcm_device->bt_wake_gpio));
> + p_bcm_device->bt_wake_irq = gpiod_to_irq
> + (p_bcm_device->bt_wake_gpio);
> + if (p_bcm_device->bt_wake_irq < 0) {
> + dev_err(&pdev->dev,
> + "bcm_bt_uart_probe - HOST_WAKE IRQ: %d\n", ret);
> + } else {
> + unsigned long intflags = IRQF_TRIGGER_RISING;
> +
> + if (p_bcm_device->bt_wake_active_low)
> + intflags = IRQF_TRIGGER_FALLING;
> +
> + ret = request_irq(p_bcm_device->bt_wake_irq,
> + bcm_bt_uart_isr,
> + intflags, "bt_host_wake",
> + p_bcm_device);
> + if (ret < 0) {
> + dev_err(&pdev->dev, "bcm_bt_uart_probe - failed to conf IRQ %d: %d",
> + p_bcm_device->bt_wake_irq, ret);
> + } else {
> + BT_DBG("bcm_bt_uart_probe - IRQ %d",
> + p_bcm_device->bt_wake_irq);
> + }
> + }
> + }
> + }
> +
> + p_bcm_device->configure_sleep = 0;
> + if (!of_property_read_u32(np, "configure-sleep",
> + &p_bcm_device->configure_sleep)) {
> + BT_DBG("configure-sleep read as %d",
> + p_bcm_device->configure_sleep);
> + }
> + p_bcm_device->manual_fc = 0;
> + if (!of_property_read_u32(np, "manual-fc",
> + &p_bcm_device->manual_fc)) {
> + BT_DBG("manual-fc read as %d",
> + p_bcm_device->manual_fc);
> + }
> + p_bcm_device->baud_rate_before_config_download = 3000000;
> + if (!of_property_read_u32(
> + np, "baud-rate-before-config-download",
> + &p_bcm_device->baud_rate_before_config_download)) {
> + BT_DBG("baud-rate-before-config-download read as %d",
> + p_bcm_device->baud_rate_before_config_download);
> + }
> + p_bcm_device->configure_audio = 0;
> + if (!of_property_read_u32(np, "configure-audio",
> + &p_bcm_device->configure_audio)) {
> + BT_DBG("configure-audio read as %d",
> + p_bcm_device->configure_audio);
> + }
> + if (p_bcm_device->configure_audio) {
> + /* Defaults for audio */
> + p_bcm_device->PCMClockMode = 0;
> + p_bcm_device->PCMFillMethod = 2;
> + p_bcm_device->PCMFillNum = 0;
> + p_bcm_device->PCMFillValue = 3;
> + p_bcm_device->PCMInCallBitclock = 0;
> + p_bcm_device->PCMLSBFirst = 0;
> + p_bcm_device->PCMRightJustify = 0;
> + p_bcm_device->PCMRouting = 0;
> + p_bcm_device->PCMShortFrameSync = 0;
> + p_bcm_device->PCMSyncMode = 0;
> +
> + if (!of_property_read_u32(np, "PCMClockMode",
> + &p_bcm_device->PCMClockMode))
> + BT_DBG("PCMClockMode read as %d",
> + p_bcm_device->PCMClockMode);
> + if (!of_property_read_u32(np, "PCMFillMethod",
> + &p_bcm_device->PCMFillMethod))
> + BT_DBG("PCMFillMethod readas %d",
> + p_bcm_device->PCMFillMethod);
> + if (!of_property_read_u32(np, "PCMFillNum",
> + &p_bcm_device->PCMFillNum))
> + BT_DBG("PCMFillNum read as %d",
> + p_bcm_device->PCMFillNum);
> + if (!of_property_read_u32(np, "PCMFillValue",
> + &p_bcm_device->PCMFillValue))
> + BT_DBG("PCMFillValue read as %d",
> + p_bcm_device->PCMFillValue);
> + if (!of_property_read_u32(np, "PCMInCallBitclock",
> + &p_bcm_device->PCMInCallBitclock))
> + BT_DBG("PCMInCallBitclock read as %d",
> + p_bcm_device->PCMInCallBitclock);
> + if (!of_property_read_u32(np, "PCMLSBFirst",
> + &p_bcm_device->PCMLSBFirst))
> + BT_DBG("PCMLSBFirst read as %d",
> + p_bcm_device->PCMLSBFirst);
> + if (!of_property_read_u32(np, "PCMRightJustify",
> + &p_bcm_device->PCMRightJustify))
> + BT_DBG("PCMRightJustify read as %d",
> + p_bcm_device->PCMRightJustify);
> + if (!of_property_read_u32(np, "PCMRouting",
> + &p_bcm_device->PCMRouting))
> + BT_DBG("PCMRouting read as %d",
> + p_bcm_device->PCMRouting);
> + if (!of_property_read_u32(np, "PCMShortFrameSync",
> + &p_bcm_device->PCMShortFrameSync))
> + BT_DBG("PCMShortFrameSync read as %d",
> + p_bcm_device->PCMShortFrameSync);
> + if (!of_property_read_u32(np, "PCMSyncMode",
> + &p_bcm_device->PCMSyncMode))
> + BT_DBG("PCMSyncMode read as %d",
> + p_bcm_device->PCMSyncMode);
> + }
> +
> + if (!of_property_read_string(np, "tty", &tty_name)) {
> + strcpy(p_bcm_device->tty_name, tty_name);
> + BT_DBG("tty name read as %s", p_bcm_device->tty_name);
> + }
> +
> + BT_DBG("idleTimeout set as %d", idleTimeout);
> +
> + ret = 0; /* If we made it here, we're fine */
> +
> + /* Place this instance on the device list */
> + spin_lock(&device_list_lock);
> + list_add_tail(&p_bcm_device->list, &device_list);
> + spin_unlock(&device_list_lock);
> +
> +end:
> + if (ret) {
> + if (p_bcm_device->reg_on_gpio) {
> + gpiod_put(p_bcm_device->reg_on_gpio);
> + p_bcm_device->reg_on_gpio = NULL;
> + }
> + if (p_bcm_device->bt_wake_gpio) {
> + gpiod_put(p_bcm_device->bt_wake_gpio);
> + p_bcm_device->bt_wake_gpio = NULL;
> + }
> + if (p_bcm_device->dev_wake_gpio) {
> + gpiod_put(p_bcm_device->dev_wake_gpio);
> + p_bcm_device->dev_wake_gpio = NULL;
> + }
> + }
> +
> + BT_DBG("bcm_bt_uart_probe with the result %d", ret);
> + return ret;
> +}
> +
> +/*
> + * Device instance removal
> + */
> +static int bcm_bt_uart_remove(struct platform_device *pdev)
> +{
> + struct bcm_device *p_bcm_device = platform_get_drvdata(pdev);
> +
> + if (p_bcm_device == NULL) {
> + BT_DBG("bcm_bt_uart_remove - logic error, no probe?!");
> + return 0;
> + }
> +
> + BT_DBG("bcm_bt_uart_remove %p context", p_bcm_device);
> +
> + spin_lock(&device_list_lock);
> + list_del(&p_bcm_device->list);
> + spin_unlock(&device_list_lock);
> +
> + BT_DBG("bcm_bt_uart_remove - freeing interrupt %d",
> + p_bcm_device->bt_wake_irq);
> + free_irq(p_bcm_device->bt_wake_irq, p_bcm_device);
> +
> + if (p_bcm_device->reg_on_gpio) {
> + BT_DBG("bcm_bt_uart_remove - releasing reg_on_gpio");
> + gpiod_put(p_bcm_device->reg_on_gpio);
> + p_bcm_device->reg_on_gpio = NULL;
> + }
> +
> + if (p_bcm_device->dev_wake_gpio) {
> + BT_DBG("bcm_bt_uart_remove - releasing dev_wake_gpio");
> + gpiod_put(p_bcm_device->dev_wake_gpio);
> + p_bcm_device->dev_wake_gpio = NULL;
> + }
> +
> + if (p_bcm_device->bt_wake_gpio) {
> + BT_DBG("bcm_bt_uart_remove - releasing bt_wake_gpio");
> + gpiod_put(p_bcm_device->bt_wake_gpio);
> + p_bcm_device->bt_wake_gpio = NULL;
> + }
> +
> + BT_DBG("bcm_bt_uart_remove %p done", p_bcm_device);
> + return 0;
> +}
> +
> +/*
> + * Platform resume callback
> + */
> +static int bcm_bt_uart_resume(struct device *pdev)
> +{
> + int resume_flag;
> + struct bcm_device *p_bcm_device = platform_get_drvdata(
> + to_platform_device(pdev));
> +
> + if (p_bcm_device == NULL) {
> + BT_DBG("bcm_bt_uart_resume - logic error, no device?!");
> + return 0;
> + }
> +
> + BT_DBG("bcm_bt_uart_resume %p", p_bcm_device);
> +
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + if (p_bcm_device->dev_wake_gpio) {
> + gpiod_set_value(p_bcm_device->dev_wake_gpio, resume_flag);
> + BT_DBG("bcm_bt_uart_resume: %d written, delaying 15 ms",
> + resume_flag);
> + mdelay(15);
> + }
> +
> + /* Let the protocol know the platform is resuming */
> + if (p_bcm_device->protocol_callbacks.p_resume)
> + p_bcm_device->protocol_callbacks.p_resume(
> + p_bcm_device->protocol_callbacks.context);
> +
> + return 0;
> +}
> +
> +/*
> + * Platform suspend callback
> + */
> +static int bcm_bt_uart_suspend(struct device *pdev)
> +{
> + int resume_flag;
> + struct bcm_device *p_bcm_device = platform_get_drvdata(
> + to_platform_device(pdev));
> +
> + if (p_bcm_device == NULL) {
> + BT_DBG("bcm_bt_uart_suspend - logic error, no device?!");
> + return 0;
> + }
> +
> + BT_DBG("bcm_bt_uart_suspend %p", p_bcm_device);
> +
> + /* Let the protocol know the platform is suspending */
> + if (p_bcm_device->protocol_callbacks.p_suspend)
> + p_bcm_device->protocol_callbacks.p_suspend(
> + p_bcm_device->protocol_callbacks.context);
> +
> +
> + /* Suspend the device */
> + if (p_bcm_device->dev_wake_gpio) {
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + gpiod_set_value(p_bcm_device->dev_wake_gpio, !resume_flag);
> + BT_DBG("bcm_bt_uart_suspend: %d written, delaying 15 ms",
> + !resume_flag);
> + mdelay(15);
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * Entry point for calls from the protocol
> + */
> +int btbcm_uart_control(int action, void *device_context,
> + void *p_data, unsigned long *p_size)
> +{
> + struct btbcm_uart_callbacks *pc;
> + struct btbcm_uart_parameters *pp = p_data; /* for pars action only */
> + int ret = 0;
> + int resume_flag, poweron_flag;
> + struct bcm_device *p_bcm_device = device_context;
> + struct list_head *ptr;
> + bool is_found = false;
> +
> + /* Special processing for the callback configuration */
> + if (action == BTBCM_UART_ACTION_CONFIGURE_CALLBACKS) {
> + pc = p_data;
> +
> + BT_DBG("btbcm_uart_control - configure callbacks");
> + if ((p_data == NULL) || *p_size != sizeof(struct
> + btbcm_uart_callbacks) || (pc->interface_version !=
> + BTBCM_UART_INTERFACE_VERSION)) {
> + BT_DBG("btbcm_uart_control - callbacks mismatch!");
> + return -E2BIG;
> + }
> +
> + BT_DBG("btbcm_uart_control - configure callbacks for %s(%p)",
> + pc->name, pc->context);
> + if (p_bcm_device == NULL) {
> + spin_lock(&device_list_lock);
> + list_for_each(ptr, &device_list) {
> + p_bcm_device = list_entry(ptr, struct
> + bcm_device, list);
> + if (!strcmp(p_bcm_device->tty_name, pc->name)) {
> + is_found = true;
> + break;
> + }
> + }
> +
> + spin_unlock(&device_list_lock);
> + if (!is_found) {
> + BT_DBG("btbcm_uart_control - no device!");
> + return -ENOENT;
> + }
> + }
> +
> + p_bcm_device->protocol_callbacks = *pc;
> + memcpy(p_data, &p_bcm_device, sizeof(p_bcm_device));
> + *p_size = sizeof(p_bcm_device);
> + return ret;
> + }
> +
> + /* All other requests must have the right context */
> + if (p_bcm_device == NULL) {
> + BT_DBG("btbcm_uart_control - failing, no device");
> + return -ENOENT;
> + }
> +
> + switch (action) {
> + case BTBCM_UART_ACTION_POWER_ON:
> + BT_DBG("btbcm_uart_control %p - power on", device_context);
> + if (p_bcm_device->reg_on_gpio) {
> + poweron_flag = !p_bcm_device->reg_on_active_low;
> + gpiod_set_value(p_bcm_device->reg_on_gpio,
> + poweron_flag);
> + BT_DBG("btbcm_uart_control - pwron %d, delay 15 ms",
> + poweron_flag);
> + mdelay(15);
> + }
> + break;
> +
> + case BTBCM_UART_ACTION_POWER_OFF:
> + BT_DBG("btbcm_uart_control %p - power off", device_context);
> + if (p_bcm_device->reg_on_gpio) {
> + poweron_flag = p_bcm_device->reg_on_active_low;
> + gpiod_set_value(p_bcm_device->reg_on_gpio,
> + poweron_flag);
> + BT_DBG("btbcm_uart_control - pwroff %d, delay 15 ms",
> + poweron_flag);
> + mdelay(15);
> + }
> + break;
> +
> + case BTBCM_UART_ACTION_RESUME:
> + BT_DBG("btbcm_uart_control %p - resume", device_context);
> + if (p_bcm_device->dev_wake_gpio) {
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + gpiod_set_value(p_bcm_device->dev_wake_gpio,
> + resume_flag);
> + BT_DBG("btbcm_uart_control - resume %d, delay 15 ms",
> + resume_flag);
> + mdelay(15);
> + }
> + break;
> +
> + case BTBCM_UART_ACTION_SUSPEND:
> + BT_DBG("btbcm_uart_control %p - suspend", device_context);
> + if (p_bcm_device->dev_wake_gpio) {
> + resume_flag = !p_bcm_device->dev_wake_active_low;
> + gpiod_set_value(p_bcm_device->dev_wake_gpio,
> + !resume_flag);
> + BT_DBG("btbcm_uart_control - suspend %d, delay 15ms",
> + !resume_flag);
> + mdelay(15);
> + }
> + break;
> +
> + case BTBCM_UART_ACTION_GET_PARAMETERS:
> + BT_DBG("btbcm_uart_control %p - get pars", device_context);
> + if ((p_data == NULL) ||
> + (*p_size < sizeof(struct btbcm_uart_parameters))) {
> + BT_DBG("btbcm_uart_control - failing, wrong par size");
> + return -E2BIG;
> + }
> +
> + memset(pp, 0, sizeof(struct btbcm_uart_parameters));
> + pp->interface_version = BTBCM_UART_INTERFACE_VERSION;
> + pp->configure_sleep = p_bcm_device->configure_sleep;
> + pp->manual_fc = p_bcm_device->manual_fc;
> + pp->dev_wake_active_low = p_bcm_device->dev_wake_active_low;
> + pp->bt_wake_active_low = p_bcm_device->bt_wake_active_low;
> + pp->idle_timeout_in_secs = idleTimeout;
> + pp->baud_rate_before_config_download =
> + p_bcm_device->baud_rate_before_config_download;
> + pp->configure_audio = p_bcm_device->configure_audio;
> + pp->PCMClockMode = p_bcm_device->PCMClockMode;
> + pp->PCMFillMethod = p_bcm_device->PCMFillMethod;
> + pp->PCMFillNum = p_bcm_device->PCMFillNum;
> + pp->PCMFillValue = p_bcm_device->PCMFillValue;
> + pp->PCMInCallBitclock = p_bcm_device->PCMInCallBitclock;
> + pp->PCMLSBFirst = p_bcm_device->PCMLSBFirst;
> + pp->PCMRightJustify = p_bcm_device->PCMRightJustify;
> + pp->PCMRouting = p_bcm_device->PCMRouting;
> + pp->PCMShortFrameSync = p_bcm_device->PCMShortFrameSync;
> + pp->PCMSyncMode = p_bcm_device->PCMSyncMode;
> + *p_size = sizeof(struct btbcm_uart_parameters);
> + break;
> +
> + default:
> + BT_DBG("btbcm_uart_control %p unknown act %d",
> + device_context, action);
> + ret = -EINVAL;
> + break;
> + }
> +
> + return ret;
> +}
> +EXPORT_SYMBOL(btbcm_uart_control);
> +
> +/* Platform susp and resume callbacks */
> +static SIMPLE_DEV_PM_OPS(bcm_bt_uart_pm_ops,
> + bcm_bt_uart_suspend, bcm_bt_uart_resume);
> +
> +/* Driver match table */
> +static const struct of_device_id bcm_bt_uart_match_table[] = {
> + { .compatible = "brcm,brcm-bt-uart" },
> + {}
> +};
> +
> +/* Driver configuration */
> +static struct platform_driver bcm_bt_uart_platform_driver = {
> + .probe = bcm_bt_uart_probe,
> + .remove = bcm_bt_uart_remove,
> + .driver = {
> + .name = "brcm_bt_uart",
> + .of_match_table = of_match_ptr(bcm_bt_uart_match_table),
> + .owner = THIS_MODULE,
> + .pm = &bcm_bt_uart_pm_ops,
> + },
> +};
> +
> +module_platform_driver(bcm_bt_uart_platform_driver);
> +
> +MODULE_AUTHOR("Ilya Faenson");
> +MODULE_DESCRIPTION("Broadcom Bluetooth UART Driver");
> +MODULE_LICENSE("Dual BSD/GPL");
> +
> diff --git a/drivers/bluetooth/btbcm_uart.h b/drivers/bluetooth/btbcm_uart.h
> new file mode 100755
> index 0000000..d7030f3
> --- /dev/null
> +++ b/drivers/bluetooth/btbcm_uart.h
> @@ -0,0 +1,94 @@
> +/*
> + *
> + * Bluetooth BCM UART Driver Header
> + *
> + * Copyright (c) 2015 Broadcom Corporation
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * 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.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + *
> + */
> +#ifndef BTBCM_UART_H
> +#define BTBCM_UART_H
> +
> +/* Change the version if you change anything in this header */
> +#define BTBCM_UART_INTERFACE_VERSION 1
> +
> +/* Callbacks from the driver into the protocol */
> +typedef void (*p_suspend_callback)(void *context);
> +typedef void (*p_resume_callback)(void *context);
> +typedef void (*p_wakeup_callback)(void *context);
> +struct btbcm_uart_callbacks {
> + int interface_version; /* interface # compiled against */
> + void *context; /* protocol instance context */
> + char name[64]; /* protocol tty device, for example, ttyS0 */
> +
> + /* Callbacks proper */
> + p_suspend_callback p_suspend;
> + p_resume_callback p_resume;
> + p_wakeup_callback p_wakeup;
> +};
> +
> +/* Driver parameters retrieved from the DT or ACPI */
> +struct btbcm_uart_parameters {
> + int interface_version; /* interface # compiled against */
> +
> + /* Parameters proper */
> + int configure_sleep;
> + int manual_fc;
> + int dev_wake_active_low;
> + int bt_wake_active_low;
> + int idle_timeout_in_secs;
> + int baud_rate_before_config_download;
> + int configure_audio;
> + int PCMClockMode;
> + int PCMFillMethod;
> + int PCMFillNum;
> + int PCMFillValue;
> + int PCMInCallBitclock;
> + int PCMLSBFirst;
> + int PCMRightJustify;
> + int PCMRouting;
> + int PCMShortFrameSync;
> + int PCMSyncMode;
> +};
> +
> +/*
> + * Actions on the BTBCM_UART driver
> + */
> +
> +/* Configure protocol callbacks */
> +#define BTBCM_UART_ACTION_CONFIGURE_CALLBACKS 0
> +
> +/* Retrieve BT device parameters */
> +#define BTBCM_UART_ACTION_GET_PARAMETERS 1
> +
> +/* Resume the BT device via GPIO */
> +#define BTBCM_UART_ACTION_RESUME 2
> +
> +/* Suspend the BT device via GPIO */
> +#define BTBCM_UART_ACTION_SUSPEND 3
> +
> +/* Power the BT device off via GPIO */
> +#define BTBCM_UART_ACTION_POWER_OFF 4
> +
> +/* Power the BT device on via GPIO */
> +#define BTBCM_UART_ACTION_POWER_ON 5
> +
> +/* Execute an action on the BT device */
> +extern int btbcm_uart_control(int action, void *device_context,
> + void *p_data, unsigned long *p_size);
> +
> +#endif
> +
> diff --git a/drivers/bluetooth/hci_bcm.c b/drivers/bluetooth/hci_bcm.c
> index 1ec0b4a..789b450 100644
> --- a/drivers/bluetooth/hci_bcm.c
> +++ b/drivers/bluetooth/hci_bcm.c
> @@ -1,8 +1,13 @@
> /*
> *
> - * Bluetooth HCI UART driver for Broadcom devices
> + * Bluetooth UART H4 protocol for Broadcom devices
> *
> - * Copyright (C) 2015 Intel Corporation
> + * Copyright (c) 2015 Intel Corporation
> + * Copyright (c) 2015 Broadcom Corporation
> + *
> + * Acknowledgements:
> + * This file has been based on hci_h4.c originally developed
> + * by Maxim Krasnyansky and Marcel Holtmann.
> *
> *
> * This program is free software; you can redistribute it and/or modify
> @@ -21,133 +26,871 @@
> *
> */
>
> +#include <linux/module.h>
> +
> #include <linux/kernel.h>
> +#include <linux/init.h>
> +#include <linux/types.h>
> +#include <linux/fcntl.h>
> +#include <linux/interrupt.h>
> +#include <linux/ptrace.h>
> +#include <linux/poll.h>
> +
> +#include <linux/slab.h>
> +#include <linux/tty.h>
> #include <linux/errno.h>
> +#include <linux/string.h>
> +#include <linux/signal.h>
> +#include <linux/ioctl.h>
> #include <linux/skbuff.h>
>
> #include <net/bluetooth/bluetooth.h>
> #include <net/bluetooth/hci_core.h>
>
> -#include "btbcm.h"
> +#include <linux/gpio/consumer.h>
> +#include <linux/of_gpio.h>
> +#include <linux/of_platform.h>
> +
> #include "hci_uart.h"
> +#include "btbcm.h"
> +#include "btbcm_uart.h"
>
> -struct bcm_data {
> - struct sk_buff *rx_skb;
> +
> +#define DRIVER_AUTHOR "Ilya Faenson"
> +#define DRIVER_DESC "Broadcom Bluetooth UART Protocol"
> +
> +/* Protocol context */
> +struct bcm_h4_struct {
> struct sk_buff_head txq;
> + struct hci_uart *hu;
> +
> + bool is_suspended; /* suspend/resume flag */
> +
> + /* Recv data parsing is not used in normal operation */
> + bool parse_recv;
> + /* buffer includes the type */
> + unsigned char reassembly[1 + HCI_MAX_FRAME_SIZE];
> + unsigned int rsize;
> + u16 rexpected;
> +
> + struct timer_list timer; /* idle timer */
> +
> + struct btbcm_uart_parameters pars; /* device parameters */
> + void *device_context; /* ACPI/DT device context */
> };
>
> -static int bcm_open(struct hci_uart *hu)
> +/* Static function prototypes for forward references */
> +static void suspend_notification(void *context);
> +static void resume_notification(void *context);
> +static void wakeup_notification(void *context);
> +static void bcm_ensure_wakeup(struct hci_uart *hu);
> +
> +/* Suspend/resume synchronization mutex */
> +static DEFINE_MUTEX(plock);
> +
> +/*
> + * Idle timer callback
> + */
> +static void bcm_idle_timeout(unsigned long arg)
> {
> - struct bcm_data *bcm;
> + struct hci_uart *hu = (struct hci_uart *) arg;
> + struct bcm_h4_struct *h4 = hu->priv;
> + int status;
>
> - BT_DBG("hu %p", hu);
> + BT_DBG("bcm_idle_timeout hu %p", hu);
>
> - bcm = kzalloc(sizeof(*bcm), GFP_KERNEL);
> - if (!bcm)
> + /* Suspend/resume operations are serialized */
> + mutex_lock(&plock);
> +
> + if (!h4->is_suspended) {
> + /* Flow control the port if configured */
> + suspend_notification(hu);
> +
> + /* Suspend the device */
> + status = btbcm_uart_control(BTBCM_UART_ACTION_SUSPEND,
> + h4->device_context, NULL, NULL);
> + if (status)
> + BT_DBG("bcm_idle_timeout failed to suspend device %d",
> + status);
> + }
> +
> + mutex_unlock(&plock);
> +}
> +
> +/*
> + * Initialize protocol
> + */
> +static int bcm_h4_open(struct hci_uart *hu)
> +{
> + struct btbcm_uart_callbacks callbacks;
> + unsigned long callbacks_size = sizeof(callbacks);
> + int status;
> + struct bcm_h4_struct *h4;
> + struct tty_struct *tty = hu->tty;
> +
> + BT_DBG("bcm_h4_open hu %p", hu);
> +
> + h4 = kzalloc(sizeof(*h4), GFP_KERNEL);
> + if (!h4)
> return -ENOMEM;
>
> - skb_queue_head_init(&bcm->txq);
> + skb_queue_head_init(&h4->txq);
> + hu->priv = h4;
> + h4->hu = hu;
> + h4->is_suspended = false;
> + h4->parse_recv = false;
> + h4->rsize = 0;
> +
> + /* Configure callbacks on the driver */
> + callbacks.interface_version = BTBCM_UART_INTERFACE_VERSION;
> + callbacks.context = hu;
> + strcpy(callbacks.name, tty->name);
> + callbacks.p_suspend = suspend_notification;
> + callbacks.p_resume = resume_notification;
> + callbacks.p_wakeup = wakeup_notification;
> + status = btbcm_uart_control(BTBCM_UART_ACTION_CONFIGURE_CALLBACKS,
> + NULL, &callbacks, &callbacks_size);
> + if (status) {
> + BT_DBG("bcm_h4_open failed to set driver callbacks %d", status);
> + return status;
> + }
> + if (callbacks_size != sizeof(void *)) {
> + BT_DBG("bcm_h4_open got back %d bytes from callbacks?!",
> + (int) callbacks_size);
> + return -EMSGSIZE;
> + }
> + memcpy(&h4->device_context, &callbacks, sizeof(void *));
> + BT_DBG("bcm_h4_open callbacks context %p", h4->device_context);
> +
> + /* Retrieve device parameters */
> + callbacks_size = sizeof(h4->pars);
> + status = btbcm_uart_control(BTBCM_UART_ACTION_GET_PARAMETERS,
> + h4->device_context, &h4->pars,
> + &callbacks_size);
> + if (status) {
> + BT_DBG("bcm_h4_open failed to get dev parameters %d", status);
> + return status;
> + }
> + BT_DBG("Pars ver %d csleep %d dalow %d balow %d idle %d",
> + h4->pars.interface_version, h4->pars.configure_sleep,
> + h4->pars.dev_wake_active_low, h4->pars.bt_wake_active_low,
> + h4->pars.idle_timeout_in_secs);
> +
> + /* Cycle power to make sure the device is in the known state */
> + status = btbcm_uart_control(BTBCM_UART_ACTION_POWER_OFF,
> + h4->device_context, NULL, NULL);
> + if (status) {
> + BT_DBG("bcm_h4_open failed to power off %d", status);
> + } else {
> + status = btbcm_uart_control(BTBCM_UART_ACTION_POWER_ON,
> + h4->device_context, NULL, NULL);
> + if (status)
> + BT_DBG("bcm_h4_open failed to power on %d", status);
> + }
> +
> + /* Start the idle timer */
> + if (h4->pars.configure_sleep) {
> + setup_timer(&h4->timer, bcm_idle_timeout, (unsigned long) hu);
> + if (h4->pars.configure_sleep)
> + mod_timer(&h4->timer, jiffies + msecs_to_jiffies(
> + h4->pars.idle_timeout_in_secs * 1000));
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * Flush protocol data
> + */
> +static int bcm_h4_flush(struct hci_uart *hu)
> +{
> + struct bcm_h4_struct *h4 = hu->priv;
> +
> + BT_DBG("bcm_h4_flush hu %p", hu);
>
> - hu->priv = bcm;
> + skb_queue_purge(&h4->txq);
> return 0;
> }
>
> -static int bcm_close(struct hci_uart *hu)
> +/*
> + * Make sure we're awake
> + * (called when the resumed state is required)
> + */
> +static void bcm_ensure_wakeup(struct hci_uart *hu)
> {
> - struct bcm_data *bcm = hu->priv;
> + struct bcm_h4_struct *h4 = hu->priv;
> + int status;
> +
> + if (!h4->pars.configure_sleep)
> + return;
> +
> + /* Suspend/resume operations are serialized */
> + mutex_lock(&plock);
> +
> + /* Nothing to do if resumed already */
> + if (!h4->is_suspended) {
> +
> + mutex_unlock(&plock);
> +
> + /* Just reset the timer */
> + status = mod_timer(&h4->timer, jiffies + msecs_to_jiffies(
> + h4->pars.idle_timeout_in_secs * 1000));
> + return;
> + }
> +
> + /* Wakeup the device */
> + status = btbcm_uart_control(BTBCM_UART_ACTION_RESUME,
> + h4->device_context, NULL, NULL);
> + if (status)
> + BT_DBG("bcm_ensure_wakeup failed to resume driver %d", status);
>
> - BT_DBG("hu %p", hu);
> + /* Unflow control the port if configured */
> + resume_notification(hu);
>
> - skb_queue_purge(&bcm->txq);
> - kfree_skb(bcm->rx_skb);
> - kfree(bcm);
> + mutex_unlock(&plock);
> +}
> +
> +/*
> + * Close protocol
> + */
> +static int bcm_h4_close(struct hci_uart *hu)
> +{
> + struct btbcm_uart_callbacks callbacks;
> + unsigned long callbacks_size = sizeof(callbacks);
> + struct bcm_h4_struct *h4 = hu->priv;
> + int status;
>
> hu->priv = NULL;
> +
> + BT_DBG("bcm_h4_close hu %p", hu);
> +
> + /* If we're being closed, we must suspend */
> + if (h4->pars.configure_sleep) {
> + mutex_lock(&plock);
> +
> + if (!h4->is_suspended) {
> + /* Flow control the port */
> + suspend_notification(hu);
> +
> + /* Suspend the device */
> + status = btbcm_uart_control(BTBCM_UART_ACTION_SUSPEND,
> + h4->device_context, NULL,
> + NULL);
> + if (status) {
> + BT_DBG("bcm_h4_close suspend driver fail %d",
> + status);
> + }
> + }
> +
> + mutex_unlock(&plock);
> +
> + del_timer_sync(&h4->timer);
> + }
> +
> + /* Power off the device if possible */
> + status = btbcm_uart_control(BTBCM_UART_ACTION_POWER_OFF,
> + h4->device_context, NULL, NULL);
> + if (status)
> + BT_DBG("bcm_h4_close failed to power off %d", status);
> +
> + /* de-configure callbacks on the driver */
> + callbacks.interface_version = BTBCM_UART_INTERFACE_VERSION;
> + callbacks.context = hu;
> + callbacks.p_suspend = NULL;
> + callbacks.p_resume = NULL;
> + callbacks.p_wakeup = NULL;
> + status = btbcm_uart_control(BTBCM_UART_ACTION_CONFIGURE_CALLBACKS,
> + h4->device_context, &callbacks,
> + &callbacks_size);
> + if (status)
> + BT_DBG("bcm_h4_close failed to reset drv callbacks %d", status);
> + skb_queue_purge(&h4->txq);
> +
> + hu->priv = NULL;
> + kfree(h4);
> +
> return 0;
> }
>
> -static int bcm_flush(struct hci_uart *hu)
> +#if 0
> +/*
> + * Send command (not currently used)
> + */
> +static int bcm_send_command(struct hci_uart *hu, void *cmd, int cmd_len)
> {
> - struct bcm_data *bcm = hu->priv;
> + struct bcm_h4_struct *h4 = hu->priv;
> + struct sk_buff *skb = bt_skb_alloc(cmd_len, GFP_ATOMIC);
>
> - BT_DBG("hu %p", hu);
> + if (!skb) {
> + BT_DBG("bcm_send_command bt_skb_alloc failure!");
> + return -ENOMEM;
> + }
>
> - skb_queue_purge(&bcm->txq);
> + /* fill in skb */
> + bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
> + memcpy(skb_put(skb, cmd_len), cmd, cmd_len);
>
> + /* Prepend skb with frame type */
> + memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
> + skb_queue_tail(&h4->txq, skb);
> + hci_uart_tx_wakeup(hu);
> return 0;
> }
> +#endif
>
> -static int bcm_setup(struct hci_uart *hu)
> +/*
> + * Enqueue frame for transmittion (padding, crc, etc)
> + */
> +static int bcm_h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
> {
> - BT_DBG("hu %p", hu);
> + struct bcm_h4_struct *h4 = hu->priv;
>
> - hu->hdev->set_bdaddr = btbcm_set_bdaddr;
> + BT_DBG("bcm_h4_enqueue hu %p skb %p type %d len %d (%x %x %x)",
> + hu, skb, bt_cb(skb)->pkt_type, skb->len,
> + skb->data[0], skb->data[1], skb->data[2]);
> +
> + /* Make sure we're resumed */
> + bcm_ensure_wakeup(hu);
> +
> + /* Prepend skb with frame type */
> + memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
> + skb_queue_tail(&h4->txq, skb);
>
> - return btbcm_setup_patchram(hu->hdev);
> + return 0;
> }
>
> -static const struct h4_recv_pkt bcm_recv_pkts[] = {
> - { H4_RECV_ACL, .recv = hci_recv_frame },
> - { H4_RECV_SCO, .recv = hci_recv_frame },
> - { H4_RECV_EVENT, .recv = hci_recv_frame },
> -};
> +/*
> + * HCI event processing if our own parsing of events is required
> + * NOTE: return 0 if the event is not to be passed up to BlueZ
> + */
> +static bool bcm_process_hci_event(struct hci_uart *hu)
> +{
> + struct bcm_h4_struct *h4 = hu->priv;
> + int status;
> + unsigned char evt_code = h4->reassembly[1];
> + unsigned char len = h4->reassembly[2];
>
> -static int bcm_recv(struct hci_uart *hu, const void *data, int count)
> + BT_DBG("bcm_process_hci_event %02x event %02x len %02x %02x",
> + h4->reassembly[0], evt_code, len, h4->reassembly[3]);
> +
> + /* switch (evt_code) { case HCI_EV_CMD_COMPLETE: break } */
> +
> + status = hci_recv_stream_fragment(hu->hdev, h4->reassembly, h4->rsize);
> + if (status < 0)
> + BT_ERR("bcm_process_hci_event - reassembly failed %d", status);
> + return true;
> +}
> +
> +/*
> + * ACL data processing if our own parsing of data is required
> + * NOTE: return 0 if the data is not to be passed up to BlueZ
> + */
> +static bool bcm_process_acl_data(struct hci_uart *hu)
> {
> - struct bcm_data *bcm = hu->priv;
> + struct bcm_h4_struct *h4 = hu->priv;
> + int ret;
> +
> + BT_DBG("bcm_process_acl_data %02x %02x %02x %02x %02x",
> + h4->reassembly[0], h4->reassembly[1], h4->reassembly[2],
> + h4->reassembly[3], h4->reassembly[4]);
>
> - if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
> + ret = hci_recv_stream_fragment(hu->hdev, h4->reassembly, h4->rsize);
> + if (ret < 0)
> + BT_ERR("bcm_process_acl_data - Frame Reassembly Failed");
> + return true;
> +}
> +
> +/*
> + * Fragment parsing in the active filtering phase
> + * (not currently actively used)
> + */
> +static void parse_fragment(struct hci_uart *hu, unsigned char *data, int count)
> +{
> + struct bcm_h4_struct *h4 = hu->priv;
> +
> + if (h4->rsize)
> + BT_DBG("parse_fragment type %x expected %d",
> + h4->reassembly[0], h4->rexpected);
> +
> + while (count) {
> + if (!h4->rsize) {
> + /* Start of the frame */
> + h4->reassembly[0] = *data++;
> + h4->rsize++;
> + count--;
> + continue;
> + }
> +
> + switch (h4->reassembly[0]) {
> + case HCI_EVENT_PKT:
> + if (h4->rsize == 1) {
> + /* event proper */
> + h4->reassembly[h4->rsize++] = *data++;
> + count--;
> + continue;
> + }
> + if (h4->rsize == 2) {
> + /* length */
> + h4->rexpected = *data;
> + h4->reassembly[h4->rsize++] = *data++;
> + count--;
> + BT_DBG("evthdr len %d, left %d", h4->rexpected, count);
> + continue;
> + }
> + if (count >= h4->rexpected) {
> + memcpy(&h4->reassembly[h4->rsize], data, h4->rexpected);
> + h4->rsize += h4->rexpected;
> + data += h4->rexpected;
> + count -= h4->rexpected;
> + bcm_process_hci_event(hu);
> + h4->rsize = 0; /* starting anew */
> + continue;
> + }
> + /* only piece of the event received */
> + memcpy(&h4->reassembly[h4->rsize], data, count);
> + h4->rsize += count;
> + data += count;
> + h4->rexpected -= count;
> + count = 0;
> + break;
> +
> + case HCI_ACLDATA_PKT:
> + if ((h4->rsize == 1) || (h4->rsize == 2) || (h4->rsize == 3)) {
> + /* handle and first byte of length */
> + h4->reassembly[h4->rsize++] = *data++;
> + count--;
> + continue;
> + }
> + if (h4->rsize == 4) {
> + /* last byte of the length */
> + h4->reassembly[h4->rsize++] = *data++;
> + h4->rexpected = h4->reassembly[h4->rsize - 2] +
> + (h4->reassembly[h4->rsize - 1] << 8);
> + count--;
> + BT_DBG("dathdr len %d, left %d", h4->rexpected, count);
> + continue;
> + }
> + if (count >= h4->rexpected) {
> + memcpy(&h4->reassembly[h4->rsize], data, h4->rexpected);
> + h4->rsize += h4->rexpected;
> + data += h4->rexpected;
> + count -= h4->rexpected;
> + bcm_process_acl_data(hu);
> + h4->rsize = 0; /* starting anew */
> + continue;
> + }
> + /* only piece of data received */
> + memcpy(&h4->reassembly[h4->rsize], data, count);
> + h4->rsize += count;
> + data += count;
> + h4->rexpected -= count;
> + count = 0;
> + break;
> +
> + default: /* Note that SCO may NOT come through the UART */
> + if (count >= 3)
> + BT_DBG("unexpected pkt type of %x (%02x %02x %02x)?!",
> + h4->reassembly[0], data[0], data[1], data[2]);
> + else if (count == 2)
> + BT_DBG("unexpected pkt type of %x (%02x %02x)?!",
> + h4->reassembly[0], data[0], data[1]);
> + else if (count == 1)
> + BT_DBG("unexpected pkt type of %x (%02x)?!",
> + h4->reassembly[0], data[0]);
> + else
> + BT_DBG("unexpected pkt type of %x?!",
> + h4->reassembly[0]);
> + h4->rsize = 0;
> + return;
> + }
> + }
> +}
> +
> +/*
> + * Data indication from the line discipline
> + */
> +static int bcm_h4_recv(struct hci_uart *hu, void *data, int count)
> +{
> + struct bcm_h4_struct *h4 = hu->priv;
> + int ret;
> +
> + BT_DBG("bcm_h4_recv hu %p len %d", hu, count);
> +
> + if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) {
> + BT_DBG("h4_recv UART not registered!");
> return -EUNATCH;
> + }
>
> - bcm->rx_skb = h4_recv_buf(hu->hdev, bcm->rx_skb, data, count,
> - bcm_recv_pkts, ARRAY_SIZE(bcm_recv_pkts));
> - if (IS_ERR(bcm->rx_skb)) {
> - int err = PTR_ERR(bcm->rx_skb);
> - BT_ERR("%s: Frame reassembly failed (%d)", hu->hdev->name, err);
> - return err;
> + /* Make sure we're resumed */
> + bcm_ensure_wakeup(hu);
> +
> + /* If we're in the active phase, parse what we get */
> + if (h4->parse_recv) {
> + parse_fragment(hu, data, count);
> + } else {
> + ret = hci_recv_stream_fragment(hu->hdev, data, count);
> + if (ret < 0) {
> + BT_ERR("bcm_h4_recv: frame reassembly failed");
> + return ret;
> + }
> }
>
> return count;
> }
>
> -static int bcm_enqueue(struct hci_uart *hu, struct sk_buff *skb)
> +/*
> + * Line discipline is grabbing a packet from the tx queue
> + */
> +static struct sk_buff *bcm_h4_dequeue(struct hci_uart *hu)
> {
> - struct bcm_data *bcm = hu->priv;
> + struct bcm_h4_struct *h4 = hu->priv;
> + int is_qempty = skb_queue_empty(&h4->txq);
>
> - BT_DBG("hu %p skb %p", hu, skb);
> + if (!is_qempty)
> + BT_DBG("bcm_h4_dequeue with non-empty queue");
> + return skb_dequeue(&h4->txq);
> +}
>
> - /* Prepend skb with frame type */
> - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
> - skb_queue_tail(&bcm->txq, skb);
> +/*
> + * Callbacks from the BCMBT_UART device
> + */
>
> - return 0;
> +/*
> + * The platform is suspending. Stop UART activity
> + */
> +static void suspend_notification(void *context)
> +{
> + struct ktermios ktermios;
> + struct hci_uart *hu = (struct hci_uart *) context;
> + struct bcm_h4_struct *h4 = hu->priv;
> + struct tty_struct *tty = hu->tty;
> + int status;
> + unsigned int set = 0;
> + unsigned int clear = 0;
> +
> + BT_DBG("suspend_notification with is_suspended %d", h4->is_suspended);
> +
> + if (!h4->pars.configure_sleep)
> + return;
> +
> + if (!h4->is_suspended) {
> + if (h4->pars.manual_fc) {
> + /* Disable hardware flow control */
> + ktermios = tty->termios;
> + ktermios.c_cflag &= ~CRTSCTS;
> + status = tty_set_termios(tty, &ktermios);
> + if (status)
> + BT_DBG("suspend_notification dis fc fail %d",
> + status);
> + else
> + BT_DBG("suspend_notification hw fc disabled");
> +
> + /* Clear RTS to prevent the device from sending */
> + /* (most PCs need OUT2 to enable interrupts) */
> + status = tty->driver->ops->tiocmget(tty);
> + BT_DBG("suspend_notification cur tiocm 0x%x", status);
> + set &= ~(TIOCM_OUT2|TIOCM_RTS);
> + clear = ~set;
> + set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + status = tty->driver->ops->tiocmset(tty, set, clear);
> + if (status)
> + BT_DBG("suspend_notification clr RTS fail %d",
> + status);
> + else
> + BT_DBG("suspend_notification RTS cleared");
> + status = tty->driver->ops->tiocmget(tty);
> + BT_DBG("suspend_notification end tiocm 0x%x", status);
> + }
> +
> + /* Once this callback returns, driver suspends BT via GPIO */
> + h4->is_suspended = true;
> + }
> }
>
> -static struct sk_buff *bcm_dequeue(struct hci_uart *hu)
> +/*
> + * The platform is resuming. Resume UART activity.
> + */
> +static void resume_notification(void *context)
> +{
> + struct ktermios ktermios;
> + struct hci_uart *hu = (struct hci_uart *) context;
> + struct bcm_h4_struct *h4 = hu->priv;
> + struct tty_struct *tty = hu->tty;
> + int status;
> + unsigned int set = 0;
> + unsigned int clear = 0;
> +
> + BT_DBG("resume_notification with is_suspended %d", h4->is_suspended);
> +
> + if (!h4->pars.configure_sleep)
> + return;
> +
> + /* When this callback executes, the device has woken up already */
> + if (h4->is_suspended) {
> + h4->is_suspended = false;
> +
> + if (h4->pars.manual_fc) {
> + status = tty->driver->ops->tiocmget(tty);
> + BT_DBG("resume_notification cur tiocm 0x%x", status);
> + set |= (TIOCM_OUT2|TIOCM_RTS);
> + clear = ~set;
> + set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + status = tty->driver->ops->tiocmset(tty, set, clear);
> + if (status)
> + BT_DBG("resume_notification set RTS fail %d",
> + status);
> + else
> + BT_DBG("resume_notification RTS set");
> +
> + /* Re-enable hardware flow control */
> + ktermios = tty->termios;
> + ktermios.c_cflag |= CRTSCTS;
> + status = tty_set_termios(tty, &ktermios);
> + if (status)
> + BT_DBG("resume_notification enable fc fail %d",
> + status);
> + else
> + BT_DBG("resume_notification hw fc re-enabled");
> + }
> + }
> +
> + /* If we're resumed, the idle timer must be running */
> + status = mod_timer(&h4->timer, jiffies +
> + msecs_to_jiffies(h4->pars.idle_timeout_in_secs * 1000));
> +}
> +
> +/*
> + * The BT device is resuming. Resume UART activity if suspended
> + */
> +static void wakeup_notification(void *context)
> {
> - struct bcm_data *bcm = hu->priv;
> + struct ktermios ktermios;
> + struct hci_uart *hu = (struct hci_uart *) context;
> + struct bcm_h4_struct *h4 = hu->priv;
> + struct tty_struct *tty = hu->tty;
> + int status;
> + unsigned int set = 0;
> + unsigned int clear = 0;
> +
> + if (!h4->pars.configure_sleep)
> + return;
> +
> + status = tty->driver->ops->tiocmget(tty);
> + BT_DBG("wakeup_notification hu %p current tiocm 0x%x", hu, status);
> + if (h4->is_suspended) {
> + if (h4->pars.manual_fc) {
> + set |= (TIOCM_OUT2|TIOCM_RTS);
> + clear = ~set;
> + set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|
> + TIOCM_LOOP;
> + status = tty->driver->ops->tiocmset(tty, set, clear);
> + if (status)
> + BT_DBG("wakeup_notification set RTS fail %d",
> + status);
> + else
> + BT_DBG("wakeup_notification RTS set");
> +
> + /* Re-enable hardware flow control */
> + ktermios = tty->termios;
> + ktermios.c_cflag |= CRTSCTS;
> + status = tty_set_termios(tty, &ktermios);
> + if (status)
> + BT_DBG("wakeup_notification fc-en failure %d",
> + status);
> + else
> + BT_DBG("wakeup_notification hw fc re-enabled");
> + }
> +
> + h4->is_suspended = false;
> + }
> +
> + /* If we're resumed, the idle timer must be running */
> + status = mod_timer(&h4->timer, jiffies + msecs_to_jiffies(
> + h4->pars.idle_timeout_in_secs * 1000));
> +}
> +
> +/*
> + * Device setup that follows the protocol open
> + */
> +static int bcm_h4_setup(struct hci_uart *hu)
> +{
> + struct bcm_h4_struct *h4 = hu->priv;
> + int status;
> + struct sk_buff *skb;
> + unsigned char sleep_pars[] = {
> + 0x01, /* sleep mode 1=UART */
> + 0x02, /* idle threshold HOST (value * 300ms) */
> + 0x02, /* idle threshold HC (value * 300ms) */
> + 0x01, /* BT_WAKE active mode - 1=active high, 0 = active low */
> + 0x00, /* HOST_WAKE active mode - 1=active high, 0 = active low */
> + 0x01, /* Allow host sleep during SCO - FALSE */
> + 0x01, /* combine sleep mode and LPM - 1 == TRUE */
> + 0x00, /* enable tristate control of UART TX line - FALSE */
> + 0x00, /* USB auto-sleep on USB SUSPEND */
> + 0x00, /* USB USB RESUME timeout (seconds) */
> + 0x00, /* Pulsed Host Wake */
> + 0x00 /* Enable Break To Host */
> + };
> + unsigned char pcm_int_pars[] = {
> + 0x00, /* 0=PCM routing, 1=SCO over HCI */
> + 0x02, /* 0=128Kbps,1=256Kbps,2=512Kbps,3=1024Kbps,4=2048Kbps */
> + 0x00, /* short frame sync 0=short, 1=long */
> + 0x00, /* sync mode 0=slave, 1=master */
> + 0x00 /* clock mode 0=slave, 1=master */
> + };
> + unsigned char pcm_format_pars[] = {
> + 0x00, /* LSB_First 1=TRUE, 0=FALSE */
> + 0x00, /* Fill_Value (use 0-7 for fill bits value) */
> + 0x02, /* Fill_Method (2=sign extended) */
> + 0x03, /* Fill_Num # of fill bits 0-3) */
> + 0x01 /* Right_Justify 1=TRUE, 0=FALSE */
> + };
> + unsigned char time_slot_number = 0;
> +
> + BT_DBG("bcm_h4_setup hu %p", hu);
> +
> + /* Bring the UART into known default state */
> + status = btbcm_init_uart(hu);
> + if (status) {
> + BT_DBG("bcm_h4_setup failed to init BT device %d", status);
> + return status;
> + }
> +
> + /* Basic sanity check */
> + skb = __hci_cmd_sync(hu->hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("bcm_h4_setup HCI Reset failed (%d)", status);
> + return status;
> + }
> + kfree_skb(skb);
> + BT_DBG("bcm_h4_setup HCI Reset succeeded");
> +
> + /* Set the new baud rate */
> + status = btbcm_set_baud_rate(hu,
> + h4->pars.baud_rate_before_config_download);
> + if (status) {
> + BT_ERR("bcm_h4_setup set_baud_rate faiilure %d", status);
> + return status;
> + }
> +
> + hu->hdev->set_bdaddr = btbcm_set_bdaddr;
> +
> + /* Download the firmware and reconfigure the UART afterwards */
> + status = btbcm_setup_patchram(hu->hdev);
> + if (status) {
> + BT_ERR("bcm_h4_setup setup_patchram faiilure %d", status);
> + return status;
> + }
>
> - return skb_dequeue(&bcm->txq);
> + /* Configure SCO PCM parameters */
> + if (h4->pars.configure_audio) {
> + pcm_int_pars[0] = h4->pars.PCMRouting;
> + pcm_int_pars[1] = h4->pars.PCMInCallBitclock;
> + pcm_int_pars[2] = h4->pars.PCMShortFrameSync;
> + pcm_int_pars[3] = h4->pars.PCMSyncMode;
> + pcm_int_pars[4] = h4->pars.PCMClockMode;
> + skb = __hci_cmd_sync(hu->hdev, 0xfc1c, sizeof(pcm_int_pars),
> + pcm_int_pars, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("bcm_h4_setup PCM INT VSC failed (%d)", status);
> + return status;
> + }
> + kfree_skb(skb);
> + BT_DBG("bcm_h4_setup PCM INT Parameters VSC succeeded");
> +
> + pcm_format_pars[0] = h4->pars.PCMLSBFirst;
> + pcm_format_pars[1] = h4->pars.PCMFillValue;
> + pcm_format_pars[2] = h4->pars.PCMFillMethod;
> + pcm_format_pars[3] = h4->pars.PCMFillNum;
> + pcm_format_pars[4] = h4->pars.PCMRightJustify;
> + skb = __hci_cmd_sync(hu->hdev, 0xfc1e, sizeof(pcm_format_pars),
> + pcm_format_pars, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("bcm_h4_setup PCM Format VSC failed (%d)",
> + status);
> + return status;
> + }
> + kfree_skb(skb);
> + BT_DBG("bcm_h4_setup PCM Format VSC succeeded");
> +
> + skb = __hci_cmd_sync(hu->hdev, 0xfc22, sizeof(time_slot_number),
> + &time_slot_number, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("bcm_h4_setup SCO Time Slot VSC failed (%d)",
> + status);
> + return status;
> + }
> + kfree_skb(skb);
> + BT_DBG("bcm_h4_setup SCO Time Slot VSC succeeded");
> + }
> +
> + /* Configure device's suspend/resume operation */
> + if (h4->pars.configure_sleep) {
> + /* Override the default */
> + sleep_pars[3] = (unsigned char)!h4->pars.bt_wake_active_low;
> + sleep_pars[4] = (unsigned char)!h4->pars.dev_wake_active_low;
> + skb = __hci_cmd_sync(hu->hdev, 0xfc27, sizeof(sleep_pars),
> + sleep_pars, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + status = PTR_ERR(skb);
> + BT_ERR("bcm_h4_setup Sleep VSC failed (%d)", status);
> + return status;
> + }
> + kfree_skb(skb);
> + BT_DBG("bcm_h4_setup Set Sleep Parameters VSC succeeded");
> + }
> +
> + return 0;
> }
>
> -static const struct hci_uart_proto bcm_proto = {
> +/*
> + * Protocol callbacks
> + */
> +static struct hci_uart_proto h4p = {
> .id = HCI_UART_BCM,
> - .name = "BCM",
> - .open = bcm_open,
> - .close = bcm_close,
> - .flush = bcm_flush,
> - .setup = bcm_setup,
> - .recv = bcm_recv,
> - .enqueue = bcm_enqueue,
> - .dequeue = bcm_dequeue,
> + .name = "UARTBCM",
> + .open = bcm_h4_open,
> + .close = bcm_h4_close,
> + .flush = bcm_h4_flush,
> + .setup = bcm_h4_setup,
> + .recv = bcm_h4_recv,
> + .enqueue = bcm_h4_enqueue,
> + .dequeue = bcm_h4_dequeue,
> };
>
> +/*
> + * Protocol init
> + */
> int __init bcm_init(void)
> {
> - return hci_uart_register_proto(&bcm_proto);
> + int status = hci_uart_register_proto(&h4p);
> +
> + if (!status)
> + BT_INFO("Broadcom H4 protocol initialized");
> + else
> + BT_ERR("Broadcom H4 protocol registration failed %d", status);
> +
> + return status;
> }
>
> +/*
> + * Protocol shutdown
> + */
> int __exit bcm_deinit(void)
> {
> - return hci_uart_unregister_proto(&bcm_proto);
> + BT_INFO("Broadcom H4 protocol de-initialized");
> + return hci_uart_unregister_proto(&h4p);
> }
> +
Could you run ./scripts/checkpatch.pl for your patches?
./scripts/checkpatch.pl
0001-Add-Broadcom-Bluetooth-UART-device-support.patch
WARNING: please write a paragraph that describes the config symbol fully
#79: FILE: drivers/bluetooth/Kconfig:146:
+config BT_UART_BCM
ERROR: do not set execute permissions for source files
#410: FILE: drivers/bluetooth/btbcm_uart.c
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#410:
new file mode 100755
ERROR: Do not include the paragraph about writing to the Free Software
Foundation's mailing address from the sample GPL notice. The FSF has
changed addresses in the past, and may do so again. Linux already
includes a copy of the GPL.
#432: FILE: drivers/bluetooth/btbcm_uart.c:18:
+ * along with this program; if not, write to the Free Software$
ERROR: Do not include the paragraph about writing to the Free Software
Foundation's mailing address from the sample GPL notice. The FSF has
changed addresses in the past, and may do so again. Linux already
includes a copy of the GPL.
#433: FILE: drivers/bluetooth/btbcm_uart.c:19:
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA$
WARNING: 'alow' may be misspelled - perhaps 'allow'?
#588: FILE: drivers/bluetooth/btbcm_uart.c:174:
+ BT_DBG("bcm_bt_uart_probe - dev_wake alow is %d (cans %d)",
WARNING: 'alow' may be misspelled - perhaps 'allow'?
#624: FILE: drivers/bluetooth/btbcm_uart.c:210:
+ BT_DBG("bcm_bt_uart_probe - reg_on alow is %d (cans %d)",
WARNING: 'alow' may be misspelled - perhaps 'allow'?
#669: FILE: drivers/bluetooth/btbcm_uart.c:255:
+ BT_DBG("bcm_bt_uart_probe - bt_wake alow is %d(cans%d)",
ERROR: do not set execute permissions for source files
#1100: FILE: drivers/bluetooth/btbcm_uart.h
ERROR: Do not include the paragraph about writing to the Free Software
Foundation's mailing address from the sample GPL notice. The FSF has
changed addresses in the past, and may do so again. Linux already
includes a copy of the GPL.
#1122: FILE: drivers/bluetooth/btbcm_uart.h:18:
+ * along with this program; if not, write to the Free Software$
ERROR: Do not include the paragraph about writing to the Free Software
Foundation's mailing address from the sample GPL notice. The FSF has
changed addresses in the past, and may do so again. Linux already
includes a copy of the GPL.
#1123: FILE: drivers/bluetooth/btbcm_uart.h:19:
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA$
total: 6 errors, 5 warnings, 2077 lines checked
0001-Add-Broadcom-Bluetooth-UART-device-support.patch has style
problems, please review.
If any of these errors are false positives, please report
them to the maintainer, see CHECKPATCH in MAINTAINERS.
Thanks
Chanyeol
^ permalink raw reply [flat|nested] 4+ messages in thread