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