[deliverable/linux.git] / drivers / bluetooth / btuart_cs.c

/*
 *
 *  Driver for Bluetooth PCMCIA cards with HCI UART interface
 *
 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  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;
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing
 *  rights and limitations under the License.
 *
 *  The initial developer of the original code is David A. Hinds
 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/spinlock.h>
#include <linux/moduleparam.h>

#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/bitops.h>
#include <asm/system.h>
#include <asm/io.h>

#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ciscode.h>
#include <pcmcia/ds.h>
#include <pcmcia/cisreg.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>


/* ======================== Module parameters ======================== */


MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
MODULE_LICENSE("GPL");


/* ======================== Local structures ======================== */


typedef struct btuart_info_t {
	struct pcmcia_device *p_dev;
	dev_node_t node;

	struct hci_dev *hdev;

	spinlock_t lock;	/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

	unsigned long rx_state;
	unsigned long rx_count;
	struct sk_buff *rx_skb;
} btuart_info_t;


static int btuart_config(struct pcmcia_device *link);
static void btuart_release(struct pcmcia_device *link);

static void btuart_detach(struct pcmcia_device *p_dev);


/* Maximum baud rate */
#define SPEED_MAX  115200

/* Default baud rate: 57600, 115200, 230400 or 460800 */
#define DEFAULT_BAUD_RATE  115200


/* Transmit states  */
#define XMIT_SENDING	1
#define XMIT_WAKEUP	2
#define XMIT_WAITING	8

/* Receiver states */
#define RECV_WAIT_PACKET_TYPE	0
#define RECV_WAIT_EVENT_HEADER	1
#define RECV_WAIT_ACL_HEADER	2
#define RECV_WAIT_SCO_HEADER	3
#define RECV_WAIT_DATA		4


/* ======================== Interrupt handling ======================== */


static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
{
	int actual = 0;

	/* Tx FIFO should be empty */
	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
		return 0;

	/* Fill FIFO with current frame */
	while ((fifo_size-- > 0) && (actual < len)) {
		/* Transmit next byte */
		outb(buf[actual], iobase + UART_TX);
		actual++;
	}

	return actual;
}


static void btuart_write_wakeup(btuart_info_t *info)
{
	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
		set_bit(XMIT_WAKEUP, &(info->tx_state));
		return;
	}

	do {
		register unsigned int iobase = info->p_dev->io.BasePort1;
		register struct sk_buff *skb;
		register int len;

		clear_bit(XMIT_WAKEUP, &(info->tx_state));

		if (!pcmcia_dev_present(info->p_dev))
			return;

		if (!(skb = skb_dequeue(&(info->txq))))
			break;

		/* Send frame */
		len = btuart_write(iobase, 16, skb->data, skb->len);
		set_bit(XMIT_WAKEUP, &(info->tx_state));

		if (len == skb->len) {
			kfree_skb(skb);
		} else {
			skb_pull(skb, len);
			skb_queue_head(&(info->txq), skb);
		}

		info->hdev->stat.byte_tx += len;

	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));

	clear_bit(XMIT_SENDING, &(info->tx_state));
}


static void btuart_receive(btuart_info_t *info)
{
	unsigned int iobase;
	int boguscount = 0;

	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	iobase = info->p_dev->io.BasePort1;

	do {
		info->hdev->stat.byte_rx++;

		/* Allocate packet */
		if (info->rx_skb == NULL) {
			info->rx_state = RECV_WAIT_PACKET_TYPE;
			info->rx_count = 0;
			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
				BT_ERR("Can't allocate mem for new packet");
				return;
			}
		}

		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			info->rx_skb->dev = (void *) info->hdev;
			bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);

			switch (bt_cb(info->rx_skb)->pkt_type) {

			case HCI_EVENT_PKT:
				info->rx_state = RECV_WAIT_EVENT_HEADER;
				info->rx_count = HCI_EVENT_HDR_SIZE;
				break;

			case HCI_ACLDATA_PKT:
				info->rx_state = RECV_WAIT_ACL_HEADER;
				info->rx_count = HCI_ACL_HDR_SIZE;
				break;

			case HCI_SCODATA_PKT:
				info->rx_state = RECV_WAIT_SCO_HEADER;
				info->rx_count = HCI_SCO_HDR_SIZE;
				break;

			default:
				/* Unknown packet */
				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
				info->hdev->stat.err_rx++;
				clear_bit(HCI_RUNNING, &(info->hdev->flags));

				kfree_skb(info->rx_skb);
				info->rx_skb = NULL;
				break;

			}

		} else {

			*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
			info->rx_count--;

			if (info->rx_count == 0) {

				int dlen;
				struct hci_event_hdr *eh;
				struct hci_acl_hdr *ah;
				struct hci_sco_hdr *sh;


				switch (info->rx_state) {

				case RECV_WAIT_EVENT_HEADER:
					eh = (struct hci_event_hdr *)(info->rx_skb->data);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

				case RECV_WAIT_ACL_HEADER:
					ah = (struct hci_acl_hdr *)(info->rx_skb->data);
					dlen = __le16_to_cpu(ah->dlen);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = dlen;
					break;

				case RECV_WAIT_SCO_HEADER:
					sh = (struct hci_sco_hdr *)(info->rx_skb->data);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = sh->dlen;
					break;

				case RECV_WAIT_DATA:
					hci_recv_frame(info->rx_skb);
					info->rx_skb = NULL;
					break;

				}

			}

		}

		/* Make sure we don't stay here too long */
		if (boguscount++ > 16)
			break;

	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
}


