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 28 #include <linux/module.h> 29 30 #include <linux/tty.h> 31 #include <linux/tty_driver.h> 32 #include <linux/tty_flip.h> 33 34 #include <net/bluetooth/bluetooth.h> 35 #include <net/bluetooth/hci_core.h> 36 #include <net/bluetooth/rfcomm.h> 37 38 #define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV /* whole lotta rfcomm devices */ 39 #define RFCOMM_TTY_MAJOR 216 /* device node major id of the usb/bluetooth.c driver */ 40 #define RFCOMM_TTY_MINOR 0 41 42 static DEFINE_MUTEX(rfcomm_ioctl_mutex); 43 static struct tty_driver *rfcomm_tty_driver; 44 45 struct rfcomm_dev { 46 struct tty_port port; 47 struct list_head list; 48 49 char name[12]; 50 int id; 51 unsigned long flags; 52 int err; 53 54 unsigned long status; /* don't export to userspace */ 55 56 bdaddr_t src; 57 bdaddr_t dst; 58 u8 channel; 59 60 uint modem_status; 61 62 struct rfcomm_dlc *dlc; 63 64 struct device *tty_dev; 65 66 atomic_t wmem_alloc; 67 68 struct sk_buff_head pending; 69 }; 70 71 static LIST_HEAD(rfcomm_dev_list); 72 static DEFINE_MUTEX(rfcomm_dev_lock); 73 74 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb); 75 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err); 76 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig); 77 78 /* ---- Device functions ---- */ 79 80 static void rfcomm_dev_destruct(struct tty_port *port) 81 { 82 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port); 83 struct rfcomm_dlc *dlc = dev->dlc; 84 85 BT_DBG("dev %p dlc %p", dev, dlc); 86 87 rfcomm_dlc_lock(dlc); 88 /* Detach DLC if it's owned by this dev */ 89 if (dlc->owner == dev) 90 dlc->owner = NULL; 91 rfcomm_dlc_unlock(dlc); 92 93 rfcomm_dlc_put(dlc); 94 95 if (dev->tty_dev) 96 tty_unregister_device(rfcomm_tty_driver, dev->id); 97 98 mutex_lock(&rfcomm_dev_lock); 99 list_del(&dev->list); 100 mutex_unlock(&rfcomm_dev_lock); 101 102 kfree(dev); 103 104 /* It's safe to call module_put() here because socket still 105 holds reference to this module. */ 106 module_put(THIS_MODULE); 107 } 108 109 /* device-specific initialization: open the dlc */ 110 static int rfcomm_dev_activate(struct tty_port *port, struct tty_struct *tty) 111 { 112 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port); 113 int err; 114 115 err = rfcomm_dlc_open(dev->dlc, &dev->src, &dev->dst, dev->channel); 116 if (err) 117 set_bit(TTY_IO_ERROR, &tty->flags); 118 return err; 119 } 120 121 /* we block the open until the dlc->state becomes BT_CONNECTED */ 122 static int rfcomm_dev_carrier_raised(struct tty_port *port) 123 { 124 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port); 125 126 return (dev->dlc->state == BT_CONNECTED); 127 } 128 129 /* device-specific cleanup: close the dlc */ 130 static void rfcomm_dev_shutdown(struct tty_port *port) 131 { 132 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port); 133 134 if (dev->tty_dev->parent) 135 device_move(dev->tty_dev, NULL, DPM_ORDER_DEV_LAST); 136 137 /* close the dlc */ 138 rfcomm_dlc_close(dev->dlc, 0); 139 } 140 141 static const struct tty_port_operations rfcomm_port_ops = { 142 .destruct = rfcomm_dev_destruct, 143 .activate = rfcomm_dev_activate, 144 .shutdown = rfcomm_dev_shutdown, 145 .carrier_raised = rfcomm_dev_carrier_raised, 146 }; 147 148 static struct rfcomm_dev *__rfcomm_dev_lookup(int id) 149 { 150 struct rfcomm_dev *dev; 151 152 list_for_each_entry(dev, &rfcomm_dev_list, list) 153 if (dev->id == id) 154 return dev; 155 156 return NULL; 157 } 158 159 static struct rfcomm_dev *rfcomm_dev_get(int id) 160 { 161 struct rfcomm_dev *dev; 162 163 mutex_lock(&rfcomm_dev_lock); 164 165 dev = __rfcomm_dev_lookup(id); 166 167 if (dev && !tty_port_get(&dev->port)) 168 dev = NULL; 169 170 mutex_unlock(&rfcomm_dev_lock); 171 172 return dev; 173 } 174 175 static void rfcomm_reparent_device(struct rfcomm_dev *dev) 176 { 177 struct hci_dev *hdev; 178 struct hci_conn *conn; 179 180 hdev = hci_get_route(&dev->dst, &dev->src, BDADDR_BREDR); 181 if (!hdev) 182 return; 183 184 /* The lookup results are unsafe to access without the 185 * hci device lock (FIXME: why is this not documented?) 186 */ 187 hci_dev_lock(hdev); 188 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst); 189 190 /* Just because the acl link is in the hash table is no 191 * guarantee the sysfs device has been added ... 192 */ 193 if (conn && device_is_registered(&conn->dev)) 194 device_move(dev->tty_dev, &conn->dev, DPM_ORDER_DEV_AFTER_PARENT); 195 196 hci_dev_unlock(hdev); 197 hci_dev_put(hdev); 198 } 199 200 static ssize_t address_show(struct device *tty_dev, 201 struct device_attribute *attr, char *buf) 202 { 203 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev); 204 return sprintf(buf, "%pMR\n", &dev->dst); 205 } 206 207 static ssize_t channel_show(struct device *tty_dev, 208 struct device_attribute *attr, char *buf) 209 { 210 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev); 211 return sprintf(buf, "%d\n", dev->channel); 212 } 213 214 static DEVICE_ATTR_RO(address); 215 static DEVICE_ATTR_RO(channel); 216 217 static struct rfcomm_dev *__rfcomm_dev_add(struct rfcomm_dev_req *req, 218 struct rfcomm_dlc *dlc) 219 { 220 struct rfcomm_dev *dev, *entry; 221 struct list_head *head = &rfcomm_dev_list; 222 int err = 0; 223 224 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL); 225 if (!dev) 226 return ERR_PTR(-ENOMEM); 227 228 mutex_lock(&rfcomm_dev_lock); 229 230 if (req->dev_id < 0) { 231 dev->id = 0; 232 233 list_for_each_entry(entry, &rfcomm_dev_list, list) { 234 if (entry->id != dev->id) 235 break; 236 237 dev->id++; 238 head = &entry->list; 239 } 240 } else { 241 dev->id = req->dev_id; 242 243 list_for_each_entry(entry, &rfcomm_dev_list, list) { 244 if (entry->id == dev->id) { 245 err = -EADDRINUSE; 246 goto out; 247 } 248 249 if (entry->id > dev->id - 1) 250 break; 251 252 head = &entry->list; 253 } 254 } 255 256 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) { 257 err = -ENFILE; 258 goto out; 259 } 260 261 sprintf(dev->name, "rfcomm%d", dev->id); 262 263 list_add(&dev->list, head); 264 265 bacpy(&dev->src, &req->src); 266 bacpy(&dev->dst, &req->dst); 267 dev->channel = req->channel; 268 269 dev->flags = req->flags & 270 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC)); 271 272 tty_port_init(&dev->port); 273 dev->port.ops = &rfcomm_port_ops; 274 275 skb_queue_head_init(&dev->pending); 276 277 rfcomm_dlc_lock(dlc); 278 279 if (req->flags & (1 << RFCOMM_REUSE_DLC)) { 280 struct sock *sk = dlc->owner; 281 struct sk_buff *skb; 282 283 BUG_ON(!sk); 284 285 rfcomm_dlc_throttle(dlc); 286 287 while ((skb = skb_dequeue(&sk->sk_receive_queue))) { 288 skb_orphan(skb); 289 skb_queue_tail(&dev->pending, skb); 290 atomic_sub(skb->len, &sk->sk_rmem_alloc); 291 } 292 } 293 294 dlc->data_ready = rfcomm_dev_data_ready; 295 dlc->state_change = rfcomm_dev_state_change; 296 dlc->modem_status = rfcomm_dev_modem_status; 297 298 dlc->owner = dev; 299 dev->dlc = dlc; 300 301 rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig); 302 303 rfcomm_dlc_unlock(dlc); 304 305 /* It's safe to call __module_get() here because socket already 306 holds reference to this module. */ 307 __module_get(THIS_MODULE); 308 309 mutex_unlock(&rfcomm_dev_lock); 310 return dev; 311 312 out: 313 mutex_unlock(&rfcomm_dev_lock); 314 kfree(dev); 315 return ERR_PTR(err); 316 } 317 318 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc) 319 { 320 struct rfcomm_dev *dev; 321 struct device *tty; 322 323 BT_DBG("id %d channel %d", req->dev_id, req->channel); 324 325 dev = __rfcomm_dev_add(req, dlc); 326 if (IS_ERR(dev)) { 327 rfcomm_dlc_put(dlc); 328 return PTR_ERR(dev); 329 } 330 331 tty = tty_port_register_device(&dev->port, rfcomm_tty_driver, 332 dev->id, NULL); 333 if (IS_ERR(tty)) { 334 tty_port_put(&dev->port); 335 return PTR_ERR(tty); 336 } 337 338 dev->tty_dev = tty; 339 rfcomm_reparent_device(dev); 340 dev_set_drvdata(dev->tty_dev, dev); 341 342 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0) 343 BT_ERR("Failed to create address attribute"); 344 345 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0) 346 BT_ERR("Failed to create channel attribute"); 347 348 return dev->id; 349 } 350 351 /* ---- Send buffer ---- */ 352 static inline unsigned int rfcomm_room(struct rfcomm_dev *dev) 353 { 354 struct rfcomm_dlc *dlc = dev->dlc; 355 356 /* Limit the outstanding number of packets not yet sent to 40 */ 357 int pending = 40 - atomic_read(&dev->wmem_alloc); 358 359 return max(0, pending) * dlc->mtu; 360 } 361 362 static void rfcomm_wfree(struct sk_buff *skb) 363 { 364 struct rfcomm_dev *dev = (void *) skb->sk; 365 atomic_dec(&dev->wmem_alloc); 366 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags)) 367 tty_port_tty_wakeup(&dev->port); 368 tty_port_put(&dev->port); 369 } 370 371 static void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev) 372 { 373 tty_port_get(&dev->port); 374 atomic_inc(&dev->wmem_alloc); 375 skb->sk = (void *) dev; 376 skb->destructor = rfcomm_wfree; 377 } 378 379 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority) 380 { 381 struct sk_buff *skb = alloc_skb(size, priority); 382 if (skb) 383 rfcomm_set_owner_w(skb, dev); 384 return skb; 385 } 386 387 /* ---- Device IOCTLs ---- */ 388 389 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP)) 390 391 static int __rfcomm_create_dev(struct sock *sk, void __user *arg) 392 { 393 struct rfcomm_dev_req req; 394 struct rfcomm_dlc *dlc; 395 int id; 396 397 if (copy_from_user(&req, arg, sizeof(req))) 398 return -EFAULT; 399 400 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags); 401 402 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) 403 return -EPERM; 404 405 if (req.flags & (1 << RFCOMM_REUSE_DLC)) { 406 /* Socket must be connected */ 407 if (sk->sk_state != BT_CONNECTED) 408 return -EBADFD; 409 410 dlc = rfcomm_pi(sk)->dlc; 411 rfcomm_dlc_hold(dlc); 412 } else { 413 /* Validate the channel is unused */ 414 dlc = rfcomm_dlc_exists(&req.src, &req.dst, req.channel); 415 if (IS_ERR(dlc)) 416 return PTR_ERR(dlc); 417 if (dlc) 418 return -EBUSY; 419 dlc = rfcomm_dlc_alloc(GFP_KERNEL); 420 if (!dlc) 421 return -ENOMEM; 422 } 423 424 id = rfcomm_dev_add(&req, dlc); 425 if (id < 0) 426 return id; 427 428 if (req.flags & (1 << RFCOMM_REUSE_DLC)) { 429 /* DLC is now used by device. 430 * Socket must be disconnected */ 431 sk->sk_state = BT_CLOSED; 432 } 433 434 return id; 435 } 436 437 static int __rfcomm_release_dev(void __user *arg) 438 { 439 struct rfcomm_dev_req req; 440 struct rfcomm_dev *dev; 441 struct tty_struct *tty; 442 443 if (copy_from_user(&req, arg, sizeof(req))) 444 return -EFAULT; 445 446 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags); 447 448 dev = rfcomm_dev_get(req.dev_id); 449 if (!dev) 450 return -ENODEV; 451 452 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) { 453 tty_port_put(&dev->port); 454 return -EPERM; 455 } 456 457 /* only release once */ 458 if (test_and_set_bit(RFCOMM_DEV_RELEASED, &dev->status)) { 459 tty_port_put(&dev->port); 460 return -EALREADY; 461 } 462 463 if (req.flags & (1 << RFCOMM_HANGUP_NOW)) 464 rfcomm_dlc_close(dev->dlc, 0); 465 466 /* Shut down TTY synchronously before freeing rfcomm_dev */ 467 tty = tty_port_tty_get(&dev->port); 468 if (tty) { 469 tty_vhangup(tty); 470 tty_kref_put(tty); 471 } 472 473 if (!test_bit(RFCOMM_TTY_OWNED, &dev->status)) 474 tty_port_put(&dev->port); 475 476 tty_port_put(&dev->port); 477 return 0; 478 } 479 480 static int rfcomm_create_dev(struct sock *sk, void __user *arg) 481 { 482 int ret; 483 484 mutex_lock(&rfcomm_ioctl_mutex); 485 ret = __rfcomm_create_dev(sk, arg); 486 mutex_unlock(&rfcomm_ioctl_mutex); 487 488 return ret; 489 } 490 491 static int rfcomm_release_dev(void __user *arg) 492 { 493 int ret; 494 495 mutex_lock(&rfcomm_ioctl_mutex); 496 ret = __rfcomm_release_dev(arg); 497 mutex_unlock(&rfcomm_ioctl_mutex); 498 499 return ret; 500 } 501 502 static int rfcomm_get_dev_list(void __user *arg) 503 { 504 struct rfcomm_dev *dev; 505 struct rfcomm_dev_list_req *dl; 506 struct rfcomm_dev_info *di; 507 int n = 0, size, err; 508 u16 dev_num; 509 510 BT_DBG(""); 511 512 if (get_user(dev_num, (u16 __user *) arg)) 513 return -EFAULT; 514 515 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di)) 516 return -EINVAL; 517 518 size = sizeof(*dl) + dev_num * sizeof(*di); 519 520 dl = kzalloc(size, GFP_KERNEL); 521 if (!dl) 522 return -ENOMEM; 523 524 di = dl->dev_info; 525 526 mutex_lock(&rfcomm_dev_lock); 527 528 list_for_each_entry(dev, &rfcomm_dev_list, list) { 529 if (!tty_port_get(&dev->port)) 530 continue; 531 (di + n)->id = dev->id; 532 (di + n)->flags = dev->flags; 533 (di + n)->state = dev->dlc->state; 534 (di + n)->channel = dev->channel; 535 bacpy(&(di + n)->src, &dev->src); 536 bacpy(&(di + n)->dst, &dev->dst); 537 tty_port_put(&dev->port); 538 if (++n >= dev_num) 539 break; 540 } 541 542 mutex_unlock(&rfcomm_dev_lock); 543 544 dl->dev_num = n; 545 size = sizeof(*dl) + n * sizeof(*di); 546 547 err = copy_to_user(arg, dl, size); 548 kfree(dl); 549 550 return err ? -EFAULT : 0; 551 } 552 553 static int rfcomm_get_dev_info(void __user *arg) 554 { 555 struct rfcomm_dev *dev; 556 struct rfcomm_dev_info di; 557 int err = 0; 558 559 BT_DBG(""); 560 561 if (copy_from_user(&di, arg, sizeof(di))) 562 return -EFAULT; 563 564 dev = rfcomm_dev_get(di.id); 565 if (!dev) 566 return -ENODEV; 567 568 di.flags = dev->flags; 569 di.channel = dev->channel; 570 di.state = dev->dlc->state; 571 bacpy(&di.src, &dev->src); 572 bacpy(&di.dst, &dev->dst); 573 574 if (copy_to_user(arg, &di, sizeof(di))) 575 err = -EFAULT; 576 577 tty_port_put(&dev->port); 578 return err; 579 } 580 581 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 582 { 583 BT_DBG("cmd %d arg %p", cmd, arg); 584 585 switch (cmd) { 586 case RFCOMMCREATEDEV: 587 return rfcomm_create_dev(sk, arg); 588 589 case RFCOMMRELEASEDEV: 590 return rfcomm_release_dev(arg); 591 592 case RFCOMMGETDEVLIST: 593 return rfcomm_get_dev_list(arg); 594 595 case RFCOMMGETDEVINFO: 596 return rfcomm_get_dev_info(arg); 597 } 598 599 return -EINVAL; 600 } 601 602 /* ---- DLC callbacks ---- */ 603 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb) 604 { 605 struct rfcomm_dev *dev = dlc->owner; 606 607 if (!dev) { 608 kfree_skb(skb); 609 return; 610 } 611 612 if (!skb_queue_empty(&dev->pending)) { 613 skb_queue_tail(&dev->pending, skb); 614 return; 615 } 616 617 BT_DBG("dlc %p len %d", dlc, skb->len); 618 619 tty_insert_flip_string(&dev->port, skb->data, skb->len); 620 tty_flip_buffer_push(&dev->port); 621 622 kfree_skb(skb); 623 } 624 625 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err) 626 { 627 struct rfcomm_dev *dev = dlc->owner; 628 if (!dev) 629 return; 630 631 BT_DBG("dlc %p dev %p err %d", dlc, dev, err); 632 633 dev->err = err; 634 if (dlc->state == BT_CONNECTED) { 635 rfcomm_reparent_device(dev); 636 637 wake_up_interruptible(&dev->port.open_wait); 638 } else if (dlc->state == BT_CLOSED) 639 tty_port_tty_hangup(&dev->port, false); 640 } 641 642 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig) 643 { 644 struct rfcomm_dev *dev = dlc->owner; 645 if (!dev) 646 return; 647 648 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig); 649 650 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) 651 tty_port_tty_hangup(&dev->port, true); 652 653 dev->modem_status = 654 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) | 655 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) | 656 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) | 657 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0); 658 } 659 660 /* ---- TTY functions ---- */ 661 static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev) 662 { 663 struct sk_buff *skb; 664 int inserted = 0; 665 666 BT_DBG("dev %p", dev); 667 668 rfcomm_dlc_lock(dev->dlc); 669 670 while ((skb = skb_dequeue(&dev->pending))) { 671 inserted += tty_insert_flip_string(&dev->port, skb->data, 672 skb->len); 673 kfree_skb(skb); 674 } 675 676 rfcomm_dlc_unlock(dev->dlc); 677 678 if (inserted > 0) 679 tty_flip_buffer_push(&dev->port); 680 } 681 682 /* do the reverse of install, clearing the tty fields and releasing the 683 * reference to tty_port 684 */ 685 static void rfcomm_tty_cleanup(struct tty_struct *tty) 686 { 687 struct rfcomm_dev *dev = tty->driver_data; 688 689 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags); 690 691 rfcomm_dlc_lock(dev->dlc); 692 tty->driver_data = NULL; 693 rfcomm_dlc_unlock(dev->dlc); 694 695 /* 696 * purge the dlc->tx_queue to avoid circular dependencies 697 * between dev and dlc 698 */ 699 skb_queue_purge(&dev->dlc->tx_queue); 700 701 tty_port_put(&dev->port); 702 } 703 704 /* we acquire the tty_port reference since it's here the tty is first used 705 * by setting the termios. We also populate the driver_data field and install 706 * the tty port 707 */ 708 static int rfcomm_tty_install(struct tty_driver *driver, struct tty_struct *tty) 709 { 710 struct rfcomm_dev *dev; 711 struct rfcomm_dlc *dlc; 712 int err; 713 714 dev = rfcomm_dev_get(tty->index); 715 if (!dev) 716 return -ENODEV; 717 718 dlc = dev->dlc; 719 720 /* Attach TTY and open DLC */ 721 rfcomm_dlc_lock(dlc); 722 tty->driver_data = dev; 723 rfcomm_dlc_unlock(dlc); 724 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags); 725 726 /* install the tty_port */ 727 err = tty_port_install(&dev->port, driver, tty); 728 if (err) { 729 rfcomm_tty_cleanup(tty); 730 return err; 731 } 732 733 /* take over the tty_port reference if the port was created with the 734 * flag RFCOMM_RELEASE_ONHUP. This will force the release of the port 735 * when the last process closes the tty. The behaviour is expected by 736 * userspace. 737 */ 738 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) { 739 set_bit(RFCOMM_TTY_OWNED, &dev->status); 740 tty_port_put(&dev->port); 741 } 742 743 return 0; 744 } 745 746 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp) 747 { 748 struct rfcomm_dev *dev = tty->driver_data; 749 int err; 750 751 BT_DBG("tty %p id %d", tty, tty->index); 752 753 BT_DBG("dev %p dst %pMR channel %d opened %d", dev, &dev->dst, 754 dev->channel, dev->port.count); 755 756 err = tty_port_open(&dev->port, tty, filp); 757 if (err) 758 return err; 759 760 /* 761 * FIXME: rfcomm should use proper flow control for 762 * received data. This hack will be unnecessary and can 763 * be removed when that's implemented 764 */ 765 rfcomm_tty_copy_pending(dev); 766 767 rfcomm_dlc_unthrottle(dev->dlc); 768 769 return 0; 770 } 771 772 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp) 773 { 774 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 775 776 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, 777 dev->port.count); 778 779 tty_port_close(&dev->port, tty, filp); 780 } 781 782 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count) 783 { 784 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 785 struct rfcomm_dlc *dlc = dev->dlc; 786 struct sk_buff *skb; 787 int sent = 0, size; 788 789 BT_DBG("tty %p count %d", tty, count); 790 791 while (count) { 792 size = min_t(uint, count, dlc->mtu); 793 794 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC); 795 if (!skb) 796 break; 797 798 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE); 799 800 skb_put_data(skb, buf + sent, size); 801 802 rfcomm_dlc_send_noerror(dlc, skb); 803 804 sent += size; 805 count -= size; 806 } 807 808 return sent; 809 } 810 811 static unsigned int rfcomm_tty_write_room(struct tty_struct *tty) 812 { 813 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 814 int room = 0; 815 816 if (dev && dev->dlc) 817 room = rfcomm_room(dev); 818 819 BT_DBG("tty %p room %d", tty, room); 820 821 return room; 822 } 823 824 static int rfcomm_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg) 825 { 826 BT_DBG("tty %p cmd 0x%02x", tty, cmd); 827 828 switch (cmd) { 829 case TCGETS: 830 BT_DBG("TCGETS is not supported"); 831 return -ENOIOCTLCMD; 832 833 case TCSETS: 834 BT_DBG("TCSETS is not supported"); 835 return -ENOIOCTLCMD; 836 837 case TIOCMIWAIT: 838 BT_DBG("TIOCMIWAIT"); 839 break; 840 841 case TIOCSERGETLSR: 842 BT_ERR("TIOCSERGETLSR is not supported"); 843 return -ENOIOCTLCMD; 844 845 case TIOCSERCONFIG: 846 BT_ERR("TIOCSERCONFIG is not supported"); 847 return -ENOIOCTLCMD; 848 849 default: 850 return -ENOIOCTLCMD; /* ioctls which we must ignore */ 851 852 } 853 854 return -ENOIOCTLCMD; 855 } 856 857 static void rfcomm_tty_set_termios(struct tty_struct *tty, 858 const struct ktermios *old) 859 { 860 struct ktermios *new = &tty->termios; 861 int old_baud_rate = tty_termios_baud_rate(old); 862 int new_baud_rate = tty_termios_baud_rate(new); 863 864 u8 baud, data_bits, stop_bits, parity, x_on, x_off; 865 u16 changes = 0; 866 867 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 868 869 BT_DBG("tty %p termios %p", tty, old); 870 871 if (!dev || !dev->dlc || !dev->dlc->session) 872 return; 873 874 /* Handle turning off CRTSCTS */ 875 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS)) 876 BT_DBG("Turning off CRTSCTS unsupported"); 877 878 /* Parity on/off and when on, odd/even */ 879 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) || 880 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD))) { 881 changes |= RFCOMM_RPN_PM_PARITY; 882 BT_DBG("Parity change detected."); 883 } 884 885 /* Mark and space parity are not supported! */ 886 if (new->c_cflag & PARENB) { 887 if (new->c_cflag & PARODD) { 888 BT_DBG("Parity is ODD"); 889 parity = RFCOMM_RPN_PARITY_ODD; 890 } else { 891 BT_DBG("Parity is EVEN"); 892 parity = RFCOMM_RPN_PARITY_EVEN; 893 } 894 } else { 895 BT_DBG("Parity is OFF"); 896 parity = RFCOMM_RPN_PARITY_NONE; 897 } 898 899 /* Setting the x_on / x_off characters */ 900 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) { 901 BT_DBG("XOFF custom"); 902 x_on = new->c_cc[VSTOP]; 903 changes |= RFCOMM_RPN_PM_XON; 904 } else { 905 BT_DBG("XOFF default"); 906 x_on = RFCOMM_RPN_XON_CHAR; 907 } 908 909 if (old->c_cc[VSTART] != new->c_cc[VSTART]) { 910 BT_DBG("XON custom"); 911 x_off = new->c_cc[VSTART]; 912 changes |= RFCOMM_RPN_PM_XOFF; 913 } else { 914 BT_DBG("XON default"); 915 x_off = RFCOMM_RPN_XOFF_CHAR; 916 } 917 918 /* Handle setting of stop bits */ 919 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB)) 920 changes |= RFCOMM_RPN_PM_STOP; 921 922 /* POSIX does not support 1.5 stop bits and RFCOMM does not 923 * support 2 stop bits. So a request for 2 stop bits gets 924 * translated to 1.5 stop bits */ 925 if (new->c_cflag & CSTOPB) 926 stop_bits = RFCOMM_RPN_STOP_15; 927 else 928 stop_bits = RFCOMM_RPN_STOP_1; 929 930 /* Handle number of data bits [5-8] */ 931 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE)) 932 changes |= RFCOMM_RPN_PM_DATA; 933 934 switch (new->c_cflag & CSIZE) { 935 case CS5: 936 data_bits = RFCOMM_RPN_DATA_5; 937 break; 938 case CS6: 939 data_bits = RFCOMM_RPN_DATA_6; 940 break; 941 case CS7: 942 data_bits = RFCOMM_RPN_DATA_7; 943 break; 944 case CS8: 945 data_bits = RFCOMM_RPN_DATA_8; 946 break; 947 default: 948 data_bits = RFCOMM_RPN_DATA_8; 949 break; 950 } 951 952 /* Handle baudrate settings */ 953 if (old_baud_rate != new_baud_rate) 954 changes |= RFCOMM_RPN_PM_BITRATE; 955 956 switch (new_baud_rate) { 957 case 2400: 958 baud = RFCOMM_RPN_BR_2400; 959 break; 960 case 4800: 961 baud = RFCOMM_RPN_BR_4800; 962 break; 963 case 7200: 964 baud = RFCOMM_RPN_BR_7200; 965 break; 966 case 9600: 967 baud = RFCOMM_RPN_BR_9600; 968 break; 969 case 19200: 970 baud = RFCOMM_RPN_BR_19200; 971 break; 972 case 38400: 973 baud = RFCOMM_RPN_BR_38400; 974 break; 975 case 57600: 976 baud = RFCOMM_RPN_BR_57600; 977 break; 978 case 115200: 979 baud = RFCOMM_RPN_BR_115200; 980 break; 981 case 230400: 982 baud = RFCOMM_RPN_BR_230400; 983 break; 984 default: 985 /* 9600 is standard accordinag to the RFCOMM specification */ 986 baud = RFCOMM_RPN_BR_9600; 987 break; 988 989 } 990 991 if (changes) 992 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud, 993 data_bits, stop_bits, parity, 994 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes); 995 } 996 997 static void rfcomm_tty_throttle(struct tty_struct *tty) 998 { 999 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1000 1001 BT_DBG("tty %p dev %p", tty, dev); 1002 1003 rfcomm_dlc_throttle(dev->dlc); 1004 } 1005 1006 static void rfcomm_tty_unthrottle(struct tty_struct *tty) 1007 { 1008 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1009 1010 BT_DBG("tty %p dev %p", tty, dev); 1011 1012 rfcomm_dlc_unthrottle(dev->dlc); 1013 } 1014 1015 static unsigned int rfcomm_tty_chars_in_buffer(struct tty_struct *tty) 1016 { 1017 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1018 1019 BT_DBG("tty %p dev %p", tty, dev); 1020 1021 if (!dev || !dev->dlc) 1022 return 0; 1023 1024 if (!skb_queue_empty(&dev->dlc->tx_queue)) 1025 return dev->dlc->mtu; 1026 1027 return 0; 1028 } 1029 1030 static void rfcomm_tty_flush_buffer(struct tty_struct *tty) 1031 { 1032 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1033 1034 BT_DBG("tty %p dev %p", tty, dev); 1035 1036 if (!dev || !dev->dlc) 1037 return; 1038 1039 skb_queue_purge(&dev->dlc->tx_queue); 1040 tty_wakeup(tty); 1041 } 1042 1043 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch) 1044 { 1045 BT_DBG("tty %p ch %c", tty, ch); 1046 } 1047 1048 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout) 1049 { 1050 BT_DBG("tty %p timeout %d", tty, timeout); 1051 } 1052 1053 static void rfcomm_tty_hangup(struct tty_struct *tty) 1054 { 1055 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1056 1057 BT_DBG("tty %p dev %p", tty, dev); 1058 1059 tty_port_hangup(&dev->port); 1060 } 1061 1062 static int rfcomm_tty_tiocmget(struct tty_struct *tty) 1063 { 1064 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1065 1066 BT_DBG("tty %p dev %p", tty, dev); 1067 1068 return dev->modem_status; 1069 } 1070 1071 static int rfcomm_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear) 1072 { 1073 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data; 1074 struct rfcomm_dlc *dlc = dev->dlc; 1075 u8 v24_sig; 1076 1077 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear); 1078 1079 rfcomm_dlc_get_modem_status(dlc, &v24_sig); 1080 1081 if (set & TIOCM_DSR || set & TIOCM_DTR) 1082 v24_sig |= RFCOMM_V24_RTC; 1083 if (set & TIOCM_RTS || set & TIOCM_CTS) 1084 v24_sig |= RFCOMM_V24_RTR; 1085 if (set & TIOCM_RI) 1086 v24_sig |= RFCOMM_V24_IC; 1087 if (set & TIOCM_CD) 1088 v24_sig |= RFCOMM_V24_DV; 1089 1090 if (clear & TIOCM_DSR || clear & TIOCM_DTR) 1091 v24_sig &= ~RFCOMM_V24_RTC; 1092 if (clear & TIOCM_RTS || clear & TIOCM_CTS) 1093 v24_sig &= ~RFCOMM_V24_RTR; 1094 if (clear & TIOCM_RI) 1095 v24_sig &= ~RFCOMM_V24_IC; 1096 if (clear & TIOCM_CD) 1097 v24_sig &= ~RFCOMM_V24_DV; 1098 1099 rfcomm_dlc_set_modem_status(dlc, v24_sig); 1100 1101 return 0; 1102 } 1103 1104 /* ---- TTY structure ---- */ 1105 1106 static const struct tty_operations rfcomm_ops = { 1107 .open = rfcomm_tty_open, 1108 .close = rfcomm_tty_close, 1109 .write = rfcomm_tty_write, 1110 .write_room = rfcomm_tty_write_room, 1111 .chars_in_buffer = rfcomm_tty_chars_in_buffer, 1112 .flush_buffer = rfcomm_tty_flush_buffer, 1113 .ioctl = rfcomm_tty_ioctl, 1114 .throttle = rfcomm_tty_throttle, 1115 .unthrottle = rfcomm_tty_unthrottle, 1116 .set_termios = rfcomm_tty_set_termios, 1117 .send_xchar = rfcomm_tty_send_xchar, 1118 .hangup = rfcomm_tty_hangup, 1119 .wait_until_sent = rfcomm_tty_wait_until_sent, 1120 .tiocmget = rfcomm_tty_tiocmget, 1121 .tiocmset = rfcomm_tty_tiocmset, 1122 .install = rfcomm_tty_install, 1123 .cleanup = rfcomm_tty_cleanup, 1124 }; 1125 1126 int __init rfcomm_init_ttys(void) 1127 { 1128 int error; 1129 1130 rfcomm_tty_driver = tty_alloc_driver(RFCOMM_TTY_PORTS, 1131 TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 1132 if (IS_ERR(rfcomm_tty_driver)) 1133 return PTR_ERR(rfcomm_tty_driver); 1134 1135 rfcomm_tty_driver->driver_name = "rfcomm"; 1136 rfcomm_tty_driver->name = "rfcomm"; 1137 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR; 1138 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR; 1139 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1140 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1141 rfcomm_tty_driver->init_termios = tty_std_termios; 1142 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL; 1143 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON; 1144 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops); 1145 1146 error = tty_register_driver(rfcomm_tty_driver); 1147 if (error) { 1148 BT_ERR("Can't register RFCOMM TTY driver"); 1149 tty_driver_kref_put(rfcomm_tty_driver); 1150 return error; 1151 } 1152 1153 BT_INFO("RFCOMM TTY layer initialized"); 1154 1155 return 0; 1156 } 1157 1158 void rfcomm_cleanup_ttys(void) 1159 { 1160 tty_unregister_driver(rfcomm_tty_driver); 1161 tty_driver_kref_put(rfcomm_tty_driver); 1162 } 1163