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

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