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
73enum {
74 FW_ICCM,
75 FW_DCCM
76};
77
78struct aml_fw_len {
79 u32 iccm_len;
80 u32 dccm_len;
81};
82
83struct aml_tci_rsp {
84 u8 num_cmd_packet;
85 u16 opcode;
86 u8 status;
87} __packed;
88
89struct aml_device_data {
90 int iccm_offset;
91 int dccm_offset;
92 bool is_coex;
93};
94
95struct 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
105struct aml_data {
106 struct sk_buff *rx_skb;
107 struct sk_buff_head txq;
108};
109
110static 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 */
124static 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, opcode: op_code, plen: buf_len, param: buf,
143 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
144 if (IS_ERR(ptr: skb)) {
145 err = PTR_ERR(ptr: 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, len: 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
161skb_free:
162 kfree_skb(skb);
163
164exit:
165 kfree(objp: buf);
166 return err;
167}
168
169static 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, param: &value, param_len: sizeof(value));
178}
179
180static 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 param: &value, param_len: 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 param: &value, param_len: sizeof(value));
197 return ret;
198}
199
200static 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, param: (u32 *)seg, param_len: seg_size);
215}
216
217static 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, seg: (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
245static 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(serdev: hu->serdev);
249 const struct firmware *firmware = NULL;
250 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 param: &value, param_len: 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 param: &value, param_len: 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, param_len: 0);
275 if (ret)
276 goto exit;
277
278 ret = request_firmware(fw: &firmware, name: fw_name, device: &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 fw_len = (struct aml_fw_len *)firmware->data;
285
286 /* Download ICCM */
287 iccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len)
288 + amldev->aml_dev_data->iccm_offset;
289 iccm_len = fw_len->iccm_len - amldev->aml_dev_data->iccm_offset;
290 ret = aml_send_firmware(hdev, fw_type: FW_ICCM, fw: iccm_start, fw_size: iccm_len,
291 offset: amldev->aml_dev_data->iccm_offset);
292 if (ret) {
293 bt_dev_err(hdev, "Failed to send FW_ICCM (%d)", ret);
294 goto exit;
295 }
296
297 /* Download DCCM */
298 dccm_start = (u8 *)(firmware->data) + sizeof(struct aml_fw_len) + fw_len->iccm_len;
299 dccm_len = fw_len->dccm_len;
300 ret = aml_send_firmware(hdev, fw_type: FW_DCCM, fw: dccm_start, fw_size: dccm_len,
301 offset: amldev->aml_dev_data->dccm_offset);
302 if (ret) {
303 bt_dev_err(hdev, "Failed to send FW_DCCM (%d)", ret);
304 goto exit;
305 }
306
307 /* Disable firmware download event */
308 value = 0;
309 ret = aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
310 AML_OP_EVT_ENABLE,
311 param: &value, param_len: sizeof(value));
312 if (ret)
313 goto exit;
314
315exit:
316 release_firmware(fw: firmware);
317 return ret;
318}
319
320static int aml_send_reset(struct hci_dev *hdev)
321{
322 struct sk_buff *skb;
323 int err;
324
325 skb = __hci_cmd_sync_ev(hdev, HCI_OP_RESET, plen: 0, NULL,
326 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
327 if (IS_ERR(ptr: skb)) {
328 err = PTR_ERR(ptr: skb);
329 bt_dev_err(hdev, "Failed to send hci reset cmd (%d)", err);
330 return err;
331 }
332
333 kfree_skb(skb);
334 return 0;
335}
336
337static int aml_dump_fw_version(struct hci_dev *hdev)
338{
339 struct aml_tci_rsp *rsp = NULL;
340 struct sk_buff *skb;
341 u8 value[6] = {0};
342 u8 *fw_ver = NULL;
343 int err = 0;
344
345 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD, plen: sizeof(value), param: value,
346 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
347 if (IS_ERR(ptr: skb)) {
348 err = PTR_ERR(ptr: skb);
349 bt_dev_err(hdev, "Failed to get fw version (error: %d)", err);
350 return err;
351 }
352
353 rsp = skb_pull_data(skb, len: sizeof(struct aml_tci_rsp));
354 if (!rsp)
355 goto exit;
356
357 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) {
358 bt_dev_err(hdev, "dump version, error response (0x%04X):(%d)",
359 rsp->opcode, rsp->status);
360 err = -EINVAL;
361 goto exit;
362 }
363
364 fw_ver = (u8 *)rsp + AML_EVT_HEAD_SIZE;
365 bt_dev_info(hdev, "fw_version: date = %02x.%02x, number = 0x%02x%02x",
366 *(fw_ver + 1), *fw_ver, *(fw_ver + 3), *(fw_ver + 2));
367
368exit:
369 kfree_skb(skb);
370 return err;
371}
372
373static int aml_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr)
374{
375 struct aml_tci_rsp *rsp = NULL;
376 struct sk_buff *skb;
377 int err = 0;
378
379 bt_dev_info(hdev, "set bdaddr (%pM)", bdaddr);
380 skb = __hci_cmd_sync_ev(hdev, AML_BT_HCI_VENDOR_CMD,
381 plen: sizeof(bdaddr_t), param: bdaddr,
382 HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
383 if (IS_ERR(ptr: skb)) {
384 err = PTR_ERR(ptr: skb);
385 bt_dev_err(hdev, "Failed to set bdaddr (error: %d)", err);
386 return err;
387 }
388
389 rsp = skb_pull_data(skb, len: sizeof(struct aml_tci_rsp));
390 if (!rsp)
391 goto exit;
392
393 if (rsp->opcode != AML_BT_HCI_VENDOR_CMD || rsp->status != 0x00) {
394 bt_dev_err(hdev, "error response (0x%x):(%d)", rsp->opcode, rsp->status);
395 err = -EINVAL;
396 goto exit;
397 }
398
399exit:
400 kfree_skb(skb);
401 return err;
402}
403
404static int aml_check_bdaddr(struct hci_dev *hdev)
405{
406 struct hci_rp_read_bd_addr *paddr;
407 struct sk_buff *skb;
408 int err;
409
410 if (bacmp(ba1: &hdev->public_addr, BDADDR_ANY))
411 return 0;
412
413 skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, plen: 0, NULL,
414 HCI_INIT_TIMEOUT);
415 if (IS_ERR(ptr: skb)) {
416 err = PTR_ERR(ptr: skb);
417 bt_dev_err(hdev, "Failed to read bdaddr (error: %d)", err);
418 return err;
419 }
420
421 paddr = skb_pull_data(skb, len: sizeof(struct hci_rp_read_bd_addr));
422 if (!paddr)
423 goto exit;
424
425 if (!bacmp(ba1: &paddr->bdaddr, AML_BDADDR_DEFAULT)) {
426 bt_dev_info(hdev, "amlbt using default bdaddr (%pM)", &paddr->bdaddr);
427 hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
428 }
429
430exit:
431 kfree_skb(skb);
432 return 0;
433}
434
435static int aml_config_rf(struct hci_dev *hdev, bool is_coex)
436{
437 u32 value = AML_RF_ANT_DOUBLE;
438
439 /* Use a single antenna when co-existing with wifi */
440 if (is_coex)
441 value = AML_RF_ANT_SINGLE;
442
443 return aml_send_tci_cmd(hdev, AML_TCI_CMD_WRITE,
444 AML_OP_RF_CFG,
445 param: &value, param_len: sizeof(value));
446}
447
448static int aml_parse_dt(struct aml_serdev *amldev)
449{
450 struct device *pdev = amldev->dev;
451
452 amldev->bt_en_gpio = devm_gpiod_get(dev: pdev, con_id: "enable",
453 flags: GPIOD_OUT_LOW);
454 if (IS_ERR(ptr: amldev->bt_en_gpio)) {
455 dev_err(pdev, "Failed to acquire enable gpios");
456 return PTR_ERR(ptr: amldev->bt_en_gpio);
457 }
458
459 if (device_property_read_string(dev: pdev, propname: "firmware-name",
460 val: &amldev->firmware_name)) {
461 dev_err(pdev, "Failed to acquire firmware path");
462 return -ENODEV;
463 }
464
465 amldev->bt_supply = devm_regulator_get(dev: pdev, id: "vddio");
466 if (IS_ERR(ptr: amldev->bt_supply)) {
467 dev_err(pdev, "Failed to acquire regulator");
468 return PTR_ERR(ptr: amldev->bt_supply);
469 }
470
471 amldev->lpo_clk = devm_clk_get(dev: pdev, NULL);
472 if (IS_ERR(ptr: amldev->lpo_clk)) {
473 dev_err(pdev, "Failed to acquire clock source");
474 return PTR_ERR(ptr: amldev->lpo_clk);
475 }
476
477 return 0;
478}
479
480static int aml_power_on(struct aml_serdev *amldev)
481{
482 int err;
483
484 err = regulator_enable(regulator: amldev->bt_supply);
485 if (err) {
486 dev_err(amldev->dev, "Failed to enable regulator: (%d)", err);
487 return err;
488 }
489
490 err = clk_prepare_enable(clk: amldev->lpo_clk);
491 if (err) {
492 dev_err(amldev->dev, "Failed to enable lpo clock: (%d)", err);
493 return err;
494 }
495
496 gpiod_set_value_cansleep(desc: amldev->bt_en_gpio, value: 1);
497
498 /* Wait 20ms for bluetooth controller power on */
499 msleep(msecs: 20);
500 return 0;
501}
502
503static int aml_power_off(struct aml_serdev *amldev)
504{
505 gpiod_set_value_cansleep(desc: amldev->bt_en_gpio, value: 0);
506
507 clk_disable_unprepare(clk: amldev->lpo_clk);
508
509 regulator_disable(regulator: amldev->bt_supply);
510
511 return 0;
512}
513
514static int aml_set_baudrate(struct hci_uart *hu, unsigned int speed)
515{
516 /* update controller baudrate */
517 if (aml_update_chip_baudrate(hdev: hu->hdev, baud: speed) != 0) {
518 bt_dev_err(hu->hdev, "Failed to update baud rate");
519 return -EINVAL;
520 }
521
522 /* update local baudrate */
523 serdev_device_set_baudrate(hu->serdev, speed);
524
525 return 0;
526}
527
528/* Initialize protocol */
529static int aml_open(struct hci_uart *hu)
530{
531 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev: hu->serdev);
532 struct aml_data *aml_data;
533 int err;
534
535 err = aml_parse_dt(amldev);
536 if (err)
537 return err;
538
539 if (!hci_uart_has_flow_control(hu)) {
540 bt_dev_err(hu->hdev, "no flow control");
541 return -EOPNOTSUPP;
542 }
543
544 aml_data = kzalloc(sizeof(*aml_data), GFP_KERNEL);
545 if (!aml_data)
546 return -ENOMEM;
547
548 skb_queue_head_init(list: &aml_data->txq);
549
550 hu->priv = aml_data;
551
552 return 0;
553}
554
555static int aml_close(struct hci_uart *hu)
556{
557 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev: hu->serdev);
558 struct aml_data *aml_data = hu->priv;
559
560 skb_queue_purge(list: &aml_data->txq);
561 kfree_skb(skb: aml_data->rx_skb);
562 kfree(objp: aml_data);
563
564 hu->priv = NULL;
565
566 return aml_power_off(amldev);
567}
568
569static int aml_flush(struct hci_uart *hu)
570{
571 struct aml_data *aml_data = hu->priv;
572
573 skb_queue_purge(list: &aml_data->txq);
574
575 return 0;
576}
577
578static int aml_setup(struct hci_uart *hu)
579{
580 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev: hu->serdev);
581 struct hci_dev *hdev = amldev->serdev_hu.hdev;
582 int err;
583
584 /* Setup bdaddr */
585 hdev->set_bdaddr = aml_set_bdaddr;
586
587 err = aml_power_on(amldev);
588 if (err)
589 return err;
590
591 err = aml_set_baudrate(hu, speed: amldev->serdev_hu.proto->oper_speed);
592 if (err)
593 return err;
594
595 err = aml_download_firmware(hdev, fw_name: amldev->firmware_name);
596 if (err)
597 return err;
598
599 err = aml_config_rf(hdev, is_coex: amldev->aml_dev_data->is_coex);
600 if (err)
601 return err;
602
603 err = aml_start_chip(hdev);
604 if (err)
605 return err;
606
607 /* Wait 60ms for controller startup */
608 msleep(msecs: 60);
609
610 err = aml_dump_fw_version(hdev);
611 if (err)
612 return err;
613
614 err = aml_send_reset(hdev);
615 if (err)
616 return err;
617
618 err = aml_check_bdaddr(hdev);
619 if (err)
620 return err;
621
622 return 0;
623}
624
625static int aml_enqueue(struct hci_uart *hu, struct sk_buff *skb)
626{
627 struct aml_data *aml_data = hu->priv;
628
629 skb_queue_tail(list: &aml_data->txq, newsk: skb);
630
631 return 0;
632}
633
634static struct sk_buff *aml_dequeue(struct hci_uart *hu)
635{
636 struct aml_data *aml_data = hu->priv;
637 struct sk_buff *skb;
638
639 skb = skb_dequeue(list: &aml_data->txq);
640
641 /* Prepend skb with frame type */
642 if (skb)
643 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
644
645 return skb;
646}
647
648static int aml_recv(struct hci_uart *hu, const void *data, int count)
649{
650 struct aml_data *aml_data = hu->priv;
651 int err;
652
653 aml_data->rx_skb = h4_recv_buf(hu, skb: aml_data->rx_skb, buffer: data, count,
654 pkts: aml_recv_pkts,
655 ARRAY_SIZE(aml_recv_pkts));
656 if (IS_ERR(ptr: aml_data->rx_skb)) {
657 err = PTR_ERR(ptr: aml_data->rx_skb);
658 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err);
659 aml_data->rx_skb = NULL;
660 return err;
661 }
662
663 return count;
664}
665
666static const struct hci_uart_proto aml_hci_proto = {
667 .id = HCI_UART_AML,
668 .name = "AML",
669 .init_speed = 115200,
670 .oper_speed = 4000000,
671 .open = aml_open,
672 .close = aml_close,
673 .setup = aml_setup,
674 .flush = aml_flush,
675 .recv = aml_recv,
676 .enqueue = aml_enqueue,
677 .dequeue = aml_dequeue,
678};
679
680static void aml_device_driver_shutdown(struct device *dev)
681{
682 struct aml_serdev *amldev = dev_get_drvdata(dev);
683
684 aml_power_off(amldev);
685}
686
687static int aml_serdev_probe(struct serdev_device *serdev)
688{
689 struct aml_serdev *amldev;
690 int err;
691
692 amldev = devm_kzalloc(dev: &serdev->dev, size: sizeof(*amldev), GFP_KERNEL);
693 if (!amldev)
694 return -ENOMEM;
695
696 amldev->serdev_hu.serdev = serdev;
697 amldev->dev = &serdev->dev;
698 serdev_device_set_drvdata(serdev, data: amldev);
699
700 err = hci_uart_register_device(hu: &amldev->serdev_hu, p: &aml_hci_proto);
701 if (err)
702 return dev_err_probe(dev: amldev->dev, err,
703 fmt: "Failed to register hci uart device");
704
705 amldev->aml_dev_data = device_get_match_data(dev: &serdev->dev);
706
707 return 0;
708}
709
710static void aml_serdev_remove(struct serdev_device *serdev)
711{
712 struct aml_serdev *amldev = serdev_device_get_drvdata(serdev);
713
714 hci_uart_unregister_device(hu: &amldev->serdev_hu);
715}
716
717static const struct aml_device_data data_w155s2 = {
718 .iccm_offset = 256 * 1024,
719};
720
721static const struct aml_device_data data_w265s2 = {
722 .iccm_offset = 384 * 1024,
723};
724
725static const struct of_device_id aml_bluetooth_of_match[] = {
726 { .compatible = "amlogic,w155s2-bt", .data = &data_w155s2 },
727 { .compatible = "amlogic,w265s2-bt", .data = &data_w265s2 },
728 { /* sentinel */ },
729};
730MODULE_DEVICE_TABLE(of, aml_bluetooth_of_match);
731
732static struct serdev_device_driver aml_serdev_driver = {
733 .probe = aml_serdev_probe,
734 .remove = aml_serdev_remove,
735 .driver = {
736 .name = "hci_uart_aml",
737 .of_match_table = aml_bluetooth_of_match,
738 .shutdown = aml_device_driver_shutdown,
739 },
740};
741
742int __init aml_init(void)
743{
744 serdev_device_driver_register(&aml_serdev_driver);
745
746 return hci_uart_register_proto(p: &aml_hci_proto);
747}
748
749int __exit aml_deinit(void)
750{
751 serdev_device_driver_unregister(sdrv: &aml_serdev_driver);
752
753 return hci_uart_unregister_proto(p: &aml_hci_proto);
754}
755

source code of linux/drivers/bluetooth/hci_aml.c