[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / bluetooth / bt3c_cs.c

/*
 *
 *  Driver for the 3Com Bluetooth PCMCIA card
 *
 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
 *                           Jose Orlando Pereira <jop@di.uminho.pt>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation;
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing
 *  rights and limitations under the License.
 *
 *  The initial developer of the original code is David A. Hinds
 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/spinlock.h>
#include <linux/moduleparam.h>

#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/bitops.h>
#include <asm/io.h>

#include <linux/device.h>
#include <linux/firmware.h>

#include <pcmcia/cistpl.h>
#include <pcmcia/ciscode.h>
#include <pcmcia/ds.h>
#include <pcmcia/cisreg.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>


/* ======================== Module parameters ======================== */


MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("BT3CPCC.bin");


/* ======================== Local structures ======================== */


typedef struct bt3c_info_t {
	struct pcmcia_device *p_dev;

	struct hci_dev *hdev;

	spinlock_t lock;		/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

	unsigned long rx_state;
	unsigned long rx_count;
	struct sk_buff *rx_skb;
} bt3c_info_t;


static int bt3c_config(struct pcmcia_device *link);
static void bt3c_release(struct pcmcia_device *link);

static void bt3c_detach(struct pcmcia_device *p_dev);


/* Transmit states  */
#define XMIT_SENDING  1
#define XMIT_WAKEUP   2
#define XMIT_WAITING  8

/* Receiver states */
#define RECV_WAIT_PACKET_TYPE   0
#define RECV_WAIT_EVENT_HEADER  1
#define RECV_WAIT_ACL_HEADER    2
#define RECV_WAIT_SCO_HEADER    3
#define RECV_WAIT_DATA          4


/* ======================== Special I/O functions ======================== */


#define DATA_L   0
#define DATA_H   1
#define ADDR_L   2
#define ADDR_H   3
#define CONTROL  4


static inline void bt3c_address(unsigned int iobase, unsigned short addr)
{
	outb(addr & 0xff, iobase + ADDR_L);
	outb((addr >> 8) & 0xff, iobase + ADDR_H);
}


static inline void bt3c_put(unsigned int iobase, unsigned short value)
{
	outb(value & 0xff, iobase + DATA_L);
	outb((value >> 8) & 0xff, iobase + DATA_H);
}


static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
{
	bt3c_address(iobase, addr);
	bt3c_put(iobase, value);
}


static inline unsigned short bt3c_get(unsigned int iobase)
{
	unsigned short value = inb(iobase + DATA_L);

	value |= inb(iobase + DATA_H) << 8;

	return value;
}


static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
{
	bt3c_address(iobase, addr);

	return bt3c_get(iobase);
}


/* ======================== Interrupt handling ======================== */


static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
{
	int actual = 0;

	bt3c_address(iobase, 0x7080);

	/* Fill FIFO with current frame */
	while (actual < len) {
		/* Transmit next byte */
		bt3c_put(iobase, buf[actual]);
		actual++;
	}

	bt3c_io_write(iobase, 0x7005, actual);

	return actual;
}


static void bt3c_write_wakeup(bt3c_info_t *info)
{
	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
		return;

	do {
		unsigned int iobase = info->p_dev->resource[0]->start;
		register struct sk_buff *skb;
		int len;

		if (!pcmcia_dev_present(info->p_dev))
			break;


		if (!(skb = skb_dequeue(&(info->txq)))) {
			clear_bit(XMIT_SENDING, &(info->tx_state));
			break;
		}

		/* Send frame */
		len = bt3c_write(iobase, 256, skb->data, skb->len);

		if (len != skb->len) {
			BT_ERR("Very strange");
		}

		kfree_skb(skb);

		info->hdev->stat.byte_tx += len;

	} while (0);
}


static void bt3c_receive(bt3c_info_t *info)
{
	unsigned int iobase;
	int size = 0, avail;

	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	iobase = info->p_dev->resource[0]->start;

	avail = bt3c_read(iobase, 0x7006);
	//printk("bt3c_cs: receiving %d bytes\n", avail);

	bt3c_address(iobase, 0x7480);
	while (size < avail) {
		size++;
		info->hdev->stat.byte_rx++;

		/* Allocate packet */
		if (info->rx_skb == NULL) {
			info->rx_state = RECV_WAIT_PACKET_TYPE;
			info->rx_count = 0;
			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
				BT_ERR("Can't allocate mem for new packet");
				return;
			}
		}


		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			info->rx_skb->dev = (void *) info->hdev;
			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->rx_skb);
					info->rx_skb = NULL;
					break;

				}

			}

		}

	}

	bt3c_io_write(iobase, 0x7006, 0x0000);
}


