[linux.git] / drivers / ide / 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
    <[email protected]>.  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/major.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/system.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 <[email protected]>");
MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
MODULE_LICENSE("Dual MPL/GPL");

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

typedef struct ide_info_t {
	struct pcmcia_device	*p_dev;
	struct ide_host		*host;
	int			ndev;
} 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;

    dev_dbg(&link->dev, "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->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO |
	    CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC;

    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;

    dev_dbg(&link->dev, "ide_detach(0x%p)\n", link);

    ide_release(link);

    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,
	.irq_flags		= IRQF_SHARED,
	.chipset		= ide_pci,
};

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, rc;
    struct ide_hw hw, *hws[] = { &hw };

    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.dev = &handle->dev;

    rc = ide_host_add(&idecs_port_info, hws, 1, &host);
    if (rc)
	goto out_release;

    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.

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

static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data)
{
	int *is_kme = priv_data;

	if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
		pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
		pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
	}
	pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
	pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;

	if (pdev->resource[1]->end) {
		pdev->resource[0]->end = 8;
		pdev->resource[1]->end = (*is_kme) ? 2 : 1;
	} else {
		if (pdev->resource[0]->end < 16)
			return -ENODEV;
	}

	return pcmcia_request_io(pdev);
}

static int ide_config(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    int ret = 0, is_kme = 0;
    unsigned long io_base, ctl_base;
    struct ide_host *host;

    dev_dbg(&link->dev, "ide_config(0x%p)\n", link);

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

    if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme)) {
	    link->config_flags &= ~CONF_AUTO_CHECK_VCC;
	    if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme))
		    goto failed; /* No suitable config found */
    }
    io_base = link->resource[0]->start;
    if (link->resource[1]->end)
	    ctl_base = link->resource[1]->start;
    else
	    ctl_base = link->resource[0]->start + 0x0e;

    if (!link->irq)
	    goto failed;

    ret = pcmcia_enable_device(link);
    if (ret)
	    goto failed;

    /* 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, link);
     if (host == NULL && resource_size(link->resource[0]) == 0x20) {
	    outb(0x02, ctl_base + 0x10);
	    host = idecs_register(io_base + 0x10, ctl_base + 0x10,
				  link->irq, link);
    }

    if (host == NULL)
	goto failed;

    info->ndev = 1;
    info->host = host;
    dev_info(&link->dev, "ide-cs: hd%c: Vpp = %d.%d\n",
	    'a' + host->ports[0]->index * 2,
	    link->vpp / 10, link->vpp % 10);

    return 0;

failed:
    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;

    dev_dbg(&link->dev, "ide_release(0x%p)\n", link);

    if (info->ndev) {
	ide_hwif_t *hwif = host->ports[0];
	unsigned long data_addr, ctl_addr;

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

	ide_host_remove(host);
	info->ndev = 0;

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

    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(0x0032, 0x2904),
	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),	/* SanDisk CFA */
	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),	/* Kingston */
	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), 	/* TI emulated */
	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-ROM", 0x46d7db81, 0x66536591),
	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", "CF CARD 1GB", 0x2e6d1829, 0x55d5bffb),
	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 4GB", 0x2e6d1829, 0x531e7d10),
	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("TRANSCEND", "TS4GCF133", 0x709b1bf1, 0x7558f133),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS8GCF133", 0x709b1bf1, 0xb2f89b47),
	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_PROD_ID2("Flash Card", 0x5a362506),
	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	<[email protected]>. 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>
1da177e4	41	#include <linux/major.h>
2aad5f03	42	#include <linux/delay.h>
1da177e4 LT	43	#include <asm/io.h>
	44	#include <asm/system.h>
	45
1da177e4 LT	46	#include <pcmcia/cistpl.h>
	47	#include <pcmcia/ds.h>
	48	#include <pcmcia/cisreg.h>
	49	#include <pcmcia/ciscode.h>
	50
d703b79e BZ	51	#define DRV_NAME "ide-cs"
d703b79e BZ	52
1da177e4 LT	53	/====================================================================/
	54
	55	/* Module parameters */
	56
	57	MODULE_AUTHOR("David Hinds <[email protected]>");
	58	MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
	59	MODULE_LICENSE("Dual MPL/GPL");
	60
