[deliverable/linux.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/sched.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/system.h>
#include <asm/io.h>

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

#include <pcmcia/cs_types.h>
#include <pcmcia/cs.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>, Jose Orlando Pereira <jop@di.uminho.pt>");
MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
MODULE_LICENSE("GPL");


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


typedef struct bt3c_info_t {
	struct pcmcia_device *p_dev;
	dev_node_t node;

	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 {
		register unsigned int iobase = info->p_dev->io.BasePort1;
		register struct sk_buff *skb;
		register 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->io.BasePort1;

	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 = (struct hci_event_hdr *)(info->rx_skb->data);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

				case RECV_WAIT_ACL_HEADER:
					ah = (struct hci_acl_hdr *)(info->rx_skb->data);
					dlen = __le16_to_cpu(ah->dlen);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = dlen;
					break;

				case RECV_WAIT_SCO_HEADER:
					sh = (struct hci_sco_hdr *)(info->rx_skb->data);
					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, struct pt_regs *regs)
{
	bt3c_info_t *info = dev_inst;
	unsigned int iobase;
	int iir;

	if (!info || !info->hdev) {
		BT_ERR("Call of irq %d for unknown device", irq);
		return IRQ_NONE;
	}

	iobase = info->p_dev->io.BasePort1;

	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 stat = bt3c_read(iobase, 0x7002) & 0x10;
				BT_INFO("%s: Antenna %s", info->hdev->name,
							stat ? "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);
		}
	}

	spin_unlock(&(info->lock));

	return IRQ_HANDLED;
}


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


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

	/* 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 = (bt3c_info_t *) (hdev->driver_data);

	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 void bt3c_hci_destruct(struct hci_dev *hdev)
{
}


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, 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->io.BasePort1;

	/* 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_strtol(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 4, 8);
		addr = simple_strtol(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + (size * 2) + 2, 2);
		fcs = simple_strtol(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_strtol(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->type = HCI_PCCARD;
	hdev->driver_data = info;

	hdev->open     = bt3c_hci_open;
	hdev->close    = bt3c_hci_close;
	hdev->flush    = bt3c_hci_flush;
	hdev->send     = bt3c_hci_send_frame;
	hdev->destruct = bt3c_hci_destruct;
	hdev->ioctl    = bt3c_hci_ioctl;

	hdev->owner = THIS_MODULE;

	/* 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);

	if (hci_unregister_dev(hdev) < 0)
		BT_ERR("Can't unregister HCI device %s", hdev->name);

	hci_free_dev(hdev);

	return 0;
}

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

	/* Create new info device */
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

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

	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	link->io.NumPorts1 = 8;
	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
	link->irq.IRQInfo1 = IRQ_LEVEL_ID;

	link->irq.Handler = bt3c_interrupt;
	link->irq.Instance = info;

	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.IntType = INT_MEMORY_AND_IO;

	return bt3c_config(link);
}


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

	bt3c_release(link);
	kfree(info);
}

static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	int i;

	i = pcmcia_get_tuple_data(handle, tuple);
	if (i != CS_SUCCESS)
		return i;

	return pcmcia_parse_tuple(handle, tuple, parse);
}

static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int bt3c_config(struct pcmcia_device *link)
{
	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	bt3c_info_t *info = link->priv;
	tuple_t tuple;
	u_short buf[256];
	cisparse_t parse;
	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	int i, j, try, last_ret, last_fn;

	tuple.TupleData = (cisdata_t *)buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;

	/* Get configuration register information */
	tuple.DesiredTuple = CISTPL_CONFIG;
	last_ret = first_tuple(link, &tuple, &parse);
	if (last_ret != CS_SUCCESS) {
		last_fn = ParseTuple;
		goto cs_failed;
	}
	link->conf.ConfigBase = parse.config.base;
	link->conf.Present = parse.config.rmask[0];

	/* First pass: look for a config entry that looks normal. */
	tuple.TupleData = (cisdata_t *)buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;
	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	/* Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++) {
		i = first_tuple(link, &tuple, &parse);
		while (i != CS_NO_MORE_ITEMS) {
			if (i != CS_SUCCESS)
				goto next_entry;
			if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
				link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
			if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
				link->conf.ConfigIndex = cf->index;
				link->io.BasePort1 = cf->io.win[0].base;
				link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
next_entry:
			i = next_tuple(link, &tuple, &parse);
		}
	}

	/* 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. */
	i = first_tuple(link, &tuple, &parse);
	while (i != CS_NO_MORE_ITEMS) {
		if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
			link->conf.ConfigIndex = cf->index;
			for (j = 0; j < 5; j++) {
				link->io.BasePort1 = base[j];
				link->io.IOAddrLines = base[j] ? 16 : 3;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
		}
		i = next_tuple(link, &tuple, &parse);
	}

found_port:
	if (i != CS_SUCCESS) {
		BT_ERR("No usable port range found");
		cs_error(link, RequestIO, i);
		goto failed;
	}

	i = pcmcia_request_irq(link, &link->irq);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestIRQ, i);
		link->irq.AssignedIRQ = 0;
	}

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
		cs_error(link, RequestConfiguration, i);
		goto failed;
	}

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

	strcpy(info->node.dev_name, info->hdev->name);
	link->dev_node = &info->node;

	return 0;

