blob: a9b81f5dacd14c942d46e46c4bdcacc9f2070ac8 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090014 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090019 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 SOFTWARE IS DISCLAIMED.
22*/
23
24/*
25 * RFCOMM TTY.
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29
30#include <linux/tty.h>
31#include <linux/tty_driver.h>
32#include <linux/tty_flip.h>
33
Randy Dunlap4fc268d2006-01-11 12:17:47 -080034#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/slab.h>
36#include <linux/skbuff.h>
37
38#include <net/bluetooth/bluetooth.h>
Marcel Holtmann0a85b962006-07-06 13:09:02 +020039#include <net/bluetooth/hci_core.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <net/bluetooth/rfcomm.h>
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#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
46
47static struct tty_driver *rfcomm_tty_driver;
48
49struct rfcomm_dev {
50 struct list_head list;
51 atomic_t refcnt;
52
53 char name[12];
54 int id;
55 unsigned long flags;
Marcel Holtmann9a5df922008-11-30 12:17:29 +010056 atomic_t opened;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 int err;
58
59 bdaddr_t src;
60 bdaddr_t dst;
61 u8 channel;
62
63 uint modem_status;
64
65 struct rfcomm_dlc *dlc;
66 struct tty_struct *tty;
67 wait_queue_head_t wait;
68 struct tasklet_struct wakeup_task;
69
Marcel Holtmannc1a33132007-02-17 23:58:57 +010070 struct device *tty_dev;
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 atomic_t wmem_alloc;
Marcel Holtmanna0c22f22008-07-14 20:13:52 +020073
74 struct sk_buff_head pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
77static LIST_HEAD(rfcomm_dev_list);
78static DEFINE_RWLOCK(rfcomm_dev_lock);
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/* ---- Device functions ---- */
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
Dave Youngf9513752008-01-10 22:22:52 -080093 /* Refcount should only hit zero when called from rfcomm_dev_del()
94 which will have taken us off the list. Everything else are
95 refcounting bugs. */
96 BUG_ON(!list_empty(&dev->list));
Ville Tervo8de0a152007-07-11 09:23:41 +020097
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 rfcomm_dlc_lock(dlc);
99 /* Detach DLC if it's owned by this dev */
100 if (dlc->owner == dev)
101 dlc->owner = NULL;
102 rfcomm_dlc_unlock(dlc);
103
104 rfcomm_dlc_put(dlc);
105
106 tty_unregister_device(rfcomm_tty_driver, dev->id);
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 kfree(dev);
109
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900110 /* It's safe to call module_put() here because socket still
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 holds reference to this module. */
112 module_put(THIS_MODULE);
113}
114
115static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
116{
117 atomic_inc(&dev->refcnt);
118}
119
120static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
121{
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()
128 anyway. */
129 if (atomic_dec_and_test(&dev->refcnt))
130 rfcomm_dev_destruct(dev);
131}
132
133static struct rfcomm_dev *__rfcomm_dev_get(int id)
134{
135 struct rfcomm_dev *dev;
136 struct list_head *p;
137
138 list_for_each(p, &rfcomm_dev_list) {
139 dev = list_entry(p, struct rfcomm_dev, list);
140 if (dev->id == id)
141 return dev;
142 }
143
144 return NULL;
145}
146
147static inline struct rfcomm_dev *rfcomm_dev_get(int id)
148{
149 struct rfcomm_dev *dev;
150
151 read_lock(&rfcomm_dev_lock);
152
153 dev = __rfcomm_dev_get(id);
Ville Tervo8de0a152007-07-11 09:23:41 +0200154
155 if (dev) {
156 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
157 dev = NULL;
158 else
159 rfcomm_dev_hold(dev);
160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 read_unlock(&rfcomm_dev_lock);
163
164 return dev;
165}
166
Marcel Holtmann0a85b962006-07-06 13:09:02 +0200167static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
168{
169 struct hci_dev *hdev;
170 struct hci_conn *conn;
171
172 hdev = hci_get_route(&dev->dst, &dev->src);
173 if (!hdev)
174 return NULL;
175
176 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
Marcel Holtmann0a85b962006-07-06 13:09:02 +0200177
178 hci_dev_put(hdev);
179
Marcel Holtmannb2cfcd72006-10-15 17:31:05 +0200180 return conn ? &conn->dev : NULL;
Marcel Holtmann0a85b962006-07-06 13:09:02 +0200181}
182
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200183static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
184{
185 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
Gustavo F. Padovand6b2eb22010-09-03 18:29:46 -0300186 return sprintf(buf, "%s\n", batostr(&dev->dst));
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200187}
188
189static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
190{
191 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
192 return sprintf(buf, "%d\n", dev->channel);
193}
194
195static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
196static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
199{
200 struct rfcomm_dev *dev;
201 struct list_head *head = &rfcomm_dev_list, *p;
202 int err = 0;
203
204 BT_DBG("id %d channel %d", req->dev_id, req->channel);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900205
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200206 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 if (!dev)
208 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
210 write_lock_bh(&rfcomm_dev_lock);
211
212 if (req->dev_id < 0) {
213 dev->id = 0;
214
215 list_for_each(p, &rfcomm_dev_list) {
216 if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
217 break;
218
219 dev->id++;
220 head = p;
221 }
222 } else {
223 dev->id = req->dev_id;
224
225 list_for_each(p, &rfcomm_dev_list) {
226 struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
227
228 if (entry->id == dev->id) {
229 err = -EADDRINUSE;
230 goto out;
231 }
232
233 if (entry->id > dev->id - 1)
234 break;
235
236 head = p;
237 }
238 }
239
240 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
241 err = -ENFILE;
242 goto out;
243 }
244
245 sprintf(dev->name, "rfcomm%d", dev->id);
246
247 list_add(&dev->list, head);
248 atomic_set(&dev->refcnt, 1);
249
250 bacpy(&dev->src, &req->src);
251 bacpy(&dev->dst, &req->dst);
252 dev->channel = req->channel;
253
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900254 dev->flags = req->flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
256
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100257 atomic_set(&dev->opened, 0);
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 init_waitqueue_head(&dev->wait);
260 tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
261
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200262 skb_queue_head_init(&dev->pending);
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 rfcomm_dlc_lock(dlc);
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200265
266 if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
267 struct sock *sk = dlc->owner;
268 struct sk_buff *skb;
269
270 BUG_ON(!sk);
271
272 rfcomm_dlc_throttle(dlc);
273
274 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
275 skb_orphan(skb);
276 skb_queue_tail(&dev->pending, skb);
277 atomic_sub(skb->len, &sk->sk_rmem_alloc);
278 }
279 }
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 dlc->data_ready = rfcomm_dev_data_ready;
282 dlc->state_change = rfcomm_dev_state_change;
283 dlc->modem_status = rfcomm_dev_modem_status;
284
285 dlc->owner = dev;
286 dev->dlc = dlc;
Marcel Holtmann8b6b3da2008-07-14 20:13:52 +0200287
288 rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 rfcomm_dlc_unlock(dlc);
291
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900292 /* It's safe to call __module_get() here because socket already
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 holds reference to this module. */
294 __module_get(THIS_MODULE);
295
296out:
297 write_unlock_bh(&rfcomm_dev_lock);
298
Ilpo Järvinen037322a2008-12-14 23:18:00 -0800299 if (err < 0)
300 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Marcel Holtmannc1a33132007-02-17 23:58:57 +0100302 dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Ville Tervo8de0a152007-07-11 09:23:41 +0200304 if (IS_ERR(dev->tty_dev)) {
Marcel Holtmann09c7d822007-07-26 00:12:25 -0700305 err = PTR_ERR(dev->tty_dev);
Ville Tervo8de0a152007-07-11 09:23:41 +0200306 list_del(&dev->list);
Ilpo Järvinen037322a2008-12-14 23:18:00 -0800307 goto free;
Ville Tervo8de0a152007-07-11 09:23:41 +0200308 }
309
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200310 dev_set_drvdata(dev->tty_dev, dev);
311
312 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
313 BT_ERR("Failed to create address attribute");
314
315 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
316 BT_ERR("Failed to create channel attribute");
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 return dev->id;
Ilpo Järvinen037322a2008-12-14 23:18:00 -0800319
320free:
321 kfree(dev);
322 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323}
324
325static void rfcomm_dev_del(struct rfcomm_dev *dev)
326{
327 BT_DBG("dev %p", dev);
328
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100329 BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags));
330
331 if (atomic_read(&dev->opened) > 0)
332 return;
Dave Youngf9513752008-01-10 22:22:52 -0800333
334 write_lock_bh(&rfcomm_dev_lock);
335 list_del_init(&dev->list);
336 write_unlock_bh(&rfcomm_dev_lock);
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 rfcomm_dev_put(dev);
339}
340
341/* ---- Send buffer ---- */
342static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
343{
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);
347}
348
349static void rfcomm_wfree(struct sk_buff *skb)
350{
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);
355 rfcomm_dev_put(dev);
356}
357
358static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
359{
360 rfcomm_dev_hold(dev);
361 atomic_add(skb->truesize, &dev->wmem_alloc);
362 skb->sk = (void *) dev;
363 skb->destructor = rfcomm_wfree;
364}
365
Al Virodd0fc662005-10-07 07:46:04 +0100366static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
368 if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
369 struct sk_buff *skb = alloc_skb(size, priority);
370 if (skb) {
371 rfcomm_set_owner_w(skb, dev);
372 return skb;
373 }
374 }
375 return NULL;
376}
377
378/* ---- Device IOCTLs ---- */
379
380#define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
381
382static int rfcomm_create_dev(struct sock *sk, void __user *arg)
383{
384 struct rfcomm_dev_req req;
385 struct rfcomm_dlc *dlc;
386 int id;
387
388 if (copy_from_user(&req, arg, sizeof(req)))
389 return -EFAULT;
390
Ville Tervo8de0a152007-07-11 09:23:41 +0200391 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
394 return -EPERM;
395
396 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
397 /* Socket must be connected */
398 if (sk->sk_state != BT_CONNECTED)
399 return -EBADFD;
400
401 dlc = rfcomm_pi(sk)->dlc;
402 rfcomm_dlc_hold(dlc);
403 } else {
404 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
405 if (!dlc)
406 return -ENOMEM;
407 }
408
409 id = rfcomm_dev_add(&req, dlc);
410 if (id < 0) {
411 rfcomm_dlc_put(dlc);
412 return id;
413 }
414
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;
419 }
420
421 return id;
422}
423
424static int rfcomm_release_dev(void __user *arg)
425{
426 struct rfcomm_dev_req req;
427 struct rfcomm_dev *dev;
428
429 if (copy_from_user(&req, arg, sizeof(req)))
430 return -EFAULT;
431
Ville Tervo8de0a152007-07-11 09:23:41 +0200432 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 if (!(dev = rfcomm_dev_get(req.dev_id)))
435 return -ENODEV;
436
437 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
438 rfcomm_dev_put(dev);
439 return -EPERM;
440 }
441
442 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
443 rfcomm_dlc_close(dev->dlc, 0);
444
Mikko Rapeli84950cf2007-07-11 09:18:15 +0200445 /* Shut down TTY synchronously before freeing rfcomm_dev */
446 if (dev->tty)
447 tty_vhangup(dev->tty);
448
Dave Young93d80742008-02-05 03:12:06 -0800449 if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
450 rfcomm_dev_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 rfcomm_dev_put(dev);
452 return 0;
453}
454
455static int rfcomm_get_dev_list(void __user *arg)
456{
457 struct rfcomm_dev_list_req *dl;
458 struct rfcomm_dev_info *di;
459 struct list_head *p;
460 int n = 0, size, err;
461 u16 dev_num;
462
463 BT_DBG("");
464
465 if (get_user(dev_num, (u16 __user *) arg))
466 return -EFAULT;
467
468 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
469 return -EINVAL;
470
471 size = sizeof(*dl) + dev_num * sizeof(*di);
472
473 if (!(dl = kmalloc(size, GFP_KERNEL)))
474 return -ENOMEM;
475
476 di = dl->dev_info;
477
478 read_lock_bh(&rfcomm_dev_lock);
479
480 list_for_each(p, &rfcomm_dev_list) {
481 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
Ville Tervo8de0a152007-07-11 09:23:41 +0200482 if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
483 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 (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);
490 if (++n >= dev_num)
491 break;
492 }
493
494 read_unlock_bh(&rfcomm_dev_lock);
495
496 dl->dev_num = n;
497 size = sizeof(*dl) + n * sizeof(*di);
498
499 err = copy_to_user(arg, dl, size);
500 kfree(dl);
501
502 return err ? -EFAULT : 0;
503}
504
505static int rfcomm_get_dev_info(void __user *arg)
506{
507 struct rfcomm_dev *dev;
508 struct rfcomm_dev_info di;
509 int err = 0;
510
511 BT_DBG("");
512
513 if (copy_from_user(&di, arg, sizeof(di)))
514 return -EFAULT;
515
516 if (!(dev = rfcomm_dev_get(di.id)))
517 return -ENODEV;
518
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);
524
525 if (copy_to_user(arg, &di, sizeof(di)))
526 err = -EFAULT;
527
528 rfcomm_dev_put(dev);
529 return err;
530}
531
532int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
533{
534 BT_DBG("cmd %d arg %p", cmd, arg);
535
536 switch (cmd) {
537 case RFCOMMCREATEDEV:
538 return rfcomm_create_dev(sk, arg);
539
540 case RFCOMMRELEASEDEV:
541 return rfcomm_release_dev(arg);
542
543 case RFCOMMGETDEVLIST:
544 return rfcomm_get_dev_list(arg);
545
546 case RFCOMMGETDEVINFO:
547 return rfcomm_get_dev_info(arg);
548 }
549
550 return -EINVAL;
551}
552
553/* ---- DLC callbacks ---- */
554static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
555{
556 struct rfcomm_dev *dev = dlc->owner;
557 struct tty_struct *tty;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900558
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200559 if (!dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 kfree_skb(skb);
561 return;
562 }
563
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200564 if (!(tty = dev->tty) || !skb_queue_empty(&dev->pending)) {
565 skb_queue_tail(&dev->pending, skb);
566 return;
567 }
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
570
Paul Fulghum817d6d32006-06-28 04:26:47 -0700571 tty_insert_flip_string(tty, skb->data, skb->len);
572 tty_flip_buffer_push(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 kfree_skb(skb);
575}
576
577static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
578{
579 struct rfcomm_dev *dev = dlc->owner;
580 if (!dev)
581 return;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
584
585 dev->err = err;
586 wake_up_interruptible(&dev->wait);
587
588 if (dlc->state == BT_CLOSED) {
589 if (!dev->tty) {
590 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
Dave Young537d59a2008-06-01 23:50:52 -0700591 /* 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
596 * the last reference
597 */
598 rfcomm_dlc_unlock(dlc);
599 if (rfcomm_dev_get(dev->id) == NULL) {
600 rfcomm_dlc_lock(dlc);
Marcel Holtmann77f2a452007-05-05 00:36:10 +0200601 return;
Dave Young537d59a2008-06-01 23:50:52 -0700602 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Marcel Holtmann77f2a452007-05-05 00:36:10 +0200604 rfcomm_dev_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 rfcomm_dev_put(dev);
Dave Young537d59a2008-06-01 23:50:52 -0700606 rfcomm_dlc_lock(dlc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900608 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 tty_hangup(dev->tty);
610 }
611}
612
613static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
614{
615 struct rfcomm_dev *dev = dlc->owner;
616 if (!dev)
617 return;
Timo Teräs7b9eb9e2005-08-09 20:28:21 -0700618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
620
Timo Teräs7b9eb9e2005-08-09 20:28:21 -0700621 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV)) {
622 if (dev->tty && !C_CLOCAL(dev->tty))
623 tty_hangup(dev->tty);
624 }
625
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900626 dev->modem_status =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 ((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);
631}
632
633/* ---- TTY functions ---- */
634static void rfcomm_tty_wakeup(unsigned long arg)
635{
636 struct rfcomm_dev *dev = (void *) arg;
637 struct tty_struct *tty = dev->tty;
638 if (!tty)
639 return;
640
641 BT_DBG("dev %p tty %p", dev, tty);
Alan Coxa352def2008-07-16 21:53:12 +0100642 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643}
644
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200645static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev)
646{
647 struct tty_struct *tty = dev->tty;
648 struct sk_buff *skb;
649 int inserted = 0;
650
651 if (!tty)
652 return;
653
654 BT_DBG("dev %p tty %p", dev, tty);
655
656 rfcomm_dlc_lock(dev->dlc);
657
658 while ((skb = skb_dequeue(&dev->pending))) {
659 inserted += tty_insert_flip_string(tty, skb->data, skb->len);
660 kfree_skb(skb);
661 }
662
663 rfcomm_dlc_unlock(dev->dlc);
664
665 if (inserted > 0)
666 tty_flip_buffer_push(tty);
667}
668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
670{
671 DECLARE_WAITQUEUE(wait, current);
672 struct rfcomm_dev *dev;
673 struct rfcomm_dlc *dlc;
674 int err, id;
675
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900676 id = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 BT_DBG("tty %p id %d", tty, id);
679
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);
685 if (!dev)
686 return -ENODEV;
687
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100688 BT_DBG("dev %p dst %s channel %d opened %d", dev, batostr(&dev->dst),
689 dev->channel, atomic_read(&dev->opened));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100691 if (atomic_inc_return(&dev->opened) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return 0;
693
694 dlc = dev->dlc;
695
696 /* Attach TTY and open DLC */
697
698 rfcomm_dlc_lock(dlc);
699 tty->driver_data = dev;
700 dev->tty = tty;
701 rfcomm_dlc_unlock(dlc);
702 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
703
704 err = rfcomm_dlc_open(dlc, &dev->src, &dev->dst, dev->channel);
705 if (err < 0)
706 return err;
707
708 /* Wait for DLC to connect */
709 add_wait_queue(&dev->wait, &wait);
710 while (1) {
711 set_current_state(TASK_INTERRUPTIBLE);
712
713 if (dlc->state == BT_CLOSED) {
714 err = -dev->err;
715 break;
716 }
717
718 if (dlc->state == BT_CONNECTED)
719 break;
720
721 if (signal_pending(current)) {
722 err = -EINTR;
723 break;
724 }
725
726 schedule();
727 }
728 set_current_state(TASK_RUNNING);
729 remove_wait_queue(&dev->wait, &wait);
730
Marcel Holtmannc1a33132007-02-17 23:58:57 +0100731 if (err == 0)
Cornelia Huckffa6a702009-03-04 12:44:00 +0100732 device_move(dev->tty_dev, rfcomm_get_device(dev),
733 DPM_ORDER_DEV_AFTER_PARENT);
Marcel Holtmannc1a33132007-02-17 23:58:57 +0100734
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200735 rfcomm_tty_copy_pending(dev);
736
737 rfcomm_dlc_unthrottle(dev->dlc);
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return err;
740}
741
742static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
743{
744 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
745 if (!dev)
746 return;
747
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100748 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc,
749 atomic_read(&dev->opened));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100751 if (atomic_dec_and_test(&dev->opened)) {
Dave Youngacea6852008-01-21 22:35:21 -0800752 if (dev->tty_dev->parent)
Cornelia Huckffa6a702009-03-04 12:44:00 +0100753 device_move(dev->tty_dev, NULL, DPM_ORDER_DEV_LAST);
Marcel Holtmannc1a33132007-02-17 23:58:57 +0100754
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 /* Close DLC and dettach TTY */
756 rfcomm_dlc_close(dev->dlc, 0);
757
758 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
759 tasklet_kill(&dev->wakeup_task);
760
761 rfcomm_dlc_lock(dev->dlc);
762 tty->driver_data = NULL;
763 dev->tty = NULL;
764 rfcomm_dlc_unlock(dev->dlc);
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100765
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);
770
771 rfcomm_dev_put(dev);
772 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 }
774
775 rfcomm_dev_put(dev);
776}
777
778static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
779{
780 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
781 struct rfcomm_dlc *dlc = dev->dlc;
782 struct sk_buff *skb;
783 int err = 0, sent = 0, size;
784
785 BT_DBG("tty %p count %d", tty, count);
786
787 while (count) {
788 size = min_t(uint, count, dlc->mtu);
789
790 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 if (!skb)
793 break;
794
795 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
796
797 memcpy(skb_put(skb, size), buf + sent, size);
798
799 if ((err = rfcomm_dlc_send(dlc, skb)) < 0) {
800 kfree_skb(skb);
801 break;
802 }
803
804 sent += size;
805 count -= size;
806 }
807
808 return sent ? sent : err;
809}
810
811static int rfcomm_tty_write_room(struct tty_struct *tty)
812{
813 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
814 int room;
815
816 BT_DBG("tty %p", tty);
817
Marcel Holtmannb6e557f2007-01-08 02:16:27 +0100818 if (!dev || !dev->dlc)
819 return 0;
820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
822 if (room < 0)
823 room = 0;
Marcel Holtmannb6e557f2007-01-08 02:16:27 +0100824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 return room;
826}
827
828static int rfcomm_tty_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
829{
830 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
831
832 switch (cmd) {
833 case TCGETS:
834 BT_DBG("TCGETS is not supported");
835 return -ENOIOCTLCMD;
836
837 case TCSETS:
838 BT_DBG("TCSETS is not supported");
839 return -ENOIOCTLCMD;
840
841 case TIOCMIWAIT:
842 BT_DBG("TIOCMIWAIT");
843 break;
844
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 case TIOCGSERIAL:
846 BT_ERR("TIOCGSERIAL is not supported");
847 return -ENOIOCTLCMD;
848
849 case TIOCSSERIAL:
850 BT_ERR("TIOCSSERIAL is not supported");
851 return -ENOIOCTLCMD;
852
853 case TIOCSERGSTRUCT:
854 BT_ERR("TIOCSERGSTRUCT is not supported");
855 return -ENOIOCTLCMD;
856
857 case TIOCSERGETLSR:
858 BT_ERR("TIOCSERGETLSR is not supported");
859 return -ENOIOCTLCMD;
860
861 case TIOCSERCONFIG:
862 BT_ERR("TIOCSERCONFIG is not supported");
863 return -ENOIOCTLCMD;
864
865 default:
866 return -ENOIOCTLCMD; /* ioctls which we must ignore */
867
868 }
869
870 return -ENOIOCTLCMD;
871}
872
Alan Cox606d0992006-12-08 02:38:45 -0800873static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874{
Alan Cox606d0992006-12-08 02:38:45 -0800875 struct ktermios *new = tty->termios;
J. Suter3a5e9032005-08-09 20:28:46 -0700876 int old_baud_rate = tty_termios_baud_rate(old);
877 int new_baud_rate = tty_termios_baud_rate(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
J. Suter3a5e9032005-08-09 20:28:46 -0700879 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
880 u16 changes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
J. Suter3a5e9032005-08-09 20:28:46 -0700882 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
883
884 BT_DBG("tty %p termios %p", tty, old);
885
Marcel Holtmannff2d3672006-11-18 22:14:42 +0100886 if (!dev || !dev->dlc || !dev->dlc->session)
Marcel Holtmanncb19d9e2006-10-15 17:31:10 +0200887 return;
888
J. Suter3a5e9032005-08-09 20:28:46 -0700889 /* Handle turning off CRTSCTS */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900890 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
J. Suter3a5e9032005-08-09 20:28:46 -0700891 BT_DBG("Turning off CRTSCTS unsupported");
892
893 /* Parity on/off and when on, odd/even */
894 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
895 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD)) ) {
896 changes |= RFCOMM_RPN_PM_PARITY;
897 BT_DBG("Parity change detected.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
J. Suter3a5e9032005-08-09 20:28:46 -0700899
900 /* Mark and space parity are not supported! */
901 if (new->c_cflag & PARENB) {
902 if (new->c_cflag & PARODD) {
903 BT_DBG("Parity is ODD");
904 parity = RFCOMM_RPN_PARITY_ODD;
905 } else {
906 BT_DBG("Parity is EVEN");
907 parity = RFCOMM_RPN_PARITY_EVEN;
908 }
909 } else {
910 BT_DBG("Parity is OFF");
911 parity = RFCOMM_RPN_PARITY_NONE;
912 }
913
914 /* Setting the x_on / x_off characters */
915 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
916 BT_DBG("XOFF custom");
917 x_on = new->c_cc[VSTOP];
918 changes |= RFCOMM_RPN_PM_XON;
919 } else {
920 BT_DBG("XOFF default");
921 x_on = RFCOMM_RPN_XON_CHAR;
922 }
923
924 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
925 BT_DBG("XON custom");
926 x_off = new->c_cc[VSTART];
927 changes |= RFCOMM_RPN_PM_XOFF;
928 } else {
929 BT_DBG("XON default");
930 x_off = RFCOMM_RPN_XOFF_CHAR;
931 }
932
933 /* Handle setting of stop bits */
934 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
935 changes |= RFCOMM_RPN_PM_STOP;
936
937 /* POSIX does not support 1.5 stop bits and RFCOMM does not
938 * support 2 stop bits. So a request for 2 stop bits gets
939 * translated to 1.5 stop bits */
940 if (new->c_cflag & CSTOPB) {
941 stop_bits = RFCOMM_RPN_STOP_15;
942 } else {
943 stop_bits = RFCOMM_RPN_STOP_1;
944 }
945
946 /* Handle number of data bits [5-8] */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900947 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
J. Suter3a5e9032005-08-09 20:28:46 -0700948 changes |= RFCOMM_RPN_PM_DATA;
949
950 switch (new->c_cflag & CSIZE) {
951 case CS5:
952 data_bits = RFCOMM_RPN_DATA_5;
953 break;
954 case CS6:
955 data_bits = RFCOMM_RPN_DATA_6;
956 break;
957 case CS7:
958 data_bits = RFCOMM_RPN_DATA_7;
959 break;
960 case CS8:
961 data_bits = RFCOMM_RPN_DATA_8;
962 break;
963 default:
964 data_bits = RFCOMM_RPN_DATA_8;
965 break;
966 }
967
968 /* Handle baudrate settings */
969 if (old_baud_rate != new_baud_rate)
970 changes |= RFCOMM_RPN_PM_BITRATE;
971
972 switch (new_baud_rate) {
973 case 2400:
974 baud = RFCOMM_RPN_BR_2400;
975 break;
976 case 4800:
977 baud = RFCOMM_RPN_BR_4800;
978 break;
979 case 7200:
980 baud = RFCOMM_RPN_BR_7200;
981 break;
982 case 9600:
983 baud = RFCOMM_RPN_BR_9600;
984 break;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900985 case 19200:
J. Suter3a5e9032005-08-09 20:28:46 -0700986 baud = RFCOMM_RPN_BR_19200;
987 break;
988 case 38400:
989 baud = RFCOMM_RPN_BR_38400;
990 break;
991 case 57600:
992 baud = RFCOMM_RPN_BR_57600;
993 break;
994 case 115200:
995 baud = RFCOMM_RPN_BR_115200;
996 break;
997 case 230400:
998 baud = RFCOMM_RPN_BR_230400;
999 break;
1000 default:
1001 /* 9600 is standard accordinag to the RFCOMM specification */
1002 baud = RFCOMM_RPN_BR_9600;
1003 break;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001004
J. Suter3a5e9032005-08-09 20:28:46 -07001005 }
1006
1007 if (changes)
1008 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
1009 data_bits, stop_bits, parity,
1010 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011}
1012
1013static void rfcomm_tty_throttle(struct tty_struct *tty)
1014{
1015 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1016
1017 BT_DBG("tty %p dev %p", tty, dev);
J. Suter3a5e9032005-08-09 20:28:46 -07001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 rfcomm_dlc_throttle(dev->dlc);
1020}
1021
1022static void rfcomm_tty_unthrottle(struct tty_struct *tty)
1023{
1024 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1025
1026 BT_DBG("tty %p dev %p", tty, dev);
J. Suter3a5e9032005-08-09 20:28:46 -07001027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 rfcomm_dlc_unthrottle(dev->dlc);
1029}
1030
1031static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
1032{
1033 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
1035 BT_DBG("tty %p dev %p", tty, dev);
1036
Marcel Holtmannb6e557f2007-01-08 02:16:27 +01001037 if (!dev || !dev->dlc)
1038 return 0;
1039
1040 if (!skb_queue_empty(&dev->dlc->tx_queue))
1041 return dev->dlc->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042
1043 return 0;
1044}
1045
1046static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
1047{
1048 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
1050 BT_DBG("tty %p dev %p", tty, dev);
1051
Marcel Holtmannb6e557f2007-01-08 02:16:27 +01001052 if (!dev || !dev->dlc)
1053 return;
1054
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 skb_queue_purge(&dev->dlc->tx_queue);
Alan Coxa352def2008-07-16 21:53:12 +01001056 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057}
1058
1059static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1060{
1061 BT_DBG("tty %p ch %c", tty, ch);
1062}
1063
1064static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1065{
1066 BT_DBG("tty %p timeout %d", tty, timeout);
1067}
1068
1069static void rfcomm_tty_hangup(struct tty_struct *tty)
1070{
1071 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
1073 BT_DBG("tty %p dev %p", tty, dev);
1074
Marcel Holtmannb6e557f2007-01-08 02:16:27 +01001075 if (!dev)
1076 return;
1077
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 rfcomm_tty_flush_buffer(tty);
1079
Marcel Holtmann77f2a452007-05-05 00:36:10 +02001080 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
1081 if (rfcomm_dev_get(dev->id) == NULL)
1082 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 rfcomm_dev_del(dev);
Marcel Holtmann77f2a452007-05-05 00:36:10 +02001084 rfcomm_dev_put(dev);
1085 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086}
1087
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088static int rfcomm_tty_tiocmget(struct tty_struct *tty, struct file *filp)
1089{
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001090 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 BT_DBG("tty %p dev %p", tty, dev);
1093
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001094 return dev->modem_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
1097static int rfcomm_tty_tiocmset(struct tty_struct *tty, struct file *filp, unsigned int set, unsigned int clear)
1098{
J. Suter3a5e9032005-08-09 20:28:46 -07001099 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1100 struct rfcomm_dlc *dlc = dev->dlc;
1101 u8 v24_sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
1103 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1104
J. Suter3a5e9032005-08-09 20:28:46 -07001105 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
J. Suter3a5e9032005-08-09 20:28:46 -07001107 if (set & TIOCM_DSR || set & TIOCM_DTR)
1108 v24_sig |= RFCOMM_V24_RTC;
1109 if (set & TIOCM_RTS || set & TIOCM_CTS)
1110 v24_sig |= RFCOMM_V24_RTR;
1111 if (set & TIOCM_RI)
1112 v24_sig |= RFCOMM_V24_IC;
1113 if (set & TIOCM_CD)
1114 v24_sig |= RFCOMM_V24_DV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
J. Suter3a5e9032005-08-09 20:28:46 -07001116 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1117 v24_sig &= ~RFCOMM_V24_RTC;
1118 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1119 v24_sig &= ~RFCOMM_V24_RTR;
1120 if (clear & TIOCM_RI)
1121 v24_sig &= ~RFCOMM_V24_IC;
1122 if (clear & TIOCM_CD)
1123 v24_sig &= ~RFCOMM_V24_DV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
J. Suter3a5e9032005-08-09 20:28:46 -07001125 rfcomm_dlc_set_modem_status(dlc, v24_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
J. Suter3a5e9032005-08-09 20:28:46 -07001127 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128}
1129
1130/* ---- TTY structure ---- */
1131
Jeff Dikeb68e31d2006-10-02 02:17:18 -07001132static const struct tty_operations rfcomm_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 .open = rfcomm_tty_open,
1134 .close = rfcomm_tty_close,
1135 .write = rfcomm_tty_write,
1136 .write_room = rfcomm_tty_write_room,
1137 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1138 .flush_buffer = rfcomm_tty_flush_buffer,
1139 .ioctl = rfcomm_tty_ioctl,
1140 .throttle = rfcomm_tty_throttle,
1141 .unthrottle = rfcomm_tty_unthrottle,
1142 .set_termios = rfcomm_tty_set_termios,
1143 .send_xchar = rfcomm_tty_send_xchar,
1144 .hangup = rfcomm_tty_hangup,
1145 .wait_until_sent = rfcomm_tty_wait_until_sent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 .tiocmget = rfcomm_tty_tiocmget,
1147 .tiocmset = rfcomm_tty_tiocmset,
1148};
1149
Gustavo F. Padovan2f8362a2010-07-24 02:04:45 -03001150int __init rfcomm_init_ttys(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151{
1152 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1153 if (!rfcomm_tty_driver)
1154 return -1;
1155
1156 rfcomm_tty_driver->owner = THIS_MODULE;
1157 rfcomm_tty_driver->driver_name = "rfcomm";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 rfcomm_tty_driver->name = "rfcomm";
1159 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1160 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1161 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1162 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07001163 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 rfcomm_tty_driver->init_termios = tty_std_termios;
1165 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Marcel Holtmannca37bdd2008-07-14 20:13:52 +02001166 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1168
1169 if (tty_register_driver(rfcomm_tty_driver)) {
1170 BT_ERR("Can't register RFCOMM TTY driver");
1171 put_tty_driver(rfcomm_tty_driver);
1172 return -1;
1173 }
1174
1175 BT_INFO("RFCOMM TTY layer initialized");
1176
1177 return 0;
1178}
1179
Gustavo F. Padovan28e95092010-07-31 19:57:05 -03001180void rfcomm_cleanup_ttys(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181{
1182 tty_unregister_driver(rfcomm_tty_driver);
1183 put_tty_driver(rfcomm_tty_driver);
1184}