[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/config.h>
#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/sched.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, struct pt_regs *regs)
{
	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;

	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, last_ret, last_fn;

	tuple.TupleData = (cisdata_t *)buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;

	/* Get configuration register information */
	tuple.DesiredTuple = CISTPL_CONFIG;
	last_ret = first_tuple(link, &tuple, &parse);
	if (last_ret != CS_SUCCESS) {
		last_fn = ParseTuple;
		goto cs_failed;
	}
	link->conf.ConfigBase = parse.config.base;
	link->conf.Present = parse.config.rmask[0];

	/* 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;

cs_failed:
	cs_error(link, last_fn, last_ret);

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