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

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

#include <linux/module.h>

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

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


typedef struct btuart_info_t {
	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;
} 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 {
		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;

		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->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;
			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) {

			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)
{
	btuart_info_t *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(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->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)
{
	btuart_info_t *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)
{
	btuart_info_t *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(btuart_info_t *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(btuart_info_t *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)
{
	btuart_info_t *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)
{
	btuart_info_t *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)
{
	btuart_info_t *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
	65	typedef struct btuart_info_t {
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;
	78	} btuart_info_t;
	79
	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
	130	static void btuart_write_wakeup(btuart_info_t *info)
	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;
	151
	152	if (!(skb = skb_dequeue(&(info->txq))))
	153	break;
	154
	155	/* Send frame */
	156	len = btuart_write(iobase, 16, skb->data, skb->len);
	157	set_bit(XMIT_WAKEUP, &(info->tx_state));
	158
	159	if (len == skb->len) {
	160	kfree_skb(skb);
	161	} else {
	162	skb_pull(skb, len);
	163	skb_queue_head(&(info->txq), skb);
	164	}
	165
	166	info->hdev->stat.byte_tx += len;
	167
	168	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	169
	170	clear_bit(XMIT_SENDING, &(info->tx_state));
	171	}
	172
	173
	174	static void btuart_receive(btuart_info_t *info)
	175	{
	176	unsigned int iobase;
	177	int boguscount = 0;
	178
	179	if (!info) {
	180	BT_ERR("Unknown device");
	181	return;
	182	}
	183
9a017a91	184	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	185
	186	do {
	187	info->hdev->stat.byte_rx++;
	188
	189	/* Allocate packet */
	190	if (info->rx_skb == NULL) {
	191	info->rx_state = RECV_WAIT_PACKET_TYPE;
	192	info->rx_count = 0;
	193	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	194	BT_ERR("Can't allocate mem for new packet");
	195	return;
	196	}
	197	}
	198
	199	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	200
0d48d939	201	bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
1da177e4	202
0d48d939	203	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	204
	205	case HCI_EVENT_PKT:
	206	info->rx_state = RECV_WAIT_EVENT_HEADER;
	207	info->rx_count = HCI_EVENT_HDR_SIZE;
	208	break;
	209
	210	case HCI_ACLDATA_PKT:
	211	info->rx_state = RECV_WAIT_ACL_HEADER;
	212	info->rx_count = HCI_ACL_HDR_SIZE;
	213	break;
	214
	215	case HCI_SCODATA_PKT:
	216	info->rx_state = RECV_WAIT_SCO_HEADER;
	217	info->rx_count = HCI_SCO_HDR_SIZE;
	218	break;
	219
	220	default:
	221	/* Unknown packet */
0d48d939	222	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	223	info->hdev->stat.err_rx++;
	224	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	225
	226	kfree_skb(info->rx_skb);
	227	info->rx_skb = NULL;
	228	break;
	229
	230	}
	231
	232	} else {
	233
	234	*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
	235	info->rx_count--;
	236
	237	if (info->rx_count == 0) {
	238
	239	int dlen;
	240	struct hci_event_hdr *eh;
	241	struct hci_acl_hdr *ah;
	242	struct hci_sco_hdr *sh;
	243
	244
	245	switch (info->rx_state) {
	246
	247	case RECV_WAIT_EVENT_HEADER:
2a123b86	248	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	249	info->rx_state = RECV_WAIT_DATA;
	250	info->rx_count = eh->plen;
	251	break;
	252
	253	case RECV_WAIT_ACL_HEADER:
2a123b86	254	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	255	dlen = __le16_to_cpu(ah->dlen);
	256	info->rx_state = RECV_WAIT_DATA;
	257	info->rx_count = dlen;
	258	break;
	259
	260	case RECV_WAIT_SCO_HEADER:
2a123b86	261	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	262	info->rx_state = RECV_WAIT_DATA;
	263	info->rx_count = sh->dlen;
	264	break;
	265
	266	case RECV_WAIT_DATA:
e1a26170	267	hci_recv_frame(info->hdev, info->rx_skb);
1da177e4 LT	268	info->rx_skb = NULL;
	269	break;
	270
	271	}
	272
	273	}
	274
	275	}
	276
	277	/* Make sure we don't stay here too long */
	278	if (boguscount++ > 16)
	279	break;
	280
	281	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
	282	}
	283
	284
7d12e780	285	static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
1da177e4 LT	286	{
	287	btuart_info_t *info = dev_inst;
	288	unsigned int iobase;
	289	int boguscount = 0;
	290	int iir, lsr;
aafcf998	291	irqreturn_t r = IRQ_NONE;
1da177e4	292
7427847d MF	293	if (!info \|\| !info->hdev)
	294	/* our irq handler is shared */
	295	return IRQ_NONE;
1da177e4	296
9a017a91	297	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	298
	299	spin_lock(&(info->lock));
	300
	301	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	302	while (iir) {
aafcf998	303	r = IRQ_HANDLED;
1da177e4 LT	304
	305	/* Clear interrupt */
	306	lsr = inb(iobase + UART_LSR);
	307
	308	switch (iir) {
	309	case UART_IIR_RLSI:
	310	BT_ERR("RLSI");
	311	break;
	312	case UART_IIR_RDI:
	313	/* Receive interrupt */
	314	btuart_receive(info);
	315	break;
	316	case UART_IIR_THRI:
	317	if (lsr & UART_LSR_THRE) {
	318	/* Transmitter ready for data */
	319	btuart_write_wakeup(info);
	320	}
	321	break;
	322	default:
	323	BT_ERR("Unhandled IIR=%#x", iir);
	324	break;
	325	}
	326
	327	/* Make sure we don't stay here too long */
	328	if (boguscount++ > 100)
	329	break;
	330
	331	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	332
	333	}
	334
	335	spin_unlock(&(info->lock));
	336
aafcf998	337	return r;
1da177e4 LT	338	}
	339
	340
	341	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	342	{
	343	unsigned long flags;
	344	unsigned int iobase;
	345	int fcr; /* FIFO control reg */
	346	int lcr; /* Line control reg */
	347	int divisor;
	348
	349	if (!info) {
	350	BT_ERR("Unknown device");
	351	return;
	352	}
	353
9a017a91	354	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	355
	356	spin_lock_irqsave(&(info->lock), flags);
	357
	358	/* Turn off interrupts */
	359	outb(0, iobase + UART_IER);
	360
	361	divisor = SPEED_MAX / speed;
	362
	363	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	364
	365	/*
	366	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	367	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	368	* about this timeout since it will always be fast enough.
	369	*/
	370
	371	if (speed < 38400)
	372	fcr \|= UART_FCR_TRIGGER_1;
	373	else
	374	fcr \|= UART_FCR_TRIGGER_14;
	375
	376	/* Bluetooth cards use 8N1 */
	377	lcr = UART_LCR_WLEN8;
	378
	379	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	380	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	381	outb(divisor >> 8, iobase + UART_DLM);
	382	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	383	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	384
b92b1c57	385	/* Turn on interrupts */
1da177e4 LT	386	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	387
	388	spin_unlock_irqrestore(&(info->lock), flags);
	389	}
	390
	391
	392
	393	/* ======================== HCI interface ======================== */
	394
	395
	396	static int btuart_hci_flush(struct hci_dev *hdev)
	397	{
155961e8	398	btuart_info_t *info = hci_get_drvdata(hdev);
1da177e4 LT	399
	400	/* Drop TX queue */
	401	skb_queue_purge(&(info->txq));
	402
	403	return 0;
	404	}
	405
	406
	407	static int btuart_hci_open(struct hci_dev *hdev)
	408	{
	409	set_bit(HCI_RUNNING, &(hdev->flags));
	410
	411	return 0;
	412	}
	413
	414
	415	static int btuart_hci_close(struct hci_dev *hdev)
	416	{
	417	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	418	return 0;
	419
	420	btuart_hci_flush(hdev);
	421
	422	return 0;
	423	}
	424
	425
7bd8f09f	426	static int btuart_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	427	{
6b5924bf	428	btuart_info_t *info = hci_get_drvdata(hdev);
1da177e4	429
0d48d939	430	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	431	case HCI_COMMAND_PKT:
	432	hdev->stat.cmd_tx++;
	433	break;
	434	case HCI_ACLDATA_PKT:
	435	hdev->stat.acl_tx++;
	436	break;
	437	case HCI_SCODATA_PKT:
	438	hdev->stat.sco_tx++;
	439	break;
5ad77795	440	}
1da177e4 LT	441
1da177e4 LT	442	/* Prepend skb with frame type */
0d48d939	443	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	444	skb_queue_tail(&(info->txq), skb);
	445
	446	btuart_write_wakeup(info);
	447
	448	return 0;
	449	}
	450
	451
