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);
186 return sprintf(buf, "%s\n", batostr(&dev->dst));
189 static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
191 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
192 return sprintf(buf, "%d\n", dev->channel);
195 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
196 static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
198 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
200 struct rfcomm_dev *dev;
201 struct list_head *head = &rfcomm_dev_list, *p;
204 BT_DBG("id %d channel %d", req->dev_id, req->channel);
206 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
210 write_lock_bh(&rfcomm_dev_lock);
212 if (req->dev_id < 0) {
215 list_for_each(p, &rfcomm_dev_list) {
216 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
223 dev->id = req->dev_id;
225 list_for_each(p, &rfcomm_dev_list) {
226 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
228 if (entry->id == dev->id) {
233 if (entry->id > dev->id - 1)
240 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
245 sprintf(dev->name, "rfcomm%d", dev->id);
247 list_add(&dev->list, head);
248 atomic_set(&dev->refcnt, 1);
250 bacpy(&dev->src, &req->src);
251 bacpy(&dev->dst, &req->dst);
252 dev->channel = req->channel;
254 dev->flags = req->flags &
255 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
257 atomic_set(&dev->opened, 0);
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);
302 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
304 if (IS_ERR(dev->tty_dev)) {
305 err = PTR_ERR(dev->tty_dev);
306 list_del(&dev->list);
310 dev_set_drvdata(dev->tty_dev, dev);
312 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
313 BT_ERR("Failed to create address attribute");
315 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
316 BT_ERR("Failed to create channel attribute");
325 static void rfcomm_dev_del(struct rfcomm_dev *dev)
327 BT_DBG("dev %p", dev);
329 BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags));
331 if (atomic_read(&dev->opened) > 0)
334 write_lock_bh(&rfcomm_dev_lock);
335 list_del_init(&dev->list);
336 write_unlock_bh(&rfcomm_dev_lock);
341 /* ---- Send buffer ---- */
342 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
344 /* We can't let it be zero, because we don't get a callback
345 when tx_credits becomes nonzero, hence we'd never wake up */
346 return dlc->mtu * (dlc->tx_credits?:1);
349 static void rfcomm_wfree(struct sk_buff *skb)
351 struct rfcomm_dev *dev = (void *) skb->sk;
352 atomic_sub(skb->truesize, &dev->wmem_alloc);
353 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
354 tasklet_schedule(&dev->wakeup_task);
358 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
360 rfcomm_dev_hold(dev);
361 atomic_add(skb->truesize, &dev->wmem_alloc);
362 skb->sk = (void *) dev;
363 skb->destructor = rfcomm_wfree;
366 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
368 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
369 struct sk_buff *skb = alloc_skb(size, priority);
371 rfcomm_set_owner_w(skb, dev);
378 /* ---- Device IOCTLs ---- */
380 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
382 static int rfcomm_create_dev(struct sock *sk, void __user *arg)
384 struct rfcomm_dev_req req;
385 struct rfcomm_dlc *dlc;
388 if (copy_from_user(&req, arg, sizeof(req)))
391 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
393 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
396 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
397 /* Socket must be connected */
398 if (sk->sk_state != BT_CONNECTED)
401 dlc = rfcomm_pi(sk)->dlc;
402 rfcomm_dlc_hold(dlc);
404 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
409 id = rfcomm_dev_add(&req, dlc);
415 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
416 /* DLC is now used by device.
417 * Socket must be disconnected */
418 sk->sk_state = BT_CLOSED;
424 static int rfcomm_release_dev(void __user *arg)
426 struct rfcomm_dev_req req;
427 struct rfcomm_dev *dev;
429 if (copy_from_user(&req, arg, sizeof(req)))
432 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
434 if (!(dev = rfcomm_dev_get(req.dev_id)))
437 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
442 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
443 rfcomm_dlc_close(dev->dlc, 0);
445 /* Shut down TTY synchronously before freeing rfcomm_dev */
447 tty_vhangup(dev->tty);
449 if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
455 static int rfcomm_get_dev_list(void __user *arg)
457 struct rfcomm_dev_list_req *dl;
458 struct rfcomm_dev_info *di;
460 int n = 0, size, err;
465 if (get_user(dev_num, (u16 __user *) arg))
468 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
471 size = sizeof(*dl) + dev_num * sizeof(*di);
473 if (!(dl = kmalloc(size, GFP_KERNEL)))
478 read_lock_bh(&rfcomm_dev_lock);
480 list_for_each(p, &rfcomm_dev_list) {
481 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
482 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
484 (di + n)->id = dev->id;
485 (di + n)->flags = dev->flags;
486 (di + n)->state = dev->dlc->state;
487 (di + n)->channel = dev->channel;
488 bacpy(&(di + n)->src, &dev->src);
489 bacpy(&(di + n)->dst, &dev->dst);
494 read_unlock_bh(&rfcomm_dev_lock);
497 size = sizeof(*dl) + n * sizeof(*di);
499 err = copy_to_user(arg, dl, size);
502 return err ? -EFAULT : 0;
505 static int rfcomm_get_dev_info(void __user *arg)
507 struct rfcomm_dev *dev;
508 struct rfcomm_dev_info di;
513 if (copy_from_user(&di, arg, sizeof(di)))
516 if (!(dev = rfcomm_dev_get(di.id)))
519 di.flags = dev->flags;
520 di.channel = dev->channel;
521 di.state = dev->dlc->state;
522 bacpy(&di.src, &dev->src);
523 bacpy(&di.dst, &dev->dst);
525 if (copy_to_user(arg, &di, sizeof(di)))
532 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
534 BT_DBG("cmd %d arg %p", cmd, arg);
537 case RFCOMMCREATEDEV:
538 return rfcomm_create_dev(sk, arg);
540 case RFCOMMRELEASEDEV:
541 return rfcomm_release_dev(arg);
543 case RFCOMMGETDEVLIST:
544 return rfcomm_get_dev_list(arg);
546 case RFCOMMGETDEVINFO:
547 return rfcomm_get_dev_info(arg);
553 /* ---- DLC callbacks ---- */
554 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
556 struct rfcomm_dev *dev = dlc->owner;
557 struct tty_struct *tty;
564 if (!(tty = dev->tty) || !skb_queue_empty(&dev->pending)) {
565 skb_queue_tail(&dev->pending, skb);
569 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
571 tty_insert_flip_string(tty, skb->data, skb->len);
572 tty_flip_buffer_push(tty);
577 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
579 struct rfcomm_dev *dev = dlc->owner;
583 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
586 wake_up_interruptible(&dev->wait);
588 if (dlc->state == BT_CLOSED) {
590 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
591 /* Drop DLC lock here to avoid deadlock
592 * 1. rfcomm_dev_get will take rfcomm_dev_lock
593 * but in rfcomm_dev_add there's lock order:
594 * rfcomm_dev_lock -> dlc lock
595 * 2. rfcomm_dev_put will deadlock if it's
598 rfcomm_dlc_unlock(dlc);
599 if (rfcomm_dev_get(dev->id) == NULL) {
600 rfcomm_dlc_lock(dlc);
606 rfcomm_dlc_lock(dlc);
609 tty_hangup(dev->tty);
613 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
615 struct rfcomm_dev *dev = dlc->owner;
619 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
621 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
622 if (dev->tty && !C_CLOCAL(dev->tty))
623 tty_hangup(dev->tty);
627 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
628 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
629 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
630 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
633 /* ---- TTY functions ---- */
634 static void rfcomm_tty_wakeup(unsigned long arg)
636 struct rfcomm_dev *dev = (void *) arg;
637 struct tty_struct *tty = dev->tty;
641 BT_DBG("dev %p tty %p", dev, tty);
645 static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev)
647 struct tty_struct *tty = dev->tty;
654 BT_DBG("dev %p tty %p", dev, tty);
656 rfcomm_dlc_lock(dev->dlc);
658 while ((skb = skb_dequeue(&dev->pending))) {
659 inserted += tty_insert_flip_string(tty, skb->data, skb->len);
663 rfcomm_dlc_unlock(dev->dlc);
666 tty_flip_buffer_push(tty);
669 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
671 DECLARE_WAITQUEUE(wait, current);
672 struct rfcomm_dev *dev;
673 struct rfcomm_dlc *dlc;
678 BT_DBG("tty %p id %d", tty, id);
680 /* We don't leak this refcount. For reasons which are not entirely
681 clear, the TTY layer will call our ->close() method even if the
682 open fails. We decrease the refcount there, and decreasing it
683 here too would cause breakage. */
684 dev = rfcomm_dev_get(id);
688 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst),
689 dev->channel, atomic_read(&dev->opened));
691 if (atomic_inc_return(&dev->opened) > 1)
696 /* Attach TTY and open DLC */
698 rfcomm_dlc_lock(dlc);
699 tty->driver_data = dev;
701 rfcomm_dlc_unlock(dlc);
702 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
704 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
708 /* Wait for DLC to connect */
709 add_wait_queue(&dev->wait, &wait);
711 set_current_state(TASK_INTERRUPTIBLE);
713 if (dlc->state == BT_CLOSED) {
718 if (dlc->state == BT_CONNECTED)
721 if (signal_pending(current)) {
728 set_current_state(TASK_RUNNING);
729 remove_wait_queue(&dev->wait, &wait);
732 device_move(dev->tty_dev, rfcomm_get_device(dev),
733 DPM_ORDER_DEV_AFTER_PARENT);
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, DPM_ORDER_DEV_LAST);
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);
1017 static void rfcomm_tty_throttle(struct tty_struct *tty)
1019 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1021 BT_DBG("tty %p dev %p", tty, dev);
1023 rfcomm_dlc_throttle(dev->dlc);
1026 static void rfcomm_tty_unthrottle(struct tty_struct *tty)
1028 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1030 BT_DBG("tty %p dev %p", tty, dev);
1032 rfcomm_dlc_unthrottle(dev->dlc);
1035 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
1037 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1039 BT_DBG("tty %p dev %p", tty, dev);
1041 if (!dev || !dev->dlc)
1044 if (!skb_queue_empty(&dev->dlc->tx_queue))
1045 return dev->dlc->mtu;
1050 static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
1052 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1054 BT_DBG("tty %p dev %p", tty, dev);
1056 if (!dev || !dev->dlc)
1059 skb_queue_purge(&dev->dlc->tx_queue);
1063 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1065 BT_DBG("tty %p ch %c", tty, ch);
1068 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1070 BT_DBG("tty %p timeout %d", tty, timeout);
1073 static void rfcomm_tty_hangup(struct tty_struct *tty)
1075 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1077 BT_DBG("tty %p dev %p", tty, dev);
1082 rfcomm_tty_flush_buffer(tty);
1084 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
1085 if (rfcomm_dev_get(dev->id) == NULL)
1087 rfcomm_dev_del(dev);
1088 rfcomm_dev_put(dev);
1092 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
1094 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1096 BT_DBG("tty %p dev %p", tty, dev);
1098 return dev->modem_status;
1101 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
1103 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1104 struct rfcomm_dlc *dlc = dev->dlc;
1107 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1109 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
1111 if (set & TIOCM_DSR || set & TIOCM_DTR)
1112 v24_sig |= RFCOMM_V24_RTC;
1113 if (set & TIOCM_RTS || set & TIOCM_CTS)
1114 v24_sig |= RFCOMM_V24_RTR;
1116 v24_sig |= RFCOMM_V24_IC;
1118 v24_sig |= RFCOMM_V24_DV;
1120 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1121 v24_sig &= ~RFCOMM_V24_RTC;
1122 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1123 v24_sig &= ~RFCOMM_V24_RTR;
1124 if (clear & TIOCM_RI)
1125 v24_sig &= ~RFCOMM_V24_IC;
1126 if (clear & TIOCM_CD)
1127 v24_sig &= ~RFCOMM_V24_DV;
1129 rfcomm_dlc_set_modem_status(dlc, v24_sig);
1134 /* ---- TTY structure ---- */
1136 static const struct tty_operations rfcomm_ops = {
1137 .open = rfcomm_tty_open,
1138 .close = rfcomm_tty_close,
1139 .write = rfcomm_tty_write,
1140 .write_room = rfcomm_tty_write_room,
1141 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1142 .flush_buffer = rfcomm_tty_flush_buffer,
1143 .ioctl = rfcomm_tty_ioctl,
1144 .throttle = rfcomm_tty_throttle,
1145 .unthrottle = rfcomm_tty_unthrottle,
1146 .set_termios = rfcomm_tty_set_termios,
1147 .send_xchar = rfcomm_tty_send_xchar,
1148 .hangup = rfcomm_tty_hangup,
1149 .wait_until_sent = rfcomm_tty_wait_until_sent,
1150 .tiocmget = rfcomm_tty_tiocmget,
1151 .tiocmset = rfcomm_tty_tiocmset,
1154 int __init rfcomm_init_ttys(void)
1156 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1157 if (!rfcomm_tty_driver)
1160 rfcomm_tty_driver->owner = THIS_MODULE;
1161 rfcomm_tty_driver->driver_name = "rfcomm";
1162 rfcomm_tty_driver->name = "rfcomm";
1163 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1164 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1165 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1166 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1167 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1168 rfcomm_tty_driver->init_termios = tty_std_termios;
1169 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1170 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
1171 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1173 if (tty_register_driver(rfcomm_tty_driver)) {
1174 BT_ERR("Can't register RFCOMM TTY driver");
1175 put_tty_driver(rfcomm_tty_driver);
1179 BT_INFO("RFCOMM TTY layer initialized");
1184 void rfcomm_cleanup_ttys(void)
1186 tty_unregister_driver(rfcomm_tty_driver);
1187 put_tty_driver(rfcomm_tty_driver);