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

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

#include <linux/module.h>

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

#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/bitops.h>
#include <linux/io.h>

#include <pcmcia/cistpl.h>
#include <pcmcia/ciscode.h>
#include <pcmcia/ds.h>
#include <pcmcia/cisreg.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>


/* ======================== Module parameters ======================== */


MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
MODULE_LICENSE("GPL");


/* ======================== Local structures ======================== */


struct btuart_info {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;	/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

	unsigned long rx_state;
	unsigned long rx_count;
	struct sk_buff *rx_skb;
};


static int btuart_config(struct pcmcia_device *link);
static void btuart_release(struct pcmcia_device *link);

static void btuart_detach(struct pcmcia_device *p_dev);


/* Maximum baud rate */
#define SPEED_MAX  115200

/* Default baud rate: 57600, 115200, 230400 or 460800 */
#define DEFAULT_BAUD_RATE  115200


/* Transmit states  */
#define XMIT_SENDING	1
#define XMIT_WAKEUP	2
#define XMIT_WAITING	8

/* Receiver states */
#define RECV_WAIT_PACKET_TYPE	0
#define RECV_WAIT_EVENT_HEADER	1
#define RECV_WAIT_ACL_HEADER	2
#define RECV_WAIT_SCO_HEADER	3
#define RECV_WAIT_DATA		4


/* ======================== Interrupt handling ======================== */


static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
{
	int actual = 0;

	/* Tx FIFO should be empty */
	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
		return 0;

	/* Fill FIFO with current frame */
	while ((fifo_size-- > 0) && (actual < len)) {
		/* Transmit next byte */
		outb(buf[actual], iobase + UART_TX);
		actual++;
	}

	return actual;
}


static void btuart_write_wakeup(struct btuart_info *info)
{
	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
		set_bit(XMIT_WAKEUP, &(info->tx_state));
		return;
	}

	do {
		unsigned int iobase = info->p_dev->resource[0]->start;
		register struct sk_buff *skb;
		int len;

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

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

		skb = skb_dequeue(&(info->txq));
		if (!skb)
			break;

		/* Send frame */
		len = btuart_write(iobase, 16, skb->data, skb->len);
		set_bit(XMIT_WAKEUP, &(info->tx_state));

		if (len == skb->len) {
			kfree_skb(skb);
		} else {
			skb_pull(skb, len);
			skb_queue_head(&(info->txq), skb);
		}

		info->hdev->stat.byte_tx += len;

	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));

	clear_bit(XMIT_SENDING, &(info->tx_state));
}


static void btuart_receive(struct btuart_info *info)
{
	unsigned int iobase;
	int boguscount = 0;

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

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

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

		/* Allocate packet */
		if (!info->rx_skb) {
			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++;

				kfree_skb(info->rx_skb);
				info->rx_skb = NULL;
				break;

			}

		} else {

			*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
			info->rx_count--;

			if (info->rx_count == 0) {

				int dlen;
				struct hci_event_hdr *eh;
				struct hci_acl_hdr *ah;
				struct hci_sco_hdr *sh;


				switch (info->rx_state) {

				case RECV_WAIT_EVENT_HEADER:
					eh = hci_event_hdr(info->rx_skb);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

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

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

				case RECV_WAIT_DATA:
					hci_recv_frame(info->hdev, info->rx_skb);
					info->rx_skb = NULL;
					break;

				}

			}

		}

		/* Make sure we don't stay here too long */
		if (boguscount++ > 16)
			break;

	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
}


