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 = kzalloc(sizeof(struct hci_uart), GFP_KERNEL))) { 276 BT_ERR("Can't allocate controll structure"); 277 return -ENFILE; 278 } 279 280 tty->disc_data = hu; 281 hu->tty = tty; 282 283 spin_lock_init(&hu->rx_lock); 284 285 /* Flush any pending characters in the driver and line discipline. */ 286 287 /* FIXME: why is this needed. Note don't use ldisc_ref here as the 288 open path is before the ldisc is referencable */ 289 290 if (tty->ldisc.flush_buffer) 291 tty->ldisc.flush_buffer(tty); 292 293 if (tty->driver->flush_buffer) 294 tty->driver->flush_buffer(tty); 295 296 return 0; 297 } 298 299 /* hci_uart_tty_close() 300 * 301 * Called when the line discipline is changed to something 302 * else, the tty is closed, or the tty detects a hangup. 303 */ 304 static void hci_uart_tty_close(struct tty_struct *tty) 305 { 306 struct hci_uart *hu = (void *)tty->disc_data; 307 308 BT_DBG("tty %p", tty); 309 310 /* Detach from the tty */ 311 tty->disc_data = NULL; 312 313 if (hu) { 314 struct hci_dev *hdev = hu->hdev; 315 hci_uart_close(hdev); 316 317 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) { 318 hu->proto->close(hu); 319 hci_unregister_dev(hdev); 320 hci_free_dev(hdev); 321 } 322 } 323 } 324 325 /* hci_uart_tty_wakeup() 326 * 327 * Callback for transmit wakeup. Called when low level 328 * device driver can accept more send data. 329 * 330 * Arguments: tty pointer to associated tty instance data 331 * Return Value: None 332 */ 333 static void hci_uart_tty_wakeup(struct tty_struct *tty) 334 { 335 struct hci_uart *hu = (void *)tty->disc_data; 336 337 BT_DBG(""); 338 339 if (!hu) 340 return; 341 342 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 343 344 if (tty != hu->tty) 345 return; 346 347 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 348 hci_uart_tx_wakeup(hu); 349 } 350 351 /* hci_uart_tty_room() 352 * 353 * Callback function from tty driver. Return the amount of 354 * space left in the receiver's buffer to decide if remote 355 * transmitter is to be throttled. 356 * 357 * Arguments: tty pointer to associated tty instance data 358 * Return Value: number of bytes left in receive buffer 359 */ 360 static int hci_uart_tty_room (struct tty_struct *tty) 361 { 362 return 65536; 363 } 364 365 /* hci_uart_tty_receive() 366 * 367 * Called by tty low level driver when receive data is 368 * available. 369 * 370 * Arguments: tty pointer to tty isntance data 371 * data pointer to received data 372 * flags pointer to flags for data 373 * count count of received data in bytes 374 * 375 * Return Value: None 376 */ 377 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count) 378 { 379 struct hci_uart *hu = (void *)tty->disc_data; 380 381 if (!hu || tty != hu->tty) 382 return; 383 384 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags)) 385 return; 386 387 spin_lock(&hu->rx_lock); 388 hu->proto->recv(hu, (void *) data, count); 389 hu->hdev->stat.byte_rx += count; 390 spin_unlock(&hu->rx_lock); 391 392 if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle) 393 tty->driver->unthrottle(tty); 394 } 395 396 static int hci_uart_register_dev(struct hci_uart *hu) 397 { 398 struct hci_dev *hdev; 399 400 BT_DBG(""); 401 402 /* Initialize and register HCI device */ 403 hdev = hci_alloc_dev(); 404 if (!hdev) { 405 BT_ERR("Can't allocate HCI device"); 406 return -ENOMEM; 407 } 408 409 hu->hdev = hdev; 410 411 hdev->type = HCI_UART; 412 hdev->driver_data = hu; 413 414 hdev->open = hci_uart_open; 415 hdev->close = hci_uart_close; 416 hdev->flush = hci_uart_flush; 417 hdev->send = hci_uart_send_frame; 418 hdev->destruct = hci_uart_destruct; 419 420 hdev->owner = THIS_MODULE; 421 422 if (reset) 423 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks); 424 425 if (hci_register_dev(hdev) < 0) { 426 BT_ERR("Can't register HCI device"); 427 hci_free_dev(hdev); 428 return -ENODEV; 429 } 430 431 return 0; 432 } 433 434 static int hci_uart_set_proto(struct hci_uart *hu, int id) 435 { 436 struct hci_uart_proto *p; 437 int err; 438 439 p = hci_uart_get_proto(id); 440 if (!p) 441 return -EPROTONOSUPPORT; 442 443 err = p->open(hu); 444 if (err) 445 return err; 446 447 hu->proto = p; 448 449 err = hci_uart_register_dev(hu); 450 if (err) { 451 p->close(hu); 452 return err; 453 } 454 455 return 0; 456 } 457 458 /* hci_uart_tty_ioctl() 459 * 460 * Process IOCTL system call for the tty device. 461 * 462 * Arguments: 463 * 464 * tty pointer to tty instance data 465 * file pointer to open file object for device 466 * cmd IOCTL command code 467 * arg argument for IOCTL call (cmd dependent) 468 * 469 * Return Value: Command dependent 470 */ 471 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file, 472 unsigned int cmd, unsigned long arg) 473 { 474 struct hci_uart *hu = (void *)tty->disc_data; 475 int err = 0; 476 477 BT_DBG(""); 478 479 /* Verify the status of the device */ 480 if (!hu) 481 return -EBADF; 482 483 switch (cmd) { 484 case HCIUARTSETPROTO: 485 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) { 486 err = hci_uart_set_proto(hu, arg); 487 if (err) { 488 clear_bit(HCI_UART_PROTO_SET, &hu->flags); 489 return err; 490 } 491 tty->low_latency = 1; 492 } else 493 return -EBUSY; 494 495 case HCIUARTGETPROTO: 496 if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) 497 return hu->proto->id; 498 return -EUNATCH; 499 500 default: 501 err = n_tty_ioctl(tty, file, cmd, arg); 502 break; 503 }; 504 505 return err; 506 } 507 508 /* 509 * We don't provide read/write/poll interface for user space. 510 */ 511 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, 512 unsigned char __user *buf, size_t nr) 513 { 514 return 0; 515 } 516 517 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, 518 const unsigned char *data, size_t count) 519 { 520 return 0; 521 } 522 523 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, 524 struct file *filp, poll_table *wait) 525 { 526 return 0; 527 } 528 529 static int __init hci_uart_init(void) 530 { 531 static struct tty_ldisc hci_uart_ldisc; 532 int err; 533 534 BT_INFO("HCI UART driver ver %s", VERSION); 535 536 /* Register the tty discipline */ 537 538 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc)); 539 hci_uart_ldisc.magic = TTY_LDISC_MAGIC; 540 hci_uart_ldisc.name = "n_hci"; 541 hci_uart_ldisc.open = hci_uart_tty_open; 542 hci_uart_ldisc.close = hci_uart_tty_close; 543 hci_uart_ldisc.read = hci_uart_tty_read; 544 hci_uart_ldisc.write = hci_uart_tty_write; 545 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl; 546 hci_uart_ldisc.poll = hci_uart_tty_poll; 547 hci_uart_ldisc.receive_room = hci_uart_tty_room; 548 hci_uart_ldisc.receive_buf = hci_uart_tty_receive; 549 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup; 550 hci_uart_ldisc.owner = THIS_MODULE; 551 552 if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) { 553 BT_ERR("HCI line discipline registration failed. (%d)", err); 554 return err; 555 } 556 557 #ifdef CONFIG_BT_HCIUART_H4 558 h4_init(); 559 #endif 560 #ifdef CONFIG_BT_HCIUART_BCSP 561 bcsp_init(); 562 #endif 563 564 return 0; 565 } 566 567 static void __exit hci_uart_exit(void) 568 { 569 int err; 570 571 #ifdef CONFIG_BT_HCIUART_H4 572 h4_deinit(); 573 #endif 574 #ifdef CONFIG_BT_HCIUART_BCSP 575 bcsp_deinit(); 576 #endif 577 578 /* Release tty registration of line discipline */ 579 if ((err = tty_unregister_ldisc(N_HCI))) 580 BT_ERR("Can't unregister HCI line discipline (%d)", err); 581 } 582 583 module_init(hci_uart_init); 584 module_exit(hci_uart_exit); 585 586 module_param(reset, bool, 0644); 587 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization"); 588 589 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>"); 590 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); 591 MODULE_VERSION(VERSION); 592 MODULE_LICENSE("GPL"); 593 MODULE_ALIAS_LDISC(N_HCI); 594