drivers/bluetooth/hci_h5.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  Bluetooth HCI Three-wire UART driver
   5  *
   6  *  Copyright (C) 2012  Intel Corporation
   7  */
   8
   9 #include <linux/acpi.h>
  10 #include <linux/errno.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/kernel.h>
  13 #include <linux/mod_devicetable.h>
  14 #include <linux/of_device.h>
  15 #include <linux/serdev.h>
  16 #include <linux/skbuff.h>
  17
  18 #include <net/bluetooth/bluetooth.h>
  19 #include <net/bluetooth/hci_core.h>
  20
  21 #include "btrtl.h"
  22 #include "hci_uart.h"
  23
  24 #define HCI_3WIRE_ACK_PKT       0
  25 #define HCI_3WIRE_LINK_PKT      15
  26
  27 /* Sliding window size */
  28 #define H5_TX_WIN_MAX           4
  29
  30 #define H5_ACK_TIMEOUT  msecs_to_jiffies(250)
  31 #define H5_SYNC_TIMEOUT msecs_to_jiffies(100)
  32
  33 /*
  34  * Maximum Three-wire packet:
  35  *     4 byte header + max value for 12-bit length + 2 bytes for CRC
  36  */
  37 #define H5_MAX_LEN (4 + 0xfff + 2)
  38
  39 /* Convenience macros for reading Three-wire header values */
  40 #define H5_HDR_SEQ(hdr)         ((hdr)[0] & 0x07)
  41 #define H5_HDR_ACK(hdr)         (((hdr)[0] >> 3) & 0x07)
  42 #define H5_HDR_CRC(hdr)         (((hdr)[0] >> 6) & 0x01)
  43 #define H5_HDR_RELIABLE(hdr)    (((hdr)[0] >> 7) & 0x01)
  44 #define H5_HDR_PKT_TYPE(hdr)    ((hdr)[1] & 0x0f)
  45 #define H5_HDR_LEN(hdr)         ((((hdr)[1] >> 4) & 0x0f) + ((hdr)[2] << 4))
  46
  47 #define SLIP_DELIMITER  0xc0
  48 #define SLIP_ESC        0xdb
  49 #define SLIP_ESC_DELIM  0xdc
  50 #define SLIP_ESC_ESC    0xdd
  51
  52 /* H5 state flags */
  53 enum {
  54         H5_RX_ESC,              /* SLIP escape mode */
  55         H5_TX_ACK_REQ,          /* Pending ack to send */
  56         H5_WAKEUP_DISABLE,      /* Device cannot wake host */
  57 };
  58
  59 struct h5 {
  60         /* Must be the first member, hci_serdev.c expects this. */
  61         struct hci_uart         serdev_hu;
  62
  63         struct sk_buff_head     unack;          /* Unack'ed packets queue */
  64         struct sk_buff_head     rel;            /* Reliable packets queue */
  65         struct sk_buff_head     unrel;          /* Unreliable packets queue */
  66
  67         unsigned long           flags;
  68
  69         struct sk_buff          *rx_skb;        /* Receive buffer */
  70         size_t                  rx_pending;     /* Expecting more bytes */
  71         u8                      rx_ack;         /* Last ack number received */
  72
  73         int                     (*rx_func)(struct hci_uart *hu, u8 c);
  74
  75         struct timer_list       timer;          /* Retransmission timer */
  76         struct hci_uart         *hu;            /* Parent HCI UART */
  77
  78         u8                      tx_seq;         /* Next seq number to send */
  79         u8                      tx_ack;         /* Next ack number to send */
  80         u8                      tx_win;         /* Sliding window size */
  81
  82         enum {
  83                 H5_UNINITIALIZED,
  84                 H5_INITIALIZED,
  85                 H5_ACTIVE,
  86         } state;
  87
  88         enum {
  89                 H5_AWAKE,
  90                 H5_SLEEPING,
  91                 H5_WAKING_UP,
  92         } sleep;
  93
  94         const struct h5_vnd *vnd;
  95         const char *id;
  96
  97         struct gpio_desc *enable_gpio;
  98         struct gpio_desc *device_wake_gpio;
  99 };
 100
 101 enum h5_driver_info {
 102         H5_INFO_WAKEUP_DISABLE = BIT(0),
 103 };
 104
 105 struct h5_vnd {
 106         int (*setup)(struct h5 *h5);
 107         void (*open)(struct h5 *h5);
 108         void (*close)(struct h5 *h5);
 109         int (*suspend)(struct h5 *h5);
 110         int (*resume)(struct h5 *h5);
 111         const struct acpi_gpio_mapping *acpi_gpio_map;
 112 };
 113
 114 struct h5_device_data {
 115         uint32_t driver_info;
 116         struct h5_vnd *vnd;
 117 };
 118
 119 static void h5_reset_rx(struct h5 *h5);
 120
 121 static void h5_link_control(struct hci_uart *hu, const void *data, size_t len)
 122 {
 123         struct h5 *h5 = hu->priv;
 124         struct sk_buff *nskb;
 125
 126         nskb = alloc_skb(3, GFP_ATOMIC);
 127         if (!nskb)
 128                 return;
 129
 130         hci_skb_pkt_type(nskb) = HCI_3WIRE_LINK_PKT;
 131
 132         skb_put_data(nskb, data, len);
 133
 134         skb_queue_tail(&h5->unrel, nskb);
 135 }
 136
 137 static u8 h5_cfg_field(struct h5 *h5)
 138 {
 139         /* Sliding window size (first 3 bits) */
 140         return h5->tx_win & 0x07;
 141 }
 142
 143 static void h5_timed_event(struct timer_list *t)
 144 {
 145         const unsigned char sync_req[] = { 0x01, 0x7e };
 146         unsigned char conf_req[3] = { 0x03, 0xfc };
 147         struct h5 *h5 = from_timer(h5, t, timer);
 148         struct hci_uart *hu = h5->hu;
 149         struct sk_buff *skb;
 150         unsigned long flags;
 151
 152         BT_DBG("%s", hu->hdev->name);
 153
 154         if (h5->state == H5_UNINITIALIZED)
 155                 h5_link_control(hu, sync_req, sizeof(sync_req));
 156
 157         if (h5->state == H5_INITIALIZED) {
 158                 conf_req[2] = h5_cfg_field(h5);
 159                 h5_link_control(hu, conf_req, sizeof(conf_req));
 160         }
 161
 162         if (h5->state != H5_ACTIVE) {
 163                 mod_timer(&h5->timer, jiffies + H5_SYNC_TIMEOUT);
 164                 goto wakeup;
 165         }
 166
 167         if (h5->sleep != H5_AWAKE) {
 168                 h5->sleep = H5_SLEEPING;
 169                 goto wakeup;
 170         }
 171
 172         BT_DBG("hu %p retransmitting %u pkts", hu, h5->unack.qlen);
 173
 174         spin_lock_irqsave_nested(&h5->unack.lock, flags, SINGLE_DEPTH_NESTING);
 175
 176         while ((skb = __skb_dequeue_tail(&h5->unack)) != NULL) {
 177                 h5->tx_seq = (h5->tx_seq - 1) & 0x07;
 178                 skb_queue_head(&h5->rel, skb);
 179         }
 180
 181         spin_unlock_irqrestore(&h5->unack.lock, flags);
 182
 183 wakeup:
 184         hci_uart_tx_wakeup(hu);
 185 }
 186
 187 static void h5_peer_reset(struct hci_uart *hu)
 188 {
 189         struct h5 *h5 = hu->priv;
 190
 191         bt_dev_err(hu->hdev, "Peer device has reset");
 192
 193         h5->state = H5_UNINITIALIZED;
 194
 195         del_timer(&h5->timer);
 196
 197         skb_queue_purge(&h5->rel);
 198         skb_queue_purge(&h5->unrel);
 199         skb_queue_purge(&h5->unack);
 200
 201         h5->tx_seq = 0;
 202         h5->tx_ack = 0;
 203
 204         /* Send reset request to upper stack */
 205         hci_reset_dev(hu->hdev);
 206 }
 207
 208 static int h5_open(struct hci_uart *hu)
 209 {
 210         struct h5 *h5;
 211         const unsigned char sync[] = { 0x01, 0x7e };
 212
 213         BT_DBG("hu %p", hu);
 214
 215         if (hu->serdev) {
 216                 h5 = serdev_device_get_drvdata(hu->serdev);
 217         } else {
 218                 h5 = kzalloc(sizeof(*h5), GFP_KERNEL);
 219                 if (!h5)
 220                         return -ENOMEM;
 221         }
 222
 223         hu->priv = h5;
 224         h5->hu = hu;
 225
 226         skb_queue_head_init(&h5->unack);
 227         skb_queue_head_init(&h5->rel);
 228         skb_queue_head_init(&h5->unrel);
 229
 230         h5_reset_rx(h5);
 231
 232         timer_setup(&h5->timer, h5_timed_event, 0);
 233
 234         h5->tx_win = H5_TX_WIN_MAX;
 235
 236         if (h5->vnd && h5->vnd->open)
 237                 h5->vnd->open(h5);
 238
 239         set_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags);
 240
 241         /* Send initial sync request */
 242         h5_link_control(hu, sync, sizeof(sync));
 243         mod_timer(&h5->timer, jiffies + H5_SYNC_TIMEOUT);
 244
 245         return 0;
 246 }
 247
 248 static int h5_close(struct hci_uart *hu)
 249 {
 250         struct h5 *h5 = hu->priv;
 251
 252         del_timer_sync(&h5->timer);
 253
 254         skb_queue_purge(&h5->unack);
 255         skb_queue_purge(&h5->rel);
 256         skb_queue_purge(&h5->unrel);
 257
 258         kfree_skb(h5->rx_skb);
 259         h5->rx_skb = NULL;
 260
 261         if (h5->vnd && h5->vnd->close)
 262                 h5->vnd->close(h5);
 263
 264         if (!hu->serdev)
 265                 kfree(h5);
 266
 267         return 0;
 268 }
 269
 270 static int h5_setup(struct hci_uart *hu)
 271 {
 272         struct h5 *h5 = hu->priv;
 273
 274         if (h5->vnd && h5->vnd->setup)
 275                 return h5->vnd->setup(h5);
 276
 277         return 0;
 278 }
 279
 280 static void h5_pkt_cull(struct h5 *h5)
 281 {
 282         struct sk_buff *skb, *tmp;
 283         unsigned long flags;
 284         int i, to_remove;
 285         u8 seq;
 286
 287         spin_lock_irqsave(&h5->unack.lock, flags);
 288
 289         to_remove = skb_queue_len(&h5->unack);
 290         if (to_remove == 0)
 291                 goto unlock;
 292
 293         seq = h5->tx_seq;
 294
 295         while (to_remove > 0) {
 296                 if (h5->rx_ack == seq)
 297                         break;
 298
 299                 to_remove--;
 300                 seq = (seq - 1) & 0x07;
 301         }
 302
 303         if (seq != h5->rx_ack)
 304                 BT_ERR("Controller acked invalid packet");
 305
 306         i = 0;
 307         skb_queue_walk_safe(&h5->unack, skb, tmp) {
 308                 if (i++ >= to_remove)
 309                         break;
 310
 311                 __skb_unlink(skb, &h5->unack);
 312                 kfree_skb(skb);
 313         }
 314
 315         if (skb_queue_empty(&h5->unack))
 316                 del_timer(&h5->timer);
 317
 318 unlock:
 319         spin_unlock_irqrestore(&h5->unack.lock, flags);
 320 }
 321
 322 static void h5_handle_internal_rx(struct hci_uart *hu)
 323 {
 324         struct h5 *h5 = hu->priv;
 325         const unsigned char sync_req[] = { 0x01, 0x7e };
 326         const unsigned char sync_rsp[] = { 0x02, 0x7d };
 327         unsigned char conf_req[3] = { 0x03, 0xfc };
 328         const unsigned char conf_rsp[] = { 0x04, 0x7b };
 329         const unsigned char wakeup_req[] = { 0x05, 0xfa };
 330         const unsigned char woken_req[] = { 0x06, 0xf9 };
 331         const unsigned char sleep_req[] = { 0x07, 0x78 };
 332         const unsigned char *hdr = h5->rx_skb->data;
 333         const unsigned char *data = &h5->rx_skb->data[4];
 334
 335         BT_DBG("%s", hu->hdev->name);
 336
 337         if (H5_HDR_PKT_TYPE(hdr) != HCI_3WIRE_LINK_PKT)
 338                 return;
 339
 340         if (H5_HDR_LEN(hdr) < 2)
 341                 return;
 342
 343         conf_req[2] = h5_cfg_field(h5);
 344
 345         if (memcmp(data, sync_req, 2) == 0) {
 346                 if (h5->state == H5_ACTIVE)
 347                         h5_peer_reset(hu);
 348                 h5_link_control(hu, sync_rsp, 2);
 349         } else if (memcmp(data, sync_rsp, 2) == 0) {
 350                 if (h5->state == H5_ACTIVE)
 351                         h5_peer_reset(hu);
 352                 h5->state = H5_INITIALIZED;
 353                 h5_link_control(hu, conf_req, 3);
 354         } else if (memcmp(data, conf_req, 2) == 0) {
 355                 h5_link_control(hu, conf_rsp, 2);
 356                 h5_link_control(hu, conf_req, 3);
 357         } else if (memcmp(data, conf_rsp, 2) == 0) {
 358                 if (H5_HDR_LEN(hdr) > 2)
 359                         h5->tx_win = (data[2] & 0x07);
 360                 BT_DBG("Three-wire init complete. tx_win %u", h5->tx_win);
 361                 h5->state = H5_ACTIVE;
 362                 hci_uart_init_ready(hu);
 363                 return;
 364         } else if (memcmp(data, sleep_req, 2) == 0) {
 365                 BT_DBG("Peer went to sleep");
 366                 h5->sleep = H5_SLEEPING;
 367                 return;
 368         } else if (memcmp(data, woken_req, 2) == 0) {
 369                 BT_DBG("Peer woke up");
 370                 h5->sleep = H5_AWAKE;
 371         } else if (memcmp(data, wakeup_req, 2) == 0) {
 372                 BT_DBG("Peer requested wakeup");
 373                 h5_link_control(hu, woken_req, 2);
 374                 h5->sleep = H5_AWAKE;
 375         } else {
 376                 BT_DBG("Link Control: 0x%02hhx 0x%02hhx", data[0], data[1]);
 377                 return;
 378         }
 379
 380         hci_uart_tx_wakeup(hu);
 381 }
 382
 383 static void h5_complete_rx_pkt(struct hci_uart *hu)
 384 {
 385         struct h5 *h5 = hu->priv;
 386         const unsigned char *hdr = h5->rx_skb->data;
 387
 388         if (H5_HDR_RELIABLE(hdr)) {
 389                 h5->tx_ack = (h5->tx_ack + 1) % 8;
 390                 set_bit(H5_TX_ACK_REQ, &h5->flags);
 391                 hci_uart_tx_wakeup(hu);
 392         }
 393
 394         h5->rx_ack = H5_HDR_ACK(hdr);
 395
 396         h5_pkt_cull(h5);
 397
 398         switch (H5_HDR_PKT_TYPE(hdr)) {
 399         case HCI_EVENT_PKT:
 400         case HCI_ACLDATA_PKT:
 401         case HCI_SCODATA_PKT:
 402         case HCI_ISODATA_PKT:
 403                 hci_skb_pkt_type(h5->rx_skb) = H5_HDR_PKT_TYPE(hdr);
 404
 405                 /* Remove Three-wire header */
 406                 skb_pull(h5->rx_skb, 4);
 407
 408                 hci_recv_frame(hu->hdev, h5->rx_skb);
 409                 h5->rx_skb = NULL;
 410
 411                 break;
 412
 413         default:
 414                 h5_handle_internal_rx(hu);
 415                 break;
 416         }
 417
 418         h5_reset_rx(h5);
 419 }
 420
 421 static int h5_rx_crc(struct hci_uart *hu, unsigned char c)
 422 {
 423         h5_complete_rx_pkt(hu);
 424
 425         return 0;
 426 }
 427
 428 static int h5_rx_payload(struct hci_uart *hu, unsigned char c)
 429 {
 430         struct h5 *h5 = hu->priv;
 431         const unsigned char *hdr = h5->rx_skb->data;
 432
 433         if (H5_HDR_CRC(hdr)) {
 434                 h5->rx_func = h5_rx_crc;
 435                 h5->rx_pending = 2;
 436         } else {
 437                 h5_complete_rx_pkt(hu);
 438         }
 439
 440         return 0;
 441 }
 442
 443 static int h5_rx_3wire_hdr(struct hci_uart *hu, unsigned char c)
 444 {
 445         struct h5 *h5 = hu->priv;
 446         const unsigned char *hdr = h5->rx_skb->data;
 447
 448         BT_DBG("%s rx: seq %u ack %u crc %u rel %u type %u len %u",
 449                hu->hdev->name, H5_HDR_SEQ(hdr), H5_HDR_ACK(hdr),
 450                H5_HDR_CRC(hdr), H5_HDR_RELIABLE(hdr), H5_HDR_PKT_TYPE(hdr),
 451                H5_HDR_LEN(hdr));
 452
 453         if (((hdr[0] + hdr[1] + hdr[2] + hdr[3]) & 0xff) != 0xff) {
 454                 bt_dev_err(hu->hdev, "Invalid header checksum");
 455                 h5_reset_rx(h5);
 456                 return 0;
 457         }
 458
 459         if (H5_HDR_RELIABLE(hdr) && H5_HDR_SEQ(hdr) != h5->tx_ack) {
 460                 bt_dev_err(hu->hdev, "Out-of-order packet arrived (%u != %u)",
 461                            H5_HDR_SEQ(hdr), h5->tx_ack);
 462                 h5_reset_rx(h5);
 463                 return 0;
 464         }
 465
 466         if (h5->state != H5_ACTIVE &&
 467             H5_HDR_PKT_TYPE(hdr) != HCI_3WIRE_LINK_PKT) {
 468                 bt_dev_err(hu->hdev, "Non-link packet received in non-active state");
 469                 h5_reset_rx(h5);
 470                 return 0;
 471         }
 472
 473         h5->rx_func = h5_rx_payload;
 474         h5->rx_pending = H5_HDR_LEN(hdr);
 475
 476         return 0;
 477 }
 478
 479 static int h5_rx_pkt_start(struct hci_uart *hu, unsigned char c)
 480 {
 481         struct h5 *h5 = hu->priv;
 482
 483         if (c == SLIP_DELIMITER)
 484                 return 1;
 485
 486         h5->rx_func = h5_rx_3wire_hdr;
 487         h5->rx_pending = 4;
 488
 489         h5->rx_skb = bt_skb_alloc(H5_MAX_LEN, GFP_ATOMIC);
 490         if (!h5->rx_skb) {
 491                 bt_dev_err(hu->hdev, "Can't allocate mem for new packet");
 492                 h5_reset_rx(h5);
 493                 return -ENOMEM;
 494         }
 495
 496         h5->rx_skb->dev = (void *)hu->hdev;
 497
 498         return 0;
 499 }
 500
 501 static int h5_rx_delimiter(struct hci_uart *hu, unsigned char c)
 502 {
 503         struct h5 *h5 = hu->priv;
 504
 505         if (c == SLIP_DELIMITER)
 506                 h5->rx_func = h5_rx_pkt_start;
 507
 508         return 1;
 509 }
 510
 511 static void h5_unslip_one_byte(struct h5 *h5, unsigned char c)
 512 {
 513         const u8 delim = SLIP_DELIMITER, esc = SLIP_ESC;
 514         const u8 *byte = &c;
 515
 516         if (!test_bit(H5_RX_ESC, &h5->flags) && c == SLIP_ESC) {
 517                 set_bit(H5_RX_ESC, &h5->flags);
 518                 return;
 519         }
 520
 521         if (test_and_clear_bit(H5_RX_ESC, &h5->flags)) {
 522                 switch (c) {
 523                 case SLIP_ESC_DELIM:
 524                         byte = &delim;
 525                         break;
 526                 case SLIP_ESC_ESC:
 527                         byte = &esc;
 528                         break;
 529                 default:
 530                         BT_ERR("Invalid esc byte 0x%02hhx", c);
 531                         h5_reset_rx(h5);
 532                         return;
 533                 }
 534         }
 535
 536         skb_put_data(h5->rx_skb, byte, 1);
 537         h5->rx_pending--;
 538
 539         BT_DBG("unslipped 0x%02hhx, rx_pending %zu", *byte, h5->rx_pending);
 540 }
 541
 542 static void h5_reset_rx(struct h5 *h5)
 543 {
 544         if (h5->rx_skb) {
 545                 kfree_skb(h5->rx_skb);
 546                 h5->rx_skb = NULL;
 547         }
 548
 549         h5->rx_func = h5_rx_delimiter;
 550         h5->rx_pending = 0;
 551         clear_bit(H5_RX_ESC, &h5->flags);
 552 }
 553
 554 static int h5_recv(struct hci_uart *hu, const void *data, int count)
 555 {
 556         struct h5 *h5 = hu->priv;
 557         const unsigned char *ptr = data;
 558
 559         BT_DBG("%s pending %zu count %d", hu->hdev->name, h5->rx_pending,
 560                count);
 561
 562         while (count > 0) {
 563                 int processed;
 564
 565                 if (h5->rx_pending > 0) {
 566                         if (*ptr == SLIP_DELIMITER) {
 567                                 bt_dev_err(hu->hdev, "Too short H5 packet");
 568                                 h5_reset_rx(h5);
 569                                 continue;
 570                         }
 571
 572                         h5_unslip_one_byte(h5, *ptr);
 573
 574                         ptr++; count--;
 575                         continue;
 576                 }
 577
 578                 processed = h5->rx_func(hu, *ptr);
 579                 if (processed < 0)
 580                         return processed;
 581
 582                 ptr += processed;
 583                 count -= processed;
 584         }
 585
 586         return 0;
 587 }
 588
 589 static int h5_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 590 {
 591         struct h5 *h5 = hu->priv;
 592
 593         if (skb->len > 0xfff) {
 594                 bt_dev_err(hu->hdev, "Packet too long (%u bytes)", skb->len);
 595                 kfree_skb(skb);
 596                 return 0;
 597         }
 598
 599         if (h5->state != H5_ACTIVE) {
 600                 bt_dev_err(hu->hdev, "Ignoring HCI data in non-active state");
 601                 kfree_skb(skb);
 602                 return 0;
 603         }
 604
 605         switch (hci_skb_pkt_type(skb)) {
 606         case HCI_ACLDATA_PKT:
 607         case HCI_COMMAND_PKT:
 608                 skb_queue_tail(&h5->rel, skb);
 609                 break;
 610
 611         case HCI_SCODATA_PKT:
 612         case HCI_ISODATA_PKT:
 613                 skb_queue_tail(&h5->unrel, skb);
 614                 break;
 615
 616         default:
 617                 bt_dev_err(hu->hdev, "Unknown packet type %u", hci_skb_pkt_type(skb));
 618                 kfree_skb(skb);
 619                 break;
 620         }
 621
 622         return 0;
 623 }
 624
 625 static void h5_slip_delim(struct sk_buff *skb)
 626 {
 627         const char delim = SLIP_DELIMITER;
 628
 629         skb_put_data(skb, &delim, 1);
 630 }
 631
 632 static void h5_slip_one_byte(struct sk_buff *skb, u8 c)
 633 {
 634         const char esc_delim[2] = { SLIP_ESC, SLIP_ESC_DELIM };
 635         const char esc_esc[2] = { SLIP_ESC, SLIP_ESC_ESC };
 636
 637         switch (c) {
 638         case SLIP_DELIMITER:
 639                 skb_put_data(skb, &esc_delim, 2);
 640                 break;
 641         case SLIP_ESC:
 642                 skb_put_data(skb, &esc_esc, 2);
 643                 break;
 644         default:
 645                 skb_put_data(skb, &c, 1);
 646         }
 647 }
 648
 649 static bool valid_packet_type(u8 type)
 650 {
 651         switch (type) {
 652         case HCI_ACLDATA_PKT:
 653         case HCI_COMMAND_PKT:
 654         case HCI_SCODATA_PKT:
 655         case HCI_ISODATA_PKT:
 656         case HCI_3WIRE_LINK_PKT:
 657         case HCI_3WIRE_ACK_PKT:
 658                 return true;
 659         default:
 660                 return false;
 661         }
 662 }
 663
 664 static struct sk_buff *h5_prepare_pkt(struct hci_uart *hu, u8 pkt_type,
 665                                       const u8 *data, size_t len)
 666 {
 667         struct h5 *h5 = hu->priv;
 668         struct sk_buff *nskb;
 669         u8 hdr[4];
 670         int i;
 671
 672         if (!valid_packet_type(pkt_type)) {
 673                 bt_dev_err(hu->hdev, "Unknown packet type %u", pkt_type);
 674                 return NULL;
 675         }
 676
 677         /*
 678          * Max len of packet: (original len + 4 (H5 hdr) + 2 (crc)) * 2
 679          * (because bytes 0xc0 and 0xdb are escaped, worst case is when
 680          * the packet is all made of 0xc0 and 0xdb) + 2 (0xc0
 681          * delimiters at start and end).
 682          */
 683         nskb = alloc_skb((len + 6) * 2 + 2, GFP_ATOMIC);
 684         if (!nskb)
 685                 return NULL;
 686
 687         hci_skb_pkt_type(nskb) = pkt_type;
 688
 689         h5_slip_delim(nskb);
 690
 691         hdr[0] = h5->tx_ack << 3;
 692         clear_bit(H5_TX_ACK_REQ, &h5->flags);
 693
 694         /* Reliable packet? */
 695         if (pkt_type == HCI_ACLDATA_PKT || pkt_type == HCI_COMMAND_PKT) {
 696                 hdr[0] |= 1 << 7;
 697                 hdr[0] |= h5->tx_seq;
 698                 h5->tx_seq = (h5->tx_seq + 1) % 8;
 699         }
 700
 701         hdr[1] = pkt_type | ((len & 0x0f) << 4);
 702         hdr[2] = len >> 4;
 703         hdr[3] = ~((hdr[0] + hdr[1] + hdr[2]) & 0xff);
 704
 705         BT_DBG("%s tx: seq %u ack %u crc %u rel %u type %u len %u",
 706                hu->hdev->name, H5_HDR_SEQ(hdr), H5_HDR_ACK(hdr),
 707                H5_HDR_CRC(hdr), H5_HDR_RELIABLE(hdr), H5_HDR_PKT_TYPE(hdr),
 708                H5_HDR_LEN(hdr));
 709
 710         for (i = 0; i < 4; i++)
 711                 h5_slip_one_byte(nskb, hdr[i]);
 712
 713         for (i = 0; i < len; i++)
 714                 h5_slip_one_byte(nskb, data[i]);
 715
 716         h5_slip_delim(nskb);
 717
 718         return nskb;
 719 }
 720
 721 static struct sk_buff *h5_dequeue(struct hci_uart *hu)
 722 {
 723         struct h5 *h5 = hu->priv;
 724         unsigned long flags;
 725         struct sk_buff *skb, *nskb;
 726
 727         if (h5->sleep != H5_AWAKE) {
 728                 const unsigned char wakeup_req[] = { 0x05, 0xfa };
 729
 730                 if (h5->sleep == H5_WAKING_UP)
 731                         return NULL;
 732
 733                 h5->sleep = H5_WAKING_UP;
 734                 BT_DBG("Sending wakeup request");
 735
 736                 mod_timer(&h5->timer, jiffies + HZ / 100);
 737                 return h5_prepare_pkt(hu, HCI_3WIRE_LINK_PKT, wakeup_req, 2);
 738         }
 739
 740         skb = skb_dequeue(&h5->unrel);
 741         if (skb) {
 742                 nskb = h5_prepare_pkt(hu, hci_skb_pkt_type(skb),
 743                                       skb->data, skb->len);
 744                 if (nskb) {
 745                         kfree_skb(skb);
 746                         return nskb;
 747                 }
 748
 749                 skb_queue_head(&h5->unrel, skb);
 750                 bt_dev_err(hu->hdev, "Could not dequeue pkt because alloc_skb failed");
 751         }
 752
 753         spin_lock_irqsave_nested(&h5->unack.lock, flags, SINGLE_DEPTH_NESTING);
 754
 755         if (h5->unack.qlen >= h5->tx_win)
 756                 goto unlock;
 757
 758         skb = skb_dequeue(&h5->rel);
 759         if (skb) {
 760                 nskb = h5_prepare_pkt(hu, hci_skb_pkt_type(skb),
 761                                       skb->data, skb->len);
 762                 if (nskb) {
 763                         __skb_queue_tail(&h5->unack, skb);
 764                         mod_timer(&h5->timer, jiffies + H5_ACK_TIMEOUT);
 765                         spin_unlock_irqrestore(&h5->unack.lock, flags);
 766                         return nskb;
 767                 }
 768
 769                 skb_queue_head(&h5->rel, skb);
 770                 bt_dev_err(hu->hdev, "Could not dequeue pkt because alloc_skb failed");
 771         }
 772
 773 unlock:
 774         spin_unlock_irqrestore(&h5->unack.lock, flags);
 775
 776         if (test_bit(H5_TX_ACK_REQ, &h5->flags))
 777                 return h5_prepare_pkt(hu, HCI_3WIRE_ACK_PKT, NULL, 0);
 778
 779         return NULL;
 780 }
 781
 782 static int h5_flush(struct hci_uart *hu)
 783 {
 784         BT_DBG("hu %p", hu);
 785         return 0;
 786 }
 787
 788 static const struct hci_uart_proto h5p = {
 789         .id             = HCI_UART_3WIRE,
 790         .name           = "Three-wire (H5)",
 791         .open           = h5_open,
 792         .close          = h5_close,
 793         .setup          = h5_setup,
 794         .recv           = h5_recv,
 795         .enqueue        = h5_enqueue,
 796         .dequeue        = h5_dequeue,
 797         .flush          = h5_flush,
 798 };
 799
 800 static int h5_serdev_probe(struct serdev_device *serdev)
 801 {
 802         struct device *dev = &serdev->dev;
 803         struct h5 *h5;
 804         const struct h5_device_data *data;
 805         int err;
 806
 807         h5 = devm_kzalloc(dev, sizeof(*h5), GFP_KERNEL);
 808         if (!h5)
 809                 return -ENOMEM;
 810
 811         h5->hu = &h5->serdev_hu;
 812         h5->serdev_hu.serdev = serdev;
 813         serdev_device_set_drvdata(serdev, h5);
 814
 815         if (has_acpi_companion(dev)) {
 816                 const struct acpi_device_id *match;
 817
 818                 match = acpi_match_device(dev->driver->acpi_match_table, dev);
 819                 if (!match)
 820                         return -ENODEV;
 821
 822                 data = (const struct h5_device_data *)match->driver_data;
 823                 h5->vnd = data->vnd;
 824                 h5->id  = (char *)match->id;
 825
 826                 if (h5->vnd->acpi_gpio_map)
 827                         devm_acpi_dev_add_driver_gpios(dev,
 828                                                        h5->vnd->acpi_gpio_map);
 829         } else {
 830                 data = of_device_get_match_data(dev);
 831                 if (!data)
 832                         return -ENODEV;
 833
 834                 h5->vnd = data->vnd;
 835         }
 836
 837
 838         h5->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_LOW);
 839         if (IS_ERR(h5->enable_gpio))
 840                 return PTR_ERR(h5->enable_gpio);
 841
 842         h5->device_wake_gpio = devm_gpiod_get_optional(dev, "device-wake",
 843                                                        GPIOD_OUT_LOW);
 844         if (IS_ERR(h5->device_wake_gpio))
 845                 return PTR_ERR(h5->device_wake_gpio);
 846
 847         err = hci_uart_register_device(&h5->serdev_hu, &h5p);
 848         if (err)
 849                 return err;
 850
 851         if (data->driver_info & H5_INFO_WAKEUP_DISABLE)
 852                 set_bit(H5_WAKEUP_DISABLE, &h5->flags);
 853
 854         return 0;
 855 }
 856
 857 static void h5_serdev_remove(struct serdev_device *serdev)
 858 {
 859         struct h5 *h5 = serdev_device_get_drvdata(serdev);
 860
 861         hci_uart_unregister_device(&h5->serdev_hu);
 862 }
 863
 864 static int __maybe_unused h5_serdev_suspend(struct device *dev)
 865 {
 866         struct h5 *h5 = dev_get_drvdata(dev);
 867         int ret = 0;
 868
 869         if (h5->vnd && h5->vnd->suspend)
 870                 ret = h5->vnd->suspend(h5);
 871
 872         return ret;
 873 }
 874
 875 static int __maybe_unused h5_serdev_resume(struct device *dev)
 876 {
 877         struct h5 *h5 = dev_get_drvdata(dev);
 878         int ret = 0;
 879
 880         if (h5->vnd && h5->vnd->resume)
 881                 ret = h5->vnd->resume(h5);
 882
 883         return ret;
 884 }
 885
 886 #ifdef CONFIG_BT_HCIUART_RTL
 887 static int h5_btrtl_setup(struct h5 *h5)
 888 {
 889         struct btrtl_device_info *btrtl_dev;
 890         struct sk_buff *skb;
 891         __le32 baudrate_data;
 892         u32 device_baudrate;
 893         unsigned int controller_baudrate;
 894         bool flow_control;
 895         int err;
 896
 897         btrtl_dev = btrtl_initialize(h5->hu->hdev, h5->id);
 898         if (IS_ERR(btrtl_dev))
 899                 return PTR_ERR(btrtl_dev);
 900
 901         err = btrtl_get_uart_settings(h5->hu->hdev, btrtl_dev,
 902                                       &controller_baudrate, &device_baudrate,
 903                                       &flow_control);
 904         if (err)
 905                 goto out_free;
 906
 907         baudrate_data = cpu_to_le32(device_baudrate);
 908         skb = __hci_cmd_sync(h5->hu->hdev, 0xfc17, sizeof(baudrate_data),
 909                              &baudrate_data, HCI_INIT_TIMEOUT);
 910         if (IS_ERR(skb)) {
 911                 rtl_dev_err(h5->hu->hdev, "set baud rate command failed\n");
 912                 err = PTR_ERR(skb);
 913                 goto out_free;
 914         } else {
 915                 kfree_skb(skb);
 916         }
 917         /* Give the device some time to set up the new baudrate. */
 918         usleep_range(10000, 20000);
 919
 920         serdev_device_set_baudrate(h5->hu->serdev, controller_baudrate);
 921         serdev_device_set_flow_control(h5->hu->serdev, flow_control);
 922
 923         err = btrtl_download_firmware(h5->hu->hdev, btrtl_dev);
 924         /* Give the device some time before the hci-core sends it a reset */
 925         usleep_range(10000, 20000);
 926
 927         btrtl_set_quirks(h5->hu->hdev, btrtl_dev);
 928
 929 out_free:
 930         btrtl_free(btrtl_dev);
 931
 932         return err;
 933 }
 934
 935 static void h5_btrtl_open(struct h5 *h5)
 936 {
 937         /*
 938          * Since h5_btrtl_resume() does a device_reprobe() the suspend handling
 939          * done by the hci_suspend_notifier is not necessary; it actually causes
 940          * delays and a bunch of errors to get logged, so disable it.
 941          */
 942         if (test_bit(H5_WAKEUP_DISABLE, &h5->flags))
 943                 set_bit(HCI_UART_NO_SUSPEND_NOTIFIER, &h5->hu->flags);
 944
 945         /* Devices always start with these fixed parameters */
 946         serdev_device_set_flow_control(h5->hu->serdev, false);
 947         serdev_device_set_parity(h5->hu->serdev, SERDEV_PARITY_EVEN);
 948         serdev_device_set_baudrate(h5->hu->serdev, 115200);
 949
 950         /* The controller needs up to 500ms to wakeup */
 951         gpiod_set_value_cansleep(h5->enable_gpio, 1);
 952         gpiod_set_value_cansleep(h5->device_wake_gpio, 1);
 953         msleep(500);
 954 }
 955
 956 static void h5_btrtl_close(struct h5 *h5)
 957 {
 958         gpiod_set_value_cansleep(h5->device_wake_gpio, 0);
 959         gpiod_set_value_cansleep(h5->enable_gpio, 0);
 960 }
 961
 962 /* Suspend/resume support. On many devices the RTL BT device loses power during
 963  * suspend/resume, causing it to lose its firmware and all state. So we simply
 964  * turn it off on suspend and reprobe on resume. This mirrors how RTL devices
 965  * are handled in the USB driver, where the BTUSB_WAKEUP_DISABLE is used which
 966  * also causes a reprobe on resume.
 967  */
 968 static int h5_btrtl_suspend(struct h5 *h5)
 969 {
 970         serdev_device_set_flow_control(h5->hu->serdev, false);
 971         gpiod_set_value_cansleep(h5->device_wake_gpio, 0);
 972
 973         if (test_bit(H5_WAKEUP_DISABLE, &h5->flags))
 974                 gpiod_set_value_cansleep(h5->enable_gpio, 0);
 975
 976         return 0;
 977 }
 978
 979 struct h5_btrtl_reprobe {
 980         struct device *dev;
 981         struct work_struct work;
 982 };
 983
 984 static void h5_btrtl_reprobe_worker(struct work_struct *work)
 985 {
 986         struct h5_btrtl_reprobe *reprobe =
 987                 container_of(work, struct h5_btrtl_reprobe, work);
 988         int ret;
 989
 990         ret = device_reprobe(reprobe->dev);
 991         if (ret && ret != -EPROBE_DEFER)
 992                 dev_err(reprobe->dev, "Reprobe error %d\n", ret);
 993
 994         put_device(reprobe->dev);
 995         kfree(reprobe);
 996         module_put(THIS_MODULE);
 997 }
 998
 999 static int h5_btrtl_resume(struct h5 *h5)
