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

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

#include <linux/module.h>

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

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

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

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


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


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


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


typedef struct btuart_info_t {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;	/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

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


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

static void btuart_detach(struct pcmcia_device *p_dev);


/* Maximum baud rate */
#define SPEED_MAX  115200

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


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

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


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


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

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

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

	return actual;
}


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

		/* Allocate packet */
		if (info->rx_skb == NULL) {
			info->rx_state = RECV_WAIT_PACKET_TYPE;
			info->rx_count = 0;
			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
				BT_ERR("Can't allocate mem for new packet");
				return;
			}
		}

		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);

			switch (bt_cb(info->rx_skb)->pkt_type) {

			case HCI_EVENT_PKT:
				info->rx_state = RECV_WAIT_EVENT_HEADER;
				info->rx_count = HCI_EVENT_HDR_SIZE;
				break;

			case HCI_ACLDATA_PKT:
				info->rx_state = RECV_WAIT_ACL_HEADER;
				info->rx_count = HCI_ACL_HDR_SIZE;
				break;

			case HCI_SCODATA_PKT:
				info->rx_state = RECV_WAIT_SCO_HEADER;
				info->rx_count = HCI_SCO_HDR_SIZE;
				break;

			default:
				/* Unknown packet */
				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
				info->hdev->stat.err_rx++;
				clear_bit(HCI_RUNNING, &(info->hdev->flags));

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

			}

		} else {

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

			if (info->rx_count == 0) {

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


				switch (info->rx_state) {

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

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

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

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

				}

			}

		}

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

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


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

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

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

	spin_lock(&(info->lock));

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

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

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

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

		iir = inb(iobase + UART_IIR) & UART_IIR_ID;

	}

	spin_unlock(&(info->lock));

	return r;
}


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

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

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

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

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

	divisor = SPEED_MAX / speed;

	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;

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

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

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

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

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

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


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


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

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

	return 0;
}


static int btuart_hci_open(struct hci_dev *hdev)
{
	set_bit(HCI_RUNNING, &(hdev->flags));

	return 0;
}


static int btuart_hci_close(struct hci_dev *hdev)
{
	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
		return 0;

	btuart_hci_flush(hdev);

	return 0;
}


static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	btuart_info_t *info;

	if (!hdev) {
		BT_ERR("Frame for unknown HCI device (hdev=NULL)");
		return -ENODEV;
	}

	info = hci_get_drvdata(hdev);

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

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

	btuart_write_wakeup(info);

	return 0;
}


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


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

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

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

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

	info->hdev = hdev;

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

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

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

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

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

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

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

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

	btuart_change_speed(info, DEFAULT_BAUD_RATE);

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

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

	return 0;
}


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

	if (!hdev)
		return -ENODEV;

	btuart_hci_close(hdev);

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

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

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

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

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

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

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

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

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

	return btuart_config(link);
}


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

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

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

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

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

	return pcmcia_request_io(p_dev);
}

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

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

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

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

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

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

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

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

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

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

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

	return 0;

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


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

	btuart_close(info);

	pcmcia_disable_device(link);
}

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

static struct pcmcia_driver btuart_driver = {
	.owner		= THIS_MODULE,
	.name		= "btuart_cs",
	.probe		= btuart_probe,
	.remove		= btuart_detach,
	.id_table	= btuart_ids,
};
module_pcmcia_driver(btuart_driver);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for Bluetooth PCMCIA cards with HCI UART interface
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	*
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation;
	11	*
	12	* Software distributed under the License is distributed on an "AS
	13	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	14	* implied. See the License for the specific language governing
	15	* rights and limitations under the License.
	16	*
	17	* The initial developer of the original code is David A. Hinds
	18	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	19	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	20	*
	21	*/
	22
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/kernel.h>
	26	#include <linux/init.h>
	27	#include <linux/slab.h>
	28	#include <linux/types.h>
