[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) {
			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) {

			hci_skb_pkt_type(info->rx_skb) = inb(iobase + DATA_L);
			inb(iobase + DATA_H);

			switch (hci_skb_pkt_type(info->rx_skb)) {

			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",
				       hci_skb_pkt_type(info->rx_skb));
				info->hdev->stat.err_rx++;

				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)
{
	return 0;
}


static int bt3c_hci_close(struct hci_dev *hdev)
{
	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 (hci_skb_pkt_type(skb)) {
	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), &hci_skb_pkt_type(skb), 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, tmp;
	unsigned long size, addr, fcs;
	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);
		if (kstrtoul(b, 16, &size) < 0)
			return -EINVAL;

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 4, 8);
		if (kstrtoul(b, 16, &addr) < 0)
			return -EINVAL;

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + (size * 2) + 2, 2);
		if (kstrtoul(b, 16, &fcs) < 0)
			return -EINVAL;

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