1000 {
1001         if (test_bit(H5_WAKEUP_DISABLE, &h5->flags)) {
1002                 struct h5_btrtl_reprobe *reprobe;
1003
1004                 reprobe = kzalloc(sizeof(*reprobe), GFP_KERNEL);
1005                 if (!reprobe)
1006                         return -ENOMEM;
1007
1008                 __module_get(THIS_MODULE);
1009
1010                 INIT_WORK(&reprobe->work, h5_btrtl_reprobe_worker);
1011                 reprobe->dev = get_device(&h5->hu->serdev->dev);
1012                 queue_work(system_long_wq, &reprobe->work);
1013         } else {
1014                 gpiod_set_value_cansleep(h5->device_wake_gpio, 1);
1015         }
1016         return 0;
1017 }
1018
1019 static const struct acpi_gpio_params btrtl_device_wake_gpios = { 0, 0, false };
1020 static const struct acpi_gpio_params btrtl_enable_gpios = { 1, 0, false };
1021 static const struct acpi_gpio_params btrtl_host_wake_gpios = { 2, 0, false };
1022 static const struct acpi_gpio_mapping acpi_btrtl_gpios[] = {
1023         { "device-wake-gpios", &btrtl_device_wake_gpios, 1 },
1024         { "enable-gpios", &btrtl_enable_gpios, 1 },
1025         { "host-wake-gpios", &btrtl_host_wake_gpios, 1 },
1026         {},
1027 };
1028
1029 static struct h5_vnd rtl_vnd = {
1030         .setup          = h5_btrtl_setup,
1031         .open           = h5_btrtl_open,
1032         .close          = h5_btrtl_close,
1033         .suspend        = h5_btrtl_suspend,
1034         .resume         = h5_btrtl_resume,
1035         .acpi_gpio_map  = acpi_btrtl_gpios,
1036 };
1037
1038 static const struct h5_device_data h5_data_rtl8822cs = {
1039         .vnd = &rtl_vnd,
1040 };
1041
1042 static const struct h5_device_data h5_data_rtl8723bs = {
1043         .driver_info = H5_INFO_WAKEUP_DISABLE,
1044         .vnd = &rtl_vnd,
1045 };
1046 #endif
1047
1048 #ifdef CONFIG_ACPI
1049 static const struct acpi_device_id h5_acpi_match[] = {
1050 #ifdef CONFIG_BT_HCIUART_RTL
1051         { "OBDA0623", (kernel_ulong_t)&h5_data_rtl8723bs },
1052         { "OBDA8723", (kernel_ulong_t)&h5_data_rtl8723bs },
1053 #endif
1054         { },
1055 };
1056 MODULE_DEVICE_TABLE(acpi, h5_acpi_match);
1057 #endif
1058
1059 static const struct dev_pm_ops h5_serdev_pm_ops = {
1060         SET_SYSTEM_SLEEP_PM_OPS(h5_serdev_suspend, h5_serdev_resume)
1061 };
1062
1063 static const struct of_device_id rtl_bluetooth_of_match[] = {
1064 #ifdef CONFIG_BT_HCIUART_RTL
1065         { .compatible = "realtek,rtl8822cs-bt",
1066           .data = (const void *)&h5_data_rtl8822cs },
1067         { .compatible = "realtek,rtl8723bs-bt",
1068           .data = (const void *)&h5_data_rtl8723bs },
1069         { .compatible = "realtek,rtl8723ds-bt",
1070           .data = (const void *)&h5_data_rtl8723bs },
1071 #endif
1072         { },
1073 };
1074 MODULE_DEVICE_TABLE(of, rtl_bluetooth_of_match);
1075
1076 static struct serdev_device_driver h5_serdev_driver = {
1077         .probe = h5_serdev_probe,
1078         .remove = h5_serdev_remove,
1079         .driver = {
1080                 .name = "hci_uart_h5",
1081                 .acpi_match_table = ACPI_PTR(h5_acpi_match),
1082                 .pm = &h5_serdev_pm_ops,
1083                 .of_match_table = rtl_bluetooth_of_match,
1084         },
1085 };
1086
1087 int __init h5_init(void)
1088 {
1089         serdev_device_driver_register(&h5_serdev_driver);
1090         return hci_uart_register_proto(&h5p);
1091 }
1092
1093 int __exit h5_deinit(void)
1094 {
1095         serdev_device_driver_unregister(&h5_serdev_driver);
1096         return hci_uart_unregister_proto(&h5p);
1097 }