Add support for FM radio in hcill and kill TI_ST

From: Sebastian Reichel <[email protected]>

Add a node for the UART part of WiLink chip.

Cc Adam Ford <[email protected]>

Signed-off-by Sebastian Reichel <[email protected]>

---
This is compile tested only!

---
 arch/arm/boot/dts/logicpd-torpedo-37xx-devkit.dts | 8 ++++++++
 1 file changed, 8 insertions(+)

arch/arm/boot/dts/logicpd-torpedo-37xx-devkit.dts +8 -1

index 9d5d53fbe9c0..2699da12dc2d 100644
@@ -54,6 +54,14 @@
        };
 };
 
+&uart2 {
+       bluetooth {
+               compatible = "ti,wl1283-st";
+               enable-gpios = <&gpio6 2 GPIO_ACTIVE_HIGH>; /* gpio 162 */
+               max-speed = <3000000>;
+       };
+};
+
 &omap3_pmx_core {
        mmc3_pins: pinmux_mm3_pins {
                pinctrl-single,pins = <
--

2.19.2

From: Sebastian Reichel <[email protected]>

Add a node for the UART part of WiLink chip.

Cc Enric Balletbo i Serra <[email protected]>

Signed-off-by Sebastian Reichel <[email protected]>

---
This is compile tested only!

---
 arch/arm/boot/dts/omap3-igep0020-rev-f.dts | 8 ++++++++
 arch/arm/boot/dts/omap3-igep0030-rev-g.dts | 8 ++++++++
 2 files changed, 16 insertions(+)

arch/arm/boot/dts/omap3-igep0020-rev-f.dts +0 -0

index 285681d7af49..8bb4298ca05e 100644

arch/arm/boot/dts/omap3-igep0020-rev-f.dts +4 -0

+               enable-gpios = <&gpio5 9 GPIO_ACTIVE_HIGH>; /* gpio 137 */
+               max-speed = <300000>;
+       };
+};

arch/arm/boot/dts/omap3-igep0030-rev-g.dts +0 -0

index 1adc73bd2ca0..03be171e9de7 100644

arch/arm/boot/dts/omap3-igep0030-rev-g.dts +4 -1

+               enable-gpios = <&gpio5 9 GPIO_ACTIVE_HIGH>; /* gpio 137 */
+               max-speed = <300000>;
+       };
+};
--

2.19.2

From: Sebastian Reichel <[email protected]>

Move global radio_disconnected into device structure to prepare converting this driver into a normal platform device driver supporting multiple instances.

Signed-off-by Sebastian Reichel <[email protected]>

From: Sebastian Reichel <[email protected]>

Move global radio_dev into device structure to prepare converting this driver into a normal platform device driver supporting multiple instances.

Signed-off-by Sebastian Reichel <[email protected]>

From: Sebastian Reichel <[email protected]>

This converts the wl128x FM radio module into a platform device. It's a preparation for using it from hci_ll Bluetooth driver instead of TI_ST.

Signed-off-by Sebastian Reichel <[email protected]>

From: Sebastian Reichel <[email protected]>

This simplifies memory allocation and removes a few useless errors in case of -ENOMEM errors.

Signed-off-by Sebastian Reichel <[email protected]>

From: Sebastian Reichel <[email protected]>

Remove unused return code from fmc_prepare() and fmc_release() to simplify the code a bit.

/*
* This function will be called from FM V4L2 release function.
* Unregister from ST driver.
*/

drivers/media/radio/wl128x/fmdrv_common.c +2 -2

-int fmc_release(struct fmdev *fmdev)
+void fmc_release(struct fmdev *fmdev)
 {
 	static struct st_proto_s fm_st_proto;
 	int ret;
 
 	if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
 		fmdbg("FM Core is already down\n");
-		return 0;
+		return;
 	}
 	/* Service pending read */
 	wake_up_interruptible(&fmdev->rx.rds.read_queue);

Quoted 26 lines · Sebastian Reichel

From: Sebastian Reichel <[email protected]>

Remove unused return code from fmc_prepare() and fmc_release() to simplify the code a bit.

/*
* This function will be called from FM V4L2 release function.
* Unregister from ST driver.
*/

drivers/media/radio/wl128x/fmdrv_common.c +2 -2

-int fmc_release(struct fmdev *fmdev)
+void fmc_release(struct fmdev *fmdev)
 {
 	static struct st_proto_s fm_st_proto;
 	int ret;
 
 	if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
 		fmdbg("FM Core is already down\n");
-		return 0;
+		return;
 	}
 	/* Service pending read */
 	wake_up_interruptible(&fmdev->rx.rds.read_queue);

@@ -1611,7 +1606,6 @@ int fmc_release(struct fmdev *fmdev)
 		fmdbg("Successfully unregistered from ST\n");
 

drivers/media/radio/wl128x/fmdrv_common.c int fmc_release(struct fmdev *fmdev) · line 1609

Quoted 3 lines

drivers/media/radio/wl128x/fmdrv_common.c +0 -1

 	clear_bit(FM_CORE_READY, &fmdev->flag);
-	return ret;
 }

You probably leave unused variable (ret) here. I guess that's okay as you remove it later in the series...?

Also... I'd kind of expect _prepare routine to return int. Even if it currently does not do anything that could return error, I'd kind of expect allocations being done there...

From: Sebastian Reichel <[email protected]>

This fixes incorrect code in the TX/RX skb debug print function and add stubs in receive/transmit packet path.

Signed-off-by Sebastian Reichel <[email protected]>

This updates the wl128x-radio driver to be used with hci_ll instead of the deprecated TI_ST driver.

Signed-off-by Sebastian Reichel <[email protected]>

---

drivers/bluetooth/hci_ll.c                | 115 ++++++++++++++++++++--
drivers/media/radio/wl128x/Kconfig        |   2 +-
drivers/media/radio/wl128x/fmdrv.h        |   1 +
drivers/media/radio/wl128x/fmdrv_common.c | 101 ++-----------------
include/linux/ti_wilink_st.h              |   2 +
5 files changed, 117 insertions(+), 104 deletions(-)

drivers/bluetooth/hci_ll.c +6 -0

index 3e767f245ed5..6bcba57e9c9c 100644
@@ -49,6 +49,7 @@
 #include <linux/skbuff.h>
 #include <linux/ti_wilink_st.h>
 #include <linux/clk.h>
+#include <linux/platform_device.h>
 
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>

@@ -62,6 +63,7 @@
 #define HCI_VS_UPDATE_UART_HCI_BAUDRATE		0xff36
 
 /* HCILL commands */
+#define HCILL_FM_RADIO		0x08
 #define HCILL_GO_TO_SLEEP_IND	0x30
 #define HCILL_GO_TO_SLEEP_ACK	0x31
 #define HCILL_WAKE_UP_IND	0x32

@@ -81,6 +83,10 @@ struct ll_device {
 	struct gpio_desc *enable_gpio;
 	struct clk *ext_clk;
 	bdaddr_t bdaddr;
+
+	struct platform_device *fmdev;
+	void (*fm_handler) (void *, struct sk_buff *);
+	void *fm_drvdata;
 };
 
 struct ll_struct {

@@ -161,6 +167,35 @@ static int ll_flush(struct hci_uart *hu)
 	return 0;
 }

drivers/bluetooth/hci_ll.c +37 -8

+	err = PTR_ERR_OR_ZERO(lldev->fmdev);
+	if (err) {
+		dev_warn(dev, "cannot register FM radio subdevice: %d\n", err);
+		lldev->fmdev = NULL;
+	}
+
+	return err;
+}
+
+static void ll_unregister_fm(struct ll_device *lldev)
+{
+	if (!lldev->fmdev)
+		return;
+	platform_device_unregister(lldev->fmdev);
+	lldev->fmdev = NULL;
+}
+
 /* Close protocol */
 static int ll_close(struct hci_uart *hu)
 {

@@ -178,6 +213,8 @@ static int ll_close(struct hci_uart *hu)
 		gpiod_set_value_cansleep(lldev->enable_gpio, 0);
 
 		clk_disable_unprepare(lldev->ext_clk);
+
+		ll_unregister_fm(lldev);
 	}
 
 	hu->priv = NULL;

@@ -313,18 +350,11 @@ static void ll_device_woke_up(struct hci_uart *hu)
 	hci_uart_tx_wakeup(hu);
 }
 
-/* Enqueue frame for transmittion (padding, crc, etc) */
-/* may be called from two simultaneous tasklets */
-static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb)
+static int ll_enqueue_prefixed(struct hci_uart *hu, struct sk_buff *skb)
 {
 	unsigned long flags = 0;
 	struct ll_struct *ll = hu->priv;
 
-	BT_DBG("hu %p skb %p", hu, skb);
-
-	/* Prepend skb with frame type */
-	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
-
 	/* lock hcill state */
 	spin_lock_irqsave(&ll->hcill_lock, flags);
 

@@ -361,6 +391,18 @@ static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 	return 0;
 }
 
+/* Enqueue frame for transmittion (padding, crc, etc) */
+/* may be called from two simultaneous tasklets */
+static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb)
+{
+	BT_DBG("hu %p skb %p", hu, skb);
+
+	/* Prepend skb with frame type */
+	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
+
+	return ll_enqueue_prefixed(hu, skb);
+}
+
 static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb)
 {
 	struct hci_uart *hu = hci_get_drvdata(hdev);

@@ -390,6 +432,32 @@ static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb)
 	return 0;
 }
 
+static int ll_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
+{
+	struct hci_uart *hu = hci_get_drvdata(hdev);
+	struct serdev_device *serdev = hu->serdev;
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);

drivers/bluetooth/hci_ll.c +24 -0

+
+	return 0;
+}
+
+#define LL_RECV_FM_RADIO \
+	.type = HCILL_FM_RADIO, \
+	.hlen = 1, \
+	.loff = 0, \
+	.lsize = 1, \
+	.maxlen = 0xff
+
 #define LL_RECV_SLEEP_IND \
 	.type = HCILL_GO_TO_SLEEP_IND, \
 	.hlen = 0, \

@@ -422,6 +490,7 @@ static const struct h4_recv_pkt ll_recv_pkts[] = {
 	{ H4_RECV_ACL,       .recv = hci_recv_frame },
 	{ H4_RECV_SCO,       .recv = hci_recv_frame },
 	{ H4_RECV_EVENT,     .recv = hci_recv_frame },
+	{ LL_RECV_FM_RADIO,  .recv = ll_recv_radio },
 	{ LL_RECV_SLEEP_IND, .recv = ll_recv_frame  },
 	{ LL_RECV_SLEEP_ACK, .recv = ll_recv_frame  },
 	{ LL_RECV_WAKE_IND,  .recv = ll_recv_frame  },

@@ -669,11 +738,41 @@ static int ll_setup(struct hci_uart *hu)
 		}
 	}
 
+	/* We intentionally ignore failures and proceed without FM device */
+	ll_register_fm(lldev);
+
 	return 0;
 }
 
 static const struct hci_uart_proto llp;
 
+void hci_ti_set_fm_handler(struct device *dev, void (*recv_handler) (void *, struct sk_buff *), void *drvdata)
+{
+	struct serdev_device *serdev = to_serdev_device(dev);
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);
+
+	lldev->fm_drvdata = drvdata;
+	lldev->fm_handler = recv_handler;
+}
+EXPORT_SYMBOL_GPL(hci_ti_set_fm_handler);

drivers/bluetooth/hci_ll.c +8 -0

