git.oblomov.eu Git - linux-2.6/blob - net/bluetooth/rfcomm/tty.c

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