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

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

#include <linux/module.h>

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

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

#include <linux/device.h>
#include <linux/firmware.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 the 3Com Bluetooth PCMCIA card");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("BT3CPCC.bin");


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


struct bt3c_info {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;		/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

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


static int bt3c_config(struct pcmcia_device *link);
static void bt3c_release(struct pcmcia_device *link);

static void bt3c_detach(struct pcmcia_device *p_dev);


/* 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


/* ======================== Special I/O functions ======================== */


#define DATA_L   0
#define DATA_H   1
#define ADDR_L   2
#define ADDR_H   3
#define CONTROL  4


static inline void bt3c_address(unsigned int iobase, unsigned short addr)
{
	outb(addr & 0xff, iobase + ADDR_L);
	outb((addr >> 8) & 0xff, iobase + ADDR_H);
}


static inline void bt3c_put(unsigned int iobase, unsigned short value)
{
	outb(value & 0xff, iobase + DATA_L);
	outb((value >> 8) & 0xff, iobase + DATA_H);
}


static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
{
	bt3c_address(iobase, addr);
	bt3c_put(iobase, value);
}


static inline unsigned short bt3c_get(unsigned int iobase)
{
	unsigned short value = inb(iobase + DATA_L);

	value |= inb(iobase + DATA_H) << 8;

	return value;
}


static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
{
	bt3c_address(iobase, addr);

	return bt3c_get(iobase);
}


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


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

	bt3c_address(iobase, 0x7080);

	/* Fill FIFO with current frame */
	while (actual < len) {
		/* Transmit next byte */
		bt3c_put(iobase, buf[actual]);
		actual++;
	}

	bt3c_io_write(iobase, 0x7005, actual);

	return actual;
}


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

	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
		return;

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

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

		skb = skb_dequeue(&(info->txq));
		if (!skb) {
			clear_bit(XMIT_SENDING, &(info->tx_state));
			break;
		}

		/* Send frame */
		len = bt3c_write(iobase, 256, skb->data, skb->len);

		if (len != skb->len) {
			BT_ERR("Very strange");
		}

		kfree_skb(skb);

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

	} while (0);
}


static void bt3c_receive(struct bt3c_info *info)
{
	unsigned int iobase;
	int size = 0, avail;

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

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

	avail = bt3c_read(iobase, 0x7006);
	//printk("bt3c_cs: receiving %d bytes\n", avail);

	bt3c_address(iobase, 0x7480);
	while (size < avail) {
		size++;
		info->hdev->stat.byte_rx++;

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


		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
			inb(iobase + DATA_H);
			//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);

			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 {

			__u8 x = inb(iobase + DATA_L);

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

			if (info->rx_count == 0) {

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

				switch (info->rx_state) {

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

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

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

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

				}

			}

		}

	}

	bt3c_io_write(iobase, 0x7006, 0x0000);
}


static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
{
	struct bt3c_info *info = dev_inst;
	unsigned int iobase;
	int iir;
	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 + CONTROL);
	if (iir & 0x80) {
		int stat = bt3c_read(iobase, 0x7001);

		if ((stat & 0xff) == 0x7f) {
			BT_ERR("Very strange (stat=0x%04x)", stat);
		} else if ((stat & 0xff) != 0xff) {
			if (stat & 0x0020) {
				int status = bt3c_read(iobase, 0x7002) & 0x10;
				BT_INFO("%s: Antenna %s", info->hdev->name,
							status ? "out" : "in");
			}
			if (stat & 0x0001)
				bt3c_receive(info);
			if (stat & 0x0002) {
				//BT_ERR("Ack (stat=0x%04x)", stat);
				clear_bit(XMIT_SENDING, &(info->tx_state));
				bt3c_write_wakeup(info);
			}

			bt3c_io_write(iobase, 0x7001, 0x0000);

			outb(iir, iobase + CONTROL);
		}
		r = IRQ_HANDLED;
	}

	spin_unlock(&(info->lock));

	return r;
}


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