static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
{
	bt3c_info_t *info = dev_inst;
	unsigned int iobase;
	int iir;
	irqreturn_t r = IRQ_NONE;

	if (!info || !info->hdev)
		/* our irq handler is shared */
		return IRQ_NONE;

	iobase = info->p_dev->resource[0]->start;

	spin_lock(&(info->lock));

	iir = inb(iobase + CONTROL);
	if (iir & 0x80) {
		int stat = bt3c_read(iobase, 0x7001);

		if ((stat & 0xff) == 0x7f) {
			BT_ERR("Very strange (stat=0x%04x)", stat);
		} else if ((stat & 0xff) != 0xff) {
			if (stat & 0x0020) {
				int status = bt3c_read(iobase, 0x7002) & 0x10;
				BT_INFO("%s: Antenna %s", info->hdev->name,
							status ? "out" : "in");
			}
			if (stat & 0x0001)
				bt3c_receive(info);
			if (stat & 0x0002) {
				//BT_ERR("Ack (stat=0x%04x)", stat);
				clear_bit(XMIT_SENDING, &(info->tx_state));
				bt3c_write_wakeup(info);
			}

			bt3c_io_write(iobase, 0x7001, 0x0000);

			outb(iir, iobase + CONTROL);
		}
		r = IRQ_HANDLED;
	}

	spin_unlock(&(info->lock));

	return r;
}


/* ======================== HCI interface ======================== */


static int bt3c_hci_flush(struct hci_dev *hdev)
{
	bt3c_info_t *info = hci_get_drvdata(hdev);

	/* Drop TX queue */
	skb_queue_purge(&(info->txq));

	return 0;
}


static int bt3c_hci_open(struct hci_dev *hdev)
{
	set_bit(HCI_RUNNING, &(hdev->flags));

	return 0;
}


static int bt3c_hci_close(struct hci_dev *hdev)
{
	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
		return 0;

	bt3c_hci_flush(hdev);

	return 0;
}


static int bt3c_hci_send_frame(struct sk_buff *skb)
{
	bt3c_info_t *info;
	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
	unsigned long flags;

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

	info = hci_get_drvdata(hdev);

	switch (bt_cb(skb)->pkt_type) {
	case HCI_COMMAND_PKT:
		hdev->stat.cmd_tx++;
		break;
	case HCI_ACLDATA_PKT:
		hdev->stat.acl_tx++;
		break;
	case HCI_SCODATA_PKT:
		hdev->stat.sco_tx++;
		break;
	};

	/* Prepend skb with frame type */
	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
	skb_queue_tail(&(info->txq), skb);

	spin_lock_irqsave(&(info->lock), flags);

	bt3c_write_wakeup(info);

	spin_unlock_irqrestore(&(info->lock), flags);

	return 0;
}


static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
{
	return -ENOIOCTLCMD;
}


/* ======================== 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;
	hdev->ioctl    = bt3c_hci_ioctl;

	/* Load firmware */
	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
	if (err < 0) {
		BT_ERR("Firmware request failed");
		goto error;
	}

	err = bt3c_load_firmware(info, firmware->data, firmware->size);

	release_firmware(firmware);

	if (err < 0) {
		BT_ERR("Firmware loading failed");
		goto error;
	}

	/* Timeout before it is safe to send the first HCI packet */
	msleep(1000);

	/* Register HCI device */
	err = hci_register_dev(hdev);
	if (err < 0) {
		BT_ERR("Can't register HCI device");
		goto error;
	}

	return 0;

error:
	info->hdev = NULL;
	hci_free_dev(hdev);
	return err;
}


static int bt3c_close(bt3c_info_t *info)
{
	struct hci_dev *hdev = info->hdev;

	if (!hdev)
		return -ENODEV;

	bt3c_hci_close(hdev);

	hci_unregister_dev(hdev);
	hci_free_dev(hdev);

	return 0;
}