1da177e4 LT	61	/====================================================================/
1da177e4 LT	62
1da177e4	63	typedef struct ide_info_t {
fd238232	64	struct pcmcia_device *p_dev;
48c3c107	65	struct ide_host *host;
ded6a1a3	66	int ndev;
1da177e4 LT	67	} ide_info_t;
1da177e4 LT	68
fba395ee	69	static void ide_release(struct pcmcia_device *);
15b99ac1	70	static int ide_config(struct pcmcia_device *);
1da177e4	71
cc3b4866	72	static void ide_detach(struct pcmcia_device *p_dev);
1da177e4	73
b4635811 DB	74
b4635811 DB	75
1da177e4 LT	76
	77	/*======================================================================
	78
	79	ide_attach() creates an "instance" of the driver, allocating
	80	local data structures for one device. The device is registered
	81	with Card Services.
	82
	83	======================================================================*/
	84
15b99ac1	85	static int ide_probe(struct pcmcia_device *link)
1da177e4 LT	86	{
1da177e4 LT	87	ide_info_t *info;
f8cfa618	88
444486a5	89	dev_dbg(&link->dev, "ide_attach()\n");
1da177e4 LT	90
1da177e4 LT	91	/* Create new ide device */
f5e3c2fa	92	info = kzalloc(sizeof(*info), GFP_KERNEL);
f8cfa618 DB	93	if (!info)
f8cfa618 DB	94	return -ENOMEM;
fd238232	95
fba395ee	96	info->p_dev = link;
fd238232	97	link->priv = info;
1da177e4	98
00990e7c DB	99	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_IO \|
00990e7c DB	100	CONF_AUTO_SET_VPP \| CONF_AUTO_CHECK_VCC;
f8cfa618	101
15b99ac1	102	return ide_config(link);
1da177e4 LT	103	} /* ide_attach */
	104
	105	/*======================================================================
	106
	107	This deletes a driver "instance". The device is de-registered
	108	with Card Services. If it has been released, all local data
	109	structures are freed. Otherwise, the structures will be freed
	110	when the device is released.
	111
	112	======================================================================*/
	113
fba395ee	114	static void ide_detach(struct pcmcia_device *link)
1da177e4	115	{
d703b79e	116	ide_info_t *info = link->priv;
d703b79e	117
444486a5	118	dev_dbg(&link->dev, "ide_detach(0x%p)\n", link);
1da177e4	119
e2d40963	120	ide_release(link);
b4635811	121
d703b79e	122	kfree(info);
1da177e4 LT	123	} /* ide_detach */
1da177e4 LT	124
ac95beed BZ	125	static const struct ide_port_ops idecs_port_ops = {
	126	.quirkproc = ide_undecoded_slave,
	127	};
	128
dccdf527 BZ	129	static const struct ide_port_info idecs_port_info = {
	130	.port_ops = &idecs_port_ops,
	131	.host_flags = IDE_HFLAG_NO_DMA,
255115fb	132	.irq_flags = IRQF_SHARED,
29e52cf7	133	.chipset = ide_pci,
dccdf527 BZ	134	};
dccdf527 BZ	135
48c3c107	136	static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
d703b79e	137	unsigned long irq, struct pcmcia_device *handle)
1da177e4	138	{
48c3c107	139	struct ide_host *host;
9e016a71	140	ide_hwif_t *hwif;
6f904d01	141	int i, rc;
9f36d314	142	struct ide_hw hw, *hws[] = { &hw };
9e016a71	143
d703b79e BZ	144	if (!request_region(io, 8, DRV_NAME)) {
	145	printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
	146	DRV_NAME, io, io + 7);
	147	return NULL;
	148	}
	149
	150	if (!request_region(ctl, 1, DRV_NAME)) {
	151	printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
	152	DRV_NAME, ctl);
	153	release_region(io, 8);
	154	return NULL;
	155	}
	156
1da177e4	157	memset(&hw, 0, sizeof(hw));
dcb425f5	158	ide_std_init_ports(&hw, io, ctl);
1da177e4	159	hw.irq = irq;
4349d5cd	160	hw.dev = &handle->dev;
9e016a71	161
dca39830	162	rc = ide_host_add(&idecs_port_info, hws, 1, &host);
6f904d01	163	if (rc)
d703b79e	164	goto out_release;
9e016a71	165
48c3c107	166	hwif = host->ports[0];
9e016a71	167
d703b79e	168	if (hwif->present)
48c3c107	169	return host;
d703b79e	170
792a1a98 BZ	171	/* retry registration in case device is still spinning up */
	172	for (i = 0; i < 10; i++) {
	173	msleep(100);
	174	ide_port_scan(hwif);
	175	if (hwif->present)
48c3c107	176	return host;
792a1a98 BZ	177	}
792a1a98 BZ	178
48c3c107	179	return host;
792a1a98	180
d703b79e BZ	181	out_release:
	182	release_region(ctl, 1);
	183	release_region(io, 8);
	184	return NULL;
