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