static int bt3c_hci_flush(struct hci_dev *hdev)
{
	struct bt3c_info *info = hci_get_drvdata(hdev);

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

	return 0;
}


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

	return 0;
}


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

	bt3c_hci_flush(hdev);

	return 0;
}


static int bt3c_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct bt3c_info *info = hci_get_drvdata(hdev);
	unsigned long flags;

	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);

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

	bt3c_write_wakeup(info);

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

	return 0;
}


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


static int bt3c_load_firmware(struct bt3c_info *info,
			      const unsigned char *firmware,
			      int count)
{
	char *ptr = (char *) firmware;
	char b[9];
	unsigned int iobase, size, addr, fcs, tmp;
	int i, err = 0;

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

	/* Reset */
	bt3c_io_write(iobase, 0x8040, 0x0404);
	bt3c_io_write(iobase, 0x8040, 0x0400);

	udelay(1);

	bt3c_io_write(iobase, 0x8040, 0x0404);

	udelay(17);

	/* Load */
	while (count) {
		if (ptr[0] != 'S') {
			BT_ERR("Bad address in firmware");
			err = -EFAULT;
			goto error;
		}

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 2, 2);
		size = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 4, 8);
		addr = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + (size * 2) + 2, 2);
		fcs = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		for (tmp = 0, i = 0; i < size; i++) {
			memcpy(b, ptr + (i * 2) + 2, 2);
			tmp += simple_strtol(b, NULL, 16);
		}

		if (((tmp + fcs) & 0xff) != 0xff) {
			BT_ERR("Checksum error in firmware");
			err = -EILSEQ;
			goto error;
		}

		if (ptr[1] == '3') {
			bt3c_address(iobase, addr);

			memset(b, 0, sizeof(b));
			for (i = 0; i < (size - 4) / 2; i++) {
				memcpy(b, ptr + (i * 4) + 12, 4);
				tmp = simple_strtoul(b, NULL, 16);
				bt3c_put(iobase, tmp);
			}
		}

		ptr   += (size * 2) + 6;
		count -= (size * 2) + 6;
	}

	udelay(17);

	/* Boot */
	bt3c_address(iobase, 0x3000);
	outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);

error:
	udelay(17);

	/* Clear */
	bt3c_io_write(iobase, 0x7006, 0x0000);
	bt3c_io_write(iobase, 0x7005, 0x0000);
	bt3c_io_write(iobase, 0x7001, 0x0000);

	return err;
}


static int bt3c_open(struct bt3c_info *info)
{
	const struct firmware *firmware;
	struct hci_dev *hdev;
	int err;

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

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

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

	info->hdev = hdev;

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

	hdev->open  = bt3c_hci_open;
	hdev->close = bt3c_hci_close;
	hdev->flush = bt3c_hci_flush;
	hdev->send  = bt3c_hci_send_frame;

	/* Load firmware */
	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
	if (err < 0) {
		BT_ERR("Firmware request failed");
		goto error;
	}

	err = bt3c_load_firmware(info, firmware->data, firmware->size);

	release_firmware(firmware);

	if (err < 0) {
		BT_ERR("Firmware loading failed");
		goto error;
	}

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

	/* Register HCI device */
	err = hci_register_dev(hdev);
	if (err < 0) {
		BT_ERR("Can't register HCI device");
		goto error;
	}

	return 0;

error:
	info->hdev = NULL;
	hci_free_dev(hdev);
	return err;
}


static int bt3c_close(struct bt3c_info *info)
{
	struct hci_dev *hdev = info->hdev;

	if (!hdev)
		return -ENODEV;

	bt3c_hci_close(hdev);

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

static int bt3c_probe(struct pcmcia_device *link)
{
	struct bt3c_info *info;

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

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

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

	return bt3c_config(link);
}


static void bt3c_detach(struct pcmcia_device *link)
{
	bt3c_release(link);
}

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

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

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

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

	return pcmcia_request_io(p_dev);
}

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

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

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

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

static int bt3c_config(struct pcmcia_device *link)
{
	struct bt3c_info *info = link->priv;
	int i;
	unsigned long 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, bt3c_check_config, (void *) 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, bt3c_check_config_notpicky, NULL))
		goto found_port;

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

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

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

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

	return 0;

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


