1 // SPDX-License-Identifier: (GPL-2.0-only OR MIT) 2 /* 3 * Copyright (C) 2024 Amlogic, Inc. All rights reserved 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/delay.h> 8 #include <linux/device.h> 9 #include <linux/property.h> 10 #include <linux/of.h> 11 #include <linux/serdev.h> 12 #include <linux/clk.h> 13 #include <linux/firmware.h> 14 #include <linux/gpio/consumer.h> 15 #include <linux/regulator/consumer.h> 16 #include <net/bluetooth/bluetooth.h> 17 #include <net/bluetooth/hci_core.h> 18 #include <net/bluetooth/hci.h> 19 20 #include "hci_uart.h" 21 22 #define AML_EVT_HEAD_SIZE 4 23 #define AML_BDADDR_DEFAULT (&(bdaddr_t) {{ 0x00, 0xff, 0x00, 0x22, 0x2d, 0xae }}) 24 25 #define AML_FIRMWARE_OPERATION_SIZE (248) 26 #define AML_FIRMWARE_MAX_SIZE (512 * 1024) 27 28 /* TCI command */ 29 #define AML_TCI_CMD_READ 0xFEF0 30 #define AML_TCI_CMD_WRITE 0xFEF1 31 #define AML_TCI_CMD_UPDATE_BAUDRATE 0xFEF2 32 #define AML_TCI_CMD_HARDWARE_RESET 0xFEF2 33 #define AML_TCI_CMD_DOWNLOAD_BT_FW 0xFEF3 34 35 /* Vendor command */ 36 #define AML_BT_HCI_VENDOR_CMD 0xFC1A 37 38 /* TCI operation parameter in controller chip */ 39 #define AML_OP_UART_MODE 0x00A30128 40 #define AML_OP_EVT_ENABLE 0x00A70014 41 #define AML_OP_MEM_HARD_TRANS_EN 0x00A7000C 42 #define AML_OP_RF_CFG 0x00F03040 43 #define AML_OP_RAM_POWER_CTR 0x00F03050 44 #define AML_OP_HARDWARE_RST 0x00F03058 45 #define AML_OP_ICCM_RAM_BASE 0x00000000 46 #define AML_OP_DCCM_RAM_BASE 0x00D00000 47 48 /* UART configuration */ 49 #define AML_UART_XMIT_EN BIT(12) 50 #define AML_UART_RECV_EN BIT(13) 51 #define AML_UART_TIMEOUT_INT_EN BIT(14) 52 #define AML_UART_CLK_SOURCE 40000000 53 54 /* Controller event */ 55 #define AML_EVT_EN BIT(24) 56 57 /* RAM power control */ 58 #define AML_RAM_POWER_ON (0) 59 #define AML_RAM_POWER_OFF (1) 60 61 /* RF configuration */ 62 #define AML_RF_ANT_SINGLE BIT(28) 63 #define AML_RF_ANT_DOUBLE BIT(29) 64 65 /* Memory transaction */ 66 #define AML_MM_CTR_HARD_TRAS_EN BIT(27) 67 68 /* Controller reset */ 69 #define AML_CTR_CPU_RESET BIT(8) 70 #define AML_CTR_MAC_RESET BIT(9) 71 #define AML_CTR_PHY_RESET BIT(10) 72 73 enum { 74 FW_ICCM, 75 FW_DCCM 76 }; 77 78 struct aml_fw_len { 79 u32 iccm_len; 80 u32 dccm_len; 81 }; 82 83 struct aml_tci_rsp { 84 u8 num_cmd_packet; 85 u16 opcode; 86 u8 status; 87 } __packed; 88 89 struct aml_device_data { 90 int iccm_offset; 91 int dccm_offset; 92 bool is_coex; 93 }; 94 95 struct aml_serdev { 96 struct hci_uart serdev_hu; 97 struct device *dev; 98 struct gpio_desc *bt_en_gpio; 99 struct regulator *bt_supply; 100 struct clk *lpo_clk; 101 const struct aml_device_data *aml_dev_data; 102 const char *firmware_name; 103 }; 104 105 struct aml_data { 106 struct sk_buff *rx_skb; 107 struct sk_buff_head txq; 108 }; 109 110 static const struct h4_recv_pkt aml_recv_pkts[] = { 111 { H4_RECV_ACL, .recv = hci_recv_frame }, 112 { H4_RECV_SCO, .recv = hci_recv_frame }, 113 { H4_RECV_EVENT, .recv = hci_recv_frame }, 114 { H4_RECV_ISO, .recv = hci_recv_frame }, 115 }; 116 117 /* The TCI command is a private command, which is for setting baud rate, 118 * downloading firmware, initiating RAM. 119 * 120 * op_code | op_len | op_addr | parameter | 121 * --------|-----------------------|---------|-------------| 122 * 2B | 1B len(addr+param) | 4B | len(param) | 123 */ 124 static int aml_send_tci_cmd(struct hci_dev *hdev, u16 op_code, u32 op_addr, 125 u32 *param, u32 param_len) 126 { 127 struct aml_tci_rsp *rsp = NULL; 128 struct sk_buff *skb = NULL; 129 size_t buf_len = 0; 130 u8 *buf = NULL; 131 int err = 0; 132 133 buf_len = sizeof(op_addr) + param_len; 134 buf = kmalloc(buf_len, GFP_KERNEL); 135 if (!buf) 136 return -ENOMEM; 137 138 memcpy(buf, &op_addr, sizeof(op_addr)); 139 if (param && param_len > 0) 140 memcpy(buf + sizeof(op_addr), param, param_len); 141 142 skb = __hci_cmd_sync_ev(hdev, op_code, buf_len, buf, 143 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT); 144 if (IS_ERR(skb)) { 145 err = PTR_ERR(skb); 146 bt_dev_err(hdev, "Failed to send TCI cmd (error: %d)", err); 147 goto exit; 148 } 149 150 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp)); 151 if (!rsp) 152 goto skb_free; 153 154 if (rsp->opcode != op_code || rsp->status != 0x00) { 155 bt_dev_err(hdev, "send TCI cmd (0x%04X), response (0x%04X):(%d)", 156 op_code, rsp->opcode, rsp->status); 157 err = -EINVAL; 158 goto skb_free; 159 } 160 161 skb_free: 162 kfree_skb(skb); 163 164 exit: 165 kfree(buf); 166 return err; 167 } 168 169 static int aml_update_chip_baudrate(struct hci_dev *hdev, u32 baud) 170 { 171 u32 value; 172 173 value = ((AML_UART_CLK_SOURCE / baud) - 1) & 0x0FFF; 174 value |= AML_UART_XMIT_EN | AML_UART_RECV_EN | AML_UART_TIMEOUT_INT_EN; 175 176 return aml_send_tci_cmd(hdev, AML_TCI_CMD_UPDATE_BAUDRATE, 177 AML_OP_UART_MODE, &value, sizeof(value)); 178 } 179 180 static int aml_start_chip(struct hci_dev *hdev) 181 { 182 u32 value = 0; 183 int ret; 184 185 value = AML_MM_CTR_HARD_TRAS_EN; 186 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE, 187 AML_OP_MEM_HARD_TRANS_EN, 188 &value, sizeof(value)); 189 if (ret) 190 return ret; 191 192 /* controller hardware reset */ 193 value = AML_CTR_CPU_RESET | AML_CTR_MAC_RESET | AML_CTR_PHY_RESET; 194 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_HARDWARE_RESET, 195 AML_OP_HARDWARE_RST, 196 &value, sizeof(value)); 197 return ret; 198 } 199 200 static int aml_send_firmware_segment(struct hci_dev *hdev, 201 u8 fw_type, 202 u8 *seg, 203 u32 seg_size, 204 u32 offset) 205 { 206 u32 op_addr = 0; 207 208 if (fw_type == FW_ICCM) 209 op_addr = AML_OP_ICCM_RAM_BASE + offset; 210 else if (fw_type == FW_DCCM) 211 op_addr = AML_OP_DCCM_RAM_BASE + offset; 212 213 return aml_send_tci_cmd(hdev, AML_TCI_CMD_DOWNLOAD_BT_FW, 214 op_addr, (u32 *)seg, seg_size); 215 } 216 217 static int aml_send_firmware(struct hci_dev *hdev, u8 fw_type, 218 u8 *fw, u32 fw_size, u32 offset) 219 { 220 u32 seg_size = 0; 221 u32 seg_off = 0; 222 223 if (fw_size > AML_FIRMWARE_MAX_SIZE) { 224 bt_dev_err(hdev, 225 "Firmware size %d kB is larger than the maximum of 512 kB. Aborting.", 226 fw_size); 227 return -EINVAL; 228 } 229 while (fw_size > 0) { 230 seg_size = (fw_size > AML_FIRMWARE_OPERATION_SIZE) ? 231 AML_FIRMWARE_OPERATION_SIZE : fw_size; 232 if (aml_send_firmware_segment(hdev, fw_type, (fw + seg_off), 233 seg_size, offset)) { 234 bt_dev_err(hdev, "Failed send firmware, type: %d, offset: 0x%x", 235 fw_type, offset); 236 return -EINVAL; 237 } 238 seg_off += seg_size; 239 fw_size -= seg_size; 240 offset += seg_size; 241 } 242 return 0; 243 } 244 245 static int aml_download_firmware(struct hci_dev *hdev, const char *fw_name) 246 { 247 struct hci_uart *hu = hci_get_drvdata(hdev); 248 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev); 249 const struct firmware *firmware = NULL; 250 const struct aml_fw_len *fw_len = NULL; 251 u8 *iccm_start = NULL, *dccm_start = NULL; 252 u32 iccm_len, dccm_len; 253 u32 value = 0; 254 int ret = 0; 255 256 /* Enable firmware download event */ 257 value = AML_EVT_EN; 258 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE, 259 AML_OP_EVT_ENABLE, 260 &value, sizeof(value)); 261 if (ret) 262 goto exit; 263 264 /* RAM power on */ 265 value = AML_RAM_POWER_ON; 266 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE, 267 AML_OP_RAM_POWER_CTR, 268 &value, sizeof(value)); 269 if (ret) 270 goto exit; 271 272 /* Check RAM power status */ 273 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_READ, 274 AML_OP_RAM_POWER_CTR, NULL, 0); 275 if (ret) 276 goto exit; 277 278 ret = request_firmware(&firmware, fw_name, &hdev->dev); 279 if (ret < 0) { 280 bt_dev_err(hdev, "Failed to load <%s>:(%d)", fw_name, ret); 281 goto exit; 282 } 283 284 if (firmware->size < sizeof(*fw_len)) { 285 bt_dev_err(hdev, "Firmware is too small for its header"); 286 ret = -EINVAL; 287 goto exit; 288 } 289 290 fw_len = (const struct aml_fw_len *)firmware->data; 291 if (fw_len->iccm_len < amldev->aml_dev_data->iccm_offset || 292 fw_len->iccm_len > firmware->size - sizeof(*fw_len) || 293 fw_len->dccm_len > firmware->size - sizeof(*fw_len) - 294 fw_len->iccm_len) { 295 bt_dev_err(hdev, "Invalid firmware segment lengths"); 296 ret = -EINVAL; 297 goto exit; 298 } 299 300 /* Download ICCM */ 301 iccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len) 302 + amldev->aml_dev_data->iccm_offset; 303 iccm_len = fw_len->iccm_len - amldev->aml_dev_data->iccm_offset; 304 ret = aml_send_firmware(hdev, FW_ICCM, iccm_start, iccm_len, 305 amldev->aml_dev_data->iccm_offset); 306 if (ret) { 307 bt_dev_err(hdev, "Failed to send FW_ICCM (%d)", ret); 308 goto exit; 309 } 310 311 /* Download DCCM */ 312 dccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len) + fw_len->iccm_len; 313 dccm_len = fw_len->dccm_len; 314 ret = aml_send_firmware(hdev, FW_DCCM, dccm_start, dccm_len, 315 amldev->aml_dev_data->dccm_offset); 316 if (ret) { 317 bt_dev_err(hdev, "Failed to send FW_DCCM (%d)", ret); 318 goto exit; 319 } 320 321 /* Disable firmware download event */ 322 value = 0; 323 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE, 324 AML_OP_EVT_ENABLE, 325 &value, sizeof(value)); 326 if (ret) 327 goto exit; 328 329 exit: 330 release_firmware(firmware); 331 return ret; 332 } 333 334 static int aml_send_reset(struct hci_dev *hdev) 335 { 336 struct sk_buff *skb; 337 int err; 338 339 skb = __hci_cmd_sync_ev(hdev, HCI_OP_RESET, 0, NULL, 340 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT); 341 if (IS_ERR(skb)) { 342 err = PTR_ERR(skb); 343 bt_dev_err(hdev, "Failed to send hci reset cmd (%d)", err); 344 return err; 345 } 346 347 kfree_skb(skb); 348 return 0; 349 } 350 351 static int aml_dump_fw_version(struct hci_dev *hdev) 352 { 353 struct aml_tci_rsp *rsp = NULL; 354 struct sk_buff *skb; 355 u8 value[6] = {0}; 356 u8 *fw_ver = NULL; 357 int err = 0; 358 359 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD, sizeof(value), value, 360 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT); 361 if (IS_ERR(skb)) { 362 err = PTR_ERR(skb); 363 bt_dev_err(hdev, "Failed to get fw version (error: %d)", err); 364 return err; 365 } 366 367 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp)); 368 if (!rsp) 369 goto exit; 370 371 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) { 372 bt_dev_err(hdev, "dump version, error response (0x%04X):(%d)", 373 rsp->opcode, rsp->status); 374 err = -EINVAL; 375 goto exit; 376 } 377 378 fw_ver = (u8 *)rsp + AML_EVT_HEAD_SIZE; 379 bt_dev_info(hdev, "fw_version: date = %02x.%02x, number = 0x%02x%02x", 380 *(fw_ver + 1), *fw_ver, *(fw_ver + 3), *(fw_ver + 2)); 381 382 exit: 383 kfree_skb(skb); 384 return err; 385 } 386 387 static int aml_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr) 388 { 389 struct aml_tci_rsp *rsp = NULL; 390 struct sk_buff *skb; 391 int err = 0; 392 393 bt_dev_info(hdev, "set bdaddr (%pM)", bdaddr); 394 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD, 395 sizeof(bdaddr_t), bdaddr, 396 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT); 397 if (IS_ERR(skb)) { 398 err = PTR_ERR(skb); 399 bt_dev_err(hdev, "Failed to set bdaddr (error: %d)", err); 400 return err; 401 } 402 403 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp)); 404 if (!rsp) 405 goto exit; 406 407 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) { 408 bt_dev_err(hdev, "error response (0x%x):(%d)", rsp->opcode, rsp->status); 409 err = -EINVAL; 410 goto exit; 411 } 412 413 exit: 414 kfree_skb(skb); 415 return err; 416 } 417 418 static int aml_check_bdaddr(struct hci_dev *hdev) 419 { 420 struct hci_rp_read_bd_addr *paddr; 421 struct sk_buff *skb; 422 int err; 423 424 if (bacmp(&hdev->public_addr, BDADDR_ANY)) 425 return 0; 426 427 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL, 428 HCI_INIT_TIMEOUT); 429 if (IS_ERR(skb)) { 430 err = PTR_ERR(skb); 431 bt_dev_err(hdev, "Failed to read bdaddr (error: %d)", err); 432 return err; 433 } 434 435 paddr = skb_pull_data(skb, sizeof(struct hci_rp_read_bd_addr)); 436 if (!paddr) 437 goto exit; 438 439 if (!bacmp(&paddr->bdaddr, AML_BDADDR_DEFAULT)) { 440 bt_dev_info(hdev, "amlbt using default bdaddr (%pM)", &paddr->bdaddr); 441 hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR); 442 } 443 444 exit: 445 kfree_skb(skb); 446 return 0; 447 } 448 449 static int aml_config_rf(struct hci_dev *hdev, bool is_coex) 450 { 451 u32 value = AML_RF_ANT_DOUBLE; 452 453 /* Use a single antenna when co-existing with wifi */ 454 if (is_coex) 455 value = AML_RF_ANT_SINGLE; 456 457 return aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE, 458 AML_OP_RF_CFG, 459 &value, sizeof(value)); 460 } 461 462 static int aml_parse_dt(struct aml_serdev *amldev) 463 { 464 struct device *pdev = amldev->dev; 465 466 amldev->bt_en_gpio = devm_gpiod_get(pdev, "enable", 467 GPIOD_OUT_LOW); 468 if (IS_ERR(amldev->bt_en_gpio)) { 469 dev_err(pdev, "Failed to acquire enable gpios"); 470 return PTR_ERR(amldev->bt_en_gpio); 471 } 472 473 if (device_property_read_string(pdev, "firmware-name", 474 &amldev->firmware_name)) { 475 dev_err(pdev, "Failed to acquire firmware path"); 476 return -ENODEV; 477 } 478 479 amldev->bt_supply = devm_regulator_get(pdev, "vddio"); 480 if (IS_ERR(amldev->bt_supply)) { 481 dev_err(pdev, "Failed to acquire regulator"); 482 return PTR_ERR(amldev->bt_supply); 483 } 484 485 amldev->lpo_clk = devm_clk_get(pdev, NULL); 486 if (IS_ERR(amldev->lpo_clk)) { 487 dev_err(pdev, "Failed to acquire clock source"); 488 return PTR_ERR(amldev->lpo_clk); 489 } 490 491 return 0; 492 } 493 494 static int aml_power_on(struct aml_serdev *amldev) 495 { 496 int err; 497 498 err = regulator_enable(amldev->bt_supply); 499 if (err) { 500 dev_err(amldev->dev, "Failed to enable regulator: (%d)", err); 501 return err; 502 } 503 504 err = clk_prepare_enable(amldev->lpo_clk); 505 if (err) { 506 dev_err(amldev->dev, "Failed to enable lpo clock: (%d)", err); 507 return err; 508 } 509 510 gpiod_set_value_cansleep(amldev->bt_en_gpio, 1); 511 512 /* Wait 20ms for bluetooth controller power on */ 513 msleep(20); 514 return 0; 515 } 516 517 static int aml_power_off(struct aml_serdev *amldev) 518 { 519 gpiod_set_value_cansleep(amldev->bt_en_gpio, 0); 520 521 clk_disable_unprepare(amldev->lpo_clk); 522 523 regulator_disable(amldev->bt_supply); 524 525 return 0; 526 } 527 528 static int aml_set_baudrate(struct hci_uart *hu, unsigned int speed) 529 { 530 /* update controller baudrate */ 531 if (aml_update_chip_baudrate(hu->hdev, speed) != 0) { 532 bt_dev_err(hu->hdev, "Failed to update baud rate"); 533 return -EINVAL; 534 } 535 536 /* update local baudrate */ 537 serdev_device_set_baudrate(hu->serdev, speed); 538 539 return 0; 540 } 541 542 /* Initialize protocol */ 543 static int aml_open(struct hci_uart *hu) 544 { 545 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev); 546 struct aml_data *aml_data; 547 int err; 548 549 err = aml_parse_dt(amldev); 550 if (err) 551 return err; 552 553 if (!hci_uart_has_flow_control(hu)) { 554 bt_dev_err(hu->hdev, "no flow control"); 555 return -EOPNOTSUPP; 556 } 557 558 aml_data = kzalloc_obj(*aml_data); 559 if (!aml_data) 560 return -ENOMEM; 561 562 skb_queue_head_init(&aml_data->txq); 563 564 hu->priv = aml_data; 565 566 return 0; 567 } 568 569 static int aml_close(struct hci_uart *hu) 570 { 571 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev); 572 struct aml_data *aml_data = hu->priv; 573 574 skb_queue_purge(&aml_data->txq); 575 kfree_skb(aml_data->rx_skb); 576 kfree(aml_data); 577 578 hu->priv = NULL; 579 580 return aml_power_off(amldev); 581 } 582 583 static int aml_flush(struct hci_uart *hu) 584 { 585 struct aml_data *aml_data = hu->priv; 586 587 skb_queue_purge(&aml_data->txq); 588 589 return 0; 590 } 591 592 static int aml_setup(struct hci_uart *hu) 593 { 594 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev); 595 struct hci_dev *hdev = amldev->serdev_hu.hdev; 596 int err; 597 598 /* Setup bdaddr */ 599 hdev->set_bdaddr = aml_set_bdaddr; 600 601 err = aml_power_on(amldev); 602 if (err) 603 return err; 604 605 err = aml_set_baudrate(hu, amldev->serdev_hu.proto->oper_speed); 606 if (err) 607 return err; 608 609 err = aml_download_firmware(hdev, amldev->firmware_name); 610 if (err) 611 return err; 612 613 err = aml_config_rf(hdev, amldev->aml_dev_data->is_coex); 614 if (err) 615 return err; 616 617 err = aml_start_chip(hdev); 618 if (err) 619 return err; 620 621 /* Wait 60ms for controller startup */ 622 msleep(60); 623 624 err = aml_dump_fw_version(hdev); 625 if (err) 626 return err; 627 628 err = aml_send_reset(hdev); 629 if (err) 630 return err; 631 632 err = aml_check_bdaddr(hdev); 633 if (err) 634 return err; 635 636 return 0; 637 } 638 639 static int aml_enqueue(struct hci_uart *hu, struct sk_buff *skb) 640 { 641 struct aml_data *aml_data = hu->priv; 642 643 skb_queue_tail(&aml_data->txq, skb); 644 645 return 0; 646 } 647 648 static struct sk_buff *aml_dequeue(struct hci_uart *hu) 649 { 650 struct aml_data *aml_data = hu->priv; 651 struct sk_buff *skb; 652 653 skb = skb_dequeue(&aml_data->txq); 654 655 /* Prepend skb with frame type */ 656 if (skb) 657 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 658 659 return skb; 660 } 661 662 static int aml_recv(struct hci_uart *hu, const void *data, int count) 663 { 664 struct aml_data *aml_data = hu->priv; 665 int err; 666 667 aml_data->rx_skb = h4_recv_buf(hu, aml_data->rx_skb, data, count, 668 aml_recv_pkts, 669 ARRAY_SIZE(aml_recv_pkts)); 670 if (IS_ERR(aml_data->rx_skb)) { 671 err = PTR_ERR(aml_data->rx_skb); 672 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 673 aml_data->rx_skb = NULL; 674 return err; 675 } 676 677 return count; 678 } 679 680 static const struct hci_uart_proto aml_hci_proto = { 681 .id = HCI_UART_AML, 682 .name = "AML", 683 .init_speed = 115200, 684 .oper_speed = 4000000, 685 .open = aml_open, 686 .close = aml_close, 687 .setup = aml_setup, 688 .flush = aml_flush, 689 .recv = aml_recv, 690 .enqueue = aml_enqueue, 691 .dequeue = aml_dequeue, 692 }; 693 694 static int aml_serdev_probe(struct serdev_device *serdev) 695 { 696 struct aml_serdev *amldev; 697 int err; 698 699 amldev = devm_kzalloc(&serdev->dev, sizeof(*amldev), GFP_KERNEL); 700 if (!amldev) 701 return -ENOMEM; 702 703 amldev->serdev_hu.serdev = serdev; 704 amldev->dev = &serdev->dev; 705 serdev_device_set_drvdata(serdev, amldev); 706 707 err = hci_uart_register_device(&amldev->serdev_hu, &aml_hci_proto); 708 if (err) 709 return dev_err_probe(amldev->dev, err, 710 "Failed to register hci uart device"); 711 712 amldev->aml_dev_data = device_get_match_data(&serdev->dev); 713 714 return 0; 715 } 716 717 static void aml_serdev_remove(struct serdev_device *serdev) 718 { 719 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev); 720 721 hci_uart_unregister_device(&amldev->serdev_hu); 722 } 723 724 static void aml_serdev_shutdown(struct serdev_device *serdev) 725 { 726 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev); 727 728 aml_power_off(amldev); 729 } 730 731 static const struct aml_device_data data_w155s2 = { 732 .iccm_offset = 256 * 1024, 733 }; 734 735 static const struct aml_device_data data_w265s2 = { 736 .iccm_offset = 384 * 1024, 737 }; 738 739 static const struct of_device_id aml_bluetooth_of_match[] = { 740 { .compatible = "amlogic,w155s2-bt", .data = &data_w155s2 }, 741 { .compatible = "amlogic,w265s2-bt", .data = &data_w265s2 }, 742 { /* sentinel */ }, 743 }; 744 MODULE_DEVICE_TABLE(of, aml_bluetooth_of_match); 745 746 static struct serdev_device_driver aml_serdev_driver = { 747 .probe = aml_serdev_probe, 748 .remove = aml_serdev_remove, 749 .shutdown = aml_serdev_shutdown, 750 .driver = { 751 .name = "hci_uart_aml", 752 .of_match_table = aml_bluetooth_of_match, 753 }, 754 }; 755 756 int __init aml_init(void) 757 { 758 serdev_device_driver_register(&aml_serdev_driver); 759 760 return hci_uart_register_proto(&aml_hci_proto); 761 } 762 763 int __exit aml_deinit(void) 764 { 765 serdev_device_driver_unregister(&aml_serdev_driver); 766 767 return hci_uart_unregister_proto(&aml_hci_proto); 768 } 769