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

/*
 *
 *  Driver for Bluetooth PCMCIA cards with HCI UART interface
 *
 *  Copyright (C) 2001-2002  Marcel Holtmann <[email protected]>
 *
 *
 *  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
 *  <[email protected]>.  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 <[email protected]>");
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;
}


static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
{
	return -ENOIOCTLCMD;
}


/* ======================== 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;
	hdev->ioctl    = btuart_hci_ioctl;

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

static int __init init_btuart_cs(void)
{
	return pcmcia_register_driver(&btuart_driver);
}


static void __exit exit_btuart_cs(void)
{
	pcmcia_unregister_driver(&btuart_driver);
}

module_init(init_btuart_cs);
module_exit(exit_btuart_cs);
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 <[email protected]>
	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	* <[email protected]>. 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 <[email protected]>");
	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	static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	462	{
	463	return -ENOIOCTLCMD;
	464	}
	465
	466
	467
	468	/* ======================== Card services HCI interaction ======================== */
	469
	470
	471	static int btuart_open(btuart_info_t *info)
	472	{
	473	unsigned long flags;
9a017a91	474	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	475	struct hci_dev *hdev;
	476
	477	spin_lock_init(&(info->lock));
	478
	479	skb_queue_head_init(&(info->txq));
	480
	481	info->rx_state = RECV_WAIT_PACKET_TYPE;
	482	info->rx_count = 0;
	483	info->rx_skb = NULL;
	484
	485	/* Initialize HCI device */
	486	hdev = hci_alloc_dev();
	487	if (!hdev) {
	488	BT_ERR("Can't allocate HCI device");
	489	return -ENOMEM;
	490	}
	491
	492	info->hdev = hdev;
	493
c13854ce	494	hdev->bus = HCI_PCCARD;
155961e8	495	hci_set_drvdata(hdev, info);
27d35284	496	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	497
	498	hdev->open = btuart_hci_open;
	499	hdev->close = btuart_hci_close;
	500	hdev->flush = btuart_hci_flush;
	501	hdev->send = btuart_hci_send_frame;
1da177e4 LT	502	hdev->ioctl = btuart_hci_ioctl;
1da177e4 LT	503
1da177e4 LT	504	spin_lock_irqsave(&(info->lock), flags);
	505
	506	/* Reset UART */
	507	outb(0, iobase + UART_MCR);
	508
	509	/* Turn off interrupts */
	510	outb(0, iobase + UART_IER);
	511
	512	/* Initialize UART */
	513	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	514	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	515
	516	/* Turn on interrupts */
	517	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	518
	519	spin_unlock_irqrestore(&(info->lock), flags);
	520
	521	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	522
	523	/* Timeout before it is safe to send the first HCI packet */
	524	msleep(1000);
	525
	526	/* Register HCI device */
	527	if (hci_register_dev(hdev) < 0) {
	528	BT_ERR("Can't register HCI device");
	529	info->hdev = NULL;
	530	hci_free_dev(hdev);
	531	return -ENODEV;
	532	}
	533
	534	return 0;
	535	}
	536
	537
	538	static int btuart_close(btuart_info_t *info)
	539	{
	540	unsigned long flags;
9a017a91	541	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	542	struct hci_dev *hdev = info->hdev;
	543
	544	if (!hdev)
	545	return -ENODEV;
	546
	547	btuart_hci_close(hdev);
	548
	549	spin_lock_irqsave(&(info->lock), flags);
	550
	551	/* Reset UART */
	552	outb(0, iobase + UART_MCR);
	553
	554	/* Turn off interrupts */
	555	outb(0, iobase + UART_IER);
	556
	557	spin_unlock_irqrestore(&(info->lock), flags);
	558
13ea4015	559	hci_unregister_dev(hdev);
1da177e4 LT	560	hci_free_dev(hdev);
	561
	562	return 0;
	563	}
	564
15b99ac1	565	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	566	{
1da177e4 LT	567	btuart_info_t *info;
1da177e4 LT	568
1da177e4 LT	569	/* Create new info device */
fdefa118	570	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	571	if (!info)
f8cfa618	572	return -ENOMEM;
1da177e4	573
fba395ee	574	info->p_dev = link;
1da177e4 LT	575	link->priv = info;
1da177e4 LT	576
00990e7c DB	577	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	578	CONF_AUTO_SET_IO;
1da177e4	579
15b99ac1	580	return btuart_config(link);
1da177e4 LT	581	}
	582
	583