static void bt3c_release(struct pcmcia_device *link)
{
	struct bt3c_info *info = link->priv;

	bt3c_close(info);

	pcmcia_disable_device(link);
}


static const struct pcmcia_device_id bt3c_ids[] = {
	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);

static struct pcmcia_driver bt3c_driver = {
	.owner		= THIS_MODULE,
	.name		= "bt3c_cs",
	.probe		= bt3c_probe,
	.remove		= bt3c_detach,
	.id_table	= bt3c_ids,
};
module_pcmcia_driver(bt3c_driver);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for the 3Com Bluetooth PCMCIA card
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	* Jose Orlando Pereira <jop@di.uminho.pt>
	7	*
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation;
	12	*
	13	* Software distributed under the License is distributed on an "AS
	14	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	15	* implied. See the License for the specific language governing
	16	* rights and limitations under the License.
	17	*
	18	* The initial developer of the original code is David A. Hinds
	19	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	20	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	21	*
	22	*/
	23
1da177e4 LT	24	#include <linux/module.h>
	25
	26	#include <linux/kernel.h>
	27	#include <linux/init.h>
	28	#include <linux/slab.h>
	29	#include <linux/types.h>
1da177e4 LT	30	#include <linux/delay.h>
	31	#include <linux/errno.h>
	32	#include <linux/ptrace.h>
	33	#include <linux/ioport.h>
	34	#include <linux/spinlock.h>
	35	#include <linux/moduleparam.h>
	36
	37	#include <linux/skbuff.h>
	38	#include <linux/string.h>
	39	#include <linux/serial.h>
	40	#include <linux/serial_reg.h>
	41	#include <linux/bitops.h>
1da177e4 LT	42	#include <asm/io.h>
	43
	44	#include <linux/device.h>
	45	#include <linux/firmware.h>
	46
1da177e4 LT	47	#include <pcmcia/cistpl.h>
	48	#include <pcmcia/ciscode.h>
	49	#include <pcmcia/ds.h>
	50	#include <pcmcia/cisreg.h>
	51
	52	#include <net/bluetooth/bluetooth.h>
	53	#include <net/bluetooth/hci_core.h>
	54
	55
	56
	57	/* ======================== Module parameters ======================== */
	58
	59
63fbd24e	60	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	61	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
1da177e4 LT	62	MODULE_LICENSE("GPL");
2312119a	63	MODULE_FIRMWARE("BT3CPCC.bin");
1da177e4 LT	64
	65
	66
	67	/* ======================== Local structures ======================== */
	68
	69
3bbaf812	70	struct bt3c_info {
fd238232	71	struct pcmcia_device *p_dev;
1da177e4 LT	72
	73	struct hci_dev *hdev;
	74
	75	spinlock_t lock; /* For serializing operations */
	76
	77	struct sk_buff_head txq;
	78	unsigned long tx_state;
	79
	80	unsigned long rx_state;
	81	unsigned long rx_count;
	82	struct sk_buff *rx_skb;
3bbaf812	83	};
1da177e4 LT	84
1da177e4 LT	85
15b99ac1	86	static int bt3c_config(struct pcmcia_device *link);
fba395ee	87	static void bt3c_release(struct pcmcia_device *link);
1da177e4	88
cc3b4866	89	static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4	90
1da177e4 LT	91
	92	/* Transmit states */
	93	#define XMIT_SENDING 1
	94	#define XMIT_WAKEUP 2
	95	#define XMIT_WAITING 8
	96
	97	/* Receiver states */
	98	#define RECV_WAIT_PACKET_TYPE 0
	99	#define RECV_WAIT_EVENT_HEADER 1
	100	#define RECV_WAIT_ACL_HEADER 2
	101	#define RECV_WAIT_SCO_HEADER 3
	102	#define RECV_WAIT_DATA 4
	103
	104
	105
	106	/* ======================== Special I/O functions ======================== */
	107
	108
	109	#define DATA_L 0
	110	#define DATA_H 1
	111	#define ADDR_L 2
	112	#define ADDR_H 3
	113	#define CONTROL 4
	114
	115
	116	static inline void bt3c_address(unsigned int iobase, unsigned short addr)
	117	{
	118	outb(addr & 0xff, iobase + ADDR_L);
	119	outb((addr >> 8) & 0xff, iobase + ADDR_H);
	120	}
	121
	122
	123	static inline void bt3c_put(unsigned int iobase, unsigned short value)
	124	{
	125	outb(value & 0xff, iobase + DATA_L);
	126	outb((value >> 8) & 0xff, iobase + DATA_H);
	127	}
	128
	129
	130	static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
	131	{
	132	bt3c_address(iobase, addr);
	133	bt3c_put(iobase, value);
	134	}
	135
	136
	137	static inline unsigned short bt3c_get(unsigned int iobase)
	138	{
	139	unsigned short value = inb(iobase + DATA_L);
	140
	141	value \|= inb(iobase + DATA_H) << 8;
	142
	143	return value;
	144	}
	145
	146
	147	static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
	148	{
	149	bt3c_address(iobase, addr);
	150
	151	return bt3c_get(iobase);
	152	}
	153
	154
