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