Loading...
Note: File does not exist in v3.1.
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 */
54enum 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 */
61enum rx_states {
62 HCI_IBS_RX_ASLEEP,
63 HCI_IBS_RX_AWAKE,
64};
65
66/* HCI_IBS transmit and receive side clock state vote */
67enum 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
75struct 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
114static 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
122static 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 */
131static 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 */
203static 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
225static 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
255static 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
282static 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
293static 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
310static 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
345static 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 */
387static 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
453static 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 */
500static 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 */
513static 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 */
539static 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 */
585static 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 */
619static 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 */
668static 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
726static 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
738static 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
750static 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
783static 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
792static 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
811static 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
818static 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
852static 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
888static 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
946static 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
961int __init qca_init(void)
962{
963 return hci_uart_register_proto(&qca_proto);
964}
965
966int __exit qca_deinit(void)
967{
968 return hci_uart_unregister_proto(&qca_proto);
969}