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
);
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
);
312 dev_set_drvdata(dev
->tty_dev
, dev
);
314 if (device_create_file(dev
->tty_dev
, &dev_attr_address
) < 0)
315 BT_ERR("Failed to create address attribute");
317 if (device_create_file(dev
->tty_dev
, &dev_attr_channel
) < 0)
318 BT_ERR("Failed to create channel attribute");
327 static void rfcomm_dev_del(struct rfcomm_dev
*dev
)
329 BT_DBG("dev %p", dev
);
331 BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED
, &dev
->flags
));
333 if (atomic_read(&dev
->opened
) > 0)
336 write_lock_bh(&rfcomm_dev_lock
);
337 list_del_init(&dev
->list
);
338 write_unlock_bh(&rfcomm_dev_lock
);
343 /* ---- Send buffer ---- */
344 static inline unsigned int rfcomm_room(struct rfcomm_dlc
*dlc
)
346 /* We can't let it be zero, because we don't get a callback
347 when tx_credits becomes nonzero, hence we'd never wake up */
348 return dlc
->mtu
* (dlc
->tx_credits
?:1);
351 static void rfcomm_wfree(struct sk_buff
*skb
)
353 struct rfcomm_dev
*dev
= (void *) skb
->sk
;
354 atomic_sub(skb
->truesize
, &dev
->wmem_alloc
);
355 if (test_bit(RFCOMM_TTY_ATTACHED
, &dev
->flags
))
356 tasklet_schedule(&dev
->wakeup_task
);
360 static inline void rfcomm_set_owner_w(struct sk_buff
*skb
, struct rfcomm_dev
*dev
)
362 rfcomm_dev_hold(dev
);
363 atomic_add(skb
->truesize
, &dev
->wmem_alloc
);
364 skb
->sk
= (void *) dev
;
365 skb
->destructor
= rfcomm_wfree
;
368 static struct sk_buff
*rfcomm_wmalloc(struct rfcomm_dev
*dev
, unsigned long size
, gfp_t priority
)
370 if (atomic_read(&dev
->wmem_alloc
) < rfcomm_room(dev
->dlc
)) {
371 struct sk_buff
*skb
= alloc_skb(size
, priority
);
373 rfcomm_set_owner_w(skb
, dev
);
380 /* ---- Device IOCTLs ---- */
382 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
384 static int rfcomm_create_dev(struct sock
*sk
, void __user
*arg
)
386 struct rfcomm_dev_req req
;
387 struct rfcomm_dlc
*dlc
;
390 if (copy_from_user(&req
, arg
, sizeof(req
)))
393 BT_DBG("sk %p dev_id %d flags 0x%x", sk
, req
.dev_id
, req
.flags
);
395 if (req
.flags
!= NOCAP_FLAGS
&& !capable(CAP_NET_ADMIN
))
398 if (req
.flags
& (1 << RFCOMM_REUSE_DLC
)) {
399 /* Socket must be connected */
400 if (sk
->sk_state
!= BT_CONNECTED
)
403 dlc
= rfcomm_pi(sk
)->dlc
;
404 rfcomm_dlc_hold(dlc
);
406 dlc
= rfcomm_dlc_alloc(GFP_KERNEL
);
411 id
= rfcomm_dev_add(&req
, dlc
);
417 if (req
.flags
& (1 << RFCOMM_REUSE_DLC
)) {
418 /* DLC is now used by device.
419 * Socket must be disconnected */
420 sk
->sk_state
= BT_CLOSED
;
426 static int rfcomm_release_dev(void __user
*arg
)
428 struct rfcomm_dev_req req
;
429 struct rfcomm_dev
*dev
;
431 if (copy_from_user(&req
, arg
, sizeof(req
)))
434 BT_DBG("dev_id %d flags 0x%x", req
.dev_id
, req
.flags
);
436 if (!(dev
= rfcomm_dev_get(req
.dev_id
)))
439 if (dev
->flags
!= NOCAP_FLAGS
&& !capable(CAP_NET_ADMIN
)) {
444 if (req
.flags
& (1 << RFCOMM_HANGUP_NOW
))
445 rfcomm_dlc_close(dev
->dlc
, 0);
447 /* Shut down TTY synchronously before freeing rfcomm_dev */
449 tty_vhangup(dev
->tty
);
451 if (!test_bit(RFCOMM_RELEASE_ONHUP
, &dev
->flags
))
457 static int rfcomm_get_dev_list(void __user
*arg
)
459 struct rfcomm_dev_list_req
*dl
;
460 struct rfcomm_dev_info
*di
;
462 int n
= 0, size
, err
;
467 if (get_user(dev_num
, (u16 __user
*) arg
))
470 if (!dev_num
|| dev_num
> (PAGE_SIZE
* 4) / sizeof(*di
))
473 size
= sizeof(*dl
) + dev_num
* sizeof(*di
);
475 if (!(dl
= kmalloc(size
, GFP_KERNEL
)))
480 read_lock_bh(&rfcomm_dev_lock
);
482 list_for_each(p
, &rfcomm_dev_list
) {
483 struct rfcomm_dev
*dev
= list_entry(p
, struct rfcomm_dev
, list
);
484 if (test_bit(RFCOMM_TTY_RELEASED
, &dev
->flags
))
486 (di
+ n
)->id
= dev
->id
;
487 (di
+ n
)->flags
= dev
->flags
;
488 (di
+ n
)->state
= dev
->dlc
->state
;
489 (di
+ n
)->channel
= dev
->channel
;
490 bacpy(&(di
+ n
)->src
, &dev
->src
);
491 bacpy(&(di
+ n
)->dst
, &dev
->dst
);
496 read_unlock_bh(&rfcomm_dev_lock
);
499 size
= sizeof(*dl
) + n
* sizeof(*di
);
501 err
= copy_to_user(arg
, dl
, size
);
504 return err
? -EFAULT
: 0;
507 static int rfcomm_get_dev_info(void __user
*arg
)
509 struct rfcomm_dev
*dev
;
510 struct rfcomm_dev_info di
;
515 if (copy_from_user(&di
, arg
, sizeof(di
)))
518 if (!(dev
= rfcomm_dev_get(di
.id
)))
521 di
.flags
= dev
->flags
;
522 di
.channel
= dev
->channel
;
523 di
.state
= dev
->dlc
->state
;
524 bacpy(&di
.src
, &dev
->src
);
525 bacpy(&di
.dst
, &dev
->dst
);
527 if (copy_to_user(arg
, &di
, sizeof(di
)))
534 int rfcomm_dev_ioctl(struct sock
*sk
, unsigned int cmd
, void __user
*arg
)
536 BT_DBG("cmd %d arg %p", cmd
, arg
);
539 case RFCOMMCREATEDEV
:
540 return rfcomm_create_dev(sk
, arg
);
542 case RFCOMMRELEASEDEV
:
543 return rfcomm_release_dev(arg
);
545 case RFCOMMGETDEVLIST
:
546 return rfcomm_get_dev_list(arg
);
548 case RFCOMMGETDEVINFO
:
549 return rfcomm_get_dev_info(arg
);
555 /* ---- DLC callbacks ---- */
556 static void rfcomm_dev_data_ready(struct rfcomm_dlc
*dlc
, struct sk_buff
*skb
)
558 struct rfcomm_dev
*dev
= dlc
->owner
;
559 struct tty_struct
*tty
;
566 if (!(tty
= dev
->tty
) || !skb_queue_empty(&dev
->pending
)) {
567 skb_queue_tail(&dev
->pending
, skb
);
571 BT_DBG("dlc %p tty %p len %d", dlc
, tty
, skb
->len
);
573 tty_insert_flip_string(tty
, skb
->data
, skb
->len
);
574 tty_flip_buffer_push(tty
);
579 static void rfcomm_dev_state_change(struct rfcomm_dlc
*dlc
, int err
)
581 struct rfcomm_dev
*dev
= dlc
->owner
;
585 BT_DBG("dlc %p dev %p err %d", dlc
, dev
, err
);
588 wake_up_interruptible(&dev
->wait
);
590 if (dlc
->state
== BT_CLOSED
) {
592 if (test_bit(RFCOMM_RELEASE_ONHUP
, &dev
->flags
)) {
593 /* Drop DLC lock here to avoid deadlock
594 * 1. rfcomm_dev_get will take rfcomm_dev_lock
595 * but in rfcomm_dev_add there's lock order:
596 * rfcomm_dev_lock -> dlc lock
597 * 2. rfcomm_dev_put will deadlock if it's
600 rfcomm_dlc_unlock(dlc
);
601 if (rfcomm_dev_get(dev
->id
) == NULL
) {
602 rfcomm_dlc_lock(dlc
);
608 rfcomm_dlc_lock(dlc
);
611 tty_hangup(dev
->tty
);
615 static void rfcomm_dev_modem_status(struct rfcomm_dlc
*dlc
, u8 v24_sig
)
617 struct rfcomm_dev
*dev
= dlc
->owner
;
621 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc
, dev
, v24_sig
);
623 if ((dev
->modem_status
& TIOCM_CD
) && !(v24_sig
& RFCOMM_V24_DV
)) {
624 if (dev
->tty
&& !C_CLOCAL(dev
->tty
))
625 tty_hangup(dev
->tty
);
629 ((v24_sig
& RFCOMM_V24_RTC
) ? (TIOCM_DSR
| TIOCM_DTR
) : 0) |
630 ((v24_sig
& RFCOMM_V24_RTR
) ? (TIOCM_RTS
| TIOCM_CTS
) : 0) |
631 ((v24_sig
& RFCOMM_V24_IC
) ? TIOCM_RI
: 0) |
632 ((v24_sig
& RFCOMM_V24_DV
) ? TIOCM_CD
: 0);
635 /* ---- TTY functions ---- */
636 static void rfcomm_tty_wakeup(unsigned long arg
)
638 struct rfcomm_dev
*dev
= (void *) arg
;
639 struct tty_struct
*tty
= dev
->tty
;
643 BT_DBG("dev %p tty %p", dev
, tty
);
647 static void rfcomm_tty_copy_pending(struct rfcomm_dev
*dev
)
649 struct tty_struct
*tty
= dev
->tty
;
656 BT_DBG("dev %p tty %p", dev
, tty
);
658 rfcomm_dlc_lock(dev
->dlc
);
660 while ((skb
= skb_dequeue(&dev
->pending
))) {
661 inserted
+= tty_insert_flip_string(tty
, skb
->data
, skb
->len
);
665 rfcomm_dlc_unlock(dev
->dlc
);
668 tty_flip_buffer_push(tty
);
671 static int rfcomm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
673 DECLARE_WAITQUEUE(wait
, current
);
674 struct rfcomm_dev
*dev
;
675 struct rfcomm_dlc
*dlc
;
680 BT_DBG("tty %p id %d", tty
, id
);
682 /* We don't leak this refcount. For reasons which are not entirely
683 clear, the TTY layer will call our ->close() method even if the
684 open fails. We decrease the refcount there, and decreasing it
685 here too would cause breakage. */
686 dev
= rfcomm_dev_get(id
);
690 BT_DBG("dev %p dst %s channel %d opened %d", dev
, batostr(&dev
->dst
),
691 dev
->channel
, atomic_read(&dev
->opened
));
693 if (atomic_inc_return(&dev
->opened
) > 1)
698 /* Attach TTY and open DLC */
700 rfcomm_dlc_lock(dlc
);
701 tty
->driver_data
= dev
;
703 rfcomm_dlc_unlock(dlc
);
704 set_bit(RFCOMM_TTY_ATTACHED
, &dev
->flags
);
706 err
= rfcomm_dlc_open(dlc
, &dev
->src
, &dev
->dst
, dev
->channel
);
710 /* Wait for DLC to connect */
711 add_wait_queue(&dev
->wait
, &wait
);
713 set_current_state(TASK_INTERRUPTIBLE
);
715 if (dlc
->state
== BT_CLOSED
) {
720 if (dlc
->state
== BT_CONNECTED
)
723 if (signal_pending(current
)) {
730 set_current_state(TASK_RUNNING
);
731 remove_wait_queue(&dev
->wait
, &wait
);
734 device_move(dev
->tty_dev
, rfcomm_get_device(dev
),
735 DPM_ORDER_DEV_AFTER_PARENT
);
737 rfcomm_tty_copy_pending(dev
);
739 rfcomm_dlc_unthrottle(dev
->dlc
);
744 static void rfcomm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
746 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
750 BT_DBG("tty %p dev %p dlc %p opened %d", tty
, dev
, dev
->dlc
,
751 atomic_read(&dev
->opened
));
753 if (atomic_dec_and_test(&dev
->opened
)) {
754 if (dev
->tty_dev
->parent
)
755 device_move(dev
->tty_dev
, NULL
, DPM_ORDER_DEV_LAST
);
757 /* Close DLC and dettach TTY */
758 rfcomm_dlc_close(dev
->dlc
, 0);
760 clear_bit(RFCOMM_TTY_ATTACHED
, &dev
->flags
);
761 tasklet_kill(&dev
->wakeup_task
);
763 rfcomm_dlc_lock(dev
->dlc
);
764 tty
->driver_data
= NULL
;
766 rfcomm_dlc_unlock(dev
->dlc
);
768 if (test_bit(RFCOMM_TTY_RELEASED
, &dev
->flags
)) {
769 write_lock_bh(&rfcomm_dev_lock
);
770 list_del_init(&dev
->list
);
771 write_unlock_bh(&rfcomm_dev_lock
);
780 static int rfcomm_tty_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
782 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
783 struct rfcomm_dlc
*dlc
= dev
->dlc
;
785 int err
= 0, sent
= 0, size
;
787 BT_DBG("tty %p count %d", tty
, count
);
790 size
= min_t(uint
, count
, dlc
->mtu
);
792 skb
= rfcomm_wmalloc(dev
, size
+ RFCOMM_SKB_RESERVE
, GFP_ATOMIC
);
797 skb_reserve(skb
, RFCOMM_SKB_HEAD_RESERVE
);
799 memcpy(skb_put(skb
, size
), buf
+ sent
, size
);
801 if ((err
= rfcomm_dlc_send(dlc
, skb
)) < 0) {
810 return sent
? sent
: err
;
813 static int rfcomm_tty_write_room(struct tty_struct
*tty
)
815 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
818 BT_DBG("tty %p", tty
);
820 if (!dev
|| !dev
->dlc
)
823 room
= rfcomm_room(dev
->dlc
) - atomic_read(&dev
->wmem_alloc
);
830 static int rfcomm_tty_ioctl(struct tty_struct
*tty
, struct file
*filp
, unsigned int cmd
, unsigned long arg
)
832 BT_DBG("tty %p cmd 0x%02x", tty
, cmd
);
836 BT_DBG("TCGETS is not supported");
840 BT_DBG("TCSETS is not supported");
844 BT_DBG("TIOCMIWAIT");
848 BT_ERR("TIOCGSERIAL is not supported");
852 BT_ERR("TIOCSSERIAL is not supported");
856 BT_ERR("TIOCSERGSTRUCT is not supported");
860 BT_ERR("TIOCSERGETLSR is not supported");
864 BT_ERR("TIOCSERCONFIG is not supported");
868 return -ENOIOCTLCMD
; /* ioctls which we must ignore */
875 static void rfcomm_tty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
877 struct ktermios
*new = tty
->termios
;
878 int old_baud_rate
= tty_termios_baud_rate(old
);
879 int new_baud_rate
= tty_termios_baud_rate(new);
881 u8 baud
, data_bits
, stop_bits
, parity
, x_on
, x_off
;
884 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
886 BT_DBG("tty %p termios %p", tty
, old
);
888 if (!dev
|| !dev
->dlc
|| !dev
->dlc
->session
)
891 /* Handle turning off CRTSCTS */
892 if ((old
->c_cflag
& CRTSCTS
) && !(new->c_cflag
& CRTSCTS
))
893 BT_DBG("Turning off CRTSCTS unsupported");
895 /* Parity on/off and when on, odd/even */
896 if (((old
->c_cflag
& PARENB
) != (new->c_cflag
& PARENB
)) ||
897 ((old
->c_cflag
& PARODD
) != (new->c_cflag
& PARODD
)) ) {
898 changes
|= RFCOMM_RPN_PM_PARITY
;
899 BT_DBG("Parity change detected.");
902 /* Mark and space parity are not supported! */
903 if (new->c_cflag
& PARENB
) {
904 if (new->c_cflag
& PARODD
) {
905 BT_DBG("Parity is ODD");
906 parity
= RFCOMM_RPN_PARITY_ODD
;
908 BT_DBG("Parity is EVEN");
909 parity
= RFCOMM_RPN_PARITY_EVEN
;
912 BT_DBG("Parity is OFF");
913 parity
= RFCOMM_RPN_PARITY_NONE
;
916 /* Setting the x_on / x_off characters */
917 if (old
->c_cc
[VSTOP
] != new->c_cc
[VSTOP
]) {
918 BT_DBG("XOFF custom");
919 x_on
= new->c_cc
[VSTOP
];
920 changes
|= RFCOMM_RPN_PM_XON
;
922 BT_DBG("XOFF default");
923 x_on
= RFCOMM_RPN_XON_CHAR
;
926 if (old
->c_cc
[VSTART
] != new->c_cc
[VSTART
]) {
927 BT_DBG("XON custom");
928 x_off
= new->c_cc
[VSTART
];
929 changes
|= RFCOMM_RPN_PM_XOFF
;
931 BT_DBG("XON default");
932 x_off
= RFCOMM_RPN_XOFF_CHAR
;
935 /* Handle setting of stop bits */
936 if ((old
->c_cflag
& CSTOPB
) != (new->c_cflag
& CSTOPB
))
937 changes
|= RFCOMM_RPN_PM_STOP
;
939 /* POSIX does not support 1.5 stop bits and RFCOMM does not
940 * support 2 stop bits. So a request for 2 stop bits gets
941 * translated to 1.5 stop bits */
942 if (new->c_cflag
& CSTOPB
) {
943 stop_bits
= RFCOMM_RPN_STOP_15
;
945 stop_bits
= RFCOMM_RPN_STOP_1
;
948 /* Handle number of data bits [5-8] */
949 if ((old
->c_cflag
& CSIZE
) != (new->c_cflag
& CSIZE
))
950 changes
|= RFCOMM_RPN_PM_DATA
;
952 switch (new->c_cflag
& CSIZE
) {
954 data_bits
= RFCOMM_RPN_DATA_5
;
957 data_bits
= RFCOMM_RPN_DATA_6
;
960 data_bits
= RFCOMM_RPN_DATA_7
;
963 data_bits
= RFCOMM_RPN_DATA_8
;
966 data_bits
= RFCOMM_RPN_DATA_8
;
970 /* Handle baudrate settings */
971 if (old_baud_rate
!= new_baud_rate
)
972 changes
|= RFCOMM_RPN_PM_BITRATE
;
974 switch (new_baud_rate
) {
976 baud
= RFCOMM_RPN_BR_2400
;
979 baud
= RFCOMM_RPN_BR_4800
;
982 baud
= RFCOMM_RPN_BR_7200
;
985 baud
= RFCOMM_RPN_BR_9600
;
988 baud
= RFCOMM_RPN_BR_19200
;
991 baud
= RFCOMM_RPN_BR_38400
;
994 baud
= RFCOMM_RPN_BR_57600
;
997 baud
= RFCOMM_RPN_BR_115200
;
1000 baud
= RFCOMM_RPN_BR_230400
;
1003 /* 9600 is standard accordinag to the RFCOMM specification */
1004 baud
= RFCOMM_RPN_BR_9600
;
1010 rfcomm_send_rpn(dev
->dlc
->session
, 1, dev
->dlc
->dlci
, baud
,
1011 data_bits
, stop_bits
, parity
,
1012 RFCOMM_RPN_FLOW_NONE
, x_on
, x_off
, changes
);
1015 static void rfcomm_tty_throttle(struct tty_struct
*tty
)
1017 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1019 BT_DBG("tty %p dev %p", tty
, dev
);
1021 rfcomm_dlc_throttle(dev
->dlc
);
1024 static void rfcomm_tty_unthrottle(struct tty_struct
*tty
)
1026 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1028 BT_DBG("tty %p dev %p", tty
, dev
);
1030 rfcomm_dlc_unthrottle(dev
->dlc
);
1033 static int rfcomm_tty_chars_in_buffer(struct tty_struct
*tty
)
1035 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1037 BT_DBG("tty %p dev %p", tty
, dev
);
1039 if (!dev
|| !dev
->dlc
)
1042 if (!skb_queue_empty(&dev
->dlc
->tx_queue
))
1043 return dev
->dlc
->mtu
;
1048 static void rfcomm_tty_flush_buffer(struct tty_struct
*tty
)
1050 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1052 BT_DBG("tty %p dev %p", tty
, dev
);
1054 if (!dev
|| !dev
->dlc
)
1057 skb_queue_purge(&dev
->dlc
->tx_queue
);
1061 static void rfcomm_tty_send_xchar(struct tty_struct
*tty
, char ch
)
1063 BT_DBG("tty %p ch %c", tty
, ch
);
1066 static void rfcomm_tty_wait_until_sent(struct tty_struct
*tty
, int timeout
)
1068 BT_DBG("tty %p timeout %d", tty
, timeout
);
1071 static void rfcomm_tty_hangup(struct tty_struct
*tty
)
1073 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1075 BT_DBG("tty %p dev %p", tty
, dev
);
1080 rfcomm_tty_flush_buffer(tty
);
1082 if (test_bit(RFCOMM_RELEASE_ONHUP
, &dev
->flags
)) {
1083 if (rfcomm_dev_get(dev
->id
) == NULL
)
1085 rfcomm_dev_del(dev
);
1086 rfcomm_dev_put(dev
);
1090 static int rfcomm_tty_tiocmget(struct tty_struct
*tty
, struct file
*filp
)
1092 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1094 BT_DBG("tty %p dev %p", tty
, dev
);
1096 return dev
->modem_status
;
1099 static int rfcomm_tty_tiocmset(struct tty_struct
*tty
, struct file
*filp
, unsigned int set
, unsigned int clear
)
1101 struct rfcomm_dev
*dev
= (struct rfcomm_dev
*) tty
->driver_data
;
1102 struct rfcomm_dlc
*dlc
= dev
->dlc
;
1105 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty
, dev
, set
, clear
);
1107 rfcomm_dlc_get_modem_status(dlc
, &v24_sig
);
1109 if (set
& TIOCM_DSR
|| set
& TIOCM_DTR
)
1110 v24_sig
|= RFCOMM_V24_RTC
;
1111 if (set
& TIOCM_RTS
|| set
& TIOCM_CTS
)
1112 v24_sig
|= RFCOMM_V24_RTR
;
1114 v24_sig
|= RFCOMM_V24_IC
;
1116 v24_sig
|= RFCOMM_V24_DV
;
1118 if (clear
& TIOCM_DSR
|| clear
& TIOCM_DTR
)
1119 v24_sig
&= ~RFCOMM_V24_RTC
;
1120 if (clear
& TIOCM_RTS
|| clear
& TIOCM_CTS
)
1121 v24_sig
&= ~RFCOMM_V24_RTR
;
1122 if (clear
& TIOCM_RI
)
1123 v24_sig
&= ~RFCOMM_V24_IC
;
1124 if (clear
& TIOCM_CD
)
1125 v24_sig
&= ~RFCOMM_V24_DV
;
1127 rfcomm_dlc_set_modem_status(dlc
, v24_sig
);
1132 /* ---- TTY structure ---- */
1134 static const struct tty_operations rfcomm_ops
= {
1135 .open
= rfcomm_tty_open
,
1136 .close
= rfcomm_tty_close
,
1137 .write
= rfcomm_tty_write
,
1138 .write_room
= rfcomm_tty_write_room
,
1139 .chars_in_buffer
= rfcomm_tty_chars_in_buffer
,
1140 .flush_buffer
= rfcomm_tty_flush_buffer
,
1141 .ioctl
= rfcomm_tty_ioctl
,
1142 .throttle
= rfcomm_tty_throttle
,
1143 .unthrottle
= rfcomm_tty_unthrottle
,
1144 .set_termios
= rfcomm_tty_set_termios
,
1145 .send_xchar
= rfcomm_tty_send_xchar
,
1146 .hangup
= rfcomm_tty_hangup
,
1147 .wait_until_sent
= rfcomm_tty_wait_until_sent
,
1148 .tiocmget
= rfcomm_tty_tiocmget
,
1149 .tiocmset
= rfcomm_tty_tiocmset
,
1152 int __init
rfcomm_init_ttys(void)
1154 rfcomm_tty_driver
= alloc_tty_driver(RFCOMM_TTY_PORTS
);
1155 if (!rfcomm_tty_driver
)
1158 rfcomm_tty_driver
->owner
= THIS_MODULE
;
1159 rfcomm_tty_driver
->driver_name
= "rfcomm";
1160 rfcomm_tty_driver
->name
= "rfcomm";
1161 rfcomm_tty_driver
->major
= RFCOMM_TTY_MAJOR
;
1162 rfcomm_tty_driver
->minor_start
= RFCOMM_TTY_MINOR
;
1163 rfcomm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1164 rfcomm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1165 rfcomm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1166 rfcomm_tty_driver
->init_termios
= tty_std_termios
;
1167 rfcomm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1168 rfcomm_tty_driver
->init_termios
.c_lflag
&= ~ICANON
;
1169 tty_set_operations(rfcomm_tty_driver
, &rfcomm_ops
);
1171 if (tty_register_driver(rfcomm_tty_driver
)) {
1172 BT_ERR("Can't register RFCOMM TTY driver");
1173 put_tty_driver(rfcomm_tty_driver
);
1177 BT_INFO("RFCOMM TTY layer initialized");
1182 void rfcomm_cleanup_ttys(void)
1184 tty_unregister_driver(rfcomm_tty_driver
);
1185 put_tty_driver(rfcomm_tty_driver
);