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>
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;
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.
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.
28 #include <linux/module.h>
30 #include <linux/tty.h>
31 #include <linux/tty_driver.h>
32 #include <linux/tty_flip.h>
34 #include <linux/capability.h>
35 #include <linux/slab.h>
36 #include <linux/skbuff.h>
38 #include <net/bluetooth/bluetooth.h>
39 #include <net/bluetooth/hci_core.h>
40 #include <net/bluetooth/rfcomm.h>
42 #define RFCOMM_TTY_MAGIC 0x6d02 /* magic number for rfcomm struct */
43 #define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV /* whole lotta rfcomm devices */
44 #define RFCOMM_TTY_MAJOR 216 /* device node major id of the usb/bluetooth.c driver */
45 #define RFCOMM_TTY_MINOR 0
47 static struct tty_driver *rfcomm_tty_driver;
50 struct list_head list;
65 struct rfcomm_dlc *dlc;
66 struct tty_struct *tty;
67 wait_queue_head_t wait;
68 struct tasklet_struct wakeup_task;
70 struct device *tty_dev;
74 struct sk_buff_head pending;
77 static LIST_HEAD(rfcomm_dev_list);
78 static DEFINE_RWLOCK(rfcomm_dev_lock);
80 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
81 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
82 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
84 static void rfcomm_tty_wakeup(unsigned long arg);
86 /* ---- Device functions ---- */
87 static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
89 struct rfcomm_dlc *dlc = dev->dlc;
91 BT_DBG("dev %p dlc %p", dev, dlc);
93 /* Refcount should only hit zero when called from rfcomm_dev_del()
94 which will have taken us off the list. Everything else are
96 BUG_ON(!list_empty(&dev->list));
99 /* Detach DLC if it's owned by this dev */
100 if (dlc->owner == dev)
102 rfcomm_dlc_unlock(dlc);
106 tty_unregister_device(rfcomm_tty_driver, dev->id);
110 /* It's safe to call module_put() here because socket still
111 holds reference to this module. */
112 module_put(THIS_MODULE);
115 static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
117 atomic_inc(&dev->refcnt);
120 static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
122 /* The reason this isn't actually a race, as you no
123 doubt have a little voice screaming at you in your
124 head, is that the refcount should never actually
125 reach zero unless the device has already been taken
126 off the list, in rfcomm_dev_del(). And if that's not
127 true, we'll hit the BUG() in rfcomm_dev_destruct()
129 if (atomic_dec_and_test(&dev->refcnt))
130 rfcomm_dev_destruct(dev);
133 static struct rfcomm_dev *__rfcomm_dev_get(int id)
135 struct rfcomm_dev *dev;
138 list_for_each(p, &rfcomm_dev_list) {
139 dev = list_entry(p, struct rfcomm_dev, list);
147 static inline struct rfcomm_dev *rfcomm_dev_get(int id)
149 struct rfcomm_dev *dev;
151 read_lock(&rfcomm_dev_lock);
153 dev = __rfcomm_dev_get(id);
156 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
159 rfcomm_dev_hold(dev);
162 read_unlock(&rfcomm_dev_lock);
167 static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
169 struct hci_dev *hdev;
170 struct hci_conn *conn;
172 hdev = hci_get_route(&dev->dst, &dev->src);
176 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
180 return conn ? &conn->dev : NULL;
183 static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
185 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
187 baswap(&bdaddr, &dev->dst);
188 return sprintf(buf, "%s\n", batostr(&bdaddr));
191 static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
193 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
194 return sprintf(buf, "%d\n", dev->channel);
197 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
198 static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
200 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
202 struct rfcomm_dev *dev;
203 struct list_head *head = &rfcomm_dev_list, *p;
206 BT_DBG("id %d channel %d", req->dev_id, req->channel);
208 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
212 write_lock_bh(&rfcomm_dev_lock);
214 if (req->dev_id < 0) {
217 list_for_each(p, &rfcomm_dev_list) {
218 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
225 dev->id = req->dev_id;
227 list_for_each(p, &rfcomm_dev_list) {
228 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
230 if (entry->id == dev->id) {
235 if (entry->id > dev->id - 1)
242 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
247 sprintf(dev->name, "rfcomm%d", dev->id);
249 list_add(&dev->list, head);
250 atomic_set(&dev->refcnt, 1);
252 bacpy(&dev->src, &req->src);
253 bacpy(&dev->dst, &req->dst);
254 dev->channel = req->channel;
256 dev->flags = req->flags &
257 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
259 init_waitqueue_head(&dev->wait);
260 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
262 skb_queue_head_init(&dev->pending);
264 rfcomm_dlc_lock(dlc);
266 if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
267 struct sock *sk = dlc->owner;
272 rfcomm_dlc_throttle(dlc);
274 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
276 skb_queue_tail(&dev->pending, skb);
277 atomic_sub(skb->len, &sk->sk_rmem_alloc);
281 dlc->data_ready = rfcomm_dev_data_ready;
282 dlc->state_change = rfcomm_dev_state_change;
283 dlc->modem_status = rfcomm_dev_modem_status;
288 rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);
290 rfcomm_dlc_unlock(dlc);
292 /* It's safe to call __module_get() here because socket already
293 holds reference to this module. */
294 __module_get(THIS_MODULE);
297 write_unlock_bh(&rfcomm_dev_lock);
304 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
306 if (IS_ERR(dev->tty_dev)) {
307 err = PTR_ERR(dev->tty_dev);
308 list_del(&dev->list);
313 dev_set_drvdata(dev->tty_dev, dev);
315 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
316 BT_ERR("Failed to create address attribute");
318 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
319 BT_ERR("Failed to create channel attribute");
324 static void rfcomm_dev_del(struct rfcomm_dev *dev)
326 BT_DBG("dev %p", dev);
328 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
331 set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
333 write_lock_bh(&rfcomm_dev_lock);
334 list_del_init(&dev->list);
335 write_unlock_bh(&rfcomm_dev_lock);
340 /* ---- Send buffer ---- */
341 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
343 /* We can't let it be zero, because we don't get a callback
344 when tx_credits becomes nonzero, hence we'd never wake up */
345 return dlc->mtu * (dlc->tx_credits?:1);
348 static void rfcomm_wfree(struct sk_buff *skb)
350 struct rfcomm_dev *dev = (void *) skb->sk;
351 atomic_sub(skb->truesize, &dev->wmem_alloc);
352 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
353 tasklet_schedule(&dev->wakeup_task);
357 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
359 rfcomm_dev_hold(dev);
360 atomic_add(skb->truesize, &dev->wmem_alloc);
361 skb->sk = (void *) dev;
362 skb->destructor = rfcomm_wfree;
365 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
367 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
368 struct sk_buff *skb = alloc_skb(size, priority);
370 rfcomm_set_owner_w(skb, dev);
377 /* ---- Device IOCTLs ---- */
379 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
381 static int rfcomm_create_dev(struct sock *sk, void __user *arg)
383 struct rfcomm_dev_req req;
384 struct rfcomm_dlc *dlc;
387 if (copy_from_user(&req, arg, sizeof(req)))
390 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
392 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
395 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
396 /* Socket must be connected */
397 if (sk->sk_state != BT_CONNECTED)
400 dlc = rfcomm_pi(sk)->dlc;
401 rfcomm_dlc_hold(dlc);
403 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
408 id = rfcomm_dev_add(&req, dlc);
414 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
415 /* DLC is now used by device.
416 * Socket must be disconnected */
417 sk->sk_state = BT_CLOSED;
423 static int rfcomm_release_dev(void __user *arg)
425 struct rfcomm_dev_req req;
426 struct rfcomm_dev *dev;
428 if (copy_from_user(&req, arg, sizeof(req)))
431 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
433 if (!(dev = rfcomm_dev_get(req.dev_id)))
436 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
441 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
442 rfcomm_dlc_close(dev->dlc, 0);
444 /* Shut down TTY synchronously before freeing rfcomm_dev */
446 tty_vhangup(dev->tty);
448 if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
454 static int rfcomm_get_dev_list(void __user *arg)
456 struct rfcomm_dev_list_req *dl;
457 struct rfcomm_dev_info *di;
459 int n = 0, size, err;
464 if (get_user(dev_num, (u16 __user *) arg))
467 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
470 size = sizeof(*dl) + dev_num * sizeof(*di);
472 if (!(dl = kmalloc(size, GFP_KERNEL)))
477 read_lock_bh(&rfcomm_dev_lock);
479 list_for_each(p, &rfcomm_dev_list) {
480 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
481 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
483 (di + n)->id = dev->id;
484 (di + n)->flags = dev->flags;
485 (di + n)->state = dev->dlc->state;
486 (di + n)->channel = dev->channel;
487 bacpy(&(di + n)->src, &dev->src);
488 bacpy(&(di + n)->dst, &dev->dst);
493 read_unlock_bh(&rfcomm_dev_lock);
496 size = sizeof(*dl) + n * sizeof(*di);
498 err = copy_to_user(arg, dl, size);
501 return err ? -EFAULT : 0;
504 static int rfcomm_get_dev_info(void __user *arg)
506 struct rfcomm_dev *dev;
507 struct rfcomm_dev_info di;
512 if (copy_from_user(&di, arg, sizeof(di)))
515 if (!(dev = rfcomm_dev_get(di.id)))
518 di.flags = dev->flags;
519 di.channel = dev->channel;
520 di.state = dev->dlc->state;
521 bacpy(&di.src, &dev->src);
522 bacpy(&di.dst, &dev->dst);
524 if (copy_to_user(arg, &di, sizeof(di)))
531 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
533 BT_DBG("cmd %d arg %p", cmd, arg);
536 case RFCOMMCREATEDEV:
537 return rfcomm_create_dev(sk, arg);
539 case RFCOMMRELEASEDEV:
540 return rfcomm_release_dev(arg);
542 case RFCOMMGETDEVLIST:
543 return rfcomm_get_dev_list(arg);
545 case RFCOMMGETDEVINFO:
546 return rfcomm_get_dev_info(arg);
552 /* ---- DLC callbacks ---- */
553 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
555 struct rfcomm_dev *dev = dlc->owner;
556 struct tty_struct *tty;
563 if (!(tty = dev->tty) || !skb_queue_empty(&dev->pending)) {
564 skb_queue_tail(&dev->pending, skb);
568 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
570 tty_insert_flip_string(tty, skb->data, skb->len);
571 tty_flip_buffer_push(tty);
576 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
578 struct rfcomm_dev *dev = dlc->owner;
582 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
585 wake_up_interruptible(&dev->wait);
587 if (dlc->state == BT_CLOSED) {
589 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
590 /* Drop DLC lock here to avoid deadlock
591 * 1. rfcomm_dev_get will take rfcomm_dev_lock
592 * but in rfcomm_dev_add there's lock order:
593 * rfcomm_dev_lock -> dlc lock
594 * 2. rfcomm_dev_put will deadlock if it's
597 rfcomm_dlc_unlock(dlc);
598 if (rfcomm_dev_get(dev->id) == NULL) {
599 rfcomm_dlc_lock(dlc);
605 rfcomm_dlc_lock(dlc);
608 tty_hangup(dev->tty);
612 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
614 struct rfcomm_dev *dev = dlc->owner;
618 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
620 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
621 if (dev->tty && !C_CLOCAL(dev->tty))
622 tty_hangup(dev->tty);
626 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
627 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
628 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
629 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
632 /* ---- TTY functions ---- */
633 static void rfcomm_tty_wakeup(unsigned long arg)
635 struct rfcomm_dev *dev = (void *) arg;
636 struct tty_struct *tty = dev->tty;
640 BT_DBG("dev %p tty %p", dev, tty);
644 static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev)
646 struct tty_struct *tty = dev->tty;
653 BT_DBG("dev %p tty %p", dev, tty);
655 rfcomm_dlc_lock(dev->dlc);
657 while ((skb = skb_dequeue(&dev->pending))) {
658 inserted += tty_insert_flip_string(tty, skb->data, skb->len);
662 rfcomm_dlc_unlock(dev->dlc);
665 tty_flip_buffer_push(tty);
668 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
670 DECLARE_WAITQUEUE(wait, current);
671 struct rfcomm_dev *dev;
672 struct rfcomm_dlc *dlc;
677 BT_DBG("tty %p id %d", tty, id);
679 /* We don't leak this refcount. For reasons which are not entirely
680 clear, the TTY layer will call our ->close() method even if the
681 open fails. We decrease the refcount there, and decreasing it
682 here too would cause breakage. */
683 dev = rfcomm_dev_get(id);
687 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst), dev->channel, dev->opened);
689 if (dev->opened++ != 0)
694 /* Attach TTY and open DLC */
696 rfcomm_dlc_lock(dlc);
697 tty->driver_data = dev;
699 rfcomm_dlc_unlock(dlc);
700 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
702 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
706 /* Wait for DLC to connect */
707 add_wait_queue(&dev->wait, &wait);
709 set_current_state(TASK_INTERRUPTIBLE);
711 if (dlc->state == BT_CLOSED) {
716 if (dlc->state == BT_CONNECTED)
719 if (signal_pending(current)) {
726 set_current_state(TASK_RUNNING);
727 remove_wait_queue(&dev->wait, &wait);
730 device_move(dev->tty_dev, rfcomm_get_device(dev));
732 rfcomm_tty_copy_pending(dev);
734 rfcomm_dlc_unthrottle(dev->dlc);
739 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
741 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
745 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, dev->opened);
747 if (--dev->opened == 0) {
748 if (dev->tty_dev->parent)
749 device_move(dev->tty_dev, NULL);
751 /* Close DLC and dettach TTY */
752 rfcomm_dlc_close(dev->dlc, 0);
754 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
755 tasklet_kill(&dev->wakeup_task);
757 rfcomm_dlc_lock(dev->dlc);
758 tty->driver_data = NULL;
760 rfcomm_dlc_unlock(dev->dlc);
766 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
768 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
769 struct rfcomm_dlc *dlc = dev->dlc;
771 int err = 0, sent = 0, size;
773 BT_DBG("tty %p count %d", tty, count);
776 size = min_t(uint, count, dlc->mtu);
778 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
783 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
785 memcpy(skb_put(skb, size), buf + sent, size);
787 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
796 return sent ? sent : err;
799 static int rfcomm_tty_write_room(struct tty_struct *tty)
801 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
804 BT_DBG("tty %p", tty);
806 if (!dev || !dev->dlc)
809 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
816 static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
818 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
822 BT_DBG("TCGETS is not supported");
826 BT_DBG("TCSETS is not supported");
830 BT_DBG("TIOCMIWAIT");
834 BT_DBG("TIOCGICOUNT");
838 BT_ERR("TIOCGSERIAL is not supported");
842 BT_ERR("TIOCSSERIAL is not supported");
846 BT_ERR("TIOCSERGSTRUCT is not supported");
850 BT_ERR("TIOCSERGETLSR is not supported");
854 BT_ERR("TIOCSERCONFIG is not supported");
858 return -ENOIOCTLCMD; /* ioctls which we must ignore */
865 static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
867 struct ktermios *new = tty->termios;
868 int old_baud_rate = tty_termios_baud_rate(old);
869 int new_baud_rate = tty_termios_baud_rate(new);
871 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
874 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
876 BT_DBG("tty %p termios %p", tty, old);
878 if (!dev || !dev->dlc || !dev->dlc->session)
881 /* Handle turning off CRTSCTS */
882 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
883 BT_DBG("Turning off CRTSCTS unsupported");
885 /* Parity on/off and when on, odd/even */
886 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
887 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) {
888 changes |= RFCOMM_RPN_PM_PARITY;
889 BT_DBG("Parity change detected.");
892 /* Mark and space parity are not supported! */
893 if (new->c_cflag & PARENB) {
894 if (new->c_cflag & PARODD) {
895 BT_DBG("Parity is ODD");
896 parity = RFCOMM_RPN_PARITY_ODD;
898 BT_DBG("Parity is EVEN");
899 parity = RFCOMM_RPN_PARITY_EVEN;
902 BT_DBG("Parity is OFF");
903 parity = RFCOMM_RPN_PARITY_NONE;
906 /* Setting the x_on / x_off characters */
907 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
908 BT_DBG("XOFF custom");
909 x_on = new->c_cc[VSTOP];
910 changes |= RFCOMM_RPN_PM_XON;
912 BT_DBG("XOFF default");
913 x_on = RFCOMM_RPN_XON_CHAR;
916 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
917 BT_DBG("XON custom");
918 x_off = new->c_cc[VSTART];
919 changes |= RFCOMM_RPN_PM_XOFF;
921 BT_DBG("XON default");
922 x_off = RFCOMM_RPN_XOFF_CHAR;
925 /* Handle setting of stop bits */
926 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
927 changes |= RFCOMM_RPN_PM_STOP;
929 /* POSIX does not support 1.5 stop bits and RFCOMM does not
930 * support 2 stop bits. So a request for 2 stop bits gets
931 * translated to 1.5 stop bits */
932 if (new->c_cflag & CSTOPB) {
933 stop_bits = RFCOMM_RPN_STOP_15;
935 stop_bits = RFCOMM_RPN_STOP_1;
938 /* Handle number of data bits [5-8] */
939 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
940 changes |= RFCOMM_RPN_PM_DATA;
942 switch (new->c_cflag & CSIZE) {
944 data_bits = RFCOMM_RPN_DATA_5;
947 data_bits = RFCOMM_RPN_DATA_6;
950 data_bits = RFCOMM_RPN_DATA_7;
953 data_bits = RFCOMM_RPN_DATA_8;
956 data_bits = RFCOMM_RPN_DATA_8;
960 /* Handle baudrate settings */
961 if (old_baud_rate != new_baud_rate)
962 changes |= RFCOMM_RPN_PM_BITRATE;
964 switch (new_baud_rate) {
966 baud = RFCOMM_RPN_BR_2400;
969 baud = RFCOMM_RPN_BR_4800;
972 baud = RFCOMM_RPN_BR_7200;
975 baud = RFCOMM_RPN_BR_9600;
978 baud = RFCOMM_RPN_BR_19200;
981 baud = RFCOMM_RPN_BR_38400;
984 baud = RFCOMM_RPN_BR_57600;
987 baud = RFCOMM_RPN_BR_115200;
990 baud = RFCOMM_RPN_BR_230400;
993 /* 9600 is standard accordinag to the RFCOMM specification */
994 baud = RFCOMM_RPN_BR_9600;
1000 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
1001 data_bits, stop_bits, parity,
1002 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
1007 static void rfcomm_tty_throttle(struct tty_struct *tty)
1009 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1011 BT_DBG("tty %p dev %p", tty, dev);
1013 rfcomm_dlc_throttle(dev->dlc);
1016 static void rfcomm_tty_unthrottle(struct tty_struct *tty)
1018 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1020 BT_DBG("tty %p dev %p", tty, dev);
1022 rfcomm_dlc_unthrottle(dev->dlc);
1025 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
1027 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1029 BT_DBG("tty %p dev %p", tty, dev);
1031 if (!dev || !dev->dlc)
1034 if (!skb_queue_empty(&dev->dlc->tx_queue))
1035 return dev->dlc->mtu;
1040 static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
1042 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1044 BT_DBG("tty %p dev %p", tty, dev);
1046 if (!dev || !dev->dlc)
1049 skb_queue_purge(&dev->dlc->tx_queue);
1053 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1055 BT_DBG("tty %p ch %c", tty, ch);
1058 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1060 BT_DBG("tty %p timeout %d", tty, timeout);
1063 static void rfcomm_tty_hangup(struct tty_struct *tty)
1065 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1067 BT_DBG("tty %p dev %p", tty, dev);
1072 rfcomm_tty_flush_buffer(tty);
1074 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
1075 if (rfcomm_dev_get(dev->id) == NULL)
1077 rfcomm_dev_del(dev);
1078 rfcomm_dev_put(dev);
1082 static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused)
1087 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
1089 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1091 BT_DBG("tty %p dev %p", tty, dev);
1093 return dev->modem_status;
1096 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
1098 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1099 struct rfcomm_dlc *dlc = dev->dlc;
1102 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1104 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
1106 if (set & TIOCM_DSR || set & TIOCM_DTR)
1107 v24_sig |= RFCOMM_V24_RTC;
1108 if (set & TIOCM_RTS || set & TIOCM_CTS)
1109 v24_sig |= RFCOMM_V24_RTR;
1111 v24_sig |= RFCOMM_V24_IC;
1113 v24_sig |= RFCOMM_V24_DV;
1115 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1116 v24_sig &= ~RFCOMM_V24_RTC;
1117 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1118 v24_sig &= ~RFCOMM_V24_RTR;
1119 if (clear & TIOCM_RI)
1120 v24_sig &= ~RFCOMM_V24_IC;
1121 if (clear & TIOCM_CD)
1122 v24_sig &= ~RFCOMM_V24_DV;
1124 rfcomm_dlc_set_modem_status(dlc, v24_sig);
1129 /* ---- TTY structure ---- */
1131 static const struct tty_operations rfcomm_ops = {
1132 .open = rfcomm_tty_open,
1133 .close = rfcomm_tty_close,
1134 .write = rfcomm_tty_write,
1135 .write_room = rfcomm_tty_write_room,
1136 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1137 .flush_buffer = rfcomm_tty_flush_buffer,
1138 .ioctl = rfcomm_tty_ioctl,
1139 .throttle = rfcomm_tty_throttle,
1140 .unthrottle = rfcomm_tty_unthrottle,
1141 .set_termios = rfcomm_tty_set_termios,
1142 .send_xchar = rfcomm_tty_send_xchar,
1143 .hangup = rfcomm_tty_hangup,
1144 .wait_until_sent = rfcomm_tty_wait_until_sent,
1145 .read_proc = rfcomm_tty_read_proc,
1146 .tiocmget = rfcomm_tty_tiocmget,
1147 .tiocmset = rfcomm_tty_tiocmset,
1150 int rfcomm_init_ttys(void)
1152 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1153 if (!rfcomm_tty_driver)
1156 rfcomm_tty_driver->owner = THIS_MODULE;
1157 rfcomm_tty_driver->driver_name = "rfcomm";
1158 rfcomm_tty_driver->name = "rfcomm";
1159 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1160 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1161 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1162 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1163 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1164 rfcomm_tty_driver->init_termios = tty_std_termios;
1165 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1166 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
1167 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1169 if (tty_register_driver(rfcomm_tty_driver)) {
1170 BT_ERR("Can't register RFCOMM TTY driver");
1171 put_tty_driver(rfcomm_tty_driver);
1175 BT_INFO("RFCOMM TTY layer initialized");
1180 void rfcomm_cleanup_ttys(void)
1182 tty_unregister_driver(rfcomm_tty_driver);
1183 put_tty_driver(rfcomm_tty_driver);