1da177e4 LT	29	#include <linux/delay.h>
	30	#include <linux/errno.h>
	31	#include <linux/ptrace.h>
	32	#include <linux/ioport.h>
	33	#include <linux/spinlock.h>
	34	#include <linux/moduleparam.h>
	35
	36	#include <linux/skbuff.h>
	37	#include <linux/string.h>
	38	#include <linux/serial.h>
	39	#include <linux/serial_reg.h>
	40	#include <linux/bitops.h>
1da177e4 LT	41	#include <asm/io.h>
1da177e4 LT	42
1da177e4 LT	43	#include <pcmcia/cistpl.h>
	44	#include <pcmcia/ciscode.h>
	45	#include <pcmcia/ds.h>
	46	#include <pcmcia/cisreg.h>
	47
	48	#include <net/bluetooth/bluetooth.h>
	49	#include <net/bluetooth/hci_core.h>
	50
	51
	52
	53	/* ======================== Module parameters ======================== */
	54
	55
	56	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	57	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	58	MODULE_LICENSE("GPL");
	59
	60
	61
	62	/* ======================== Local structures ======================== */
	63
	64
	65	typedef struct btuart_info_t {
fd238232	66	struct pcmcia_device *p_dev;
1da177e4 LT	67
	68	struct hci_dev *hdev;
	69
	70	spinlock_t lock; /* For serializing operations */
	71
	72	struct sk_buff_head txq;
	73	unsigned long tx_state;
	74
	75	unsigned long rx_state;
	76	unsigned long rx_count;
	77	struct sk_buff *rx_skb;
	78	} btuart_info_t;
	79
	80
