1 /* 2 * Texas Instruments' Bluetooth HCILL UART protocol 3 * 4 * HCILL (HCI Low Level) is a Texas Instruments' power management 5 * protocol extension to H4. 6 * 7 * Copyright (C) 2007 Texas Instruments, Inc. 8 * 9 * Written by Ohad Ben-Cohen <ohad@bencohen.org> 10 * 11 * Acknowledgements: 12 * This file is based on hci_h4.c, which was written 13 * by Maxim Krasnyansky and Marcel Holtmann. 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License version 2 17 * as published by the Free Software Foundation 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 27 * 28 */ 29 30 #include <linux/module.h> 31 #include <linux/kernel.h> 32 33 #include <linux/init.h> 34 #include <linux/sched.h> 35 #include <linux/types.h> 36 #include <linux/fcntl.h> 37 #include <linux/firmware.h> 38 #include <linux/interrupt.h> 39 #include <linux/ptrace.h> 40 #include <linux/poll.h> 41 42 #include <linux/slab.h> 43 #include <linux/errno.h> 44 #include <linux/string.h> 45 #include <linux/signal.h> 46 #include <linux/ioctl.h> 47 #include <linux/of.h> 48 #include <linux/serdev.h> 49 #include <linux/skbuff.h> 50 #include <linux/ti_wilink_st.h> 51 #include <linux/clk.h> 52 53 #include <net/bluetooth/bluetooth.h> 54 #include <net/bluetooth/hci_core.h> 55 #include <linux/gpio/consumer.h> 56 #include <linux/nvmem-consumer.h> 57 58 #include "hci_uart.h" 59 60 /* Vendor-specific HCI commands */ 61 #define HCI_VS_WRITE_BD_ADDR 0xfc06 62 #define HCI_VS_UPDATE_UART_HCI_BAUDRATE 0xff36 63 64 /* HCILL commands */ 65 #define HCILL_GO_TO_SLEEP_IND 0x30 66 #define HCILL_GO_TO_SLEEP_ACK 0x31 67 #define HCILL_WAKE_UP_IND 0x32 68 #define HCILL_WAKE_UP_ACK 0x33 69 70 /* HCILL states */ 71 enum hcill_states_e { 72 HCILL_ASLEEP, 73 HCILL_ASLEEP_TO_AWAKE, 74 HCILL_AWAKE, 75 HCILL_AWAKE_TO_ASLEEP 76 }; 77 78 struct ll_device { 79 struct hci_uart hu; 80 struct serdev_device *serdev; 81 struct gpio_desc *enable_gpio; 82 struct clk *ext_clk; 83 bdaddr_t bdaddr; 84 }; 85 86 struct ll_struct { 87 struct sk_buff *rx_skb; 88 struct sk_buff_head txq; 89 spinlock_t hcill_lock; /* HCILL state lock */ 90 unsigned long hcill_state; /* HCILL power state */ 91 struct sk_buff_head tx_wait_q; /* HCILL wait queue */ 92 }; 93 94 /* 95 * Builds and sends an HCILL command packet. 96 * These are very simple packets with only 1 cmd byte 97 */ 98 static int send_hcill_cmd(u8 cmd, struct hci_uart *hu) 99 { 100 int err = 0; 101 struct sk_buff *skb = NULL; 102 struct ll_struct *ll = hu->priv; 103 104 BT_DBG("hu %p cmd 0x%x", hu, cmd); 105 106 /* allocate packet */ 107 skb = bt_skb_alloc(1, GFP_ATOMIC); 108 if (!skb) { 109 BT_ERR("cannot allocate memory for HCILL packet"); 110 err = -ENOMEM; 111 goto out; 112 } 113 114 /* prepare packet */ 115 skb_put_u8(skb, cmd); 116 117 /* send packet */ 118 skb_queue_tail(&ll->txq, skb); 119 out: 120 return err; 121 } 122 123 /* Initialize protocol */ 124 static int ll_open(struct hci_uart *hu) 125 { 126 struct ll_struct *ll; 127 128 BT_DBG("hu %p", hu); 129 130 ll = kzalloc(sizeof(*ll), GFP_KERNEL); 131 if (!ll) 132 return -ENOMEM; 133 134 skb_queue_head_init(&ll->txq); 135 skb_queue_head_init(&ll->tx_wait_q); 136 spin_lock_init(&ll->hcill_lock); 137 138 ll->hcill_state = HCILL_AWAKE; 139 140 hu->priv = ll; 141 142 if (hu->serdev) { 143 struct ll_device *lldev = serdev_device_get_drvdata(hu->serdev); 144 serdev_device_open(hu->serdev); 145 if (!IS_ERR(lldev->ext_clk)) 146 clk_prepare_enable(lldev->ext_clk); 147 } 148 149 return 0; 150 } 151 152 /* Flush protocol data */ 153 static int ll_flush(struct hci_uart *hu) 154 { 155 struct ll_struct *ll = hu->priv; 156 157 BT_DBG("hu %p", hu); 158 159 skb_queue_purge(&ll->tx_wait_q); 160 skb_queue_purge(&ll->txq); 161 162 return 0; 163 } 164 165 /* Close protocol */ 166 static int ll_close(struct hci_uart *hu) 167 { 168 struct ll_struct *ll = hu->priv; 169 170 BT_DBG("hu %p", hu); 171 172 skb_queue_purge(&ll->tx_wait_q); 173 skb_queue_purge(&ll->txq); 174 175 kfree_skb(ll->rx_skb); 176 177 if (hu->serdev) { 178 struct ll_device *lldev = serdev_device_get_drvdata(hu->serdev); 179 gpiod_set_value_cansleep(lldev->enable_gpio, 0); 180 181 clk_disable_unprepare(lldev->ext_clk); 182 183 serdev_device_close(hu->serdev); 184 } 185 186 hu->priv = NULL; 187 188 kfree(ll); 189 190 return 0; 191 } 192 193 /* 194 * internal function, which does common work of the device wake up process: 195 * 1. places all pending packets (waiting in tx_wait_q list) in txq list. 196 * 2. changes internal state to HCILL_AWAKE. 197 * Note: assumes that hcill_lock spinlock is taken, 198 * shouldn't be called otherwise! 199 */ 200 static void __ll_do_awake(struct ll_struct *ll) 201 { 202 struct sk_buff *skb = NULL; 203 204 while ((skb = skb_dequeue(&ll->tx_wait_q))) 205 skb_queue_tail(&ll->txq, skb); 206 207 ll->hcill_state = HCILL_AWAKE; 208 } 209 210 /* 211 * Called upon a wake-up-indication from the device 212 */ 213 static void ll_device_want_to_wakeup(struct hci_uart *hu) 214 { 215 unsigned long flags; 216 struct ll_struct *ll = hu->priv; 217 218 BT_DBG("hu %p", hu); 219 220 /* lock hcill state */ 221 spin_lock_irqsave(&ll->hcill_lock, flags); 222 223 switch (ll->hcill_state) { 224 case HCILL_ASLEEP_TO_AWAKE: 225 /* 226 * This state means that both the host and the BRF chip 227 * have simultaneously sent a wake-up-indication packet. 228 * Traditionally, in this case, receiving a wake-up-indication 229 * was enough and an additional wake-up-ack wasn't needed. 230 * This has changed with the BRF6350, which does require an 231 * explicit wake-up-ack. Other BRF versions, which do not 232 * require an explicit ack here, do accept it, thus it is 233 * perfectly safe to always send one. 234 */ 235 BT_DBG("dual wake-up-indication"); 236 /* fall through */ 237 case HCILL_ASLEEP: 238 /* acknowledge device wake up */ 239 if (send_hcill_cmd(HCILL_WAKE_UP_ACK, hu) < 0) { 240 BT_ERR("cannot acknowledge device wake up"); 241 goto out; 242 } 243 break; 244 default: 245 /* any other state is illegal */ 246 BT_ERR("received HCILL_WAKE_UP_IND in state %ld", ll->hcill_state); 247 break; 248 } 249 250 /* send pending packets and change state to HCILL_AWAKE */ 251 __ll_do_awake(ll); 252 253 out: 254 spin_unlock_irqrestore(&ll->hcill_lock, flags); 255 256 /* actually send the packets */ 257 hci_uart_tx_wakeup(hu); 258 } 259 260 /* 261 * Called upon a sleep-indication from the device 262 */ 263 static void ll_device_want_to_sleep(struct hci_uart *hu) 264 { 265 unsigned long flags; 266 struct ll_struct *ll = hu->priv; 267 268 BT_DBG("hu %p", hu); 269 270 /* lock hcill state */ 271 spin_lock_irqsave(&ll->hcill_lock, flags); 272 273 /* sanity check */ 274 if (ll->hcill_state != HCILL_AWAKE) 275 BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", ll->hcill_state); 276 277 /* acknowledge device sleep */ 278 if (send_hcill_cmd(HCILL_GO_TO_SLEEP_ACK, hu) < 0) { 279 BT_ERR("cannot acknowledge device sleep"); 280 goto out; 281 } 282 283 /* update state */ 284 ll->hcill_state = HCILL_ASLEEP; 285 286 out: 287 spin_unlock_irqrestore(&ll->hcill_lock, flags); 288 289 /* actually send the sleep ack packet */ 290 hci_uart_tx_wakeup(hu); 291 } 292 293 /* 294 * Called upon wake-up-acknowledgement from the device 295 */ 296 static void ll_device_woke_up(struct hci_uart *hu) 297 { 298 unsigned long flags; 299 struct ll_struct *ll = hu->priv; 300 301 BT_DBG("hu %p", hu); 302 303 /* lock hcill state */ 304 spin_lock_irqsave(&ll->hcill_lock, flags); 305 306 /* sanity check */ 307 if (ll->hcill_state != HCILL_ASLEEP_TO_AWAKE) 308 BT_ERR("received HCILL_WAKE_UP_ACK in state %ld", ll->hcill_state); 309 310 /* send pending packets and change state to HCILL_AWAKE */ 311 __ll_do_awake(ll); 312 313 spin_unlock_irqrestore(&ll->hcill_lock, flags); 314 315 /* actually send the packets */ 316 hci_uart_tx_wakeup(hu); 317 } 318 319 /* Enqueue frame for transmittion (padding, crc, etc) */ 320 /* may be called from two simultaneous tasklets */ 321 static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb) 322 { 323 unsigned long flags = 0; 324 struct ll_struct *ll = hu->priv; 325 326 BT_DBG("hu %p skb %p", hu, skb); 327 328 /* Prepend skb with frame type */ 329 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 330 331 /* lock hcill state */ 332 spin_lock_irqsave(&ll->hcill_lock, flags); 333 334 /* act according to current state */ 335 switch (ll->hcill_state) { 336 case HCILL_AWAKE: 337 BT_DBG("device awake, sending normally"); 338 skb_queue_tail(&ll->txq, skb); 339 break; 340 case HCILL_ASLEEP: 341 BT_DBG("device asleep, waking up and queueing packet"); 342 /* save packet for later */ 343 skb_queue_tail(&ll->tx_wait_q, skb); 344 /* awake device */ 345 if (send_hcill_cmd(HCILL_WAKE_UP_IND, hu) < 0) { 346 BT_ERR("cannot wake up device"); 347 break; 348 } 349 ll->hcill_state = HCILL_ASLEEP_TO_AWAKE; 350 break; 351 case HCILL_ASLEEP_TO_AWAKE: 352 BT_DBG("device waking up, queueing packet"); 353 /* transient state; just keep packet for later */ 354 skb_queue_tail(&ll->tx_wait_q, skb); 355 break; 356 default: 357 BT_ERR("illegal hcill state: %ld (losing packet)", ll->hcill_state); 358 kfree_skb(skb); 359 break; 360 } 361 362 spin_unlock_irqrestore(&ll->hcill_lock, flags); 363 364 return 0; 365 } 366 367 static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 368 { 369 struct hci_uart *hu = hci_get_drvdata(hdev); 370 struct ll_struct *ll = hu->priv; 371 372 switch (hci_skb_pkt_type(skb)) { 373 case HCILL_GO_TO_SLEEP_IND: 374 BT_DBG("HCILL_GO_TO_SLEEP_IND packet"); 375 ll_device_want_to_sleep(hu); 376 break; 377 case HCILL_GO_TO_SLEEP_ACK: 378 /* shouldn't happen */ 379 bt_dev_err(hdev, "received HCILL_GO_TO_SLEEP_ACK in state %ld", 380 ll->hcill_state); 381 break; 382 case HCILL_WAKE_UP_IND: 383 BT_DBG("HCILL_WAKE_UP_IND packet"); 384 ll_device_want_to_wakeup(hu); 385 break; 386 case HCILL_WAKE_UP_ACK: 387 BT_DBG("HCILL_WAKE_UP_ACK packet"); 388 ll_device_woke_up(hu); 389 break; 390 } 391 392 kfree_skb(skb); 393 return 0; 394 } 395 396 #define LL_RECV_SLEEP_IND \ 397 .type = HCILL_GO_TO_SLEEP_IND, \ 398 .hlen = 0, \ 399 .loff = 0, \ 400 .lsize = 0, \ 401 .maxlen = 0 402 403 #define LL_RECV_SLEEP_ACK \ 404 .type = HCILL_GO_TO_SLEEP_ACK, \ 405 .hlen = 0, \ 406 .loff = 0, \ 407 .lsize = 0, \ 408 .maxlen = 0 409 410 #define LL_RECV_WAKE_IND \ 411 .type = HCILL_WAKE_UP_IND, \ 412 .hlen = 0, \ 413 .loff = 0, \ 414 .lsize = 0, \ 415 .maxlen = 0 416 417 #define LL_RECV_WAKE_ACK \ 418 .type = HCILL_WAKE_UP_ACK, \ 419 .hlen = 0, \ 420 .loff = 0, \ 421 .lsize = 0, \ 422 .maxlen = 0 423 424 static const struct h4_recv_pkt ll_recv_pkts[] = { 425 { H4_RECV_ACL, .recv = hci_recv_frame }, 426 { H4_RECV_SCO, .recv = hci_recv_frame }, 427 { H4_RECV_EVENT, .recv = hci_recv_frame }, 428 { LL_RECV_SLEEP_IND, .recv = ll_recv_frame }, 429 { LL_RECV_SLEEP_ACK, .recv = ll_recv_frame }, 430 { LL_RECV_WAKE_IND, .recv = ll_recv_frame }, 431 { LL_RECV_WAKE_ACK, .recv = ll_recv_frame }, 432 }; 433 434 /* Recv data */ 435 static int ll_recv(struct hci_uart *hu, const void *data, int count) 436 { 437 struct ll_struct *ll = hu->priv; 438 439 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 440 return -EUNATCH; 441 442 ll->rx_skb = h4_recv_buf(hu->hdev, ll->rx_skb, data, count, 443 ll_recv_pkts, ARRAY_SIZE(ll_recv_pkts)); 444 if (IS_ERR(ll->rx_skb)) { 445 int err = PTR_ERR(ll->rx_skb); 446 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 447 ll->rx_skb = NULL; 448 return err; 449 } 450 451 return count; 452 } 453 454 static struct sk_buff *ll_dequeue(struct hci_uart *hu) 455 { 456 struct ll_struct *ll = hu->priv; 457 return skb_dequeue(&ll->txq); 458 } 459 460 #if IS_ENABLED(CONFIG_SERIAL_DEV_BUS) 461 static int read_local_version(struct hci_dev *hdev) 462 { 463 int err = 0; 464 unsigned short version = 0; 465 struct sk_buff *skb; 466 struct hci_rp_read_local_version *ver; 467 468 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL, HCI_INIT_TIMEOUT); 469 if (IS_ERR(skb)) { 470 bt_dev_err(hdev, "Reading TI version information failed (%ld)", 471 PTR_ERR(skb)); 472 return PTR_ERR(skb); 473 } 474 if (skb->len != sizeof(*ver)) { 475 err = -EILSEQ; 476 goto out; 477 } 478 479 ver = (struct hci_rp_read_local_version *)skb->data; 480 if (le16_to_cpu(ver->manufacturer) != 13) { 481 err = -ENODEV; 482 goto out; 483 } 484 485 version = le16_to_cpu(ver->lmp_subver); 486 487 out: 488 if (err) bt_dev_err(hdev, "Failed to read TI version info: %d", err); 489 kfree_skb(skb); 490 return err ? err : version; 491 } 492 493 /** 494 * download_firmware - 495 * internal function which parses through the .bts firmware 496 * script file intreprets SEND, DELAY actions only as of now 497 */ 498 static int download_firmware(struct ll_device *lldev) 499 { 500 unsigned short chip, min_ver, maj_ver; 501 int version, err, len; 502 unsigned char *ptr, *action_ptr; 503 unsigned char bts_scr_name[40]; /* 40 char long bts scr name? */ 504 const struct firmware *fw; 505 struct sk_buff *skb; 506 struct hci_command *cmd; 507 508 version = read_local_version(lldev->hu.hdev); 509 if (version < 0) 510 return version; 511 512 chip = (version & 0x7C00) >> 10; 513 min_ver = (version & 0x007F); 514 maj_ver = (version & 0x0380) >> 7; 515 if (version & 0x8000) 516 maj_ver |= 0x0008; 517 518 snprintf(bts_scr_name, sizeof(bts_scr_name), 519 "ti-connectivity/TIInit_%d.%d.%d.bts", 520 chip, maj_ver, min_ver); 521 522 err = request_firmware(&fw, bts_scr_name, &lldev->serdev->dev); 523 if (err || !fw->data || !fw->size) { 524 bt_dev_err(lldev->hu.hdev, "request_firmware failed(errno %d) for %s", 525 err, bts_scr_name); 526 return -EINVAL; 527 } 528 ptr = (void *)fw->data; 529 len = fw->size; 530 /* bts_header to remove out magic number and 531 * version 532 */ 533 ptr += sizeof(struct bts_header); 534 len -= sizeof(struct bts_header); 535 536 while (len > 0 && ptr) { 537 bt_dev_dbg(lldev->hu.hdev, " action size %d, type %d ", 538 ((struct bts_action *)ptr)->size, 539 ((struct bts_action *)ptr)->type); 540 541 action_ptr = &(((struct bts_action *)ptr)->data[0]); 542 543 switch (((struct bts_action *)ptr)->type) { 544 case ACTION_SEND_COMMAND: /* action send */ 545 bt_dev_dbg(lldev->hu.hdev, "S"); 546 cmd = (struct hci_command *)action_ptr; 547 if (cmd->opcode == HCI_VS_UPDATE_UART_HCI_BAUDRATE) { 548 /* ignore remote change 549 * baud rate HCI VS command 550 */ 551 bt_dev_warn(lldev->hu.hdev, "change remote baud rate command in firmware"); 552 break; 553 } 554 if (cmd->prefix != 1) 555 bt_dev_dbg(lldev->hu.hdev, "command type %d", cmd->prefix); 556 557 skb = __hci_cmd_sync(lldev->hu.hdev, cmd->opcode, cmd->plen, &cmd->speed, HCI_INIT_TIMEOUT); 558 if (IS_ERR(skb)) { 559 bt_dev_err(lldev->hu.hdev, "send command failed"); 560 err = PTR_ERR(skb); 561 goto out_rel_fw; 562 } 563 kfree_skb(skb); 564 break; 565 case ACTION_WAIT_EVENT: /* wait */ 566 /* no need to wait as command was synchronous */ 567 bt_dev_dbg(lldev->hu.hdev, "W"); 568 break; 569 case ACTION_DELAY: /* sleep */ 570 bt_dev_info(lldev->hu.hdev, "sleep command in scr"); 571 msleep(((struct bts_action_delay *)action_ptr)->msec); 572 break; 573 } 574 len -= (sizeof(struct bts_action) + 575 ((struct bts_action *)ptr)->size); 576 ptr += sizeof(struct bts_action) + 577 ((struct bts_action *)ptr)->size; 578 } 579 580 out_rel_fw: 581 /* fw download complete */ 582 release_firmware(fw); 583 return err; 584 } 585 586 static int ll_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr) 587 { 588 bdaddr_t bdaddr_swapped; 589 struct sk_buff *skb; 590 591 /* HCI_VS_WRITE_BD_ADDR (at least on a CC2560A chip) expects the BD 592 * address to be MSB first, but bdaddr_t has the convention of being 593 * LSB first. 594 */ 595 baswap(&bdaddr_swapped, bdaddr); 596 skb = __hci_cmd_sync(hdev, HCI_VS_WRITE_BD_ADDR, sizeof(bdaddr_t), 597 &bdaddr_swapped, HCI_INIT_TIMEOUT); 598 if (!IS_ERR(skb)) 599 kfree_skb(skb); 600 601 return PTR_ERR_OR_ZERO(skb); 602 } 603 604 static int ll_setup(struct hci_uart *hu) 605 { 606 int err, retry = 3; 607 struct ll_device *lldev; 608 struct serdev_device *serdev = hu->serdev; 609 u32 speed; 610 611 if (!serdev) 612 return 0; 613 614 lldev = serdev_device_get_drvdata(serdev); 615 616 hu->hdev->set_bdaddr = ll_set_bdaddr; 617 618 serdev_device_set_flow_control(serdev, true); 619 620 do { 621 /* Reset the Bluetooth device */ 622 gpiod_set_value_cansleep(lldev->enable_gpio, 0); 623 msleep(5); 624 gpiod_set_value_cansleep(lldev->enable_gpio, 1); 625 err = serdev_device_wait_for_cts(serdev, true, 200); 626 if (err) { 627 bt_dev_err(hu->hdev, "Failed to get CTS"); 628 return err; 629 } 630 631 err = download_firmware(lldev); 632 if (!err) 633 break; 634 635 /* Toggle BT_EN and retry */ 636 bt_dev_err(hu->hdev, "download firmware failed, retrying..."); 637 } while (retry--); 638 639 if (err) 640 return err; 641 642 /* Set BD address if one was specified at probe */ 643 if (!bacmp(&lldev->bdaddr, BDADDR_NONE)) { 644 /* This means that there was an error getting the BD address 645 * during probe, so mark the device as having a bad address. 646 */ 647 set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks); 648 } else if (bacmp(&lldev->bdaddr, BDADDR_ANY)) { 649 err = ll_set_bdaddr(hu->hdev, &lldev->bdaddr); 650 if (err) 651 set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks); 652 } 653 654 /* Operational speed if any */ 655 if (hu->oper_speed) 656 speed = hu->oper_speed; 657 else if (hu->proto->oper_speed) 658 speed = hu->proto->oper_speed; 659 else 660 speed = 0; 661 662 if (speed) { 663 __le32 speed_le = cpu_to_le32(speed); 664 struct sk_buff *skb; 665 666 skb = __hci_cmd_sync(hu->hdev, HCI_VS_UPDATE_UART_HCI_BAUDRATE, 667 sizeof(speed_le), &speed_le, 668 HCI_INIT_TIMEOUT); 669 if (!IS_ERR(skb)) { 670 kfree_skb(skb); 671 serdev_device_set_baudrate(serdev, speed); 672 } 673 } 674 675 return 0; 676 } 677 678 static const struct hci_uart_proto llp; 679 680 static int hci_ti_probe(struct serdev_device *serdev) 681 { 682 struct hci_uart *hu; 683 struct ll_device *lldev; 684 struct nvmem_cell *bdaddr_cell; 685 u32 max_speed = 3000000; 686 687 lldev = devm_kzalloc(&serdev->dev, sizeof(struct ll_device), GFP_KERNEL); 688 if (!lldev) 689 return -ENOMEM; 690 hu = &lldev->hu; 691 692 serdev_device_set_drvdata(serdev, lldev); 693 lldev->serdev = hu->serdev = serdev; 694 695 lldev->enable_gpio = devm_gpiod_get_optional(&serdev->dev, "enable", GPIOD_OUT_LOW); 696 if (IS_ERR(lldev->enable_gpio)) 697 return PTR_ERR(lldev->enable_gpio); 698 699 lldev->ext_clk = devm_clk_get(&serdev->dev, "ext_clock"); 700 if (IS_ERR(lldev->ext_clk) && PTR_ERR(lldev->ext_clk) != -ENOENT) 701 return PTR_ERR(lldev->ext_clk); 702 703 of_property_read_u32(serdev->dev.of_node, "max-speed", &max_speed); 704 hci_uart_set_speeds(hu, 115200, max_speed); 705 706 /* optional BD address from nvram */ 707 bdaddr_cell = nvmem_cell_get(&serdev->dev, "bd-address"); 708 if (IS_ERR(bdaddr_cell)) { 709 int err = PTR_ERR(bdaddr_cell); 710 711 if (err == -EPROBE_DEFER) 712 return err; 713 714 /* ENOENT means there is no matching nvmem cell and ENOSYS 715 * means that nvmem is not enabled in the kernel configuration. 716 */ 717 if (err != -ENOENT && err != -ENOSYS) { 718 /* If there was some other error, give userspace a 719 * chance to fix the problem instead of failing to load 720 * the driver. Using BDADDR_NONE as a flag that is 721 * tested later in the setup function. 722 */ 723 dev_warn(&serdev->dev, 724 "Failed to get \"bd-address\" nvmem cell (%d)\n", 725 err); 726 bacpy(&lldev->bdaddr, BDADDR_NONE); 727 } 728 } else { 729 bdaddr_t *bdaddr; 730 size_t len; 731 732 bdaddr = nvmem_cell_read(bdaddr_cell, &len); 733 nvmem_cell_put(bdaddr_cell); 734 if (IS_ERR(bdaddr)) { 735 dev_err(&serdev->dev, "Failed to read nvmem bd-address\n"); 736 return PTR_ERR(bdaddr); 737 } 738 if (len != sizeof(bdaddr_t)) { 739 dev_err(&serdev->dev, "Invalid nvmem bd-address length\n"); 740 kfree(bdaddr); 741 return -EINVAL; 742 } 743 744 /* As per the device tree bindings, the value from nvmem is 745 * expected to be MSB first, but in the kernel it is expected 746 * that bdaddr_t is LSB first. 747 */ 748 baswap(&lldev->bdaddr, bdaddr); 749 kfree(bdaddr); 750 } 751 752 return hci_uart_register_device(hu, &llp); 753 } 754 755 static void hci_ti_remove(struct serdev_device *serdev) 756 { 757 struct ll_device *lldev = serdev_device_get_drvdata(serdev); 758 759 hci_uart_unregister_device(&lldev->hu); 760 } 761 762 static const struct of_device_id hci_ti_of_match[] = { 763 { .compatible = "ti,cc2560" }, 764 { .compatible = "ti,wl1271-st" }, 765 { .compatible = "ti,wl1273-st" }, 766 { .compatible = "ti,wl1281-st" }, 767 { .compatible = "ti,wl1283-st" }, 768 { .compatible = "ti,wl1285-st" }, 769 { .compatible = "ti,wl1801-st" }, 770 { .compatible = "ti,wl1805-st" }, 771 { .compatible = "ti,wl1807-st" }, 772 { .compatible = "ti,wl1831-st" }, 773 { .compatible = "ti,wl1835-st" }, 774 { .compatible = "ti,wl1837-st" }, 775 {}, 776 }; 777 MODULE_DEVICE_TABLE(of, hci_ti_of_match); 778 779 static struct serdev_device_driver hci_ti_drv = { 780 .driver = { 781 .name = "hci-ti", 782 .of_match_table = of_match_ptr(hci_ti_of_match), 783 }, 784 .probe = hci_ti_probe, 785 .remove = hci_ti_remove, 786 }; 787 #else 788 #define ll_setup NULL 789 #endif 790 791 static const struct hci_uart_proto llp = { 792 .id = HCI_UART_LL, 793 .name = "LL", 794 .setup = ll_setup, 795 .open = ll_open, 796 .close = ll_close, 797 .recv = ll_recv, 798 .enqueue = ll_enqueue, 799 .dequeue = ll_dequeue, 800 .flush = ll_flush, 801 }; 802 803 int __init ll_init(void) 804 { 805 serdev_device_driver_register(&hci_ti_drv); 806 807 return hci_uart_register_proto(&llp); 808 } 809 810 int __exit ll_deinit(void) 811 { 812 serdev_device_driver_unregister(&hci_ti_drv); 813 814 return hci_uart_unregister_proto(&llp); 815 } 816