[linux-2.6-block.git] / drivers / ide / legacy / ide-cs.c

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

    A driver for PCMCIA IDE/ATA disk cards

    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/kernel.h>
#include <linux/init.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/ide.h>
#include <linux/hdreg.h>
#include <linux/major.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/system.h>

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

#define DRV_NAME "ide-cs"

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

/* Module parameters */

MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
MODULE_LICENSE("Dual MPL/GPL");

#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)

#ifdef CONFIG_PCMCIA_DEBUG
INT_MODULE_PARM(pc_debug, 0);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
#else
#define DEBUG(n, args...)
#endif

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

typedef struct ide_info_t {
	struct pcmcia_device	*p_dev;
	struct ide_host		*host;
    int		ndev;
    dev_node_t	node;
} ide_info_t;

static void ide_release(struct pcmcia_device *);
static int ide_config(struct pcmcia_device *);

static void ide_detach(struct pcmcia_device *p_dev);


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

    ide_attach() creates an "instance" of the driver, allocating
    local data structures for one device.  The device is registered
    with Card Services.

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

static int ide_probe(struct pcmcia_device *link)
{
    ide_info_t *info;

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

    /* Create new ide 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_AUTO;
    link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
    link->io.IOAddrLines = 3;
    link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
    link->irq.IRQInfo1 = IRQ_LEVEL_ID;
    link->conf.Attributes = CONF_ENABLE_IRQ;
    link->conf.IntType = INT_MEMORY_AND_IO;

    return ide_config(link);
} /* ide_attach */

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

    This deletes a driver "instance".  The device is de-registered
    with Card Services.  If it has been released, all local data
    structures are freed.  Otherwise, the structures will be freed
    when the device is released.

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

static void ide_detach(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    ide_hwif_t *hwif = info->host->ports[0];
    unsigned long data_addr, ctl_addr;

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

    data_addr = hwif->io_ports.data_addr;
    ctl_addr  = hwif->io_ports.ctl_addr;

    ide_release(link);

    release_region(ctl_addr, 1);
    release_region(data_addr, 8);

    kfree(info);
} /* ide_detach */

static const struct ide_port_ops idecs_port_ops = {
	.quirkproc		= ide_undecoded_slave,
};

static const struct ide_port_info idecs_port_info = {
	.port_ops		= &idecs_port_ops,
	.host_flags		= IDE_HFLAG_NO_DMA,
};

static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
				unsigned long irq, struct pcmcia_device *handle)
{
    struct ide_host *host;
    ide_hwif_t *hwif;
    int i;
    hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };

    if (!request_region(io, 8, DRV_NAME)) {
	printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
			DRV_NAME, io, io + 7);
	return NULL;
    }

    if (!request_region(ctl, 1, DRV_NAME)) {
	printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
			DRV_NAME, ctl);
	release_region(io, 8);
	return NULL;
    }

    memset(&hw, 0, sizeof(hw));
    ide_std_init_ports(&hw, io, ctl);
    hw.irq = irq;
    hw.chipset = ide_pci;
    hw.dev = &handle->dev;

    host = ide_host_alloc(&idecs_port_info, hws);
    if (host == NULL)
	goto out_release;

    ide_host_register(host, &idecs_port_info, hws);

    hwif = host->ports[0];

    if (hwif->present)
	return host;

    /* retry registration in case device is still spinning up */
    for (i = 0; i < 10; i++) {
	msleep(100);
	ide_port_scan(hwif);
	if (hwif->present)
	    return host;
    }

    return host;

out_release:
    release_region(ctl, 1);
    release_region(io, 8);
    return NULL;
}

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

    ide_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    ide device available to the system.

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

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

