| 1 | |
| 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 |
|
| 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 |
|
| 36 | #define AML_BT_HCI_VENDOR_CMD 0xFC1A
|
| 37 |
|
| 38 |
|
| 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 |
|
| 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 |
|
| 55 | #define AML_EVT_EN BIT(24)
|
| 56 |
|
| 57 |
|
| 58 | #define AML_RAM_POWER_ON (0)
|
| 59 | #define AML_RAM_POWER_OFF (1)
|
| 60 |
|
| 61 |
|
| 62 | #define AML_RF_ANT_SINGLE BIT(28)
|
| 63 | #define AML_RF_ANT_DOUBLE BIT(29)
|
| 64 |
|
| 65 |
|
| 66 | #define AML_MM_CTR_HARD_TRAS_EN BIT(27)
|
| 67 |
|
| 68 |
|
| 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 | |
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 449 | static int aml_config_rf(struct hci_dev *hdev, bool is_coex)
|
| 450 | {
|
| 451 | u32 value = AML_RF_ANT_DOUBLE;
|
| 452 |
|
| 453 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 513 | msleep(20);
|
| 514 | return 0;
|
| 515 | }
|
| 516 |
|
| 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 |
|
| 528 | static int aml_set_baudrate(struct hci_uart *hu, unsigned int speed)
|
| 529 | {
|
| 530 |
|
| 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 |
|
| 537 | serdev_device_set_baudrate(hu->serdev, speed);
|
| 538 |
|
| 539 | return 0;
|
| 540 | }
|
| 541 |
|
| 542 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 656 | if (skb)
|
| 657 | memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
|
| 658 |
|
| 659 | return skb;
|
| 660 | }
|
| 661 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 | { },
|
| 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 |
|
| 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 |
|
| 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 | }
|