static int bt3c_probe(struct pcmcia_device *link)
{
	bt3c_info_t *info;

	/* Create new info device */
	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->p_dev = link;
	link->priv = info;

	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
		CONF_AUTO_SET_IO;

	return bt3c_config(link);
}


static void bt3c_detach(struct pcmcia_device *link)
{
	bt3c_release(link);
}

static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
{
	int *try = priv_data;

	if (!try)
		p_dev->io_lines = 16;

	if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
		return -EINVAL;

	p_dev->resource[0]->end = 8;
	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;

	return pcmcia_request_io(p_dev);
}

static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
				      void *priv_data)
{
	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	int j;

	if (p_dev->io_lines > 3)
		return -ENODEV;

	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
	p_dev->resource[0]->end = 8;

	for (j = 0; j < 5; j++) {
		p_dev->resource[0]->start = base[j];
		p_dev->io_lines = base[j] ? 16 : 3;
		if (!pcmcia_request_io(p_dev))
			return 0;
	}
	return -ENODEV;
}

static int bt3c_config(struct pcmcia_device *link)
{
	bt3c_info_t *info = link->priv;
	int i;
	unsigned long try;

	/* First pass: look for a config entry that looks normal.
	   Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++)
		if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
			goto found_port;

	/* Second pass: try to find an entry that isn't picky about
	   its base address, then try to grab any standard serial port
	   address, and finally try to get any free port. */
	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
		goto found_port;

	BT_ERR("No usable port range found");
	goto failed;

found_port:
	i = pcmcia_request_irq(link, &bt3c_interrupt);
	if (i != 0)
		goto failed;

	i = pcmcia_enable_device(link);
	if (i != 0)
		goto failed;

	if (bt3c_open(info) != 0)
		goto failed;

	return 0;

failed:
	bt3c_release(link);
	return -ENODEV;
}


static void bt3c_release(struct pcmcia_device *link)
{
	bt3c_info_t *info = link->priv;

	bt3c_close(info);

	pcmcia_disable_device(link);
}


static const struct pcmcia_device_id bt3c_ids[] = {
	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);

static struct pcmcia_driver bt3c_driver = {
	.owner		= THIS_MODULE,
	.name		= "bt3c_cs",
	.probe		= bt3c_probe,
	.remove		= bt3c_detach,
	.id_table	= bt3c_ids,
};
module_pcmcia_driver(bt3c_driver);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for the 3Com Bluetooth PCMCIA card
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	* Jose Orlando Pereira <jop@di.uminho.pt>
	7	*
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation;
	12	*
	13	* Software distributed under the License is distributed on an "AS
	14	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	15	* implied. See the License for the specific language governing
	16	* rights and limitations under the License.
	17	*
	18	* The initial developer of the original code is David A. Hinds
	19	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	20	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	21	*
	22	*/
	23
1da177e4 LT	24	#include <linux/module.h>
	25
	26	#include <linux/kernel.h>
	27	#include <linux/init.h>
	28	#include <linux/slab.h>
	29	#include <linux/types.h>
1da177e4 LT	30	#include <linux/delay.h>
	31	#include <linux/errno.h>
	32	#include <linux/ptrace.h>
	33	#include <linux/ioport.h>
	34	#include <linux/spinlock.h>
	35	#include <linux/moduleparam.h>
	36
	37	#include <linux/skbuff.h>
	38	#include <linux/string.h>
	39	#include <linux/serial.h>
	40	#include <linux/serial_reg.h>
	41	#include <linux/bitops.h>
1da177e4 LT	42	#include <asm/io.h>
	43
	44	#include <linux/device.h>
	45	#include <linux/firmware.h>
	46
1da177e4 LT	47	#include <pcmcia/cistpl.h>
	48	#include <pcmcia/ciscode.h>
	49	#include <pcmcia/ds.h>
	50	#include <pcmcia/cisreg.h>
	51
	52	#include <net/bluetooth/bluetooth.h>
	53	#include <net/bluetooth/hci_core.h>
	54
	55
	56
	57	/* ======================== Module parameters ======================== */
	58
	59