static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
{
	btuart_info_t *info = dev_inst;
	unsigned int iobase;
	int boguscount = 0;
	int iir, lsr;

	if (!info || !info->hdev) {
		BT_ERR("Call of irq %d for unknown device", irq);
		return IRQ_NONE;
	}

	iobase = info->p_dev->io.BasePort1;

	spin_lock(&(info->lock));

	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	while (iir) {

		/* Clear interrupt */
		lsr = inb(iobase + UART_LSR);

		switch (iir) {
		case UART_IIR_RLSI:
			BT_ERR("RLSI");
			break;
		case UART_IIR_RDI:
			/* Receive interrupt */
			btuart_receive(info);
			break;
		case UART_IIR_THRI:
			if (lsr & UART_LSR_THRE) {
				/* Transmitter ready for data */
				btuart_write_wakeup(info);
			}
			break;
		default:
			BT_ERR("Unhandled IIR=%#x", iir);
			break;
		}

		/* Make sure we don't stay here too long */
		if (boguscount++ > 100)
			break;

		iir = inb(iobase + UART_IIR) & UART_IIR_ID;

	}

	spin_unlock(&(info->lock));

	return IRQ_HANDLED;
}


static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
{
	unsigned long flags;
	unsigned int iobase;
	int fcr;		/* FIFO control reg */
	int lcr;		/* Line control reg */
	int divisor;

	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	iobase = info->p_dev->io.BasePort1;

	spin_lock_irqsave(&(info->lock), flags);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	divisor = SPEED_MAX / speed;

	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;

	/* 
	 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	 * about this timeout since it will always be fast enough. 
	 */

	if (speed < 38400)
		fcr |= UART_FCR_TRIGGER_1;
	else
		fcr |= UART_FCR_TRIGGER_14;

	/* Bluetooth cards use 8N1 */
	lcr = UART_LCR_WLEN8;

	outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);	/* Set DLAB */
	outb(divisor & 0xff, iobase + UART_DLL);	/* Set speed */
	outb(divisor >> 8, iobase + UART_DLM);
	outb(lcr, iobase + UART_LCR);	/* Set 8N1  */
	outb(fcr, iobase + UART_FCR);	/* Enable FIFO's */

	/* Turn on interrups */
	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);
}


/* ======================== HCI interface ======================== */


static int btuart_hci_flush(struct hci_dev *hdev)
{
	btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);

	/* Drop TX queue */
	skb_queue_purge(&(info->txq));

	return 0;
}


static int btuart_hci_open(struct hci_dev *hdev)
{
	set_bit(HCI_RUNNING, &(hdev->flags));

	return 0;
}


static int btuart_hci_close(struct hci_dev *hdev)
{
	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
		return 0;

	btuart_hci_flush(hdev);

	return 0;
}


static int btuart_hci_send_frame(struct sk_buff *skb)
{
	btuart_info_t *info;
	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);

	if (!hdev) {
		BT_ERR("Frame for unknown HCI device (hdev=NULL)");
		return -ENODEV;
	}

	info = (btuart_info_t *)(hdev->driver_data);

	switch (bt_cb(skb)->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.sco_tx++;
		break;
	};

	/* Prepend skb with frame type */
	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
	skb_queue_tail(&(info->txq), skb);

	btuart_write_wakeup(info);

	return 0;
}


static void btuart_hci_destruct(struct hci_dev *hdev)
{
}


static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
{
	return -ENOIOCTLCMD;
}


/* ======================== Card services HCI interaction ======================== */


