1 /* 2 * Bluetooth Software UART Qualcomm protocol 3 * 4 * HCI_IBS (HCI In-Band Sleep) is Qualcomm's power management 5 * protocol extension to H4. 6 * 7 * Copyright (C) 2007 Texas Instruments, Inc. 8 * Copyright (c) 2010, 2012 The Linux Foundation. All rights reserved. 9 * 10 * Acknowledgements: 11 * This file is based on hci_ll.c, which was... 12 * Written by Ohad Ben-Cohen <ohad@bencohen.org> 13 * which was in turn based on hci_h4.c, which was written 14 * by Maxim Krasnyansky and Marcel Holtmann. 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License version 2 18 * as published by the Free Software Foundation 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 * 29 */ 30 31 #include <linux/kernel.h> 32 #include <linux/clk.h> 33 #include <linux/debugfs.h> 34 #include <linux/gpio/consumer.h> 35 #include <linux/mod_devicetable.h> 36 #include <linux/module.h> 37 #include <linux/serdev.h> 38 39 #include <net/bluetooth/bluetooth.h> 40 #include <net/bluetooth/hci_core.h> 41 42 #include "hci_uart.h" 43 #include "btqca.h" 44 45 /* HCI_IBS protocol messages */ 46 #define HCI_IBS_SLEEP_IND 0xFE 47 #define HCI_IBS_WAKE_IND 0xFD 48 #define HCI_IBS_WAKE_ACK 0xFC 49 #define HCI_MAX_IBS_SIZE 10 50 51 /* Controller states */ 52 #define STATE_IN_BAND_SLEEP_ENABLED 1 53 54 #define IBS_WAKE_RETRANS_TIMEOUT_MS 100 55 #define IBS_TX_IDLE_TIMEOUT_MS 2000 56 #define BAUDRATE_SETTLE_TIMEOUT_MS 300 57 58 /* susclk rate */ 59 #define SUSCLK_RATE_32KHZ 32768 60 61 /* HCI_IBS transmit side sleep protocol states */ 62 enum tx_ibs_states { 63 HCI_IBS_TX_ASLEEP, 64 HCI_IBS_TX_WAKING, 65 HCI_IBS_TX_AWAKE, 66 }; 67 68 /* HCI_IBS receive side sleep protocol states */ 69 enum rx_states { 70 HCI_IBS_RX_ASLEEP, 71 HCI_IBS_RX_AWAKE, 72 }; 73 74 /* HCI_IBS transmit and receive side clock state vote */ 75 enum hci_ibs_clock_state_vote { 76 HCI_IBS_VOTE_STATS_UPDATE, 77 HCI_IBS_TX_VOTE_CLOCK_ON, 78 HCI_IBS_TX_VOTE_CLOCK_OFF, 79 HCI_IBS_RX_VOTE_CLOCK_ON, 80 HCI_IBS_RX_VOTE_CLOCK_OFF, 81 }; 82 83 struct qca_data { 84 struct hci_uart *hu; 85 struct sk_buff *rx_skb; 86 struct sk_buff_head txq; 87 struct sk_buff_head tx_wait_q; /* HCI_IBS wait queue */ 88 spinlock_t hci_ibs_lock; /* HCI_IBS state lock */ 89 u8 tx_ibs_state; /* HCI_IBS transmit side power state*/ 90 u8 rx_ibs_state; /* HCI_IBS receive side power state */ 91 bool tx_vote; /* Clock must be on for TX */ 92 bool rx_vote; /* Clock must be on for RX */ 93 struct timer_list tx_idle_timer; 94 u32 tx_idle_delay; 95 struct timer_list wake_retrans_timer; 96 u32 wake_retrans; 97 struct workqueue_struct *workqueue; 98 struct work_struct ws_awake_rx; 99 struct work_struct ws_awake_device; 100 struct work_struct ws_rx_vote_off; 101 struct work_struct ws_tx_vote_off; 102 unsigned long flags; 103 104 /* For debugging purpose */ 105 u64 ibs_sent_wacks; 106 u64 ibs_sent_slps; 107 u64 ibs_sent_wakes; 108 u64 ibs_recv_wacks; 109 u64 ibs_recv_slps; 110 u64 ibs_recv_wakes; 111 u64 vote_last_jif; 112 u32 vote_on_ms; 113 u32 vote_off_ms; 114 u64 tx_votes_on; 115 u64 rx_votes_on; 116 u64 tx_votes_off; 117 u64 rx_votes_off; 118 u64 votes_on; 119 u64 votes_off; 120 }; 121 122 struct qca_serdev { 123 struct hci_uart serdev_hu; 124 struct gpio_desc *bt_en; 125 struct clk *susclk; 126 }; 127 128 static void __serial_clock_on(struct tty_struct *tty) 129 { 130 /* TODO: Some chipset requires to enable UART clock on client 131 * side to save power consumption or manual work is required. 132 * Please put your code to control UART clock here if needed 133 */ 134 } 135 136 static void __serial_clock_off(struct tty_struct *tty) 137 { 138 /* TODO: Some chipset requires to disable UART clock on client 139 * side to save power consumption or manual work is required. 140 * Please put your code to control UART clock off here if needed 141 */ 142 } 143 144 /* serial_clock_vote needs to be called with the ibs lock held */ 145 static void serial_clock_vote(unsigned long vote, struct hci_uart *hu) 146 { 147 struct qca_data *qca = hu->priv; 148 unsigned int diff; 149 150 bool old_vote = (qca->tx_vote | qca->rx_vote); 151 bool new_vote; 152 153 switch (vote) { 154 case HCI_IBS_VOTE_STATS_UPDATE: 155 diff = jiffies_to_msecs(jiffies - qca->vote_last_jif); 156 157 if (old_vote) 158 qca->vote_off_ms += diff; 159 else 160 qca->vote_on_ms += diff; 161 return; 162 163 case HCI_IBS_TX_VOTE_CLOCK_ON: 164 qca->tx_vote = true; 165 qca->tx_votes_on++; 166 new_vote = true; 167 break; 168 169 case HCI_IBS_RX_VOTE_CLOCK_ON: 170 qca->rx_vote = true; 171 qca->rx_votes_on++; 172 new_vote = true; 173 break; 174 175 case HCI_IBS_TX_VOTE_CLOCK_OFF: 176 qca->tx_vote = false; 177 qca->tx_votes_off++; 178 new_vote = qca->rx_vote | qca->tx_vote; 179 break; 180 181 case HCI_IBS_RX_VOTE_CLOCK_OFF: 182 qca->rx_vote = false; 183 qca->rx_votes_off++; 184 new_vote = qca->rx_vote | qca->tx_vote; 185 break; 186 187 default: 188 BT_ERR("Voting irregularity"); 189 return; 190 } 191 192 if (new_vote != old_vote) { 193 if (new_vote) 194 __serial_clock_on(hu->tty); 195 else 196 __serial_clock_off(hu->tty); 197 198 BT_DBG("Vote serial clock %s(%s)", new_vote ? "true" : "false", 199 vote ? "true" : "false"); 200 201 diff = jiffies_to_msecs(jiffies - qca->vote_last_jif); 202 203 if (new_vote) { 204 qca->votes_on++; 205 qca->vote_off_ms += diff; 206 } else { 207 qca->votes_off++; 208 qca->vote_on_ms += diff; 209 } 210 qca->vote_last_jif = jiffies; 211 } 212 } 213 214 /* Builds and sends an HCI_IBS command packet. 215 * These are very simple packets with only 1 cmd byte. 216 */ 217 static int send_hci_ibs_cmd(u8 cmd, struct hci_uart *hu) 218 { 219 int err = 0; 220 struct sk_buff *skb = NULL; 221 struct qca_data *qca = hu->priv; 222 223 BT_DBG("hu %p send hci ibs cmd 0x%x", hu, cmd); 224 225 skb = bt_skb_alloc(1, GFP_ATOMIC); 226 if (!skb) { 227 BT_ERR("Failed to allocate memory for HCI_IBS packet"); 228 return -ENOMEM; 229 } 230 231 /* Assign HCI_IBS type */ 232 skb_put_u8(skb, cmd); 233 234 skb_queue_tail(&qca->txq, skb); 235 236 return err; 237 } 238 239 static void qca_wq_awake_device(struct work_struct *work) 240 { 241 struct qca_data *qca = container_of(work, struct qca_data, 242 ws_awake_device); 243 struct hci_uart *hu = qca->hu; 244 unsigned long retrans_delay; 245 246 BT_DBG("hu %p wq awake device", hu); 247 248 /* Vote for serial clock */ 249 serial_clock_vote(HCI_IBS_TX_VOTE_CLOCK_ON, hu); 250 251 spin_lock(&qca->hci_ibs_lock); 252 253 /* Send wake indication to device */ 254 if (send_hci_ibs_cmd(HCI_IBS_WAKE_IND, hu) < 0) 255 BT_ERR("Failed to send WAKE to device"); 256 257 qca->ibs_sent_wakes++; 258 259 /* Start retransmit timer */ 260 retrans_delay = msecs_to_jiffies(qca->wake_retrans); 261 mod_timer(&qca->wake_retrans_timer, jiffies + retrans_delay); 262 263 spin_unlock(&qca->hci_ibs_lock); 264 265 /* Actually send the packets */ 266 hci_uart_tx_wakeup(hu); 267 } 268 269 static void qca_wq_awake_rx(struct work_struct *work) 270 { 271 struct qca_data *qca = container_of(work, struct qca_data, 272 ws_awake_rx); 273 struct hci_uart *hu = qca->hu; 274 275 BT_DBG("hu %p wq awake rx", hu); 276 277 serial_clock_vote(HCI_IBS_RX_VOTE_CLOCK_ON, hu); 278 279 spin_lock(&qca->hci_ibs_lock); 280 qca->rx_ibs_state = HCI_IBS_RX_AWAKE; 281 282 /* Always acknowledge device wake up, 283 * sending IBS message doesn't count as TX ON. 284 */ 285 if (send_hci_ibs_cmd(HCI_IBS_WAKE_ACK, hu) < 0) 286 BT_ERR("Failed to acknowledge device wake up"); 287 288 qca->ibs_sent_wacks++; 289 290 spin_unlock(&qca->hci_ibs_lock); 291 292 /* Actually send the packets */ 293 hci_uart_tx_wakeup(hu); 294 } 295 296 static void qca_wq_serial_rx_clock_vote_off(struct work_struct *work) 297 { 298 struct qca_data *qca = container_of(work, struct qca_data, 299 ws_rx_vote_off); 300 struct hci_uart *hu = qca->hu; 301 302 BT_DBG("hu %p rx clock vote off", hu); 303 304 serial_clock_vote(HCI_IBS_RX_VOTE_CLOCK_OFF, hu); 305 } 306 307 static void qca_wq_serial_tx_clock_vote_off(struct work_struct *work) 308 { 309 struct qca_data *qca = container_of(work, struct qca_data, 310 ws_tx_vote_off); 311 struct hci_uart *hu = qca->hu; 312 313 BT_DBG("hu %p tx clock vote off", hu); 314 315 /* Run HCI tx handling unlocked */ 316 hci_uart_tx_wakeup(hu); 317 318 /* Now that message queued to tty driver, vote for tty clocks off. 319 * It is up to the tty driver to pend the clocks off until tx done. 320 */ 321 serial_clock_vote(HCI_IBS_TX_VOTE_CLOCK_OFF, hu); 322 } 323 324 static void hci_ibs_tx_idle_timeout(struct timer_list *t) 325 { 326 struct qca_data *qca = from_timer(qca, t, tx_idle_timer); 327 struct hci_uart *hu = qca->hu; 328 unsigned long flags; 329 330 BT_DBG("hu %p idle timeout in %d state", hu, qca->tx_ibs_state); 331 332 spin_lock_irqsave_nested(&qca->hci_ibs_lock, 333 flags, SINGLE_DEPTH_NESTING); 334 335 switch (qca->tx_ibs_state) { 336 case HCI_IBS_TX_AWAKE: 337 /* TX_IDLE, go to SLEEP */ 338 if (send_hci_ibs_cmd(HCI_IBS_SLEEP_IND, hu) < 0) { 339 BT_ERR("Failed to send SLEEP to device"); 340 break; 341 } 342 qca->tx_ibs_state = HCI_IBS_TX_ASLEEP; 343 qca->ibs_sent_slps++; 344 queue_work(qca->workqueue, &qca->ws_tx_vote_off); 345 break; 346 347 case HCI_IBS_TX_ASLEEP: 348 case HCI_IBS_TX_WAKING: 349 /* Fall through */ 350 351 default: 352 BT_ERR("Spurious timeout tx state %d", qca->tx_ibs_state); 353 break; 354 } 355 356 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 357 } 358 359 static void hci_ibs_wake_retrans_timeout(struct timer_list *t) 360 { 361 struct qca_data *qca = from_timer(qca, t, wake_retrans_timer); 362 struct hci_uart *hu = qca->hu; 363 unsigned long flags, retrans_delay; 364 bool retransmit = false; 365 366 BT_DBG("hu %p wake retransmit timeout in %d state", 367 hu, qca->tx_ibs_state); 368 369 spin_lock_irqsave_nested(&qca->hci_ibs_lock, 370 flags, SINGLE_DEPTH_NESTING); 371 372 switch (qca->tx_ibs_state) { 373 case HCI_IBS_TX_WAKING: 374 /* No WAKE_ACK, retransmit WAKE */ 375 retransmit = true; 376 if (send_hci_ibs_cmd(HCI_IBS_WAKE_IND, hu) < 0) { 377 BT_ERR("Failed to acknowledge device wake up"); 378 break; 379 } 380 qca->ibs_sent_wakes++; 381 retrans_delay = msecs_to_jiffies(qca->wake_retrans); 382 mod_timer(&qca->wake_retrans_timer, jiffies + retrans_delay); 383 break; 384 385 case HCI_IBS_TX_ASLEEP: 386 case HCI_IBS_TX_AWAKE: 387 /* Fall through */ 388 389 default: 390 BT_ERR("Spurious timeout tx state %d", qca->tx_ibs_state); 391 break; 392 } 393 394 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 395 396 if (retransmit) 397 hci_uart_tx_wakeup(hu); 398 } 399 400 /* Initialize protocol */ 401 static int qca_open(struct hci_uart *hu) 402 { 403 struct qca_serdev *qcadev; 404 struct qca_data *qca; 405 406 BT_DBG("hu %p qca_open", hu); 407 408 qca = kzalloc(sizeof(struct qca_data), GFP_ATOMIC); 409 if (!qca) 410 return -ENOMEM; 411 412 skb_queue_head_init(&qca->txq); 413 skb_queue_head_init(&qca->tx_wait_q); 414 spin_lock_init(&qca->hci_ibs_lock); 415 qca->workqueue = alloc_ordered_workqueue("qca_wq", 0); 416 if (!qca->workqueue) { 417 BT_ERR("QCA Workqueue not initialized properly"); 418 kfree(qca); 419 return -ENOMEM; 420 } 421 422 INIT_WORK(&qca->ws_awake_rx, qca_wq_awake_rx); 423 INIT_WORK(&qca->ws_awake_device, qca_wq_awake_device); 424 INIT_WORK(&qca->ws_rx_vote_off, qca_wq_serial_rx_clock_vote_off); 425 INIT_WORK(&qca->ws_tx_vote_off, qca_wq_serial_tx_clock_vote_off); 426 427 qca->hu = hu; 428 429 /* Assume we start with both sides asleep -- extra wakes OK */ 430 qca->tx_ibs_state = HCI_IBS_TX_ASLEEP; 431 qca->rx_ibs_state = HCI_IBS_RX_ASLEEP; 432 433 /* clocks actually on, but we start votes off */ 434 qca->tx_vote = false; 435 qca->rx_vote = false; 436 qca->flags = 0; 437 438 qca->ibs_sent_wacks = 0; 439 qca->ibs_sent_slps = 0; 440 qca->ibs_sent_wakes = 0; 441 qca->ibs_recv_wacks = 0; 442 qca->ibs_recv_slps = 0; 443 qca->ibs_recv_wakes = 0; 444 qca->vote_last_jif = jiffies; 445 qca->vote_on_ms = 0; 446 qca->vote_off_ms = 0; 447 qca->votes_on = 0; 448 qca->votes_off = 0; 449 qca->tx_votes_on = 0; 450 qca->tx_votes_off = 0; 451 qca->rx_votes_on = 0; 452 qca->rx_votes_off = 0; 453 454 hu->priv = qca; 455 456 timer_setup(&qca->wake_retrans_timer, hci_ibs_wake_retrans_timeout, 0); 457 qca->wake_retrans = IBS_WAKE_RETRANS_TIMEOUT_MS; 458 459 timer_setup(&qca->tx_idle_timer, hci_ibs_tx_idle_timeout, 0); 460 qca->tx_idle_delay = IBS_TX_IDLE_TIMEOUT_MS; 461 462 if (hu->serdev) { 463 serdev_device_open(hu->serdev); 464 465 qcadev = serdev_device_get_drvdata(hu->serdev); 466 gpiod_set_value_cansleep(qcadev->bt_en, 1); 467 } 468 469 BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u", 470 qca->tx_idle_delay, qca->wake_retrans); 471 472 return 0; 473 } 474 475 static void qca_debugfs_init(struct hci_dev *hdev) 476 { 477 struct hci_uart *hu = hci_get_drvdata(hdev); 478 struct qca_data *qca = hu->priv; 479 struct dentry *ibs_dir; 480 umode_t mode; 481 482 if (!hdev->debugfs) 483 return; 484 485 ibs_dir = debugfs_create_dir("ibs", hdev->debugfs); 486 487 /* read only */ 488 mode = S_IRUGO; 489 debugfs_create_u8("tx_ibs_state", mode, ibs_dir, &qca->tx_ibs_state); 490 debugfs_create_u8("rx_ibs_state", mode, ibs_dir, &qca->rx_ibs_state); 491 debugfs_create_u64("ibs_sent_sleeps", mode, ibs_dir, 492 &qca->ibs_sent_slps); 493 debugfs_create_u64("ibs_sent_wakes", mode, ibs_dir, 494 &qca->ibs_sent_wakes); 495 debugfs_create_u64("ibs_sent_wake_acks", mode, ibs_dir, 496 &qca->ibs_sent_wacks); 497 debugfs_create_u64("ibs_recv_sleeps", mode, ibs_dir, 498 &qca->ibs_recv_slps); 499 debugfs_create_u64("ibs_recv_wakes", mode, ibs_dir, 500 &qca->ibs_recv_wakes); 501 debugfs_create_u64("ibs_recv_wake_acks", mode, ibs_dir, 502 &qca->ibs_recv_wacks); 503 debugfs_create_bool("tx_vote", mode, ibs_dir, &qca->tx_vote); 504 debugfs_create_u64("tx_votes_on", mode, ibs_dir, &qca->tx_votes_on); 505 debugfs_create_u64("tx_votes_off", mode, ibs_dir, &qca->tx_votes_off); 506 debugfs_create_bool("rx_vote", mode, ibs_dir, &qca->rx_vote); 507 debugfs_create_u64("rx_votes_on", mode, ibs_dir, &qca->rx_votes_on); 508 debugfs_create_u64("rx_votes_off", mode, ibs_dir, &qca->rx_votes_off); 509 debugfs_create_u64("votes_on", mode, ibs_dir, &qca->votes_on); 510 debugfs_create_u64("votes_off", mode, ibs_dir, &qca->votes_off); 511 debugfs_create_u32("vote_on_ms", mode, ibs_dir, &qca->vote_on_ms); 512 debugfs_create_u32("vote_off_ms", mode, ibs_dir, &qca->vote_off_ms); 513 514 /* read/write */ 515 mode = S_IRUGO | S_IWUSR; 516 debugfs_create_u32("wake_retrans", mode, ibs_dir, &qca->wake_retrans); 517 debugfs_create_u32("tx_idle_delay", mode, ibs_dir, 518 &qca->tx_idle_delay); 519 } 520 521 /* Flush protocol data */ 522 static int qca_flush(struct hci_uart *hu) 523 { 524 struct qca_data *qca = hu->priv; 525 526 BT_DBG("hu %p qca flush", hu); 527 528 skb_queue_purge(&qca->tx_wait_q); 529 skb_queue_purge(&qca->txq); 530 531 return 0; 532 } 533 534 /* Close protocol */ 535 static int qca_close(struct hci_uart *hu) 536 { 537 struct qca_serdev *qcadev; 538 struct qca_data *qca = hu->priv; 539 540 BT_DBG("hu %p qca close", hu); 541 542 serial_clock_vote(HCI_IBS_VOTE_STATS_UPDATE, hu); 543 544 skb_queue_purge(&qca->tx_wait_q); 545 skb_queue_purge(&qca->txq); 546 del_timer(&qca->tx_idle_timer); 547 del_timer(&qca->wake_retrans_timer); 548 destroy_workqueue(qca->workqueue); 549 qca->hu = NULL; 550 551 if (hu->serdev) { 552 serdev_device_close(hu->serdev); 553 554 qcadev = serdev_device_get_drvdata(hu->serdev); 555 gpiod_set_value_cansleep(qcadev->bt_en, 0); 556 } 557 558 kfree_skb(qca->rx_skb); 559 560 hu->priv = NULL; 561 562 kfree(qca); 563 564 return 0; 565 } 566 567 /* Called upon a wake-up-indication from the device. 568 */ 569 static void device_want_to_wakeup(struct hci_uart *hu) 570 { 571 unsigned long flags; 572 struct qca_data *qca = hu->priv; 573 574 BT_DBG("hu %p want to wake up", hu); 575 576 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 577 578 qca->ibs_recv_wakes++; 579 580 switch (qca->rx_ibs_state) { 581 case HCI_IBS_RX_ASLEEP: 582 /* Make sure clock is on - we may have turned clock off since 583 * receiving the wake up indicator awake rx clock. 584 */ 585 queue_work(qca->workqueue, &qca->ws_awake_rx); 586 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 587 return; 588 589 case HCI_IBS_RX_AWAKE: 590 /* Always acknowledge device wake up, 591 * sending IBS message doesn't count as TX ON. 592 */ 593 if (send_hci_ibs_cmd(HCI_IBS_WAKE_ACK, hu) < 0) { 594 BT_ERR("Failed to acknowledge device wake up"); 595 break; 596 } 597 qca->ibs_sent_wacks++; 598 break; 599 600 default: 601 /* Any other state is illegal */ 602 BT_ERR("Received HCI_IBS_WAKE_IND in rx state %d", 603 qca->rx_ibs_state); 604 break; 605 } 606 607 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 608 609 /* Actually send the packets */ 610 hci_uart_tx_wakeup(hu); 611 } 612 613 /* Called upon a sleep-indication from the device. 614 */ 615 static void device_want_to_sleep(struct hci_uart *hu) 616 { 617 unsigned long flags; 618 struct qca_data *qca = hu->priv; 619 620 BT_DBG("hu %p want to sleep", hu); 621 622 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 623 624 qca->ibs_recv_slps++; 625 626 switch (qca->rx_ibs_state) { 627 case HCI_IBS_RX_AWAKE: 628 /* Update state */ 629 qca->rx_ibs_state = HCI_IBS_RX_ASLEEP; 630 /* Vote off rx clock under workqueue */ 631 queue_work(qca->workqueue, &qca->ws_rx_vote_off); 632 break; 633 634 case HCI_IBS_RX_ASLEEP: 635 /* Fall through */ 636 637 default: 638 /* Any other state is illegal */ 639 BT_ERR("Received HCI_IBS_SLEEP_IND in rx state %d", 640 qca->rx_ibs_state); 641 break; 642 } 643 644 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 645 } 646 647 /* Called upon wake-up-acknowledgement from the device 648 */ 649 static void device_woke_up(struct hci_uart *hu) 650 { 651 unsigned long flags, idle_delay; 652 struct qca_data *qca = hu->priv; 653 struct sk_buff *skb = NULL; 654 655 BT_DBG("hu %p woke up", hu); 656 657 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 658 659 qca->ibs_recv_wacks++; 660 661 switch (qca->tx_ibs_state) { 662 case HCI_IBS_TX_AWAKE: 663 /* Expect one if we send 2 WAKEs */ 664 BT_DBG("Received HCI_IBS_WAKE_ACK in tx state %d", 665 qca->tx_ibs_state); 666 break; 667 668 case HCI_IBS_TX_WAKING: 669 /* Send pending packets */ 670 while ((skb = skb_dequeue(&qca->tx_wait_q))) 671 skb_queue_tail(&qca->txq, skb); 672 673 /* Switch timers and change state to HCI_IBS_TX_AWAKE */ 674 del_timer(&qca->wake_retrans_timer); 675 idle_delay = msecs_to_jiffies(qca->tx_idle_delay); 676 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay); 677 qca->tx_ibs_state = HCI_IBS_TX_AWAKE; 678 break; 679 680 case HCI_IBS_TX_ASLEEP: 681 /* Fall through */ 682 683 default: 684 BT_ERR("Received HCI_IBS_WAKE_ACK in tx state %d", 685 qca->tx_ibs_state); 686 break; 687 } 688 689 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 690 691 /* Actually send the packets */ 692 hci_uart_tx_wakeup(hu); 693 } 694 695 /* Enqueue frame for transmittion (padding, crc, etc) may be called from 696 * two simultaneous tasklets. 697 */ 698 static int qca_enqueue(struct hci_uart *hu, struct sk_buff *skb) 699 { 700 unsigned long flags = 0, idle_delay; 701 struct qca_data *qca = hu->priv; 702 703 BT_DBG("hu %p qca enq skb %p tx_ibs_state %d", hu, skb, 704 qca->tx_ibs_state); 705 706 /* Prepend skb with frame type */ 707 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 708 709 /* Don't go to sleep in middle of patch download or 710 * Out-Of-Band(GPIOs control) sleep is selected. 711 */ 712 if (!test_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags)) { 713 skb_queue_tail(&qca->txq, skb); 714 return 0; 715 } 716 717 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 718 719 /* Act according to current state */ 720 switch (qca->tx_ibs_state) { 721 case HCI_IBS_TX_AWAKE: 722 BT_DBG("Device awake, sending normally"); 723 skb_queue_tail(&qca->txq, skb); 724 idle_delay = msecs_to_jiffies(qca->tx_idle_delay); 725 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay); 726 break; 727 728 case HCI_IBS_TX_ASLEEP: 729 BT_DBG("Device asleep, waking up and queueing packet"); 730 /* Save packet for later */ 731 skb_queue_tail(&qca->tx_wait_q, skb); 732 733 qca->tx_ibs_state = HCI_IBS_TX_WAKING; 734 /* Schedule a work queue to wake up device */ 735 queue_work(qca->workqueue, &qca->ws_awake_device); 736 break; 737 738 case HCI_IBS_TX_WAKING: 739 BT_DBG("Device waking up, queueing packet"); 740 /* Transient state; just keep packet for later */ 741 skb_queue_tail(&qca->tx_wait_q, skb); 742 break; 743 744 default: 745 BT_ERR("Illegal tx state: %d (losing packet)", 746 qca->tx_ibs_state); 747 kfree_skb(skb); 748 break; 749 } 750 751 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 752 753 return 0; 754 } 755 756 static int qca_ibs_sleep_ind(struct hci_dev *hdev, struct sk_buff *skb) 757 { 758 struct hci_uart *hu = hci_get_drvdata(hdev); 759 760 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_SLEEP_IND); 761 762 device_want_to_sleep(hu); 763 764 kfree_skb(skb); 765 return 0; 766 } 767 768 static int qca_ibs_wake_ind(struct hci_dev *hdev, struct sk_buff *skb) 769 { 770 struct hci_uart *hu = hci_get_drvdata(hdev); 771 772 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_IND); 773 774 device_want_to_wakeup(hu); 775 776 kfree_skb(skb); 777 return 0; 778 } 779 780 static int qca_ibs_wake_ack(struct hci_dev *hdev, struct sk_buff *skb) 781 { 782 struct hci_uart *hu = hci_get_drvdata(hdev); 783 784 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_ACK); 785 786 device_woke_up(hu); 787 788 kfree_skb(skb); 789 return 0; 790 } 791 792 #define QCA_IBS_SLEEP_IND_EVENT \ 793 .type = HCI_IBS_SLEEP_IND, \ 794 .hlen = 0, \ 795 .loff = 0, \ 796 .lsize = 0, \ 797 .maxlen = HCI_MAX_IBS_SIZE 798 799 #define QCA_IBS_WAKE_IND_EVENT \ 800 .type = HCI_IBS_WAKE_IND, \ 801 .hlen = 0, \ 802 .loff = 0, \ 803 .lsize = 0, \ 804 .maxlen = HCI_MAX_IBS_SIZE 805 806 #define QCA_IBS_WAKE_ACK_EVENT \ 807 .type = HCI_IBS_WAKE_ACK, \ 808 .hlen = 0, \ 809 .loff = 0, \ 810 .lsize = 0, \ 811 .maxlen = HCI_MAX_IBS_SIZE 812 813 static const struct h4_recv_pkt qca_recv_pkts[] = { 814 { H4_RECV_ACL, .recv = hci_recv_frame }, 815 { H4_RECV_SCO, .recv = hci_recv_frame }, 816 { H4_RECV_EVENT, .recv = hci_recv_frame }, 817 { QCA_IBS_WAKE_IND_EVENT, .recv = qca_ibs_wake_ind }, 818 { QCA_IBS_WAKE_ACK_EVENT, .recv = qca_ibs_wake_ack }, 819 { QCA_IBS_SLEEP_IND_EVENT, .recv = qca_ibs_sleep_ind }, 820 }; 821 822 static int qca_recv(struct hci_uart *hu, const void *data, int count) 823 { 824 struct qca_data *qca = hu->priv; 825 826 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 827 return -EUNATCH; 828 829 qca->rx_skb = h4_recv_buf(hu->hdev, qca->rx_skb, data, count, 830 qca_recv_pkts, ARRAY_SIZE(qca_recv_pkts)); 831 if (IS_ERR(qca->rx_skb)) { 832 int err = PTR_ERR(qca->rx_skb); 833 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 834 qca->rx_skb = NULL; 835 return err; 836 } 837 838 return count; 839 } 840 841 static struct sk_buff *qca_dequeue(struct hci_uart *hu) 842 { 843 struct qca_data *qca = hu->priv; 844 845 return skb_dequeue(&qca->txq); 846 } 847 848 static uint8_t qca_get_baudrate_value(int speed) 849 { 850 switch (speed) { 851 case 9600: 852 return QCA_BAUDRATE_9600; 853 case 19200: 854 return QCA_BAUDRATE_19200; 855 case 38400: 856 return QCA_BAUDRATE_38400; 857 case 57600: 858 return QCA_BAUDRATE_57600; 859 case 115200: 860 return QCA_BAUDRATE_115200; 861 case 230400: 862 return QCA_BAUDRATE_230400; 863 case 460800: 864 return QCA_BAUDRATE_460800; 865 case 500000: 866 return QCA_BAUDRATE_500000; 867 case 921600: 868 return QCA_BAUDRATE_921600; 869 case 1000000: 870 return QCA_BAUDRATE_1000000; 871 case 2000000: 872 return QCA_BAUDRATE_2000000; 873 case 3000000: 874 return QCA_BAUDRATE_3000000; 875 case 3500000: 876 return QCA_BAUDRATE_3500000; 877 default: 878 return QCA_BAUDRATE_115200; 879 } 880 } 881 882 static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate) 883 { 884 struct hci_uart *hu = hci_get_drvdata(hdev); 885 struct qca_data *qca = hu->priv; 886 struct sk_buff *skb; 887 u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 }; 888 889 if (baudrate > QCA_BAUDRATE_3000000) 890 return -EINVAL; 891 892 cmd[4] = baudrate; 893 894 skb = bt_skb_alloc(sizeof(cmd), GFP_ATOMIC); 895 if (!skb) { 896 bt_dev_err(hdev, "Failed to allocate baudrate packet"); 897 return -ENOMEM; 898 } 899 900 /* Assign commands to change baudrate and packet type. */ 901 skb_put_data(skb, cmd, sizeof(cmd)); 902 hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 903 904 skb_queue_tail(&qca->txq, skb); 905 hci_uart_tx_wakeup(hu); 906 907 /* wait 300ms to change new baudrate on controller side 908 * controller will come back after they receive this HCI command 909 * then host can communicate with new baudrate to controller 910 */ 911 set_current_state(TASK_UNINTERRUPTIBLE); 912 schedule_timeout(msecs_to_jiffies(BAUDRATE_SETTLE_TIMEOUT_MS)); 913 set_current_state(TASK_RUNNING); 914 915 return 0; 916 } 917 918 static inline void host_set_baudrate(struct hci_uart *hu, unsigned int speed) 919 { 920 if (hu->serdev) 921 serdev_device_set_baudrate(hu->serdev, speed); 922 else 923 hci_uart_set_baudrate(hu, speed); 924 } 925 926 static int qca_setup(struct hci_uart *hu) 927 { 928 struct hci_dev *hdev = hu->hdev; 929 struct qca_data *qca = hu->priv; 930 unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200; 931 int ret; 932 933 bt_dev_info(hdev, "ROME setup"); 934 935 /* Patch downloading has to be done without IBS mode */ 936 clear_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags); 937 938 /* Setup initial baudrate */ 939 speed = 0; 940 if (hu->init_speed) 941 speed = hu->init_speed; 942 else if (hu->proto->init_speed) 943 speed = hu->proto->init_speed; 944 945 if (speed) 946 host_set_baudrate(hu, speed); 947 948 /* Setup user speed if needed */ 949 speed = 0; 950 if (hu->oper_speed) 951 speed = hu->oper_speed; 952 else if (hu->proto->oper_speed) 953 speed = hu->proto->oper_speed; 954 955 if (speed) { 956 qca_baudrate = qca_get_baudrate_value(speed); 957 958 bt_dev_info(hdev, "Set UART speed to %d", speed); 959 ret = qca_set_baudrate(hdev, qca_baudrate); 960 if (ret) { 961 bt_dev_err(hdev, "Failed to change the baud rate (%d)", 962 ret); 963 return ret; 964 } 965 host_set_baudrate(hu, speed); 966 } 967 968 /* Setup patch / NVM configurations */ 969 ret = qca_uart_setup_rome(hdev, qca_baudrate); 970 if (!ret) { 971 set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags); 972 qca_debugfs_init(hdev); 973 } else if (ret == -ENOENT) { 974 /* No patch/nvm-config found, run with original fw/config */ 975 ret = 0; 976 } else if (ret == -EAGAIN) { 977 /* 978 * Userspace firmware loader will return -EAGAIN in case no 979 * patch/nvm-config is found, so run with original fw/config. 980 */ 981 ret = 0; 982 } 983 984 /* Setup bdaddr */ 985 hu->hdev->set_bdaddr = qca_set_bdaddr_rome; 986 987 return ret; 988 } 989 990 static struct hci_uart_proto qca_proto = { 991 .id = HCI_UART_QCA, 992 .name = "QCA", 993 .manufacturer = 29, 994 .init_speed = 115200, 995 .oper_speed = 3000000, 996 .open = qca_open, 997 .close = qca_close, 998 .flush = qca_flush, 999 .setup = qca_setup, 1000 .recv = qca_recv, 1001 .enqueue = qca_enqueue, 1002 .dequeue = qca_dequeue, 1003 }; 1004 1005 static int qca_serdev_probe(struct serdev_device *serdev) 1006 { 1007 struct qca_serdev *qcadev; 1008 int err; 1009 1010 qcadev = devm_kzalloc(&serdev->dev, sizeof(*qcadev), GFP_KERNEL); 1011 if (!qcadev) 1012 return -ENOMEM; 1013 1014 qcadev->serdev_hu.serdev = serdev; 1015 serdev_device_set_drvdata(serdev, qcadev); 1016 1017 qcadev->bt_en = devm_gpiod_get(&serdev->dev, "enable", 1018 GPIOD_OUT_LOW); 1019 if (IS_ERR(qcadev->bt_en)) { 1020 dev_err(&serdev->dev, "failed to acquire enable gpio\n"); 1021 return PTR_ERR(qcadev->bt_en); 1022 } 1023 1024 qcadev->susclk = devm_clk_get(&serdev->dev, NULL); 1025 if (IS_ERR(qcadev->susclk)) { 1026 dev_err(&serdev->dev, "failed to acquire clk\n"); 1027 return PTR_ERR(qcadev->susclk); 1028 } 1029 1030 err = clk_set_rate(qcadev->susclk, SUSCLK_RATE_32KHZ); 1031 if (err) 1032 return err; 1033 1034 err = clk_prepare_enable(qcadev->susclk); 1035 if (err) 1036 return err; 1037 1038 err = hci_uart_register_device(&qcadev->serdev_hu, &qca_proto); 1039 if (err) 1040 clk_disable_unprepare(qcadev->susclk); 1041 1042 return err; 1043 } 1044 1045 static void qca_serdev_remove(struct serdev_device *serdev) 1046 { 1047 struct qca_serdev *qcadev = serdev_device_get_drvdata(serdev); 1048 1049 hci_uart_unregister_device(&qcadev->serdev_hu); 1050 1051 clk_disable_unprepare(qcadev->susclk); 1052 } 1053 1054 static const struct of_device_id qca_bluetooth_of_match[] = { 1055 { .compatible = "qcom,qca6174-bt" }, 1056 { /* sentinel */ } 1057 }; 1058 MODULE_DEVICE_TABLE(of, qca_bluetooth_of_match); 1059 1060 static struct serdev_device_driver qca_serdev_driver = { 1061 .probe = qca_serdev_probe, 1062 .remove = qca_serdev_remove, 1063 .driver = { 1064 .name = "hci_uart_qca", 1065 .of_match_table = qca_bluetooth_of_match, 1066 }, 1067 }; 1068 1069 int __init qca_init(void) 1070 { 1071 serdev_device_driver_register(&qca_serdev_driver); 1072 1073 return hci_uart_register_proto(&qca_proto); 1074 } 1075 1076 int __exit qca_deinit(void) 1077 { 1078 serdev_device_driver_unregister(&qca_serdev_driver); 1079 1080 return hci_uart_unregister_proto(&qca_proto); 1081 } 1082