Commit | Line | Data |
---|---|---|
45051539 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
166d2f6a OBC |
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. | |
166d2f6a OBC |
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> | |
37180552 | 24 | #include <linux/firmware.h> |
166d2f6a OBC |
25 | #include <linux/interrupt.h> |
26 | #include <linux/ptrace.h> | |
27 | #include <linux/poll.h> | |
28 | ||
29 | #include <linux/slab.h> | |
166d2f6a OBC |
30 | #include <linux/errno.h> |
31 | #include <linux/string.h> | |
32 | #include <linux/signal.h> | |
33 | #include <linux/ioctl.h> | |
37180552 RH |
34 | #include <linux/of.h> |
35 | #include <linux/serdev.h> | |
166d2f6a | 36 | #include <linux/skbuff.h> |
37180552 | 37 | #include <linux/ti_wilink_st.h> |
43d3d092 | 38 | #include <linux/clk.h> |
166d2f6a OBC |
39 | |
40 | #include <net/bluetooth/bluetooth.h> | |
41 | #include <net/bluetooth/hci_core.h> | |
37180552 | 42 | #include <linux/gpio/consumer.h> |
0e58d0cd | 43 | #include <linux/nvmem-consumer.h> |
166d2f6a OBC |
44 | |
45 | #include "hci_uart.h" | |
46 | ||
7c6ca120 | 47 | /* Vendor-specific HCI commands */ |
aa099398 | 48 | #define HCI_VS_WRITE_BD_ADDR 0xfc06 |
7c6ca120 DL |
49 | #define HCI_VS_UPDATE_UART_HCI_BAUDRATE 0xff36 |
50 | ||
166d2f6a OBC |
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 | ||
166d2f6a OBC |
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 | ||
37180552 RH |
65 | struct ll_device { |
66 | struct hci_uart hu; | |
67 | struct serdev_device *serdev; | |
68 | struct gpio_desc *enable_gpio; | |
43d3d092 | 69 | struct clk *ext_clk; |
0e58d0cd | 70 | bdaddr_t bdaddr; |
37180552 RH |
71 | }; |
72 | ||
166d2f6a | 73 | struct ll_struct { |
166d2f6a OBC |
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; | |
166d2f6a OBC |
90 | |
91 | BT_DBG("hu %p cmd 0x%x", hu, cmd); | |
92 | ||
93 | /* allocate packet */ | |
94 | skb = bt_skb_alloc(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 */ | |
9bef22fb | 102 | skb_put_u8(skb, cmd); |
166d2f6a OBC |
103 | |
104 | /* send packet */ | |
105 | skb_queue_tail(&ll->txq, 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 | ||
9eb648c3 | 117 | ll = kzalloc(sizeof(*ll), GFP_KERNEL); |
166d2f6a OBC |
118 | if (!ll) |
119 | return -ENOMEM; | |
120 | ||
121 | skb_queue_head_init(&ll->txq); | |
122 | skb_queue_head_init(&ll->tx_wait_q); | |
123 | spin_lock_init(&ll->hcill_lock); | |
124 | ||
125 | ll->hcill_state = HCILL_AWAKE; | |
126 | ||
127 | hu->priv = ll; | |
128 | ||
43d3d092 UH |
129 | if (hu->serdev) { |
130 | struct ll_device *lldev = serdev_device_get_drvdata(hu->serdev); | |
82b7d856 | 131 | |
43d3d092 UH |
132 | if (!IS_ERR(lldev->ext_clk)) |
133 | clk_prepare_enable(lldev->ext_clk); | |
134 | } | |
37180552 | 135 | |
166d2f6a OBC |
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(&ll->tx_wait_q); | |
147 | skb_queue_purge(&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(&ll->tx_wait_q); | |
160 | skb_queue_purge(&ll->txq); | |
161 | ||
b1fb0683 | 162 | kfree_skb(ll->rx_skb); |
166d2f6a | 163 | |
37180552 RH |
164 | if (hu->serdev) { |
165 | struct ll_device *lldev = serdev_device_get_drvdata(hu->serdev); | |
82b7d856 | 166 | |
37180552 RH |
167 | gpiod_set_value_cansleep(lldev->enable_gpio, 0); |
168 | ||
43d3d092 | 169 | clk_disable_unprepare(lldev->ext_clk); |
37180552 RH |
170 | } |
171 | ||
166d2f6a OBC |
172 | hu->priv = NULL; |
173 | ||
174 | kfree(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(&ll->tx_wait_q))) | |
191 | skb_queue_tail(&ll->txq, 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) { | |
5c548226 OBC |
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. | |
25985edc | 214 | * Traditionally, in this case, receiving a wake-up-indication |
5c548226 OBC |
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"); | |
fac72b24 | 222 | /* fall through */ |
166d2f6a OBC |
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; | |
166d2f6a | 230 | default: |
5c548226 | 231 | /* any other state is illegal */ |
82b7d856 FS |
232 | BT_ERR("received HCILL_WAKE_UP_IND in state %ld", |
233 | ll->hcill_state); | |
166d2f6a OBC |
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(&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) | |
82b7d856 FS |
262 | BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", |
263 | ll->hcill_state); | |
166d2f6a OBC |
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(&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) | |
82b7d856 FS |
296 | BT_ERR("received HCILL_WAKE_UP_ACK in state %ld", |
297 | ll->hcill_state); | |
166d2f6a OBC |
298 | |
299 | /* send pending packets and change state to HCILL_AWAKE */ | |
300 | __ll_do_awake(ll); | |
301 | ||
302 | spin_unlock_irqrestore(&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 */ | |
618e8bc2 | 318 | memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); |
166d2f6a OBC |
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(&ll->txq, 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(&ll->tx_wait_q, 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(&ll->tx_wait_q, skb); | |
344 | break; | |
345 | default: | |
82b7d856 FS |
346 | BT_ERR("illegal hcill state: %ld (losing packet)", |
347 | ll->hcill_state); | |
166d2f6a OBC |
348 | kfree_skb(skb); |
349 | break; | |
350 | } | |
351 | ||
352 | spin_unlock_irqrestore(&ll->hcill_lock, flags); | |
353 | ||
354 | return 0; | |
355 | } | |
356 | ||
f9d7c8fd | 357 | static int ll_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) |
166d2f6a | 358 | { |
f9d7c8fd MH |
359 | struct hci_uart *hu = hci_get_drvdata(hdev); |
360 | struct ll_struct *ll = hu->priv; | |
166d2f6a | 361 | |
f9d7c8fd MH |
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 | } | |
166d2f6a | 381 | |
f9d7c8fd | 382 | kfree_skb(skb); |
166d2f6a OBC |
383 | return 0; |
384 | } | |
385 | ||
f9d7c8fd MH |
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 | ||
166d2f6a | 424 | /* Recv data */ |
9d1c40eb | 425 | static int ll_recv(struct hci_uart *hu, const void *data, int count) |
166d2f6a OBC |
426 | { |
427 | struct ll_struct *ll = hu->priv; | |
166d2f6a | 428 | |
f9d7c8fd MH |
429 | if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) |
430 | return -EUNATCH; | |
166d2f6a | 431 | |
f9d7c8fd MH |
432 | ll->rx_skb = h4_recv_buf(hu->hdev, ll->rx_skb, data, count, |
433 | ll_recv_pkts, ARRAY_SIZE(ll_recv_pkts)); | |
434 | if (IS_ERR(ll->rx_skb)) { | |
435 | int err = PTR_ERR(ll->rx_skb); | |
436 | bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); | |
437 | ll->rx_skb = NULL; | |
438 | return err; | |
166d2f6a OBC |
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; | |
82b7d856 | 447 | |
166d2f6a OBC |
448 | return skb_dequeue(&ll->txq); |
449 | } | |
450 | ||
37180552 RH |
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 | ||
82b7d856 FS |
459 | skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL, |
460 | HCI_INIT_TIMEOUT); | |
37180552 RH |
461 | if (IS_ERR(skb)) { |
462 | bt_dev_err(hdev, "Reading TI version information failed (%ld)", | |
463 | PTR_ERR(skb)); | |
f2edd9f6 | 464 | return PTR_ERR(skb); |
37180552 RH |
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: | |
82b7d856 FS |
480 | if (err) |
481 | bt_dev_err(hdev, "Failed to read TI version info: %d", err); | |
37180552 RH |
482 | kfree_skb(skb); |
483 | return err ? err : version; | |
484 | } | |
485 | ||
6322f377 FS |
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(lldev->hu.hdev, cmd->opcode, cmd->plen, | |
503 | &cmd->speed, HCI_INIT_TIMEOUT); | |
504 | if (IS_ERR(skb)) { | |
505 | bt_dev_err(lldev->hu.hdev, "send command failed"); | |
506 | return PTR_ERR(skb); | |
507 | } | |
508 | kfree_skb(skb); | |
509 | return 0; | |
510 | } | |
511 | ||
37180552 RH |
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; | |
37180552 RH |
524 | struct hci_command *cmd; |
525 | ||
526 | version = read_local_version(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(bts_scr_name, sizeof(bts_scr_name), | |
537 | "ti-connectivity/TIInit_%d.%d.%d.bts", | |
538 | chip, maj_ver, min_ver); | |
539 | ||
540 | err = request_firmware(&fw, bts_scr_name, &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; | |
6322f377 FS |
565 | err = send_command_from_firmware(lldev, cmd); |
566 | if (err) | |
37180552 | 567 | goto out_rel_fw; |
37180552 RH |
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"); | |
06633ee1 | 575 | msleep(((struct bts_action_delay *)action_ptr)->msec); |
37180552 RH |
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 | ||
aa099398 DL |
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(&bdaddr_swapped, bdaddr); | |
600 | skb = __hci_cmd_sync(hdev, HCI_VS_WRITE_BD_ADDR, sizeof(bdaddr_t), | |
601 | &bdaddr_swapped, HCI_INIT_TIMEOUT); | |
602 | if (!IS_ERR(skb)) | |
603 | kfree_skb(skb); | |
604 | ||
605 | return PTR_ERR_OR_ZERO(skb); | |
606 | } | |
607 | ||
37180552 RH |
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 | ||
aa099398 DL |
620 | hu->hdev->set_bdaddr = ll_set_bdaddr; |
621 | ||
37180552 RH |
622 | serdev_device_set_flow_control(serdev, true); |
623 | ||
a2e02f38 PP |
624 | if (hu->oper_speed) |
625 | speed = hu->oper_speed; | |
626 | else if (hu->proto->oper_speed) | |
627 | speed = hu->proto->oper_speed; | |
628 | else | |
629 | speed = 0; | |
630 | ||
37180552 | 631 | do { |
d54fdcf9 | 632 | /* Reset the Bluetooth device */ |
37180552 RH |
633 | gpiod_set_value_cansleep(lldev->enable_gpio, 0); |
634 | msleep(5); | |
635 | gpiod_set_value_cansleep(lldev->enable_gpio, 1); | |
d54fdcf9 DL |
636 | err = serdev_device_wait_for_cts(serdev, true, 200); |
637 | if (err) { | |
638 | bt_dev_err(hu->hdev, "Failed to get CTS"); | |
639 | return err; | |
640 | } | |
37180552 | 641 | |
a2e02f38 PP |
642 | if (speed) { |
643 | __le32 speed_le = cpu_to_le32(speed); | |
644 | struct sk_buff *skb; | |
645 | ||
646 | skb = __hci_cmd_sync(hu->hdev, | |
647 | HCI_VS_UPDATE_UART_HCI_BAUDRATE, | |
648 | sizeof(speed_le), &speed_le, | |
649 | HCI_INIT_TIMEOUT); | |
650 | if (!IS_ERR(skb)) { | |
651 | kfree_skb(skb); | |
652 | serdev_device_set_baudrate(serdev, speed); | |
653 | } | |
654 | } | |
655 | ||
37180552 RH |
656 | err = download_firmware(lldev); |
657 | if (!err) | |
658 | break; | |
659 | ||
660 | /* Toggle BT_EN and retry */ | |
661 | bt_dev_err(hu->hdev, "download firmware failed, retrying..."); | |
662 | } while (retry--); | |
663 | ||
664 | if (err) | |
665 | return err; | |
666 | ||
0e58d0cd DL |
667 | /* Set BD address if one was specified at probe */ |
668 | if (!bacmp(&lldev->bdaddr, BDADDR_NONE)) { | |
669 | /* This means that there was an error getting the BD address | |
670 | * during probe, so mark the device as having a bad address. | |
671 | */ | |
672 | set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks); | |
673 | } else if (bacmp(&lldev->bdaddr, BDADDR_ANY)) { | |
674 | err = ll_set_bdaddr(hu->hdev, &lldev->bdaddr); | |
675 | if (err) | |
676 | set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks); | |
677 | } | |
678 | ||
37180552 | 679 | /* Operational speed if any */ |
7c6ca120 | 680 | |
37180552 RH |
681 | |
682 | return 0; | |
683 | } | |
684 | ||
685 | static const struct hci_uart_proto llp; | |
686 | ||
687 | static int hci_ti_probe(struct serdev_device *serdev) | |
688 | { | |
689 | struct hci_uart *hu; | |
690 | struct ll_device *lldev; | |
0e58d0cd | 691 | struct nvmem_cell *bdaddr_cell; |
37180552 RH |
692 | u32 max_speed = 3000000; |
693 | ||
694 | lldev = devm_kzalloc(&serdev->dev, sizeof(struct ll_device), GFP_KERNEL); | |
695 | if (!lldev) | |
696 | return -ENOMEM; | |
697 | hu = &lldev->hu; | |
698 | ||
699 | serdev_device_set_drvdata(serdev, lldev); | |
700 | lldev->serdev = hu->serdev = serdev; | |
701 | ||
82b7d856 FS |
702 | lldev->enable_gpio = devm_gpiod_get_optional(&serdev->dev, |
703 | "enable", | |
704 | GPIOD_OUT_LOW); | |
37180552 RH |
705 | if (IS_ERR(lldev->enable_gpio)) |
706 | return PTR_ERR(lldev->enable_gpio); | |
707 | ||
43d3d092 UH |
708 | lldev->ext_clk = devm_clk_get(&serdev->dev, "ext_clock"); |
709 | if (IS_ERR(lldev->ext_clk) && PTR_ERR(lldev->ext_clk) != -ENOENT) | |
710 | return PTR_ERR(lldev->ext_clk); | |
711 | ||
37180552 RH |
712 | of_property_read_u32(serdev->dev.of_node, "max-speed", &max_speed); |
713 | hci_uart_set_speeds(hu, 115200, max_speed); | |
714 | ||
0e58d0cd DL |
715 | /* optional BD address from nvram */ |
716 | bdaddr_cell = nvmem_cell_get(&serdev->dev, "bd-address"); | |
717 | if (IS_ERR(bdaddr_cell)) { | |
718 | int err = PTR_ERR(bdaddr_cell); | |
719 | ||
720 | if (err == -EPROBE_DEFER) | |
721 | return err; | |
722 | ||
723 | /* ENOENT means there is no matching nvmem cell and ENOSYS | |
724 | * means that nvmem is not enabled in the kernel configuration. | |
725 | */ | |
726 | if (err != -ENOENT && err != -ENOSYS) { | |
727 | /* If there was some other error, give userspace a | |
728 | * chance to fix the problem instead of failing to load | |
729 | * the driver. Using BDADDR_NONE as a flag that is | |
730 | * tested later in the setup function. | |
731 | */ | |
732 | dev_warn(&serdev->dev, | |
733 | "Failed to get \"bd-address\" nvmem cell (%d)\n", | |
734 | err); | |
735 | bacpy(&lldev->bdaddr, BDADDR_NONE); | |
736 | } | |
737 | } else { | |
738 | bdaddr_t *bdaddr; | |
739 | size_t len; | |
740 | ||
741 | bdaddr = nvmem_cell_read(bdaddr_cell, &len); | |
742 | nvmem_cell_put(bdaddr_cell); | |
743 | if (IS_ERR(bdaddr)) { | |
744 | dev_err(&serdev->dev, "Failed to read nvmem bd-address\n"); | |
745 | return PTR_ERR(bdaddr); | |
746 | } | |
747 | if (len != sizeof(bdaddr_t)) { | |
748 | dev_err(&serdev->dev, "Invalid nvmem bd-address length\n"); | |
749 | kfree(bdaddr); | |
750 | return -EINVAL; | |
751 | } | |
752 | ||
753 | /* As per the device tree bindings, the value from nvmem is | |
754 | * expected to be MSB first, but in the kernel it is expected | |
755 | * that bdaddr_t is LSB first. | |
756 | */ | |
757 | baswap(&lldev->bdaddr, bdaddr); | |
758 | kfree(bdaddr); | |
759 | } | |
760 | ||
37180552 RH |
761 | return hci_uart_register_device(hu, &llp); |
762 | } | |
763 | ||
764 | static void hci_ti_remove(struct serdev_device *serdev) | |
765 | { | |
766 | struct ll_device *lldev = serdev_device_get_drvdata(serdev); | |
37180552 | 767 | |
37f5258d | 768 | hci_uart_unregister_device(&lldev->hu); |
37180552 RH |
769 | } |
770 | ||
771 | static const struct of_device_id hci_ti_of_match[] = { | |
4166493c | 772 | { .compatible = "ti,cc2560" }, |
c127a871 SR |
773 | { .compatible = "ti,wl1271-st" }, |
774 | { .compatible = "ti,wl1273-st" }, | |
775 | { .compatible = "ti,wl1281-st" }, | |
776 | { .compatible = "ti,wl1283-st" }, | |
777 | { .compatible = "ti,wl1285-st" }, | |
778 | { .compatible = "ti,wl1801-st" }, | |
779 | { .compatible = "ti,wl1805-st" }, | |
780 | { .compatible = "ti,wl1807-st" }, | |
37180552 RH |
781 | { .compatible = "ti,wl1831-st" }, |
782 | { .compatible = "ti,wl1835-st" }, | |
783 | { .compatible = "ti,wl1837-st" }, | |
784 | {}, | |
785 | }; | |
786 | MODULE_DEVICE_TABLE(of, hci_ti_of_match); | |
787 | ||
788 | static struct serdev_device_driver hci_ti_drv = { | |
789 | .driver = { | |
790 | .name = "hci-ti", | |
791 | .of_match_table = of_match_ptr(hci_ti_of_match), | |
792 | }, | |
793 | .probe = hci_ti_probe, | |
794 | .remove = hci_ti_remove, | |
795 | }; | |
796 | #else | |
797 | #define ll_setup NULL | |
798 | #endif | |
799 | ||
4ee7ef19 | 800 | static const struct hci_uart_proto llp = { |
166d2f6a | 801 | .id = HCI_UART_LL, |
7c40fb8d | 802 | .name = "LL", |
37180552 | 803 | .setup = ll_setup, |
166d2f6a OBC |
804 | .open = ll_open, |
805 | .close = ll_close, | |
806 | .recv = ll_recv, | |
807 | .enqueue = ll_enqueue, | |
808 | .dequeue = ll_dequeue, | |
809 | .flush = ll_flush, | |
810 | }; | |
811 | ||
f2b94bb9 | 812 | int __init ll_init(void) |
166d2f6a | 813 | { |
37180552 RH |
814 | serdev_device_driver_register(&hci_ti_drv); |
815 | ||
01009eec | 816 | return hci_uart_register_proto(&llp); |
166d2f6a OBC |
817 | } |
818 | ||
f2b94bb9 | 819 | int __exit ll_deinit(void) |
166d2f6a | 820 | { |
37180552 RH |
821 | serdev_device_driver_unregister(&hci_ti_drv); |
822 | ||
166d2f6a OBC |
823 | return hci_uart_unregister_proto(&llp); |
824 | } |