drivers/bluetooth/hci_serdev.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Bluetooth HCI serdev driver lib
   4  *
   5  *  Copyright (C) 2017  Linaro, Ltd., Rob Herring <robh@kernel.org>
   6  *
   7  *  Based on hci_ldisc.c:
   8  *
   9  *  Copyright (C) 2000-2001  Qualcomm Incorporated
  10  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
  11  *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/types.h>
  16 #include <linux/serdev.h>
  17 #include <linux/skbuff.h>
  18
  19 #include <net/bluetooth/bluetooth.h>
  20 #include <net/bluetooth/hci_core.h>
  21
  22 #include "hci_uart.h"
  23
  24 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
  25 {
  26         struct hci_dev *hdev = hu->hdev;
  27
  28         /* Update HCI stat counters */
  29         switch (pkt_type) {
  30         case HCI_COMMAND_PKT:
  31                 hdev->stat.cmd_tx++;
  32                 break;
  33
  34         case HCI_ACLDATA_PKT:
  35                 hdev->stat.acl_tx++;
  36                 break;
  37
  38         case HCI_SCODATA_PKT:
  39                 hdev->stat.sco_tx++;
  40                 break;
  41         }
  42 }
  43
  44 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
  45 {
  46         struct sk_buff *skb = hu->tx_skb;
  47
  48         if (!skb) {
  49                 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
  50                         skb = hu->proto->dequeue(hu);
  51         } else
  52                 hu->tx_skb = NULL;
  53
  54         return skb;
  55 }
  56
  57 static void hci_uart_write_work(struct work_struct *work)
  58 {
  59         struct hci_uart *hu = container_of(work, struct hci_uart, write_work);
  60         struct serdev_device *serdev = hu->serdev;
  61         struct hci_dev *hdev = hu->hdev;
  62         struct sk_buff *skb;
  63
  64         /* REVISIT:
  65          * should we cope with bad skbs or ->write() returning an error value?
  66          */
  67         do {
  68                 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
  69
  70                 while ((skb = hci_uart_dequeue(hu))) {
  71                         int len;
  72
  73                         len = serdev_device_write_buf(serdev,
  74                                                       skb->data, skb->len);
  75                         hdev->stat.byte_tx += len;
  76
  77                         skb_pull(skb, len);
  78                         if (skb->len) {
  79                                 hu->tx_skb = skb;
  80                                 break;
  81                         }
  82
  83                         hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
  84                         kfree_skb(skb);
  85                 }
  86
  87                 clear_bit(HCI_UART_SENDING, &hu->tx_state);
  88         } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state));
  89 }
  90
  91 /* ------- Interface to HCI layer ------ */
  92
  93 /* Reset device */
  94 static int hci_uart_flush(struct hci_dev *hdev)
  95 {
  96         struct hci_uart *hu  = hci_get_drvdata(hdev);
  97
  98         BT_DBG("hdev %p serdev %p", hdev, hu->serdev);
  99
 100         if (hu->tx_skb) {
 101                 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
 102         }
 103
 104         /* Flush any pending characters in the driver and discipline. */
 105         serdev_device_write_flush(hu->serdev);
 106
 107         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 108                 hu->proto->flush(hu);
 109
 110         return 0;
 111 }
 112
 113 /* Initialize device */
 114 static int hci_uart_open(struct hci_dev *hdev)
 115 {
 116         struct hci_uart *hu = hci_get_drvdata(hdev);
 117         int err;
 118
 119         BT_DBG("%s %p", hdev->name, hdev);
 120
 121         /* When Quirk HCI_QUIRK_NON_PERSISTENT_SETUP is set by
 122          * driver, BT SoC is completely turned OFF during
 123          * BT OFF. Upon next BT ON UART port should be opened.
 124          */
 125         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 126                 err = serdev_device_open(hu->serdev);
 127                 if (err)
 128                         return err;
 129                 set_bit(HCI_UART_PROTO_READY, &hu->flags);
 130         }
 131
 132         /* Undo clearing this from hci_uart_close() */
 133         hdev->flush = hci_uart_flush;
 134
 135         return 0;
 136 }
 137
 138 /* Close device */
 139 static int hci_uart_close(struct hci_dev *hdev)
 140 {
 141         struct hci_uart *hu = hci_get_drvdata(hdev);
 142
 143         BT_DBG("hdev %p", hdev);
 144
 145         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 146                 return 0;
 147
 148         hci_uart_flush(hdev);
 149         hdev->flush = NULL;
 150
 151         /* When QUIRK HCI_QUIRK_NON_PERSISTENT_SETUP is set by driver,
 152          * BT SOC is completely powered OFF during BT OFF, holding port
 153          * open may drain the battery.
 154          */
 155         if (test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) {
 156                 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 157                 serdev_device_close(hu->serdev);
 158         }
 159
 160         return 0;
 161 }
 162
 163 /* Send frames from HCI layer */
 164 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 165 {
 166         struct hci_uart *hu = hci_get_drvdata(hdev);
 167
 168         BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
 169                skb->len);
 170
 171         hu->proto->enqueue(hu, skb);
 172
 173         hci_uart_tx_wakeup(hu);
 174
 175         return 0;
 176 }
 177
 178 static int hci_uart_setup(struct hci_dev *hdev)
 179 {
 180         struct hci_uart *hu = hci_get_drvdata(hdev);
 181         struct hci_rp_read_local_version *ver;
 182         struct sk_buff *skb;
 183         unsigned int speed;
 184         int err;
 185
 186         /* Init speed if any */
 187         if (hu->init_speed)
 188                 speed = hu->init_speed;
 189         else if (hu->proto->init_speed)
 190                 speed = hu->proto->init_speed;
 191         else
 192                 speed = 0;
 193
 194         if (speed)
 195                 serdev_device_set_baudrate(hu->serdev, speed);
 196
 197         /* Operational speed if any */
 198         if (hu->oper_speed)
 199                 speed = hu->oper_speed;
 200         else if (hu->proto->oper_speed)
 201                 speed = hu->proto->oper_speed;
 202         else
 203                 speed = 0;
 204
 205         if (hu->proto->set_baudrate && speed) {
 206                 err = hu->proto->set_baudrate(hu, speed);
 207                 if (err)
 208                         bt_dev_err(hdev, "Failed to set baudrate");
 209                 else
 210                         serdev_device_set_baudrate(hu->serdev, speed);
 211         }
 212
 213         if (hu->proto->setup)
 214                 return hu->proto->setup(hu);
 215
 216         if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
 217                 return 0;
 218
 219         skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
 220                              HCI_INIT_TIMEOUT);
 221         if (IS_ERR(skb)) {
 222                 bt_dev_err(hdev, "Reading local version info failed (%ld)",
 223                            PTR_ERR(skb));
 224                 return 0;
 225         }
 226
 227         if (skb->len != sizeof(*ver))
 228                 bt_dev_err(hdev, "Event length mismatch for version info");
 229
 230         kfree_skb(skb);
 231         return 0;
 232 }
 233
 234 /* Check if the device is wakeable */
 235 static bool hci_uart_wakeup(struct hci_dev *hdev)
 236 {
 237         /* HCI UART devices are assumed to be wakeable by default.
 238          * Implement wakeup callback to override this behavior.
 239          */
 240         return true;
 241 }
 242
 243 /** hci_uart_write_wakeup - transmit buffer wakeup
 244  * @serdev: serial device
 245  *
 246  * This function is called by the serdev framework when it accepts
 247  * more data being sent.
 248  */
 249 static void hci_uart_write_wakeup(struct serdev_device *serdev)
 250 {
 251         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 252
 253         BT_DBG("");
 254
 255         if (!hu || serdev != hu->serdev) {
 256                 WARN_ON(1);
 257                 return;
 258         }
 259
 260         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 261                 hci_uart_tx_wakeup(hu);
 262 }
 263
 264 /** hci_uart_receive_buf - receive buffer wakeup
 265  * @serdev: serial device
 266  * @data:   pointer to received data
 267  * @count:  count of received data in bytes
 268  *
 269  * This function is called by the serdev framework when it received data
 270  * in the RX buffer.
 271  *
 272  * Return: number of processed bytes
 273  */
 274 static size_t hci_uart_receive_buf(struct serdev_device *serdev,
 275                                    const u8 *data, size_t count)
 276 {
 277         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 278
 279         if (!hu || serdev != hu->serdev) {
 280                 WARN_ON(1);
 281                 return 0;
 282         }
 283
 284         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 285                 return 0;
 286
 287         /* It does not need a lock here as it is already protected by a mutex in
 288          * tty caller
 289          */
 290         hu->proto->recv(hu, data, count);
 291
 292         if (hu->hdev)
 293                 hu->hdev->stat.byte_rx += count;
 294
 295         return count;
 296 }
 297
 298 static const struct serdev_device_ops hci_serdev_client_ops = {
 299         .receive_buf = hci_uart_receive_buf,
 300         .write_wakeup = hci_uart_write_wakeup,
 301 };
 302
 303 int hci_uart_register_device_priv(struct hci_uart *hu,
 304                              const struct hci_uart_proto *p,
 305                              int sizeof_priv)
 306 {
 307         int err;
 308         struct hci_dev *hdev;
 309
 310         BT_DBG("");
 311
 312         serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops);
 313
 314         if (percpu_init_rwsem(&hu->proto_lock))
 315                 return -ENOMEM;
 316
 317         err = serdev_device_open(hu->serdev);
 318         if (err)
 319                 goto err_rwsem;
 320
 321         err = p->open(hu);
 322         if (err)
 323                 goto err_open;
 324
 325         hu->proto = p;
 326         set_bit(HCI_UART_PROTO_READY, &hu->flags);
 327
 328         /* Initialize and register HCI device */
 329         hdev = hci_alloc_dev_priv(sizeof_priv);
 330         if (!hdev) {
 331                 BT_ERR("Can't allocate HCI device");
 332                 err = -ENOMEM;
 333                 goto err_alloc;
 334         }
 335
 336         hu->hdev = hdev;
 337
 338         hdev->bus = HCI_UART;
 339         hci_set_drvdata(hdev, hu);
 340
 341         INIT_WORK(&hu->init_ready, hci_uart_init_work);
 342         INIT_WORK(&hu->write_work, hci_uart_write_work);
 343
 344         /* Only when vendor specific setup callback is provided, consider
 345          * the manufacturer information valid. This avoids filling in the
 346          * value for Ericsson when nothing is specified.
 347          */
 348         if (hu->proto->setup)
 349                 hdev->manufacturer = hu->proto->manufacturer;
 350
 351         hdev->open  = hci_uart_open;
 352         hdev->close = hci_uart_close;
 353         hdev->flush = hci_uart_flush;
 354         hdev->send  = hci_uart_send_frame;
 355         hdev->setup = hci_uart_setup;
 356         if (!hdev->wakeup)
 357                 hdev->wakeup = hci_uart_wakeup;
 358         SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
 359
 360         if (test_bit(HCI_UART_NO_SUSPEND_NOTIFIER, &hu->flags))
 361                 set_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks);
 362
 363         if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 364                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 365
 366         if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 367                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 368
 369         if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 370                 return 0;
 371
 372         if (hci_register_dev(hdev) < 0) {
 373                 BT_ERR("Can't register HCI device");
 374                 err = -ENODEV;
 375                 goto err_register;
 376         }
 377
 378         set_bit(HCI_UART_REGISTERED, &hu->flags);
 379
 380         return 0;
 381
 382 err_register:
 383         hci_free_dev(hdev);
 384 err_alloc:
 385         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 386         p->close(hu);
 387 err_open:
 388         serdev_device_close(hu->serdev);
 389 err_rwsem:
 390         percpu_free_rwsem(&hu->proto_lock);
 391         return err;
 392 }
 393 EXPORT_SYMBOL_GPL(hci_uart_register_device_priv);
 394
 395 void hci_uart_unregister_device(struct hci_uart *hu)
 396 {
 397         struct hci_dev *hdev = hu->hdev;
 398
 399         cancel_work_sync(&hu->init_ready);
 400         if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 401                 hci_unregister_dev(hdev);
 402         hci_free_dev(hdev);
 403
 404         cancel_work_sync(&hu->write_work);
 405
 406         hu->proto->close(hu);
 407
 408         if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 409                 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 410                 serdev_device_close(hu->serdev);
 411         }
 412         percpu_free_rwsem(&hu->proto_lock);
 413 }
 414 EXPORT_SYMBOL_GPL(hci_uart_unregister_device);