+
+	if (!ret)
+		hci_uart_tx_wakeup(hu);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(hci_ti_fm_send);
+
 static int hci_ti_probe(struct serdev_device *serdev)
 {
 	struct hci_uart *hu;

drivers/media/radio/wl128x/Kconfig +0 -0

index 64b66bbdae72..847b3ed92639 100644
@@ -4,7 +4,7 @@

menu "Texas Instruments WL128x FM driver (ST based)" config RADIO_WL128X
tristate "Texas Instruments WL128x FM Radio"

drivers/media/radio/wl128x/Kconfig +1 -1

-	depends on VIDEO_V4L2 && RFKILL && TTY && TI_ST
+	depends on VIDEO_V4L2 && RFKILL && TTY && BT_HCIUART_LL

	depends on GPIOLIB || COMPILE_TEST
	help
	  Choose Y here if you have this FM radio chip.

drivers/media/radio/wl128x/fmdrv.h +1 -0

index 4a337f38cfc9..717a8a3f533f 100644
@@ -197,6 +197,7 @@ struct fmtx_data {
 
 /* FM driver operation structure */
 struct fmdev {
+	struct device *dev;
 	struct video_device radio_dev;	/* V4L2 video device pointer */
 	struct v4l2_device v4l2_dev;	/* V4L2 top level struct */
 	struct snd_card *card;	/* Card which holds FM mixer controls */

drivers/media/radio/wl128x/fmdrv_common.c +6 -95

index c20d518af4f3..88a2197c4815 100644
@@ -172,9 +172,6 @@ static int_handler_prototype int_handler_table[] = {
 	fm_irq_handle_intmsk_cmd_resp
 };
 
-static long (*g_st_write) (struct sk_buff *skb);
-static struct completion wait_for_fmdrv_reg_comp;
-
 static inline void fm_irq_call(struct fmdev *fmdev)
 {
 	fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev);

@@ -373,7 +370,7 @@ static void send_tasklet(unsigned long arg)
 
 	/* Write FM packet to ST driver */
 	dump_tx_skb_data(skb);
-	len = g_st_write(skb);
+	len = hci_ti_fm_send(fmdev->dev->parent, skb);
 	if (len < 0) {
 		kfree_skb(skb);
 		fmdev->resp_comp = NULL;

@@ -1441,42 +1438,13 @@ int fmc_get_mode(struct fmdev *fmdev, u8 *fmmode)
 }
 
 /* Called by ST layer when FM packet is available */
-static long fm_st_receive(void *arg, struct sk_buff *skb)
+static void fm_st_receive(void *arg, struct sk_buff *skb)
 {
-	struct fmdev *fmdev;
-
-	fmdev = (struct fmdev *)arg;
-
-	if (skb == NULL) {
-		fmerr("Invalid SKB received from ST\n");
-		return -EFAULT;
-	}
-
-	if (skb->cb[0] != FM_PKT_LOGICAL_CHAN_NUMBER) {
-		fmerr("Received SKB (%p) is not FM Channel 8 pkt\n", skb);
-		return -EINVAL;
-	}
+	struct fmdev *fmdev = (struct fmdev *) arg;
 
-	memcpy(skb_push(skb, 1), &skb->cb[0], 1);
 	dump_rx_skb_data(skb);
-
 	skb_queue_tail(&fmdev->rx_q, skb);
 	tasklet_schedule(&fmdev->rx_task);
-
-	return 0;
-}
-
-/*
- * Called by ST layer to indicate protocol registration completion
- * status.
- */
-static void fm_st_reg_comp_cb(void *arg, int data)
-{
-	struct fmdev *fmdev;
-
-	fmdev = (struct fmdev *)arg;
-	fmdev->streg_cbdata = data;
-	complete(&wait_for_fmdrv_reg_comp);
 }
 
 /*

@@ -1485,59 +1453,12 @@ static void fm_st_reg_comp_cb(void *arg, int data)
 */
 void fmc_prepare(struct fmdev *fmdev)
 {
-	static struct st_proto_s fm_st_proto;
-
 	if (test_bit(FM_CORE_READY, &fmdev->flag)) {
 		fmdbg("FM Core is already up\n");
 		return;
 	}
 
-	memset(&fm_st_proto, 0, sizeof(fm_st_proto));
-	fm_st_proto.recv = fm_st_receive;
-	fm_st_proto.match_packet = NULL;
-	fm_st_proto.reg_complete_cb = fm_st_reg_comp_cb;
-	fm_st_proto.write = NULL; /* TI ST driver will fill write pointer */
-	fm_st_proto.priv_data = fmdev;
-	fm_st_proto.chnl_id = 0x08;
-	fm_st_proto.max_frame_size = 0xff;
-	fm_st_proto.hdr_len = 1;
-	fm_st_proto.offset_len_in_hdr = 0;
-	fm_st_proto.len_size = 1;
-	fm_st_proto.reserve = 1;
-
-	ret = st_register(&fm_st_proto);
-	if (ret == -EINPROGRESS) {
-		init_completion(&wait_for_fmdrv_reg_comp);
-		fmdev->streg_cbdata = -EINPROGRESS;
-		fmdbg("%s waiting for ST reg completion signal\n", __func__);
-
-		if (!wait_for_completion_timeout(&wait_for_fmdrv_reg_comp,
-						 FM_ST_REG_TIMEOUT)) {
-			fmerr("Timeout(%d sec), didn't get reg completion signal from ST\n",
-					jiffies_to_msecs(FM_ST_REG_TIMEOUT) / 1000);
-			return -ETIMEDOUT;
-		}
-		if (fmdev->streg_cbdata != 0) {
-			fmerr("ST reg comp CB called with error status %d\n",
-			      fmdev->streg_cbdata);
-			return -EAGAIN;
-		}
-
-		ret = 0;
-	} else if (ret == -1) {
-		fmerr("st_register failed %d\n", ret);
-		return -EAGAIN;
-	}
-
-	if (fm_st_proto.write != NULL) {
-		g_st_write = fm_st_proto.write;
-	} else {
-		fmerr("Failed to get ST write func pointer\n");
-		ret = st_unregister(&fm_st_proto);
-		if (ret < 0)
-			fmerr("st_unregister failed %d\n", ret);
-		return -EAGAIN;
-	}
+	hci_ti_set_fm_handler(fmdev->dev->parent, fm_st_receive, fmdev);
 
 	spin_lock_init(&fmdev->rds_buff_lock);
 	spin_lock_init(&fmdev->resp_skb_lock);

@@ -1582,9 +1503,6 @@ void fmc_prepare(struct fmdev *fmdev)
 */
 void fmc_release(struct fmdev *fmdev)
 {
-	static struct st_proto_s fm_st_proto;
-	int ret;
-
 	if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
 		fmdbg("FM Core is already down\n");
 		return;

@@ -1601,15 +1519,7 @@ void fmc_release(struct fmdev *fmdev)
 	fmdev->resp_comp = NULL;
 	fmdev->rx.freq = 0;
 
-	memset(&fm_st_proto, 0, sizeof(fm_st_proto));
-	fm_st_proto.chnl_id = 0x08;
-
-	ret = st_unregister(&fm_st_proto);
-
-	if (ret < 0)
-		fmerr("Failed to de-register FM from ST %d\n", ret);
-	else
-		fmdbg("Successfully unregistered from ST\n");
+	hci_ti_set_fm_handler(fmdev->dev->parent, NULL, NULL);
 
 	clear_bit(FM_CORE_READY, &fmdev->flag);
 }

@@ -1624,6 +1534,7 @@ static int wl128x_fm_probe(struct platform_device *pdev)
 	if (!fmdev)
 		return -ENOMEM;
 	platform_set_drvdata(pdev, fmdev);
+	fmdev->dev = &pdev->dev;
 
 	fmdev->rx.rds.buf_size = default_rds_buf * FM_RDS_BLK_SIZE;
 	fmdev->rx.rds.buff = devm_kzalloc(&pdev->dev, fmdev->rx.rds.buf_size, GFP_KERNEL);

include/linux/ti_wilink_st.h +0 -0

index f2293028ab9d..a9de5654b0cd 100644

Hi Sebastian,

Quoted 5 lines

drivers/bluetooth/hci_ll.c +5 -0

+static int ll_register_fm(struct ll_device *lldev)
+{
+	struct device *dev = &lldev->serdev->dev;
+	int err;
+

drivers/bluetooth/hci_ll.c static int ll_flush(struct hci_uart *hu) · line 178

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	if (!of_device_is_compatible(dev->of_node, "ti,wl1281-st") &&
+	    !of_device_is_compatible(dev->of_node, "ti,wl1283-st") &&
+	    !of_device_is_compatible(dev->of_node, "ti,wl1285-st"))
+		return -ENODEV;

do we really want to hardcode this here? Isn't there some HCI vendor command or some better DT description that we can use to decide when to register this platform device.

drivers/bluetooth/hci_ll.c static int ll_flush(struct hci_uart *hu) · line 181

Quoted 2 lines

drivers/bluetooth/hci_ll.c +2 -0

+	lldev->fmdev = platform_device_register_data(dev, "wl128x-fm",
+		PLATFORM_DEVID_AUTO, NULL, 0);

Fix the indentation please to following networking coding style.

Quoted 11 lines

drivers/bluetooth/hci_ll.c +11 -0

+static int ll_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
+{
+	struct hci_uart *hu = hci_get_drvdata(hdev);
+	struct serdev_device *serdev = hu->serdev;
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);
+
+	if (!lldev->fm_handler) {
+		kfree_skb(skb);
+		return -EINVAL;
+	}
+

drivers/bluetooth/hci_ll.c static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) · line 449

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	/* Prepend skb with frame type */
+	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
+
+	lldev->fm_handler(lldev->fm_drvdata, skb);

So I have no idea why we bother adding the frame type here. What is the purpose. I think this is useless and we better fix the radio driver if that is what is expected.

Quoted 2 lines

drivers/bluetooth/hci_ll.c +2 -0

+	return 0;
+}

Quoted 5 lines

drivers/bluetooth/hci_ll.c +5 -0

+int hci_ti_fm_send(struct device *dev, struct sk_buff *skb)
+{
+	struct serdev_device *serdev = to_serdev_device(dev);
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);
+	struct hci_uart *hu = &lldev->hu;

drivers/bluetooth/hci_ll.c static int ll_setup(struct hci_uart *hu) · line 767

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	int ret;
+
+	hci_skb_pkt_type(skb) = HCILL_FM_RADIO;
+	ret = ll_enqueue_prefixed(hu, skb);

This is the same as above, lets have the radio driver not add this H:4 protocol type in the first place. It is really pointless that this driver tries to hack around it.

Quoted 8 lines

include/linux/ti_wilink_st.h +0 -0

index f2293028ab9d..a9de5654b0cd 100644
@@ -86,6 +86,8 @@ struct st_proto_s {
 extern long st_register(struct st_proto_s *);
 extern long st_unregister(struct st_proto_s *);
 

include/linux/ti_wilink_st.h struct st_proto_s { · line 90

Quoted 2 lines

include/linux/ti_wilink_st.h +2 -0

+void hci_ti_set_fm_handler(struct device *dev, void (*recv_handler) (void *, struct sk_buff *), void *drvdata);
+int hci_ti_fm_send(struct device *dev, struct sk_buff *skb);

This really needs to be put somewhere else if we are removing the TI Wilink driver. This header file has to be removed as well.

I wonder really if we are not better having the Bluetooth HCI core provide an abstraction for a vendor channel. So that the HCI packets actually can flow through HCI monitor and be recorded via btmon. This would also mean that the driver could do something like hci_vnd_chan_add() and hci_vnd_chan_del() and use a struct hci_vnd_chan for callback handler hci_vnd_chan_send() functions.

On a side note, what is the protocol the TI FM radio is using anyway? Is that anywhere documented except the driver itself? Are they using HCI commands as well?

Quoted 5 lines

Quoted 5 lines

drivers/bluetooth/hci_ll.c +5 -0

+static int ll_register_fm(struct ll_device *lldev)
+{
+	struct device *dev = &lldev->serdev->dev;
+	int err;
+

Quoted 8 lines

drivers/bluetooth/hci_ll.c static int ll_flush(struct hci_uart *hu) · line 178

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	if (!of_device_is_compatible(dev->of_node, "ti,wl1281-st") &&
+	    !of_device_is_compatible(dev->of_node, "ti,wl1283-st") &&
+	    !of_device_is_compatible(dev->of_node, "ti,wl1285-st"))
+		return -ENODEV;

do we really want to hardcode this here? Isn't there some HCI vendor command or some better DT description that we can use to decide when to register this platform device.

I don't know if there is some way to identify the availability based on some HCI vendor command. The public documentation from the WiLink chips is pretty bad.

Quoted 5 lines

drivers/bluetooth/hci_ll.c static int ll_flush(struct hci_uart *hu) · line 181

Quoted 3 lines

drivers/bluetooth/hci_ll.c +2 -0

+	lldev->fmdev = platform_device_register_data(dev, "wl128x-fm",
+		PLATFORM_DEVID_AUTO, NULL, 0);

Fix the indentation please to following networking coding style.

Ok.

[...]

Quoted 11 lines

Quoted 11 lines

drivers/bluetooth/hci_ll.c +11 -0

+static int ll_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
+{
+	struct hci_uart *hu = hci_get_drvdata(hdev);
+	struct serdev_device *serdev = hu->serdev;
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);
+
+	if (!lldev->fm_handler) {
+		kfree_skb(skb);
+		return -EINVAL;
+	}
+

Quoted 8 lines

drivers/bluetooth/hci_ll.c static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) · line 449

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	/* Prepend skb with frame type */
+	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
+
+	lldev->fm_handler(lldev->fm_drvdata, skb);

So I have no idea why we bother adding the frame type here. What is the purpose. I think this is useless and we better fix the radio driver if that is what is expected.

That should be possible. I will change this before sending another revision.

Quoted 2 lines

Quoted 2 lines

drivers/bluetooth/hci_ll.c +2 -0

+	return 0;
+}

[...]

Quoted 5 lines

Quoted 5 lines

drivers/bluetooth/hci_ll.c +5 -0

+int hci_ti_fm_send(struct device *dev, struct sk_buff *skb)
+{
+	struct serdev_device *serdev = to_serdev_device(dev);
+	struct ll_device *lldev = serdev_device_get_drvdata(serdev);
+	struct hci_uart *hu = &lldev->hu;

Quoted 8 lines

drivers/bluetooth/hci_ll.c static int ll_setup(struct hci_uart *hu) · line 767

Quoted 4 lines

drivers/bluetooth/hci_ll.c +4 -0

+	int ret;
+
+	hci_skb_pkt_type(skb) = HCILL_FM_RADIO;
+	ret = ll_enqueue_prefixed(hu, skb);

This is the same as above, lets have the radio driver not add this H:4 protocol type in the first place. It is really pointless that this driver tries to hack around it.

Yes, obviously both paths should follow the same logic.

[...]

Quoted 8 lines

Quoted 8 lines

include/linux/ti_wilink_st.h +0 -0

index f2293028ab9d..a9de5654b0cd 100644
@@ -86,6 +86,8 @@ struct st_proto_s {
 extern long st_register(struct st_proto_s *);
 extern long st_unregister(struct st_proto_s *);
 

Quoted 5 lines

include/linux/ti_wilink_st.h struct st_proto_s { · line 90

Quoted 2 lines

include/linux/ti_wilink_st.h +2 -0

+void hci_ti_set_fm_handler(struct device *dev, void (*recv_handler) (void *, struct sk_buff *), void *drvdata);
+int hci_ti_fm_send(struct device *dev, struct sk_buff *skb);

This really needs to be put somewhere else if we are removing the TI Wilink driver. This header file has to be removed as well.

That header is already being used by the hci_ll driver (before this patch) for some packet structures. I removed all WiLink specific things in the patch removing the TI WiLink driver and kept it otherwise.

Quoted 7 lines

I wonder really if we are not better having the Bluetooth HCI core provide an abstraction for a vendor channel. So that the HCI packets actually can flow through HCI monitor and be recorded via btmon. This would also mean that the driver could do something like hci_vnd_chan_add() and hci_vnd_chan_del() and use a struct hci_vnd_chan for callback handler hci_vnd_chan_send() functions.

Was this question directed to me? I trust your decision how this should be implemented. I'm missing the big picture from other BT devices ;)

If I understood you correctly the suggestion is, that the TI BT driver uses hci_recv_frame() for packet type 0x08 (LL_RECV_FM_RADIO). Then the FM driver can call hci_vnd_chan_add() in its probe function and hci_vnd_chan_del() in its remove function to register the receive hook? Also the dump_tx_skb_data()/dump_rx_skb_data() could be removed, since btmon can be used to see the packets? Sounds very nice to me.

Quoted 3 lines

On a side note, what is the protocol the TI FM radio is using anyway? Is that anywhere documented except the driver itself? Are they using HCI commands as well?

AFAIK there is no public documentation for the TI WiLink chips. At least my only information source are the existing drivers. The driver protocol can be seen in drivers/media/radio/wl128x/fmdrv_common.h:

struct fm_cmd_msg_hdr {
	__u8 hdr;		/* Logical Channel-8 */
	__u8 len;		/* Number of bytes follows */
	__u8 op;		/* FM Opcode */
	__u8 rd_wr;		/* Read/Write command */
	__u8 dlen;		/* Length of payload */
} __attribute__ ((packed));

struct fm_event_msg_hdr {
	__u8 header;		/* Logical Channel-8 */
	__u8 len;		/* Number of bytes follows */
	__u8 status;		/* Event status */
	__u8 num_fm_hci_cmds;	/* Number of pkts the host allowed to send */
	__u8 op;		/* FM Opcode */
	__u8 rd_wr;		/* Read/Write command */
	__u8 dlen;		/* Length of payload */
} __attribute__ ((packed));

Apart from the Bluetooth and FM part, the chips also support GPS (packet type 0x9). The GPS feature is not used on Droid 4 stock rom and seems to carry some TI specific protocol instead of NMEA. Here is an old submission for this driver:
http://lkml.iu.edu/hypermail/linux/kernel/1005.0/00918.html

(I don't plan to work on the GPS part, but it provides some more details about the WiLink chips protocol)

Hi Sebastian,

Quoted 14 lines

Quoted 13 lines

drivers/bluetooth/hci_ll.c static int ll_flush(struct hci_uart *hu) · line 178

Quoted 9 lines

drivers/bluetooth/hci_ll.c +9 -0

+static int ll_register_fm(struct ll_device *lldev)
+{
+   struct device *dev = &lldev->serdev->dev;
+   int err;
+
+   if (!of_device_is_compatible(dev->of_node, "ti,wl1281-st") &&
+       !of_device_is_compatible(dev->of_node, "ti,wl1283-st") &&
+       !of_device_is_compatible(dev->of_node, "ti,wl1285-st"))
+           return -ENODEV;

do we really want to hardcode this here? Isn't there some HCI vendor command or some better DT description that we can use to decide when to register this platform device.

Quoted 3 lines

I don't know if there is some way to identify the availability based on some HCI vendor command. The public documentation from the WiLink chips is pretty bad.

can we have some boolean property in the DT file then instead of hardcoding this in the driver.

From: Sebastian Reichel <[email protected]>

This driver has been superseded by the serdev based Bluetooth hci_ll driver, which is initialized from DT. All mainline users have been converted and this driver can be safely dropped.

Signed-off-by Sebastian Reichel <[email protected]>

---
 drivers/misc/Kconfig         |   1 -
 drivers/misc/Makefile        |   1 -
 drivers/misc/ti-st/Kconfig   |  18 -
 drivers/misc/ti-st/Makefile  |   6 -
 drivers/misc/ti-st/st_core.c | 922 -----------------------------------
 drivers/misc/ti-st/st_kim.c  | 868 ---------------------------------
 drivers/misc/ti-st/st_ll.c   | 169 -------
 include/linux/ti_wilink_st.h | 335 -------------
 8 files changed, 2320 deletions(-)
 delete mode 100644 drivers/misc/ti-st/Kconfig
 delete mode 100644 drivers/misc/ti-st/Makefile
 delete mode 100644 drivers/misc/ti-st/st_core.c
 delete mode 100644 drivers/misc/ti-st/st_kim.c
 delete mode 100644 drivers/misc/ti-st/st_ll.c

drivers/misc/Kconfig +0 -1

index 3726eacdf65d..a5cc07d33c74 100644
@@ -516,7 +516,6 @@ config MISC_RTSX
 source "drivers/misc/c2port/Kconfig"
 source "drivers/misc/eeprom/Kconfig"
 source "drivers/misc/cb710/Kconfig"
-source "drivers/misc/ti-st/Kconfig"
 source "drivers/misc/lis3lv02d/Kconfig"
 source "drivers/misc/altera-stapl/Kconfig"
 source "drivers/misc/mei/Kconfig"

drivers/misc/Makefile +0 -1

index af22bbc3d00c..31c1e3eb4952 100644
@@ -39,7 +39,6 @@ obj-y                         += cb710/
 obj-$(CONFIG_SPEAR13XX_PCIE_GADGET)    += spear13xx_pcie_gadget.o
 obj-$(CONFIG_VMWARE_BALLOON)   += vmw_balloon.o
 obj-$(CONFIG_PCH_PHUB)         += pch_phub.o
-obj-y                          += ti-st/
 obj-y                          += lis3lv02d/
 obj-$(CONFIG_USB_SWITCH_FSA9480) += fsa9480.o
 obj-$(CONFIG_ALTERA_STAPL)     +=altera-stapl/

drivers/misc/ti-st/Kconfig deleted +0 -18

deleted file mode 100644
index 5bb92698bc80..000000000000
@@ -1,18 +0,0 @@
-#
-# TI's shared transport line discipline and the protocol
-# drivers (BT, FM and GPS)
-#
-menu "Texas Instruments shared transport line discipline"
-config TI_ST
-       tristate "Shared transport core driver"
-       depends on NET && TTY
-       depends on GPIOLIB || COMPILE_TEST
-       select FW_LOADER
-       help
-         This enables the shared transport core driver for TI
-         BT / FM and GPS combo chips. This enables protocol drivers
-         to register themselves with core and send data, the responses
-         are returned to relevant protocol drivers based on their
-         packet types.
-
-endmenu

drivers/misc/ti-st/Makefile deleted +0 -6

deleted file mode 100644
index 78d7ebb14749..000000000000
@@ -1,6 +0,0 @@
-#
-# Makefile for TI's shared transport line discipline
-# and its protocol drivers (BT, FM, GPS)
-#
-obj-$(CONFIG_TI_ST)            += st_drv.o
-st_drv-objs                    := st_core.o st_kim.o st_ll.o

drivers/misc/ti-st/st_core.c deleted +0 -922

deleted file mode 100644
index eda8d407be28..000000000000
@@ -1,922 +0,0 @@
-/*
- *  Shared Transport Line discipline driver Core
- *     This hooks up ST KIM driver and ST LL driver
- *  Copyright (C) 2009-2010 Texas Instruments
- *  Author: Pavan Savoy <[email protected]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License 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.
- *
- *  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
- *
- */
-
-#define pr_fmt(fmt)    "(stc): " fmt
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/tty.h>
-
-#include <linux/seq_file.h>
-#include <linux/skbuff.h>
-
-#include <linux/ti_wilink_st.h>
-
-extern void st_kim_recv(void *, const unsigned char *, long);
-void st_int_recv(void *, const unsigned char *, long);
-/* function pointer pointing to either,
- * st_kim_recv during registration to receive fw download responses
- * st_int_recv after registration to receive proto stack responses
- */
-static void (*st_recv) (void *, const unsigned char *, long);
-
-/********************************************************************/
-static void add_channel_to_table(struct st_data_s *st_gdata,
-               struct st_proto_s *new_proto)
-{
-       pr_info("%s: id %d\n", __func__, new_proto->chnl_id);
-       /* list now has the channel id as index itself */
-       st_gdata->list[new_proto->chnl_id] = new_proto;
-       st_gdata->is_registered[new_proto->chnl_id] = true;
-}
-
-static void remove_channel_from_table(struct st_data_s *st_gdata,
-               struct st_proto_s *proto)
-{
-       pr_info("%s: id %d\n", __func__, proto->chnl_id);
-/*     st_gdata->list[proto->chnl_id] = NULL; */
-       st_gdata->is_registered[proto->chnl_id] = false;
-}
-
-/*
- * called from KIM during firmware download.
- *
- * This is a wrapper function to tty->ops->write_room.
- * It returns number of free space available in
- * uart tx buffer.
- */
-int st_get_uart_wr_room(struct st_data_s *st_gdata)
-{
-       struct tty_struct *tty;
-       if (unlikely(st_gdata == NULL || st_gdata->tty == NULL)) {
-               pr_err("tty unavailable to perform write");
-               return -1;
-       }
-       tty = st_gdata->tty;
-       return tty->ops->write_room(tty);
-}
-
-/* can be called in from
- * -- KIM (during fw download)
- * -- ST Core (during st_write)
- *
- *  This is the internal write function - a wrapper
- *  to tty->ops->write
- */
-int st_int_write(struct st_data_s *st_gdata,
-       const unsigned char *data, int count)
-{
-       struct tty_struct *tty;
-       if (unlikely(st_gdata == NULL || st_gdata->tty == NULL)) {
-               pr_err("tty unavailable to perform write");
-               return -EINVAL;
-       }
-       tty = st_gdata->tty;
-#ifdef VERBOSE
-       print_hex_dump(KERN_DEBUG, "<out<", DUMP_PREFIX_NONE,
-               16, 1, data, count, 0);
-#endif
-       return tty->ops->write(tty, data, count);
-
-}
-
-/*
- * push the skb received to relevant
- * protocol stacks
- */
-static void st_send_frame(unsigned char chnl_id, struct st_data_s *st_gdata)
-{
-       pr_debug(" %s(prot:%d) ", __func__, chnl_id);
-
-       if (unlikely
-           (st_gdata == NULL || st_gdata->rx_skb == NULL
-            || st_gdata->is_registered[chnl_id] == false)) {
-               pr_err("chnl_id %d not registered, no data to send?",
-                          chnl_id);
-               kfree_skb(st_gdata->rx_skb);
-               return;
-       }
-       /* this cannot fail
-        * this shouldn't take long
-        * - should be just skb_queue_tail for the
-        *   protocol stack driver
-        */
-       if (likely(st_gdata->list[chnl_id]->recv != NULL)) {
-               if (unlikely
-                       (st_gdata->list[chnl_id]->recv
-                       (st_gdata->list[chnl_id]->priv_data, st_gdata->rx_skb)
-                            != 0)) {
-                       pr_err(" proto stack %d's ->recv failed", chnl_id);
-                       kfree_skb(st_gdata->rx_skb);
-                       return;
-               }
-       } else {
-               pr_err(" proto stack %d's ->recv null", chnl_id);
-               kfree_skb(st_gdata->rx_skb);
-       }
-       return;
-}
-
-/**
- * st_reg_complete -
- * to call registration complete callbacks
- * of all protocol stack drivers
- * This function is being called with spin lock held, protocol drivers are
- * only expected to complete their waits and do nothing more than that.
- */
-static void st_reg_complete(struct st_data_s *st_gdata, int err)
-{
-       unsigned char i = 0;
-       pr_info(" %s ", __func__);
-       for (i = 0; i < ST_MAX_CHANNELS; i++) {
-               if (likely(st_gdata != NULL &&
-                       st_gdata->is_registered[i] == true &&
-                               st_gdata->list[i]->reg_complete_cb != NULL)) {
-                       st_gdata->list[i]->reg_complete_cb
-                               (st_gdata->list[i]->priv_data, err);
-                       pr_info("protocol %d's cb sent %d\n", i, err);
-                       if (err) { /* cleanup registered protocol */
-                               st_gdata->is_registered[i] = false;
-                               if (st_gdata->protos_registered)
-                                       st_gdata->protos_registered--;
-                       }
-               }
-       }
-}
-
-static inline int st_check_data_len(struct st_data_s *st_gdata,
-       unsigned char chnl_id, int len)
-{
-       int room = skb_tailroom(st_gdata->rx_skb);
-
-       pr_debug("len %d room %d", len, room);
-
-       if (!len) {
-               /* Received packet has only packet header and
-                * has zero length payload. So, ask ST CORE to
-                * forward the packet to protocol driver (BT/FM/GPS)
-                */
-               st_send_frame(chnl_id, st_gdata);
-
-       } else if (len > room) {
-               /* Received packet's payload length is larger.
-                * We can't accommodate it in created skb.
-                */
-               pr_err("Data length is too large len %d room %d", len,
-                          room);
-               kfree_skb(st_gdata->rx_skb);
-       } else {
-               /* Packet header has non-zero payload length and
-                * we have enough space in created skb. Lets read
-                * payload data */
-               st_gdata->rx_state = ST_W4_DATA;
-               st_gdata->rx_count = len;
-               return len;
-       }
-
-       /* Change ST state to continue to process next
-        * packet */
-       st_gdata->rx_state = ST_W4_PACKET_TYPE;
-       st_gdata->rx_skb = NULL;
-       st_gdata->rx_count = 0;
-       st_gdata->rx_chnl = 0;
-
-       return 0;
-}
-
-/**
- * st_wakeup_ack - internal function for action when wake-up ack
- *     received
- */
-static inline void st_wakeup_ack(struct st_data_s *st_gdata,
-       unsigned char cmd)
-{
-       struct sk_buff *waiting_skb;
-       unsigned long flags = 0;
-
-       spin_lock_irqsave(&st_gdata->lock, flags);
-       /* de-Q from waitQ and Q in txQ now that the
-        * chip is awake
-        */
-       while ((waiting_skb = skb_dequeue(&st_gdata->tx_waitq)))
-               skb_queue_tail(&st_gdata->txq, waiting_skb);
-
-       /* state forwarded to ST LL */
-       st_ll_sleep_state(st_gdata, (unsigned long)cmd);
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-
-       /* wake up to send the recently copied skbs from waitQ */
-       st_tx_wakeup(st_gdata);
-}
-
-/**
- * st_int_recv - ST's internal receive function.
- *     Decodes received RAW data and forwards to corresponding
- *     client drivers (Bluetooth,FM,GPS..etc).
- *     This can receive various types of packets,
- *     HCI-Events, ACL, SCO, 4 types of HCI-LL PM packets
- *     CH-8 packets from FM, CH-9 packets from GPS cores.
- */
-void st_int_recv(void *disc_data,
-       const unsigned char *data, long count)
-{
-       char *ptr;
-       struct st_proto_s *proto;
-       unsigned short payload_len = 0;
-       int len = 0;
-       unsigned char type = 0;
-       unsigned char *plen;
-       struct st_data_s *st_gdata = (struct st_data_s *)disc_data;
-       unsigned long flags;
-
-       ptr = (char *)data;
-       /* tty_receive sent null ? */
-       if (unlikely(ptr == NULL) || (st_gdata == NULL)) {
-               pr_err(" received null from TTY ");
-               return;
-       }
-
-       pr_debug("count %ld rx_state %ld"
-                  "rx_count %ld", count, st_gdata->rx_state,
-                  st_gdata->rx_count);
-
-       spin_lock_irqsave(&st_gdata->lock, flags);
-       /* Decode received bytes here */
-       while (count) {
-               if (st_gdata->rx_count) {
-                       len = min_t(unsigned int, st_gdata->rx_count, count);
-                       skb_put_data(st_gdata->rx_skb, ptr, len);
-                       st_gdata->rx_count -= len;
-                       count -= len;
-                       ptr += len;
-
-                       if (st_gdata->rx_count)
-                               continue;
-
-                       /* Check ST RX state machine , where are we? */
-                       switch (st_gdata->rx_state) {
-                       /* Waiting for complete packet ? */
-                       case ST_W4_DATA:
-                               pr_debug("Complete pkt received");
-                               /* Ask ST CORE to forward
-                                * the packet to protocol driver */
-                               st_send_frame(st_gdata->rx_chnl, st_gdata);
-
-                               st_gdata->rx_state = ST_W4_PACKET_TYPE;
-                               st_gdata->rx_skb = NULL;
-                               continue;
-                       /* parse the header to know details */
-                       case ST_W4_HEADER:
-                               proto = st_gdata->list[st_gdata->rx_chnl];
-                               plen =
-                               &st_gdata->rx_skb->data
-                               [proto->offset_len_in_hdr];
-                               pr_debug("plen pointing to %x\n", *plen);
-                               if (proto->len_size == 1)/* 1 byte len field */
-                                       payload_len = *(unsigned char *)plen;
-                               else if (proto->len_size == 2)
-                                       payload_len =
-                                       __le16_to_cpu(*(unsigned short *)plen);
-                               else
-                                       pr_info("%s: invalid length "
-                                       "for id %d\n",
-                                       __func__, proto->chnl_id);
-                               st_check_data_len(st_gdata, proto->chnl_id,
-                                               payload_len);
-                               pr_debug("off %d, pay len %d\n",
-                                       proto->offset_len_in_hdr, payload_len);
-                               continue;
-                       }       /* end of switch rx_state */
-               }
-
-               /* end of if rx_count */
-               /* Check first byte of packet and identify module
-                * owner (BT/FM/GPS) */
-               switch (*ptr) {
-               case LL_SLEEP_IND:
-               case LL_SLEEP_ACK:
-               case LL_WAKE_UP_IND:
-                       pr_debug("PM packet");
-                       /* this takes appropriate action based on
-                        * sleep state received --
-                        */
-                       st_ll_sleep_state(st_gdata, *ptr);
-                       /* if WAKEUP_IND collides copy from waitq to txq
-                        * and assume chip awake
-                        */
-                       spin_unlock_irqrestore(&st_gdata->lock, flags);
-                       if (st_ll_getstate(st_gdata) == ST_LL_AWAKE)
-                               st_wakeup_ack(st_gdata, LL_WAKE_UP_ACK);
-                       spin_lock_irqsave(&st_gdata->lock, flags);
-
-                       ptr++;
-                       count--;
-                       continue;
-               case LL_WAKE_UP_ACK:
-                       pr_debug("PM packet");
-
-                       spin_unlock_irqrestore(&st_gdata->lock, flags);
-                       /* wake up ack received */
-                       st_wakeup_ack(st_gdata, *ptr);
-                       spin_lock_irqsave(&st_gdata->lock, flags);
-
-                       ptr++;
-                       count--;
-                       continue;
-                       /* Unknow packet? */
-               default:
-                       type = *ptr;
-
-                       /* Default case means non-HCILL packets,
-                        * possibilities are packets for:
-                        * (a) valid protocol -  Supported Protocols within
-                        *     the ST_MAX_CHANNELS.
-                        * (b) registered protocol - Checked by
-                        *     "st_gdata->list[type] == NULL)" are supported
-                        *     protocols only.
-                        *  Rules out any invalid protocol and
-                        *  unregistered protocols with channel ID < 16.
-                        */
-
-                       if ((type >= ST_MAX_CHANNELS) ||
-                                       (st_gdata->list[type] == NULL)) {
-                               pr_err("chip/interface misbehavior: "
-                                               "dropping frame starting "
-                                               "with 0x%02x\n", type);
-                               goto done;
-                       }
-
-                       st_gdata->rx_skb = alloc_skb(
-                                       st_gdata->list[type]->max_frame_size,
-                                       GFP_ATOMIC);
-                       if (st_gdata->rx_skb == NULL) {
-                               pr_err("out of memory: dropping\n");
-                               goto done;
-                       }
-
-                       skb_reserve(st_gdata->rx_skb,
-                                       st_gdata->list[type]->reserve);
-                       /* next 2 required for BT only */
-                       st_gdata->rx_skb->cb[0] = type; /*pkt_type*/
-                       st_gdata->rx_skb->cb[1] = 0; /*incoming*/
-                       st_gdata->rx_chnl = *ptr;
-                       st_gdata->rx_state = ST_W4_HEADER;
-                       st_gdata->rx_count = st_gdata->list[type]->hdr_len;
-                       pr_debug("rx_count %ld\n", st_gdata->rx_count);
-               };
-               ptr++;
-               count--;
-       }
-done:
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-       pr_debug("done %s", __func__);
-       return;
-}
-
-/**
- * st_int_dequeue - internal de-Q function.
- *     If the previous data set was not written
- *     completely, return that skb which has the pending data.
- *     In normal cases, return top of txq.
- */
-static struct sk_buff *st_int_dequeue(struct st_data_s *st_gdata)
-{
-       struct sk_buff *returning_skb;
-
-       pr_debug("%s", __func__);
-       if (st_gdata->tx_skb != NULL) {
-               returning_skb = st_gdata->tx_skb;
-               st_gdata->tx_skb = NULL;
-               return returning_skb;
-       }
-       return skb_dequeue(&st_gdata->txq);
-}
-
-/**
- * st_int_enqueue - internal Q-ing function.
- *     Will either Q the skb to txq or the tx_waitq
- *     depending on the ST LL state.
- *     If the chip is asleep, then Q it onto waitq and
- *     wakeup the chip.
- *     txq and waitq needs protection since the other contexts
- *     may be sending data, waking up chip.
- */
-static void st_int_enqueue(struct st_data_s *st_gdata, struct sk_buff *skb)
-{
-       unsigned long flags = 0;
-
-       pr_debug("%s", __func__);
-       spin_lock_irqsave(&st_gdata->lock, flags);
-
-       switch (st_ll_getstate(st_gdata)) {
-       case ST_LL_AWAKE:
-               pr_debug("ST LL is AWAKE, sending normally");
-               skb_queue_tail(&st_gdata->txq, skb);
-               break;
-       case ST_LL_ASLEEP_TO_AWAKE:
-               skb_queue_tail(&st_gdata->tx_waitq, skb);
-               break;
-       case ST_LL_AWAKE_TO_ASLEEP:
-               pr_err("ST LL is illegal state(%ld),"
-                          "purging received skb.", st_ll_getstate(st_gdata));
-               kfree_skb(skb);
-               break;
-       case ST_LL_ASLEEP:
-               skb_queue_tail(&st_gdata->tx_waitq, skb);
-               st_ll_wakeup(st_gdata);
-               break;
-       default:
-               pr_err("ST LL is illegal state(%ld),"
-                          "purging received skb.", st_ll_getstate(st_gdata));
-               kfree_skb(skb);
-               break;
-       }
-
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-       pr_debug("done %s", __func__);
-       return;
-}
-
-/*
- * internal wakeup function
- * called from either
- * - TTY layer when write's finished
- * - st_write (in context of the protocol stack)
- */
-static void work_fn_write_wakeup(struct work_struct *work)
-{
-       struct st_data_s *st_gdata = container_of(work, struct st_data_s,
-                       work_write_wakeup);
-
-       st_tx_wakeup((void *)st_gdata);
-}
-void st_tx_wakeup(struct st_data_s *st_data)
-{
-       struct sk_buff *skb;
-       unsigned long flags;    /* for irq save flags */
-       pr_debug("%s", __func__);
-       /* check for sending & set flag sending here */
-       if (test_and_set_bit(ST_TX_SENDING, &st_data->tx_state)) {
-               pr_debug("ST already sending");
-               /* keep sending */
-               set_bit(ST_TX_WAKEUP, &st_data->tx_state);
-               return;
-               /* TX_WAKEUP will be checked in another
-                * context
-                */
-       }
-       do {                    /* come back if st_tx_wakeup is set */
-               /* woke-up to write */
-               clear_bit(ST_TX_WAKEUP, &st_data->tx_state);
-               while ((skb = st_int_dequeue(st_data))) {
-                       int len;
-                       spin_lock_irqsave(&st_data->lock, flags);
-                       /* enable wake-up from TTY */
-                       set_bit(TTY_DO_WRITE_WAKEUP, &st_data->tty->flags);
-                       len = st_int_write(st_data, skb->data, skb->len);
-                       skb_pull(skb, len);
-                       /* if skb->len = len as expected, skb->len=0 */
-                       if (skb->len) {
-                               /* would be the next skb to be sent */
-                               st_data->tx_skb = skb;
-                               spin_unlock_irqrestore(&st_data->lock, flags);
-                               break;
-                       }
-                       kfree_skb(skb);
-                       spin_unlock_irqrestore(&st_data->lock, flags);
-               }
-               /* if wake-up is set in another context- restart sending */
-       } while (test_bit(ST_TX_WAKEUP, &st_data->tx_state));
-
-       /* clear flag sending */
-       clear_bit(ST_TX_SENDING, &st_data->tx_state);
-}
-
-/********************************************************************/
-/* functions called from ST KIM
-*/
-void kim_st_list_protocols(struct st_data_s *st_gdata, void *buf)
-{
-       seq_printf(buf, "[%d]\nBT=%c\nFM=%c\nGPS=%c\n",
-                       st_gdata->protos_registered,
-                       st_gdata->is_registered[0x04] == true ? 'R' : 'U',
-                       st_gdata->is_registered[0x08] == true ? 'R' : 'U',
-                       st_gdata->is_registered[0x09] == true ? 'R' : 'U');
-}
-
-/********************************************************************/
-/*
- * functions called from protocol stack drivers
- * to be EXPORT-ed
- */
-long st_register(struct st_proto_s *new_proto)
-{
-       struct st_data_s        *st_gdata;
-       long err = 0;
-       unsigned long flags = 0;
-
-       st_kim_ref(&st_gdata, 0);
-       if (st_gdata == NULL || new_proto == NULL || new_proto->recv == NULL
-           || new_proto->reg_complete_cb == NULL) {
-               pr_err("gdata/new_proto/recv or reg_complete_cb not ready");
-               return -EINVAL;
-       }
-
-       if (new_proto->chnl_id >= ST_MAX_CHANNELS) {
-               pr_err("chnl_id %d not supported", new_proto->chnl_id);
-               return -EPROTONOSUPPORT;
-       }
-
-       if (st_gdata->is_registered[new_proto->chnl_id] == true) {
-               pr_err("chnl_id %d already registered", new_proto->chnl_id);
-               return -EALREADY;
-       }
-
-       /* can be from process context only */
-       spin_lock_irqsave(&st_gdata->lock, flags);
-
-       if (test_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state)) {
-               pr_info(" ST_REG_IN_PROGRESS:%d ", new_proto->chnl_id);
-               /* fw download in progress */
-
-               add_channel_to_table(st_gdata, new_proto);
-               st_gdata->protos_registered++;
-               new_proto->write = st_write;
-
-               set_bit(ST_REG_PENDING, &st_gdata->st_state);
-               spin_unlock_irqrestore(&st_gdata->lock, flags);
-               return -EINPROGRESS;
-       } else if (st_gdata->protos_registered == ST_EMPTY) {
-               pr_info(" chnl_id list empty :%d ", new_proto->chnl_id);
-               set_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state);
-               st_recv = st_kim_recv;
-
-               /* enable the ST LL - to set default chip state */
-               st_ll_enable(st_gdata);
-
-               /* release lock previously held - re-locked below */
-               spin_unlock_irqrestore(&st_gdata->lock, flags);
-
-               /* this may take a while to complete
-                * since it involves BT fw download
-                */
-               err = st_kim_start(st_gdata->kim_data);
-               if (err != 0) {
-                       clear_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state);
-                       if ((st_gdata->protos_registered != ST_EMPTY) &&
-                           (test_bit(ST_REG_PENDING, &st_gdata->st_state))) {
-                               pr_err(" KIM failure complete callback ");
-                               spin_lock_irqsave(&st_gdata->lock, flags);
-                               st_reg_complete(st_gdata, err);
-                               spin_unlock_irqrestore(&st_gdata->lock, flags);
-                               clear_bit(ST_REG_PENDING, &st_gdata->st_state);
-                       }
-                       return -EINVAL;
-               }
-
-               spin_lock_irqsave(&st_gdata->lock, flags);
-
-               clear_bit(ST_REG_IN_PROGRESS, &st_gdata->st_state);
-               st_recv = st_int_recv;
-
-               /* this is where all pending registration
-                * are signalled to be complete by calling callback functions
-                */
-               if ((st_gdata->protos_registered != ST_EMPTY) &&
-                   (test_bit(ST_REG_PENDING, &st_gdata->st_state))) {
-                       pr_debug(" call reg complete callback ");
-                       st_reg_complete(st_gdata, 0);
-               }
-               clear_bit(ST_REG_PENDING, &st_gdata->st_state);
-
-               /* check for already registered once more,
-                * since the above check is old
-                */
-               if (st_gdata->is_registered[new_proto->chnl_id] == true) {
-                       pr_err(" proto %d already registered ",
-                                  new_proto->chnl_id);
-                       spin_unlock_irqrestore(&st_gdata->lock, flags);
-                       return -EALREADY;
-               }
-
-               add_channel_to_table(st_gdata, new_proto);
-               st_gdata->protos_registered++;
-               new_proto->write = st_write;
-               spin_unlock_irqrestore(&st_gdata->lock, flags);
-               return err;
-       }
-       /* if fw is already downloaded & new stack registers protocol */
-       else {
-               add_channel_to_table(st_gdata, new_proto);
-               st_gdata->protos_registered++;
-               new_proto->write = st_write;
-
-               /* lock already held before entering else */
-               spin_unlock_irqrestore(&st_gdata->lock, flags);
-               return err;
-       }
-}
-EXPORT_SYMBOL_GPL(st_register);
-
-/* to unregister a protocol -
- * to be called from protocol stack driver
- */
-long st_unregister(struct st_proto_s *proto)
-{
-       long err = 0;
-       unsigned long flags = 0;
-       struct st_data_s        *st_gdata;
-
-       pr_debug("%s: %d ", __func__, proto->chnl_id);
-
-       st_kim_ref(&st_gdata, 0);
-       if (!st_gdata || proto->chnl_id >= ST_MAX_CHANNELS) {
-               pr_err(" chnl_id %d not supported", proto->chnl_id);
-               return -EPROTONOSUPPORT;
-       }
-
-       spin_lock_irqsave(&st_gdata->lock, flags);
-
-       if (st_gdata->is_registered[proto->chnl_id] == false) {
-               pr_err(" chnl_id %d not registered", proto->chnl_id);
-               spin_unlock_irqrestore(&st_gdata->lock, flags);
-               return -EPROTONOSUPPORT;
-       }
-
-       if (st_gdata->protos_registered)
-               st_gdata->protos_registered--;
-
-       remove_channel_from_table(st_gdata, proto);
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-
-       if ((st_gdata->protos_registered == ST_EMPTY) &&
-           (!test_bit(ST_REG_PENDING, &st_gdata->st_state))) {
-               pr_info(" all chnl_ids unregistered ");
-
-               /* stop traffic on tty */
-               if (st_gdata->tty) {
-                       tty_ldisc_flush(st_gdata->tty);
-                       stop_tty(st_gdata->tty);
-               }
-
-               /* all chnl_ids now unregistered */
-               st_kim_stop(st_gdata->kim_data);
-               /* disable ST LL */
-               st_ll_disable(st_gdata);
-       }
-       return err;
-}
-
-/*
- * called in protocol stack drivers
- * via the write function pointer
- */
-long st_write(struct sk_buff *skb)
-{
-       struct st_data_s *st_gdata;
-       long len;
-
-       st_kim_ref(&st_gdata, 0);
-       if (unlikely(skb == NULL || st_gdata == NULL
-               || st_gdata->tty == NULL)) {
-               pr_err("data/tty unavailable to perform write");
-               return -EINVAL;
-       }
-
-       pr_debug("%d to be written", skb->len);
-       len = skb->len;
-
-       /* st_ll to decide where to enqueue the skb */
-       st_int_enqueue(st_gdata, skb);
-       /* wake up */
-       st_tx_wakeup(st_gdata);
-
-       /* return number of bytes written */
-       return len;
-}
-
-/* for protocols making use of shared transport */
-EXPORT_SYMBOL_GPL(st_unregister);
-
-/********************************************************************/
-/*
- * functions called from TTY layer
- */
-static int st_tty_open(struct tty_struct *tty)
-{
-       int err = 0;
-       struct st_data_s *st_gdata;
-       pr_info("%s ", __func__);
-
-       st_kim_ref(&st_gdata, 0);
-       st_gdata->tty = tty;
-       tty->disc_data = st_gdata;
-
-       /* don't do an wakeup for now */
-       clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
-
-       /* mem already allocated
-        */
-       tty->receive_room = 65536;
-       /* Flush any pending characters in the driver and discipline. */
-       tty_ldisc_flush(tty);
-       tty_driver_flush_buffer(tty);
-       /*
-        * signal to UIM via KIM that -
-        * installation of N_TI_WL ldisc is complete
-        */
-       st_kim_complete(st_gdata->kim_data);
-       pr_debug("done %s", __func__);
-       return err;
-}
-
-static void st_tty_close(struct tty_struct *tty)
-{
-       unsigned char i = ST_MAX_CHANNELS;
-       unsigned long flags = 0;
-       struct  st_data_s *st_gdata = tty->disc_data;
-
-       pr_info("%s ", __func__);
-
-       /* TODO:
-        * if a protocol has been registered & line discipline
-        * un-installed for some reason - what should be done ?
-        */
-       spin_lock_irqsave(&st_gdata->lock, flags);
-       for (i = ST_BT; i < ST_MAX_CHANNELS; i++) {
-               if (st_gdata->is_registered[i] == true)
-                       pr_err("%d not un-registered", i);
-               st_gdata->list[i] = NULL;
-               st_gdata->is_registered[i] = false;
-       }
-       st_gdata->protos_registered = 0;
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-       /*
-        * signal to UIM via KIM that -
-        * N_TI_WL ldisc is un-installed
-        */
-       st_kim_complete(st_gdata->kim_data);
-       st_gdata->tty = NULL;
-       /* Flush any pending characters in the driver and discipline. */
-       tty_ldisc_flush(tty);
-       tty_driver_flush_buffer(tty);
-
-       spin_lock_irqsave(&st_gdata->lock, flags);
-       /* empty out txq and tx_waitq */
-       skb_queue_purge(&st_gdata->txq);
-       skb_queue_purge(&st_gdata->tx_waitq);
-       /* reset the TTY Rx states of ST */
-       st_gdata->rx_count = 0;
-       st_gdata->rx_state = ST_W4_PACKET_TYPE;
-       kfree_skb(st_gdata->rx_skb);
-       st_gdata->rx_skb = NULL;
-       spin_unlock_irqrestore(&st_gdata->lock, flags);
-
-       pr_debug("%s: done ", __func__);
-}
-
-static void st_tty_receive(struct tty_struct *tty, const unsigned char *data,
-                          char *tty_flags, int count)
-{
-#ifdef VERBOSE
-       print_hex_dump(KERN_DEBUG, ">in>", DUMP_PREFIX_NONE,
-               16, 1, data, count, 0);
-#endif
-
-       /*
-        * if fw download is in progress then route incoming data
-        * to KIM for validation
-        */
-       st_recv(tty->disc_data, data, count);
-       pr_debug("done %s", __func__);
-}
-
-/* wake-up function called in from the TTY layer
- * inside the internal wakeup function will be called
- */
-static void st_tty_wakeup(struct tty_struct *tty)
-{
-       struct  st_data_s *st_gdata = tty->disc_data;
-       pr_debug("%s ", __func__);
-       /* don't do an wakeup for now */
-       clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
-
-       /*
-        * schedule the internal wakeup instead of calling directly to
-        * avoid lockup (port->lock needed in tty->ops->write is
-        * already taken here
-        */
-       schedule_work(&st_gdata->work_write_wakeup);
-}
-
-static void st_tty_flush_buffer(struct tty_struct *tty)
-{
-       struct  st_data_s *st_gdata = tty->disc_data;
-       pr_debug("%s ", __func__);
-
-       kfree_skb(st_gdata->tx_skb);
-       st_gdata->tx_skb = NULL;
-
-       tty_driver_flush_buffer(tty);
-       return;
-}
-
-static struct tty_ldisc_ops st_ldisc_ops = {
-       .magic = TTY_LDISC_MAGIC,
-       .name = "n_st",
-       .open = st_tty_open,
-       .close = st_tty_close,
-       .receive_buf = st_tty_receive,
-       .write_wakeup = st_tty_wakeup,
-       .flush_buffer = st_tty_flush_buffer,
-       .owner = THIS_MODULE
-};
-
-/********************************************************************/
-int st_core_init(struct st_data_s **core_data)
-{
-       struct st_data_s *st_gdata;
-       long err;
-
-       err = tty_register_ldisc(N_TI_WL, &st_ldisc_ops);
-       if (err) {
-               pr_err("error registering %d line discipline %ld",
-                          N_TI_WL, err);
-               return err;
-       }
-       pr_debug("registered n_shared line discipline");
-
-       st_gdata = kzalloc(sizeof(struct st_data_s), GFP_KERNEL);
-       if (!st_gdata) {
-               pr_err("memory allocation failed");
-               err = tty_unregister_ldisc(N_TI_WL);
-               if (err)
-                       pr_err("unable to un-register ldisc %ld", err);
-               err = -ENOMEM;
-               return err;
-       }
-
-       /* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's
-        * will be pushed in this queue for actual transmission.
-        */
-       skb_queue_head_init(&st_gdata->txq);
-       skb_queue_head_init(&st_gdata->tx_waitq);
-
-       /* Locking used in st_int_enqueue() to avoid multiple execution */
-       spin_lock_init(&st_gdata->lock);
-
-       err = st_ll_init(st_gdata);
-       if (err) {
-               pr_err("error during st_ll initialization(%ld)", err);
-               kfree(st_gdata);
-               err = tty_unregister_ldisc(N_TI_WL);
-               if (err)
-                       pr_err("unable to un-register ldisc");
-               return err;
-       }
-
-       INIT_WORK(&st_gdata->work_write_wakeup, work_fn_write_wakeup);
-
-       *core_data = st_gdata;
-       return 0;
-}
-
-void st_core_exit(struct st_data_s *st_gdata)
-{
-       long err;
-       /* internal module cleanup */
-       err = st_ll_deinit(st_gdata);
-       if (err)
-               pr_err("error during deinit of ST LL %ld", err);
-
-       if (st_gdata != NULL) {
-               /* Free ST Tx Qs and skbs */
-               skb_queue_purge(&st_gdata->txq);
-               skb_queue_purge(&st_gdata->tx_waitq);
-               kfree_skb(st_gdata->rx_skb);
-               kfree_skb(st_gdata->tx_skb);
-               /* TTY ldisc cleanup */
-               err = tty_unregister_ldisc(N_TI_WL);
-               if (err)
-                       pr_err("unable to un-register ldisc %ld", err);
-               /* free the global data pointer */
-               kfree(st_gdata);
-       }
-}

drivers/misc/ti-st/st_kim.c deleted +0 -868

deleted file mode 100644
index 1874ac922166..000000000000
@@ -1,868 +0,0 @@
-/*
- *  Shared Transport Line discipline driver Core
- *     Init Manager module responsible for GPIO control
- *     and firmware download
- *  Copyright (C) 2009-2010 Texas Instruments
- *  Author: Pavan Savoy <[email protected]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License 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.
- *
- *  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
- *
- */
-
-#define pr_fmt(fmt) "(stk) :" fmt
-#include <linux/platform_device.h>
-#include <linux/jiffies.h>
-#include <linux/firmware.h>
-#include <linux/delay.h>
-#include <linux/wait.h>
-#include <linux/gpio.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/sched.h>
-#include <linux/sysfs.h>
-#include <linux/tty.h>
-
-#include <linux/skbuff.h>
-#include <linux/ti_wilink_st.h>
-#include <linux/module.h>
-
-#define MAX_ST_DEVICES 3       /* Imagine 1 on each UART for now */
-static struct platform_device *st_kim_devices[MAX_ST_DEVICES];
-
-/**********************************************************************/
-/* internal functions */
-
-/**
- * st_get_plat_device -
- *     function which returns the reference to the platform device
- *     requested by id. As of now only 1 such device exists (id=0)
- *     the context requesting for reference can get the id to be
- *     requested by a. The protocol driver which is registering or
- *     b. the tty device which is opened.
- */
-static struct platform_device *st_get_plat_device(int id)
-{
-       return st_kim_devices[id];
-}
-
-/**
- * validate_firmware_response -
- *     function to return whether the firmware response was proper
- *     in case of error don't complete so that waiting for proper
- *     response times out
- */
-static void validate_firmware_response(struct kim_data_s *kim_gdata)
-{
-       struct sk_buff *skb = kim_gdata->rx_skb;
-       if (!skb)
-               return;
-
-       /* these magic numbers are the position in the response buffer which
-        * allows us to distinguish whether the response is for the read
-        * version info. command
-        */
-       if (skb->data[2] == 0x01 && skb->data[3] == 0x01 &&
-                       skb->data[4] == 0x10 && skb->data[5] == 0x00) {
-               /* fw version response */
-               memcpy(kim_gdata->resp_buffer,
-                               kim_gdata->rx_skb->data,
-                               kim_gdata->rx_skb->len);
-               kim_gdata->rx_state = ST_W4_PACKET_TYPE;
-               kim_gdata->rx_skb = NULL;
-               kim_gdata->rx_count = 0;
-       } else if (unlikely(skb->data[5] != 0)) {
-               pr_err("no proper response during fw download");
-               pr_err("data6 %x", skb->data[5]);
-               kfree_skb(skb);
-               return;         /* keep waiting for the proper response */
-       }
-       /* becos of all the script being downloaded */
-       complete_all(&kim_gdata->kim_rcvd);
-       kfree_skb(skb);
-}
-
-/* check for data len received inside kim_int_recv
- * most often hit the last case to update state to waiting for data
- */
-static inline int kim_check_data_len(struct kim_data_s *kim_gdata, int len)
-{
-       register int room = skb_tailroom(kim_gdata->rx_skb);
-
-       pr_debug("len %d room %d", len, room);
-
-       if (!len) {
-               validate_firmware_response(kim_gdata);
-       } else if (len > room) {
-               /* Received packet's payload length is larger.
-                * We can't accommodate it in created skb.
-                */
-               pr_err("Data length is too large len %d room %d", len,
-                          room);
-               kfree_skb(kim_gdata->rx_skb);
-       } else {
-               /* Packet header has non-zero payload length and
-                * we have enough space in created skb. Lets read
-                * payload data */
-               kim_gdata->rx_state = ST_W4_DATA;
-               kim_gdata->rx_count = len;
-               return len;
-       }
-
-       /* Change ST LL state to continue to process next
-        * packet */
-       kim_gdata->rx_state = ST_W4_PACKET_TYPE;
-       kim_gdata->rx_skb = NULL;
-       kim_gdata->rx_count = 0;
-
-       return 0;
-}
-
-/**
- * kim_int_recv - receive function called during firmware download
- *     firmware download responses on different UART drivers
- *     have been observed to come in bursts of different
- *     tty_receive and hence the logic
- */
-static void kim_int_recv(struct kim_data_s *kim_gdata,
-       const unsigned char *data, long count)
-{
-       const unsigned char *ptr;
-       int len = 0;
-       unsigned char *plen;
-
-       pr_debug("%s", __func__);
-       /* Decode received bytes here */
-       ptr = data;
-       if (unlikely(ptr == NULL)) {
-               pr_err(" received null from TTY ");
-               return;
-       }
-
-       while (count) {
-               if (kim_gdata->rx_count) {
-                       len = min_t(unsigned int, kim_gdata->rx_count, count);
-                       skb_put_data(kim_gdata->rx_skb, ptr, len);
-                       kim_gdata->rx_count -= len;
-                       count -= len;
-                       ptr += len;
-
-                       if (kim_gdata->rx_count)
-                               continue;
-
-                       /* Check ST RX state machine , where are we? */
-                       switch (kim_gdata->rx_state) {
-                               /* Waiting for complete packet ? */
-                       case ST_W4_DATA:
-                               pr_debug("Complete pkt received");
-                               validate_firmware_response(kim_gdata);
-                               kim_gdata->rx_state = ST_W4_PACKET_TYPE;
-                               kim_gdata->rx_skb = NULL;
-                               continue;
-                               /* Waiting for Bluetooth event header ? */
-                       case ST_W4_HEADER:
-                               plen =
-                               (unsigned char *)&kim_gdata->rx_skb->data[1];
-                               pr_debug("event hdr: plen 0x%02x\n", *plen);
-                               kim_check_data_len(kim_gdata, *plen);
-                               continue;
-                       }       /* end of switch */
-               }               /* end of if rx_state */
-               switch (*ptr) {
-                       /* Bluetooth event packet? */
-               case 0x04:
-                       kim_gdata->rx_state = ST_W4_HEADER;
-                       kim_gdata->rx_count = 2;
-                       break;
-               default:
-                       pr_info("unknown packet");
-                       ptr++;
-                       count--;
-                       continue;
-               }
-               ptr++;
-               count--;
-               kim_gdata->rx_skb =
-                       alloc_skb(1024+8, GFP_ATOMIC);
-               if (!kim_gdata->rx_skb) {
-                       pr_err("can't allocate mem for new packet");
-                       kim_gdata->rx_state = ST_W4_PACKET_TYPE;
-                       kim_gdata->rx_count = 0;
-                       return;
-               }
-               skb_reserve(kim_gdata->rx_skb, 8);
-               kim_gdata->rx_skb->cb[0] = 4;
-               kim_gdata->rx_skb->cb[1] = 0;
-
-       }
-       return;
-}
-
-static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
-{
-       unsigned short version = 0, chip = 0, min_ver = 0, maj_ver = 0;
-       const char read_ver_cmd[] = { 0x01, 0x01, 0x10, 0x00 };
-       long timeout;
-
-       pr_debug("%s", __func__);
-
-       reinit_completion(&kim_gdata->kim_rcvd);
-       if (4 != st_int_write(kim_gdata->core_data, read_ver_cmd, 4)) {
-               pr_err("kim: couldn't write 4 bytes");
-               return -EIO;
-       }
-
-       timeout = wait_for_completion_interruptible_timeout(
-               &kim_gdata->kim_rcvd, msecs_to_jiffies(CMD_RESP_TIME));
-       if (timeout <= 0) {
-               pr_err(" waiting for ver info- timed out or received signal");
-               return timeout ? -ERESTARTSYS : -ETIMEDOUT;
-       }
-       reinit_completion(&kim_gdata->kim_rcvd);
-       /* the positions 12 & 13 in the response buffer provide with the
-        * chip, major & minor numbers
-        */
-
-       version =
-               MAKEWORD(kim_gdata->resp_buffer[12],
-                               kim_gdata->resp_buffer[13]);
-       chip = (version & 0x7C00) >> 10;
-       min_ver = (version & 0x007F);
-       maj_ver = (version & 0x0380) >> 7;
-
-       if (version & 0x8000)
-               maj_ver |= 0x0008;
-
-       sprintf(bts_scr_name, "ti-connectivity/TIInit_%d.%d.%d.bts",
-               chip, maj_ver, min_ver);
-
-       /* to be accessed later via sysfs entry */
-       kim_gdata->version.full = version;
-       kim_gdata->version.chip = chip;
-       kim_gdata->version.maj_ver = maj_ver;
-       kim_gdata->version.min_ver = min_ver;
-
-       pr_info("%s", bts_scr_name);
-       return 0;
-}
-
-static void skip_change_remote_baud(unsigned char **ptr, long *len)
-{
-       unsigned char *nxt_action, *cur_action;
-       cur_action = *ptr;
-
-       nxt_action = cur_action + sizeof(struct bts_action) +
-               ((struct bts_action *) cur_action)->size;
-
-       if (((struct bts_action *) nxt_action)->type != ACTION_WAIT_EVENT) {
-               pr_err("invalid action after change remote baud command");
-       } else {
-               *ptr = *ptr + sizeof(struct bts_action) +
-                       ((struct bts_action *)cur_action)->size;
-               *len = *len - (sizeof(struct bts_action) +
-                               ((struct bts_action *)cur_action)->size);
-               /* warn user on not commenting these in firmware */
-               pr_warn("skipping the wait event of change remote baud");
-       }
-}
-
-/**
- * download_firmware -
- *     internal function which parses through the .bts firmware
- *     script file intreprets SEND, DELAY actions only as of now
- */
-static long download_firmware(struct kim_data_s *kim_gdata)
-{
-       long err = 0;
-       long len = 0;
-       unsigned char *ptr = NULL;
-       unsigned char *action_ptr = NULL;
-       unsigned char bts_scr_name[40] = { 0 }; /* 40 char long bts scr name? */
-       int wr_room_space;
-       int cmd_size;
-       unsigned long timeout;
-
-       err = read_local_version(kim_gdata, bts_scr_name);
-       if (err != 0) {
-               pr_err("kim: failed to read local ver");
-               return err;
-       }
-       err =
-           request_firmware(&kim_gdata->fw_entry, bts_scr_name,
-                            &kim_gdata->kim_pdev->dev);
-       if (unlikely((err != 0) || (kim_gdata->fw_entry->data == NULL) ||
-                    (kim_gdata->fw_entry->size == 0))) {
-               pr_err(" request_firmware failed(errno %ld) for %s", err,
-                          bts_scr_name);
-               return -EINVAL;
-       }
-       ptr = (void *)kim_gdata->fw_entry->data;
-       len = kim_gdata->fw_entry->size;
-       /* bts_header to remove out magic number and
-        * version
-        */
-       ptr += sizeof(struct bts_header);
-       len -= sizeof(struct bts_header);
-
-       while (len > 0 && ptr) {
-               pr_debug(" action size %d, type %d ",
-                          ((struct bts_action *)ptr)->size,
-                          ((struct bts_action *)ptr)->type);
-
-               switch (((struct bts_action *)ptr)->type) {
-               case ACTION_SEND_COMMAND:       /* action send */
-                       pr_debug("S");
-                       action_ptr = &(((struct bts_action *)ptr)->data[0]);
-                       if (unlikely
-                           (((struct hci_command *)action_ptr)->opcode ==
-                            0xFF36)) {
-                               /* ignore remote change
-                                * baud rate HCI VS command */
-                               pr_warn("change remote baud"
-                                   " rate command in firmware");
-                               skip_change_remote_baud(&ptr, &len);
-                               break;
-                       }
-                       /*
-                        * Make sure we have enough free space in uart
-                        * tx buffer to write current firmware command
-                        */
-                       cmd_size = ((struct bts_action *)ptr)->size;
-                       timeout = jiffies + msecs_to_jiffies(CMD_WR_TIME);
-                       do {
-                               wr_room_space =
-                                       st_get_uart_wr_room(kim_gdata->core_data);
-                               if (wr_room_space < 0) {
-                                       pr_err("Unable to get free "
-                                                       "space info from uart tx buffer");
-                                       release_firmware(kim_gdata->fw_entry);
-                                       return wr_room_space;
-                               }
-                               mdelay(1); /* wait 1ms before checking room */
-                       } while ((wr_room_space < cmd_size) &&
-                                       time_before(jiffies, timeout));
-
-                       /* Timeout happened ? */
-                       if (time_after_eq(jiffies, timeout)) {
-                               pr_err("Timeout while waiting for free "
-                                               "free space in uart tx buffer");
-                               release_firmware(kim_gdata->fw_entry);
-                               return -ETIMEDOUT;
-                       }
-                       /* reinit completion before sending for the
-                        * relevant wait
-                        */
-                       reinit_completion(&kim_gdata->kim_rcvd);
-
-                       /*
-                        * Free space found in uart buffer, call st_int_write
-                        * to send current firmware command to the uart tx
-                        * buffer.
-                        */
-                       err = st_int_write(kim_gdata->core_data,
-                       ((struct bts_action_send *)action_ptr)->data,
-                                          ((struct bts_action *)ptr)->size);
-                       if (unlikely(err < 0)) {
-                               release_firmware(kim_gdata->fw_entry);
-                               return err;
-                       }
-                       /*
-                        * Check number of bytes written to the uart tx buffer
-                        * and requested command write size
-                        */
-                       if (err != cmd_size) {
-                               pr_err("Number of bytes written to uart "
-                                               "tx buffer are not matching with "
-                                               "requested cmd write size");
-                               release_firmware(kim_gdata->fw_entry);
-                               return -EIO;
-                       }
-                       break;
-               case ACTION_WAIT_EVENT:  /* wait */
-                       pr_debug("W");
-                       err = wait_for_completion_interruptible_timeout(
-                                       &kim_gdata->kim_rcvd,
-                                       msecs_to_jiffies(CMD_RESP_TIME));
-                       if (err <= 0) {
-                               pr_err("response timeout/signaled during fw download ");
-                               /* timed out */
-                               release_firmware(kim_gdata->fw_entry);
-                               return err ? -ERESTARTSYS : -ETIMEDOUT;
-                       }
-                       reinit_completion(&kim_gdata->kim_rcvd);
-                       break;
-               case ACTION_DELAY:      /* sleep */
-                       pr_info("sleep command in scr");
-                       action_ptr = &(((struct bts_action *)ptr)->data[0]);
-                       mdelay(((struct bts_action_delay *)action_ptr)->msec);
-                       break;
-               }
-               len =
-                   len - (sizeof(struct bts_action) +
-                          ((struct bts_action *)ptr)->size);
-               ptr =
-                   ptr + sizeof(struct bts_action) +
-                   ((struct bts_action *)ptr)->size;
-       }
-       /* fw download complete */
-       release_firmware(kim_gdata->fw_entry);
-       return 0;
-}
-
-/**********************************************************************/
-/* functions called from ST core */
-/* called from ST Core, when REG_IN_PROGRESS (registration in progress)
- * can be because of
- * 1. response to read local version
- * 2. during send/recv's of firmware download
- */
-void st_kim_recv(void *disc_data, const unsigned char *data, long count)
-{
-       struct st_data_s        *st_gdata = (struct st_data_s *)disc_data;
-       struct kim_data_s       *kim_gdata = st_gdata->kim_data;
-
-       /* proceed to gather all data and distinguish read fw version response
-        * from other fw responses when data gathering is complete
-        */
-       kim_int_recv(kim_gdata, data, count);
-       return;
-}
-
-/* to signal completion of line discipline installation
- * called from ST Core, upon tty_open
- */
-void st_kim_complete(void *kim_data)
-{
-       struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
-       complete(&kim_gdata->ldisc_installed);
-}
-
-/**
- * st_kim_start - called from ST Core upon 1st registration
- *     This involves toggling the chip enable gpio, reading
- *     the firmware version from chip, forming the fw file name
- *     based on the chip version, requesting the fw, parsing it
- *     and perform download(send/recv).
- */
-long st_kim_start(void *kim_data)
-{
-       long err = 0;
-       long retry = POR_RETRY_COUNT;
-       struct ti_st_plat_data  *pdata;
-       struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
-
-       pr_info(" %s", __func__);
-       pdata = kim_gdata->kim_pdev->dev.platform_data;
-
-       do {
-               /* platform specific enabling code here */
-               if (pdata->chip_enable)
-                       pdata->chip_enable(kim_gdata);
-
-               /* Configure BT nShutdown to HIGH state */
-               gpio_set_value_cansleep(kim_gdata->nshutdown, GPIO_LOW);
-               mdelay(5);      /* FIXME: a proper toggle */
-               gpio_set_value_cansleep(kim_gdata->nshutdown, GPIO_HIGH);
-               mdelay(100);
-               /* re-initialize the completion */
-               reinit_completion(&kim_gdata->ldisc_installed);
-               /* send notification to UIM */
-               kim_gdata->ldisc_install = 1;
-               pr_info("ldisc_install = 1");
-               sysfs_notify(&kim_gdata->kim_pdev->dev.kobj,
-                               NULL, "install");
-               /* wait for ldisc to be installed */
-               err = wait_for_completion_interruptible_timeout(
-                       &kim_gdata->ldisc_installed, msecs_to_jiffies(LDISC_TIME));
-               if (!err) {
-                       /* ldisc installation timeout,
-                        * flush uart, power cycle BT_EN */
-                       pr_err("ldisc installation timeout");
-                       err = st_kim_stop(kim_gdata);
-                       continue;
-               } else {
-                       /* ldisc installed now */
-                       pr_info("line discipline installed");
-                       err = download_firmware(kim_gdata);
-                       if (err != 0) {
-                               /* ldisc installed but fw download failed,
-                                * flush uart & power cycle BT_EN */
-                               pr_err("download firmware failed");
-                               err = st_kim_stop(kim_gdata);
-                               continue;
-                       } else {        /* on success don't retry */
-                               break;
-                       }
-               }
-       } while (retry--);
-       return err;
-}
-
-/**
- * st_kim_stop - stop communication with chip.
- *     This can be called from ST Core/KIM, on the-
- *     (a) last un-register when chip need not be powered there-after,
- *     (b) upon failure to either install ldisc or download firmware.
- *     The function is responsible to (a) notify UIM about un-installation,
- *     (b) flush UART if the ldisc was installed.
- *     (c) reset BT_EN - pull down nshutdown at the end.
- *     (d) invoke platform's chip disabling routine.
- */
-long st_kim_stop(void *kim_data)
-{
-       long err = 0;
-       struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
-       struct ti_st_plat_data  *pdata =
-               kim_gdata->kim_pdev->dev.platform_data;
-       struct tty_struct       *tty = kim_gdata->core_data->tty;
-
-       reinit_completion(&kim_gdata->ldisc_installed);
-
-       if (tty) {      /* can be called before ldisc is installed */
-               /* Flush any pending characters in the driver and discipline. */
-               tty_ldisc_flush(tty);
-               tty_driver_flush_buffer(tty);
-       }
-
-       /* send uninstall notification to UIM */
-       pr_info("ldisc_install = 0");
-       kim_gdata->ldisc_install = 0;
-       sysfs_notify(&kim_gdata->kim_pdev->dev.kobj, NULL, "install");
-
-       /* wait for ldisc to be un-installed */
-       err = wait_for_completion_interruptible_timeout(
-               &kim_gdata->ldisc_installed, msecs_to_jiffies(LDISC_TIME));
-       if (!err) {             /* timeout */
-               pr_err(" timed out waiting for ldisc to be un-installed");
-               err = -ETIMEDOUT;
-       }
-
-       /* By default configure BT nShutdown to LOW state */
-       gpio_set_value_cansleep(kim_gdata->nshutdown, GPIO_LOW);
-       mdelay(1);
-       gpio_set_value_cansleep(kim_gdata->nshutdown, GPIO_HIGH);
-       mdelay(1);
-       gpio_set_value_cansleep(kim_gdata->nshutdown, GPIO_LOW);
-
-       /* platform specific disable */
-       if (pdata->chip_disable)
-               pdata->chip_disable(kim_gdata);
-       return err;
-}
-
-/**********************************************************************/
-/* functions called from subsystems */
-/* called when debugfs entry is read from */
-
-static int show_version(struct seq_file *s, void *unused)
-{
-       struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private;
-       seq_printf(s, "%04X %d.%d.%d\n", kim_gdata->version.full,
-                       kim_gdata->version.chip, kim_gdata->version.maj_ver,
-                       kim_gdata->version.min_ver);
-       return 0;
-}
-
-static int show_list(struct seq_file *s, void *unused)
-{
-       struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private;
-       kim_st_list_protocols(kim_gdata->core_data, s);
-       return 0;
-}
-
-static ssize_t show_install(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       return sprintf(buf, "%d\n", kim_data->ldisc_install);
-}
-
-#ifdef DEBUG
-static ssize_t store_dev_name(struct device *dev,
-               struct device_attribute *attr, const char *buf, size_t count)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       pr_debug("storing dev name >%s<", buf);
-       strncpy(kim_data->dev_name, buf, count);
-       pr_debug("stored dev name >%s<", kim_data->dev_name);
-       return count;
-}
-
-static ssize_t store_baud_rate(struct device *dev,
-               struct device_attribute *attr, const char *buf, size_t count)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       pr_debug("storing baud rate >%s<", buf);
-       sscanf(buf, "%ld", &kim_data->baud_rate);
-       pr_debug("stored baud rate >%ld<", kim_data->baud_rate);
-       return count;
-}
-#endif /* if DEBUG */
-
-static ssize_t show_dev_name(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       return sprintf(buf, "%s\n", kim_data->dev_name);
-}
-
-static ssize_t show_baud_rate(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       return sprintf(buf, "%d\n", kim_data->baud_rate);
-}
-
-static ssize_t show_flow_cntrl(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct kim_data_s *kim_data = dev_get_drvdata(dev);
-       return sprintf(buf, "%d\n", kim_data->flow_cntrl);
-}
-
-/* structures specific for sysfs entries */
-static struct kobj_attribute ldisc_install =
-__ATTR(install, 0444, (void *)show_install, NULL);
-
-static struct kobj_attribute uart_dev_name =
-#ifdef DEBUG   /* TODO: move this to debug-fs if possible */
-__ATTR(dev_name, 0644, (void *)show_dev_name, (void *)store_dev_name);
-#else
-__ATTR(dev_name, 0444, (void *)show_dev_name, NULL);
-#endif
-
-static struct kobj_attribute uart_baud_rate =
-#ifdef DEBUG   /* TODO: move to debugfs */
-__ATTR(baud_rate, 0644, (void *)show_baud_rate, (void *)store_baud_rate);
-#else
-__ATTR(baud_rate, 0444, (void *)show_baud_rate, NULL);
-#endif
-
-static struct kobj_attribute uart_flow_cntrl =
-__ATTR(flow_cntrl, 0444, (void *)show_flow_cntrl, NULL);
-
-static struct attribute *uim_attrs[] = {
-       &ldisc_install.attr,
-       &uart_dev_name.attr,
-       &uart_baud_rate.attr,
-       &uart_flow_cntrl.attr,
-       NULL,
-};
-
-static const struct attribute_group uim_attr_grp = {
-       .attrs = uim_attrs,
-};
-
-/**
- * st_kim_ref - reference the core's data
- *     This references the per-ST platform device in the arch/xx/
- *     board-xx.c file.
- *     This would enable multiple such platform devices to exist
- *     on a given platform
- */
-void st_kim_ref(struct st_data_s **core_data, int id)
-{
-       struct platform_device  *pdev;
-       struct kim_data_s       *kim_gdata;
-       /* get kim_gdata reference from platform device */
-       pdev = st_get_plat_device(id);
-       if (!pdev)
-               goto err;
-       kim_gdata = platform_get_drvdata(pdev);
-       if (!kim_gdata)
-               goto err;
-
-       *core_data = kim_gdata->core_data;
-       return;
-err:
-       *core_data = NULL;
-}
-
-static int kim_version_open(struct inode *i, struct file *f)
-{
-       return single_open(f, show_version, i->i_private);
-}
-
-static int kim_list_open(struct inode *i, struct file *f)
-{
-       return single_open(f, show_list, i->i_private);
-}
-
-static const struct file_operations version_debugfs_fops = {
-       /* version info */
-       .open = kim_version_open,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-static const struct file_operations list_debugfs_fops = {
-       /* protocols info */
-       .open = kim_list_open,
-       .read = seq_read,
-       .llseek = seq_lseek,
-       .release = single_release,
-};
-
-/**********************************************************************/
-/* functions called from platform device driver subsystem
- * need to have a relevant platform device entry in the platform's
- * board-*.c file
- */
-
-static struct dentry *kim_debugfs_dir;
-static int kim_probe(struct platform_device *pdev)
-{
-       struct kim_data_s       *kim_gdata;
-       struct ti_st_plat_data  *pdata = pdev->dev.platform_data;
-       int err;
-
-       if ((pdev->id != -1) && (pdev->id < MAX_ST_DEVICES)) {
-               /* multiple devices could exist */
-               st_kim_devices[pdev->id] = pdev;
-       } else {
-               /* platform's sure about existence of 1 device */
-               st_kim_devices[0] = pdev;
-       }
-
-       kim_gdata = kzalloc(sizeof(struct kim_data_s), GFP_KERNEL);
-       if (!kim_gdata) {
-               pr_err("no mem to allocate");
-               return -ENOMEM;
-       }
-       platform_set_drvdata(pdev, kim_gdata);
-
-       err = st_core_init(&kim_gdata->core_data);
-       if (err != 0) {
-               pr_err(" ST core init failed");
-               err = -EIO;
-               goto err_core_init;
-       }
-       /* refer to itself */
-       kim_gdata->core_data->kim_data = kim_gdata;
-
-       /* Claim the chip enable nShutdown gpio from the system */
-       kim_gdata->nshutdown = pdata->nshutdown_gpio;
-       err = gpio_request(kim_gdata->nshutdown, "kim");
-       if (unlikely(err)) {
-               pr_err(" gpio %d request failed ", kim_gdata->nshutdown);
-               goto err_sysfs_group;
-       }
-
-       /* Configure nShutdown GPIO as output=0 */
-       err = gpio_direction_output(kim_gdata->nshutdown, 0);
-       if (unlikely(err)) {
-               pr_err(" unable to configure gpio %d", kim_gdata->nshutdown);
-               goto err_sysfs_group;
-       }
-       /* get reference of pdev for request_firmware
-        */
-       kim_gdata->kim_pdev = pdev;
-       init_completion(&kim_gdata->kim_rcvd);
-       init_completion(&kim_gdata->ldisc_installed);
-
-       err = sysfs_create_group(&pdev->dev.kobj, &uim_attr_grp);
-       if (err) {
-               pr_err("failed to create sysfs entries");
-               goto err_sysfs_group;
-       }
-
-       /* copying platform data */
-       strncpy(kim_gdata->dev_name, pdata->dev_name, UART_DEV_NAME_LEN);
-       kim_gdata->flow_cntrl = pdata->flow_cntrl;
-       kim_gdata->baud_rate = pdata->baud_rate;
-       pr_info("sysfs entries created\n");
-
-       kim_debugfs_dir = debugfs_create_dir("ti-st", NULL);
-       if (!kim_debugfs_dir) {
-               pr_err(" debugfs entries creation failed ");
-               return 0;
-       }
-
-       debugfs_create_file("version", S_IRUGO, kim_debugfs_dir,
-                               kim_gdata, &version_debugfs_fops);
-       debugfs_create_file("protocols", S_IRUGO, kim_debugfs_dir,
-                               kim_gdata, &list_debugfs_fops);
-       return 0;
-
-err_sysfs_group:
-       st_core_exit(kim_gdata->core_data);
-
-err_core_init:
-       kfree(kim_gdata);
-
-       return err;
-}
-
-static int kim_remove(struct platform_device *pdev)
-{
-       /* free the GPIOs requested */
-       struct ti_st_plat_data  *pdata = pdev->dev.platform_data;
-       struct kim_data_s       *kim_gdata;
-
-       kim_gdata = platform_get_drvdata(pdev);
-
-       /* Free the Bluetooth/FM/GPIO
-        * nShutdown gpio from the system
-        */
-       gpio_free(pdata->nshutdown_gpio);
-       pr_info("nshutdown GPIO Freed");
-
-       debugfs_remove_recursive(kim_debugfs_dir);
-       sysfs_remove_group(&pdev->dev.kobj, &uim_attr_grp);
-       pr_info("sysfs entries removed");
-
-       kim_gdata->kim_pdev = NULL;
-       st_core_exit(kim_gdata->core_data);
-
-       kfree(kim_gdata);
-       kim_gdata = NULL;
-       return 0;
-}
-
-static int kim_suspend(struct platform_device *pdev, pm_message_t state)
-{
-       struct ti_st_plat_data  *pdata = pdev->dev.platform_data;
-
-       if (pdata->suspend)
-               return pdata->suspend(pdev, state);
-
-       return 0;
-}
-
-static int kim_resume(struct platform_device *pdev)
-{
-       struct ti_st_plat_data  *pdata = pdev->dev.platform_data;
-
-       if (pdata->resume)
-               return pdata->resume(pdev);
-
-       return 0;
-}
-
-/**********************************************************************/
-/* entry point for ST KIM module, called in from ST Core */
-static struct platform_driver kim_platform_driver = {
-       .probe = kim_probe,
-       .remove = kim_remove,
-       .suspend = kim_suspend,
-       .resume = kim_resume,
-       .driver = {
-               .name = "kim",
-       },
-};
-
-module_platform_driver(kim_platform_driver);
-
-MODULE_AUTHOR("Pavan Savoy <[email protected]>");
-MODULE_DESCRIPTION("Shared Transport Driver for TI BT/FM/GPS combo chips ");
-MODULE_LICENSE("GPL");

drivers/misc/ti-st/st_ll.c deleted +0 -169

deleted file mode 100644
index 93b4d67cc4a3..000000000000
@@ -1,169 +0,0 @@
-/*
- *  Shared Transport driver
- *     HCI-LL module responsible for TI proprietary HCI_LL protocol
- *  Copyright (C) 2009-2010 Texas Instruments
- *  Author: Pavan Savoy <[email protected]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License 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.
- *
- *  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
- *
- */
-
-#define pr_fmt(fmt) "(stll) :" fmt
-#include <linux/skbuff.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/ti_wilink_st.h>
-
-/**********************************************************************/
-/* internal functions */
-static void send_ll_cmd(struct st_data_s *st_data,
-       unsigned char cmd)
-{
-
-       pr_debug("%s: writing %x", __func__, cmd);
-       st_int_write(st_data, &cmd, 1);
-       return;
-}
-
-static void ll_device_want_to_sleep(struct st_data_s *st_data)
-{
-       struct kim_data_s       *kim_data;
-       struct ti_st_plat_data  *pdata;
-
-       pr_debug("%s", __func__);
-       /* sanity check */
-       if (st_data->ll_state != ST_LL_AWAKE)
-               pr_err("ERR hcill: ST_LL_GO_TO_SLEEP_IND"
-                         "in state %ld", st_data->ll_state);
-
-       send_ll_cmd(st_data, LL_SLEEP_ACK);
-       /* update state */
-       st_data->ll_state = ST_LL_ASLEEP;
-
-       /* communicate to platform about chip asleep */
-       kim_data = st_data->kim_data;
-       pdata = kim_data->kim_pdev->dev.platform_data;
-       if (pdata->chip_asleep)
-               pdata->chip_asleep(NULL);
-}
-
-static void ll_device_want_to_wakeup(struct st_data_s *st_data)
-{
-       struct kim_data_s       *kim_data;
-       struct ti_st_plat_data  *pdata;
-
-       /* diff actions in diff states */
-       switch (st_data->ll_state) {
-       case ST_LL_ASLEEP:
-               send_ll_cmd(st_data, LL_WAKE_UP_ACK);   /* send wake_ack */
-               break;
-       case ST_LL_ASLEEP_TO_AWAKE:
-               /* duplicate wake_ind */
-               pr_err("duplicate wake_ind while waiting for Wake ack");
-               break;
-       case ST_LL_AWAKE:
-               /* duplicate wake_ind */
-               pr_err("duplicate wake_ind already AWAKE");
-               break;
-       case ST_LL_AWAKE_TO_ASLEEP:
-               /* duplicate wake_ind */
-               pr_err("duplicate wake_ind");
-               break;
-       }
-       /* update state */
-       st_data->ll_state = ST_LL_AWAKE;
-
-       /* communicate to platform about chip wakeup */
-       kim_data = st_data->kim_data;
-       pdata = kim_data->kim_pdev->dev.platform_data;
-       if (pdata->chip_awake)
-               pdata->chip_awake(NULL);
-}
-
-/**********************************************************************/
-/* functions invoked by ST Core */
-
-/* called when ST Core wants to
- * enable ST LL */
-void st_ll_enable(struct st_data_s *ll)
-{
-       ll->ll_state = ST_LL_AWAKE;
-}
-
-/* called when ST Core /local module wants to
- * disable ST LL */
-void st_ll_disable(struct st_data_s *ll)
-{
-       ll->ll_state = ST_LL_INVALID;
-}
-
-/* called when ST Core wants to update the state */
-void st_ll_wakeup(struct st_data_s *ll)
-{
-       if (likely(ll->ll_state != ST_LL_AWAKE)) {
-               send_ll_cmd(ll, LL_WAKE_UP_IND);        /* WAKE_IND */
-               ll->ll_state = ST_LL_ASLEEP_TO_AWAKE;
-       } else {
-               /* don't send the duplicate wake_indication */
-               pr_err(" Chip already AWAKE ");
-       }
-}
-
-/* called when ST Core wants the state */
-unsigned long st_ll_getstate(struct st_data_s *ll)
-{
-       pr_debug(" returning state %ld", ll->ll_state);
-       return ll->ll_state;
-}
-
-/* called from ST Core, when a PM related packet arrives */
-unsigned long st_ll_sleep_state(struct st_data_s *st_data,
-       unsigned char cmd)
-{
-       switch (cmd) {
-       case LL_SLEEP_IND:      /* sleep ind */
-               pr_debug("sleep indication recvd");
-               ll_device_want_to_sleep(st_data);
-               break;
-       case LL_SLEEP_ACK:      /* sleep ack */
-               pr_err("sleep ack rcvd: host shouldn't");
-               break;
-       case LL_WAKE_UP_IND:    /* wake ind */
-               pr_debug("wake indication recvd");
-               ll_device_want_to_wakeup(st_data);
-               break;
-       case LL_WAKE_UP_ACK:    /* wake ack */
-               pr_debug("wake ack rcvd");
-               st_data->ll_state = ST_LL_AWAKE;
-               break;
-       default:
-               pr_err(" unknown input/state ");
-               return -EINVAL;
-       }
-       return 0;
-}
-
-/* Called from ST CORE to initialize ST LL */
-long st_ll_init(struct st_data_s *ll)
-{
-       /* set state to invalid */
-       ll->ll_state = ST_LL_INVALID;
-       return 0;
-}
-
-/* Called from ST CORE to de-initialize ST LL */
-long st_ll_deinit(struct st_data_s *ll)
-{
-       return 0;
-}

include/linux/ti_wilink_st.h +0 -336

index a9de5654b0cd..76a372bdf540 100644
@@ -27,268 +27,9 @@
 
 #include <linux/skbuff.h>
 
-/**
- * enum proto-type - The protocol on WiLink chips which share a
- *     common physical interface like UART.
- */
-enum proto_type {
-       ST_BT,
-       ST_FM,
-       ST_GPS,
-       ST_MAX_CHANNELS = 16,
-};
-
-/**
- * struct st_proto_s - Per Protocol structure from BT/FM/GPS to ST
- * @type: type of the protocol being registered among the
- *     available proto_type(BT, FM, GPS the protocol which share TTY).
- * @recv: the receiver callback pointing to a function in the
- *     protocol drivers called by the ST driver upon receiving
- *     relevant data.
- * @match_packet: reserved for future use, to make ST more generic
- * @reg_complete_cb: callback handler pointing to a function in protocol
- *     handler called by ST when the pending registrations are complete.
- *     The registrations are marked pending, in situations when fw
- *     download is in progress.
- * @write: pointer to function in ST provided to protocol drivers from ST,
- *     to be made use when protocol drivers have data to send to TTY.
- * @priv_data: privdate data holder for the protocol drivers, sent
- *     from the protocol drivers during registration, and sent back on
- *     reg_complete_cb and recv.
- * @chnl_id: channel id the protocol driver is interested in, the channel
- *     id is nothing but the 1st byte of the packet in UART frame.
- * @max_frame_size: size of the largest frame the protocol can receive.
- * @hdr_len: length of the header structure of the protocol.
- * @offset_len_in_hdr: this provides the offset of the length field in the
- *     header structure of the protocol header, to assist ST to know
- *     how much to receive, if the data is split across UART frames.
- * @len_size: whether the length field inside the header is 2 bytes
- *     or 1 byte.
- * @reserve: the number of bytes ST needs to reserve in the skb being
- *     prepared for the protocol driver.
- */
-struct st_proto_s {
-       enum proto_type type;
-       long (*recv) (void *, struct sk_buff *);
-       unsigned char (*match_packet) (const unsigned char *data);
-       void (*reg_complete_cb) (void *, int data);
-       long (*write) (struct sk_buff *skb);
-       void *priv_data;
-
-       unsigned char chnl_id;
-       unsigned short max_frame_size;
-       unsigned char hdr_len;
-       unsigned char offset_len_in_hdr;
-       unsigned char len_size;
-       unsigned char reserve;
-};
-
-extern long st_register(struct st_proto_s *);
-extern long st_unregister(struct st_proto_s *);
-
 void hci_ti_set_fm_handler(struct device *dev, void (*recv_handler) (void *, struct sk_buff *), void *drvdata);
 int hci_ti_fm_send(struct device *dev, struct sk_buff *skb);
 
-/*
- * header information used by st_core.c
- */
-
-/* states of protocol list */
-#define ST_NOTEMPTY    1
-#define ST_EMPTY       0
-
-/*
- * possible st_states
- */
-#define ST_INITIALIZING                1
-#define ST_REG_IN_PROGRESS     2
-#define ST_REG_PENDING         3
-#define ST_WAITING_FOR_RESP    4
-
-/**
- * struct st_data_s - ST core internal structure
- * @st_state: different states of ST like initializing, registration
- *     in progress, this is mainly used to return relevant err codes
- *     when protocol drivers are registering. It is also used to track
- *     the recv function, as in during fw download only HCI events
- *     can occur , where as during other times other events CH8, CH9
- *     can occur.
- * @tty: tty provided by the TTY core for line disciplines.
- * @tx_skb: If for some reason the tty's write returns lesser bytes written
- *     then to maintain the rest of data to be written on next instance.
- *     This needs to be protected, hence the lock inside wakeup func.
- * @tx_state: if the data is being written onto the TTY and protocol driver
- *     wants to send more, queue up data and mark that there is
- *     more data to send.
- * @list: the list of protocols registered, only MAX can exist, one protocol
- *     can register only once.
- * @rx_state: states to be maintained inside st's tty receive
- * @rx_count: count to be maintained inside st's tty receieve
- * @rx_skb: the skb where all data for a protocol gets accumulated,
- *     since tty might not call receive when a complete event packet
- *     is received, the states, count and the skb needs to be maintained.
- * @rx_chnl: the channel ID for which the data is getting accumalated for.
- * @txq: the list of skbs which needs to be sent onto the TTY.
- * @tx_waitq: if the chip is not in AWAKE state, the skbs needs to be queued
- *     up in here, PM(WAKEUP_IND) data needs to be sent and then the skbs
- *     from waitq can be moved onto the txq.
- *     Needs locking too.
- * @lock: the lock to protect skbs, queues, and ST states.
- * @protos_registered: count of the protocols registered, also when 0 the
- *     chip enable gpio can be toggled, and when it changes to 1 the fw
- *     needs to be downloaded to initialize chip side ST.
- * @ll_state: the various PM states the chip can be, the states are notified
- *     to us, when the chip sends relevant PM packets(SLEEP_IND, WAKE_IND).
- * @kim_data: reference to the parent encapsulating structure.
- *
- */
-struct st_data_s {
-       unsigned long st_state;
-       struct sk_buff *tx_skb;
-#define ST_TX_SENDING  1
-#define ST_TX_WAKEUP   2
-       unsigned long tx_state;
-       struct st_proto_s *list[ST_MAX_CHANNELS];
-       bool is_registered[ST_MAX_CHANNELS];
-       unsigned long rx_state;
-       unsigned long rx_count;
-       struct sk_buff *rx_skb;
-       unsigned char rx_chnl;
-       struct sk_buff_head txq, tx_waitq;
-       spinlock_t lock;
-       unsigned char   protos_registered;
-       unsigned long ll_state;
-       void *kim_data;
-       struct tty_struct *tty;
-       struct work_struct work_write_wakeup;
-};
-
-/*
- * wrapper around tty->ops->write_room to check
- * availability during firmware download
- */
-int st_get_uart_wr_room(struct st_data_s *st_gdata);
-/**
- * st_int_write -
- * point this to tty->driver->write or tty->ops->write
- * depending upon the kernel version
- */
-int st_int_write(struct st_data_s*, const unsigned char*, int);
-
-/**
- * st_write -
- * internal write function, passed onto protocol drivers
- * via the write function ptr of protocol struct
- */
-long st_write(struct sk_buff *);
-
-/* function to be called from ST-LL */
-void st_ll_send_frame(enum proto_type, struct sk_buff *);
-
-/* internal wake up function */
-void st_tx_wakeup(struct st_data_s *st_data);
-
-/* init, exit entry funcs called from KIM */
-int st_core_init(struct st_data_s **);
-void st_core_exit(struct st_data_s *);
-
-/* ask for reference from KIM */
-void st_kim_ref(struct st_data_s **, int);
-
-#define GPS_STUB_TEST
-#ifdef GPS_STUB_TEST
-int gps_chrdrv_stub_write(const unsigned char*, int);
-void gps_chrdrv_stub_init(void);
-#endif
-
-/*
- * header information used by st_kim.c
- */
-
-/* time in msec to wait for
- * line discipline to be installed
- */
-#define LDISC_TIME     1000
-#define CMD_RESP_TIME  800
-#define CMD_WR_TIME    5000
-#define MAKEWORD(a, b)  ((unsigned short)(((unsigned char)(a)) \
-       | ((unsigned short)((unsigned char)(b))) << 8))
-
-#define GPIO_HIGH 1
-#define GPIO_LOW  0
-
-/* the Power-On-Reset logic, requires to attempt
- * to download firmware onto chip more than once
- * since the self-test for chip takes a while
- */
-#define POR_RETRY_COUNT 5
-
-/**
- * struct chip_version - save the chip version
- */
-struct chip_version {
-       unsigned short full;
-       unsigned short chip;
-       unsigned short min_ver;
-       unsigned short maj_ver;
-};
-
-#define UART_DEV_NAME_LEN 32
-/**
- * struct kim_data_s - the KIM internal data, embedded as the
- *     platform's drv data. One for each ST device in the system.
- * @uim_pid: KIM needs to communicate with UIM to request to install
- *     the ldisc by opening UART when protocol drivers register.
- * @kim_pdev: the platform device added in one of the board-XX.c file
- *     in arch/XX/ directory, 1 for each ST device.
- * @kim_rcvd: completion handler to notify when data was received,
- *     mainly used during fw download, which involves multiple send/wait
- *     for each of the HCI-VS commands.
- * @ldisc_installed: completion handler to notify that the UIM accepted
- *     the request to install ldisc, notify from tty_open which suggests
- *     the ldisc was properly installed.
- * @resp_buffer: data buffer for the .bts fw file name.
- * @fw_entry: firmware class struct to request/release the fw.
- * @rx_state: the rx state for kim's receive func during fw download.
- * @rx_count: the rx count for the kim's receive func during fw download.
- * @rx_skb: all of fw data might not come at once, and hence data storage for
- *     whole of the fw response, only HCI_EVENTs and hence diff from ST's
- *     response.
- * @core_data: ST core's data, which mainly is the tty's disc_data
- * @version: chip version available via a sysfs entry.
- *
- */
-struct kim_data_s {
-       long uim_pid;
-       struct platform_device *kim_pdev;
-       struct completion kim_rcvd, ldisc_installed;
-       char resp_buffer[30];
-       const struct firmware *fw_entry;
-       unsigned nshutdown;
-       unsigned long rx_state;
-       unsigned long rx_count;
-       struct sk_buff *rx_skb;
-       struct st_data_s *core_data;
-       struct chip_version version;
-       unsigned char ldisc_install;
-       unsigned char dev_name[UART_DEV_NAME_LEN + 1];
-       unsigned flow_cntrl;
-       unsigned baud_rate;
-};
-
-/**
- * functions called when 1 of the protocol drivers gets
- * registered, these need to communicate with UIM to request
- * ldisc installed, read chip_version, download relevant fw
- */
-long st_kim_start(void *);
-long st_kim_stop(void *);
-
-void st_kim_complete(void *);
-void kim_st_list_protocols(struct st_data_s *, void *);
-void st_kim_recv(void *, const unsigned char *, long);
-
-
 /*
  * BTS headers
  */

@@ -355,47 +96,6 @@ struct hci_command {
        u32 speed;
 } __attribute__ ((packed));
 
-/*
- * header information used by st_ll.c
- */
-
-/* ST LL receiver states */
-#define ST_W4_PACKET_TYPE       0
-#define ST_W4_HEADER           1
-#define ST_W4_DATA             2
-
-/* ST LL state machines */
-#define ST_LL_ASLEEP               0
-#define ST_LL_ASLEEP_TO_AWAKE      1
-#define ST_LL_AWAKE                2
-#define ST_LL_AWAKE_TO_ASLEEP      3
-#define ST_LL_INVALID             4
-
-/* different PM notifications coming from chip */
-#define LL_SLEEP_IND   0x30
-#define LL_SLEEP_ACK   0x31
-#define LL_WAKE_UP_IND 0x32
-#define LL_WAKE_UP_ACK 0x33
-
-/* initialize and de-init ST LL */
-long st_ll_init(struct st_data_s *);
-long st_ll_deinit(struct st_data_s *);
-
-/**
- * enable/disable ST LL along with KIM start/stop
- * called by ST Core
- */
-void st_ll_enable(struct st_data_s *);
-void st_ll_disable(struct st_data_s *);
-
-/**
- * various funcs used by ST core to set/get the various PM states
- * of the chip.
- */
-unsigned long st_ll_getstate(struct st_data_s *);
-unsigned long st_ll_sleep_state(struct st_data_s *, unsigned char);
-void st_ll_wakeup(struct st_data_s *);
-
 /*
  * header information used by st_core.c for FM and GPS
  * packet parsing, the bluetooth headers are already available

@@ -416,39 +116,4 @@ struct gps_event_hdr {
        u16 plen;
 } __attribute__ ((packed));
 
-/**
- * struct ti_st_plat_data - platform data shared between ST driver and
- *     platform specific board file which adds the ST device.
- * @nshutdown_gpio: Host's GPIO line to which chip's BT_EN is connected.
- * @dev_name: The UART/TTY name to which chip is interfaced. (eg: /dev/ttyS1)
- * @flow_cntrl: Should always be 1, since UART's CTS/RTS is used for PM
- *     purposes.
- * @baud_rate: The baud rate supported by the Host UART controller, this will
- *     be shared across with the chip via a HCI VS command from User-Space Init
- *     Mgr application.
- * @suspend:
- * @resume: legacy PM routines hooked to platform specific board file, so as
- *     to take chip-host interface specific action.
- * @chip_enable:
- * @chip_disable: Platform/Interface specific mux mode setting, GPIO
- *     configuring, Host side PM disabling etc.. can be done here.
- * @chip_asleep:
- * @chip_awake: Chip specific deep sleep states is communicated to Host
- *     specific board-xx.c to take actions such as cut UART clocks when chip
- *     asleep or run host faster when chip awake etc..
- *
- */
-struct ti_st_plat_data {
-       u32 nshutdown_gpio;
-       unsigned char dev_name[UART_DEV_NAME_LEN]; /* uart name */
-       u32 flow_cntrl; /* flow control flag */
-       u32 baud_rate;
-       int (*suspend)(struct platform_device *, pm_message_t);
-       int (*resume)(struct platform_device *);
-       int (*chip_enable) (struct kim_data_s *);
-       int (*chip_disable) (struct kim_data_s *);
-       int (*chip_asleep) (struct kim_data_s *);
-       int (*chip_awake) (struct kim_data_s *);
-};
-
 #endif /* TI_WILINK_ST_H */
 
--

2.19.2