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(unsigned long arg) 311 { 312 struct hci_uart *hu = (struct hci_uart *)arg; 313 struct qca_data *qca = hu->priv; 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(unsigned long arg) 346 { 347 struct hci_uart *hu = (struct hci_uart *)arg; 348 struct qca_data *qca = hu->priv; 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 setup_timer(&qca->wake_retrans_timer, hci_ibs_wake_retrans_timeout, 442 (u_long)hu); 443 qca->wake_retrans = IBS_WAKE_RETRANS_TIMEOUT_MS; 444 445 setup_timer(&qca->tx_idle_timer, hci_ibs_tx_idle_timeout, (u_long)hu); 446 qca->tx_idle_delay = IBS_TX_IDLE_TIMEOUT_MS; 447 448 BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u", 449 qca->tx_idle_delay, qca->wake_retrans); 450 451 return 0; 452 } 453 454 static void qca_debugfs_init(struct hci_dev *hdev) 455 { 456 struct hci_uart *hu = hci_get_drvdata(hdev); 457 struct qca_data *qca = hu->priv; 458 struct dentry *ibs_dir; 459 umode_t mode; 460 461 if (!hdev->debugfs) 462 return; 463 464 ibs_dir = debugfs_create_dir("ibs", hdev->debugfs); 465 466 /* read only */ 467 mode = S_IRUGO; 468 debugfs_create_u8("tx_ibs_state", mode, ibs_dir, &qca->tx_ibs_state); 469 debugfs_create_u8("rx_ibs_state", mode, ibs_dir, &qca->rx_ibs_state); 470 debugfs_create_u64("ibs_sent_sleeps", mode, ibs_dir, 471 &qca->ibs_sent_slps); 472 debugfs_create_u64("ibs_sent_wakes", mode, ibs_dir, 473 &qca->ibs_sent_wakes); 474 debugfs_create_u64("ibs_sent_wake_acks", mode, ibs_dir, 475 &qca->ibs_sent_wacks); 476 debugfs_create_u64("ibs_recv_sleeps", mode, ibs_dir, 477 &qca->ibs_recv_slps); 478 debugfs_create_u64("ibs_recv_wakes", mode, ibs_dir, 479 &qca->ibs_recv_wakes); 480 debugfs_create_u64("ibs_recv_wake_acks", mode, ibs_dir, 481 &qca->ibs_recv_wacks); 482 debugfs_create_bool("tx_vote", mode, ibs_dir, &qca->tx_vote); 483 debugfs_create_u64("tx_votes_on", mode, ibs_dir, &qca->tx_votes_on); 484 debugfs_create_u64("tx_votes_off", mode, ibs_dir, &qca->tx_votes_off); 485 debugfs_create_bool("rx_vote", mode, ibs_dir, &qca->rx_vote); 486 debugfs_create_u64("rx_votes_on", mode, ibs_dir, &qca->rx_votes_on); 487 debugfs_create_u64("rx_votes_off", mode, ibs_dir, &qca->rx_votes_off); 488 debugfs_create_u64("votes_on", mode, ibs_dir, &qca->votes_on); 489 debugfs_create_u64("votes_off", mode, ibs_dir, &qca->votes_off); 490 debugfs_create_u32("vote_on_ms", mode, ibs_dir, &qca->vote_on_ms); 491 debugfs_create_u32("vote_off_ms", mode, ibs_dir, &qca->vote_off_ms); 492 493 /* read/write */ 494 mode = S_IRUGO | S_IWUSR; 495 debugfs_create_u32("wake_retrans", mode, ibs_dir, &qca->wake_retrans); 496 debugfs_create_u32("tx_idle_delay", mode, ibs_dir, 497 &qca->tx_idle_delay); 498 } 499 500 /* Flush protocol data */ 501 static int qca_flush(struct hci_uart *hu) 502 { 503 struct qca_data *qca = hu->priv; 504 505 BT_DBG("hu %p qca flush", hu); 506 507 skb_queue_purge(&qca->tx_wait_q); 508 skb_queue_purge(&qca->txq); 509 510 return 0; 511 } 512 513 /* Close protocol */ 514 static int qca_close(struct hci_uart *hu) 515 { 516 struct qca_data *qca = hu->priv; 517 518 BT_DBG("hu %p qca close", hu); 519 520 serial_clock_vote(HCI_IBS_VOTE_STATS_UPDATE, hu); 521 522 skb_queue_purge(&qca->tx_wait_q); 523 skb_queue_purge(&qca->txq); 524 del_timer(&qca->tx_idle_timer); 525 del_timer(&qca->wake_retrans_timer); 526 destroy_workqueue(qca->workqueue); 527 qca->hu = NULL; 528 529 kfree_skb(qca->rx_skb); 530 531 hu->priv = NULL; 532 533 kfree(qca); 534 535 return 0; 536 } 537 538 /* Called upon a wake-up-indication from the device. 539 */ 540 static void device_want_to_wakeup(struct hci_uart *hu) 541 { 542 unsigned long flags; 543 struct qca_data *qca = hu->priv; 544 545 BT_DBG("hu %p want to wake up", hu); 546 547 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 548 549 qca->ibs_recv_wakes++; 550 551 switch (qca->rx_ibs_state) { 552 case HCI_IBS_RX_ASLEEP: 553 /* Make sure clock is on - we may have turned clock off since 554 * receiving the wake up indicator awake rx clock. 555 */ 556 queue_work(qca->workqueue, &qca->ws_awake_rx); 557 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 558 return; 559 560 case HCI_IBS_RX_AWAKE: 561 /* Always acknowledge device wake up, 562 * sending IBS message doesn't count as TX ON. 563 */ 564 if (send_hci_ibs_cmd(HCI_IBS_WAKE_ACK, hu) < 0) { 565 BT_ERR("Failed to acknowledge device wake up"); 566 break; 567 } 568 qca->ibs_sent_wacks++; 569 break; 570 571 default: 572 /* Any other state is illegal */ 573 BT_ERR("Received HCI_IBS_WAKE_IND in rx state %d", 574 qca->rx_ibs_state); 575 break; 576 } 577 578 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 579 580 /* Actually send the packets */ 581 hci_uart_tx_wakeup(hu); 582 } 583 584 /* Called upon a sleep-indication from the device. 585 */ 586 static void device_want_to_sleep(struct hci_uart *hu) 587 { 588 unsigned long flags; 589 struct qca_data *qca = hu->priv; 590 591 BT_DBG("hu %p want to sleep", hu); 592 593 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 594 595 qca->ibs_recv_slps++; 596 597 switch (qca->rx_ibs_state) { 598 case HCI_IBS_RX_AWAKE: 599 /* Update state */ 600 qca->rx_ibs_state = HCI_IBS_RX_ASLEEP; 601 /* Vote off rx clock under workqueue */ 602 queue_work(qca->workqueue, &qca->ws_rx_vote_off); 603 break; 604 605 case HCI_IBS_RX_ASLEEP: 606 /* Fall through */ 607 608 default: 609 /* Any other state is illegal */ 610 BT_ERR("Received HCI_IBS_SLEEP_IND in rx state %d", 611 qca->rx_ibs_state); 612 break; 613 } 614 615 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 616 } 617 618 /* Called upon wake-up-acknowledgement from the device 619 */ 620 static void device_woke_up(struct hci_uart *hu) 621 { 622 unsigned long flags, idle_delay; 623 struct qca_data *qca = hu->priv; 624 struct sk_buff *skb = NULL; 625 626 BT_DBG("hu %p woke up", hu); 627 628 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 629 630 qca->ibs_recv_wacks++; 631 632 switch (qca->tx_ibs_state) { 633 case HCI_IBS_TX_AWAKE: 634 /* Expect one if we send 2 WAKEs */ 635 BT_DBG("Received HCI_IBS_WAKE_ACK in tx state %d", 636 qca->tx_ibs_state); 637 break; 638 639 case HCI_IBS_TX_WAKING: 640 /* Send pending packets */ 641 while ((skb = skb_dequeue(&qca->tx_wait_q))) 642 skb_queue_tail(&qca->txq, skb); 643 644 /* Switch timers and change state to HCI_IBS_TX_AWAKE */ 645 del_timer(&qca->wake_retrans_timer); 646 idle_delay = msecs_to_jiffies(qca->tx_idle_delay); 647 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay); 648 qca->tx_ibs_state = HCI_IBS_TX_AWAKE; 649 break; 650 651 case HCI_IBS_TX_ASLEEP: 652 /* Fall through */ 653 654 default: 655 BT_ERR("Received HCI_IBS_WAKE_ACK in tx state %d", 656 qca->tx_ibs_state); 657 break; 658 } 659 660 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 661 662 /* Actually send the packets */ 663 hci_uart_tx_wakeup(hu); 664 } 665 666 /* Enqueue frame for transmittion (padding, crc, etc) may be called from 667 * two simultaneous tasklets. 668 */ 669 static int qca_enqueue(struct hci_uart *hu, struct sk_buff *skb) 670 { 671 unsigned long flags = 0, idle_delay; 672 struct qca_data *qca = hu->priv; 673 674 BT_DBG("hu %p qca enq skb %p tx_ibs_state %d", hu, skb, 675 qca->tx_ibs_state); 676 677 /* Prepend skb with frame type */ 678 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 679 680 /* Don't go to sleep in middle of patch download or 681 * Out-Of-Band(GPIOs control) sleep is selected. 682 */ 683 if (!test_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags)) { 684 skb_queue_tail(&qca->txq, skb); 685 return 0; 686 } 687 688 spin_lock_irqsave(&qca->hci_ibs_lock, flags); 689 690 /* Act according to current state */ 691 switch (qca->tx_ibs_state) { 692 case HCI_IBS_TX_AWAKE: 693 BT_DBG("Device awake, sending normally"); 694 skb_queue_tail(&qca->txq, skb); 695 idle_delay = msecs_to_jiffies(qca->tx_idle_delay); 696 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay); 697 break; 698 699 case HCI_IBS_TX_ASLEEP: 700 BT_DBG("Device asleep, waking up and queueing packet"); 701 /* Save packet for later */ 702 skb_queue_tail(&qca->tx_wait_q, skb); 703 704 qca->tx_ibs_state = HCI_IBS_TX_WAKING; 705 /* Schedule a work queue to wake up device */ 706 queue_work(qca->workqueue, &qca->ws_awake_device); 707 break; 708 709 case HCI_IBS_TX_WAKING: 710 BT_DBG("Device waking up, queueing packet"); 711 /* Transient state; just keep packet for later */ 712 skb_queue_tail(&qca->tx_wait_q, skb); 713 break; 714 715 default: 716 BT_ERR("Illegal tx state: %d (losing packet)", 717 qca->tx_ibs_state); 718 kfree_skb(skb); 719 break; 720 } 721 722 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags); 723 724 return 0; 725 } 726 727 static int qca_ibs_sleep_ind(struct hci_dev *hdev, struct sk_buff *skb) 728 { 729 struct hci_uart *hu = hci_get_drvdata(hdev); 730 731 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_SLEEP_IND); 732 733 device_want_to_sleep(hu); 734 735 kfree_skb(skb); 736 return 0; 737 } 738 739 static int qca_ibs_wake_ind(struct hci_dev *hdev, struct sk_buff *skb) 740 { 741 struct hci_uart *hu = hci_get_drvdata(hdev); 742 743 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_IND); 744 745 device_want_to_wakeup(hu); 746 747 kfree_skb(skb); 748 return 0; 749 } 750 751 static int qca_ibs_wake_ack(struct hci_dev *hdev, struct sk_buff *skb) 752 { 753 struct hci_uart *hu = hci_get_drvdata(hdev); 754 755 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_ACK); 756 757 device_woke_up(hu); 758 759 kfree_skb(skb); 760 return 0; 761 } 762 763 #define QCA_IBS_SLEEP_IND_EVENT \ 764 .type = HCI_IBS_SLEEP_IND, \ 765 .hlen = 0, \ 766 .loff = 0, \ 767 .lsize = 0, \ 768 .maxlen = HCI_MAX_IBS_SIZE 769 770 #define QCA_IBS_WAKE_IND_EVENT \ 771 .type = HCI_IBS_WAKE_IND, \ 772 .hlen = 0, \ 773 .loff = 0, \ 774 .lsize = 0, \ 775 .maxlen = HCI_MAX_IBS_SIZE 776 777 #define QCA_IBS_WAKE_ACK_EVENT \ 778 .type = HCI_IBS_WAKE_ACK, \ 779 .hlen = 0, \ 780 .loff = 0, \ 781 .lsize = 0, \ 782 .maxlen = HCI_MAX_IBS_SIZE 783 784 static const struct h4_recv_pkt qca_recv_pkts[] = { 785 { H4_RECV_ACL, .recv = hci_recv_frame }, 786 { H4_RECV_SCO, .recv = hci_recv_frame }, 787 { H4_RECV_EVENT, .recv = hci_recv_frame }, 788 { QCA_IBS_WAKE_IND_EVENT, .recv = qca_ibs_wake_ind }, 789 { QCA_IBS_WAKE_ACK_EVENT, .recv = qca_ibs_wake_ack }, 790 { QCA_IBS_SLEEP_IND_EVENT, .recv = qca_ibs_sleep_ind }, 791 }; 792 793 static int qca_recv(struct hci_uart *hu, const void *data, int count) 794 { 795 struct qca_data *qca = hu->priv; 796 797 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 798 return -EUNATCH; 799 800 qca->rx_skb = h4_recv_buf(hu->hdev, qca->rx_skb, data, count, 801 qca_recv_pkts, ARRAY_SIZE(qca_recv_pkts)); 802 if (IS_ERR(qca->rx_skb)) { 803 int err = PTR_ERR(qca->rx_skb); 804 BT_ERR("%s: Frame reassembly failed (%d)", hu->hdev->name, err); 805 qca->rx_skb = NULL; 806 return err; 807 } 808 809 return count; 810 } 811 812 static struct sk_buff *qca_dequeue(struct hci_uart *hu) 813 { 814 struct qca_data *qca = hu->priv; 815 816 return skb_dequeue(&qca->txq); 817 } 818 819 static uint8_t qca_get_baudrate_value(int speed) 820 { 821 switch (speed) { 822 case 9600: 823 return QCA_BAUDRATE_9600; 824 case 19200: 825 return QCA_BAUDRATE_19200; 826 case 38400: 827 return QCA_BAUDRATE_38400; 828 case 57600: 829 return QCA_BAUDRATE_57600; 830 case 115200: 831 return QCA_BAUDRATE_115200; 832 case 230400: 833 return QCA_BAUDRATE_230400; 834 case 460800: 835 return QCA_BAUDRATE_460800; 836 case 500000: 837 return QCA_BAUDRATE_500000; 838 case 921600: 839 return QCA_BAUDRATE_921600; 840 case 1000000: 841 return QCA_BAUDRATE_1000000; 842 case 2000000: 843 return QCA_BAUDRATE_2000000; 844 case 3000000: 845 return QCA_BAUDRATE_3000000; 846 case 3500000: 847 return QCA_BAUDRATE_3500000; 848 default: 849 return QCA_BAUDRATE_115200; 850 } 851 } 852 853 static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate) 854 { 855 struct hci_uart *hu = hci_get_drvdata(hdev); 856 struct qca_data *qca = hu->priv; 857 struct sk_buff *skb; 858 u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 }; 859 860 if (baudrate > QCA_BAUDRATE_3000000) 861 return -EINVAL; 862 863 cmd[4] = baudrate; 864 865 skb = bt_skb_alloc(sizeof(cmd), GFP_ATOMIC); 866 if (!skb) { 867 BT_ERR("Failed to allocate memory for baudrate packet"); 868 return -ENOMEM; 869 } 870 871 /* Assign commands to change baudrate and packet type. */ 872 skb_put_data(skb, cmd, sizeof(cmd)); 873 hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 874 875 skb_queue_tail(&qca->txq, skb); 876 hci_uart_tx_wakeup(hu); 877 878 /* wait 300ms to change new baudrate on controller side 879 * controller will come back after they receive this HCI command 880 * then host can communicate with new baudrate to controller 881 */ 882 set_current_state(TASK_UNINTERRUPTIBLE); 883 schedule_timeout(msecs_to_jiffies(BAUDRATE_SETTLE_TIMEOUT_MS)); 884 set_current_state(TASK_INTERRUPTIBLE); 885 886 return 0; 887 } 888 889 static int qca_setup(struct hci_uart *hu) 890 { 891 struct hci_dev *hdev = hu->hdev; 892 struct qca_data *qca = hu->priv; 893 unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200; 894 int ret; 895 896 BT_INFO("%s: ROME setup", hdev->name); 897 898 /* Patch downloading has to be done without IBS mode */ 899 clear_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags); 900 901 /* Setup initial baudrate */ 902 speed = 0; 903 if (hu->init_speed) 904 speed = hu->init_speed; 905 else if (hu->proto->init_speed) 906 speed = hu->proto->init_speed; 907 908 if (speed) 909 hci_uart_set_baudrate(hu, speed); 910 911 /* Setup user speed if needed */ 912 speed = 0; 913 if (hu->oper_speed) 914 speed = hu->oper_speed; 915 else if (hu->proto->oper_speed) 916 speed = hu->proto->oper_speed; 917 918 if (speed) { 919 qca_baudrate = qca_get_baudrate_value(speed); 920 921 BT_INFO("%s: Set UART speed to %d", hdev->name, speed); 922 ret = qca_set_baudrate(hdev, qca_baudrate); 923 if (ret) { 924 BT_ERR("%s: Failed to change the baud rate (%d)", 925 hdev->name, ret); 926 return ret; 927 } 928 hci_uart_set_baudrate(hu, speed); 929 } 930 931 /* Setup patch / NVM configurations */ 932 ret = qca_uart_setup_rome(hdev, qca_baudrate); 933 if (!ret) { 934 set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags); 935 qca_debugfs_init(hdev); 936 } 937 938 /* Setup bdaddr */ 939 hu->hdev->set_bdaddr = qca_set_bdaddr_rome; 940 941 return ret; 942 } 943 944 static struct hci_uart_proto qca_proto = { 945 .id = HCI_UART_QCA, 946 .name = "QCA", 947 .manufacturer = 29, 948 .init_speed = 115200, 949 .oper_speed = 3000000, 950 .open = qca_open, 951 .close = qca_close, 952 .flush = qca_flush, 953 .setup = qca_setup, 954 .recv = qca_recv, 955 .enqueue = qca_enqueue, 956 .dequeue = qca_dequeue, 957 }; 958 959 int __init qca_init(void) 960 { 961 return hci_uart_register_proto(&qca_proto); 962 } 963 964 int __exit qca_deinit(void) 965 { 966 return hci_uart_unregister_proto(&qca_proto); 967 } 968