static int btuart_open(btuart_info_t *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->io.BasePort1;
	struct hci_dev *hdev;

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

	info->rx_state = RECV_WAIT_PACKET_TYPE;
	info->rx_count = 0;
	info->rx_skb = NULL;

	/* Initialize HCI device */
	hdev = hci_alloc_dev();
	if (!hdev) {
		BT_ERR("Can't allocate HCI device");
		return -ENOMEM;
	}

	info->hdev = hdev;

	hdev->type = HCI_PCCARD;
	hdev->driver_data = info;
	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);

	hdev->open     = btuart_hci_open;
	hdev->close    = btuart_hci_close;
	hdev->flush    = btuart_hci_flush;
	hdev->send     = btuart_hci_send_frame;
	hdev->destruct = btuart_hci_destruct;
	hdev->ioctl    = btuart_hci_ioctl;

	hdev->owner = THIS_MODULE;

	spin_lock_irqsave(&(info->lock), flags);

	/* Reset UART */
	outb(0, iobase + UART_MCR);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	/* Initialize UART */
	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */
	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);

	/* Turn on interrupts */
	// outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);

	btuart_change_speed(info, DEFAULT_BAUD_RATE);

	/* Timeout before it is safe to send the first HCI packet */
	msleep(1000);

	/* Register HCI device */
	if (hci_register_dev(hdev) < 0) {
		BT_ERR("Can't register HCI device");
		info->hdev = NULL;
		hci_free_dev(hdev);
		return -ENODEV;
	}

	return 0;
}


static int btuart_close(btuart_info_t *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->io.BasePort1;
	struct hci_dev *hdev = info->hdev;

	if (!hdev)
		return -ENODEV;

	btuart_hci_close(hdev);

	spin_lock_irqsave(&(info->lock), flags);

	/* Reset UART */
	outb(0, iobase + UART_MCR);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);

	if (hci_unregister_dev(hdev) < 0)
		BT_ERR("Can't unregister HCI device %s", hdev->name);

	hci_free_dev(hdev);

	return 0;
}

static int btuart_probe(struct pcmcia_device *link)
{
	btuart_info_t *info;

	/* Create new info device */
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->p_dev = link;
	link->priv = info;

	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	link->io.NumPorts1 = 8;
	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
	link->irq.IRQInfo1 = IRQ_LEVEL_ID;

	link->irq.Handler = btuart_interrupt;
	link->irq.Instance = info;

	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.IntType = INT_MEMORY_AND_IO;

	return btuart_config(link);
}


static void btuart_detach(struct pcmcia_device *link)
{
	btuart_info_t *info = link->priv;

	btuart_release(link);
	kfree(info);
}

static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	int i;

	i = pcmcia_get_tuple_data(handle, tuple);
	if (i != CS_SUCCESS)
		return i;

	return pcmcia_parse_tuple(handle, tuple, parse);
}

static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int btuart_config(struct pcmcia_device *link)
{
	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	btuart_info_t *info = link->priv;
	tuple_t tuple;
	u_short buf[256];
	cisparse_t parse;
	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	int i, j, try;

	/* First pass: look for a config entry that looks normal. */
	tuple.TupleData = (cisdata_t *) buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;
	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	/* Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++) {
		i = first_tuple(link, &tuple, &parse);
		while (i != CS_NO_MORE_ITEMS) {
			if (i != CS_SUCCESS)
				goto next_entry;
			if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
				link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
			if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
				link->conf.ConfigIndex = cf->index;
				link->io.BasePort1 = cf->io.win[0].base;
				link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
next_entry:
			i = next_tuple(link, &tuple, &parse);
		}
	}

	/* Second pass: try to find an entry that isn't picky about
	   its base address, then try to grab any standard serial port
	   address, and finally try to get any free port. */
	i = first_tuple(link, &tuple, &parse);
	while (i != CS_NO_MORE_ITEMS) {
		if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
		    && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
			link->conf.ConfigIndex = cf->index;
			for (j = 0; j < 5; j++) {
				link->io.BasePort1 = base[j];
				link->io.IOAddrLines = base[j] ? 16 : 3;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
		}
		i = next_tuple(link, &tuple, &parse);
	}

found_port:
	if (i != CS_SUCCESS) {
		BT_ERR("No usable port range found");
		cs_error(link, RequestIO, i);
		goto failed;
	}

	i = pcmcia_request_irq(link, &link->irq);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestIRQ, i);
		link->irq.AssignedIRQ = 0;
	}

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestConfiguration, i);
		goto failed;
	}

	if (btuart_open(info) != 0)
		goto failed;

	strcpy(info->node.dev_name, info->hdev->name);
	link->dev_node = &info->node;

	return 0;

