aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorBen Young Tae Kim <ytkim@qca.qualcomm.com>2015-08-10 17:24:17 -0400
committerMarcel Holtmann <marcel@holtmann.org>2015-08-10 17:52:20 -0400
commit0ff252c1976da5d80db1377eb39b551931e61826 (patch)
treeb2d83c1c6009871e7a2ce403c634f543505bd6c8
parent83e81961ff7ef75f97756f316caea5aa6bcc19cc (diff)
Bluetooth: hciuart: Add support QCA chipset for UART
QCA61x4 chips have supported sleep feature using In-Band-Sleep commands to enable sleep feature based on H4 protocol. After sending patch/nvm configuration is done, IBS mode will be up and running Signed-off-by: Ben Young Tae Kim <ytkim@qca.qualcomm.com> Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
Diffstat
-rw-r--r--drivers/bluetooth/Kconfig13
-rw-r--r--drivers/bluetooth/Makefile1
-rw-r--r--drivers/bluetooth/hci_ldisc.c6
-rw-r--r--drivers/bluetooth/hci_qca.c969
-rw-r--r--drivers/bluetooth/hci_uart.h8
5 files changed, 996 insertions, 1 deletions
diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
index f5803345e305..0bd88c942a52 100644
--- a/drivers/bluetooth/Kconfig
+++ b/drivers/bluetooth/Kconfig
@@ -155,6 +155,19 @@ config BT_HCIUART_BCM
155 155
156 Say Y here to compile support for Broadcom protocol. 156 Say Y here to compile support for Broadcom protocol.
157 157
158config BT_HCIUART_QCA
159 bool "Qualcomm Atheros protocol support"
160 depends on BT_HCIUART
161 select BT_HCIUART_H4
162 select BT_QCA
163 help
164 The Qualcomm Atheros protocol supports HCI In-Band Sleep feature
165 over serial port interface(H4) between controller and host.
166 This protocol is required for UART clock control for QCA Bluetooth
167 devices.
168
169 Say Y here to compile support for QCA protocol.
170
158config BT_HCIBCM203X 171config BT_HCIBCM203X
159 tristate "HCI BCM203x USB driver" 172 tristate "HCI BCM203x USB driver"
160 depends on USB 173 depends on USB
diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile
index 15a0d1de4db4..07c9cf381e5a 100644
--- a/drivers/bluetooth/Makefile
+++ b/drivers/bluetooth/Makefile
@@ -35,6 +35,7 @@ hci_uart-$(CONFIG_BT_HCIUART_ATH3K) += hci_ath.o
35hci_uart-$(CONFIG_BT_HCIUART_3WIRE) += hci_h5.o 35hci_uart-$(CONFIG_BT_HCIUART_3WIRE) += hci_h5.o
36hci_uart-$(CONFIG_BT_HCIUART_INTEL) += hci_intel.o 36hci_uart-$(CONFIG_BT_HCIUART_INTEL) += hci_intel.o
37hci_uart-$(CONFIG_BT_HCIUART_BCM) += hci_bcm.o 37hci_uart-$(CONFIG_BT_HCIUART_BCM) += hci_bcm.o
38hci_uart-$(CONFIG_BT_HCIUART_QCA) += hci_qca.o
38hci_uart-objs := $(hci_uart-y) 39hci_uart-objs := $(hci_uart-y)
39 40
40ccflags-y += -D__CHECK_ENDIAN__ 41ccflags-y += -D__CHECK_ENDIAN__
diff --git a/drivers/bluetooth/hci_ldisc.c b/drivers/bluetooth/hci_ldisc.c
index 20c2ac193ff9..0d5a05a7c1fd 100644
--- a/drivers/bluetooth/hci_ldisc.c
+++ b/drivers/bluetooth/hci_ldisc.c
@@ -810,6 +810,9 @@ static int __init hci_uart_init(void)
810#ifdef CONFIG_BT_HCIUART_BCM 810#ifdef CONFIG_BT_HCIUART_BCM
811 bcm_init(); 811 bcm_init();
812#endif 812#endif
813#ifdef CONFIG_BT_HCIUART_QCA
814 qca_init();
815#endif
813 816
814 return 0; 817 return 0;
815} 818}
@@ -839,6 +842,9 @@ static void __exit hci_uart_exit(void)
839#ifdef CONFIG_BT_HCIUART_BCM 842#ifdef CONFIG_BT_HCIUART_BCM
840 bcm_deinit(); 843 bcm_deinit();
841#endif 844#endif
845#ifdef CONFIG_BT_HCIUART_QCA
846 qca_deinit();
847#endif
842 848
843 /* Release tty registration of line discipline */ 849 /* Release tty registration of line discipline */
844 err = tty_unregister_ldisc(N_HCI); 850 err = tty_unregister_ldisc(N_HCI);
diff --git a/drivers/bluetooth/hci_qca.c b/drivers/bluetooth/hci_qca.c
new file mode 100644
index 000000000000..62e45fff0b4b
--- /dev/null
+++ b/drivers/bluetooth/hci_qca.c
@@ -0,0 +1,969 @@
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(skb, 1) = 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(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("Spurrious 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(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 unsigned long retransmit = 0;
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 = 1;
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("Spurrious 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 = create_singlethread_workqueue("qca_wq");
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 init_timer(&qca->wake_retrans_timer);
442 qca->wake_retrans_timer.function = hci_ibs_wake_retrans_timeout;
443 qca->wake_retrans_timer.data = (u_long)hu;
444 qca->wake_retrans = IBS_WAKE_RETRANS_TIMEOUT_MS;
445
446 init_timer(&qca->tx_idle_timer);
447 qca->tx_idle_timer.function = hci_ibs_tx_idle_timeout;
448 qca->tx_idle_timer.data = (u_long)hu;
449 qca->tx_idle_delay = IBS_TX_IDLE_TIMEOUT_MS;
450
451 BT_DBG("HCI_UART_QCA open, tx_idle_delay=%u, wake_retrans=%u",
452 qca->tx_idle_delay, qca->wake_retrans);
453
454 return 0;
455}
456
457static void qca_debugfs_init(struct hci_dev *hdev)
458{
459 struct hci_uart *hu = hci_get_drvdata(hdev);
460 struct qca_data *qca = hu->priv;
461 struct dentry *ibs_dir;
462 umode_t mode;
463
464 if (!hdev->debugfs)
465 return;
466
467 ibs_dir = debugfs_create_dir("ibs", hdev->debugfs);
468
469 /* read only */
470 mode = S_IRUGO;
471 debugfs_create_u8("tx_ibs_state", mode, ibs_dir, &qca->tx_ibs_state);
472 debugfs_create_u8("rx_ibs_state", mode, ibs_dir, &qca->rx_ibs_state);
473 debugfs_create_u64("ibs_sent_sleeps", mode, ibs_dir,
474 &qca->ibs_sent_slps);
475 debugfs_create_u64("ibs_sent_wakes", mode, ibs_dir,
476 &qca->ibs_sent_wakes);
477 debugfs_create_u64("ibs_sent_wake_acks", mode, ibs_dir,
478 &qca->ibs_sent_wacks);
479 debugfs_create_u64("ibs_recv_sleeps", mode, ibs_dir,
480 &qca->ibs_recv_slps);
481 debugfs_create_u64("ibs_recv_wakes", mode, ibs_dir,
482 &qca->ibs_recv_wakes);
483 debugfs_create_u64("ibs_recv_wake_acks", mode, ibs_dir,
484 &qca->ibs_recv_wacks);
485 debugfs_create_bool("tx_vote", mode, ibs_dir, (u32 *)&qca->tx_vote);
486 debugfs_create_u64("tx_votes_on", mode, ibs_dir, &qca->tx_votes_on);
487 debugfs_create_u64("tx_votes_off", mode, ibs_dir, &qca->tx_votes_off);
488 debugfs_create_bool("rx_vote", mode, ibs_dir, (u32 *)&qca->rx_vote);
489 debugfs_create_u64("rx_votes_on", mode, ibs_dir, &qca->rx_votes_on);
490 debugfs_create_u64("rx_votes_off", mode, ibs_dir, &qca->rx_votes_off);
491 debugfs_create_u64("votes_on", mode, ibs_dir, &qca->votes_on);
492 debugfs_create_u64("votes_off", mode, ibs_dir, &qca->votes_off);
493 debugfs_create_u32("vote_on_ms", mode, ibs_dir, &qca->vote_on_ms);
494 debugfs_create_u32("vote_off_ms", mode, ibs_dir, &qca->vote_off_ms);
495
496 /* read/write */
497 mode = S_IRUGO | S_IWUSR;
498 debugfs_create_u32("wake_retrans", mode, ibs_dir, &qca->wake_retrans);
499 debugfs_create_u32("tx_idle_delay", mode, ibs_dir,
500 &qca->tx_idle_delay);
501}
502
503/* Flush protocol data */
504static int qca_flush(struct hci_uart *hu)
505{
506 struct qca_data *qca = hu->priv;
507
508 BT_DBG("hu %p qca flush", hu);
509
510 skb_queue_purge(&qca->tx_wait_q);
511 skb_queue_purge(&qca->txq);
512
513 return 0;
514}
515
516/* Close protocol */
517static int qca_close(struct hci_uart *hu)
518{
519 struct qca_data *qca = hu->priv;
520
521 BT_DBG("hu %p qca close", hu);
522
523 serial_clock_vote(HCI_IBS_VOTE_STATS_UPDATE, hu);
524
525 skb_queue_purge(&qca->tx_wait_q);
526 skb_queue_purge(&qca->txq);
527 del_timer(&qca->tx_idle_timer);
528 del_timer(&qca->wake_retrans_timer);
529 destroy_workqueue(qca->workqueue);
530 qca->hu = NULL;
531
532 kfree_skb(qca->rx_skb);
533
534 hu->priv = NULL;
535
536 kfree(qca);
537
538 return 0;
539}
540
541/* Called upon a wake-up-indication from the device.
542 */
543static void device_want_to_wakeup(struct hci_uart *hu)
544{
545 unsigned long flags;
546 struct qca_data *qca = hu->priv;
547
548 BT_DBG("hu %p want to wake up", hu);
549
550 spin_lock_irqsave(&qca->hci_ibs_lock, flags);
551
552 qca->ibs_recv_wakes++;
553
554 switch (qca->rx_ibs_state) {
555 case HCI_IBS_RX_ASLEEP:
556 /* Make sure clock is on - we may have turned clock off since
557 * receiving the wake up indicator awake rx clock.
558 */
559 queue_work(qca->workqueue, &qca->ws_awake_rx);
560 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags);
561 return;
562
563 case HCI_IBS_RX_AWAKE:
564 /* Always acknowledge device wake up,
565 * sending IBS message doesn't count as TX ON.
566 */
567 if (send_hci_ibs_cmd(HCI_IBS_WAKE_ACK, hu) < 0) {
568 BT_ERR("Failed to acknowledge device wake up");
569 break;
570 }
571 qca->ibs_sent_wacks++;
572 break;
573
574 default:
575 /* Any other state is illegal */
576 BT_ERR("Received HCI_IBS_WAKE_IND in rx state %d",
577 qca->rx_ibs_state);
578 break;
579 }
580
581 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags);
582
583 /* Actually send the packets */
584 hci_uart_tx_wakeup(hu);
585}
586
587/* Called upon a sleep-indication from the device.
588 */
589static void device_want_to_sleep(struct hci_uart *hu)
590{
591 unsigned long flags;
592 struct qca_data *qca = hu->priv;
593
594 BT_DBG("hu %p want to sleep", hu);
595
596 spin_lock_irqsave(&qca->hci_ibs_lock, flags);
597
598 qca->ibs_recv_slps++;
599
600 switch (qca->rx_ibs_state) {
601 case HCI_IBS_RX_AWAKE:
602 /* Update state */
603 qca->rx_ibs_state = HCI_IBS_RX_ASLEEP;
604 /* Vote off rx clock under workqueue */
605 queue_work(qca->workqueue, &qca->ws_rx_vote_off);
606 break;
607
608 case HCI_IBS_RX_ASLEEP:
609 /* Fall through */
610
611 default:
612 /* Any other state is illegal */
613 BT_ERR("Received HCI_IBS_SLEEP_IND in rx state %d",
614 qca->rx_ibs_state);
615 break;
616 }
617
618 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags);
619}
620
621/* Called upon wake-up-acknowledgement from the device
622 */
623static void device_woke_up(struct hci_uart *hu)
624{
625 unsigned long flags, idle_delay;
626 struct qca_data *qca = hu->priv;
627 struct sk_buff *skb = NULL;
628
629 BT_DBG("hu %p woke up", hu);
630
631 spin_lock_irqsave(&qca->hci_ibs_lock, flags);
632
633 qca->ibs_recv_wacks++;
634
635 switch (qca->tx_ibs_state) {
636 case HCI_IBS_TX_AWAKE:
637 /* Expect one if we send 2 WAKEs */
638 BT_DBG("Received HCI_IBS_WAKE_ACK in tx state %d",
639 qca->tx_ibs_state);
640 break;
641
642 case HCI_IBS_TX_WAKING:
643 /* Send pending packets */
644 while ((skb = skb_dequeue(&qca->tx_wait_q)))
645 skb_queue_tail(&qca->txq, skb);
646
647 /* Switch timers and change state to HCI_IBS_TX_AWAKE */
648 del_timer(&qca->wake_retrans_timer);
649 idle_delay = msecs_to_jiffies(qca->tx_idle_delay);
650 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay);
651 qca->tx_ibs_state = HCI_IBS_TX_AWAKE;
652 break;
653
654 case HCI_IBS_TX_ASLEEP:
655 /* Fall through */
656
657 default:
658 BT_ERR("Received HCI_IBS_WAKE_ACK in tx state %d",
659 qca->tx_ibs_state);
660 break;
661 }
662
663 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags);
664
665 /* Actually send the packets */
666 hci_uart_tx_wakeup(hu);
667}
668
669/* Enqueue frame for transmittion (padding, crc, etc) may be called from
670 * two simultaneous tasklets.
671 */
672static int qca_enqueue(struct hci_uart *hu, struct sk_buff *skb)
673{
674 unsigned long flags = 0, idle_delay;
675 struct qca_data *qca = hu->priv;
676
677 BT_DBG("hu %p qca enq skb %p tx_ibs_state %d", hu, skb,
678 qca->tx_ibs_state);
679
680 /* Prepend skb with frame type */
681 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
682
683 /* Don't go to sleep in middle of patch download or
684 * Out-Of-Band(GPIOs control) sleep is selected.
685 */
686 if (!test_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags)) {
687 skb_queue_tail(&qca->txq, skb);
688 return 0;
689 }
690
691 spin_lock_irqsave(&qca->hci_ibs_lock, flags);
692
693 /* Act according to current state */
694 switch (qca->tx_ibs_state) {
695 case HCI_IBS_TX_AWAKE:
696 BT_DBG("Device awake, sending normally");
697 skb_queue_tail(&qca->txq, skb);
698 idle_delay = msecs_to_jiffies(qca->tx_idle_delay);
699 mod_timer(&qca->tx_idle_timer, jiffies + idle_delay);
700 break;
701
702 case HCI_IBS_TX_ASLEEP:
703 BT_DBG("Device asleep, waking up and queueing packet");
704 /* Save packet for later */
705 skb_queue_tail(&qca->tx_wait_q, skb);
706
707 qca->tx_ibs_state = HCI_IBS_TX_WAKING;
708 /* Schedule a work queue to wake up device */
709 queue_work(qca->workqueue, &qca->ws_awake_device);
710 break;
711
712 case HCI_IBS_TX_WAKING:
713 BT_DBG("Device waking up, queueing packet");
714 /* Transient state; just keep packet for later */
715 skb_queue_tail(&qca->tx_wait_q, skb);
716 break;
717
718 default:
719 BT_ERR("Illegal tx state: %d (losing packet)",
720 qca->tx_ibs_state);
721 kfree_skb(skb);
722 break;
723 }
724
725 spin_unlock_irqrestore(&qca->hci_ibs_lock, flags);
726
727 return 0;
728}
729
730static int qca_ibs_sleep_ind(struct hci_dev *hdev, struct sk_buff *skb)
731{
732 struct hci_uart *hu = hci_get_drvdata(hdev);
733
734 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_SLEEP_IND);
735
736 device_want_to_sleep(hu);
737
738 kfree_skb(skb);
739 return 0;
740}
741
742static int qca_ibs_wake_ind(struct hci_dev *hdev, struct sk_buff *skb)
743{
744 struct hci_uart *hu = hci_get_drvdata(hdev);
745
746 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_IND);
747
748 device_want_to_wakeup(hu);
749
750 kfree_skb(skb);
751 return 0;
752}
753
754static int qca_ibs_wake_ack(struct hci_dev *hdev, struct sk_buff *skb)
755{
756 struct hci_uart *hu = hci_get_drvdata(hdev);
757
758 BT_DBG("hu %p recv hci ibs cmd 0x%x", hu, HCI_IBS_WAKE_ACK);
759
760 device_woke_up(hu);
761
762 kfree_skb(skb);
763 return 0;
764}
765
766#define QCA_IBS_SLEEP_IND_EVENT \
767 .type = HCI_IBS_SLEEP_IND, \
768 .hlen = 0, \
769 .loff = 0, \
770 .lsize = 0, \
771 .maxlen = HCI_MAX_IBS_SIZE
772
773#define QCA_IBS_WAKE_IND_EVENT \
774 .type = HCI_IBS_WAKE_IND, \
775 .hlen = 0, \
776 .loff = 0, \
777 .lsize = 0, \
778 .maxlen = HCI_MAX_IBS_SIZE
779
780#define QCA_IBS_WAKE_ACK_EVENT \
781 .type = HCI_IBS_WAKE_ACK, \
782 .hlen = 0, \
783 .loff = 0, \
784 .lsize = 0, \
785 .maxlen = HCI_MAX_IBS_SIZE
786
787static const struct h4_recv_pkt qca_recv_pkts[] = {
788 { H4_RECV_ACL, .recv = hci_recv_frame },
789 { H4_RECV_SCO, .recv = hci_recv_frame },
790 { H4_RECV_EVENT, .recv = hci_recv_frame },
791 { QCA_IBS_WAKE_IND_EVENT, .recv = qca_ibs_wake_ind },
792 { QCA_IBS_WAKE_ACK_EVENT, .recv = qca_ibs_wake_ack },
793 { QCA_IBS_SLEEP_IND_EVENT, .recv = qca_ibs_sleep_ind },
794};
795
796static int qca_recv(struct hci_uart *hu, const void *data, int count)
797{
798 struct qca_data *qca = hu->priv;
799
800 if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
801 return -EUNATCH;
802
803 qca->rx_skb = h4_recv_buf(hu->hdev, qca->rx_skb, data, count,
804 qca_recv_pkts, ARRAY_SIZE(qca_recv_pkts));
805 if (IS_ERR(qca->rx_skb)) {
806 int err = PTR_ERR(qca->rx_skb);
807 BT_ERR("%s: Frame reassembly failed (%d)", hu->hdev->name, err);
808 qca->rx_skb = NULL;
809 return err;
810 }
811
812 return count;
813}
814
815static struct sk_buff *qca_dequeue(struct hci_uart *hu)
816{
817 struct qca_data *qca = hu->priv;
818
819 return skb_dequeue(&qca->txq);
820}
821
822static uint8_t qca_get_baudrate_value(int speed)
823{
824 switch(speed) {
825 case 9600:
826 return QCA_BAUDRATE_9600;
827 case 19200:
828 return QCA_BAUDRATE_19200;
829 case 38400:
830 return QCA_BAUDRATE_38400;
831 case 57600:
832 return QCA_BAUDRATE_57600;
833 case 115200:
834 return QCA_BAUDRATE_115200;
835 case 230400:
836 return QCA_BAUDRATE_230400;
837 case 460800:
838 return QCA_BAUDRATE_460800;
839 case 500000:
840 return QCA_BAUDRATE_500000;
841 case 921600:
842 return QCA_BAUDRATE_921600;
843 case 1000000:
844 return QCA_BAUDRATE_1000000;
845 case 2000000:
846 return QCA_BAUDRATE_2000000;
847 case 3000000:
848 return QCA_BAUDRATE_3000000;
849 case 3500000:
850 return QCA_BAUDRATE_3500000;
851 default:
852 return QCA_BAUDRATE_115200;
853 }
854}
855
856static int qca_set_baudrate(struct hci_dev *hdev, uint8_t baudrate)
857{
858 struct hci_uart *hu = hci_get_drvdata(hdev);
859 struct qca_data *qca = hu->priv;
860 struct sk_buff *skb;
861 u8 cmd[] = { 0x01, 0x48, 0xFC, 0x01, 0x00 };
862
863 if (baudrate > QCA_BAUDRATE_3000000)
864 return -EINVAL;
865
866 cmd[4] = baudrate;
867
868 skb = bt_skb_alloc(sizeof(cmd), GFP_ATOMIC);
869 if (!skb) {
870 BT_ERR("Failed to allocate memory for baudrate packet");
871 return -ENOMEM;
872 }
873
874 /* Assign commands to change baudrate and packet type. */
875 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
876 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
877
878 skb_queue_tail(&qca->txq, skb);
879 hci_uart_tx_wakeup(hu);
880
881 /* wait 300ms to change new baudrate on controller side
882 * controller will come back after they receive this HCI command
883 * then host can communicate with new baudrate to controller
884 */
885 set_current_state(TASK_UNINTERRUPTIBLE);
886 schedule_timeout(msecs_to_jiffies(BAUDRATE_SETTLE_TIMEOUT_MS));
887 set_current_state(TASK_INTERRUPTIBLE);
888
889 return 0;
890}
891
892static int qca_setup(struct hci_uart *hu)
893{
894 struct hci_dev *hdev = hu->hdev;
895 struct qca_data *qca = hu->priv;
896 unsigned int speed, qca_baudrate = QCA_BAUDRATE_115200;
897 int ret;
898
899 BT_INFO("%s: ROME setup", hdev->name);
900
901 /* Patch downloading has to be done without IBS mode */
902 clear_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);
903
904 /* Setup initial baudrate */
905 speed = 0;
906 if (hu->init_speed)
907 speed = hu->init_speed;
908 else if (hu->proto->init_speed)
909 speed = hu->proto->init_speed;
910
911 if (speed)
912 hci_uart_set_baudrate(hu, speed);
913
914 /* Setup user speed if needed */
915 speed = 0;
916 if (hu->oper_speed)
917 speed = hu->oper_speed;
918 else if (hu->proto->oper_speed)
919 speed = hu->proto->oper_speed;
920
921 if (speed) {
922 qca_baudrate = qca_get_baudrate_value(speed);
923
924 BT_INFO("%s: Set UART speed to %d", hdev->name, speed);
925 ret = qca_set_baudrate(hdev, qca_baudrate);
926 if (ret) {
927 BT_ERR("%s: Failed to change the baud rate (%d)",
928 hdev->name, ret);
929 return ret;
930 }
931 hci_uart_set_baudrate(hu, speed);
932 }
933
934 /* Setup patch / NVM configurations */
935 ret = qca_uart_setup_rome(hdev, qca_baudrate);
936 if (!ret) {
937 set_bit(STATE_IN_BAND_SLEEP_ENABLED, &qca->flags);
938 qca_debugfs_init(hdev);
939 }
940
941 /* Setup bdaddr */
942 hu->hdev->set_bdaddr = qca_set_bdaddr_rome;
943
944 return ret;
945}
946
947static struct hci_uart_proto qca_proto = {
948 .id = HCI_UART_QCA,
949 .name = "QCA",
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}
diff --git a/drivers/bluetooth/hci_uart.h b/drivers/bluetooth/hci_uart.h
index 496587a73a9d..495b9ef52bb0 100644
--- a/drivers/bluetooth/hci_uart.h
+++ b/drivers/bluetooth/hci_uart.h
@@ -35,7 +35,7 @@
35#define HCIUARTGETFLAGS _IOR('U', 204, int) 35#define HCIUARTGETFLAGS _IOR('U', 204, int)
36 36
37/* UART protocols */ 37/* UART protocols */
38#define HCI_UART_MAX_PROTO 8 38#define HCI_UART_MAX_PROTO 9
39 39
40#define HCI_UART_H4 0 40#define HCI_UART_H4 0
41#define HCI_UART_BCSP 1 41#define HCI_UART_BCSP 1
@@ -45,6 +45,7 @@
45#define HCI_UART_ATH3K 5 45#define HCI_UART_ATH3K 5
46#define HCI_UART_INTEL 6 46#define HCI_UART_INTEL 6
47#define HCI_UART_BCM 7 47#define HCI_UART_BCM 7
48#define HCI_UART_QCA 8
48 49
49#define HCI_UART_RAW_DEVICE 0 50#define HCI_UART_RAW_DEVICE 0
50#define HCI_UART_RESET_ON_INIT 1 51#define HCI_UART_RESET_ON_INIT 1
@@ -176,3 +177,8 @@ int intel_deinit(void);
176int bcm_init(void); 177int bcm_init(void);
177int bcm_deinit(void); 178int bcm_deinit(void);
178#endif 179#endif
180
181#ifdef CONFIG_BT_HCIUART_QCA
182int qca_init(void);
183int qca_deinit(void);
184#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-10 07:48:43 -0400