[GitHub/MotorolaMobilityLLC/kernel-slsi.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/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 = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;
	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);

	info->manf_id = link->manf_id;

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