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