1da177e4 LT	185	}
	186
	187	/*======================================================================
	188
	189	ide_config() is scheduled to run after a CARD_INSERTION event
	190	is received, to configure the PCMCIA socket, and to make the
	191	ide device available to the system.
	192
	193	======================================================================*/
	194
00990e7c	195	static int pcmcia_check_one_config(struct pcmcia_device pdev, void priv_data)
0bac660a	196	{
00990e7c DB	197	int *is_kme = priv_data;
	198
	199	if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
	200	pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	201	pdev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_AUTO;
	202	}
	203	pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
	204	pdev->resource[1]->flags \|= IO_DATA_PATH_WIDTH_8;
	205
	206	if (pdev->resource[1]->end) {
	207	pdev->resource[0]->end = 8;
	208	pdev->resource[1]->end = (*is_kme) ? 2 : 1;
	209	} else {
	210	if (pdev->resource[0]->end < 16)
8e2fc39d	211	return -ENODEV;
0bac660a	212	}
00990e7c DB	213
00990e7c DB	214	return pcmcia_request_io(pdev);
0bac660a DB	215	}
0bac660a DB	216
15b99ac1	217	static int ide_config(struct pcmcia_device *link)
1da177e4	218	{
1da177e4	219	ide_info_t *info = link->priv;
444486a5	220	int ret = 0, is_kme = 0;
2f1b9250	221	unsigned long io_base, ctl_base;
48c3c107	222	struct ide_host *host;
1da177e4	223
444486a5	224	dev_dbg(&link->dev, "ide_config(0x%p)\n", link);
1da177e4	225
efd50585 DB	226	is_kme = ((link->manf_id == MANFID_KME) &&
	227	((link->card_id == PRODID_KME_KXLC005_A) \|\|
	228	(link->card_id == PRODID_KME_KXLC005_B)));
1da177e4	229
00990e7c	230	if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme)) {
440eed43	231	link->config_flags &= ~CONF_AUTO_CHECK_VCC;
00990e7c	232	if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme))
0bac660a	233	goto failed; /* No suitable config found */
1da177e4	234	}
9a017a91	235	io_base = link->resource[0]->start;
00990e7c DB	236	if (link->resource[1]->end)
	237	ctl_base = link->resource[1]->start;
	238	else
	239	ctl_base = link->resource[0]->start + 0x0e;
1da177e4	240
eb14120f	241	if (!link->irq)
444486a5	242	goto failed;
1ac71e5a DB	243
1ac71e5a DB	244	ret = pcmcia_enable_device(link);
444486a5 DB	245	if (ret)
444486a5 DB	246	goto failed;
1da177e4 LT	247
1da177e4 LT	248	/* disable drive interrupts during IDE probe */
2f1b9250	249	outb(0x02, ctl_base);
1da177e4 LT	250
	251	/* special setup for KXLC005 card */
	252	if (is_kme)