static int ide_config(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    tuple_t tuple;
    struct {
	u_short		buf[128];
	cisparse_t	parse;
	config_info_t	conf;
	cistpl_cftable_entry_t dflt;
    } *stk = NULL;
    cistpl_cftable_entry_t *cfg;
    int pass, last_ret = 0, last_fn = 0, is_kme = 0;
    unsigned long io_base, ctl_base;
    struct ide_host *host;

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

    stk = kzalloc(sizeof(*stk), GFP_KERNEL);
    if (!stk) goto err_mem;
    cfg = &stk->parse.cftable_entry;

    tuple.TupleData = (cisdata_t *)&stk->buf;
    tuple.TupleOffset = 0;
    tuple.TupleDataMax = 255;
    tuple.Attributes = 0;

    is_kme = ((link->manf_id == MANFID_KME) &&
	      ((link->card_id == PRODID_KME_KXLC005_A) ||
	       (link->card_id == PRODID_KME_KXLC005_B)));

    /* Not sure if this is right... look up the current Vcc */
    CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));

    pass = io_base = ctl_base = 0;
    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
    tuple.Attributes = 0;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
    while (1) {
    	if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
	if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;

	/* Check for matching Vcc, unless we're desperate */
	if (!pass) {
	    if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
		if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
		    goto next_entry;
	    } else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
		if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
		    goto next_entry;
	    }
	}

	if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
	    link->conf.Vpp =
		cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
	else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
	    link->conf.Vpp =
		stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;

	if ((cfg->io.nwin > 0) || (stk->dflt.io.nwin > 0)) {
	    cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
	    link->conf.ConfigIndex = cfg->index;
	    link->io.BasePort1 = io->win[0].base;
	    link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	    if (!(io->flags & CISTPL_IO_16BIT))
		link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	    if (io->nwin == 2) {
		link->io.NumPorts1 = 8;
		link->io.BasePort2 = io->win[1].base;
		link->io.NumPorts2 = (is_kme) ? 2 : 1;
		if (pcmcia_request_io(link, &link->io) != 0)
			goto next_entry;
		io_base = link->io.BasePort1;
		ctl_base = link->io.BasePort2;
	    } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
		link->io.NumPorts1 = io->win[0].len;
		link->io.NumPorts2 = 0;
		if (pcmcia_request_io(link, &link->io) != 0)
			goto next_entry;
		io_base = link->io.BasePort1;
		ctl_base = link->io.BasePort1 + 0x0e;
	    } else goto next_entry;
	    /* If we've got this far, we're done */
	    break;
	}

    next_entry:
	if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
	    memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
	if (pass) {
	    CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
	} else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
	    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	    memset(&stk->dflt, 0, sizeof(stk->dflt));
	    pass++;
	}
    }

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

    /* disable drive interrupts during IDE probe */
    outb(0x02, ctl_base);

    /* special setup for KXLC005 card */
    if (is_kme)
	outb(0x81, ctl_base+1);

     host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
     if (host == NULL && link->io.NumPorts1 == 0x20) {
	    outb(0x02, ctl_base + 0x10);
	    host = idecs_register(io_base + 0x10, ctl_base + 0x10,
				  link->irq.AssignedIRQ, link);
    }

    if (host == NULL)
	goto failed;

    info->ndev = 1;
    sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
    info->node.major = host->ports[0]->major;
    info->node.minor = 0;
    info->host = host;
    link->dev_node = &info->node;
    printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
	   info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);

    kfree(stk);
    return 0;

err_mem:
    printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
    goto failed;

cs_failed:
    cs_error(link, last_fn, last_ret);
failed:
    kfree(stk);
    ide_release(link);
    return -ENODEV;
} /* ide_config */

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

    After a card is removed, ide_release() will unregister the net
    device, and release the PCMCIA configuration.  If the device is
    still open, this will be postponed until it is closed.

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

static void ide_release(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    struct ide_host *host = info->host;

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

    if (info->ndev)
	/* FIXME: if this fails we need to queue the cleanup somehow
	   -- need to investigate the required PCMCIA magic */
	ide_host_remove(host);

    info->ndev = 0;

    pcmcia_disable_device(link);
} /* ide_release */


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

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.  A CARD_REMOVAL event
    also sets some flags to discourage the ide drivers from
    talking to the ports.

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

