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 /** hci_uart_write_wakeup - transmit buffer wakeup
 235  * @serdev: serial device
 236  *
 237  * This function is called by the serdev framework when it accepts
 238  * more data being sent.
 239  */
 240 static void hci_uart_write_wakeup(struct serdev_device *serdev)
 241 {
 242         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 243
 244         BT_DBG("");
 245
 246         if (!hu || serdev != hu->serdev) {
 247                 WARN_ON(1);
 248                 return;
 249         }
 250
 251         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 252                 hci_uart_tx_wakeup(hu);
 253 }
 254
 255 /** hci_uart_receive_buf - receive buffer wakeup
 256  * @serdev: serial device
 257  * @data:   pointer to received data
 258  * @count:  count of received data in bytes
 259  *
 260  * This function is called by the serdev framework when it received data
 261  * in the RX buffer.
 262  *
 263  * Return: number of processed bytes
 264  */
 265 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data,
 266                                    size_t count)
 267 {
 268         struct hci_uart *hu = serdev_device_get_drvdata(serdev);
 269
 270         if (!hu || serdev != hu->serdev) {
 271                 WARN_ON(1);
 272                 return 0;
 273         }
 274
 275         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 276                 return 0;
 277
 278         /* It does not need a lock here as it is already protected by a mutex in
 279          * tty caller
 280          */
 281         hu->proto->recv(hu, data, count);
 282
 283         if (hu->hdev)
 284                 hu->hdev->stat.byte_rx += count;
 285
 286         return count;
 287 }
 288
 289 static const struct serdev_device_ops hci_serdev_client_ops = {
 290         .receive_buf = hci_uart_receive_buf,
 291         .write_wakeup = hci_uart_write_wakeup,
 292 };
 293
 294 int hci_uart_register_device(struct hci_uart *hu,
 295                              const struct hci_uart_proto *p)
 296 {
 297         int err;
 298         struct hci_dev *hdev;
 299
 300         BT_DBG("");
 301
 302         serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops);
 303
 304         err = serdev_device_open(hu->serdev);
 305         if (err)
 306                 return err;
 307
 308         err = p->open(hu);
 309         if (err)
 310                 goto err_open;
 311
 312         hu->proto = p;
 313         set_bit(HCI_UART_PROTO_READY, &hu->flags);
 314
 315         /* Initialize and register HCI device */
 316         hdev = hci_alloc_dev();
 317         if (!hdev) {
 318                 BT_ERR("Can't allocate HCI device");
 319                 err = -ENOMEM;
 320                 goto err_alloc;
 321         }
 322
 323         hu->hdev = hdev;
 324
 325         hdev->bus = HCI_UART;
 326         hci_set_drvdata(hdev, hu);
 327
 328         INIT_WORK(&hu->init_ready, hci_uart_init_work);
 329         INIT_WORK(&hu->write_work, hci_uart_write_work);
 330         percpu_init_rwsem(&hu->proto_lock);
 331
 332         /* Only when vendor specific setup callback is provided, consider
 333          * the manufacturer information valid. This avoids filling in the
 334          * value for Ericsson when nothing is specified.
 335          */
 336         if (hu->proto->setup)
 337                 hdev->manufacturer = hu->proto->manufacturer;
 338
 339         hdev->open  = hci_uart_open;
 340         hdev->close = hci_uart_close;
 341         hdev->flush = hci_uart_flush;
 342         hdev->send  = hci_uart_send_frame;
 343         hdev->setup = hci_uart_setup;
 344         SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
 345
 346         if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 347                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 348
 349         if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 350                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 351
 352         if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
 353                 hdev->dev_type = HCI_AMP;
 354         else
 355                 hdev->dev_type = HCI_PRIMARY;
 356
 357         if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 358                 return 0;
 359
 360         if (hci_register_dev(hdev) < 0) {
 361                 BT_ERR("Can't register HCI device");
 362                 err = -ENODEV;
 363                 goto err_register;
 364         }
 365
 366         set_bit(HCI_UART_REGISTERED, &hu->flags);
 367
 368         return 0;
 369
 370 err_register:
 371         hci_free_dev(hdev);
 372 err_alloc:
 373         clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 374         p->close(hu);
 375 err_open:
 376         serdev_device_close(hu->serdev);
 377         return err;
 378 }
 379 EXPORT_SYMBOL_GPL(hci_uart_register_device);
 380
 381 void hci_uart_unregister_device(struct hci_uart *hu)
 382 {
 383         struct hci_dev *hdev = hu->hdev;
 384
 385         cancel_work_sync(&hu->init_ready);
 386         if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 387                 hci_unregister_dev(hdev);
 388         hci_free_dev(hdev);
 389
 390         cancel_work_sync(&hu->write_work);
 391
 392         hu->proto->close(hu);
 393
 394         if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 395                 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 396                 serdev_device_close(hu->serdev);
 397         }
 398 }
 399 EXPORT_SYMBOL_GPL(hci_uart_unregister_device);