15b99ac1	81	static int btuart_config(struct pcmcia_device *link);
fba395ee	82	static void btuart_release(struct pcmcia_device *link);
1da177e4	83
cc3b4866	84	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	85
1da177e4 LT	86
	87	/* Maximum baud rate */
	88	#define SPEED_MAX 115200
	89
	90	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	91	#define DEFAULT_BAUD_RATE 115200
	92
	93
	94	/* Transmit states */
	95	#define XMIT_SENDING 1
	96	#define XMIT_WAKEUP 2
	97	#define XMIT_WAITING 8
	98
	99	/* Receiver states */
	100	#define RECV_WAIT_PACKET_TYPE 0
	101	#define RECV_WAIT_EVENT_HEADER 1
	102	#define RECV_WAIT_ACL_HEADER 2
	103	#define RECV_WAIT_SCO_HEADER 3
	104	#define RECV_WAIT_DATA 4
	105
	106
	107
	108	/* ======================== Interrupt handling ======================== */
	109
	110
	111	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	112	{
	113	int actual = 0;
	114
	115	/* Tx FIFO should be empty */
	116	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	117	return 0;
	118
	119	/* Fill FIFO with current frame */
	120	while ((fifo_size-- > 0) && (actual < len)) {
	121	/* Transmit next byte */
	122	outb(buf[actual], iobase + UART_TX);
	123	actual++;
	124	}
	125
	126	return actual;
	127	}
	128
	129
	130	static void btuart_write_wakeup(btuart_info_t *info)
	131	{
	132	if (!info) {
	133	BT_ERR("Unknown device");
	134	return;
	135	}
	136
	137	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	138	set_bit(XMIT_WAKEUP, &(info->tx_state));
	139	return;
	140	}
	141
	142	do {
fc5fef61	143	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4	144	register struct sk_buff *skb;
fc5fef61	145	int len;
1da177e4 LT	146
	147	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	148
e2d40963	149	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	150	return;
	151
	152	if (!(skb = skb_dequeue(&(info->txq))))
	153	break;
	154
	155	/* Send frame */
	156	len = btuart_write(iobase, 16, skb->data, skb->len);
	157	set_bit(XMIT_WAKEUP, &(info->tx_state));
	158
	159	if (len == skb->len) {
	160	kfree_skb(skb);
	161	} else {
	162	skb_pull(skb, len);
	163	skb_queue_head(&(info->txq), skb);
	164	}
	165
	166	info->hdev->stat.byte_tx += len;
	167
	168	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	169
	170	clear_bit(XMIT_SENDING, &(info->tx_state));
	171	}
	172
	173
	174	static void btuart_receive(btuart_info_t *info)
	175	{
	176	unsigned int iobase;
	177	int boguscount = 0;
	178
	179	if (!info) {
	180	BT_ERR("Unknown device");
	181	return;
	182	}
	183
9a017a91	184	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	185
	186	do {
	187	info->hdev->stat.byte_rx++;
	188
	189	/* Allocate packet */
	190	if (info->rx_skb == NULL) {
	191	info->rx_state = RECV_WAIT_PACKET_TYPE;
	192	info->rx_count = 0;
	193	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	194	BT_ERR("Can't allocate mem for new packet");
	195	return;
	196	}
	197	}
	198
	199	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	200
0d48d939	201	bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
1da177e4	202
0d48d939	203	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	204
	205	case HCI_EVENT_PKT:
	206	info->rx_state = RECV_WAIT_EVENT_HEADER;
	207	info->rx_count = HCI_EVENT_HDR_SIZE;
	208	break;
	209
	210	case HCI_ACLDATA_PKT:
	211	info->rx_state = RECV_WAIT_ACL_HEADER;
	212	info->rx_count = HCI_ACL_HDR_SIZE;
	213	break;
	214
	215	case HCI_SCODATA_PKT:
	216	info->rx_state = RECV_WAIT_SCO_HEADER;
	217	info->rx_count = HCI_SCO_HDR_SIZE;
	218	break;
	219
	220	default:
	221	/* Unknown packet */
0d48d939	222	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	223	info->hdev->stat.err_rx++;
	224	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	225
	226	kfree_skb(info->rx_skb);
	227	info->rx_skb = NULL;
	228	break;
	229
	230	}
	231
	232	} else {
	233
	234	*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
	235	info->rx_count--;
	236
	237	if (info->rx_count == 0) {
	238
	239	int dlen;
	240	struct hci_event_hdr *eh;
	241	struct hci_acl_hdr *ah;
	242	struct hci_sco_hdr *sh;
	243
	244
	245	switch (info->rx_state) {
	246
	247	case RECV_WAIT_EVENT_HEADER:
2a123b86	248	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	249	info->rx_state = RECV_WAIT_DATA;
	250	info->rx_count = eh->plen;
	251	break;
	252
	253	case RECV_WAIT_ACL_HEADER:
2a123b86	254	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	255	dlen = __le16_to_cpu(ah->dlen);
	256	info->rx_state = RECV_WAIT_DATA;
	257	info->rx_count = dlen;
	258	break;
	259
	260	case RECV_WAIT_SCO_HEADER:
2a123b86	261	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	262	info->rx_state = RECV_WAIT_DATA;
	263	info->rx_count = sh->dlen;
	264	break;
	265
	266	case RECV_WAIT_DATA:
e1a26170	267	hci_recv_frame(info->hdev, info->rx_skb);
1da177e4 LT	268	info->rx_skb = NULL;
	269	break;
	270
	271	}
	272
	273	}
	274
	275	}
	276
	277	/* Make sure we don't stay here too long */
	278	if (boguscount++ > 16)
	279	break;
	280
	281	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
	282	}
	283
	284
