[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/cs_types.h>
#include <pcmcia/cs.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;
	dev_node_t node;

	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->io.BasePort1;
		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->io.BasePort1;

	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;

	BUG_ON(!info->hdev);

	iobase = info->p_dev->io.BasePort1;

	spin_lock(&(info->lock));

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

		/* 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 IRQ_HANDLED;
}


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->io.BasePort1;

	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 void btuart_hci_destruct(struct hci_dev *hdev)
{
}


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->io.BasePort1;
	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->type = 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->destruct = btuart_hci_destruct;
	hdev->ioctl    = btuart_hci_ioctl;

	hdev->owner = THIS_MODULE;

	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->io.BasePort1;
	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);

	if (hci_unregister_dev(hdev) < 0)
		BT_ERR("Can't unregister HCI device %s", hdev->name);

	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->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	link->io.NumPorts1 = 8;
	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
	link->irq.IRQInfo1 = IRQ_LEVEL_ID;

	link->irq.Handler = btuart_interrupt;
	link->irq.Instance = info;

	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.IntType = INT_MEMORY_AND_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,
			       cistpl_cftable_entry_t *cf,
			       cistpl_cftable_entry_t *dflt,
			       unsigned int vcc,
			       void *priv_data)
{
	int *try = priv_data;

	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
		p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
	    (cf->io.win[0].base != 0)) {
		p_dev->io.BasePort1 = cf->io.win[0].base;
		p_dev->io.IOAddrLines = (*try == 0) ? 16 :
			cf->io.flags & CISTPL_IO_LINES_MASK;
		if (!pcmcia_request_io(p_dev, &p_dev->io))
			return 0;
	}
	return -ENODEV;
}

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

	if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
		for (j = 0; j < 5; j++) {
			p_dev->io.BasePort1 = base[j];
			p_dev->io.IOAddrLines = base[j] ? 16 : 3;
			if (!pcmcia_request_io(p_dev, &p_dev->io))
				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");
	cs_error(link, RequestIO, -ENODEV);
	goto failed;

found_port:
	i = pcmcia_request_irq(link, &link->irq);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestIRQ, i);
		link->irq.AssignedIRQ = 0;
	}

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestConfiguration, i);
		goto failed;
	}

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

	strcpy(info->node.dev_name, info->hdev->name);
	link->dev_node = &info->node;

	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 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,
	.drv		= {
		.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/cs_types.h>
	45	#include <pcmcia/cs.h>
	46	#include <pcmcia/cistpl.h>
	47	#include <pcmcia/ciscode.h>
	48	#include <pcmcia/ds.h>
	49	#include <pcmcia/cisreg.h>
	50
	51	#include <net/bluetooth/bluetooth.h>
	52	#include <net/bluetooth/hci_core.h>
	53
	54
	55
	56	/* ======================== Module parameters ======================== */
	57
	58
	59	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	60	MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
	61	MODULE_LICENSE("GPL");
	62
	63
	64
	65	/* ======================== Local structures ======================== */
	66
	67
	68	typedef struct btuart_info_t {
fd238232	69	struct pcmcia_device *p_dev;
1da177e4 LT	70	dev_node_t node;
	71
	72	struct hci_dev *hdev;
	73
	74	spinlock_t lock; /* For serializing operations */
	75
	76	struct sk_buff_head txq;
	77	unsigned long tx_state;
	78
	79	unsigned long rx_state;
	80	unsigned long rx_count;
	81	struct sk_buff *rx_skb;
	82	} btuart_info_t;
	83
	84
15b99ac1	85	static int btuart_config(struct pcmcia_device *link);
fba395ee	86	static void btuart_release(struct pcmcia_device *link);
1da177e4	87
cc3b4866	88	static void btuart_detach(struct pcmcia_device *p_dev);
1da177e4	89
1da177e4 LT	90
	91	/* Maximum baud rate */
	92	#define SPEED_MAX 115200
	93
	94	/* Default baud rate: 57600, 115200, 230400 or 460800 */
	95	#define DEFAULT_BAUD_RATE 115200
	96
	97
	98	/* Transmit states */
	99	#define XMIT_SENDING 1
	100	#define XMIT_WAKEUP 2
	101	#define XMIT_WAITING 8
	102
	103	/* Receiver states */
	104	#define RECV_WAIT_PACKET_TYPE 0
	105	#define RECV_WAIT_EVENT_HEADER 1
	106	#define RECV_WAIT_ACL_HEADER 2
	107	#define RECV_WAIT_SCO_HEADER 3
	108	#define RECV_WAIT_DATA 4
	109
	110
	111
	112	/* ======================== Interrupt handling ======================== */
	113
	114
	115	static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
	116	{
	117	int actual = 0;
	118
	119	/* Tx FIFO should be empty */
	120	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
	121	return 0;
	122
	123	/* Fill FIFO with current frame */
	124	while ((fifo_size-- > 0) && (actual < len)) {
	125	/* Transmit next byte */
	126	outb(buf[actual], iobase + UART_TX);
	127	actual++;
	128	}
	129
	130	return actual;
	131	}
	132
	133
	134	static void btuart_write_wakeup(btuart_info_t *info)
	135	{
	136	if (!info) {
	137	BT_ERR("Unknown device");
	138	return;
	139	}
	140
	141	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
	142	set_bit(XMIT_WAKEUP, &(info->tx_state));
	143	return;
	144	}
	145
	146	do {
fd238232	147	register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	148	register struct sk_buff *skb;
	149	register int len;
	150
	151	clear_bit(XMIT_WAKEUP, &(info->tx_state));
	152
e2d40963	153	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	154	return;
	155
	156	if (!(skb = skb_dequeue(&(info->txq))))
	157	break;
	158
	159	/* Send frame */
	160	len = btuart_write(iobase, 16, skb->data, skb->len);
	161	set_bit(XMIT_WAKEUP, &(info->tx_state));
	162
	163	if (len == skb->len) {
	164	kfree_skb(skb);
	165	} else {
	166	skb_pull(skb, len);
	167	skb_queue_head(&(info->txq), skb);
	168	}
	169
	170	info->hdev->stat.byte_tx += len;
	171
	172	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
	173
	174	clear_bit(XMIT_SENDING, &(info->tx_state));
	175	}
	176
	177
	178	static void btuart_receive(btuart_info_t *info)
	179	{
	180	unsigned int iobase;
	181	int boguscount = 0;
	182
	183	if (!info) {
	184	BT_ERR("Unknown device");
	185	return;
	186	}
	187
fd238232	188	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	189
	190	do {
	191	info->hdev->stat.byte_rx++;
	192
	193	/* Allocate packet */
	194	if (info->rx_skb == NULL) {
	195	info->rx_state = RECV_WAIT_PACKET_TYPE;
	196	info->rx_count = 0;
	197	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	198	BT_ERR("Can't allocate mem for new packet");
	199	return;
	200	}
	201	}
	202
	203	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	204
	205	info->rx_skb->dev = (void *) info->hdev;
0d48d939	206	bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
1da177e4	207
0d48d939	208	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	209
	210	case HCI_EVENT_PKT:
	211	info->rx_state = RECV_WAIT_EVENT_HEADER;
	212	info->rx_count = HCI_EVENT_HDR_SIZE;
	213	break;
	214
	215	case HCI_ACLDATA_PKT:
	216	info->rx_state = RECV_WAIT_ACL_HEADER;
	217	info->rx_count = HCI_ACL_HDR_SIZE;
	218	break;
	219
	220	case HCI_SCODATA_PKT:
	221	info->rx_state = RECV_WAIT_SCO_HEADER;
	222	info->rx_count = HCI_SCO_HDR_SIZE;
	223	break;
	224
	225	default:
	226	/* Unknown packet */
0d48d939	227	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	228	info->hdev->stat.err_rx++;
	229	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	230
	231	kfree_skb(info->rx_skb);
	232	info->rx_skb = NULL;
	233	break;
	234
	235	}
	236
	237	} else {
	238
	239	*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
	240	info->rx_count--;
	241
	242	if (info->rx_count == 0) {
	243
	244	int dlen;
	245	struct hci_event_hdr *eh;
	246	struct hci_acl_hdr *ah;
	247	struct hci_sco_hdr *sh;
	248
	249
	250	switch (info->rx_state) {
	251
	252	case RECV_WAIT_EVENT_HEADER:
2a123b86	253	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	254	info->rx_state = RECV_WAIT_DATA;
	255	info->rx_count = eh->plen;
	256	break;
	257
	258	case RECV_WAIT_ACL_HEADER:
2a123b86	259	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	260	dlen = __le16_to_cpu(ah->dlen);
	261	info->rx_state = RECV_WAIT_DATA;
	262	info->rx_count = dlen;
	263	break;
	264
	265	case RECV_WAIT_SCO_HEADER:
2a123b86	266	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	267	info->rx_state = RECV_WAIT_DATA;
	268	info->rx_count = sh->dlen;
	269	break;
	270
	271	case RECV_WAIT_DATA:
	272	hci_recv_frame(info->rx_skb);
	273	info->rx_skb = NULL;
	274	break;
	275
	276	}
	277
	278	}
	279
	280	}
	281
	282	/* Make sure we don't stay here too long */
	283	if (boguscount++ > 16)
	284	break;
	285
	286	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
	287	}
	288
	289
