[GitHub/mt8127/android_kernel_alcatel_ttab.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.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->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;
	irqreturn_t r = IRQ_NONE;

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

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

	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->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->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->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->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");
	goto failed;

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

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