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(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 }