7d12e780	290	static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
1da177e4 LT	291	{
	292	btuart_info_t *info = dev_inst;
	293	unsigned int iobase;
	294	int boguscount = 0;
	295	int iir, lsr;
	296
ac019360	297	BUG_ON(!info->hdev);
1da177e4	298
fd238232	299	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	300
	301	spin_lock(&(info->lock));
	302
	303	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	304	while (iir) {
	305
	306	/* Clear interrupt */
	307	lsr = inb(iobase + UART_LSR);
	308
	309	switch (iir) {
	310	case UART_IIR_RLSI:
	311	BT_ERR("RLSI");
	312	break;
	313	case UART_IIR_RDI:
	314	/* Receive interrupt */
	315	btuart_receive(info);
	316	break;
	317	case UART_IIR_THRI:
	318	if (lsr & UART_LSR_THRE) {
	319	/* Transmitter ready for data */
	320	btuart_write_wakeup(info);
	321	}
	322	break;
	323	default:
	324	BT_ERR("Unhandled IIR=%#x", iir);
	325	break;
	326	}
	327
	328	/* Make sure we don't stay here too long */
	329	if (boguscount++ > 100)
	330	break;
	331
	332	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
	333
	334	}
	335
	336	spin_unlock(&(info->lock));
	337
	338	return IRQ_HANDLED;
	339	}
	340
	341
	342	static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
	343	{
	344	unsigned long flags;
	345	unsigned int iobase;
	346	int fcr; /* FIFO control reg */
	347	int lcr; /* Line control reg */
	348	int divisor;
	349
	350	if (!info) {
	351	BT_ERR("Unknown device");
	352	return;
	353	}
	354
fd238232	355	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	356
	357	spin_lock_irqsave(&(info->lock), flags);
	358
	359	/* Turn off interrupts */
	360	outb(0, iobase + UART_IER);
	361
	362	divisor = SPEED_MAX / speed;
	363
	364	fcr = UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_RCVR \| UART_FCR_CLEAR_XMIT;
	365
	366	/*
	367	* Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
	368	* almost 1,7 ms at 19200 bps. At speeds above that we can just forget
	369	* about this timeout since it will always be fast enough.
	370	*/
	371
	372	if (speed < 38400)
	373	fcr \|= UART_FCR_TRIGGER_1;
	374	else
	375	fcr \|= UART_FCR_TRIGGER_14;
	376
	377	/* Bluetooth cards use 8N1 */
	378	lcr = UART_LCR_WLEN8;
	379
	380	outb(UART_LCR_DLAB \| lcr, iobase + UART_LCR); /* Set DLAB */
	381	outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
	382	outb(divisor >> 8, iobase + UART_DLM);
	383	outb(lcr, iobase + UART_LCR); /* Set 8N1 */
	384	outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
	385
b92b1c57	386	/* Turn on interrupts */
1da177e4 LT	387	outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	388
	389	spin_unlock_irqrestore(&(info->lock), flags);
	390	}
	391
	392
	393
	394	/* ======================== HCI interface ======================== */
	395
	396
	397	static int btuart_hci_flush(struct hci_dev *hdev)
	398	{
	399	btuart_info_t info = (btuart_info_t )(hdev->driver_data);
	400
	401	/* Drop TX queue */
	402	skb_queue_purge(&(info->txq));
	403
	404	return 0;
	405	}
	406
	407
	408	static int btuart_hci_open(struct hci_dev *hdev)
	409	{
	410	set_bit(HCI_RUNNING, &(hdev->flags));
	411
	412	return 0;
	413	}
	414
	415
	416	static int btuart_hci_close(struct hci_dev *hdev)
	417	{
	418	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	419	return 0;
	420
	421	btuart_hci_flush(hdev);
	422
	423	return 0;
	424	}
	425
	426
	427	static int btuart_hci_send_frame(struct sk_buff *skb)
	428	{
	429	btuart_info_t *info;
	430	struct hci_dev hdev = (struct hci_dev )(skb->dev);
	431
	432	if (!hdev) {
	433	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
	434	return -ENODEV;
	435	}
	436
	437	info = (btuart_info_t *)(hdev->driver_data);
	438
0d48d939	439	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	440	case HCI_COMMAND_PKT:
	441	hdev->stat.cmd_tx++;
	442	break;
	443	case HCI_ACLDATA_PKT:
	444	hdev->stat.acl_tx++;
	445	break;
	446	case HCI_SCODATA_PKT:
	447	hdev->stat.sco_tx++;
	448	break;
	449	};
	450
	451	/* Prepend skb with frame type */
