Return-Path: From: pavan_savoy@ti.com To: marcel@holtmann.org Cc: pavan_savoy@yahoo.co.in, linux-kernel@vger.kernel.org, linux-bluetooth@vger.kernel.org, Pavan Savoy Subject: [PATCH 1/1] bluetooth: BT driver using ST for TI combo devices Date: Wed, 24 Mar 2010 16:37:02 -0500 Message-Id: <1269466622-1881-1-git-send-email-pavan_savoy@ti.com> List-ID: From: Pavan Savoy This is BlueZ driver making use of Shared Transport line discipline to communicate with the chip. Signed-off-by: Pavan Savoy --- drivers/staging/ti-st/bt_drv.c | 502 ++++++++++++++++++++++++++++++++++++++++ drivers/staging/ti-st/bt_drv.h | 61 +++++ 2 files changed, 563 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/ti-st/bt_drv.c create mode 100644 drivers/staging/ti-st/bt_drv.h diff --git a/drivers/staging/ti-st/bt_drv.c b/drivers/staging/ti-st/bt_drv.c new file mode 100644 index 0000000..d8420b5 --- /dev/null +++ b/drivers/staging/ti-st/bt_drv.c @@ -0,0 +1,502 @@ +/* + * Texas Instrument's Bluetooth Driver For Shared Transport. + * + * Bluetooth Driver acts as interface between HCI CORE and + * TI Shared Transport Layer. + * + * Copyright (C) 2009 Texas Instruments + * + * 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 + * + */ + +#include +#include + +#include "st.h" +#include "bt_drv.h" + +/* Define this macro to get debug msg */ +#undef DEBUG + +#ifdef DEBUG +#define BT_DRV_DBG(fmt, arg...) printk(KERN_INFO "(btdrv):"fmt"\n" , ## arg) +#define BTDRV_API_START() printk(KERN_INFO "(btdrv): %s Start\n", \ + __func__) +#define BTDRV_API_EXIT(errno) printk(KERN_INFO "(btdrv): %s Exit(%d)\n", \ + __func__, errno) +#else +#define BT_DRV_DBG(fmt, arg...) +#define BTDRV_API_START() +#define BTDRV_API_EXIT(errno) +#endif + +#define BT_DRV_ERR(fmt, arg...) printk(KERN_ERR "(btdrv):"fmt"\n" , ## arg) + +static int reset; +static struct hci_st *hst; + +/* Increments HCI counters based on pocket ID (cmd,acl,sco) */ +static inline void hci_st_tx_complete(struct hci_st *hst, int pkt_type) +{ + struct hci_dev *hdev; + + BTDRV_API_START(); + + hdev = hst->hdev; + + /* Update HCI stat counters */ + switch (pkt_type) { + case HCI_COMMAND_PKT: + hdev->stat.cmd_tx++; + break; + + case HCI_ACLDATA_PKT: + hdev->stat.acl_tx++; + break; + + case HCI_SCODATA_PKT: + hdev->stat.cmd_tx++; + break; + } + + BTDRV_API_EXIT(0); +} + +/* ------- Interfaces to Shared Transport ------ */ + +/* Called by ST layer to indicate protocol registration completion + * status.hci_st_open() function will wait for signal from this + * API when st_register() function returns ST_PENDING. + */ +static void hci_st_registration_completion_cb(char data) +{ + BTDRV_API_START(); + + /* hci_st_open() function needs value of 'data' to know + * the registration status(success/fail),So have a back + * up of it. + */ + hst->streg_cbdata = data; + + /* Got a feedback from ST for BT driver registration + * request.Wackup hci_st_open() function to continue + * it's open operation. + */ + complete(&hst->wait_for_btdrv_reg_completion); + + BTDRV_API_EXIT(0); +} + +/* Called by Shared Transport layer when receive data is + * available */ +static long hci_st_receive(struct sk_buff *skb) +{ + int err; + int len; + + BTDRV_API_START(); + + err = 0; + len = 0; + + if (skb == NULL) { + BT_DRV_ERR("Invalid SKB received from ST"); + BTDRV_API_EXIT(-EFAULT); + return -EFAULT; + } + if (!hst) { + kfree_skb(skb); + BT_DRV_ERR("Invalid hci_st memory,freeing SKB"); + BTDRV_API_EXIT(-EFAULT); + return -EFAULT; + } + if (!test_bit(BT_DRV_RUNNING, &hst->flags)) { + kfree_skb(skb); + BT_DRV_ERR("Device is not running,freeing SKB"); + BTDRV_API_EXIT(-EINVAL); + return -EINVAL; + } + + len = skb->len; + skb->dev = (struct net_device *)hst->hdev; + + /* Forward skb to HCI CORE layer */ + err = hci_recv_frame(skb); + if (err) { + kfree_skb(skb); + BT_DRV_ERR("Unable to push skb to HCI CORE(%d),freeing SKB", + err); + BTDRV_API_EXIT(err); + return err; + } + hst->hdev->stat.byte_rx += len; + + BTDRV_API_EXIT(0); + return 0; +} + +/* ------- Interfaces to HCI layer ------ */ + +/* Called from HCI core to initialize the device */ +static int hci_st_open(struct hci_dev *hdev) +{ + static struct st_proto_s hci_st_proto; + unsigned long timeleft; + int err; + + BTDRV_API_START(); + + err = 0; + + BT_DRV_DBG("%s %p", hdev->name, hdev); + + /* Already registered with ST ? */ + if (test_bit(BT_ST_REGISTERED, &hst->flags)) { + BT_DRV_ERR("Registered with ST already,open called again?"); + BTDRV_API_EXIT(0); + return 0; + } + + /* Populate BT driver info required by ST */ + memset(&hci_st_proto, 0, sizeof(hci_st_proto)); + + /* BT driver ID */ + hci_st_proto.type = ST_BT; + + /* Receive function which called from ST */ + hci_st_proto.recv = hci_st_receive; + + /* Packet match function may used in future */ + hci_st_proto.match_packet = NULL; + + /* Callback to be called when registration is pending */ + hci_st_proto.reg_complete_cb = hci_st_registration_completion_cb; + + /* This is write function pointer of ST. BT driver will make use of this + * for sending any packets to chip. ST will assign and give to us, so + * make it as NULL */ + hci_st_proto.write = NULL; + + /* Register with ST layer */ + err = st_register(&hci_st_proto); + if (err == ST_ERR_PENDING) { + /* Prepare wait-for-completion handler data structures. + * Needed to syncronize this and st_registration_completion_cb() + * functions. + */ + init_completion(&hst->wait_for_btdrv_reg_completion); + + /* Reset ST registration callback status flag , this value + * will be updated in hci_st_registration_completion_cb() + * function whenever it called from ST driver. + */ + hst->streg_cbdata = -EINPROGRESS; + + /* ST is busy with other protocol registration(may be busy with + * firmware download).So,Wait till the registration callback + * (passed as a argument to st_register() function) getting + * called from ST. + */ + BT_DRV_DBG(" %s waiting for reg completion signal from ST", + __func__); + + timeleft = + wait_for_completion_timeout + (&hst->wait_for_btdrv_reg_completion, + msecs_to_jiffies(BT_REGISTER_TIMEOUT)); + if (!timeleft) { + BT_DRV_ERR("Timeout(%ld sec),didn't get reg" + "completion signal from ST", + BT_REGISTER_TIMEOUT / 1000); + BTDRV_API_EXIT(-ETIMEDOUT); + return -ETIMEDOUT; + } + + /* Is ST registration callback called with ERROR value? */ + if (hst->streg_cbdata != 0) { + BT_DRV_ERR("ST reg completion CB called with invalid" + "status %d", hst->streg_cbdata); + BTDRV_API_EXIT(-EAGAIN); + return -EAGAIN; + } + err = 0; + } else if (err == ST_ERR_FAILURE) { + BT_DRV_ERR("st_register failed %d", err); + BTDRV_API_EXIT(-EAGAIN); + return -EAGAIN; + } + + /* Do we have proper ST write function? */ + if (hci_st_proto.write != NULL) { + /* We need this pointer for sending any Bluetooth pkts */ + hst->st_write = hci_st_proto.write; + } else { + BT_DRV_ERR("failed to get ST write func pointer"); + + /* Undo registration with ST */ + err = st_unregister(ST_BT); + if (err < 0) + BT_DRV_ERR("st_unregister failed %d", err); + + hst->st_write = NULL; + BTDRV_API_EXIT(-EAGAIN); + return -EAGAIN; + } + + /* Registration with ST layer is completed successfully, + * now chip is ready to accept commands from HCI CORE. + * Mark HCI Device flag as RUNNING + */ + set_bit(HCI_RUNNING, &hdev->flags); + + /* Registration with ST successful */ + set_bit(BT_ST_REGISTERED, &hst->flags); + + BTDRV_API_EXIT(err); + return err; +} + +/* Close device */ +static int hci_st_close(struct hci_dev *hdev) +{ + int err; + + BTDRV_API_START(); + + err = 0; + + /* Unregister from ST layer */ + if (test_and_clear_bit(BT_ST_REGISTERED, &hst->flags)) { + err = st_unregister(ST_BT); + if (err != ST_SUCCESS) { + BT_DRV_ERR("st_unregister failed %d", err); + BTDRV_API_EXIT(-EBUSY); + return -EBUSY; + } + } + + hst->st_write = NULL; + + /* ST layer would have moved chip to inactive state. + * So,clear HCI device RUNNING flag. + */ + if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) { + BTDRV_API_EXIT(0); + return 0; + } + + BTDRV_API_EXIT(err); + return err; +} + +/* Called from HCI CORE , Sends frames to Shared Transport */ +static int hci_st_send_frame(struct sk_buff *skb) +{ + struct hci_dev *hdev; + struct hci_st *hst; + long len; + + BTDRV_API_START(); + + if (skb == NULL) { + BT_DRV_ERR("Invalid skb received from HCI CORE"); + BTDRV_API_EXIT(-ENOMEM); + return -ENOMEM; + } + hdev = (struct hci_dev *)skb->dev; + if (!hdev) { + BT_DRV_ERR("SKB received for invalid HCI Device (hdev=NULL)"); + BTDRV_API_EXIT(-ENODEV); + return -ENODEV; + } + if (!test_bit(HCI_RUNNING, &hdev->flags)) { + BT_DRV_ERR("Device is not running"); + BTDRV_API_EXIT(-EBUSY); + return -EBUSY; + } + + hst = (struct hci_st *)hdev->driver_data; + + /* Prepend skb with frame type */ + memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); + + BT_DRV_DBG(" %s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, + skb->len); + + /* Insert skb to shared transport layer's transmit queue. + * Freeing skb memory is taken care in shared transport layer, + * so don't free skb memory here. + */ + if (!hst->st_write) { + kfree_skb(skb); + BT_DRV_ERR(" Can't write to ST, st_write null?"); + BTDRV_API_EXIT(-EAGAIN); + return -EAGAIN; + } + len = hst->st_write(skb); + if (len < 0) { + /* Something went wrong in st write , free skb memory */ + kfree_skb(skb); + BT_DRV_ERR(" ST write failed (%ld)", len); + BTDRV_API_EXIT(-EAGAIN); + return -EAGAIN; + } + + /* ST accepted our skb. So, Go ahead and do rest */ + hdev->stat.byte_tx += len; + hci_st_tx_complete(hst, bt_cb(skb)->pkt_type); + + BTDRV_API_EXIT(0); + return 0; +} + +static void hci_st_destruct(struct hci_dev *hdev) +{ + BTDRV_API_START(); + + if (!hdev) { + BT_DRV_ERR("Destruct called with invalid HCI Device" + "(hdev=NULL)"); + BTDRV_API_EXIT(0); + return; + } + + BT_DRV_DBG("%s", hdev->name); + + /* free hci_st memory */ + if (hdev->driver_data != NULL) + kfree(hdev->driver_data); + + BTDRV_API_EXIT(0); + return; +} + +/* Creates new HCI device */ +static int hci_st_register_dev(struct hci_st *hst) +{ + struct hci_dev *hdev; + + BTDRV_API_START(); + + /* Initialize and register HCI device */ + hdev = hci_alloc_dev(); + if (!hdev) { + BT_DRV_ERR("Can't allocate HCI device"); + BTDRV_API_EXIT(-ENOMEM); + return -ENOMEM; + } + BT_DRV_DBG(" HCI device allocated. hdev= %p", hdev); + + hst->hdev = hdev; + hdev->bus = HCI_UART; + hdev->driver_data = hst; + hdev->open = hci_st_open; + hdev->close = hci_st_close; + hdev->flush = NULL; + hdev->send = hci_st_send_frame; + hdev->destruct = hci_st_destruct; + hdev->owner = THIS_MODULE; + + if (reset) + set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks); + + if (hci_register_dev(hdev) < 0) { + BT_DRV_ERR("Can't register HCI device"); + hci_free_dev(hdev); + BTDRV_API_EXIT(-ENODEV); + return -ENODEV; + } + + BT_DRV_DBG(" HCI device registered. hdev= %p", hdev); + BTDRV_API_EXIT(0); + return 0; +} + +/* ------- Module Init interface ------ */ + +static int __init bt_drv_init(void) +{ + int err; + + BTDRV_API_START(); + + err = 0; + + BT_DRV_DBG(" Bluetooth Driver Version %s", VERSION); + + /* Allocate local resource memory */ + hst = kzalloc(sizeof(struct hci_st), GFP_KERNEL); + if (!hst) { + BT_DRV_ERR("Can't allocate control structure"); + BTDRV_API_EXIT(-ENFILE); + return -ENFILE; + } + + /* Expose "hciX" device to user space */ + err = hci_st_register_dev(hst); + if (err) { + /* Release local resource memory */ + kfree(hst); + + BT_DRV_ERR("Unable to expose hci0 device(%d)", err); + BTDRV_API_EXIT(err); + return err; + } + set_bit(BT_DRV_RUNNING, &hst->flags); + + BTDRV_API_EXIT(err); + return err; +} + +/* ------- Module Exit interface ------ */ + +static void __exit bt_drv_exit(void) +{ + BTDRV_API_START(); + + /* Deallocate local resource's memory */ + if (hst) { + struct hci_dev *hdev = hst->hdev; + + if (hdev == NULL) { + BT_DRV_ERR("Invalid hdev memory"); + kfree(hst); + } else { + hci_st_close(hdev); + if (test_and_clear_bit(BT_DRV_RUNNING, &hst->flags)) { + /* Remove HCI device (hciX) created + * in module init. + */ + hci_unregister_dev(hdev); + + /* Free HCI device memory */ + hci_free_dev(hdev); + } + } + } + BTDRV_API_EXIT(0); +} + +module_init(bt_drv_init); +module_exit(bt_drv_exit); + +/* ------ Module Info ------ */ + +module_param(reset, bool, 0644); +MODULE_PARM_DESC(reset, "Send HCI reset command on initialization"); +MODULE_AUTHOR("Raja Mani "); +MODULE_DESCRIPTION("Bluetooth Driver for TI Shared Transport" VERSION); +MODULE_VERSION(VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/staging/ti-st/bt_drv.h b/drivers/staging/ti-st/bt_drv.h new file mode 100644 index 0000000..a0beebe --- /dev/null +++ b/drivers/staging/ti-st/bt_drv.h @@ -0,0 +1,61 @@ +/* + * Texas Instrument's Bluetooth Driver For Shared Transport. + * + * Bluetooth Driver acts as interface between HCI CORE and + * TI Shared Transport Layer. + * + * Copyright (C) 2009 Texas Instruments + * + * 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 + * + */ + +#ifndef _BT_DRV_H +#define _BT_DRV_H + +/* Bluetooth Driver Version */ +#define VERSION "1.0" + +/* Defines number of seconds to wait for reg completion + * callback getting called from ST (in case,registration + * with ST returns PENDING status) + */ +#define BT_REGISTER_TIMEOUT msecs_to_jiffies(6000) /* 6 sec */ + +/* BT driver's local status */ +#define BT_DRV_RUNNING 0 +#define BT_ST_REGISTERED 1 + +/* BT driver operation structure */ +struct hci_st { + + /* hci device pointer which binds to bt driver */ + struct hci_dev *hdev; + + /* used locally,to maintain various BT driver status */ + unsigned long flags; + + /* to hold ST registration callback status */ + char streg_cbdata; + + /* write function pointer of ST driver */ + long (*st_write) (struct sk_buff *); + + /* Wait on comepletion handler needed to synchronize + * hci_st_open() and hci_st_registration_completion_cb() + * functions.*/ + struct completion wait_for_btdrv_reg_completion; +}; + +#endif -- 1.5.4.3