[linux-2.6-block.git] / drivers / scsi / pcmcia / aha152x_stub.c

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

    A driver for Adaptec AHA152X-compatible PCMCIA SCSI cards.

    This driver supports the Adaptec AHA-1460, the New Media Bus
    Toaster, and the New Media Toast & Jam.
    
    aha152x_cs.c 1.54 2000/06/12 21:27:25

    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 <scsi/scsi.h>
#include <linux/major.h>
#include <linux/blkdev.h>
#include <scsi/scsi_ioctl.h>

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

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

#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 =
"aha152x_cs.c 1.54 2000/06/12 21:27:25 (David Hinds)";
#else
#define DEBUG(n, args...)
#endif

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

/* Parameters that can be set with 'insmod' */

/* SCSI bus setup options */
static int host_id = 7;
static int reconnect = 1;
static int parity = 1;
static int synchronous = 1;
static int reset_delay = 100;
static int ext_trans = 0;

module_param(host_id, int, 0);
module_param(reconnect, int, 0);
module_param(parity, int, 0);
module_param(synchronous, int, 0);
module_param(reset_delay, int, 0);
module_param(ext_trans, int, 0);

MODULE_LICENSE("Dual MPL/GPL");

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

typedef struct scsi_info_t {
    dev_link_t		link;
    dev_node_t		node;
    struct Scsi_Host	*host;
} scsi_info_t;

static void aha152x_release_cs(dev_link_t *link);
static int aha152x_event(event_t event, int priority,
			 event_callback_args_t *args);

static dev_link_t *aha152x_attach(void);
static void aha152x_detach(dev_link_t *);

static dev_link_t *dev_list;
static dev_info_t dev_info = "aha152x_cs";

static dev_link_t *aha152x_attach(void)
{
    scsi_info_t *info;
    client_reg_t client_reg;
    dev_link_t *link;
    int ret;
    
    DEBUG(0, "aha152x_attach()\n");

    /* Create new SCSI device */
    info = kmalloc(sizeof(*info), GFP_KERNEL);
    if (!info) return NULL;
    memset(info, 0, sizeof(*info));
    link = &info->link; link->priv = info;

    link->io.NumPorts1 = 0x20;
    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.Vcc = 50;
    link->conf.IntType = INT_MEMORY_AND_IO;
    link->conf.Present = PRESENT_OPTION;

    /* Register with Card Services */
    link->next = dev_list;
    dev_list = link;
    client_reg.dev_info = &dev_info;
    client_reg.Version = 0x0210;
    client_reg.event_callback_args.client_data = link;
    ret = pcmcia_register_client(&link->handle, &client_reg);
    if (ret != 0) {
	cs_error(link->handle, RegisterClient, ret);
	aha152x_detach(link);
	return NULL;
    }
    
    return link;
} /* aha152x_attach */

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

static void aha152x_detach(dev_link_t *link)
{
    dev_link_t **linkp;

    DEBUG(0, "aha152x_detach(0x%p)\n", link);
    
    /* Locate device structure */
    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
	if (*linkp == link) break;
    if (*linkp == NULL)
	return;

    if (link->state & DEV_CONFIG)
	aha152x_release_cs(link);

    if (link->handle)
	pcmcia_deregister_client(link->handle);
    
    /* Unlink device structure, free bits */
    *linkp = link->next;
    kfree(link->priv);
    
} /* aha152x_detach */

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

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

