[deliverable/linux.git] / drivers / scsi / pcmcia / qlogic_stub.c

/*======================================================================

    A driver for the Qlogic SCSI card

    qlogic_cs.c 1.79 2000/06/12 21:27:26

    The contents of this file are subject to the Mozilla Public
    License Version 1.1 (the "License"); you may not use this file
    except in compliance with the License. You may obtain a copy of
    the License at http://www.mozilla.org/MPL/

    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.

    Alternatively, the contents of this file may be used under the
    terms of the GNU General Public License version 2 (the "GPL"), in which
    case the provisions of the GPL are applicable instead of the
    above.  If you wish to allow the use of your version of this file
    only under the terms of the GPL and not to allow others to use
    your version of this file under the MPL, indicate your decision
    by deleting the provisions above and replace them with the notice
    and other provisions required by the GPL.  If you do not delete
    the provisions above, a recipient may use your version of this
    file under either the MPL or the GPL.
    
======================================================================*/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <asm/io.h>
#include <scsi/scsi.h>
#include <linux/major.h>
#include <linux/blkdev.h>
#include <scsi/scsi_ioctl.h>
#include <linux/interrupt.h>

#include "scsi.h"
#include <scsi/scsi_host.h>
#include "../qlogicfas408.h"

#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>
#include <pcmcia/ciscode.h>

/* Set the following to 2 to use normal interrupt (active high/totempole-
 * tristate), otherwise use 0 (REQUIRED FOR PCMCIA) for active low, open
 * drain
 */
#define INT_TYPE	0

static char qlogic_name[] = "qlogic_cs";

#ifdef PCMCIA_DEBUG
static int pc_debug = PCMCIA_DEBUG;
module_param(pc_debug, int, 0644);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
static char *version = "qlogic_cs.c 1.79-ac 2002/10/26 (David Hinds)";
#else
#define DEBUG(n, args...)
#endif

static struct scsi_host_template qlogicfas_driver_template = {
	.module			= THIS_MODULE,
	.name			= qlogic_name,
	.proc_name		= qlogic_name,
	.info			= qlogicfas408_info,
	.queuecommand		= qlogicfas408_queuecommand,
	.eh_abort_handler	= qlogicfas408_abort,
	.eh_bus_reset_handler	= qlogicfas408_bus_reset,
	.bios_param		= qlogicfas408_biosparam,
	.can_queue		= 1,
	.this_id		= -1,
	.sg_tablesize		= SG_ALL,
	.cmd_per_lun		= 1,
	.use_clustering		= DISABLE_CLUSTERING,
};

/*====================================================================*/

typedef struct scsi_info_t {
	struct pcmcia_device	*p_dev;
	dev_node_t node;
	struct Scsi_Host *host;
	unsigned short manf_id;
} scsi_info_t;

static void qlogic_release(struct pcmcia_device *link);
static void qlogic_detach(struct pcmcia_device *p_dev);
static int qlogic_config(struct pcmcia_device * link);

static struct Scsi_Host *qlogic_detect(struct scsi_host_template *host,
				struct pcmcia_device *link, int qbase, int qlirq)
{
	int qltyp;		/* type of chip */
	int qinitid;
	struct Scsi_Host *shost;	/* registered host structure */
	struct qlogicfas408_priv *priv;

	qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE);
	qinitid = host->this_id;
	if (qinitid < 0)
		qinitid = 7;	/* if no ID, use 7 */

	qlogicfas408_setup(qbase, qinitid, INT_TYPE);

	host->name = qlogic_name;
	shost = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv));
	if (!shost)
		goto err;
	shost->io_port = qbase;
	shost->n_io_port = 16;
	shost->dma_channel = -1;
	if (qlirq != -1)
		shost->irq = qlirq;

	priv = get_priv_by_host(shost);
	priv->qlirq = qlirq;
	priv->qbase = qbase;
	priv->qinitid = qinitid;
	priv->shost = shost;
	priv->int_type = INT_TYPE;					

	if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogic_name, shost))
		goto free_scsi_host;

	sprintf(priv->qinfo,
		"Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d",
		qltyp, qbase, qlirq, QL_TURBO_PDMA);

	if (scsi_add_host(shost, NULL))
		goto free_interrupt;

	scsi_scan_host(shost);

	return shost;

