?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[DECNET]: Use correct config option for routing by fwmark in compare_keys()
[hh.org.git] / net / bluetooth / rfcomm / tty.c
blob1958ad1b8541e57be7f32bb70b2b19a242884dce
1 /*
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>
5
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;
9
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.
18
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.
22 */
23
24 /*
25 * RFCOMM TTY.
26 *
27 * $Id: tty.c,v 1.24 2002/10/03 01:54:38 holtmann Exp $
28 */
29
30 #include <linux/module.h>
31
32 #include <linux/tty.h>
33 #include <linux/tty_driver.h>
34 #include <linux/tty_flip.h>
35
36 #include <linux/capability.h>
37 #include <linux/slab.h>
38 #include <linux/skbuff.h>
39
40 #include <net/bluetooth/bluetooth.h>
41 #include <net/bluetooth/hci_core.h>
42 #include <net/bluetooth/rfcomm.h>
43
44 #ifndef CONFIG_BT_RFCOMM_DEBUG
45 #undef BT_DBG
46 #define BT_DBG(D...)
47 #endif
48
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
53
54 static struct tty_driver *rfcomm_tty_driver;
55
56 struct rfcomm_dev {
57 struct list_head list;
58 atomic_t refcnt;
59
60 char name[12];
61 int id;
62 unsigned long flags;
63 int opened;
64 int err;
65
66 bdaddr_t src;
67 bdaddr_t dst;
68 u8 channel;
69
70 uint modem_status;
71
72 struct rfcomm_dlc *dlc;
73 struct tty_struct *tty;
74 wait_queue_head_t wait;
75 struct tasklet_struct wakeup_task;
76
77 atomic_t wmem_alloc;
78 };
79
80 static LIST_HEAD(rfcomm_dev_list);
81 static DEFINE_RWLOCK(rfcomm_dev_lock);
82
83 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
84 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
85 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
86
87 static void rfcomm_tty_wakeup(unsigned long arg);
88
89 /* ---- Device functions ---- */
90 static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
91 {
92 struct rfcomm_dlc *dlc = dev->dlc;
93
94 BT_DBG("dev %p dlc %p", dev, dlc);
95
96 rfcomm_dlc_lock(dlc);
97 /* Detach DLC if it's owned by this dev */
98 if (dlc->owner == dev)
99 dlc->owner = NULL;
100 rfcomm_dlc_unlock(dlc);
101
102 rfcomm_dlc_put(dlc);
103
104 tty_unregister_device(rfcomm_tty_driver, dev->id);
105
106 /* Refcount should only hit zero when called from rfcomm_dev_del()
107 which will have taken us off the list. Everything else are
108 refcounting bugs. */
109 BUG_ON(!list_empty(&dev->list));
110
111 kfree(dev);
112
113 /* It's safe to call module_put() here because socket still
114 holds reference to this module. */
115 module_put(THIS_MODULE);
116 }
117
118 static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
119 {
120 atomic_inc(&dev->refcnt);
121 }
122
123 static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
124 {
125 /* The reason this isn't actually a race, as you no
126 doubt have a little voice screaming at you in your
127 head, is that the refcount should never actually
128 reach zero unless the device has already been taken
129 off the list, in rfcomm_dev_del(). And if that's not
130 true, we'll hit the BUG() in rfcomm_dev_destruct()
131 anyway. */
132 if (atomic_dec_and_test(&dev->refcnt))
133 rfcomm_dev_destruct(dev);
134 }
135
136 static struct rfcomm_dev *__rfcomm_dev_get(int id)
137 {
138 struct rfcomm_dev *dev;
139 struct list_head *p;
140
141 list_for_each(p, &rfcomm_dev_list) {
142 dev = list_entry(p, struct rfcomm_dev, list);
143 if (dev->id == id)
144 return dev;
145 }
146
147 return NULL;
148 }
149
150 static inline struct rfcomm_dev *rfcomm_dev_get(int id)
151 {
152 struct rfcomm_dev *dev;
153
154 read_lock(&rfcomm_dev_lock);
155
156 dev = __rfcomm_dev_get(id);
157 if (dev)
158 rfcomm_dev_hold(dev);
159
160 read_unlock(&rfcomm_dev_lock);
161
162 return dev;
163 }
164
165 static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
166 {
167 struct hci_dev *hdev;
168 struct hci_conn *conn;
169
170 hdev = hci_get_route(&dev->dst, &dev->src);
171 if (!hdev)
172 return NULL;
173
174 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
175 if (!conn)
176 return NULL;
177
178 hci_dev_put(hdev);
179
180 return &conn->dev;
181 }
182
183 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
184 {
185 struct rfcomm_dev *dev;
186 struct list_head *head = &rfcomm_dev_list, *p;
187 int err = 0;
188
189 BT_DBG("id %d channel %d", req->dev_id, req->channel);
190
191 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
192 if (!dev)
193 return -ENOMEM;
194
195 write_lock_bh(&rfcomm_dev_lock);
196
197 if (req->dev_id < 0) {
198 dev->id = 0;
199
200 list_for_each(p, &rfcomm_dev_list) {
201 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
202 break;
203
204 dev->id++;
205 head = p;
206 }
207 } else {
208 dev->id = req->dev_id;
209
210 list_for_each(p, &rfcomm_dev_list) {
211 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
212
213 if (entry->id == dev->id) {
214 err = -EADDRINUSE;
215 goto out;
216 }
217
218 if (entry->id > dev->id - 1)
219 break;
220
221 head = p;
222 }
223 }
224
225 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
226 err = -ENFILE;
227 goto out;
228 }
229
230 sprintf(dev->name, "rfcomm%d", dev->id);
231
232 list_add(&dev->list, head);
233 atomic_set(&dev->refcnt, 1);
234
235 bacpy(&dev->src, &req->src);
236 bacpy(&dev->dst, &req->dst);
237 dev->channel = req->channel;
238
239 dev->flags = req->flags &
240 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
241
242 init_waitqueue_head(&dev->wait);
243 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
244
245 rfcomm_dlc_lock(dlc);
246 dlc->data_ready = rfcomm_dev_data_ready;
247 dlc->state_change = rfcomm_dev_state_change;
248 dlc->modem_status = rfcomm_dev_modem_status;
249
250 dlc->owner = dev;
251 dev->dlc = dlc;
252 rfcomm_dlc_unlock(dlc);
253
254 /* It's safe to call __module_get() here because socket already
255 holds reference to this module. */
256 __module_get(THIS_MODULE);
257
258 out:
259 write_unlock_bh(&rfcomm_dev_lock);
260
261 if (err) {
262 kfree(dev);
263 return err;
264 }
265
266 tty_register_device(rfcomm_tty_driver, dev->id, rfcomm_get_device(dev));
267
268 return dev->id;
269 }
270
271 static void rfcomm_dev_del(struct rfcomm_dev *dev)
272 {
273 BT_DBG("dev %p", dev);
274
275 write_lock_bh(&rfcomm_dev_lock);
276 list_del_init(&dev->list);
277 write_unlock_bh(&rfcomm_dev_lock);
278
279 rfcomm_dev_put(dev);
280 }
281
282 /* ---- Send buffer ---- */
283 static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
284 {
285 /* We can't let it be zero, because we don't get a callback
286 when tx_credits becomes nonzero, hence we'd never wake up */
287 return dlc->mtu * (dlc->tx_credits?:1);
288 }
289
290 static void rfcomm_wfree(struct sk_buff *skb)
291 {
292 struct rfcomm_dev *dev = (void *) skb->sk;
293 atomic_sub(skb->truesize, &dev->wmem_alloc);
294 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
295 tasklet_schedule(&dev->wakeup_task);
296 rfcomm_dev_put(dev);
297 }
298
299 static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
300 {
301 rfcomm_dev_hold(dev);
302 atomic_add(skb->truesize, &dev->wmem_alloc);
303 skb->sk = (void *) dev;
304 skb->destructor = rfcomm_wfree;
305 }
306
307 static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
308 {
309 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
310 struct sk_buff *skb = alloc_skb(size, priority);
311 if (skb) {
312 rfcomm_set_owner_w(skb, dev);
313 return skb;
314 }
315 }
316 return NULL;
317 }
318
319 /* ---- Device IOCTLs ---- */
320
321 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
322
323 static int rfcomm_create_dev(struct sock *sk, void __user *arg)
324 {
325 struct rfcomm_dev_req req;
326 struct rfcomm_dlc *dlc;
327 int id;
328
329 if (copy_from_user(&req, arg, sizeof(req)))
330 return -EFAULT;
331
332 BT_DBG("sk %p dev_id %id flags 0x%x", sk, req.dev_id, req.flags);
333
334 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
335 return -EPERM;
336
337 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
338 /* Socket must be connected */
339 if (sk->sk_state != BT_CONNECTED)
340 return -EBADFD;
341
342 dlc = rfcomm_pi(sk)->dlc;
343 rfcomm_dlc_hold(dlc);
344 } else {
345 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
346 if (!dlc)
347 return -ENOMEM;
348 }
349
350 id = rfcomm_dev_add(&req, dlc);
351 if (id < 0) {
352 rfcomm_dlc_put(dlc);
353 return id;
354 }
355
356 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
357 /* DLC is now used by device.
358 * Socket must be disconnected */
359 sk->sk_state = BT_CLOSED;
360 }
361
362 return id;
363 }
364
365 static int rfcomm_release_dev(void __user *arg)
366 {
367 struct rfcomm_dev_req req;
368 struct rfcomm_dev *dev;
369
370 if (copy_from_user(&req, arg, sizeof(req)))
371 return -EFAULT;
372
373 BT_DBG("dev_id %id flags 0x%x", req.dev_id, req.flags);
374
375 if (!(dev = rfcomm_dev_get(req.dev_id)))
376 return -ENODEV;
377
378 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
379 rfcomm_dev_put(dev);
380 return -EPERM;
381 }
382
383 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
384 rfcomm_dlc_close(dev->dlc, 0);
385
386 rfcomm_dev_del(dev);
387 rfcomm_dev_put(dev);
388 return 0;
389 }
390
391 static int rfcomm_get_dev_list(void __user *arg)
392 {
393 struct rfcomm_dev_list_req *dl;
394 struct rfcomm_dev_info *di;
395 struct list_head *p;
396 int n = 0, size, err;
397 u16 dev_num;
398
399 BT_DBG("");
400
401 if (get_user(dev_num, (u16 __user *) arg))
402 return -EFAULT;
403
404 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
405 return -EINVAL;
406
407 size = sizeof(*dl) + dev_num * sizeof(*di);
408
409 if (!(dl = kmalloc(size, GFP_KERNEL)))
410 return -ENOMEM;
411
412 di = dl->dev_info;
413
414 read_lock_bh(&rfcomm_dev_lock);
415
416 list_for_each(p, &rfcomm_dev_list) {
417 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
418 (di + n)->id = dev->id;
419 (di + n)->flags = dev->flags;
420 (di + n)->state = dev->dlc->state;
421 (di + n)->channel = dev->channel;
422 bacpy(&(di + n)->src, &dev->src);
423 bacpy(&(di + n)->dst, &dev->dst);
424 if (++n >= dev_num)
425 break;
426 }
427
428 read_unlock_bh(&rfcomm_dev_lock);
429
430 dl->dev_num = n;
431 size = sizeof(*dl) + n * sizeof(*di);
432
433 err = copy_to_user(arg, dl, size);
434 kfree(dl);
435
436 return err ? -EFAULT : 0;
437 }
438
439 static int rfcomm_get_dev_info(void __user *arg)
440 {
441 struct rfcomm_dev *dev;
442 struct rfcomm_dev_info di;
443 int err = 0;
444
445 BT_DBG("");
446
447 if (copy_from_user(&di, arg, sizeof(di)))
448 return -EFAULT;
449
450 if (!(dev = rfcomm_dev_get(di.id)))
451 return -ENODEV;
452
453 di.flags = dev->flags;
454 di.channel = dev->channel;
455 di.state = dev->dlc->state;
456 bacpy(&di.src, &dev->src);
457 bacpy(&di.dst, &dev->dst);
458
459 if (copy_to_user(arg, &di, sizeof(di)))
460 err = -EFAULT;
461
462 rfcomm_dev_put(dev);
463 return err;
464 }
465
466 int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
467 {
468 BT_DBG("cmd %d arg %p", cmd, arg);
469
470 switch (cmd) {
471 case RFCOMMCREATEDEV:
472 return rfcomm_create_dev(sk, arg);
473
474 case RFCOMMRELEASEDEV:
475 return rfcomm_release_dev(arg);
476
477 case RFCOMMGETDEVLIST:
478 return rfcomm_get_dev_list(arg);
479
480 case RFCOMMGETDEVINFO:
481 return rfcomm_get_dev_info(arg);
482 }
483
484 return -EINVAL;
485 }
486
487 /* ---- DLC callbacks ---- */
488 static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
489 {
490 struct rfcomm_dev *dev = dlc->owner;
491 struct tty_struct *tty;
492
493 if (!dev || !(tty = dev->tty)) {
494 kfree_skb(skb);
495 return;
496 }
497
498 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
499
500 tty_insert_flip_string(tty, skb->data, skb->len);
501 tty_flip_buffer_push(tty);
502
503 kfree_skb(skb);
504 }
505
506 static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
507 {
508 struct rfcomm_dev *dev = dlc->owner;
509 if (!dev)
510 return;
511
512 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
513
514 dev->err = err;
515 wake_up_interruptible(&dev->wait);
516
517 if (dlc->state == BT_CLOSED) {
518 if (!dev->tty) {
519 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
520 rfcomm_dev_hold(dev);
521 rfcomm_dev_del(dev);
522
523 /* We have to drop DLC lock here, otherwise
524 rfcomm_dev_put() will dead lock if it's
525 the last reference. */
526 rfcomm_dlc_unlock(dlc);
527 rfcomm_dev_put(dev);
528 rfcomm_dlc_lock(dlc);
529 }
530 } else
531 tty_hangup(dev->tty);
532 }
533 }
534
535 static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
536 {
537 struct rfcomm_dev *dev = dlc->owner;
538 if (!dev)
539 return;
540
541 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
542
543 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
544 if (dev->tty && !C_CLOCAL(dev->tty))
545 tty_hangup(dev->tty);
546 }
547
548 dev->modem_status =
549 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
550 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
551 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
552 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
553 }
554
555 /* ---- TTY functions ---- */
556 static void rfcomm_tty_wakeup(unsigned long arg)
557 {
558 struct rfcomm_dev *dev = (void *) arg;
559 struct tty_struct *tty = dev->tty;
560 if (!tty)
561 return;
562
563 BT_DBG("dev %p tty %p", dev, tty);
564
565 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup)
566 (tty->ldisc.write_wakeup)(tty);
567
568 wake_up_interruptible(&tty->write_wait);
569 #ifdef SERIAL_HAVE_POLL_WAIT
570 wake_up_interruptible(&tty->poll_wait);
571 #endif
572 }
573
574 static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
575 {
576 DECLARE_WAITQUEUE(wait, current);
577 struct rfcomm_dev *dev;
578 struct rfcomm_dlc *dlc;
579 int err, id;
580
581 id = tty->index;
582
583 BT_DBG("tty %p id %d", tty, id);
584
585 /* We don't leak this refcount. For reasons which are not entirely
586 clear, the TTY layer will call our ->close() method even if the
587 open fails. We decrease the refcount there, and decreasing it
588 here too would cause breakage. */
589 dev = rfcomm_dev_get(id);
590 if (!dev)
591 return -ENODEV;
592
593 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst), dev->channel, dev->opened);
594
595 if (dev->opened++ != 0)
596 return 0;
597
598 dlc = dev->dlc;
599
600 /* Attach TTY and open DLC */
601
602 rfcomm_dlc_lock(dlc);
603 tty->driver_data = dev;
604 dev->tty = tty;
605 rfcomm_dlc_unlock(dlc);
606 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
607
608 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
609 if (err < 0)
610 return err;
611
612 /* Wait for DLC to connect */
613 add_wait_queue(&dev->wait, &wait);
614 while (1) {
615 set_current_state(TASK_INTERRUPTIBLE);
616
617 if (dlc->state == BT_CLOSED) {
618 err = -dev->err;
619 break;
620 }
621
622 if (dlc->state == BT_CONNECTED)
623 break;
624
625 if (signal_pending(current)) {
626 err = -EINTR;
627 break;
628 }
629
630 schedule();
631 }
632 set_current_state(TASK_RUNNING);
633 remove_wait_queue(&dev->wait, &wait);
634
635 return err;
636 }
637
638 static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
639 {
640 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
641 if (!dev)
642 return;
643
644 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, dev->opened);
645
646 if (--dev->opened == 0) {
647 /* Close DLC and dettach TTY */
648 rfcomm_dlc_close(dev->dlc, 0);
649
650 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
651 tasklet_kill(&dev->wakeup_task);
652
653 rfcomm_dlc_lock(dev->dlc);
654 tty->driver_data = NULL;
655 dev->tty = NULL;
656 rfcomm_dlc_unlock(dev->dlc);
657 }
658
659 rfcomm_dev_put(dev);
660 }
661
662 static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
663 {
664 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
665 struct rfcomm_dlc *dlc = dev->dlc;
666 struct sk_buff *skb;
667 int err = 0, sent = 0, size;
668
669 BT_DBG("tty %p count %d", tty, count);
670
671 while (count) {
672 size = min_t(uint, count, dlc->mtu);
673
674 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
675
676 if (!skb)
677 break;
678
679 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
680
681 memcpy(skb_put(skb, size), buf + sent, size);
682
683 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
684 kfree_skb(skb);
685 break;
686 }
687
688 sent += size;
689 count -= size;
690 }
691
692 return sent ? sent : err;
693 }
694
695 static int rfcomm_tty_write_room(struct tty_struct *tty)
696 {
697 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
698 int room;
699
700 BT_DBG("tty %p", tty);
701
702 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
703 if (room < 0)
704 room = 0;
705 return room;
706 }
707
708 static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
709 {
710 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
711
712 switch (cmd) {
713 case TCGETS:
714 BT_DBG("TCGETS is not supported");
715 return -ENOIOCTLCMD;
716
717 case TCSETS:
718 BT_DBG("TCSETS is not supported");
719 return -ENOIOCTLCMD;
720
721 case TIOCMIWAIT:
722 BT_DBG("TIOCMIWAIT");
723 break;
724
725 case TIOCGICOUNT:
726 BT_DBG("TIOCGICOUNT");
727 break;
728
729 case TIOCGSERIAL:
730 BT_ERR("TIOCGSERIAL is not supported");
731 return -ENOIOCTLCMD;
732
733 case TIOCSSERIAL:
734 BT_ERR("TIOCSSERIAL is not supported");
735 return -ENOIOCTLCMD;
736
737 case TIOCSERGSTRUCT:
738 BT_ERR("TIOCSERGSTRUCT is not supported");
739 return -ENOIOCTLCMD;
740
741 case TIOCSERGETLSR:
742 BT_ERR("TIOCSERGETLSR is not supported");
743 return -ENOIOCTLCMD;
744
745 case TIOCSERCONFIG:
746 BT_ERR("TIOCSERCONFIG is not supported");
747 return -ENOIOCTLCMD;
748
749 default:
750 return -ENOIOCTLCMD; /* ioctls which we must ignore */
751
752 }
753
754 return -ENOIOCTLCMD;
755 }
756
757 static void rfcomm_tty_set_termios(struct tty_struct *tty, struct termios *old)
758 {
759 struct termios *new = (struct termios *) tty->termios;
760 int old_baud_rate = tty_termios_baud_rate(old);
761 int new_baud_rate = tty_termios_baud_rate(new);
762
763 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
764 u16 changes = 0;
765
766 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
767
768 BT_DBG("tty %p termios %p", tty, old);
769
770 /* Handle turning off CRTSCTS */
771 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
772 BT_DBG("Turning off CRTSCTS unsupported");
773
774 /* Parity on/off and when on, odd/even */
775 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
776 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) {
777 changes |= RFCOMM_RPN_PM_PARITY;
778 BT_DBG("Parity change detected.");
779 }
780
781 /* Mark and space parity are not supported! */
782 if (new->c_cflag & PARENB) {
783 if (new->c_cflag & PARODD) {
784 BT_DBG("Parity is ODD");
785 parity = RFCOMM_RPN_PARITY_ODD;
786 } else {
787 BT_DBG("Parity is EVEN");
788 parity = RFCOMM_RPN_PARITY_EVEN;
789 }
790 } else {
791 BT_DBG("Parity is OFF");
792 parity = RFCOMM_RPN_PARITY_NONE;
793 }
794
795 /* Setting the x_on / x_off characters */
796 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
797 BT_DBG("XOFF custom");
798 x_on = new->c_cc[VSTOP];
799 changes |= RFCOMM_RPN_PM_XON;
800 } else {
801 BT_DBG("XOFF default");
802 x_on = RFCOMM_RPN_XON_CHAR;
803 }
804
805 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
806 BT_DBG("XON custom");
807 x_off = new->c_cc[VSTART];
808 changes |= RFCOMM_RPN_PM_XOFF;
809 } else {
810 BT_DBG("XON default");
811 x_off = RFCOMM_RPN_XOFF_CHAR;
812 }
813
814 /* Handle setting of stop bits */
815 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
816 changes |= RFCOMM_RPN_PM_STOP;
817
818 /* POSIX does not support 1.5 stop bits and RFCOMM does not
819 * support 2 stop bits. So a request for 2 stop bits gets
820 * translated to 1.5 stop bits */
821 if (new->c_cflag & CSTOPB) {
822 stop_bits = RFCOMM_RPN_STOP_15;
823 } else {
824 stop_bits = RFCOMM_RPN_STOP_1;
825 }
826
827 /* Handle number of data bits [5-8] */
828 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
829 changes |= RFCOMM_RPN_PM_DATA;
830
831 switch (new->c_cflag & CSIZE) {
832 case CS5:
833 data_bits = RFCOMM_RPN_DATA_5;
834 break;
835 case CS6:
836 data_bits = RFCOMM_RPN_DATA_6;
837 break;
838 case CS7:
839 data_bits = RFCOMM_RPN_DATA_7;
840 break;
841 case CS8:
842 data_bits = RFCOMM_RPN_DATA_8;
843 break;
844 default:
845 data_bits = RFCOMM_RPN_DATA_8;
846 break;
847 }
848
849 /* Handle baudrate settings */
850 if (old_baud_rate != new_baud_rate)
851 changes |= RFCOMM_RPN_PM_BITRATE;
852
853 switch (new_baud_rate) {
854 case 2400:
855 baud = RFCOMM_RPN_BR_2400;
856 break;
857 case 4800:
858 baud = RFCOMM_RPN_BR_4800;
859 break;
860 case 7200:
861 baud = RFCOMM_RPN_BR_7200;
862 break;
863 case 9600:
864 baud = RFCOMM_RPN_BR_9600;
865 break;
866 case 19200:
867 baud = RFCOMM_RPN_BR_19200;
868 break;
869 case 38400:
870 baud = RFCOMM_RPN_BR_38400;
871 break;
872 case 57600:
873 baud = RFCOMM_RPN_BR_57600;
874 break;
875 case 115200:
876 baud = RFCOMM_RPN_BR_115200;
877 break;
878 case 230400:
879 baud = RFCOMM_RPN_BR_230400;
880 break;
881 default:
882 /* 9600 is standard accordinag to the RFCOMM specification */
883 baud = RFCOMM_RPN_BR_9600;
884 break;
885
886 }
887
888 if (changes)
889 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
890 data_bits, stop_bits, parity,
891 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
892
893 return;
894 }
895
896 static void rfcomm_tty_throttle(struct tty_struct *tty)
897 {
898 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
899
900 BT_DBG("tty %p dev %p", tty, dev);
901
902 rfcomm_dlc_throttle(dev->dlc);
903 }
904
905 static void rfcomm_tty_unthrottle(struct tty_struct *tty)
906 {
907 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
908
909 BT_DBG("tty %p dev %p", tty, dev);
910
911 rfcomm_dlc_unthrottle(dev->dlc);
912 }
913
914 static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
915 {
916 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
917 struct rfcomm_dlc *dlc = dev->dlc;
918
919 BT_DBG("tty %p dev %p", tty, dev);
920
921 if (!skb_queue_empty(&dlc->tx_queue))
922 return dlc->mtu;
923
924 return 0;
925 }
926
927 static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
928 {
929 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
930 if (!dev)
931 return;
932
933 BT_DBG("tty %p dev %p", tty, dev);
934
935 skb_queue_purge(&dev->dlc->tx_queue);
936
937 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && tty->ldisc.write_wakeup)
938 tty->ldisc.write_wakeup(tty);
939 }
940
941 static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
942 {
943 BT_DBG("tty %p ch %c", tty, ch);
944 }
945
946 static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
947 {
948 BT_DBG("tty %p timeout %d", tty, timeout);
949 }
950
951 static void rfcomm_tty_hangup(struct tty_struct *tty)
952 {
953 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
954 if (!dev)
955 return;
956
957 BT_DBG("tty %p dev %p", tty, dev);
958
959 rfcomm_tty_flush_buffer(tty);
960
961 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
962 rfcomm_dev_del(dev);
963 }
964
965 static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused)
966 {
967 return 0;
968 }
969
970 static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
971 {
972 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
973
974 BT_DBG("tty %p dev %p", tty, dev);
975
976 return dev->modem_status;
977 }
978
979 static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
980 {
981 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
982 struct rfcomm_dlc *dlc = dev->dlc;
983 u8 v24_sig;
984
985 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
986
987 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
988
989 if (set & TIOCM_DSR || set & TIOCM_DTR)
990 v24_sig |= RFCOMM_V24_RTC;
991 if (set & TIOCM_RTS || set & TIOCM_CTS)
992 v24_sig |= RFCOMM_V24_RTR;
993 if (set & TIOCM_RI)
994 v24_sig |= RFCOMM_V24_IC;
995 if (set & TIOCM_CD)
996 v24_sig |= RFCOMM_V24_DV;
997
998 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
999 v24_sig &= ~RFCOMM_V24_RTC;
1000 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1001 v24_sig &= ~RFCOMM_V24_RTR;
1002 if (clear & TIOCM_RI)
1003 v24_sig &= ~RFCOMM_V24_IC;
1004 if (clear & TIOCM_CD)
1005 v24_sig &= ~RFCOMM_V24_DV;
1006
1007 rfcomm_dlc_set_modem_status(dlc, v24_sig);
1008
1009 return 0;
1010 }
1011
1012 /* ---- TTY structure ---- */
1013
1014 static const struct tty_operations rfcomm_ops = {
1015 .open = rfcomm_tty_open,
1016 .close = rfcomm_tty_close,
1017 .write = rfcomm_tty_write,
1018 .write_room = rfcomm_tty_write_room,
1019 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1020 .flush_buffer = rfcomm_tty_flush_buffer,
1021 .ioctl = rfcomm_tty_ioctl,
1022 .throttle = rfcomm_tty_throttle,
1023 .unthrottle = rfcomm_tty_unthrottle,
1024 .set_termios = rfcomm_tty_set_termios,
1025 .send_xchar = rfcomm_tty_send_xchar,
1026 .hangup = rfcomm_tty_hangup,
1027 .wait_until_sent = rfcomm_tty_wait_until_sent,
1028 .read_proc = rfcomm_tty_read_proc,
1029 .tiocmget = rfcomm_tty_tiocmget,
1030 .tiocmset = rfcomm_tty_tiocmset,
1031 };
1032
1033 int rfcomm_init_ttys(void)
1034 {
1035 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1036 if (!rfcomm_tty_driver)
1037 return -1;
1038
1039 rfcomm_tty_driver->owner = THIS_MODULE;
1040 rfcomm_tty_driver->driver_name = "rfcomm";
1041 rfcomm_tty_driver->name = "rfcomm";
1042 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1043 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1044 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1045 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1046 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1047 rfcomm_tty_driver->init_termios = tty_std_termios;
1048 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1049 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1050
1051 if (tty_register_driver(rfcomm_tty_driver)) {
1052 BT_ERR("Can't register RFCOMM TTY driver");
1053 put_tty_driver(rfcomm_tty_driver);
1054 return -1;
1055 }
1056
1057 BT_INFO("RFCOMM TTY layer initialized");
1058
1059 return 0;
1060 }
1061
1062 void rfcomm_cleanup_ttys(void)
1063 {
1064 tty_unregister_driver(rfcomm_tty_driver);
1065 put_tty_driver(rfcomm_tty_driver);
1066 }
hh.org GIT migration