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

		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(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;
			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)
{
	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;
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
	175	static void btuart_receive(btuart_info_t *info)
	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 LT	288	{
	289	btuart_info_t *info = dev_inst;
	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
	343	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	344	{
	345	unsigned long flags;
	346	unsigned int iobase;
	347	int fcr; /* FIFO control reg */
	348	int lcr; /* Line control reg */
	349	int divisor;
	350
	351	if (!info) {
	352	BT_ERR("Unknown device");
	353	return;
	354	}
	355
9a017a91	356	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	357
	358	spin_lock_irqsave(&(info->lock), flags);
	359
	360	/* Turn off interrupts */
	361	outb(0, iobase + UART_IER);
	362
	363	divisor = SPEED_MAX / speed;
	364
	365	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	366
	367	/*
	368	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	369	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	370	* about this timeout since it will always be fast enough.
	371	*/
	372
	373	if (speed < 38400)
	374	fcr \|= UART_FCR_TRIGGER_1;
	375	else
	376	fcr \|= UART_FCR_TRIGGER_14;
	377
	378	/* Bluetooth cards use 8N1 */
	379	lcr = UART_LCR_WLEN8;
	380
	381	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	382	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	383	outb(divisor >> 8, iobase + UART_DLM);
	384	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	385	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	386
b92b1c57	387	/* Turn on interrupts */
1da177e4 LT	388	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	389
	390	spin_unlock_irqrestore(&(info->lock), flags);
	391	}
	392
	393
	394
	395	/* ======================== HCI interface ======================== */
	396
	397
	398	static int btuart_hci_flush(struct hci_dev *hdev)
	399	{
155961e8	400	btuart_info_t *info = hci_get_drvdata(hdev);
1da177e4 LT	401
	402	/* Drop TX queue */
	403	skb_queue_purge(&(info->txq));
	404
	405	return 0;
	406	}
	407
	408
	409	static int btuart_hci_open(struct hci_dev *hdev)
	410	{
	411	set_bit(HCI_RUNNING, &(hdev->flags));
	412
	413	return 0;
	414	}
	415
	416
	417	static int btuart_hci_close(struct hci_dev *hdev)
	418	{
	419	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	420	return 0;
	421
	422	btuart_hci_flush(hdev);
	423
	424	return 0;
	425	}
	426
	427
7bd8f09f	428	static int btuart_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	429	{
6b5924bf	430	btuart_info_t *info = hci_get_drvdata(hdev);
1da177e4	431
0d48d939	432	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	433	case HCI_COMMAND_PKT:
	434	hdev->stat.cmd_tx++;
	435	break;
	436	case HCI_ACLDATA_PKT:
	437	hdev->stat.acl_tx++;
	438	break;
	439	case HCI_SCODATA_PKT:
	440	hdev->stat.sco_tx++;
	441	break;
5ad77795	442	}
1da177e4 LT	443
1da177e4 LT	444	/* Prepend skb with frame type */
0d48d939	445	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	446	skb_queue_tail(&(info->txq), skb);
	447
	448	btuart_write_wakeup(info);
	449
	450	return 0;
	451	}
	452
	453
1da177e4 LT	454
	455	/* ======================== Card services HCI interaction ======================== */
	456
	457
	458	static int btuart_open(btuart_info_t *info)
	459	{
	460	unsigned long flags;
9a017a91	461	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	462	struct hci_dev *hdev;
	463
	464	spin_lock_init(&(info->lock));
	465
	466	skb_queue_head_init(&(info->txq));
	467
	468	info->rx_state = RECV_WAIT_PACKET_TYPE;
	469	info->rx_count = 0;
	470	info->rx_skb = NULL;
	471
	472	/* Initialize HCI device */
	473	hdev = hci_alloc_dev();
	474	if (!hdev) {
	475	BT_ERR("Can't allocate HCI device");
	476	return -ENOMEM;
	477	}
	478
	479	info->hdev = hdev;
	480
c13854ce	481	hdev->bus = HCI_PCCARD;
155961e8	482	hci_set_drvdata(hdev, info);
27d35284	483	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	484
71f39030 MH	485	hdev->open = btuart_hci_open;
	486	hdev->close = btuart_hci_close;
	487	hdev->flush = btuart_hci_flush;
	488	hdev->send = btuart_hci_send_frame;
1da177e4	489
1da177e4 LT	490	spin_lock_irqsave(&(info->lock), flags);
	491
	492	/* Reset UART */
	493	outb(0, iobase + UART_MCR);
	494
	495	/* Turn off interrupts */
	496	outb(0, iobase + UART_IER);
	497
	498	/* Initialize UART */
	499	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	500	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	501
	502	/* Turn on interrupts */
	503	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	504
	505	spin_unlock_irqrestore(&(info->lock), flags);
	506
	507	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	508
	509	/* Timeout before it is safe to send the first HCI packet */
	510	msleep(1000);
	511
	512	/* Register HCI device */
	513	if (hci_register_dev(hdev) < 0) {
	514	BT_ERR("Can't register HCI device");
	515	info->hdev = NULL;
	516	hci_free_dev(hdev);
	517	return -ENODEV;
	518	}
	519
	520	return 0;
	521	}
	522
	523
	524	static int btuart_close(btuart_info_t *info)
	525	{
	526	unsigned long flags;
9a017a91	527	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	528	struct hci_dev *hdev = info->hdev;
	529
	530	if (!hdev)
	531	return -ENODEV;
	532
	533	btuart_hci_close(hdev);
	534
	535	spin_lock_irqsave(&(info->lock), flags);
	536
	537	/* Reset UART */
	538	outb(0, iobase + UART_MCR);
	539
	540	/* Turn off interrupts */
	541	outb(0, iobase + UART_IER);
	542
	543	spin_unlock_irqrestore(&(info->lock), flags);
	544
13ea4015	545	hci_unregister_dev(hdev);
1da177e4 LT	546	hci_free_dev(hdev);
	547
	548	return 0;
	549	}
	550
15b99ac1	551	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	552	{
1da177e4 LT	553	btuart_info_t *info;
1da177e4 LT	554
1da177e4 LT	555	/* Create new info device */
fdefa118	556	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	557	if (!info)
f8cfa618	558	return -ENOMEM;
1da177e4	559
fba395ee	560	info->p_dev = link;
1da177e4 LT	561	link->priv = info;
1da177e4 LT	562
00990e7c DB	563	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	564	CONF_AUTO_SET_IO;
1da177e4	565
15b99ac1	566	return btuart_config(link);
1da177e4 LT	567	}
	568
	569
fba395ee	570	static void btuart_detach(struct pcmcia_device *link)
1da177e4	571	{
e2d40963	572	btuart_release(link);
1da177e4 LT	573	}
1da177e4 LT	574
00990e7c	575	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	576	{
ad913c11	577	int *try = priv_data;
90abdc3b	578
510df251	579	if (!try)
00990e7c DB	580	p_dev->io_lines = 16;
	581
	582	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	583	return -EINVAL;
	584
	585	p_dev->resource[0]->end = 8;
	586	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	587	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	588
	589	return pcmcia_request_io(p_dev);
1da177e4 LT	590	}
1da177e4 LT	591
ed58872a	592	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	593	void *priv_data)
1da177e4	594	{
ed58872a DB	595	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	596	int j;
	597
00990e7c DB	598	if (p_dev->io_lines > 3)
	599	return -ENODEV;
	600
	601	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	602	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	603	p_dev->resource[0]->end = 8;
	604
	605	for (j = 0; j < 5; j++) {
	606	p_dev->resource[0]->start = base[j];
	607	p_dev->io_lines = base[j] ? 16 : 3;
	608	if (!pcmcia_request_io(p_dev))
	609	return 0;
ed58872a DB	610	}
ed58872a DB	611	return -ENODEV;
1da177e4 LT	612	}
1da177e4 LT	613
15b99ac1	614	static int btuart_config(struct pcmcia_device *link)
1da177e4	615	{
1da177e4	616	btuart_info_t *info = link->priv;
ed58872a	617	int i;
ad913c11	618	int try;
ed58872a DB	619
	620	/* First pass: look for a config entry that looks normal.
	621	Two tries: without IO aliases, then with aliases */
	622	for (try = 0; try < 2; try++)
ad913c11	623	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	624	goto found_port;
1da177e4 LT	625
	626	/* Second pass: try to find an entry that isn't picky about
	627	its base address, then try to grab any standard serial port
	628	address, and finally try to get any free port. */
ed58872a DB	629	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	630	goto found_port;
1da177e4	631
ed58872a	632	BT_ERR("No usable port range found");
ed58872a	633	goto failed;
1da177e4	634
ed58872a	635	found_port:
eb14120f	636	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	637	if (i != 0)
eb14120f	638	goto failed;
1da177e4	639
1ac71e5a	640	i = pcmcia_enable_device(link);
9ac3e58c	641	if (i != 0)
1da177e4	642	goto failed;
1da177e4 LT	643
	644	if (btuart_open(info) != 0)
	645	goto failed;
	646
15b99ac1	647	return 0;
1da177e4	648
1da177e4 LT	649	failed:
1da177e4 LT	650	btuart_release(link);
15b99ac1	651	return -ENODEV;
1da177e4 LT	652	}
	653
	654
fba395ee	655	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	656	{
	657	btuart_info_t *info = link->priv;
	658
e2d40963	659	btuart_close(info);
1da177e4	660
fba395ee	661	pcmcia_disable_device(link);
1da177e4 LT	662	}
1da177e4 LT	663
25f8f54f	664	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	665	/* don't use this driver. Use serial_cs + hci_uart instead */
	666	PCMCIA_DEVICE_NULL
	667	};
	668	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	669
1da177e4 LT	670	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	671	.owner = THIS_MODULE,
2e9b981a	672	.name = "btuart_cs",
15b99ac1	673	.probe = btuart_probe,
cc3b4866	674	.remove = btuart_detach,
279c9361	675	.id_table = btuart_ids,
1da177e4	676	};
e0c005f4	677	module_pcmcia_driver(btuart_driver);