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.
27 * $Id: tty.c,v 1.24 2002/10/03 01:54:38 holtmann Exp $
30 #include <linux/module.h>
32 #include <linux/tty.h>
33 #include <linux/tty_driver.h>
34 #include <linux/tty_flip.h>
36 #include <linux/capability.h>
37 #include <linux/slab.h>
38 #include <linux/skbuff.h>
40 #include <net/bluetooth/bluetooth.h>
41 #include <net/bluetooth/hci_core.h>
42 #include <net/bluetooth/rfcomm.h>
44 #ifndef CONFIG_BT_RFCOMM_DEBUG
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
54 static struct tty_driver *rfcomm_tty_driver;
57 struct list_head list;
72 struct rfcomm_dlc *dlc;
73 struct tty_struct *tty;
74 wait_queue_head_t wait;
75 struct tasklet_struct wakeup_task;
77 struct device *tty_dev;
82 static LIST_HEAD(rfcomm_dev_list);
83 static DEFINE_RWLOCK(rfcomm_dev_lock);
85 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
86 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
87 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
89 static void rfcomm_tty_wakeup(unsigned long arg);
91 /* ---- Device functions ---- */
92 static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
94 struct rfcomm_dlc *dlc = dev->dlc;
96 BT_DBG("dev %p dlc %p", dev, dlc);
98 /* Refcount should only hit zero when called from rfcomm_dev_del()
99 which will have taken us off the list. Everything else are
101 BUG_ON(!list_empty(&dev->list));
103 rfcomm_dlc_lock(dlc);
104 /* Detach DLC if it's owned by this dev */
105 if (dlc->owner == dev)
107 rfcomm_dlc_unlock(dlc);
111 tty_unregister_device(rfcomm_tty_driver, dev->id);
115 /* It's safe to call module_put() here because socket still
116 holds reference to this module. */
117 module_put(THIS_MODULE);
120 static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
122 atomic_inc(&dev->refcnt);
125 static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
127 /* The reason this isn't actually a race, as you no
128 doubt have a little voice screaming at you in your
129 head, is that the refcount should never actually
130 reach zero unless the device has already been taken
131 off the list, in rfcomm_dev_del(). And if that's not
132 true, we'll hit the BUG() in rfcomm_dev_destruct()
134 if (atomic_dec_and_test(&dev->refcnt))
135 rfcomm_dev_destruct(dev);
138 static struct rfcomm_dev *__rfcomm_dev_get(int id)
140 struct rfcomm_dev *dev;
143 list_for_each(p, &rfcomm_dev_list) {
144 dev = list_entry(p, struct rfcomm_dev, list);
152 static inline struct rfcomm_dev *rfcomm_dev_get(int id)
154 struct rfcomm_dev *dev;
156 read_lock(&rfcomm_dev_lock);
158 dev = __rfcomm_dev_get(id);
161 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
164 rfcomm_dev_hold(dev);
167 read_unlock(&rfcomm_dev_lock);
172 static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
174 struct hci_dev *hdev;
175 struct hci_conn *conn;
177 hdev = hci_get_route(&dev->dst, &dev->src);
181 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
185 return conn ? &conn->dev : NULL;
188 static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
190 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
192 baswap(&bdaddr, &dev->dst);
193 return sprintf(buf, "%s\n", batostr(&bdaddr));
196 static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
198 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
199 return sprintf(buf, "%d\n", dev->channel);
202 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
203 static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
205 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
207 struct rfcomm_dev *dev;
208 struct list_head *head = &rfcomm_dev_list, *p;
211 BT_DBG("id %d channel %d", req->dev_id, req->channel);
213 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
217 write_lock_bh(&rfcomm_dev_lock);
219 if (req->dev_id < 0) {
222 list_for_each(p, &rfcomm_dev_list) {
223 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
230 dev->id = req->dev_id;
232 list_for_each(p, &rfcomm_dev_list) {
233 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
235 if (entry->id == dev->id) {
240 if (entry->id > dev->id - 1)
247 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
252 sprintf(dev->name, "rfcomm%d", dev->id);
254 list_add(&dev->list, head);
255 atomic_set(&dev->refcnt, 1);
257 bacpy(&dev->src, &req->src);
258 bacpy(&dev->dst, &req->dst);
259 dev->channel = req->channel;
261 dev->flags = req->flags &
262 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
264 init_waitqueue_head(&dev->wait);
265 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
267 rfcomm_dlc_lock(dlc);
268 dlc->data_ready = rfcomm_dev_data_ready;
269 dlc->state_change = rfcomm_dev_state_change;
270 dlc->modem_status = rfcomm_dev_modem_status;
274 rfcomm_dlc_unlock(dlc);
276 /* It's safe to call __module_get() here because socket already
277 holds reference to this module. */
278 __module_get(THIS_MODULE);
281 write_unlock_bh(&rfcomm_dev_lock);
288 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
290 if (IS_ERR(dev->tty_dev)) {
291 err = PTR_ERR(dev->tty_dev);
292 list_del(&dev->list);
297 dev_set_drvdata(dev->tty_dev, dev);
299 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
300 BT_ERR("Failed to create address attribute");
302 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
303 BT_ERR("Failed to create channel attribute");
308 static void rfcomm_dev_del(struct rfcomm_dev *dev)
310 BT_DBG("dev %p", dev);
312 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
315 set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
317 write_lock_bh(&rfcomm_dev_lock);
318 list_del_init(&dev->list);
319 write_unlock_bh(&rfcomm_dev_lock);
324 /* ---- Send buffer ---- */
325 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
327 /* We can't let it be zero, because we don't get a callback
328 when tx_credits becomes nonzero, hence we'd never wake up */
329 return dlc->mtu * (dlc->tx_credits?:1);
332 static void rfcomm_wfree(struct sk_buff *skb)
334 struct rfcomm_dev *dev = (void *) skb->sk;
335 atomic_sub(skb->truesize, &dev->wmem_alloc);
336 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
337 tasklet_schedule(&dev->wakeup_task);
341 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
343 rfcomm_dev_hold(dev);
344 atomic_add(skb->truesize, &dev->wmem_alloc);
345 skb->sk = (void *) dev;
346 skb->destructor = rfcomm_wfree;
349 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
351 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
352 struct sk_buff *skb = alloc_skb(size, priority);
354 rfcomm_set_owner_w(skb, dev);
361 /* ---- Device IOCTLs ---- */
363 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
365 static int rfcomm_create_dev(struct sock *sk, void __user *arg)
367 struct rfcomm_dev_req req;
368 struct rfcomm_dlc *dlc;
371 if (copy_from_user(&req, arg, sizeof(req)))
374 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
376 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
379 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
380 /* Socket must be connected */
381 if (sk->sk_state != BT_CONNECTED)
384 dlc = rfcomm_pi(sk)->dlc;
385 rfcomm_dlc_hold(dlc);
387 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
392 id = rfcomm_dev_add(&req, dlc);
398 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
399 /* DLC is now used by device.
400 * Socket must be disconnected */
401 sk->sk_state = BT_CLOSED;
407 static int rfcomm_release_dev(void __user *arg)
409 struct rfcomm_dev_req req;
410 struct rfcomm_dev *dev;
412 if (copy_from_user(&req, arg, sizeof(req)))
415 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
417 if (!(dev = rfcomm_dev_get(req.dev_id)))
420 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
425 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
426 rfcomm_dlc_close(dev->dlc, 0);
428 /* Shut down TTY synchronously before freeing rfcomm_dev */
430 tty_vhangup(dev->tty);
437 static int rfcomm_get_dev_list(void __user *arg)
439 struct rfcomm_dev_list_req *dl;
440 struct rfcomm_dev_info *di;
442 int n = 0, size, err;
447 if (get_user(dev_num, (u16 __user *) arg))
450 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
453 size = sizeof(*dl) + dev_num * sizeof(*di);
455 if (!(dl = kmalloc(size, GFP_KERNEL)))
460 read_lock_bh(&rfcomm_dev_lock);
462 list_for_each(p, &rfcomm_dev_list) {
463 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
464 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
466 (di + n)->id = dev->id;
467 (di + n)->flags = dev->flags;
468 (di + n)->state = dev->dlc->state;
469 (di + n)->channel = dev->channel;
470 bacpy(&(di + n)->src, &dev->src);
471 bacpy(&(di + n)->dst, &dev->dst);
476 read_unlock_bh(&rfcomm_dev_lock);
479 size = sizeof(*dl) + n * sizeof(*di);
481 err = copy_to_user(arg, dl, size);
484 return err ? -EFAULT : 0;
487 static int rfcomm_get_dev_info(void __user *arg)
489 struct rfcomm_dev *dev;
490 struct rfcomm_dev_info di;
495 if (copy_from_user(&di, arg, sizeof(di)))
498 if (!(dev = rfcomm_dev_get(di.id)))
501 di.flags = dev->flags;
502 di.channel = dev->channel;
503 di.state = dev->dlc->state;
504 bacpy(&di.src, &dev->src);
505 bacpy(&di.dst, &dev->dst);
507 if (copy_to_user(arg, &di, sizeof(di)))
514 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
516 BT_DBG("cmd %d arg %p", cmd, arg);
519 case RFCOMMCREATEDEV:
520 return rfcomm_create_dev(sk, arg);
522 case RFCOMMRELEASEDEV:
523 return rfcomm_release_dev(arg);
525 case RFCOMMGETDEVLIST:
526 return rfcomm_get_dev_list(arg);
528 case RFCOMMGETDEVINFO:
529 return rfcomm_get_dev_info(arg);
535 /* ---- DLC callbacks ---- */
536 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
538 struct rfcomm_dev *dev = dlc->owner;
539 struct tty_struct *tty;
541 if (!dev || !(tty = dev->tty)) {
546 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
548 tty_insert_flip_string(tty, skb->data, skb->len);
549 tty_flip_buffer_push(tty);
554 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
556 struct rfcomm_dev *dev = dlc->owner;
560 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
563 wake_up_interruptible(&dev->wait);
565 if (dlc->state == BT_CLOSED) {
567 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
568 if (rfcomm_dev_get(dev->id) == NULL)
572 /* We have to drop DLC lock here, otherwise
573 rfcomm_dev_put() will dead lock if it's
574 the last reference. */
575 rfcomm_dlc_unlock(dlc);
577 rfcomm_dlc_lock(dlc);
580 tty_hangup(dev->tty);
584 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
586 struct rfcomm_dev *dev = dlc->owner;
590 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
592 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
593 if (dev->tty && !C_CLOCAL(dev->tty))
594 tty_hangup(dev->tty);
598 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
599 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
600 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
601 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
604 /* ---- TTY functions ---- */
605 static void rfcomm_tty_wakeup(unsigned long arg)
607 struct rfcomm_dev *dev = (void *) arg;
608 struct tty_struct *tty = dev->tty;
612 BT_DBG("dev %p tty %p", dev, tty);
614 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup)
615 (tty->ldisc.write_wakeup)(tty);
617 wake_up_interruptible(&tty->write_wait);
618 #ifdef SERIAL_HAVE_POLL_WAIT
619 wake_up_interruptible(&tty->poll_wait);
623 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
625 DECLARE_WAITQUEUE(wait, current);
626 struct rfcomm_dev *dev;
627 struct rfcomm_dlc *dlc;
632 BT_DBG("tty %p id %d", tty, id);
634 /* We don't leak this refcount. For reasons which are not entirely
635 clear, the TTY layer will call our ->close() method even if the
636 open fails. We decrease the refcount there, and decreasing it
637 here too would cause breakage. */
638 dev = rfcomm_dev_get(id);
642 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst), dev->channel, dev->opened);
644 if (dev->opened++ != 0)
649 /* Attach TTY and open DLC */
651 rfcomm_dlc_lock(dlc);
652 tty->driver_data = dev;
654 rfcomm_dlc_unlock(dlc);
655 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
657 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
661 /* Wait for DLC to connect */
662 add_wait_queue(&dev->wait, &wait);
664 set_current_state(TASK_INTERRUPTIBLE);
666 if (dlc->state == BT_CLOSED) {
671 if (dlc->state == BT_CONNECTED)
674 if (signal_pending(current)) {
681 set_current_state(TASK_RUNNING);
682 remove_wait_queue(&dev->wait, &wait);
685 device_move(dev->tty_dev, rfcomm_get_device(dev));
690 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
692 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
696 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, dev->opened);
698 if (--dev->opened == 0) {
699 device_move(dev->tty_dev, NULL);
701 /* Close DLC and dettach TTY */
702 rfcomm_dlc_close(dev->dlc, 0);
704 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
705 tasklet_kill(&dev->wakeup_task);
707 rfcomm_dlc_lock(dev->dlc);
708 tty->driver_data = NULL;
710 rfcomm_dlc_unlock(dev->dlc);
716 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
718 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
719 struct rfcomm_dlc *dlc = dev->dlc;
721 int err = 0, sent = 0, size;
723 BT_DBG("tty %p count %d", tty, count);
726 size = min_t(uint, count, dlc->mtu);
728 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
733 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
735 memcpy(skb_put(skb, size), buf + sent, size);
737 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
746 return sent ? sent : err;
749 static int rfcomm_tty_write_room(struct tty_struct *tty)
751 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
754 BT_DBG("tty %p", tty);
756 if (!dev || !dev->dlc)
759 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
766 static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
768 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
772 BT_DBG("TCGETS is not supported");
776 BT_DBG("TCSETS is not supported");
780 BT_DBG("TIOCMIWAIT");
784 BT_DBG("TIOCGICOUNT");
788 BT_ERR("TIOCGSERIAL is not supported");
792 BT_ERR("TIOCSSERIAL is not supported");
796 BT_ERR("TIOCSERGSTRUCT is not supported");
800 BT_ERR("TIOCSERGETLSR is not supported");
804 BT_ERR("TIOCSERCONFIG is not supported");
808 return -ENOIOCTLCMD; /* ioctls which we must ignore */
815 static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
817 struct ktermios *new = tty->termios;
818 int old_baud_rate = tty_termios_baud_rate(old);
819 int new_baud_rate = tty_termios_baud_rate(new);
821 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
824 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
826 BT_DBG("tty %p termios %p", tty, old);
828 if (!dev || !dev->dlc || !dev->dlc->session)
831 /* Handle turning off CRTSCTS */
832 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
833 BT_DBG("Turning off CRTSCTS unsupported");
835 /* Parity on/off and when on, odd/even */
836 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
837 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) {
838 changes |= RFCOMM_RPN_PM_PARITY;
839 BT_DBG("Parity change detected.");
842 /* Mark and space parity are not supported! */
843 if (new->c_cflag & PARENB) {
844 if (new->c_cflag & PARODD) {
845 BT_DBG("Parity is ODD");
846 parity = RFCOMM_RPN_PARITY_ODD;
848 BT_DBG("Parity is EVEN");
849 parity = RFCOMM_RPN_PARITY_EVEN;
852 BT_DBG("Parity is OFF");
853 parity = RFCOMM_RPN_PARITY_NONE;
856 /* Setting the x_on / x_off characters */
857 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
858 BT_DBG("XOFF custom");
859 x_on = new->c_cc[VSTOP];
860 changes |= RFCOMM_RPN_PM_XON;
862 BT_DBG("XOFF default");
863 x_on = RFCOMM_RPN_XON_CHAR;
866 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
867 BT_DBG("XON custom");
868 x_off = new->c_cc[VSTART];
869 changes |= RFCOMM_RPN_PM_XOFF;
871 BT_DBG("XON default");
872 x_off = RFCOMM_RPN_XOFF_CHAR;
875 /* Handle setting of stop bits */
876 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
877 changes |= RFCOMM_RPN_PM_STOP;
879 /* POSIX does not support 1.5 stop bits and RFCOMM does not
880 * support 2 stop bits. So a request for 2 stop bits gets
881 * translated to 1.5 stop bits */
882 if (new->c_cflag & CSTOPB) {
883 stop_bits = RFCOMM_RPN_STOP_15;
885 stop_bits = RFCOMM_RPN_STOP_1;
888 /* Handle number of data bits [5-8] */
889 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
890 changes |= RFCOMM_RPN_PM_DATA;
892 switch (new->c_cflag & CSIZE) {
894 data_bits = RFCOMM_RPN_DATA_5;
897 data_bits = RFCOMM_RPN_DATA_6;
900 data_bits = RFCOMM_RPN_DATA_7;
903 data_bits = RFCOMM_RPN_DATA_8;
906 data_bits = RFCOMM_RPN_DATA_8;
910 /* Handle baudrate settings */
911 if (old_baud_rate != new_baud_rate)
912 changes |= RFCOMM_RPN_PM_BITRATE;
914 switch (new_baud_rate) {
916 baud = RFCOMM_RPN_BR_2400;
919 baud = RFCOMM_RPN_BR_4800;
922 baud = RFCOMM_RPN_BR_7200;
925 baud = RFCOMM_RPN_BR_9600;
928 baud = RFCOMM_RPN_BR_19200;
931 baud = RFCOMM_RPN_BR_38400;
934 baud = RFCOMM_RPN_BR_57600;
937 baud = RFCOMM_RPN_BR_115200;
940 baud = RFCOMM_RPN_BR_230400;
943 /* 9600 is standard accordinag to the RFCOMM specification */
944 baud = RFCOMM_RPN_BR_9600;
950 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
951 data_bits, stop_bits, parity,
952 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
957 static void rfcomm_tty_throttle(struct tty_struct *tty)
959 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
961 BT_DBG("tty %p dev %p", tty, dev);
963 rfcomm_dlc_throttle(dev->dlc);
966 static void rfcomm_tty_unthrottle(struct tty_struct *tty)
968 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
970 BT_DBG("tty %p dev %p", tty, dev);
972 rfcomm_dlc_unthrottle(dev->dlc);
975 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
977 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
979 BT_DBG("tty %p dev %p", tty, dev);
981 if (!dev || !dev->dlc)
984 if (!skb_queue_empty(&dev->dlc->tx_queue))
985 return dev->dlc->mtu;
990 static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
992 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
994 BT_DBG("tty %p dev %p", tty, dev);
996 if (!dev || !dev->dlc)
999 skb_queue_purge(&dev->dlc->tx_queue);
1001 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup)
1002 tty->ldisc.write_wakeup(tty);
1005 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1007 BT_DBG("tty %p ch %c", tty, ch);
1010 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1012 BT_DBG("tty %p timeout %d", tty, timeout);
1015 static void rfcomm_tty_hangup(struct tty_struct *tty)
1017 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1019 BT_DBG("tty %p dev %p", tty, dev);
1024 rfcomm_tty_flush_buffer(tty);
1026 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
1027 if (rfcomm_dev_get(dev->id) == NULL)
1029 rfcomm_dev_del(dev);
1030 rfcomm_dev_put(dev);
1034 static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused)
1039 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
1041 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1043 BT_DBG("tty %p dev %p", tty, dev);
1045 return dev->modem_status;
1048 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
1050 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1051 struct rfcomm_dlc *dlc = dev->dlc;
1054 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1056 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
1058 if (set & TIOCM_DSR || set & TIOCM_DTR)
1059 v24_sig |= RFCOMM_V24_RTC;
1060 if (set & TIOCM_RTS || set & TIOCM_CTS)
1061 v24_sig |= RFCOMM_V24_RTR;
1063 v24_sig |= RFCOMM_V24_IC;
1065 v24_sig |= RFCOMM_V24_DV;
1067 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1068 v24_sig &= ~RFCOMM_V24_RTC;
1069 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1070 v24_sig &= ~RFCOMM_V24_RTR;
1071 if (clear & TIOCM_RI)
1072 v24_sig &= ~RFCOMM_V24_IC;
1073 if (clear & TIOCM_CD)
1074 v24_sig &= ~RFCOMM_V24_DV;
1076 rfcomm_dlc_set_modem_status(dlc, v24_sig);
1081 /* ---- TTY structure ---- */
1083 static const struct tty_operations rfcomm_ops = {
1084 .open = rfcomm_tty_open,
1085 .close = rfcomm_tty_close,
1086 .write = rfcomm_tty_write,
1087 .write_room = rfcomm_tty_write_room,
1088 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1089 .flush_buffer = rfcomm_tty_flush_buffer,
1090 .ioctl = rfcomm_tty_ioctl,
1091 .throttle = rfcomm_tty_throttle,
1092 .unthrottle = rfcomm_tty_unthrottle,
1093 .set_termios = rfcomm_tty_set_termios,
1094 .send_xchar = rfcomm_tty_send_xchar,
1095 .hangup = rfcomm_tty_hangup,
1096 .wait_until_sent = rfcomm_tty_wait_until_sent,
1097 .read_proc = rfcomm_tty_read_proc,
1098 .tiocmget = rfcomm_tty_tiocmget,
1099 .tiocmset = rfcomm_tty_tiocmset,
1102 int rfcomm_init_ttys(void)
1104 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1105 if (!rfcomm_tty_driver)
1108 rfcomm_tty_driver->owner = THIS_MODULE;
1109 rfcomm_tty_driver->driver_name = "rfcomm";
1110 rfcomm_tty_driver->name = "rfcomm";
1111 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1112 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1113 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1114 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1115 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1116 rfcomm_tty_driver->init_termios = tty_std_termios;
1117 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1118 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1120 if (tty_register_driver(rfcomm_tty_driver)) {
1121 BT_ERR("Can't register RFCOMM TTY driver");
1122 put_tty_driver(rfcomm_tty_driver);
1126 BT_INFO("RFCOMM TTY layer initialized");
1131 void rfcomm_cleanup_ttys(void)
1133 tty_unregister_driver(rfcomm_tty_driver);
1134 put_tty_driver(rfcomm_tty_driver);