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