static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
{
	struct btuart_info *info = dev_inst;
	unsigned int iobase;
	int boguscount = 0;
	int iir, lsr;
	irqreturn_t r = IRQ_NONE;

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

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

	spin_lock(&(info->lock));

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

		/* Clear interrupt */
		lsr = inb(iobase + UART_LSR);

		switch (iir) {
		case UART_IIR_RLSI:
			BT_ERR("RLSI");
			break;
		case UART_IIR_RDI:
			/* Receive interrupt */
			btuart_receive(info);
			break;
		case UART_IIR_THRI:
			if (lsr & UART_LSR_THRE) {
				/* Transmitter ready for data */
				btuart_write_wakeup(info);
			}
			break;
		default:
			BT_ERR("Unhandled IIR=%#x", iir);
			break;
		}

		/* Make sure we don't stay here too long */
		if (boguscount++ > 100)
			break;

		iir = inb(iobase + UART_IIR) & UART_IIR_ID;

	}

	spin_unlock(&(info->lock));

	return r;
}


static void btuart_change_speed(struct btuart_info *info,
				unsigned int speed)
{
	unsigned long flags;
	unsigned int iobase;
	int fcr;		/* FIFO control reg */
	int lcr;		/* Line control reg */
	int divisor;

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

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

	spin_lock_irqsave(&(info->lock), flags);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	divisor = SPEED_MAX / speed;

	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;

	/* 
	 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	 * about this timeout since it will always be fast enough. 
	 */

	if (speed < 38400)
		fcr |= UART_FCR_TRIGGER_1;
	else
		fcr |= UART_FCR_TRIGGER_14;

	/* Bluetooth cards use 8N1 */
	lcr = UART_LCR_WLEN8;

	outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);	/* Set DLAB */
	outb(divisor & 0xff, iobase + UART_DLL);	/* Set speed */
	outb(divisor >> 8, iobase + UART_DLM);
	outb(lcr, iobase + UART_LCR);	/* Set 8N1  */
	outb(fcr, iobase + UART_FCR);	/* Enable FIFO's */

	/* Turn on interrupts */
	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);
}


/* ======================== HCI interface ======================== */


static int btuart_hci_flush(struct hci_dev *hdev)
{
	struct btuart_info *info = hci_get_drvdata(hdev);

	/* Drop TX queue */
	skb_queue_purge(&(info->txq));

	return 0;
}


static int btuart_hci_open(struct hci_dev *hdev)
{
	return 0;
}


static int btuart_hci_close(struct hci_dev *hdev)
{
	btuart_hci_flush(hdev);

	return 0;
}


static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct btuart_info *info = hci_get_drvdata(hdev);

	switch (bt_cb(skb)->pkt_type) {
	case HCI_COMMAND_PKT:
		hdev->stat.cmd_tx++;
		break;
	case HCI_ACLDATA_PKT:
		hdev->stat.acl_tx++;
		break;
	case HCI_SCODATA_PKT:
		hdev->stat.sco_tx++;
		break;
	}

	/* Prepend skb with frame type */
	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
	skb_queue_tail(&(info->txq), skb);

	btuart_write_wakeup(info);

	return 0;
}


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


static int btuart_open(struct btuart_info *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->resource[0]->start;
	struct hci_dev *hdev;

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

	info->rx_state = RECV_WAIT_PACKET_TYPE;
	info->rx_count = 0;
	info->rx_skb = NULL;

	/* Initialize HCI device */
	hdev = hci_alloc_dev();
	if (!hdev) {
		BT_ERR("Can't allocate HCI device");
		return -ENOMEM;
	}

	info->hdev = hdev;

	hdev->bus = HCI_PCCARD;
	hci_set_drvdata(hdev, info);
	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);

	hdev->open  = btuart_hci_open;
	hdev->close = btuart_hci_close;
	hdev->flush = btuart_hci_flush;
	hdev->send  = btuart_hci_send_frame;

	spin_lock_irqsave(&(info->lock), flags);

	/* Reset UART */
	outb(0, iobase + UART_MCR);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	/* Initialize UART */
	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */
	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);

	/* Turn on interrupts */
	// outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);

	btuart_change_speed(info, DEFAULT_BAUD_RATE);

	/* Timeout before it is safe to send the first HCI packet */
	msleep(1000);

	/* Register HCI device */
	if (hci_register_dev(hdev) < 0) {
		BT_ERR("Can't register HCI device");
		info->hdev = NULL;
		hci_free_dev(hdev);
		return -ENODEV;
	}

	return 0;
}


