btmrvl_main.c

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