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