]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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... ) | |
1da177e4 LT |
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 */ | |
64ccd715 | 577 | if ((err = tty_unregister_ldisc(N_HCI))) |
1da177e4 LT |
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); |