hci_ldisc.c 12.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/* 
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
   SOFTWARE IS DISCLAIMED.
*/

/*
 * BlueZ HCI UART driver.
 *
28
 * $Id: hci_ldisc.c,v 1.5 2002/10/02 18:37:20 maxk Exp $    
Linus Torvalds's avatar
Linus Torvalds committed
29
 */
30
#define VERSION "2.1"
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35

#include <linux/config.h>
#include <linux/module.h>

#include <linux/version.h>
36
#include <linux/config.h>
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39 40 41 42 43 44 45
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/poll.h>

Linus Torvalds's avatar
Linus Torvalds committed
46
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51 52 53 54 55
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/signal.h>
#include <linux/ioctl.h>
#include <linux/skbuff.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
56
#include "hci_uart.h"
Linus Torvalds's avatar
Linus Torvalds committed
57 58

#ifndef HCI_UART_DEBUG
59 60 61 62
#undef  BT_DBG
#define BT_DBG( A... )
#undef  BT_DMP
#define BT_DMP( A... )
Linus Torvalds's avatar
Linus Torvalds committed
63 64
#endif

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];

int hci_uart_register_proto(struct hci_uart_proto *p)
{
	if (p->id >= HCI_UART_MAX_PROTO)
		return -EINVAL;

	if (hup[p->id])
		return -EEXIST;

	hup[p->id] = p;
	return 0;
}

int hci_uart_unregister_proto(struct hci_uart_proto *p)
{
	if (p->id >= HCI_UART_MAX_PROTO)
		return -EINVAL;

	if (!hup[p->id])
		return -EINVAL;

	hup[p->id] = NULL;
	return 0;
}

91
static struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
92 93 94 95 96 97
{
	if (id >= HCI_UART_MAX_PROTO)
		return NULL;
	return hup[id];
}

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
{
	struct hci_dev *hdev = &hu->hdev;
	
	/* Update HCI stat counters */
	switch (pkt_type) {
	case HCI_COMMAND_PKT:
		hdev->stat.cmd_tx++;
		break;

	case HCI_ACLDATA_PKT:
		hdev->stat.acl_tx++;
		break;

	case HCI_SCODATA_PKT:
		hdev->stat.cmd_tx++;
		break;
	}
}

static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
{
	struct sk_buff *skb = hu->tx_skb;
	if (!skb)
		skb = hu->proto->dequeue(hu);
	else
		hu->tx_skb = NULL;
	return skb;
}

int hci_uart_tx_wakeup(struct hci_uart *hu)
{
	struct tty_struct *tty = hu->tty;
	struct hci_dev *hdev = &hu->hdev;
	struct sk_buff *skb;
	
	if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
		set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
		return 0;
	}

	BT_DBG("");

