Merge master.kernel.org:/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6
[linux-3.10.git] / drivers / bluetooth / hci_ldisc.c
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, 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, 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);