[linux-2.6-block.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);

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

			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) {
				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
aebceccc	205	if (len != skb->len)
1da177e4	206	BT_ERR("Very strange");
1da177e4 LT	207
	208	kfree_skb(skb);
	209
	210	info->hdev->stat.byte_tx += len;
	211
	212	} while (0);
	213	}
	214
	215
3bbaf812	216	static void bt3c_receive(struct bt3c_info *info)
1da177e4 LT	217	{
	218	unsigned int iobase;
	219	int size = 0, avail;
	220
	221	if (!info) {
	222	BT_ERR("Unknown device");
	223	return;
	224	}
	225
9a017a91	226	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	227
1da177e4 LT	228	avail = bt3c_read(iobase, 0x7006);
1da177e4 LT	229
	230	bt3c_address(iobase, 0x7480);
	231	while (size < avail) {
	232	size++;
	233	info->hdev->stat.byte_rx++;
	234
	235	/* Allocate packet */
	236	if (info->rx_skb == NULL) {
	237	info->rx_state = RECV_WAIT_PACKET_TYPE;
	238	info->rx_count = 0;
a08b15e6 VI	239	info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
a08b15e6 VI	240	if (!info->rx_skb) {
1da177e4 LT	241	BT_ERR("Can't allocate mem for new packet");
	242	return;
	243	}
	244	}
	245
	246
	247	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	248
0d48d939	249	bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4	250	inb(iobase + DATA_H);
1da177e4	251
0d48d939	252	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	253
	254	case HCI_EVENT_PKT:
	255	info->rx_state = RECV_WAIT_EVENT_HEADER;
	256	info->rx_count = HCI_EVENT_HDR_SIZE;
	257	break;
	258
	259	case HCI_ACLDATA_PKT:
	260	info->rx_state = RECV_WAIT_ACL_HEADER;
	261	info->rx_count = HCI_ACL_HDR_SIZE;
	262	break;
	263
	264	case HCI_SCODATA_PKT:
	265	info->rx_state = RECV_WAIT_SCO_HEADER;
	266	info->rx_count = HCI_SCO_HDR_SIZE;
	267	break;
	268
	269	default:
	270	/* Unknown packet */
0d48d939	271	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	272	info->hdev->stat.err_rx++;
	273	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	274
	275	kfree_skb(info->rx_skb);
	276	info->rx_skb = NULL;
	277	break;
	278
	279	}
	280
	281	} else {
	282
	283	__u8 x = inb(iobase + DATA_L);
	284
	285	*skb_put(info->rx_skb, 1) = x;
	286	inb(iobase + DATA_H);
	287	info->rx_count--;
	288
	289	if (info->rx_count == 0) {
	290
	291	int dlen;
	292	struct hci_event_hdr *eh;
	293	struct hci_acl_hdr *ah;
	294	struct hci_sco_hdr *sh;
	295
	296	switch (info->rx_state) {
	297
	298	case RECV_WAIT_EVENT_HEADER:
2a123b86	299	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	300	info->rx_state = RECV_WAIT_DATA;
	301	info->rx_count = eh->plen;
	302	break;
	303
	304	case RECV_WAIT_ACL_HEADER:
2a123b86	305	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	306	dlen = __le16_to_cpu(ah->dlen);
	307	info->rx_state = RECV_WAIT_DATA;
	308	info->rx_count = dlen;
	309	break;
	310
	311	case RECV_WAIT_SCO_HEADER:
2a123b86	312	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	313	info->rx_state = RECV_WAIT_DATA;
	314	info->rx_count = sh->dlen;
	315	break;
	316
	317	case RECV_WAIT_DATA:
e1a26170	318	hci_recv_frame(info->hdev, info->rx_skb);
1da177e4 LT	319	info->rx_skb = NULL;
	320	break;
	321
	322	}
	323
	324	}
	325
	326	}
	327
	328	}
	329
	330	bt3c_io_write(iobase, 0x7006, 0x0000);
	331	}
	332
	333
