[linux-2.6-block.git] / drivers / bluetooth / btuart_cs.c

/*
 *
 *  Driver for Bluetooth PCMCIA cards with HCI UART interface
 *
 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation;
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing
 *  rights and limitations under the License.
 *
 *  The initial developer of the original code is David A. Hinds
 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 */

#include <linux/module.h>

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

#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/bitops.h>
#include <asm/io.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 ======================== */


struct btuart_info {
	struct pcmcia_device *p_dev;

	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;
};


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(struct btuart_info *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 {
		unsigned int iobase = info->p_dev->resource[0]->start;
		register struct sk_buff *skb;
		int len;

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

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

		skb = skb_dequeue(&(info->txq));
		if (!skb)
			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(struct btuart_info *info)
{
	unsigned int iobase;
	int boguscount = 0;

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

	iobase = info->p_dev->resource[0]->start;

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

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

		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			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 = hci_event_hdr(info->rx_skb);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

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

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

				case RECV_WAIT_DATA:
					hci_recv_frame(info->hdev, 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 btuart_info *info = dev_inst;
	unsigned int iobase;
	int boguscount = 0;
	int iir, lsr;
	irqreturn_t r = IRQ_NONE;

	if (!info || !info->hdev)
		/* our irq handler is shared */
		return IRQ_NONE;

	iobase = info->p_dev->resource[0]->start;

	spin_lock(&(info->lock));

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

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


static void btuart_change_speed(struct btuart_info *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->resource[0]->start;

	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 interrupts */
	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)
{
	struct btuart_info *info = hci_get_drvdata(hdev);

	/* 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 hci_dev *hdev, struct sk_buff *skb)
{
	struct btuart_info *info = hci_get_drvdata(hdev);

	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;
}


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


static int btuart_open(struct btuart_info *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->resource[0]->start;
	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->bus = HCI_PCCARD;
	hci_set_drvdata(hdev, 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;

	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(struct btuart_info *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->resource[0]->start;
	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);

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

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

	/* Create new info device */
	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

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

	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
		CONF_AUTO_SET_IO;

	return btuart_config(link);
}


static void btuart_detach(struct pcmcia_device *link)
{
	btuart_release(link);
}

static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
{
	int *try = priv_data;

	if (!try)
		p_dev->io_lines = 16;

	if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
		return -EINVAL;

	p_dev->resource[0]->end = 8;
	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;

	return pcmcia_request_io(p_dev);
}

static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
					void *priv_data)
{
	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	int j;

	if (p_dev->io_lines > 3)
		return -ENODEV;

	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
	p_dev->resource[0]->end = 8;

	for (j = 0; j < 5; j++) {
		p_dev->resource[0]->start = base[j];
		p_dev->io_lines = base[j] ? 16 : 3;
		if (!pcmcia_request_io(p_dev))
			return 0;
	}
	return -ENODEV;
}

static int btuart_config(struct pcmcia_device *link)
{
	struct btuart_info *info = link->priv;
	int i;
	int try;

	/* First pass: look for a config entry that looks normal.
	   Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++)
		if (!pcmcia_loop_config(link, btuart_check_config, &try))
			goto found_port;

	/* 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. */
	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
		goto found_port;

	BT_ERR("No usable port range found");
	goto failed;

found_port:
	i = pcmcia_request_irq(link, btuart_interrupt);
	if (i != 0)
		goto failed;

	i = pcmcia_enable_device(link);
	if (i != 0)
		goto failed;

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

	return 0;

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


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

	btuart_close(info);

	pcmcia_disable_device(link);
}

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