cs_failed:
	cs_error(link, last_fn, last_ret);

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 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,
	.drv		= {
		.name	= "bt3c_cs",
	},
	.probe		= bt3c_probe,
	.remove		= bt3c_detach,
	.id_table	= bt3c_ids,
};

static int __init init_bt3c_cs(void)
{
	return pcmcia_register_driver(&bt3c_driver);
}


static void __exit exit_bt3c_cs(void)
{
	pcmcia_unregister_driver(&bt3c_driver);
}

module_init(init_bt3c_cs);
module_exit(exit_bt3c_cs);
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>
	30	#include <linux/sched.h>
	31	#include <linux/delay.h>
	32	#include <linux/errno.h>
	33	#include <linux/ptrace.h>
	34	#include <linux/ioport.h>
	35	#include <linux/spinlock.h>
	36	#include <linux/moduleparam.h>
	37
	38	#include <linux/skbuff.h>
	39	#include <linux/string.h>
	40	#include <linux/serial.h>
	41	#include <linux/serial_reg.h>
	42	#include <linux/bitops.h>
	43	#include <asm/system.h>
	44	#include <asm/io.h>
	45
	46	#include <linux/device.h>
	47	#include <linux/firmware.h>
	48
1da177e4 LT	49	#include <pcmcia/cs_types.h>
	50	#include <pcmcia/cs.h>
	51	#include <pcmcia/cistpl.h>
	52	#include <pcmcia/ciscode.h>
	53	#include <pcmcia/ds.h>
	54	#include <pcmcia/cisreg.h>
	55
	56	#include <net/bluetooth/bluetooth.h>
	57	#include <net/bluetooth/hci_core.h>
	58
	59
	60
	61	/* ======================== Module parameters ======================== */
	62
	63
	64	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
	65	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
	66	MODULE_LICENSE("GPL");
	67
	68
	69
	70	/* ======================== Local structures ======================== */
	71
	72
	73	typedef struct bt3c_info_t {
fd238232	74	struct pcmcia_device *p_dev;
1da177e4 LT	75	dev_node_t node;
	76
	77	struct hci_dev *hdev;
	78
	79	spinlock_t lock; /* For serializing operations */
	80
	81	struct sk_buff_head txq;
	82	unsigned long tx_state;
	83
	84	unsigned long rx_state;
	85	unsigned long rx_count;
	86	struct sk_buff *rx_skb;
	87	} bt3c_info_t;
	88
	89
15b99ac1	90	static int bt3c_config(struct pcmcia_device *link);
fba395ee	91	static void bt3c_release(struct pcmcia_device *link);
1da177e4	92
cc3b4866	93	static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4	94
1da177e4 LT	95
	96	/* Transmit states */
	97	#define XMIT_SENDING 1
	98	#define XMIT_WAKEUP 2
	99	#define XMIT_WAITING 8
	100
	101	/* Receiver states */
	102	#define RECV_WAIT_PACKET_TYPE 0
	103	#define RECV_WAIT_EVENT_HEADER 1
	104	#define RECV_WAIT_ACL_HEADER 2
	105	#define RECV_WAIT_SCO_HEADER 3
	106	#define RECV_WAIT_DATA 4
	107
	108
	109
	110	/* ======================== Special I/O functions ======================== */
	111
	112
	113	#define DATA_L 0
	114	#define DATA_H 1
	115	#define ADDR_L 2
	116	#define ADDR_H 3
	117	#define CONTROL 4
	118
	119
	120	static inline void bt3c_address(unsigned int iobase, unsigned short addr)
	121	{
	122	outb(addr & 0xff, iobase + ADDR_L);
	123	outb((addr >> 8) & 0xff, iobase + ADDR_H);
	124	}
	125
	126
	127	static inline void bt3c_put(unsigned int iobase, unsigned short value)
	128	{
	129	outb(value & 0xff, iobase + DATA_L);
	130	outb((value >> 8) & 0xff, iobase + DATA_H);
	131	}
	132
	133
	134	static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
	135	{
	136	bt3c_address(iobase, addr);
	137	bt3c_put(iobase, value);
	138	}
	139
	140
	141	static inline unsigned short bt3c_get(unsigned int iobase)
	142	{
	143	unsigned short value = inb(iobase + DATA_L);
	144
	145	value \|= inb(iobase + DATA_H) << 8;
	146
	147	return value;
	148	}
	149
	150
	151	static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
	152	{
	153	bt3c_address(iobase, addr);
	154
	155	return bt3c_get(iobase);
	156	}
	157
	158
