hci_aml.c

  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, 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
161skb_free:
162	kfree_skb(skb);
163
164exit:
165	kfree(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, &value, 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			       &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
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, (u32 *)seg, 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, (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(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			       &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	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_ICCM, iccm_start, iccm_len,
291				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_DCCM, dccm_start, dccm_len,
301				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			       &value, sizeof(value));
312	if (ret)
313		goto exit;
314
315exit:
316	release_firmware(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, 0, NULL,
326				HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
327	if (IS_ERR(skb)) {
328		err = PTR_ERR(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, sizeof(value), value,
346				HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
347	if (IS_ERR(skb)) {
348		err = PTR_ERR(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, 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				sizeof(bdaddr_t), bdaddr,
382				HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
383	if (IS_ERR(skb)) {
384		err = PTR_ERR(skb);
385		bt_dev_err(hdev, "Failed to set bdaddr (error: %d)", err);
386		return err;
387	}
388
389	rsp = skb_pull_data(skb, 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(&hdev->public_addr, BDADDR_ANY))
411		return 0;
412
413	skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
414			     HCI_INIT_TIMEOUT);
415	if (IS_ERR(skb)) {
416		err = PTR_ERR(skb);
417		bt_dev_err(hdev, "Failed to read bdaddr (error: %d)", err);
418		return err;
419	}
420
421	paddr = skb_pull_data(skb, sizeof(struct hci_rp_read_bd_addr));
422	if (!paddr)
423		goto exit;
424
425	if (!bacmp(&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				&value, 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(pdev, "enable",
453					GPIOD_OUT_LOW);
454	if (IS_ERR(amldev->bt_en_gpio)) {
455		dev_err(pdev, "Failed to acquire enable gpios");
456		return PTR_ERR(amldev->bt_en_gpio);
457	}
458
459	if (device_property_read_string(pdev, "firmware-name",
460					&amldev->firmware_name)) {
461		dev_err(pdev, "Failed to acquire firmware path");
462		return -ENODEV;
463	}
464
465	amldev->bt_supply = devm_regulator_get(pdev, "vddio");
466	if (IS_ERR(amldev->bt_supply)) {
467		dev_err(pdev, "Failed to acquire regulator");
468		return PTR_ERR(amldev->bt_supply);
469	}
470
471	amldev->lpo_clk = devm_clk_get(pdev, NULL);
472	if (IS_ERR(amldev->lpo_clk)) {
473		dev_err(pdev, "Failed to acquire clock source");
474		return PTR_ERR(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(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(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(amldev->bt_en_gpio, 1);
497
498	/* Wait 20ms for bluetooth controller power on */
499	msleep(20);
500	return 0;
501}
502
503static int aml_power_off(struct aml_serdev *amldev)
504{
505	gpiod_set_value_cansleep(amldev->bt_en_gpio, 0);
506
507	clk_disable_unprepare(amldev->lpo_clk);
508
509	regulator_disable(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(hu->hdev, 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(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(&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(hu->serdev);
558	struct aml_data *aml_data = hu->priv;
559
560	skb_queue_purge(&aml_data->txq);
561	kfree_skb(aml_data->rx_skb);
562	kfree(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(&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(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, amldev->serdev_hu.proto->oper_speed);
592	if (err)
593		return err;
594
595	err = aml_download_firmware(hdev, amldev->firmware_name);
596	if (err)
597		return err;
598
599	err = aml_config_rf(hdev, 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(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(&aml_data->txq, 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(&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, aml_data->rx_skb, data, count,
654				       aml_recv_pkts,
655				       ARRAY_SIZE(aml_recv_pkts));
656	if (IS_ERR(aml_data->rx_skb)) {
657		err = PTR_ERR(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(&serdev->dev, 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, amldev);
699
700	err = hci_uart_register_device(&amldev->serdev_hu, &aml_hci_proto);
701	if (err)
702		return dev_err_probe(amldev->dev, err,
703			      "Failed to register hci uart device");
704
705	amldev->aml_dev_data = device_get_match_data(&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(&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(&aml_hci_proto);
747}
748
749int __exit aml_deinit(void)
750{
751	serdev_device_driver_unregister(&aml_serdev_driver);
752
753	return hci_uart_unregister_proto(&aml_hci_proto);
754}