7d12e780	285	static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
1da177e4 LT	286	{
	287	btuart_info_t *info = dev_inst;
	288	unsigned int iobase;
	289	int boguscount = 0;
	290	int iir, lsr;
aafcf998	291	irqreturn_t r = IRQ_NONE;
1da177e4	292
7427847d MF	293	if (!info \|\| !info->hdev)
	294	/* our irq handler is shared */
	295	return IRQ_NONE;
1da177e4	296
9a017a91	297	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	298
	299	spin_lock(&(info->lock));
	300
	301	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	302	while (iir) {
aafcf998	303	r = IRQ_HANDLED;
1da177e4 LT	304
	305	/* Clear interrupt */
	306	lsr = inb(iobase + UART_LSR);
	307
	308	switch (iir) {
	309	case UART_IIR_RLSI:
	310	BT_ERR("RLSI");
	311	break;
	312	case UART_IIR_RDI:
	313	/* Receive interrupt */
	314	btuart_receive(info);
	315	break;
	316	case UART_IIR_THRI:
	317	if (lsr & UART_LSR_THRE) {
	318	/* Transmitter ready for data */
	319	btuart_write_wakeup(info);
	320	}
	321	break;
	322	default:
	323	BT_ERR("Unhandled IIR=%#x", iir);
	324	break;
	325	}
	326
	327	/* Make sure we don't stay here too long */
	328	if (boguscount++ > 100)
	329	break;
	330
	331	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	332
	333	}
	334
	335	spin_unlock(&(info->lock));
	336
aafcf998	337	return r;
1da177e4 LT	338	}
	339
	340
	341	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	342	{
	343	unsigned long flags;
	344	unsigned int iobase;
	345	int fcr; /* FIFO control reg */
	346	int lcr; /* Line control reg */
	347	int divisor;
	348
	349	if (!info) {
	350	BT_ERR("Unknown device");
	351	return;
	352	}
	353
9a017a91	354	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	355
	356	spin_lock_irqsave(&(info->lock), flags);
	357
	358	/* Turn off interrupts */
	359	outb(0, iobase + UART_IER);
	360
	361	divisor = SPEED_MAX / speed;
	362
	363	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	364
	365	/*
	366	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	367	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	368	* about this timeout since it will always be fast enough.
	369	*/
	370
	371	if (speed < 38400)
	372	fcr \|= UART_FCR_TRIGGER_1;
	373	else
	374	fcr \|= UART_FCR_TRIGGER_14;
	375
	376	/* Bluetooth cards use 8N1 */
	377	lcr = UART_LCR_WLEN8;
	378
	379	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	380	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	381	outb(divisor >> 8, iobase + UART_DLM);
	382	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	383	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	384
b92b1c57	385	/* Turn on interrupts */
1da177e4 LT	386	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	387
	388	spin_unlock_irqrestore(&(info->lock), flags);
	389	}
	390
	391
	392
	393	/* ======================== HCI interface ======================== */
	394
	395
	396	static int btuart_hci_flush(struct hci_dev *hdev)
	397	{
155961e8	398	btuart_info_t *info = hci_get_drvdata(hdev);
1da177e4 LT	399
	400	/* Drop TX queue */
	401	skb_queue_purge(&(info->txq));
	402
	403	return 0;
	404	}
	405
	406
	407	static int btuart_hci_open(struct hci_dev *hdev)
	408	{
	409	set_bit(HCI_RUNNING, &(hdev->flags));
	410
	411	return 0;
	412	}
	413
	414
	415	static int btuart_hci_close(struct hci_dev *hdev)
	416	{
	417	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	418	return 0;
	419
	420	btuart_hci_flush(hdev);
	421
	422	return 0;
	423	}
	424
	425
7bd8f09f	426	static int btuart_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4 LT	427	{
1da177e4 LT	428	btuart_info_t *info;
1da177e4 LT	429
	430	if (!hdev) {
	431	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
	432	return -ENODEV;
	433	}
	434
155961e8	435	info = hci_get_drvdata(hdev);
1da177e4	436
0d48d939	437	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	438	case HCI_COMMAND_PKT:
	439	hdev->stat.cmd_tx++;
	440	break;
	441	case HCI_ACLDATA_PKT:
	442	hdev->stat.acl_tx++;
	443	break;
	444	case HCI_SCODATA_PKT:
	445	hdev->stat.sco_tx++;
	446	break;
5ad77795	447	}
1da177e4 LT	448
1da177e4 LT	449	/* Prepend skb with frame type */
0d48d939	450	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	451	skb_queue_tail(&(info->txq), skb);
	452
	453	btuart_write_wakeup(info);
	454
	455	return 0;
	456	}
	457
	458