static struct pcmcia_device_id ide_ids[] = {
	PCMCIA_DEVICE_FUNC_ID(4),
	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),	/* Corsair */
	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),	/* Hitachi */
	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),	/* I-O Data CFA */
	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),	/* Mitsubishi CFA */
	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),	/* SanDisk CFA */
	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),	/* Kingston */
	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),	/* Toshiba */
	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),	/* Samsung */
	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),	/* Hitachi */
	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),	/* Viking CFA */
	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),	/* Lexar, Viking CFA */
	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, ide_ids);

static struct pcmcia_driver ide_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "ide-cs",
	},
	.probe		= ide_probe,
	.remove		= ide_detach,
	.id_table       = ide_ids,
};

static int __init init_ide_cs(void)
{
	return pcmcia_register_driver(&ide_cs_driver);
}

static void __exit exit_ide_cs(void)
{
	pcmcia_unregister_driver(&ide_cs_driver);
}

late_initcall(init_ide_cs);
module_exit(exit_ide_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for PCMCIA IDE/ATA disk cards
	4
1da177e4 LT	5	The contents of this file are subject to the Mozilla Public
	6	License Version 1.1 (the "License"); you may not use this file
	7	except in compliance with the License. You may obtain a copy of
	8	the License at http://www.mozilla.org/MPL/
	9
	10	Software distributed under the License is distributed on an "AS
	11	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	12	implied. See the License for the specific language governing
	13	rights and limitations under the License.
	14
	15	The initial developer of the original code is David A. Hinds
	16	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	17	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	18
	19	Alternatively, the contents of this file may be used under the
	20	terms of the GNU General Public License version 2 (the "GPL"), in
	21	which case the provisions of the GPL are applicable instead of the
	22	above. If you wish to allow the use of your version of this file
	23	only under the terms of the GPL and not to allow others to use
	24	your version of this file under the MPL, indicate your decision
	25	by deleting the provisions above and replace them with the notice
	26	and other provisions required by the GPL. If you do not delete
	27	the provisions above, a recipient may use your version of this
	28	file under either the MPL or the GPL.
7b1dec59	29
1da177e4 LT	30	======================================================================*/
	31
	32	#include <linux/module.h>
	33	#include <linux/kernel.h>
	34	#include <linux/init.h>
1da177e4 LT	35	#include <linux/ptrace.h>
	36	#include <linux/slab.h>
	37	#include <linux/string.h>
	38	#include <linux/timer.h>
	39	#include <linux/ioport.h>
	40	#include <linux/ide.h>
	41	#include <linux/hdreg.h>
	42	#include <linux/major.h>
2aad5f03	43	#include <linux/delay.h>
1da177e4 LT	44	#include <asm/io.h>
	45	#include <asm/system.h>
	46
1da177e4 LT	47	#include <pcmcia/cs_types.h>
	48	#include <pcmcia/cs.h>
	49	#include <pcmcia/cistpl.h>
	50	#include <pcmcia/ds.h>
	51	#include <pcmcia/cisreg.h>
	52	#include <pcmcia/ciscode.h>
	53
d703b79e BZ	54	#define DRV_NAME "ide-cs"
d703b79e BZ	55
1da177e4 LT	56	/====================================================================/
	57
	58	/* Module parameters */
	59
	60	MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
	61	MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
	62	MODULE_LICENSE("Dual MPL/GPL");
	63
	64	#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
	65
81522429 LF	66	#ifdef CONFIG_PCMCIA_DEBUG
81522429 LF	67	INT_MODULE_PARM(pc_debug, 0);
1da177e4	68	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
1da177e4 LT	69	#else
	70	#define DEBUG(n, args...)
	71	#endif
	72
	73	/====================================================================/
	74
1da177e4	75	typedef struct ide_info_t {
fd238232	76	struct pcmcia_device *p_dev;
48c3c107	77	struct ide_host *host;
1da177e4 LT	78	int ndev;
1da177e4 LT	79	dev_node_t node;
1da177e4 LT	80	} ide_info_t;
1da177e4 LT	81
fba395ee	82	static void ide_release(struct pcmcia_device *);
15b99ac1	83	static int ide_config(struct pcmcia_device *);
1da177e4	84
cc3b4866	85	static void ide_detach(struct pcmcia_device *p_dev);
1da177e4	86
b4635811 DB	87
b4635811 DB	88
1da177e4 LT	89
	90	/*======================================================================
	91
	92	ide_attach() creates an "instance" of the driver, allocating
	93	local data structures for one device. The device is registered
	94	with Card Services.
	95
	96	======================================================================*/
	97
15b99ac1	98	static int ide_probe(struct pcmcia_device *link)
1da177e4 LT	99	{
1da177e4 LT	100	ide_info_t *info;
f8cfa618	101
1da177e4 LT	102	DEBUG(0, "ide_attach()\n");
	103
	104	/* Create new ide device */
f5e3c2fa	105	info = kzalloc(sizeof(*info), GFP_KERNEL);
f8cfa618 DB	106	if (!info)
f8cfa618 DB	107	return -ENOMEM;
fd238232	108
fba395ee	109	info->p_dev = link;
fd238232	110	link->priv = info;
1da177e4 LT	111
	112	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	113	link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
	114	link->io.IOAddrLines = 3;
53a04c6f	115	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
1da177e4 LT	116	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
1da177e4 LT	117	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4	118	link->conf.IntType = INT_MEMORY_AND_IO;
f8cfa618	119
15b99ac1	120	return ide_config(link);
1da177e4 LT	121	} /* ide_attach */
	122
	123	/*======================================================================
	124
	125	This deletes a driver "instance". The device is de-registered
	126	with Card Services. If it has been released, all local data
	127	structures are freed. Otherwise, the structures will be freed
	128	when the device is released.
	129
	130	======================================================================*/
	131
fba395ee	132	static void ide_detach(struct pcmcia_device *link)
1da177e4	133	{
d703b79e	134	ide_info_t *info = link->priv;
48c3c107	135	ide_hwif_t *hwif = info->host->ports[0];
fbc69fd9	136	unsigned long data_addr, ctl_addr;
d703b79e	137
1da177e4	138	DEBUG(0, "ide_detach(0x%p)\n", link);
1da177e4	139
fbc69fd9 BZ	140	data_addr = hwif->io_ports.data_addr;
	141	ctl_addr = hwif->io_ports.ctl_addr;
	142
e2d40963	143	ide_release(link);
b4635811	144
fbc69fd9 BZ	145	release_region(ctl_addr, 1);
fbc69fd9 BZ	146	release_region(data_addr, 8);
d703b79e BZ	147
d703b79e BZ	148	kfree(info);
1da177e4 LT	149	} /* ide_detach */
1da177e4 LT	150
ac95beed BZ	151	static const struct ide_port_ops idecs_port_ops = {
	152	.quirkproc = ide_undecoded_slave,
	153	};
	154
dccdf527 BZ	155	static const struct ide_port_info idecs_port_info = {
	156	.port_ops = &idecs_port_ops,
	157	.host_flags = IDE_HFLAG_NO_DMA,
	158	};
	159
48c3c107	160	static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
d703b79e	161	unsigned long irq, struct pcmcia_device *handle)
1da177e4	162	{
48c3c107	163	struct ide_host *host;
9e016a71	164	ide_hwif_t *hwif;
9e016a71	165	int i;
c97c6aca	166	hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
9e016a71	167
d703b79e BZ	168	if (!request_region(io, 8, DRV_NAME)) {
	169	printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
	170	DRV_NAME, io, io + 7);
	171	return NULL;
	172	}
	173
	174	if (!request_region(ctl, 1, DRV_NAME)) {
	175	printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
	176	DRV_NAME, ctl);
	177	release_region(io, 8);
	178	return NULL;
	179	}
	180
