[mirror_ubuntu-zesty-kernel.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)
/*static char *version =
"ide-cs.c 1.3 2002/10/26 05:45:31 (David Hinds)";*/
#else
#define DEBUG(n, args...)
#endif

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

typedef struct ide_info_t {
	struct pcmcia_device	*p_dev;
	ide_hwif_t		*hwif;
    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->hwif;
    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 ide_hwif_t *idecs_register(unsigned long io, unsigned long ctl,
				unsigned long irq, struct pcmcia_device *handle)
{
    ide_hwif_t *hwif;
    hw_regs_t hw;
    int i;
    u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };

    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;

    hwif = ide_find_port();
    if (hwif == NULL)
	goto out_release;

    i = hwif->index;

    ide_init_port_hw(hwif, &hw);
    hwif->port_ops = &idecs_port_ops;

    idx[0] = i;

    ide_device_add(idx, NULL);

    if (hwif->present)
	return hwif;

    /* 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 hwif;
    }

    return hwif;

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;
    ide_hwif_t *hwif;

    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);

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

    if (hwif == NULL)
	goto failed;

    info->ndev = 1;
    sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
    info->node.major = hwif->major;
    info->node.minor = 0;
    info->hwif = hwif;
    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;
    ide_hwif_t *hwif = info->hwif;

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