[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
	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
	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>
	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>
	42	#include <asm/io.h>
	43
	44	#include <linux/device.h>
	45	#include <linux/firmware.h>
	46
	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
	60	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
	61	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
	62	MODULE_LICENSE("GPL");
	63	MODULE_FIRMWARE("BT3CPCC.bin");
	64
	65
	66
	67	/* ======================== Local structures ======================== */
	68
	69
	70	struct bt3c_info {
	71	struct pcmcia_device *p_dev;
	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	};
	84
	85
	86	static int bt3c_config(struct pcmcia_device *link);
	87	static void bt3c_release(struct pcmcia_device *link);
	88
	89	static void bt3c_detach(struct pcmcia_device *p_dev);
	90
	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(struct bt3c_info *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 {
	189	unsigned int iobase = info->p_dev->resource[0]->start;
	190	register struct sk_buff *skb;
	191	int len;
	192
	193	if (!pcmcia_dev_present(info->p_dev))
	194	break;
	195
	196	skb = skb_dequeue(&(info->txq));
	197	if (!skb) {
	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	kfree_skb(skb);
	209
	210	info->hdev->stat.byte_tx += len;
	211
	212	} while (0);
	213	}
	214
	215
	216	static void bt3c_receive(struct bt3c_info *info)
	217	{
	218	unsigned int iobase;
	219	int size = 0, avail;
	220
	221	if (!info) {
	222	BT_ERR("Unknown device");
	223	return;
	224	}
	225
	226	iobase = info->p_dev->resource[0]->start;
	227
	228	avail = bt3c_read(iobase, 0x7006);
	229
	230	bt3c_address(iobase, 0x7480);
	231	while (size < avail) {
	232	size++;
	233	info->hdev->stat.byte_rx++;
	234
	235	/* Allocate packet */
	236	if (!info->rx_skb) {
	237	info->rx_state = RECV_WAIT_PACKET_TYPE;
	238	info->rx_count = 0;
	239	info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
	240	if (!info->rx_skb) {
	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
	249	hci_skb_pkt_type(info->rx_skb) = inb(iobase + DATA_L);
	250	inb(iobase + DATA_H);
	251
	252	switch (hci_skb_pkt_type(info->rx_skb)) {
	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 */
	271	BT_ERR("Unknown HCI packet with type 0x%02x received",
	272	hci_skb_pkt_type(info->rx_skb));
	273	info->hdev->stat.err_rx++;
	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:
	299	eh = hci_event_hdr(info->rx_skb);
	300	info->rx_state = RECV_WAIT_DATA;
	301	info->rx_count = eh->plen;
	302	break;
	303
	304	case RECV_WAIT_ACL_HEADER:
	305	ah = hci_acl_hdr(info->rx_skb);
	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:
	312	sh = hci_sco_hdr(info->rx_skb);
	313	info->rx_state = RECV_WAIT_DATA;
	314	info->rx_count = sh->dlen;
	315	break;
	316
	317	case RECV_WAIT_DATA:
	318	hci_recv_frame(info->hdev, info->rx_skb);
	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
	334	static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
	335	{
	336	struct bt3c_info *info = dev_inst;
	337	unsigned int iobase;
	338	int iir;
	339	irqreturn_t r = IRQ_NONE;
	340
	341	if (!info \|\| !info->hdev)
	342	/* our irq handler is shared */
	343	return IRQ_NONE;
	344
	345	iobase = info->p_dev->resource[0]->start;
	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) {
	357	int status = bt3c_read(iobase, 0x7002) & 0x10;
	358	BT_INFO("%s: Antenna %s", info->hdev->name,
	359	status ? "out" : "in");
	360	}
	361	if (stat & 0x0001)
	362	bt3c_receive(info);
	363	if (stat & 0x0002) {
	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	}
	372	r = IRQ_HANDLED;
	373	}
	374
	375	spin_unlock(&(info->lock));
	376
	377	return r;
	378	}
	379
	380
	381
	382	/* ======================== HCI interface ======================== */
	383
	384
	385	static int bt3c_hci_flush(struct hci_dev *hdev)
	386	{
	387	struct bt3c_info *info = hci_get_drvdata(hdev);
	388
	389	/* Drop TX queue */
	390	skb_queue_purge(&(info->txq));
	391
	392	return 0;
	393	}
	394
	395
	396	static int bt3c_hci_open(struct hci_dev *hdev)
	397	{
	398	return 0;
	399	}
	400
	401
	402	static int bt3c_hci_close(struct hci_dev *hdev)
	403	{
	404	bt3c_hci_flush(hdev);
	405
	406	return 0;
	407	}
	408
	409
	410	static int bt3c_hci_send_frame(struct hci_dev hdev, struct sk_buff skb)
	411	{
	412	struct bt3c_info *info = hci_get_drvdata(hdev);
	413	unsigned long flags;
	414
	415	switch (hci_skb_pkt_type(skb)) {
	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;
	425	}
	426
	427	/* Prepend skb with frame type */
	428	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
	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
	441
	442	/* ======================== Card services HCI interaction ======================== */
	443
	444
	445	static int bt3c_load_firmware(struct bt3c_info *info,
	446	const unsigned char *firmware,
	447	int count)
	448	{
	449	char ptr = (char ) firmware;
	450	char b[9];
	451	unsigned int iobase, tmp;
	452	unsigned long size, addr, fcs;
	453	int i, err = 0;
	454
	455	iobase = info->p_dev->resource[0]->start;
	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);
	477	if (kstrtoul(b, 16, &size) < 0)
	478	return -EINVAL;
	479
	480	memset(b, 0, sizeof(b));
	481	memcpy(b, ptr + 4, 8);
	482	if (kstrtoul(b, 16, &addr) < 0)
	483	return -EINVAL;
	484
	485	memset(b, 0, sizeof(b));
	486	memcpy(b, ptr + (size * 2) + 2, 2);
	487	if (kstrtoul(b, 16, &fcs) < 0)
	488	return -EINVAL;
	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);
	508	tmp = simple_strtoul(b, NULL, 16);
	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
	535	static int bt3c_open(struct bt3c_info *info)
	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
	558	hdev->bus = HCI_PCCARD;
	559	hci_set_drvdata(hdev, info);
	560	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
	561
	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;
	566
	567	/* Load firmware */
	568	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
	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
	602	static int bt3c_close(struct bt3c_info *info)
	603	{
	604	struct hci_dev *hdev = info->hdev;
	605
	606	if (!hdev)
	607	return -ENODEV;
	608
	609	bt3c_hci_close(hdev);
	610
	611	hci_unregister_dev(hdev);
	612	hci_free_dev(hdev);
	613
	614	return 0;
	615	}
	616
	617	static int bt3c_probe(struct pcmcia_device *link)
	618	{
	619	struct bt3c_info *info;
	620
	621	/* Create new info device */
	622	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
	623	if (!info)
	624	return -ENOMEM;
	625
	626	info->p_dev = link;
	627	link->priv = info;
	628
	629	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
	630	CONF_AUTO_SET_IO;
	631
	632	return bt3c_config(link);
	633	}
	634
	635
	636	static void bt3c_detach(struct pcmcia_device *link)
	637	{
	638	bt3c_release(link);
	639	}
	640
	641	static int bt3c_check_config(struct pcmcia_device p_dev, void priv_data)
	642	{
	643	int *try = priv_data;
	644
	645	if (!try)
	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);
	656	}
	657
	658	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
	659	void *priv_data)
	660	{
	661	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	662	int j;
	663
	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;
	676	}
	677	return -ENODEV;
	678	}
	679
	680	static int bt3c_config(struct pcmcia_device *link)
	681	{
	682	struct bt3c_info *info = link->priv;
	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;
	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. */
	695	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
	696	goto found_port;
	697
	698	BT_ERR("No usable port range found");
	699	goto failed;
	700
	701	found_port:
	702	i = pcmcia_request_irq(link, &bt3c_interrupt);
	703	if (i != 0)
	704	goto failed;
	705
	706	i = pcmcia_enable_device(link);
	707	if (i != 0)
	708	goto failed;
	709
	710	if (bt3c_open(info) != 0)
	711	goto failed;
	712
	713	return 0;
	714
	715	failed:
	716	bt3c_release(link);
	717	return -ENODEV;
	718	}
	719
	720
	721	static void bt3c_release(struct pcmcia_device *link)
	722	{
	723	struct bt3c_info *info = link->priv;
	724
	725	bt3c_close(info);
	726
	727	pcmcia_disable_device(link);
	728	}
	729
	730
	731	static const struct pcmcia_device_id bt3c_ids[] = {
	732	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	733	PCMCIA_DEVICE_NULL
	734	};
	735	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	736
	737	static struct pcmcia_driver bt3c_driver = {
	738	.owner = THIS_MODULE,
	739	.name = "bt3c_cs",
	740	.probe = bt3c_probe,
	741	.remove = bt3c_detach,
	742	.id_table = bt3c_ids,
	743	};
	744	module_pcmcia_driver(bt3c_driver);