[net-next-2.6.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/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)
{
	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, 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
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>
	29	#include <linux/sched.h>
	30	#include <linux/delay.h>
	31	#include <linux/errno.h>
	32	#include <linux/ptrace.h>
	33	#include <linux/ioport.h>
	34	#include <linux/spinlock.h>
	35	#include <linux/moduleparam.h>
	36
	37	#include <linux/skbuff.h>
	38	#include <linux/string.h>
	39	#include <linux/serial.h>
	40	#include <linux/serial_reg.h>
	41	#include <linux/bitops.h>
	42	#include <asm/system.h>
	43	#include <asm/io.h>
	44
1da177e4 LT	45	#include <pcmcia/cs_types.h>
	46	#include <pcmcia/cs.h>
	47	#include <pcmcia/cistpl.h>
	48	#include <pcmcia/ciscode.h>
	49	#include <pcmcia/ds.h>
	50	#include <pcmcia/cisreg.h>
	51
	52	#include <net/bluetooth/bluetooth.h>
	53	#include <net/bluetooth/hci_core.h>
	54
	55
	56
	57	/* ======================== Module parameters ======================== */
	58
	59
	60	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	61	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	62	MODULE_LICENSE("GPL");
	63
	64
	65
	66	/* ======================== Local structures ======================== */
	67
	68
	69	typedef struct btuart_info_t {
fd238232	70	struct pcmcia_device *p_dev;
1da177e4 LT	71	dev_node_t node;
	72
	73	struct hci_dev *hdev;
	74
	75	spinlock_t lock; /* For serializing operations */
	76
	77	struct sk_buff_head txq;
	78	unsigned long tx_state;
	79
	80	unsigned long rx_state;
	81	unsigned long rx_count;
	82	struct sk_buff *rx_skb;
	83	} btuart_info_t;
	84
	85
15b99ac1	86	static int btuart_config(struct pcmcia_device *link);
fba395ee	87	static void btuart_release(struct pcmcia_device *link);
1da177e4	88
cc3b4866	89	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	90
1da177e4 LT	91
	92	/* Maximum baud rate */
	93	#define SPEED_MAX 115200
	94
	95	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	96	#define DEFAULT_BAUD_RATE 115200
	97
	98
	99	/* Transmit states */
	100	#define XMIT_SENDING 1
	101	#define XMIT_WAKEUP 2
	102	#define XMIT_WAITING 8
	103
	104	/* Receiver states */
	105	#define RECV_WAIT_PACKET_TYPE 0
	106	#define RECV_WAIT_EVENT_HEADER 1
	107	#define RECV_WAIT_ACL_HEADER 2
	108	#define RECV_WAIT_SCO_HEADER 3
	109	#define RECV_WAIT_DATA 4
	110
	111
	112
	113	/* ======================== Interrupt handling ======================== */
	114
	115
	116	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	117	{
	118	int actual = 0;
	119
	120	/* Tx FIFO should be empty */
	121	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	122	return 0;
	123
	124	/* Fill FIFO with current frame */
	125	while ((fifo_size-- > 0) && (actual < len)) {
	126	/* Transmit next byte */
	127	outb(buf[actual], iobase + UART_TX);
	128	actual++;
	129	}
	130
	131	return actual;
	132	}
	133
	134
	135	static void btuart_write_wakeup(btuart_info_t *info)
	136	{
	137	if (!info) {
	138	BT_ERR("Unknown device");
	139	return;
	140	}
	141
	142	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	143	set_bit(XMIT_WAKEUP, &(info->tx_state));
	144	return;
	145	}
	146
	147	do {
fd238232	148	register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	149	register struct sk_buff *skb;
	150	register int len;
	151
	152	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	153
e2d40963	154	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	155	return;
	156
	157	if (!(skb = skb_dequeue(&(info->txq))))
	158	break;
	159
	160	/* Send frame */
	161	len = btuart_write(iobase, 16, skb->data, skb->len);
	162	set_bit(XMIT_WAKEUP, &(info->tx_state));
	163
	164	if (len == skb->len) {
	165	kfree_skb(skb);
	166	} else {
	167	skb_pull(skb, len);
	168	skb_queue_head(&(info->txq), skb);
	169	}
	170
	171	info->hdev->stat.byte_tx += len;
	172
	173	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	174
	175	clear_bit(XMIT_SENDING, &(info->tx_state));
	176	}
	177
	178
	179	static void btuart_receive(btuart_info_t *info)
	180	{
	181	unsigned int iobase;
	182	int boguscount = 0;
	183
	184	if (!info) {
	185	BT_ERR("Unknown device");
	186	return;
	187	}
	188
fd238232	189	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	190
	191	do {
	192	info->hdev->stat.byte_rx++;
	193
	194	/* Allocate packet */
	195	if (info->rx_skb == NULL) {
	196	info->rx_state = RECV_WAIT_PACKET_TYPE;
	197	info->rx_count = 0;
	198	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	199	BT_ERR("Can't allocate mem for new packet");
	200	return;
	201	}
	202	}
	203
	204	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	205
	206	info->rx_skb->dev = (void *) info->hdev;
0d48d939	207	bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
1da177e4	208
0d48d939	209	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	210
	211	case HCI_EVENT_PKT:
	212	info->rx_state = RECV_WAIT_EVENT_HEADER;
	213	info->rx_count = HCI_EVENT_HDR_SIZE;
	214	break;
	215
	216	case HCI_ACLDATA_PKT:
	217	info->rx_state = RECV_WAIT_ACL_HEADER;
	218	info->rx_count = HCI_ACL_HDR_SIZE;
	219	break;
	220
	221	case HCI_SCODATA_PKT:
	222	info->rx_state = RECV_WAIT_SCO_HEADER;
	223	info->rx_count = HCI_SCO_HDR_SIZE;
	224	break;
	225
	226	default:
	227	/* Unknown packet */
0d48d939	228	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	229	info->hdev->stat.err_rx++;
	230	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	231
	232	kfree_skb(info->rx_skb);
	233	info->rx_skb = NULL;
	234	break;
	235
	236	}
	237
	238	} else {
	239
	240	*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
	241	info->rx_count--;
	242
	243	if (info->rx_count == 0) {
	244
	245	int dlen;
	246	struct hci_event_hdr *eh;
	247	struct hci_acl_hdr *ah;
	248	struct hci_sco_hdr *sh;
	249
	250
	251	switch (info->rx_state) {
	252
	253	case RECV_WAIT_EVENT_HEADER:
	254	eh = (struct hci_event_hdr *)(info->rx_skb->data);
	255	info->rx_state = RECV_WAIT_DATA;
	256	info->rx_count = eh->plen;
	257	break;
	258
	259	case RECV_WAIT_ACL_HEADER:
	260	ah = (struct hci_acl_hdr *)(info->rx_skb->data);
	261	dlen = __le16_to_cpu(ah->dlen);
	262	info->rx_state = RECV_WAIT_DATA;
	263	info->rx_count = dlen;
	264	break;
	265
	266	case RECV_WAIT_SCO_HEADER:
	267	sh = (struct hci_sco_hdr *)(info->rx_skb->data);
	268	info->rx_state = RECV_WAIT_DATA;
	269	info->rx_count = sh->dlen;
	270	break;
	271
	272	case RECV_WAIT_DATA:
	273	hci_recv_frame(info->rx_skb);
	274	info->rx_skb = NULL;
	275	break;
	276
	277	}
	278
	279	}
	280
	281	}
	282
	283	/* Make sure we don't stay here too long */
	284	if (boguscount++ > 16)
	285	break;
	286
	287	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
	288	}
	289
	290