63fbd24e	60	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	61	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
1da177e4 LT	62	MODULE_LICENSE("GPL");
2312119a	63	MODULE_FIRMWARE("BT3CPCC.bin");
1da177e4 LT	64
	65
	66
	67	/* ======================== Local structures ======================== */
	68
	69
	70	typedef struct bt3c_info_t {
fd238232	71	struct pcmcia_device *p_dev;
1da177e4 LT	72
	73	struct hci_dev *hdev;
	74
	75	spinlock_t lock; /* For serializing operations */
	76
	77	struct sk_buff_head txq;
	78	unsigned long tx_state;
	79
	80	unsigned long rx_state;
	81	unsigned long rx_count;
	82	struct sk_buff *rx_skb;
	83	} bt3c_info_t;
	84
	85
15b99ac1	86	static int bt3c_config(struct pcmcia_device *link);
fba395ee	87	static void bt3c_release(struct pcmcia_device *link);
1da177e4	88
cc3b4866	89	static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4	90
1da177e4 LT	91
	92	/* Transmit states */
	93	#define XMIT_SENDING 1
	94	#define XMIT_WAKEUP 2
	95	#define XMIT_WAITING 8
	96
	97	/* Receiver states */
	98	#define RECV_WAIT_PACKET_TYPE 0
	99	#define RECV_WAIT_EVENT_HEADER 1
	100	#define RECV_WAIT_ACL_HEADER 2
	101	#define RECV_WAIT_SCO_HEADER 3
	102	#define RECV_WAIT_DATA 4
	103
	104
	105
	106	/* ======================== Special I/O functions ======================== */
	107
	108
	109	#define DATA_L 0
	110	#define DATA_H 1
	111	#define ADDR_L 2
	112	#define ADDR_H 3
	113	#define CONTROL 4
	114
	115
	116	static inline void bt3c_address(unsigned int iobase, unsigned short addr)
	117	{
	118	outb(addr & 0xff, iobase + ADDR_L);
	119	outb((addr >> 8) & 0xff, iobase + ADDR_H);
	120	}
	121
	122
	123	static inline void bt3c_put(unsigned int iobase, unsigned short value)
	124	{
	125	outb(value & 0xff, iobase + DATA_L);
	126	outb((value >> 8) & 0xff, iobase + DATA_H);
	127	}
	128
	129
	130	static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
	131	{
	132	bt3c_address(iobase, addr);
	133	bt3c_put(iobase, value);
	134	}
	135
	136
	137	static inline unsigned short bt3c_get(unsigned int iobase)
	138	{
	139	unsigned short value = inb(iobase + DATA_L);
	140
	141	value \|= inb(iobase + DATA_H) << 8;
	142
	143	return value;
	144	}
	145
	146
	147	static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
	148	{
	149	bt3c_address(iobase, addr);
	150
	151	return bt3c_get(iobase);
	152	}
	153
	154