free_interrupt:
	free_irq(qlirq, shost);

free_scsi_host:
	scsi_host_put(shost);
	
err:
	return NULL;
}
static int qlogic_probe(struct pcmcia_device *link)
{
	scsi_info_t *info;

	DEBUG(0, "qlogic_attach()\n");

	/* Create new SCSI device */
	info = kmalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;
	memset(info, 0, sizeof(*info));
	info->p_dev = link;
	link->priv = info;
	link->io.NumPorts1 = 16;
	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	link->io.IOAddrLines = 10;
	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.IntType = INT_MEMORY_AND_IO;
	link->conf.Present = PRESENT_OPTION;

	return qlogic_config(link);
}				/* qlogic_attach */

/*====================================================================*/

static void qlogic_detach(struct pcmcia_device *link)
{
	DEBUG(0, "qlogic_detach(0x%p)\n", link);

	qlogic_release(link);
	kfree(link->priv);

}				/* qlogic_detach */

/*====================================================================*/

#define CS_CHECK(fn, ret) \
do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)

static int qlogic_config(struct pcmcia_device * link)
{
	scsi_info_t *info = link->priv;
	tuple_t tuple;
	cisparse_t parse;
	int i, last_ret, last_fn;
	unsigned short tuple_data[32];
	struct Scsi_Host *host;

	DEBUG(0, "qlogic_config(0x%p)\n", link);

	tuple.TupleData = (cisdata_t *) tuple_data;
	tuple.TupleDataMax = 64;
	tuple.TupleOffset = 0;
	tuple.DesiredTuple = CISTPL_CONFIG;
	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
	CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
	link->conf.ConfigBase = parse.config.base;

	tuple.DesiredTuple = CISTPL_MANFID;
	if ((pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) && (pcmcia_get_tuple_data(link, &tuple) == CS_SUCCESS))
		info->manf_id = le16_to_cpu(tuple.TupleData[0]);

	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	while (1) {
		if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
				pcmcia_parse_tuple(link, &tuple, &parse) != 0)
			goto next_entry;
		link->conf.ConfigIndex = parse.cftable_entry.index;
		link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
		link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
		if (link->io.BasePort1 != 0) {
			i = pcmcia_request_io(link, &link->io);
			if (i == CS_SUCCESS)
				break;
		}
	      next_entry:
		CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
	}

	CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));

	if ((info->manf_id == MANFID_MACNICA) || (info->manf_id == MANFID_PIONEER) || (info->manf_id == 0x0098)) {
		/* set ATAcmd */
		outb(0xb4, link->io.BasePort1 + 0xd);
		outb(0x24, link->io.BasePort1 + 0x9);
		outb(0x04, link->io.BasePort1 + 0xd);
	}

	/* The KXL-810AN has a bigger IO port window */
	if (link->io.NumPorts1 == 32)
		host = qlogic_detect(&qlogicfas_driver_template, link,
			link->io.BasePort1 + 16, link->irq.AssignedIRQ);
	else
		host = qlogic_detect(&qlogicfas_driver_template, link,
			link->io.BasePort1, link->irq.AssignedIRQ);
	
	if (!host) {
		printk(KERN_INFO "%s: no SCSI devices found\n", qlogic_name);
		goto cs_failed;
	}

	sprintf(info->node.dev_name, "scsi%d", host->host_no);
	link->dev_node = &info->node;
	info->host = host;

	return 0;

cs_failed:
	cs_error(link, last_fn, last_ret);
	pcmcia_disable_device(link);
	return -ENODEV;

}				/* qlogic_config */

/*====================================================================*/

static void qlogic_release(struct pcmcia_device *link)
{
	scsi_info_t *info = link->priv;

	DEBUG(0, "qlogic_release(0x%p)\n", link);

	scsi_remove_host(info->host);

	free_irq(link->irq.AssignedIRQ, info->host);
	pcmcia_disable_device(link);

	scsi_host_put(info->host);
}