155
156	/* ======================== Interrupt handling ======================== */
157
158
159	static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
160	{
161	int actual = 0;
162
163	bt3c_address(iobase, 0x7080);
164
165	/* Fill FIFO with current frame */
166	while (actual < len) {
167	/* Transmit next byte */
168	bt3c_put(iobase, buf[actual]);
169	actual++;
170	}
171
172	bt3c_io_write(iobase, 0x7005, actual);
173
174	return actual;
175	}
176
177
3bbaf812	178	static void bt3c_write_wakeup(struct bt3c_info *info)
1da177e4 LT	179	{
	180	if (!info) {
	181	BT_ERR("Unknown device");
	182	return;
	183	}
	184
	185	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
	186	return;
	187
	188	do {
fc5fef61	189	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4	190	register struct sk_buff *skb;
fc5fef61	191	int len;
1da177e4	192
e2d40963	193	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	194	break;
1da177e4 LT	195
a08b15e6 VI	196	skb = skb_dequeue(&(info->txq));
a08b15e6 VI	197	if (!skb) {
1da177e4 LT	198	clear_bit(XMIT_SENDING, &(info->tx_state));
	199	break;
	200	}
	201
	202	/* Send frame */
	203	len = bt3c_write(iobase, 256, skb->data, skb->len);
	204
	205	if (len != skb->len) {
	206	BT_ERR("Very strange");
	207	}
	208
	209	kfree_skb(skb);
	210
	211	info->hdev->stat.byte_tx += len;
	212
	213	} while (0);
	214	}
	215
	216