1da177e4	181	memset(&hw, 0, sizeof(hw));
dcb425f5	182	ide_std_init_ports(&hw, io, ctl);
1da177e4 LT	183	hw.irq = irq;
1da177e4 LT	184	hw.chipset = ide_pci;
4349d5cd	185	hw.dev = &handle->dev;
9e016a71	186
48c3c107 BZ	187	host = ide_host_alloc(&idecs_port_info, hws);
48c3c107 BZ	188	if (host == NULL)
d703b79e	189	goto out_release;
9e016a71	190
48c3c107	191	ide_host_register(host, &idecs_port_info, hws);
9e016a71	192
48c3c107	193	hwif = host->ports[0];
9e016a71	194
d703b79e	195	if (hwif->present)
48c3c107	196	return host;
d703b79e	197
792a1a98 BZ	198	/* retry registration in case device is still spinning up */
	199	for (i = 0; i < 10; i++) {
	200	msleep(100);
	201	ide_port_scan(hwif);
	202	if (hwif->present)
48c3c107	203	return host;
792a1a98 BZ	204	}
792a1a98 BZ	205
48c3c107	206	return host;
792a1a98	207
d703b79e BZ	208	out_release:
	209	release_region(ctl, 1);
	210	release_region(io, 8);
	211	return NULL;
