drivers/bluetooth/hci_qca.c

   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 }