1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/config.h>
31#include <linux/module.h>
32
33#include <linux/tty.h>
34#include <linux/tty_driver.h>
35#include <linux/tty_flip.h>
36
37#include <linux/slab.h>
38#include <linux/skbuff.h>
39
40#include <net/bluetooth/bluetooth.h>
41#include <net/bluetooth/rfcomm.h>
42
43#ifndef CONFIG_BLUEZ_RFCOMM_DEBUG
44#undef BT_DBG
45#define BT_DBG(D...)
46#endif
47
48#define RFCOMM_TTY_MAGIC 0x6d02
49#define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV
50#define RFCOMM_TTY_MAJOR 216
51#define RFCOMM_TTY_MINOR 0
52
53struct rfcomm_dev {
54 struct list_head list;
55 atomic_t refcnt;
56
57 char name[12];
58 int id;
59 unsigned long flags;
60 int opened;
61 int err;
62
63 bdaddr_t src;
64 bdaddr_t dst;
65 u8 channel;
66
67 uint modem_status;
68
69 struct rfcomm_dlc *dlc;
70 struct tty_struct *tty;
71 wait_queue_head_t wait;
72 struct tasklet_struct wakeup_task;
73
74 atomic_t wmem_alloc;
75};
76
77static LIST_HEAD(rfcomm_dev_list);
78static rwlock_t rfcomm_dev_lock = RW_LOCK_UNLOCKED;
79
80static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
81static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
82static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
83
84static void rfcomm_tty_wakeup(unsigned long arg);
85
86
87static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
88{
89 struct rfcomm_dlc *dlc = dev->dlc;
90
91 BT_DBG("dev %p dlc %p", dev, dlc);
92
93 rfcomm_dlc_lock(dlc);
94
95 if (dlc->owner == dev)
96 dlc->owner = NULL;
97 rfcomm_dlc_unlock(dlc);
98
99 rfcomm_dlc_put(dlc);
100 kfree(dev);
101
102 MOD_DEC_USE_COUNT;
103}
104
105static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
106{
107 atomic_inc(&dev->refcnt);
108}
109
110static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
111{
112
113
114
115
116
117
118
119 if (atomic_dec_and_test(&dev->refcnt))
120 rfcomm_dev_destruct(dev);
121}
122
123static struct rfcomm_dev *__rfcomm_dev_get(int id)
124{
125 struct rfcomm_dev *dev;
126 struct list_head *p;
127
128 list_for_each(p, &rfcomm_dev_list) {
129 dev = list_entry(p, struct rfcomm_dev, list);
130 if (dev->id == id)
131 return dev;
132 }
133
134 return NULL;
135}
136
137static inline struct rfcomm_dev *rfcomm_dev_get(int id)
138{
139 struct rfcomm_dev *dev;
140
141 read_lock(&rfcomm_dev_lock);
142
143 dev = __rfcomm_dev_get(id);
144 if (dev)
145 rfcomm_dev_hold(dev);
146
147 read_unlock(&rfcomm_dev_lock);
148
149 return dev;
150}
151
152static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
153{
154 struct rfcomm_dev *dev;
155 struct list_head *head = &rfcomm_dev_list, *p;
156 int err = 0;
157
158 BT_DBG("id %d channel %d", req->dev_id, req->channel);
159
160 dev = kmalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
161 if (!dev)
162 return -ENOMEM;
163 memset(dev, 0, sizeof(struct rfcomm_dev));
164
165 write_lock_bh(&rfcomm_dev_lock);
166
167 if (req->dev_id < 0) {
168 dev->id = 0;
169
170 list_for_each(p, &rfcomm_dev_list) {
171 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
172 break;
173
174 dev->id++;
175 head = p;
176 }
177 } else {
178 dev->id = req->dev_id;
179
180 list_for_each(p, &rfcomm_dev_list) {
181 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
182
183 if (entry->id == dev->id) {
184 err = -EADDRINUSE;
185 goto out;
186 }
187
188 if (entry->id > dev->id - 1)
189 break;
190
191 head = p;
192 }
193 }
194
195 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
196 err = -ENFILE;
197 goto out;
198 }
199
200 sprintf(dev->name, "rfcomm%d", dev->id);
201
202 list_add(&dev->list, head);
203 atomic_set(&dev->refcnt, 1);
204
205 bacpy(&dev->src, &req->src);
206 bacpy(&dev->dst, &req->dst);
207 dev->channel = req->channel;
208
209 dev->flags = req->flags &
210 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
211
212 init_waitqueue_head(&dev->wait);
213 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
214
215 rfcomm_dlc_lock(dlc);
216 dlc->data_ready = rfcomm_dev_data_ready;
217 dlc->state_change = rfcomm_dev_state_change;
218 dlc->modem_status = rfcomm_dev_modem_status;
219
220 dlc->owner = dev;
221 dev->dlc = dlc;
222 rfcomm_dlc_unlock(dlc);
223
224 MOD_INC_USE_COUNT;
225
226out:
227 write_unlock_bh(&rfcomm_dev_lock);
228
229 if (err) {
230 kfree(dev);
231 return err;
232 } else
233 return dev->id;
234}
235
236static void rfcomm_dev_del(struct rfcomm_dev *dev)
237{
238 BT_DBG("dev %p", dev);
239
240 write_lock_bh(&rfcomm_dev_lock);
241 list_del_init(&dev->list);
242 write_unlock_bh(&rfcomm_dev_lock);
243
244 rfcomm_dev_put(dev);
245}
246
247
248
249static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
250{
251
252
253 return dlc->mtu * (dlc->tx_credits?:1);
254}
255
256static void rfcomm_wfree(struct sk_buff *skb)
257{
258 struct rfcomm_dev *dev = (void *) skb->sk;
259 atomic_sub(skb->truesize, &dev->wmem_alloc);
260 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
261 tasklet_schedule(&dev->wakeup_task);
262 rfcomm_dev_put(dev);
263}
264
265static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
266{
267 rfcomm_dev_hold(dev);
268 atomic_add(skb->truesize, &dev->wmem_alloc);
269 skb->sk = (void *) dev;
270 skb->destructor = rfcomm_wfree;
271}
272
273static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, int force, int priority)
274{
275 if (force || atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
276 struct sk_buff *skb = alloc_skb(size, priority);
277 if (skb) {
278 rfcomm_set_owner_w(skb, dev);
279 return skb;
280 }
281 }
282 return NULL;
283}
284
285
286
287#define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
288
289static int rfcomm_create_dev(struct sock *sk, unsigned long arg)
290{
291 struct rfcomm_dev_req req;
292 struct rfcomm_dlc *dlc;
293 int id;
294
295 if (copy_from_user(&req, (void *) arg, sizeof(req)))
296 return -EFAULT;
297
298 BT_DBG("sk %p dev_id %id flags 0x%x", sk, req.dev_id, req.flags);
299
300 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
301 return -EPERM;
302
303 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
304
305 if (sk->state != BT_CONNECTED)
306 return -EBADFD;
307
308 dlc = rfcomm_pi(sk)->dlc;
309 rfcomm_dlc_hold(dlc);
310 } else {
311 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
312 if (!dlc)
313 return -ENOMEM;
314 }
315
316 id = rfcomm_dev_add(&req, dlc);
317 if (id < 0) {
318 rfcomm_dlc_put(dlc);
319 return id;
320 }
321
322 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
323
324
325 sk->state = BT_CLOSED;
326 }
327
328 return id;
329}
330
331static int rfcomm_release_dev(unsigned long arg)
332{
333 struct rfcomm_dev_req req;
334 struct rfcomm_dev *dev;
335
336 if (copy_from_user(&req, (void *) arg, sizeof(req)))
337 return -EFAULT;
338
339 BT_DBG("dev_id %id flags 0x%x", req.dev_id, req.flags);
340
341 if (!(dev = rfcomm_dev_get(req.dev_id)))
342 return -ENODEV;
343
344 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
345 rfcomm_dev_put(dev);
346 return -EPERM;
347 }
348
349 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
350 rfcomm_dlc_close(dev->dlc, 0);
351
352 rfcomm_dev_del(dev);
353 rfcomm_dev_put(dev);
354 return 0;
355}
356
357static int rfcomm_get_dev_list(unsigned long arg)
358{
359 struct rfcomm_dev_list_req *dl;
360 struct rfcomm_dev_info *di;
361 struct list_head *p;
362 int n = 0, size, err;
363 u16 dev_num;
364
365 BT_DBG("");
366
367 if (get_user(dev_num, (u16 *) arg))
368 return -EFAULT;
369
370 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
371 return -EINVAL;
372
373 size = sizeof(*dl) + dev_num * sizeof(*di);
374
375 if (!(dl = kmalloc(size, GFP_KERNEL)))
376 return -ENOMEM;
377
378 di = dl->dev_info;
379
380 read_lock_bh(&rfcomm_dev_lock);
381
382 list_for_each(p, &rfcomm_dev_list) {
383 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
384 (di + n)->id = dev->id;
385 (di + n)->flags = dev->flags;
386 (di + n)->state = dev->dlc->state;
387 (di + n)->channel = dev->channel;
388 bacpy(&(di + n)->src, &dev->src);
389 bacpy(&(di + n)->dst, &dev->dst);
390 if (++n >= dev_num)
391 break;
392 }
393
394 read_unlock_bh(&rfcomm_dev_lock);
395
396 dl->dev_num = n;
397 size = sizeof(*dl) + n * sizeof(*di);
398
399 err = copy_to_user((void *) arg, dl, size);
400 kfree(dl);
401
402 return err ? -EFAULT : 0;
403}
404
405static int rfcomm_get_dev_info(unsigned long arg)
406{
407 struct rfcomm_dev *dev;
408 struct rfcomm_dev_info di;
409 int err = 0;
410
411 BT_DBG("");
412
413 if (copy_from_user(&di, (void *)arg, sizeof(di)))
414 return -EFAULT;
415
416 if (!(dev = rfcomm_dev_get(di.id)))
417 return -ENODEV;
418
419 di.flags = dev->flags;
420 di.channel = dev->channel;
421 di.state = dev->dlc->state;
422 bacpy(&di.src, &dev->src);
423 bacpy(&di.dst, &dev->dst);
424
425 if (copy_to_user((void *)arg, &di, sizeof(di)))
426 err = -EFAULT;
427
428 rfcomm_dev_put(dev);
429 return err;
430}
431
432int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
433{
434 BT_DBG("cmd %d arg %ld", cmd, arg);
435
436 switch (cmd) {
437 case RFCOMMCREATEDEV:
438 return rfcomm_create_dev(sk, arg);
439
440 case RFCOMMRELEASEDEV:
441 return rfcomm_release_dev(arg);
442
443 case RFCOMMGETDEVLIST:
444 return rfcomm_get_dev_list(arg);
445
446 case RFCOMMGETDEVINFO:
447 return rfcomm_get_dev_info(arg);
448 }
449
450 return -EINVAL;
451}
452
453
454static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
455{
456 struct rfcomm_dev *dev = dlc->owner;
457 struct tty_struct *tty;
458
459 if (!dev || !(tty = dev->tty)) {
460 kfree_skb(skb);
461 return;
462 }
463
464 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
465
466 if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
467 register int i;
468 for (i = 0; i < skb->len; i++) {
469 if (tty->flip.count >= TTY_FLIPBUF_SIZE)
470 tty_flip_buffer_push(tty);
471
472 tty_insert_flip_char(tty, skb->data[i], 0);
473 }
474 tty_flip_buffer_push(tty);
475 } else
476 tty->ldisc.receive_buf(tty, skb->data, NULL, skb->len);
477
478 kfree_skb(skb);
479}
480
481static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
482{
483 struct rfcomm_dev *dev = dlc->owner;
484 if (!dev)
485 return;
486
487 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
488
489 dev->err = err;
490 wake_up_interruptible(&dev->wait);
491
492 if (dlc->state == BT_CLOSED) {
493 if (!dev->tty) {
494 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
495 rfcomm_dev_hold(dev);
496 rfcomm_dev_del(dev);
497
498
499
500
501 rfcomm_dlc_unlock(dlc);
502 rfcomm_dev_put(dev);
503 rfcomm_dlc_lock(dlc);
504 }
505 } else
506 tty_hangup(dev->tty);
507 }
508}
509
510static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
511{
512 struct rfcomm_dev *dev = dlc->owner;
513 if (!dev)
514 return;
515
516 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
517
518 dev->modem_status =
519 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
520 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
521 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
522 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
523}
524
525
526static void rfcomm_tty_wakeup(unsigned long arg)
527{
528 struct rfcomm_dev *dev = (void *) arg;
529 struct tty_struct *tty = dev->tty;
530 if (!tty)
531 return;
532
533 BT_DBG("dev %p tty %p", dev, tty);
534
535 tty_wakeup(tty);
536
537#ifdef SERIAL_HAVE_POLL_WAIT
538 wake_up_interruptible(&tty->poll_wait);
539#endif
540}
541
542static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
543{
544 DECLARE_WAITQUEUE(wait, current);
545 struct rfcomm_dev *dev;
546 struct rfcomm_dlc *dlc;
547 int err, id;
548
549 id = MINOR(tty->device) - tty->driver.minor_start;
550
551 BT_DBG("tty %p id %d", tty, id);
552
553
554
555
556
557 dev = rfcomm_dev_get(id);
558 if (!dev)
559 return -ENODEV;
560
561 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst), dev->channel, dev->opened);
562
563 if (dev->opened++ != 0)
564 return 0;
565
566 dlc = dev->dlc;
567
568
569
570 rfcomm_dlc_lock(dlc);
571 tty->driver_data = dev;
572 dev->tty = tty;
573 rfcomm_dlc_unlock(dlc);
574 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
575
576 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
577 if (err < 0)
578 return err;
579
580
581 add_wait_queue(&dev->wait, &wait);
582 while (1) {
583 set_current_state(TASK_INTERRUPTIBLE);
584
585 if (dlc->state == BT_CLOSED) {
586 err = -dev->err;
587 break;
588 }
589
590 if (dlc->state == BT_CONNECTED)
591 break;
592
593 if (signal_pending(current)) {
594 err = -EINTR;
595 break;
596 }
597
598 schedule();
599 }
600 set_current_state(TASK_RUNNING);
601 remove_wait_queue(&dev->wait, &wait);
602
603 return err;
604}
605
606static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
607{
608 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
609 if (!dev)
610 return;
611
612 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc, dev->opened);
613
614 if (--dev->opened == 0) {
615
616 rfcomm_dlc_close(dev->dlc, 0);
617
618 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
619 tasklet_kill(&dev->wakeup_task);
620
621 rfcomm_dlc_lock(dev->dlc);
622 tty->driver_data = NULL;
623 dev->tty = NULL;
624 rfcomm_dlc_unlock(dev->dlc);
625 }
626
627 rfcomm_dev_put(dev);
628}
629
630static int rfcomm_tty_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
631{
632 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
633 struct rfcomm_dlc *dlc = dev->dlc;
634 struct sk_buff *skb;
635 int err = 0, sent = 0, size;
636
637 BT_DBG("tty %p from_user %d count %d", tty, from_user, count);
638
639 while (count) {
640 size = min_t(uint, count, dlc->mtu);
641
642 if (from_user)
643 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, 0, GFP_KERNEL);
644 else
645 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, 0, GFP_ATOMIC);
646
647 if (!skb)
648 break;
649
650 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
651
652 if (from_user)
653 copy_from_user(skb_put(skb, size), buf + sent, size);
654 else
655 memcpy(skb_put(skb, size), buf + sent, size);
656
657 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
658 kfree_skb(skb);
659 break;
660 }
661
662 sent += size;
663 count -= size;
664 }
665
666 return sent ? sent : err;
667}
668
669static void rfcomm_tty_put_char(struct tty_struct *tty, unsigned char ch)
670{
671 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
672 struct rfcomm_dlc *dlc = dev->dlc;
673 struct sk_buff *skb;
674
675 BT_DBG("tty %p char %x", tty, ch);
676
677 skb = rfcomm_wmalloc(dev, 1 + RFCOMM_SKB_RESERVE, 1, GFP_ATOMIC);
678
679 if (!skb)
680 return;
681
682 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
683
684 *(char *)skb_put(skb, 1) = ch;
685
686 if ((rfcomm_dlc_send(dlc, skb)) < 0)
687 kfree_skb(skb);
688}
689
690static int rfcomm_tty_write_room(struct tty_struct *tty)
691{
692 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
693 int room;
694
695 BT_DBG("tty %p", tty);
696
697 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
698 if (room < 0)
699 room = 0;
700
701 return room;
702}
703
704static int rfcomm_tty_set_modem_status(uint cmd, struct rfcomm_dlc *dlc, uint status)
705{
706 u8 v24_sig, mask;
707
708 BT_DBG("dlc %p cmd 0x%02x", dlc, cmd);
709
710 if (cmd == TIOCMSET)
711 v24_sig = 0;
712 else
713 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
714
715 mask = ((status & TIOCM_DSR) ? RFCOMM_V24_RTC : 0) |
716 ((status & TIOCM_DTR) ? RFCOMM_V24_RTC : 0) |
717 ((status & TIOCM_RTS) ? RFCOMM_V24_RTR : 0) |
718 ((status & TIOCM_CTS) ? RFCOMM_V24_RTR : 0) |
719 ((status & TIOCM_RI) ? RFCOMM_V24_IC : 0) |
720 ((status & TIOCM_CD) ? RFCOMM_V24_DV : 0);
721
722 if (cmd == TIOCMBIC)
723 v24_sig &= ~mask;
724 else
725 v24_sig |= mask;
726
727 rfcomm_dlc_set_modem_status(dlc, v24_sig);
728 return 0;
729}
730
731static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
732{
733 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
734 struct rfcomm_dlc *dlc = dev->dlc;
735 uint status;
736 int err;
737
738 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
739
740 switch (cmd) {
741 case TCGETS:
742 BT_DBG("TCGETS is not supported");
743 return -ENOIOCTLCMD;
744
745 case TCSETS:
746 BT_DBG("TCSETS is not supported");
747 return -ENOIOCTLCMD;
748
749 case TIOCMGET:
750 BT_DBG("TIOCMGET");
751
752 return put_user(dev->modem_status, (unsigned int *)arg);
753
754 case TIOCMSET:
755 case TIOCMBIS:
756 case TIOCMBIC:
757 if ((err = get_user(status, (unsigned int *)arg)))
758 return err;
759 return rfcomm_tty_set_modem_status(cmd, dlc, status);
760
761 case TIOCMIWAIT:
762 BT_DBG("TIOCMIWAIT");
763 break;
764
765 case TIOCGICOUNT:
766 BT_DBG("TIOCGICOUNT");
767 break;
768
769 case TIOCGSERIAL:
770 BT_ERR("TIOCGSERIAL is not supported");
771 return -ENOIOCTLCMD;
772
773 case TIOCSSERIAL:
774 BT_ERR("TIOCSSERIAL is not supported");
775 return -ENOIOCTLCMD;
776
777 case TIOCSERGSTRUCT:
778 BT_ERR("TIOCSERGSTRUCT is not supported");
779 return -ENOIOCTLCMD;
780
781 case TIOCSERGETLSR:
782 BT_ERR("TIOCSERGETLSR is not supported");
783 return -ENOIOCTLCMD;
784
785 case TIOCSERCONFIG:
786 BT_ERR("TIOCSERCONFIG is not supported");
787 return -ENOIOCTLCMD;
788
789 default:
790 return -ENOIOCTLCMD;
791
792 }
793
794 return -ENOIOCTLCMD;
795}
796
797#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
798
799static void rfcomm_tty_set_termios(struct tty_struct *tty, struct termios *old)
800{
801 BT_DBG("tty %p", tty);
802
803 if ((tty->termios->c_cflag == old->c_cflag) &&
804 (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old->c_iflag)))
805 return;
806
807
808 if ((old->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
809 BT_DBG("turning off CRTSCTS");
810 }
811}
812
813static void rfcomm_tty_throttle(struct tty_struct *tty)
814{
815 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
816
817 BT_DBG("tty %p dev %p", tty, dev);
818
819 rfcomm_dlc_throttle(dev->dlc);
820}
821
822static void rfcomm_tty_unthrottle(struct tty_struct *tty)
823{
824 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
825
826 BT_DBG("tty %p dev %p", tty, dev);
827
828 rfcomm_dlc_unthrottle(dev->dlc);
829}
830
831static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
832{
833 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
834 struct rfcomm_dlc *dlc = dev->dlc;
835
836 BT_DBG("tty %p dev %p", tty, dev);
837
838 if (skb_queue_len(&dlc->tx_queue))
839 return dlc->mtu;
840
841 return 0;
842}
843
844static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
845{
846 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
847 if (!dev)
848 return;
849
850 BT_DBG("tty %p dev %p", tty, dev);
851
852 skb_queue_purge(&dev->dlc->tx_queue);
853
854 tty_wakeup(tty);
855}
856
857static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
858{
859 BT_DBG("tty %p ch %c", tty, ch);
860}
861
862static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
863{
864 BT_DBG("tty %p timeout %d", tty, timeout);
865}
866
867static void rfcomm_tty_hangup(struct tty_struct *tty)
868{
869 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
870 if (!dev)
871 return;
872
873 BT_DBG("tty %p dev %p", tty, dev);
874
875 rfcomm_tty_flush_buffer(tty);
876
877 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
878 rfcomm_dev_del(dev);
879}
880
881static int rfcomm_tty_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *unused)
882{
883 return 0;
884}
885
886
887static int rfcomm_tty_refcount;
888
889static struct tty_struct *rfcomm_tty_table[RFCOMM_TTY_PORTS];
890static struct termios *rfcomm_tty_termios[RFCOMM_TTY_PORTS];
891static struct termios *rfcomm_tty_termios_locked[RFCOMM_TTY_PORTS];
892
893static struct tty_driver rfcomm_tty_driver = {
894 magic: TTY_DRIVER_MAGIC,
895 driver_name: "rfcomm",
896#ifdef CONFIG_DEVFS_FS
897 name: "bluetooth/rfcomm/%d",
898#else
899 name: "rfcomm",
900#endif
901 major: RFCOMM_TTY_MAJOR,
902 minor_start: RFCOMM_TTY_MINOR,
903 num: RFCOMM_TTY_PORTS,
904 type: TTY_DRIVER_TYPE_SERIAL,
905 subtype: SERIAL_TYPE_NORMAL,
906 flags: TTY_DRIVER_REAL_RAW,
907
908 refcount: &rfcomm_tty_refcount,
909 table: rfcomm_tty_table,
910 termios: rfcomm_tty_termios,
911 termios_locked: rfcomm_tty_termios_locked,
912
913 open: rfcomm_tty_open,
914 close: rfcomm_tty_close,
915 put_char: rfcomm_tty_put_char,
916 write: rfcomm_tty_write,
917 write_room: rfcomm_tty_write_room,
918 chars_in_buffer: rfcomm_tty_chars_in_buffer,
919 flush_buffer: rfcomm_tty_flush_buffer,
920 ioctl: rfcomm_tty_ioctl,
921 throttle: rfcomm_tty_throttle,
922 unthrottle: rfcomm_tty_unthrottle,
923 set_termios: rfcomm_tty_set_termios,
924 send_xchar: rfcomm_tty_send_xchar,
925 stop: NULL,
926 start: NULL,
927 hangup: rfcomm_tty_hangup,
928 wait_until_sent: rfcomm_tty_wait_until_sent,
929 read_proc: rfcomm_tty_read_proc,
930};
931
932int rfcomm_init_ttys(void)
933{
934 int i;
935
936
937 for (i = 0; i < RFCOMM_TTY_PORTS; i++)
938 rfcomm_tty_table[i] = NULL;
939
940
941 rfcomm_tty_driver.init_termios = tty_std_termios;
942 rfcomm_tty_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
943 rfcomm_tty_driver.flags = TTY_DRIVER_REAL_RAW;
944
945 if (tty_register_driver(&rfcomm_tty_driver)) {
946 BT_ERR("Can't register RFCOMM TTY driver");
947 return -1;
948 }
949
950 return 0;
951}
952
953void rfcomm_cleanup_ttys(void)
954{
955 tty_unregister_driver(&rfcomm_tty_driver);
956 return;
957}
958