0d48d939	452	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	453	skb_queue_tail(&(info->txq), skb);
	454
	455	btuart_write_wakeup(info);
	456
	457	return 0;
	458	}
	459
	460
	461	static void btuart_hci_destruct(struct hci_dev *hdev)
	462	{
	463	}
	464
	465
	466	static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	467	{
	468	return -ENOIOCTLCMD;
	469	}
	470
	471
	472
	473	/* ======================== Card services HCI interaction ======================== */
	474
	475
	476	static int btuart_open(btuart_info_t *info)
	477	{
	478	unsigned long flags;
fd238232	479	unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	480	struct hci_dev *hdev;
	481
	482	spin_lock_init(&(info->lock));
	483
	484	skb_queue_head_init(&(info->txq));
	485
	486	info->rx_state = RECV_WAIT_PACKET_TYPE;
	487	info->rx_count = 0;
	488	info->rx_skb = NULL;
	489
	490	/* Initialize HCI device */
	491	hdev = hci_alloc_dev();
	492	if (!hdev) {
	493	BT_ERR("Can't allocate HCI device");
	494	return -ENOMEM;
	495	}
	496
	497	info->hdev = hdev;
	498
	499	hdev->type = HCI_PCCARD;
	500	hdev->driver_data = info;
27d35284	501	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	502
	503	hdev->open = btuart_hci_open;
	504	hdev->close = btuart_hci_close;
	505	hdev->flush = btuart_hci_flush;
	506	hdev->send = btuart_hci_send_frame;
	507	hdev->destruct = btuart_hci_destruct;
	508	hdev->ioctl = btuart_hci_ioctl;
	509
	510	hdev->owner = THIS_MODULE;
	511
	512	spin_lock_irqsave(&(info->lock), flags);
	513
	514	/* Reset UART */
	515	outb(0, iobase + UART_MCR);
	516
	517	/* Turn off interrupts */
	518	outb(0, iobase + UART_IER);
	519
	520	/* Initialize UART */
	521	outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
	522	outb((UART_MCR_DTR \| UART_MCR_RTS \| UART_MCR_OUT2), iobase + UART_MCR);
	523
	524	/* Turn on interrupts */
	525	// outb(UART_IER_RLSI \| UART_IER_RDI \| UART_IER_THRI, iobase + UART_IER);
	526
	527	spin_unlock_irqrestore(&(info->lock), flags);
	528
	529	btuart_change_speed(info, DEFAULT_BAUD_RATE);
	530
	531	/* Timeout before it is safe to send the first HCI packet */
	532	msleep(1000);
	533
	534	/* Register HCI device */
	535	if (hci_register_dev(hdev) < 0) {
	536	BT_ERR("Can't register HCI device");
	537	info->hdev = NULL;
	538	hci_free_dev(hdev);
	539	return -ENODEV;
	540	}
	541
	542	return 0;
	543	}
	544
	545
	546	static int btuart_close(btuart_info_t *info)
	547	{
	548	unsigned long flags;
fd238232	549	unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	550	struct hci_dev *hdev = info->hdev;
	551
	552	if (!hdev)
	553	return -ENODEV;
	554
	555	btuart_hci_close(hdev);
	556
	557	spin_lock_irqsave(&(info->lock), flags);
	558
	559	/* Reset UART */
	560	outb(0, iobase + UART_MCR);
	561
	562	/* Turn off interrupts */
	563	outb(0, iobase + UART_IER);
	564
	565	spin_unlock_irqrestore(&(info->lock), flags);
	566
	567	if (hci_unregister_dev(hdev) < 0)
	568	BT_ERR("Can't unregister HCI device %s", hdev->name);
	569
	570	hci_free_dev(hdev);
	571
	572	return 0;
	573	}
	574
