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_RESET_ON_INIT, &hu->hdev_flags)) 435 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); 436 437 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) 438 hdev->dev_type = HCI_AMP; 439 else 440 hdev->dev_type = HCI_BREDR; 441 442 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 443 return 0; 444 445 if (hci_register_dev(hdev) < 0) { 446 BT_ERR("Can't register HCI device"); 447 hci_free_dev(hdev); 448 return -ENODEV; 449 } 450 451 set_bit(HCI_UART_REGISTERED, &hu->flags); 452 453 return 0; 454 } 455 456 static int hci_uart_set_proto(struct hci_uart *hu, int id) 457 { 458 struct hci_uart_proto *p; 459 int err; 460 461 p = hci_uart_get_proto(id); 462 if (!p) 463 return -EPROTONOSUPPORT; 464 465 err = p->open(hu); 466 if (err) 467 return err; 468 469 hu->proto = p; 470 471 err = hci_uart_register_dev(hu); 472 if (err) { 473 p->close(hu); 474 return err; 475 } 476 477 return 0; 478 } 479 480 /* hci_uart_tty_ioctl() 481 * 482 * Process IOCTL system call for the tty device. 483 * 484 * Arguments: 485 * 486 * tty pointer to tty instance data 487 * file pointer to open file object for device 488 * cmd IOCTL command code 489 * arg argument for IOCTL call (cmd dependent) 490 * 491 * Return Value: Command dependent 492 */ 493 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file, 494 unsigned int cmd, unsigned long arg) 495 { 496 struct hci_uart *hu = (void *)tty->disc_data; 497 int err = 0; 498 499 BT_DBG(""); 500 501 /* Verify the status of the device */ 502 if (!hu) 503 return -EBADF; 504 505 switch (cmd) { 506 case HCIUARTSETPROTO: 507 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) { 508 err = hci_uart_set_proto(hu, arg); 509 if (err) { 510 clear_bit(HCI_UART_PROTO_SET, &hu->flags); 511 return err; 512 } 513 } else 514 return -EBUSY; 515 break; 516 517 case HCIUARTGETPROTO: 518 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 519 return hu->proto->id; 520 return -EUNATCH; 521 522 case HCIUARTGETDEVICE: 523 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 524 return hu->hdev->id; 525 return -EUNATCH; 526 527 case HCIUARTSETFLAGS: 528 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 529 return -EBUSY; 530 hu->hdev_flags = arg; 531 break; 532 533 case HCIUARTGETFLAGS: 534 return hu->hdev_flags; 535 536 default: 537 err = n_tty_ioctl_helper(tty, file, cmd, arg); 538 break; 539 } 540 541 return err; 542 } 543 544 /* 545 * We don't provide read/write/poll interface for user space. 546 */ 547 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, 548 unsigned char __user *buf, size_t nr) 549 { 550 return 0; 551 } 552 553 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, 554 const unsigned char *data, size_t count) 555 { 556 return 0; 557 } 558 559 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, 560 struct file *filp, poll_table *wait) 561 { 562 return 0; 563 } 564 565 static int __init hci_uart_init(void) 566 { 567 static struct tty_ldisc_ops hci_uart_ldisc; 568 int err; 569 570 BT_INFO("HCI UART driver ver %s", VERSION); 571 572 /* Register the tty discipline */ 573 574 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc)); 575 hci_uart_ldisc.magic = TTY_LDISC_MAGIC; 576 hci_uart_ldisc.name = "n_hci"; 577 hci_uart_ldisc.open = hci_uart_tty_open; 578 hci_uart_ldisc.close = hci_uart_tty_close; 579 hci_uart_ldisc.read = hci_uart_tty_read; 580 hci_uart_ldisc.write = hci_uart_tty_write; 581 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl; 582 hci_uart_ldisc.poll = hci_uart_tty_poll; 583 hci_uart_ldisc.receive_buf = hci_uart_tty_receive; 584 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup; 585 hci_uart_ldisc.owner = THIS_MODULE; 586 587 err = tty_register_ldisc(N_HCI, &hci_uart_ldisc); 588 if (err) { 589 BT_ERR("HCI line discipline registration failed. (%d)", err); 590 return err; 591 } 592 593 #ifdef CONFIG_BT_HCIUART_H4 594 h4_init(); 595 #endif 596 #ifdef CONFIG_BT_HCIUART_BCSP 597 bcsp_init(); 598 #endif 599 #ifdef CONFIG_BT_HCIUART_LL 600 ll_init(); 601 #endif 602 #ifdef CONFIG_BT_HCIUART_ATH3K 603 ath_init(); 604 #endif 605 #ifdef CONFIG_BT_HCIUART_3WIRE 606 h5_init(); 607 #endif 608 609 return 0; 610 } 611 612 static void __exit hci_uart_exit(void) 613 { 614 int err; 615 616 #ifdef CONFIG_BT_HCIUART_H4 617 h4_deinit(); 618 #endif 619 #ifdef CONFIG_BT_HCIUART_BCSP 620 bcsp_deinit(); 621 #endif 622 #ifdef CONFIG_BT_HCIUART_LL 623 ll_deinit(); 624 #endif 625 #ifdef CONFIG_BT_HCIUART_ATH3K 626 ath_deinit(); 627 #endif 628 #ifdef CONFIG_BT_HCIUART_3WIRE 629 h5_deinit(); 630 #endif 631 632 /* Release tty registration of line discipline */ 633 err = tty_unregister_ldisc(N_HCI); 634 if (err) 635 BT_ERR("Can't unregister HCI line discipline (%d)", err); 636 } 637 638 module_init(hci_uart_init); 639 module_exit(hci_uart_exit); 640 641 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 642 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); 643 MODULE_VERSION(VERSION); 644 MODULE_LICENSE("GPL"); 645 MODULE_ALIAS_LDISC(N_HCI); 646