[GitHub/mt8127/android_kernel_alcatel_ttab.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 void 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 (!(info->p_dev->state & DEV_PRESENT))
			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_attach(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;

	link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
	btuart_config(link);

	return 0;
}


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

	if (link->state & DEV_CONFIG)
		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 void 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];

	/* Configure card */
	link->state |= DEV_CONFIG;

	/* 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;
	link->state &= ~DEV_CONFIG_PENDING;

	return;

cs_failed:
	cs_error(link, last_fn, last_ret);

failed:
	btuart_release(link);
}


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

	if (link->state & DEV_PRESENT)
		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_attach,
	.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
fba395ee DB	87	static void btuart_config(struct pcmcia_device *link);
fba395ee DB	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
fd238232	155	if (!(info->p_dev->state & DEV_PRESENT))
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
fba395ee	579	static int btuart_attach(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
f8cfa618 DB	602	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
f8cfa618 DB	603	btuart_config(link);
1da177e4	604
f8cfa618	605	return 0;
1da177e4 LT	606	}
	607
	608
fba395ee	609	static void btuart_detach(struct pcmcia_device *link)
1da177e4 LT	610	{
1da177e4 LT	611	btuart_info_t *info = link->priv;
1da177e4 LT	612
	613	if (link->state & DEV_CONFIG)
	614	btuart_release(link);
	615
1da177e4 LT	616	kfree(info);
	617	}
	618
fba395ee	619	static int get_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	620	{
	621	int i;
	622
	623	i = pcmcia_get_tuple_data(handle, tuple);
	624	if (i != CS_SUCCESS)
	625	return i;
	626
	627	return pcmcia_parse_tuple(handle, tuple, parse);
	628	}
	629
fba395ee	630	static int first_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	631	{
	632	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
	633	return CS_NO_MORE_ITEMS;
	634	return get_tuple(handle, tuple, parse);
	635	}
	636
fba395ee	637	static int next_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	638	{
	639	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
	640	return CS_NO_MORE_ITEMS;
	641	return get_tuple(handle, tuple, parse);
	642	}
	643
fba395ee	644	static void btuart_config(struct pcmcia_device *link)
1da177e4 LT	645	{
1da177e4 LT	646	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4 LT	647	btuart_info_t *info = link->priv;
	648	tuple_t tuple;
	649	u_short buf[256];
	650	cisparse_t parse;
	651	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
1da177e4 LT	652	int i, j, try, last_ret, last_fn;
	653
	654	tuple.TupleData = (cisdata_t *)buf;
	655	tuple.TupleOffset = 0;
	656	tuple.TupleDataMax = 255;
	657	tuple.Attributes = 0;
	658
	659	/* Get configuration register information */
	660	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee	661	last_ret = first_tuple(link, &tuple, &parse);
1da177e4 LT	662	if (last_ret != CS_SUCCESS) {
	663	last_fn = ParseTuple;
	664	goto cs_failed;
	665	}
	666	link->conf.ConfigBase = parse.config.base;
	667	link->conf.Present = parse.config.rmask[0];
	668
	669	/* Configure card */
	670	link->state \|= DEV_CONFIG;
1da177e4 LT	671
	672	/* First pass: look for a config entry that looks normal. */
	673	tuple.TupleData = (cisdata_t *) buf;
	674	tuple.TupleOffset = 0;
	675	tuple.TupleDataMax = 255;
	676	tuple.Attributes = 0;
	677	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	678	/* Two tries: without IO aliases, then with aliases */
	679	for (try = 0; try < 2; try++) {
fba395ee	680	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	681	while (i != CS_NO_MORE_ITEMS) {
	682	if (i != CS_SUCCESS)
	683	goto next_entry;
	684	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	685	link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	686	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
	687	link->conf.ConfigIndex = cf->index;
	688	link->io.BasePort1 = cf->io.win[0].base;
	689	link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee	690	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	691	if (i == CS_SUCCESS)
	692	goto found_port;
	693	}
	694	next_entry:
fba395ee	695	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	696	}
	697	}
	698
	699	/* Second pass: try to find an entry that isn't picky about
	700	its base address, then try to grab any standard serial port
	701	address, and finally try to get any free port. */
fba395ee	702	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	703	while (i != CS_NO_MORE_ITEMS) {
	704	if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
	705	&& ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
	706	link->conf.ConfigIndex = cf->index;
	707	for (j = 0; j < 5; j++) {
	708	link->io.BasePort1 = base[j];
	709	link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee	710	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	711	if (i == CS_SUCCESS)
	712	goto found_port;
	713	}
	714	}
fba395ee	715	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	716	}
	717
	718	found_port:
	719	if (i != CS_SUCCESS) {
	720	BT_ERR("No usable port range found");
fba395ee	721	cs_error(link, RequestIO, i);
1da177e4 LT	722	goto failed;
	723	}
	724
fba395ee	725	i = pcmcia_request_irq(link, &link->irq);
1da177e4	726	if (i != CS_SUCCESS) {
fba395ee	727	cs_error(link, RequestIRQ, i);
1da177e4 LT	728	link->irq.AssignedIRQ = 0;
	729	}
	730
fba395ee	731	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	732	if (i != CS_SUCCESS) {
fba395ee	733	cs_error(link, RequestConfiguration, i);
1da177e4 LT	734	goto failed;
	735	}
	736
	737	if (btuart_open(info) != 0)
	738	goto failed;
	739
	740	strcpy(info->node.dev_name, info->hdev->name);
fd238232	741	link->dev_node = &info->node;
1da177e4 LT	742	link->state &= ~DEV_CONFIG_PENDING;
	743
	744	return;
	745
	746	cs_failed:
fba395ee	747	cs_error(link, last_fn, last_ret);
1da177e4 LT	748
	749	failed:
	750	btuart_release(link);
	751	}
	752
	753
fba395ee	754	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	755	{
	756	btuart_info_t *info = link->priv;
	757
	758	if (link->state & DEV_PRESENT)
	759	btuart_close(info);
	760
fba395ee	761	pcmcia_disable_device(link);
1da177e4 LT	762	}
1da177e4 LT	763
279c9361 DB	764	static struct pcmcia_device_id btuart_ids[] = {
	765	/* don't use this driver. Use serial_cs + hci_uart instead */
	766	PCMCIA_DEVICE_NULL
	767	};
	768	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	769
1da177e4 LT	770	static struct pcmcia_driver btuart_driver = {
	771	.owner = THIS_MODULE,
	772	.drv = {
	773	.name = "btuart_cs",
	774	},
f8cfa618	775	.probe = btuart_attach,
cc3b4866	776	.remove = btuart_detach,
279c9361	777	.id_table = btuart_ids,
1da177e4 LT	778	};
	779
	780	static int __init init_btuart_cs(void)
	781	{
	782	return pcmcia_register_driver(&btuart_driver);
	783	}
	784
	785
	786	static void __exit exit_btuart_cs(void)
	787	{
	788	pcmcia_unregister_driver(&btuart_driver);
1da177e4 LT	789	}
	790
	791	module_init(init_btuart_cs);
	792	module_exit(exit_btuart_cs);