159
160	/* ======================== Interrupt handling ======================== */
161
162
163	static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
164	{
165	int actual = 0;
166
167	bt3c_address(iobase, 0x7080);
168
169	/* Fill FIFO with current frame */
170	while (actual < len) {
171	/* Transmit next byte */
172	bt3c_put(iobase, buf[actual]);
173	actual++;
174	}
175
176	bt3c_io_write(iobase, 0x7005, actual);
177
178	return actual;
179	}
180
181
182	static void bt3c_write_wakeup(bt3c_info_t *info)
183	{
184	if (!info) {
185	BT_ERR("Unknown device");
186	return;
187	}
188
189	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
190	return;
191
192	do {
fd238232	193	register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	194	register struct sk_buff *skb;
	195	register int len;
	196
e2d40963	197	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	198	break;
	199
	200
	201	if (!(skb = skb_dequeue(&(info->txq)))) {
	202	clear_bit(XMIT_SENDING, &(info->tx_state));
	203	break;
	204	}
	205
	206	/* Send frame */
	207	len = bt3c_write(iobase, 256, skb->data, skb->len);
	208
	209	if (len != skb->len) {
	210	BT_ERR("Very strange");
	211	}
	212
	213	kfree_skb(skb);
	214
	215	info->hdev->stat.byte_tx += len;
	216
	217	} while (0);
	218	}
	219
	220
	221	static void bt3c_receive(bt3c_info_t *info)
	222	{
	223	unsigned int iobase;
	224	int size = 0, avail;
	225
	226	if (!info) {
	227	BT_ERR("Unknown device");
	228	return;
	229	}
	230
fd238232	231	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	232
	233	avail = bt3c_read(iobase, 0x7006);
	234	//printk("bt3c_cs: receiving %d bytes\n", avail);
	235
	236	bt3c_address(iobase, 0x7480);
	237	while (size < avail) {
	238	size++;
	239	info->hdev->stat.byte_rx++;
	240
	241	/* Allocate packet */
	242	if (info->rx_skb == NULL) {
	243	info->rx_state = RECV_WAIT_PACKET_TYPE;
	244	info->rx_count = 0;
	245	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	246	BT_ERR("Can't allocate mem for new packet");
	247	return;
	248	}
	249	}
	250
	251
	252	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	253
	254	info->rx_skb->dev = (void *) info->hdev;
0d48d939	255	bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4	256	inb(iobase + DATA_H);
0d48d939	257	//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
1da177e4	258
0d48d939	259	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	260
	261	case HCI_EVENT_PKT:
	262	info->rx_state = RECV_WAIT_EVENT_HEADER;
	263	info->rx_count = HCI_EVENT_HDR_SIZE;
	264	break;
	265
	266	case HCI_ACLDATA_PKT:
	267	info->rx_state = RECV_WAIT_ACL_HEADER;
	268	info->rx_count = HCI_ACL_HDR_SIZE;
	269	break;
	270
	271	case HCI_SCODATA_PKT:
	272	info->rx_state = RECV_WAIT_SCO_HEADER;
	273	info->rx_count = HCI_SCO_HDR_SIZE;
	274	break;
	275
	276	default:
	277	/* Unknown packet */
0d48d939	278	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	279	info->hdev->stat.err_rx++;
	280	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	281
	282	kfree_skb(info->rx_skb);
	283	info->rx_skb = NULL;
	284	break;
	285
	286	}
	287
	288	} else {
	289
	290	__u8 x = inb(iobase + DATA_L);
	291
	292	*skb_put(info->rx_skb, 1) = x;
	293	inb(iobase + DATA_H);
	294	info->rx_count--;
	295
	296	if (info->rx_count == 0) {
	297
	298	int dlen;
	299	struct hci_event_hdr *eh;
	300	struct hci_acl_hdr *ah;
	301	struct hci_sco_hdr *sh;
	302
	303	switch (info->rx_state) {
	304
	305	case RECV_WAIT_EVENT_HEADER:
	306	eh = (struct hci_event_hdr *)(info->rx_skb->data);
	307	info->rx_state = RECV_WAIT_DATA;
	308	info->rx_count = eh->plen;
	309	break;
	310
	311	case RECV_WAIT_ACL_HEADER:
	312	ah = (struct hci_acl_hdr *)(info->rx_skb->data);
	313	dlen = __le16_to_cpu(ah->dlen);
	314	info->rx_state = RECV_WAIT_DATA;
	315	info->rx_count = dlen;
	316	break;
	317
	318	case RECV_WAIT_SCO_HEADER:
	319	sh = (struct hci_sco_hdr *)(info->rx_skb->data);
	320	info->rx_state = RECV_WAIT_DATA;
	321	info->rx_count = sh->dlen;
	322	break;
	323
	324	case RECV_WAIT_DATA:
	325	hci_recv_frame(info->rx_skb);
	326	info->rx_skb = NULL;
	327	break;
	328
	329	}
	330
	331	}
	332
	333	}
	334
	335	}
	336
	337	bt3c_io_write(iobase, 0x7006, 0x0000);
	338	}
	339
	340
	341	static irqreturn_t bt3c_interrupt(int irq, void dev_inst, struct pt_regs regs)
	342	{
343	bt3c_info_t *info = dev_inst;
344	unsigned int iobase;
345	int iir;
346
347	if (!info \|\| !info->hdev) {
348	BT_ERR("Call of irq %d for unknown device", irq);
349	return IRQ_NONE;
350	}
351
fd238232	352	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	353
	354	spin_lock(&(info->lock));
	355
	356	iir = inb(iobase + CONTROL);
	357	if (iir & 0x80) {
	358	int stat = bt3c_read(iobase, 0x7001);
	359
	360	if ((stat & 0xff) == 0x7f) {
	361	BT_ERR("Very strange (stat=0x%04x)", stat);
	362	} else if ((stat & 0xff) != 0xff) {
	363	if (stat & 0x0020) {
	364	int stat = bt3c_read(iobase, 0x7002) & 0x10;
	365	BT_INFO("%s: Antenna %s", info->hdev->name,
	366	stat ? "out" : "in");
	367	}
	368	if (stat & 0x0001)
	369	bt3c_receive(info);
	370	if (stat & 0x0002) {
	371	//BT_ERR("Ack (stat=0x%04x)", stat);
	372	clear_bit(XMIT_SENDING, &(info->tx_state));
	373	bt3c_write_wakeup(info);
	374	}
	375
	376	bt3c_io_write(iobase, 0x7001, 0x0000);
	377
	378	outb(iir, iobase + CONTROL);
	379	}
	380	}
	381
	382	spin_unlock(&(info->lock));
	383
	384	return IRQ_HANDLED;
	385	}
	386
	387
	388
	389	/* ======================== HCI interface ======================== */
	390
	391
	392	static int bt3c_hci_flush(struct hci_dev *hdev)
	393	{
	394	bt3c_info_t info = (bt3c_info_t )(hdev->driver_data);
	395
	396	/* Drop TX queue */
	397	skb_queue_purge(&(info->txq));
	398
	399	return 0;
	400	}
	401
	402
	403	static int bt3c_hci_open(struct hci_dev *hdev)
	404	{
	405	set_bit(HCI_RUNNING, &(hdev->flags));
	406
	407	return 0;
	408	}
	409
	410
	411	static int bt3c_hci_close(struct hci_dev *hdev)
	412	{
	413	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	414	return 0;
	415
	416	bt3c_hci_flush(hdev);
417
418	return 0;
419	}
420
421
422	static int bt3c_hci_send_frame(struct sk_buff *skb)
423	{
424	bt3c_info_t *info;
425	struct hci_dev hdev = (struct hci_dev )(skb->dev);
426	unsigned long flags;
427
428	if (!hdev) {
429	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
430	return -ENODEV;
431	}
432
433	info = (bt3c_info_t *) (hdev->driver_data);
434
0d48d939	435	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	436	case HCI_COMMAND_PKT:
	437	hdev->stat.cmd_tx++;
	438	break;
	439	case HCI_ACLDATA_PKT:
	440	hdev->stat.acl_tx++;
	441	break;
	442	case HCI_SCODATA_PKT:
	443	hdev->stat.sco_tx++;
	444	break;
	445	};
	446
	447	/* Prepend skb with frame type */
