linux/drivers/bluetooth/hci_ldisc.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *
   4 *  Bluetooth HCI UART driver
   5 *
   6 *  Copyright (C) 2000-2001  Qualcomm Incorporated
   7 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
   8 *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
   9 */
  10
  11#include <linux/module.h>
  12
  13#include <linux/kernel.h>
  14#include <linux/init.h>
  15#include <linux/types.h>
  16#include <linux/fcntl.h>
  17#include <linux/interrupt.h>
  18#include <linux/ptrace.h>
  19#include <linux/poll.h>
  20
  21#include <linux/slab.h>
  22#include <linux/tty.h>
  23#include <linux/errno.h>
  24#include <linux/string.h>
  25#include <linux/signal.h>
  26#include <linux/ioctl.h>
  27#include <linux/skbuff.h>
  28#include <linux/firmware.h>
  29#include <linux/serdev.h>
  30
  31#include <net/bluetooth/bluetooth.h>
  32#include <net/bluetooth/hci_core.h>
  33
  34#include "btintel.h"
  35#include "btbcm.h"
  36#include "hci_uart.h"
  37
  38#define VERSION "2.3"
  39
  40static const struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
  41
  42int hci_uart_register_proto(const struct hci_uart_proto *p)
  43{
  44        if (p->id >= HCI_UART_MAX_PROTO)
  45                return -EINVAL;
  46
  47        if (hup[p->id])
  48                return -EEXIST;
  49
  50        hup[p->id] = p;
  51
  52        BT_INFO("HCI UART protocol %s registered", p->name);
  53
  54        return 0;
  55}
  56
  57int hci_uart_unregister_proto(const struct hci_uart_proto *p)
  58{
  59        if (p->id >= HCI_UART_MAX_PROTO)
  60                return -EINVAL;
  61
  62        if (!hup[p->id])
  63                return -EINVAL;
  64
  65        hup[p->id] = NULL;
  66
  67        return 0;
  68}
  69
  70static const struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
  71{
  72        if (id >= HCI_UART_MAX_PROTO)
  73                return NULL;
  74
  75        return hup[id];
  76}
  77
  78static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
  79{
  80        struct hci_dev *hdev = hu->hdev;
  81
  82        /* Update HCI stat counters */
  83        switch (pkt_type) {
  84        case HCI_COMMAND_PKT:
  85                hdev->stat.cmd_tx++;
  86                break;
  87
  88        case HCI_ACLDATA_PKT:
  89                hdev->stat.acl_tx++;
  90                break;
  91
  92        case HCI_SCODATA_PKT:
  93                hdev->stat.sco_tx++;
  94                break;
  95        }
  96}
  97
  98static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
  99{
 100        struct sk_buff *skb = hu->tx_skb;
 101
 102        if (!skb) {
 103                percpu_down_read(&hu->proto_lock);
 104
 105                if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 106                        skb = hu->proto->dequeue(hu);
 107
 108                percpu_up_read(&hu->proto_lock);
 109        } else {
 110                hu->tx_skb = NULL;
 111        }
 112
 113        return skb;
 114}
 115
 116int hci_uart_tx_wakeup(struct hci_uart *hu)
 117{
 118        /* This may be called in an IRQ context, so we can't sleep. Therefore
 119         * we try to acquire the lock only, and if that fails we assume the
 120         * tty is being closed because that is the only time the write lock is
 121         * acquired. If, however, at some point in the future the write lock
 122         * is also acquired in other situations, then this must be revisited.
 123         */
 124        if (!percpu_down_read_trylock(&hu->proto_lock))
 125                return 0;
 126
 127        if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
 128                goto no_schedule;
 129
 130        set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
 131        if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state))
 132                goto no_schedule;
 133
 134        BT_DBG("");
 135
 136        schedule_work(&hu->write_work);
 137
 138no_schedule:
 139        percpu_up_read(&hu->proto_lock);
 140
 141        return 0;
 142}
 143EXPORT_SYMBOL_GPL(hci_uart_tx_wakeup);
 144
 145static void hci_uart_write_work(struct work_struct *work)
 146{
 147        struct hci_uart *hu = container_of(work, struct hci_uart, write_work);
 148        struct tty_struct *tty = hu->tty;
 149        struct hci_dev *hdev = hu->hdev;
 150        struct sk_buff *skb;
 151
 152        /* REVISIT: should we cope with bad skbs or ->write() returning
 153         * and error value ?
 154         */
 155
 156restart:
 157        clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
 158
 159        while ((skb = hci_uart_dequeue(hu))) {
 160                int len;
 161
 162                set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 163                len = tty->ops->write(tty, skb->data, skb->len);
 164                hdev->stat.byte_tx += len;
 165
 166                skb_pull(skb, len);
 167                if (skb->len) {
 168                        hu->tx_skb = skb;
 169                        break;
 170                }
 171
 172                hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
 173                kfree_skb(skb);
 174        }
 175
 176        clear_bit(HCI_UART_SENDING, &hu->tx_state);
 177        if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
 178                goto restart;
 179
 180        wake_up_bit(&hu->tx_state, HCI_UART_SENDING);
 181}
 182
 183void hci_uart_init_work(struct work_struct *work)
 184{
 185        struct hci_uart *hu = container_of(work, struct hci_uart, init_ready);
 186        int err;
 187        struct hci_dev *hdev;
 188
 189        if (!test_and_clear_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 190                return;
 191
 192        err = hci_register_dev(hu->hdev);
 193        if (err < 0) {
 194                BT_ERR("Can't register HCI device");
 195                clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 196                hu->proto->close(hu);
 197                hdev = hu->hdev;
 198                hu->hdev = NULL;
 199                hci_free_dev(hdev);
 200                return;
 201        }
 202
 203        set_bit(HCI_UART_REGISTERED, &hu->flags);
 204}
 205
 206int hci_uart_init_ready(struct hci_uart *hu)
 207{
 208        if (!test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 209                return -EALREADY;
 210
 211        schedule_work(&hu->init_ready);
 212
 213        return 0;
 214}
 215
 216int hci_uart_wait_until_sent(struct hci_uart *hu)
 217{
 218        return wait_on_bit_timeout(&hu->tx_state, HCI_UART_SENDING,
 219                                   TASK_INTERRUPTIBLE,
 220                                   msecs_to_jiffies(2000));
 221}
 222
 223/* ------- Interface to HCI layer ------ */
 224/* Reset device */
 225static int hci_uart_flush(struct hci_dev *hdev)
 226{
 227        struct hci_uart *hu  = hci_get_drvdata(hdev);
 228        struct tty_struct *tty = hu->tty;
 229
 230        BT_DBG("hdev %p tty %p", hdev, tty);
 231
 232        if (hu->tx_skb) {
 233                kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
 234        }
 235
 236        /* Flush any pending characters in the driver and discipline. */
 237        tty_ldisc_flush(tty);
 238        tty_driver_flush_buffer(tty);
 239
 240        percpu_down_read(&hu->proto_lock);
 241
 242        if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 243                hu->proto->flush(hu);
 244
 245        percpu_up_read(&hu->proto_lock);
 246
 247        return 0;
 248}
 249
 250/* Initialize device */
 251static int hci_uart_open(struct hci_dev *hdev)
 252{
 253        BT_DBG("%s %p", hdev->name, hdev);
 254
 255        /* Undo clearing this from hci_uart_close() */
 256        hdev->flush = hci_uart_flush;
 257
 258        return 0;
 259}
 260
 261/* Close device */
 262static int hci_uart_close(struct hci_dev *hdev)
 263{
 264        BT_DBG("hdev %p", hdev);
 265
 266        hci_uart_flush(hdev);
 267        hdev->flush = NULL;
 268        return 0;
 269}
 270
 271/* Send frames from HCI layer */
 272static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 273{
 274        struct hci_uart *hu = hci_get_drvdata(hdev);
 275
 276        BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
 277               skb->len);
 278
 279        percpu_down_read(&hu->proto_lock);
 280
 281        if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 282                percpu_up_read(&hu->proto_lock);
 283                return -EUNATCH;
 284        }
 285
 286        hu->proto->enqueue(hu, skb);
 287        percpu_up_read(&hu->proto_lock);
 288
 289        hci_uart_tx_wakeup(hu);
 290
 291        return 0;
 292}
 293
 294/* Check the underlying device or tty has flow control support */
 295bool hci_uart_has_flow_control(struct hci_uart *hu)
 296{
 297        /* serdev nodes check if the needed operations are present */
 298        if (hu->serdev)
 299                return true;
 300
 301        if (hu->tty->driver->ops->tiocmget && hu->tty->driver->ops->tiocmset)
 302                return true;
 303
 304        return false;
 305}
 306
 307/* Flow control or un-flow control the device */
 308void hci_uart_set_flow_control(struct hci_uart *hu, bool enable)
 309{
 310        struct tty_struct *tty = hu->tty;
 311        struct ktermios ktermios;
 312        int status;
 313        unsigned int set = 0;
 314        unsigned int clear = 0;
 315
 316        if (hu->serdev) {
 317                serdev_device_set_flow_control(hu->serdev, !enable);
 318                serdev_device_set_rts(hu->serdev, !enable);
 319                return;
 320        }
 321
 322        if (enable) {
 323                /* Disable hardware flow control */
 324                ktermios = tty->termios;
 325                ktermios.c_cflag &= ~CRTSCTS;
 326                status = tty_set_termios(tty, &ktermios);
 327                BT_DBG("Disabling hardware flow control: %s",
 328                       status ? "failed" : "success");
 329
 330                /* Clear RTS to prevent the device from sending */
 331                /* Most UARTs need OUT2 to enable interrupts */
 332                status = tty->driver->ops->tiocmget(tty);
 333                BT_DBG("Current tiocm 0x%x", status);
 334
 335                set &= ~(TIOCM_OUT2 | TIOCM_RTS);
 336                clear = ~set;
 337                set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
 338                       TIOCM_OUT2 | TIOCM_LOOP;
 339                clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
 340                         TIOCM_OUT2 | TIOCM_LOOP;
 341                status = tty->driver->ops->tiocmset(tty, set, clear);
 342                BT_DBG("Clearing RTS: %s", status ? "failed" : "success");
 343        } else {
 344                /* Set RTS to allow the device to send again */
 345                status = tty->driver->ops->tiocmget(tty);
 346                BT_DBG("Current tiocm 0x%x", status);
 347
 348                set |= (TIOCM_OUT2 | TIOCM_RTS);
 349                clear = ~set;
 350                set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
 351                       TIOCM_OUT2 | TIOCM_LOOP;
 352                clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
 353                         TIOCM_OUT2 | TIOCM_LOOP;
 354                status = tty->driver->ops->tiocmset(tty, set, clear);
 355                BT_DBG("Setting RTS: %s", status ? "failed" : "success");
 356
 357                /* Re-enable hardware flow control */
 358                ktermios = tty->termios;
 359                ktermios.c_cflag |= CRTSCTS;
 360                status = tty_set_termios(tty, &ktermios);
 361                BT_DBG("Enabling hardware flow control: %s",
 362                       status ? "failed" : "success");
 363        }
 364}
 365
 366void hci_uart_set_speeds(struct hci_uart *hu, unsigned int init_speed,
 367                         unsigned int oper_speed)
 368{
 369        hu->init_speed = init_speed;
 370        hu->oper_speed = oper_speed;
 371}
 372
 373void hci_uart_set_baudrate(struct hci_uart *hu, unsigned int speed)
 374{
 375        struct tty_struct *tty = hu->tty;
 376        struct ktermios ktermios;
 377
 378        ktermios = tty->termios;
 379        ktermios.c_cflag &= ~CBAUD;
 380        tty_termios_encode_baud_rate(&ktermios, speed, speed);
 381
 382        /* tty_set_termios() return not checked as it is always 0 */
 383        tty_set_termios(tty, &ktermios);
 384
 385        BT_DBG("%s: New tty speeds: %d/%d", hu->hdev->name,
 386               tty->termios.c_ispeed, tty->termios.c_ospeed);
 387}
 388
 389static int hci_uart_setup(struct hci_dev *hdev)
 390{
 391        struct hci_uart *hu = hci_get_drvdata(hdev);
 392        struct hci_rp_read_local_version *ver;
 393        struct sk_buff *skb;
 394        unsigned int speed;
 395        int err;
 396
 397        /* Init speed if any */
 398        if (hu->init_speed)
 399                speed = hu->init_speed;
 400        else if (hu->proto->init_speed)
 401                speed = hu->proto->init_speed;
 402        else
 403                speed = 0;
 404
 405        if (speed)
 406                hci_uart_set_baudrate(hu, speed);
 407
 408        /* Operational speed if any */
 409        if (hu->oper_speed)
 410                speed = hu->oper_speed;
 411        else if (hu->proto->oper_speed)
 412                speed = hu->proto->oper_speed;
 413        else
 414                speed = 0;
 415
 416        if (hu->proto->set_baudrate && speed) {
 417                err = hu->proto->set_baudrate(hu, speed);
 418                if (!err)
 419                        hci_uart_set_baudrate(hu, speed);
 420        }
 421
 422        if (hu->proto->setup)
 423                return hu->proto->setup(hu);
 424
 425        if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
 426                return 0;
 427
 428        skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
 429                             HCI_INIT_TIMEOUT);
 430        if (IS_ERR(skb)) {
 431                BT_ERR("%s: Reading local version information failed (%ld)",
 432                       hdev->name, PTR_ERR(skb));
 433                return 0;
 434        }
 435
 436        if (skb->len != sizeof(*ver)) {
 437                BT_ERR("%s: Event length mismatch for version information",
 438                       hdev->name);
 439                goto done;
 440        }
 441
 442        ver = (struct hci_rp_read_local_version *)skb->data;
 443
 444        switch (le16_to_cpu(ver->manufacturer)) {
 445#ifdef CONFIG_BT_HCIUART_INTEL
 446        case 2:
 447                hdev->set_bdaddr = btintel_set_bdaddr;
 448                btintel_check_bdaddr(hdev);
 449                break;
 450#endif
 451#ifdef CONFIG_BT_HCIUART_BCM
 452        case 15:
 453                hdev->set_bdaddr = btbcm_set_bdaddr;
 454                btbcm_check_bdaddr(hdev);
 455                break;
 456#endif
 457        default:
 458                break;
 459        }
 460
 461done:
 462        kfree_skb(skb);
 463        return 0;
 464}
 465
 466/* ------ LDISC part ------ */
 467/* hci_uart_tty_open
 468 *
 469 *     Called when line discipline changed to HCI_UART.
 470 *
 471 * Arguments:
 472 *     tty    pointer to tty info structure
 473 * Return Value:
 474 *     0 if success, otherwise error code
 475 */
 476static int hci_uart_tty_open(struct tty_struct *tty)
 477{
 478        struct hci_uart *hu;
 479
 480        BT_DBG("tty %p", tty);
 481
 482        /* Error if the tty has no write op instead of leaving an exploitable
 483         * hole
 484         */
 485        if (tty->ops->write == NULL)
 486                return -EOPNOTSUPP;
 487
 488        hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL);
 489        if (!hu) {
 490                BT_ERR("Can't allocate control structure");
 491                return -ENFILE;
 492        }
 493
 494        tty->disc_data = hu;
 495        hu->tty = tty;
 496        tty->receive_room = 65536;
 497
 498        /* disable alignment support by default */
 499        hu->alignment = 1;
 500        hu->padding = 0;
 501
 502        INIT_WORK(&hu->init_ready, hci_uart_init_work);
 503        INIT_WORK(&hu->write_work, hci_uart_write_work);
 504
 505        percpu_init_rwsem(&hu->proto_lock);
 506
 507        /* Flush any pending characters in the driver */
 508        tty_driver_flush_buffer(tty);
 509
 510        return 0;
 511}
 512
 513/* hci_uart_tty_close()
 514 *
 515 *    Called when the line discipline is changed to something
 516 *    else, the tty is closed, or the tty detects a hangup.
 517 */
 518static void hci_uart_tty_close(struct tty_struct *tty)
 519{
 520        struct hci_uart *hu = tty->disc_data;
 521        struct hci_dev *hdev;
 522
 523        BT_DBG("tty %p", tty);
 524
 525        /* Detach from the tty */
 526        tty->disc_data = NULL;
 527
 528        if (!hu)
 529                return;
 530
 531        hdev = hu->hdev;
 532        if (hdev)
 533                hci_uart_close(hdev);
 534
 535        if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 536                percpu_down_write(&hu->proto_lock);
 537                clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 538                percpu_up_write(&hu->proto_lock);
 539
 540                cancel_work_sync(&hu->init_ready);
 541                cancel_work_sync(&hu->write_work);
 542
 543                if (hdev) {
 544                        if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 545                                hci_unregister_dev(hdev);
 546                        hci_free_dev(hdev);
 547                }
 548                hu->proto->close(hu);
 549        }
 550        clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 551
 552        percpu_free_rwsem(&hu->proto_lock);
 553
 554        kfree(hu);
 555}
 556
 557/* hci_uart_tty_wakeup()
 558 *
 559 *    Callback for transmit wakeup. Called when low level
 560 *    device driver can accept more send data.
 561 *
 562 * Arguments:        tty    pointer to associated tty instance data
 563 * Return Value:    None
 564 */
 565static void hci_uart_tty_wakeup(struct tty_struct *tty)
 566{
 567        struct hci_uart *hu = tty->disc_data;
 568
 569        BT_DBG("");
 570
 571        if (!hu)
 572                return;
 573
 574        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 575
 576        if (tty != hu->tty)
 577                return;
 578
 579        if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 580                hci_uart_tx_wakeup(hu);
 581}
 582
 583/* hci_uart_tty_receive()
 584 *
 585 *     Called by tty low level driver when receive data is
 586 *     available.
 587 *
 588 * Arguments:  tty          pointer to tty isntance data
 589 *             data         pointer to received data
 590 *             flags        pointer to flags for data
 591 *             count        count of received data in bytes
 592 *
 593 * Return Value:    None
 594 */
 595static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
 596                                 const char *flags, int count)
 597{
 598        struct hci_uart *hu = tty->disc_data;
 599
 600        if (!hu || tty != hu->tty)
 601                return;
 602
 603        percpu_down_read(&hu->proto_lock);
 604
 605        if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 606                percpu_up_read(&hu->proto_lock);
 607                return;
 608        }
 609
 610        /* It does not need a lock here as it is already protected by a mutex in
 611         * tty caller
 612         */
 613        hu->proto->recv(hu, data, count);
 614        percpu_up_read(&hu->proto_lock);
 615
 616        if (hu->hdev)
 617                hu->hdev->stat.byte_rx += count;
 618
 619        tty_unthrottle(tty);
 620}
 621
 622static int hci_uart_register_dev(struct hci_uart *hu)
 623{
 624        struct hci_dev *hdev;
 625        int err;
 626
 627        BT_DBG("");
 628
 629        /* Initialize and register HCI device */
 630        hdev = hci_alloc_dev();
 631        if (!hdev) {
 632                BT_ERR("Can't allocate HCI device");
 633                return -ENOMEM;
 634        }
 635
 636        hu->hdev = hdev;
 637
 638        hdev->bus = HCI_UART;
 639        hci_set_drvdata(hdev, hu);
 640
 641        /* Only when vendor specific setup callback is provided, consider
 642         * the manufacturer information valid. This avoids filling in the
 643         * value for Ericsson when nothing is specified.
 644         */
 645        if (hu->proto->setup)
 646                hdev->manufacturer = hu->proto->manufacturer;
 647
 648        hdev->open  = hci_uart_open;
 649        hdev->close = hci_uart_close;
 650        hdev->flush = hci_uart_flush;
 651        hdev->send  = hci_uart_send_frame;
 652        hdev->setup = hci_uart_setup;
 653        SET_HCIDEV_DEV(hdev, hu->tty->dev);
 654
 655        if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 656                set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 657
 658        if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 659                set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 660
 661        if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags))
 662                set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 663
 664        if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
 665                hdev->dev_type = HCI_AMP;
 666        else
 667                hdev->dev_type = HCI_PRIMARY;
 668
 669        /* Only call open() for the protocol after hdev is fully initialized as
 670         * open() (or a timer/workqueue it starts) may attempt to reference it.
 671         */
 672        err = hu->proto->open(hu);
 673        if (err) {
 674                hu->hdev = NULL;
 675                hci_free_dev(hdev);
 676                return err;
 677        }
 678
 679        if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 680                return 0;
 681
 682        if (hci_register_dev(hdev) < 0) {
 683                BT_ERR("Can't register HCI device");
 684                hu->proto->close(hu);
 685                hu->hdev = NULL;
 686                hci_free_dev(hdev);
 687                return -ENODEV;
 688        }
 689
 690        set_bit(HCI_UART_REGISTERED, &hu->flags);
 691
 692        return 0;
 693}
 694
 695static int hci_uart_set_proto(struct hci_uart *hu, int id)
 696{
 697        const struct hci_uart_proto *p;
 698        int err;
 699
 700        p = hci_uart_get_proto(id);
 701        if (!p)
 702                return -EPROTONOSUPPORT;
 703
 704        hu->proto = p;
 705
 706        err = hci_uart_register_dev(hu);
 707        if (err) {
 708                return err;
 709        }
 710
 711        set_bit(HCI_UART_PROTO_READY, &hu->flags);
 712        return 0;
 713}
 714
 715static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags)
 716{
 717        unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) |
 718                                    BIT(HCI_UART_RESET_ON_INIT) |
 719                                    BIT(HCI_UART_CREATE_AMP) |
 720                                    BIT(HCI_UART_INIT_PENDING) |
 721                                    BIT(HCI_UART_EXT_CONFIG) |
 722                                    BIT(HCI_UART_VND_DETECT);
 723
 724        if (flags & ~valid_flags)
 725                return -EINVAL;
 726
 727        hu->hdev_flags = flags;
 728
 729        return 0;
 730}
 731
 732/* hci_uart_tty_ioctl()
 733 *
 734 *    Process IOCTL system call for the tty device.
 735 *
 736 * Arguments:
 737 *
 738 *    tty        pointer to tty instance data
 739 *    file       pointer to open file object for device
 740 *    cmd        IOCTL command code
 741 *    arg        argument for IOCTL call (cmd dependent)
 742 *
 743 * Return Value:    Command dependent
 744 */
 745static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
 746                              unsigned int cmd, unsigned long arg)
 747{
 748        struct hci_uart *hu = tty->disc_data;
 749        int err = 0;
 750
 751        BT_DBG("");
 752
 753        /* Verify the status of the device */
 754        if (!hu)
 755                return -EBADF;
 756
 757        switch (cmd) {
 758        case HCIUARTSETPROTO:
 759                if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 760                        err = hci_uart_set_proto(hu, arg);
 761                        if (err)
 762                                clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 763                } else
 764                        err = -EBUSY;
 765                break;
 766
 767        case HCIUARTGETPROTO:
 768                if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 769                        err = hu->proto->id;
 770                else
 771                        err = -EUNATCH;
 772                break;
 773
 774        case HCIUARTGETDEVICE:
 775                if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 776                        err = hu->hdev->id;
 777                else
 778                        err = -EUNATCH;
 779                break;
 780
 781        case HCIUARTSETFLAGS:
 782                if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 783                        err = -EBUSY;
 784                else
 785                        err = hci_uart_set_flags(hu, arg);
 786                break;
 787
 788        case HCIUARTGETFLAGS:
 789                err = hu->hdev_flags;
 790                break;
 791
 792        default:
 793                err = n_tty_ioctl_helper(tty, file, cmd, arg);
 794                break;
 795        }
 796
 797        return err;
 798}
 799
 800/*
 801 * We don't provide read/write/poll interface for user space.
 802 */
 803static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file,
 804                                 unsigned char *buf, size_t nr,
 805                                 void **cookie, unsigned long offset)
 806{
 807        return 0;
 808}
 809
 810static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file,
 811                                  const unsigned char *data, size_t count)
 812{
 813        return 0;
 814}
 815
 816static __poll_t hci_uart_tty_poll(struct tty_struct *tty,
 817                                      struct file *filp, poll_table *wait)
 818{
 819        return 0;
 820}
 821
 822static struct tty_ldisc_ops hci_uart_ldisc = {
 823        .owner          = THIS_MODULE,
 824        .num            = N_HCI,
 825        .name           = "n_hci",
 826        .open           = hci_uart_tty_open,
 827        .close          = hci_uart_tty_close,
 828        .read           = hci_uart_tty_read,
 829        .write          = hci_uart_tty_write,
 830        .ioctl          = hci_uart_tty_ioctl,
 831        .compat_ioctl   = hci_uart_tty_ioctl,
 832        .poll           = hci_uart_tty_poll,
 833        .receive_buf    = hci_uart_tty_receive,
 834        .write_wakeup   = hci_uart_tty_wakeup,
 835};
 836
 837static int __init hci_uart_init(void)
 838{
 839        int err;
 840
 841        BT_INFO("HCI UART driver ver %s", VERSION);
 842
 843        /* Register the tty discipline */
 844        err = tty_register_ldisc(&hci_uart_ldisc);
 845        if (err) {
 846                BT_ERR("HCI line discipline registration failed. (%d)", err);
 847                return err;
 848        }
 849
 850#ifdef CONFIG_BT_HCIUART_H4
 851        h4_init();
 852#endif
 853#ifdef CONFIG_BT_HCIUART_BCSP
 854        bcsp_init();
 855#endif
 856#ifdef CONFIG_BT_HCIUART_LL
 857        ll_init();
 858#endif
 859#ifdef CONFIG_BT_HCIUART_ATH3K
 860        ath_init();
 861#endif
 862#ifdef CONFIG_BT_HCIUART_3WIRE
 863        h5_init();
 864#endif
 865#ifdef CONFIG_BT_HCIUART_INTEL
 866        intel_init();
 867#endif
 868#ifdef CONFIG_BT_HCIUART_BCM
 869        bcm_init();
 870#endif
 871#ifdef CONFIG_BT_HCIUART_QCA
 872        qca_init();
 873#endif
 874#ifdef CONFIG_BT_HCIUART_AG6XX
 875        ag6xx_init();
 876#endif
 877#ifdef CONFIG_BT_HCIUART_MRVL
 878        mrvl_init();
 879#endif
 880
 881        return 0;
 882}
 883
 884static void __exit hci_uart_exit(void)
 885{
 886#ifdef CONFIG_BT_HCIUART_H4
 887        h4_deinit();
 888#endif
 889#ifdef CONFIG_BT_HCIUART_BCSP
 890        bcsp_deinit();
 891#endif
 892#ifdef CONFIG_BT_HCIUART_LL
 893        ll_deinit();
 894#endif
 895#ifdef CONFIG_BT_HCIUART_ATH3K
 896        ath_deinit();
 897#endif
 898#ifdef CONFIG_BT_HCIUART_3WIRE
 899        h5_deinit();
 900#endif
 901#ifdef CONFIG_BT_HCIUART_INTEL
 902        intel_deinit();
 903#endif
 904#ifdef CONFIG_BT_HCIUART_BCM
 905        bcm_deinit();
 906#endif
 907#ifdef CONFIG_BT_HCIUART_QCA
 908        qca_deinit();
 909#endif
 910#ifdef CONFIG_BT_HCIUART_AG6XX
 911        ag6xx_deinit();
 912#endif
 913#ifdef CONFIG_BT_HCIUART_MRVL
 914        mrvl_deinit();
 915#endif
 916
 917        tty_unregister_ldisc(&hci_uart_ldisc);
 918}
 919
 920module_init(hci_uart_init);
 921module_exit(hci_uart_exit);
 922
 923MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 924MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
 925MODULE_VERSION(VERSION);
 926MODULE_LICENSE("GPL");
 927MODULE_ALIAS_LDISC(N_HCI);
 928