155
156	/* ======================== Interrupt handling ======================== */
157
158
159	static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
160	{
161	int actual = 0;
162
163	bt3c_address(iobase, 0x7080);
164
165	/* Fill FIFO with current frame */
166	while (actual < len) {
167	/* Transmit next byte */
168	bt3c_put(iobase, buf[actual]);
169	actual++;
170	}
171
172	bt3c_io_write(iobase, 0x7005, actual);
173
174	return actual;
175	}
176
177
178	static void bt3c_write_wakeup(bt3c_info_t *info)
179	{
180	if (!info) {
181	BT_ERR("Unknown device");
182	return;
183	}
184
185	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
186	return;
187
188	do {
fc5fef61	189	unsigned int iobase = info->p_dev->resource[0]->start;
1da177e4	190	register struct sk_buff *skb;
fc5fef61	191	int len;
1da177e4	192
e2d40963	193	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	194	break;
	195
	196
	197	if (!(skb = skb_dequeue(&(info->txq)))) {
	198	clear_bit(XMIT_SENDING, &(info->tx_state));
	199	break;
	200	}
	201
	202	/* Send frame */
	203	len = bt3c_write(iobase, 256, skb->data, skb->len);
	204
	205	if (len != skb->len) {
	206	BT_ERR("Very strange");
	207	}
	208
	209	kfree_skb(skb);
	210
	211	info->hdev->stat.byte_tx += len;
	212
	213	} while (0);
	214	}
	215
	216
	217	static void bt3c_receive(bt3c_info_t *info)
	218	{
	219	unsigned int iobase;
	220	int size = 0, avail;
	221
	222	if (!info) {
	223	BT_ERR("Unknown device");
	224	return;
	225	}
	226
9a017a91	227	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	228
	229	avail = bt3c_read(iobase, 0x7006);
	230	//printk("bt3c_cs: receiving %d bytes\n", avail);
	231
	232	bt3c_address(iobase, 0x7480);
	233	while (size < avail) {
	234	size++;
	235	info->hdev->stat.byte_rx++;
	236
	237	/* Allocate packet */
	238	if (info->rx_skb == NULL) {
	239	info->rx_state = RECV_WAIT_PACKET_TYPE;
	240	info->rx_count = 0;
	241	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	242	BT_ERR("Can't allocate mem for new packet");
	243	return;
	244	}
	245	}
	246
	247
	248	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	249
	250	info->rx_skb->dev = (void *) info->hdev;
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:
	321	hci_recv_frame(info->rx_skb);
	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
	419	static int bt3c_hci_send_frame(struct sk_buff *skb)
	420	{
	421	bt3c_info_t *info;
	422	struct hci_dev hdev = (struct hci_dev )(skb->dev);
	423	unsigned long flags;
	424
	425	if (!hdev) {
	426	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
	427	return -ENODEV;
	428	}
	429
155961e8	430	info = hci_get_drvdata(hdev);
1da177e4	431
0d48d939	432	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	433	case HCI_COMMAND_PKT:
	434	hdev->stat.cmd_tx++;
	435	break;
	436	case HCI_ACLDATA_PKT:
	437	hdev->stat.acl_tx++;
	438	break;
	439	case HCI_SCODATA_PKT:
	440	hdev->stat.sco_tx++;
	441	break;
	442	};
	443
	444	/* Prepend skb with frame type */
0d48d939	445	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	446	skb_queue_tail(&(info->txq), skb);
	447
	448	spin_lock_irqsave(&(info->lock), flags);
	449
	450	bt3c_write_wakeup(info);
	451
	452	spin_unlock_irqrestore(&(info->lock), flags);
	453
	454	return 0;
	455	}
	456
	457
1da177e4 LT	458	static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	459	{
	460	return -ENOIOCTLCMD;
	461	}
	462
	463
	464
	465	/* ======================== Card services HCI interaction ======================== */
	466
	467