1da177e4 LT	459
	460	/* ======================== Card services HCI interaction ======================== */
	461
	462
	463	static int btuart_open(btuart_info_t *info)
	464	{
	465	unsigned long flags;
9a017a91	466	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	467	struct hci_dev *hdev;
	468
	469	spin_lock_init(&(info->lock));
	470
	471	skb_queue_head_init(&(info->txq));
	472
	473	info->rx_state = RECV_WAIT_PACKET_TYPE;
	474	info->rx_count = 0;
	475	info->rx_skb = NULL;
	476
	477	/* Initialize HCI device */
	478	hdev = hci_alloc_dev();
	479	if (!hdev) {
	480	BT_ERR("Can't allocate HCI device");
	481	return -ENOMEM;
	482	}
	483
	484	info->hdev = hdev;
	485
c13854ce	486	hdev->bus = HCI_PCCARD;
155961e8	487	hci_set_drvdata(hdev, info);
27d35284	488	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	489
71f39030 MH	490	hdev->open = btuart_hci_open;
	491	hdev->close = btuart_hci_close;
	492	hdev->flush = btuart_hci_flush;
	493	hdev->send = btuart_hci_send_frame;
1da177e4	494
1da177e4 LT	495	spin_lock_irqsave(&(info->lock), flags);
	496
	497	/* Reset UART */
	498	outb(0, iobase + UART_MCR);
	499
	500	/* Turn off interrupts */
	501	outb(0, iobase + UART_IER);
	502
	503	/* Initialize UART */
	504	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	505	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	506
	507	/* Turn on interrupts */
	508	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	509
	510	spin_unlock_irqrestore(&(info->lock), flags);
	511
	512	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	513
	514	/* Timeout before it is safe to send the first HCI packet */
	515	msleep(1000);
	516
	517	/* Register HCI device */
	518	if (hci_register_dev(hdev) < 0) {
	519	BT_ERR("Can't register HCI device");
	520	info->hdev = NULL;
	521	hci_free_dev(hdev);
	522	return -ENODEV;
	523	}
	524
	525	return 0;
	526	}
	527
	528
	529	static int btuart_close(btuart_info_t *info)
	530	{
	531	unsigned long flags;
9a017a91	532	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4 LT	533	struct hci_dev *hdev = info->hdev;
	534
	535	if (!hdev)
	536	return -ENODEV;
	537
	538	btuart_hci_close(hdev);
	539
	540	spin_lock_irqsave(&(info->lock), flags);
	541
	542	/* Reset UART */
	543	outb(0, iobase + UART_MCR);
	544
	545	/* Turn off interrupts */
	546	outb(0, iobase + UART_IER);
	547
	548	spin_unlock_irqrestore(&(info->lock), flags);
	549
13ea4015	550	hci_unregister_dev(hdev);
1da177e4 LT	551	hci_free_dev(hdev);
	552
	553	return 0;
	554	}
	555
15b99ac1	556	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	557	{
1da177e4 LT	558	btuart_info_t *info;
1da177e4 LT	559
1da177e4 LT	560	/* Create new info device */
fdefa118	561	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	562	if (!info)
f8cfa618	563	return -ENOMEM;
1da177e4	564
fba395ee	565	info->p_dev = link;
1da177e4 LT	566	link->priv = info;
1da177e4 LT	567
00990e7c DB	568	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	569	CONF_AUTO_SET_IO;
1da177e4	570
15b99ac1	571	return btuart_config(link);
1da177e4 LT	572	}
	573
	574
