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 44 #include <net/bluetooth/bluetooth.h> 45 #include <net/bluetooth/hci_core.h> 46 47 #include "hci_uart.h" 48 49 #define VERSION "2.2" 50 51 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO]; 52 53 int hci_uart_register_proto(struct hci_uart_proto *p) 54 { 55 if (p->id >= HCI_UART_MAX_PROTO) 56 return -EINVAL; 57 58 if (hup[p->id]) 59 return -EEXIST; 60 61 hup[p->id] = p; 62 63 return 0; 64 } 65 66 int hci_uart_unregister_proto(struct hci_uart_proto *p) 67 { 68 if (p->id >= HCI_UART_MAX_PROTO) 69 return -EINVAL; 70 71 if (!hup[p->id]) 72 return -EINVAL; 73 74 hup[p->id] = NULL; 75 76 return 0; 77 } 78 79 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id) 80 { 81 if (id >= HCI_UART_MAX_PROTO) 82 return NULL; 83 84 return hup[id]; 85 } 86 87 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type) 88 { 89 struct hci_dev *hdev = hu->hdev; 90 91 /* Update HCI stat counters */ 92 switch (pkt_type) { 93 case HCI_COMMAND_PKT: 94 hdev->stat.cmd_tx++; 95 break; 96 97 case HCI_ACLDATA_PKT: 98 hdev->stat.acl_tx++; 99 break; 100 101 case HCI_SCODATA_PKT: 102 hdev->stat.sco_tx++; 103 break; 104 } 105 } 106 107 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu) 108 { 109 struct sk_buff *skb = hu->tx_skb; 110 111 if (!skb) 112 skb = hu->proto->dequeue(hu); 113 else 114 hu->tx_skb = NULL; 115 116 return skb; 117 } 118 119 int hci_uart_tx_wakeup(struct hci_uart *hu) 120 { 121 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) { 122 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); 123 return 0; 124 } 125 126 BT_DBG(""); 127 128 schedule_work(&hu->write_work); 129 130 return 0; 131 } 132 133 static void hci_uart_write_work(struct work_struct *work) 134 { 135 struct hci_uart *hu = container_of(work, struct hci_uart, write_work); 136 struct tty_struct *tty = hu->tty; 137 struct hci_dev *hdev = hu->hdev; 138 struct sk_buff *skb; 139 140 /* REVISIT: should we cope with bad skbs or ->write() returning 141 * and error value ? 142 */ 143 144 restart: 145 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); 146 147 while ((skb = hci_uart_dequeue(hu))) { 148 int len; 149 150 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 151 len = tty->ops->write(tty, skb->data, skb->len); 152 hdev->stat.byte_tx += len; 153 154 skb_pull(skb, len); 155 if (skb->len) { 156 hu->tx_skb = skb; 157 break; 158 } 159 160 hci_uart_tx_complete(hu, bt_cb(skb)->pkt_type); 161 kfree_skb(skb); 162 } 163 164 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)) 165 goto restart; 166 167 clear_bit(HCI_UART_SENDING, &hu->tx_state); 168 } 169 170 static void hci_uart_init_work(struct work_struct *work) 171 { 172 struct hci_uart *hu = container_of(work, struct hci_uart, init_ready); 173 int err; 174 175 if (!test_and_clear_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 176 return; 177 178 err = hci_register_dev(hu->hdev); 179 if (err < 0) { 180 BT_ERR("Can't register HCI device"); 181 hci_free_dev(hu->hdev); 182 hu->hdev = NULL; 183 hu->proto->close(hu); 184 } 185 186 set_bit(HCI_UART_REGISTERED, &hu->flags); 187 } 188 189 int hci_uart_init_ready(struct hci_uart *hu) 190 { 191 if (!test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 192 return -EALREADY; 193 194 schedule_work(&hu->init_ready); 195 196 return 0; 197 } 198 199 /* ------- Interface to HCI layer ------ */ 200 /* Initialize device */ 201 static int hci_uart_open(struct hci_dev *hdev) 202 { 203 BT_DBG("%s %p", hdev->name, hdev); 204 205 /* Nothing to do for UART driver */ 206 207 set_bit(HCI_RUNNING, &hdev->flags); 208 209 return 0; 210 } 211 212 /* Reset device */ 213 static int hci_uart_flush(struct hci_dev *hdev) 214 { 215 struct hci_uart *hu = hci_get_drvdata(hdev); 216 struct tty_struct *tty = hu->tty; 217 218 BT_DBG("hdev %p tty %p", hdev, tty); 219 220 if (hu->tx_skb) { 221 kfree_skb(hu->tx_skb); hu->tx_skb = NULL; 222 } 223 224 /* Flush any pending characters in the driver and discipline. */ 225 tty_ldisc_flush(tty); 226 tty_driver_flush_buffer(tty); 227 228 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 229 hu->proto->flush(hu); 230 231 return 0; 232 } 233 234 /* Close device */ 235 static int hci_uart_close(struct hci_dev *hdev) 236 { 237 BT_DBG("hdev %p", hdev); 238 239 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 240 return 0; 241 242 hci_uart_flush(hdev); 243 hdev->flush = NULL; 244 return 0; 245 } 246 247 /* Send frames from HCI layer */ 248 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 249 { 250 struct hci_uart *hu = hci_get_drvdata(hdev); 251 252 if (!test_bit(HCI_RUNNING, &hdev->flags)) 253 return -EBUSY; 254 255 BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 256 257 hu->proto->enqueue(hu, skb); 258 259 hci_uart_tx_wakeup(hu); 260 261 return 0; 262 } 263 264 /* ------ LDISC part ------ */ 265 /* hci_uart_tty_open 266 * 267 * Called when line discipline changed to HCI_UART. 268 * 269 * Arguments: 270 * tty pointer to tty info structure 271 * Return Value: 272 * 0 if success, otherwise error code 273 */ 274 static int hci_uart_tty_open(struct tty_struct *tty) 275 { 276 struct hci_uart *hu; 277 278 BT_DBG("tty %p", tty); 279 280 /* Error if the tty has no write op instead of leaving an exploitable 281 hole */ 282 if (tty->ops->write == NULL) 283 return -EOPNOTSUPP; 284 285 hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL); 286 if (!hu) { 287 BT_ERR("Can't allocate control structure"); 288 return -ENFILE; 289 } 290 291 tty->disc_data = hu; 292 hu->tty = tty; 293 tty->receive_room = 65536; 294 295 INIT_WORK(&hu->init_ready, hci_uart_init_work); 296 INIT_WORK(&hu->write_work, hci_uart_write_work); 297 298 spin_lock_init(&hu->rx_lock); 299 300 /* Flush any pending characters in the driver and line discipline. */ 301 302 /* FIXME: why is this needed. Note don't use ldisc_ref here as the 303 open path is before the ldisc is referencable */ 304 305 if (tty->ldisc->ops->flush_buffer) 306 tty->ldisc->ops->flush_buffer(tty); 307 tty_driver_flush_buffer(tty); 308 309 return 0; 310 } 311 312 /* hci_uart_tty_close() 313 * 314 * Called when the line discipline is changed to something 315 * else, the tty is closed, or the tty detects a hangup. 316 */ 317 static void hci_uart_tty_close(struct tty_struct *tty) 318 { 319 struct hci_uart *hu = (void *)tty->disc_data; 320 struct hci_dev *hdev; 321 322 BT_DBG("tty %p", tty); 323 324 /* Detach from the tty */ 325 tty->disc_data = NULL; 326 327 if (!hu) 328 return; 329 330 hdev = hu->hdev; 331 if (hdev) 332 hci_uart_close(hdev); 333 334 cancel_work_sync(&hu->write_work); 335 336 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) { 337 if (hdev) { 338 if (test_bit(HCI_UART_REGISTERED, &hu->flags)) 339 hci_unregister_dev(hdev); 340 hci_free_dev(hdev); 341 } 342 hu->proto->close(hu); 343 } 344 345 kfree(hu); 346 } 347 348 /* hci_uart_tty_wakeup() 349 * 350 * Callback for transmit wakeup. Called when low level 351 * device driver can accept more send data. 352 * 353 * Arguments: tty pointer to associated tty instance data 354 * Return Value: None 355 */ 356 static void hci_uart_tty_wakeup(struct tty_struct *tty) 357 { 358 struct hci_uart *hu = (void *)tty->disc_data; 359 360 BT_DBG(""); 361 362 if (!hu) 363 return; 364 365 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 366 367 if (tty != hu->tty) 368 return; 369 370 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 371 hci_uart_tx_wakeup(hu); 372 } 373 374 /* hci_uart_tty_receive() 375 * 376 * Called by tty low level driver when receive data is 377 * available. 378 * 379 * Arguments: tty pointer to tty isntance data 380 * data pointer to received data 381 * flags pointer to flags for data 382 * count count of received data in bytes 383 * 384 * Return Value: None 385 */ 386 static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data, char *flags, int count) 387 { 388 struct hci_uart *hu = (void *)tty->disc_data; 389 390 if (!hu || tty != hu->tty) 391 return; 392 393 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags)) 394 return; 395 396 spin_lock(&hu->rx_lock); 397 hu->proto->recv(hu, (void *) data, count); 398 399 if (hu->hdev) 400 hu->hdev->stat.byte_rx += count; 401 402 spin_unlock(&hu->rx_lock); 403 404 tty_unthrottle(tty); 405 } 406 407 static int hci_uart_register_dev(struct hci_uart *hu) 408 { 409 struct hci_dev *hdev; 410 411 BT_DBG(""); 412 413 /* Initialize and register HCI device */ 414 hdev = hci_alloc_dev(); 415 if (!hdev) { 416 BT_ERR("Can't allocate HCI device"); 417 return -ENOMEM; 418 } 419 420 hu->hdev = hdev; 421 422 hdev->bus = HCI_UART; 423 hci_set_drvdata(hdev, hu); 424 425 hdev->open = hci_uart_open; 426 hdev->close = hci_uart_close; 427 hdev->flush = hci_uart_flush; 428 hdev->send = hci_uart_send_frame; 429 SET_HCIDEV_DEV(hdev, hu->tty->dev); 430 431 if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags)) 432 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); 433 434 if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags)) 435 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks); 436 437 if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags)) 438 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); 439 440 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) 441 hdev->dev_type = HCI_AMP; 442 else 443 hdev->dev_type = HCI_BREDR; 444 445 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 446 return 0; 447 448 if (hci_register_dev(hdev) < 0) { 449 BT_ERR("Can't register HCI device"); 450 hci_free_dev(hdev); 451 return -ENODEV; 452 } 453 454 set_bit(HCI_UART_REGISTERED, &hu->flags); 455 456 return 0; 457 } 458 459 static int hci_uart_set_proto(struct hci_uart *hu, int id) 460 { 461 struct hci_uart_proto *p; 462 int err; 463 464 p = hci_uart_get_proto(id); 465 if (!p) 466 return -EPROTONOSUPPORT; 467 468 err = p->open(hu); 469 if (err) 470 return err; 471 472 hu->proto = p; 473 474 err = hci_uart_register_dev(hu); 475 if (err) { 476 p->close(hu); 477 return err; 478 } 479 480 return 0; 481 } 482 483 static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags) 484 { 485 unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) | 486 BIT(HCI_UART_RESET_ON_INIT) | 487 BIT(HCI_UART_CREATE_AMP) | 488 BIT(HCI_UART_INIT_PENDING) | 489 BIT(HCI_UART_EXT_CONFIG); 490 491 if ((flags & ~valid_flags)) 492 return -EINVAL; 493 494 hu->hdev_flags = flags; 495 496 return 0; 497 } 498 499 /* hci_uart_tty_ioctl() 500 * 501 * Process IOCTL system call for the tty device. 502 * 503 * Arguments: 504 * 505 * tty pointer to tty instance data 506 * file pointer to open file object for device 507 * cmd IOCTL command code 508 * arg argument for IOCTL call (cmd dependent) 509 * 510 * Return Value: Command dependent 511 */ 512 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file, 513 unsigned int cmd, unsigned long arg) 514 { 515 struct hci_uart *hu = (void *)tty->disc_data; 516 int err = 0; 517 518 BT_DBG(""); 519 520 /* Verify the status of the device */ 521 if (!hu) 522 return -EBADF; 523 524 switch (cmd) { 525 case HCIUARTSETPROTO: 526 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) { 527 err = hci_uart_set_proto(hu, arg); 528 if (err) { 529 clear_bit(HCI_UART_PROTO_SET, &hu->flags); 530 return err; 531 } 532 } else 533 return -EBUSY; 534 break; 535 536 case HCIUARTGETPROTO: 537 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 538 return hu->proto->id; 539 return -EUNATCH; 540 541 case HCIUARTGETDEVICE: 542 if (test_bit(HCI_UART_REGISTERED, &hu->flags)) 543 return hu->hdev->id; 544 return -EUNATCH; 545 546 case HCIUARTSETFLAGS: 547 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 548 return -EBUSY; 549 err = hci_uart_set_flags(hu, arg); 550 if (err) 551 return err; 552 break; 553 554 case HCIUARTGETFLAGS: 555 return hu->hdev_flags; 556 557 default: 558 err = n_tty_ioctl_helper(tty, file, cmd, arg); 559 break; 560 } 561 562 return err; 563 } 564 565 /* 566 * We don't provide read/write/poll interface for user space. 567 */ 568 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, 569 unsigned char __user *buf, size_t nr) 570 { 571 return 0; 572 } 573 574 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, 575 const unsigned char *data, size_t count) 576 { 577 return 0; 578 } 579 580 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, 581 struct file *filp, poll_table *wait) 582 { 583 return 0; 584 } 585 586 static int __init hci_uart_init(void) 587 { 588 static struct tty_ldisc_ops hci_uart_ldisc; 589 int err; 590 591 BT_INFO("HCI UART driver ver %s", VERSION); 592 593 /* Register the tty discipline */ 594 595 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc)); 596 hci_uart_ldisc.magic = TTY_LDISC_MAGIC; 597 hci_uart_ldisc.name = "n_hci"; 598 hci_uart_ldisc.open = hci_uart_tty_open; 599 hci_uart_ldisc.close = hci_uart_tty_close; 600 hci_uart_ldisc.read = hci_uart_tty_read; 601 hci_uart_ldisc.write = hci_uart_tty_write; 602 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl; 603 hci_uart_ldisc.poll = hci_uart_tty_poll; 604 hci_uart_ldisc.receive_buf = hci_uart_tty_receive; 605 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup; 606 hci_uart_ldisc.owner = THIS_MODULE; 607 608 err = tty_register_ldisc(N_HCI, &hci_uart_ldisc); 609 if (err) { 610 BT_ERR("HCI line discipline registration failed. (%d)", err); 611 return err; 612 } 613 614 #ifdef CONFIG_BT_HCIUART_H4 615 h4_init(); 616 #endif 617 #ifdef CONFIG_BT_HCIUART_BCSP 618 bcsp_init(); 619 #endif 620 #ifdef CONFIG_BT_HCIUART_LL 621 ll_init(); 622 #endif 623 #ifdef CONFIG_BT_HCIUART_ATH3K 624 ath_init(); 625 #endif 626 #ifdef CONFIG_BT_HCIUART_3WIRE 627 h5_init(); 628 #endif 629 630 return 0; 631 } 632 633 static void __exit hci_uart_exit(void) 634 { 635 int err; 636 637 #ifdef CONFIG_BT_HCIUART_H4 638 h4_deinit(); 639 #endif 640 #ifdef CONFIG_BT_HCIUART_BCSP 641 bcsp_deinit(); 642 #endif 643 #ifdef CONFIG_BT_HCIUART_LL 644 ll_deinit(); 645 #endif 646 #ifdef CONFIG_BT_HCIUART_ATH3K 647 ath_deinit(); 648 #endif 649 #ifdef CONFIG_BT_HCIUART_3WIRE 650 h5_deinit(); 651 #endif 652 653 /* Release tty registration of line discipline */ 654 err = tty_unregister_ldisc(N_HCI); 655 if (err) 656 BT_ERR("Can't unregister HCI line discipline (%d)", err); 657 } 658 659 module_init(hci_uart_init); 660 module_exit(hci_uart_exit); 661 662 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 663 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); 664 MODULE_VERSION(VERSION); 665 MODULE_LICENSE("GPL"); 666 MODULE_ALIAS_LDISC(N_HCI); 667