7d12e780	334	static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
1da177e4	335	{
3bbaf812	336	struct bt3c_info *info = dev_inst;
1da177e4 LT	337	unsigned int iobase;
1da177e4 LT	338	int iir;
aafcf998	339	irqreturn_t r = IRQ_NONE;
1da177e4	340
7427847d MF	341	if (!info \|\| !info->hdev)
	342	/* our irq handler is shared */
	343	return IRQ_NONE;
1da177e4	344
9a017a91	345	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	346
	347	spin_lock(&(info->lock));
	348
	349	iir = inb(iobase + CONTROL);
	350	if (iir & 0x80) {
	351	int stat = bt3c_read(iobase, 0x7001);
	352
	353	if ((stat & 0xff) == 0x7f) {
	354	BT_ERR("Very strange (stat=0x%04x)", stat);
	355	} else if ((stat & 0xff) != 0xff) {
	356	if (stat & 0x0020) {
34a55eda	357	int status = bt3c_read(iobase, 0x7002) & 0x10;
1da177e4	358	BT_INFO("%s: Antenna %s", info->hdev->name,
34a55eda	359	status ? "out" : "in");
1da177e4 LT	360	}
	361	if (stat & 0x0001)
	362	bt3c_receive(info);
	363	if (stat & 0x0002) {
1da177e4 LT	364	clear_bit(XMIT_SENDING, &(info->tx_state));
	365	bt3c_write_wakeup(info);
	366	}
	367
	368	bt3c_io_write(iobase, 0x7001, 0x0000);
	369
	370	outb(iir, iobase + CONTROL);
	371	}
aafcf998	372	r = IRQ_HANDLED;
1da177e4 LT	373	}
	374
	375	spin_unlock(&(info->lock));
	376
aafcf998	377	return r;
1da177e4 LT	378	}
	379
	380
	381
	382	/* ======================== HCI interface ======================== */
	383
	384
	385	static int bt3c_hci_flush(struct hci_dev *hdev)
	386	{
3bbaf812	387	struct bt3c_info *info = hci_get_drvdata(hdev);
1da177e4 LT	388
	389	/* Drop TX queue */
	390	skb_queue_purge(&(info->txq));
	391
	392	return 0;
	393	}
	394
	395
	396	static int bt3c_hci_open(struct hci_dev *hdev)
	397	{
	398	set_bit(HCI_RUNNING, &(hdev->flags));
	399
	400	return 0;
	401	}
	402
	403
	404	static int bt3c_hci_close(struct hci_dev *hdev)
	405	{
	406	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	407	return 0;
	408
	409	bt3c_hci_flush(hdev);
	410
	411	return 0;
	412	}
	413
	414
7bd8f09f	415	static int bt3c_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	416	{
3bbaf812	417	struct bt3c_info *info = hci_get_drvdata(hdev);
1da177e4 LT	418	unsigned long flags;
1da177e4 LT	419
0d48d939	420	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	421	case HCI_COMMAND_PKT:
	422	hdev->stat.cmd_tx++;
	423	break;
	424	case HCI_ACLDATA_PKT:
	425	hdev->stat.acl_tx++;
	426	break;
	427	case HCI_SCODATA_PKT:
	428	hdev->stat.sco_tx++;
	429	break;
	430	};
	431
	432	/* Prepend skb with frame type */
0d48d939	433	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	434	skb_queue_tail(&(info->txq), skb);
	435
	436	spin_lock_irqsave(&(info->lock), flags);
	437
	438	bt3c_write_wakeup(info);
	439
	440	spin_unlock_irqrestore(&(info->lock), flags);
	441
	442	return 0;
	443	}
	444
	445
1da177e4 LT	446
	447	/* ======================== Card services HCI interaction ======================== */
	448
	449