15b99ac1	575	static int btuart_probe(struct pcmcia_device *link)
1da177e4 LT	576	{
1da177e4 LT	577	btuart_info_t *info;
1da177e4 LT	578
1da177e4 LT	579	/* Create new info device */
089b1dbb	580	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	581	if (!info)
f8cfa618	582	return -ENOMEM;
1da177e4	583
fba395ee	584	info->p_dev = link;
1da177e4 LT	585	link->priv = info;
	586
	587	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	588	link->io.NumPorts1 = 8;
	589	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	590	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	591
	592	link->irq.Handler = btuart_interrupt;
	593	link->irq.Instance = info;
	594
	595	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	596	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	597
15b99ac1	598	return btuart_config(link);
1da177e4 LT	599	}
	600
	601
fba395ee	602	static void btuart_detach(struct pcmcia_device *link)
1da177e4 LT	603	{
1da177e4 LT	604	btuart_info_t *info = link->priv;
1da177e4	605
e2d40963	606	btuart_release(link);
1da177e4 LT	607	kfree(info);
	608	}
	609
ed58872a DB	610	static int btuart_check_config(struct pcmcia_device *p_dev,
ed58872a DB	611	cistpl_cftable_entry_t *cf,
8e2fc39d	612	cistpl_cftable_entry_t *dflt,
ad913c11	613	unsigned int vcc,
ed58872a	614	void *priv_data)
1da177e4	615	{
ad913c11	616	int *try = priv_data;
ed58872a DB	617
	618	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
	619	p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
	620	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
	621	(cf->io.win[0].base != 0)) {
ed58872a	622	p_dev->io.BasePort1 = cf->io.win[0].base;
ad913c11	623	p_dev->io.IOAddrLines = (*try == 0) ? 16 :
ed58872a DB	624	cf->io.flags & CISTPL_IO_LINES_MASK;
	625	if (!pcmcia_request_io(p_dev, &p_dev->io))
	626	return 0;
	627	}
	628	return -ENODEV;