static void aha152x_config_cs(dev_link_t *link)
{
    client_handle_t handle = link->handle;
    scsi_info_t *info = link->priv;
    struct aha152x_setup s;
    tuple_t tuple;
    cisparse_t parse;
    int i, last_ret, last_fn;
    u_char tuple_data[64];
    struct Scsi_Host *host;
    
    DEBUG(0, "aha152x_config(0x%p)\n", link);

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

    /* Configure card */
    link->state |= DEV_CONFIG;

    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
    while (1) {
	if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
		pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
	    goto next_entry;
	/* For New Media T&J, look for a SCSI window */
	if (parse.cftable_entry.io.win[0].len >= 0x20)
	    link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
	else if ((parse.cftable_entry.io.nwin > 1) &&
		 (parse.cftable_entry.io.win[1].len >= 0x20))
	    link->io.BasePort1 = parse.cftable_entry.io.win[1].base;
	if ((parse.cftable_entry.io.nwin > 0) &&
	    (link->io.BasePort1 < 0xffff)) {
	    link->conf.ConfigIndex = parse.cftable_entry.index;
	    i = pcmcia_request_io(handle, &link->io);
	    if (i == CS_SUCCESS) break;
	}
    next_entry:
	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
    }
    
    CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
    
    /* Set configuration options for the aha152x driver */
    memset(&s, 0, sizeof(s));
    s.conf        = "PCMCIA setup";
    s.io_port     = link->io.BasePort1;
    s.irq         = link->irq.AssignedIRQ;
    s.scsiid      = host_id;
    s.reconnect   = reconnect;
    s.parity      = parity;
    s.synchronous = synchronous;
    s.delay       = reset_delay;
    if (ext_trans)
        s.ext_trans = ext_trans;

    host = aha152x_probe_one(&s);
    if (host == NULL) {
	printk(KERN_INFO "aha152x_cs: no SCSI devices found\n");
	goto cs_failed;
    }

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

    link->state &= ~DEV_CONFIG_PENDING;
    return;
    
cs_failed:
    cs_error(link->handle, last_fn, last_ret);
    aha152x_release_cs(link);
    return;
}

static void aha152x_release_cs(dev_link_t *link)
{
	scsi_info_t *info = link->priv;

	aha152x_release(info->host);
	link->dev = NULL;
    
	pcmcia_release_configuration(link->handle);
	pcmcia_release_io(link->handle, &link->io);
	pcmcia_release_irq(link->handle, &link->irq);
    
	link->state &= ~DEV_CONFIG;
}

static int aha152x_suspend(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state |= DEV_SUSPEND;
	if (link->state & DEV_CONFIG)
		pcmcia_release_configuration(link->handle);

	return 0;
}

static int aha152x_resume(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);
	scsi_info_t *info = link->priv;

	link->state &= ~DEV_SUSPEND;
	if (link->state & DEV_CONFIG) {
		Scsi_Cmnd tmp;
		pcmcia_request_configuration(link->handle, &link->conf);
		tmp.device->host = info->host;
		aha152x_host_reset(&tmp);
	}

	return 0;
}

static int aha152x_event(event_t event, int priority,
			 event_callback_args_t *args)
{
    dev_link_t *link = args->client_data;
    
    DEBUG(0, "aha152x_event(0x%06x)\n", event);
    
    switch (event) {
    case CS_EVENT_CARD_REMOVAL:
	link->state &= ~DEV_PRESENT;
	if (link->state & DEV_CONFIG)
	    aha152x_release_cs(link);
	break;
    case CS_EVENT_CARD_INSERTION:
	link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
	aha152x_config_cs(link);
	break;
    }
    return 0;
}

static struct pcmcia_device_id aha152x_ids[] = {
	PCMCIA_DEVICE_PROD_ID123("New Media", "SCSI", "Bus Toaster", 0xcdf7e4cc, 0x35f26476, 0xa8851d6e),
	PCMCIA_DEVICE_PROD_ID123("NOTEWORTHY", "SCSI", "Bus Toaster", 0xad89c6e8, 0x35f26476, 0xa8851d6e),
	PCMCIA_DEVICE_PROD_ID12("Adaptec, Inc.", "APA-1460 SCSI Host Adapter", 0x24ba9738, 0x3a3c3d20),
	PCMCIA_DEVICE_PROD_ID12("New Media Corporation", "Multimedia Sound/SCSI", 0x085a850b, 0x80a6535c),
	PCMCIA_DEVICE_PROD_ID12("NOTEWORTHY", "NWCOMB02 SCSI/AUDIO COMBO CARD", 0xad89c6e8, 0x5f9a615b),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, aha152x_ids);

static struct pcmcia_driver aha152x_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "aha152x_cs",
	},
	.attach		= aha152x_attach,
	.event		= aha152x_event,
	.detach		= aha152x_detach,
	.id_table       = aha152x_ids,
	.suspend	= aha152x_suspend,
	.resume		= aha152x_resume,
};

static int __init init_aha152x_cs(void)
{
	return pcmcia_register_driver(&aha152x_cs_driver);
}

static void __exit exit_aha152x_cs(void)
{
	pcmcia_unregister_driver(&aha152x_cs_driver);
	BUG_ON(dev_list != NULL);
}