1da177e4 LT	212	}
	213
	214	/*======================================================================
	215
	216	ide_config() is scheduled to run after a CARD_INSERTION event
	217	is received, to configure the PCMCIA socket, and to make the
	218	ide device available to the system.
	219
	220	======================================================================*/
	221
	222	#define CS_CHECK(fn, ret) \
	223	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	224
15b99ac1	225	static int ide_config(struct pcmcia_device *link)
1da177e4	226	{
1da177e4 LT	227	ide_info_t *info = link->priv;
	228	tuple_t tuple;
	229	struct {
	230	u_short buf[128];
	231	cisparse_t parse;
	232	config_info_t conf;
	233	cistpl_cftable_entry_t dflt;
	234	} *stk = NULL;
	235	cistpl_cftable_entry_t *cfg;
792a1a98	236	int pass, last_ret = 0, last_fn = 0, is_kme = 0;
2f1b9250	237	unsigned long io_base, ctl_base;
48c3c107	238	struct ide_host *host;
1da177e4 LT	239
	240	DEBUG(0, "ide_config(0x%p)\n", link);
	241
f5e3c2fa	242	stk = kzalloc(sizeof(*stk), GFP_KERNEL);
1da177e4	243	if (!stk) goto err_mem;
1da177e4 LT	244	cfg = &stk->parse.cftable_entry;
	245
	246	tuple.TupleData = (cisdata_t *)&stk->buf;
	247	tuple.TupleOffset = 0;
	248	tuple.TupleDataMax = 255;
	249	tuple.Attributes = 0;
1da177e4	250
efd50585 DB	251	is_kme = ((link->manf_id == MANFID_KME) &&
	252	((link->card_id == PRODID_KME_KXLC005_A) \|\|
	253	(link->card_id == PRODID_KME_KXLC005_B)));
1da177e4	254
1da177e4	255	/* Not sure if this is right... look up the current Vcc */
fba395ee	256	CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
1da177e4	257
2f1b9250	258	pass = io_base = ctl_base = 0;
1da177e4 LT	259	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
1da177e4 LT	260	tuple.Attributes = 0;
fba395ee	261	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1da177e4	262	while (1) {
fba395ee DB	263	if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
fba395ee DB	264	if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;
1da177e4 LT	265
	266	/* Check for matching Vcc, unless we're desperate */
	267	if (!pass) {
	268	if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
	269	if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
	270	goto next_entry;
	271	} else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
	272	if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
	273	goto next_entry;
	274	}
	275	}
	276
	277	if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	278	link->conf.Vpp =
