2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
26 * Bluetooth HCI UART driver.
28 * $Id: hci_ldisc.c,v 1.5 2002/10/02 18:37:20 maxk Exp $
32 #include <linux/config.h>
33 #include <linux/module.h>
35 #include <linux/config.h>
36 #include <linux/kernel.h>
37 #include <linux/init.h>
38 #include <linux/sched.h>
39 #include <linux/types.h>
40 #include <linux/fcntl.h>
41 #include <linux/interrupt.h>
42 #include <linux/ptrace.h>
43 #include <linux/poll.h>
45 #include <linux/slab.h>
46 #include <linux/tty.h>
47 #include <linux/errno.h>
48 #include <linux/string.h>
49 #include <linux/signal.h>
50 #include <linux/ioctl.h>
51 #include <linux/skbuff.h>
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/hci_core.h>
57 #ifndef CONFIG_BT_HCIUART_DEBUG
59 #define BT_DBG( A... )
61 #define BT_DMP( A... )
64 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
66 int hci_uart_register_proto(struct hci_uart_proto *p)
68 if (p->id >= HCI_UART_MAX_PROTO)
78 int hci_uart_unregister_proto(struct hci_uart_proto *p)
80 if (p->id >= HCI_UART_MAX_PROTO)
90 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
92 if (id >= HCI_UART_MAX_PROTO)
97 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
99 struct hci_dev *hdev = hu->hdev;
101 /* Update HCI stat counters */
103 case HCI_COMMAND_PKT:
107 case HCI_ACLDATA_PKT:
111 case HCI_SCODATA_PKT:
117 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
119 struct sk_buff *skb = hu->tx_skb;
121 skb = hu->proto->dequeue(hu);
127 int hci_uart_tx_wakeup(struct hci_uart *hu)
129 struct tty_struct *tty = hu->tty;
130 struct hci_dev *hdev = hu->hdev;
133 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
134 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
141 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
143 while ((skb = hci_uart_dequeue(hu))) {
146 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
147 len = tty->driver->write(tty, 0, skb->data, skb->len);
148 hdev->stat.byte_tx += len;
156 hci_uart_tx_complete(hu, skb->pkt_type);
160 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
163 clear_bit(HCI_UART_SENDING, &hu->tx_state);
167 /* ------- Interface to HCI layer ------ */
168 /* Initialize device */
169 static int hci_uart_open(struct hci_dev *hdev)
171 BT_DBG("%s %p", hdev->name, hdev);
173 /* Nothing to do for UART driver */
175 set_bit(HCI_RUNNING, &hdev->flags);
180 static int hci_uart_flush(struct hci_dev *hdev)
182 struct hci_uart *hu = (struct hci_uart *) hdev->driver_data;
183 struct tty_struct *tty = hu->tty;
185 BT_DBG("hdev %p tty %p", hdev, tty);
188 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
191 /* Flush any pending characters in the driver and discipline. */
192 if (tty->ldisc.flush_buffer)
193 tty->ldisc.flush_buffer(tty);
195 if (tty->driver->flush_buffer)
196 tty->driver->flush_buffer(tty);
198 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
199 hu->proto->flush(hu);
205 static int hci_uart_close(struct hci_dev *hdev)
207 BT_DBG("hdev %p", hdev);
209 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
212 hci_uart_flush(hdev);
216 /* Send frames from HCI layer */
217 static int hci_uart_send_frame(struct sk_buff *skb)
219 struct hci_dev* hdev = (struct hci_dev *) skb->dev;
220 struct tty_struct *tty;
224 BT_ERR("Frame for uknown device (hdev=NULL)");
228 if (!test_bit(HCI_RUNNING, &hdev->flags))
231 hu = (struct hci_uart *) hdev->driver_data;
234 BT_DBG("%s: type %d len %d", hdev->name, skb->pkt_type, skb->len);
236 hu->proto->enqueue(hu, skb);
238 hci_uart_tx_wakeup(hu);
242 static void hci_uart_destruct(struct hci_dev *hdev)
248 BT_DBG("%s", hdev->name);
250 hu = (struct hci_uart *) hdev->driver_data;
254 /* ------ LDISC part ------ */
257 * Called when line discipline changed to HCI_UART.
260 * tty pointer to tty info structure
262 * 0 if success, otherwise error code
264 static int hci_uart_tty_open(struct tty_struct *tty)
266 struct hci_uart *hu = (void *) tty->disc_data;
268 BT_DBG("tty %p", tty);
273 if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
274 BT_ERR("Can't allocate controll structure");
277 memset(hu, 0, sizeof(struct hci_uart));
282 spin_lock_init(&hu->rx_lock);
284 /* Flush any pending characters in the driver and line discipline */
285 if (tty->ldisc.flush_buffer)
286 tty->ldisc.flush_buffer(tty);
288 if (tty->driver->flush_buffer)
289 tty->driver->flush_buffer(tty);
294 /* hci_uart_tty_close()
296 * Called when the line discipline is changed to something
297 * else, the tty is closed, or the tty detects a hangup.
299 static void hci_uart_tty_close(struct tty_struct *tty)
301 struct hci_uart *hu = (void *)tty->disc_data;
303 BT_DBG("tty %p", tty);
305 /* Detach from the tty */
306 tty->disc_data = NULL;
309 struct hci_dev *hdev = hu->hdev;
310 hci_uart_close(hdev);
312 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
313 hu->proto->close(hu);
314 hci_unregister_dev(hdev);
320 /* hci_uart_tty_wakeup()
322 * Callback for transmit wakeup. Called when low level
323 * device driver can accept more send data.
325 * Arguments: tty pointer to associated tty instance data
328 static void hci_uart_tty_wakeup(struct tty_struct *tty)
330 struct hci_uart *hu = (void *)tty->disc_data;
337 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
342 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
343 hci_uart_tx_wakeup(hu);
346 /* hci_uart_tty_room()
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.
352 * Arguments: tty pointer to associated tty instance data
353 * Return Value: number of bytes left in receive buffer
355 static int hci_uart_tty_room (struct tty_struct *tty)
360 /* hci_uart_tty_receive()
362 * Called by tty low level driver when receive data is
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
372 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
374 struct hci_uart *hu = (void *)tty->disc_data;
376 if (!hu || tty != hu->tty)
379 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
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);
387 if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
388 tty->driver->unthrottle(tty);
391 static int hci_uart_register_dev(struct hci_uart *hu)
393 struct hci_dev *hdev;
397 /* Initialize and register HCI device */
398 hdev = hci_alloc_dev();
400 BT_ERR("Can't allocate HCI device");
406 hdev->type = HCI_UART;
407 hdev->driver_data = hu;
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;
415 hdev->owner = THIS_MODULE;
417 if (hci_register_dev(hdev) < 0) {
418 BT_ERR("Can't register HCI device");
426 static int hci_uart_set_proto(struct hci_uart *hu, int id)
428 struct hci_uart_proto *p;
431 p = hci_uart_get_proto(id);
433 return -EPROTONOSUPPORT;
441 err = hci_uart_register_dev(hu);
449 /* hci_uart_tty_ioctl()
451 * Process IOCTL system call for the tty device.
455 * tty pointer to tty instance data
456 * file pointer to open file object for device
457 * cmd IOCTL command code
458 * arg argument for IOCTL call (cmd dependent)
460 * Return Value: Command dependent
462 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
463 unsigned int cmd, unsigned long arg)
465 struct hci_uart *hu = (void *)tty->disc_data;
470 /* Verify the status of the device */
475 case HCIUARTSETPROTO:
476 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
477 err = hci_uart_set_proto(hu, arg);
479 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
482 tty->low_latency = 1;
486 case HCIUARTGETPROTO:
487 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
488 return hu->proto->id;
492 err = n_tty_ioctl(tty, file, cmd, arg);
500 * We don't provide read/write/poll interface for user space.
502 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
506 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
510 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
515 #ifdef CONFIG_BT_HCIUART_H4
519 #ifdef CONFIG_BT_HCIUART_BCSP
521 int bcsp_deinit(void);
524 static int __init hci_uart_init(void)
526 static struct tty_ldisc hci_uart_ldisc;
529 BT_INFO("HCI UART driver ver %s", VERSION);
531 /* Register the tty discipline */
533 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
534 hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
535 hci_uart_ldisc.name = "n_hci";
536 hci_uart_ldisc.open = hci_uart_tty_open;
537 hci_uart_ldisc.close = hci_uart_tty_close;
538 hci_uart_ldisc.read = hci_uart_tty_read;
539 hci_uart_ldisc.write = hci_uart_tty_write;
540 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
541 hci_uart_ldisc.poll = hci_uart_tty_poll;
542 hci_uart_ldisc.receive_room= hci_uart_tty_room;
543 hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
544 hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
545 hci_uart_ldisc.owner = THIS_MODULE;
547 if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
548 BT_ERR("HCI line discipline registration failed. (%d)", err);
552 #ifdef CONFIG_BT_HCIUART_H4
555 #ifdef CONFIG_BT_HCIUART_BCSP
562 static void __exit hci_uart_exit(void)
566 #ifdef CONFIG_BT_HCIUART_H4
569 #ifdef CONFIG_BT_HCIUART_BCSP
573 /* Release tty registration of line discipline */
574 if ((err = tty_register_ldisc(N_HCI, NULL)))
575 BT_ERR("Can't unregister HCI line discipline (%d)", err);
578 module_init(hci_uart_init);
579 module_exit(hci_uart_exit);
581 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
582 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
583 MODULE_VERSION(VERSION);
584 MODULE_LICENSE("GPL");
585 MODULE_ALIAS_LDISC(N_HCI);