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 atomic_set(&dev->opened, 0);
261 init_waitqueue_head(&dev->wait);
262 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
264 skb_queue_head_init(&dev->pending);
266 rfcomm_dlc_lock(dlc);
268 if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
269 struct sock *sk = dlc->owner;
274 rfcomm_dlc_throttle(dlc);
276 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
278 skb_queue_tail(&dev->pending, skb);
279 atomic_sub(skb->len, &sk->sk_rmem_alloc);
283 dlc->data_ready = rfcomm_dev_data_ready;
284 dlc->state_change = rfcomm_dev_state_change;
285 dlc->modem_status = rfcomm_dev_modem_status;
290 rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);
292 rfcomm_dlc_unlock(dlc);
294 /* It's safe to call __module_get() here because socket already
295 holds reference to this module. */
296 __module_get(THIS_MODULE);
299 write_unlock_bh(&rfcomm_dev_lock);
306 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
308 if (IS_ERR(dev->tty_dev)) {
309 err = PTR_ERR(dev->tty_dev);
310 list_del(&dev->list);
315 dev_set_drvdata(dev->tty_dev, dev);
317 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
318 BT_ERR("Failed to create address attribute");
320 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
321 BT_ERR("Failed to create channel attribute");
326 static void rfcomm_dev_del(struct rfcomm_dev *dev)
328 BT_DBG("dev %p", dev);
330 BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags));
332 if (atomic_read(&dev->opened) > 0)
335 write_lock_bh(&rfcomm_dev_lock);
336 list_del_init(&dev->list);
337 write_unlock_bh(&rfcomm_dev_lock);
342 /* ---- Send buffer ---- */
343 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
345 /* We can't let it be zero, because we don't get a callback
346 when tx_credits becomes nonzero, hence we'd never wake up */
347 return dlc->mtu * (dlc->tx_credits?:1);
350 static void rfcomm_wfree(struct sk_buff *skb)
352 struct rfcomm_dev *dev = (void *) skb->sk;
353 atomic_sub(skb->truesize, &dev->wmem_alloc);
354 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
355 tasklet_schedule(&dev->wakeup_task);
359 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
361 rfcomm_dev_hold(dev);
362 atomic_add(skb->truesize, &dev->wmem_alloc);
363 skb->sk = (void *) dev;
364 skb->destructor = rfcomm_wfree;
367 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
369 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
370 struct sk_buff *skb = alloc_skb(size, priority);
372 rfcomm_set_owner_w(skb, dev);
379 /* ---- Device IOCTLs ---- */
381 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
383 static int rfcomm_create_dev(struct sock *sk, void __user *arg)
385 struct rfcomm_dev_req req;
386 struct rfcomm_dlc *dlc;
389 if (copy_from_user(&req, arg, sizeof(req)))
392 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
394 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
397 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
398 /* Socket must be connected */
399 if (sk->sk_state != BT_CONNECTED)
402 dlc = rfcomm_pi(sk)->dlc;
403 rfcomm_dlc_hold(dlc);
405 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
410 id = rfcomm_dev_add(&req, dlc);
416 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
417 /* DLC is now used by device.
418 * Socket must be disconnected */
419 sk->sk_state = BT_CLOSED;
425 static int rfcomm_release_dev(void __user *arg)
427 struct rfcomm_dev_req req;
428 struct rfcomm_dev *dev;
430 if (copy_from_user(&req, arg, sizeof(req)))
433 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
435 if (!(dev = rfcomm_dev_get(req.dev_id)))
438 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
443 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
444 rfcomm_dlc_close(dev->dlc, 0);
446 /* Shut down TTY synchronously before freeing rfcomm_dev */
448 tty_vhangup(dev->tty);
450 if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
456 static int rfcomm_get_dev_list(void __user *arg)
458 struct rfcomm_dev_list_req *dl;
459 struct rfcomm_dev_info *di;
461 int n = 0, size, err;
466 if (get_user(dev_num, (u16 __user *) arg))
469 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
472 size = sizeof(*dl) + dev_num * sizeof(*di);
474 if (!(dl = kmalloc(size, GFP_KERNEL)))
479 read_lock_bh(&rfcomm_dev_lock);
481 list_for_each(p, &rfcomm_dev_list) {
482 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
483 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
485 (di + n)->id = dev->id;
486 (di + n)->flags = dev->flags;
487 (di + n)->state = dev->dlc->state;
488 (di + n)->channel = dev->channel;
489 bacpy(&(di + n)->src, &dev->src);
490 bacpy(&(di + n)->dst, &dev->dst);
495 read_unlock_bh(&rfcomm_dev_lock);
498 size = sizeof(*dl) + n * sizeof(*di);
500 err = copy_to_user(arg, dl, size);
503 return err ? -EFAULT : 0;
506 static int rfcomm_get_dev_info(void __user *arg)
508 struct rfcomm_dev *dev;
509 struct rfcomm_dev_info di;
514 if (copy_from_user(&di, arg, sizeof(di)))
517 if (!(dev = rfcomm_dev_get(di.id)))
520 di.flags = dev->flags;
521 di.channel = dev->channel;
522 di.state = dev->dlc->state;
523 bacpy(&di.src, &dev->src);
524 bacpy(&di.dst, &dev->dst);
526 if (copy_to_user(arg, &di, sizeof(di)))
533 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
535 BT_DBG("cmd %d arg %p", cmd, arg);
538 case RFCOMMCREATEDEV:
539 return rfcomm_create_dev(sk, arg);
541 case RFCOMMRELEASEDEV:
542 return rfcomm_release_dev(arg);
544 case RFCOMMGETDEVLIST:
545 return rfcomm_get_dev_list(arg);
547 case RFCOMMGETDEVINFO:
548 return rfcomm_get_dev_info(arg);
554 /* ---- DLC callbacks ---- */
555 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
557 struct rfcomm_dev *dev = dlc->owner;
558 struct tty_struct *tty;
565 if (!(tty = dev->tty) || !skb_queue_empty(&dev->pending)) {
566 skb_queue_tail(&dev->pending, skb);
570 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
572 tty_insert_flip_string(tty, skb->data, skb->len);
573 tty_flip_buffer_push(tty);
578 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
580 struct rfcomm_dev *dev = dlc->owner;
584 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
587 wake_up_interruptible(&dev->wait);
589 if (dlc->state == BT_CLOSED) {
591 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
592 /* Drop DLC lock here to avoid deadlock
593 * 1. rfcomm_dev_get will take rfcomm_dev_lock
594 * but in rfcomm_dev_add there's lock order:
595 * rfcomm_dev_lock -> dlc lock
596 * 2. rfcomm_dev_put will deadlock if it's
599 rfcomm_dlc_unlock(dlc);
600 if (rfcomm_dev_get(dev->id) == NULL) {
601 rfcomm_dlc_lock(dlc);
607 rfcomm_dlc_lock(dlc);
610 tty_hangup(dev->tty);
614 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
616 struct rfcomm_dev *dev = dlc->owner;
620 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
622 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
623 if (dev->tty && !C_CLOCAL(dev->tty))
624 tty_hangup(dev->tty);
628 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
629 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
630 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
631 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
634 /* ---- TTY functions ---- */
635 static void rfcomm_tty_wakeup(unsigned long arg)
637 struct rfcomm_dev *dev = (void *) arg;
638 struct tty_struct *tty = dev->tty;
642 BT_DBG("dev %p tty %p", dev, tty);
646 static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev)
648 struct tty_struct *tty = dev->tty;
655 BT_DBG("dev %p tty %p", dev, tty);
657 rfcomm_dlc_lock(dev->dlc);
659 while ((skb = skb_dequeue(&dev->pending))) {
660 inserted += tty_insert_flip_string(tty, skb->data, skb->len);
664 rfcomm_dlc_unlock(dev->dlc);
667 tty_flip_buffer_push(tty);
670 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
672 DECLARE_WAITQUEUE(wait, current);
673 struct rfcomm_dev *dev;
674 struct rfcomm_dlc *dlc;
679 BT_DBG("tty %p id %d", tty, id);
681 /* We don't leak this refcount. For reasons which are not entirely
682 clear, the TTY layer will call our ->close() method even if the
683 open fails. We decrease the refcount there, and decreasing it
684 here too would cause breakage. */
685 dev = rfcomm_dev_get(id);
689 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst),
690 dev->channel, atomic_read(&dev->opened));
692 if (atomic_inc_return(&dev->opened) > 1)
697 /* Attach TTY and open DLC */
699 rfcomm_dlc_lock(dlc);
700 tty->driver_data = dev;
702 rfcomm_dlc_unlock(dlc);
703 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
705 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
709 /* Wait for DLC to connect */
710 add_wait_queue(&dev->wait, &wait);
712 set_current_state(TASK_INTERRUPTIBLE);
714 if (dlc->state == BT_CLOSED) {
719 if (dlc->state == BT_CONNECTED)
722 if (signal_pending(current)) {
729 set_current_state(TASK_RUNNING);
730 remove_wait_queue(&dev->wait, &wait);
733 device_move(dev->tty_dev, rfcomm_get_device(dev));
735 rfcomm_tty_copy_pending(dev);
737 rfcomm_dlc_unthrottle(dev->dlc);
742 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
744 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
748 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc,
749 atomic_read(&dev->opened));
751 if (atomic_dec_and_test(&dev->opened)) {
752 if (dev->tty_dev->parent)
753 device_move(dev->tty_dev, NULL);
755 /* Close DLC and dettach TTY */
756 rfcomm_dlc_close(dev->dlc, 0);
758 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
759 tasklet_kill(&dev->wakeup_task);
761 rfcomm_dlc_lock(dev->dlc);
762 tty->driver_data = NULL;
764 rfcomm_dlc_unlock(dev->dlc);
766 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags)) {
767 write_lock_bh(&rfcomm_dev_lock);
768 list_del_init(&dev->list);
769 write_unlock_bh(&rfcomm_dev_lock);
778 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
780 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
781 struct rfcomm_dlc *dlc = dev->dlc;
783 int err = 0, sent = 0, size;
785 BT_DBG("tty %p count %d", tty, count);
788 size = min_t(uint, count, dlc->mtu);
790 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
795 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
797 memcpy(skb_put(skb, size), buf + sent, size);
799 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
808 return sent ? sent : err;
811 static int rfcomm_tty_write_room(struct tty_struct *tty)
813 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
816 BT_DBG("tty %p", tty);
818 if (!dev || !dev->dlc)
821 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
828 static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
830 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
834 BT_DBG("TCGETS is not supported");
838 BT_DBG("TCSETS is not supported");
842 BT_DBG("TIOCMIWAIT");
846 BT_DBG("TIOCGICOUNT");
850 BT_ERR("TIOCGSERIAL is not supported");
854 BT_ERR("TIOCSSERIAL is not supported");
858 BT_ERR("TIOCSERGSTRUCT is not supported");
862 BT_ERR("TIOCSERGETLSR is not supported");
866 BT_ERR("TIOCSERCONFIG is not supported");
870 return -ENOIOCTLCMD; /* ioctls which we must ignore */
877 static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
879 struct ktermios *new = tty->termios;
880 int old_baud_rate = tty_termios_baud_rate(old);
881 int new_baud_rate = tty_termios_baud_rate(new);
883 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
886 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
888 BT_DBG("tty %p termios %p", tty, old);
890 if (!dev || !dev->dlc || !dev->dlc->session)
893 /* Handle turning off CRTSCTS */
894 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
895 BT_DBG("Turning off CRTSCTS unsupported");
897 /* Parity on/off and when on, odd/even */
898 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
899 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) {
900 changes |= RFCOMM_RPN_PM_PARITY;
901 BT_DBG("Parity change detected.");
904 /* Mark and space parity are not supported! */
905 if (new->c_cflag & PARENB) {
906 if (new->c_cflag & PARODD) {
907 BT_DBG("Parity is ODD");
908 parity = RFCOMM_RPN_PARITY_ODD;
910 BT_DBG("Parity is EVEN");
911 parity = RFCOMM_RPN_PARITY_EVEN;
914 BT_DBG("Parity is OFF");
915 parity = RFCOMM_RPN_PARITY_NONE;
918 /* Setting the x_on / x_off characters */
919 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
920 BT_DBG("XOFF custom");
921 x_on = new->c_cc[VSTOP];
922 changes |= RFCOMM_RPN_PM_XON;
924 BT_DBG("XOFF default");
925 x_on = RFCOMM_RPN_XON_CHAR;
928 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
929 BT_DBG("XON custom");
930 x_off = new->c_cc[VSTART];
931 changes |= RFCOMM_RPN_PM_XOFF;
933 BT_DBG("XON default");
934 x_off = RFCOMM_RPN_XOFF_CHAR;
937 /* Handle setting of stop bits */
938 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
939 changes |= RFCOMM_RPN_PM_STOP;
941 /* POSIX does not support 1.5 stop bits and RFCOMM does not
942 * support 2 stop bits. So a request for 2 stop bits gets
943 * translated to 1.5 stop bits */
944 if (new->c_cflag & CSTOPB) {
945 stop_bits = RFCOMM_RPN_STOP_15;
947 stop_bits = RFCOMM_RPN_STOP_1;
950 /* Handle number of data bits [5-8] */
951 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
952 changes |= RFCOMM_RPN_PM_DATA;
954 switch (new->c_cflag & CSIZE) {
956 data_bits = RFCOMM_RPN_DATA_5;
959 data_bits = RFCOMM_RPN_DATA_6;
962 data_bits = RFCOMM_RPN_DATA_7;
965 data_bits = RFCOMM_RPN_DATA_8;
968 data_bits = RFCOMM_RPN_DATA_8;
972 /* Handle baudrate settings */
973 if (old_baud_rate != new_baud_rate)
974 changes |= RFCOMM_RPN_PM_BITRATE;
976 switch (new_baud_rate) {
978 baud = RFCOMM_RPN_BR_2400;
981 baud = RFCOMM_RPN_BR_4800;
984 baud = RFCOMM_RPN_BR_7200;
987 baud = RFCOMM_RPN_BR_9600;
990 baud = RFCOMM_RPN_BR_19200;
993 baud = RFCOMM_RPN_BR_38400;
996 baud = RFCOMM_RPN_BR_57600;
999 baud = RFCOMM_RPN_BR_115200;
1002 baud = RFCOMM_RPN_BR_230400;
1005 /* 9600 is standard accordinag to the RFCOMM specification */
1006 baud = RFCOMM_RPN_BR_9600;
1012 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
1013 data_bits, stop_bits, parity,
1014 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
1019 static void rfcomm_tty_throttle(struct tty_struct *tty)
1021 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1023 BT_DBG("tty %p dev %p", tty, dev);
1025 rfcomm_dlc_throttle(dev->dlc);
1028 static void rfcomm_tty_unthrottle(struct tty_struct *tty)
1030 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1032 BT_DBG("tty %p dev %p", tty, dev);
1034 rfcomm_dlc_unthrottle(dev->dlc);
1037 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
1039 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1041 BT_DBG("tty %p dev %p", tty, dev);
1043 if (!dev || !dev->dlc)
1046 if (!skb_queue_empty(&dev->dlc->tx_queue))
1047 return dev->dlc->mtu;
1052 static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
1054 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1056 BT_DBG("tty %p dev %p", tty, dev);
1058 if (!dev || !dev->dlc)
1061 skb_queue_purge(&dev->dlc->tx_queue);
1065 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1067 BT_DBG("tty %p ch %c", tty, ch);
1070 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1072 BT_DBG("tty %p timeout %d", tty, timeout);
1075 static void rfcomm_tty_hangup(struct tty_struct *tty)
1077 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1079 BT_DBG("tty %p dev %p", tty, dev);
1084 rfcomm_tty_flush_buffer(tty);
1086 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
1087 if (rfcomm_dev_get(dev->id) == NULL)
1089 rfcomm_dev_del(dev);
1090 rfcomm_dev_put(dev);
1094 static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused)
1099 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
1101 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1103 BT_DBG("tty %p dev %p", tty, dev);
1105 return dev->modem_status;
1108 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
1110 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1111 struct rfcomm_dlc *dlc = dev->dlc;
1114 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1116 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
1118 if (set & TIOCM_DSR || set & TIOCM_DTR)
1119 v24_sig |= RFCOMM_V24_RTC;
1120 if (set & TIOCM_RTS || set & TIOCM_CTS)
1121 v24_sig |= RFCOMM_V24_RTR;
1123 v24_sig |= RFCOMM_V24_IC;
1125 v24_sig |= RFCOMM_V24_DV;
1127 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1128 v24_sig &= ~RFCOMM_V24_RTC;
1129 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1130 v24_sig &= ~RFCOMM_V24_RTR;
1131 if (clear & TIOCM_RI)
1132 v24_sig &= ~RFCOMM_V24_IC;
1133 if (clear & TIOCM_CD)
1134 v24_sig &= ~RFCOMM_V24_DV;
1136 rfcomm_dlc_set_modem_status(dlc, v24_sig);
1141 /* ---- TTY structure ---- */
1143 static const struct tty_operations rfcomm_ops = {
1144 .open = rfcomm_tty_open,
1145 .close = rfcomm_tty_close,
1146 .write = rfcomm_tty_write,
1147 .write_room = rfcomm_tty_write_room,
1148 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1149 .flush_buffer = rfcomm_tty_flush_buffer,
1150 .ioctl = rfcomm_tty_ioctl,
1151 .throttle = rfcomm_tty_throttle,
1152 .unthrottle = rfcomm_tty_unthrottle,
1153 .set_termios = rfcomm_tty_set_termios,
1154 .send_xchar = rfcomm_tty_send_xchar,
1155 .hangup = rfcomm_tty_hangup,
1156 .wait_until_sent = rfcomm_tty_wait_until_sent,
1157 .read_proc = rfcomm_tty_read_proc,
1158 .tiocmget = rfcomm_tty_tiocmget,
1159 .tiocmset = rfcomm_tty_tiocmset,
1162 int rfcomm_init_ttys(void)
1164 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1165 if (!rfcomm_tty_driver)
1168 rfcomm_tty_driver->owner = THIS_MODULE;
1169 rfcomm_tty_driver->driver_name = "rfcomm";
1170 rfcomm_tty_driver->name = "rfcomm";
1171 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1172 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1173 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1174 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1175 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1176 rfcomm_tty_driver->init_termios = tty_std_termios;
1177 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1178 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
1179 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1181 if (tty_register_driver(rfcomm_tty_driver)) {
1182 BT_ERR("Can't register RFCOMM TTY driver");
1183 put_tty_driver(rfcomm_tty_driver);
1187 BT_INFO("RFCOMM TTY layer initialized");
1192 void rfcomm_cleanup_ttys(void)
1194 tty_unregister_driver(rfcomm_tty_driver);
1195 put_tty_driver(rfcomm_tty_driver);