drivers/bluetooth/hci_ldisc.c

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