7d12e780	291	static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
1da177e4 LT	292	{
	293	btuart_info_t *info = dev_inst;
	294	unsigned int iobase;
	295	int boguscount = 0;
	296	int iir, lsr;
	297
	298	if (!info \|\| !info->hdev) {
	299	BT_ERR("Call of irq %d for unknown device", irq);
	300	return IRQ_NONE;
	301	}
	302
fd238232	303	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	304
	305	spin_lock(&(info->lock));
	306
	307	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	308	while (iir) {
	309
	310	/* Clear interrupt */
	311	lsr = inb(iobase + UART_LSR);
	312
	313	switch (iir) {
	314	case UART_IIR_RLSI:
	315	BT_ERR("RLSI");
	316	break;
	317	case UART_IIR_RDI:
	318	/* Receive interrupt */
	319	btuart_receive(info);
	320	break;
	321	case UART_IIR_THRI:
	322	if (lsr & UART_LSR_THRE) {
	323	/* Transmitter ready for data */
	324	btuart_write_wakeup(info);
	325	}
	326	break;
	327	default:
	328	BT_ERR("Unhandled IIR=%#x", iir);
	329	break;
	330	}
	331
	332	/* Make sure we don't stay here too long */
	333	if (boguscount++ > 100)
	334	break;
	335
	336	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	337
	338	}
	339
	340	spin_unlock(&(info->lock));
	341
	342	return IRQ_HANDLED;
	343	}
	344
	345
	346	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	347	{
	348	unsigned long flags;
	349	unsigned int iobase;
	350	int fcr; /* FIFO control reg */
	351	int lcr; /* Line control reg */
	352	int divisor;
	353
	354	if (!info) {
	355	BT_ERR("Unknown device");
	356	return;
	357	}
	358
fd238232	359	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	360
	361	spin_lock_irqsave(&(info->lock), flags);
	362
	363	/* Turn off interrupts */
	364	outb(0, iobase + UART_IER);
	365
	366	divisor = SPEED_MAX / speed;
	367
	368	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	369
	370	/*
	371	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	372	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	373	* about this timeout since it will always be fast enough.
	374	*/
	375
	376	if (speed < 38400)
	377	fcr \|= UART_FCR_TRIGGER_1;
	378	else
	379	fcr \|= UART_FCR_TRIGGER_14;
	380
	381	/* Bluetooth cards use 8N1 */
	382	lcr = UART_LCR_WLEN8;
	383
	384	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	385	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	386	outb(divisor >> 8, iobase + UART_DLM);
	387	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	388	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	389
	390	/* Turn on interrups */
	391	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	392
	393	spin_unlock_irqrestore(&(info->lock), flags);
	394	}
	395
	396
	397
	398	/* ======================== HCI interface ======================== */
	399
	400
	401	static int btuart_hci_flush(struct hci_dev *hdev)
	402	{
	403	btuart_info_t info = (btuart_info_t )(hdev->driver_data);
	404
	405	/* Drop TX queue */
	406	skb_queue_purge(&(info->txq));
	407
	408	return 0;
	409	}
	410
	411
	412	static int btuart_hci_open(struct hci_dev *hdev)
	413	{
	414	set_bit(HCI_RUNNING, &(hdev->flags));
	415
	416	return 0;
	417	}
	418
	419
	420	static int btuart_hci_close(struct hci_dev *hdev)
	421	{
	422	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	423	return 0;
424
425	btuart_hci_flush(hdev);
426
427	return 0;
428	}
429
430
431	static int btuart_hci_send_frame(struct sk_buff *skb)
432	{
433	btuart_info_t *info;
434	struct hci_dev hdev = (struct hci_dev )(skb->dev);
435
436	if (!hdev) {
437	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
438	return -ENODEV;
439	}
440
441	info = (btuart_info_t *)(hdev->driver_data);
442
0d48d939	443	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	444	case HCI_COMMAND_PKT:
	445	hdev->stat.cmd_tx++;
	446	break;
	447	case HCI_ACLDATA_PKT:
	448	hdev->stat.acl_tx++;
	449	break;
	450	case HCI_SCODATA_PKT:
	451	hdev->stat.sco_tx++;
	452	break;
	453	};
	454
	455	/* Prepend skb with frame type */
