cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

btmrvl_main.c (18707B)


      1/*
      2 * Marvell Bluetooth driver
      3 *
      4 * Copyright (C) 2009, Marvell International Ltd.
      5 *
      6 * This software file (the "File") is distributed by Marvell International
      7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
      8 * (the "License").  You may use, redistribute and/or modify this File in
      9 * accordance with the terms and conditions of the License, a copy of which
     10 * is available by writing to the Free Software Foundation, Inc.,
     11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
     12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
     13 *
     14 *
     15 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
     16 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
     17 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
     18 * this warranty disclaimer.
     19 **/
     20
     21#include <linux/module.h>
     22#include <linux/of.h>
     23#include <net/bluetooth/bluetooth.h>
     24#include <net/bluetooth/hci_core.h>
     25#include <linux/mmc/sdio_func.h>
     26
     27#include "btmrvl_drv.h"
     28#include "btmrvl_sdio.h"
     29
     30#define VERSION "1.0"
     31
     32/*
     33 * This function is called by interface specific interrupt handler.
     34 * It updates Power Save & Host Sleep states, and wakes up the main
     35 * thread.
     36 */
     37void btmrvl_interrupt(struct btmrvl_private *priv)
     38{
     39	priv->adapter->ps_state = PS_AWAKE;
     40
     41	priv->adapter->wakeup_tries = 0;
     42
     43	priv->adapter->int_count++;
     44
     45	if (priv->adapter->hs_state == HS_ACTIVATED) {
     46		BT_DBG("BT: HS DEACTIVATED in ISR!");
     47		priv->adapter->hs_state = HS_DEACTIVATED;
     48	}
     49
     50	wake_up_interruptible(&priv->main_thread.wait_q);
     51}
     52EXPORT_SYMBOL_GPL(btmrvl_interrupt);
     53
     54bool btmrvl_check_evtpkt(struct btmrvl_private *priv, struct sk_buff *skb)
     55{
     56	struct hci_event_hdr *hdr = (void *) skb->data;
     57
     58	if (hdr->evt == HCI_EV_CMD_COMPLETE) {
     59		struct hci_ev_cmd_complete *ec;
     60		u16 opcode;
     61
     62		ec = (void *) (skb->data + HCI_EVENT_HDR_SIZE);
     63		opcode = __le16_to_cpu(ec->opcode);
     64
     65		if (priv->btmrvl_dev.sendcmdflag) {
     66			priv->btmrvl_dev.sendcmdflag = false;
     67			priv->adapter->cmd_complete = true;
     68			wake_up_interruptible(&priv->adapter->cmd_wait_q);
     69
     70			if (hci_opcode_ogf(opcode) == 0x3F) {
     71				BT_DBG("vendor event skipped: opcode=%#4.4x",
     72				       opcode);
     73				kfree_skb(skb);
     74				return false;
     75			}
     76		}
     77	}
     78
     79	return true;
     80}
     81EXPORT_SYMBOL_GPL(btmrvl_check_evtpkt);
     82
     83int btmrvl_process_event(struct btmrvl_private *priv, struct sk_buff *skb)
     84{
     85	struct btmrvl_adapter *adapter = priv->adapter;
     86	struct btmrvl_event *event;
     87	int ret = 0;
     88
     89	event = (struct btmrvl_event *) skb->data;
     90	if (event->ec != 0xff) {
     91		BT_DBG("Not Marvell Event=%x", event->ec);
     92		ret = -EINVAL;
     93		goto exit;
     94	}
     95
     96	switch (event->data[0]) {
     97	case BT_EVENT_AUTO_SLEEP_MODE:
     98		if (!event->data[2]) {
     99			if (event->data[1] == BT_PS_ENABLE)
    100				adapter->psmode = 1;
    101			else
    102				adapter->psmode = 0;
    103			BT_DBG("PS Mode:%s",
    104				(adapter->psmode) ? "Enable" : "Disable");
    105		} else {
    106			BT_DBG("PS Mode command failed");
    107		}
    108		break;
    109
    110	case BT_EVENT_HOST_SLEEP_CONFIG:
    111		if (!event->data[3])
    112			BT_DBG("gpio=%x, gap=%x", event->data[1],
    113							event->data[2]);
    114		else
    115			BT_DBG("HSCFG command failed");
    116		break;
    117
    118	case BT_EVENT_HOST_SLEEP_ENABLE:
    119		if (!event->data[1]) {
    120			adapter->hs_state = HS_ACTIVATED;
    121			if (adapter->psmode)
    122				adapter->ps_state = PS_SLEEP;
    123			wake_up_interruptible(&adapter->event_hs_wait_q);
    124			BT_DBG("HS ACTIVATED!");
    125		} else {
    126			BT_DBG("HS Enable failed");
    127		}
    128		break;
    129
    130	case BT_EVENT_MODULE_CFG_REQ:
    131		if (priv->btmrvl_dev.sendcmdflag &&
    132				event->data[1] == MODULE_BRINGUP_REQ) {
    133			BT_DBG("EVENT:%s",
    134				((event->data[2] == MODULE_BROUGHT_UP) ||
    135				(event->data[2] == MODULE_ALREADY_UP)) ?
    136				"Bring-up succeed" : "Bring-up failed");
    137
    138			if (event->length > 3 && event->data[3])
    139				priv->btmrvl_dev.dev_type = HCI_AMP;
    140			else
    141				priv->btmrvl_dev.dev_type = HCI_PRIMARY;
    142
    143			BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
    144		} else if (priv->btmrvl_dev.sendcmdflag &&
    145				event->data[1] == MODULE_SHUTDOWN_REQ) {
    146			BT_DBG("EVENT:%s", (event->data[2]) ?
    147				"Shutdown failed" : "Shutdown succeed");
    148		} else {
    149			BT_DBG("BT_CMD_MODULE_CFG_REQ resp for APP");
    150			ret = -EINVAL;
    151		}
    152		break;
    153
    154	case BT_EVENT_POWER_STATE:
    155		if (event->data[1] == BT_PS_SLEEP)
    156			adapter->ps_state = PS_SLEEP;
    157		BT_DBG("EVENT:%s",
    158			(adapter->ps_state) ? "PS_SLEEP" : "PS_AWAKE");
    159		break;
    160
    161	default:
    162		BT_DBG("Unknown Event=%d", event->data[0]);
    163		ret = -EINVAL;
    164		break;
    165	}
    166
    167exit:
    168	if (!ret)
    169		kfree_skb(skb);
    170
    171	return ret;
    172}
    173EXPORT_SYMBOL_GPL(btmrvl_process_event);
    174
    175static int btmrvl_send_sync_cmd(struct btmrvl_private *priv, u16 opcode,
    176				const void *param, u8 len)
    177{
    178	struct sk_buff *skb;
    179	struct hci_command_hdr *hdr;
    180
    181	if (priv->surprise_removed) {
    182		BT_ERR("Card is removed");
    183		return -EFAULT;
    184	}
    185
    186	skb = bt_skb_alloc(HCI_COMMAND_HDR_SIZE + len, GFP_KERNEL);
    187	if (!skb) {
    188		BT_ERR("No free skb");
    189		return -ENOMEM;
    190	}
    191
    192	hdr = skb_put(skb, HCI_COMMAND_HDR_SIZE);
    193	hdr->opcode = cpu_to_le16(opcode);
    194	hdr->plen = len;
    195
    196	if (len)
    197		skb_put_data(skb, param, len);
    198
    199	hci_skb_pkt_type(skb) = MRVL_VENDOR_PKT;
    200
    201	skb_queue_head(&priv->adapter->tx_queue, skb);
    202
    203	priv->btmrvl_dev.sendcmdflag = true;
    204
    205	priv->adapter->cmd_complete = false;
    206
    207	wake_up_interruptible(&priv->main_thread.wait_q);
    208
    209	if (!wait_event_interruptible_timeout(priv->adapter->cmd_wait_q,
    210					      priv->adapter->cmd_complete ||
    211					      priv->surprise_removed,
    212					      WAIT_UNTIL_CMD_RESP))
    213		return -ETIMEDOUT;
    214
    215	if (priv->surprise_removed)
    216		return -EFAULT;
    217
    218	return 0;
    219}
    220
    221int btmrvl_send_module_cfg_cmd(struct btmrvl_private *priv, u8 subcmd)
    222{
    223	int ret;
    224
    225	ret = btmrvl_send_sync_cmd(priv, BT_CMD_MODULE_CFG_REQ, &subcmd, 1);
    226	if (ret)
    227		BT_ERR("module_cfg_cmd(%x) failed", subcmd);
    228
    229	return ret;
    230}
    231EXPORT_SYMBOL_GPL(btmrvl_send_module_cfg_cmd);
    232
    233static int btmrvl_enable_sco_routing_to_host(struct btmrvl_private *priv)
    234{
    235	int ret;
    236	u8 subcmd = 0;
    237
    238	ret = btmrvl_send_sync_cmd(priv, BT_CMD_ROUTE_SCO_TO_HOST, &subcmd, 1);
    239	if (ret)
    240		BT_ERR("BT_CMD_ROUTE_SCO_TO_HOST command failed: %#x", ret);
    241
    242	return ret;
    243}
    244
    245int btmrvl_pscan_window_reporting(struct btmrvl_private *priv, u8 subcmd)
    246{
    247	struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
    248	int ret;
    249
    250	if (!card->support_pscan_win_report)
    251		return 0;
    252
    253	ret = btmrvl_send_sync_cmd(priv, BT_CMD_PSCAN_WIN_REPORT_ENABLE,
    254				   &subcmd, 1);
    255	if (ret)
    256		BT_ERR("PSCAN_WIN_REPORT_ENABLE command failed: %#x", ret);
    257
    258	return ret;
    259}
    260EXPORT_SYMBOL_GPL(btmrvl_pscan_window_reporting);
    261
    262int btmrvl_send_hscfg_cmd(struct btmrvl_private *priv)
    263{
    264	int ret;
    265	u8 param[2];
    266
    267	param[0] = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
    268	param[1] = (u8) (priv->btmrvl_dev.gpio_gap & 0x00ff);
    269
    270	BT_DBG("Sending HSCFG Command, gpio=0x%x, gap=0x%x",
    271	       param[0], param[1]);
    272
    273	ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_CONFIG, param, 2);
    274	if (ret)
    275		BT_ERR("HSCFG command failed");
    276
    277	return ret;
    278}
    279EXPORT_SYMBOL_GPL(btmrvl_send_hscfg_cmd);
    280
    281int btmrvl_enable_ps(struct btmrvl_private *priv)
    282{
    283	int ret;
    284	u8 param;
    285
    286	if (priv->btmrvl_dev.psmode)
    287		param = BT_PS_ENABLE;
    288	else
    289		param = BT_PS_DISABLE;
    290
    291	ret = btmrvl_send_sync_cmd(priv, BT_CMD_AUTO_SLEEP_MODE, &param, 1);
    292	if (ret)
    293		BT_ERR("PSMODE command failed");
    294
    295	return 0;
    296}
    297EXPORT_SYMBOL_GPL(btmrvl_enable_ps);
    298
    299int btmrvl_enable_hs(struct btmrvl_private *priv)
    300{
    301	struct btmrvl_adapter *adapter = priv->adapter;
    302	int ret;
    303
    304	ret = btmrvl_send_sync_cmd(priv, BT_CMD_HOST_SLEEP_ENABLE, NULL, 0);
    305	if (ret) {
    306		BT_ERR("Host sleep enable command failed");
    307		return ret;
    308	}
    309
    310	ret = wait_event_interruptible_timeout(adapter->event_hs_wait_q,
    311					       adapter->hs_state ||
    312					       priv->surprise_removed,
    313					       WAIT_UNTIL_HS_STATE_CHANGED);
    314	if (ret < 0 || priv->surprise_removed) {
    315		BT_ERR("event_hs_wait_q terminated (%d): %d,%d,%d",
    316		       ret, adapter->hs_state, adapter->ps_state,
    317		       adapter->wakeup_tries);
    318	} else if (!ret) {
    319		BT_ERR("hs_enable timeout: %d,%d,%d", adapter->hs_state,
    320		       adapter->ps_state, adapter->wakeup_tries);
    321		ret = -ETIMEDOUT;
    322	} else {
    323		BT_DBG("host sleep enabled: %d,%d,%d", adapter->hs_state,
    324		       adapter->ps_state, adapter->wakeup_tries);
    325		ret = 0;
    326	}
    327
    328	return ret;
    329}
    330EXPORT_SYMBOL_GPL(btmrvl_enable_hs);
    331
    332int btmrvl_prepare_command(struct btmrvl_private *priv)
    333{
    334	int ret = 0;
    335
    336	if (priv->btmrvl_dev.hscfgcmd) {
    337		priv->btmrvl_dev.hscfgcmd = 0;
    338		btmrvl_send_hscfg_cmd(priv);
    339	}
    340
    341	if (priv->btmrvl_dev.pscmd) {
    342		priv->btmrvl_dev.pscmd = 0;
    343		btmrvl_enable_ps(priv);
    344	}
    345
    346	if (priv->btmrvl_dev.hscmd) {
    347		priv->btmrvl_dev.hscmd = 0;
    348
    349		if (priv->btmrvl_dev.hsmode) {
    350			ret = btmrvl_enable_hs(priv);
    351		} else {
    352			ret = priv->hw_wakeup_firmware(priv);
    353			priv->adapter->hs_state = HS_DEACTIVATED;
    354			BT_DBG("BT: HS DEACTIVATED due to host activity!");
    355		}
    356	}
    357
    358	return ret;
    359}
    360
    361static int btmrvl_tx_pkt(struct btmrvl_private *priv, struct sk_buff *skb)
    362{
    363	int ret = 0;
    364
    365	if (!skb || !skb->data)
    366		return -EINVAL;
    367
    368	if (!skb->len || ((skb->len + BTM_HEADER_LEN) > BTM_UPLD_SIZE)) {
    369		BT_ERR("Tx Error: Bad skb length %d : %d",
    370						skb->len, BTM_UPLD_SIZE);
    371		return -EINVAL;
    372	}
    373
    374	skb_push(skb, BTM_HEADER_LEN);
    375
    376	/* header type: byte[3]
    377	 * HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor
    378	 * header length: byte[2][1][0]
    379	 */
    380
    381	skb->data[0] = (skb->len & 0x0000ff);
    382	skb->data[1] = (skb->len & 0x00ff00) >> 8;
    383	skb->data[2] = (skb->len & 0xff0000) >> 16;
    384	skb->data[3] = hci_skb_pkt_type(skb);
    385
    386	if (priv->hw_host_to_card)
    387		ret = priv->hw_host_to_card(priv, skb->data, skb->len);
    388
    389	return ret;
    390}
    391
    392static void btmrvl_init_adapter(struct btmrvl_private *priv)
    393{
    394	int buf_size;
    395
    396	skb_queue_head_init(&priv->adapter->tx_queue);
    397
    398	priv->adapter->ps_state = PS_AWAKE;
    399
    400	buf_size = ALIGN_SZ(SDIO_BLOCK_SIZE, BTSDIO_DMA_ALIGN);
    401	priv->adapter->hw_regs_buf = kzalloc(buf_size, GFP_KERNEL);
    402	if (!priv->adapter->hw_regs_buf) {
    403		priv->adapter->hw_regs = NULL;
    404		BT_ERR("Unable to allocate buffer for hw_regs.");
    405	} else {
    406		priv->adapter->hw_regs =
    407			(u8 *)ALIGN_ADDR(priv->adapter->hw_regs_buf,
    408					 BTSDIO_DMA_ALIGN);
    409		BT_DBG("hw_regs_buf=%p hw_regs=%p",
    410		       priv->adapter->hw_regs_buf, priv->adapter->hw_regs);
    411	}
    412
    413	init_waitqueue_head(&priv->adapter->cmd_wait_q);
    414	init_waitqueue_head(&priv->adapter->event_hs_wait_q);
    415}
    416
    417static void btmrvl_free_adapter(struct btmrvl_private *priv)
    418{
    419	skb_queue_purge(&priv->adapter->tx_queue);
    420
    421	kfree(priv->adapter->hw_regs_buf);
    422	kfree(priv->adapter);
    423
    424	priv->adapter = NULL;
    425}
    426
    427static int btmrvl_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
    428{
    429	struct btmrvl_private *priv = hci_get_drvdata(hdev);
    430
    431	BT_DBG("type=%d, len=%d", hci_skb_pkt_type(skb), skb->len);
    432
    433	if (priv->adapter->is_suspending || priv->adapter->is_suspended) {
    434		BT_ERR("%s: Device is suspending or suspended", __func__);
    435		return -EBUSY;
    436	}
    437
    438	switch (hci_skb_pkt_type(skb)) {
    439	case HCI_COMMAND_PKT:
    440		hdev->stat.cmd_tx++;
    441		break;
    442
    443	case HCI_ACLDATA_PKT:
    444		hdev->stat.acl_tx++;
    445		break;
    446
    447	case HCI_SCODATA_PKT:
    448		hdev->stat.sco_tx++;
    449		break;
    450	}
    451
    452	skb_queue_tail(&priv->adapter->tx_queue, skb);
    453
    454	if (!priv->adapter->is_suspended)
    455		wake_up_interruptible(&priv->main_thread.wait_q);
    456
    457	return 0;
    458}
    459
    460static int btmrvl_flush(struct hci_dev *hdev)
    461{
    462	struct btmrvl_private *priv = hci_get_drvdata(hdev);
    463
    464	skb_queue_purge(&priv->adapter->tx_queue);
    465
    466	return 0;
    467}
    468
    469static int btmrvl_close(struct hci_dev *hdev)
    470{
    471	struct btmrvl_private *priv = hci_get_drvdata(hdev);
    472
    473	skb_queue_purge(&priv->adapter->tx_queue);
    474
    475	return 0;
    476}
    477
    478static int btmrvl_open(struct hci_dev *hdev)
    479{
    480	return 0;
    481}
    482
    483static int btmrvl_download_cal_data(struct btmrvl_private *priv,
    484				    u8 *data, int len)
    485{
    486	int ret;
    487
    488	data[0] = 0x00;
    489	data[1] = 0x00;
    490	data[2] = 0x00;
    491	data[3] = len;
    492
    493	print_hex_dump_bytes("Calibration data: ",
    494			     DUMP_PREFIX_OFFSET, data, BT_CAL_HDR_LEN + len);
    495
    496	ret = btmrvl_send_sync_cmd(priv, BT_CMD_LOAD_CONFIG_DATA, data,
    497				   BT_CAL_HDR_LEN + len);
    498	if (ret)
    499		BT_ERR("Failed to download calibration data");
    500
    501	return 0;
    502}
    503
    504static int btmrvl_check_device_tree(struct btmrvl_private *priv)
    505{
    506	struct device_node *dt_node;
    507	struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
    508	u8 cal_data[BT_CAL_HDR_LEN + BT_CAL_DATA_SIZE];
    509	int ret = 0;
    510	u16 gpio, gap;
    511
    512	if (card->plt_of_node) {
    513		dt_node = card->plt_of_node;
    514		ret = of_property_read_u16(dt_node, "marvell,wakeup-pin",
    515					   &gpio);
    516		if (ret)
    517			gpio = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
    518
    519		ret = of_property_read_u16(dt_node, "marvell,wakeup-gap-ms",
    520					   &gap);
    521		if (ret)
    522			gap = (u8)(priv->btmrvl_dev.gpio_gap & 0x00ff);
    523
    524		priv->btmrvl_dev.gpio_gap = (gpio << 8) + gap;
    525
    526		ret = of_property_read_u8_array(dt_node, "marvell,cal-data",
    527						cal_data + BT_CAL_HDR_LEN,
    528						BT_CAL_DATA_SIZE);
    529		if (ret)
    530			return ret;
    531
    532		BT_DBG("Use cal data from device tree");
    533		ret = btmrvl_download_cal_data(priv, cal_data,
    534					       BT_CAL_DATA_SIZE);
    535		if (ret)
    536			BT_ERR("Fail to download calibrate data");
    537	}
    538
    539	return ret;
    540}
    541
    542static int btmrvl_setup(struct hci_dev *hdev)
    543{
    544	struct btmrvl_private *priv = hci_get_drvdata(hdev);
    545	int ret;
    546
    547	ret = btmrvl_send_module_cfg_cmd(priv, MODULE_BRINGUP_REQ);
    548	if (ret)
    549		return ret;
    550
    551	priv->btmrvl_dev.gpio_gap = 0xfffe;
    552
    553	btmrvl_check_device_tree(priv);
    554
    555	btmrvl_enable_sco_routing_to_host(priv);
    556
    557	btmrvl_pscan_window_reporting(priv, 0x01);
    558
    559	priv->btmrvl_dev.psmode = 1;
    560	btmrvl_enable_ps(priv);
    561
    562	btmrvl_send_hscfg_cmd(priv);
    563
    564	return 0;
    565}
    566
    567static int btmrvl_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
    568{
    569	struct sk_buff *skb;
    570	long ret;
    571	u8 buf[8];
    572
    573	buf[0] = MRVL_VENDOR_PKT;
    574	buf[1] = sizeof(bdaddr_t);
    575	memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
    576
    577	skb = __hci_cmd_sync(hdev, BT_CMD_SET_BDADDR, sizeof(buf), buf,
    578			     HCI_INIT_TIMEOUT);
    579	if (IS_ERR(skb)) {
    580		ret = PTR_ERR(skb);
    581		BT_ERR("%s: changing btmrvl device address failed (%ld)",
    582		       hdev->name, ret);
    583		return ret;
    584	}
    585	kfree_skb(skb);
    586
    587	return 0;
    588}
    589
    590static bool btmrvl_wakeup(struct hci_dev *hdev)
    591{
    592	struct btmrvl_private *priv = hci_get_drvdata(hdev);
    593	struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
    594
    595	return device_may_wakeup(&card->func->dev);
    596}
    597
    598/*
    599 * This function handles the event generated by firmware, rx data
    600 * received from firmware, and tx data sent from kernel.
    601 */
    602static int btmrvl_service_main_thread(void *data)
    603{
    604	struct btmrvl_thread *thread = data;
    605	struct btmrvl_private *priv = thread->priv;
    606	struct btmrvl_adapter *adapter = priv->adapter;
    607	wait_queue_entry_t wait;
    608	struct sk_buff *skb;
    609	ulong flags;
    610
    611	init_waitqueue_entry(&wait, current);
    612
    613	for (;;) {
    614		add_wait_queue(&thread->wait_q, &wait);
    615
    616		set_current_state(TASK_INTERRUPTIBLE);
    617		if (kthread_should_stop() || priv->surprise_removed) {
    618			BT_DBG("main_thread: break from main thread");
    619			break;
    620		}
    621
    622		if (adapter->wakeup_tries ||
    623				((!adapter->int_count) &&
    624				(!priv->btmrvl_dev.tx_dnld_rdy ||
    625				skb_queue_empty(&adapter->tx_queue)))) {
    626			BT_DBG("main_thread is sleeping...");
    627			schedule();
    628		}
    629
    630		set_current_state(TASK_RUNNING);
    631
    632		remove_wait_queue(&thread->wait_q, &wait);
    633
    634		BT_DBG("main_thread woke up");
    635
    636		if (kthread_should_stop() || priv->surprise_removed) {
    637			BT_DBG("main_thread: break from main thread");
    638			break;
    639		}
    640
    641		spin_lock_irqsave(&priv->driver_lock, flags);
    642		if (adapter->int_count) {
    643			adapter->int_count = 0;
    644			spin_unlock_irqrestore(&priv->driver_lock, flags);
    645			priv->hw_process_int_status(priv);
    646		} else if (adapter->ps_state == PS_SLEEP &&
    647					!skb_queue_empty(&adapter->tx_queue)) {
    648			spin_unlock_irqrestore(&priv->driver_lock, flags);
    649			adapter->wakeup_tries++;
    650			priv->hw_wakeup_firmware(priv);
    651			continue;
    652		} else {
    653			spin_unlock_irqrestore(&priv->driver_lock, flags);
    654		}
    655
    656		if (adapter->ps_state == PS_SLEEP)
    657			continue;
    658
    659		if (!priv->btmrvl_dev.tx_dnld_rdy ||
    660		    priv->adapter->is_suspended)
    661			continue;
    662
    663		skb = skb_dequeue(&adapter->tx_queue);
    664		if (skb) {
    665			if (btmrvl_tx_pkt(priv, skb))
    666				priv->btmrvl_dev.hcidev->stat.err_tx++;
    667			else
    668				priv->btmrvl_dev.hcidev->stat.byte_tx += skb->len;
    669
    670			kfree_skb(skb);
    671		}
    672	}
    673
    674	return 0;
    675}
    676
    677int btmrvl_register_hdev(struct btmrvl_private *priv)
    678{
    679	struct hci_dev *hdev = NULL;
    680	struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
    681	int ret;
    682
    683	hdev = hci_alloc_dev();
    684	if (!hdev) {
    685		BT_ERR("Can not allocate HCI device");
    686		goto err_hdev;
    687	}
    688
    689	priv->btmrvl_dev.hcidev = hdev;
    690	hci_set_drvdata(hdev, priv);
    691
    692	hdev->bus   = HCI_SDIO;
    693	hdev->open  = btmrvl_open;
    694	hdev->close = btmrvl_close;
    695	hdev->flush = btmrvl_flush;
    696	hdev->send  = btmrvl_send_frame;
    697	hdev->setup = btmrvl_setup;
    698	hdev->set_bdaddr = btmrvl_set_bdaddr;
    699	hdev->wakeup = btmrvl_wakeup;
    700	SET_HCIDEV_DEV(hdev, &card->func->dev);
    701
    702	hdev->dev_type = priv->btmrvl_dev.dev_type;
    703
    704	ret = hci_register_dev(hdev);
    705	if (ret < 0) {
    706		BT_ERR("Can not register HCI device");
    707		goto err_hci_register_dev;
    708	}
    709
    710#ifdef CONFIG_DEBUG_FS
    711	btmrvl_debugfs_init(hdev);
    712#endif
    713
    714	return 0;
    715
    716err_hci_register_dev:
    717	hci_free_dev(hdev);
    718
    719err_hdev:
    720	/* Stop the thread servicing the interrupts */
    721	kthread_stop(priv->main_thread.task);
    722
    723	btmrvl_free_adapter(priv);
    724	kfree(priv);
    725
    726	return -ENOMEM;
    727}
    728EXPORT_SYMBOL_GPL(btmrvl_register_hdev);
    729
    730struct btmrvl_private *btmrvl_add_card(void *card)
    731{
    732	struct btmrvl_private *priv;
    733
    734	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    735	if (!priv) {
    736		BT_ERR("Can not allocate priv");
    737		goto err_priv;
    738	}
    739
    740	priv->adapter = kzalloc(sizeof(*priv->adapter), GFP_KERNEL);
    741	if (!priv->adapter) {
    742		BT_ERR("Allocate buffer for btmrvl_adapter failed!");
    743		goto err_adapter;
    744	}
    745
    746	btmrvl_init_adapter(priv);
    747
    748	BT_DBG("Starting kthread...");
    749	priv->main_thread.priv = priv;
    750	spin_lock_init(&priv->driver_lock);
    751
    752	init_waitqueue_head(&priv->main_thread.wait_q);
    753	priv->main_thread.task = kthread_run(btmrvl_service_main_thread,
    754				&priv->main_thread, "btmrvl_main_service");
    755	if (IS_ERR(priv->main_thread.task))
    756		goto err_thread;
    757
    758	priv->btmrvl_dev.card = card;
    759	priv->btmrvl_dev.tx_dnld_rdy = true;
    760
    761	return priv;
    762
    763err_thread:
    764	btmrvl_free_adapter(priv);
    765
    766err_adapter:
    767	kfree(priv);
    768
    769err_priv:
    770	return NULL;
    771}
    772EXPORT_SYMBOL_GPL(btmrvl_add_card);
    773
    774int btmrvl_remove_card(struct btmrvl_private *priv)
    775{
    776	struct hci_dev *hdev;
    777
    778	hdev = priv->btmrvl_dev.hcidev;
    779
    780	wake_up_interruptible(&priv->adapter->cmd_wait_q);
    781	wake_up_interruptible(&priv->adapter->event_hs_wait_q);
    782
    783	kthread_stop(priv->main_thread.task);
    784
    785#ifdef CONFIG_DEBUG_FS
    786	btmrvl_debugfs_remove(hdev);
    787#endif
    788
    789	hci_unregister_dev(hdev);
    790
    791	hci_free_dev(hdev);
    792
    793	priv->btmrvl_dev.hcidev = NULL;
    794
    795	btmrvl_free_adapter(priv);
    796
    797	kfree(priv);
    798
    799	return 0;
    800}
    801EXPORT_SYMBOL_GPL(btmrvl_remove_card);
    802
    803MODULE_AUTHOR("Marvell International Ltd.");
    804MODULE_DESCRIPTION("Marvell Bluetooth driver ver " VERSION);
    805MODULE_VERSION(VERSION);
    806MODULE_LICENSE("GPL v2");