failed:
	btuart_release(link);
	return -ENODEV;
}


static void btuart_release(struct pcmcia_device *link)
{
	btuart_info_t *info = link->priv;

	btuart_close(info);

	pcmcia_disable_device(link);
}

static struct pcmcia_device_id btuart_ids[] = {
	/* don't use this driver. Use serial_cs + hci_uart instead */
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, btuart_ids);

static struct pcmcia_driver btuart_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "btuart_cs",
	},
	.probe		= btuart_probe,
	.remove		= btuart_detach,
	.id_table	= btuart_ids,
};

static int __init init_btuart_cs(void)
{
	return pcmcia_register_driver(&btuart_driver);
}


static void __exit exit_btuart_cs(void)
{
	pcmcia_unregister_driver(&btuart_driver);
}

module_init(init_btuart_cs);
module_exit(exit_btuart_cs);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for Bluetooth PCMCIA cards with HCI UART interface
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	*
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation;
	11	*
	12	* Software distributed under the License is distributed on an "AS
	13	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	14	* implied. See the License for the specific language governing
	15	* rights and limitations under the License.
	16	*
	17	* The initial developer of the original code is David A. Hinds
	18	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	19	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	20	*
	21	*/
	22
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/kernel.h>
	26	#include <linux/init.h>
	27	#include <linux/slab.h>
	28	#include <linux/types.h>
1da177e4 LT	29	#include <linux/delay.h>
	30	#include <linux/errno.h>
	31	#include <linux/ptrace.h>
	32	#include <linux/ioport.h>
	33	#include <linux/spinlock.h>
	34	#include <linux/moduleparam.h>
	35
	36	#include <linux/skbuff.h>
	37	#include <linux/string.h>
	38	#include <linux/serial.h>
	39	#include <linux/serial_reg.h>
	40	#include <linux/bitops.h>
	41	#include <asm/system.h>
	42	#include <asm/io.h>
	43
1da177e4 LT	44	#include <pcmcia/cs_types.h>
	45	#include <pcmcia/cs.h>
	46	#include <pcmcia/cistpl.h>
	47	#include <pcmcia/ciscode.h>
	48	#include <pcmcia/ds.h>
	49	#include <pcmcia/cisreg.h>
	50
	51	#include <net/bluetooth/bluetooth.h>
	52	#include <net/bluetooth/hci_core.h>
	53
	54
	55
	56	/* ======================== Module parameters ======================== */
	57
	58
	59	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	60	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	61	MODULE_LICENSE("GPL");
	62
	63
	64
	65	/* ======================== Local structures ======================== */
	66
	67
	68	typedef struct btuart_info_t {
fd238232	69	struct pcmcia_device *p_dev;
1da177e4 LT	70	dev_node_t node;
	71
	72	struct hci_dev *hdev;
	73
	74	spinlock_t lock; /* For serializing operations */
	75
	76	struct sk_buff_head txq;
	77	unsigned long tx_state;
	78
	79	unsigned long rx_state;
	80	unsigned long rx_count;
	81	struct sk_buff *rx_skb;
	82	} btuart_info_t;
	83
	84