/*====================================================================*/

static int qlogic_resume(struct pcmcia_device *link)
{
	scsi_info_t *info = link->priv;

	pcmcia_request_configuration(link, &link->conf);
	if ((info->manf_id == MANFID_MACNICA) ||
	    (info->manf_id == MANFID_PIONEER) ||
	    (info->manf_id == 0x0098)) {
		outb(0x80, link->io.BasePort1 + 0xd);
		outb(0x24, link->io.BasePort1 + 0x9);
		outb(0x04, link->io.BasePort1 + 0xd);
	}
	/* Ugggglllyyyy!!! */
	qlogicfas408_bus_reset(NULL);

	return 0;
}

static struct pcmcia_device_id qlogic_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("EIger Labs", "PCMCIA-to-SCSI Adapter", 0x88395fa7, 0x33b7a5e6),
	PCMCIA_DEVICE_PROD_ID12("EPSON", "SCSI-2 PC Card SC200", 0xd361772f, 0x299d1751),
	PCMCIA_DEVICE_PROD_ID12("MACNICA", "MIRACLE SCSI-II mPS110", 0x20841b68, 0xab3c3b6d),
	PCMCIA_DEVICE_PROD_ID12("MIDORI ELECTRONICS ", "CN-SC43", 0x6534382a, 0xd67eee79),
	PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J03R", 0x18df0ba0, 0x24662e8a),
	PCMCIA_DEVICE_PROD_ID12("KME ", "KXLC003", 0x82375a27, 0xf68e5bf7),
	PCMCIA_DEVICE_PROD_ID12("KME ", "KXLC004", 0x82375a27, 0x68eace54),
	PCMCIA_DEVICE_PROD_ID12("KME", "KXLC101", 0x3faee676, 0x194250ec),
	PCMCIA_DEVICE_PROD_ID12("QLOGIC CORPORATION", "pc05", 0xd77b2930, 0xa85b2735),
	PCMCIA_DEVICE_PROD_ID12("QLOGIC CORPORATION", "pc05 rev 1.10", 0xd77b2930, 0x70f8b5f8),
	PCMCIA_DEVICE_PROD_ID123("KME", "KXLC002", "00", 0x3faee676, 0x81896b61, 0xf99f065f),
	PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "SCSI2 CARD 37", 0x85c10e17, 0x1a2640c1),
	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "SCSC200A PC CARD SCSI", 0xb4585a1a, 0xa6f06ebe),
	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "SCSC200B PC CARD SCSI-10", 0xb4585a1a, 0x0a88dea0),
	/* these conflict with other cards! */
	/* PCMCIA_DEVICE_PROD_ID123("MACNICA", "MIRACLE SCSI", "mPS100", 0x20841b68, 0xf8dedaeb, 0x89f7fafb), */
	/* PCMCIA_DEVICE_PROD_ID123("MACNICA", "MIRACLE SCSI", "mPS100", 0x20841b68, 0xf8dedaeb, 0x89f7fafb), */
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, qlogic_ids);

static struct pcmcia_driver qlogic_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
	.name		= "qlogic_cs",
	},
	.probe		= qlogic_probe,
	.remove		= qlogic_detach,
	.id_table       = qlogic_ids,
	.resume		= qlogic_resume,
};

static int __init init_qlogic_cs(void)
{
	return pcmcia_register_driver(&qlogic_cs_driver);
}

static void __exit exit_qlogic_cs(void)
{
	pcmcia_unregister_driver(&qlogic_cs_driver);
}

MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
MODULE_DESCRIPTION("Driver for the PCMCIA Qlogic FAS SCSI controllers");
MODULE_LICENSE("GPL");
module_init(init_qlogic_cs);
module_exit(exit_qlogic_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for the Qlogic SCSI card
	4
	5	qlogic_cs.c 1.79 2000/06/12 21:27:26
	6
	7	The contents of this file are subject to the Mozilla Public
	8	License Version 1.1 (the "License"); you may not use this file
	9	except in compliance with the License. You may obtain a copy of
	10	the License at http://www.mozilla.org/MPL/
	11
	12	Software distributed under the License is distributed on an "AS
	13	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	14	implied. See the License for the specific language governing
	15	rights and limitations under the License.
	16
	17	The initial developer of the original code is David A. Hinds
	18	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	19	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	20
	21	Alternatively, the contents of this file may be used under the
	22	terms of the GNU General Public License version 2 (the "GPL"), in which
	23	case the provisions of the GPL are applicable instead of the
	24	above. If you wish to allow the use of your version of this file
	25	only under the terms of the GPL and not to allow others to use
	26	your version of this file under the MPL, indicate your decision
	27	by deleting the provisions above and replace them with the notice
	28	and other provisions required by the GPL. If you do not delete
	29	the provisions above, a recipient may use your version of this
	30	file under either the MPL or the GPL.
	31
	32	======================================================================*/
	33
	34	#include <linux/module.h>
	35	#include <linux/init.h>
	36	#include <linux/kernel.h>
	37	#include <linux/sched.h>
	38	#include <linux/slab.h>
	39	#include <linux/string.h>
	40	#include <linux/ioport.h>
	41	#include <asm/io.h>
	42	#include <scsi/scsi.h>
	43	#include <linux/major.h>
	44	#include <linux/blkdev.h>
	45	#include <scsi/scsi_ioctl.h>
	46	#include <linux/interrupt.h>
	47
	48	#include "scsi.h"
	49	#include <scsi/scsi_host.h>
	50	#include "../qlogicfas408.h"
	51
1da177e4 LT	52	#include <pcmcia/cs_types.h>
	53	#include <pcmcia/cs.h>
	54	#include <pcmcia/cistpl.h>
	55	#include <pcmcia/ds.h>
	56	#include <pcmcia/ciscode.h>
	57
	58	/* Set the following to 2 to use normal interrupt (active high/totempole-
	59	* tristate), otherwise use 0 (REQUIRED FOR PCMCIA) for active low, open
	60	* drain
	61	*/
	62	#define INT_TYPE 0
	63
	64	static char qlogic_name[] = "qlogic_cs";
	65
	66	#ifdef PCMCIA_DEBUG
	67	static int pc_debug = PCMCIA_DEBUG;
	68	module_param(pc_debug, int, 0644);
	69	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	70	static char *version = "qlogic_cs.c 1.79-ac 2002/10/26 (David Hinds)";
	71	#else
	72	#define DEBUG(n, args...)
	73	#endif
	74
d0be4a7d	75	static struct scsi_host_template qlogicfas_driver_template = {
1da177e4 LT	76	.module = THIS_MODULE,
	77	.name = qlogic_name,
	78	.proc_name = qlogic_name,
	79	.info = qlogicfas408_info,
	80	.queuecommand = qlogicfas408_queuecommand,
	81	.eh_abort_handler = qlogicfas408_abort,
	82	.eh_bus_reset_handler = qlogicfas408_bus_reset,
1da177e4 LT	83	.bios_param = qlogicfas408_biosparam,
	84	.can_queue = 1,
	85	.this_id = -1,
	86	.sg_tablesize = SG_ALL,
	87	.cmd_per_lun = 1,
	88	.use_clustering = DISABLE_CLUSTERING,
	89	};
	90
	91	/====================================================================/
	92
	93	typedef struct scsi_info_t {
fd238232	94	struct pcmcia_device *p_dev;
1da177e4 LT	95	dev_node_t node;
	96	struct Scsi_Host *host;
	97	unsigned short manf_id;
	98	} scsi_info_t;
	99
fba395ee	100	static void qlogic_release(struct pcmcia_device *link);
cc3b4866	101	static void qlogic_detach(struct pcmcia_device *p_dev);
15b99ac1	102	static int qlogic_config(struct pcmcia_device * link);
1da177e4	103
d0be4a7d	104	static struct Scsi_Host qlogic_detect(struct scsi_host_template host,
fba395ee	105	struct pcmcia_device *link, int qbase, int qlirq)
1da177e4 LT	106	{
	107	int qltyp; /* type of chip */
	108	int qinitid;
	109	struct Scsi_Host shost; / registered host structure */
	110	struct qlogicfas408_priv *priv;
	111
	112	qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE);
	113	qinitid = host->this_id;
	114	if (qinitid < 0)
	115	qinitid = 7; /* if no ID, use 7 */
	116
	117	qlogicfas408_setup(qbase, qinitid, INT_TYPE);
	118
	119	host->name = qlogic_name;
	120	shost = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv));
	121	if (!shost)
	122	goto err;
	123	shost->io_port = qbase;
	124	shost->n_io_port = 16;
	125	shost->dma_channel = -1;
	126	if (qlirq != -1)
	127	shost->irq = qlirq;
	128
	129	priv = get_priv_by_host(shost);
	130	priv->qlirq = qlirq;
	131	priv->qbase = qbase;
	132	priv->qinitid = qinitid;
	133	priv->shost = shost;
	134	priv->int_type = INT_TYPE;
	135
	136	if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogic_name, shost))
	137	goto free_scsi_host;
	138
	139	sprintf(priv->qinfo,
	140	"Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d",
	141	qltyp, qbase, qlirq, QL_TURBO_PDMA);
	142
	143	if (scsi_add_host(shost, NULL))
	144	goto free_interrupt;
	145
	146	scsi_scan_host(shost);
	147
	148	return shost;
	149
	150	free_interrupt:
	151	free_irq(qlirq, shost);
	152
	153	free_scsi_host:
	154	scsi_host_put(shost);
	155
	156	err:
	157	return NULL;
	158	}