2f1b9250	253	outb(0x81, ctl_base+1);
1da177e4	254
eb14120f	255	host = idecs_register(io_base, ctl_base, link->irq, link);
9a017a91	256	if (host == NULL && resource_size(link->resource[0]) == 0x20) {
2f1b9250	257	outb(0x02, ctl_base + 0x10);
48c3c107	258	host = idecs_register(io_base + 0x10, ctl_base + 0x10,
eb14120f	259	link->irq, link);
1da177e4 LT	260	}
1da177e4 LT	261
48c3c107	262	if (host == NULL)
1da177e4	263	goto failed;
1da177e4 LT	264
1da177e4 LT	265	info->ndev = 1;
48c3c107	266	info->host = host;
ded6a1a3 DB	267	dev_info(&link->dev, "ide-cs: hd%c: Vpp = %d.%d\n",
ded6a1a3 DB	268	'a' + host->ports[0]->index * 2,
e8405f0f	269	link->vpp / 10, link->vpp % 10);
1da177e4	270
15b99ac1	271	return 0;
1da177e4	272
1da177e4	273	failed:
1da177e4	274	ide_release(link);
15b99ac1	275	return -ENODEV;
1da177e4 LT	276	} /* ide_config */
	277
	278	/*======================================================================
	279
	280	After a card is removed, ide_release() will unregister the net
	281	device, and release the PCMCIA configuration. If the device is
	282	still open, this will be postponed until it is closed.
7b1dec59	283
1da177e4 LT	284	======================================================================*/
1da177e4 LT	285
727c6742	286	static void ide_release(struct pcmcia_device *link)
1da177e4 LT	287	{
1da177e4 LT	288	ide_info_t *info = link->priv;
48c3c107	289	struct ide_host *host = info->host;
7b1dec59	290
444486a5	291	dev_dbg(&link->dev, "ide_release(0x%p)\n", link);
1da177e4	292
d4ae5415 WS	293	if (info->ndev) {
	294	ide_hwif_t *hwif = host->ports[0];
	295	unsigned long data_addr, ctl_addr;
	296
	297	data_addr = hwif->io_ports.data_addr;
	298	ctl_addr = hwif->io_ports.ctl_addr;
	299
48c3c107	300	ide_host_remove(host);
d4ae5415	301	info->ndev = 0;
48c3c107	302
d4ae5415 WS	303	release_region(ctl_addr, 1);
	304	release_region(data_addr, 8);
	305	}
1da177e4	306
fba395ee	307	pcmcia_disable_device(link);
1da177e4 LT	308	} /* ide_release */
1da177e4 LT	309
98e4c28b	310
1da177e4 LT	311	/*======================================================================
	312
	313	The card status event handler. Mostly, this schedules other
	314	stuff to run after an event is received. A CARD_REMOVAL event
	315	also sets some flags to discourage the ide drivers from
	316	talking to the ports.
7b1dec59	317
1da177e4 LT	318	======================================================================*/
1da177e4 LT	319
f70b7d40 DB	320	static struct pcmcia_device_id ide_ids[] = {
f70b7d40 DB	321	PCMCIA_DEVICE_FUNC_ID(4),
7b1dec59	322	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */
725a6abf	323	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
ed896167 MD	324	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */
ed896167 MD	325	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */
f70b7d40	326	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
795659ef	327	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
ed896167	328	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */
a49c06bf	329	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000), /* Kingston */
795659ef	330	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), /* TI emulated */
d3feb184	331	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */
f70b7d40	332	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
d3feb184	333	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */
7b1dec59	334	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */
f70b7d40	335	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
ed896167 MD	336	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100), /* Viking CFA */
ed896167 MD	337	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar, Viking CFA */
f70b7d40 DB	338	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	339	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	340	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	341	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	342	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
c9a2bfd1	343	PCMCIA_DEVICE_PROD_ID12("CNF ", "CD-ROM", 0x46d7db81, 0x66536591),
f70b7d40 DB	344	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	345	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	346	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
d277ad0e	347	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
f70b7d40 DB	348	PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	349	PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	350	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
725a6abf RP	351	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
725a6abf RP	352	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
7b1dec59	353	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
264a3412	354	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
f70b7d40	355	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
85ea2d3f	356	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 1GB", 0x2e6d1829, 0x55d5bffb),
f25798ed	357	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 4GB", 0x2e6d1829, 0x531e7d10),
363f7e42	358	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
f70b7d40 DB	359	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b),
	360	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	361	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	362	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b),
74e23386	363	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
4fa902a9	364	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
2570b746	365	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
f70b7d40 DB	366	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	367	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	368	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
4fa902a9 MJ	369	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	370	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	371	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
f70b7d40	372	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
42935656	373	PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443),
a17bf220	374	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
bf4e1829	375	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
aa12b284	376	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
4fa902a9	377	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
85ea2d3f	378	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF133", 0x709b1bf1, 0x7558f133),
f25798ed	379	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS8GCF133", 0x709b1bf1, 0xb2f89b47),
f70b7d40	380	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
0517793f	381	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
f70b7d40	382	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
d3feb184	383	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
698e22c4	384	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
980fc29f	385	PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506),
f70b7d40 DB	386	PCMCIA_DEVICE_NULL,
	387	};
	388	MODULE_DEVICE_TABLE(pcmcia, ide_ids);
	389
1da177e4 LT	390	static struct pcmcia_driver ide_cs_driver = {
	391	.owner = THIS_MODULE,
	392	.drv = {
	393	.name = "ide-cs",
	394	},
15b99ac1	395	.probe = ide_probe,
cc3b4866	396	.remove = ide_detach,
f70b7d40	397	.id_table = ide_ids,
1da177e4 LT	398	};
	399
	400	static int __init init_ide_cs(void)
	401	{
	402	return pcmcia_register_driver(&ide_cs_driver);
	403	}
	404
	405	static void __exit exit_ide_cs(void)
	406	{
	407	pcmcia_unregister_driver(&ide_cs_driver);
1da177e4 LT	408	}
1da177e4 LT	409
2b8d4669	410	late_initcall(init_ide_cs);
1da177e4	411	module_exit(exit_ide_cs);