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/config.h> 27 #include <linux/module.h> 28 29 #include <linux/kernel.h> 30 #include <linux/init.h> 31 #include <linux/sched.h> 32 #include <linux/types.h> 33 #include <linux/fcntl.h> 34 #include <linux/interrupt.h> 35 #include <linux/ptrace.h> 36 #include <linux/poll.h> 37 38 #include <linux/slab.h> 39 #include <linux/tty.h> 40 #include <linux/errno.h> 41 #include <linux/string.h> 42 #include <linux/signal.h> 43 #include <linux/ioctl.h> 44 #include <linux/skbuff.h> 45 46 #include <net/bluetooth/bluetooth.h> 47 #include <net/bluetooth/hci_core.h> 48 49 #include "hci_uart.h" 50 51 #ifndef CONFIG_BT_HCIUART_DEBUG 52 #undef BT_DBG 53 #define BT_DBG( A... ) 54 #endif 55 56 #define VERSION "2.2" 57 58 static int reset = 0; 59 60 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO]; 61 62 int hci_uart_register_proto(struct hci_uart_proto *p) 63 { 64 if (p->id >= HCI_UART_MAX_PROTO) 65 return -EINVAL; 66 67 if (hup[p->id]) 68 return -EEXIST; 69 70 hup[p->id] = p; 71 72 return 0; 73 } 74 75 int hci_uart_unregister_proto(struct hci_uart_proto *p) 76 { 77 if (p->id >= HCI_UART_MAX_PROTO) 78 return -EINVAL; 79 80 if (!hup[p->id]) 81 return -EINVAL; 82 83 hup[p->id] = NULL; 84 85 return 0; 86 } 87 88 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id) 89 { 90 if (id >= HCI_UART_MAX_PROTO) 91 return NULL; 92 93 return hup[id]; 94 } 95 96 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type) 97 { 98 struct hci_dev *hdev = hu->hdev; 99 100 /* Update HCI stat counters */ 101 switch (pkt_type) { 102 case HCI_COMMAND_PKT: 103 hdev->stat.cmd_tx++; 104 break; 105 106 case HCI_ACLDATA_PKT: 107 hdev->stat.acl_tx++; 108 break; 109 110 case HCI_SCODATA_PKT: 111 hdev->stat.cmd_tx++; 112 break; 113 } 114 } 115 116 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu) 117 { 118 struct sk_buff *skb = hu->tx_skb; 119 120 if (!skb) 121 skb = hu->proto->dequeue(hu); 122 else 123 hu->tx_skb = NULL; 124 125 return skb; 126 } 127 128 int hci_uart_tx_wakeup(struct hci_uart *hu) 129 { 130 struct tty_struct *tty = hu->tty; 131 struct hci_dev *hdev = hu->hdev; 132 struct sk_buff *skb; 133 134 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) { 135 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); 136 return 0; 137 } 138 139 BT_DBG(""); 140 141 restart: 142 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); 143 144 while ((skb = hci_uart_dequeue(hu))) { 145 int len; 146 147 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 148 len = tty->driver->write(tty, skb->data, skb->len); 149 hdev->stat.byte_tx += len; 150 151 skb_pull(skb, len); 152 if (skb->len) { 153 hu->tx_skb = skb; 154 break; 155 } 156 157 hci_uart_tx_complete(hu, bt_cb(skb)->pkt_type); 158 kfree_skb(skb); 159 } 160 161 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)) 162 goto restart; 163 164 clear_bit(HCI_UART_SENDING, &hu->tx_state); 165 return 0; 166 } 167 168 /* ------- Interface to HCI layer ------ */ 169 /* Initialize device */ 170 static int hci_uart_open(struct hci_dev *hdev) 171 { 172 BT_DBG("%s %p", hdev->name, hdev); 173 174 /* Nothing to do for UART driver */ 175 176 set_bit(HCI_RUNNING, &hdev->flags); 177 178 return 0; 179 } 180 181 /* Reset device */ 182 static int hci_uart_flush(struct hci_dev *hdev) 183 { 184 struct hci_uart *hu = (struct hci_uart *) hdev->driver_data; 185 struct tty_struct *tty = hu->tty; 186 187 BT_DBG("hdev %p tty %p", hdev, tty); 188 189 if (hu->tx_skb) { 190 kfree_skb(hu->tx_skb); hu->tx_skb = NULL; 191 } 192 193 /* Flush any pending characters in the driver and discipline. */ 194 tty_ldisc_flush(tty); 195 if (tty->driver->flush_buffer) 196 tty->driver->flush_buffer(tty); 197 198 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 199 hu->proto->flush(hu); 200 201 return 0; 202 } 203 204 /* Close device */ 205 static int hci_uart_close(struct hci_dev *hdev) 206 { 207 BT_DBG("hdev %p", hdev); 208 209 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 210 return 0; 211 212 hci_uart_flush(hdev); 213 return 0; 214 } 215 216 /* Send frames from HCI layer */ 217 static int hci_uart_send_frame(struct sk_buff *skb) 218 { 219 struct hci_dev* hdev = (struct hci_dev *) skb->dev; 220 struct tty_struct *tty; 221 struct hci_uart *hu; 222 223 if (!hdev) { 224 BT_ERR("Frame for uknown device (hdev=NULL)"); 225 return -ENODEV; 226 } 227 228 if (!test_bit(HCI_RUNNING, &hdev->flags)) 229 return -EBUSY; 230 231 hu = (struct hci_uart *) hdev->driver_data; 232 tty = hu->tty; 233 234 BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 235 236 hu->proto->enqueue(hu, skb); 237 238 hci_uart_tx_wakeup(hu); 239 240 return 0; 241 } 242 243 static void hci_uart_destruct(struct hci_dev *hdev) 244 { 245 struct hci_uart *hu; 246 247 if (!hdev) 248 return; 249 250 BT_DBG("%s", hdev->name); 251 252 hu = (struct hci_uart *) hdev->driver_data; 253 kfree(hu); 254 } 255 256 /* ------ LDISC part ------ */ 257 /* hci_uart_tty_open 258 * 259 * Called when line discipline changed to HCI_UART. 260 * 261 * Arguments: 262 * tty pointer to tty info structure 263 * Return Value: 264 * 0 if success, otherwise error code 265 */ 266 static int hci_uart_tty_open(struct tty_struct *tty) 267 { 268 struct hci_uart *hu = (void *) tty->disc_data; 269 270 BT_DBG("tty %p", tty); 271 272 if (hu) 273 return -EEXIST; 274 275 if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) { 276 BT_ERR("Can't allocate controll structure"); 277 return -ENFILE; 278 } 279 280 memset(hu, 0, sizeof(struct hci_uart)); 281 282 tty->disc_data = hu; 283 hu->tty = tty; 284 285 spin_lock_init(&hu->rx_lock); 286 287 /* Flush any pending characters in the driver and line discipline. */ 288 289 /* FIXME: why is this needed. Note don't use ldisc_ref here as the 290 open path is before the ldisc is referencable */ 291 292 if (tty->ldisc.flush_buffer) 293 tty->ldisc.flush_buffer(tty); 294 295 if (tty->driver->flush_buffer) 296 tty->driver->flush_buffer(tty); 297 298 return 0; 299 } 300 301 /* hci_uart_tty_close() 302 * 303 * Called when the line discipline is changed to something 304 * else, the tty is closed, or the tty detects a hangup. 305 */ 306 static void hci_uart_tty_close(struct tty_struct *tty) 307 { 308 struct hci_uart *hu = (void *)tty->disc_data; 309 310 BT_DBG("tty %p", tty); 311 312 /* Detach from the tty */ 313 tty->disc_data = NULL; 314 315 if (hu) { 316 struct hci_dev *hdev = hu->hdev; 317 hci_uart_close(hdev); 318 319 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) { 320 hu->proto->close(hu); 321 hci_unregister_dev(hdev); 322 hci_free_dev(hdev); 323 } 324 } 325 } 326 327 /* hci_uart_tty_wakeup() 328 * 329 * Callback for transmit wakeup. Called when low level 330 * device driver can accept more send data. 331 * 332 * Arguments: tty pointer to associated tty instance data 333 * Return Value: None 334 */ 335 static void hci_uart_tty_wakeup(struct tty_struct *tty) 336 { 337 struct hci_uart *hu = (void *)tty->disc_data; 338 339 BT_DBG(""); 340 341 if (!hu) 342 return; 343 344 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 345 346 if (tty != hu->tty) 347 return; 348 349 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 350 hci_uart_tx_wakeup(hu); 351 } 352 353 /* hci_uart_tty_room() 354 * 355 * Callback function from tty driver. Return the amount of 356 * space left in the receiver's buffer to decide if remote 357 * transmitter is to be throttled. 358 * 359 * Arguments: tty pointer to associated tty instance data 360 * Return Value: number of bytes left in receive buffer 361 */ 362 static int hci_uart_tty_room (struct tty_struct *tty) 363 { 364 return 65536; 365 } 366 367 /* hci_uart_tty_receive() 368 * 369 * Called by tty low level driver when receive data is 370 * available. 371 * 372 * Arguments: tty pointer to tty isntance data 373 * data pointer to received data 374 * flags pointer to flags for data 375 * count count of received data in bytes 376 * 377 * Return Value: None 378 */ 379 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count) 380 { 381 struct hci_uart *hu = (void *)tty->disc_data; 382 383 if (!hu || tty != hu->tty) 384 return; 385 386 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags)) 387 return; 388 389 spin_lock(&hu->rx_lock); 390 hu->proto->recv(hu, (void *) data, count); 391 hu->hdev->stat.byte_rx += count; 392 spin_unlock(&hu->rx_lock); 393 394 if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle) 395 tty->driver->unthrottle(tty); 396 } 397 398 static int hci_uart_register_dev(struct hci_uart *hu) 399 { 400 struct hci_dev *hdev; 401 402 BT_DBG(""); 403 404 /* Initialize and register HCI device */ 405 hdev = hci_alloc_dev(); 406 if (!hdev) { 407 BT_ERR("Can't allocate HCI device"); 408 return -ENOMEM; 409 } 410 411 hu->hdev = hdev; 412 413 hdev->type = HCI_UART; 414 hdev->driver_data = hu; 415 416 hdev->open = hci_uart_open; 417 hdev->close = hci_uart_close; 418 hdev->flush = hci_uart_flush; 419 hdev->send = hci_uart_send_frame; 420 hdev->destruct = hci_uart_destruct; 421 422 hdev->owner = THIS_MODULE; 423 424 if (reset) 425 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks); 426 427 if (hci_register_dev(hdev) < 0) { 428 BT_ERR("Can't register HCI device"); 429 hci_free_dev(hdev); 430 return -ENODEV; 431 } 432 433 return 0; 434 } 435 436 static int hci_uart_set_proto(struct hci_uart *hu, int id) 437 { 438 struct hci_uart_proto *p; 439 int err; 440 441 p = hci_uart_get_proto(id); 442 if (!p) 443 return -EPROTONOSUPPORT; 444 445 err = p->open(hu); 446 if (err) 447 return err; 448 449 hu->proto = p; 450 451 err = hci_uart_register_dev(hu); 452 if (err) { 453 p->close(hu); 454 return err; 455 } 456 457 return 0; 458 } 459 460 /* hci_uart_tty_ioctl() 461 * 462 * Process IOCTL system call for the tty device. 463 * 464 * Arguments: 465 * 466 * tty pointer to tty instance data 467 * file pointer to open file object for device 468 * cmd IOCTL command code 469 * arg argument for IOCTL call (cmd dependent) 470 * 471 * Return Value: Command dependent 472 */ 473 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file, 474 unsigned int cmd, unsigned long arg) 475 { 476 struct hci_uart *hu = (void *)tty->disc_data; 477 int err = 0; 478 479 BT_DBG(""); 480 481 /* Verify the status of the device */ 482 if (!hu) 483 return -EBADF; 484 485 switch (cmd) { 486 case HCIUARTSETPROTO: 487 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) { 488 err = hci_uart_set_proto(hu, arg); 489 if (err) { 490 clear_bit(HCI_UART_PROTO_SET, &hu->flags); 491 return err; 492 } 493 tty->low_latency = 1; 494 } else 495 return -EBUSY; 496 497 case HCIUARTGETPROTO: 498 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 499 return hu->proto->id; 500 return -EUNATCH; 501 502 default: 503 err = n_tty_ioctl(tty, file, cmd, arg); 504 break; 505 }; 506 507 return err; 508 } 509 510 /* 511 * We don't provide read/write/poll interface for user space. 512 */ 513 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, 514 unsigned char __user *buf, size_t nr) 515 { 516 return 0; 517 } 518 519 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, 520 const unsigned char *data, size_t count) 521 { 522 return 0; 523 } 524 525 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, 526 struct file *filp, poll_table *wait) 527 { 528 return 0; 529 } 530 531 static int __init hci_uart_init(void) 532 { 533 static struct tty_ldisc hci_uart_ldisc; 534 int err; 535 536 BT_INFO("HCI UART driver ver %s", VERSION); 537 538 /* Register the tty discipline */ 539 540 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc)); 541 hci_uart_ldisc.magic = TTY_LDISC_MAGIC; 542 hci_uart_ldisc.name = "n_hci"; 543 hci_uart_ldisc.open = hci_uart_tty_open; 544 hci_uart_ldisc.close = hci_uart_tty_close; 545 hci_uart_ldisc.read = hci_uart_tty_read; 546 hci_uart_ldisc.write = hci_uart_tty_write; 547 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl; 548 hci_uart_ldisc.poll = hci_uart_tty_poll; 549 hci_uart_ldisc.receive_room = hci_uart_tty_room; 550 hci_uart_ldisc.receive_buf = hci_uart_tty_receive; 551 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup; 552 hci_uart_ldisc.owner = THIS_MODULE; 553 554 if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) { 555 BT_ERR("HCI line discipline registration failed. (%d)", err); 556 return err; 557 } 558 559 #ifdef CONFIG_BT_HCIUART_H4 560 h4_init(); 561 #endif 562 #ifdef CONFIG_BT_HCIUART_BCSP 563 bcsp_init(); 564 #endif 565 566 return 0; 567 } 568 569 static void __exit hci_uart_exit(void) 570 { 571 int err; 572 573 #ifdef CONFIG_BT_HCIUART_H4 574 h4_deinit(); 575 #endif 576 #ifdef CONFIG_BT_HCIUART_BCSP 577 bcsp_deinit(); 578 #endif 579 580 /* Release tty registration of line discipline */ 581 if ((err = tty_unregister_ldisc(N_HCI))) 582 BT_ERR("Can't unregister HCI line discipline (%d)", err); 583 } 584 585 module_init(hci_uart_init); 586 module_exit(hci_uart_exit); 587 588 module_param(reset, bool, 0644); 589 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization"); 590 591 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>"); 592 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); 593 MODULE_VERSION(VERSION); 594 MODULE_LICENSE("GPL"); 595 MODULE_ALIAS_LDISC(N_HCI); 596