15b99ac1	159	static int qlogic_probe(struct pcmcia_device *link)
1da177e4 LT	160	{
1da177e4 LT	161	scsi_info_t *info;
1da177e4 LT	162
	163	DEBUG(0, "qlogic_attach()\n");
	164
	165	/* Create new SCSI device */
	166	info = kmalloc(sizeof(*info), GFP_KERNEL);
	167	if (!info)
f8cfa618	168	return -ENOMEM;
1da177e4	169	memset(info, 0, sizeof(*info));
fba395ee	170	info->p_dev = link;
1da177e4 LT	171	link->priv = info;
	172	link->io.NumPorts1 = 16;
	173	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	174	link->io.IOAddrLines = 10;
	175	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	176	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	177	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	178	link->conf.IntType = INT_MEMORY_AND_IO;
	179	link->conf.Present = PRESENT_OPTION;
	180
15b99ac1	181	return qlogic_config(link);
1da177e4 LT	182	} /* qlogic_attach */
	183
	184	/====================================================================/
	185
fba395ee	186	static void qlogic_detach(struct pcmcia_device *link)
1da177e4	187	{
1da177e4 LT	188	DEBUG(0, "qlogic_detach(0x%p)\n", link);
1da177e4 LT	189
e2d40963	190	qlogic_release(link);
1da177e4 LT	191	kfree(link->priv);
	192
	193	} /* qlogic_detach */
	194
	195	/====================================================================/
	196
	197	#define CS_CHECK(fn, ret) \
	198	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	199