1da177e4 LT	629	}
1da177e4 LT	630
ed58872a DB	631	static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a DB	632	cistpl_cftable_entry_t *cf,
8e2fc39d	633	cistpl_cftable_entry_t *dflt,
ad913c11	634	unsigned int vcc,
ed58872a	635	void *priv_data)
1da177e4	636	{
ed58872a DB	637	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	638	int j;
	639
	640	if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
ed58872a DB	641	for (j = 0; j < 5; j++) {
	642	p_dev->io.BasePort1 = base[j];
	643	p_dev->io.IOAddrLines = base[j] ? 16 : 3;
	644	if (!pcmcia_request_io(p_dev, &p_dev->io))
	645	return 0;
	646	}
	647	}
	648	return -ENODEV;
1da177e4 LT	649	}
1da177e4 LT	650
15b99ac1	651	static int btuart_config(struct pcmcia_device *link)
1da177e4	652	{
1da177e4	653	btuart_info_t *info = link->priv;
ed58872a	654	int i;
ad913c11	655	int try;
ed58872a DB	656
	657	/* First pass: look for a config entry that looks normal.
	658	Two tries: without IO aliases, then with aliases */
	659	for (try = 0; try < 2; try++)
ad913c11	660	if (!pcmcia_loop_config(link, btuart_check_config, &try))
ed58872a	661	goto found_port;
1da177e4 LT	662
	663	/* Second pass: try to find an entry that isn't picky about
	664	its base address, then try to grab any standard serial port
	665	address, and finally try to get any free port. */
ed58872a DB	666	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
ed58872a DB	667	goto found_port;
1da177e4	668
ed58872a DB	669	BT_ERR("No usable port range found");
	670	cs_error(link, RequestIO, -ENODEV);
	671	goto failed;
1da177e4	672
ed58872a	673	found_port:
fba395ee	674	i = pcmcia_request_irq(link, &link->irq);
1da177e4	675	if (i != CS_SUCCESS) {
fba395ee	676	cs_error(link, RequestIRQ, i);
1da177e4 LT	677	link->irq.AssignedIRQ = 0;
	678	}
	679
fba395ee	680	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	681	if (i != CS_SUCCESS) {
fba395ee	682	cs_error(link, RequestConfiguration, i);
1da177e4 LT	683	goto failed;
	684	}
	685
	686	if (btuart_open(info) != 0)
	687	goto failed;
	688
	689	strcpy(info->node.dev_name, info->hdev->name);
fd238232	690	link->dev_node = &info->node;
1da177e4	691
15b99ac1	692	return 0;
1da177e4	693
1da177e4 LT	694	failed:
1da177e4 LT	695	btuart_release(link);
15b99ac1	696	return -ENODEV;
1da177e4 LT	697	}
	698
	699
