1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Texas Instruments' Bluetooth HCILL UART protocol |
4 | * |
5 | * HCILL (HCI Low Level) is a Texas Instruments' power management |
6 | * protocol extension to H4. |
7 | * |
8 | * Copyright (C) 2007 Texas Instruments, Inc. |
9 | * |
10 | * Written by Ohad Ben-Cohen <ohad@bencohen.org> |
11 | * |
12 | * Acknowledgements: |
13 | * This file is based on hci_h4.c, which was written |
14 | * by Maxim Krasnyansky and Marcel Holtmann. |
15 | */ |
16 | |
17 | #include <linux/module.h> |
18 | #include <linux/kernel.h> |
19 | |
20 | #include <linux/init.h> |
21 | #include <linux/sched.h> |
22 | #include <linux/types.h> |
23 | #include <linux/fcntl.h> |
24 | #include <linux/firmware.h> |
25 | #include <linux/interrupt.h> |
26 | #include <linux/ptrace.h> |
27 | #include <linux/poll.h> |
28 | |
29 | #include <linux/slab.h> |
30 | #include <linux/errno.h> |
31 | #include <linux/string.h> |
32 | #include <linux/signal.h> |
33 | #include <linux/ioctl.h> |
34 | #include <linux/of.h> |
35 | #include <linux/serdev.h> |
36 | #include <linux/skbuff.h> |
37 | #include <linux/ti_wilink_st.h> |
38 | #include <linux/clk.h> |
39 | |
40 | #include <net/bluetooth/bluetooth.h> |
41 | #include <net/bluetooth/hci_core.h> |
42 | #include <linux/gpio/consumer.h> |
43 | #include <linux/nvmem-consumer.h> |
44 | |
45 | #include "hci_uart.h" |
46 | |
47 | /* Vendor-specific HCI commands */ |
48 | #define HCI_VS_WRITE_BD_ADDR 0xfc06 |
49 | #define HCI_VS_UPDATE_UART_HCI_BAUDRATE 0xff36 |
50 | |
51 | /* HCILL commands */ |
52 | #define HCILL_GO_TO_SLEEP_IND 0x30 |
53 | #define HCILL_GO_TO_SLEEP_ACK 0x31 |
54 | #define HCILL_WAKE_UP_IND 0x32 |
55 | #define HCILL_WAKE_UP_ACK 0x33 |
56 | |
57 | /* HCILL states */ |
58 | enum hcill_states_e { |
59 | HCILL_ASLEEP, |
60 | HCILL_ASLEEP_TO_AWAKE, |
61 | HCILL_AWAKE, |
62 | HCILL_AWAKE_TO_ASLEEP |
63 | }; |
64 | |
65 | struct ll_device { |
66 | struct hci_uart hu; |
67 | struct serdev_device *serdev; |
68 | struct gpio_desc *enable_gpio; |
69 | struct clk *ext_clk; |
70 | bdaddr_t bdaddr; |
71 | }; |
72 | |
73 | struct ll_struct { |
74 | struct sk_buff *rx_skb; |
75 | struct sk_buff_head txq; |
76 | spinlock_t hcill_lock; /* HCILL state lock */ |
77 | unsigned long hcill_state; /* HCILL power state */ |
78 | struct sk_buff_head tx_wait_q; /* HCILL wait queue */ |
79 | }; |
80 | |
81 | /* |
82 | * Builds and sends an HCILL command packet. |
83 | * These are very simple packets with only 1 cmd byte |
84 | */ |
85 | static int send_hcill_cmd(u8 cmd, struct hci_uart *hu) |
86 | { |
87 | int err = 0; |
88 | struct sk_buff *skb = NULL; |
89 | struct ll_struct *ll = hu->priv; |
90 | |
91 | BT_DBG("hu %p cmd 0x%x" , hu, cmd); |
92 | |
93 | /* allocate packet */ |
94 | skb = bt_skb_alloc(len: 1, GFP_ATOMIC); |
95 | if (!skb) { |
96 | BT_ERR("cannot allocate memory for HCILL packet" ); |
97 | err = -ENOMEM; |
98 | goto out; |
99 | } |
100 | |
101 | /* prepare packet */ |
102 | skb_put_u8(skb, val: cmd); |
103 | |
104 | /* send packet */ |
105 | skb_queue_tail(list: &ll->txq, newsk: skb); |
106 | out: |
107 | return err; |
108 | } |
109 | |
110 | /* Initialize protocol */ |
111 | static int ll_open(struct hci_uart *hu) |
112 | { |
113 | struct ll_struct *ll; |
114 | |
115 | BT_DBG("hu %p" , hu); |
116 | |
117 | ll = kzalloc(size: sizeof(*ll), GFP_KERNEL); |
118 | if (!ll) |
119 | return -ENOMEM; |
120 | |
121 | skb_queue_head_init(list: &ll->txq); |
122 | skb_queue_head_init(list: &ll->tx_wait_q); |
123 | spin_lock_init(&ll->hcill_lock); |
124 | |
125 | ll->hcill_state = HCILL_AWAKE; |
126 | |
127 | hu->priv = ll; |
128 | |
129 | if (hu->serdev) { |
130 | struct ll_device *lldev = serdev_device_get_drvdata(serdev: hu->serdev); |
131 | |
132 | if (!IS_ERR(ptr: lldev->ext_clk)) |
133 | clk_prepare_enable(clk: lldev->ext_clk); |
134 | } |
135 | |
136 | return 0; |
137 | } |
138 | |
139 | /* Flush protocol data */ |
140 | static int ll_flush(struct hci_uart *hu) |
141 | { |
142 | struct ll_struct *ll = hu->priv; |
143 | |
144 | BT_DBG("hu %p" , hu); |
145 | |
146 | skb_queue_purge(list: &ll->tx_wait_q); |
147 | skb_queue_purge(list: &ll->txq); |
148 | |
149 | return 0; |
150 | } |
151 | |
152 | /* Close protocol */ |
153 | static int ll_close(struct hci_uart *hu) |
154 | { |
155 | struct ll_struct *ll = hu->priv; |
156 | |
157 | BT_DBG("hu %p" , hu); |
158 | |
159 | skb_queue_purge(list: &ll->tx_wait_q); |
160 | skb_queue_purge(list: &ll->txq); |
161 | |
162 | kfree_skb(skb: ll->rx_skb); |
163 | |
164 | if (hu->serdev) { |
165 | struct ll_device *lldev = serdev_device_get_drvdata(serdev: hu->serdev); |
166 | |
167 | gpiod_set_value_cansleep(desc: lldev->enable_gpio, value: 0); |
168 | |
169 | clk_disable_unprepare(clk: lldev->ext_clk); |
170 | } |
171 | |
172 | hu->priv = NULL; |
173 | |
174 | kfree(objp: ll); |
175 | |
176 | return 0; |
177 | } |
178 | |
179 | /* |
180 | * internal function, which does common work of the device wake up process: |
181 | * 1. places all pending packets (waiting in tx_wait_q list) in txq list. |
182 | * 2. changes internal state to HCILL_AWAKE. |
183 | * Note: assumes that hcill_lock spinlock is taken, |
184 | * shouldn't be called otherwise! |
185 | */ |
186 | static void __ll_do_awake(struct ll_struct *ll) |
187 | { |
188 | struct sk_buff *skb = NULL; |
189 | |
190 | while ((skb = skb_dequeue(list: &ll->tx_wait_q))) |
191 | skb_queue_tail(list: &ll->txq, newsk: skb); |
192 | |
193 | ll->hcill_state = HCILL_AWAKE; |
194 | } |
195 | |
196 | /* |
197 | * Called upon a wake-up-indication from the device |
198 | */ |
199 | static void ll_device_want_to_wakeup(struct hci_uart *hu) |
200 | { |
201 | unsigned long flags; |
202 | struct ll_struct *ll = hu->priv; |
203 | |
204 | BT_DBG("hu %p" , hu); |
205 | |
206 | /* lock hcill state */ |
207 | spin_lock_irqsave(&ll->hcill_lock, flags); |
208 | |
209 | switch (ll->hcill_state) { |
210 | case HCILL_ASLEEP_TO_AWAKE: |
211 | /* |
212 | * This state means that both the host and the BRF chip |
213 | * have simultaneously sent a wake-up-indication packet. |
214 | * Traditionally, in this case, receiving a wake-up-indication |
215 | * was enough and an additional wake-up-ack wasn't needed. |
216 | * This has changed with the BRF6350, which does require an |
217 | * explicit wake-up-ack. Other BRF versions, which do not |
218 | * require an explicit ack here, do accept it, thus it is |
219 | * perfectly safe to always send one. |
220 | */ |
221 | BT_DBG("dual wake-up-indication" ); |
222 | fallthrough; |
223 | case HCILL_ASLEEP: |
224 | /* acknowledge device wake up */ |
225 | if (send_hcill_cmd(HCILL_WAKE_UP_ACK, hu) < 0) { |
226 | BT_ERR("cannot acknowledge device wake up" ); |
227 | goto out; |
228 | } |
229 | break; |
230 | default: |
231 | /* any other state is illegal */ |
232 | BT_ERR("received HCILL_WAKE_UP_IND in state %ld" , |
233 | ll->hcill_state); |
234 | break; |
235 | } |
236 | |
237 | /* send pending packets and change state to HCILL_AWAKE */ |
238 | __ll_do_awake(ll); |
239 | |
240 | out: |
241 | spin_unlock_irqrestore(lock: &ll->hcill_lock, flags); |
242 | |
243 | /* actually send the packets */ |
244 | hci_uart_tx_wakeup(hu); |
245 | } |
246 | |
247 | /* |
248 | * Called upon a sleep-indication from the device |
249 | */ |
250 | static void ll_device_want_to_sleep(struct hci_uart *hu) |
251 | { |
252 | unsigned long flags; |
253 | struct ll_struct *ll = hu->priv; |
254 | |
255 | BT_DBG("hu %p" , hu); |
256 | |
257 | /* lock hcill state */ |
258 | spin_lock_irqsave(&ll->hcill_lock, flags); |
259 | |
260 | /* sanity check */ |
261 | if (ll->hcill_state != HCILL_AWAKE) |
262 | BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld" , |
263 | ll->hcill_state); |
264 | |
265 | /* acknowledge device sleep */ |
266 | if (send_hcill_cmd(HCILL_GO_TO_SLEEP_ACK, hu) < 0) { |
267 | BT_ERR("cannot acknowledge device sleep" ); |
268 | goto out; |
269 | } |
270 | |
271 | /* update state */ |
272 | ll->hcill_state = HCILL_ASLEEP; |
273 | |
274 | out: |
275 | spin_unlock_irqrestore(lock: &ll->hcill_lock, flags); |
276 | |
277 | /* actually send the sleep ack packet */ |
278 | hci_uart_tx_wakeup(hu); |
279 | } |
280 | |
281 | /* |
282 | * Called upon wake-up-acknowledgement from the device |
283 | */ |
284 | static void ll_device_woke_up(struct hci_uart *hu) |
285 | { |
286 | unsigned long flags; |
287 | struct ll_struct *ll = hu->priv; |
288 | |
289 | BT_DBG("hu %p" , hu); |
290 | |
291 | /* lock hcill state */ |
292 | spin_lock_irqsave(&ll->hcill_lock, flags); |
293 | |
294 | /* sanity check */ |
295 | if (ll->hcill_state != HCILL_ASLEEP_TO_AWAKE) |
296 | BT_ERR("received HCILL_WAKE_UP_ACK in state %ld" , |
297 | ll->hcill_state); |
298 | |
299 | /* send pending packets and change state to HCILL_AWAKE */ |
300 | __ll_do_awake(ll); |
301 | |
302 | spin_unlock_irqrestore(lock: &ll->hcill_lock, flags); |
303 | |
304 | /* actually send the packets */ |
305 | hci_uart_tx_wakeup(hu); |
306 | } |
307 | |
308 | /* Enqueue frame for transmittion (padding, crc, etc) */ |
309 | /* may be called from two simultaneous tasklets */ |
310 | static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb) |
311 | { |
312 | unsigned long flags = 0; |
313 | struct ll_struct *ll = hu->priv; |
314 | |
315 | BT_DBG("hu %p skb %p" , hu, skb); |
316 | |
317 | /* Prepend skb with frame type */ |
318 | memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); |
319 | |
320 | /* lock hcill state */ |
321 | spin_lock_irqsave(&ll->hcill_lock, flags); |
322 | |
323 | /* act according to current state */ |
324 | switch (ll->hcill_state) { |
325 | case HCILL_AWAKE: |
326 | BT_DBG("device awake, sending normally" ); |
327 | skb_queue_tail(list: &ll->txq, newsk: skb); |
328 | break; |
329 | case HCILL_ASLEEP: |
330 | BT_DBG("device asleep, waking up and queueing packet" ); |
331 | /* save packet for later */ |
332 | skb_queue_tail(list: &ll->tx_wait_q, newsk: skb); |
333 | /* awake device */ |
334 | if (send_hcill_cmd(HCILL_WAKE_UP_IND, hu) < 0) { |
335 | BT_ERR("cannot wake up device" ); |
336 | break; |
337 | } |
338 | ll->hcill_state = HCILL_ASLEEP_TO_AWAKE; |
339 | break; |
340 | case HCILL_ASLEEP_TO_AWAKE: |
341 | BT_DBG("device waking up, queueing packet" ); |
342 | /* transient state; just keep packet for later */ |
343 | skb_queue_tail(list: &ll->tx_wait_q, newsk: skb); |
344 | break; |
345 | default: |
346 | BT_ERR("illegal hcill state: %ld (losing packet)" , |
347 | ll->hcill_state); |
348 | dev_kfree_skb_irq(skb); |
349 | break; |
350 | } |
351 | |
352 | spin_unlock_irqrestore(lock: &ll->hcill_lock, flags); |
353 | |
354 | return 0; |
355 | } |
356 | |
357 | static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) |
358 | { |
359 | struct hci_uart *hu = hci_get_drvdata(hdev); |
360 | struct ll_struct *ll = hu->priv; |
361 | |
362 | switch (hci_skb_pkt_type(skb)) { |
363 | case HCILL_GO_TO_SLEEP_IND: |
364 | BT_DBG("HCILL_GO_TO_SLEEP_IND packet" ); |
365 | ll_device_want_to_sleep(hu); |
366 | break; |
367 | case HCILL_GO_TO_SLEEP_ACK: |
368 | /* shouldn't happen */ |
369 | bt_dev_err(hdev, "received HCILL_GO_TO_SLEEP_ACK in state %ld" , |
370 | ll->hcill_state); |
371 | break; |
372 | case HCILL_WAKE_UP_IND: |
373 | BT_DBG("HCILL_WAKE_UP_IND packet" ); |
374 | ll_device_want_to_wakeup(hu); |
375 | break; |
376 | case HCILL_WAKE_UP_ACK: |
377 | BT_DBG("HCILL_WAKE_UP_ACK packet" ); |
378 | ll_device_woke_up(hu); |
379 | break; |
380 | } |
381 | |
382 | kfree_skb(skb); |
383 | return 0; |
384 | } |
385 | |
386 | #define LL_RECV_SLEEP_IND \ |
387 | .type = HCILL_GO_TO_SLEEP_IND, \ |
388 | .hlen = 0, \ |
389 | .loff = 0, \ |
390 | .lsize = 0, \ |
391 | .maxlen = 0 |
392 | |
393 | #define LL_RECV_SLEEP_ACK \ |
394 | .type = HCILL_GO_TO_SLEEP_ACK, \ |
395 | .hlen = 0, \ |
396 | .loff = 0, \ |
397 | .lsize = 0, \ |
398 | .maxlen = 0 |
399 | |
400 | #define LL_RECV_WAKE_IND \ |
401 | .type = HCILL_WAKE_UP_IND, \ |
402 | .hlen = 0, \ |
403 | .loff = 0, \ |
404 | .lsize = 0, \ |
405 | .maxlen = 0 |
406 | |
407 | #define LL_RECV_WAKE_ACK \ |
408 | .type = HCILL_WAKE_UP_ACK, \ |
409 | .hlen = 0, \ |
410 | .loff = 0, \ |
411 | .lsize = 0, \ |
412 | .maxlen = 0 |
413 | |
414 | static const struct h4_recv_pkt ll_recv_pkts[] = { |
415 | { H4_RECV_ACL, .recv = hci_recv_frame }, |
416 | { H4_RECV_SCO, .recv = hci_recv_frame }, |
417 | { H4_RECV_EVENT, .recv = hci_recv_frame }, |
418 | { LL_RECV_SLEEP_IND, .recv = ll_recv_frame }, |
419 | { LL_RECV_SLEEP_ACK, .recv = ll_recv_frame }, |
420 | { LL_RECV_WAKE_IND, .recv = ll_recv_frame }, |
421 | { LL_RECV_WAKE_ACK, .recv = ll_recv_frame }, |
422 | }; |
423 | |
424 | /* Recv data */ |
425 | static int ll_recv(struct hci_uart *hu, const void *data, int count) |
426 | { |
427 | struct ll_struct *ll = hu->priv; |
428 | |
429 | if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) |
430 | return -EUNATCH; |
431 | |
432 | ll->rx_skb = h4_recv_buf(hdev: hu->hdev, skb: ll->rx_skb, buffer: data, count, |
433 | pkts: ll_recv_pkts, ARRAY_SIZE(ll_recv_pkts)); |
434 | if (IS_ERR(ptr: ll->rx_skb)) { |
435 | int err = PTR_ERR(ptr: ll->rx_skb); |
436 | bt_dev_err(hu->hdev, "Frame reassembly failed (%d)" , err); |
437 | ll->rx_skb = NULL; |
438 | return err; |
439 | } |
440 | |
441 | return count; |
442 | } |
443 | |
444 | static struct sk_buff *ll_dequeue(struct hci_uart *hu) |
445 | { |
446 | struct ll_struct *ll = hu->priv; |
447 | |
448 | return skb_dequeue(list: &ll->txq); |
449 | } |
450 | |
451 | #if IS_ENABLED(CONFIG_SERIAL_DEV_BUS) |
452 | static int read_local_version(struct hci_dev *hdev) |
453 | { |
454 | int err = 0; |
455 | unsigned short version = 0; |
456 | struct sk_buff *skb; |
457 | struct hci_rp_read_local_version *ver; |
458 | |
459 | skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, plen: 0, NULL, |
460 | HCI_INIT_TIMEOUT); |
461 | if (IS_ERR(ptr: skb)) { |
462 | bt_dev_err(hdev, "Reading TI version information failed (%ld)" , |
463 | PTR_ERR(skb)); |
464 | return PTR_ERR(ptr: skb); |
465 | } |
466 | if (skb->len != sizeof(*ver)) { |
467 | err = -EILSEQ; |
468 | goto out; |
469 | } |
470 | |
471 | ver = (struct hci_rp_read_local_version *)skb->data; |
472 | if (le16_to_cpu(ver->manufacturer) != 13) { |
473 | err = -ENODEV; |
474 | goto out; |
475 | } |
476 | |
477 | version = le16_to_cpu(ver->lmp_subver); |
478 | |
479 | out: |
480 | if (err) |
481 | bt_dev_err(hdev, "Failed to read TI version info: %d" , err); |
482 | kfree_skb(skb); |
483 | return err ? err : version; |
484 | } |
485 | |
486 | static int send_command_from_firmware(struct ll_device *lldev, |
487 | struct hci_command *cmd) |
488 | { |
489 | struct sk_buff *skb; |
490 | |
491 | if (cmd->opcode == HCI_VS_UPDATE_UART_HCI_BAUDRATE) { |
492 | /* ignore remote change |
493 | * baud rate HCI VS command |
494 | */ |
495 | bt_dev_warn(lldev->hu.hdev, |
496 | "change remote baud rate command in firmware" ); |
497 | return 0; |
498 | } |
499 | if (cmd->prefix != 1) |
500 | bt_dev_dbg(lldev->hu.hdev, "command type %d" , cmd->prefix); |
501 | |
502 | skb = __hci_cmd_sync(hdev: lldev->hu.hdev, opcode: cmd->opcode, plen: cmd->plen, |
503 | param: &cmd->speed, HCI_INIT_TIMEOUT); |
504 | if (IS_ERR(ptr: skb)) { |
505 | bt_dev_err(lldev->hu.hdev, "send command failed" ); |
506 | return PTR_ERR(ptr: skb); |
507 | } |
508 | kfree_skb(skb); |
509 | return 0; |
510 | } |
511 | |
512 | /* |
513 | * download_firmware - |
514 | * internal function which parses through the .bts firmware |
515 | * script file intreprets SEND, DELAY actions only as of now |
516 | */ |
517 | static int download_firmware(struct ll_device *lldev) |
518 | { |
519 | unsigned short chip, min_ver, maj_ver; |
520 | int version, err, len; |
521 | unsigned char *ptr, *action_ptr; |
522 | unsigned char bts_scr_name[40]; /* 40 char long bts scr name? */ |
523 | const struct firmware *fw; |
524 | struct hci_command *cmd; |
525 | |
526 | version = read_local_version(hdev: lldev->hu.hdev); |
527 | if (version < 0) |
528 | return version; |
529 | |
530 | chip = (version & 0x7C00) >> 10; |
531 | min_ver = (version & 0x007F); |
532 | maj_ver = (version & 0x0380) >> 7; |
533 | if (version & 0x8000) |
534 | maj_ver |= 0x0008; |
535 | |
536 | snprintf(buf: bts_scr_name, size: sizeof(bts_scr_name), |
537 | fmt: "ti-connectivity/TIInit_%d.%d.%d.bts" , |
538 | chip, maj_ver, min_ver); |
539 | |
540 | err = request_firmware(fw: &fw, name: bts_scr_name, device: &lldev->serdev->dev); |
541 | if (err || !fw->data || !fw->size) { |
542 | bt_dev_err(lldev->hu.hdev, "request_firmware failed(errno %d) for %s" , |
543 | err, bts_scr_name); |
544 | return -EINVAL; |
545 | } |
546 | ptr = (void *)fw->data; |
547 | len = fw->size; |
548 | /* bts_header to remove out magic number and |
549 | * version |
550 | */ |
551 | ptr += sizeof(struct bts_header); |
552 | len -= sizeof(struct bts_header); |
553 | |
554 | while (len > 0 && ptr) { |
555 | bt_dev_dbg(lldev->hu.hdev, " action size %d, type %d " , |
556 | ((struct bts_action *)ptr)->size, |
557 | ((struct bts_action *)ptr)->type); |
558 | |
559 | action_ptr = &(((struct bts_action *)ptr)->data[0]); |
560 | |
561 | switch (((struct bts_action *)ptr)->type) { |
562 | case ACTION_SEND_COMMAND: /* action send */ |
563 | bt_dev_dbg(lldev->hu.hdev, "S" ); |
564 | cmd = (struct hci_command *)action_ptr; |
565 | err = send_command_from_firmware(lldev, cmd); |
566 | if (err) |
567 | goto out_rel_fw; |
568 | break; |
569 | case ACTION_WAIT_EVENT: /* wait */ |
570 | /* no need to wait as command was synchronous */ |
571 | bt_dev_dbg(lldev->hu.hdev, "W" ); |
572 | break; |
573 | case ACTION_DELAY: /* sleep */ |
574 | bt_dev_info(lldev->hu.hdev, "sleep command in scr" ); |
575 | msleep(msecs: ((struct bts_action_delay *)action_ptr)->msec); |
576 | break; |
577 | } |
578 | len -= (sizeof(struct bts_action) + |
579 | ((struct bts_action *)ptr)->size); |
580 | ptr += sizeof(struct bts_action) + |
581 | ((struct bts_action *)ptr)->size; |
582 | } |
583 | |
584 | out_rel_fw: |
585 | /* fw download complete */ |
586 | release_firmware(fw); |
587 | return err; |
588 | } |
589 | |
590 | static int ll_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr) |
591 | { |
592 | bdaddr_t bdaddr_swapped; |
593 | struct sk_buff *skb; |
594 | |
595 | /* HCI_VS_WRITE_BD_ADDR (at least on a CC2560A chip) expects the BD |
596 | * address to be MSB first, but bdaddr_t has the convention of being |
597 | * LSB first. |
598 | */ |
599 | baswap(dst: &bdaddr_swapped, src: bdaddr); |
600 | skb = __hci_cmd_sync(hdev, HCI_VS_WRITE_BD_ADDR, plen: sizeof(bdaddr_t), |
601 | param: &bdaddr_swapped, HCI_INIT_TIMEOUT); |
602 | if (!IS_ERR(ptr: skb)) |
603 | kfree_skb(skb); |
604 | |
605 | return PTR_ERR_OR_ZERO(ptr: skb); |
606 | } |
607 | |
608 | static int ll_setup(struct hci_uart *hu) |
609 | { |
610 | int err, retry = 3; |
611 | struct ll_device *lldev; |
612 | struct serdev_device *serdev = hu->serdev; |
613 | u32 speed; |
614 | |
615 | if (!serdev) |
616 | return 0; |
617 | |
618 | lldev = serdev_device_get_drvdata(serdev); |
619 | |
620 | hu->hdev->set_bdaddr = ll_set_bdaddr; |
621 | |
622 | serdev_device_set_flow_control(serdev, true); |
623 | |
624 | do { |
625 | /* Reset the Bluetooth device */ |
626 | gpiod_set_value_cansleep(desc: lldev->enable_gpio, value: 0); |
627 | msleep(msecs: 5); |
628 | gpiod_set_value_cansleep(desc: lldev->enable_gpio, value: 1); |
629 | mdelay(100); |
630 | err = serdev_device_wait_for_cts(serdev, state: true, timeout_ms: 200); |
631 | if (err) { |
632 | bt_dev_err(hu->hdev, "Failed to get CTS" ); |
633 | return err; |
634 | } |
635 | |
636 | err = download_firmware(lldev); |
637 | if (!err) |
638 | break; |
639 | |
640 | /* Toggle BT_EN and retry */ |
641 | bt_dev_err(hu->hdev, "download firmware failed, retrying..." ); |
642 | } while (retry--); |
643 | |
644 | if (err) |
645 | return err; |
646 | |
647 | /* Set BD address if one was specified at probe */ |
648 | if (!bacmp(ba1: &lldev->bdaddr, BDADDR_NONE)) { |
649 | /* This means that there was an error getting the BD address |
650 | * during probe, so mark the device as having a bad address. |
651 | */ |
652 | set_bit(nr: HCI_QUIRK_INVALID_BDADDR, addr: &hu->hdev->quirks); |
653 | } else if (bacmp(ba1: &lldev->bdaddr, BDADDR_ANY)) { |
654 | err = ll_set_bdaddr(hdev: hu->hdev, bdaddr: &lldev->bdaddr); |
655 | if (err) |
656 | set_bit(nr: HCI_QUIRK_INVALID_BDADDR, addr: &hu->hdev->quirks); |
657 | } |
658 | |
659 | /* Operational speed if any */ |
660 | if (hu->oper_speed) |
661 | speed = hu->oper_speed; |
662 | else if (hu->proto->oper_speed) |
663 | speed = hu->proto->oper_speed; |
664 | else |
665 | speed = 0; |
666 | |
667 | if (speed) { |
668 | __le32 speed_le = cpu_to_le32(speed); |
669 | struct sk_buff *skb; |
670 | |
671 | skb = __hci_cmd_sync(hdev: hu->hdev, HCI_VS_UPDATE_UART_HCI_BAUDRATE, |
672 | plen: sizeof(speed_le), param: &speed_le, |
673 | HCI_INIT_TIMEOUT); |
674 | if (!IS_ERR(ptr: skb)) { |
675 | kfree_skb(skb); |
676 | serdev_device_set_baudrate(serdev, speed); |
677 | } |
678 | } |
679 | |
680 | return 0; |
681 | } |
682 | |
683 | static const struct hci_uart_proto llp; |
684 | |
685 | static int hci_ti_probe(struct serdev_device *serdev) |
686 | { |
687 | struct hci_uart *hu; |
688 | struct ll_device *lldev; |
689 | struct nvmem_cell *bdaddr_cell; |
690 | u32 max_speed = 3000000; |
691 | |
692 | lldev = devm_kzalloc(dev: &serdev->dev, size: sizeof(struct ll_device), GFP_KERNEL); |
693 | if (!lldev) |
694 | return -ENOMEM; |
695 | hu = &lldev->hu; |
696 | |
697 | serdev_device_set_drvdata(serdev, data: lldev); |
698 | lldev->serdev = hu->serdev = serdev; |
699 | |
700 | lldev->enable_gpio = devm_gpiod_get_optional(dev: &serdev->dev, |
701 | con_id: "enable" , |
702 | flags: GPIOD_OUT_LOW); |
703 | if (IS_ERR(ptr: lldev->enable_gpio)) |
704 | return PTR_ERR(ptr: lldev->enable_gpio); |
705 | |
706 | lldev->ext_clk = devm_clk_get(dev: &serdev->dev, id: "ext_clock" ); |
707 | if (IS_ERR(ptr: lldev->ext_clk) && PTR_ERR(ptr: lldev->ext_clk) != -ENOENT) |
708 | return PTR_ERR(ptr: lldev->ext_clk); |
709 | |
710 | of_property_read_u32(np: serdev->dev.of_node, propname: "max-speed" , out_value: &max_speed); |
711 | hci_uart_set_speeds(hu, init_speed: 115200, oper_speed: max_speed); |
712 | |
713 | /* optional BD address from nvram */ |
714 | bdaddr_cell = nvmem_cell_get(dev: &serdev->dev, id: "bd-address" ); |
715 | if (IS_ERR(ptr: bdaddr_cell)) { |
716 | int err = PTR_ERR(ptr: bdaddr_cell); |
717 | |
718 | if (err == -EPROBE_DEFER) |
719 | return err; |
720 | |
721 | /* ENOENT means there is no matching nvmem cell and ENOSYS |
722 | * means that nvmem is not enabled in the kernel configuration. |
723 | */ |
724 | if (err != -ENOENT && err != -ENOSYS) { |
725 | /* If there was some other error, give userspace a |
726 | * chance to fix the problem instead of failing to load |
727 | * the driver. Using BDADDR_NONE as a flag that is |
728 | * tested later in the setup function. |
729 | */ |
730 | dev_warn(&serdev->dev, |
731 | "Failed to get \"bd-address\" nvmem cell (%d)\n" , |
732 | err); |
733 | bacpy(dst: &lldev->bdaddr, BDADDR_NONE); |
734 | } |
735 | } else { |
736 | bdaddr_t *bdaddr; |
737 | size_t len; |
738 | |
739 | bdaddr = nvmem_cell_read(cell: bdaddr_cell, len: &len); |
740 | nvmem_cell_put(cell: bdaddr_cell); |
741 | if (IS_ERR(ptr: bdaddr)) { |
742 | dev_err(&serdev->dev, "Failed to read nvmem bd-address\n" ); |
743 | return PTR_ERR(ptr: bdaddr); |
744 | } |
745 | if (len != sizeof(bdaddr_t)) { |
746 | dev_err(&serdev->dev, "Invalid nvmem bd-address length\n" ); |
747 | kfree(objp: bdaddr); |
748 | return -EINVAL; |
749 | } |
750 | |
751 | /* As per the device tree bindings, the value from nvmem is |
752 | * expected to be MSB first, but in the kernel it is expected |
753 | * that bdaddr_t is LSB first. |
754 | */ |
755 | baswap(dst: &lldev->bdaddr, src: bdaddr); |
756 | kfree(objp: bdaddr); |
757 | } |
758 | |
759 | return hci_uart_register_device(hu, p: &llp); |
760 | } |
761 | |
762 | static void hci_ti_remove(struct serdev_device *serdev) |
763 | { |
764 | struct ll_device *lldev = serdev_device_get_drvdata(serdev); |
765 | |
766 | hci_uart_unregister_device(hu: &lldev->hu); |
767 | } |
768 | |
769 | static const struct of_device_id hci_ti_of_match[] = { |
770 | { .compatible = "ti,cc2560" }, |
771 | { .compatible = "ti,wl1271-st" }, |
772 | { .compatible = "ti,wl1273-st" }, |
773 | { .compatible = "ti,wl1281-st" }, |
774 | { .compatible = "ti,wl1283-st" }, |
775 | { .compatible = "ti,wl1285-st" }, |
776 | { .compatible = "ti,wl1801-st" }, |
777 | { .compatible = "ti,wl1805-st" }, |
778 | { .compatible = "ti,wl1807-st" }, |
779 | { .compatible = "ti,wl1831-st" }, |
780 | { .compatible = "ti,wl1835-st" }, |
781 | { .compatible = "ti,wl1837-st" }, |
782 | {}, |
783 | }; |
784 | MODULE_DEVICE_TABLE(of, hci_ti_of_match); |
785 | |
786 | static struct serdev_device_driver hci_ti_drv = { |
787 | .driver = { |
788 | .name = "hci-ti" , |
789 | .of_match_table = hci_ti_of_match, |
790 | }, |
791 | .probe = hci_ti_probe, |
792 | .remove = hci_ti_remove, |
793 | }; |
794 | #else |
795 | #define ll_setup NULL |
796 | #endif |
797 | |
798 | static const struct hci_uart_proto llp = { |
799 | .id = HCI_UART_LL, |
800 | .name = "LL" , |
801 | .setup = ll_setup, |
802 | .open = ll_open, |
803 | .close = ll_close, |
804 | .recv = ll_recv, |
805 | .enqueue = ll_enqueue, |
806 | .dequeue = ll_dequeue, |
807 | .flush = ll_flush, |
808 | }; |
809 | |
810 | int __init ll_init(void) |
811 | { |
812 | serdev_device_driver_register(&hci_ti_drv); |
813 | |
814 | return hci_uart_register_proto(p: &llp); |
815 | } |
816 | |
817 | int __exit ll_deinit(void) |
818 | { |
819 | serdev_device_driver_unregister(sdrv: &hci_ti_drv); |
820 | |
821 | return hci_uart_unregister_proto(p: &llp); |
822 | } |
823 | |