drivers/bluetooth/hci_ldisc.c

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