1da177e4 LT	452
	453	/* ======================== Card services HCI interaction ======================== */
	454
	455
	456	static int btuart_open(btuart_info_t *info)
	457	{
	458	unsigned long flags;
9a017a91	459	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	460	struct hci_dev *hdev;
	461
	462	spin_lock_init(&(info->lock));
	463
	464	skb_queue_head_init(&(info->txq));
	465
	466	info->rx_state = RECV_WAIT_PACKET_TYPE;
	467	info->rx_count = 0;
	468	info->rx_skb = NULL;
	469
	470	/* Initialize HCI device */
	471	hdev = hci_alloc_dev();
	472	if (!hdev) {
	473	BT_ERR("Can't allocate HCI device");
	474	return -ENOMEM;
	475	}
	476
	477	info->hdev = hdev;
	478
c13854ce	479	hdev->bus = HCI_PCCARD;
155961e8	480	hci_set_drvdata(hdev, info);
27d35284	481	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	482
71f39030 MH	483	hdev->open = btuart_hci_open;
	484	hdev->close = btuart_hci_close;
	485	hdev->flush = btuart_hci_flush;
	486	hdev->send = btuart_hci_send_frame;
1da177e4	487
1da177e4 LT	488	spin_lock_irqsave(&(info->lock), flags);
	489
	490	/* Reset UART */
	491	outb(0, iobase + UART_MCR);
	492
	493	/* Turn off interrupts */
	494	outb(0, iobase + UART_IER);
	495
	496	/* Initialize UART */
	497	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	498	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	499
	500	/* Turn on interrupts */
	501	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	502
	503	spin_unlock_irqrestore(&(info->lock), flags);
	504
	505	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	506
	507	/* Timeout before it is safe to send the first HCI packet */
	508	msleep(1000);
	509
	510	/* Register HCI device */
	511	if (hci_register_dev(hdev) < 0) {
	512	BT_ERR("Can't register HCI device");
	513	info->hdev = NULL;
	514	hci_free_dev(hdev);
	515	return -ENODEV;
	516	}
	517
	518	return 0;
	519	}
	520
	521
	522	static int btuart_close(btuart_info_t *info)
	523	{
	524	unsigned long flags;
9a017a91	525	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	526	struct hci_dev *hdev = info->hdev;
	527
	528	if (!hdev)
	529	return -ENODEV;
	530
	531	btuart_hci_close(hdev);
	532
	533	spin_lock_irqsave(&(info->lock), flags);
	534
	535	/* Reset UART */
	536	outb(0, iobase + UART_MCR);
	537
	538	/* Turn off interrupts */
	539	outb(0, iobase + UART_IER);
	540
	541	spin_unlock_irqrestore(&(info->lock), flags);
	542
13ea4015	543	hci_unregister_dev(hdev);
1da177e4 LT	544	hci_free_dev(hdev);
	545
	546	return 0;
	547	}
	548
