[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/system.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 {
		register unsigned int iobase = info->p_dev->resource[0]->start;
		register struct sk_buff *skb;
		register 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 = (btuart_info_t *)(hdev->driver_data);

	/* 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 = (btuart_info_t *)(hdev->driver_data);

	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;
	hdev->driver_data = 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 = kzalloc(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_info_t *info = link->priv;

	btuart_release(link);
	kfree(info);
}

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

	if (try == 0)
		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 <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>
	41	#include <asm/system.h>
	42	#include <asm/io.h>
	43
1da177e4 LT	44	#include <pcmcia/cistpl.h>
	45	#include <pcmcia/ciscode.h>
	46	#include <pcmcia/ds.h>
	47	#include <pcmcia/cisreg.h>
	48
	49	#include <net/bluetooth/bluetooth.h>
	50	#include <net/bluetooth/hci_core.h>
	51
	52
	53
	54	/* ======================== Module parameters ======================== */
	55
	56
	57	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	58	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	59	MODULE_LICENSE("GPL");
	60
	61
	62
	63	/* ======================== Local structures ======================== */
	64
	65
	66	typedef struct btuart_info_t {
fd238232	67	struct pcmcia_device *p_dev;
1da177e4 LT	68
	69	struct hci_dev *hdev;
	70
	71	spinlock_t lock; /* For serializing operations */
	72
	73	struct sk_buff_head txq;
	74	unsigned long tx_state;
	75
	76	unsigned long rx_state;
	77	unsigned long rx_count;
	78	struct sk_buff *rx_skb;
	79	} btuart_info_t;
	80
	81
15b99ac1	82	static int btuart_config(struct pcmcia_device *link);
fba395ee	83	static void btuart_release(struct pcmcia_device *link);
1da177e4	84
cc3b4866	85	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	86
1da177e4 LT	87
	88	/* Maximum baud rate */
	89	#define SPEED_MAX 115200
	90
	91	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	92	#define DEFAULT_BAUD_RATE 115200
	93
	94
	95	/* Transmit states */
	96	#define XMIT_SENDING 1
	97	#define XMIT_WAKEUP 2
	98	#define XMIT_WAITING 8
	99
	100	/* Receiver states */
	101	#define RECV_WAIT_PACKET_TYPE 0
	102	#define RECV_WAIT_EVENT_HEADER 1
	103	#define RECV_WAIT_ACL_HEADER 2
	104	#define RECV_WAIT_SCO_HEADER 3
	105	#define RECV_WAIT_DATA 4
	106
	107
	108
	109	/* ======================== Interrupt handling ======================== */
	110
	111
	112	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	113	{
	114	int actual = 0;
	115
	116	/* Tx FIFO should be empty */
	117	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	118	return 0;
	119
	120	/* Fill FIFO with current frame */
	121	while ((fifo_size-- > 0) && (actual < len)) {
	122	/* Transmit next byte */
	123	outb(buf[actual], iobase + UART_TX);
	124	actual++;
	125	}
	126
	127	return actual;
	128	}
	129
	130
	131	static void btuart_write_wakeup(btuart_info_t *info)
	132	{
	133	if (!info) {
	134	BT_ERR("Unknown device");
	135	return;
	136	}
	137
	138	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	139	set_bit(XMIT_WAKEUP, &(info->tx_state));
	140	return;
	141	}
	142
	143	do {
9a017a91	144	register unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	145	register struct sk_buff *skb;
	146	register int len;
	147
	148	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	149
e2d40963	150	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	151	return;
	152
	153	if (!(skb = skb_dequeue(&(info->txq))))
	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;
	194	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	195	BT_ERR("Can't allocate mem for new packet");
	196	return;
	197	}
	198	}
	199
	200	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	201
	202	info->rx_skb->dev = (void *) info->hdev;
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:
	269	hci_recv_frame(info->rx_skb);
	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	{
	400	btuart_info_t info = (btuart_info_t )(hdev->driver_data);
	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
	428	static int btuart_hci_send_frame(struct sk_buff *skb)
	429	{
	430	btuart_info_t *info;
	431	struct hci_dev hdev = (struct hci_dev )(skb->dev);
	432
	433	if (!hdev) {
	434	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
	435	return -ENODEV;
	436	}
	437
	438	info = (btuart_info_t *)(hdev->driver_data);
	439
0d48d939	440	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	441	case HCI_COMMAND_PKT:
	442	hdev->stat.cmd_tx++;
	443	break;
	444	case HCI_ACLDATA_PKT:
	445	hdev->stat.acl_tx++;
	446	break;
	447	case HCI_SCODATA_PKT:
	448	hdev->stat.sco_tx++;
	449	break;
	450	};
	451
	452	/* Prepend skb with frame type */
0d48d939	453	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	454	skb_queue_tail(&(info->txq), skb);
	455
	456	btuart_write_wakeup(info);
	457
	458	return 0;
	459	}
	460
	461
1da177e4 LT	462	static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	463	{
	464	return -ENOIOCTLCMD;
	465	}
	466
	467
	468
	469	/* ======================== Card services HCI interaction ======================== */
	470
	471
	472	static int btuart_open(btuart_info_t *info)
	473	{
	474	unsigned long flags;
9a017a91	475	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	476	struct hci_dev *hdev;
	477
	478	spin_lock_init(&(info->lock));
	479
	480	skb_queue_head_init(&(info->txq));
	481
	482	info->rx_state = RECV_WAIT_PACKET_TYPE;
	483	info->rx_count = 0;
	484	info->rx_skb = NULL;
	485
	486	/* Initialize HCI device */
	487	hdev = hci_alloc_dev();
	488	if (!hdev) {
	489	BT_ERR("Can't allocate HCI device");
	490	return -ENOMEM;
	491	}
	492
	493	info->hdev = hdev;
	494
c13854ce	495	hdev->bus = HCI_PCCARD;
1da177e4	496	hdev->driver_data = info;
27d35284	497	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	498
	499	hdev->open = btuart_hci_open;
	500	hdev->close = btuart_hci_close;
	501	hdev->flush = btuart_hci_flush;
	502	hdev->send = btuart_hci_send_frame;
1da177e4 LT	503	hdev->ioctl = btuart_hci_ioctl;
1da177e4 LT	504
1da177e4 LT	505	spin_lock_irqsave(&(info->lock), flags);
	506
	507	/* Reset UART */
	508	outb(0, iobase + UART_MCR);
	509
	510	/* Turn off interrupts */
	511	outb(0, iobase + UART_IER);
	512
	513	/* Initialize UART */
	514	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	515	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	516
	517	/* Turn on interrupts */
	518	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	519
	520	spin_unlock_irqrestore(&(info->lock), flags);
	521
	522	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	523
	524	/* Timeout before it is safe to send the first HCI packet */
	525	msleep(1000);
	526
	527	/* Register HCI device */
	528	if (hci_register_dev(hdev) < 0) {
	529	BT_ERR("Can't register HCI device");
	530	info->hdev = NULL;
	531	hci_free_dev(hdev);
	532	return -ENODEV;
	533	}
	534
	535	return 0;
	536	}
	537
	538
	539	static int btuart_close(btuart_info_t *info)
	540	{
	541	unsigned long flags;
9a017a91	542	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	543	struct hci_dev *hdev = info->hdev;
	544
	545	if (!hdev)
	546	return -ENODEV;
	547
	548	btuart_hci_close(hdev);
	549
	550	spin_lock_irqsave(&(info->lock), flags);
	551
	552	/* Reset UART */
	553	outb(0, iobase + UART_MCR);
	554
	555	/* Turn off interrupts */
	556	outb(0, iobase + UART_IER);
	557
	558	spin_unlock_irqrestore(&(info->lock), flags);
	559
13ea4015	560	hci_unregister_dev(hdev);
1da177e4 LT	561	hci_free_dev(hdev);
	562
	563	return 0;
	564	}
	565
15b99ac1	566	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	567	{
1da177e4 LT	568	btuart_info_t *info;
1da177e4 LT	569
1da177e4 LT	570	/* Create new info device */
089b1dbb	571	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	572	if (!info)
f8cfa618	573	return -ENOMEM;
1da177e4	574
fba395ee	575	info->p_dev = link;
1da177e4 LT	576	link->priv = info;
1da177e4 LT	577
00990e7c DB	578	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	579	CONF_AUTO_SET_IO;
1da177e4	580
15b99ac1	581	return btuart_config(link);
1da177e4 LT	582	}
	583
	584
fba395ee	585	static void btuart_detach(struct pcmcia_device *link)
1da177e4 LT	586	{
1da177e4 LT	587	btuart_info_t *info = link->priv;
1da177e4	588
e2d40963	589	btuart_release(link);
1da177e4 LT	590	kfree(info);
	591	}
	592
00990e7c	593	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	594	{
ad913c11	595	int *try = priv_data;
90abdc3b	596
00990e7c DB	597	if (try == 0)
	598	p_dev->io_lines = 16;
	599
	600	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	601	return -EINVAL;
	602
	603	p_dev->resource[0]->end = 8;
	604	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	605	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	606
	607	return pcmcia_request_io(p_dev);
1da177e4 LT	608	}
1da177e4 LT	609
ed58872a	610	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	611	void *priv_data)
1da177e4	612	{
ed58872a DB	613	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	614	int j;
	615
00990e7c DB	616	if (p_dev->io_lines > 3)
	617	return -ENODEV;
	618
	619	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	620	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	621	p_dev->resource[0]->end = 8;
	622
	623	for (j = 0; j < 5; j++) {
	624	p_dev->resource[0]->start = base[j];
	625	p_dev->io_lines = base[j] ? 16 : 3;
	626	if (!pcmcia_request_io(p_dev))
	627	return 0;
ed58872a DB	628	}
ed58872a DB	629	return -ENODEV;
1da177e4 LT	630	}
1da177e4 LT	631
15b99ac1	632	static int btuart_config(struct pcmcia_device *link)
1da177e4	633	{
1da177e4	634	btuart_info_t *info = link->priv;
ed58872a	635	int i;
ad913c11	636	int try;
ed58872a DB	637
	638	/* First pass: look for a config entry that looks normal.
	639	Two tries: without IO aliases, then with aliases */
	640	for (try = 0; try < 2; try++)
ad913c11	641	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	642	goto found_port;
1da177e4 LT	643
	644	/* Second pass: try to find an entry that isn't picky about
	645	its base address, then try to grab any standard serial port
	646	address, and finally try to get any free port. */
ed58872a DB	647	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	648	goto found_port;
1da177e4	649
ed58872a	650	BT_ERR("No usable port range found");
ed58872a	651	goto failed;
1da177e4	652
ed58872a	653	found_port:
eb14120f	654	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	655	if (i != 0)
eb14120f	656	goto failed;
1da177e4	657
1ac71e5a	658	i = pcmcia_enable_device(link);
9ac3e58c	659	if (i != 0)
1da177e4	660	goto failed;
1da177e4 LT	661
	662	if (btuart_open(info) != 0)
	663	goto failed;
	664
15b99ac1	665	return 0;
1da177e4	666
1da177e4 LT	667	failed:
1da177e4 LT	668	btuart_release(link);
15b99ac1	669	return -ENODEV;
1da177e4 LT	670	}
	671
	672
fba395ee	673	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	674	{
	675	btuart_info_t *info = link->priv;
	676
e2d40963	677	btuart_close(info);
1da177e4	678
fba395ee	679	pcmcia_disable_device(link);
1da177e4 LT	680	}
1da177e4 LT	681
25f8f54f	682	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	683	/* don't use this driver. Use serial_cs + hci_uart instead */
	684	PCMCIA_DEVICE_NULL
	685	};
	686	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	687
1da177e4 LT	688	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	689	.owner = THIS_MODULE,
2e9b981a	690	.name = "btuart_cs",
15b99ac1	691	.probe = btuart_probe,
cc3b4866	692	.remove = btuart_detach,
279c9361	693	.id_table = btuart_ids,
1da177e4 LT	694	};
	695
	696	static int __init init_btuart_cs(void)
	697	{
	698	return pcmcia_register_driver(&btuart_driver);
	699	}
	700
	701
	702	static void __exit exit_btuart_cs(void)
	703	{
	704	pcmcia_unregister_driver(&btuart_driver);
1da177e4 LT	705	}
	706
	707	module_init(init_btuart_cs);
	708	module_exit(exit_btuart_cs);