15b99ac1	200	static int qlogic_config(struct pcmcia_device * link)
1da177e4	201	{
1da177e4 LT	202	scsi_info_t *info = link->priv;
	203	tuple_t tuple;
	204	cisparse_t parse;
	205	int i, last_ret, last_fn;
	206	unsigned short tuple_data[32];
	207	struct Scsi_Host *host;
	208
	209	DEBUG(0, "qlogic_config(0x%p)\n", link);
	210
	211	tuple.TupleData = (cisdata_t *) tuple_data;
	212	tuple.TupleDataMax = 64;
	213	tuple.TupleOffset = 0;
	214	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee DB	215	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	216	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
	217	CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
1da177e4 LT	218	link->conf.ConfigBase = parse.config.base;
	219
	220	tuple.DesiredTuple = CISTPL_MANFID;
fba395ee	221	if ((pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) && (pcmcia_get_tuple_data(link, &tuple) == CS_SUCCESS))
1da177e4 LT	222	info->manf_id = le16_to_cpu(tuple.TupleData[0]);
1da177e4 LT	223
1da177e4	224	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
fba395ee	225	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1da177e4	226	while (1) {
fba395ee DB	227	if (pcmcia_get_tuple_data(link, &tuple) != 0 \|\|
fba395ee DB	228	pcmcia_parse_tuple(link, &tuple, &parse) != 0)
1da177e4 LT	229	goto next_entry;
	230	link->conf.ConfigIndex = parse.cftable_entry.index;
	231	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
	232	link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
	233	if (link->io.BasePort1 != 0) {
fba395ee	234	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	235	if (i == CS_SUCCESS)
	236	break;
	237	}
	238	next_entry:
fba395ee	239	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
1da177e4 LT	240	}
1da177e4 LT	241
fba395ee DB	242	CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
fba395ee DB	243	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1da177e4 LT	244
	245	if ((info->manf_id == MANFID_MACNICA) \|\| (info->manf_id == MANFID_PIONEER) \|\| (info->manf_id == 0x0098)) {
	246	/* set ATAcmd */
	247	outb(0xb4, link->io.BasePort1 + 0xd);
	248	outb(0x24, link->io.BasePort1 + 0x9);
	249	outb(0x04, link->io.BasePort1 + 0xd);
	250	}
	251
	252	/* The KXL-810AN has a bigger IO port window */
	253	if (link->io.NumPorts1 == 32)
	254	host = qlogic_detect(&qlogicfas_driver_template, link,
	255	link->io.BasePort1 + 16, link->irq.AssignedIRQ);
	256	else
	257	host = qlogic_detect(&qlogicfas_driver_template, link,
	258	link->io.BasePort1, link->irq.AssignedIRQ);
	259
	260	if (!host) {
	261	printk(KERN_INFO "%s: no SCSI devices found\n", qlogic_name);
15b99ac1	262	goto cs_failed;
1da177e4 LT	263	}
	264
	265	sprintf(info->node.dev_name, "scsi%d", host->host_no);
fd238232	266	link->dev_node = &info->node;
1da177e4 LT	267	info->host = host;
1da177e4 LT	268
15b99ac1	269	return 0;
1da177e4 LT	270
1da177e4 LT	271	cs_failed:
fba395ee DB	272	cs_error(link, last_fn, last_ret);
fba395ee DB	273	pcmcia_disable_device(link);
15b99ac1	274	return -ENODEV;
1da177e4 LT	275
	276	} /* qlogic_config */
	277
	278	/====================================================================/
	279
fba395ee	280	static void qlogic_release(struct pcmcia_device *link)
1da177e4 LT	281	{
	282	scsi_info_t *info = link->priv;
	283
	284	DEBUG(0, "qlogic_release(0x%p)\n", link);
	285
	286	scsi_remove_host(info->host);
1da177e4 LT	287
1da177e4 LT	288	free_irq(link->irq.AssignedIRQ, info->host);
fba395ee	289	pcmcia_disable_device(link);
1da177e4 LT	290
1da177e4 LT	291	scsi_host_put(info->host);
1da177e4 LT	292	}
	293
	294	/====================================================================/
	295
fba395ee	296	static int qlogic_resume(struct pcmcia_device *link)
98e4c28b	297	{
e2d40963 DB	298	scsi_info_t *info = link->priv;
	299
	300	pcmcia_request_configuration(link, &link->conf);
	301	if ((info->manf_id == MANFID_MACNICA) \|\|
	302	(info->manf_id == MANFID_PIONEER) \|\|
	303	(info->manf_id == 0x0098)) {
	304	outb(0x80, link->io.BasePort1 + 0xd);
	305	outb(0x24, link->io.BasePort1 + 0x9);
	306	outb(0x04, link->io.BasePort1 + 0xd);
98e4c28b	307	}
e2d40963 DB	308	/* Ugggglllyyyy!!! */
e2d40963 DB	309	qlogicfas408_bus_reset(NULL);
98e4c28b DB	310
	311	return 0;
	312	}
	313