0d48d939	448	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	449	skb_queue_tail(&(info->txq), skb);
	450
	451	spin_lock_irqsave(&(info->lock), flags);
	452
	453	bt3c_write_wakeup(info);
	454
	455	spin_unlock_irqrestore(&(info->lock), flags);
	456
	457	return 0;
	458	}
	459
	460
	461	static void bt3c_hci_destruct(struct hci_dev *hdev)
	462	{
	463	}
	464
	465
	466	static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	467	{
	468	return -ENOIOCTLCMD;
	469	}
	470
	471
	472
	473	/* ======================== Card services HCI interaction ======================== */
	474
	475
1da177e4 LT	476	static int bt3c_load_firmware(bt3c_info_t info, unsigned char firmware, int count)
	477	{
	478	char ptr = (char ) firmware;
	479	char b[9];
	480	unsigned int iobase, size, addr, fcs, tmp;
	481	int i, err = 0;
	482
fd238232	483	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	484
	485	/* Reset */
	486	bt3c_io_write(iobase, 0x8040, 0x0404);
	487	bt3c_io_write(iobase, 0x8040, 0x0400);
	488
	489	udelay(1);
	490
	491	bt3c_io_write(iobase, 0x8040, 0x0404);
	492
	493	udelay(17);
	494
	495	/* Load */
	496	while (count) {
	497	if (ptr[0] != 'S') {
	498	BT_ERR("Bad address in firmware");
	499	err = -EFAULT;
	500	goto error;
	501	}
	502
	503	memset(b, 0, sizeof(b));
	504	memcpy(b, ptr + 2, 2);
	505	size = simple_strtol(b, NULL, 16);
	506
	507	memset(b, 0, sizeof(b));
	508	memcpy(b, ptr + 4, 8);
	509	addr = simple_strtol(b, NULL, 16);
	510
	511	memset(b, 0, sizeof(b));
	512	memcpy(b, ptr + (size * 2) + 2, 2);
	513	fcs = simple_strtol(b, NULL, 16);
	514
	515	memset(b, 0, sizeof(b));
	516	for (tmp = 0, i = 0; i < size; i++) {
	517	memcpy(b, ptr + (i * 2) + 2, 2);
	518	tmp += simple_strtol(b, NULL, 16);
	519	}
	520
	521	if (((tmp + fcs) & 0xff) != 0xff) {
	522	BT_ERR("Checksum error in firmware");
	523	err = -EILSEQ;
	524	goto error;
	525	}
	526
	527	if (ptr[1] == '3') {
	528	bt3c_address(iobase, addr);
	529
	530	memset(b, 0, sizeof(b));
	531	for (i = 0; i < (size - 4) / 2; i++) {
	532	memcpy(b, ptr + (i * 4) + 12, 4);
	533	tmp = simple_strtol(b, NULL, 16);
	534	bt3c_put(iobase, tmp);
	535	}
	536	}
	537
	538	ptr += (size * 2) + 6;
	539	count -= (size * 2) + 6;
	540	}
	541
	542	udelay(17);
	543
	544	/* Boot */
	545	bt3c_address(iobase, 0x3000);
	546	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	547
548	error:
549	udelay(17);
550
551	/* Clear */
552	bt3c_io_write(iobase, 0x7006, 0x0000);
553	bt3c_io_write(iobase, 0x7005, 0x0000);
554	bt3c_io_write(iobase, 0x7001, 0x0000);
555
556	return err;
557	}
558
559
560	static int bt3c_open(bt3c_info_t *info)
561	{
562	const struct firmware *firmware;
563	struct hci_dev *hdev;
564	int err;
565
566	spin_lock_init(&(info->lock));
567
568	skb_queue_head_init(&(info->txq));
569
570	info->rx_state = RECV_WAIT_PACKET_TYPE;
571	info->rx_count = 0;
572	info->rx_skb = NULL;
573
574	/* Initialize HCI device */
575	hdev = hci_alloc_dev();
576	if (!hdev) {
577	BT_ERR("Can't allocate HCI device");
578	return -ENOMEM;
579	}
580
581	info->hdev = hdev;
582
583	hdev->type = HCI_PCCARD;
584	hdev->driver_data = info;
585
586	hdev->open = bt3c_hci_open;
587	hdev->close = bt3c_hci_close;
588	hdev->flush = bt3c_hci_flush;
589	hdev->send = bt3c_hci_send_frame;
590	hdev->destruct = bt3c_hci_destruct;
591	hdev->ioctl = bt3c_hci_ioctl;
592
593	hdev->owner = THIS_MODULE;
594
595	/* Load firmware */
fd238232	596	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	597	if (err < 0) {
	598	BT_ERR("Firmware request failed");
	599	goto error;
	600	}
	601
	602	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	603
	604	release_firmware(firmware);
	605
	606	if (err < 0) {
	607	BT_ERR("Firmware loading failed");
	608	goto error;
	609	}
	610
	611	/* Timeout before it is safe to send the first HCI packet */
	612	msleep(1000);
	613
	614	/* Register HCI device */
	615	err = hci_register_dev(hdev);
	616	if (err < 0) {
	617	BT_ERR("Can't register HCI device");
	618	goto error;
	619	}
	620
	621	return 0;
	622
	623	error:
	624	info->hdev = NULL;
	625	hci_free_dev(hdev);
	626	return err;
	627	}
	628
	629
	630	static int bt3c_close(bt3c_info_t *info)
	631	{
	632	struct hci_dev *hdev = info->hdev;
	633
	634	if (!hdev)
	635	return -ENODEV;
	636
	637	bt3c_hci_close(hdev);
	638
	639	if (hci_unregister_dev(hdev) < 0)
	640	BT_ERR("Can't unregister HCI device %s", hdev->name);
	641
	642	hci_free_dev(hdev);
	643
	644	return 0;
	645	}
	646
