net/bluetooth/rfcomm/tty.c

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

DEFINITIONS
