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