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          */
 462         if (tty->ops->write == NULL)
 463                 return -EOPNOTSUPP;
 464
 465         hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL);
 466         if (!hu) {
 467                 BT_ERR("Can't allocate control structure");
 468                 return -ENFILE;
 469         }
 470
 471         tty->disc_data = hu;
 472         hu->tty = tty;
 473         tty->receive_room = 65536;
 474
 475         /* disable alignment support by default */
 476         hu->alignment = 1;
 477         hu->padding = 0;
 478
 479         INIT_WORK(&hu->init_ready, hci_uart_init_work);
 480         INIT_WORK(&hu->write_work, hci_uart_write_work);
 481
 482         rwlock_init(&hu->proto_lock);
 483
 484         /* Flush any pending characters in the driver */
 485         tty_driver_flush_buffer(tty);
 486
 487         return 0;
 488 }
 489
 490 /* hci_uart_tty_close()
 491  *
 492  *    Called when the line discipline is changed to something
 493  *    else, the tty is closed, or the tty detects a hangup.
 494  */
 495 static void hci_uart_tty_close(struct tty_struct *tty)
 496 {
 497         struct hci_uart *hu = tty->disc_data;
 498         struct hci_dev *hdev;
 499         unsigned long flags;
 500
 501         BT_DBG("tty %p", tty);
 502
 503         /* Detach from the tty */
 504         tty->disc_data = NULL;
 505
 506         if (!hu)
 507                 return;
 508
 509         hdev = hu->hdev;
 510         if (hdev)
 511                 hci_uart_close(hdev);
 512
 513         cancel_work_sync(&hu->write_work);
 514
 515         if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 516                 write_lock_irqsave(&hu->proto_lock, flags);
 517                 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 518                 write_unlock_irqrestore(&hu->proto_lock, flags);
 519
 520                 if (hdev) {
 521                         if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 522                                 hci_unregister_dev(hdev);
 523                         hci_free_dev(hdev);
 524                 }
 525                 hu->proto->close(hu);
 526         }
 527         clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 528
 529         kfree(hu);
 530 }
 531
 532 /* hci_uart_tty_wakeup()
 533  *
 534  *    Callback for transmit wakeup. Called when low level
 535  *    device driver can accept more send data.
 536  *
 537  * Arguments:        tty    pointer to associated tty instance data
 538  * Return Value:    None
 539  */
 540 static void hci_uart_tty_wakeup(struct tty_struct *tty)
 541 {
 542         struct hci_uart *hu = tty->disc_data;
 543
 544         BT_DBG("");
 545
 546         if (!hu)
 547                 return;
 548
 549         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 550
 551         if (tty != hu->tty)
 552                 return;
 553
 554         if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
 555                 hci_uart_tx_wakeup(hu);
 556 }
 557
 558 /* hci_uart_tty_receive()
 559  *
 560  *     Called by tty low level driver when receive data is
 561  *     available.
 562  *
 563  * Arguments:  tty          pointer to tty isntance data
 564  *             data         pointer to received data
 565  *             flags        pointer to flags for data
 566  *             count        count of received data in bytes
 567  *
 568  * Return Value:    None
 569  */
 570 static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
 571                                  char *flags, int count)
 572 {
 573         struct hci_uart *hu = tty->disc_data;
 574
 575         if (!hu || tty != hu->tty)
 576                 return;
 577
 578         read_lock(&hu->proto_lock);
 579
 580         if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
 581                 read_unlock(&hu->proto_lock);
 582                 return;
 583         }
 584
 585         /* It does not need a lock here as it is already protected by a mutex in
 586          * tty caller
 587          */
 588         hu->proto->recv(hu, data, count);
 589         read_unlock(&hu->proto_lock);
 590
 591         if (hu->hdev)
 592                 hu->hdev->stat.byte_rx += count;
 593
 594         tty_unthrottle(tty);
 595 }
 596
 597 static int hci_uart_register_dev(struct hci_uart *hu)
 598 {
 599         struct hci_dev *hdev;
 600
 601         BT_DBG("");
 602
 603         /* Initialize and register HCI device */
 604         hdev = hci_alloc_dev();
 605         if (!hdev) {
 606                 BT_ERR("Can't allocate HCI device");
 607                 return -ENOMEM;
 608         }
 609
 610         hu->hdev = hdev;
 611
 612         hdev->bus = HCI_UART;
 613         hci_set_drvdata(hdev, hu);
 614
 615         /* Only when vendor specific setup callback is provided, consider
 616          * the manufacturer information valid. This avoids filling in the
 617          * value for Ericsson when nothing is specified.
 618          */
 619         if (hu->proto->setup)
 620                 hdev->manufacturer = hu->proto->manufacturer;
 621
 622         hdev->open  = hci_uart_open;
 623         hdev->close = hci_uart_close;
 624         hdev->flush = hci_uart_flush;
 625         hdev->send  = hci_uart_send_frame;
 626         hdev->setup = hci_uart_setup;
 627         SET_HCIDEV_DEV(hdev, hu->tty->dev);
 628
 629         if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
 630                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 631
 632         if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
 633                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 634
 635         if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags))
 636                 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 637
 638         if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
 639                 hdev->dev_type = HCI_AMP;
 640         else
 641                 hdev->dev_type = HCI_PRIMARY;
 642
 643         if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
 644                 return 0;
 645
 646         if (hci_register_dev(hdev) < 0) {
 647                 BT_ERR("Can't register HCI device");
 648                 hu->hdev = NULL;
 649                 hci_free_dev(hdev);
 650                 return -ENODEV;
 651         }
 652
 653         set_bit(HCI_UART_REGISTERED, &hu->flags);
 654
 655         return 0;
 656 }
 657
 658 static int hci_uart_set_proto(struct hci_uart *hu, int id)
 659 {
 660         const struct hci_uart_proto *p;
 661         int err;
 662
 663         p = hci_uart_get_proto(id);
 664         if (!p)
 665                 return -EPROTONOSUPPORT;
 666
 667         err = p->open(hu);
 668         if (err)
 669                 return err;
 670
 671         hu->proto = p;
 672         set_bit(HCI_UART_PROTO_READY, &hu->flags);
 673
 674         err = hci_uart_register_dev(hu);
 675         if (err) {
 676                 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
 677                 p->close(hu);
 678                 return err;
 679         }
 680
 681         return 0;
 682 }
 683
 684 static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags)
 685 {
 686         unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) |
 687                                     BIT(HCI_UART_RESET_ON_INIT) |
 688                                     BIT(HCI_UART_CREATE_AMP) |
 689                                     BIT(HCI_UART_INIT_PENDING) |
 690                                     BIT(HCI_UART_EXT_CONFIG) |
 691                                     BIT(HCI_UART_VND_DETECT);
 692
 693         if (flags & ~valid_flags)
 694                 return -EINVAL;
 695
 696         hu->hdev_flags = flags;
 697
 698         return 0;
 699 }
 700
 701 /* hci_uart_tty_ioctl()
 702  *
 703  *    Process IOCTL system call for the tty device.
 704  *
 705  * Arguments:
 706  *
 707  *    tty        pointer to tty instance data
 708  *    file       pointer to open file object for device
 709  *    cmd        IOCTL command code
 710  *    arg        argument for IOCTL call (cmd dependent)
 711  *
 712  * Return Value:    Command dependent
 713  */
 714 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
 715                               unsigned int cmd, unsigned long arg)
 716 {
 717         struct hci_uart *hu = tty->disc_data;
 718         int err = 0;
 719
 720         BT_DBG("");
 721
 722         /* Verify the status of the device */
 723         if (!hu)
 724                 return -EBADF;
 725
 726         switch (cmd) {
 727         case HCIUARTSETPROTO:
 728                 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 729                         err = hci_uart_set_proto(hu, arg);
 730                         if (err)
 731                                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 732                 } else
 733                         err = -EBUSY;
 734                 break;
 735
 736         case HCIUARTGETPROTO:
 737                 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 738                         err = hu->proto->id;
 739                 else
 740                         err = -EUNATCH;
 741                 break;
 742
 743         case HCIUARTGETDEVICE:
 744                 if (test_bit(HCI_UART_REGISTERED, &hu->flags))
 745                         err = hu->hdev->id;
 746                 else
 747                         err = -EUNATCH;
 748                 break;
 749
 750         case HCIUARTSETFLAGS:
 751                 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 752                         err = -EBUSY;
 753                 else
 754                         err = hci_uart_set_flags(hu, arg);
 755                 break;
 756
 757         case HCIUARTGETFLAGS:
 758                 err = hu->hdev_flags;
 759                 break;
 760
 761         default:
 762                 err = n_tty_ioctl_helper(tty, file, cmd, arg);
 763                 break;
 764         }
 765
 766         return err;
 767 }
 768
 769 /*
 770  * We don't provide read/write/poll interface for user space.
 771  */
 772 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file,
 773                                  unsigned char __user *buf, size_t nr)
 774 {
 775         return 0;
 776 }
 777
 778 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file,
 779                                   const unsigned char *data, size_t count)
 780 {
 781         return 0;
 782 }
 783
 784 static unsigned int hci_uart_tty_poll(struct tty_struct *tty,
 785                                       struct file *filp, poll_table *wait)
 786 {
 787         return 0;
 788 }
 789
 790 static int __init hci_uart_init(void)
 791 {
 792         static struct tty_ldisc_ops hci_uart_ldisc;
 793         int err;
 794
 795         BT_INFO("HCI UART driver ver %s", VERSION);
 796
 797         /* Register the tty discipline */
 798
 799         memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc));
 800         hci_uart_ldisc.magic            = TTY_LDISC_MAGIC;
 801         hci_uart_ldisc.name             = "n_hci";
 802         hci_uart_ldisc.open             = hci_uart_tty_open;
 803         hci_uart_ldisc.close            = hci_uart_tty_close;
 804         hci_uart_ldisc.read             = hci_uart_tty_read;
 805         hci_uart_ldisc.write            = hci_uart_tty_write;
 806         hci_uart_ldisc.ioctl            = hci_uart_tty_ioctl;
 807         hci_uart_ldisc.poll             = hci_uart_tty_poll;
 808         hci_uart_ldisc.receive_buf      = hci_uart_tty_receive;
 809         hci_uart_ldisc.write_wakeup     = hci_uart_tty_wakeup;
 810         hci_uart_ldisc.owner            = THIS_MODULE;
 811
 812         err = tty_register_ldisc(N_HCI, &hci_uart_ldisc);
 813         if (err) {
 814                 BT_ERR("HCI line discipline registration failed. (%d)", err);
 815                 return err;
 816         }
 817
 818 #ifdef CONFIG_BT_HCIUART_H4
 819         h4_init();
 820 #endif
 821 #ifdef CONFIG_BT_HCIUART_BCSP
 822         bcsp_init();
 823 #endif
 824 #ifdef CONFIG_BT_HCIUART_LL
 825         ll_init();
 826 #endif
 827 #ifdef CONFIG_BT_HCIUART_ATH3K
 828         ath_init();
 829 #endif
 830 #ifdef CONFIG_BT_HCIUART_3WIRE
 831         h5_init();
 832 #endif
 833 #ifdef CONFIG_BT_HCIUART_INTEL
 834         intel_init();
 835 #endif
 836 #ifdef CONFIG_BT_HCIUART_BCM
 837         bcm_init();
 838 #endif
 839 #ifdef CONFIG_BT_HCIUART_QCA
 840         qca_init();
 841 #endif
 842 #ifdef CONFIG_BT_HCIUART_AG6XX
 843         ag6xx_init();
 844 #endif
 845 #ifdef CONFIG_BT_HCIUART_MRVL
 846         mrvl_init();
 847 #endif
 848
 849         return 0;
 850 }
 851
 852 static void __exit hci_uart_exit(void)
 853 {
 854         int err;
 855
 856 #ifdef CONFIG_BT_HCIUART_H4
 857         h4_deinit();
 858 #endif
 859 #ifdef CONFIG_BT_HCIUART_BCSP
 860         bcsp_deinit();
 861 #endif
 862 #ifdef CONFIG_BT_HCIUART_LL
 863         ll_deinit();
 864 #endif
 865 #ifdef CONFIG_BT_HCIUART_ATH3K
 866         ath_deinit();
 867 #endif
 868 #ifdef CONFIG_BT_HCIUART_3WIRE
 869         h5_deinit();
 870 #endif
 871 #ifdef CONFIG_BT_HCIUART_INTEL
 872         intel_deinit();
 873 #endif
 874 #ifdef CONFIG_BT_HCIUART_BCM
 875         bcm_deinit();
 876 #endif
 877 #ifdef CONFIG_BT_HCIUART_QCA
 878         qca_deinit();
 879 #endif
 880 #ifdef CONFIG_BT_HCIUART_AG6XX
 881         ag6xx_deinit();
 882 #endif
 883 #ifdef CONFIG_BT_HCIUART_MRVL
 884         mrvl_deinit();
 885 #endif
 886
 887         /* Release tty registration of line discipline */
 888         err = tty_unregister_ldisc(N_HCI);
 889         if (err)
 890                 BT_ERR("Can't unregister HCI line discipline (%d)", err);
 891 }
 892
 893 module_init(hci_uart_init);
 894 module_exit(hci_uart_exit);
 895
 896 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 897 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
 898 MODULE_VERSION(VERSION);
 899 MODULE_LICENSE("GPL");
 900 MODULE_ALIAS_LDISC(N_HCI);