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         } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state));
  87
  88         clear_bit(HCI_UART_SENDING, &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         BT_DBG("%s %p", hdev->name, hdev);
 117
 118         /* Undo clearing this from hci_uart_close() */
 119         hdev->flush = hci_uart_flush;
 120
 121         return 0;
 122 }
 123
 124 /* Close device */
 125 static int hci_uart_close(struct hci_dev *hdev)
 126 {
 127         BT_DBG("hdev %p", hdev);
 128
 129         hci_uart_flush(hdev);
 130         hdev->flush = NULL;
 131
 132         return 0;
 133 }
 134
 135 /* Send frames from HCI layer */
 136 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 137 {
 138         struct hci_uart *hu = hci_get_drvdata(hdev);
 139
 140         BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
 141                skb->len);
 142
 143         hu->proto->enqueue(hu, skb);
 144
 145         hci_uart_tx_wakeup(hu);
 146
 147         return 0;
 148 }
 149
 150 static int hci_uart_setup(struct hci_dev *hdev)
 151 {
 152         struct hci_uart *hu = hci_get_drvdata(hdev);
 153         struct hci_rp_read_local_version *ver;
 154         struct sk_buff *skb;
 155         unsigned int speed;
 156         int err;
 157
 158         /* Init speed if any */
 159         if (hu->init_speed)
 160                 speed = hu->init_speed;
 161         else if (hu->proto->init_speed)
 162                 speed = hu->proto->init_speed;
 163         else
 164                 speed = 0;
 165
 166         if (speed)
 167                 serdev_device_set_baudrate(hu->serdev, speed);
 168
 169         /* Operational speed if any */
 170         if (hu->oper_speed)
 171                 speed = hu->oper_speed;
 172         else if (hu->proto->oper_speed)
 173                 speed = hu->proto->oper_speed;
 174         else
 175                 speed = 0;
 176
 177         if (hu->proto->set_baudrate && speed) {
 178                 err = hu->proto->set_baudrate(hu, speed);
 179                 if (err)
 180                         bt_dev_err(hdev, "Failed to set baudrate");
 181                 else
 182                         serdev_device_set_baudrate(hu->serdev, speed);
 183         }
 184
 185         if (hu->proto->setup)
 186                 return hu->proto->setup(hu);
 187
 188         if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
 189                 return 0;
 190
 191         skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
 192                              HCI_INIT_TIMEOUT);
 193         if (IS_ERR(skb)) {
 194                 bt_dev_err(hdev, "Reading local version info failed (%ld)",
 195                            PTR_ERR(skb));
 196                 return 0;
 197         }
 198
 199         if (skb->len != sizeof(*ver))
 200                 bt_dev_err(hdev, "Event length mismatch for version info");
 201
 202         kfree_skb(skb);
 203         return 0;
 204 }
 205
 206 /** hci_uart_write_wakeup - transmit buffer wakeup
 207  * @serdev: serial device
 208  *
 209  * This function is called by the serdev framework when it accepts
 210  * more data being sent.
 211  */
 212 static void hci_uart_write_wakeup(struct serdev_device *serdev)
 213 {
 214         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 215
 216         BT_DBG("");
 217
 218         if (!hu || serdev != hu->serdev) {
 219                 WARN_ON(1);
 220                 return;
 221         }
 222
 223         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 224                 hci_uart_tx_wakeup(hu);
 225 }
 226
 227 /** hci_uart_receive_buf - receive buffer wakeup
 228  * @serdev: serial device
 229  * @data:   pointer to received data
 230  * @count:  count of received data in bytes
 231  *
 232  * This function is called by the serdev framework when it received data
 233  * in the RX buffer.
 234  *
 235  * Return: number of processed bytes
 236  */
 237 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data,
 238                                    size_t count)
 239 {
 240         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 241
 242         if (!hu || serdev != hu->serdev) {
 243                 WARN_ON(1);
 244                 return 0;
 245         }
 246
 247         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 248                 return 0;
 249
 250         /* It does not need a lock here as it is already protected by a mutex in
 251          * tty caller
 252          */
 253         hu->proto->recv(hu, data, count);
 254
 255         if (hu->hdev)
 256                 hu->hdev->stat.byte_rx += count;
 257
 258         return count;
 259 }
 260
 261 static const struct serdev_device_ops hci_serdev_client_ops = {
 262         .receive_buf = hci_uart_receive_buf,
 263         .write_wakeup = hci_uart_write_wakeup,
 264 };
 265
 266 int hci_uart_register_device(struct hci_uart *hu,
 267                              const struct hci_uart_proto *p)
 268 {
 269         int err;
 270         struct hci_dev *hdev;
 271
 272         BT_DBG("");
 273
 274         serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops);
 275
 276         err = serdev_device_open(hu->serdev);
 277         if (err)
 278                 return err;
 279
 280         err = p->open(hu);
 281         if (err)
 282                 goto err_open;
 283
 284         hu->proto = p;
 285         set_bit(HCI_UART_PROTO_READY, &hu->flags);
 286
 287         /* Initialize and register HCI device */
 288         hdev = hci_alloc_dev();
 289         if (!hdev) {
 290                 BT_ERR("Can't allocate HCI device");
 291                 err = -ENOMEM;
 292                 goto err_alloc;
 293         }
 294
 295         hu->hdev = hdev;
 296
 297         hdev->bus = HCI_UART;
 298         hci_set_drvdata(hdev, hu);
 299
 300         INIT_WORK(&hu->init_ready, hci_uart_init_work);
 301         INIT_WORK(&hu->write_work, hci_uart_write_work);
 302         percpu_init_rwsem(&hu->proto_lock);
 303
 304         /* Only when vendor specific setup callback is provided, consider
 305          * the manufacturer information valid. This avoids filling in the
 306          * value for Ericsson when nothing is specified.
 307          */
 308         if (hu->proto->setup)
 309                 hdev->manufacturer = hu->proto->manufacturer;
 310
 311         hdev->open  = hci_uart_open;
 312         hdev->close = hci_uart_close;
 313         hdev->flush = hci_uart_flush;
 314         hdev->send  = hci_uart_send_frame;
 315         hdev->setup = hci_uart_setup;
 316         SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
 317
 318         if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 319                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 320
 321         if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 322                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 323
 324         if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
 325                 hdev->dev_type = HCI_AMP;
 326         else
 327                 hdev->dev_type = HCI_PRIMARY;
 328
 329         if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 330                 return 0;
 331
 332         if (hci_register_dev(hdev) < 0) {
 333                 BT_ERR("Can't register HCI device");
 334                 err = -ENODEV;
 335                 goto err_register;
 336         }
 337
 338         set_bit(HCI_UART_REGISTERED, &hu->flags);
 339
 340         return 0;
 341
 342 err_register:
 343         hci_free_dev(hdev);
 344 err_alloc:
 345         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 346         p->close(hu);
 347 err_open:
 348         serdev_device_close(hu->serdev);
 349         return err;
 350 }
 351 EXPORT_SYMBOL_GPL(hci_uart_register_device);
 352
 353 void hci_uart_unregister_device(struct hci_uart *hu)
 354 {
 355         struct hci_dev *hdev = hu->hdev;
 356
 357         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 358
 359         cancel_work_sync(&hu->init_ready);
 360         if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 361                 hci_unregister_dev(hdev);
 362         hci_free_dev(hdev);
 363
 364         cancel_work_sync(&hu->write_work);
 365
 366         hu->proto->close(hu);
 367         serdev_device_close(hu->serdev);
 368 }
 369 EXPORT_SYMBOL_GPL(hci_uart_unregister_device);