3bbaf812	217	static void bt3c_receive(struct bt3c_info *info)
1da177e4 LT	218	{
	219	unsigned int iobase;
	220	int size = 0, avail;
	221
	222	if (!info) {
	223	BT_ERR("Unknown device");
	224	return;
	225	}
	226
9a017a91	227	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	228
	229	avail = bt3c_read(iobase, 0x7006);
	230	//printk("bt3c_cs: receiving %d bytes\n", avail);
	231
	232	bt3c_address(iobase, 0x7480);
	233	while (size < avail) {
	234	size++;
	235	info->hdev->stat.byte_rx++;
	236
	237	/* Allocate packet */
	238	if (info->rx_skb == NULL) {
	239	info->rx_state = RECV_WAIT_PACKET_TYPE;
	240	info->rx_count = 0;
a08b15e6 VI	241	info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
a08b15e6 VI	242	if (!info->rx_skb) {
1da177e4 LT	243	BT_ERR("Can't allocate mem for new packet");
	244	return;
	245	}
	246	}
	247
	248
	249	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	250
0d48d939	251	bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4	252	inb(iobase + DATA_H);
0d48d939	253	//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
1da177e4	254
0d48d939	255	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	256
	257	case HCI_EVENT_PKT:
	258	info->rx_state = RECV_WAIT_EVENT_HEADER;
	259	info->rx_count = HCI_EVENT_HDR_SIZE;
	260	break;
	261
	262	case HCI_ACLDATA_PKT:
	263	info->rx_state = RECV_WAIT_ACL_HEADER;
	264	info->rx_count = HCI_ACL_HDR_SIZE;
	265	break;
	266
	267	case HCI_SCODATA_PKT:
	268	info->rx_state = RECV_WAIT_SCO_HEADER;
	269	info->rx_count = HCI_SCO_HDR_SIZE;
	270	break;
	271
	272	default:
	273	/* Unknown packet */
0d48d939	274	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	275	info->hdev->stat.err_rx++;
	276	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	277
	278	kfree_skb(info->rx_skb);
	279	info->rx_skb = NULL;
	280	break;
	281
	282	}
	283
	284	} else {
	285
	286	__u8 x = inb(iobase + DATA_L);
	287
	288	*skb_put(info->rx_skb, 1) = x;
	289	inb(iobase + DATA_H);
	290	info->rx_count--;
	291
	292	if (info->rx_count == 0) {
	293
	294	int dlen;
	295	struct hci_event_hdr *eh;
	296	struct hci_acl_hdr *ah;
	297	struct hci_sco_hdr *sh;
	298
	299	switch (info->rx_state) {
	300
	301	case RECV_WAIT_EVENT_HEADER:
2a123b86	302	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	303	info->rx_state = RECV_WAIT_DATA;
	304	info->rx_count = eh->plen;
	305	break;
	306
	307	case RECV_WAIT_ACL_HEADER:
2a123b86	308	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	309	dlen = __le16_to_cpu(ah->dlen);
	310	info->rx_state = RECV_WAIT_DATA;
	311	info->rx_count = dlen;
	312	break;
	313
	314	case RECV_WAIT_SCO_HEADER:
2a123b86	315	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	316	info->rx_state = RECV_WAIT_DATA;
	317	info->rx_count = sh->dlen;
	318	break;
	319
	320	case RECV_WAIT_DATA:
e1a26170	321	hci_recv_frame(info->hdev, info->rx_skb);
1da177e4 LT	322	info->rx_skb = NULL;
	323	break;
	324
	325	}
	326
	327	}
	328
	329	}
	330
	331	}
	332
	333	bt3c_io_write(iobase, 0x7006, 0x0000);
	334	}
	335
	336
7d12e780	337	static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
1da177e4	338	{
3bbaf812	339	struct bt3c_info *info = dev_inst;
1da177e4 LT	340	unsigned int iobase;
1da177e4 LT	341	int iir;
aafcf998	342	irqreturn_t r = IRQ_NONE;
1da177e4	343
7427847d MF	344	if (!info \|\| !info->hdev)
	345	/* our irq handler is shared */
	346	return IRQ_NONE;
1da177e4	347
9a017a91	348	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	349
	350	spin_lock(&(info->lock));
	351
	352	iir = inb(iobase + CONTROL);
	353	if (iir & 0x80) {
	354	int stat = bt3c_read(iobase, 0x7001);
	355
	356	if ((stat & 0xff) == 0x7f) {
	357	BT_ERR("Very strange (stat=0x%04x)", stat);
	358	} else if ((stat & 0xff) != 0xff) {
	359	if (stat & 0x0020) {
34a55eda	360	int status = bt3c_read(iobase, 0x7002) & 0x10;
1da177e4	361	BT_INFO("%s: Antenna %s", info->hdev->name,
34a55eda	362	status ? "out" : "in");
1da177e4 LT	363	}
	364	if (stat & 0x0001)
	365	bt3c_receive(info);
	366	if (stat & 0x0002) {
	367	//BT_ERR("Ack (stat=0x%04x)", stat);
	368	clear_bit(XMIT_SENDING, &(info->tx_state));
	369	bt3c_write_wakeup(info);
	370	}
	371
	372	bt3c_io_write(iobase, 0x7001, 0x0000);
	373
	374	outb(iir, iobase + CONTROL);
	375	}
aafcf998	376	r = IRQ_HANDLED;
1da177e4 LT	377	}
	378
	379	spin_unlock(&(info->lock));
	380
aafcf998	381	return r;
1da177e4 LT	382	}
	383
	384
	385
	386	/* ======================== HCI interface ======================== */
	387
	388
	389	static int bt3c_hci_flush(struct hci_dev *hdev)
	390	{
3bbaf812	391	struct bt3c_info *info = hci_get_drvdata(hdev);
1da177e4 LT	392
	393	/* Drop TX queue */
	394	skb_queue_purge(&(info->txq));
	395
	396	return 0;
	397	}
	398
	399
	400	static int bt3c_hci_open(struct hci_dev *hdev)
	401	{
	402	set_bit(HCI_RUNNING, &(hdev->flags));
	403
	404	return 0;
	405	}
	406
	407
	408	static int bt3c_hci_close(struct hci_dev *hdev)
	409	{
	410	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	411	return 0;
	412
	413	bt3c_hci_flush(hdev);
	414
	415	return 0;
	416	}
	417
	418
