[mirror_ubuntu-bionic-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;

		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(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;
			info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
			if (!info->rx_skb) {
				BT_ERR("Can't allocate mem for new packet");
				return;
			}
		}


		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

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