8187b4fb DW	468	static int bt3c_load_firmware(bt3c_info_t info, const unsigned char firmware,
8187b4fb DW	469	int count)
1da177e4 LT	470	{
	471	char ptr = (char ) firmware;
	472	char b[9];
	473	unsigned int iobase, size, addr, fcs, tmp;
	474	int i, err = 0;
	475
9a017a91	476	iobase = info->p_dev->resource[0]->start;
1da177e4 LT	477
	478	/* Reset */
	479	bt3c_io_write(iobase, 0x8040, 0x0404);
	480	bt3c_io_write(iobase, 0x8040, 0x0400);
	481
	482	udelay(1);
	483
	484	bt3c_io_write(iobase, 0x8040, 0x0404);
	485
	486	udelay(17);
	487
	488	/* Load */
	489	while (count) {
	490	if (ptr[0] != 'S') {
	491	BT_ERR("Bad address in firmware");
	492	err = -EFAULT;
	493	goto error;
	494	}
	495
	496	memset(b, 0, sizeof(b));
	497	memcpy(b, ptr + 2, 2);
51a6fbc8	498	size = simple_strtoul(b, NULL, 16);
1da177e4 LT	499
	500	memset(b, 0, sizeof(b));
	501	memcpy(b, ptr + 4, 8);
51a6fbc8	502	addr = simple_strtoul(b, NULL, 16);
1da177e4 LT	503
	504	memset(b, 0, sizeof(b));
	505	memcpy(b, ptr + (size * 2) + 2, 2);
51a6fbc8	506	fcs = simple_strtoul(b, NULL, 16);
1da177e4 LT	507
	508	memset(b, 0, sizeof(b));
	509	for (tmp = 0, i = 0; i < size; i++) {
	510	memcpy(b, ptr + (i * 2) + 2, 2);
	511	tmp += simple_strtol(b, NULL, 16);
	512	}
	513
	514	if (((tmp + fcs) & 0xff) != 0xff) {
	515	BT_ERR("Checksum error in firmware");
	516	err = -EILSEQ;
	517	goto error;
	518	}
	519
	520	if (ptr[1] == '3') {
	521	bt3c_address(iobase, addr);
	522
	523	memset(b, 0, sizeof(b));
	524	for (i = 0; i < (size - 4) / 2; i++) {
	525	memcpy(b, ptr + (i * 4) + 12, 4);
51a6fbc8	526	tmp = simple_strtoul(b, NULL, 16);
1da177e4 LT	527	bt3c_put(iobase, tmp);
	528	}
	529	}
	530
	531	ptr += (size * 2) + 6;
	532	count -= (size * 2) + 6;
	533	}
	534
	535	udelay(17);
	536
	537	/* Boot */
	538	bt3c_address(iobase, 0x3000);
	539	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	540
	541	error:
	542	udelay(17);
	543
	544	/* Clear */
	545	bt3c_io_write(iobase, 0x7006, 0x0000);
	546	bt3c_io_write(iobase, 0x7005, 0x0000);
	547	bt3c_io_write(iobase, 0x7001, 0x0000);
	548
	549	return err;
	550	}
	551
	552
	553	static int bt3c_open(bt3c_info_t *info)
	554	{
	555	const struct firmware *firmware;
	556	struct hci_dev *hdev;
	557	int err;
	558
	559	spin_lock_init(&(info->lock));
	560
	561	skb_queue_head_init(&(info->txq));
	562
	563	info->rx_state = RECV_WAIT_PACKET_TYPE;
	564	info->rx_count = 0;
	565	info->rx_skb = NULL;
	566
	567	/* Initialize HCI device */
	568	hdev = hci_alloc_dev();
	569	if (!hdev) {
	570	BT_ERR("Can't allocate HCI device");
	571	return -ENOMEM;
	572	}
	573
	574	info->hdev = hdev;
	575
c13854ce	576	hdev->bus = HCI_PCCARD;
155961e8	577	hci_set_drvdata(hdev, info);
27d35284	578	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	579
	580	hdev->open = bt3c_hci_open;
	581	hdev->close = bt3c_hci_close;
	582	hdev->flush = bt3c_hci_flush;
	583	hdev->send = bt3c_hci_send_frame;
1da177e4 LT	584	hdev->ioctl = bt3c_hci_ioctl;
1da177e4 LT	585
1da177e4	586	/* Load firmware */
fd238232	587	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	588	if (err < 0) {
	589	BT_ERR("Firmware request failed");
	590	goto error;
	591	}
	592
	593	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	594
	595	release_firmware(firmware);
	596
	597	if (err < 0) {
	598	BT_ERR("Firmware loading failed");
	599	goto error;
	600	}
	601
	602	/* Timeout before it is safe to send the first HCI packet */
	603	msleep(1000);
	604
	605	/* Register HCI device */
	606	err = hci_register_dev(hdev);
	607	if (err < 0) {
	608	BT_ERR("Can't register HCI device");
	609	goto error;
	610	}
	611
	612	return 0;
	613
	614	error:
	615	info->hdev = NULL;
	616	hci_free_dev(hdev);
	617	return err;
	618	}
	619
	620
	621	static int bt3c_close(bt3c_info_t *info)
	622	{
	623	struct hci_dev *hdev = info->hdev;
	624
	625	if (!hdev)
	626	return -ENODEV;
	627
	628	bt3c_hci_close(hdev);
	629
13ea4015	630	hci_unregister_dev(hdev);
1da177e4 LT	631	hci_free_dev(hdev);
	632
	633	return 0;
	634	}
	635
15b99ac1	636	static int bt3c_probe(struct pcmcia_device *link)
1da177e4 LT	637	{
1da177e4 LT	638	bt3c_info_t *info;
1da177e4 LT	639
1da177e4 LT	640	/* Create new info device */
4f61cb18	641	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
1da177e4	642	if (!info)
f8cfa618	643	return -ENOMEM;
1da177e4	644
fba395ee	645	info->p_dev = link;
1da177e4 LT	646	link->priv = info;
1da177e4 LT	647
00990e7c DB	648	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c DB	649	CONF_AUTO_SET_IO;
1da177e4	650
15b99ac1	651	return bt3c_config(link);
1da177e4 LT	652	}
	653
	654
