[mirror_ubuntu-artful-kernel.git] / drivers / scsi / pcmcia / fdomain_stub.c

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

    A driver for Future Domain-compatible PCMCIA SCSI cards

    fdomain_cs.c 1.47 2001/10/13 00:08:52

    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 "fdomain.h"

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

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

/* Module parameters */

MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
MODULE_DESCRIPTION("Future Domain PCMCIA SCSI driver");
MODULE_LICENSE("Dual MPL/GPL");

#ifdef PCMCIA_DEBUG
static int pc_debug = PCMCIA_DEBUG;
module_param(pc_debug, int, 0);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
static char *version =
"fdomain_cs.c 1.47 2001/10/13 00:08:52 (David Hinds)";
#else
#define DEBUG(n, args...)
#endif

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

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


static void fdomain_release(dev_link_t *link);
static int fdomain_event(event_t event, int priority,
			event_callback_args_t *args);

static dev_link_t *fdomain_attach(void);
static void fdomain_detach(dev_link_t *);


static dev_link_t *dev_list = NULL;

static dev_info_t dev_info = "fdomain_cs";

static dev_link_t *fdomain_attach(void)
{
    scsi_info_t *info;
    client_reg_t client_reg;
    dev_link_t *link;
    int ret;
    
    DEBUG(0, "fdomain_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 = 0x10;
    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);
	fdomain_detach(link);
	return NULL;
    }
    
    return link;
} /* fdomain_attach */

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

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

    DEBUG(0, "fdomain_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)
	fdomain_release(link);

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

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

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

static void fdomain_config(dev_link_t *link)
{
    client_handle_t handle = link->handle;
    scsi_info_t *info = link->priv;
    tuple_t tuple;
    cisparse_t parse;
    int i, last_ret, last_fn;
    u_char tuple_data[64];
    char str[16];
    struct Scsi_Host *host;

    DEBUG(0, "fdomain_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;
	link->conf.ConfigIndex = parse.cftable_entry.index;
	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
	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));
    
    /* A bad hack... */
    release_region(link->io.BasePort1, link->io.NumPorts1);

    /* Set configuration options for the fdomain driver */
    sprintf(str, "%d,%d", link->io.BasePort1, link->irq.AssignedIRQ);
    fdomain_setup(str);
    
    host = __fdomain_16x0_detect(&fdomain_driver_template);
    if (!host) {
        printk(KERN_INFO "fdomain_cs: no SCSI devices found\n");
	goto cs_failed;
    }
 
    scsi_add_host(host, NULL); /* XXX handle failure */
    scsi_scan_host(host);

    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);
    fdomain_release(link);
    return;
    
} /* fdomain_config */

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

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

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

    scsi_remove_host(info->host);
    link->dev = NULL;
    
    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);

    scsi_unregister(info->host);

    link->state &= ~DEV_CONFIG;
}

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

static int fdomain_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 fdomain_resume(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state &= ~DEV_SUSPEND;
	if (link->state & DEV_CONFIG) {
		pcmcia_request_configuration(link->handle, &link->conf);
		fdomain_16x0_bus_reset(NULL);
	}

	return 0;
}

static int fdomain_event(event_t event, int priority,
			event_callback_args_t *args)
{
    dev_link_t *link = args->client_data;

    DEBUG(1, "fdomain_event(0x%06x)\n", event);
    
    switch (event) {
    case CS_EVENT_CARD_REMOVAL:
	link->state &= ~DEV_PRESENT;
	if (link->state & DEV_CONFIG)
	    fdomain_release(link);
	break;
    case CS_EVENT_CARD_INSERTION:
	link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
	fdomain_config(link);
	break;
    }
    return 0;
} /* fdomain_event */


static struct pcmcia_device_id fdomain_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "SCSI PCMCIA Card", 0xe3736c88, 0x859cad20),
	PCMCIA_DEVICE_PROD_ID1("SCSI PCMCIA Adapter Card", 0x8dacb57e),
	PCMCIA_DEVICE_PROD_ID12(" SIMPLE TECHNOLOGY Corporation", "SCSI PCMCIA Credit Card Controller", 0x182bdafe, 0xc80d106f),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, fdomain_ids);

static struct pcmcia_driver fdomain_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "fdomain_cs",
	},
	.attach		= fdomain_attach,
	.event		= fdomain_event,
	.detach		= fdomain_detach,
	.id_table       = fdomain_ids,
	.suspend	= fdomain_suspend,
	.resume		= fdomain_resume,
};

static int __init init_fdomain_cs(void)
{
	return pcmcia_register_driver(&fdomain_cs_driver);
}

static void __exit exit_fdomain_cs(void)
{
	pcmcia_unregister_driver(&fdomain_cs_driver);
	BUG_ON(dev_list != NULL);
}

