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

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

#include <linux/module.h>

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

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

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

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


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


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


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


typedef struct btuart_info_t {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;	/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

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


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

static void btuart_detach(struct pcmcia_device *p_dev);


/* Maximum baud rate */
#define SPEED_MAX  115200

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


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

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


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


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

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

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

	return actual;
}


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			info->rx_skb->dev = (void *) info->hdev;
			bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);

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

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

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

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

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

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

			}

		} else {

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

			if (info->rx_count == 0) {

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


				switch (info->rx_state) {

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

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

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

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

				}

			}

		}

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

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


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

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

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

	spin_lock(&(info->lock));

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

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

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

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

		iir = inb(iobase + UART_IIR) & UART_IIR_ID;

	}

	spin_unlock(&(info->lock));

	return r;
}


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

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

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

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

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

	divisor = SPEED_MAX / speed;

	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;

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

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

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

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

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

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


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


static int btuart_hci_flush(struct hci_dev *hdev)
{
	btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);

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

	return 0;
}


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

	return 0;
}


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

	btuart_hci_flush(hdev);

	return 0;
}


static int btuart_hci_send_frame(struct sk_buff *skb)
{
	btuart_info_t *info;
	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);

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

	info = (btuart_info_t *)(hdev->driver_data);

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

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

	btuart_write_wakeup(info);

	return 0;
}


static 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->resource[0]->start;
	struct hci_dev *hdev;

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

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

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

	info->hdev = hdev;

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

	hdev->open     = btuart_hci_open;
	hdev->close    = btuart_hci_close;
	hdev->flush    = btuart_hci_flush;
	hdev->send     = btuart_hci_send_frame;
	hdev->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->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);

	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->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
	link->resource[0]->end = 8;

	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP;

	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,
			       void *priv_data)
{
	int *try = priv_data;
	p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;

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