module_init(init_aha152x_cs);
module_exit(exit_aha152x_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for Adaptec AHA152X-compatible PCMCIA SCSI cards.
	4
	5	This driver supports the Adaptec AHA-1460, the New Media Bus
	6	Toaster, and the New Media Toast & Jam.
	7
	8	aha152x_cs.c 1.54 2000/06/12 21:27:25
	9
	10	The contents of this file are subject to the Mozilla Public
	11	License Version 1.1 (the "License"); you may not use this file
	12	except in compliance with the License. You may obtain a copy of
	13	the License at http://www.mozilla.org/MPL/
	14
	15	Software distributed under the License is distributed on an "AS
	16	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	17	implied. See the License for the specific language governing
	18	rights and limitations under the License.
	19
	20	The initial developer of the original code is David A. Hinds
	21	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	22	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	23
	24	Alternatively, the contents of this file may be used under the
	25	terms of the GNU General Public License version 2 (the "GPL"), in which
	26	case the provisions of the GPL are applicable instead of the
	27	above. If you wish to allow the use of your version of this file
	28	only under the terms of the GPL and not to allow others to use
	29	your version of this file under the MPL, indicate your decision
	30	by deleting the provisions above and replace them with the notice
	31	and other provisions required by the GPL. If you do not delete
	32	the provisions above, a recipient may use your version of this
	33	file under either the MPL or the GPL.
	34
	35	======================================================================*/
	36
	37	#include <linux/module.h>
	38	#include <linux/init.h>
	39	#include <linux/kernel.h>
	40	#include <linux/sched.h>
	41	#include <linux/slab.h>
	42	#include <linux/string.h>
	43	#include <linux/ioport.h>
	44	#include <scsi/scsi.h>
	45	#include <linux/major.h>
	46	#include <linux/blkdev.h>
	47	#include <scsi/scsi_ioctl.h>
	48
	49	#include "scsi.h"
	50	#include <scsi/scsi_host.h>
	51	#include "aha152x.h"
	52
1da177e4 LT	53	#include <pcmcia/cs_types.h>
	54	#include <pcmcia/cs.h>
	55	#include <pcmcia/cistpl.h>
	56	#include <pcmcia/ds.h>
	57
	58	#ifdef PCMCIA_DEBUG
	59	static int pc_debug = PCMCIA_DEBUG;
	60	module_param(pc_debug, int, 0644);
	61	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	62	static char *version =
	63	"aha152x_cs.c 1.54 2000/06/12 21:27:25 (David Hinds)";
	64	#else
	65	#define DEBUG(n, args...)
	66	#endif
	67
	68	/====================================================================/
	69
	70	/* Parameters that can be set with 'insmod' */
	71
	72	/* SCSI bus setup options */
	73	static int host_id = 7;
	74	static int reconnect = 1;
	75	static int parity = 1;
	76	static int synchronous = 1;
	77	static int reset_delay = 100;
	78	static int ext_trans = 0;
	79
	80	module_param(host_id, int, 0);
	81	module_param(reconnect, int, 0);
	82	module_param(parity, int, 0);
	83	module_param(synchronous, int, 0);
	84	module_param(reset_delay, int, 0);
	85	module_param(ext_trans, int, 0);
	86
	87	MODULE_LICENSE("Dual MPL/GPL");
	88
	89	/====================================================================/
	90
	91	typedef struct scsi_info_t {
	92	dev_link_t link;
	93	dev_node_t node;
	94	struct Scsi_Host *host;
	95	} scsi_info_t;
	96
	97	static void aha152x_release_cs(dev_link_t *link);
	98	static int aha152x_event(event_t event, int priority,
	99	event_callback_args_t *args);
	100
	101	static dev_link_t *aha152x_attach(void);
	102	static void aha152x_detach(dev_link_t *);
	103
	104	static dev_link_t *dev_list;
	105	static dev_info_t dev_info = "aha152x_cs";
	106
	107	static dev_link_t *aha152x_attach(void)
	108	{
	109	scsi_info_t *info;
	110	client_reg_t client_reg;
	111	dev_link_t *link;
	112	int ret;
	113
	114	DEBUG(0, "aha152x_attach()\n");
	115
	116	/* Create new SCSI device */
117	info = kmalloc(sizeof(*info), GFP_KERNEL);
118	if (!info) return NULL;
119	memset(info, 0, sizeof(*info));
120	link = &info->link; link->priv = info;
121
122	link->io.NumPorts1 = 0x20;
123	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
124	link->io.IOAddrLines = 10;
125	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
126	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
127	link->conf.Attributes = CONF_ENABLE_IRQ;
128	link->conf.Vcc = 50;
129	link->conf.IntType = INT_MEMORY_AND_IO;
130	link->conf.Present = PRESENT_OPTION;
131
132	/* Register with Card Services */
133	link->next = dev_list;
134	dev_list = link;
135	client_reg.dev_info = &dev_info;
1da177e4 LT	136	client_reg.Version = 0x0210;
	137	client_reg.event_callback_args.client_data = link;
	138	ret = pcmcia_register_client(&link->handle, &client_reg);
	139	if (ret != 0) {
	140	cs_error(link->handle, RegisterClient, ret);
	141	aha152x_detach(link);
	142	return NULL;
	143	}
	144
	145	return link;
	146	} /* aha152x_attach */
	147
	148	/====================================================================/
	149
	150	static void aha152x_detach(dev_link_t *link)
	151	{
	152	dev_link_t **linkp;
	153
	154	DEBUG(0, "aha152x_detach(0x%p)\n", link);
	155
	156	/* Locate device structure */
	157	for (linkp = &dev_list; linkp; linkp = &(linkp)->next)
	158	if (*linkp == link) break;
	159	if (*linkp == NULL)
	160	return;
	161
	162	if (link->state & DEV_CONFIG)
	163	aha152x_release_cs(link);
	164
	165	if (link->handle)
	166	pcmcia_deregister_client(link->handle);
	167
	168	/* Unlink device structure, free bits */
	169	*linkp = link->next;
	170	kfree(link->priv);
	171
	172	} /* aha152x_detach */
	173
	174	/====================================================================/
	175
	176	#define CS_CHECK(fn, ret) \
	177	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	178
	179	static void aha152x_config_cs(dev_link_t *link)
	180	{
	181	client_handle_t handle = link->handle;
	182	scsi_info_t *info = link->priv;
	183	struct aha152x_setup s;
	184	tuple_t tuple;
	185	cisparse_t parse;
	186	int i, last_ret, last_fn;
	187	u_char tuple_data[64];
	188	struct Scsi_Host *host;
	189
	190	DEBUG(0, "aha152x_config(0x%p)\n", link);
	191
	192	tuple.DesiredTuple = CISTPL_CONFIG;
	193	tuple.TupleData = tuple_data;
	194	tuple.TupleDataMax = 64;
	195	tuple.TupleOffset = 0;
	196	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	197	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	198	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	199	link->conf.ConfigBase = parse.config.base;
200
201	/* Configure card */
202	link->state \|= DEV_CONFIG;
203
204	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
205	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
206	while (1) {
207	if (pcmcia_get_tuple_data(handle, &tuple) != 0 \|\|
208	pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
209	goto next_entry;
210	/* For New Media T&J, look for a SCSI window */
211	if (parse.cftable_entry.io.win[0].len >= 0x20)
212	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
213	else if ((parse.cftable_entry.io.nwin > 1) &&
214	(parse.cftable_entry.io.win[1].len >= 0x20))
215	link->io.BasePort1 = parse.cftable_entry.io.win[1].base;
216	if ((parse.cftable_entry.io.nwin > 0) &&
217	(link->io.BasePort1 < 0xffff)) {
218	link->conf.ConfigIndex = parse.cftable_entry.index;
219	i = pcmcia_request_io(handle, &link->io);
220	if (i == CS_SUCCESS) break;
221	}
222	next_entry:
223	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
224	}
225
226	CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
227	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
228
229	/* Set configuration options for the aha152x driver */
230	memset(&s, 0, sizeof(s));
231	s.conf = "PCMCIA setup";
232	s.io_port = link->io.BasePort1;
233	s.irq = link->irq.AssignedIRQ;
234	s.scsiid = host_id;
235	s.reconnect = reconnect;
236	s.parity = parity;
237	s.synchronous = synchronous;
238	s.delay = reset_delay;
239	if (ext_trans)
240	s.ext_trans = ext_trans;
241
242	host = aha152x_probe_one(&s);
243	if (host == NULL) {
244	printk(KERN_INFO "aha152x_cs: no SCSI devices found\n");
245	goto cs_failed;
246	}
247
248	sprintf(info->node.dev_name, "scsi%d", host->host_no);
249	link->dev = &info->node;
250	info->host = host;
251
252	link->state &= ~DEV_CONFIG_PENDING;
253	return;
254
255	cs_failed:
256	cs_error(link->handle, last_fn, last_ret);
257	aha152x_release_cs(link);
258	return;
259	}
260
261	static void aha152x_release_cs(dev_link_t *link)
262	{
263	scsi_info_t *info = link->priv;
264
265	aha152x_release(info->host);
266	link->dev = NULL;
267
268	pcmcia_release_configuration(link->handle);
269	pcmcia_release_io(link->handle, &link->io);
270	pcmcia_release_irq(link->handle, &link->irq);
271
272	link->state &= ~DEV_CONFIG;
273	}
274
98e4c28b DB	275	static int aha152x_suspend(struct pcmcia_device *dev)
	276	{
	277	dev_link_t *link = dev_to_instance(dev);
	278
	279	link->state \|= DEV_SUSPEND;
	280	if (link->state & DEV_CONFIG)
	281	pcmcia_release_configuration(link->handle);
	282
	283	return 0;
	284	}
	285
	286	static int aha152x_resume(struct pcmcia_device *dev)
	287	{
	288	dev_link_t *link = dev_to_instance(dev);
	289	scsi_info_t *info = link->priv;
	290
	291	link->state &= ~DEV_SUSPEND;
	292	if (link->state & DEV_CONFIG) {
	293	Scsi_Cmnd tmp;
	294	pcmcia_request_configuration(link->handle, &link->conf);
	295	tmp.device->host = info->host;
	296	aha152x_host_reset(&tmp);
	297	}
	298
	299	return 0;
	300	}
	301
1da177e4 LT	302	static int aha152x_event(event_t event, int priority,
	303	event_callback_args_t *args)
	304	{
	305	dev_link_t *link = args->client_data;
1da177e4 LT	306
	307	DEBUG(0, "aha152x_event(0x%06x)\n", event);
	308
	309	switch (event) {
	310	case CS_EVENT_CARD_REMOVAL:
	311	link->state &= ~DEV_PRESENT;
	312	if (link->state & DEV_CONFIG)
	313	aha152x_release_cs(link);
	314	break;
	315	case CS_EVENT_CARD_INSERTION:
	316	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
	317	aha152x_config_cs(link);
	318	break;
1da177e4 LT	319	}
	320	return 0;
	321	}
	322
2dc27daa DB	323	static struct pcmcia_device_id aha152x_ids[] = {
	324	PCMCIA_DEVICE_PROD_ID123("New Media", "SCSI", "Bus Toaster", 0xcdf7e4cc, 0x35f26476, 0xa8851d6e),
	325	PCMCIA_DEVICE_PROD_ID123("NOTEWORTHY", "SCSI", "Bus Toaster", 0xad89c6e8, 0x35f26476, 0xa8851d6e),
	326	PCMCIA_DEVICE_PROD_ID12("Adaptec, Inc.", "APA-1460 SCSI Host Adapter", 0x24ba9738, 0x3a3c3d20),
	327	PCMCIA_DEVICE_PROD_ID12("New Media Corporation", "Multimedia Sound/SCSI", 0x085a850b, 0x80a6535c),
	328	PCMCIA_DEVICE_PROD_ID12("NOTEWORTHY", "NWCOMB02 SCSI/AUDIO COMBO CARD", 0xad89c6e8, 0x5f9a615b),
	329	PCMCIA_DEVICE_NULL,
	330	};
	331	MODULE_DEVICE_TABLE(pcmcia, aha152x_ids);
	332
1da177e4 LT	333	static struct pcmcia_driver aha152x_cs_driver = {
	334	.owner = THIS_MODULE,
	335	.drv = {
	336	.name = "aha152x_cs",
	337	},
	338	.attach = aha152x_attach,
1e212f36	339	.event = aha152x_event,
1da177e4	340	.detach = aha152x_detach,
2dc27daa	341	.id_table = aha152x_ids,
98e4c28b DB	342	.suspend = aha152x_suspend,
98e4c28b DB	343	.resume = aha152x_resume,
1da177e4 LT	344	};
	345
	346	static int __init init_aha152x_cs(void)
	347	{
	348	return pcmcia_register_driver(&aha152x_cs_driver);
	349	}
	350
	351	static void __exit exit_aha152x_cs(void)
	352	{
	353	pcmcia_unregister_driver(&aha152x_cs_driver);
	354	BUG_ON(dev_list != NULL);
	355	}
	356
	357	module_init(init_aha152x_cs);
	358	module_exit(exit_aha152x_cs);
	359