ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/os/linux/ar6k_pal.c

+//------------------------------------------------------------------------------
+// Copyright (c) 2004-2010 Atheros Communications Inc.
+// All rights reserved.
+//
+// 
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+//
+//
+// Author(s): ="Atheros"
+//------------------------------------------------------------------------------
+
+#include "ar6000_drv.h"
+#ifdef AR6K_ENABLE_HCI_PAL
+#include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
+#include <ar6k_pal.h>
+
+extern unsigned int setupbtdev;
+#define bt_check_bit(val, bit) (val & bit)
+#define bt_set_bit(val, bit) (val |= bit)
+#define bt_clear_bit(val, bit) (val &= ~bit)
+
+/* export ATH_AR6K_DEBUG_HCI_PAL=yes in host/localmake.linux.inc
+ * to enable debug information */
+#ifdef HCIPAL_DEBUG
+#define PRIN_LOG(format, args...) printk(KERN_ALERT "%s:%d - %s Msg:" format "\n",__FUNCTION__, __LINE__, __FILE__, ## args) 
+#else
+#define PRIN_LOG(format, args...)
+#endif
+
+/**********************************
+ * HCI PAL private info structure 
+ *********************************/
+typedef struct ar6k_hci_pal_info_s{
+
+        unsigned long ulFlags;
+#define HCI_NORMAL_MODE (1)
+#define HCI_REGISTERED (1<<1)
+        struct hci_dev *hdev;            /* BT Stack HCI dev */
+        AR_SOFTC_T *ar;
+
+}ar6k_hci_pal_info_t;
+
+/*** BT Stack Entrypoints *******/
+/***************************************
+ * bt_open - open a handle to the device
+ ***************************************/
+static int bt_open(struct hci_dev *hdev)
+{
+        PRIN_LOG("HCI PAL: bt_open - enter - x\n");
+        set_bit(HCI_RUNNING, &hdev->flags);
+        set_bit(HCI_UP, &hdev->flags);
+        set_bit(HCI_INIT, &hdev->flags);         
+        return 0;
+}
+
+/***************************************
+ * bt_close - close handle to the device
+ ***************************************/
+static int bt_close(struct hci_dev *hdev)
+{
+        PRIN_LOG("HCI PAL: bt_close - enter\n");
+        clear_bit(HCI_RUNNING, &hdev->flags);
+        return 0;
+}
+
+/*****************************
+ * bt_ioctl - ioctl processing
+ *****************************/
+static int bt_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
+{
+        PRIN_LOG("HCI PAL: bt_ioctl - enter\n");
+        return -ENOIOCTLCMD;
+}
+
+/**************************************
+ * bt_flush - flush outstanding packets
+ **************************************/
+static int bt_flush(struct hci_dev *hdev)
+{
+        PRIN_LOG("HCI PAL: bt_flush - enter\n");
+        return 0;
+}
+
+/***************
+ * bt_destruct  
+ ***************/
+static void bt_destruct(struct hci_dev *hdev)
+{
+        PRIN_LOG("HCI PAL: bt_destruct - enter\n");
+        /* nothing to do here */
+}
+
+/****************************************************
+ * Invoked from bluetooth stack via hdev->send()
+ * to send the packet out via ar6k to PAL firmware.
+ *
+ * For HCI command packet wmi_send_hci_cmd() is invoked.
+ * wmi_send_hci_cmd adds WMI_CMD_HDR and sends the packet
+ * to PAL firmware.
+ *
+ * For HCI ACL data packet wmi_data_hdr_add is invoked 
+ * to add WMI_DATA_HDR to the packet.  ar6000_acl_data_tx 
+ * is then invoked to send the packet to PAL firmware.
+ ******************************************************/
+static int btpal_send_frame(struct sk_buff *skb)
+{
+        struct hci_dev *hdev = (struct hci_dev *)skb->dev;
+        HCI_TRANSPORT_PACKET_TYPE type;
+        ar6k_hci_pal_info_t *pHciPalInfo;
+        A_STATUS status = A_OK;
+        struct sk_buff *txSkb = NULL;
+        AR_SOFTC_T *ar;
+
+        if (!hdev) {
+                PRIN_LOG("HCI PAL: btpal_send_frame - no device\n");
+                return -ENODEV;
+        }
+
+        if (!test_bit(HCI_RUNNING, &hdev->flags)) {
+                PRIN_LOG("HCI PAL: btpal_send_frame - not open\n");
+                return -EBUSY;
+        }
+
+        pHciPalInfo = (ar6k_hci_pal_info_t *)hdev->driver_data;   
+        A_ASSERT(pHciPalInfo != NULL);
+        ar = pHciPalInfo->ar;
+
+        PRIN_LOG("+btpal_send_frame type: %d \n",bt_cb(skb)->pkt_type);
+        type = HCI_COMMAND_TYPE;
+
+        switch (bt_cb(skb)->pkt_type) {
+                case HCI_COMMAND_PKT:
+                        type = HCI_COMMAND_TYPE;
+                        hdev->stat.cmd_tx++;
+                        break;
+
+                case HCI_ACLDATA_PKT:
+                        type = HCI_ACL_TYPE;
+                        hdev->stat.acl_tx++;
+                        break;
+
+                case HCI_SCODATA_PKT:
+                        /* we don't support SCO over the pal */
+                        kfree_skb(skb);
+                        return 0;
+                default:
+                        A_ASSERT(FALSE);
+                        kfree_skb(skb);
+                        return 0;
+        } 
+
+        if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_HCI_DUMP)) {
+                A_PRINTF(">>> Send HCI %s packet len: %d\n",
+                                (type == HCI_COMMAND_TYPE) ? "COMMAND" : "ACL",
+                                skb->len);
+                if (type == HCI_COMMAND_TYPE) {
+                        PRIN_LOG("    HCI Command: OGF:0x%X OCF:0x%X \r\n", 
+                                        HCI_GET_OP_CODE(skb-data) >> 10, HCI_GET_OP_CODE(skb-data) & 0x3FF);
+                }
+                AR_DEBUG_PRINTBUF(skb->data,skb->len,"BT HCI SEND Packet Dump");
+        }
+
+        do {
+                if(type == HCI_COMMAND_TYPE)
+                {
+                        PRIN_LOG("HCI command");
+
+                        if (ar->arWmiReady == FALSE)
+                        {
+                                PRIN_LOG("WMI not ready ");
+                                break;
+                        }
+
+                        if (wmi_send_hci_cmd(ar->arWmi, skb->data, skb->len) != A_OK)
+                        {
+                                PRIN_LOG("send hci cmd error");
+                                break;
+                        }
+                }
+                else if(type == HCI_ACL_TYPE)
+                {
+                        void *osbuf;
+
+                        PRIN_LOG("ACL data");
+                        if (ar->arWmiReady == FALSE)
+                        {
+                                PRIN_LOG("WMI not ready");
+                                break;
+                        }
+
+                        /* need to add WMI header so allocate a skb with more space */
+                        txSkb = bt_skb_alloc(TX_PACKET_RSV_OFFSET + WMI_MAX_TX_META_SZ + 
+                                        sizeof(WMI_DATA_HDR) + skb->len, 
+                                        GFP_ATOMIC);
+
+                        if (txSkb == NULL) {
+                                status = A_NO_MEMORY;
+                                PRIN_LOG("No memory");
+                                break;
+                        }
+
+                        bt_cb(txSkb)->pkt_type = bt_cb(skb)->pkt_type;
+                        txSkb->dev = (void *)pHciPalInfo->hdev;
+                        skb_reserve(txSkb, TX_PACKET_RSV_OFFSET + WMI_MAX_TX_META_SZ + sizeof(WMI_DATA_HDR));
+                        A_MEMCPY(txSkb->data, skb->data, skb->len);
+                        skb_put(txSkb,skb->len);
+                        /* Add WMI packet type */
+                        osbuf = (void *)txSkb;
+
+                        if (wmi_data_hdr_add(ar->arWmi, osbuf, DATA_MSGTYPE, 0, WMI_DATA_HDR_DATA_TYPE_ACL,0,NULL) != A_OK) {
+                                PRIN_LOG("XIOCTL_ACL_DATA - wmi_data_hdr_add failed\n");
+                        } else {
+                                /* Send data buffer over HTC */
+                                PRIN_LOG("acl data tx");
+                                ar6000_acl_data_tx(osbuf, ar->arNetDev);
+                        }
+                        txSkb = NULL;
+                }
+        } while (FALSE);
+
+        if (txSkb != NULL) {
+                PRIN_LOG("Free skb");
+                kfree_skb(txSkb);    
+        }
+        kfree_skb(skb);        
+        return 0;
+}
+
+
+/***********************************************
+ * Unregister HCI device and free HCI device info
+ ***********************************************/
+static void bt_cleanup_hci_pal(ar6k_hci_pal_info_t *pHciPalInfo)
+{   
+        int err;      
+
+        if (bt_check_bit(pHciPalInfo->ulFlags, HCI_REGISTERED)) {
+                bt_clear_bit(pHciPalInfo->ulFlags, HCI_REGISTERED);
+                clear_bit(HCI_RUNNING, &pHciPalInfo->hdev->flags);
+                clear_bit(HCI_UP, &pHciPalInfo->hdev->flags);
+                clear_bit(HCI_INIT, &pHciPalInfo->hdev->flags);   
+                A_ASSERT(pHciPalInfo->hdev != NULL);
+                /* unregister */
+                PRIN_LOG("Unregister PAL device");
+                if ((err = hci_unregister_dev(pHciPalInfo->hdev)) < 0) {
+                        PRIN_LOG("HCI PAL: failed to unregister with bluetooth %d\n",err);
+                }          
+        }
+
+        if (pHciPalInfo->hdev != NULL) {
+                kfree(pHciPalInfo->hdev);
+                pHciPalInfo->hdev = NULL;
+        }
+}
+
+/*********************************************************
+ * Allocate HCI device and store in PAL private info structure.
+ *********************************************************/
+static A_STATUS bt_setup_hci_pal(ar6k_hci_pal_info_t *pHciPalInfo)
+{
+        A_STATUS status = A_OK;
+        struct hci_dev *pHciDev = NULL;
+
+        if (!setupbtdev) {
+                return A_OK;    
+        } 
+
+        do {
+                /* allocate a BT HCI struct for this device */
+                pHciDev = hci_alloc_dev();
+                if (NULL == pHciDev) {
+                        PRIN_LOG("HCI PAL driver - failed to allocate BT HCI struct \n");
+                        status = A_NO_MEMORY;
+                        break;
+                }    
+
+                /* save the device, we'll register this later */
+                pHciPalInfo->hdev = pHciDev;       
+                SET_HCI_BUS_TYPE(pHciDev, HCI_VIRTUAL, HCI_80211);
+                pHciDev->driver_data = pHciPalInfo;
+                pHciDev->open     = bt_open;
+                pHciDev->close    = bt_close;
+                pHciDev->send     = btpal_send_frame;
+                pHciDev->ioctl    = bt_ioctl;
+                pHciDev->flush    = bt_flush;
+                pHciDev->destruct = bt_destruct;
+                pHciDev->owner = THIS_MODULE; 
+                /* driver is running in normal BT mode */
+                PRIN_LOG("Normal mode enabled");
+                bt_set_bit(pHciPalInfo->ulFlags, HCI_NORMAL_MODE);
+
+        } while (FALSE);
+
+        if (A_FAILED(status)) {
+                bt_cleanup_hci_pal(pHciPalInfo);    
+        }
+        return status;
+}
+
+/**********************************************
+ * Cleanup HCI device and free HCI PAL private info
+ *********************************************/
+void ar6k_cleanup_hci_pal(void *ar_p)
+{
+        AR_SOFTC_T *ar = (AR_SOFTC_T *)ar_p;
+        ar6k_hci_pal_info_t *pHciPalInfo = (ar6k_hci_pal_info_t *)ar->hcipal_info;
+
+        if (pHciPalInfo != NULL) {
+                bt_cleanup_hci_pal(pHciPalInfo);   
+                A_FREE(pHciPalInfo);
+                ar->hcipal_info = NULL;
+        }
+}
+
+/****************************
+ *  Register HCI device
+ ****************************/
+static A_BOOL ar6k_pal_transport_ready(void *pHciPal)
+{
+        ar6k_hci_pal_info_t *pHciPalInfo = (ar6k_hci_pal_info_t *)pHciPal;
+
+        PRIN_LOG("HCI device transport ready");
+        if(pHciPalInfo == NULL)
+                return FALSE;
+
+        if (hci_register_dev(pHciPalInfo->hdev) < 0) {
+                PRIN_LOG("Can't register HCI device");
+                hci_free_dev(pHciPalInfo->hdev);
+                return FALSE;
+        }
+        PRIN_LOG("HCI device registered");
+        pHciPalInfo->ulFlags |= HCI_REGISTERED;
+        return TRUE;
+}
+
+/**************************************************
+ * Called from ar6k driver when command or ACL data 
+ * packet is received. Pass the packet to bluetooth
+ * stack via hci_recv_frame.
+ **************************************************/
+A_BOOL ar6k_pal_recv_pkt(void *pHciPal, void *osbuf)
+{
+        struct sk_buff *skb = (struct sk_buff *)osbuf;
+        ar6k_hci_pal_info_t *pHciPalInfo;
+        A_BOOL success = FALSE;
+        A_UINT8 btType = 0;
+        pHciPalInfo = (ar6k_hci_pal_info_t *)pHciPal;
+
+        do {
+
+                /* if normal mode is not enabled pass on to the stack
+                 * by returning failure */
+                if(!(pHciPalInfo->ulFlags & HCI_NORMAL_MODE))
+                {
+                        PRIN_LOG("Normal mode not enabled");
+                        break;
+                }
+
+                if (!test_bit(HCI_RUNNING, &pHciPalInfo->hdev->flags)) {
+                        PRIN_LOG("HCI PAL: HCI - not running\n");
+                        break;
+                }
+
+                if(*((short *)A_NETBUF_DATA(skb)) == WMI_ACL_DATA_EVENTID)
+                        btType = HCI_ACLDATA_PKT;
+                else
+                        btType = HCI_EVENT_PKT;
+                /* pull 4 bytes which contains WMI packet type */
+                A_NETBUF_PULL(skb, sizeof(int));
+                bt_cb(skb)->pkt_type = btType;
+                skb->dev = (void *)pHciPalInfo->hdev;
+
+                /* pass the received event packet up the stack */    
+                if (hci_recv_frame(skb) != 0) {
+                        PRIN_LOG("HCI PAL: hci_recv_frame failed \n");
+                        break;
+                } else {
+                        PRIN_LOG("HCI PAL: Indicated RCV of type:%d, Length:%d \n",HCI_EVENT_PKT, skb->len);
+                }
+                PRIN_LOG("hci recv success");
+                success = TRUE;
+        }while(FALSE);
+        return success;
+}
+
+/**********************************************************
+ * HCI PAL init function called from ar6k when it is loaded..
+ * Allocates PAL private info, stores the same in ar6k private info.
+ * Registers a HCI device.
+ * Registers packet receive callback function with ar6k 
+ **********************************************************/
+A_STATUS ar6k_setup_hci_pal(void *ar_p)
+{
+        A_STATUS status = A_OK;
+        ar6k_hci_pal_info_t *pHciPalInfo;
+        ar6k_pal_config_t ar6k_pal_config;
+        AR_SOFTC_T *ar = (AR_SOFTC_T *)ar_p;
+
+        do {
+
+                pHciPalInfo = (ar6k_hci_pal_info_t *)A_MALLOC(sizeof(ar6k_hci_pal_info_t));
+
+                if (NULL == pHciPalInfo) {
+                        status = A_NO_MEMORY;
+                        break;    
+                }
+
+                A_MEMZERO(pHciPalInfo, sizeof(ar6k_hci_pal_info_t));
+                ar->hcipal_info = pHciPalInfo;
+                pHciPalInfo->ar = ar;
+
+                status = bt_setup_hci_pal(pHciPalInfo);
+                if (A_FAILED(status)) {
+                        break;    
+                }
+
+                if(bt_check_bit(pHciPalInfo->ulFlags, HCI_NORMAL_MODE))
+                        PRIN_LOG("HCI PAL: running in normal mode... \n");    
+                else 
+                        PRIN_LOG("HCI PAL: running in test mode... \n");     
+
+                ar6k_pal_config.fpar6k_pal_recv_pkt = ar6k_pal_recv_pkt;
+                register_pal_cb(&ar6k_pal_config);
+                ar6k_pal_transport_ready(ar->hcipal_info);
+        } while (FALSE);
+
+        if (A_FAILED(status)) {
+                ar6k_cleanup_hci_pal(ar);    
+        }
+        return status;
+}
+#else  /* AR6K_ENABLE_HCI_PAL */
+A_STATUS ar6k_setup_hci_pal(void *ar_p)
+{
+        return A_OK;
+}
+void ar6k_cleanup_hci_pal(void *ar_p)
+{
+}
+#endif /* AR6K_ENABLE_HCI_PAL */
+
+#ifdef EXPORT_HCI_PAL_INTERFACE
+/*****************************************************
+ * Register init and callback function with ar6k
+ * when PAL driver is a separate kernel module.
+ ****************************************************/
+A_STATUS ar6k_register_hci_pal(HCI_TRANSPORT_CALLBACKS *hciTransCallbacks);
+static int __init pal_init_module(void)
+{
+        HCI_TRANSPORT_CALLBACKS hciTransCallbacks;
+
+        hciTransCallbacks.setupTransport = ar6k_setup_hci_pal;
+        hciTransCallbacks.cleanupTransport = ar6k_cleanup_hci_pal;
+
+        if(ar6k_register_hci_pal(&hciTransCallbacks) != A_OK)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void __exit pal_cleanup_module(void)
+{
+}
+
+module_init(pal_init_module);
+module_exit(pal_cleanup_module);
+MODULE_LICENSE("Dual BSD/GPL");
+#endif