fba395ee	655	static void bt3c_detach(struct pcmcia_device *link)
1da177e4	656	{
e2d40963	657	bt3c_release(link);
1da177e4 LT	658	}
1da177e4 LT	659
00990e7c	660	static int bt3c_check_config(struct pcmcia_device p_dev, void priv_data)
1da177e4	661	{
00990e7c	662	int *try = priv_data;
90abdc3b	663
510df251	664	if (!try)
00990e7c DB	665	p_dev->io_lines = 16;
	666
	667	if ((p_dev->resource[0]->end != 8) \|\| (p_dev->resource[0]->start == 0))
	668	return -EINVAL;
	669
	670	p_dev->resource[0]->end = 8;
	671	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	672	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	673
	674	return pcmcia_request_io(p_dev);
1da177e4 LT	675	}
1da177e4 LT	676
ed58872a	677	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a	678	void *priv_data)
1da177e4	679	{
ed58872a DB	680	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	681	int j;
	682
00990e7c DB	683	if (p_dev->io_lines > 3)
	684	return -ENODEV;
	685
	686	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	687	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
	688	p_dev->resource[0]->end = 8;
	689
	690	for (j = 0; j < 5; j++) {
	691	p_dev->resource[0]->start = base[j];
	692	p_dev->io_lines = base[j] ? 16 : 3;
	693	if (!pcmcia_request_io(p_dev))
	694	return 0;
ed58872a DB	695	}
ed58872a DB	696	return -ENODEV;
1da177e4 LT	697	}
1da177e4 LT	698
15b99ac1	699	static int bt3c_config(struct pcmcia_device *link)
1da177e4	700	{
1da177e4	701	bt3c_info_t *info = link->priv;
ed58872a DB	702	int i;
	703	unsigned long try;
	704
	705	/* First pass: look for a config entry that looks normal.
	706	Two tries: without IO aliases, then with aliases */
	707	for (try = 0; try < 2; try++)
	708	if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
	709	goto found_port;
1da177e4 LT	710
	711	/* Second pass: try to find an entry that isn't picky about
	712	its base address, then try to grab any standard serial port
	713	address, and finally try to get any free port. */
ed58872a DB	714	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
ed58872a DB	715	goto found_port;
1da177e4	716
ed58872a	717	BT_ERR("No usable port range found");
ed58872a	718	goto failed;
1da177e4	719
ed58872a	720	found_port:
eb14120f	721	i = pcmcia_request_irq(link, &bt3c_interrupt);
9ac3e58c	722	if (i != 0)
eb14120f	723	goto failed;
1da177e4	724
1ac71e5a	725	i = pcmcia_enable_device(link);
9ac3e58c	726	if (i != 0)
1da177e4	727	goto failed;
1da177e4 LT	728
	729	if (bt3c_open(info) != 0)
	730	goto failed;
	731
15b99ac1	732	return 0;
1da177e4	733
1da177e4 LT	734	failed:
1da177e4 LT	735	bt3c_release(link);
15b99ac1	736	return -ENODEV;
1da177e4 LT	737	}
	738
	739
fba395ee	740	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	741	{
	742	bt3c_info_t *info = link->priv;
	743
e2d40963	744	bt3c_close(info);
1da177e4	745
fba395ee	746	pcmcia_disable_device(link);
1da177e4 LT	747	}
1da177e4 LT	748
1da177e4	749
25f8f54f	750	static const struct pcmcia_device_id bt3c_ids[] = {
a01c3ed4 DB	751	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	752	PCMCIA_DEVICE_NULL
	753	};
	754	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	755
1da177e4 LT	756	static struct pcmcia_driver bt3c_driver = {
1da177e4 LT	757	.owner = THIS_MODULE,
2e9b981a	758	.name = "bt3c_cs",
15b99ac1	759	.probe = bt3c_probe,
cc3b4866	760	.remove = bt3c_detach,
a01c3ed4	761	.id_table = bt3c_ids,
1da177e4	762	};
e0c005f4	763	module_pcmcia_driver(bt3c_driver);