7bd8f09f	419	static int bt3c_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	420	{
3bbaf812	421	struct bt3c_info *info = hci_get_drvdata(hdev);
1da177e4 LT	422	unsigned long flags;
1da177e4 LT	423
0d48d939	424	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	425	case HCI_COMMAND_PKT:
	426	hdev->stat.cmd_tx++;
	427	break;
	428	case HCI_ACLDATA_PKT:
	429	hdev->stat.acl_tx++;
	430	break;
	431	case HCI_SCODATA_PKT:
	432	hdev->stat.sco_tx++;
	433	break;
	434	};
	435
	436	/* Prepend skb with frame type */
0d48d939	437	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	438	skb_queue_tail(&(info->txq), skb);
	439
	440	spin_lock_irqsave(&(info->lock), flags);
	441
	442	bt3c_write_wakeup(info);
	443
	444	spin_unlock_irqrestore(&(info->lock), flags);
	445
	446	return 0;
	447	}
	448
	449
1da177e4 LT	450
	451	/* ======================== Card services HCI interaction ======================== */
	452
	453
3bbaf812 HS	454	static int bt3c_load_firmware(struct bt3c_info *info,
3bbaf812 HS	455	const unsigned char *firmware,
8187b4fb	456	int count)
1da177e4 LT	457	{
	458	char ptr = (char ) firmware;
	459	char b[9];
	460	unsigned int iobase, size, addr, fcs, tmp;
	461	int i, err = 0;
	462
9a017a91	463	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	464
	465	/* Reset */
	466	bt3c_io_write(iobase, 0x8040, 0x0404);
	467	bt3c_io_write(iobase, 0x8040, 0x0400);
	468
	469	udelay(1);
	470
	471	bt3c_io_write(iobase, 0x8040, 0x0404);
	472
	473	udelay(17);
	474
	475	/* Load */
	476	while (count) {
	477	if (ptr[0] != 'S') {
	478	BT_ERR("Bad address in firmware");
	479	err = -EFAULT;
	480	goto error;
	481	}
	482
	483	memset(b, 0, sizeof(b));
	484	memcpy(b, ptr + 2, 2);
51a6fbc8	485	size = simple_strtoul(b, NULL, 16);
1da177e4 LT	486
	487	memset(b, 0, sizeof(b));
	488	memcpy(b, ptr + 4, 8);
51a6fbc8	489	addr = simple_strtoul(b, NULL, 16);
1da177e4 LT	490
	491	memset(b, 0, sizeof(b));
	492	memcpy(b, ptr + (size * 2) + 2, 2);
51a6fbc8	493	fcs = simple_strtoul(b, NULL, 16);
1da177e4 LT	494
	495	memset(b, 0, sizeof(b));
	496	for (tmp = 0, i = 0; i < size; i++) {
	497	memcpy(b, ptr + (i * 2) + 2, 2);
	498	tmp += simple_strtol(b, NULL, 16);
	499	}
	500
	501	if (((tmp + fcs) & 0xff) != 0xff) {
	502	BT_ERR("Checksum error in firmware");
	503	err = -EILSEQ;
	504	goto error;
	505	}
	506
	507	if (ptr[1] == '3') {
	508	bt3c_address(iobase, addr);
	509
	510	memset(b, 0, sizeof(b));
	511	for (i = 0; i < (size - 4) / 2; i++) {
	512	memcpy(b, ptr + (i * 4) + 12, 4);
51a6fbc8	513	tmp = simple_strtoul(b, NULL, 16);
1da177e4 LT	514	bt3c_put(iobase, tmp);
	515	}
	516	}
	517
	518	ptr += (size * 2) + 6;
	519	count -= (size * 2) + 6;
	520	}
	521
	522	udelay(17);
	523
	524	/* Boot */
	525	bt3c_address(iobase, 0x3000);
	526	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	527
	528	error:
	529	udelay(17);
	530
	531	/* Clear */
	532	bt3c_io_write(iobase, 0x7006, 0x0000);
	533	bt3c_io_write(iobase, 0x7005, 0x0000);
	534	bt3c_io_write(iobase, 0x7001, 0x0000);
	535
	536	return err;
	537	}
	538
	539