15b99ac1	85	static int btuart_config(struct pcmcia_device *link);
fba395ee	86	static void btuart_release(struct pcmcia_device *link);
1da177e4	87
cc3b4866	88	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	89
1da177e4 LT	90
	91	/* Maximum baud rate */
	92	#define SPEED_MAX 115200
	93
	94	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	95	#define DEFAULT_BAUD_RATE 115200
	96
	97
	98	/* Transmit states */
	99	#define XMIT_SENDING 1
	100	#define XMIT_WAKEUP 2
	101	#define XMIT_WAITING 8
	102
	103	/* Receiver states */
	104	#define RECV_WAIT_PACKET_TYPE 0
	105	#define RECV_WAIT_EVENT_HEADER 1
	106	#define RECV_WAIT_ACL_HEADER 2
	107	#define RECV_WAIT_SCO_HEADER 3
	108	#define RECV_WAIT_DATA 4
	109
	110
	111
	112	/* ======================== Interrupt handling ======================== */
	113
	114
	115	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	116	{
	117	int actual = 0;
	118
	119	/* Tx FIFO should be empty */
	120	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	121	return 0;
	122
	123	/* Fill FIFO with current frame */
	124	while ((fifo_size-- > 0) && (actual < len)) {
	125	/* Transmit next byte */
	126	outb(buf[actual], iobase + UART_TX);
	127	actual++;
	128	}
	129
	130	return actual;
	131	}
	132
	133
	134	static void btuart_write_wakeup(btuart_info_t *info)
	135	{
	136	if (!info) {
	137	BT_ERR("Unknown device");
	138	return;
	139	}
	140
	141	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	142	set_bit(XMIT_WAKEUP, &(info->tx_state));
	143	return;
	144	}
	145
	146	do {
fd238232	147	register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	148	register struct sk_buff *skb;
	149	register int len;
	150
	151	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	152
e2d40963	153	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	154	return;
	155
	156	if (!(skb = skb_dequeue(&(info->txq))))
	157	break;
	158
	159	/* Send frame */
	160	len = btuart_write(iobase, 16, skb->data, skb->len);
	161	set_bit(XMIT_WAKEUP, &(info->tx_state));
	162
	163	if (len == skb->len) {
	164	kfree_skb(skb);
	165	} else {
	166	skb_pull(skb, len);
	167	skb_queue_head(&(info->txq), skb);
	168	}
	169
	170	info->hdev->stat.byte_tx += len;
	171
	172	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	173
	174	clear_bit(XMIT_SENDING, &(info->tx_state));
	175	}
	176
	177
	178	static void btuart_receive(btuart_info_t *info)
	179	{
	180	unsigned int iobase;
	181	int boguscount = 0;
	182
	183	if (!info) {
	184	BT_ERR("Unknown device");
	185	return;
	186	}
	187
fd238232	188	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	189
	190	do {
	191	info->hdev->stat.byte_rx++;
	192
	193	/* Allocate packet */
	194	if (info->rx_skb == NULL) {
	195	info->rx_state = RECV_WAIT_PACKET_TYPE;
	196	info->rx_count = 0;
	197	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	198	BT_ERR("Can't allocate mem for new packet");
	199	return;
	200	}
	201	}
	202
	203	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	204
	205	info->rx_skb->dev = (void *) info->hdev;
0d48d939	206	bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
1da177e4	207
0d48d939	208	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	209
	210	case HCI_EVENT_PKT:
	211	info->rx_state = RECV_WAIT_EVENT_HEADER;
	212	info->rx_count = HCI_EVENT_HDR_SIZE;
	213	break;
	214
	215	case HCI_ACLDATA_PKT:
	216	info->rx_state = RECV_WAIT_ACL_HEADER;
	217	info->rx_count = HCI_ACL_HDR_SIZE;
	218	break;
	219
	220	case HCI_SCODATA_PKT:
	221	info->rx_state = RECV_WAIT_SCO_HEADER;
	222	info->rx_count = HCI_SCO_HDR_SIZE;
	223	break;
	224
	225	default:
	226	/* Unknown packet */
0d48d939	227	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	228	info->hdev->stat.err_rx++;
	229	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	230
	231	kfree_skb(info->rx_skb);
	232	info->rx_skb = NULL;
	233	break;
	234
	235	}
	236
	237	} else {
	238
	239	*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
	240	info->rx_count--;
	241
	242	if (info->rx_count == 0) {
	243
	244	int dlen;
	245	struct hci_event_hdr *eh;
	246	struct hci_acl_hdr *ah;
	247	struct hci_sco_hdr *sh;
	248
	249
	250	switch (info->rx_state) {
	251
	252	case RECV_WAIT_EVENT_HEADER:
	253	eh = (struct hci_event_hdr *)(info->rx_skb->data);
	254	info->rx_state = RECV_WAIT_DATA;
	255	info->rx_count = eh->plen;
	256	break;
	257
	258	case RECV_WAIT_ACL_HEADER:
	259	ah = (struct hci_acl_hdr *)(info->rx_skb->data);
	260	dlen = __le16_to_cpu(ah->dlen);
	261	info->rx_state = RECV_WAIT_DATA;
	262	info->rx_count = dlen;
	263	break;
	264
	265	case RECV_WAIT_SCO_HEADER:
	266	sh = (struct hci_sco_hdr *)(info->rx_skb->data);
	267	info->rx_state = RECV_WAIT_DATA;
	268	info->rx_count = sh->dlen;
	269	break;
	270
	271	case RECV_WAIT_DATA:
	272	hci_recv_frame(info->rx_skb);
	273	info->rx_skb = NULL;
	274	break;
	275
	276	}
	277
	278	}
	279
	280	}
	281
	282	/* Make sure we don't stay here too long */
	283	if (boguscount++ > 16)
	284	break;
	285
	286	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
	287	}
	288
	289
