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