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


typedef struct bt3c_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;
} bt3c_info_t;


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(bt3c_info_t *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;


		if (!(skb = skb_dequeue(&(info->txq)))) {
			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(bt3c_info_t *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;
			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) {

			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)
{
	bt3c_info_t *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)
{
	bt3c_info_t *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 sk_buff *skb)
{
	bt3c_info_t *info;
	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
	unsigned long flags;

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

	info = hci_get_drvdata(hdev);

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