7d12e780	290	static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
1da177e4 LT	291	{
	292	btuart_info_t *info = dev_inst;
	293	unsigned int iobase;
	294	int boguscount = 0;
	295	int iir, lsr;
	296
	297	if (!info \|\| !info->hdev) {
	298	BT_ERR("Call of irq %d for unknown device", irq);
	299	return IRQ_NONE;
	300	}
	301
fd238232	302	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	303
	304	spin_lock(&(info->lock));
	305
	306	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	307	while (iir) {
	308
	309	/* Clear interrupt */
	310	lsr = inb(iobase + UART_LSR);
	311
	312	switch (iir) {
	313	case UART_IIR_RLSI:
	314	BT_ERR("RLSI");
	315	break;
	316	case UART_IIR_RDI:
	317	/* Receive interrupt */
	318	btuart_receive(info);
	319	break;
	320	case UART_IIR_THRI:
	321	if (lsr & UART_LSR_THRE) {
	322	/* Transmitter ready for data */
	323	btuart_write_wakeup(info);
	324	}
	325	break;
	326	default:
	327	BT_ERR("Unhandled IIR=%#x", iir);
	328	break;
	329	}
	330
	331	/* Make sure we don't stay here too long */
	332	if (boguscount++ > 100)
	333	break;
	334
	335	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	336
	337	}
	338
	339	spin_unlock(&(info->lock));
	340
	341	return IRQ_HANDLED;
	342	}
	343
	344
	345	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	346	{
	347	unsigned long flags;
	348	unsigned int iobase;
	349	int fcr; /* FIFO control reg */
	350	int lcr; /* Line control reg */
	351	int divisor;
	352
	353	if (!info) {
	354	BT_ERR("Unknown device");
	355	return;
	356	}
	357
fd238232	358	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	359
	360	spin_lock_irqsave(&(info->lock), flags);
	361
	362	/* Turn off interrupts */
	363	outb(0, iobase + UART_IER);
	364
	365	divisor = SPEED_MAX / speed;
	366
	367	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	368
	369	/*
	370	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	371	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	372	* about this timeout since it will always be fast enough.
	373	*/
	374
	375	if (speed < 38400)
	376	fcr \|= UART_FCR_TRIGGER_1;
	377	else
	378	fcr \|= UART_FCR_TRIGGER_14;
	379
	380	/* Bluetooth cards use 8N1 */
	381	lcr = UART_LCR_WLEN8;
	382
	383	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	384	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	385	outb(divisor >> 8, iobase + UART_DLM);
	386	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	387	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	388
	389	/* Turn on interrups */
	390	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	391
	392	spin_unlock_irqrestore(&(info->lock), flags);
	393	}
	394
	395
	396
	397	/* ======================== HCI interface ======================== */
	398
	399
	400	static int btuart_hci_flush(struct hci_dev *hdev)
	401	{
	402	btuart_info_t info = (btuart_info_t )(hdev->driver_data);
	403
	404	/* Drop TX queue */
	405	skb_queue_purge(&(info->txq));
	406
	407	return 0;
	408	}
	409
	410
	411	static int btuart_hci_open(struct hci_dev *hdev)
	412	{
	413	set_bit(HCI_RUNNING, &(hdev->flags));
	414
	415	return 0;
	416	}
	417
	418
	419	static int btuart_hci_close(struct hci_dev *hdev)
	420	{
	421	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	422	return 0;
423
424	btuart_hci_flush(hdev);
425
426	return 0;
427	}
428
429
430	static int btuart_hci_send_frame(struct sk_buff *skb)
431	{
432	btuart_info_t *info;
433	struct hci_dev hdev = (struct hci_dev )(skb->dev);
434
435	if (!hdev) {
436	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
437	return -ENODEV;
438	}
439
440	info = (btuart_info_t *)(hdev->driver_data);
441
0d48d939	442	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	443	case HCI_COMMAND_PKT:
	444	hdev->stat.cmd_tx++;
	445	break;
	446	case HCI_ACLDATA_PKT:
	447	hdev->stat.acl_tx++;
	448	break;
	449	case HCI_SCODATA_PKT:
	450	hdev->stat.sco_tx++;
	451	break;
	452	};
	453
	454	/* Prepend skb with frame type */
