[mirror_ubuntu-artful-kernel.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 hci_dev *hdev, struct sk_buff *skb)
{
	bt3c_info_t *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(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
7bd8f09f	418	static int bt3c_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	419	{
2e174558	420	bt3c_info_t *info = hci_get_drvdata(hdev);
1da177e4 LT	421	unsigned long flags;
1da177e4 LT	422
0d48d939	423	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	424	case HCI_COMMAND_PKT:
	425	hdev->stat.cmd_tx++;
	426	break;
	427	case HCI_ACLDATA_PKT:
	428	hdev->stat.acl_tx++;
	429	break;
	430	case HCI_SCODATA_PKT:
	431	hdev->stat.sco_tx++;
	432	break;
	433	};
	434
	435	/* Prepend skb with frame type */
0d48d939	436	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	437	skb_queue_tail(&(info->txq), skb);
	438
	439	spin_lock_irqsave(&(info->lock), flags);
	440
	441	bt3c_write_wakeup(info);
	442
	443	spin_unlock_irqrestore(&(info->lock), flags);
	444
	445	return 0;
	446	}
	447
	448
1da177e4 LT	449
	450	/* ======================== Card services HCI interaction ======================== */
	451
	452
8187b4fb DW	453	static int bt3c_load_firmware(bt3c_info_t info, const unsigned char firmware,
8187b4fb DW	454	int count)
1da177e4 LT	455	{
	456	char ptr = (char ) firmware;
	457	char b[9];
	458	unsigned int iobase, size, addr, fcs, tmp;
	459	int i, err = 0;
	460
9a017a91	461	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	462
	463	/* Reset */
	464	bt3c_io_write(iobase, 0x8040, 0x0404);
	465	bt3c_io_write(iobase, 0x8040, 0x0400);
	466
	467	udelay(1);
	468
	469	bt3c_io_write(iobase, 0x8040, 0x0404);
	470
	471	udelay(17);
	472
	473	/* Load */
	474	while (count) {
	475	if (ptr[0] != 'S') {
	476	BT_ERR("Bad address in firmware");
	477	err = -EFAULT;
	478	goto error;
	479	}
	480
	481	memset(b, 0, sizeof(b));
	482	memcpy(b, ptr + 2, 2);
51a6fbc8	483	size = simple_strtoul(b, NULL, 16);
1da177e4 LT	484
	485	memset(b, 0, sizeof(b));
	486	memcpy(b, ptr + 4, 8);
51a6fbc8	487	addr = simple_strtoul(b, NULL, 16);
1da177e4 LT	488
	489	memset(b, 0, sizeof(b));
	490	memcpy(b, ptr + (size * 2) + 2, 2);
51a6fbc8	491	fcs = simple_strtoul(b, NULL, 16);
1da177e4 LT	492
	493	memset(b, 0, sizeof(b));
	494	for (tmp = 0, i = 0; i < size; i++) {
	495	memcpy(b, ptr + (i * 2) + 2, 2);
	496	tmp += simple_strtol(b, NULL, 16);
	497	}
	498
	499	if (((tmp + fcs) & 0xff) != 0xff) {
	500	BT_ERR("Checksum error in firmware");
	501	err = -EILSEQ;
	502	goto error;
	503	}
	504
	505	if (ptr[1] == '3') {
	506	bt3c_address(iobase, addr);
	507
	508	memset(b, 0, sizeof(b));
	509	for (i = 0; i < (size - 4) / 2; i++) {
	510	memcpy(b, ptr + (i * 4) + 12, 4);
51a6fbc8	511	tmp = simple_strtoul(b, NULL, 16);
1da177e4 LT	512	bt3c_put(iobase, tmp);
	513	}
	514	}
	515
	516	ptr += (size * 2) + 6;
	517	count -= (size * 2) + 6;
	518	}
	519
	520	udelay(17);
	521
	522	/* Boot */
	523	bt3c_address(iobase, 0x3000);
	524	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	525
	526	error:
	527	udelay(17);
	528
	529	/* Clear */
	530	bt3c_io_write(iobase, 0x7006, 0x0000);
	531	bt3c_io_write(iobase, 0x7005, 0x0000);
	532	bt3c_io_write(iobase, 0x7001, 0x0000);
	533
	534	return err;
	535	}
	536
	537
	538	static int bt3c_open(bt3c_info_t *info)
	539	{
	540	const struct firmware *firmware;
	541	struct hci_dev *hdev;
	542	int err;
	543
	544	spin_lock_init(&(info->lock));
	545
	546	skb_queue_head_init(&(info->txq));
	547
	548	info->rx_state = RECV_WAIT_PACKET_TYPE;
	549	info->rx_count = 0;
	550	info->rx_skb = NULL;
	551
	552	/* Initialize HCI device */
	553	hdev = hci_alloc_dev();
	554	if (!hdev) {
	555	BT_ERR("Can't allocate HCI device");
	556	return -ENOMEM;
	557	}
	558
	559	info->hdev = hdev;
	560
c13854ce	561	hdev->bus = HCI_PCCARD;
155961e8	562	hci_set_drvdata(hdev, info);
27d35284	563	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4	564
69b7e170 MH	565	hdev->open = bt3c_hci_open;
	566	hdev->close = bt3c_hci_close;
	567	hdev->flush = bt3c_hci_flush;
	568	hdev->send = bt3c_hci_send_frame;
1da177e4	569
1da177e4	570	/* Load firmware */
fd238232	571	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	572	if (err < 0) {
	573	BT_ERR("Firmware request failed");
	574	goto error;
	575	}
	576
	577	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	578
	579	release_firmware(firmware);
	580
	581	if (err < 0) {
	582	BT_ERR("Firmware loading failed");
	583	goto error;
	584	}
	585
	586	/* Timeout before it is safe to send the first HCI packet */
	587	msleep(1000);
	588
	589	/* Register HCI device */
	590	err = hci_register_dev(hdev);
	591	if (err < 0) {
	592	BT_ERR("Can't register HCI device");
	593	goto error;
	594	}
	595
	596	return 0;
	597
	598	error:
	599	info->hdev = NULL;
	600	hci_free_dev(hdev);
	601	return err;
	602	}
	603
	604
	605	static int bt3c_close(bt3c_info_t *info)
	606	{
	607	struct hci_dev *hdev = info->hdev;
	608
	609	if (!hdev)
	610	return -ENODEV;
	611
	612	bt3c_hci_close(hdev);
	613
13ea4015	614	hci_unregister_dev(hdev);
1da177e4 LT	615	hci_free_dev(hdev);
	616
	617	return 0;
	618	}
	619
15b99ac1	620	static int bt3c_probe(struct pcmcia_device *link)
1da177e4 LT	621	{
1da177e4 LT	622	bt3c_info_t *info;
1da177e4 LT	623
1da177e4 LT	624	/* Create new info device */
4f61cb18	625	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	626	if (!info)
f8cfa618	627	return -ENOMEM;
1da177e4	628
fba395ee	629	info->p_dev = link;
1da177e4 LT	630	link->priv = info;
1da177e4 LT	631
00990e7c DB	632	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	633	CONF_AUTO_SET_IO;
1da177e4	634
15b99ac1	635	return bt3c_config(link);
1da177e4 LT	636	}
	637
	638
fba395ee	639	static void bt3c_detach(struct pcmcia_device *link)
1da177e4	640	{
e2d40963	641	bt3c_release(link);
1da177e4 LT	642	}
1da177e4 LT	643
00990e7c	644	static int bt3c_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	645	{
00990e7c	646	int *try = priv_data;
90abdc3b	647
510df251	648	if (!try)
00990e7c DB	649	p_dev->io_lines = 16;
	650
	651	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	652	return -EINVAL;
	653
	654	p_dev->resource[0]->end = 8;
	655	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	656	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	657
	658	return pcmcia_request_io(p_dev);
1da177e4 LT	659	}
1da177e4 LT	660
ed58872a	661	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	662	void *priv_data)
1da177e4	663	{
ed58872a DB	664	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	665	int j;
	666
00990e7c DB	667	if (p_dev->io_lines > 3)
	668	return -ENODEV;
	669
	670	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	671	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	672	p_dev->resource[0]->end = 8;
	673
	674	for (j = 0; j < 5; j++) {
	675	p_dev->resource[0]->start = base[j];
	676	p_dev->io_lines = base[j] ? 16 : 3;
	677	if (!pcmcia_request_io(p_dev))
	678	return 0;
ed58872a DB	679	}
ed58872a DB	680	return -ENODEV;
1da177e4 LT	681	}
1da177e4 LT	682
15b99ac1	683	static int bt3c_config(struct pcmcia_device *link)
1da177e4	684	{
1da177e4	685	bt3c_info_t *info = link->priv;
ed58872a DB	686	int i;
	687	unsigned long try;
	688
	689	/* First pass: look for a config entry that looks normal.
	690	Two tries: without IO aliases, then with aliases */
	691	for (try = 0; try < 2; try++)
	692	if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
	693	goto found_port;
1da177e4 LT	694
	695	/* Second pass: try to find an entry that isn't picky about
	696	its base address, then try to grab any standard serial port
	697	address, and finally try to get any free port. */
ed58872a DB	698	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
ed58872a DB	699	goto found_port;
1da177e4	700
ed58872a	701	BT_ERR("No usable port range found");
ed58872a	702	goto failed;
1da177e4	703
ed58872a	704	found_port:
eb14120f	705	i = pcmcia_request_irq(link, &bt3c_interrupt);
9ac3e58c	706	if (i != 0)
eb14120f	707	goto failed;
1da177e4	708
1ac71e5a	709	i = pcmcia_enable_device(link);
9ac3e58c	710	if (i != 0)
1da177e4	711	goto failed;
1da177e4 LT	712
	713	if (bt3c_open(info) != 0)
	714	goto failed;
	715
15b99ac1	716	return 0;
1da177e4	717
1da177e4 LT	718	failed:
1da177e4 LT	719	bt3c_release(link);
15b99ac1	720	return -ENODEV;
1da177e4 LT	721	}
	722
	723
fba395ee	724	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	725	{
	726	bt3c_info_t *info = link->priv;
	727
e2d40963	728	bt3c_close(info);
1da177e4	729
fba395ee	730	pcmcia_disable_device(link);
1da177e4 LT	731	}
1da177e4 LT	732
1da177e4	733
25f8f54f	734	static const struct pcmcia_device_id bt3c_ids[] = {
a01c3ed4 DB	735	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	736	PCMCIA_DEVICE_NULL
	737	};
	738	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	739
1da177e4 LT	740	static struct pcmcia_driver bt3c_driver = {
1da177e4 LT	741	.owner = THIS_MODULE,
2e9b981a	742	.name = "bt3c_cs",
15b99ac1	743	.probe = bt3c_probe,
cc3b4866	744	.remove = bt3c_detach,
a01c3ed4	745	.id_table = bt3c_ids,
1da177e4	746	};
e0c005f4	747	module_pcmcia_driver(bt3c_driver);