module_init(init_fdomain_cs);
module_exit(exit_fdomain_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for Future Domain-compatible PCMCIA SCSI cards
	4
	5	fdomain_cs.c 1.47 2001/10/13 00:08:52
	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
	23	which 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 <scsi/scsi.h>
	42	#include <linux/major.h>
	43	#include <linux/blkdev.h>
	44	#include <scsi/scsi_ioctl.h>
	45
	46	#include "scsi.h"
	47	#include <scsi/scsi_host.h>
	48	#include "fdomain.h"
	49
1da177e4 LT	50	#include <pcmcia/cs_types.h>
	51	#include <pcmcia/cs.h>
	52	#include <pcmcia/cistpl.h>
	53	#include <pcmcia/ds.h>
	54
	55	/====================================================================/
	56
	57	/* Module parameters */
	58
	59	MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
	60	MODULE_DESCRIPTION("Future Domain PCMCIA SCSI driver");
	61	MODULE_LICENSE("Dual MPL/GPL");
	62
	63	#ifdef PCMCIA_DEBUG
	64	static int pc_debug = PCMCIA_DEBUG;
	65	module_param(pc_debug, int, 0);
	66	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	67	static char *version =
	68	"fdomain_cs.c 1.47 2001/10/13 00:08:52 (David Hinds)";
	69	#else
	70	#define DEBUG(n, args...)
	71	#endif
	72
	73	/====================================================================/
	74
	75	typedef struct scsi_info_t {
	76	dev_link_t link;
	77	dev_node_t node;
	78	struct Scsi_Host *host;
	79	} scsi_info_t;
	80
	81
	82	static void fdomain_release(dev_link_t *link);
	83	static int fdomain_event(event_t event, int priority,
	84	event_callback_args_t *args);
	85
	86	static dev_link_t *fdomain_attach(void);
	87	static void fdomain_detach(dev_link_t *);
	88
	89
	90	static dev_link_t *dev_list = NULL;
	91
	92	static dev_info_t dev_info = "fdomain_cs";
	93
	94	static dev_link_t *fdomain_attach(void)
	95	{
	96	scsi_info_t *info;
	97	client_reg_t client_reg;
	98	dev_link_t *link;
	99	int ret;
	100
	101	DEBUG(0, "fdomain_attach()\n");
	102
	103	/* Create new SCSI device */
	104	info = kmalloc(sizeof(*info), GFP_KERNEL);
	105	if (!info) return NULL;
	106	memset(info, 0, sizeof(*info));
	107	link = &info->link; link->priv = info;
	108	link->io.NumPorts1 = 0x10;
	109	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	110	link->io.IOAddrLines = 10;
	111	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	112	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	113	link->conf.Attributes = CONF_ENABLE_IRQ;
114	link->conf.Vcc = 50;
115	link->conf.IntType = INT_MEMORY_AND_IO;
116	link->conf.Present = PRESENT_OPTION;
117
118	/* Register with Card Services */
119	link->next = dev_list;
120	dev_list = link;
121	client_reg.dev_info = &dev_info;
1da177e4 LT	122	client_reg.Version = 0x0210;
	123	client_reg.event_callback_args.client_data = link;
	124	ret = pcmcia_register_client(&link->handle, &client_reg);
	125	if (ret != 0) {
	126	cs_error(link->handle, RegisterClient, ret);
	127	fdomain_detach(link);
	128	return NULL;
	129	}
	130
	131	return link;
	132	} /* fdomain_attach */
	133
	134	/====================================================================/
	135
	136	static void fdomain_detach(dev_link_t *link)
	137	{
	138	dev_link_t **linkp;
	139
	140	DEBUG(0, "fdomain_detach(0x%p)\n", link);
	141
	142	/* Locate device structure */
	143	for (linkp = &dev_list; linkp; linkp = &(linkp)->next)
	144	if (*linkp == link) break;
	145	if (*linkp == NULL)
	146	return;
	147
	148	if (link->state & DEV_CONFIG)
	149	fdomain_release(link);
	150
	151	if (link->handle)
	152	pcmcia_deregister_client(link->handle);
	153
	154	/* Unlink device structure, free bits */
	155	*linkp = link->next;
	156	kfree(link->priv);
	157
	158	} /* fdomain_detach */
	159
	160	/====================================================================/
	161
	162	#define CS_CHECK(fn, ret) \
	163	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	164
	165	static void fdomain_config(dev_link_t *link)
	166	{
	167	client_handle_t handle = link->handle;
	168	scsi_info_t *info = link->priv;
	169	tuple_t tuple;
	170	cisparse_t parse;
	171	int i, last_ret, last_fn;
	172	u_char tuple_data[64];
	173	char str[16];
	174	struct Scsi_Host *host;
	175
	176	DEBUG(0, "fdomain_config(0x%p)\n", link);
	177
	178	tuple.DesiredTuple = CISTPL_CONFIG;
	179	tuple.TupleData = tuple_data;
	180	tuple.TupleDataMax = 64;
	181	tuple.TupleOffset = 0;
	182	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	183	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	184	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	185	link->conf.ConfigBase = parse.config.base;
186
187	/* Configure card */
188	link->state \|= DEV_CONFIG;
189
190	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
191	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
192	while (1) {
193	if (pcmcia_get_tuple_data(handle, &tuple) != 0 \|\|
194	pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
195	goto next_entry;
196	link->conf.ConfigIndex = parse.cftable_entry.index;
197	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
198	i = pcmcia_request_io(handle, &link->io);
199	if (i == CS_SUCCESS) break;
200	next_entry:
201	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
202	}
203
204	CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
205	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
206
207	/* A bad hack... */
208	release_region(link->io.BasePort1, link->io.NumPorts1);
209
210	/* Set configuration options for the fdomain driver */
211	sprintf(str, "%d,%d", link->io.BasePort1, link->irq.AssignedIRQ);
212	fdomain_setup(str);
213
214	host = __fdomain_16x0_detect(&fdomain_driver_template);
215	if (!host) {
216	printk(KERN_INFO "fdomain_cs: no SCSI devices found\n");
217	goto cs_failed;
218	}
219
220	scsi_add_host(host, NULL); /* XXX handle failure */
221	scsi_scan_host(host);
222
223	sprintf(info->node.dev_name, "scsi%d", host->host_no);
224	link->dev = &info->node;
225	info->host = host;
226
227	link->state &= ~DEV_CONFIG_PENDING;
228	return;
229
230	cs_failed:
231	cs_error(link->handle, last_fn, last_ret);
232	fdomain_release(link);
233	return;
234
235	} /* fdomain_config */
236
237	/====================================================================/
238
239	static void fdomain_release(dev_link_t *link)
240	{
241	scsi_info_t *info = link->priv;
242
243	DEBUG(0, "fdomain_release(0x%p)\n", link);
244
245	scsi_remove_host(info->host);
246	link->dev = NULL;
247
248	pcmcia_release_configuration(link->handle);
249	pcmcia_release_io(link->handle, &link->io);
250	pcmcia_release_irq(link->handle, &link->irq);
251
252	scsi_unregister(info->host);
253
254	link->state &= ~DEV_CONFIG;
255	}
256
257	/====================================================================/
258
98e4c28b DB	259	static int fdomain_suspend(struct pcmcia_device *dev)
	260	{
	261	dev_link_t *link = dev_to_instance(dev);
	262
	263	link->state \|= DEV_SUSPEND;
	264	if (link->state & DEV_CONFIG)
	265	pcmcia_release_configuration(link->handle);
	266
	267	return 0;
	268	}
	269
	270	static int fdomain_resume(struct pcmcia_device *dev)
	271	{
	272	dev_link_t *link = dev_to_instance(dev);
	273
	274	link->state &= ~DEV_SUSPEND;
	275	if (link->state & DEV_CONFIG) {
	276	pcmcia_request_configuration(link->handle, &link->conf);
	277	fdomain_16x0_bus_reset(NULL);
	278	}
	279
	280	return 0;
	281	}
	282
1da177e4 LT	283	static int fdomain_event(event_t event, int priority,
	284	event_callback_args_t *args)
	285	{
	286	dev_link_t *link = args->client_data;
	287
	288	DEBUG(1, "fdomain_event(0x%06x)\n", event);
	289
	290	switch (event) {
	291	case CS_EVENT_CARD_REMOVAL:
	292	link->state &= ~DEV_PRESENT;
	293	if (link->state & DEV_CONFIG)
	294	fdomain_release(link);
	295	break;
	296	case CS_EVENT_CARD_INSERTION:
	297	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
	298	fdomain_config(link);
	299	break;
1da177e4 LT	300	}
	301	return 0;
	302	} /* fdomain_event */
	303
2d1fb376 DB	304
	305	static struct pcmcia_device_id fdomain_ids[] = {
	306	PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "SCSI PCMCIA Card", 0xe3736c88, 0x859cad20),
	307	PCMCIA_DEVICE_PROD_ID1("SCSI PCMCIA Adapter Card", 0x8dacb57e),
	308	PCMCIA_DEVICE_PROD_ID12(" SIMPLE TECHNOLOGY Corporation", "SCSI PCMCIA Credit Card Controller", 0x182bdafe, 0xc80d106f),
	309	PCMCIA_DEVICE_NULL,
	310	};
	311	MODULE_DEVICE_TABLE(pcmcia, fdomain_ids);
	312
1da177e4 LT	313	static struct pcmcia_driver fdomain_cs_driver = {
	314	.owner = THIS_MODULE,
	315	.drv = {
	316	.name = "fdomain_cs",
	317	},
	318	.attach = fdomain_attach,
1e212f36	319	.event = fdomain_event,
1da177e4	320	.detach = fdomain_detach,
2d1fb376	321	.id_table = fdomain_ids,
98e4c28b DB	322	.suspend = fdomain_suspend,
98e4c28b DB	323	.resume = fdomain_resume,
1da177e4 LT	324	};
	325
	326	static int __init init_fdomain_cs(void)
	327	{
	328	return pcmcia_register_driver(&fdomain_cs_driver);
	329	}
	330
	331	static void __exit exit_fdomain_cs(void)
	332	{
	333	pcmcia_unregister_driver(&fdomain_cs_driver);
	334	BUG_ON(dev_list != NULL);
	335	}
	336
	337	module_init(init_fdomain_cs);
	338	module_exit(exit_fdomain_cs);