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 struct serdev_device_ops hci_serdev_client_ops;
  25
  26 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
  27 {
  28         struct hci_dev *hdev = hu->hdev;
  29
  30         /* Update HCI stat counters */
  31         switch (pkt_type) {
  32         case HCI_COMMAND_PKT:
  33                 hdev->stat.cmd_tx++;
  34                 break;
  35
  36         case HCI_ACLDATA_PKT:
  37                 hdev->stat.acl_tx++;
  38                 break;
  39
  40         case HCI_SCODATA_PKT:
  41                 hdev->stat.sco_tx++;
  42                 break;
  43         }
  44 }
  45
  46 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
  47 {
  48         struct sk_buff *skb = hu->tx_skb;
  49
  50         if (!skb) {
  51                 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
  52                         skb = hu->proto->dequeue(hu);
  53         } else
  54                 hu->tx_skb = NULL;
  55
  56         return skb;
  57 }
  58
  59 static void hci_uart_write_work(struct work_struct *work)
  60 {
  61         struct hci_uart *hu = container_of(work, struct hci_uart, write_work);
  62         struct serdev_device *serdev = hu->serdev;
  63         struct hci_dev *hdev = hu->hdev;
  64         struct sk_buff *skb;
  65
  66         /* REVISIT:
  67          * should we cope with bad skbs or ->write() returning an error value?
  68          */
  69         do {
  70                 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
  71
  72                 while ((skb = hci_uart_dequeue(hu))) {
  73                         int len;
  74
  75                         len = serdev_device_write_buf(serdev,
  76                                                       skb->data, skb->len);
  77                         hdev->stat.byte_tx += len;
  78
  79                         skb_pull(skb, len);
  80                         if (skb->len) {
  81                                 hu->tx_skb = skb;
  82                                 break;
  83                         }
  84
  85                         hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
  86                         kfree_skb(skb);
  87                 }
  88         } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state));
  89
  90         clear_bit(HCI_UART_SENDING, &hu->tx_state);
  91 }
  92
  93 /* ------- Interface to HCI layer ------ */
  94
  95 /* Reset device */
  96 static int hci_uart_flush(struct hci_dev *hdev)
  97 {
  98         struct hci_uart *hu  = hci_get_drvdata(hdev);
  99
 100         BT_DBG("hdev %p serdev %p", hdev, hu->serdev);
 101
 102         if (hu->tx_skb) {
 103                 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
 104         }
 105
 106         /* Flush any pending characters in the driver and discipline. */
 107         serdev_device_write_flush(hu->serdev);
 108
 109         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 110                 hu->proto->flush(hu);
 111
 112         return 0;
 113 }
 114
 115 /* Initialize device */
 116 static int hci_uart_open(struct hci_dev *hdev)
 117 {
 118         BT_DBG("%s %p", hdev->name, hdev);
 119
 120         /* Undo clearing this from hci_uart_close() */
 121         hdev->flush = hci_uart_flush;
 122
 123         return 0;
 124 }
 125
 126 /* Close device */
 127 static int hci_uart_close(struct hci_dev *hdev)
 128 {
 129         BT_DBG("hdev %p", hdev);
 130
 131         hci_uart_flush(hdev);
 132         hdev->flush = NULL;
 133
 134         return 0;
 135 }
 136
 137 /* Send frames from HCI layer */
 138 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 139 {
 140         struct hci_uart *hu = hci_get_drvdata(hdev);
 141
 142         BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
 143                skb->len);
 144
 145         hu->proto->enqueue(hu, skb);
 146
 147         hci_uart_tx_wakeup(hu);
 148
 149         return 0;
 150 }
 151
 152 static int hci_uart_setup(struct hci_dev *hdev)
 153 {
 154         struct hci_uart *hu = hci_get_drvdata(hdev);
 155         struct hci_rp_read_local_version *ver;
 156         struct sk_buff *skb;
 157         unsigned int speed;
 158         int err;
 159
 160         /* Init speed if any */
 161         if (hu->init_speed)
 162                 speed = hu->init_speed;
 163         else if (hu->proto->init_speed)
 164                 speed = hu->proto->init_speed;
 165         else
 166                 speed = 0;
 167
 168         if (speed)
 169                 serdev_device_set_baudrate(hu->serdev, speed);
 170
 171         /* Operational speed if any */
 172         if (hu->oper_speed)
 173                 speed = hu->oper_speed;
 174         else if (hu->proto->oper_speed)
 175                 speed = hu->proto->oper_speed;
 176         else
 177                 speed = 0;
 178
 179         if (hu->proto->set_baudrate && speed) {
 180                 err = hu->proto->set_baudrate(hu, speed);
 181                 if (err)
 182                         bt_dev_err(hdev, "Failed to set baudrate");
 183                 else
 184                         serdev_device_set_baudrate(hu->serdev, speed);
 185         }
 186
 187         if (hu->proto->setup)
 188                 return hu->proto->setup(hu);
 189
 190         if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
 191                 return 0;
 192
 193         skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
 194                              HCI_INIT_TIMEOUT);
 195         if (IS_ERR(skb)) {
 196                 bt_dev_err(hdev, "Reading local version info failed (%ld)",
 197                            PTR_ERR(skb));
 198                 return 0;
 199         }
 200
 201         if (skb->len != sizeof(*ver))
 202                 bt_dev_err(hdev, "Event length mismatch for version info");
 203
 204         kfree_skb(skb);
 205         return 0;
 206 }
 207
 208 /** hci_uart_write_wakeup - transmit buffer wakeup
 209  * @serdev: serial device
 210  *
 211  * This function is called by the serdev framework when it accepts
 212  * more data being sent.
 213  */
 214 static void hci_uart_write_wakeup(struct serdev_device *serdev)
 215 {
 216         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 217
 218         BT_DBG("");
 219
 220         if (!hu || serdev != hu->serdev) {
 221                 WARN_ON(1);
 222                 return;
 223         }
 224
 225         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 226                 hci_uart_tx_wakeup(hu);
 227 }
 228
 229 /** hci_uart_receive_buf - receive buffer wakeup
 230  * @serdev: serial device
 231  * @data:   pointer to received data
 232  * @count:  count of received data in bytes
 233  *
 234  * This function is called by the serdev framework when it received data
 235  * in the RX buffer.
 236  *
 237  * Return: number of processed bytes
 238  */
 239 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data,
 240                                    size_t count)
 241 {
 242         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 243
 244         if (!hu || serdev != hu->serdev) {
 245                 WARN_ON(1);
 246                 return 0;
 247         }
 248
 249         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 250                 return 0;
 251
 252         /* It does not need a lock here as it is already protected by a mutex in
 253          * tty caller
 254          */
 255         hu->proto->recv(hu, data, count);
 256
 257         if (hu->hdev)
 258                 hu->hdev->stat.byte_rx += count;
 259
 260         return count;
 261 }
 262
 263 static struct serdev_device_ops hci_serdev_client_ops = {
 264         .receive_buf = hci_uart_receive_buf,
 265         .write_wakeup = hci_uart_write_wakeup,
 266 };
 267
 268 int hci_uart_register_device(struct hci_uart *hu,
 269                              const struct hci_uart_proto *p)
 270 {
 271         int err;
 272         struct hci_dev *hdev;
 273
 274         BT_DBG("");
 275
 276         serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops);
 277
 278         err = serdev_device_open(hu->serdev);
 279         if (err)
 280                 return err;
 281
 282         err = p->open(hu);
 283         if (err)
 284                 goto err_open;
 285
 286         hu->proto = p;
 287         set_bit(HCI_UART_PROTO_READY, &hu->flags);
 288
 289         /* Initialize and register HCI device */
 290         hdev = hci_alloc_dev();
 291         if (!hdev) {
 292                 BT_ERR("Can't allocate HCI device");
 293                 err = -ENOMEM;
 294                 goto err_alloc;
 295         }
 296
 297         hu->hdev = hdev;
 298
 299         hdev->bus = HCI_UART;
 300         hci_set_drvdata(hdev, hu);
 301
 302         INIT_WORK(&hu->init_ready, hci_uart_init_work);
 303         INIT_WORK(&hu->write_work, hci_uart_write_work);
 304         percpu_init_rwsem(&hu->proto_lock);
 305
 306         /* Only when vendor specific setup callback is provided, consider
 307          * the manufacturer information valid. This avoids filling in the
 308          * value for Ericsson when nothing is specified.
 309          */
 310         if (hu->proto->setup)
 311                 hdev->manufacturer = hu->proto->manufacturer;
 312
 313         hdev->open  = hci_uart_open;
 314         hdev->close = hci_uart_close;
 315         hdev->flush = hci_uart_flush;
 316         hdev->send  = hci_uart_send_frame;
 317         hdev->setup = hci_uart_setup;
 318         SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
 319
 320         if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 321                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 322
 323         if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 324                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 325
 326         if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
 327                 hdev->dev_type = HCI_AMP;
 328         else
 329                 hdev->dev_type = HCI_PRIMARY;
 330
 331         if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 332                 return 0;
 333
 334         if (hci_register_dev(hdev) < 0) {
 335                 BT_ERR("Can't register HCI device");
 336                 err = -ENODEV;
 337                 goto err_register;
 338         }
 339
 340         set_bit(HCI_UART_REGISTERED, &hu->flags);
 341
 342         return 0;
 343
 344 err_register:
 345         hci_free_dev(hdev);
 346 err_alloc:
 347         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 348         p->close(hu);
 349 err_open:
 350         serdev_device_close(hu->serdev);
 351         return err;
 352 }
 353 EXPORT_SYMBOL_GPL(hci_uart_register_device);
 354
 355 void hci_uart_unregister_device(struct hci_uart *hu)
 356 {
 357         struct hci_dev *hdev = hu->hdev;
 358
 359         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 360         hci_unregister_dev(hdev);
 361         hci_free_dev(hdev);
 362
 363         cancel_work_sync(&hu->write_work);
 364
 365         hu->proto->close(hu);
 366         serdev_device_close(hu->serdev);
 367 }
 368 EXPORT_SYMBOL_GPL(hci_uart_unregister_device);