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 * BlueZ 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/version.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>
44
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>
52
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/hci_core.h>
55 #include "hci_uart.h"
56
57 #ifndef HCI_UART_DEBUG
58 #undef BT_DBG
59 #define BT_DBG( A... )
60 #undef BT_DMP
61 #define BT_DMP( A... )
62 #endif
63
64 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
65
hci_uart_register_proto(struct hci_uart_proto * p)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
hci_uart_unregister_proto(struct hci_uart_proto * p)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
hci_uart_get_proto(unsigned int id)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
hci_uart_tx_complete(struct hci_uart * hu,int pkt_type)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
hci_uart_dequeue(struct hci_uart * hu)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
hci_uart_tx_wakeup(struct hci_uart * hu)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, 0, 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 */
hci_uart_open(struct hci_dev * hdev)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 */
hci_uart_flush(struct hci_dev * hdev)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 tty_ldisc_flush(tty);
192
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 */
hci_uart_close(struct hci_dev * hdev)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 */
hci_uart_send_frame(struct sk_buff * skb)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
hci_uart_destruct(struct hci_dev * hdev)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 MOD_DEC_USE_COUNT;
252 }
253
254 /* ------ LDISC part ------ */
255 /* hci_uart_tty_open
256 *
257 * Called when line discipline changed to HCI_UART.
258 *
259 * Arguments:
260 * tty pointer to tty info structure
261 * Return Value:
262 * 0 if success, otherwise error code
263 */
hci_uart_tty_open(struct tty_struct * tty)264 static int hci_uart_tty_open(struct tty_struct *tty)
265 {
266 struct hci_uart *hu = (void *) tty->disc_data;
267
268 BT_DBG("tty %p", tty);
269
270 if (hu)
271 return -EEXIST;
272
273 if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
274 BT_ERR("Can't allocate controll structure");
275 return -ENFILE;
276 }
277 memset(hu, 0, sizeof(struct hci_uart));
278
279 tty->disc_data = hu;
280 hu->tty = tty;
281
282 spin_lock_init(&hu->rx_lock);
283
284 /* Flush any pending characters in the driver and line discipline. */
285 /* FIXME: why is this needed. Note don't use ldisc_ref here as the
286 open path is before the ldisc is referencable */
287 tty_ldisc_flush(tty);
288
289 if (tty->driver.flush_buffer)
290 tty->driver.flush_buffer(tty);
291
292 MOD_INC_USE_COUNT;
293 return 0;
294 }
295
296 /* hci_uart_tty_close()
297 *
298 * Called when the line discipline is changed to something
299 * else, the tty is closed, or the tty detects a hangup.
300 */
hci_uart_tty_close(struct tty_struct * tty)301 static void hci_uart_tty_close(struct tty_struct *tty)
302 {
303 struct hci_uart *hu = (void *)tty->disc_data;
304
305 BT_DBG("tty %p", tty);
306
307 /* Detach from the tty */
308 tty->disc_data = NULL;
309
310 if (hu) {
311 struct hci_dev *hdev = &hu->hdev;
312
313 if (hdev)
314 hci_uart_close(hdev);
315
316 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
317 hu->proto->close(hu);
318 hci_unregister_dev(hdev);
319 }
320
321 MOD_DEC_USE_COUNT;
322 }
323 }
324
325 /* hci_uart_tty_wakeup()
326 *
327 * Callback for transmit wakeup. Called when low level
328 * device driver can accept more send data.
329 *
330 * Arguments: tty pointer to associated tty instance data
331 * Return Value: None
332 */
hci_uart_tty_wakeup(struct tty_struct * tty)333 static void hci_uart_tty_wakeup(struct tty_struct *tty)
334 {
335 struct hci_uart *hu = (void *)tty->disc_data;
336
337 BT_DBG("");
338
339 if (!hu)
340 return;
341
342 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
343
344 if (tty != hu->tty)
345 return;
346
347 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
348 hci_uart_tx_wakeup(hu);
349 }
350
351 /* hci_uart_tty_room()
352 *
353 * Callback function from tty driver. Return the amount of
354 * space left in the receiver's buffer to decide if remote
355 * transmitter is to be throttled.
356 *
357 * Arguments: tty pointer to associated tty instance data
358 * Return Value: number of bytes left in receive buffer
359 */
hci_uart_tty_room(struct tty_struct * tty)360 static int hci_uart_tty_room (struct tty_struct *tty)
361 {
362 return 65536;
363 }
364
365 /* hci_uart_tty_receive()
366 *
367 * Called by tty low level driver when receive data is
368 * available.
369 *
370 * Arguments: tty pointer to tty isntance data
371 * data pointer to received data
372 * flags pointer to flags for data
373 * count count of received data in bytes
374 *
375 * Return Value: None
376 */
hci_uart_tty_receive(struct tty_struct * tty,const __u8 * data,char * flags,int count)377 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
378 {
379 struct hci_uart *hu = (void *)tty->disc_data;
380
381 if (!hu || tty != hu->tty)
382 return;
383
384 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
385 return;
386
387 spin_lock(&hu->rx_lock);
388 hu->proto->recv(hu, (void *) data, count);
389 hu->hdev.stat.byte_rx += count;
390 spin_unlock(&hu->rx_lock);
391
392 if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver.unthrottle)
393 tty->driver.unthrottle(tty);
394 }
395
hci_uart_register_dev(struct hci_uart * hu)396 static int hci_uart_register_dev(struct hci_uart *hu)
397 {
398 struct hci_dev *hdev;
399
400 BT_DBG("");
401
402 /* Initialize and register HCI device */
403 hdev = &hu->hdev;
404
405 hdev->type = HCI_UART;
406 hdev->driver_data = hu;
407
408 hdev->open = hci_uart_open;
409 hdev->close = hci_uart_close;
410 hdev->flush = hci_uart_flush;
411 hdev->send = hci_uart_send_frame;
412 hdev->destruct = hci_uart_destruct;
413
414 if (hci_register_dev(hdev) < 0) {
415 BT_ERR("Can't register HCI device %s", hdev->name);
416 return -ENODEV;
417 }
418 MOD_INC_USE_COUNT;
419 return 0;
420 }
421
hci_uart_set_proto(struct hci_uart * hu,int id)422 static int hci_uart_set_proto(struct hci_uart *hu, int id)
423 {
424 struct hci_uart_proto *p;
425 int err;
426
427 p = hci_uart_get_proto(id);
428 if (!p)
429 return -EPROTONOSUPPORT;
430
431 err = p->open(hu);
432 if (err)
433 return err;
434
435 hu->proto = p;
436
437 err = hci_uart_register_dev(hu);
438 if (err) {
439 p->close(hu);
440 return err;
441 }
442 return 0;
443 }
444
445 /* hci_uart_tty_ioctl()
446 *
447 * Process IOCTL system call for the tty device.
448 *
449 * Arguments:
450 *
451 * tty pointer to tty instance data
452 * file pointer to open file object for device
453 * cmd IOCTL command code
454 * arg argument for IOCTL call (cmd dependent)
455 *
456 * Return Value: Command dependent
457 */
hci_uart_tty_ioctl(struct tty_struct * tty,struct file * file,unsigned int cmd,unsigned long arg)458 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
459 unsigned int cmd, unsigned long arg)
460 {
461 struct hci_uart *hu = (void *)tty->disc_data;
462 int err = 0;
463
464 BT_DBG("");
465
466 /* Verify the status of the device */
467 if (!hu)
468 return -EBADF;
469
470 switch (cmd) {
471 case HCIUARTSETPROTO:
472 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
473 err = hci_uart_set_proto(hu, arg);
474 if (err) {
475 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
476 return err;
477 }
478 tty->low_latency = 1;
479 } else
480 return -EBUSY;
481 break;
482
483 case HCIUARTGETPROTO:
484 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
485 return hu->proto->id;
486 return -EUNATCH;
487
488 default:
489 err = n_tty_ioctl(tty, file, cmd, arg);
490 break;
491 };
492
493 return err;
494 }
495
496 /*
497 * We don't provide read/write/poll interface for user space.
498 */
hci_uart_tty_read(struct tty_struct * tty,struct file * file,unsigned char * buf,size_t nr)499 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
500 {
501 return 0;
502 }
hci_uart_tty_write(struct tty_struct * tty,struct file * file,const unsigned char * data,size_t count)503 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
504 {
505 return 0;
506 }
hci_uart_tty_poll(struct tty_struct * tty,struct file * filp,poll_table * wait)507 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
508 {
509 return 0;
510 }
511
512 #ifdef CONFIG_BLUEZ_HCIUART_H4
513 int h4_init(void);
514 int h4_deinit(void);
515 #endif
516 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
517 int bcsp_init(void);
518 int bcsp_deinit(void);
519 #endif
520
hci_uart_init(void)521 int __init hci_uart_init(void)
522 {
523 static struct tty_ldisc hci_uart_ldisc;
524 int err;
525
526 BT_INFO("BlueZ HCI UART driver ver %s Copyright (C) 2000,2001 Qualcomm Inc",
527 VERSION);
528 BT_INFO("Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>");
529
530 /* Register the tty discipline */
531
532 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
533 hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
534 hci_uart_ldisc.name = "n_hci";
535 hci_uart_ldisc.open = hci_uart_tty_open;
536 hci_uart_ldisc.close = hci_uart_tty_close;
537 hci_uart_ldisc.read = hci_uart_tty_read;
538 hci_uart_ldisc.write = hci_uart_tty_write;
539 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
540 hci_uart_ldisc.poll = hci_uart_tty_poll;
541 hci_uart_ldisc.receive_room= hci_uart_tty_room;
542 hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
543 hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
544
545 if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
546 BT_ERR("Can't register HCI line discipline (%d)", err);
547 return err;
548 }
549
550 #ifdef CONFIG_BLUEZ_HCIUART_H4
551 h4_init();
552 #endif
553 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
554 bcsp_init();
555 #endif
556
557 return 0;
558 }
559
hci_uart_cleanup(void)560 void hci_uart_cleanup(void)
561 {
562 int err;
563
564 #ifdef CONFIG_BLUEZ_HCIUART_H4
565 h4_deinit();
566 #endif
567 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
568 bcsp_deinit();
569 #endif
570
571 /* Release tty registration of line discipline */
572 if ((err = tty_register_ldisc(N_HCI, NULL)))
573 BT_ERR("Can't unregister HCI line discipline (%d)", err);
574 }
575
576 module_init(hci_uart_init);
577 module_exit(hci_uart_cleanup);
578
579 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
580 MODULE_DESCRIPTION("BlueZ HCI UART driver ver " VERSION);
581 MODULE_LICENSE("GPL");
582