1 // SPDX-License-Identifier: (GPL-2.0-only OR MIT)
2 /*
3 * Copyright (C) 2024 Amlogic, Inc. All rights reserved
4 */
5
6 #include <linux/kernel.h>
7 #include <linux/delay.h>
8 #include <linux/device.h>
9 #include <linux/property.h>
10 #include <linux/of.h>
11 #include <linux/serdev.h>
12 #include <linux/clk.h>
13 #include <linux/firmware.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/regulator/consumer.h>
16 #include <net/bluetooth/bluetooth.h>
17 #include <net/bluetooth/hci_core.h>
18 #include <net/bluetooth/hci.h>
19
20 #include "hci_uart.h"
21
22 #define AML_EVT_HEAD_SIZE 4
23 #define AML_BDADDR_DEFAULT (&(bdaddr_t) {{ 0x00, 0xff, 0x00, 0x22, 0x2d, 0xae }})
24
25 #define AML_FIRMWARE_OPERATION_SIZE (248)
26 #define AML_FIRMWARE_MAX_SIZE (512 * 1024)
27
28 /* TCI command */
29 #define AML_TCI_CMD_READ 0xFEF0
30 #define AML_TCI_CMD_WRITE 0xFEF1
31 #define AML_TCI_CMD_UPDATE_BAUDRATE 0xFEF2
32 #define AML_TCI_CMD_HARDWARE_RESET 0xFEF2
33 #define AML_TCI_CMD_DOWNLOAD_BT_FW 0xFEF3
34
35 /* Vendor command */
36 #define AML_BT_HCI_VENDOR_CMD 0xFC1A
37
38 /* TCI operation parameter in controller chip */
39 #define AML_OP_UART_MODE 0x00A30128
40 #define AML_OP_EVT_ENABLE 0x00A70014
41 #define AML_OP_MEM_HARD_TRANS_EN 0x00A7000C
42 #define AML_OP_RF_CFG 0x00F03040
43 #define AML_OP_RAM_POWER_CTR 0x00F03050
44 #define AML_OP_HARDWARE_RST 0x00F03058
45 #define AML_OP_ICCM_RAM_BASE 0x00000000
46 #define AML_OP_DCCM_RAM_BASE 0x00D00000
47
48 /* UART configuration */
49 #define AML_UART_XMIT_EN BIT(12)
50 #define AML_UART_RECV_EN BIT(13)
51 #define AML_UART_TIMEOUT_INT_EN BIT(14)
52 #define AML_UART_CLK_SOURCE 40000000
53
54 /* Controller event */
55 #define AML_EVT_EN BIT(24)
56
57 /* RAM power control */
58 #define AML_RAM_POWER_ON (0)
59 #define AML_RAM_POWER_OFF (1)
60
61 /* RF configuration */
62 #define AML_RF_ANT_SINGLE BIT(28)
63 #define AML_RF_ANT_DOUBLE BIT(29)
64
65 /* Memory transaction */
66 #define AML_MM_CTR_HARD_TRAS_EN BIT(27)
67
68 /* Controller reset */
69 #define AML_CTR_CPU_RESET BIT(8)
70 #define AML_CTR_MAC_RESET BIT(9)
71 #define AML_CTR_PHY_RESET BIT(10)
72
73 enum {
74 FW_ICCM,
75 FW_DCCM
76 };
77
78 struct aml_fw_len {
79 u32 iccm_len;
80 u32 dccm_len;
81 };
82
83 struct aml_tci_rsp {
84 u8 num_cmd_packet;
85 u16 opcode;
86 u8 status;
87 } __packed;
88
89 struct aml_device_data {
90 int iccm_offset;
91 int dccm_offset;
92 bool is_coex;
93 };
94
95 struct aml_serdev {
96 struct hci_uart serdev_hu;
97 struct device *dev;
98 struct gpio_desc *bt_en_gpio;
99 struct regulator *bt_supply;
100 struct clk *lpo_clk;
101 const struct aml_device_data *aml_dev_data;
102 const char *firmware_name;
103 };
104
105 struct aml_data {
106 struct sk_buff *rx_skb;
107 struct sk_buff_head txq;
108 };
109
110 static const struct h4_recv_pkt aml_recv_pkts[] = {
111 { H4_RECV_ACL, .recv = hci_recv_frame },
112 { H4_RECV_SCO, .recv = hci_recv_frame },
113 { H4_RECV_EVENT, .recv = hci_recv_frame },
114 { H4_RECV_ISO, .recv = hci_recv_frame },
115 };
116
117 /* The TCI command is a private command, which is for setting baud rate,
118 * downloading firmware, initiating RAM.
119 *
120 * op_code | op_len | op_addr | parameter |
121 * --------|-----------------------|---------|-------------|
122 * 2B | 1B len(addr+param) | 4B | len(param) |
123 */
aml_send_tci_cmd(struct hci_dev * hdev,u16 op_code,u32 op_addr,u32 * param,u32 param_len)124 static int aml_send_tci_cmd(struct hci_dev *hdev, u16 op_code, u32 op_addr,
125 u32 *param, u32 param_len)
126 {
127 struct aml_tci_rsp *rsp = NULL;
128 struct sk_buff *skb = NULL;
129 size_t buf_len = 0;
130 u8 *buf = NULL;
131 int err = 0;
132
133 buf_len = sizeof(op_addr) + param_len;
134 buf = kmalloc(buf_len, GFP_KERNEL);
135 if (!buf)
136 return -ENOMEM;
137
138 memcpy(buf, &op_addr, sizeof(op_addr));
139 if (param && param_len > 0)
140 memcpy(buf + sizeof(op_addr), param, param_len);
141
142 skb = __hci_cmd_sync_ev(hdev, op_code, buf_len, buf,
143 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
144 if (IS_ERR(skb)) {
145 err = PTR_ERR(skb);
146 bt_dev_err(hdev, "Failed to send TCI cmd (error: %d)", err);
147 goto exit;
148 }
149
150 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp));
151 if (!rsp)
152 goto skb_free;
153
154 if (rsp->opcode != op_code || rsp->status != 0x00) {
155 bt_dev_err(hdev, "send TCI cmd (0x%04X), response (0x%04X):(%d)",
156 op_code, rsp->opcode, rsp->status);
157 err = -EINVAL;
158 goto skb_free;
159 }
160
161 skb_free:
162 kfree_skb(skb);
163
164 exit:
165 kfree(buf);
166 return err;
167 }
168
aml_update_chip_baudrate(struct hci_dev * hdev,u32 baud)169 static int aml_update_chip_baudrate(struct hci_dev *hdev, u32 baud)
170 {
171 u32 value;
172
173 value = ((AML_UART_CLK_SOURCE / baud) - 1) & 0x0FFF;
174 value |= AML_UART_XMIT_EN | AML_UART_RECV_EN | AML_UART_TIMEOUT_INT_EN;
175
176 return aml_send_tci_cmd(hdev, AML_TCI_CMD_UPDATE_BAUDRATE,
177 AML_OP_UART_MODE, &value, sizeof(value));
178 }
179
aml_start_chip(struct hci_dev * hdev)180 static int aml_start_chip(struct hci_dev *hdev)
181 {
182 u32 value = 0;
183 int ret;
184
185 value = AML_MM_CTR_HARD_TRAS_EN;
186 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
187 AML_OP_MEM_HARD_TRANS_EN,
188 &value, sizeof(value));
189 if (ret)
190 return ret;
191
192 /* controller hardware reset */
193 value = AML_CTR_CPU_RESET | AML_CTR_MAC_RESET | AML_CTR_PHY_RESET;
194 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_HARDWARE_RESET,
195 AML_OP_HARDWARE_RST,
196 &value, sizeof(value));
197 return ret;
198 }
199
aml_send_firmware_segment(struct hci_dev * hdev,u8 fw_type,u8 * seg,u32 seg_size,u32 offset)200 static int aml_send_firmware_segment(struct hci_dev *hdev,
201 u8 fw_type,
202 u8 *seg,
203 u32 seg_size,
204 u32 offset)
205 {
206 u32 op_addr = 0;
207
208 if (fw_type == FW_ICCM)
209 op_addr = AML_OP_ICCM_RAM_BASE + offset;
210 else if (fw_type == FW_DCCM)
211 op_addr = AML_OP_DCCM_RAM_BASE + offset;
212
213 return aml_send_tci_cmd(hdev, AML_TCI_CMD_DOWNLOAD_BT_FW,
214 op_addr, (u32 *)seg, seg_size);
215 }
216
aml_send_firmware(struct hci_dev * hdev,u8 fw_type,u8 * fw,u32 fw_size,u32 offset)217 static int aml_send_firmware(struct hci_dev *hdev, u8 fw_type,
218 u8 *fw, u32 fw_size, u32 offset)
219 {
220 u32 seg_size = 0;
221 u32 seg_off = 0;
222
223 if (fw_size > AML_FIRMWARE_MAX_SIZE) {
224 bt_dev_err(hdev,
225 "Firmware size %d kB is larger than the maximum of 512 kB. Aborting.",
226 fw_size);
227 return -EINVAL;
228 }
229 while (fw_size > 0) {
230 seg_size = (fw_size > AML_FIRMWARE_OPERATION_SIZE) ?
231 AML_FIRMWARE_OPERATION_SIZE : fw_size;
232 if (aml_send_firmware_segment(hdev, fw_type, (fw + seg_off),
233 seg_size, offset)) {
234 bt_dev_err(hdev, "Failed send firmware, type: %d, offset: 0x%x",
235 fw_type, offset);
236 return -EINVAL;
237 }
238 seg_off += seg_size;
239 fw_size -= seg_size;
240 offset += seg_size;
241 }
242 return 0;
243 }
244
aml_download_firmware(struct hci_dev * hdev,const char * fw_name)245 static int aml_download_firmware(struct hci_dev *hdev, const char *fw_name)
246 {
247 struct hci_uart *hu = hci_get_drvdata(hdev);
248 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev);
249 const struct firmware *firmware = NULL;
250 const struct aml_fw_len *fw_len = NULL;
251 u8 *iccm_start = NULL, *dccm_start = NULL;
252 u32 iccm_len, dccm_len;
253 u32 value = 0;
254 int ret = 0;
255
256 /* Enable firmware download event */
257 value = AML_EVT_EN;
258 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
259 AML_OP_EVT_ENABLE,
260 &value, sizeof(value));
261 if (ret)
262 goto exit;
263
264 /* RAM power on */
265 value = AML_RAM_POWER_ON;
266 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
267 AML_OP_RAM_POWER_CTR,
268 &value, sizeof(value));
269 if (ret)
270 goto exit;
271
272 /* Check RAM power status */
273 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_READ,
274 AML_OP_RAM_POWER_CTR, NULL, 0);
275 if (ret)
276 goto exit;
277
278 ret = request_firmware(&firmware, fw_name, &hdev->dev);
279 if (ret < 0) {
280 bt_dev_err(hdev, "Failed to load <%s>:(%d)", fw_name, ret);
281 goto exit;
282 }
283
284 if (firmware->size < sizeof(*fw_len)) {
285 bt_dev_err(hdev, "Firmware is too small for its header");
286 ret = -EINVAL;
287 goto exit;
288 }
289
290 fw_len = (const struct aml_fw_len *)firmware->data;
291 if (fw_len->iccm_len < amldev->aml_dev_data->iccm_offset ||
292 fw_len->iccm_len > firmware->size - sizeof(*fw_len) ||
293 fw_len->dccm_len > firmware->size - sizeof(*fw_len) -
294 fw_len->iccm_len) {
295 bt_dev_err(hdev, "Invalid firmware segment lengths");
296 ret = -EINVAL;
297 goto exit;
298 }
299
300 /* Download ICCM */
301 iccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len)
302 + amldev->aml_dev_data->iccm_offset;
303 iccm_len = fw_len->iccm_len - amldev->aml_dev_data->iccm_offset;
304 ret = aml_send_firmware(hdev, FW_ICCM, iccm_start, iccm_len,
305 amldev->aml_dev_data->iccm_offset);
306 if (ret) {
307 bt_dev_err(hdev, "Failed to send FW_ICCM (%d)", ret);
308 goto exit;
309 }
310
311 /* Download DCCM */
312 dccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len) + fw_len->iccm_len;
313 dccm_len = fw_len->dccm_len;
314 ret = aml_send_firmware(hdev, FW_DCCM, dccm_start, dccm_len,
315 amldev->aml_dev_data->dccm_offset);
316 if (ret) {
317 bt_dev_err(hdev, "Failed to send FW_DCCM (%d)", ret);
318 goto exit;
319 }
320
321 /* Disable firmware download event */
322 value = 0;
323 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
324 AML_OP_EVT_ENABLE,
325 &value, sizeof(value));
326 if (ret)
327 goto exit;
328
329 exit:
330 release_firmware(firmware);
331 return ret;
332 }
333
aml_send_reset(struct hci_dev * hdev)334 static int aml_send_reset(struct hci_dev *hdev)
335 {
336 struct sk_buff *skb;
337 int err;
338
339 skb = __hci_cmd_sync_ev(hdev, HCI_OP_RESET, 0, NULL,
340 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
341 if (IS_ERR(skb)) {
342 err = PTR_ERR(skb);
343 bt_dev_err(hdev, "Failed to send hci reset cmd (%d)", err);
344 return err;
345 }
346
347 kfree_skb(skb);
348 return 0;
349 }
350
aml_dump_fw_version(struct hci_dev * hdev)351 static int aml_dump_fw_version(struct hci_dev *hdev)
352 {
353 struct aml_tci_rsp *rsp = NULL;
354 struct sk_buff *skb;
355 u8 value[6] = {0};
356 u8 *fw_ver = NULL;
357 int err = 0;
358
359 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD, sizeof(value), value,
360 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
361 if (IS_ERR(skb)) {
362 err = PTR_ERR(skb);
363 bt_dev_err(hdev, "Failed to get fw version (error: %d)", err);
364 return err;
365 }
366
367 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp));
368 if (!rsp)
369 goto exit;
370
371 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) {
372 bt_dev_err(hdev, "dump version, error response (0x%04X):(%d)",
373 rsp->opcode, rsp->status);
374 err = -EINVAL;
375 goto exit;
376 }
377
378 fw_ver = (u8 *)rsp + AML_EVT_HEAD_SIZE;
379 bt_dev_info(hdev, "fw_version: date = %02x.%02x, number = 0x%02x%02x",
380 *(fw_ver + 1), *fw_ver, *(fw_ver + 3), *(fw_ver + 2));
381
382 exit:
383 kfree_skb(skb);
384 return err;
385 }
386
aml_set_bdaddr(struct hci_dev * hdev,const bdaddr_t * bdaddr)387 static int aml_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
388 {
389 struct aml_tci_rsp *rsp = NULL;
390 struct sk_buff *skb;
391 int err = 0;
392
393 bt_dev_info(hdev, "set bdaddr (%pM)", bdaddr);
394 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD,
395 sizeof(bdaddr_t), bdaddr,
396 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
397 if (IS_ERR(skb)) {
398 err = PTR_ERR(skb);
399 bt_dev_err(hdev, "Failed to set bdaddr (error: %d)", err);
400 return err;
401 }
402
403 rsp = skb_pull_data(skb, sizeof(struct aml_tci_rsp));
404 if (!rsp)
405 goto exit;
406
407 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) {
408 bt_dev_err(hdev, "error response (0x%x):(%d)", rsp->opcode, rsp->status);
409 err = -EINVAL;
410 goto exit;
411 }
412
413 exit:
414 kfree_skb(skb);
415 return err;
416 }
417
aml_check_bdaddr(struct hci_dev * hdev)418 static int aml_check_bdaddr(struct hci_dev *hdev)
419 {
420 struct hci_rp_read_bd_addr *paddr;
421 struct sk_buff *skb;
422 int err;
423
424 if (bacmp(&hdev->public_addr, BDADDR_ANY))
425 return 0;
426
427 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
428 HCI_INIT_TIMEOUT);
429 if (IS_ERR(skb)) {
430 err = PTR_ERR(skb);
431 bt_dev_err(hdev, "Failed to read bdaddr (error: %d)", err);
432 return err;
433 }
434
435 paddr = skb_pull_data(skb, sizeof(struct hci_rp_read_bd_addr));
436 if (!paddr)
437 goto exit;
438
439 if (!bacmp(&paddr->bdaddr, AML_BDADDR_DEFAULT)) {
440 bt_dev_info(hdev, "amlbt using default bdaddr (%pM)", &paddr->bdaddr);
441 hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
442 }
443
444 exit:
445 kfree_skb(skb);
446 return 0;
447 }
448
aml_config_rf(struct hci_dev * hdev,bool is_coex)449 static int aml_config_rf(struct hci_dev *hdev, bool is_coex)
450 {
451 u32 value = AML_RF_ANT_DOUBLE;
452
453 /* Use a single antenna when co-existing with wifi */
454 if (is_coex)
455 value = AML_RF_ANT_SINGLE;
456
457 return aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
458 AML_OP_RF_CFG,
459 &value, sizeof(value));
460 }
461
aml_parse_dt(struct aml_serdev * amldev)462 static int aml_parse_dt(struct aml_serdev *amldev)
463 {
464 struct device *pdev = amldev->dev;
465
466 amldev->bt_en_gpio = devm_gpiod_get(pdev, "enable",
467 GPIOD_OUT_LOW);
468 if (IS_ERR(amldev->bt_en_gpio)) {
469 dev_err(pdev, "Failed to acquire enable gpios");
470 return PTR_ERR(amldev->bt_en_gpio);
471 }
472
473 if (device_property_read_string(pdev, "firmware-name",
474 &amldev->firmware_name)) {
475 dev_err(pdev, "Failed to acquire firmware path");
476 return -ENODEV;
477 }
478
479 amldev->bt_supply = devm_regulator_get(pdev, "vddio");
480 if (IS_ERR(amldev->bt_supply)) {
481 dev_err(pdev, "Failed to acquire regulator");
482 return PTR_ERR(amldev->bt_supply);
483 }
484
485 amldev->lpo_clk = devm_clk_get(pdev, NULL);
486 if (IS_ERR(amldev->lpo_clk)) {
487 dev_err(pdev, "Failed to acquire clock source");
488 return PTR_ERR(amldev->lpo_clk);
489 }
490
491 return 0;
492 }
493
aml_power_on(struct aml_serdev * amldev)494 static int aml_power_on(struct aml_serdev *amldev)
495 {
496 int err;
497
498 err = regulator_enable(amldev->bt_supply);
499 if (err) {
500 dev_err(amldev->dev, "Failed to enable regulator: (%d)", err);
501 return err;
502 }
503
504 err = clk_prepare_enable(amldev->lpo_clk);
505 if (err) {
506 dev_err(amldev->dev, "Failed to enable lpo clock: (%d)", err);
507 return err;
508 }
509
510 gpiod_set_value_cansleep(amldev->bt_en_gpio, 1);
511
512 /* Wait 20ms for bluetooth controller power on */
513 msleep(20);
514 return 0;
515 }
516
aml_power_off(struct aml_serdev * amldev)517 static int aml_power_off(struct aml_serdev *amldev)
518 {
519 gpiod_set_value_cansleep(amldev->bt_en_gpio, 0);
520
521 clk_disable_unprepare(amldev->lpo_clk);
522
523 regulator_disable(amldev->bt_supply);
524
525 return 0;
526 }
527
aml_set_baudrate(struct hci_uart * hu,unsigned int speed)528 static int aml_set_baudrate(struct hci_uart *hu, unsigned int speed)
529 {
530 /* update controller baudrate */
531 if (aml_update_chip_baudrate(hu->hdev, speed) != 0) {
532 bt_dev_err(hu->hdev, "Failed to update baud rate");
533 return -EINVAL;
534 }
535
536 /* update local baudrate */
537 serdev_device_set_baudrate(hu->serdev, speed);
538
539 return 0;
540 }
541
542 /* Initialize protocol */
aml_open(struct hci_uart * hu)543 static int aml_open(struct hci_uart *hu)
544 {
545 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev);
546 struct aml_data *aml_data;
547 int err;
548
549 err = aml_parse_dt(amldev);
550 if (err)
551 return err;
552
553 if (!hci_uart_has_flow_control(hu)) {
554 bt_dev_err(hu->hdev, "no flow control");
555 return -EOPNOTSUPP;
556 }
557
558 aml_data = kzalloc_obj(*aml_data);
559 if (!aml_data)
560 return -ENOMEM;
561
562 skb_queue_head_init(&aml_data->txq);
563
564 hu->priv = aml_data;
565
566 return 0;
567 }
568
aml_close(struct hci_uart * hu)569 static int aml_close(struct hci_uart *hu)
570 {
571 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev);
572 struct aml_data *aml_data = hu->priv;
573
574 skb_queue_purge(&aml_data->txq);
575 kfree_skb(aml_data->rx_skb);
576 kfree(aml_data);
577
578 hu->priv = NULL;
579
580 return aml_power_off(amldev);
581 }
582
aml_flush(struct hci_uart * hu)583 static int aml_flush(struct hci_uart *hu)
584 {
585 struct aml_data *aml_data = hu->priv;
586
587 skb_queue_purge(&aml_data->txq);
588
589 return 0;
590 }
591
aml_setup(struct hci_uart * hu)592 static int aml_setup(struct hci_uart *hu)
593 {
594 struct aml_serdev *amldev = serdev_device_get_drvdata(hu->serdev);
595 struct hci_dev *hdev = amldev->serdev_hu.hdev;
596 int err;
597
598 /* Setup bdaddr */
599 hdev->set_bdaddr = aml_set_bdaddr;
600
601 err = aml_power_on(amldev);
602 if (err)
603 return err;
604
605 err = aml_set_baudrate(hu, amldev->serdev_hu.proto->oper_speed);
606 if (err)
607 return err;
608
609 err = aml_download_firmware(hdev, amldev->firmware_name);
610 if (err)
611 return err;
612
613 err = aml_config_rf(hdev, amldev->aml_dev_data->is_coex);
614 if (err)
615 return err;
616
617 err = aml_start_chip(hdev);
618 if (err)
619 return err;
620
621 /* Wait 60ms for controller startup */
622 msleep(60);
623
624 err = aml_dump_fw_version(hdev);
625 if (err)
626 return err;
627
628 err = aml_send_reset(hdev);
629 if (err)
630 return err;
631
632 err = aml_check_bdaddr(hdev);
633 if (err)
634 return err;
635
636 return 0;
637 }
638
aml_enqueue(struct hci_uart * hu,struct sk_buff * skb)639 static int aml_enqueue(struct hci_uart *hu, struct sk_buff *skb)
640 {
641 struct aml_data *aml_data = hu->priv;
642
643 skb_queue_tail(&aml_data->txq, skb);
644
645 return 0;
646 }
647
aml_dequeue(struct hci_uart * hu)648 static struct sk_buff *aml_dequeue(struct hci_uart *hu)
649 {
650 struct aml_data *aml_data = hu->priv;
651 struct sk_buff *skb;
652
653 skb = skb_dequeue(&aml_data->txq);
654
655 /* Prepend skb with frame type */
656 if (skb)
657 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
658
659 return skb;
660 }
661
aml_recv(struct hci_uart * hu,const void * data,int count)662 static int aml_recv(struct hci_uart *hu, const void *data, int count)
663 {
664 struct aml_data *aml_data = hu->priv;
665 int err;
666
667 aml_data->rx_skb = h4_recv_buf(hu, aml_data->rx_skb, data, count,
668 aml_recv_pkts,
669 ARRAY_SIZE(aml_recv_pkts));
670 if (IS_ERR(aml_data->rx_skb)) {
671 err = PTR_ERR(aml_data->rx_skb);
672 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err);
673 aml_data->rx_skb = NULL;
674 return err;
675 }
676
677 return count;
678 }
679
680 static const struct hci_uart_proto aml_hci_proto = {
681 .id = HCI_UART_AML,
682 .name = "AML",
683 .init_speed = 115200,
684 .oper_speed = 4000000,
685 .open = aml_open,
686 .close = aml_close,
687 .setup = aml_setup,
688 .flush = aml_flush,
689 .recv = aml_recv,
690 .enqueue = aml_enqueue,
691 .dequeue = aml_dequeue,
692 };
693
aml_serdev_probe(struct serdev_device * serdev)694 static int aml_serdev_probe(struct serdev_device *serdev)
695 {
696 struct aml_serdev *amldev;
697 int err;
698
699 amldev = devm_kzalloc(&serdev->dev, sizeof(*amldev), GFP_KERNEL);
700 if (!amldev)
701 return -ENOMEM;
702
703 amldev->serdev_hu.serdev = serdev;
704 amldev->dev = &serdev->dev;
705 serdev_device_set_drvdata(serdev, amldev);
706
707 err = hci_uart_register_device(&amldev->serdev_hu, &aml_hci_proto);
708 if (err)
709 return dev_err_probe(amldev->dev, err,
710 "Failed to register hci uart device");
711
712 amldev->aml_dev_data = device_get_match_data(&serdev->dev);
713
714 return 0;
715 }
716
aml_serdev_remove(struct serdev_device * serdev)717 static void aml_serdev_remove(struct serdev_device *serdev)
718 {
719 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev);
720
721 hci_uart_unregister_device(&amldev->serdev_hu);
722 }
723
aml_serdev_shutdown(struct serdev_device * serdev)724 static void aml_serdev_shutdown(struct serdev_device *serdev)
725 {
726 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev);
727
728 aml_power_off(amldev);
729 }
730
731 static const struct aml_device_data data_w155s2 = {
732 .iccm_offset = 256 * 1024,
733 };
734
735 static const struct aml_device_data data_w265s2 = {
736 .iccm_offset = 384 * 1024,
737 };
738
739 static const struct of_device_id aml_bluetooth_of_match[] = {
740 { .compatible = "amlogic,w155s2-bt", .data = &data_w155s2 },
741 { .compatible = "amlogic,w265s2-bt", .data = &data_w265s2 },
742 { /* sentinel */ },
743 };
744 MODULE_DEVICE_TABLE(of, aml_bluetooth_of_match);
745
746 static struct serdev_device_driver aml_serdev_driver = {
747 .probe = aml_serdev_probe,
748 .remove = aml_serdev_remove,
749 .shutdown = aml_serdev_shutdown,
750 .driver = {
751 .name = "hci_uart_aml",
752 .of_match_table = aml_bluetooth_of_match,
753 },
754 };
755
aml_init(void)756 int __init aml_init(void)
757 {
758 serdev_device_driver_register(&aml_serdev_driver);
759
760 return hci_uart_register_proto(&aml_hci_proto);
761 }
762
aml_deinit(void)763 int __exit aml_deinit(void)
764 {
765 serdev_device_driver_unregister(&aml_serdev_driver);
766
767 return hci_uart_unregister_proto(&aml_hci_proto);
768 }
769