3bbaf812	540	static int bt3c_open(struct bt3c_info *info)
1da177e4 LT	541	{
	542	const struct firmware *firmware;
	543	struct hci_dev *hdev;
	544	int err;
	545
	546	spin_lock_init(&(info->lock));
	547
	548	skb_queue_head_init(&(info->txq));
	549
	550	info->rx_state = RECV_WAIT_PACKET_TYPE;
	551	info->rx_count = 0;
	552	info->rx_skb = NULL;
	553
	554	/* Initialize HCI device */
	555	hdev = hci_alloc_dev();
	556	if (!hdev) {
	557	BT_ERR("Can't allocate HCI device");
	558	return -ENOMEM;
	559	}
	560
	561	info->hdev = hdev;
	562
c13854ce	563	hdev->bus = HCI_PCCARD;
155961e8	564	hci_set_drvdata(hdev, info);
27d35284	565	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	566
69b7e170 MH	567	hdev->open = bt3c_hci_open;
	568	hdev->close = bt3c_hci_close;
	569	hdev->flush = bt3c_hci_flush;
	570	hdev->send = bt3c_hci_send_frame;
1da177e4	571
1da177e4	572	/* Load firmware */
fd238232	573	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	574	if (err < 0) {
	575	BT_ERR("Firmware request failed");
	576	goto error;
	577	}
	578
	579	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	580
	581	release_firmware(firmware);
	582
	583	if (err < 0) {
	584	BT_ERR("Firmware loading failed");
	585	goto error;
	586	}
	587
	588	/* Timeout before it is safe to send the first HCI packet */
	589	msleep(1000);
	590
	591	/* Register HCI device */
	592	err = hci_register_dev(hdev);
	593	if (err < 0) {
	594	BT_ERR("Can't register HCI device");
	595	goto error;
	596	}
	597
	598	return 0;
	599
	600	error:
	601	info->hdev = NULL;
	602	hci_free_dev(hdev);
	603	return err;
	604	}
	605
	606
3bbaf812	607	static int bt3c_close(struct bt3c_info *info)
1da177e4 LT	608	{
	609	struct hci_dev *hdev = info->hdev;
	610
	611	if (!hdev)
	612	return -ENODEV;
	613
	614	bt3c_hci_close(hdev);
	615
13ea4015	616	hci_unregister_dev(hdev);
1da177e4 LT	617	hci_free_dev(hdev);
	618
	619	return 0;
	620	}
	621
15b99ac1	622	static int bt3c_probe(struct pcmcia_device *link)
1da177e4	623	{
3bbaf812	624	struct bt3c_info *info;
1da177e4 LT	625
1da177e4 LT	626	/* Create new info device */
4f61cb18	627	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	628	if (!info)
f8cfa618	629	return -ENOMEM;
1da177e4	630
fba395ee	631	info->p_dev = link;
1da177e4 LT	632	link->priv = info;
1da177e4 LT	633
00990e7c DB	634	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	635	CONF_AUTO_SET_IO;
1da177e4	636
15b99ac1	637	return bt3c_config(link);
1da177e4 LT	638	}
	639
	640