static int btuart_close(struct btuart_info *info)
{
	unsigned long flags;
	unsigned int iobase = info->p_dev->resource[0]->start;
	struct hci_dev *hdev = info->hdev;

	if (!hdev)
		return -ENODEV;

	btuart_hci_close(hdev);

	spin_lock_irqsave(&(info->lock), flags);

	/* Reset UART */
	outb(0, iobase + UART_MCR);

	/* Turn off interrupts */
	outb(0, iobase + UART_IER);

	spin_unlock_irqrestore(&(info->lock), flags);

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

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

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

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

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

	return btuart_config(link);
}


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

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

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

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

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

	return pcmcia_request_io(p_dev);
}

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

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

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

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

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

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

	/* Second pass: try to find an entry that isn't picky about
	   its base address, then try to grab any standard serial port
	   address, and finally try to get any free port. */
	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
		goto found_port;

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

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

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

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

	return 0;

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


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

	btuart_close(info);

	pcmcia_disable_device(link);
}

static const struct pcmcia_device_id btuart_ids[] = {
	/* don't use this driver. Use serial_cs + hci_uart instead */
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, btuart_ids);

static struct pcmcia_driver btuart_driver = {
	.owner		= THIS_MODULE,
	.name		= "btuart_cs",
	.probe		= btuart_probe,
	.remove		= btuart_detach,
	.id_table	= btuart_ids,
};
module_pcmcia_driver(btuart_driver);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for Bluetooth PCMCIA cards with HCI UART interface
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	*
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation;
	11	*
	12	* Software distributed under the License is distributed on an "AS
	13	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	14	* implied. See the License for the specific language governing
	15	* rights and limitations under the License.
	16	*
	17	* The initial developer of the original code is David A. Hinds
	18	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	19	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	20	*
	21	*/
	22
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/kernel.h>
	26	#include <linux/init.h>
	27	#include <linux/slab.h>
	28	#include <linux/types.h>
1da177e4 LT	29	#include <linux/delay.h>
	30	#include <linux/errno.h>
	31	#include <linux/ptrace.h>
	32	#include <linux/ioport.h>
	33	#include <linux/spinlock.h>
	34	#include <linux/moduleparam.h>
	35
	36	#include <linux/skbuff.h>
	37	#include <linux/string.h>
	38	#include <linux/serial.h>
	39	#include <linux/serial_reg.h>
	40	#include <linux/bitops.h>
239ede3c	41	#include <linux/io.h>
1da177e4	42
1da177e4 LT	43	#include <pcmcia/cistpl.h>
	44	#include <pcmcia/ciscode.h>
	45	#include <pcmcia/ds.h>
	46	#include <pcmcia/cisreg.h>
	47
	48	#include <net/bluetooth/bluetooth.h>
	49	#include <net/bluetooth/hci_core.h>
	50
	51
	52
	53	/* ======================== Module parameters ======================== */
	54
	55
	56	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	57	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	58	MODULE_LICENSE("GPL");
	59
	60
	61
	62	/* ======================== Local structures ======================== */
	63
	64