0d48d939	455	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	456	skb_queue_tail(&(info->txq), skb);
	457
	458	btuart_write_wakeup(info);
	459
	460	return 0;
	461	}
	462
	463
	464	static void btuart_hci_destruct(struct hci_dev *hdev)
	465	{
	466	}
	467
	468
	469	static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	470	{
	471	return -ENOIOCTLCMD;
	472	}
	473
	474
	475
	476	/* ======================== Card services HCI interaction ======================== */
	477
	478
	479	static int btuart_open(btuart_info_t *info)
	480	{
	481	unsigned long flags;
fd238232	482	unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	483	struct hci_dev *hdev;
	484
	485	spin_lock_init(&(info->lock));
	486
	487	skb_queue_head_init(&(info->txq));
	488
	489	info->rx_state = RECV_WAIT_PACKET_TYPE;
	490	info->rx_count = 0;
	491	info->rx_skb = NULL;
	492
	493	/* Initialize HCI device */
	494	hdev = hci_alloc_dev();
	495	if (!hdev) {
	496	BT_ERR("Can't allocate HCI device");
	497	return -ENOMEM;
	498	}
	499
	500	info->hdev = hdev;
	501
	502	hdev->type = HCI_PCCARD;
	503	hdev->driver_data = info;
27d35284	504	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	505
	506	hdev->open = btuart_hci_open;
	507	hdev->close = btuart_hci_close;
	508	hdev->flush = btuart_hci_flush;
	509	hdev->send = btuart_hci_send_frame;
	510	hdev->destruct = btuart_hci_destruct;
	511	hdev->ioctl = btuart_hci_ioctl;
	512
	513	hdev->owner = THIS_MODULE;
	514
	515	spin_lock_irqsave(&(info->lock), flags);
	516
	517	/* Reset UART */
	518	outb(0, iobase + UART_MCR);
	519
	520	/* Turn off interrupts */
	521	outb(0, iobase + UART_IER);
	522
	523	/* Initialize UART */
	524	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	525	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	526
	527	/* Turn on interrupts */
	528	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	529
	530	spin_unlock_irqrestore(&(info->lock), flags);
	531
	532	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	533
	534	/* Timeout before it is safe to send the first HCI packet */
	535	msleep(1000);
	536
	537	/* Register HCI device */
	538	if (hci_register_dev(hdev) < 0) {
	539	BT_ERR("Can't register HCI device");
	540	info->hdev = NULL;
	541	hci_free_dev(hdev);
	542	return -ENODEV;
	543	}
	544
	545	return 0;
	546	}
	547
	548
	549	static int btuart_close(btuart_info_t *info)
	550	{
	551	unsigned long flags;
fd238232	552	unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	553	struct hci_dev *hdev = info->hdev;
	554
	555	if (!hdev)
	556	return -ENODEV;
	557
	558	btuart_hci_close(hdev);
	559
	560	spin_lock_irqsave(&(info->lock), flags);
	561
	562	/* Reset UART */
	563	outb(0, iobase + UART_MCR);
	564
	565	/* Turn off interrupts */
	566	outb(0, iobase + UART_IER);
	567
	568	spin_unlock_irqrestore(&(info->lock), flags);
	569
	570	if (hci_unregister_dev(hdev) < 0)
	571	BT_ERR("Can't unregister HCI device %s", hdev->name);
	572
	573	hci_free_dev(hdev);
	574
	575	return 0;
	576	}
	577
15b99ac1	578	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	579	{
1da177e4 LT	580	btuart_info_t *info;
1da177e4 LT	581
1da177e4 LT	582	/* Create new info device */
089b1dbb	583	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	584	if (!info)
f8cfa618	585	return -ENOMEM;
1da177e4	586
fba395ee	587	info->p_dev = link;
1da177e4 LT	588	link->priv = info;
	589
	590	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	591	link->io.NumPorts1 = 8;
	592	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	593	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	594
	595	link->irq.Handler = btuart_interrupt;
	596	link->irq.Instance = info;
	597
	598	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	599	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	600
15b99ac1	601	return btuart_config(link);
1da177e4 LT	602	}
	603
	604
fba395ee	605	static void btuart_detach(struct pcmcia_device *link)
1da177e4 LT	606	{
1da177e4 LT	607	btuart_info_t *info = link->priv;
1da177e4	608
e2d40963	609	btuart_release(link);
1da177e4 LT	610	kfree(info);
	611	}
	612
fba395ee	613	static int get_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	614	{
	615	int i;
	616
	617	i = pcmcia_get_tuple_data(handle, tuple);
	618	if (i != CS_SUCCESS)
	619	return i;
	620
	621	return pcmcia_parse_tuple(handle, tuple, parse);
	622	}
	623
fba395ee	624	static int first_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	625	{
	626	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
	627	return CS_NO_MORE_ITEMS;
	628	return get_tuple(handle, tuple, parse);
	629	}
	630