15b99ac1	647	static int bt3c_probe(struct pcmcia_device *link)
1da177e4 LT	648	{
1da177e4 LT	649	bt3c_info_t *info;
1da177e4 LT	650
1da177e4 LT	651	/* Create new info device */
089b1dbb	652	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	653	if (!info)
f8cfa618	654	return -ENOMEM;
1da177e4	655
fba395ee	656	info->p_dev = link;
1da177e4 LT	657	link->priv = info;
	658
	659	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	660	link->io.NumPorts1 = 8;
	661	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	662	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	663
	664	link->irq.Handler = bt3c_interrupt;
	665	link->irq.Instance = info;
	666
	667	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	668	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	669
15b99ac1	670	return bt3c_config(link);
1da177e4 LT	671	}
	672
	673
fba395ee	674	static void bt3c_detach(struct pcmcia_device *link)
1da177e4 LT	675	{
1da177e4 LT	676	bt3c_info_t *info = link->priv;
1da177e4	677
e2d40963	678	bt3c_release(link);
1da177e4 LT	679	kfree(info);
	680	}
	681
fba395ee	682	static int get_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	683	{
	684	int i;
	685
	686	i = pcmcia_get_tuple_data(handle, tuple);
	687	if (i != CS_SUCCESS)
	688	return i;
	689
	690	return pcmcia_parse_tuple(handle, tuple, parse);
	691	}
	692