ad709d48	65	struct btuart_info {
fd238232	66	struct pcmcia_device *p_dev;
1da177e4 LT	67
	68	struct hci_dev *hdev;
	69
	70	spinlock_t lock; /* For serializing operations */
	71
	72	struct sk_buff_head txq;
	73	unsigned long tx_state;
	74
	75	unsigned long rx_state;
	76	unsigned long rx_count;
	77	struct sk_buff *rx_skb;
ad709d48	78	};
1da177e4 LT	79
1da177e4 LT	80
15b99ac1	81	static int btuart_config(struct pcmcia_device *link);
fba395ee	82	static void btuart_release(struct pcmcia_device *link);
1da177e4	83
cc3b4866	84	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	85
1da177e4 LT	86
	87	/* Maximum baud rate */
	88	#define SPEED_MAX 115200
	89
	90	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	91	#define DEFAULT_BAUD_RATE 115200
	92
	93
	94	/* Transmit states */
	95	#define XMIT_SENDING 1
	96	#define XMIT_WAKEUP 2
	97	#define XMIT_WAITING 8
	98
	99	/* Receiver states */
	100	#define RECV_WAIT_PACKET_TYPE 0
	101	#define RECV_WAIT_EVENT_HEADER 1
	102	#define RECV_WAIT_ACL_HEADER 2
	103	#define RECV_WAIT_SCO_HEADER 3
	104	#define RECV_WAIT_DATA 4
	105
	106
	107
	108	/* ======================== Interrupt handling ======================== */
	109
	110
	111	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	112	{
	113	int actual = 0;
	114
	115	/* Tx FIFO should be empty */
	116	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	117	return 0;
	118
	119	/* Fill FIFO with current frame */
	120	while ((fifo_size-- > 0) && (actual < len)) {
	121	/* Transmit next byte */
	122	outb(buf[actual], iobase + UART_TX);
	123	actual++;
	124	}
	125
	126	return actual;
	127	}
	128
	129
ad709d48	130	static void btuart_write_wakeup(struct btuart_info *info)
1da177e4 LT	131	{
	132	if (!info) {
	133	BT_ERR("Unknown device");
	134	return;
	135	}
	136
	137	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	138	set_bit(XMIT_WAKEUP, &(info->tx_state));
	139	return;
	140	}
	141
	142	do {
fc5fef61	143	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4	144	register struct sk_buff *skb;
fc5fef61	145	int len;
1da177e4 LT	146
	147	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	148
e2d40963	149	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	150	return;
1da177e4 LT	151
a08b15e6 VI	152	skb = skb_dequeue(&(info->txq));
a08b15e6 VI	153	if (!skb)
1da177e4 LT	154	break;
	155
	156	/* Send frame */
	157	len = btuart_write(iobase, 16, skb->data, skb->len);
	158	set_bit(XMIT_WAKEUP, &(info->tx_state));
	159
	160	if (len == skb->len) {
	161	kfree_skb(skb);
	162	} else {
	163	skb_pull(skb, len);
	164	skb_queue_head(&(info->txq), skb);
	165	}
	166
	167	info->hdev->stat.byte_tx += len;
	168
	169	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	170
	171	clear_bit(XMIT_SENDING, &(info->tx_state));
	172	}
	173
	174