0d48d939	456	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	457	skb_queue_tail(&(info->txq), skb);
	458
	459	btuart_write_wakeup(info);
	460
	461	return 0;
	462	}
	463
	464
	465	static void btuart_hci_destruct(struct hci_dev *hdev)
	466	{
	467	}
	468
	469
	470	static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	471	{
	472	return -ENOIOCTLCMD;
	473	}
	474
	475
	476
	477	/* ======================== Card services HCI interaction ======================== */
	478
	479
	480	static int btuart_open(btuart_info_t *info)
	481	{
	482	unsigned long flags;
fd238232	483	unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	484	struct hci_dev *hdev;
	485
	486	spin_lock_init(&(info->lock));
	487
	488	skb_queue_head_init(&(info->txq));
	489
	490	info->rx_state = RECV_WAIT_PACKET_TYPE;
	491	info->rx_count = 0;
	492	info->rx_skb = NULL;
	493
	494	/* Initialize HCI device */
	495	hdev = hci_alloc_dev();
	496	if (!hdev) {
	497	BT_ERR("Can't allocate HCI device");
	498	return -ENOMEM;
	499	}
	500
	501	info->hdev = hdev;
	502
	503	hdev->type = HCI_PCCARD;
	504	hdev->driver_data = info;
27d35284	505	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	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);