1 /* 2 RFCOMM implementation for Linux Bluetooth stack (BlueZ). 3 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> 4 Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License version 2 as 8 published by the Free Software Foundation; 9 10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 21 SOFTWARE IS DISCLAIMED. 22 */ 23 24 /* 25 * RFCOMM TTY. 26 * 27 * $Id: tty.c,v 1.24 2002/10/03 01:54:38 holtmann Exp $ 28 */ 29 30 #include <linux/module.h> 31 32 #include <linux/tty.h> 33 #include <linux/tty_driver.h> 34 #include <linux/tty_flip.h> 35 36 #include <linux/capability.h> 37 #include <linux/slab.h> 38 #include <linux/skbuff.h> 39 40 #include <net/bluetooth/bluetooth.h> 41 #include <net/bluetooth/hci_core.h> 42 #include <net/bluetooth/rfcomm.h> 43 44 #ifndef CONFIG_BT_RFCOMM_DEBUG 45 #undef BT_DBG 46 #define BT_DBG(D...) 47 #endif 48 49 #define RFCOMM_TTY_MAGIC 0x6d02 /* magic number for rfcomm struct */ 50 #define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV /* whole lotta rfcomm devices */ 51 #define RFCOMM_TTY_MAJOR 216 /* device node major id of the usb/bluetooth.c driver */ 52 #define RFCOMM_TTY_MINOR 0 53 54 static struct tty_driver *rfcomm_tty_driver; 55 56 struct rfcomm_dev { 57 struct list_head list; 58 atomic_t refcnt; 59 60 char name[12]; 61 int id; 62 unsigned long flags; 63 int opened; 64 int err; 65 66 bdaddr_t src; 67 bdaddr_t dst; 68 u8 channel; 69 70 uint modem_status; 71 72 struct rfcomm_dlc *dlc; 73 struct tty_struct *tty; 74 wait_queue_head_t wait; 75 struct tasklet_struct wakeup_task; 76 77 struct device *tty_dev; 78 79 atomic_t wmem_alloc; 80 }; 81 82 static LIST_HEAD(rfcomm_dev_list); 83 static DEFINE_RWLOCK(rfcomm_dev_lock); 84 85 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb); 86 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err); 87 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig); 88 89 static void rfcomm_tty_wakeup(unsigned long arg); 90 91 /* ---- Device functions ---- */ 92 static void rfcomm_dev_destruct(struct rfcomm_dev *dev) 93 { 94 struct rfcomm_dlc *dlc = dev->dlc; 95 96 BT_DBG("dev %p dlc %p", dev, dlc); 97 98 /* Refcount should only hit zero when called from rfcomm_dev_del() 99 which will have taken us off the list. Everything else are 100 refcounting bugs. */ 101 BUG_ON(!list_empty(&dev->list)); 102 103 rfcomm_dlc_lock(dlc); 104 /* Detach DLC if it's owned by this dev */ 105 if (dlc->owner == dev) 106 dlc->owner = NULL; 107 rfcomm_dlc_unlock(dlc); 108 109 rfcomm_dlc_put(dlc); 110 111 tty_unregister_device(rfcomm_tty_driver, dev->id); 112 113 kfree(dev); 114 115 /* It's safe to call module_put() here because socket still 116 holds reference to this module. */ 117 module_put(THIS_MODULE); 118 } 119 120 static inline void rfcomm_dev_hold(struct rfcomm_dev *dev) 121 { 122 atomic_inc(&dev->refcnt); 123 } 124 125 static inline void rfcomm_dev_put(struct rfcomm_dev *dev) 126 { 127 /* The reason this isn't actually a race, as you no 128 doubt have a little voice screaming at you in your 129 head, is that the refcount should never actually 130 reach zero unless the device has already been taken 131 off the list, in rfcomm_dev_del(). And if that's not 132 true, we'll hit the BUG() in rfcomm_dev_destruct() 133 anyway. */ 134 if (atomic_dec_and_test(&dev->refcnt)) 135 rfcomm_dev_destruct(dev); 136 } 137 138 static struct rfcomm_dev *__rfcomm_dev_get(int id) 139 { 140 struct rfcomm_dev *dev; 141 struct list_head *p; 142 143 list_for_each(p, &rfcomm_dev_list) { 144 dev = list_entry(p, struct rfcomm_dev, list); 145 if (dev->id == id) 146 return dev; 147 } 148 149 return NULL; 150 } 151 152 static inline struct rfcomm_dev *rfcomm_dev_get(int id) 153 { 154 struct rfcomm_dev *dev; 155 156 read_lock(&rfcomm_dev_lock); 157 158 dev = __rfcomm_dev_get(id); 159 160 if (dev) { 161 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags)) 162 dev = NULL; 163 else 164 rfcomm_dev_hold(dev); 165 } 166 167 read_unlock(&rfcomm_dev_lock); 168 169 return dev; 170 } 171 172 static struct device *rfcomm_get_device(struct rfcomm_dev *dev) 173 { 174 struct hci_dev *hdev; 175 struct hci_conn *conn; 176 177 hdev = hci_get_route(&dev->dst, &dev->src); 178 if (!hdev) 179 return NULL; 180 181 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst); 182 183 hci_dev_put(hdev); 184 185 return conn ? &conn->dev : NULL; 186 } 187 188 static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf) 189 { 190 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev); 191 bdaddr_t bdaddr; 192 baswap(&bdaddr, &dev->dst); 193 return sprintf(buf, "%s\n", batostr(&bdaddr)); 194 } 195 196 static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf) 197 { 198 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev); 199 return sprintf(buf, "%d\n", dev->channel); 200 } 201 202 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL); 203 static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL); 204 205 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc) 206 { 207 struct rfcomm_dev *dev; 208 struct list_head *head = &rfcomm_dev_list, *p; 209 int err = 0; 210 211 BT_DBG("id %d channel %d", req->dev_id, req->channel); 212 213 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL); 214 if (!dev) 215 return -ENOMEM; 216 217 write_lock_bh(&rfcomm_dev_lock); 218 219 if (req->dev_id < 0) { 220 dev->id = 0; 221 222 list_for_each(p, &rfcomm_dev_list) { 223 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id) 224 break; 225 226 dev->id++; 227 head = p; 228 } 229 } else { 230 dev->id = req->dev_id; 231 232 list_for_each(p, &rfcomm_dev_list) { 233 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list); 234 235 if (entry->id == dev->id) { 236 err = -EADDRINUSE; 237 goto out; 238 } 239 240 if (entry->id > dev->id - 1) 241 break; 242 243 head = p; 244 } 245 } 246 247 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) { 248 err = -ENFILE; 249 goto out; 250 } 251 252 sprintf(dev->name, "rfcomm%d", dev->id); 253 254 list_add(&dev->list, head); 255 atomic_set(&dev->refcnt, 1); 256 257 bacpy(&dev->src, &req->src); 258 bacpy(&dev->dst, &req->dst); 259 dev->channel = req->channel; 260 261 dev->flags = req->flags & 262 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC)); 263 264 init_waitqueue_head(&dev->wait); 265 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev); 266 267 rfcomm_dlc_lock(dlc); 268 dlc->data_ready = rfcomm_dev_data_ready; 269 dlc->state_change = rfcomm_dev_state_change; 270 dlc->modem_status = rfcomm_dev_modem_status; 271 272 dlc->owner = dev; 273 dev->dlc = dlc; 274 rfcomm_dlc_unlock(dlc); 275 276 /* It's safe to call __module_get() here because socket already 277 holds reference to this module. */ 278 __module_get(THIS_MODULE); 279 280 out: 281 write_unlock_bh(&rfcomm_dev_lock); 282 283 if (err < 0) { 284 kfree(dev); 285 return err; 286 } 287 288 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL); 289 290 if (IS_ERR(dev->tty_dev)) { 291 err = PTR_ERR(dev->tty_dev); 292 list_del(&dev->list); 293 kfree(dev); 294 return err; 295 } 296 297 dev_set_drvdata(dev->tty_dev, dev); 298 299 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0) 300 BT_ERR("Failed to create address attribute"); 301 302 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0) 303 BT_ERR("Failed to create channel attribute"); 304 305 return dev->id; 306 } 307 308 static void rfcomm_dev_del(struct rfcomm_dev *dev) 309 { 310 BT_DBG("dev %p", dev); 311 312 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags)) 313 BUG_ON(1); 314 else 315 set_bit(RFCOMM_TTY_RELEASED, &dev->flags); 316 317 write_lock_bh(&rfcomm_dev_lock); 318 list_del_init(&dev->list); 319 write_unlock_bh(&rfcomm_dev_lock); 320 321 rfcomm_dev_put(dev); 322 } 323 324 /* ---- Send buffer ---- */ 325 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc) 326 { 327 /* We can't let it be zero, because we don't get a callback 328 when tx_credits becomes nonzero, hence we'd never wake up */ 329 return dlc->mtu * (dlc->tx_credits?:1); 330 } 331 332 static void rfcomm_wfree(struct sk_buff *skb) 333 { 334 struct rfcomm_dev *dev = (void *) skb->sk; 335 atomic_sub(skb->truesize, &dev->wmem_alloc); 336 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags)) 337 tasklet_schedule(&dev->wakeup_task); 338 rfcomm_dev_put(dev); 339 } 340 341 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev) 342 { 343 rfcomm_dev_hold(dev); 344 atomic_add(skb->truesize, &dev->wmem_alloc); 345 skb->sk = (void *) dev; 346 skb->destructor = rfcomm_wfree; 347 } 348 349 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority) 350 { 351 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) { 352 struct sk_buff *skb = alloc_skb(size, priority); 353 if (skb) { 354 rfcomm_set_owner_w(skb, dev); 355 return skb; 356 } 357 } 358 return NULL; 359 } 360 361 /* ---- Device IOCTLs ---- */ 362 363 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP)) 364 365 static int rfcomm_create_dev(struct sock *sk, void __user *arg) 366 { 367 struct rfcomm_dev_req req; 368 struct rfcomm_dlc *dlc; 369 int id; 370 371 if (copy_from_user(&req, arg, sizeof(req))) 372 return -EFAULT; 373 374 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags); 375 376 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) 377 return -EPERM; 378 379 if (req.flags & (1 << RFCOMM_REUSE_DLC)) { 380 /* Socket must be connected */ 381 if (sk->sk_state != BT_CONNECTED) 382 return -EBADFD; 383 384 dlc = rfcomm_pi(sk)->dlc; 385 rfcomm_dlc_hold(dlc); 386 } else { 387 dlc = rfcomm_dlc_alloc(GFP_KERNEL); 388 if (!dlc) 389 return -ENOMEM; 390 } 391 392 id = rfcomm_dev_add(&req, dlc); 393 if (id < 0) { 394 rfcomm_dlc_put(dlc); 395 return id; 396 } 397 398 if (req.flags & (1 << RFCOMM_REUSE_DLC)) { 399 /* DLC is now used by device. 400 * Socket must be disconnected */ 401 sk->sk_state = BT_CLOSED; 402 } 403 404 return id; 405 } 406 407 static int rfcomm_release_dev(void __user *arg) 408 { 409 struct rfcomm_dev_req req; 410 struct rfcomm_dev *dev; 411 412 if (copy_from_user(&req, arg, sizeof(req))) 413 return -EFAULT; 414 415 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags); 416 417 if (!(dev = rfcomm_dev_get(req.dev_id))) 418 return -ENODEV; 419 420 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) { 421 rfcomm_dev_put(dev); 422 return -EPERM; 423 } 424 425 if (req.flags & (1 << RFCOMM_HANGUP_NOW)) 426 rfcomm_dlc_close(dev->dlc, 0); 427 428 /* Shut down TTY synchronously before freeing rfcomm_dev */ 429 if (dev->tty) 430 tty_vhangup(dev->tty); 431 432 if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) 433 rfcomm_dev_del(dev); 434 rfcomm_dev_put(dev); 435 return 0; 436 } 437 438 static int rfcomm_get_dev_list(void __user *arg) 439 { 440 struct rfcomm_dev_list_req *dl; 441 struct rfcomm_dev_info *di; 442 struct list_head *p; 443 int n = 0, size, err; 444 u16 dev_num; 445 446 BT_DBG(""); 447 448 if (get_user(dev_num, (u16 __user *) arg)) 449 return -EFAULT; 450 451 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di)) 452 return -EINVAL; 453 454 size = sizeof(*dl) + dev_num * sizeof(*di); 455 456 if (!(dl = kmalloc(size, GFP_KERNEL))) 457 return -ENOMEM; 458 459 di = dl->dev_info; 460 461 read_lock_bh(&rfcomm_dev_lock); 462 463 list_for_each(p, &rfcomm_dev_list) { 464 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list); 465 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags)) 466 continue; 467 (di + n)->id = dev->id; 468 (di + n)->flags = dev->flags; 469 (di + n)->state = dev->dlc->state; 470 (di + n)->channel = dev->channel; 471 bacpy(&(di + n)->src, &dev->src); 472 bacpy(&(di + n)->dst, &dev->dst); 473 if (++n >= dev_num) 474 break; 475 } 476 477 read_unlock_bh(&rfcomm_dev_lock); 478 479 dl->dev_num = n; 480 size = sizeof(*dl) + n * sizeof(*di); 481 482 err = copy_to_user(arg, dl, size); 483 kfree(dl); 484 485 return err ? -EFAULT : 0; 486 } 487 488 static int rfcomm_get_dev_info(void __user *arg) 489 { 490 struct rfcomm_dev *dev; 491 struct rfcomm_dev_info di; 492 int err = 0; 493 494 BT_DBG(""); 495 496 if (copy_from_user(&di, arg, sizeof(di))) 497 return -EFAULT; 498 499 if (!(dev = rfcomm_dev_get(di.id))) 500 return -ENODEV; 501 502 di.flags = dev->flags; 503 di.channel = dev->channel; 504 di.state = dev->dlc->state; 505 bacpy(&di.src, &dev->src); 506 bacpy(&di.dst, &dev->dst); 507 508 if (copy_to_user(arg, &di, sizeof(di))) 509 err = -EFAULT; 510 511 rfcomm_dev_put(dev); 512 return err; 513 } 514 515 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 516 { 517 BT_DBG("cmd %d arg %p", cmd, arg); 518 519 switch (cmd) { 520 case RFCOMMCREATEDEV: 521 return rfcomm_create_dev(sk, arg); 522 523 case RFCOMMRELEASEDEV: 524 return rfcomm_release_dev(arg); 525 526 case RFCOMMGETDEVLIST: 527 return rfcomm_get_dev_list(arg); 528 529 case RFCOMMGETDEVINFO: 530 return rfcomm_get_dev_info(arg); 531 } 532 533 return -EINVAL; 534 } 535 536 /* ---- DLC callbacks ---- */ 537 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb) 538 { 539 struct rfcomm_dev *dev = dlc->owner; 540 struct tty_struct *tty; 541 542 if (!dev || !(tty = dev->tty)) { 543 kfree_skb(skb); 544 return; 545 } 546 547 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len); 548 549 tty_insert_flip_string(tty, skb->data, skb->len); 550 tty_flip_buffer_push(tty); 551 552 kfree_skb(skb); 553 } 554 555 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err) 556 { 557 struct rfcomm_dev *dev = dlc->owner; 558 if (!dev) 559 return; 560 561 BT_DBG("dlc %p dev %p err %d", dlc, dev, err); 562 563 dev->err = err; 564 wake_up_interruptible(&dev->wait); 565 566 if (dlc->state == BT_CLOSED) { 567 if (!dev->tty) { 568 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) { 569 if (rfcomm_dev_get(dev->id) == NULL) 570 return; 571 572 rfcomm_dev_del(dev); 573 rfcomm_dev_put(dev); 574 } 575 } else 576 tty_hangup(dev->tty); 577 } 578 } 579 580 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig) 581 { 582 struct rfcomm_dev *dev = dlc->owner; 583 if (!dev) 584 return; 585 586 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig); 587 588 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) { 589 if (dev->tty && !C_CLOCAL(dev->tty)) 590 tty_hangup(dev->tty); 591 } 592 593 dev->modem_status = 594 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) | 595 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) | 596 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) | 597 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0); 598 } 599 600 /* ---- TTY functions ---- */ 601 static void rfcomm_tty_wakeup(unsigned long arg) 602 { 603 struct rfcomm_dev *dev = (void *) arg; 604 struct tty_struct *tty = dev->tty; 605 if (!tty) 606 return; 607 608 BT_DBG("dev %p tty %p", dev, tty); 609 610 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup) 611 (tty->ldisc.write_wakeup)(tty); 612 613 wake_up_interruptible(&tty->write_wait); 614 #ifdef SERIAL_HAVE_POLL_WAIT 615 wake_up_interruptible(&tty->poll_wait); 616 #endif 617 } 618 619 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp) 620 { 621 DECLARE_WAITQUEUE(wait, current); 622 struct rfcomm_dev *dev; 623 struct rfcomm_dlc *dlc; 624 int err, id; 625 626 id = tty->index; 627 628 BT_DBG("tty %p id %d", tty, id); 629 630 /* We don't leak this refcount. For reasons which are not entirely 631 clear, the TTY layer will call our ->close() method even if the 632 open fails. We decrease the refcount there, and decreasing it 633 here too would cause breakage. */ 634 dev = rfcomm_dev_get(id); 635 if (!dev) 636 return -ENODEV; 637 638 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst), dev->channel, dev->opened); 639 640 if (dev->opened++ != 0) 641 return 0; 642 643 dlc = dev->dlc; 644 645 /* Attach TTY and open DLC */ 646 647 rfcomm_dlc_lock(dlc); 648 tty->driver_data = dev; 649 dev->tty = tty; 650 rfcomm_dlc_unlock(dlc); 651 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags); 652 653 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel); 654 if (err < 0) 655 return err; 656 657 /* Wait for DLC to connect */ 658 add_wait_queue(&dev->wait, &wait); 659 while (1) { 660 set_current_state(TASK_INTERRUPTIBLE); 661 662 if (dlc->state == BT_CLOSED) { 663 err = -dev->err; 664 break; 665 } 666 667 if (dlc->state == BT_CONNECTED) 668 break; 669 670 if (signal_pending(current)) { 671 err = -EINTR; 672 break; 673 } 674 675 schedule(); 676 } 677 set_current_state(TASK_RUNNING); 678 remove_wait_queue(&dev->wait, &wait); 679 680 if (err == 0) 681 device_move(dev->tty_dev, rfcomm_get_device(dev)); 682 683 return err; 684 } 685 686 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp) 687 { 688 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 689 if (!dev) 690 return; 691 692 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, dev->opened); 693 694 if (--dev->opened == 0) { 695 if (dev->tty_dev->parent) 696 device_move(dev->tty_dev, NULL); 697 698 /* Close DLC and dettach TTY */ 699 rfcomm_dlc_close(dev->dlc, 0); 700 701 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags); 702 tasklet_kill(&dev->wakeup_task); 703 704 rfcomm_dlc_lock(dev->dlc); 705 tty->driver_data = NULL; 706 dev->tty = NULL; 707 rfcomm_dlc_unlock(dev->dlc); 708 } 709 710 rfcomm_dev_put(dev); 711 } 712 713 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count) 714 { 715 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 716 struct rfcomm_dlc *dlc = dev->dlc; 717 struct sk_buff *skb; 718 int err = 0, sent = 0, size; 719 720 BT_DBG("tty %p count %d", tty, count); 721 722 while (count) { 723 size = min_t(uint, count, dlc->mtu); 724 725 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC); 726 727 if (!skb) 728 break; 729 730 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE); 731 732 memcpy(skb_put(skb, size), buf + sent, size); 733 734 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) { 735 kfree_skb(skb); 736 break; 737 } 738 739 sent += size; 740 count -= size; 741 } 742 743 return sent ? sent : err; 744 } 745 746 static int rfcomm_tty_write_room(struct tty_struct *tty) 747 { 748 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 749 int room; 750 751 BT_DBG("tty %p", tty); 752 753 if (!dev || !dev->dlc) 754 return 0; 755 756 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc); 757 if (room < 0) 758 room = 0; 759 760 return room; 761 } 762 763 static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg) 764 { 765 BT_DBG("tty %p cmd 0x%02x", tty, cmd); 766 767 switch (cmd) { 768 case TCGETS: 769 BT_DBG("TCGETS is not supported"); 770 return -ENOIOCTLCMD; 771 772 case TCSETS: 773 BT_DBG("TCSETS is not supported"); 774 return -ENOIOCTLCMD; 775 776 case TIOCMIWAIT: 777 BT_DBG("TIOCMIWAIT"); 778 break; 779 780 case TIOCGICOUNT: 781 BT_DBG("TIOCGICOUNT"); 782 break; 783 784 case TIOCGSERIAL: 785 BT_ERR("TIOCGSERIAL is not supported"); 786 return -ENOIOCTLCMD; 787 788 case TIOCSSERIAL: 789 BT_ERR("TIOCSSERIAL is not supported"); 790 return -ENOIOCTLCMD; 791 792 case TIOCSERGSTRUCT: 793 BT_ERR("TIOCSERGSTRUCT is not supported"); 794 return -ENOIOCTLCMD; 795 796 case TIOCSERGETLSR: 797 BT_ERR("TIOCSERGETLSR is not supported"); 798 return -ENOIOCTLCMD; 799 800 case TIOCSERCONFIG: 801 BT_ERR("TIOCSERCONFIG is not supported"); 802 return -ENOIOCTLCMD; 803 804 default: 805 return -ENOIOCTLCMD; /* ioctls which we must ignore */ 806 807 } 808 809 return -ENOIOCTLCMD; 810 } 811 812 static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old) 813 { 814 struct ktermios *new = tty->termios; 815 int old_baud_rate = tty_termios_baud_rate(old); 816 int new_baud_rate = tty_termios_baud_rate(new); 817 818 u8 baud, data_bits, stop_bits, parity, x_on, x_off; 819 u16 changes = 0; 820 821 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 822 823 BT_DBG("tty %p termios %p", tty, old); 824 825 if (!dev || !dev->dlc || !dev->dlc->session) 826 return; 827 828 /* Handle turning off CRTSCTS */ 829 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS)) 830 BT_DBG("Turning off CRTSCTS unsupported"); 831 832 /* Parity on/off and when on, odd/even */ 833 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) || 834 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) { 835 changes |= RFCOMM_RPN_PM_PARITY; 836 BT_DBG("Parity change detected."); 837 } 838 839 /* Mark and space parity are not supported! */ 840 if (new->c_cflag & PARENB) { 841 if (new->c_cflag & PARODD) { 842 BT_DBG("Parity is ODD"); 843 parity = RFCOMM_RPN_PARITY_ODD; 844 } else { 845 BT_DBG("Parity is EVEN"); 846 parity = RFCOMM_RPN_PARITY_EVEN; 847 } 848 } else { 849 BT_DBG("Parity is OFF"); 850 parity = RFCOMM_RPN_PARITY_NONE; 851 } 852 853 /* Setting the x_on / x_off characters */ 854 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) { 855 BT_DBG("XOFF custom"); 856 x_on = new->c_cc[VSTOP]; 857 changes |= RFCOMM_RPN_PM_XON; 858 } else { 859 BT_DBG("XOFF default"); 860 x_on = RFCOMM_RPN_XON_CHAR; 861 } 862 863 if (old->c_cc[VSTART] != new->c_cc[VSTART]) { 864 BT_DBG("XON custom"); 865 x_off = new->c_cc[VSTART]; 866 changes |= RFCOMM_RPN_PM_XOFF; 867 } else { 868 BT_DBG("XON default"); 869 x_off = RFCOMM_RPN_XOFF_CHAR; 870 } 871 872 /* Handle setting of stop bits */ 873 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB)) 874 changes |= RFCOMM_RPN_PM_STOP; 875 876 /* POSIX does not support 1.5 stop bits and RFCOMM does not 877 * support 2 stop bits. So a request for 2 stop bits gets 878 * translated to 1.5 stop bits */ 879 if (new->c_cflag & CSTOPB) { 880 stop_bits = RFCOMM_RPN_STOP_15; 881 } else { 882 stop_bits = RFCOMM_RPN_STOP_1; 883 } 884 885 /* Handle number of data bits [5-8] */ 886 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE)) 887 changes |= RFCOMM_RPN_PM_DATA; 888 889 switch (new->c_cflag & CSIZE) { 890 case CS5: 891 data_bits = RFCOMM_RPN_DATA_5; 892 break; 893 case CS6: 894 data_bits = RFCOMM_RPN_DATA_6; 895 break; 896 case CS7: 897 data_bits = RFCOMM_RPN_DATA_7; 898 break; 899 case CS8: 900 data_bits = RFCOMM_RPN_DATA_8; 901 break; 902 default: 903 data_bits = RFCOMM_RPN_DATA_8; 904 break; 905 } 906 907 /* Handle baudrate settings */ 908 if (old_baud_rate != new_baud_rate) 909 changes |= RFCOMM_RPN_PM_BITRATE; 910 911 switch (new_baud_rate) { 912 case 2400: 913 baud = RFCOMM_RPN_BR_2400; 914 break; 915 case 4800: 916 baud = RFCOMM_RPN_BR_4800; 917 break; 918 case 7200: 919 baud = RFCOMM_RPN_BR_7200; 920 break; 921 case 9600: 922 baud = RFCOMM_RPN_BR_9600; 923 break; 924 case 19200: 925 baud = RFCOMM_RPN_BR_19200; 926 break; 927 case 38400: 928 baud = RFCOMM_RPN_BR_38400; 929 break; 930 case 57600: 931 baud = RFCOMM_RPN_BR_57600; 932 break; 933 case 115200: 934 baud = RFCOMM_RPN_BR_115200; 935 break; 936 case 230400: 937 baud = RFCOMM_RPN_BR_230400; 938 break; 939 default: 940 /* 9600 is standard accordinag to the RFCOMM specification */ 941 baud = RFCOMM_RPN_BR_9600; 942 break; 943 944 } 945 946 if (changes) 947 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud, 948 data_bits, stop_bits, parity, 949 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes); 950 951 return; 952 } 953 954 static void rfcomm_tty_throttle(struct tty_struct *tty) 955 { 956 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 957 958 BT_DBG("tty %p dev %p", tty, dev); 959 960 rfcomm_dlc_throttle(dev->dlc); 961 } 962 963 static void rfcomm_tty_unthrottle(struct tty_struct *tty) 964 { 965 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 966 967 BT_DBG("tty %p dev %p", tty, dev); 968 969 rfcomm_dlc_unthrottle(dev->dlc); 970 } 971 972 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty) 973 { 974 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 975 976 BT_DBG("tty %p dev %p", tty, dev); 977 978 if (!dev || !dev->dlc) 979 return 0; 980 981 if (!skb_queue_empty(&dev->dlc->tx_queue)) 982 return dev->dlc->mtu; 983 984 return 0; 985 } 986 987 static void rfcomm_tty_flush_buffer(struct tty_struct *tty) 988 { 989 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 990 991 BT_DBG("tty %p dev %p", tty, dev); 992 993 if (!dev || !dev->dlc) 994 return; 995 996 skb_queue_purge(&dev->dlc->tx_queue); 997 998 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup) 999 tty->ldisc.write_wakeup(tty); 1000 } 1001 1002 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch) 1003 { 1004 BT_DBG("tty %p ch %c", tty, ch); 1005 } 1006 1007 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout) 1008 { 1009 BT_DBG("tty %p timeout %d", tty, timeout); 1010 } 1011 1012 static void rfcomm_tty_hangup(struct tty_struct *tty) 1013 { 1014 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1015 1016 BT_DBG("tty %p dev %p", tty, dev); 1017 1018 if (!dev) 1019 return; 1020 1021 rfcomm_tty_flush_buffer(tty); 1022 1023 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) { 1024 if (rfcomm_dev_get(dev->id) == NULL) 1025 return; 1026 rfcomm_dev_del(dev); 1027 rfcomm_dev_put(dev); 1028 } 1029 } 1030 1031 static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused) 1032 { 1033 return 0; 1034 } 1035 1036 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp) 1037 { 1038 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1039 1040 BT_DBG("tty %p dev %p", tty, dev); 1041 1042 return dev->modem_status; 1043 } 1044 1045 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear) 1046 { 1047 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1048 struct rfcomm_dlc *dlc = dev->dlc; 1049 u8 v24_sig; 1050 1051 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear); 1052 1053 rfcomm_dlc_get_modem_status(dlc, &v24_sig); 1054 1055 if (set & TIOCM_DSR || set & TIOCM_DTR) 1056 v24_sig |= RFCOMM_V24_RTC; 1057 if (set & TIOCM_RTS || set & TIOCM_CTS) 1058 v24_sig |= RFCOMM_V24_RTR; 1059 if (set & TIOCM_RI) 1060 v24_sig |= RFCOMM_V24_IC; 1061 if (set & TIOCM_CD) 1062 v24_sig |= RFCOMM_V24_DV; 1063 1064 if (clear & TIOCM_DSR || clear & TIOCM_DTR) 1065 v24_sig &= ~RFCOMM_V24_RTC; 1066 if (clear & TIOCM_RTS || clear & TIOCM_CTS) 1067 v24_sig &= ~RFCOMM_V24_RTR; 1068 if (clear & TIOCM_RI) 1069 v24_sig &= ~RFCOMM_V24_IC; 1070 if (clear & TIOCM_CD) 1071 v24_sig &= ~RFCOMM_V24_DV; 1072 1073 rfcomm_dlc_set_modem_status(dlc, v24_sig); 1074 1075 return 0; 1076 } 1077 1078 /* ---- TTY structure ---- */ 1079 1080 static const struct tty_operations rfcomm_ops = { 1081 .open = rfcomm_tty_open, 1082 .close = rfcomm_tty_close, 1083 .write = rfcomm_tty_write, 1084 .write_room = rfcomm_tty_write_room, 1085 .chars_in_buffer = rfcomm_tty_chars_in_buffer, 1086 .flush_buffer = rfcomm_tty_flush_buffer, 1087 .ioctl = rfcomm_tty_ioctl, 1088 .throttle = rfcomm_tty_throttle, 1089 .unthrottle = rfcomm_tty_unthrottle, 1090 .set_termios = rfcomm_tty_set_termios, 1091 .send_xchar = rfcomm_tty_send_xchar, 1092 .hangup = rfcomm_tty_hangup, 1093 .wait_until_sent = rfcomm_tty_wait_until_sent, 1094 .read_proc = rfcomm_tty_read_proc, 1095 .tiocmget = rfcomm_tty_tiocmget, 1096 .tiocmset = rfcomm_tty_tiocmset, 1097 }; 1098 1099 int rfcomm_init_ttys(void) 1100 { 1101 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS); 1102 if (!rfcomm_tty_driver) 1103 return -1; 1104 1105 rfcomm_tty_driver->owner = THIS_MODULE; 1106 rfcomm_tty_driver->driver_name = "rfcomm"; 1107 rfcomm_tty_driver->name = "rfcomm"; 1108 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR; 1109 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR; 1110 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1111 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1112 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1113 rfcomm_tty_driver->init_termios = tty_std_termios; 1114 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1115 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops); 1116 1117 if (tty_register_driver(rfcomm_tty_driver)) { 1118 BT_ERR("Can't register RFCOMM TTY driver"); 1119 put_tty_driver(rfcomm_tty_driver); 1120 return -1; 1121 } 1122 1123 BT_INFO("RFCOMM TTY layer initialized"); 1124 1125 return 0; 1126 } 1127 1128 void rfcomm_cleanup_ttys(void) 1129 { 1130 tty_unregister_driver(rfcomm_tty_driver); 1131 put_tty_driver(rfcomm_tty_driver); 1132 } 1133