15b99ac1	549	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	550	{
1da177e4 LT	551	btuart_info_t *info;
1da177e4 LT	552
1da177e4 LT	553	/* Create new info device */
fdefa118	554	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	555	if (!info)
f8cfa618	556	return -ENOMEM;
1da177e4	557
fba395ee	558	info->p_dev = link;
1da177e4 LT	559	link->priv = info;
1da177e4 LT	560
00990e7c DB	561	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	562	CONF_AUTO_SET_IO;
1da177e4	563
15b99ac1	564	return btuart_config(link);
1da177e4 LT	565	}
	566
	567
fba395ee	568	static void btuart_detach(struct pcmcia_device *link)
1da177e4	569	{
e2d40963	570	btuart_release(link);
1da177e4 LT	571	}
1da177e4 LT	572
00990e7c	573	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	574	{
ad913c11	575	int *try = priv_data;
90abdc3b	576
510df251	577	if (!try)
00990e7c DB	578	p_dev->io_lines = 16;
	579
	580	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	581	return -EINVAL;
	582
	583	p_dev->resource[0]->end = 8;
	584	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	585	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	586
	587	return pcmcia_request_io(p_dev);
1da177e4 LT	588	}
1da177e4 LT	589
ed58872a	590	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	591	void *priv_data)
1da177e4	592	{
ed58872a DB	593	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	594	int j;
	595
00990e7c DB	596	if (p_dev->io_lines > 3)
	597	return -ENODEV;
	598
	599	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	600	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	601	p_dev->resource[0]->end = 8;
	602
	603	for (j = 0; j < 5; j++) {
	604	p_dev->resource[0]->start = base[j];
	605	p_dev->io_lines = base[j] ? 16 : 3;
	606	if (!pcmcia_request_io(p_dev))
	607	return 0;
ed58872a DB	608	}
ed58872a DB	609	return -ENODEV;
1da177e4 LT	610	}
1da177e4 LT	611
15b99ac1	612	static int btuart_config(struct pcmcia_device *link)
1da177e4	613	{
1da177e4	614	btuart_info_t *info = link->priv;
ed58872a	615	int i;
ad913c11	616	int try;
ed58872a DB	617
	618	/* First pass: look for a config entry that looks normal.
	619	Two tries: without IO aliases, then with aliases */
	620	for (try = 0; try < 2; try++)
ad913c11	621	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	622	goto found_port;
1da177e4 LT	623
	624	/* Second pass: try to find an entry that isn't picky about
	625	its base address, then try to grab any standard serial port
	626	address, and finally try to get any free port. */
ed58872a DB	627	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	628	goto found_port;
1da177e4	629
ed58872a	630	BT_ERR("No usable port range found");
ed58872a	631	goto failed;
1da177e4	632
ed58872a	633	found_port:
eb14120f	634	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	635	if (i != 0)
eb14120f	636	goto failed;
1da177e4	637
1ac71e5a	638	i = pcmcia_enable_device(link);
9ac3e58c	639	if (i != 0)
1da177e4	640	goto failed;
1da177e4 LT	641
	642	if (btuart_open(info) != 0)
	643	goto failed;
	644
15b99ac1	645	return 0;
1da177e4	646
1da177e4 LT	647	failed:
1da177e4 LT	648	btuart_release(link);
15b99ac1	649	return -ENODEV;
1da177e4 LT	650	}
	651
	652
fba395ee	653	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	654	{
	655	btuart_info_t *info = link->priv;
	656
e2d40963	657	btuart_close(info);
1da177e4	658
fba395ee	659	pcmcia_disable_device(link);
1da177e4 LT	660	}
1da177e4 LT	661
25f8f54f	662	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	663	/* don't use this driver. Use serial_cs + hci_uart instead */
	664	PCMCIA_DEVICE_NULL
	665	};
	666	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	667
1da177e4 LT	668	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	669	.owner = THIS_MODULE,
2e9b981a	670	.name = "btuart_cs",
15b99ac1	671	.probe = btuart_probe,
cc3b4866	672	.remove = btuart_detach,
279c9361	673	.id_table = btuart_ids,
1da177e4	674	};
e0c005f4	675	module_pcmcia_driver(btuart_driver);