ad709d48	175	static void btuart_receive(struct btuart_info *info)
1da177e4 LT	176	{
	177	unsigned int iobase;
	178	int boguscount = 0;
	179
	180	if (!info) {
	181	BT_ERR("Unknown device");
	182	return;
	183	}
	184
9a017a91	185	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	186
	187	do {
	188	info->hdev->stat.byte_rx++;
	189
	190	/* Allocate packet */
05bd7762	191	if (!info->rx_skb) {
1da177e4 LT	192	info->rx_state = RECV_WAIT_PACKET_TYPE;
1da177e4 LT	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	225	info->hdev->stat.err_rx++;
1da177e4 LT	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:
e1a26170	268	hci_recv_frame(info->hdev, info->rx_skb);
1da177e4 LT	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	287	{
ad709d48	288	struct btuart_info *info = dev_inst;
1da177e4 LT	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
ad709d48 HS	342	static void btuart_change_speed(struct btuart_info *info,
ad709d48 HS	343	unsigned int speed)
1da177e4 LT	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	{
ad709d48	400	struct btuart_info *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	{
1da177e4 LT	411	return 0;
	412	}
	413
	414
	415	static int btuart_hci_close(struct hci_dev *hdev)
	416	{
1da177e4 LT	417	btuart_hci_flush(hdev);
	418
	419	return 0;
	420	}
	421
	422
7bd8f09f	423	static int btuart_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	424	{
ad709d48	425	struct btuart_info *info = hci_get_drvdata(hdev);
1da177e4	426
0d48d939	427	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	428	case HCI_COMMAND_PKT:
	429	hdev->stat.cmd_tx++;
	430	break;
	431	case HCI_ACLDATA_PKT:
	432	hdev->stat.acl_tx++;
	433	break;
	434	case HCI_SCODATA_PKT:
	435	hdev->stat.sco_tx++;
	436	break;
5ad77795	437	}
1da177e4 LT	438
1da177e4 LT	439	/* Prepend skb with frame type */
0d48d939	440	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	441	skb_queue_tail(&(info->txq), skb);
	442
	443	btuart_write_wakeup(info);
	444
	445	return 0;
	446	}
	447
	448
1da177e4 LT	449
	450	/* ======================== Card services HCI interaction ======================== */
	451
	452
ad709d48	453	static int btuart_open(struct btuart_info *info)
1da177e4 LT	454	{
1da177e4 LT	455	unsigned long flags;
9a017a91	456	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	457	struct hci_dev *hdev;
	458
	459	spin_lock_init(&(info->lock));
	460
	461	skb_queue_head_init(&(info->txq));
	462
	463	info->rx_state = RECV_WAIT_PACKET_TYPE;
	464	info->rx_count = 0;
	465	info->rx_skb = NULL;
	466
	467	/* Initialize HCI device */
	468	hdev = hci_alloc_dev();
	469	if (!hdev) {
	470	BT_ERR("Can't allocate HCI device");
	471	return -ENOMEM;
	472	}
	473
	474	info->hdev = hdev;
	475
c13854ce	476	hdev->bus = HCI_PCCARD;
155961e8	477	hci_set_drvdata(hdev, info);
27d35284	478	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	479
71f39030 MH	480	hdev->open = btuart_hci_open;
	481	hdev->close = btuart_hci_close;
	482	hdev->flush = btuart_hci_flush;
	483	hdev->send = btuart_hci_send_frame;
1da177e4	484
1da177e4 LT	485	spin_lock_irqsave(&(info->lock), flags);
	486
	487	/* Reset UART */
	488	outb(0, iobase + UART_MCR);
	489
	490	/* Turn off interrupts */
	491	outb(0, iobase + UART_IER);
	492
	493	/* Initialize UART */
	494	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	495	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	496
	497	/* Turn on interrupts */
	498	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	499
	500	spin_unlock_irqrestore(&(info->lock), flags);
	501
	502	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	503
	504	/* Timeout before it is safe to send the first HCI packet */
	505	msleep(1000);
	506
	507	/* Register HCI device */
	508	if (hci_register_dev(hdev) < 0) {
	509	BT_ERR("Can't register HCI device");
	510	info->hdev = NULL;
	511	hci_free_dev(hdev);
	512	return -ENODEV;
	513	}
	514
	515	return 0;
	516	}
	517
	518
ad709d48	519	static int btuart_close(struct btuart_info *info)
1da177e4 LT	520	{
1da177e4 LT	521	unsigned long flags;
9a017a91	522	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	523	struct hci_dev *hdev = info->hdev;
	524
	525	if (!hdev)
	526	return -ENODEV;
	527
	528	btuart_hci_close(hdev);
	529
	530	spin_lock_irqsave(&(info->lock), flags);
	531
	532	/* Reset UART */
	533	outb(0, iobase + UART_MCR);
	534
	535	/* Turn off interrupts */
	536	outb(0, iobase + UART_IER);
	537
	538	spin_unlock_irqrestore(&(info->lock), flags);
	539
13ea4015	540	hci_unregister_dev(hdev);
1da177e4 LT	541	hci_free_dev(hdev);
	542
	543	return 0;
	544	}
	545
15b99ac1	546	static int btuart_probe(struct pcmcia_device *link)
1da177e4	547	{
ad709d48	548	struct btuart_info *info;
1da177e4 LT	549
1da177e4 LT	550	/* Create new info device */
fdefa118	551	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	552	if (!info)
f8cfa618	553	return -ENOMEM;
1da177e4	554
fba395ee	555	info->p_dev = link;
1da177e4 LT	556	link->priv = info;
1da177e4 LT	557
00990e7c DB	558	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	559	CONF_AUTO_SET_IO;
1da177e4	560
15b99ac1	561	return btuart_config(link);
1da177e4 LT	562	}
	563
	564
fba395ee	565	static void btuart_detach(struct pcmcia_device *link)
1da177e4	566	{
e2d40963	567	btuart_release(link);
1da177e4 LT	568	}
1da177e4 LT	569
00990e7c	570	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	571	{
ad913c11	572	int *try = priv_data;
90abdc3b	573
510df251	574	if (!try)
00990e7c DB	575	p_dev->io_lines = 16;
	576
	577	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	578	return -EINVAL;
	579
	580	p_dev->resource[0]->end = 8;
	581	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	582	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	583
	584	return pcmcia_request_io(p_dev);
1da177e4 LT	585	}
1da177e4 LT	586
ed58872a	587	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	588	void *priv_data)
1da177e4	589	{
ed58872a DB	590	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	591	int j;
	592
00990e7c DB	593	if (p_dev->io_lines > 3)
	594	return -ENODEV;
	595
	596	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	597	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	598	p_dev->resource[0]->end = 8;
	599
	600	for (j = 0; j < 5; j++) {
	601	p_dev->resource[0]->start = base[j];
	602	p_dev->io_lines = base[j] ? 16 : 3;
	603	if (!pcmcia_request_io(p_dev))
	604	return 0;
ed58872a DB	605	}
ed58872a DB	606	return -ENODEV;
1da177e4 LT	607	}
1da177e4 LT	608
15b99ac1	609	static int btuart_config(struct pcmcia_device *link)
1da177e4	610	{
ad709d48	611	struct btuart_info *info = link->priv;
ed58872a	612	int i;
ad913c11	613	int try;
ed58872a DB	614
	615	/* First pass: look for a config entry that looks normal.
	616	Two tries: without IO aliases, then with aliases */
	617	for (try = 0; try < 2; try++)
ad913c11	618	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	619	goto found_port;
1da177e4 LT	620
	621	/* Second pass: try to find an entry that isn't picky about
	622	its base address, then try to grab any standard serial port
	623	address, and finally try to get any free port. */
ed58872a DB	624	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	625	goto found_port;
1da177e4	626
ed58872a	627	BT_ERR("No usable port range found");
ed58872a	628	goto failed;
1da177e4	629
ed58872a	630	found_port:
eb14120f	631	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	632	if (i != 0)
eb14120f	633	goto failed;
1da177e4	634
1ac71e5a	635	i = pcmcia_enable_device(link);
9ac3e58c	636	if (i != 0)
1da177e4	637	goto failed;
1da177e4 LT	638
	639	if (btuart_open(info) != 0)
	640	goto failed;
	641
15b99ac1	642	return 0;
1da177e4	643
1da177e4 LT	644	failed:
1da177e4 LT	645	btuart_release(link);
15b99ac1	646	return -ENODEV;
1da177e4 LT	647	}
	648
	649
fba395ee	650	static void btuart_release(struct pcmcia_device *link)
1da177e4	651	{
ad709d48	652	struct btuart_info *info = link->priv;
1da177e4	653
e2d40963	654	btuart_close(info);
1da177e4	655
fba395ee	656	pcmcia_disable_device(link);
1da177e4 LT	657	}
1da177e4 LT	658
25f8f54f	659	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	660	/* don't use this driver. Use serial_cs + hci_uart instead */
	661	PCMCIA_DEVICE_NULL
	662	};
	663	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	664
1da177e4 LT	665	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	666	.owner = THIS_MODULE,
2e9b981a	667	.name = "btuart_cs",
15b99ac1	668	.probe = btuart_probe,
cc3b4866	669	.remove = btuart_detach,
279c9361	670	.id_table = btuart_ids,
1da177e4	671	};
e0c005f4	672	module_pcmcia_driver(btuart_driver);