3bbaf812 HS	450	static int bt3c_load_firmware(struct bt3c_info *info,
3bbaf812 HS	451	const unsigned char *firmware,
8187b4fb	452	int count)
1da177e4 LT	453	{
	454	char ptr = (char ) firmware;
	455	char b[9];
	456	unsigned int iobase, size, addr, fcs, tmp;
	457	int i, err = 0;
	458
9a017a91	459	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	460
	461	/* Reset */
	462	bt3c_io_write(iobase, 0x8040, 0x0404);
	463	bt3c_io_write(iobase, 0x8040, 0x0400);
	464
	465	udelay(1);
	466
	467	bt3c_io_write(iobase, 0x8040, 0x0404);
	468
	469	udelay(17);
	470
	471	/* Load */
	472	while (count) {
	473	if (ptr[0] != 'S') {
	474	BT_ERR("Bad address in firmware");
	475	err = -EFAULT;
	476	goto error;
	477	}
	478
	479	memset(b, 0, sizeof(b));
	480	memcpy(b, ptr + 2, 2);
51a6fbc8	481	size = simple_strtoul(b, NULL, 16);
1da177e4 LT	482
	483	memset(b, 0, sizeof(b));
	484	memcpy(b, ptr + 4, 8);
51a6fbc8	485	addr = simple_strtoul(b, NULL, 16);
1da177e4 LT	486
	487	memset(b, 0, sizeof(b));
	488	memcpy(b, ptr + (size * 2) + 2, 2);
51a6fbc8	489	fcs = simple_strtoul(b, NULL, 16);
1da177e4 LT	490
	491	memset(b, 0, sizeof(b));
	492	for (tmp = 0, i = 0; i < size; i++) {
	493	memcpy(b, ptr + (i * 2) + 2, 2);
	494	tmp += simple_strtol(b, NULL, 16);
	495	}
	496
	497	if (((tmp + fcs) & 0xff) != 0xff) {
	498	BT_ERR("Checksum error in firmware");
	499	err = -EILSEQ;
	500	goto error;
	501	}
	502
	503	if (ptr[1] == '3') {
	504	bt3c_address(iobase, addr);
	505
	506	memset(b, 0, sizeof(b));
	507	for (i = 0; i < (size - 4) / 2; i++) {
	508	memcpy(b, ptr + (i * 4) + 12, 4);
51a6fbc8	509	tmp = simple_strtoul(b, NULL, 16);
1da177e4 LT	510	bt3c_put(iobase, tmp);
	511	}
	512	}
	513
	514	ptr += (size * 2) + 6;
	515	count -= (size * 2) + 6;
	516	}
	517
	518	udelay(17);
	519
	520	/* Boot */
	521	bt3c_address(iobase, 0x3000);
	522	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	523
	524	error:
	525	udelay(17);
	526
	527	/* Clear */
	528	bt3c_io_write(iobase, 0x7006, 0x0000);
	529	bt3c_io_write(iobase, 0x7005, 0x0000);
	530	bt3c_io_write(iobase, 0x7001, 0x0000);
	531
	532	return err;
	533	}
	534
	535
3bbaf812	536	static int bt3c_open(struct bt3c_info *info)
1da177e4 LT	537	{
	538	const struct firmware *firmware;
	539	struct hci_dev *hdev;
	540	int err;
	541
	542	spin_lock_init(&(info->lock));
	543
	544	skb_queue_head_init(&(info->txq));
	545
	546	info->rx_state = RECV_WAIT_PACKET_TYPE;
	547	info->rx_count = 0;
	548	info->rx_skb = NULL;
	549
	550	/* Initialize HCI device */
	551	hdev = hci_alloc_dev();
	552	if (!hdev) {
	553	BT_ERR("Can't allocate HCI device");
	554	return -ENOMEM;
	555	}
	556
	557	info->hdev = hdev;
	558
c13854ce	559	hdev->bus = HCI_PCCARD;
155961e8	560	hci_set_drvdata(hdev, info);
27d35284	561	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	562
69b7e170 MH	563	hdev->open = bt3c_hci_open;
	564	hdev->close = bt3c_hci_close;
	565	hdev->flush = bt3c_hci_flush;
	566	hdev->send = bt3c_hci_send_frame;
1da177e4	567
1da177e4	568	/* Load firmware */
fd238232	569	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	570	if (err < 0) {
	571	BT_ERR("Firmware request failed");
	572	goto error;
	573	}
	574
	575	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	576
	577	release_firmware(firmware);
	578
	579	if (err < 0) {
	580	BT_ERR("Firmware loading failed");
	581	goto error;
	582	}
	583
	584	/* Timeout before it is safe to send the first HCI packet */
	585	msleep(1000);
	586
	587	/* Register HCI device */
	588	err = hci_register_dev(hdev);
	589	if (err < 0) {
	590	BT_ERR("Can't register HCI device");
	591	goto error;
	592	}
	593
	594	return 0;
	595
	596	error:
	597	info->hdev = NULL;
	598	hci_free_dev(hdev);
	599	return err;
	600	}
	601
	602
3bbaf812	603	static int bt3c_close(struct bt3c_info *info)
1da177e4 LT	604	{
	605	struct hci_dev *hdev = info->hdev;
	606
	607	if (!hdev)
	608	return -ENODEV;
	609
	610	bt3c_hci_close(hdev);
	611
13ea4015	612	hci_unregister_dev(hdev);
1da177e4 LT	613	hci_free_dev(hdev);
	614
	615	return 0;
	616	}
	617
