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, data: param, len);
179
180 hci_skb_pkt_type(skb) = MRVL_VENDOR_PKT;
181
182 skb_queue_head(list: &priv->adapter->tx_queue, newsk: 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, param: &subcmd, len: 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, param: &subcmd, len: 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 param: &subcmd, len: 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, len: 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: &param, len: 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, len: 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(list: &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(list: &priv->adapter->tx_queue);
401
402 kfree(objp: priv->adapter->hw_regs_buf);
403 kfree(objp: 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(list: &priv->adapter->tx_queue, newsk: 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(list: &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(list: &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, param: 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(np: dt_node, propname: "marvell,wakeup-pin",
496 out_value: &gpio);
497 if (ret)
498 gpio = (priv->btmrvl_dev.gpio_gap & 0xff00) >> 8;
499
500 ret = of_property_read_u16(np: dt_node, propname: "marvell,wakeup-gap-ms",
501 out_value: &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(np: dt_node, propname: "marvell,cal-data",
508 out_values: 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, data: 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, plen: sizeof(buf), param: buf,
559 HCI_INIT_TIMEOUT);
560 if (IS_ERR(ptr: skb)) {
561 ret = PTR_ERR(ptr: 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(dev: &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(wq_entry: &wait, current);
593
594 for (;;) {
595 add_wait_queue(wq_head: &thread->wait_q, wq_entry: &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(list: &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(wq_head: &thread->wait_q, wq_entry: &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(lock: &priv->driver_lock, flags);
626 priv->hw_process_int_status(priv);
627 } else if (adapter->ps_state == PS_SLEEP &&
628 !skb_queue_empty(list: &adapter->tx_queue)) {
629 spin_unlock_irqrestore(lock: &priv->driver_lock, flags);
630 adapter->wakeup_tries++;
631 priv->hw_wakeup_firmware(priv);
632 continue;
633 } else {
634 spin_unlock_irqrestore(lock: &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(list: &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, data: 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(k: priv->main_thread.task);
701
702 btmrvl_free_adapter(priv);
703 kfree(objp: 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(ptr: 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(objp: 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(k: 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(objp: 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");
786

source code of linux/drivers/bluetooth/btmrvl_main.c