fba395ee	641	static void bt3c_detach(struct pcmcia_device *link)
1da177e4	642	{
e2d40963	643	bt3c_release(link);
1da177e4 LT	644	}
1da177e4 LT	645
00990e7c	646	static int bt3c_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	647	{
00990e7c	648	int *try = priv_data;
90abdc3b	649
510df251	650	if (!try)
00990e7c DB	651	p_dev->io_lines = 16;
	652
	653	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	654	return -EINVAL;
	655
	656	p_dev->resource[0]->end = 8;
	657	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	658	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	659
	660	return pcmcia_request_io(p_dev);
1da177e4 LT	661	}
1da177e4 LT	662
ed58872a	663	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	664	void *priv_data)
1da177e4	665	{
ed58872a DB	666	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	667	int j;
	668
00990e7c DB	669	if (p_dev->io_lines > 3)
	670	return -ENODEV;
	671
	672	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	673	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	674	p_dev->resource[0]->end = 8;
	675
	676	for (j = 0; j < 5; j++) {
	677	p_dev->resource[0]->start = base[j];
	678	p_dev->io_lines = base[j] ? 16 : 3;
	679	if (!pcmcia_request_io(p_dev))
	680	return 0;
ed58872a DB	681	}
ed58872a DB	682	return -ENODEV;
1da177e4 LT	683	}
1da177e4 LT	684
15b99ac1	685	static int bt3c_config(struct pcmcia_device *link)
1da177e4	686	{
3bbaf812	687	struct bt3c_info *info = link->priv;
ed58872a DB	688	int i;
	689	unsigned long try;
	690
	691	/* First pass: look for a config entry that looks normal.
	692	Two tries: without IO aliases, then with aliases */
	693	for (try = 0; try < 2; try++)
	694	if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
	695	goto found_port;
1da177e4 LT	696
	697	/* Second pass: try to find an entry that isn't picky about
	698	its base address, then try to grab any standard serial port
	699	address, and finally try to get any free port. */
ed58872a DB	700	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
ed58872a DB	701	goto found_port;
1da177e4	702
ed58872a	703	BT_ERR("No usable port range found");
ed58872a	704	goto failed;
1da177e4	705
ed58872a	706	found_port:
eb14120f	707	i = pcmcia_request_irq(link, &bt3c_interrupt);
9ac3e58c	708	if (i != 0)
eb14120f	709	goto failed;
1da177e4	710
1ac71e5a	711	i = pcmcia_enable_device(link);
9ac3e58c	712	if (i != 0)
1da177e4	713	goto failed;
1da177e4 LT	714
	715	if (bt3c_open(info) != 0)
	716	goto failed;
	717
15b99ac1	718	return 0;
1da177e4	719
1da177e4 LT	720	failed:
1da177e4 LT	721	bt3c_release(link);
15b99ac1	722	return -ENODEV;
1da177e4 LT	723	}
	724
	725
fba395ee	726	static void bt3c_release(struct pcmcia_device *link)
1da177e4	727	{
3bbaf812	728	struct bt3c_info *info = link->priv;
1da177e4	729
e2d40963	730	bt3c_close(info);
1da177e4	731
fba395ee	732	pcmcia_disable_device(link);
1da177e4 LT	733	}
1da177e4 LT	734
1da177e4	735
25f8f54f	736	static const struct pcmcia_device_id bt3c_ids[] = {
a01c3ed4 DB	737	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	738	PCMCIA_DEVICE_NULL
	739	};
	740	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	741
1da177e4 LT	742	static struct pcmcia_driver bt3c_driver = {
1da177e4 LT	743	.owner = THIS_MODULE,
2e9b981a	744	.name = "bt3c_cs",
15b99ac1	745	.probe = bt3c_probe,
cc3b4866	746	.remove = bt3c_detach,
a01c3ed4	747	.id_table = bt3c_ids,
1da177e4	748	};
e0c005f4	749	module_pcmcia_driver(bt3c_driver);