fba395ee	575	static void btuart_detach(struct pcmcia_device *link)
1da177e4	576	{
e2d40963	577	btuart_release(link);
1da177e4 LT	578	}
1da177e4 LT	579
00990e7c	580	static int btuart_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	581	{
ad913c11	582	int *try = priv_data;
90abdc3b	583
510df251	584	if (!try)
00990e7c DB	585	p_dev->io_lines = 16;
	586
	587	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	588	return -EINVAL;
	589
	590	p_dev->resource[0]->end = 8;
	591	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	592	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	593
	594	return pcmcia_request_io(p_dev);
1da177e4 LT	595	}
1da177e4 LT	596
ed58872a	597	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	598	void *priv_data)
1da177e4	599	{
ed58872a DB	600	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	601	int j;
	602
00990e7c DB	603	if (p_dev->io_lines > 3)
	604	return -ENODEV;
	605
	606	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	607	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	608	p_dev->resource[0]->end = 8;
	609
	610	for (j = 0; j < 5; j++) {
	611	p_dev->resource[0]->start = base[j];
	612	p_dev->io_lines = base[j] ? 16 : 3;
	613	if (!pcmcia_request_io(p_dev))
	614	return 0;
ed58872a DB	615	}
ed58872a DB	616	return -ENODEV;
1da177e4 LT	617	}
1da177e4 LT	618
15b99ac1	619	static int btuart_config(struct pcmcia_device *link)
1da177e4	620	{
1da177e4	621	btuart_info_t *info = link->priv;
ed58872a	622	int i;
ad913c11	623	int try;
ed58872a DB	624
	625	/* First pass: look for a config entry that looks normal.
	626	Two tries: without IO aliases, then with aliases */
	627	for (try = 0; try < 2; try++)
ad913c11	628	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	629	goto found_port;
1da177e4 LT	630
	631	/* Second pass: try to find an entry that isn't picky about
	632	its base address, then try to grab any standard serial port
	633	address, and finally try to get any free port. */
ed58872a DB	634	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	635	goto found_port;
1da177e4	636
ed58872a	637	BT_ERR("No usable port range found");
ed58872a	638	goto failed;
1da177e4	639
ed58872a	640	found_port:
eb14120f	641	i = pcmcia_request_irq(link, btuart_interrupt);
9ac3e58c	642	if (i != 0)
eb14120f	643	goto failed;
1da177e4	644
1ac71e5a	645	i = pcmcia_enable_device(link);
9ac3e58c	646	if (i != 0)
1da177e4	647	goto failed;
1da177e4 LT	648
	649	if (btuart_open(info) != 0)
	650	goto failed;
	651
15b99ac1	652	return 0;
1da177e4	653
1da177e4 LT	654	failed:
1da177e4 LT	655	btuart_release(link);
15b99ac1	656	return -ENODEV;
1da177e4 LT	657	}
	658
	659
fba395ee	660	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	661	{
	662	btuart_info_t *info = link->priv;
	663
e2d40963	664	btuart_close(info);
1da177e4	665
fba395ee	666	pcmcia_disable_device(link);
1da177e4 LT	667	}
1da177e4 LT	668
25f8f54f	669	static const struct pcmcia_device_id btuart_ids[] = {
279c9361 DB	670	/* don't use this driver. Use serial_cs + hci_uart instead */
	671	PCMCIA_DEVICE_NULL
	672	};
	673	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	674
1da177e4 LT	675	static struct pcmcia_driver btuart_driver = {
1da177e4 LT	676	.owner = THIS_MODULE,
2e9b981a	677	.name = "btuart_cs",
15b99ac1	678	.probe = btuart_probe,
cc3b4866	679	.remove = btuart_detach,
279c9361	680	.id_table = btuart_ids,
1da177e4	681	};
e0c005f4	682	module_pcmcia_driver(btuart_driver);