fba395ee	693	static int first_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	694	{
	695	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
	696	return CS_NO_MORE_ITEMS;
	697	return get_tuple(handle, tuple, parse);
	698	}
	699
fba395ee	700	static int next_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	701	{
	702	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
	703	return CS_NO_MORE_ITEMS;
	704	return get_tuple(handle, tuple, parse);
	705	}
	706
15b99ac1	707	static int bt3c_config(struct pcmcia_device *link)
1da177e4 LT	708	{
1da177e4 LT	709	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4 LT	710	bt3c_info_t *info = link->priv;
	711	tuple_t tuple;
	712	u_short buf[256];
	713	cisparse_t parse;
	714	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
1da177e4 LT	715	int i, j, try, last_ret, last_fn;
	716
	717	tuple.TupleData = (cisdata_t *)buf;
	718	tuple.TupleOffset = 0;
	719	tuple.TupleDataMax = 255;
	720	tuple.Attributes = 0;
	721
	722	/* Get configuration register information */
	723	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee	724	last_ret = first_tuple(link, &tuple, &parse);
1da177e4 LT	725	if (last_ret != CS_SUCCESS) {
	726	last_fn = ParseTuple;
	727	goto cs_failed;
	728	}
	729	link->conf.ConfigBase = parse.config.base;
	730	link->conf.Present = parse.config.rmask[0];
	731
1da177e4 LT	732	/* First pass: look for a config entry that looks normal. */
	733	tuple.TupleData = (cisdata_t *)buf;
	734	tuple.TupleOffset = 0;
	735	tuple.TupleDataMax = 255;
	736	tuple.Attributes = 0;
	737	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	738	/* Two tries: without IO aliases, then with aliases */
	739	for (try = 0; try < 2; try++) {
fba395ee	740	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	741	while (i != CS_NO_MORE_ITEMS) {
	742	if (i != CS_SUCCESS)
	743	goto next_entry;
	744	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	745	link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	746	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
	747	link->conf.ConfigIndex = cf->index;
	748	link->io.BasePort1 = cf->io.win[0].base;
	749	link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee	750	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	751	if (i == CS_SUCCESS)
	752	goto found_port;
	753	}
	754	next_entry:
fba395ee	755	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	756	}
	757	}
	758
	759	/* Second pass: try to find an entry that isn't picky about
	760	its base address, then try to grab any standard serial port
	761	address, and finally try to get any free port. */
