[linux-2.6-block.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
    <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/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");

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

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;

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

    dev_dbg(&link->dev, "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,
	.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.

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

struct pcmcia_config_check {
	unsigned long ctl_base;
	int skip_vcc;
	int is_kme;
};

static int pcmcia_check_one_config(struct pcmcia_device *pdev,
				   cistpl_cftable_entry_t *cfg,
				   cistpl_cftable_entry_t *dflt,
				   unsigned int vcc,
				   void *priv_data)
{
	struct pcmcia_config_check *stk = priv_data;

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

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

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

static int ide_config(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    struct pcmcia_config_check *stk = NULL;
    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)));

    stk = kzalloc(sizeof(*stk), GFP_KERNEL);
    if (!stk)
	    goto err_mem;
    stk->is_kme = is_kme;
    stk->skip_vcc = io_base = ctl_base = 0;

    if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
	    stk->skip_vcc = 1;
	    if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
		    goto failed; /* No suitable config found */
    }
    io_base = link->io.BasePort1;
    ctl_base = stk->ctl_base;

    ret = pcmcia_request_irq(link, &link->irq);
    if (ret)
	    goto failed;
    ret = pcmcia_request_configuration(link, &link->conf);
    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.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;

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;

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