blob: 8e385a0ae60e0bd6e4b1ed7615905a7170c4a8bc [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <net/bluetooth/bluetooth.h>
Marcel Holtmann0a85b962006-07-06 13:09:02 +020035#include <net/bluetooth/hci_core.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <net/bluetooth/rfcomm.h>
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#define RFCOMM_TTY_MAGIC 0x6d02 /* magic number for rfcomm struct */
39#define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV /* whole lotta rfcomm devices */
40#define RFCOMM_TTY_MAJOR 216 /* device node major id of the usb/bluetooth.c driver */
41#define RFCOMM_TTY_MINOR 0
42
Peter Hurley033ace92014-02-09 20:59:18 -050043static DEFINE_MUTEX(rfcomm_ioctl_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044static struct tty_driver *rfcomm_tty_driver;
45
46struct rfcomm_dev {
Jiri Slabyf60db8c2012-04-02 13:54:50 +020047 struct tty_port port;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50 char name[12];
51 int id;
52 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 int err;
54
Peter Hurley1c648342014-02-09 20:59:07 -050055 unsigned long status; /* don't export to userspace */
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 bdaddr_t src;
58 bdaddr_t dst;
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +020059 u8 channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +020061 uint modem_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63 struct rfcomm_dlc *dlc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Marcel Holtmannc1a33132007-02-17 23:58:57 +010065 struct device *tty_dev;
66
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +020067 atomic_t wmem_alloc;
Marcel Holtmanna0c22f22008-07-14 20:13:52 +020068
69 struct sk_buff_head pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070};
71
72static LIST_HEAD(rfcomm_dev_list);
Libor Pechacek86aae6c2014-04-29 20:38:34 +020073static DEFINE_MUTEX(rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
76static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
77static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079/* ---- Device functions ---- */
Jiri Slaby67054012012-04-02 13:54:51 +020080
Jiri Slaby67054012012-04-02 13:54:51 +020081static void rfcomm_dev_destruct(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
Jiri Slaby67054012012-04-02 13:54:51 +020083 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 struct rfcomm_dlc *dlc = dev->dlc;
85
86 BT_DBG("dev %p dlc %p", dev, dlc);
87
88 rfcomm_dlc_lock(dlc);
89 /* Detach DLC if it's owned by this dev */
90 if (dlc->owner == dev)
91 dlc->owner = NULL;
92 rfcomm_dlc_unlock(dlc);
93
94 rfcomm_dlc_put(dlc);
95
Peter Hurleyfb856e52014-02-09 20:59:20 -050096 if (dev->tty_dev)
97 tty_unregister_device(rfcomm_tty_driver, dev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Libor Pechacek86aae6c2014-04-29 20:38:34 +020099 mutex_lock(&rfcomm_dev_lock);
Peter Hurleyc949c222014-02-09 20:59:09 -0500100 list_del(&dev->list);
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200101 mutex_unlock(&rfcomm_dev_lock);
Peter Hurleyc949c222014-02-09 20:59:09 -0500102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 kfree(dev);
104
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900105 /* It's safe to call module_put() here because socket still
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 holds reference to this module. */
107 module_put(THIS_MODULE);
108}
109
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200110/* device-specific initialization: open the dlc */
111static int rfcomm_dev_activate(struct tty_port *port, struct tty_struct *tty)
112{
113 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
Peter Hurley5326a4e2014-02-09 20:59:21 -0500114 int err;
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200115
Peter Hurley5326a4e2014-02-09 20:59:21 -0500116 err = rfcomm_dlc_open(dev->dlc, &dev->src, &dev->dst, dev->channel);
117 if (err)
118 set_bit(TTY_IO_ERROR, &tty->flags);
119 return err;
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200120}
121
Peter Hurley7f717b92014-02-09 20:59:01 -0500122/* we block the open until the dlc->state becomes BT_CONNECTED */
123static int rfcomm_dev_carrier_raised(struct tty_port *port)
124{
125 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
126
127 return (dev->dlc->state == BT_CONNECTED);
128}
129
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200130/* device-specific cleanup: close the dlc */
131static void rfcomm_dev_shutdown(struct tty_port *port)
132{
133 struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
134
135 if (dev->tty_dev->parent)
136 device_move(dev->tty_dev, NULL, DPM_ORDER_DEV_LAST);
137
138 /* close the dlc */
139 rfcomm_dlc_close(dev->dlc, 0);
140}
141
Jiri Slaby67054012012-04-02 13:54:51 +0200142static const struct tty_port_operations rfcomm_port_ops = {
143 .destruct = rfcomm_dev_destruct,
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200144 .activate = rfcomm_dev_activate,
145 .shutdown = rfcomm_dev_shutdown,
Peter Hurley136c3732014-02-09 20:59:02 -0500146 .carrier_raised = rfcomm_dev_carrier_raised,
Jiri Slaby67054012012-04-02 13:54:51 +0200147};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Peter Hurley7611fce2014-02-09 20:59:17 -0500149static struct rfcomm_dev *__rfcomm_dev_lookup(int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 struct rfcomm_dev *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200153 list_for_each_entry(dev, &rfcomm_dev_list, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 if (dev->id == id)
155 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 return NULL;
158}
159
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300160static struct rfcomm_dev *rfcomm_dev_get(int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
162 struct rfcomm_dev *dev;
163
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200164 mutex_lock(&rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Peter Hurley7611fce2014-02-09 20:59:17 -0500166 dev = __rfcomm_dev_lookup(id);
Ville Tervo8de0a152007-07-11 09:23:41 +0200167
Peter Hurley082a1532014-02-09 20:59:05 -0500168 if (dev && !tty_port_get(&dev->port))
169 dev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200171 mutex_unlock(&rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
173 return dev;
174}
175
Peter Hurleyb92483d2014-02-09 20:59:15 -0500176static void rfcomm_reparent_device(struct rfcomm_dev *dev)
Peter Hurleyf87c24e2014-02-09 20:59:03 -0500177{
178 struct hci_dev *hdev;
179 struct hci_conn *conn;
180
181 hdev = hci_get_route(&dev->dst, &dev->src);
182 if (!hdev)
Peter Hurleyb92483d2014-02-09 20:59:15 -0500183 return;
Peter Hurleyf87c24e2014-02-09 20:59:03 -0500184
Peter Hurleyb92483d2014-02-09 20:59:15 -0500185 /* The lookup results are unsafe to access without the
186 * hci device lock (FIXME: why is this not documented?)
187 */
188 hci_dev_lock(hdev);
Peter Hurleyf87c24e2014-02-09 20:59:03 -0500189 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
190
Peter Hurleyb92483d2014-02-09 20:59:15 -0500191 /* Just because the acl link is in the hash table is no
192 * guarantee the sysfs device has been added ...
193 */
194 if (conn && device_is_registered(&conn->dev))
195 device_move(dev->tty_dev, &conn->dev, DPM_ORDER_DEV_AFTER_PARENT);
Peter Hurleyf87c24e2014-02-09 20:59:03 -0500196
Peter Hurleyb92483d2014-02-09 20:59:15 -0500197 hci_dev_unlock(hdev);
198 hci_dev_put(hdev);
Peter Hurleyf87c24e2014-02-09 20:59:03 -0500199}
200
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200201static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
202{
203 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
Andrei Emeltchenkofcb73332012-09-25 12:49:44 +0300204 return sprintf(buf, "%pMR\n", &dev->dst);
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200205}
206
207static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
208{
209 struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
210 return sprintf(buf, "%d\n", dev->channel);
211}
212
213static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
214static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
215
Peter Hurleyf3550952014-02-09 20:59:19 -0500216static struct rfcomm_dev *__rfcomm_dev_add(struct rfcomm_dev_req *req,
217 struct rfcomm_dlc *dlc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200219 struct rfcomm_dev *dev, *entry;
Luiz Augusto von Dentze57d758a2012-03-07 20:20:14 +0200220 struct list_head *head = &rfcomm_dev_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 int err = 0;
222
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200223 dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 if (!dev)
Peter Hurleyf3550952014-02-09 20:59:19 -0500225 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200227 mutex_lock(&rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 if (req->dev_id < 0) {
230 dev->id = 0;
231
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200232 list_for_each_entry(entry, &rfcomm_dev_list, list) {
233 if (entry->id != dev->id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 break;
235
236 dev->id++;
Luiz Augusto von Dentze57d758a2012-03-07 20:20:14 +0200237 head = &entry->list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239 } else {
240 dev->id = req->dev_id;
241
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200242 list_for_each_entry(entry, &rfcomm_dev_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (entry->id == dev->id) {
244 err = -EADDRINUSE;
245 goto out;
246 }
247
248 if (entry->id > dev->id - 1)
249 break;
250
Luiz Augusto von Dentze57d758a2012-03-07 20:20:14 +0200251 head = &entry->list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253 }
254
255 if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
256 err = -ENFILE;
257 goto out;
258 }
259
260 sprintf(dev->name, "rfcomm%d", dev->id);
261
262 list_add(&dev->list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 bacpy(&dev->src, &req->src);
265 bacpy(&dev->dst, &req->dst);
266 dev->channel = req->channel;
267
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900268 dev->flags = req->flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 ((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));
270
Jiri Slabyf60db8c2012-04-02 13:54:50 +0200271 tty_port_init(&dev->port);
Jiri Slaby67054012012-04-02 13:54:51 +0200272 dev->port.ops = &rfcomm_port_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200274 skb_queue_head_init(&dev->pending);
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 rfcomm_dlc_lock(dlc);
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200277
278 if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
279 struct sock *sk = dlc->owner;
280 struct sk_buff *skb;
281
282 BUG_ON(!sk);
283
284 rfcomm_dlc_throttle(dlc);
285
286 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
287 skb_orphan(skb);
288 skb_queue_tail(&dev->pending, skb);
289 atomic_sub(skb->len, &sk->sk_rmem_alloc);
290 }
291 }
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 dlc->data_ready = rfcomm_dev_data_ready;
294 dlc->state_change = rfcomm_dev_state_change;
295 dlc->modem_status = rfcomm_dev_modem_status;
296
297 dlc->owner = dev;
298 dev->dlc = dlc;
Marcel Holtmann8b6b3da2008-07-14 20:13:52 +0200299
300 rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 rfcomm_dlc_unlock(dlc);
303
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900304 /* It's safe to call __module_get() here because socket already
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 holds reference to this module. */
306 __module_get(THIS_MODULE);
307
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200308 mutex_unlock(&rfcomm_dev_lock);
Peter Hurleyf3550952014-02-09 20:59:19 -0500309 return dev;
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311out:
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200312 mutex_unlock(&rfcomm_dev_lock);
Peter Hurleyf3550952014-02-09 20:59:19 -0500313 kfree(dev);
314 return ERR_PTR(err);
315}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Peter Hurleyf3550952014-02-09 20:59:19 -0500317static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
318{
319 struct rfcomm_dev *dev;
320 struct device *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Peter Hurleyf3550952014-02-09 20:59:19 -0500322 BT_DBG("id %d channel %d", req->dev_id, req->channel);
323
324 dev = __rfcomm_dev_add(req, dlc);
Peter Hurleyfb856e52014-02-09 20:59:20 -0500325 if (IS_ERR(dev)) {
326 rfcomm_dlc_put(dlc);
Peter Hurleyf3550952014-02-09 20:59:19 -0500327 return PTR_ERR(dev);
Peter Hurleyfb856e52014-02-09 20:59:20 -0500328 }
Peter Hurleyf3550952014-02-09 20:59:19 -0500329
330 tty = tty_port_register_device(&dev->port, rfcomm_tty_driver,
Jiri Slaby734cc172012-08-07 21:47:47 +0200331 dev->id, NULL);
Peter Hurleyf3550952014-02-09 20:59:19 -0500332 if (IS_ERR(tty)) {
Peter Hurleyfb856e52014-02-09 20:59:20 -0500333 tty_port_put(&dev->port);
Peter Hurleyf3550952014-02-09 20:59:19 -0500334 return PTR_ERR(tty);
Ville Tervo8de0a152007-07-11 09:23:41 +0200335 }
336
Peter Hurleyf3550952014-02-09 20:59:19 -0500337 dev->tty_dev = tty;
Peter Hurleyb4d21f192014-02-09 20:59:16 -0500338 rfcomm_reparent_device(dev);
Marcel Holtmanndae6a0f2007-10-20 14:52:38 +0200339 dev_set_drvdata(dev->tty_dev, dev);
340
341 if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
342 BT_ERR("Failed to create address attribute");
343
344 if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
345 BT_ERR("Failed to create channel attribute");
346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return dev->id;
348}
349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350/* ---- Send buffer ---- */
Peter Hurleyb16b4352014-02-09 20:59:23 -0500351static inline unsigned int rfcomm_room(struct rfcomm_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Peter Hurleyb16b4352014-02-09 20:59:23 -0500353 struct rfcomm_dlc *dlc = dev->dlc;
354
Peter Hurley8981be92014-02-09 20:59:24 -0500355 /* Limit the outstanding number of packets not yet sent to 40 */
356 int pending = 40 - atomic_read(&dev->wmem_alloc);
Peter Hurleyb16b4352014-02-09 20:59:23 -0500357
Peter Hurley8981be92014-02-09 20:59:24 -0500358 return max(0, pending) * dlc->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
361static void rfcomm_wfree(struct sk_buff *skb)
362{
363 struct rfcomm_dev *dev = (void *) skb->sk;
Peter Hurley8981be92014-02-09 20:59:24 -0500364 atomic_dec(&dev->wmem_alloc);
Gianluca Anzolin396dc222013-07-29 17:08:08 +0200365 if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
366 tty_port_tty_wakeup(&dev->port);
Jiri Slaby67054012012-04-02 13:54:51 +0200367 tty_port_put(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368}
369
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300370static void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Jiri Slaby67054012012-04-02 13:54:51 +0200372 tty_port_get(&dev->port);
Peter Hurley8981be92014-02-09 20:59:24 -0500373 atomic_inc(&dev->wmem_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 skb->sk = (void *) dev;
375 skb->destructor = rfcomm_wfree;
376}
377
Al Virodd0fc662005-10-07 07:46:04 +0100378static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Peter Hurley72e51082014-02-09 20:59:22 -0500380 struct sk_buff *skb = alloc_skb(size, priority);
381 if (skb)
382 rfcomm_set_owner_w(skb, dev);
383 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384}
385
386/* ---- Device IOCTLs ---- */
387
388#define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
389
Peter Hurley033ace92014-02-09 20:59:18 -0500390static int __rfcomm_create_dev(struct sock *sk, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
392 struct rfcomm_dev_req req;
393 struct rfcomm_dlc *dlc;
394 int id;
395
396 if (copy_from_user(&req, arg, sizeof(req)))
397 return -EFAULT;
398
Ville Tervo8de0a152007-07-11 09:23:41 +0200399 BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
402 return -EPERM;
403
404 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
405 /* Socket must be connected */
406 if (sk->sk_state != BT_CONNECTED)
407 return -EBADFD;
408
409 dlc = rfcomm_pi(sk)->dlc;
410 rfcomm_dlc_hold(dlc);
411 } else {
Peter Hurleyc10a8482014-02-09 20:59:10 -0500412 /* Validate the channel is unused */
413 dlc = rfcomm_dlc_exists(&req.src, &req.dst, req.channel);
414 if (IS_ERR(dlc))
415 return PTR_ERR(dlc);
416 else if (dlc) {
417 rfcomm_dlc_put(dlc);
418 return -EBUSY;
419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
421 if (!dlc)
422 return -ENOMEM;
423 }
424
425 id = rfcomm_dev_add(&req, dlc);
Peter Hurleyfb856e52014-02-09 20:59:20 -0500426 if (id < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429 if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
430 /* DLC is now used by device.
431 * Socket must be disconnected */
432 sk->sk_state = BT_CLOSED;
433 }
434
435 return id;
436}
437
Peter Hurley033ace92014-02-09 20:59:18 -0500438static int __rfcomm_release_dev(void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
440 struct rfcomm_dev_req req;
441 struct rfcomm_dev *dev;
Gianluca Anzolin396dc222013-07-29 17:08:08 +0200442 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 if (copy_from_user(&req, arg, sizeof(req)))
445 return -EFAULT;
446
Ville Tervo8de0a152007-07-11 09:23:41 +0200447 BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200449 dev = rfcomm_dev_get(req.dev_id);
450 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return -ENODEV;
452
453 if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
Jiri Slaby67054012012-04-02 13:54:51 +0200454 tty_port_put(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 return -EPERM;
456 }
457
Peter Hurley1c648342014-02-09 20:59:07 -0500458 /* only release once */
459 if (test_and_set_bit(RFCOMM_DEV_RELEASED, &dev->status)) {
460 tty_port_put(&dev->port);
461 return -EALREADY;
462 }
463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 if (req.flags & (1 << RFCOMM_HANGUP_NOW))
465 rfcomm_dlc_close(dev->dlc, 0);
466
Mikko Rapeli84950cf2007-07-11 09:18:15 +0200467 /* Shut down TTY synchronously before freeing rfcomm_dev */
Gianluca Anzolin396dc222013-07-29 17:08:08 +0200468 tty = tty_port_tty_get(&dev->port);
469 if (tty) {
470 tty_vhangup(tty);
471 tty_kref_put(tty);
472 }
Mikko Rapeli84950cf2007-07-11 09:18:15 +0200473
Peter Hurley80ea7332014-02-09 20:59:08 -0500474 if (!test_bit(RFCOMM_TTY_OWNED, &dev->status))
Gianluca Anzolinece31502013-07-29 17:08:12 +0200475 tty_port_put(&dev->port);
476
Jiri Slaby67054012012-04-02 13:54:51 +0200477 tty_port_put(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 return 0;
479}
480
Peter Hurley033ace92014-02-09 20:59:18 -0500481static int rfcomm_create_dev(struct sock *sk, void __user *arg)
482{
483 int ret;
484
485 mutex_lock(&rfcomm_ioctl_mutex);
486 ret = __rfcomm_create_dev(sk, arg);
487 mutex_unlock(&rfcomm_ioctl_mutex);
488
489 return ret;
490}
491
492static int rfcomm_release_dev(void __user *arg)
493{
494 int ret;
495
496 mutex_lock(&rfcomm_ioctl_mutex);
497 ret = __rfcomm_release_dev(arg);
498 mutex_unlock(&rfcomm_ioctl_mutex);
499
500 return ret;
501}
502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503static int rfcomm_get_dev_list(void __user *arg)
504{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200505 struct rfcomm_dev *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 struct rfcomm_dev_list_req *dl;
507 struct rfcomm_dev_info *di;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 int n = 0, size, err;
509 u16 dev_num;
510
511 BT_DBG("");
512
513 if (get_user(dev_num, (u16 __user *) arg))
514 return -EFAULT;
515
516 if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
517 return -EINVAL;
518
519 size = sizeof(*dl) + dev_num * sizeof(*di);
520
Mathias Krausef9432c52012-08-15 11:31:49 +0000521 dl = kzalloc(size, GFP_KERNEL);
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200522 if (!dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return -ENOMEM;
524
525 di = dl->dev_info;
526
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200527 mutex_lock(&rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200529 list_for_each_entry(dev, &rfcomm_dev_list, list) {
Peter Hurley960603a2014-02-09 20:59:06 -0500530 if (!tty_port_get(&dev->port))
Ville Tervo8de0a152007-07-11 09:23:41 +0200531 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 (di + n)->id = dev->id;
533 (di + n)->flags = dev->flags;
534 (di + n)->state = dev->dlc->state;
535 (di + n)->channel = dev->channel;
536 bacpy(&(di + n)->src, &dev->src);
537 bacpy(&(di + n)->dst, &dev->dst);
Peter Hurley960603a2014-02-09 20:59:06 -0500538 tty_port_put(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 if (++n >= dev_num)
540 break;
541 }
542
Libor Pechacek86aae6c2014-04-29 20:38:34 +0200543 mutex_unlock(&rfcomm_dev_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 dl->dev_num = n;
546 size = sizeof(*dl) + n * sizeof(*di);
547
548 err = copy_to_user(arg, dl, size);
549 kfree(dl);
550
551 return err ? -EFAULT : 0;
552}
553
554static int rfcomm_get_dev_info(void __user *arg)
555{
556 struct rfcomm_dev *dev;
557 struct rfcomm_dev_info di;
558 int err = 0;
559
560 BT_DBG("");
561
562 if (copy_from_user(&di, arg, sizeof(di)))
563 return -EFAULT;
564
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200565 dev = rfcomm_dev_get(di.id);
566 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 return -ENODEV;
568
569 di.flags = dev->flags;
570 di.channel = dev->channel;
571 di.state = dev->dlc->state;
572 bacpy(&di.src, &dev->src);
573 bacpy(&di.dst, &dev->dst);
574
575 if (copy_to_user(arg, &di, sizeof(di)))
576 err = -EFAULT;
577
Jiri Slaby67054012012-04-02 13:54:51 +0200578 tty_port_put(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return err;
580}
581
582int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
583{
584 BT_DBG("cmd %d arg %p", cmd, arg);
585
586 switch (cmd) {
587 case RFCOMMCREATEDEV:
588 return rfcomm_create_dev(sk, arg);
589
590 case RFCOMMRELEASEDEV:
591 return rfcomm_release_dev(arg);
592
593 case RFCOMMGETDEVLIST:
594 return rfcomm_get_dev_list(arg);
595
596 case RFCOMMGETDEVINFO:
597 return rfcomm_get_dev_info(arg);
598 }
599
600 return -EINVAL;
601}
602
603/* ---- DLC callbacks ---- */
604static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
605{
606 struct rfcomm_dev *dev = dlc->owner;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900607
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200608 if (!dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 kfree_skb(skb);
610 return;
611 }
612
Jiri Slaby2e124b42013-01-03 15:53:06 +0100613 if (!skb_queue_empty(&dev->pending)) {
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200614 skb_queue_tail(&dev->pending, skb);
615 return;
616 }
617
Jiri Slaby2e124b42013-01-03 15:53:06 +0100618 BT_DBG("dlc %p len %d", dlc, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100620 tty_insert_flip_string(&dev->port, skb->data, skb->len);
Jiri Slaby2e124b42013-01-03 15:53:06 +0100621 tty_flip_buffer_push(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 kfree_skb(skb);
624}
625
626static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
627{
628 struct rfcomm_dev *dev = dlc->owner;
629 if (!dev)
630 return;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
633
634 dev->err = err;
Peter Hurley136c3732014-02-09 20:59:02 -0500635 if (dlc->state == BT_CONNECTED) {
Peter Hurleyb92483d2014-02-09 20:59:15 -0500636 rfcomm_reparent_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Peter Hurley136c3732014-02-09 20:59:02 -0500638 wake_up_interruptible(&dev->port.open_wait);
639 } else if (dlc->state == BT_CLOSED)
Gianluca Anzolin29cd7182013-08-27 18:28:46 +0200640 tty_port_tty_hangup(&dev->port, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
642
643static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
644{
645 struct rfcomm_dev *dev = dlc->owner;
646 if (!dev)
647 return;
Timo Teräs7b9eb9e2005-08-09 20:28:21 -0700648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 BT_DBG("dlc %p dev %p v24_sig 0x%02x", dlc, dev, v24_sig);
650
Gianluca Anzolin396dc222013-07-29 17:08:08 +0200651 if ((dev->modem_status & TIOCM_CD) && !(v24_sig & RFCOMM_V24_DV))
652 tty_port_tty_hangup(&dev->port, true);
Timo Teräs7b9eb9e2005-08-09 20:28:21 -0700653
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900654 dev->modem_status =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 ((v24_sig & RFCOMM_V24_RTC) ? (TIOCM_DSR | TIOCM_DTR) : 0) |
656 ((v24_sig & RFCOMM_V24_RTR) ? (TIOCM_RTS | TIOCM_CTS) : 0) |
657 ((v24_sig & RFCOMM_V24_IC) ? TIOCM_RI : 0) |
658 ((v24_sig & RFCOMM_V24_DV) ? TIOCM_CD : 0);
659}
660
661/* ---- TTY functions ---- */
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200662static void rfcomm_tty_copy_pending(struct rfcomm_dev *dev)
663{
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200664 struct sk_buff *skb;
665 int inserted = 0;
666
Jiri Slaby2e124b42013-01-03 15:53:06 +0100667 BT_DBG("dev %p", dev);
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200668
669 rfcomm_dlc_lock(dev->dlc);
670
671 while ((skb = skb_dequeue(&dev->pending))) {
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100672 inserted += tty_insert_flip_string(&dev->port, skb->data,
673 skb->len);
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200674 kfree_skb(skb);
675 }
676
677 rfcomm_dlc_unlock(dev->dlc);
678
679 if (inserted > 0)
Jiri Slaby2e124b42013-01-03 15:53:06 +0100680 tty_flip_buffer_push(&dev->port);
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200681}
682
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200683/* do the reverse of install, clearing the tty fields and releasing the
684 * reference to tty_port
685 */
686static void rfcomm_tty_cleanup(struct tty_struct *tty)
687{
688 struct rfcomm_dev *dev = tty->driver_data;
689
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200690 clear_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
691
692 rfcomm_dlc_lock(dev->dlc);
693 tty->driver_data = NULL;
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200694 rfcomm_dlc_unlock(dev->dlc);
695
Gianluca Anzolinffe6b682013-07-29 17:08:13 +0200696 /*
697 * purge the dlc->tx_queue to avoid circular dependencies
698 * between dev and dlc
699 */
700 skb_queue_purge(&dev->dlc->tx_queue);
701
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200702 tty_port_put(&dev->port);
703}
704
705/* we acquire the tty_port reference since it's here the tty is first used
706 * by setting the termios. We also populate the driver_data field and install
707 * the tty port
708 */
709static int rfcomm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 struct rfcomm_dev *dev;
712 struct rfcomm_dlc *dlc;
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200713 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200715 dev = rfcomm_dev_get(tty->index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 if (!dev)
717 return -ENODEV;
718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 dlc = dev->dlc;
720
721 /* Attach TTY and open DLC */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 rfcomm_dlc_lock(dlc);
723 tty->driver_data = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 rfcomm_dlc_unlock(dlc);
725 set_bit(RFCOMM_TTY_ATTACHED, &dev->flags);
726
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200727 /* install the tty_port */
728 err = tty_port_install(&dev->port, driver, tty);
Gianluca Anzolin5b899242014-01-06 21:23:50 +0100729 if (err) {
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200730 rfcomm_tty_cleanup(tty);
Gianluca Anzolin5b899242014-01-06 21:23:50 +0100731 return err;
732 }
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200733
Gianluca Anzolin5b899242014-01-06 21:23:50 +0100734 /* take over the tty_port reference if the port was created with the
735 * flag RFCOMM_RELEASE_ONHUP. This will force the release of the port
736 * when the last process closes the tty. The behaviour is expected by
737 * userspace.
738 */
Peter Hurley80ea7332014-02-09 20:59:08 -0500739 if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
740 set_bit(RFCOMM_TTY_OWNED, &dev->status);
Gianluca Anzolin5b899242014-01-06 21:23:50 +0100741 tty_port_put(&dev->port);
Peter Hurley80ea7332014-02-09 20:59:08 -0500742 }
Gianluca Anzolin5b899242014-01-06 21:23:50 +0100743
744 return 0;
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200745}
746
747static int rfcomm_tty_open(struct tty_struct *tty, struct file *filp)
748{
749 struct rfcomm_dev *dev = tty->driver_data;
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200750 int err;
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200751
752 BT_DBG("tty %p id %d", tty, tty->index);
753
754 BT_DBG("dev %p dst %pMR channel %d opened %d", dev, &dev->dst,
755 dev->channel, dev->port.count);
756
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200757 err = tty_port_open(&dev->port, tty, filp);
758 if (err)
759 return err;
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200760
761 /*
762 * FIXME: rfcomm should use proper flow control for
763 * received data. This hack will be unnecessary and can
764 * be removed when that's implemented
765 */
Marcel Holtmanna0c22f22008-07-14 20:13:52 +0200766 rfcomm_tty_copy_pending(dev);
767
768 rfcomm_dlc_unthrottle(dev->dlc);
769
Gianluca Anzolin54b926a2013-07-29 17:08:10 +0200770 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
772
773static void rfcomm_tty_close(struct tty_struct *tty, struct file *filp)
774{
775 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Jiri Slabyf997a012012-04-02 13:54:53 +0200776
Marcel Holtmann9a5df922008-11-30 12:17:29 +0100777 BT_DBG("tty %p dev %p dlc %p opened %d", tty, dev, dev->dlc,
Jiri Slabyf997a012012-04-02 13:54:53 +0200778 dev->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Gianluca Anzolincad348a2013-07-29 17:08:11 +0200780 tty_port_close(&dev->port, tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781}
782
783static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
784{
785 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
786 struct rfcomm_dlc *dlc = dev->dlc;
787 struct sk_buff *skb;
Peter Hurley72e51082014-02-09 20:59:22 -0500788 int sent = 0, size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 BT_DBG("tty %p count %d", tty, count);
791
792 while (count) {
793 size = min_t(uint, count, dlc->mtu);
794
795 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (!skb)
797 break;
798
799 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
800
801 memcpy(skb_put(skb, size), buf + sent, size);
802
Peter Hurley72e51082014-02-09 20:59:22 -0500803 rfcomm_dlc_send_noerror(dlc, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 sent += size;
806 count -= size;
807 }
808
Peter Hurley72e51082014-02-09 20:59:22 -0500809 return sent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
812static int rfcomm_tty_write_room(struct tty_struct *tty)
813{
814 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Peter Hurleyb16b4352014-02-09 20:59:23 -0500815 int room = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Peter Hurleyb16b4352014-02-09 20:59:23 -0500817 if (dev && dev->dlc)
818 room = rfcomm_room(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Peter Hurleyb16b4352014-02-09 20:59:23 -0500820 BT_DBG("tty %p room %d", tty, room);
Marcel Holtmannb6e557f2007-01-08 02:16:27 +0100821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return room;
823}
824
Alan Cox6caa76b2011-02-14 16:27:22 +0000825static int rfcomm_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826{
827 BT_DBG("tty %p cmd 0x%02x", tty, cmd);
828
829 switch (cmd) {
830 case TCGETS:
831 BT_DBG("TCGETS is not supported");
832 return -ENOIOCTLCMD;
833
834 case TCSETS:
835 BT_DBG("TCSETS is not supported");
836 return -ENOIOCTLCMD;
837
838 case TIOCMIWAIT:
839 BT_DBG("TIOCMIWAIT");
840 break;
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 case TIOCGSERIAL:
843 BT_ERR("TIOCGSERIAL is not supported");
844 return -ENOIOCTLCMD;
845
846 case TIOCSSERIAL:
847 BT_ERR("TIOCSSERIAL is not supported");
848 return -ENOIOCTLCMD;
849
850 case TIOCSERGSTRUCT:
851 BT_ERR("TIOCSERGSTRUCT is not supported");
852 return -ENOIOCTLCMD;
853
854 case TIOCSERGETLSR:
855 BT_ERR("TIOCSERGETLSR is not supported");
856 return -ENOIOCTLCMD;
857
858 case TIOCSERCONFIG:
859 BT_ERR("TIOCSERCONFIG is not supported");
860 return -ENOIOCTLCMD;
861
862 default:
863 return -ENOIOCTLCMD; /* ioctls which we must ignore */
864
865 }
866
867 return -ENOIOCTLCMD;
868}
869
Alan Cox606d0992006-12-08 02:38:45 -0800870static void rfcomm_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
Alan Coxadc8d742012-07-14 15:31:47 +0100872 struct ktermios *new = &tty->termios;
J. Suter3a5e9032005-08-09 20:28:46 -0700873 int old_baud_rate = tty_termios_baud_rate(old);
874 int new_baud_rate = tty_termios_baud_rate(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
J. Suter3a5e9032005-08-09 20:28:46 -0700876 u8 baud, data_bits, stop_bits, parity, x_on, x_off;
877 u16 changes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
J. Suter3a5e9032005-08-09 20:28:46 -0700879 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
880
881 BT_DBG("tty %p termios %p", tty, old);
882
Marcel Holtmannff2d3672006-11-18 22:14:42 +0100883 if (!dev || !dev->dlc || !dev->dlc->session)
Marcel Holtmanncb19d9e2006-10-15 17:31:10 +0200884 return;
885
J. Suter3a5e9032005-08-09 20:28:46 -0700886 /* Handle turning off CRTSCTS */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900887 if ((old->c_cflag & CRTSCTS) && !(new->c_cflag & CRTSCTS))
J. Suter3a5e9032005-08-09 20:28:46 -0700888 BT_DBG("Turning off CRTSCTS unsupported");
889
890 /* Parity on/off and when on, odd/even */
891 if (((old->c_cflag & PARENB) != (new->c_cflag & PARENB)) ||
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200892 ((old->c_cflag & PARODD) != (new->c_cflag & PARODD))) {
J. Suter3a5e9032005-08-09 20:28:46 -0700893 changes |= RFCOMM_RPN_PM_PARITY;
894 BT_DBG("Parity change detected.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 }
J. Suter3a5e9032005-08-09 20:28:46 -0700896
897 /* Mark and space parity are not supported! */
898 if (new->c_cflag & PARENB) {
899 if (new->c_cflag & PARODD) {
900 BT_DBG("Parity is ODD");
901 parity = RFCOMM_RPN_PARITY_ODD;
902 } else {
903 BT_DBG("Parity is EVEN");
904 parity = RFCOMM_RPN_PARITY_EVEN;
905 }
906 } else {
907 BT_DBG("Parity is OFF");
908 parity = RFCOMM_RPN_PARITY_NONE;
909 }
910
911 /* Setting the x_on / x_off characters */
912 if (old->c_cc[VSTOP] != new->c_cc[VSTOP]) {
913 BT_DBG("XOFF custom");
914 x_on = new->c_cc[VSTOP];
915 changes |= RFCOMM_RPN_PM_XON;
916 } else {
917 BT_DBG("XOFF default");
918 x_on = RFCOMM_RPN_XON_CHAR;
919 }
920
921 if (old->c_cc[VSTART] != new->c_cc[VSTART]) {
922 BT_DBG("XON custom");
923 x_off = new->c_cc[VSTART];
924 changes |= RFCOMM_RPN_PM_XOFF;
925 } else {
926 BT_DBG("XON default");
927 x_off = RFCOMM_RPN_XOFF_CHAR;
928 }
929
930 /* Handle setting of stop bits */
931 if ((old->c_cflag & CSTOPB) != (new->c_cflag & CSTOPB))
932 changes |= RFCOMM_RPN_PM_STOP;
933
934 /* POSIX does not support 1.5 stop bits and RFCOMM does not
935 * support 2 stop bits. So a request for 2 stop bits gets
936 * translated to 1.5 stop bits */
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200937 if (new->c_cflag & CSTOPB)
J. Suter3a5e9032005-08-09 20:28:46 -0700938 stop_bits = RFCOMM_RPN_STOP_15;
Andrei Emeltchenko285b4e92010-12-01 16:58:23 +0200939 else
J. Suter3a5e9032005-08-09 20:28:46 -0700940 stop_bits = RFCOMM_RPN_STOP_1;
J. Suter3a5e9032005-08-09 20:28:46 -0700941
942 /* Handle number of data bits [5-8] */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900943 if ((old->c_cflag & CSIZE) != (new->c_cflag & CSIZE))
J. Suter3a5e9032005-08-09 20:28:46 -0700944 changes |= RFCOMM_RPN_PM_DATA;
945
946 switch (new->c_cflag & CSIZE) {
947 case CS5:
948 data_bits = RFCOMM_RPN_DATA_5;
949 break;
950 case CS6:
951 data_bits = RFCOMM_RPN_DATA_6;
952 break;
953 case CS7:
954 data_bits = RFCOMM_RPN_DATA_7;
955 break;
956 case CS8:
957 data_bits = RFCOMM_RPN_DATA_8;
958 break;
959 default:
960 data_bits = RFCOMM_RPN_DATA_8;
961 break;
962 }
963
964 /* Handle baudrate settings */
965 if (old_baud_rate != new_baud_rate)
966 changes |= RFCOMM_RPN_PM_BITRATE;
967
968 switch (new_baud_rate) {
969 case 2400:
970 baud = RFCOMM_RPN_BR_2400;
971 break;
972 case 4800:
973 baud = RFCOMM_RPN_BR_4800;
974 break;
975 case 7200:
976 baud = RFCOMM_RPN_BR_7200;
977 break;
978 case 9600:
979 baud = RFCOMM_RPN_BR_9600;
980 break;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900981 case 19200:
J. Suter3a5e9032005-08-09 20:28:46 -0700982 baud = RFCOMM_RPN_BR_19200;
983 break;
984 case 38400:
985 baud = RFCOMM_RPN_BR_38400;
986 break;
987 case 57600:
988 baud = RFCOMM_RPN_BR_57600;
989 break;
990 case 115200:
991 baud = RFCOMM_RPN_BR_115200;
992 break;
993 case 230400:
994 baud = RFCOMM_RPN_BR_230400;
995 break;
996 default:
997 /* 9600 is standard accordinag to the RFCOMM specification */
998 baud = RFCOMM_RPN_BR_9600;
999 break;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001000
J. Suter3a5e9032005-08-09 20:28:46 -07001001 }
1002
1003 if (changes)
1004 rfcomm_send_rpn(dev->dlc->session, 1, dev->dlc->dlci, baud,
1005 data_bits, stop_bits, parity,
1006 RFCOMM_RPN_FLOW_NONE, x_on, x_off, changes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
1009static void rfcomm_tty_throttle(struct tty_struct *tty)
1010{
1011 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1012
1013 BT_DBG("tty %p dev %p", tty, dev);
J. Suter3a5e9032005-08-09 20:28:46 -07001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 rfcomm_dlc_throttle(dev->dlc);
1016}
1017
1018static void rfcomm_tty_unthrottle(struct tty_struct *tty)
1019{
1020 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1021
1022 BT_DBG("tty %p dev %p", tty, dev);
J. Suter3a5e9032005-08-09 20:28:46 -07001023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 rfcomm_dlc_unthrottle(dev->dlc);
1025}
1026
1027static int rfcomm_tty_chars_in_buffer(struct tty_struct *tty)
1028{
1029 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030
1031 BT_DBG("tty %p dev %p", tty, dev);
1032
Marcel Holtmannb6e557f2007-01-08 02:16:27 +01001033 if (!dev || !dev->dlc)
1034 return 0;
1035
1036 if (!skb_queue_empty(&dev->dlc->tx_queue))
1037 return dev->dlc->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 return 0;
1040}
1041
1042static void rfcomm_tty_flush_buffer(struct tty_struct *tty)
1043{
1044 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
1046 BT_DBG("tty %p dev %p", tty, dev);
1047
Marcel Holtmannb6e557f2007-01-08 02:16:27 +01001048 if (!dev || !dev->dlc)
1049 return;
1050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 skb_queue_purge(&dev->dlc->tx_queue);
Alan Coxa352def2008-07-16 21:53:12 +01001052 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053}
1054
1055static void rfcomm_tty_send_xchar(struct tty_struct *tty, char ch)
1056{
1057 BT_DBG("tty %p ch %c", tty, ch);
1058}
1059
1060static void rfcomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1061{
1062 BT_DBG("tty %p timeout %d", tty, timeout);
1063}
1064
1065static void rfcomm_tty_hangup(struct tty_struct *tty)
1066{
1067 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
1069 BT_DBG("tty %p dev %p", tty, dev);
1070
Gianluca Anzolincad348a2013-07-29 17:08:11 +02001071 tty_port_hangup(&dev->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072}
1073
Alan Cox60b33c12011-02-14 16:26:14 +00001074static int rfcomm_tty_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001076 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078 BT_DBG("tty %p dev %p", tty, dev);
1079
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001080 return dev->modem_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081}
1082
Alan Cox20b9d172011-02-14 16:26:50 +00001083static int rfcomm_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084{
J. Suter3a5e9032005-08-09 20:28:46 -07001085 struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
1086 struct rfcomm_dlc *dlc = dev->dlc;
1087 u8 v24_sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
1089 BT_DBG("tty %p dev %p set 0x%02x clear 0x%02x", tty, dev, set, clear);
1090
J. Suter3a5e9032005-08-09 20:28:46 -07001091 rfcomm_dlc_get_modem_status(dlc, &v24_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
J. Suter3a5e9032005-08-09 20:28:46 -07001093 if (set & TIOCM_DSR || set & TIOCM_DTR)
1094 v24_sig |= RFCOMM_V24_RTC;
1095 if (set & TIOCM_RTS || set & TIOCM_CTS)
1096 v24_sig |= RFCOMM_V24_RTR;
1097 if (set & TIOCM_RI)
1098 v24_sig |= RFCOMM_V24_IC;
1099 if (set & TIOCM_CD)
1100 v24_sig |= RFCOMM_V24_DV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
J. Suter3a5e9032005-08-09 20:28:46 -07001102 if (clear & TIOCM_DSR || clear & TIOCM_DTR)
1103 v24_sig &= ~RFCOMM_V24_RTC;
1104 if (clear & TIOCM_RTS || clear & TIOCM_CTS)
1105 v24_sig &= ~RFCOMM_V24_RTR;
1106 if (clear & TIOCM_RI)
1107 v24_sig &= ~RFCOMM_V24_IC;
1108 if (clear & TIOCM_CD)
1109 v24_sig &= ~RFCOMM_V24_DV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
J. Suter3a5e9032005-08-09 20:28:46 -07001111 rfcomm_dlc_set_modem_status(dlc, v24_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
J. Suter3a5e9032005-08-09 20:28:46 -07001113 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114}
1115
1116/* ---- TTY structure ---- */
1117
Jeff Dikeb68e31d2006-10-02 02:17:18 -07001118static const struct tty_operations rfcomm_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 .open = rfcomm_tty_open,
1120 .close = rfcomm_tty_close,
1121 .write = rfcomm_tty_write,
1122 .write_room = rfcomm_tty_write_room,
1123 .chars_in_buffer = rfcomm_tty_chars_in_buffer,
1124 .flush_buffer = rfcomm_tty_flush_buffer,
1125 .ioctl = rfcomm_tty_ioctl,
1126 .throttle = rfcomm_tty_throttle,
1127 .unthrottle = rfcomm_tty_unthrottle,
1128 .set_termios = rfcomm_tty_set_termios,
1129 .send_xchar = rfcomm_tty_send_xchar,
1130 .hangup = rfcomm_tty_hangup,
1131 .wait_until_sent = rfcomm_tty_wait_until_sent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 .tiocmget = rfcomm_tty_tiocmget,
1133 .tiocmset = rfcomm_tty_tiocmset,
Gianluca Anzolin54b926a2013-07-29 17:08:10 +02001134 .install = rfcomm_tty_install,
1135 .cleanup = rfcomm_tty_cleanup,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136};
1137
Gustavo F. Padovan2f8362a2010-07-24 02:04:45 -03001138int __init rfcomm_init_ttys(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
David Herrmann5ada9912011-10-24 15:30:57 +02001140 int error;
1141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS);
1143 if (!rfcomm_tty_driver)
David Herrmann5ada9912011-10-24 15:30:57 +02001144 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 rfcomm_tty_driver->driver_name = "rfcomm";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 rfcomm_tty_driver->name = "rfcomm";
1148 rfcomm_tty_driver->major = RFCOMM_TTY_MAJOR;
1149 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR;
1150 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1151 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -07001152 rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 rfcomm_tty_driver->init_termios = tty_std_termios;
Peter Hurley136c3732014-02-09 20:59:02 -05001154 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
Marcel Holtmannca37bdd2008-07-14 20:13:52 +02001155 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);
1157
David Herrmann5ada9912011-10-24 15:30:57 +02001158 error = tty_register_driver(rfcomm_tty_driver);
1159 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 BT_ERR("Can't register RFCOMM TTY driver");
1161 put_tty_driver(rfcomm_tty_driver);
David Herrmann5ada9912011-10-24 15:30:57 +02001162 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 }
1164
1165 BT_INFO("RFCOMM TTY layer initialized");
1166
1167 return 0;
1168}
1169
Gustavo F. Padovan28e95092010-07-31 19:57:05 -03001170void rfcomm_cleanup_ttys(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171{
1172 tty_unregister_driver(rfcomm_tty_driver);
1173 put_tty_driver(rfcomm_tty_driver);
1174}