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 <linux/unaligned.h> 14 #include <linux/atomic.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/init.h> 17 #include <linux/iopoll.h> 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/of.h> 21 #include <linux/pm_runtime.h> 22 #include <linux/skbuff.h> 23 #include <linux/usb.h> 24 25 #include <linux/mmc/host.h> 26 #include <linux/mmc/sdio_ids.h> 27 #include <linux/mmc/sdio_func.h> 28 29 #include <net/bluetooth/bluetooth.h> 30 #include <net/bluetooth/hci_core.h> 31 32 #include "hci_uart.h" 33 #include "btmtk.h" 34 35 #define VERSION "0.1" 36 37 #define MTKBTSDIO_AUTOSUSPEND_DELAY 1000 38 39 static bool enable_autosuspend = true; 40 41 struct btmtksdio_data { 42 const char *fwname; 43 u16 chipid; 44 bool lp_mbox_supported; 45 bool pm_runtime_supported; 46 }; 47 48 static const struct btmtksdio_data mt7663_data = { 49 .fwname = FIRMWARE_MT7663, 50 .chipid = 0x7663, 51 .lp_mbox_supported = false, 52 .pm_runtime_supported = true, 53 }; 54 55 static const struct btmtksdio_data mt7668_data = { 56 .fwname = FIRMWARE_MT7668, 57 .chipid = 0x7668, 58 .lp_mbox_supported = false, 59 .pm_runtime_supported = true, 60 }; 61 62 static const struct btmtksdio_data mt7921_data = { 63 .fwname = FIRMWARE_MT7961, 64 .chipid = 0x7921, 65 .lp_mbox_supported = true, 66 .pm_runtime_supported = true, 67 }; 68 69 static const struct btmtksdio_data mt7902_data = { 70 .fwname = FIRMWARE_MT7902, 71 .chipid = 0x7902, 72 .lp_mbox_supported = false, 73 .pm_runtime_supported = false, 74 }; 75 76 static const struct sdio_device_id btmtksdio_table[] = { 77 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663), 78 .driver_data = (kernel_ulong_t)&mt7663_data }, 79 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668), 80 .driver_data = (kernel_ulong_t)&mt7668_data }, 81 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961), 82 .driver_data = (kernel_ulong_t)&mt7921_data }, 83 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7902), 84 .driver_data = (kernel_ulong_t)&mt7902_data }, 85 { } /* Terminating entry */ 86 }; 87 MODULE_DEVICE_TABLE(sdio, btmtksdio_table); 88 89 #define MTK_REG_CHLPCR 0x4 /* W1S */ 90 #define C_INT_EN_SET BIT(0) 91 #define C_INT_EN_CLR BIT(1) 92 #define C_FW_OWN_REQ_SET BIT(8) /* For write */ 93 #define C_COM_DRV_OWN BIT(8) /* For read */ 94 #define C_FW_OWN_REQ_CLR BIT(9) 95 96 #define MTK_REG_CSDIOCSR 0x8 97 #define SDIO_RE_INIT_EN BIT(0) 98 #define SDIO_INT_CTL BIT(2) 99 100 #define MTK_REG_CHCR 0xc 101 #define C_INT_CLR_CTRL BIT(1) 102 #define BT_RST_DONE BIT(8) 103 104 /* CHISR have the same bits field definition with CHIER */ 105 #define MTK_REG_CHISR 0x10 106 #define MTK_REG_CHIER 0x14 107 #define FW_OWN_BACK_INT BIT(0) 108 #define RX_DONE_INT BIT(1) 109 #define TX_EMPTY BIT(2) 110 #define TX_FIFO_OVERFLOW BIT(8) 111 #define FW_MAILBOX_INT BIT(15) 112 #define INT_MASK GENMASK(15, 0) 113 #define RX_PKT_LEN GENMASK(31, 16) 114 115 #define MTK_REG_CSICR 0xc0 116 #define CSICR_CLR_MBOX_ACK BIT(0) 117 #define MTK_REG_PH2DSM0R 0xc4 118 #define PH2DSM0R_DRIVER_OWN BIT(0) 119 #define MTK_REG_PD2HRM0R 0xdc 120 #define PD2HRM0R_DRV_OWN BIT(0) 121 122 #define MTK_REG_CTDR 0x18 123 124 #define MTK_REG_CRDR 0x1c 125 126 #define MTK_REG_CRPLR 0x24 127 128 #define MTK_SDIO_BLOCK_SIZE 256 129 130 #define BTMTKSDIO_TX_WAIT_VND_EVT 1 131 #define BTMTKSDIO_HW_TX_READY 2 132 #define BTMTKSDIO_FUNC_ENABLED 3 133 #define BTMTKSDIO_PATCH_ENABLED 4 134 #define BTMTKSDIO_HW_RESET_ACTIVE 5 135 #define BTMTKSDIO_BT_WAKE_ENABLED 6 136 137 struct mtkbtsdio_hdr { 138 __le16 len; 139 __le16 reserved; 140 u8 bt_type; 141 } __packed; 142 143 struct btmtksdio_dev { 144 struct hci_dev *hdev; 145 struct sdio_func *func; 146 struct device *dev; 147 148 struct work_struct txrx_work; 149 unsigned long tx_state; 150 struct sk_buff_head txq; 151 152 struct sk_buff *evt_skb; 153 154 const struct btmtksdio_data *data; 155 156 struct gpio_desc *reset; 157 }; 158 159 static int mtk_hci_wmt_sync(struct hci_dev *hdev, 160 struct btmtk_hci_wmt_params *wmt_params) 161 { 162 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 163 struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc; 164 struct btmtk_hci_wmt_evt_reg *wmt_evt_reg; 165 u32 hlen, status = BTMTK_WMT_INVALID; 166 struct btmtk_hci_wmt_evt *wmt_evt; 167 struct btmtk_hci_wmt_cmd *wc; 168 struct btmtk_wmt_hdr *hdr; 169 int err; 170 171 /* Send the WMT command and wait until the WMT event returns */ 172 hlen = sizeof(*hdr) + wmt_params->dlen; 173 if (hlen > 255) 174 return -EINVAL; 175 176 wc = kzalloc(hlen, GFP_KERNEL); 177 if (!wc) 178 return -ENOMEM; 179 180 hdr = &wc->hdr; 181 hdr->dir = 1; 182 hdr->op = wmt_params->op; 183 hdr->dlen = cpu_to_le16(wmt_params->dlen + 1); 184 hdr->flag = wmt_params->flag; 185 memcpy(wc->data, wmt_params->data, wmt_params->dlen); 186 187 set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 188 189 err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc); 190 if (err < 0) { 191 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 192 goto err_free_wc; 193 } 194 195 /* The vendor specific WMT commands are all answered by a vendor 196 * specific event and will not have the Command Status or Command 197 * Complete as with usual HCI command flow control. 198 * 199 * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT 200 * state to be cleared. The driver specific event receive routine 201 * will clear that state and with that indicate completion of the 202 * WMT command. 203 */ 204 err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT, 205 TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT); 206 if (err == -EINTR) { 207 bt_dev_err(hdev, "Execution of wmt command interrupted"); 208 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 209 goto err_free_wc; 210 } 211 212 if (err) { 213 bt_dev_err(hdev, "Execution of wmt command timed out"); 214 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state); 215 err = -ETIMEDOUT; 216 goto err_free_wc; 217 } 218 219 /* Parse and handle the return WMT event */ 220 wmt_evt = skb_pull_data(bdev->evt_skb, sizeof(*wmt_evt)); 221 if (!wmt_evt) { 222 bt_dev_err(hdev, "WMT event too short (%u bytes)", 223 bdev->evt_skb->len); 224 err = -EINVAL; 225 goto err_free_skb; 226 } 227 228 if (wmt_evt->whdr.op != hdr->op) { 229 bt_dev_err(hdev, "Wrong op received %d expected %d", 230 wmt_evt->whdr.op, hdr->op); 231 err = -EIO; 232 goto err_free_skb; 233 } 234 235 switch (wmt_evt->whdr.op) { 236 case BTMTK_WMT_SEMAPHORE: 237 if (wmt_evt->whdr.flag == 2) 238 status = BTMTK_WMT_PATCH_UNDONE; 239 else 240 status = BTMTK_WMT_PATCH_DONE; 241 break; 242 case BTMTK_WMT_FUNC_CTRL: 243 if (!skb_pull_data(bdev->evt_skb, 244 sizeof(wmt_evt_funcc->status))) { 245 /* A plain enable/disable request is acked with just 246 * the WMT header and no trailing status word; the 247 * result is carried in the header's own flag byte. 248 */ 249 status = wmt_evt->whdr.flag ? BTMTK_WMT_ON_UNDONE : 250 BTMTK_WMT_ON_DONE; 251 break; 252 } 253 254 wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt; 255 if (be16_to_cpu(wmt_evt_funcc->status) == 0x404) 256 status = BTMTK_WMT_ON_DONE; 257 else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420) 258 status = BTMTK_WMT_ON_PROGRESS; 259 else 260 status = BTMTK_WMT_ON_UNDONE; 261 break; 262 case BTMTK_WMT_PATCH_DWNLD: 263 if (wmt_evt->whdr.flag == 2) 264 status = BTMTK_WMT_PATCH_DONE; 265 else if (wmt_evt->whdr.flag == 1) 266 status = BTMTK_WMT_PATCH_PROGRESS; 267 else 268 status = BTMTK_WMT_PATCH_UNDONE; 269 break; 270 case BTMTK_WMT_REGISTER: 271 wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt; 272 if (le16_to_cpu(wmt_evt->whdr.dlen) == 12) 273 status = le32_to_cpu(wmt_evt_reg->val); 274 break; 275 } 276 277 if (wmt_params->status) 278 *wmt_params->status = status; 279 280 err_free_skb: 281 kfree_skb(bdev->evt_skb); 282 bdev->evt_skb = NULL; 283 err_free_wc: 284 kfree(wc); 285 286 return err; 287 } 288 289 static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev, 290 struct sk_buff *skb) 291 { 292 struct mtkbtsdio_hdr *sdio_hdr; 293 unsigned int len, pad_len; 294 int err; 295 296 /* Make sure that the data buffer is not shared with anyone else and 297 * that there is enough room for the SDIO header 298 */ 299 err = skb_cow_head(skb, sizeof(*sdio_hdr)); 300 if (err < 0) 301 return err; 302 303 /* The transfer is rounded up to the SDIO block size, so the buffer 304 * has to provide tailroom for the padding as well 305 */ 306 len = skb->len + sizeof(*sdio_hdr); 307 pad_len = round_up(len, MTK_SDIO_BLOCK_SIZE) - len; 308 309 if (unlikely(skb_tailroom(skb) < pad_len)) { 310 err = pskb_expand_head(skb, 0, pad_len, GFP_ATOMIC); 311 if (err < 0) 312 return err; 313 } 314 315 /* Prepend MediaTek SDIO Specific Header */ 316 skb_push(skb, sizeof(*sdio_hdr)); 317 318 sdio_hdr = (void *)skb->data; 319 sdio_hdr->len = cpu_to_le16(skb->len); 320 sdio_hdr->reserved = cpu_to_le16(0); 321 sdio_hdr->bt_type = hci_skb_pkt_type(skb); 322 323 /* Zero the padding so that no uninitialised memory is sent out */ 324 skb_put_zero(skb, pad_len); 325 326 clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 327 err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data, skb->len); 328 if (err < 0) 329 goto err_skb_restore; 330 331 bdev->hdev->stat.byte_tx += len; 332 333 kfree_skb(skb); 334 335 return 0; 336 337 err_skb_restore: 338 skb_trim(skb, len); 339 skb_pull(skb, sizeof(*sdio_hdr)); 340 341 return err; 342 } 343 344 static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev) 345 { 346 return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL); 347 } 348 349 static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev) 350 { 351 return sdio_readl(bdev->func, MTK_REG_PD2HRM0R, NULL); 352 } 353 354 static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev) 355 { 356 return sdio_readl(bdev->func, MTK_REG_CHCR, NULL); 357 } 358 359 static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev) 360 { 361 u32 status; 362 int err; 363 364 sdio_claim_host(bdev->func); 365 366 if (bdev->data->lp_mbox_supported && 367 test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) { 368 sdio_writel(bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR, 369 &err); 370 err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev, 371 status, !(status & PD2HRM0R_DRV_OWN), 372 2000, 1000000); 373 if (err < 0) { 374 bt_dev_err(bdev->hdev, "mailbox ACK not cleared"); 375 goto out; 376 } 377 } 378 379 /* Return ownership to the device */ 380 sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err); 381 if (err < 0) 382 goto out; 383 384 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 385 !(status & C_COM_DRV_OWN), 2000, 1000000); 386 387 out: 388 sdio_release_host(bdev->func); 389 390 if (err < 0) 391 bt_dev_err(bdev->hdev, "Cannot return ownership to device"); 392 393 return err; 394 } 395 396 static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev) 397 { 398 u32 status; 399 int err; 400 401 sdio_claim_host(bdev->func); 402 403 /* Get ownership from the device */ 404 sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err); 405 if (err < 0) 406 goto out; 407 408 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status, 409 status & C_COM_DRV_OWN, 2000, 1000000); 410 411 if (!err && bdev->data->lp_mbox_supported && 412 test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) 413 err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev, 414 status, status & PD2HRM0R_DRV_OWN, 415 2000, 1000000); 416 417 out: 418 sdio_release_host(bdev->func); 419 420 if (err < 0) 421 bt_dev_err(bdev->hdev, "Cannot get ownership from device"); 422 423 return err; 424 } 425 426 static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 427 { 428 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 429 struct hci_event_hdr *hdr = (void *)skb->data; 430 u8 evt = hdr->evt; 431 int err; 432 433 /* When someone waits for the WMT event, the skb is being cloned 434 * and being processed the events from there then. 435 */ 436 if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) { 437 bdev->evt_skb = skb_clone(skb, GFP_KERNEL); 438 if (!bdev->evt_skb) { 439 err = -ENOMEM; 440 goto err_out; 441 } 442 } 443 444 err = hci_recv_frame(hdev, skb); 445 if (err < 0) 446 goto err_free_skb; 447 448 if (evt == HCI_EV_WMT) { 449 if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, 450 &bdev->tx_state)) { 451 /* Barrier to sync with other CPUs */ 452 smp_mb__after_atomic(); 453 wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT); 454 } 455 } 456 457 return 0; 458 459 err_free_skb: 460 kfree_skb(bdev->evt_skb); 461 bdev->evt_skb = NULL; 462 463 err_out: 464 return err; 465 } 466 467 static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb) 468 { 469 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 470 u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle); 471 472 switch (handle) { 473 case 0xfc6f: 474 /* Firmware dump from device: when the firmware hangs, the 475 * device can no longer suspend and thus disable auto-suspend. 476 */ 477 pm_runtime_forbid(bdev->dev); 478 fallthrough; 479 case 0x05ff: 480 case 0x05fe: 481 /* Firmware debug logging */ 482 return hci_recv_diag(hdev, skb); 483 } 484 485 return hci_recv_frame(hdev, skb); 486 } 487 488 static const struct h4_recv_pkt mtk_recv_pkts[] = { 489 { H4_RECV_ACL, .recv = btmtksdio_recv_acl }, 490 { H4_RECV_SCO, .recv = hci_recv_frame }, 491 { H4_RECV_EVENT, .recv = btmtksdio_recv_event }, 492 }; 493 494 static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size) 495 { 496 const struct h4_recv_pkt *pkts = mtk_recv_pkts; 497 int pkts_count = ARRAY_SIZE(mtk_recv_pkts); 498 struct mtkbtsdio_hdr *sdio_hdr; 499 int err, i, pad_size; 500 struct sk_buff *skb; 501 u16 dlen; 502 503 if (rx_size < sizeof(*sdio_hdr)) 504 return -EILSEQ; 505 506 /* A SDIO packet is exactly containing a Bluetooth packet */ 507 skb = bt_skb_alloc(rx_size, GFP_KERNEL); 508 if (!skb) 509 return -ENOMEM; 510 511 skb_put(skb, rx_size); 512 513 err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size); 514 if (err < 0) 515 goto err_kfree_skb; 516 517 sdio_hdr = (void *)skb->data; 518 519 /* We assume the default error as -EILSEQ simply to make the error path 520 * be cleaner. 521 */ 522 err = -EILSEQ; 523 524 if (rx_size != le16_to_cpu(sdio_hdr->len)) { 525 bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched "); 526 goto err_kfree_skb; 527 } 528 529 hci_skb_pkt_type(skb) = sdio_hdr->bt_type; 530 531 /* Remove MediaTek SDIO header */ 532 skb_pull(skb, sizeof(*sdio_hdr)); 533 534 /* We have to dig into the packet to get payload size and then know how 535 * many padding bytes at the tail, these padding bytes should be removed 536 * before the packet is indicated to the core layer. 537 */ 538 for (i = 0; i < pkts_count; i++) { 539 if (sdio_hdr->bt_type == (&pkts[i])->type) 540 break; 541 } 542 543 if (i >= pkts_count) { 544 bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x", 545 sdio_hdr->bt_type); 546 goto err_kfree_skb; 547 } 548 549 /* Remaining bytes cannot hold a header*/ 550 if (skb->len < (&pkts[i])->hlen) { 551 bt_dev_err(bdev->hdev, "The size of bt header is mismatched"); 552 goto err_kfree_skb; 553 } 554 555 switch ((&pkts[i])->lsize) { 556 case 1: 557 dlen = skb->data[(&pkts[i])->loff]; 558 break; 559 case 2: 560 dlen = get_unaligned_le16(skb->data + 561 (&pkts[i])->loff); 562 break; 563 default: 564 goto err_kfree_skb; 565 } 566 567 pad_size = skb->len - (&pkts[i])->hlen - dlen; 568 569 /* Remaining bytes cannot hold a payload */ 570 if (pad_size < 0) { 571 bt_dev_err(bdev->hdev, "The size of bt payload is mismatched"); 572 goto err_kfree_skb; 573 } 574 575 /* Remove padding bytes */ 576 skb_trim(skb, skb->len - pad_size); 577 578 /* Complete frame */ 579 (&pkts[i])->recv(bdev->hdev, skb); 580 581 bdev->hdev->stat.byte_rx += rx_size; 582 583 return 0; 584 585 err_kfree_skb: 586 kfree_skb(skb); 587 588 return err; 589 } 590 591 static void btmtksdio_txrx_work(struct work_struct *work) 592 { 593 struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev, 594 txrx_work); 595 unsigned long txrx_timeout; 596 u32 int_status, rx_size; 597 struct sk_buff *skb; 598 int err; 599 600 pm_runtime_get_sync(bdev->dev); 601 602 sdio_claim_host(bdev->func); 603 604 /* Disable interrupt */ 605 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 606 607 txrx_timeout = jiffies + 5 * HZ; 608 609 do { 610 int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL); 611 612 /* Ack an interrupt as soon as possible before any operation on 613 * hardware. 614 * 615 * Note that we don't ack any status during operations to avoid race 616 * condition between the host and the device such as it's possible to 617 * mistakenly ack RX_DONE for the next packet and then cause interrupts 618 * not be raised again but there is still pending data in the hardware 619 * FIFO. 620 */ 621 sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL); 622 int_status &= INT_MASK; 623 624 if ((int_status & FW_MAILBOX_INT) && 625 bdev->data->chipid == 0x7921) { 626 sdio_writel(bdev->func, PH2DSM0R_DRIVER_OWN, 627 MTK_REG_PH2DSM0R, NULL); 628 } 629 630 if (int_status & FW_OWN_BACK_INT) 631 bt_dev_dbg(bdev->hdev, "Get fw own back"); 632 633 if (int_status & TX_EMPTY) 634 set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 635 636 else if (unlikely(int_status & TX_FIFO_OVERFLOW)) 637 bt_dev_warn(bdev->hdev, "Tx fifo overflow"); 638 639 if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) { 640 skb = skb_dequeue(&bdev->txq); 641 if (skb) { 642 err = btmtksdio_tx_packet(bdev, skb); 643 if (err < 0) { 644 bdev->hdev->stat.err_tx++; 645 skb_queue_head(&bdev->txq, skb); 646 } 647 } 648 } 649 650 if (int_status & RX_DONE_INT) { 651 rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL); 652 rx_size = (rx_size & RX_PKT_LEN) >> 16; 653 if (btmtksdio_rx_packet(bdev, rx_size) < 0) 654 bdev->hdev->stat.err_rx++; 655 } 656 } while (int_status && time_is_after_jiffies(txrx_timeout)); 657 658 /* Enable interrupt */ 659 if (bdev->func->irq_handler) 660 sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL); 661 662 sdio_release_host(bdev->func); 663 664 pm_runtime_put_autosuspend(bdev->dev); 665 } 666 667 static void btmtksdio_interrupt(struct sdio_func *func) 668 { 669 struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 670 671 if (test_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state)) { 672 if (bdev->hdev->suspended) 673 pm_wakeup_event(bdev->dev, 0); 674 clear_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state); 675 } 676 677 /* Disable interrupt */ 678 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 679 680 schedule_work(&bdev->txrx_work); 681 } 682 683 static int btmtksdio_open(struct hci_dev *hdev) 684 { 685 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 686 u32 val; 687 int err; 688 689 sdio_claim_host(bdev->func); 690 691 err = sdio_enable_func(bdev->func); 692 if (err < 0) 693 goto err_release_host; 694 695 set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state); 696 697 err = btmtksdio_drv_pmctrl(bdev); 698 if (err < 0) 699 goto err_disable_func; 700 701 /* Disable interrupt & mask out all interrupt sources */ 702 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err); 703 if (err < 0) 704 goto err_disable_func; 705 706 sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err); 707 if (err < 0) 708 goto err_disable_func; 709 710 err = sdio_claim_irq(bdev->func, btmtksdio_interrupt); 711 if (err < 0) 712 goto err_disable_func; 713 714 err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE); 715 if (err < 0) 716 goto err_release_irq; 717 718 /* SDIO CMD 5 allows the SDIO device back to idle state an 719 * synchronous interrupt is supported in SDIO 4-bit mode 720 */ 721 val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err); 722 if (err < 0) 723 goto err_release_irq; 724 725 val |= SDIO_INT_CTL; 726 sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err); 727 if (err < 0) 728 goto err_release_irq; 729 730 /* Explicitly set write-1-clear method */ 731 val = sdio_readl(bdev->func, MTK_REG_CHCR, &err); 732 if (err < 0) 733 goto err_release_irq; 734 735 val |= C_INT_CLR_CTRL; 736 sdio_writel(bdev->func, val, MTK_REG_CHCR, &err); 737 if (err < 0) 738 goto err_release_irq; 739 740 /* Setup interrupt sources */ 741 sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW, 742 MTK_REG_CHIER, &err); 743 if (err < 0) 744 goto err_release_irq; 745 746 /* Enable interrupt */ 747 sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err); 748 if (err < 0) 749 goto err_release_irq; 750 751 sdio_release_host(bdev->func); 752 753 return 0; 754 755 err_release_irq: 756 sdio_release_irq(bdev->func); 757 758 err_disable_func: 759 sdio_disable_func(bdev->func); 760 761 err_release_host: 762 sdio_release_host(bdev->func); 763 764 return err; 765 } 766 767 static int btmtksdio_close(struct hci_dev *hdev) 768 { 769 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 770 771 /* Skip btmtksdio_close if BTMTKSDIO_FUNC_ENABLED isn't set */ 772 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) 773 return 0; 774 775 sdio_claim_host(bdev->func); 776 777 /* Disable interrupt */ 778 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 779 780 sdio_release_irq(bdev->func); 781 782 cancel_work_sync(&bdev->txrx_work); 783 784 btmtksdio_fw_pmctrl(bdev); 785 786 clear_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state); 787 sdio_disable_func(bdev->func); 788 789 sdio_release_host(bdev->func); 790 791 return 0; 792 } 793 794 static int btmtksdio_flush(struct hci_dev *hdev) 795 { 796 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 797 798 skb_queue_purge(&bdev->txq); 799 800 cancel_work_sync(&bdev->txrx_work); 801 802 return 0; 803 } 804 805 static int btmtksdio_func_query(struct hci_dev *hdev) 806 { 807 struct btmtk_hci_wmt_params wmt_params; 808 int status, err; 809 u8 param = 0; 810 811 /* Query whether the function is enabled */ 812 wmt_params.op = BTMTK_WMT_FUNC_CTRL; 813 wmt_params.flag = 4; 814 wmt_params.dlen = sizeof(param); 815 wmt_params.data = ¶m; 816 wmt_params.status = &status; 817 818 err = mtk_hci_wmt_sync(hdev, &wmt_params); 819 if (err < 0) { 820 bt_dev_err(hdev, "Failed to query function status (%d)", err); 821 return err; 822 } 823 824 return status; 825 } 826 827 static int mt76xx_setup(struct hci_dev *hdev, const char *fwname) 828 { 829 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 830 struct btmtk_hci_wmt_params wmt_params; 831 struct btmtk_tci_sleep tci_sleep; 832 struct sk_buff *skb; 833 int err, status; 834 u8 param = 0x1; 835 836 /* Query whether the firmware is already download */ 837 wmt_params.op = BTMTK_WMT_SEMAPHORE; 838 wmt_params.flag = 1; 839 wmt_params.dlen = 0; 840 wmt_params.data = NULL; 841 wmt_params.status = &status; 842 843 err = mtk_hci_wmt_sync(hdev, &wmt_params); 844 if (err < 0) { 845 bt_dev_err(hdev, "Failed to query firmware status (%d)", err); 846 return err; 847 } 848 849 if (status == BTMTK_WMT_PATCH_DONE) { 850 bt_dev_info(hdev, "Firmware already downloaded"); 851 goto ignore_setup_fw; 852 } 853 854 /* Setup a firmware which the device definitely requires */ 855 err = btmtk_setup_firmware(hdev, fwname, mtk_hci_wmt_sync); 856 if (err < 0) 857 return err; 858 859 ignore_setup_fw: 860 /* Query whether the device is already enabled */ 861 err = readx_poll_timeout(btmtksdio_func_query, hdev, status, 862 status < 0 || status != BTMTK_WMT_ON_PROGRESS, 863 2000, 5000000); 864 /* -ETIMEDOUT happens */ 865 if (err < 0) 866 return err; 867 868 /* The other errors happen in btusb_mtk_func_query */ 869 if (status < 0) 870 return status; 871 872 if (status == BTMTK_WMT_ON_DONE) { 873 bt_dev_info(hdev, "function already on"); 874 goto ignore_func_on; 875 } 876 877 /* Enable Bluetooth protocol */ 878 wmt_params.op = BTMTK_WMT_FUNC_CTRL; 879 wmt_params.flag = 0; 880 wmt_params.dlen = sizeof(param); 881 wmt_params.data = ¶m; 882 wmt_params.status = NULL; 883 884 err = mtk_hci_wmt_sync(hdev, &wmt_params); 885 if (err < 0) { 886 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 887 return err; 888 } 889 890 set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state); 891 892 ignore_func_on: 893 /* Apply the low power environment setup */ 894 tci_sleep.mode = 0x5; 895 tci_sleep.duration = cpu_to_le16(0x640); 896 tci_sleep.host_duration = cpu_to_le16(0x640); 897 tci_sleep.host_wakeup_pin = 0; 898 tci_sleep.time_compensation = 0; 899 900 skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep, 901 HCI_INIT_TIMEOUT); 902 if (IS_ERR(skb)) { 903 err = PTR_ERR(skb); 904 bt_dev_err(hdev, "Failed to apply low power setting (%d)", err); 905 return err; 906 } 907 kfree_skb(skb); 908 909 return 0; 910 } 911 912 static int mt79xx_setup(struct hci_dev *hdev, const char *fwname) 913 { 914 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 915 struct btmtk_hci_wmt_params wmt_params; 916 u8 param = 0x1; 917 int err; 918 919 err = btmtk_setup_firmware_79xx(hdev, fwname, mtk_hci_wmt_sync, 0); 920 if (err < 0) { 921 bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err); 922 return err; 923 } 924 925 err = btmtksdio_fw_pmctrl(bdev); 926 if (err < 0) 927 return err; 928 929 err = btmtksdio_drv_pmctrl(bdev); 930 if (err < 0) 931 return err; 932 933 /* Enable Bluetooth protocol */ 934 wmt_params.op = BTMTK_WMT_FUNC_CTRL; 935 wmt_params.flag = 0; 936 wmt_params.dlen = sizeof(param); 937 wmt_params.data = ¶m; 938 wmt_params.status = NULL; 939 940 err = mtk_hci_wmt_sync(hdev, &wmt_params); 941 if (err < 0) { 942 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 943 return err; 944 } 945 946 hci_set_msft_opcode(hdev, 0xFD30); 947 hci_set_aosp_capable(hdev); 948 set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state); 949 950 return err; 951 } 952 953 static int btmtksdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val) 954 { 955 struct btmtk_hci_wmt_params wmt_params; 956 struct reg_read_cmd reg_read = { 957 .type = 1, 958 .num = 1, 959 }; 960 u32 status; 961 int err; 962 963 reg_read.addr = cpu_to_le32(reg); 964 wmt_params.op = BTMTK_WMT_REGISTER; 965 wmt_params.flag = BTMTK_WMT_REG_READ; 966 wmt_params.dlen = sizeof(reg_read); 967 wmt_params.data = ®_read; 968 wmt_params.status = &status; 969 970 err = mtk_hci_wmt_sync(hdev, &wmt_params); 971 if (err < 0) { 972 bt_dev_err(hdev, "Failed to read reg (%d)", err); 973 return err; 974 } 975 976 *val = status; 977 978 return err; 979 } 980 981 static int btmtksdio_mtk_reg_write(struct hci_dev *hdev, u32 reg, u32 val, u32 mask) 982 { 983 struct btmtk_hci_wmt_params wmt_params; 984 const struct reg_write_cmd reg_write = { 985 .type = 1, 986 .num = 1, 987 .addr = cpu_to_le32(reg), 988 .data = cpu_to_le32(val), 989 .mask = cpu_to_le32(mask), 990 }; 991 int err, status; 992 993 wmt_params.op = BTMTK_WMT_REGISTER; 994 wmt_params.flag = BTMTK_WMT_REG_WRITE; 995 wmt_params.dlen = sizeof(reg_write); 996 wmt_params.data = ®_write; 997 wmt_params.status = &status; 998 999 err = mtk_hci_wmt_sync(hdev, &wmt_params); 1000 if (err < 0) 1001 bt_dev_err(hdev, "Failed to write reg (%d)", err); 1002 1003 return err; 1004 } 1005 1006 static int btmtksdio_get_data_path_id(struct hci_dev *hdev, __u8 *data_path_id) 1007 { 1008 /* uses 1 as data path id for all the usecases */ 1009 *data_path_id = 1; 1010 return 0; 1011 } 1012 1013 static int btmtksdio_get_codec_config_data(struct hci_dev *hdev, 1014 __u8 link, struct bt_codec *codec, 1015 __u8 *ven_len, __u8 **ven_data) 1016 { 1017 int err = 0; 1018 1019 if (!ven_data || !ven_len) 1020 return -EINVAL; 1021 1022 *ven_len = 0; 1023 *ven_data = NULL; 1024 1025 if (link != ESCO_LINK) { 1026 bt_dev_err(hdev, "Invalid link type(%u)", link); 1027 return -EINVAL; 1028 } 1029 1030 *ven_data = kmalloc(sizeof(__u8), GFP_KERNEL); 1031 if (!*ven_data) { 1032 err = -ENOMEM; 1033 goto error; 1034 } 1035 1036 /* supports only CVSD and mSBC offload codecs */ 1037 switch (codec->id) { 1038 case 0x02: 1039 **ven_data = 0x00; 1040 break; 1041 case 0x05: 1042 **ven_data = 0x01; 1043 break; 1044 default: 1045 err = -EINVAL; 1046 bt_dev_err(hdev, "Invalid codec id(%u)", codec->id); 1047 goto error; 1048 } 1049 /* codec and its capabilities are pre-defined to ids 1050 * preset id = 0x00 represents CVSD codec with sampling rate 8K 1051 * preset id = 0x01 represents mSBC codec with sampling rate 16K 1052 */ 1053 *ven_len = sizeof(__u8); 1054 return err; 1055 1056 error: 1057 kfree(*ven_data); 1058 *ven_data = NULL; 1059 return err; 1060 } 1061 1062 static int btmtksdio_sco_setting(struct hci_dev *hdev) 1063 { 1064 const struct btmtk_sco sco_setting = { 1065 .clock_config = 0x49, 1066 .channel_format_config = 0x80, 1067 }; 1068 struct sk_buff *skb; 1069 u32 val; 1070 int err; 1071 1072 /* Enable SCO over I2S/PCM for MediaTek chipset */ 1073 skb = __hci_cmd_sync(hdev, 0xfc72, sizeof(sco_setting), 1074 &sco_setting, HCI_CMD_TIMEOUT); 1075 if (IS_ERR(skb)) 1076 return PTR_ERR(skb); 1077 1078 kfree_skb(skb); 1079 1080 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_0, &val); 1081 if (err < 0) 1082 return err; 1083 1084 val |= 0x11000000; 1085 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_0, val, ~0); 1086 if (err < 0) 1087 return err; 1088 1089 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val); 1090 if (err < 0) 1091 return err; 1092 1093 val |= 0x00000101; 1094 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0); 1095 if (err < 0) 1096 return err; 1097 1098 hdev->get_data_path_id = btmtksdio_get_data_path_id; 1099 hdev->get_codec_config_data = btmtksdio_get_codec_config_data; 1100 1101 return err; 1102 } 1103 1104 static int btmtksdio_reset_setting(struct hci_dev *hdev) 1105 { 1106 int err; 1107 u32 val; 1108 1109 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val); 1110 if (err < 0) 1111 return err; 1112 1113 val |= 0x20; /* set the pin (bit field 11:8) work as GPIO mode */ 1114 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0); 1115 if (err < 0) 1116 return err; 1117 1118 err = btmtksdio_mtk_reg_read(hdev, MT7921_BTSYS_RST, &val); 1119 if (err < 0) 1120 return err; 1121 1122 val |= MT7921_BTSYS_RST_WITH_GPIO; 1123 return btmtksdio_mtk_reg_write(hdev, MT7921_BTSYS_RST, val, ~0); 1124 } 1125 1126 static int btmtksdio_setup(struct hci_dev *hdev) 1127 { 1128 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1129 ktime_t calltime, delta, rettime; 1130 unsigned long long duration; 1131 char fwname[64]; 1132 int err, dev_id; 1133 u32 fw_version = 0, val; 1134 1135 calltime = ktime_get(); 1136 set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state); 1137 1138 switch (bdev->data->chipid) { 1139 case 0x7902: 1140 case 0x7921: 1141 if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) { 1142 err = btmtksdio_mtk_reg_read(hdev, MT7921_DLSTATUS, 1143 &val); 1144 if (err < 0) 1145 return err; 1146 1147 val &= ~BT_DL_STATE; 1148 err = btmtksdio_mtk_reg_write(hdev, MT7921_DLSTATUS, 1149 val, ~0); 1150 if (err < 0) 1151 return err; 1152 1153 btmtksdio_fw_pmctrl(bdev); 1154 msleep(20); 1155 btmtksdio_drv_pmctrl(bdev); 1156 1157 clear_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state); 1158 } 1159 1160 err = btmtksdio_mtk_reg_read(hdev, 0x70010200, &dev_id); 1161 if (err < 0) { 1162 bt_dev_err(hdev, "Failed to get device id (%d)", err); 1163 return err; 1164 } 1165 1166 err = btmtksdio_mtk_reg_read(hdev, 0x80021004, &fw_version); 1167 if (err < 0) { 1168 bt_dev_err(hdev, "Failed to get fw version (%d)", err); 1169 return err; 1170 } 1171 1172 btmtk_fw_get_filename(fwname, sizeof(fwname), dev_id, 1173 fw_version, 0); 1174 1175 snprintf(fwname, sizeof(fwname), 1176 "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin", 1177 dev_id & 0xffff, (fw_version & 0xff) + 1); 1178 err = mt79xx_setup(hdev, fwname); 1179 if (err < 0) 1180 return err; 1181 1182 /* Enable SCO over I2S/PCM */ 1183 err = btmtksdio_sco_setting(hdev); 1184 if (err < 0) { 1185 bt_dev_err(hdev, "Failed to enable SCO setting (%d)", err); 1186 return err; 1187 } 1188 1189 /* Enable WBS with mSBC codec */ 1190 hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED); 1191 1192 /* Enable GPIO reset mechanism */ 1193 if (bdev->reset) { 1194 err = btmtksdio_reset_setting(hdev); 1195 if (err < 0) { 1196 bt_dev_err(hdev, "Failed to enable Reset setting (%d)", err); 1197 devm_gpiod_put(bdev->dev, bdev->reset); 1198 bdev->reset = NULL; 1199 } 1200 } 1201 1202 break; 1203 case 0x7663: 1204 case 0x7668: 1205 err = mt76xx_setup(hdev, bdev->data->fwname); 1206 if (err < 0) 1207 return err; 1208 break; 1209 default: 1210 return -ENODEV; 1211 } 1212 1213 rettime = ktime_get(); 1214 delta = ktime_sub(rettime, calltime); 1215 duration = (unsigned long long)ktime_to_ns(delta) >> 10; 1216 1217 if (bdev->data->pm_runtime_supported) { 1218 pm_runtime_set_autosuspend_delay(bdev->dev, 1219 MTKBTSDIO_AUTOSUSPEND_DELAY); 1220 pm_runtime_use_autosuspend(bdev->dev); 1221 1222 err = pm_runtime_set_active(bdev->dev); 1223 if (err < 0) 1224 return err; 1225 1226 /* Default forbid runtime auto suspend, that can be allowed by 1227 * enable_autosuspend flag or the PM runtime entry under sysfs. 1228 */ 1229 pm_runtime_forbid(bdev->dev); 1230 pm_runtime_enable(bdev->dev); 1231 1232 if (enable_autosuspend) 1233 pm_runtime_allow(bdev->dev); 1234 } 1235 1236 bt_dev_info(hdev, "Device setup in %llu usecs", duration); 1237 1238 return 0; 1239 } 1240 1241 static int btmtksdio_shutdown(struct hci_dev *hdev) 1242 { 1243 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1244 struct btmtk_hci_wmt_params wmt_params; 1245 u8 param = 0x0; 1246 int err; 1247 1248 /* Get back the state to be consistent with the state 1249 * in btmtksdio_setup. 1250 */ 1251 pm_runtime_get_sync(bdev->dev); 1252 1253 /* wmt command only works until the reset is complete */ 1254 if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) 1255 goto ignore_wmt_cmd; 1256 1257 /* Disable the device */ 1258 wmt_params.op = BTMTK_WMT_FUNC_CTRL; 1259 wmt_params.flag = 0; 1260 wmt_params.dlen = sizeof(param); 1261 wmt_params.data = ¶m; 1262 wmt_params.status = NULL; 1263 1264 err = mtk_hci_wmt_sync(hdev, &wmt_params); 1265 if (err < 0) 1266 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err); 1267 1268 ignore_wmt_cmd: 1269 pm_runtime_put_noidle(bdev->dev); 1270 pm_runtime_disable(bdev->dev); 1271 1272 return 0; 1273 } 1274 1275 static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 1276 { 1277 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1278 1279 switch (hci_skb_pkt_type(skb)) { 1280 case HCI_COMMAND_PKT: 1281 hdev->stat.cmd_tx++; 1282 break; 1283 1284 case HCI_ACLDATA_PKT: 1285 hdev->stat.acl_tx++; 1286 break; 1287 1288 case HCI_SCODATA_PKT: 1289 hdev->stat.sco_tx++; 1290 break; 1291 1292 default: 1293 return -EILSEQ; 1294 } 1295 1296 skb_queue_tail(&bdev->txq, skb); 1297 1298 schedule_work(&bdev->txrx_work); 1299 1300 return 0; 1301 } 1302 1303 static void btmtksdio_reset(struct hci_dev *hdev) 1304 { 1305 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1306 u32 status; 1307 int err; 1308 1309 if (!bdev->reset || bdev->data->chipid != 0x7921) 1310 return; 1311 1312 pm_runtime_get_sync(bdev->dev); 1313 1314 if (test_and_set_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) 1315 return; 1316 1317 sdio_claim_host(bdev->func); 1318 1319 /* set drv_pmctrl if BT is closed before doing reset */ 1320 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) { 1321 sdio_enable_func(bdev->func); 1322 btmtksdio_drv_pmctrl(bdev); 1323 } 1324 1325 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL); 1326 skb_queue_purge(&bdev->txq); 1327 cancel_work_sync(&bdev->txrx_work); 1328 1329 gpiod_set_value_cansleep(bdev->reset, 1); 1330 msleep(100); 1331 gpiod_set_value_cansleep(bdev->reset, 0); 1332 1333 err = readx_poll_timeout(btmtksdio_chcr_query, bdev, status, 1334 status & BT_RST_DONE, 100000, 2000000); 1335 if (err < 0) { 1336 bt_dev_err(hdev, "Failed to reset (%d)", err); 1337 goto err; 1338 } 1339 1340 /* set fw_pmctrl back if BT is closed after doing reset */ 1341 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) { 1342 btmtksdio_fw_pmctrl(bdev); 1343 sdio_disable_func(bdev->func); 1344 } 1345 1346 clear_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state); 1347 err: 1348 sdio_release_host(bdev->func); 1349 1350 pm_runtime_put_noidle(bdev->dev); 1351 pm_runtime_disable(bdev->dev); 1352 1353 hci_reset_dev(hdev); 1354 } 1355 1356 static bool btmtksdio_sdio_inband_wakeup(struct hci_dev *hdev) 1357 { 1358 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1359 1360 return device_may_wakeup(bdev->dev); 1361 } 1362 1363 static bool btmtksdio_sdio_wakeup(struct hci_dev *hdev) 1364 { 1365 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev); 1366 bool may_wakeup = device_may_wakeup(bdev->dev); 1367 const struct btmtk_wakeon bt_awake = { 1368 .mode = 0x1, 1369 .gpo = 0, 1370 .active_high = 0x1, 1371 .enable_delay = cpu_to_le16(0xc80), 1372 .wakeup_delay = cpu_to_le16(0x20), 1373 }; 1374 1375 if (may_wakeup && bdev->data->chipid == 0x7921) { 1376 struct sk_buff *skb; 1377 1378 skb = __hci_cmd_sync(hdev, 0xfc27, sizeof(bt_awake), 1379 &bt_awake, HCI_CMD_TIMEOUT); 1380 if (IS_ERR(skb)) 1381 may_wakeup = false; 1382 else 1383 kfree_skb(skb); 1384 } 1385 1386 return may_wakeup; 1387 } 1388 1389 static int btmtksdio_probe(struct sdio_func *func, 1390 const struct sdio_device_id *id) 1391 { 1392 struct btmtksdio_dev *bdev; 1393 struct hci_dev *hdev; 1394 struct device_node *old_node; 1395 bool restore_node; 1396 int err; 1397 1398 bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL); 1399 if (!bdev) 1400 return -ENOMEM; 1401 1402 bdev->data = (void *)id->driver_data; 1403 if (!bdev->data) 1404 return -ENODEV; 1405 1406 bdev->dev = &func->dev; 1407 bdev->func = func; 1408 1409 INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work); 1410 skb_queue_head_init(&bdev->txq); 1411 1412 /* Initialize and register HCI device */ 1413 hdev = hci_alloc_dev(); 1414 if (!hdev) { 1415 dev_err(&func->dev, "Can't allocate HCI device\n"); 1416 return -ENOMEM; 1417 } 1418 1419 bdev->hdev = hdev; 1420 1421 hdev->bus = HCI_SDIO; 1422 hci_set_drvdata(hdev, bdev); 1423 1424 hdev->open = btmtksdio_open; 1425 hdev->close = btmtksdio_close; 1426 hdev->reset = btmtksdio_reset; 1427 hdev->flush = btmtksdio_flush; 1428 hdev->setup = btmtksdio_setup; 1429 hdev->shutdown = btmtksdio_shutdown; 1430 hdev->send = btmtksdio_send_frame; 1431 hdev->wakeup = btmtksdio_sdio_wakeup; 1432 /* 1433 * If SDIO controller supports wake on Bluetooth, sending a wakeon 1434 * command is not necessary. 1435 */ 1436 if (device_can_wakeup(func->card->host->parent)) 1437 hdev->wakeup = btmtksdio_sdio_inband_wakeup; 1438 else 1439 hdev->wakeup = btmtksdio_sdio_wakeup; 1440 hdev->set_bdaddr = btmtk_set_bdaddr; 1441 1442 SET_HCIDEV_DEV(hdev, &func->dev); 1443 1444 hdev->manufacturer = 70; 1445 hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP); 1446 1447 sdio_set_drvdata(func, bdev); 1448 1449 err = hci_register_dev(hdev); 1450 if (err < 0) { 1451 dev_err(&func->dev, "Can't register HCI device\n"); 1452 hci_free_dev(hdev); 1453 return err; 1454 } 1455 1456 /* pm_runtime_enable would be done after the firmware is being 1457 * downloaded because the core layer probably already enables 1458 * runtime PM for this func such as the case host->caps & 1459 * MMC_CAP_POWER_OFF_CARD. 1460 */ 1461 if (pm_runtime_enabled(bdev->dev)) 1462 pm_runtime_disable(bdev->dev); 1463 1464 /* As explanation in drivers/mmc/core/sdio_bus.c tells us: 1465 * Unbound SDIO functions are always suspended. 1466 * During probe, the function is set active and the usage count 1467 * is incremented. If the driver supports runtime PM, 1468 * it should call pm_runtime_put_noidle() in its probe routine and 1469 * pm_runtime_get_noresume() in its remove routine. 1470 * 1471 * So, put a pm_runtime_put_noidle here ! 1472 */ 1473 pm_runtime_put_noidle(bdev->dev); 1474 1475 err = devm_device_init_wakeup(bdev->dev); 1476 if (err) 1477 bt_dev_err(hdev, "failed to initialize device wakeup"); 1478 1479 restore_node = false; 1480 if (!of_device_is_compatible(bdev->dev->of_node, "mediatek,mt7921s-bluetooth")) { 1481 restore_node = true; 1482 old_node = bdev->dev->of_node; 1483 bdev->dev->of_node = of_find_compatible_node(NULL, NULL, 1484 "mediatek,mt7921s-bluetooth"); 1485 } 1486 1487 bdev->reset = devm_gpiod_get_optional(bdev->dev, "reset", 1488 GPIOD_OUT_LOW); 1489 if (IS_ERR(bdev->reset)) 1490 err = PTR_ERR(bdev->reset); 1491 1492 if (restore_node) { 1493 of_node_put(bdev->dev->of_node); 1494 bdev->dev->of_node = old_node; 1495 } 1496 1497 return err; 1498 } 1499 1500 static void btmtksdio_remove(struct sdio_func *func) 1501 { 1502 struct btmtksdio_dev *bdev = sdio_get_drvdata(func); 1503 struct hci_dev *hdev; 1504 1505 if (!bdev) 1506 return; 1507 1508 hdev = bdev->hdev; 1509 1510 /* Make sure to call btmtksdio_close before removing sdio card */ 1511 if (test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) 1512 btmtksdio_close(hdev); 1513 1514 if (bdev->data->pm_runtime_supported) 1515 pm_runtime_dont_use_autosuspend(bdev->dev); 1516 1517 /* Be consistent the state in btmtksdio_probe */ 1518 pm_runtime_get_noresume(bdev->dev); 1519 1520 sdio_set_drvdata(func, NULL); 1521 hci_unregister_dev(hdev); 1522 hci_free_dev(hdev); 1523 } 1524 1525 static int btmtksdio_runtime_suspend(struct device *dev) 1526 { 1527 struct sdio_func *func = dev_to_sdio_func(dev); 1528 struct btmtksdio_dev *bdev; 1529 int err; 1530 1531 bdev = sdio_get_drvdata(func); 1532 if (!bdev) 1533 return 0; 1534 1535 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) 1536 return 0; 1537 1538 sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1539 1540 err = btmtksdio_fw_pmctrl(bdev); 1541 1542 bt_dev_dbg(bdev->hdev, "status (%d) return ownership to device", err); 1543 1544 return err; 1545 } 1546 1547 static int btmtksdio_system_suspend(struct device *dev) 1548 { 1549 struct sdio_func *func = dev_to_sdio_func(dev); 1550 struct btmtksdio_dev *bdev; 1551 1552 bdev = sdio_get_drvdata(func); 1553 if (!bdev) 1554 return 0; 1555 1556 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) 1557 return 0; 1558 1559 set_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state); 1560 1561 return btmtksdio_runtime_suspend(dev); 1562 } 1563 1564 static int btmtksdio_runtime_resume(struct device *dev) 1565 { 1566 struct sdio_func *func = dev_to_sdio_func(dev); 1567 struct btmtksdio_dev *bdev; 1568 int err; 1569 1570 bdev = sdio_get_drvdata(func); 1571 if (!bdev) 1572 return 0; 1573 1574 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) 1575 return 0; 1576 1577 err = btmtksdio_drv_pmctrl(bdev); 1578 1579 bt_dev_dbg(bdev->hdev, "status (%d) get ownership from device", err); 1580 1581 return err; 1582 } 1583 1584 static int btmtksdio_system_resume(struct device *dev) 1585 { 1586 return btmtksdio_runtime_resume(dev); 1587 } 1588 1589 static const struct dev_pm_ops btmtksdio_pm_ops = { 1590 SYSTEM_SLEEP_PM_OPS(btmtksdio_system_suspend, btmtksdio_system_resume) 1591 RUNTIME_PM_OPS(btmtksdio_runtime_suspend, btmtksdio_runtime_resume, NULL) 1592 }; 1593 1594 static struct sdio_driver btmtksdio_driver = { 1595 .name = "btmtksdio", 1596 .probe = btmtksdio_probe, 1597 .remove = btmtksdio_remove, 1598 .id_table = btmtksdio_table, 1599 .drv = { 1600 .pm = pm_ptr(&btmtksdio_pm_ops), 1601 } 1602 }; 1603 1604 module_sdio_driver(btmtksdio_driver); 1605 1606 module_param(enable_autosuspend, bool, 0644); 1607 MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default"); 1608 1609 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 1610 MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION); 1611 MODULE_VERSION(VERSION); 1612 MODULE_LICENSE("GPL"); 1613