restart:
	clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);

	while ((skb = hci_uart_dequeue(hu))) {
		int len;
	
		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
		len = tty->driver.write(tty, 0, skb->data, skb->len);
		hdev->stat.byte_tx += len;

		skb_pull(skb, len);
		if (skb->len) {
			hu->tx_skb = skb;
			break;
		}
	
		hci_uart_tx_complete(hu, skb->pkt_type);
		kfree_skb(skb);
	} 
	
	if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
		goto restart;

	clear_bit(HCI_UART_SENDING, &hu->tx_state);
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
168 169
/* ------- Interface to HCI layer ------ */
/* Initialize device */
170
static int hci_uart_open(struct hci_dev *hdev)
Linus Torvalds's avatar
Linus Torvalds committed
171
{
172
	BT_DBG("%s %p", hdev->name, hdev);
Linus Torvalds's avatar
Linus Torvalds committed
173 174 175

	/* Nothing to do for UART driver */

176
	set_bit(HCI_RUNNING, &hdev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
177 178 179 180
	return 0;
}

/* Reset device */
181
static int hci_uart_flush(struct hci_dev *hdev)
Linus Torvalds's avatar
Linus Torvalds committed
182
{
183 184
	struct hci_uart *hu  = (struct hci_uart *) hdev->driver_data;
	struct tty_struct *tty = hu->tty;
Linus Torvalds's avatar
Linus Torvalds committed
185

186
	BT_DBG("hdev %p tty %p", hdev, tty);
Linus Torvalds's avatar
Linus Torvalds committed
187

188 189 190
	if (hu->tx_skb) {
		kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
	}
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195 196 197 198

	/* Flush any pending characters in the driver and discipline. */
	if (tty->ldisc.flush_buffer)
		tty->ldisc.flush_buffer(tty);

	if (tty->driver.flush_buffer)
		tty->driver.flush_buffer(tty);

199 200
	if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
		hu->proto->flush(hu);
201

Linus Torvalds's avatar
Linus Torvalds committed
202 203 204 205
	return 0;
}

/* Close device */
206
static int hci_uart_close(struct hci_dev *hdev)
Linus Torvalds's avatar
Linus Torvalds committed
207
{
208
	BT_DBG("hdev %p", hdev);
Linus Torvalds's avatar
Linus Torvalds committed
209

210 211
	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
212

213
	hci_uart_flush(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217
	return 0;
}

/* Send frames from HCI layer */
218
static int hci_uart_send_frame(struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221
{
	struct hci_dev* hdev = (struct hci_dev *) skb->dev;
	struct tty_struct *tty;
222
	struct hci_uart *hu;
Linus Torvalds's avatar
Linus Torvalds committed
223 224

	if (!hdev) {
225
		BT_ERR("Frame for uknown device (hdev=NULL)");
Linus Torvalds's avatar
Linus Torvalds committed
226 227 228
		return -ENODEV;
	}

229
	if (!test_bit(HCI_RUNNING, &hdev->flags))
Linus Torvalds's avatar
Linus Torvalds committed
230 231
		return -EBUSY;

232 233
	hu = (struct hci_uart *) hdev->driver_data;
	tty = hu->tty;
Linus Torvalds's avatar
Linus Torvalds committed
234

235
	BT_DBG("%s: type %d len %d", hdev->name, skb->pkt_type, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
236

237 238 239
	hu->proto->enqueue(hu, skb);

	hci_uart_tx_wakeup(hu);
240 241
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
242

243
static void hci_uart_destruct(struct hci_dev *hdev)
244
{
245
	struct hci_uart *hu;
Linus Torvalds's avatar
Linus Torvalds committed
246

247
	if (!hdev) return;
Linus Torvalds's avatar
Linus Torvalds committed
248

249
	BT_DBG("%s", hdev->name);
Linus Torvalds's avatar
Linus Torvalds committed
250

251 252
	hu = (struct hci_uart *) hdev->driver_data;
	kfree(hu);
Linus Torvalds's avatar
Linus Torvalds committed
253

254
	MOD_DEC_USE_COUNT;
Linus Torvalds's avatar
Linus Torvalds committed
255 256 257
}

/* ------ LDISC part ------ */
258
/* hci_uart_tty_open
Linus Torvalds's avatar
Linus Torvalds committed
259
 * 
260
 *     Called when line discipline changed to HCI_UART.
261 262
 *
 * Arguments:
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265 266
 *     tty    pointer to tty info structure
 * Return Value:    
 *     0 if success, otherwise error code
 */
267
static int hci_uart_tty_open(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
268
{
269
	struct hci_uart *hu = (void *) tty->disc_data;
Linus Torvalds's avatar
Linus Torvalds committed
270

271
	BT_DBG("tty %p", tty);
Linus Torvalds's avatar
Linus Torvalds committed
272

273
	if (hu)
Linus Torvalds's avatar
Linus Torvalds committed
274 275
		return -EEXIST;

276
	if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
277
		BT_ERR("Can't allocate controll structure");
Linus Torvalds's avatar
Linus Torvalds committed
278 279
		return -ENFILE;
	}
280
	memset(hu, 0, sizeof(struct hci_uart));
Linus Torvalds's avatar
Linus Torvalds committed
281

282 283
	tty->disc_data = hu;
	hu->tty = tty;
Linus Torvalds's avatar
Linus Torvalds committed
284

285
	spin_lock_init(&hu->rx_lock);
Linus Torvalds's avatar
Linus Torvalds committed
286

287
	/* Flush any pending characters in the driver and line discipline */
Linus Torvalds's avatar
Linus Torvalds committed
288 289 290 291 292
	if (tty->ldisc.flush_buffer)
		tty->ldisc.flush_buffer(tty);

	if (tty->driver.flush_buffer)
		tty->driver.flush_buffer(tty);
293 294
	
	MOD_INC_USE_COUNT;
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297
	return 0;
}

298
/* hci_uart_tty_close()
Linus Torvalds's avatar
Linus Torvalds committed
299 300 301 302
 *
 *    Called when the line discipline is changed to something
 *    else, the tty is closed, or the tty detects a hangup.
 */
303
static void hci_uart_tty_close(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
305
	struct hci_uart *hu = (void *)tty->disc_data;
Linus Torvalds's avatar
Linus Torvalds committed
306

307
	BT_DBG("tty %p", tty);
Linus Torvalds's avatar
Linus Torvalds committed
308

309 310 311
	/* Detach from the tty */
	tty->disc_data = NULL;

312 313 314
	if (hu) {
		struct hci_dev *hdev = &hu->hdev;
		hci_uart_close(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
315

316 317
		if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
			hu->proto->close(hu);
318
			hci_unregister_dev(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
319
		}
320

Linus Torvalds's avatar
Linus Torvalds committed
321 322 323 324
		MOD_DEC_USE_COUNT;
	}
}

325
/* hci_uart_tty_wakeup()
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329 330 331 332
 *
 *    Callback for transmit wakeup. Called when low level
 *    device driver can accept more send data.
 *
 * Arguments:        tty    pointer to associated tty instance data
 * Return Value:    None
 */
333
static void hci_uart_tty_wakeup(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
334
{
335
	struct hci_uart *hu = (void *)tty->disc_data;
Linus Torvalds's avatar
Linus Torvalds committed
336

337
	BT_DBG("");
Linus Torvalds's avatar
Linus Torvalds committed
338

339
	if (!hu)
Linus Torvalds's avatar
Linus Torvalds committed
340 341
		return;

342
	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Linus Torvalds's avatar
Linus Torvalds committed
343

344
	if (tty != hu->tty)
Linus Torvalds's avatar
Linus Torvalds committed
345 346
		return;

347
	hci_uart_tx_wakeup(hu);
Linus Torvalds's avatar
Linus Torvalds committed
348 349
}

350
/* hci_uart_tty_room()
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355 356 357 358
 * 
 *    Callback function from tty driver. Return the amount of 
 *    space left in the receiver's buffer to decide if remote
 *    transmitter is to be throttled.
 *
 * Arguments:        tty    pointer to associated tty instance data
 * Return Value:    number of bytes left in receive buffer
 */
359
static int hci_uart_tty_room (struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362 363
{
	return 65536;
}

364
/* hci_uart_tty_receive()
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368 369 370 371 372 373 374 375
 * 
 *     Called by tty low level driver when receive data is
 *     available.
 *     
 * Arguments:  tty          pointer to tty isntance data
 *             data         pointer to received data
 *             flags        pointer to flags for data
 *             count        count of received data in bytes
 *     
 * Return Value:    None
 */
376
static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
Linus Torvalds's avatar
Linus Torvalds committed
377
{
378
	struct hci_uart *hu = (void *)tty->disc_data;
379
	
380
	if (!hu || tty != hu->tty)
Linus Torvalds's avatar
Linus Torvalds committed
381 382
		return;

383
	if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
384 385
		return;
	
386 387 388 389
	spin_lock(&hu->rx_lock);
	hu->proto->recv(hu, (void *) data, count);
	hu->hdev.stat.byte_rx += count;
	spin_unlock(&hu->rx_lock);
Linus Torvalds's avatar
Linus Torvalds committed
390 391 392 393 394

	if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver.unthrottle)
		tty->driver.unthrottle(tty);
}

395
static int hci_uart_register_dev(struct hci_uart *hu)
396 397 398 399 400 401
{
	struct hci_dev *hdev;

	BT_DBG("");

	/* Initialize and register HCI device */
402
	hdev = &hu->hdev;
403 404

	hdev->type = HCI_UART;
405
	hdev->driver_data = hu;
406

407 408 409 410 411
	hdev->open  = hci_uart_open;
	hdev->close = hci_uart_close;
	hdev->flush = hci_uart_flush;
	hdev->send  = hci_uart_send_frame;
	hdev->destruct = hci_uart_destruct;
412 413 414 415 416 417 418 419 420

	if (hci_register_dev(hdev) < 0) {
		BT_ERR("Can't register HCI device %s", hdev->name);
		return -ENODEV;
	}
	MOD_INC_USE_COUNT;
	return 0;
}

421
static int hci_uart_set_proto(struct hci_uart *hu, int id)
422 423 424 425
{
	struct hci_uart_proto *p;
	int err;	
	
426
	p = hci_uart_get_proto(id);
427 428 429
	if (!p)
		return -EPROTONOSUPPORT;

430
	err = p->open(hu);
431 432 433
	if (err)
		return err;

434
	hu->proto = p;
435

436
	err = hci_uart_register_dev(hu);
437
	if (err) {
438
		p->close(hu);
439 440 441 442 443
		return err;
	}
	return 0;
}

444
/* hci_uart_tty_ioctl()
Linus Torvalds's avatar
Linus Torvalds committed
445 446 447 448 449 450 451 452 453 454 455 456
 *
 *    Process IOCTL system call for the tty device.
 *
 * Arguments:
 *
 *    tty        pointer to tty instance data
 *    file       pointer to open file object for device
 *    cmd        IOCTL command code
 *    arg        argument for IOCTL call (cmd dependent)
 *
 * Return Value:    Command dependent
 */
457
static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
Linus Torvalds's avatar
Linus Torvalds committed
458 459
                            unsigned int cmd, unsigned long arg)
{
460
	struct hci_uart *hu = (void *)tty->disc_data;
461
	int err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
462

463
	BT_DBG("");
Linus Torvalds's avatar
Linus Torvalds committed
464 465

	/* Verify the status of the device */
466
	if (!hu)
Linus Torvalds's avatar
Linus Torvalds committed
467 468 469
		return -EBADF;

	switch (cmd) {
470
	case HCIUARTSETPROTO:
471 472
		if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
			err = hci_uart_set_proto(hu, arg);
473
			if (err) {
474
				clear_bit(HCI_UART_PROTO_SET, &hu->flags);
475 476 477 478 479 480 481
				return err;
			}
			tty->low_latency = 1;
		} else	
			return -EBUSY;

	case HCIUARTGETPROTO:
482 483
		if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
			return hu->proto->id;
484 485 486 487 488
		return -EUNATCH;
		
	default:
		err = n_tty_ioctl(tty, file, cmd, arg);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
489 490
	};

491
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496
}

/*
 * We don't provide read/write/poll interface for user space.
 */
497
static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500
{
	return 0;
}
501
static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504
{
	return 0;
}
505
static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508 509
{
	return 0;
}

510 511 512 513
#ifdef CONFIG_BLUEZ_HCIUART_H4
int h4_init(void);
int h4_deinit(void);
#endif
514 515 516 517
#ifdef CONFIG_BLUEZ_HCIUART_BCSP
int bcsp_init(void);
int bcsp_deinit(void);
#endif
518

519
int __init hci_uart_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
520
{
521
	static struct tty_ldisc hci_uart_ldisc;
Linus Torvalds's avatar
Linus Torvalds committed
522 523
	int err;

524
	BT_INFO("BlueZ HCI UART driver ver %s Copyright (C) 2000,2001 Qualcomm Inc", 
Linus Torvalds's avatar
Linus Torvalds committed
525
		VERSION);
526
	BT_INFO("Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>");
Linus Torvalds's avatar
Linus Torvalds committed
527 528 529

	/* Register the tty discipline */

530 531 532 533 534 535 536 537 538 539 540 541 542 543
	memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
	hci_uart_ldisc.magic       = TTY_LDISC_MAGIC;
	hci_uart_ldisc.name        = "n_hci";
	hci_uart_ldisc.open        = hci_uart_tty_open;
	hci_uart_ldisc.close       = hci_uart_tty_close;
	hci_uart_ldisc.read        = hci_uart_tty_read;
	hci_uart_ldisc.write       = hci_uart_tty_write;
	hci_uart_ldisc.ioctl       = hci_uart_tty_ioctl;
	hci_uart_ldisc.poll        = hci_uart_tty_poll;
	hci_uart_ldisc.receive_room= hci_uart_tty_room;
	hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
	hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;

	if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
544
		BT_ERR("Can't register HCI line discipline (%d)", err);
Linus Torvalds's avatar
Linus Torvalds committed
545 546 547
		return err;
	}

548 549 550
#ifdef CONFIG_BLUEZ_HCIUART_H4
	h4_init();
#endif
551 552 553
#ifdef CONFIG_BLUEZ_HCIUART_BCSP
	bcsp_init();
#endif
554
	
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557
	return 0;
}

558
void hci_uart_cleanup(void)
Linus Torvalds's avatar
Linus Torvalds committed
559 560 561
{
	int err;

562 563 564
#ifdef CONFIG_BLUEZ_HCIUART_H4
	h4_deinit();
#endif
565 566 567
#ifdef CONFIG_BLUEZ_HCIUART_BCSP
	bcsp_deinit();
#endif
568

Linus Torvalds's avatar
Linus Torvalds committed
569 570
	/* Release tty registration of line discipline */
	if ((err = tty_register_ldisc(N_HCI, NULL)))
571
		BT_ERR("Can't unregister HCI line discipline (%d)", err);
Linus Torvalds's avatar
Linus Torvalds committed
572 573
}

574 575
module_init(hci_uart_init);
module_exit(hci_uart_cleanup);
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579

MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
MODULE_DESCRIPTION("BlueZ HCI UART driver ver " VERSION);
MODULE_LICENSE("GPL");