1da177e4 LT	279	cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	280	else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	281	link->conf.Vpp =
1da177e4 LT	282	stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
	283
	284	if ((cfg->io.nwin > 0) \|\| (stk->dflt.io.nwin > 0)) {
	285	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
	286	link->conf.ConfigIndex = cfg->index;
	287	link->io.BasePort1 = io->win[0].base;
	288	link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	289	if (!(io->flags & CISTPL_IO_16BIT))
	290	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	291	if (io->nwin == 2) {
	292	link->io.NumPorts1 = 8;
	293	link->io.BasePort2 = io->win[1].base;
	294	link->io.NumPorts2 = (is_kme) ? 2 : 1;
fba395ee	295	if (pcmcia_request_io(link, &link->io) != 0)
1da177e4 LT	296	goto next_entry;
	297	io_base = link->io.BasePort1;
	298	ctl_base = link->io.BasePort2;
	299	} else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
	300	link->io.NumPorts1 = io->win[0].len;
	301	link->io.NumPorts2 = 0;
fba395ee	302	if (pcmcia_request_io(link, &link->io) != 0)
1da177e4 LT	303	goto next_entry;
	304	io_base = link->io.BasePort1;
	305	ctl_base = link->io.BasePort1 + 0x0e;
	306	} else goto next_entry;
	307	/* If we've got this far, we're done */
	308	break;
	309	}
	310
	311	next_entry:
	312	if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
	313	memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
	314	if (pass) {
fba395ee DB	315	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
	316	} else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
	317	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1da177e4 LT	318	memset(&stk->dflt, 0, sizeof(stk->dflt));
	319	pass++;
	320	}
	321	}
	322
fba395ee DB	323	CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
fba395ee DB	324	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1da177e4 LT	325
1da177e4 LT	326	/* disable drive interrupts during IDE probe */
2f1b9250	327	outb(0x02, ctl_base);
1da177e4 LT	328
	329	/* special setup for KXLC005 card */
	330	if (is_kme)
2f1b9250	331	outb(0x81, ctl_base+1);
1da177e4	332
48c3c107 BZ	333	host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
48c3c107 BZ	334	if (host == NULL && link->io.NumPorts1 == 0x20) {
2f1b9250	335	outb(0x02, ctl_base + 0x10);
48c3c107	336	host = idecs_register(io_base + 0x10, ctl_base + 0x10,
d703b79e	337	link->irq.AssignedIRQ, link);
1da177e4 LT	338	}
1da177e4 LT	339
48c3c107	340	if (host == NULL)
1da177e4	341	goto failed;
1da177e4 LT	342
1da177e4 LT	343	info->ndev = 1;
48c3c107 BZ	344	sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
48c3c107 BZ	345	info->node.major = host->ports[0]->major;
1da177e4	346	info->node.minor = 0;
48c3c107	347	info->host = host;
fd238232	348	link->dev_node = &info->node;
70294b46 DB	349	printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
70294b46 DB	350	info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
1da177e4	351
1da177e4	352	kfree(stk);
15b99ac1	353	return 0;
1da177e4 LT	354
	355	err_mem:
	356	printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
	357	goto failed;
	358
	359	cs_failed:
fba395ee	360	cs_error(link, last_fn, last_ret);
1da177e4 LT	361	failed:
	362	kfree(stk);
	363	ide_release(link);
