[mirror_ubuntu-bionic-kernel.git] / drivers / bluetooth / btuart_cs.c

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

#include <linux/module.h>

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

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

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

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


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


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


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


struct btuart_info {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;	/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

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


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

static void btuart_detach(struct pcmcia_device *p_dev);


/* Maximum baud rate */
#define SPEED_MAX  115200

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


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

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


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


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

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

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

	return actual;
}


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

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

			switch (hci_skb_pkt_type(info->rx_skb)) {

			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",
				       hci_skb_pkt_type(info->rx_skb));
				info->hdev->stat.err_rx++;

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

			}

		} else {

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

			if (info->rx_count == 0) {

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


				switch (info->rx_state) {

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

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

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

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

				}

			}

		}

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

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


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

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

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

	spin_lock(&(info->lock));

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

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

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

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

		iir = inb(iobase + UART_IIR) & UART_IIR_ID;

	}

	spin_unlock(&(info->lock));

	return r;
}


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

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

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

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

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

	divisor = SPEED_MAX / speed;

	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;

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

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

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

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

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

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


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


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

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

	return 0;
}


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


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

	return 0;
}


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

	switch (hci_skb_pkt_type(skb)) {
	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), &hci_skb_pkt_type(skb), 1);
	skb_queue_tail(&(info->txq), skb);

	btuart_write_wakeup(info);

	return 0;
}


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


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

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

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

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

	info->hdev = hdev;

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

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

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

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

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

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

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

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

	btuart_change_speed(info, DEFAULT_BAUD_RATE);

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

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

	return 0;
}


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

	if (!hdev)
		return -ENODEV;

	btuart_hci_close(hdev);

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

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

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

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

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

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

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

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

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

	return btuart_config(link);
}


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

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

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

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

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

	return pcmcia_request_io(p_dev);
}

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

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

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

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

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

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

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

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

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

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

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

	return 0;

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


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

	btuart_close(info);

	pcmcia_disable_device(link);
}

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

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