fba395ee	584	static void btuart_detach(struct pcmcia_device *link)
1da177e4	585	{
e2d40963	586	btuart_release(link);
1da177e4 LT	587	}
1da177e4 LT	588
00990e7c	589	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	590	{
ad913c11	591	int *try = priv_data;
90abdc3b	592
510df251	593	if (!try)
00990e7c DB	594	p_dev->io_lines = 16;
	595
	596	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	597	return -EINVAL;
	598
	599	p_dev->resource[0]->end = 8;
	600	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	601	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	602
	603	return pcmcia_request_io(p_dev);
1da177e4 LT	604	}
1da177e4 LT	605
ed58872a	606	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	607	void *priv_data)
1da177e4	608	{
ed58872a DB	609	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	610	int j;
	611
00990e7c DB	612	if (p_dev->io_lines > 3)
	613	return -ENODEV;
	614
	615	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	616	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	617	p_dev->resource[0]->end = 8;
	618
	619	for (j = 0; j < 5; j++) {
	620	p_dev->resource[0]->start = base[j];
	621	p_dev->io_lines = base[j] ? 16 : 3;
	622	if (!pcmcia_request_io(p_dev))
	623	return 0;
ed58872a DB	624	}
ed58872a DB	625	return -ENODEV;
1da177e4 LT	626	}
1da177e4 LT	627
15b99ac1	628	static int btuart_config(struct pcmcia_device *link)
1da177e4	629	{
1da177e4	630	btuart_info_t *info = link->priv;
ed58872a	631	int i;
ad913c11	632	int try;
ed58872a DB	633
	634	/* First pass: look for a config entry that looks normal.
	635	Two tries: without IO aliases, then with aliases */
	636	for (try = 0; try < 2; try++)
ad913c11	637	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	638	goto found_port;
1da177e4 LT	639
	640	/* Second pass: try to find an entry that isn't picky about
	641	its base address, then try to grab any standard serial port
	642	address, and finally try to get any free port. */
ed58872a DB	643	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	644	goto found_port;
1da177e4	645
ed58872a	646	BT_ERR("No usable port range found");
ed58872a	647	goto failed;
1da177e4	648
ed58872a	649	found_port:
eb14120f	650	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	651	if (i != 0)
eb14120f	652	goto failed;
1da177e4	653
1ac71e5a	654	i = pcmcia_enable_device(link);
9ac3e58c	655	if (i != 0)
1da177e4	656	goto failed;
1da177e4 LT	657
	658	if (btuart_open(info) != 0)
	659	goto failed;
	660
15b99ac1	661	return 0;
1da177e4	662
1da177e4 LT	663	failed:
1da177e4 LT	664	btuart_release(link);
15b99ac1	665	return -ENODEV;
1da177e4 LT	666	}
	667
	668
fba395ee	669	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	670	{
	671	btuart_info_t *info = link->priv;
	672
e2d40963	673	btuart_close(info);
1da177e4	674
fba395ee	675	pcmcia_disable_device(link);
1da177e4 LT	676	}
1da177e4 LT	677
25f8f54f	678	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	679	/* don't use this driver. Use serial_cs + hci_uart instead */
	680	PCMCIA_DEVICE_NULL
	681	};
	682	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	683
1da177e4 LT	684	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	685	.owner = THIS_MODULE,
2e9b981a	686	.name = "btuart_cs",
15b99ac1	687	.probe = btuart_probe,
cc3b4866	688	.remove = btuart_detach,
279c9361	689	.id_table = btuart_ids,
1da177e4 LT	690	};
	691
	692	static int __init init_btuart_cs(void)
	693	{
	694	return pcmcia_register_driver(&btuart_driver);
	695	}
	696
	697
	698	static void __exit exit_btuart_cs(void)
	699	{
	700	pcmcia_unregister_driver(&btuart_driver);
1da177e4 LT	701	}
	702
	703	module_init(init_btuart_cs);
	704	module_exit(exit_btuart_cs);