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