xref: /linux/drivers/bluetooth/hci_ldisc.c (revision 13abf8130139c2ccd4962a7e5a8902be5e6cb5a7) 
1 /*
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
4 
5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6 
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License version 2 as
9    published by the Free Software Foundation;
10 
11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 
20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22    SOFTWARE IS DISCLAIMED.
23 */
24 
25 /*
26  * Bluetooth HCI UART driver.
27  *
28  * $Id: hci_ldisc.c,v 1.5 2002/10/02 18:37:20 maxk Exp $
29  */
30 #define VERSION "2.1"
31 
32 #include <linux/config.h>
33 #include <linux/module.h>
34 
35 #include <linux/kernel.h>
36 #include <linux/init.h>
37 #include <linux/sched.h>
38 #include <linux/types.h>
39 #include <linux/fcntl.h>
40 #include <linux/interrupt.h>
41 #include <linux/ptrace.h>
42 #include <linux/poll.h>
43 
44 #include <linux/slab.h>
45 #include <linux/tty.h>
46 #include <linux/errno.h>
47 #include <linux/string.h>
48 #include <linux/signal.h>
49 #include <linux/ioctl.h>
50 #include <linux/skbuff.h>
51 
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
54 
55 #include "hci_uart.h"
56 
57 #ifndef CONFIG_BT_HCIUART_DEBUG
58 #undef  BT_DBG
59 #define BT_DBG( A... )
60 #endif
61 
62 static int reset = 0;
63 
64 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
65 
66 int hci_uart_register_proto(struct hci_uart_proto *p)
67 {
68 	if (p->id >= HCI_UART_MAX_PROTO)
69 		return -EINVAL;
70 
71 	if (hup[p->id])
72 		return -EEXIST;
73 
74 	hup[p->id] = p;
75 	return 0;
76 }
77 
78 int hci_uart_unregister_proto(struct hci_uart_proto *p)
79 {
80 	if (p->id >= HCI_UART_MAX_PROTO)
81 		return -EINVAL;
82 
83 	if (!hup[p->id])
84 		return -EINVAL;
85 
86 	hup[p->id] = NULL;
87 	return 0;
88 }
89 
90 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
91 {
92 	if (id >= HCI_UART_MAX_PROTO)
93 		return NULL;
94 	return hup[id];
95 }
96 
97 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
98 {
99 	struct hci_dev *hdev = hu->hdev;
100 
101 	/* Update HCI stat counters */
102 	switch (pkt_type) {
103 	case HCI_COMMAND_PKT:
104 		hdev->stat.cmd_tx++;
105 		break;
106 
107 	case HCI_ACLDATA_PKT:
108 		hdev->stat.acl_tx++;
109 		break;
110 
111 	case HCI_SCODATA_PKT:
112 		hdev->stat.cmd_tx++;
113 		break;
114 	}
115 }
116 
117 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
118 {
119 	struct sk_buff *skb = hu->tx_skb;
120 	if (!skb)
121 		skb = hu->proto->dequeue(hu);
122 	else
123 		hu->tx_skb = NULL;
124 	return skb;
125 }
126 
127 int hci_uart_tx_wakeup(struct hci_uart *hu)
128 {
129 	struct tty_struct *tty = hu->tty;
130 	struct hci_dev *hdev = hu->hdev;
131 	struct sk_buff *skb;
132 
133 	if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
134 		set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
135 		return 0;
136 	}
137 
138 	BT_DBG("");
139 
140 restart:
141 	clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
142 
143 	while ((skb = hci_uart_dequeue(hu))) {
144 		int len;
145 
146 		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
147 		len = tty->driver->write(tty, skb->data, skb->len);
148 		hdev->stat.byte_tx += len;
149 
150 		skb_pull(skb, len);
151 		if (skb->len) {
152 			hu->tx_skb = skb;
153 			break;
154 		}
155 
156 		hci_uart_tx_complete(hu, bt_cb(skb)->pkt_type);
157 		kfree_skb(skb);
158 	}
159 
160 	if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
161 		goto restart;
162 
163 	clear_bit(HCI_UART_SENDING, &hu->tx_state);
164 	return 0;
165 }
166 
167 /* ------- Interface to HCI layer ------ */
168 /* Initialize device */
169 static int hci_uart_open(struct hci_dev *hdev)
170 {
171 	BT_DBG("%s %p", hdev->name, hdev);
172 
173 	/* Nothing to do for UART driver */
174 
175 	set_bit(HCI_RUNNING, &hdev->flags);
176 	return 0;
177 }
178 
179 /* Reset device */
180 static int hci_uart_flush(struct hci_dev *hdev)
181 {
182 	struct hci_uart *hu  = (struct hci_uart *) hdev->driver_data;
183 	struct tty_struct *tty = hu->tty;
184 
185 	BT_DBG("hdev %p tty %p", hdev, tty);
186 
187 	if (hu->tx_skb) {
188 		kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
189 	}
190 
191 	/* Flush any pending characters in the driver and discipline. */
192 	tty_ldisc_flush(tty);
193 	if (tty->driver->flush_buffer)
194 		tty->driver->flush_buffer(tty);
195 
196 	if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
197 		hu->proto->flush(hu);
198 
199 	return 0;
200 }
201 
202 /* Close device */
203 static int hci_uart_close(struct hci_dev *hdev)
204 {
205 	BT_DBG("hdev %p", hdev);
206 
207 	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
208 		return 0;
209 
210 	hci_uart_flush(hdev);
211 	return 0;
212 }
213 
214 /* Send frames from HCI layer */
215 static int hci_uart_send_frame(struct sk_buff *skb)
216 {
217 	struct hci_dev* hdev = (struct hci_dev *) skb->dev;
218 	struct tty_struct *tty;
219 	struct hci_uart *hu;
220 
221 	if (!hdev) {
222 		BT_ERR("Frame for uknown device (hdev=NULL)");
223 		return -ENODEV;
224 	}
225 
226 	if (!test_bit(HCI_RUNNING, &hdev->flags))
227 		return -EBUSY;
228 
229 	hu = (struct hci_uart *) hdev->driver_data;
230 	tty = hu->tty;
231 
232 	BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
233 
234 	hu->proto->enqueue(hu, skb);
235 
236 	hci_uart_tx_wakeup(hu);
237 	return 0;
238 }
239 
240 static void hci_uart_destruct(struct hci_dev *hdev)
241 {
242 	struct hci_uart *hu;
243 
244 	if (!hdev) return;
245 
246 	BT_DBG("%s", hdev->name);
247 
248 	hu = (struct hci_uart *) hdev->driver_data;
249 	kfree(hu);
250 }
251 
252 /* ------ LDISC part ------ */
253 /* hci_uart_tty_open
254  *
255  *     Called when line discipline changed to HCI_UART.
256  *
257  * Arguments:
258  *     tty    pointer to tty info structure
259  * Return Value:
260  *     0 if success, otherwise error code
261  */
262 static int hci_uart_tty_open(struct tty_struct *tty)
263 {
264 	struct hci_uart *hu = (void *) tty->disc_data;
265 
266 	BT_DBG("tty %p", tty);
267 
268 	if (hu)
269 		return -EEXIST;
270 
271 	if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
272 		BT_ERR("Can't allocate controll structure");
273 		return -ENFILE;
274 	}
275 	memset(hu, 0, sizeof(struct hci_uart));
276 
277 	tty->disc_data = hu;
278 	hu->tty = tty;
279 
280 	spin_lock_init(&hu->rx_lock);
281 
282 	/* Flush any pending characters in the driver and line discipline. */
283 	/* FIXME: why is this needed. Note don't use ldisc_ref here as the
284 	   open path is before the ldisc is referencable */
285 	if (tty->ldisc.flush_buffer)
286 		tty->ldisc.flush_buffer(tty);
287 
288 	if (tty->driver->flush_buffer)
289 		tty->driver->flush_buffer(tty);
290 
291 	return 0;
292 }
293 
294 /* hci_uart_tty_close()
295  *
296  *    Called when the line discipline is changed to something
297  *    else, the tty is closed, or the tty detects a hangup.
298  */
299 static void hci_uart_tty_close(struct tty_struct *tty)
300 {
301 	struct hci_uart *hu = (void *)tty->disc_data;
302 
303 	BT_DBG("tty %p", tty);
304 
305 	/* Detach from the tty */
306 	tty->disc_data = NULL;
307 
308 	if (hu) {
309 		struct hci_dev *hdev = hu->hdev;
310 		hci_uart_close(hdev);
311 
312 		if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
313 			hu->proto->close(hu);
314 			hci_unregister_dev(hdev);
315 			hci_free_dev(hdev);
316 		}
317 	}
318 }
319 
320 /* hci_uart_tty_wakeup()
321  *
322  *    Callback for transmit wakeup. Called when low level
323  *    device driver can accept more send data.
324  *
325  * Arguments:        tty    pointer to associated tty instance data
326  * Return Value:    None
327  */
328 static void hci_uart_tty_wakeup(struct tty_struct *tty)
329 {
330 	struct hci_uart *hu = (void *)tty->disc_data;
331 
332 	BT_DBG("");
333 
334 	if (!hu)
335 		return;
336 
337 	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
338 
339 	if (tty != hu->tty)
340 		return;
341 
342 	if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
343 		hci_uart_tx_wakeup(hu);
344 }
345 
346 /* hci_uart_tty_room()
347  *
348  *    Callback function from tty driver. Return the amount of
349  *    space left in the receiver's buffer to decide if remote
350  *    transmitter is to be throttled.
351  *
352  * Arguments:        tty    pointer to associated tty instance data
353  * Return Value:    number of bytes left in receive buffer
354  */
355 static int hci_uart_tty_room (struct tty_struct *tty)
356 {
357 	return 65536;
358 }
359 
360 /* hci_uart_tty_receive()
361  *
362  *     Called by tty low level driver when receive data is
363  *     available.
364  *
365  * Arguments:  tty          pointer to tty isntance data
366  *             data         pointer to received data
367  *             flags        pointer to flags for data
368  *             count        count of received data in bytes
369  *
370  * Return Value:    None
371  */
372 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
373 {
374 	struct hci_uart *hu = (void *)tty->disc_data;
375 
376 	if (!hu || tty != hu->tty)
377 		return;
378 
379 	if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
380 		return;
381 
382 	spin_lock(&hu->rx_lock);
383 	hu->proto->recv(hu, (void *) data, count);
384 	hu->hdev->stat.byte_rx += count;
385 	spin_unlock(&hu->rx_lock);
386 
387 	if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
388 		tty->driver->unthrottle(tty);
389 }
390 
391 static int hci_uart_register_dev(struct hci_uart *hu)
392 {
393 	struct hci_dev *hdev;
394 
395 	BT_DBG("");
396 
397 	/* Initialize and register HCI device */
398 	hdev = hci_alloc_dev();
399 	if (!hdev) {
400 		BT_ERR("Can't allocate HCI device");
401 		return -ENOMEM;
402 	}
403 
404 	hu->hdev = hdev;
405 
406 	hdev->type = HCI_UART;
407 	hdev->driver_data = hu;
408 
409 	hdev->open  = hci_uart_open;
410 	hdev->close = hci_uart_close;
411 	hdev->flush = hci_uart_flush;
412 	hdev->send  = hci_uart_send_frame;
413 	hdev->destruct = hci_uart_destruct;
414 
415 	hdev->owner = THIS_MODULE;
416 
417 	if (reset)
418 		set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
419 
420 	if (hci_register_dev(hdev) < 0) {
421 		BT_ERR("Can't register HCI device");
422 		hci_free_dev(hdev);
423 		return -ENODEV;
424 	}
425 
426 	return 0;
427 }
428 
429 static int hci_uart_set_proto(struct hci_uart *hu, int id)
430 {
431 	struct hci_uart_proto *p;
432 	int err;
433 
434 	p = hci_uart_get_proto(id);
435 	if (!p)
436 		return -EPROTONOSUPPORT;
437 
438 	err = p->open(hu);
439 	if (err)
440 		return err;
441 
442 	hu->proto = p;
443 
444 	err = hci_uart_register_dev(hu);
445 	if (err) {
446 		p->close(hu);
447 		return err;
448 	}
449 	return 0;
450 }
451 
452 /* hci_uart_tty_ioctl()
453  *
454  *    Process IOCTL system call for the tty device.
455  *
456  * Arguments:
457  *
458  *    tty        pointer to tty instance data
459  *    file       pointer to open file object for device
460  *    cmd        IOCTL command code
461  *    arg        argument for IOCTL call (cmd dependent)
462  *
463  * Return Value:    Command dependent
464  */
465 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
466                             unsigned int cmd, unsigned long arg)
467 {
468 	struct hci_uart *hu = (void *)tty->disc_data;
469 	int err = 0;
470 
471 	BT_DBG("");
472 
473 	/* Verify the status of the device */
474 	if (!hu)
475 		return -EBADF;
476 
477 	switch (cmd) {
478 	case HCIUARTSETPROTO:
479 		if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
480 			err = hci_uart_set_proto(hu, arg);
481 			if (err) {
482 				clear_bit(HCI_UART_PROTO_SET, &hu->flags);
483 				return err;
484 			}
485 			tty->low_latency = 1;
486 		} else
487 			return -EBUSY;
488 
489 	case HCIUARTGETPROTO:
490 		if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
491 			return hu->proto->id;
492 		return -EUNATCH;
493 
494 	default:
495 		err = n_tty_ioctl(tty, file, cmd, arg);
496 		break;
497 	};
498 
499 	return err;
500 }
501 
502 /*
503  * We don't provide read/write/poll interface for user space.
504  */
505 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char __user *buf, size_t nr)
506 {
507 	return 0;
508 }
509 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
510 {
511 	return 0;
512 }
513 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
514 {
515 	return 0;
516 }
517 
518 #ifdef CONFIG_BT_HCIUART_H4
519 int h4_init(void);
520 int h4_deinit(void);
521 #endif
522 #ifdef CONFIG_BT_HCIUART_BCSP
523 int bcsp_init(void);
524 int bcsp_deinit(void);
525 #endif
526 
527 static int __init hci_uart_init(void)
528 {
529 	static struct tty_ldisc hci_uart_ldisc;
530 	int err;
531 
532 	BT_INFO("HCI UART driver ver %s", VERSION);
533 
534 	/* Register the tty discipline */
535 
536 	memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
537 	hci_uart_ldisc.magic       = TTY_LDISC_MAGIC;
538 	hci_uart_ldisc.name        = "n_hci";
539 	hci_uart_ldisc.open        = hci_uart_tty_open;
540 	hci_uart_ldisc.close       = hci_uart_tty_close;
541 	hci_uart_ldisc.read        = hci_uart_tty_read;
542 	hci_uart_ldisc.write       = hci_uart_tty_write;
543 	hci_uart_ldisc.ioctl       = hci_uart_tty_ioctl;
544 	hci_uart_ldisc.poll        = hci_uart_tty_poll;
545 	hci_uart_ldisc.receive_room= hci_uart_tty_room;
546 	hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
547 	hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
548 	hci_uart_ldisc.owner       = THIS_MODULE;
549 
550 	if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
551 		BT_ERR("HCI line discipline registration failed. (%d)", err);
552 		return err;
553 	}
554 
555 #ifdef CONFIG_BT_HCIUART_H4
556 	h4_init();
557 #endif
558 #ifdef CONFIG_BT_HCIUART_BCSP
559 	bcsp_init();
560 #endif
561 
562 	return 0;
563 }
564 
565 static void __exit hci_uart_exit(void)
566 {
567 	int err;
568 
569 #ifdef CONFIG_BT_HCIUART_H4
570 	h4_deinit();
571 #endif
572 #ifdef CONFIG_BT_HCIUART_BCSP
573 	bcsp_deinit();
574 #endif
575 
576 	/* Release tty registration of line discipline */
577 	if ((err = tty_unregister_ldisc(N_HCI)))
578 		BT_ERR("Can't unregister HCI line discipline (%d)", err);
579 }
580 
581 module_init(hci_uart_init);
582 module_exit(hci_uart_exit);
583 
584 module_param(reset, bool, 0644);
585 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
586 
587 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
588 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
589 MODULE_VERSION(VERSION);
590 MODULE_LICENSE("GPL");
591 MODULE_ALIAS_LDISC(N_HCI);
592