fba395ee	700	static void btuart_release(struct pcmcia_device *link)
1da177e4 LT	701	{
	702	btuart_info_t *info = link->priv;
	703
e2d40963	704	btuart_close(info);
1da177e4	705
fba395ee	706	pcmcia_disable_device(link);
1da177e4 LT	707	}
1da177e4 LT	708
279c9361 DB	709	static struct pcmcia_device_id btuart_ids[] = {
	710	/* don't use this driver. Use serial_cs + hci_uart instead */
	711	PCMCIA_DEVICE_NULL
	712	};
	713	MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
	714
1da177e4 LT	715	static struct pcmcia_driver btuart_driver = {
	716	.owner = THIS_MODULE,
	717	.drv = {
	718	.name = "btuart_cs",
	719	},
15b99ac1	720	.probe = btuart_probe,
cc3b4866	721	.remove = btuart_detach,
279c9361	722	.id_table = btuart_ids,
1da177e4 LT	723	};
	724
	725	static int __init init_btuart_cs(void)
	726	{
	727	return pcmcia_register_driver(&btuart_driver);
	728	}
	729
	730
	731	static void __exit exit_btuart_cs(void)
	732	{
	733	pcmcia_unregister_driver(&btuart_driver);
1da177e4 LT	734	}
	735
	736	module_init(init_btuart_cs);
	737	module_exit(exit_btuart_cs);