fba395ee	762	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	763	while (i != CS_NO_MORE_ITEMS) {
	764	if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
	765	link->conf.ConfigIndex = cf->index;
	766	for (j = 0; j < 5; j++) {
	767	link->io.BasePort1 = base[j];
	768	link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee	769	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	770	if (i == CS_SUCCESS)
	771	goto found_port;
	772	}
	773	}
fba395ee	774	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	775	}
	776
	777	found_port:
	778	if (i != CS_SUCCESS) {
	779	BT_ERR("No usable port range found");
fba395ee	780	cs_error(link, RequestIO, i);
1da177e4 LT	781	goto failed;
	782	}
	783
fba395ee	784	i = pcmcia_request_irq(link, &link->irq);
1da177e4	785	if (i != CS_SUCCESS) {
fba395ee	786	cs_error(link, RequestIRQ, i);
1da177e4 LT	787	link->irq.AssignedIRQ = 0;
	788	}
	789
fba395ee	790	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	791	if (i != CS_SUCCESS) {
fba395ee	792	cs_error(link, RequestConfiguration, i);
1da177e4 LT	793	goto failed;
	794	}
	795
	796	if (bt3c_open(info) != 0)
	797	goto failed;
	798
	799	strcpy(info->node.dev_name, info->hdev->name);
fd238232	800	link->dev_node = &info->node;
1da177e4	801
15b99ac1	802	return 0;
1da177e4 LT	803
1da177e4 LT	804	cs_failed:
fba395ee	805	cs_error(link, last_fn, last_ret);
1da177e4 LT	806
	807	failed:
	808	bt3c_release(link);
15b99ac1	809	return -ENODEV;
1da177e4 LT	810	}
	811
	812
fba395ee	813	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	814	{
	815	bt3c_info_t *info = link->priv;
	816
e2d40963	817	bt3c_close(info);
1da177e4	818
fba395ee	819	pcmcia_disable_device(link);
1da177e4 LT	820	}
1da177e4 LT	821
1da177e4	822
a01c3ed4 DB	823	static struct pcmcia_device_id bt3c_ids[] = {
	824	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	825	PCMCIA_DEVICE_NULL
	826	};
	827	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	828
1da177e4 LT	829	static struct pcmcia_driver bt3c_driver = {
	830	.owner = THIS_MODULE,
	831	.drv = {
	832	.name = "bt3c_cs",
	833	},
15b99ac1	834	.probe = bt3c_probe,
cc3b4866	835	.remove = bt3c_detach,
a01c3ed4	836	.id_table = bt3c_ids,
1da177e4 LT	837	};
	838
	839	static int __init init_bt3c_cs(void)
	840	{
	841	return pcmcia_register_driver(&bt3c_driver);
	842	}
	843
	844
	845	static void __exit exit_bt3c_cs(void)
	846	{
	847	pcmcia_unregister_driver(&bt3c_driver);
1da177e4 LT	848	}
	849
	850	module_init(init_bt3c_cs);
	851	module_exit(exit_bt3c_cs);