fba395ee	631	static int next_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	632	{
	633	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
	634	return CS_NO_MORE_ITEMS;
	635	return get_tuple(handle, tuple, parse);
	636	}
	637
15b99ac1	638	static int btuart_config(struct pcmcia_device *link)
1da177e4 LT	639	{
1da177e4 LT	640	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4 LT	641	btuart_info_t *info = link->priv;
	642	tuple_t tuple;
	643	u_short buf[256];
	644	cisparse_t parse;
	645	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
af2b3b50	646	int i, j, try;
1da177e4	647
1da177e4 LT	648	/* First pass: look for a config entry that looks normal. */
	649	tuple.TupleData = (cisdata_t *) buf;
	650	tuple.TupleOffset = 0;
	651	tuple.TupleDataMax = 255;
	652	tuple.Attributes = 0;
	653	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	654	/* Two tries: without IO aliases, then with aliases */
	655	for (try = 0; try < 2; try++) {
fba395ee	656	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	657	while (i != CS_NO_MORE_ITEMS) {
	658	if (i != CS_SUCCESS)
	659	goto next_entry;
	660	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	661	link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	662	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
	663	link->conf.ConfigIndex = cf->index;
	664	link->io.BasePort1 = cf->io.win[0].base;
	665	link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee	666	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	667	if (i == CS_SUCCESS)
	668	goto found_port;
	669	}
	670	next_entry:
fba395ee	671	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	672	}
	673	}
	674
	675	/* Second pass: try to find an entry that isn't picky about
	676	its base address, then try to grab any standard serial port
	677	address, and finally try to get any free port. */
fba395ee	678	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	679	while (i != CS_NO_MORE_ITEMS) {
	680	if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
	681	&& ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
	682	link->conf.ConfigIndex = cf->index;
	683	for (j = 0; j < 5; j++) {
	684	link->io.BasePort1 = base[j];
	685	link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee	686	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	687	if (i == CS_SUCCESS)
	688	goto found_port;
	689	}
	690	}
fba395ee	691	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	692	}
	693
	694	found_port:
	695	if (i != CS_SUCCESS) {
	696	BT_ERR("No usable port range found");
fba395ee	697	cs_error(link, RequestIO, i);
1da177e4 LT	698	goto failed;
	699	}
	700
fba395ee	701	i = pcmcia_request_irq(link, &link->irq);
1da177e4	702	if (i != CS_SUCCESS) {
fba395ee	703	cs_error(link, RequestIRQ, i);
1da177e4 LT	704	link->irq.AssignedIRQ = 0;
	705	}
	706
fba395ee	707	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	708	if (i != CS_SUCCESS) {
fba395ee	709	cs_error(link, RequestConfiguration, i);
1da177e4 LT	710	goto failed;
	711	}
	712
	713	if (btuart_open(info) != 0)
	714	goto failed;
	715
	716	strcpy(info->node.dev_name, info->hdev->name);
fd238232	717	link->dev_node = &info->node;
1da177e4	718
15b99ac1	719	return 0;
1da177e4	720
1da177e4 LT	721	failed:
1da177e4 LT	722	btuart_release(link);
15b99ac1	723	return -ENODEV;
1da177e4 LT	724	}
	725
	726
fba395ee	727	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	728	{
	729	btuart_info_t *info = link->priv;
	730
e2d40963	731	btuart_close(info);
1da177e4	732
fba395ee	733	pcmcia_disable_device(link);
1da177e4 LT	734	}
1da177e4 LT	735
279c9361 DB	736	static struct pcmcia_device_id btuart_ids[] = {
	737	/* don't use this driver. Use serial_cs + hci_uart instead */
	738	PCMCIA_DEVICE_NULL
	739	};
	740	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	741
1da177e4 LT	742	static struct pcmcia_driver btuart_driver = {
	743	.owner = THIS_MODULE,
	744	.drv = {
	745	.name = "btuart_cs",
	746	},
15b99ac1	747	.probe = btuart_probe,
cc3b4866	748	.remove = btuart_detach,
279c9361	749	.id_table = btuart_ids,
1da177e4 LT	750	};
	751
	752	static int __init init_btuart_cs(void)
	753	{
	754	return pcmcia_register_driver(&btuart_driver);
	755	}
	756
	757
	758	static void __exit exit_btuart_cs(void)
	759	{
	760	pcmcia_unregister_driver(&btuart_driver);
1da177e4 LT	761	}
	762
	763	module_init(init_btuart_cs);
	764	module_exit(exit_btuart_cs);