1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * 4 * Bluetooth HCI UART driver for Intel devices 5 * 6 * Copyright (C) 2015 Intel Corporation 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/errno.h> 11 #include <linux/skbuff.h> 12 #include <linux/firmware.h> 13 #include <linux/module.h> 14 #include <linux/wait.h> 15 #include <linux/tty.h> 16 #include <linux/platform_device.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/acpi.h> 19 #include <linux/interrupt.h> 20 #include <linux/pm_runtime.h> 21 22 #include <net/bluetooth/bluetooth.h> 23 #include <net/bluetooth/hci_core.h> 24 25 #include "hci_uart.h" 26 #include "btintel.h" 27 28 #define STATE_BOOTLOADER 0 29 #define STATE_DOWNLOADING 1 30 #define STATE_FIRMWARE_LOADED 2 31 #define STATE_FIRMWARE_FAILED 3 32 #define STATE_BOOTING 4 33 #define STATE_LPM_ENABLED 5 34 #define STATE_TX_ACTIVE 6 35 #define STATE_SUSPENDED 7 36 #define STATE_LPM_TRANSACTION 8 37 38 #define HCI_LPM_WAKE_PKT 0xf0 39 #define HCI_LPM_PKT 0xf1 40 #define HCI_LPM_MAX_SIZE 10 41 #define HCI_LPM_HDR_SIZE HCI_EVENT_HDR_SIZE 42 43 #define LPM_OP_TX_NOTIFY 0x00 44 #define LPM_OP_SUSPEND_ACK 0x02 45 #define LPM_OP_RESUME_ACK 0x03 46 47 #define LPM_SUSPEND_DELAY_MS 1000 48 49 struct hci_lpm_pkt { 50 __u8 opcode; 51 __u8 dlen; 52 __u8 data[0]; 53 } __packed; 54 55 struct intel_device { 56 struct list_head list; 57 struct platform_device *pdev; 58 struct gpio_desc *reset; 59 struct hci_uart *hu; 60 struct mutex hu_lock; 61 int irq; 62 }; 63 64 static LIST_HEAD(intel_device_list); 65 static DEFINE_MUTEX(intel_device_list_lock); 66 67 struct intel_data { 68 struct sk_buff *rx_skb; 69 struct sk_buff_head txq; 70 struct work_struct busy_work; 71 struct hci_uart *hu; 72 unsigned long flags; 73 }; 74 75 static u8 intel_convert_speed(unsigned int speed) 76 { 77 switch (speed) { 78 case 9600: 79 return 0x00; 80 case 19200: 81 return 0x01; 82 case 38400: 83 return 0x02; 84 case 57600: 85 return 0x03; 86 case 115200: 87 return 0x04; 88 case 230400: 89 return 0x05; 90 case 460800: 91 return 0x06; 92 case 921600: 93 return 0x07; 94 case 1843200: 95 return 0x08; 96 case 3250000: 97 return 0x09; 98 case 2000000: 99 return 0x0a; 100 case 3000000: 101 return 0x0b; 102 default: 103 return 0xff; 104 } 105 } 106 107 static int intel_wait_booting(struct hci_uart *hu) 108 { 109 struct intel_data *intel = hu->priv; 110 int err; 111 112 err = wait_on_bit_timeout(&intel->flags, STATE_BOOTING, 113 TASK_INTERRUPTIBLE, 114 msecs_to_jiffies(1000)); 115 116 if (err == -EINTR) { 117 bt_dev_err(hu->hdev, "Device boot interrupted"); 118 return -EINTR; 119 } 120 121 if (err) { 122 bt_dev_err(hu->hdev, "Device boot timeout"); 123 return -ETIMEDOUT; 124 } 125 126 return err; 127 } 128 129 #ifdef CONFIG_PM 130 static int intel_wait_lpm_transaction(struct hci_uart *hu) 131 { 132 struct intel_data *intel = hu->priv; 133 int err; 134 135 err = wait_on_bit_timeout(&intel->flags, STATE_LPM_TRANSACTION, 136 TASK_INTERRUPTIBLE, 137 msecs_to_jiffies(1000)); 138 139 if (err == -EINTR) { 140 bt_dev_err(hu->hdev, "LPM transaction interrupted"); 141 return -EINTR; 142 } 143 144 if (err) { 145 bt_dev_err(hu->hdev, "LPM transaction timeout"); 146 return -ETIMEDOUT; 147 } 148 149 return err; 150 } 151 152 static int intel_lpm_suspend(struct hci_uart *hu) 153 { 154 static const u8 suspend[] = { 0x01, 0x01, 0x01 }; 155 struct intel_data *intel = hu->priv; 156 struct sk_buff *skb; 157 158 if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 159 test_bit(STATE_SUSPENDED, &intel->flags)) 160 return 0; 161 162 if (test_bit(STATE_TX_ACTIVE, &intel->flags)) 163 return -EAGAIN; 164 165 bt_dev_dbg(hu->hdev, "Suspending"); 166 167 skb = bt_skb_alloc(sizeof(suspend), GFP_KERNEL); 168 if (!skb) { 169 bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 170 return -ENOMEM; 171 } 172 173 skb_put_data(skb, suspend, sizeof(suspend)); 174 hci_skb_pkt_type(skb) = HCI_LPM_PKT; 175 176 set_bit(STATE_LPM_TRANSACTION, &intel->flags); 177 178 /* LPM flow is a priority, enqueue packet at list head */ 179 skb_queue_head(&intel->txq, skb); 180 hci_uart_tx_wakeup(hu); 181 182 intel_wait_lpm_transaction(hu); 183 /* Even in case of failure, continue and test the suspended flag */ 184 185 clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 186 187 if (!test_bit(STATE_SUSPENDED, &intel->flags)) { 188 bt_dev_err(hu->hdev, "Device suspend error"); 189 return -EINVAL; 190 } 191 192 bt_dev_dbg(hu->hdev, "Suspended"); 193 194 hci_uart_set_flow_control(hu, true); 195 196 return 0; 197 } 198 199 static int intel_lpm_resume(struct hci_uart *hu) 200 { 201 struct intel_data *intel = hu->priv; 202 struct sk_buff *skb; 203 204 if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 205 !test_bit(STATE_SUSPENDED, &intel->flags)) 206 return 0; 207 208 bt_dev_dbg(hu->hdev, "Resuming"); 209 210 hci_uart_set_flow_control(hu, false); 211 212 skb = bt_skb_alloc(0, GFP_KERNEL); 213 if (!skb) { 214 bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 215 return -ENOMEM; 216 } 217 218 hci_skb_pkt_type(skb) = HCI_LPM_WAKE_PKT; 219 220 set_bit(STATE_LPM_TRANSACTION, &intel->flags); 221 222 /* LPM flow is a priority, enqueue packet at list head */ 223 skb_queue_head(&intel->txq, skb); 224 hci_uart_tx_wakeup(hu); 225 226 intel_wait_lpm_transaction(hu); 227 /* Even in case of failure, continue and test the suspended flag */ 228 229 clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 230 231 if (test_bit(STATE_SUSPENDED, &intel->flags)) { 232 bt_dev_err(hu->hdev, "Device resume error"); 233 return -EINVAL; 234 } 235 236 bt_dev_dbg(hu->hdev, "Resumed"); 237 238 return 0; 239 } 240 #endif /* CONFIG_PM */ 241 242 static int intel_lpm_host_wake(struct hci_uart *hu) 243 { 244 static const u8 lpm_resume_ack[] = { LPM_OP_RESUME_ACK, 0x00 }; 245 struct intel_data *intel = hu->priv; 246 struct sk_buff *skb; 247 248 hci_uart_set_flow_control(hu, false); 249 250 clear_bit(STATE_SUSPENDED, &intel->flags); 251 252 skb = bt_skb_alloc(sizeof(lpm_resume_ack), GFP_KERNEL); 253 if (!skb) { 254 bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 255 return -ENOMEM; 256 } 257 258 skb_put_data(skb, lpm_resume_ack, sizeof(lpm_resume_ack)); 259 hci_skb_pkt_type(skb) = HCI_LPM_PKT; 260 261 /* LPM flow is a priority, enqueue packet at list head */ 262 skb_queue_head(&intel->txq, skb); 263 hci_uart_tx_wakeup(hu); 264 265 bt_dev_dbg(hu->hdev, "Resumed by controller"); 266 267 return 0; 268 } 269 270 static irqreturn_t intel_irq(int irq, void *dev_id) 271 { 272 struct intel_device *idev = dev_id; 273 274 dev_info(&idev->pdev->dev, "hci_intel irq\n"); 275 276 mutex_lock(&idev->hu_lock); 277 if (idev->hu) 278 intel_lpm_host_wake(idev->hu); 279 mutex_unlock(&idev->hu_lock); 280 281 /* Host/Controller are now LPM resumed, trigger a new delayed suspend */ 282 pm_runtime_get(&idev->pdev->dev); 283 pm_runtime_mark_last_busy(&idev->pdev->dev); 284 pm_runtime_put_autosuspend(&idev->pdev->dev); 285 286 return IRQ_HANDLED; 287 } 288 289 static int intel_set_power(struct hci_uart *hu, bool powered) 290 { 291 struct list_head *p; 292 int err = -ENODEV; 293 294 if (!hu->tty->dev) 295 return err; 296 297 mutex_lock(&intel_device_list_lock); 298 299 list_for_each(p, &intel_device_list) { 300 struct intel_device *idev = list_entry(p, struct intel_device, 301 list); 302 303 /* tty device and pdev device should share the same parent 304 * which is the UART port. 305 */ 306 if (hu->tty->dev->parent != idev->pdev->dev.parent) 307 continue; 308 309 if (!idev->reset) { 310 err = -ENOTSUPP; 311 break; 312 } 313 314 BT_INFO("hu %p, Switching compatible pm device (%s) to %u", 315 hu, dev_name(&idev->pdev->dev), powered); 316 317 gpiod_set_value(idev->reset, powered); 318 319 /* Provide to idev a hu reference which is used to run LPM 320 * transactions (lpm suspend/resume) from PM callbacks. 321 * hu needs to be protected against concurrent removing during 322 * these PM ops. 323 */ 324 mutex_lock(&idev->hu_lock); 325 idev->hu = powered ? hu : NULL; 326 mutex_unlock(&idev->hu_lock); 327 328 if (idev->irq < 0) 329 break; 330 331 if (powered && device_can_wakeup(&idev->pdev->dev)) { 332 err = devm_request_threaded_irq(&idev->pdev->dev, 333 idev->irq, NULL, 334 intel_irq, 335 IRQF_ONESHOT, 336 "bt-host-wake", idev); 337 if (err) { 338 BT_ERR("hu %p, unable to allocate irq-%d", 339 hu, idev->irq); 340 break; 341 } 342 343 device_wakeup_enable(&idev->pdev->dev); 344 345 pm_runtime_set_active(&idev->pdev->dev); 346 pm_runtime_use_autosuspend(&idev->pdev->dev); 347 pm_runtime_set_autosuspend_delay(&idev->pdev->dev, 348 LPM_SUSPEND_DELAY_MS); 349 pm_runtime_enable(&idev->pdev->dev); 350 } else if (!powered && device_may_wakeup(&idev->pdev->dev)) { 351 devm_free_irq(&idev->pdev->dev, idev->irq, idev); 352 device_wakeup_disable(&idev->pdev->dev); 353 354 pm_runtime_disable(&idev->pdev->dev); 355 } 356 } 357 358 mutex_unlock(&intel_device_list_lock); 359 360 return err; 361 } 362 363 static void intel_busy_work(struct work_struct *work) 364 { 365 struct list_head *p; 366 struct intel_data *intel = container_of(work, struct intel_data, 367 busy_work); 368 369 if (!intel->hu->tty->dev) 370 return; 371 372 /* Link is busy, delay the suspend */ 373 mutex_lock(&intel_device_list_lock); 374 list_for_each(p, &intel_device_list) { 375 struct intel_device *idev = list_entry(p, struct intel_device, 376 list); 377 378 if (intel->hu->tty->dev->parent == idev->pdev->dev.parent) { 379 pm_runtime_get(&idev->pdev->dev); 380 pm_runtime_mark_last_busy(&idev->pdev->dev); 381 pm_runtime_put_autosuspend(&idev->pdev->dev); 382 break; 383 } 384 } 385 mutex_unlock(&intel_device_list_lock); 386 } 387 388 static int intel_open(struct hci_uart *hu) 389 { 390 struct intel_data *intel; 391 392 BT_DBG("hu %p", hu); 393 394 intel = kzalloc(sizeof(*intel), GFP_KERNEL); 395 if (!intel) 396 return -ENOMEM; 397 398 skb_queue_head_init(&intel->txq); 399 INIT_WORK(&intel->busy_work, intel_busy_work); 400 401 intel->hu = hu; 402 403 hu->priv = intel; 404 405 if (!intel_set_power(hu, true)) 406 set_bit(STATE_BOOTING, &intel->flags); 407 408 return 0; 409 } 410 411 static int intel_close(struct hci_uart *hu) 412 { 413 struct intel_data *intel = hu->priv; 414 415 BT_DBG("hu %p", hu); 416 417 cancel_work_sync(&intel->busy_work); 418 419 intel_set_power(hu, false); 420 421 skb_queue_purge(&intel->txq); 422 kfree_skb(intel->rx_skb); 423 kfree(intel); 424 425 hu->priv = NULL; 426 return 0; 427 } 428 429 static int intel_flush(struct hci_uart *hu) 430 { 431 struct intel_data *intel = hu->priv; 432 433 BT_DBG("hu %p", hu); 434 435 skb_queue_purge(&intel->txq); 436 437 return 0; 438 } 439 440 static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode) 441 { 442 struct sk_buff *skb; 443 struct hci_event_hdr *hdr; 444 struct hci_ev_cmd_complete *evt; 445 446 skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_KERNEL); 447 if (!skb) 448 return -ENOMEM; 449 450 hdr = skb_put(skb, sizeof(*hdr)); 451 hdr->evt = HCI_EV_CMD_COMPLETE; 452 hdr->plen = sizeof(*evt) + 1; 453 454 evt = skb_put(skb, sizeof(*evt)); 455 evt->ncmd = 0x01; 456 evt->opcode = cpu_to_le16(opcode); 457 458 skb_put_u8(skb, 0x00); 459 460 hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 461 462 return hci_recv_frame(hdev, skb); 463 } 464 465 static int intel_set_baudrate(struct hci_uart *hu, unsigned int speed) 466 { 467 struct intel_data *intel = hu->priv; 468 struct hci_dev *hdev = hu->hdev; 469 u8 speed_cmd[] = { 0x06, 0xfc, 0x01, 0x00 }; 470 struct sk_buff *skb; 471 int err; 472 473 /* This can be the first command sent to the chip, check 474 * that the controller is ready. 475 */ 476 err = intel_wait_booting(hu); 477 478 clear_bit(STATE_BOOTING, &intel->flags); 479 480 /* In case of timeout, try to continue anyway */ 481 if (err && err != -ETIMEDOUT) 482 return err; 483 484 bt_dev_info(hdev, "Change controller speed to %d", speed); 485 486 speed_cmd[3] = intel_convert_speed(speed); 487 if (speed_cmd[3] == 0xff) { 488 bt_dev_err(hdev, "Unsupported speed"); 489 return -EINVAL; 490 } 491 492 /* Device will not accept speed change if Intel version has not been 493 * previously requested. 494 */ 495 skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_CMD_TIMEOUT); 496 if (IS_ERR(skb)) { 497 bt_dev_err(hdev, "Reading Intel version information failed (%ld)", 498 PTR_ERR(skb)); 499 return PTR_ERR(skb); 500 } 501 kfree_skb(skb); 502 503 skb = bt_skb_alloc(sizeof(speed_cmd), GFP_KERNEL); 504 if (!skb) { 505 bt_dev_err(hdev, "Failed to alloc memory for baudrate packet"); 506 return -ENOMEM; 507 } 508 509 skb_put_data(skb, speed_cmd, sizeof(speed_cmd)); 510 hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 511 512 hci_uart_set_flow_control(hu, true); 513 514 skb_queue_tail(&intel->txq, skb); 515 hci_uart_tx_wakeup(hu); 516 517 /* wait 100ms to change baudrate on controller side */ 518 msleep(100); 519 520 hci_uart_set_baudrate(hu, speed); 521 hci_uart_set_flow_control(hu, false); 522 523 return 0; 524 } 525 526 static int intel_setup(struct hci_uart *hu) 527 { 528 struct intel_data *intel = hu->priv; 529 struct hci_dev *hdev = hu->hdev; 530 struct sk_buff *skb; 531 struct intel_version ver; 532 struct intel_boot_params params; 533 struct list_head *p; 534 const struct firmware *fw; 535 char fwname[64]; 536 u32 boot_param; 537 ktime_t calltime, delta, rettime; 538 unsigned long long duration; 539 unsigned int init_speed, oper_speed; 540 int speed_change = 0; 541 int err; 542 543 bt_dev_dbg(hdev, "start intel_setup"); 544 545 hu->hdev->set_diag = btintel_set_diag; 546 hu->hdev->set_bdaddr = btintel_set_bdaddr; 547 548 /* Set the default boot parameter to 0x0 and it is updated to 549 * SKU specific boot parameter after reading Intel_Write_Boot_Params 550 * command while downloading the firmware. 551 */ 552 boot_param = 0x00000000; 553 554 calltime = ktime_get(); 555 556 if (hu->init_speed) 557 init_speed = hu->init_speed; 558 else 559 init_speed = hu->proto->init_speed; 560 561 if (hu->oper_speed) 562 oper_speed = hu->oper_speed; 563 else 564 oper_speed = hu->proto->oper_speed; 565 566 if (oper_speed && init_speed && oper_speed != init_speed) 567 speed_change = 1; 568 569 /* Check that the controller is ready */ 570 err = intel_wait_booting(hu); 571 572 clear_bit(STATE_BOOTING, &intel->flags); 573 574 /* In case of timeout, try to continue anyway */ 575 if (err && err != -ETIMEDOUT) 576 return err; 577 578 set_bit(STATE_BOOTLOADER, &intel->flags); 579 580 /* Read the Intel version information to determine if the device 581 * is in bootloader mode or if it already has operational firmware 582 * loaded. 583 */ 584 err = btintel_read_version(hdev, &ver); 585 if (err) 586 return err; 587 588 /* The hardware platform number has a fixed value of 0x37 and 589 * for now only accept this single value. 590 */ 591 if (ver.hw_platform != 0x37) { 592 bt_dev_err(hdev, "Unsupported Intel hardware platform (%u)", 593 ver.hw_platform); 594 return -EINVAL; 595 } 596 597 /* Check for supported iBT hardware variants of this firmware 598 * loading method. 599 * 600 * This check has been put in place to ensure correct forward 601 * compatibility options when newer hardware variants come along. 602 */ 603 switch (ver.hw_variant) { 604 case 0x0b: /* LnP */ 605 case 0x0c: /* WsP */ 606 case 0x12: /* ThP */ 607 break; 608 default: 609 bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)", 610 ver.hw_variant); 611 return -EINVAL; 612 } 613 614 btintel_version_info(hdev, &ver); 615 616 /* The firmware variant determines if the device is in bootloader 617 * mode or is running operational firmware. The value 0x06 identifies 618 * the bootloader and the value 0x23 identifies the operational 619 * firmware. 620 * 621 * When the operational firmware is already present, then only 622 * the check for valid Bluetooth device address is needed. This 623 * determines if the device will be added as configured or 624 * unconfigured controller. 625 * 626 * It is not possible to use the Secure Boot Parameters in this 627 * case since that command is only available in bootloader mode. 628 */ 629 if (ver.fw_variant == 0x23) { 630 clear_bit(STATE_BOOTLOADER, &intel->flags); 631 btintel_check_bdaddr(hdev); 632 return 0; 633 } 634 635 /* If the device is not in bootloader mode, then the only possible 636 * choice is to return an error and abort the device initialization. 637 */ 638 if (ver.fw_variant != 0x06) { 639 bt_dev_err(hdev, "Unsupported Intel firmware variant (%u)", 640 ver.fw_variant); 641 return -ENODEV; 642 } 643 644 /* Read the secure boot parameters to identify the operating 645 * details of the bootloader. 646 */ 647 err = btintel_read_boot_params(hdev, ¶ms); 648 if (err) 649 return err; 650 651 /* It is required that every single firmware fragment is acknowledged 652 * with a command complete event. If the boot parameters indicate 653 * that this bootloader does not send them, then abort the setup. 654 */ 655 if (params.limited_cce != 0x00) { 656 bt_dev_err(hdev, "Unsupported Intel firmware loading method (%u)", 657 params.limited_cce); 658 return -EINVAL; 659 } 660 661 /* If the OTP has no valid Bluetooth device address, then there will 662 * also be no valid address for the operational firmware. 663 */ 664 if (!bacmp(¶ms.otp_bdaddr, BDADDR_ANY)) { 665 bt_dev_info(hdev, "No device address configured"); 666 set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks); 667 } 668 669 /* With this Intel bootloader only the hardware variant and device 670 * revision information are used to select the right firmware for SfP 671 * and WsP. 672 * 673 * The firmware filename is ibt-<hw_variant>-<dev_revid>.sfi. 674 * 675 * Currently the supported hardware variants are: 676 * 11 (0x0b) for iBT 3.0 (LnP/SfP) 677 * 12 (0x0c) for iBT 3.5 (WsP) 678 * 679 * For ThP/JfP and for future SKU's, the FW name varies based on HW 680 * variant, HW revision and FW revision, as these are dependent on CNVi 681 * and RF Combination. 682 * 683 * 18 (0x12) for iBT3.5 (ThP/JfP) 684 * 685 * The firmware file name for these will be 686 * ibt-<hw_variant>-<hw_revision>-<fw_revision>.sfi. 687 * 688 */ 689 switch (ver.hw_variant) { 690 case 0x0b: /* SfP */ 691 case 0x0c: /* WsP */ 692 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u.sfi", 693 le16_to_cpu(ver.hw_variant), 694 le16_to_cpu(params.dev_revid)); 695 break; 696 case 0x12: /* ThP */ 697 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u-%u.sfi", 698 le16_to_cpu(ver.hw_variant), 699 le16_to_cpu(ver.hw_revision), 700 le16_to_cpu(ver.fw_revision)); 701 break; 702 default: 703 bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)", 704 ver.hw_variant); 705 return -EINVAL; 706 } 707 708 err = request_firmware(&fw, fwname, &hdev->dev); 709 if (err < 0) { 710 bt_dev_err(hdev, "Failed to load Intel firmware file (%d)", 711 err); 712 return err; 713 } 714 715 bt_dev_info(hdev, "Found device firmware: %s", fwname); 716 717 /* Save the DDC file name for later */ 718 switch (ver.hw_variant) { 719 case 0x0b: /* SfP */ 720 case 0x0c: /* WsP */ 721 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u.ddc", 722 le16_to_cpu(ver.hw_variant), 723 le16_to_cpu(params.dev_revid)); 724 break; 725 case 0x12: /* ThP */ 726 snprintf(fwname, sizeof(fwname), "intel/ibt-%u-%u-%u.ddc", 727 le16_to_cpu(ver.hw_variant), 728 le16_to_cpu(ver.hw_revision), 729 le16_to_cpu(ver.fw_revision)); 730 break; 731 default: 732 bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)", 733 ver.hw_variant); 734 return -EINVAL; 735 } 736 737 if (fw->size < 644) { 738 bt_dev_err(hdev, "Invalid size of firmware file (%zu)", 739 fw->size); 740 err = -EBADF; 741 goto done; 742 } 743 744 set_bit(STATE_DOWNLOADING, &intel->flags); 745 746 /* Start firmware downloading and get boot parameter */ 747 err = btintel_download_firmware(hdev, fw, &boot_param); 748 if (err < 0) 749 goto done; 750 751 set_bit(STATE_FIRMWARE_LOADED, &intel->flags); 752 753 bt_dev_info(hdev, "Waiting for firmware download to complete"); 754 755 /* Before switching the device into operational mode and with that 756 * booting the loaded firmware, wait for the bootloader notification 757 * that all fragments have been successfully received. 758 * 759 * When the event processing receives the notification, then the 760 * STATE_DOWNLOADING flag will be cleared. 761 * 762 * The firmware loading should not take longer than 5 seconds 763 * and thus just timeout if that happens and fail the setup 764 * of this device. 765 */ 766 err = wait_on_bit_timeout(&intel->flags, STATE_DOWNLOADING, 767 TASK_INTERRUPTIBLE, 768 msecs_to_jiffies(5000)); 769 if (err == -EINTR) { 770 bt_dev_err(hdev, "Firmware loading interrupted"); 771 err = -EINTR; 772 goto done; 773 } 774 775 if (err) { 776 bt_dev_err(hdev, "Firmware loading timeout"); 777 err = -ETIMEDOUT; 778 goto done; 779 } 780 781 if (test_bit(STATE_FIRMWARE_FAILED, &intel->flags)) { 782 bt_dev_err(hdev, "Firmware loading failed"); 783 err = -ENOEXEC; 784 goto done; 785 } 786 787 rettime = ktime_get(); 788 delta = ktime_sub(rettime, calltime); 789 duration = (unsigned long long) ktime_to_ns(delta) >> 10; 790 791 bt_dev_info(hdev, "Firmware loaded in %llu usecs", duration); 792 793 done: 794 release_firmware(fw); 795 796 if (err < 0) 797 return err; 798 799 /* We need to restore the default speed before Intel reset */ 800 if (speed_change) { 801 err = intel_set_baudrate(hu, init_speed); 802 if (err) 803 return err; 804 } 805 806 calltime = ktime_get(); 807 808 set_bit(STATE_BOOTING, &intel->flags); 809 810 err = btintel_send_intel_reset(hdev, boot_param); 811 if (err) 812 return err; 813 814 /* The bootloader will not indicate when the device is ready. This 815 * is done by the operational firmware sending bootup notification. 816 * 817 * Booting into operational firmware should not take longer than 818 * 1 second. However if that happens, then just fail the setup 819 * since something went wrong. 820 */ 821 bt_dev_info(hdev, "Waiting for device to boot"); 822 823 err = intel_wait_booting(hu); 824 if (err) 825 return err; 826 827 clear_bit(STATE_BOOTING, &intel->flags); 828 829 rettime = ktime_get(); 830 delta = ktime_sub(rettime, calltime); 831 duration = (unsigned long long) ktime_to_ns(delta) >> 10; 832 833 bt_dev_info(hdev, "Device booted in %llu usecs", duration); 834 835 /* Enable LPM if matching pdev with wakeup enabled, set TX active 836 * until further LPM TX notification. 837 */ 838 mutex_lock(&intel_device_list_lock); 839 list_for_each(p, &intel_device_list) { 840 struct intel_device *dev = list_entry(p, struct intel_device, 841 list); 842 if (!hu->tty->dev) 843 break; 844 if (hu->tty->dev->parent == dev->pdev->dev.parent) { 845 if (device_may_wakeup(&dev->pdev->dev)) { 846 set_bit(STATE_LPM_ENABLED, &intel->flags); 847 set_bit(STATE_TX_ACTIVE, &intel->flags); 848 } 849 break; 850 } 851 } 852 mutex_unlock(&intel_device_list_lock); 853 854 /* Ignore errors, device can work without DDC parameters */ 855 btintel_load_ddc_config(hdev, fwname); 856 857 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_CMD_TIMEOUT); 858 if (IS_ERR(skb)) 859 return PTR_ERR(skb); 860 kfree_skb(skb); 861 862 if (speed_change) { 863 err = intel_set_baudrate(hu, oper_speed); 864 if (err) 865 return err; 866 } 867 868 bt_dev_info(hdev, "Setup complete"); 869 870 clear_bit(STATE_BOOTLOADER, &intel->flags); 871 872 return 0; 873 } 874 875 static int intel_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 876 { 877 struct hci_uart *hu = hci_get_drvdata(hdev); 878 struct intel_data *intel = hu->priv; 879 struct hci_event_hdr *hdr; 880 881 if (!test_bit(STATE_BOOTLOADER, &intel->flags) && 882 !test_bit(STATE_BOOTING, &intel->flags)) 883 goto recv; 884 885 hdr = (void *)skb->data; 886 887 /* When the firmware loading completes the device sends 888 * out a vendor specific event indicating the result of 889 * the firmware loading. 890 */ 891 if (skb->len == 7 && hdr->evt == 0xff && hdr->plen == 0x05 && 892 skb->data[2] == 0x06) { 893 if (skb->data[3] != 0x00) 894 set_bit(STATE_FIRMWARE_FAILED, &intel->flags); 895 896 if (test_and_clear_bit(STATE_DOWNLOADING, &intel->flags) && 897 test_bit(STATE_FIRMWARE_LOADED, &intel->flags)) 898 wake_up_bit(&intel->flags, STATE_DOWNLOADING); 899 900 /* When switching to the operational firmware the device 901 * sends a vendor specific event indicating that the bootup 902 * completed. 903 */ 904 } else if (skb->len == 9 && hdr->evt == 0xff && hdr->plen == 0x07 && 905 skb->data[2] == 0x02) { 906 if (test_and_clear_bit(STATE_BOOTING, &intel->flags)) 907 wake_up_bit(&intel->flags, STATE_BOOTING); 908 } 909 recv: 910 return hci_recv_frame(hdev, skb); 911 } 912 913 static void intel_recv_lpm_notify(struct hci_dev *hdev, int value) 914 { 915 struct hci_uart *hu = hci_get_drvdata(hdev); 916 struct intel_data *intel = hu->priv; 917 918 bt_dev_dbg(hdev, "TX idle notification (%d)", value); 919 920 if (value) { 921 set_bit(STATE_TX_ACTIVE, &intel->flags); 922 schedule_work(&intel->busy_work); 923 } else { 924 clear_bit(STATE_TX_ACTIVE, &intel->flags); 925 } 926 } 927 928 static int intel_recv_lpm(struct hci_dev *hdev, struct sk_buff *skb) 929 { 930 struct hci_lpm_pkt *lpm = (void *)skb->data; 931 struct hci_uart *hu = hci_get_drvdata(hdev); 932 struct intel_data *intel = hu->priv; 933 934 switch (lpm->opcode) { 935 case LPM_OP_TX_NOTIFY: 936 if (lpm->dlen < 1) { 937 bt_dev_err(hu->hdev, "Invalid LPM notification packet"); 938 break; 939 } 940 intel_recv_lpm_notify(hdev, lpm->data[0]); 941 break; 942 case LPM_OP_SUSPEND_ACK: 943 set_bit(STATE_SUSPENDED, &intel->flags); 944 if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) 945 wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 946 break; 947 case LPM_OP_RESUME_ACK: 948 clear_bit(STATE_SUSPENDED, &intel->flags); 949 if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) 950 wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 951 break; 952 default: 953 bt_dev_err(hdev, "Unknown LPM opcode (%02x)", lpm->opcode); 954 break; 955 } 956 957 kfree_skb(skb); 958 959 return 0; 960 } 961 962 #define INTEL_RECV_LPM \ 963 .type = HCI_LPM_PKT, \ 964 .hlen = HCI_LPM_HDR_SIZE, \ 965 .loff = 1, \ 966 .lsize = 1, \ 967 .maxlen = HCI_LPM_MAX_SIZE 968 969 static const struct h4_recv_pkt intel_recv_pkts[] = { 970 { H4_RECV_ACL, .recv = hci_recv_frame }, 971 { H4_RECV_SCO, .recv = hci_recv_frame }, 972 { H4_RECV_EVENT, .recv = intel_recv_event }, 973 { INTEL_RECV_LPM, .recv = intel_recv_lpm }, 974 }; 975 976 static int intel_recv(struct hci_uart *hu, const void *data, int count) 977 { 978 struct intel_data *intel = hu->priv; 979 980 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 981 return -EUNATCH; 982 983 intel->rx_skb = h4_recv_buf(hu->hdev, intel->rx_skb, data, count, 984 intel_recv_pkts, 985 ARRAY_SIZE(intel_recv_pkts)); 986 if (IS_ERR(intel->rx_skb)) { 987 int err = PTR_ERR(intel->rx_skb); 988 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 989 intel->rx_skb = NULL; 990 return err; 991 } 992 993 return count; 994 } 995 996 static int intel_enqueue(struct hci_uart *hu, struct sk_buff *skb) 997 { 998 struct intel_data *intel = hu->priv; 999 struct list_head *p; 1000 1001 BT_DBG("hu %p skb %p", hu, skb); 1002 1003 if (!hu->tty->dev) 1004 goto out_enqueue; 1005 1006 /* Be sure our controller is resumed and potential LPM transaction 1007 * completed before enqueuing any packet. 1008 */ 1009 mutex_lock(&intel_device_list_lock); 1010 list_for_each(p, &intel_device_list) { 1011 struct intel_device *idev = list_entry(p, struct intel_device, 1012 list); 1013 1014 if (hu->tty->dev->parent == idev->pdev->dev.parent) { 1015 pm_runtime_get_sync(&idev->pdev->dev); 1016 pm_runtime_mark_last_busy(&idev->pdev->dev); 1017 pm_runtime_put_autosuspend(&idev->pdev->dev); 1018 break; 1019 } 1020 } 1021 mutex_unlock(&intel_device_list_lock); 1022 out_enqueue: 1023 skb_queue_tail(&intel->txq, skb); 1024 1025 return 0; 1026 } 1027 1028 static struct sk_buff *intel_dequeue(struct hci_uart *hu) 1029 { 1030 struct intel_data *intel = hu->priv; 1031 struct sk_buff *skb; 1032 1033 skb = skb_dequeue(&intel->txq); 1034 if (!skb) 1035 return skb; 1036 1037 if (test_bit(STATE_BOOTLOADER, &intel->flags) && 1038 (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT)) { 1039 struct hci_command_hdr *cmd = (void *)skb->data; 1040 __u16 opcode = le16_to_cpu(cmd->opcode); 1041 1042 /* When the 0xfc01 command is issued to boot into 1043 * the operational firmware, it will actually not 1044 * send a command complete event. To keep the flow 1045 * control working inject that event here. 1046 */ 1047 if (opcode == 0xfc01) 1048 inject_cmd_complete(hu->hdev, opcode); 1049 } 1050 1051 /* Prepend skb with frame type */ 1052 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 1053 1054 return skb; 1055 } 1056 1057 static const struct hci_uart_proto intel_proto = { 1058 .id = HCI_UART_INTEL, 1059 .name = "Intel", 1060 .manufacturer = 2, 1061 .init_speed = 115200, 1062 .oper_speed = 3000000, 1063 .open = intel_open, 1064 .close = intel_close, 1065 .flush = intel_flush, 1066 .setup = intel_setup, 1067 .set_baudrate = intel_set_baudrate, 1068 .recv = intel_recv, 1069 .enqueue = intel_enqueue, 1070 .dequeue = intel_dequeue, 1071 }; 1072 1073 #ifdef CONFIG_ACPI 1074 static const struct acpi_device_id intel_acpi_match[] = { 1075 { "INT33E1", 0 }, 1076 { }, 1077 }; 1078 MODULE_DEVICE_TABLE(acpi, intel_acpi_match); 1079 #endif 1080 1081 #ifdef CONFIG_PM 1082 static int intel_suspend_device(struct device *dev) 1083 { 1084 struct intel_device *idev = dev_get_drvdata(dev); 1085 1086 mutex_lock(&idev->hu_lock); 1087 if (idev->hu) 1088 intel_lpm_suspend(idev->hu); 1089 mutex_unlock(&idev->hu_lock); 1090 1091 return 0; 1092 } 1093 1094 static int intel_resume_device(struct device *dev) 1095 { 1096 struct intel_device *idev = dev_get_drvdata(dev); 1097 1098 mutex_lock(&idev->hu_lock); 1099 if (idev->hu) 1100 intel_lpm_resume(idev->hu); 1101 mutex_unlock(&idev->hu_lock); 1102 1103 return 0; 1104 } 1105 #endif 1106 1107 #ifdef CONFIG_PM_SLEEP 1108 static int intel_suspend(struct device *dev) 1109 { 1110 struct intel_device *idev = dev_get_drvdata(dev); 1111 1112 if (device_may_wakeup(dev)) 1113 enable_irq_wake(idev->irq); 1114 1115 return intel_suspend_device(dev); 1116 } 1117 1118 static int intel_resume(struct device *dev) 1119 { 1120 struct intel_device *idev = dev_get_drvdata(dev); 1121 1122 if (device_may_wakeup(dev)) 1123 disable_irq_wake(idev->irq); 1124 1125 return intel_resume_device(dev); 1126 } 1127 #endif 1128 1129 static const struct dev_pm_ops intel_pm_ops = { 1130 SET_SYSTEM_SLEEP_PM_OPS(intel_suspend, intel_resume) 1131 SET_RUNTIME_PM_OPS(intel_suspend_device, intel_resume_device, NULL) 1132 }; 1133 1134 static const struct acpi_gpio_params reset_gpios = { 0, 0, false }; 1135 static const struct acpi_gpio_params host_wake_gpios = { 1, 0, false }; 1136 1137 static const struct acpi_gpio_mapping acpi_hci_intel_gpios[] = { 1138 { "reset-gpios", &reset_gpios, 1 }, 1139 { "host-wake-gpios", &host_wake_gpios, 1 }, 1140 { }, 1141 }; 1142 1143 static int intel_probe(struct platform_device *pdev) 1144 { 1145 struct intel_device *idev; 1146 int ret; 1147 1148 idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL); 1149 if (!idev) 1150 return -ENOMEM; 1151 1152 mutex_init(&idev->hu_lock); 1153 1154 idev->pdev = pdev; 1155 1156 ret = devm_acpi_dev_add_driver_gpios(&pdev->dev, acpi_hci_intel_gpios); 1157 if (ret) 1158 dev_dbg(&pdev->dev, "Unable to add GPIO mapping table\n"); 1159 1160 idev->reset = devm_gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW); 1161 if (IS_ERR(idev->reset)) { 1162 dev_err(&pdev->dev, "Unable to retrieve gpio\n"); 1163 return PTR_ERR(idev->reset); 1164 } 1165 1166 idev->irq = platform_get_irq(pdev, 0); 1167 if (idev->irq < 0) { 1168 struct gpio_desc *host_wake; 1169 1170 dev_err(&pdev->dev, "No IRQ, falling back to gpio-irq\n"); 1171 1172 host_wake = devm_gpiod_get(&pdev->dev, "host-wake", GPIOD_IN); 1173 if (IS_ERR(host_wake)) { 1174 dev_err(&pdev->dev, "Unable to retrieve IRQ\n"); 1175 goto no_irq; 1176 } 1177 1178 idev->irq = gpiod_to_irq(host_wake); 1179 if (idev->irq < 0) { 1180 dev_err(&pdev->dev, "No corresponding irq for gpio\n"); 1181 goto no_irq; 1182 } 1183 } 1184 1185 /* Only enable wake-up/irq when controller is powered */ 1186 device_set_wakeup_capable(&pdev->dev, true); 1187 device_wakeup_disable(&pdev->dev); 1188 1189 no_irq: 1190 platform_set_drvdata(pdev, idev); 1191 1192 /* Place this instance on the device list */ 1193 mutex_lock(&intel_device_list_lock); 1194 list_add_tail(&idev->list, &intel_device_list); 1195 mutex_unlock(&intel_device_list_lock); 1196 1197 dev_info(&pdev->dev, "registered, gpio(%d)/irq(%d).\n", 1198 desc_to_gpio(idev->reset), idev->irq); 1199 1200 return 0; 1201 } 1202 1203 static int intel_remove(struct platform_device *pdev) 1204 { 1205 struct intel_device *idev = platform_get_drvdata(pdev); 1206 1207 device_wakeup_disable(&pdev->dev); 1208 1209 mutex_lock(&intel_device_list_lock); 1210 list_del(&idev->list); 1211 mutex_unlock(&intel_device_list_lock); 1212 1213 dev_info(&pdev->dev, "unregistered.\n"); 1214 1215 return 0; 1216 } 1217 1218 static struct platform_driver intel_driver = { 1219 .probe = intel_probe, 1220 .remove = intel_remove, 1221 .driver = { 1222 .name = "hci_intel", 1223 .acpi_match_table = ACPI_PTR(intel_acpi_match), 1224 .pm = &intel_pm_ops, 1225 }, 1226 }; 1227 1228 int __init intel_init(void) 1229 { 1230 platform_driver_register(&intel_driver); 1231 1232 return hci_uart_register_proto(&intel_proto); 1233 } 1234 1235 int __exit intel_deinit(void) 1236 { 1237 platform_driver_unregister(&intel_driver); 1238 1239 return hci_uart_unregister_proto(&intel_proto); 1240 } 1241