1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2019 MediaTek Inc. 3 4 /* 5 * Bluetooth support for MediaTek SDIO devices 6 * 7 * This file is written based on btsdio.c and btmtkuart.c. 8 * 9 * Author: Sean Wang <sean.wang@mediatek.com> 10 * 11 */ 12 13 #include <asm/unaligned.h> 14 #include <linux/atomic.h> 15 #include <linux/firmware.h> 16 #include <linux/init.h> 17 #include <linux/iopoll.h> 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/skbuff.h> 22 23 #include <linux/mmc/host.h> 24 #include <linux/mmc/sdio_ids.h> 25 #include <linux/mmc/sdio_func.h> 26 27 #include <net/bluetooth/bluetooth.h> 28 #include <net/bluetooth/hci_core.h> 29 30 #include "h4_recv.h" 31 32 #define VERSION "0.1" 33 34 #define FIRMWARE_MT7663 "mediatek/mt7663pr2h.bin" 35 #define FIRMWARE_MT7668 "mediatek/mt7668pr2h.bin" 36 37 #define MTKBTSDIO_AUTOSUSPEND_DELAY 8000 38 39 static bool enable_autosuspend; 40 41 struct btmtksdio_data { 42 const char *fwname; 43 }; 44 45 static const struct btmtksdio_data mt7663_data = { 46 .fwname = FIRMWARE_MT7663, 47 }; 48 49 static const struct btmtksdio_data mt7668_data = { 50 .fwname = FIRMWARE_MT7668, 51 }; 52 53 static const struct sdio_device_id btmtksdio_table[] = { 54 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7663), 55 .driver_data = (kernel_ulong_t)&mt7663_data }, 56 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, 0x7668), 57 .driver_data = (kernel_ulong_t)&mt7668_data }, 58 { } /* Terminating entry */ 59 }; 60 MODULE_DEVICE_TABLE(sdio, btmtksdio_table); 61 62 #define MTK_REG_CHLPCR 0x4 /* W1S */ 63 #define C_INT_EN_SET BIT(0) 64 #define C_INT_EN_CLR BIT(1) 65 #define C_FW_OWN_REQ_SET BIT(8) /* For write */ 66 #define C_COM_DRV_OWN BIT(8) /* For read */ 67 #define C_FW_OWN_REQ_CLR BIT(9) 68 69 #define MTK_REG_CSDIOCSR 0x8 70 #define SDIO_RE_INIT_EN BIT(0) 71 #define SDIO_INT_CTL BIT(2) 72 73 #define MTK_REG_CHCR 0xc 74 #define C_INT_CLR_CTRL BIT(1) 75 76 /* CHISR have the same bits field definition with CHIER */ 77 #define MTK_REG_CHISR 0x10 78 #define MTK_REG_CHIER 0x14 79 #define FW_OWN_BACK_INT BIT(0) 80 #define RX_DONE_INT BIT(1) 81 #define TX_EMPTY BIT(2) 82 #define TX_FIFO_OVERFLOW BIT(8) 83 #define RX_PKT_LEN GENMASK(31, 16) 84 85 #define MTK_REG_CTDR 0x18 86 87 #define MTK_REG_CRDR 0x1c 88 89 #define MTK_SDIO_BLOCK_SIZE 256 90 91 #define BTMTKSDIO_TX_WAIT_VND_EVT 1 92 93 enum { 94 MTK_WMT_PATCH_DWNLD = 0x1, 95 MTK_WMT_TEST = 0x2, 96 MTK_WMT_WAKEUP = 0x3, 97 MTK_WMT_HIF = 0x4, 98 MTK_WMT_FUNC_CTRL = 0x6, 99 MTK_WMT_RST = 0x7, 100 MTK_WMT_SEMAPHORE = 0x17, 101 }; 102 103 enum { 104 BTMTK_WMT_INVALID, 105 BTMTK_WMT_PATCH_UNDONE, 106 BTMTK_WMT_PATCH_DONE, 107 BTMTK_WMT_ON_UNDONE, 108 BTMTK_WMT_ON_DONE, 109 BTMTK_WMT_ON_PROGRESS, 110 }; 111 112 struct mtkbtsdio_hdr { 113 __le16 len; 114 __le16 reserved; 115 u8 bt_type; 116 } __packed; 117 118 struct mtk_wmt_hdr { 119 u8 dir; 120 u8 op; 121 __le16 dlen; 122 u8 flag; 123 } __packed; 124 125 struct mtk_hci_wmt_cmd { 126 struct mtk_wmt_hdr hdr; 127 u8 data[256]; 128 } __packed; 129 130 struct btmtk_hci_wmt_evt { 131 struct hci_event_hdr hhdr; 132 struct mtk_wmt_hdr whdr; 133 } __packed; 134 135 struct btmtk_hci_wmt_evt_funcc { 136 struct btmtk_hci_wmt_evt hwhdr; 137 __be16 status; 138 } __packed; 139 140 struct btmtk_tci_sleep { 141 u8 mode; 142 __le16 duration; 143 __le16 host_duration; 144 u8 host_wakeup_pin; 145 u8 time_compensation; 146 } __packed; 147 148 struct btmtk_hci_wmt_params { 149 u8 op; 150 u8 flag; 151 u16 dlen; 152 const void *data; 153 u32 *status; 154 }; 155 156 struct btmtksdio_dev { 157 struct hci_dev *hdev; 158 struct sdio_func *func; 159 struct device *dev; 160 161 struct work_struct tx_work; 162 unsigned long tx_state; 163 struct sk_buff_head txq; 164 165 struct sk_buff *evt_skb; 166 167 const struct btmtksdio_data *data; 168 }; 169 170 static int mtk_hci_wmt_sync(struct hci_dev *hdev, 171 struct btmtk_hci_wmt_params *wmt_params) 172 { 173 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 174 struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc; 175 u32 hlen, status = BTMTK_WMT_INVALID; 176 struct btmtk_hci_wmt_evt *wmt_evt; 177 struct mtk_hci_wmt_cmd wc; 178 struct mtk_wmt_hdr *hdr; 179 int err; 180 181 hlen = sizeof(*hdr) + wmt_params->dlen; 182 if (hlen > 255) 183 return -EINVAL; 184 185 hdr = (struct mtk_wmt_hdr *)&wc; 186 hdr->dir = 1; 187 hdr->op = wmt_params->op; 188 hdr->dlen = cpu_to_le16(wmt_params->dlen + 1); 189 hdr->flag = wmt_params->flag; 190 memcpy(wc.data, wmt_params->data, wmt_params->dlen); 191 192 set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 193 194 err = __hci_cmd_send(hdev, 0xfc6f, hlen, &wc); 195 if (err < 0) { 196 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 197 return err; 198 } 199 200 /* The vendor specific WMT commands are all answered by a vendor 201 * specific event and will not have the Command Status or Command 202 * Complete as with usual HCI command flow control. 203 * 204 * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT 205 * state to be cleared. The driver specific event receive routine 206 * will clear that state and with that indicate completion of the 207 * WMT command. 208 */ 209 err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT, 210 TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT); 211 if (err == -EINTR) { 212 bt_dev_err(hdev, "Execution of wmt command interrupted"); 213 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 214 return err; 215 } 216 217 if (err) { 218 bt_dev_err(hdev, "Execution of wmt command timed out"); 219 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 220 return -ETIMEDOUT; 221 } 222 223 /* Parse and handle the return WMT event */ 224 wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data; 225 if (wmt_evt->whdr.op != hdr->op) { 226 bt_dev_err(hdev, "Wrong op received %d expected %d", 227 wmt_evt->whdr.op, hdr->op); 228 err = -EIO; 229 goto err_free_skb; 230 } 231 232 switch (wmt_evt->whdr.op) { 233 case MTK_WMT_SEMAPHORE: 234 if (wmt_evt->whdr.flag == 2) 235 status = BTMTK_WMT_PATCH_UNDONE; 236 else 237 status = BTMTK_WMT_PATCH_DONE; 238 break; 239 case MTK_WMT_FUNC_CTRL: 240 wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt; 241 if (be16_to_cpu(wmt_evt_funcc->status) == 0x404) 242 status = BTMTK_WMT_ON_DONE; 243 else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420) 244 status = BTMTK_WMT_ON_PROGRESS; 245 else 246 status = BTMTK_WMT_ON_UNDONE; 247 break; 248 } 249 250 if (wmt_params->status) 251 *wmt_params->status = status; 252 253 err_free_skb: 254 kfree_skb(bdev->evt_skb); 255 bdev->evt_skb = NULL; 256 257 return err; 258 } 259 260 static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev, 261 struct sk_buff *skb) 262 { 263 struct mtkbtsdio_hdr *sdio_hdr; 264 int err; 265 266 /* Make sure that there are enough rooms for SDIO header */ 267 if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) { 268 err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0, 269 GFP_ATOMIC); 270 if (err < 0) 271 return err; 272 } 273 274 /* Prepend MediaTek SDIO Specific Header */ 275 skb_push(skb, sizeof(*sdio_hdr)); 276 277 sdio_hdr = (void *)skb->data; 278 sdio_hdr->len = cpu_to_le16(skb->len); 279 sdio_hdr->reserved = cpu_to_le16(0); 280 sdio_hdr->bt_type = hci_skb_pkt_type(skb); 281 282 err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data, 283 round_up(skb->len, MTK_SDIO_BLOCK_SIZE)); 284 if (err < 0) 285 goto err_skb_pull; 286 287 bdev->hdev->stat.byte_tx += skb->len; 288 289 kfree_skb(skb); 290 291 return 0; 292 293 err_skb_pull: 294 skb_pull(skb, sizeof(*sdio_hdr)); 295 296 return err; 297 } 298 299 static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev) 300 { 301 return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL); 302 } 303 304 static void btmtksdio_tx_work(struct work_struct *work) 305 { 306 struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev, 307 tx_work); 308 struct sk_buff *skb; 309 int err; 310 311 pm_runtime_get_sync(bdev->dev); 312 313 sdio_claim_host(bdev->func); 314 315 while ((skb = skb_dequeue(&bdev->txq))) { 316 err = btmtksdio_tx_packet(bdev, skb); 317 if (err < 0) { 318 bdev->hdev->stat.err_tx++; 319 skb_queue_head(&bdev->txq, skb); 320 break; 321 } 322 } 323 324 sdio_release_host(bdev->func); 325 326 pm_runtime_mark_last_busy(bdev->dev); 327 pm_runtime_put_autosuspend(bdev->dev); 328 } 329 330 static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 331 { 332 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 333 struct hci_event_hdr *hdr = (void *)skb->data; 334 int err; 335 336 /* Fix up the vendor event id with 0xff for vendor specific instead 337 * of 0xe4 so that event send via monitoring socket can be parsed 338 * properly. 339 */ 340 if (hdr->evt == 0xe4) 341 hdr->evt = HCI_EV_VENDOR; 342 343 /* When someone waits for the WMT event, the skb is being cloned 344 * and being processed the events from there then. 345 */ 346 if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) { 347 bdev->evt_skb = skb_clone(skb, GFP_KERNEL); 348 if (!bdev->evt_skb) { 349 err = -ENOMEM; 350 goto err_out; 351 } 352 } 353 354 err = hci_recv_frame(hdev, skb); 355 if (err < 0) 356 goto err_free_skb; 357 358 if (hdr->evt == HCI_EV_VENDOR) { 359 if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, 360 &bdev->tx_state)) { 361 /* Barrier to sync with other CPUs */ 362 smp_mb__after_atomic(); 363 wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT); 364 } 365 } 366 367 return 0; 368 369 err_free_skb: 370 kfree_skb(bdev->evt_skb); 371 bdev->evt_skb = NULL; 372 373 err_out: 374 return err; 375 } 376 377 static const struct h4_recv_pkt mtk_recv_pkts[] = { 378 { H4_RECV_ACL, .recv = hci_recv_frame }, 379 { H4_RECV_SCO, .recv = hci_recv_frame }, 380 { H4_RECV_EVENT, .recv = btmtksdio_recv_event }, 381 }; 382 383 static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size) 384 { 385 const struct h4_recv_pkt *pkts = mtk_recv_pkts; 386 int pkts_count = ARRAY_SIZE(mtk_recv_pkts); 387 struct mtkbtsdio_hdr *sdio_hdr; 388 int err, i, pad_size; 389 struct sk_buff *skb; 390 u16 dlen; 391 392 if (rx_size < sizeof(*sdio_hdr)) 393 return -EILSEQ; 394 395 /* A SDIO packet is exactly containing a Bluetooth packet */ 396 skb = bt_skb_alloc(rx_size, GFP_KERNEL); 397 if (!skb) 398 return -ENOMEM; 399 400 skb_put(skb, rx_size); 401 402 err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size); 403 if (err < 0) 404 goto err_kfree_skb; 405 406 sdio_hdr = (void *)skb->data; 407 408 /* We assume the default error as -EILSEQ simply to make the error path 409 * be cleaner. 410 */ 411 err = -EILSEQ; 412 413 if (rx_size != le16_to_cpu(sdio_hdr->len)) { 414 bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched "); 415 goto err_kfree_skb; 416 } 417 418 hci_skb_pkt_type(skb) = sdio_hdr->bt_type; 419 420 /* Remove MediaTek SDIO header */ 421 skb_pull(skb, sizeof(*sdio_hdr)); 422 423 /* We have to dig into the packet to get payload size and then know how 424 * many padding bytes at the tail, these padding bytes should be removed 425 * before the packet is indicated to the core layer. 426 */ 427 for (i = 0; i < pkts_count; i++) { 428 if (sdio_hdr->bt_type == (&pkts[i])->type) 429 break; 430 } 431 432 if (i >= pkts_count) { 433 bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x", 434 sdio_hdr->bt_type); 435 goto err_kfree_skb; 436 } 437 438 /* Remaining bytes cannot hold a header*/ 439 if (skb->len < (&pkts[i])->hlen) { 440 bt_dev_err(bdev->hdev, "The size of bt header is mismatched"); 441 goto err_kfree_skb; 442 } 443 444 switch ((&pkts[i])->lsize) { 445 case 1: 446 dlen = skb->data[(&pkts[i])->loff]; 447 break; 448 case 2: 449 dlen = get_unaligned_le16(skb->data + 450 (&pkts[i])->loff); 451 break; 452 default: 453 goto err_kfree_skb; 454 } 455 456 pad_size = skb->len - (&pkts[i])->hlen - dlen; 457 458 /* Remaining bytes cannot hold a payload */ 459 if (pad_size < 0) { 460 bt_dev_err(bdev->hdev, "The size of bt payload is mismatched"); 461 goto err_kfree_skb; 462 } 463 464 /* Remove padding bytes */ 465 skb_trim(skb, skb->len - pad_size); 466 467 /* Complete frame */ 468 (&pkts[i])->recv(bdev->hdev, skb); 469 470 bdev->hdev->stat.byte_rx += rx_size; 471 472 return 0; 473 474 err_kfree_skb: 475 kfree_skb(skb); 476 477 return err; 478 } 479 480 static void btmtksdio_interrupt(struct sdio_func *func) 481 { 482 struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 483 u32 int_status; 484 u16 rx_size; 485 486 /* It is required that the host gets ownership from the device before 487 * accessing any register, however, if SDIO host is not being released, 488 * a potential deadlock probably happens in a circular wait between SDIO 489 * IRQ work and PM runtime work. So, we have to explicitly release SDIO 490 * host here and claim again after the PM runtime work is all done. 491 */ 492 sdio_release_host(bdev->func); 493 494 pm_runtime_get_sync(bdev->dev); 495 496 sdio_claim_host(bdev->func); 497 498 /* Disable interrupt */ 499 sdio_writel(func, C_INT_EN_CLR, MTK_REG_CHLPCR, 0); 500 501 int_status = sdio_readl(func, MTK_REG_CHISR, NULL); 502 503 /* Ack an interrupt as soon as possible before any operation on 504 * hardware. 505 * 506 * Note that we don't ack any status during operations to avoid race 507 * condition between the host and the device such as it's possible to 508 * mistakenly ack RX_DONE for the next packet and then cause interrupts 509 * not be raised again but there is still pending data in the hardware 510 * FIFO. 511 */ 512 sdio_writel(func, int_status, MTK_REG_CHISR, NULL); 513 514 if (unlikely(!int_status)) 515 bt_dev_err(bdev->hdev, "CHISR is 0"); 516 517 if (int_status & FW_OWN_BACK_INT) 518 bt_dev_dbg(bdev->hdev, "Get fw own back"); 519 520 if (int_status & TX_EMPTY) 521 schedule_work(&bdev->tx_work); 522 else if (unlikely(int_status & TX_FIFO_OVERFLOW)) 523 bt_dev_warn(bdev->hdev, "Tx fifo overflow"); 524 525 if (int_status & RX_DONE_INT) { 526 rx_size = (int_status & RX_PKT_LEN) >> 16; 527 528 if (btmtksdio_rx_packet(bdev, rx_size) < 0) 529 bdev->hdev->stat.err_rx++; 530 } 531 532 /* Enable interrupt */ 533 sdio_writel(func, C_INT_EN_SET, MTK_REG_CHLPCR, 0); 534 535 pm_runtime_mark_last_busy(bdev->dev); 536 pm_runtime_put_autosuspend(bdev->dev); 537 } 538 539 static int btmtksdio_open(struct hci_dev *hdev) 540 { 541 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 542 int err; 543 u32 status; 544 545 sdio_claim_host(bdev->func); 546 547 err = sdio_enable_func(bdev->func); 548 if (err < 0) 549 goto err_release_host; 550 551 /* Get ownership from the device */ 552 sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err); 553 if (err < 0) 554 goto err_disable_func; 555 556 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 557 status & C_COM_DRV_OWN, 2000, 1000000); 558 if (err < 0) { 559 bt_dev_err(bdev->hdev, "Cannot get ownership from device"); 560 goto err_disable_func; 561 } 562 563 /* Disable interrupt & mask out all interrupt sources */ 564 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err); 565 if (err < 0) 566 goto err_disable_func; 567 568 sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err); 569 if (err < 0) 570 goto err_disable_func; 571 572 err = sdio_claim_irq(bdev->func, btmtksdio_interrupt); 573 if (err < 0) 574 goto err_disable_func; 575 576 err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE); 577 if (err < 0) 578 goto err_release_irq; 579 580 /* SDIO CMD 5 allows the SDIO device back to idle state an 581 * synchronous interrupt is supported in SDIO 4-bit mode 582 */ 583 sdio_writel(bdev->func, SDIO_INT_CTL | SDIO_RE_INIT_EN, 584 MTK_REG_CSDIOCSR, &err); 585 if (err < 0) 586 goto err_release_irq; 587 588 /* Setup write-1-clear for CHISR register */ 589 sdio_writel(bdev->func, C_INT_CLR_CTRL, MTK_REG_CHCR, &err); 590 if (err < 0) 591 goto err_release_irq; 592 593 /* Setup interrupt sources */ 594 sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW, 595 MTK_REG_CHIER, &err); 596 if (err < 0) 597 goto err_release_irq; 598 599 /* Enable interrupt */ 600 sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err); 601 if (err < 0) 602 goto err_release_irq; 603 604 sdio_release_host(bdev->func); 605 606 return 0; 607 608 err_release_irq: 609 sdio_release_irq(bdev->func); 610 611 err_disable_func: 612 sdio_disable_func(bdev->func); 613 614 err_release_host: 615 sdio_release_host(bdev->func); 616 617 return err; 618 } 619 620 static int btmtksdio_close(struct hci_dev *hdev) 621 { 622 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 623 u32 status; 624 int err; 625 626 sdio_claim_host(bdev->func); 627 628 /* Disable interrupt */ 629 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 630 631 sdio_release_irq(bdev->func); 632 633 /* Return ownership to the device */ 634 sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, NULL); 635 636 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 637 !(status & C_COM_DRV_OWN), 2000, 1000000); 638 if (err < 0) 639 bt_dev_err(bdev->hdev, "Cannot return ownership to device"); 640 641 sdio_disable_func(bdev->func); 642 643 sdio_release_host(bdev->func); 644 645 return 0; 646 } 647 648 static int btmtksdio_flush(struct hci_dev *hdev) 649 { 650 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 651 652 skb_queue_purge(&bdev->txq); 653 654 cancel_work_sync(&bdev->tx_work); 655 656 return 0; 657 } 658 659 static int btmtksdio_func_query(struct hci_dev *hdev) 660 { 661 struct btmtk_hci_wmt_params wmt_params; 662 int status, err; 663 u8 param = 0; 664 665 /* Query whether the function is enabled */ 666 wmt_params.op = MTK_WMT_FUNC_CTRL; 667 wmt_params.flag = 4; 668 wmt_params.dlen = sizeof(param); 669 wmt_params.data = ¶m; 670 wmt_params.status = &status; 671 672 err = mtk_hci_wmt_sync(hdev, &wmt_params); 673 if (err < 0) { 674 bt_dev_err(hdev, "Failed to query function status (%d)", err); 675 return err; 676 } 677 678 return status; 679 } 680 681 static int mtk_setup_firmware(struct hci_dev *hdev, const char *fwname) 682 { 683 struct btmtk_hci_wmt_params wmt_params; 684 const struct firmware *fw; 685 const u8 *fw_ptr; 686 size_t fw_size; 687 int err, dlen; 688 u8 flag; 689 690 err = request_firmware(&fw, fwname, &hdev->dev); 691 if (err < 0) { 692 bt_dev_err(hdev, "Failed to load firmware file (%d)", err); 693 return err; 694 } 695 696 fw_ptr = fw->data; 697 fw_size = fw->size; 698 699 /* The size of patch header is 30 bytes, should be skip */ 700 if (fw_size < 30) { 701 err = -EINVAL; 702 goto free_fw; 703 } 704 705 fw_size -= 30; 706 fw_ptr += 30; 707 flag = 1; 708 709 wmt_params.op = MTK_WMT_PATCH_DWNLD; 710 wmt_params.status = NULL; 711 712 while (fw_size > 0) { 713 dlen = min_t(int, 250, fw_size); 714 715 /* Tell device the position in sequence */ 716 if (fw_size - dlen <= 0) 717 flag = 3; 718 else if (fw_size < fw->size - 30) 719 flag = 2; 720 721 wmt_params.flag = flag; 722 wmt_params.dlen = dlen; 723 wmt_params.data = fw_ptr; 724 725 err = mtk_hci_wmt_sync(hdev, &wmt_params); 726 if (err < 0) { 727 bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)", 728 err); 729 goto free_fw; 730 } 731 732 fw_size -= dlen; 733 fw_ptr += dlen; 734 } 735 736 wmt_params.op = MTK_WMT_RST; 737 wmt_params.flag = 4; 738 wmt_params.dlen = 0; 739 wmt_params.data = NULL; 740 wmt_params.status = NULL; 741 742 /* Activate funciton the firmware providing to */ 743 err = mtk_hci_wmt_sync(hdev, &wmt_params); 744 if (err < 0) { 745 bt_dev_err(hdev, "Failed to send wmt rst (%d)", err); 746 goto free_fw; 747 } 748 749 /* Wait a few moments for firmware activation done */ 750 usleep_range(10000, 12000); 751 752 free_fw: 753 release_firmware(fw); 754 return err; 755 } 756 757 static int btmtksdio_setup(struct hci_dev *hdev) 758 { 759 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 760 struct btmtk_hci_wmt_params wmt_params; 761 ktime_t calltime, delta, rettime; 762 struct btmtk_tci_sleep tci_sleep; 763 unsigned long long duration; 764 struct sk_buff *skb; 765 int err, status; 766 u8 param = 0x1; 767 768 calltime = ktime_get(); 769 770 /* Query whether the firmware is already download */ 771 wmt_params.op = MTK_WMT_SEMAPHORE; 772 wmt_params.flag = 1; 773 wmt_params.dlen = 0; 774 wmt_params.data = NULL; 775 wmt_params.status = &status; 776 777 err = mtk_hci_wmt_sync(hdev, &wmt_params); 778 if (err < 0) { 779 bt_dev_err(hdev, "Failed to query firmware status (%d)", err); 780 return err; 781 } 782 783 if (status == BTMTK_WMT_PATCH_DONE) { 784 bt_dev_info(hdev, "Firmware already downloaded"); 785 goto ignore_setup_fw; 786 } 787 788 /* Setup a firmware which the device definitely requires */ 789 err = mtk_setup_firmware(hdev, bdev->data->fwname); 790 if (err < 0) 791 return err; 792 793 ignore_setup_fw: 794 /* Query whether the device is already enabled */ 795 err = readx_poll_timeout(btmtksdio_func_query, hdev, status, 796 status < 0 || status != BTMTK_WMT_ON_PROGRESS, 797 2000, 5000000); 798 /* -ETIMEDOUT happens */ 799 if (err < 0) 800 return err; 801 802 /* The other errors happen in btusb_mtk_func_query */ 803 if (status < 0) 804 return status; 805 806 if (status == BTMTK_WMT_ON_DONE) { 807 bt_dev_info(hdev, "function already on"); 808 goto ignore_func_on; 809 } 810 811 /* Enable Bluetooth protocol */ 812 wmt_params.op = MTK_WMT_FUNC_CTRL; 813 wmt_params.flag = 0; 814 wmt_params.dlen = sizeof(param); 815 wmt_params.data = ¶m; 816 wmt_params.status = NULL; 817 818 err = mtk_hci_wmt_sync(hdev, &wmt_params); 819 if (err < 0) { 820 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 821 return err; 822 } 823 824 ignore_func_on: 825 /* Apply the low power environment setup */ 826 tci_sleep.mode = 0x5; 827 tci_sleep.duration = cpu_to_le16(0x640); 828 tci_sleep.host_duration = cpu_to_le16(0x640); 829 tci_sleep.host_wakeup_pin = 0; 830 tci_sleep.time_compensation = 0; 831 832 skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep, 833 HCI_INIT_TIMEOUT); 834 if (IS_ERR(skb)) { 835 err = PTR_ERR(skb); 836 bt_dev_err(hdev, "Failed to apply low power setting (%d)", err); 837 return err; 838 } 839 kfree_skb(skb); 840 841 rettime = ktime_get(); 842 delta = ktime_sub(rettime, calltime); 843 duration = (unsigned long long)ktime_to_ns(delta) >> 10; 844 845 pm_runtime_set_autosuspend_delay(bdev->dev, 846 MTKBTSDIO_AUTOSUSPEND_DELAY); 847 pm_runtime_use_autosuspend(bdev->dev); 848 849 err = pm_runtime_set_active(bdev->dev); 850 if (err < 0) 851 return err; 852 853 /* Default forbid runtime auto suspend, that can be allowed by 854 * enable_autosuspend flag or the PM runtime entry under sysfs. 855 */ 856 pm_runtime_forbid(bdev->dev); 857 pm_runtime_enable(bdev->dev); 858 859 if (enable_autosuspend) 860 pm_runtime_allow(bdev->dev); 861 862 bt_dev_info(hdev, "Device setup in %llu usecs", duration); 863 864 return 0; 865 } 866 867 static int btmtksdio_shutdown(struct hci_dev *hdev) 868 { 869 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 870 struct btmtk_hci_wmt_params wmt_params; 871 u8 param = 0x0; 872 int err; 873 874 /* Get back the state to be consistent with the state 875 * in btmtksdio_setup. 876 */ 877 pm_runtime_get_sync(bdev->dev); 878 879 /* Disable the device */ 880 wmt_params.op = MTK_WMT_FUNC_CTRL; 881 wmt_params.flag = 0; 882 wmt_params.dlen = sizeof(param); 883 wmt_params.data = ¶m; 884 wmt_params.status = NULL; 885 886 err = mtk_hci_wmt_sync(hdev, &wmt_params); 887 if (err < 0) { 888 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 889 return err; 890 } 891 892 pm_runtime_put_noidle(bdev->dev); 893 pm_runtime_disable(bdev->dev); 894 895 return 0; 896 } 897 898 static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 899 { 900 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 901 902 switch (hci_skb_pkt_type(skb)) { 903 case HCI_COMMAND_PKT: 904 hdev->stat.cmd_tx++; 905 break; 906 907 case HCI_ACLDATA_PKT: 908 hdev->stat.acl_tx++; 909 break; 910 911 case HCI_SCODATA_PKT: 912 hdev->stat.sco_tx++; 913 break; 914 915 default: 916 return -EILSEQ; 917 } 918 919 skb_queue_tail(&bdev->txq, skb); 920 921 schedule_work(&bdev->tx_work); 922 923 return 0; 924 } 925 926 static int btmtksdio_probe(struct sdio_func *func, 927 const struct sdio_device_id *id) 928 { 929 struct btmtksdio_dev *bdev; 930 struct hci_dev *hdev; 931 int err; 932 933 bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL); 934 if (!bdev) 935 return -ENOMEM; 936 937 bdev->data = (void *)id->driver_data; 938 if (!bdev->data) 939 return -ENODEV; 940 941 bdev->dev = &func->dev; 942 bdev->func = func; 943 944 INIT_WORK(&bdev->tx_work, btmtksdio_tx_work); 945 skb_queue_head_init(&bdev->txq); 946 947 /* Initialize and register HCI device */ 948 hdev = hci_alloc_dev(); 949 if (!hdev) { 950 dev_err(&func->dev, "Can't allocate HCI device\n"); 951 return -ENOMEM; 952 } 953 954 bdev->hdev = hdev; 955 956 hdev->bus = HCI_SDIO; 957 hci_set_drvdata(hdev, bdev); 958 959 hdev->open = btmtksdio_open; 960 hdev->close = btmtksdio_close; 961 hdev->flush = btmtksdio_flush; 962 hdev->setup = btmtksdio_setup; 963 hdev->shutdown = btmtksdio_shutdown; 964 hdev->send = btmtksdio_send_frame; 965 SET_HCIDEV_DEV(hdev, &func->dev); 966 967 hdev->manufacturer = 70; 968 set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks); 969 970 err = hci_register_dev(hdev); 971 if (err < 0) { 972 dev_err(&func->dev, "Can't register HCI device\n"); 973 hci_free_dev(hdev); 974 return err; 975 } 976 977 sdio_set_drvdata(func, bdev); 978 979 /* pm_runtime_enable would be done after the firmware is being 980 * downloaded because the core layer probably already enables 981 * runtime PM for this func such as the case host->caps & 982 * MMC_CAP_POWER_OFF_CARD. 983 */ 984 if (pm_runtime_enabled(bdev->dev)) 985 pm_runtime_disable(bdev->dev); 986 987 /* As explaination in drivers/mmc/core/sdio_bus.c tells us: 988 * Unbound SDIO functions are always suspended. 989 * During probe, the function is set active and the usage count 990 * is incremented. If the driver supports runtime PM, 991 * it should call pm_runtime_put_noidle() in its probe routine and 992 * pm_runtime_get_noresume() in its remove routine. 993 * 994 * So, put a pm_runtime_put_noidle here ! 995 */ 996 pm_runtime_put_noidle(bdev->dev); 997 998 return 0; 999 } 1000 1001 static void btmtksdio_remove(struct sdio_func *func) 1002 { 1003 struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 1004 struct hci_dev *hdev; 1005 1006 if (!bdev) 1007 return; 1008 1009 /* Be consistent the state in btmtksdio_probe */ 1010 pm_runtime_get_noresume(bdev->dev); 1011 1012 hdev = bdev->hdev; 1013 1014 sdio_set_drvdata(func, NULL); 1015 hci_unregister_dev(hdev); 1016 hci_free_dev(hdev); 1017 } 1018 1019 #ifdef CONFIG_PM 1020 static int btmtksdio_runtime_suspend(struct device *dev) 1021 { 1022 struct sdio_func *func = dev_to_sdio_func(dev); 1023 struct btmtksdio_dev *bdev; 1024 u32 status; 1025 int err; 1026 1027 bdev = sdio_get_drvdata(func); 1028 if (!bdev) 1029 return 0; 1030 1031 sdio_claim_host(bdev->func); 1032 1033 sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err); 1034 if (err < 0) 1035 goto out; 1036 1037 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 1038 !(status & C_COM_DRV_OWN), 2000, 1000000); 1039 out: 1040 bt_dev_info(bdev->hdev, "status (%d) return ownership to device", err); 1041 1042 sdio_release_host(bdev->func); 1043 1044 return err; 1045 } 1046 1047 static int btmtksdio_runtime_resume(struct device *dev) 1048 { 1049 struct sdio_func *func = dev_to_sdio_func(dev); 1050 struct btmtksdio_dev *bdev; 1051 u32 status; 1052 int err; 1053 1054 bdev = sdio_get_drvdata(func); 1055 if (!bdev) 1056 return 0; 1057 1058 sdio_claim_host(bdev->func); 1059 1060 sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err); 1061 if (err < 0) 1062 goto out; 1063 1064 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 1065 status & C_COM_DRV_OWN, 2000, 1000000); 1066 out: 1067 bt_dev_info(bdev->hdev, "status (%d) get ownership from device", err); 1068 1069 sdio_release_host(bdev->func); 1070 1071 return err; 1072 } 1073 1074 static UNIVERSAL_DEV_PM_OPS(btmtksdio_pm_ops, btmtksdio_runtime_suspend, 1075 btmtksdio_runtime_resume, NULL); 1076 #define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops) 1077 #else /* CONFIG_PM */ 1078 #define BTMTKSDIO_PM_OPS NULL 1079 #endif /* CONFIG_PM */ 1080 1081 static struct sdio_driver btmtksdio_driver = { 1082 .name = "btmtksdio", 1083 .probe = btmtksdio_probe, 1084 .remove = btmtksdio_remove, 1085 .id_table = btmtksdio_table, 1086 .drv = { 1087 .owner = THIS_MODULE, 1088 .pm = BTMTKSDIO_PM_OPS, 1089 } 1090 }; 1091 1092 module_sdio_driver(btmtksdio_driver); 1093 1094 module_param(enable_autosuspend, bool, 0644); 1095 MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default"); 1096 1097 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 1098 MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION); 1099 MODULE_VERSION(VERSION); 1100 MODULE_LICENSE("GPL"); 1101 MODULE_FIRMWARE(FIRMWARE_MT7663); 1102 MODULE_FIRMWARE(FIRMWARE_MT7668); 1103