15b99ac1	618	static int bt3c_probe(struct pcmcia_device *link)
1da177e4	619	{
3bbaf812	620	struct bt3c_info *info;
1da177e4 LT	621
1da177e4 LT	622	/* Create new info device */
4f61cb18	623	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	624	if (!info)
f8cfa618	625	return -ENOMEM;
1da177e4	626
fba395ee	627	info->p_dev = link;
1da177e4 LT	628	link->priv = info;
1da177e4 LT	629
00990e7c DB	630	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	631	CONF_AUTO_SET_IO;
1da177e4	632
15b99ac1	633	return bt3c_config(link);
1da177e4 LT	634	}
	635
	636
fba395ee	637	static void bt3c_detach(struct pcmcia_device *link)
1da177e4	638	{
e2d40963	639	bt3c_release(link);
1da177e4 LT	640	}
1da177e4 LT	641
00990e7c	642	static int bt3c_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	643	{
00990e7c	644	int *try = priv_data;
90abdc3b	645
510df251	646	if (!try)
00990e7c DB	647	p_dev->io_lines = 16;
	648
	649	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	650	return -EINVAL;
	651
	652	p_dev->resource[0]->end = 8;
	653	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	654	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	655
	656	return pcmcia_request_io(p_dev);
1da177e4 LT	657	}
1da177e4 LT	658
ed58872a	659	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	660	void *priv_data)
1da177e4	661	{
ed58872a DB	662	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	663	int j;
	664
00990e7c DB	665	if (p_dev->io_lines > 3)
	666	return -ENODEV;
	667
	668	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	669	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	670	p_dev->resource[0]->end = 8;
	671
	672	for (j = 0; j < 5; j++) {
	673	p_dev->resource[0]->start = base[j];
	674	p_dev->io_lines = base[j] ? 16 : 3;
	675	if (!pcmcia_request_io(p_dev))
	676	return 0;
ed58872a DB	677	}
ed58872a DB	678	return -ENODEV;
1da177e4 LT	679	}
1da177e4 LT	680
15b99ac1	681	static int bt3c_config(struct pcmcia_device *link)
1da177e4	682	{
3bbaf812	683	struct bt3c_info *info = link->priv;
ed58872a DB	684	int i;
	685	unsigned long try;
	686
	687	/* First pass: look for a config entry that looks normal.
	688	Two tries: without IO aliases, then with aliases */
	689	for (try = 0; try < 2; try++)
	690	if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
	691	goto found_port;
1da177e4 LT	692
	693	/* Second pass: try to find an entry that isn't picky about
	694	its base address, then try to grab any standard serial port
	695	address, and finally try to get any free port. */
ed58872a DB	696	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
ed58872a DB	697	goto found_port;
1da177e4	698
ed58872a	699	BT_ERR("No usable port range found");
ed58872a	700	goto failed;
1da177e4	701
ed58872a	702	found_port:
eb14120f	703	i = pcmcia_request_irq(link, &bt3c_interrupt);
9ac3e58c	704	if (i != 0)
eb14120f	705	goto failed;
1da177e4	706
1ac71e5a	707	i = pcmcia_enable_device(link);
9ac3e58c	708	if (i != 0)
1da177e4	709	goto failed;
1da177e4 LT	710
	711	if (bt3c_open(info) != 0)
	712	goto failed;
	713
15b99ac1	714	return 0;
1da177e4	715
1da177e4 LT	716	failed:
1da177e4 LT	717	bt3c_release(link);
15b99ac1	718	return -ENODEV;
1da177e4 LT	719	}
	720
	721
fba395ee	722	static void bt3c_release(struct pcmcia_device *link)
1da177e4	723	{
3bbaf812	724	struct bt3c_info *info = link->priv;
1da177e4	725
e2d40963	726	bt3c_close(info);
1da177e4	727
fba395ee	728	pcmcia_disable_device(link);
1da177e4 LT	729	}
1da177e4 LT	730
1da177e4	731
25f8f54f	732	static const struct pcmcia_device_id bt3c_ids[] = {
a01c3ed4 DB	733	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	734	PCMCIA_DEVICE_NULL
	735	};
	736	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	737
1da177e4 LT	738	static struct pcmcia_driver bt3c_driver = {
1da177e4 LT	739	.owner = THIS_MODULE,
2e9b981a	740	.name = "bt3c_cs",
15b99ac1	741	.probe = bt3c_probe,
cc3b4866	742	.remove = bt3c_detach,
a01c3ed4	743	.id_table = bt3c_ids,
1da177e4	744	};
e0c005f4	745	module_pcmcia_driver(bt3c_driver);