15b99ac1	364	return -ENODEV;
1da177e4 LT	365	} /* ide_config */
	366
	367	/*======================================================================
	368
	369	After a card is removed, ide_release() will unregister the net
	370	device, and release the PCMCIA configuration. If the device is
	371	still open, this will be postponed until it is closed.
7b1dec59	372
1da177e4 LT	373	======================================================================*/
1da177e4 LT	374
727c6742	375	static void ide_release(struct pcmcia_device *link)
1da177e4 LT	376	{
1da177e4 LT	377	ide_info_t *info = link->priv;
48c3c107	378	struct ide_host *host = info->host;
7b1dec59	379
1da177e4 LT	380	DEBUG(0, "ide_release(0x%p)\n", link);
1da177e4 LT	381
48c3c107	382	if (info->ndev)
1da177e4 LT	383	/* FIXME: if this fails we need to queue the cleanup somehow
1da177e4 LT	384	-- need to investigate the required PCMCIA magic */
48c3c107 BZ	385	ide_host_remove(host);
48c3c107 BZ	386
1da177e4	387	info->ndev = 0;
1da177e4	388
fba395ee	389	pcmcia_disable_device(link);
1da177e4 LT	390	} /* ide_release */
1da177e4 LT	391
98e4c28b	392
1da177e4 LT	393	/*======================================================================
	394
	395	The card status event handler. Mostly, this schedules other
	396	stuff to run after an event is received. A CARD_REMOVAL event
	397	also sets some flags to discourage the ide drivers from
	398	talking to the ports.
7b1dec59	399
1da177e4 LT	400	======================================================================*/
1da177e4 LT	401
f70b7d40 DB	402	static struct pcmcia_device_id ide_ids[] = {
f70b7d40 DB	403	PCMCIA_DEVICE_FUNC_ID(4),
7b1dec59	404	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */
725a6abf	405	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
ed896167 MD	406	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */
ed896167 MD	407	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */
f70b7d40	408	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
ed896167	409	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */
a49c06bf	410	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000), /* Kingston */
d3feb184	411	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */
f70b7d40	412	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
d3feb184	413	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */
7b1dec59	414	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */
f70b7d40	415	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
ed896167 MD	416	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100), /* Viking CFA */
ed896167 MD	417	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar, Viking CFA */
f70b7d40 DB	418	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	419	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	420	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	421	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	422	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
	423	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	424	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	425	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
d277ad0e	426	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
f70b7d40 DB	427	PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	428	PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	429	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
725a6abf RP	430	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
725a6abf RP	431	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
7b1dec59	432	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
264a3412	433	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
f70b7d40	434	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
363f7e42	435	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
f70b7d40 DB	436	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b),
	437	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	438	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	439	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b),
74e23386	440	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
4fa902a9	441	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
2570b746	442	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
f70b7d40 DB	443	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	444	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	445	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
4fa902a9 MJ	446	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	447	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	448	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
f70b7d40	449	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
42935656	450	PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443),
a17bf220	451	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
bf4e1829	452	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
aa12b284	453	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
4fa902a9	454	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
f70b7d40	455	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
0517793f	456	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
f70b7d40	457	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
d3feb184	458	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
698e22c4	459	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
f70b7d40 DB	460	PCMCIA_DEVICE_NULL,
	461	};
	462	MODULE_DEVICE_TABLE(pcmcia, ide_ids);
	463
1da177e4 LT	464	static struct pcmcia_driver ide_cs_driver = {
	465	.owner = THIS_MODULE,
	466	.drv = {
	467	.name = "ide-cs",
	468	},
15b99ac1	469	.probe = ide_probe,
cc3b4866	470	.remove = ide_detach,
f70b7d40	471	.id_table = ide_ids,
1da177e4 LT	472	};
	473
	474	static int __init init_ide_cs(void)
	475	{
	476	return pcmcia_register_driver(&ide_cs_driver);
	477	}
	478
	479	static void __exit exit_ide_cs(void)
	480	{
	481	pcmcia_unregister_driver(&ide_cs_driver);
1da177e4 LT	482	}
1da177e4 LT	483
2b8d4669	484	late_initcall(init_ide_cs);
1da177e4	485	module_exit(exit_ide_cs);