7a5a6eeb DB	314	static struct pcmcia_device_id qlogic_ids[] = {
	315	PCMCIA_DEVICE_PROD_ID12("EIger Labs", "PCMCIA-to-SCSI Adapter", 0x88395fa7, 0x33b7a5e6),
	316	PCMCIA_DEVICE_PROD_ID12("EPSON", "SCSI-2 PC Card SC200", 0xd361772f, 0x299d1751),
	317	PCMCIA_DEVICE_PROD_ID12("MACNICA", "MIRACLE SCSI-II mPS110", 0x20841b68, 0xab3c3b6d),
	318	PCMCIA_DEVICE_PROD_ID12("MIDORI ELECTRONICS ", "CN-SC43", 0x6534382a, 0xd67eee79),
	319	PCMCIA_DEVICE_PROD_ID12("NEC", "PC-9801N-J03R", 0x18df0ba0, 0x24662e8a),
	320	PCMCIA_DEVICE_PROD_ID12("KME ", "KXLC003", 0x82375a27, 0xf68e5bf7),
	321	PCMCIA_DEVICE_PROD_ID12("KME ", "KXLC004", 0x82375a27, 0x68eace54),
	322	PCMCIA_DEVICE_PROD_ID12("KME", "KXLC101", 0x3faee676, 0x194250ec),
	323	PCMCIA_DEVICE_PROD_ID12("QLOGIC CORPORATION", "pc05", 0xd77b2930, 0xa85b2735),
	324	PCMCIA_DEVICE_PROD_ID12("QLOGIC CORPORATION", "pc05 rev 1.10", 0xd77b2930, 0x70f8b5f8),
	325	PCMCIA_DEVICE_PROD_ID123("KME", "KXLC002", "00", 0x3faee676, 0x81896b61, 0xf99f065f),
	326	PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "SCSI2 CARD 37", 0x85c10e17, 0x1a2640c1),
	327	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "SCSC200A PC CARD SCSI", 0xb4585a1a, 0xa6f06ebe),
	328	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "SCSC200B PC CARD SCSI-10", 0xb4585a1a, 0x0a88dea0),
	329	/* these conflict with other cards! */
	330	/* PCMCIA_DEVICE_PROD_ID123("MACNICA", "MIRACLE SCSI", "mPS100", 0x20841b68, 0xf8dedaeb, 0x89f7fafb), */
	331	/* PCMCIA_DEVICE_PROD_ID123("MACNICA", "MIRACLE SCSI", "mPS100", 0x20841b68, 0xf8dedaeb, 0x89f7fafb), */
	332	PCMCIA_DEVICE_NULL,
	333	};
	334	MODULE_DEVICE_TABLE(pcmcia, qlogic_ids);
1da177e4 LT	335
	336	static struct pcmcia_driver qlogic_cs_driver = {
	337	.owner = THIS_MODULE,
	338	.drv = {
	339	.name = "qlogic_cs",
	340	},
15b99ac1	341	.probe = qlogic_probe,
cc3b4866	342	.remove = qlogic_detach,
7a5a6eeb	343	.id_table = qlogic_ids,
98e4c28b	344	.resume = qlogic_resume,
1da177e4 LT	345	};
	346
	347	static int __init init_qlogic_cs(void)
	348	{
	349	return pcmcia_register_driver(&qlogic_cs_driver);
	350	}
	351
	352	static void __exit exit_qlogic_cs(void)
	353	{
	354	pcmcia_unregister_driver(&qlogic_cs_driver);
1da177e4 LT	355	}
	356
	357	MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
	358	MODULE_DESCRIPTION("Driver for the PCMCIA Qlogic FAS SCSI controllers");
	359	MODULE_LICENSE("GPL");
	360	module_init(init_qlogic_cs);
	361	module_exit(exit_qlogic_cs);