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

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

    A driver for PCMCIA IDE/ATA disk cards

    The contents of this file are subject to the Mozilla Public
    License Version 1.1 (the "License"); you may not use this file
    except in compliance with the License. You may obtain a copy of
    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS
    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    implied. See the License for the specific language governing
    rights and limitations under the License.

    The initial developer of the original code is David A. Hinds
    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.

    Alternatively, the contents of this file may be used under the
    terms of the GNU General Public License version 2 (the "GPL"), in
    which case the provisions of the GPL are applicable instead of the
    above.  If you wish to allow the use of your version of this file
    only under the terms of the GPL and not to allow others to use
    your version of this file under the MPL, indicate your decision
    by deleting the provisions above and replace them with the notice
    and other provisions required by the GPL.  If you do not delete
    the provisions above, a recipient may use your version of this
    file under either the MPL or the GPL.

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

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/ide.h>
#include <linux/hdreg.h>
#include <linux/major.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/system.h>

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

#define DRV_NAME "ide-cs"

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

/* Module parameters */

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

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

#ifdef PCMCIA_DEBUG
INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
#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_data(hwif, i);
    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.

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

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(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", "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", "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
	66	#ifdef PCMCIA_DEBUG
	67	INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
	68	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	69	static char *version =
	70	"ide-cs.c 1.3 2002/10/26 05:45:31 (David Hinds)";
	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
bf64b7a9	190	ide_init_port_data(hwif, i);
9e016a71	191	ide_init_port_hw(hwif, &hw);
ac95beed	192	hwif->port_ops = &idecs_port_ops;
9e016a71 BZ	193
	194	idx[0] = i;
	195
	196	ide_device_add(idx, NULL);
	197
d703b79e BZ	198	if (hwif->present)
	199	return hwif;
	200
792a1a98 BZ	201	/* retry registration in case device is still spinning up */
	202	for (i = 0; i < 10; i++) {
	203	msleep(100);
	204	ide_port_scan(hwif);
	205	if (hwif->present)
	206	return hwif;
	207	}
	208
	209	return hwif;
	210
d703b79e BZ	211	out_release:
	212	release_region(ctl, 1);
	213	release_region(io, 8);
	214	return NULL;
1da177e4 LT	215	}
	216
	217	/*======================================================================
	218
	219	ide_config() is scheduled to run after a CARD_INSERTION event
	220	is received, to configure the PCMCIA socket, and to make the
	221	ide device available to the system.
	222
	223	======================================================================*/
	224
	225	#define CS_CHECK(fn, ret) \
	226	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	227
15b99ac1	228	static int ide_config(struct pcmcia_device *link)
1da177e4	229	{
1da177e4 LT	230	ide_info_t *info = link->priv;
	231	tuple_t tuple;
	232	struct {
	233	u_short buf[128];
	234	cisparse_t parse;
	235	config_info_t conf;
	236	cistpl_cftable_entry_t dflt;
	237	} *stk = NULL;
	238	cistpl_cftable_entry_t *cfg;
792a1a98	239	int pass, last_ret = 0, last_fn = 0, is_kme = 0;
2f1b9250	240	unsigned long io_base, ctl_base;
d703b79e	241	ide_hwif_t *hwif;
1da177e4 LT	242
	243	DEBUG(0, "ide_config(0x%p)\n", link);
	244
f5e3c2fa	245	stk = kzalloc(sizeof(*stk), GFP_KERNEL);
1da177e4	246	if (!stk) goto err_mem;
1da177e4 LT	247	cfg = &stk->parse.cftable_entry;
	248
	249	tuple.TupleData = (cisdata_t *)&stk->buf;
	250	tuple.TupleOffset = 0;
	251	tuple.TupleDataMax = 255;
	252	tuple.Attributes = 0;
1da177e4	253
efd50585 DB	254	is_kme = ((link->manf_id == MANFID_KME) &&
	255	((link->card_id == PRODID_KME_KXLC005_A) \|\|
	256	(link->card_id == PRODID_KME_KXLC005_B)));
1da177e4	257
1da177e4	258	/* Not sure if this is right... look up the current Vcc */
fba395ee	259	CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
1da177e4	260
2f1b9250	261	pass = io_base = ctl_base = 0;
1da177e4 LT	262	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
1da177e4 LT	263	tuple.Attributes = 0;
fba395ee	264	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1da177e4	265	while (1) {
fba395ee DB	266	if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
fba395ee DB	267	if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;
1da177e4 LT	268
	269	/* Check for matching Vcc, unless we're desperate */
	270	if (!pass) {
	271	if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
	272	if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
	273	goto next_entry;
	274	} else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
	275	if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
	276	goto next_entry;
	277	}
	278	}
	279
	280	if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	281	link->conf.Vpp =
1da177e4 LT	282	cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	283	else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	284	link->conf.Vpp =
1da177e4 LT	285	stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
	286
	287	if ((cfg->io.nwin > 0) \|\| (stk->dflt.io.nwin > 0)) {
	288	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
	289	link->conf.ConfigIndex = cfg->index;
	290	link->io.BasePort1 = io->win[0].base;
	291	link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	292	if (!(io->flags & CISTPL_IO_16BIT))
	293	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	294	if (io->nwin == 2) {
	295	link->io.NumPorts1 = 8;
	296	link->io.BasePort2 = io->win[1].base;
	297	link->io.NumPorts2 = (is_kme) ? 2 : 1;
fba395ee	298	if (pcmcia_request_io(link, &link->io) != 0)
1da177e4 LT	299	goto next_entry;
	300	io_base = link->io.BasePort1;
	301	ctl_base = link->io.BasePort2;
	302	} else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
	303	link->io.NumPorts1 = io->win[0].len;
	304	link->io.NumPorts2 = 0;
fba395ee	305	if (pcmcia_request_io(link, &link->io) != 0)
1da177e4 LT	306	goto next_entry;
	307	io_base = link->io.BasePort1;
	308	ctl_base = link->io.BasePort1 + 0x0e;
	309	} else goto next_entry;
	310	/* If we've got this far, we're done */
	311	break;
	312	}
	313
	314	next_entry:
	315	if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
	316	memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
	317	if (pass) {
fba395ee DB	318	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
	319	} else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
	320	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1da177e4 LT	321	memset(&stk->dflt, 0, sizeof(stk->dflt));
	322	pass++;
	323	}
	324	}
	325
fba395ee DB	326	CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
fba395ee DB	327	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1da177e4 LT	328
1da177e4 LT	329	/* disable drive interrupts during IDE probe */
2f1b9250	330	outb(0x02, ctl_base);
1da177e4 LT	331
	332	/* special setup for KXLC005 card */
	333	if (is_kme)
2f1b9250	334	outb(0x81, ctl_base+1);
1da177e4	335
792a1a98 BZ	336	hwif = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
792a1a98 BZ	337	if (hwif == NULL && link->io.NumPorts1 == 0x20) {
2f1b9250	338	outb(0x02, ctl_base + 0x10);
d703b79e BZ	339	hwif = idecs_register(io_base + 0x10, ctl_base + 0x10,
d703b79e BZ	340	link->irq.AssignedIRQ, link);
1da177e4 LT	341	}
1da177e4 LT	342
792a1a98	343	if (hwif == NULL)
1da177e4	344	goto failed;
1da177e4 LT	345
1da177e4 LT	346	info->ndev = 1;
d703b79e BZ	347	sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
d703b79e BZ	348	info->node.major = hwif->major;
1da177e4	349	info->node.minor = 0;
d703b79e	350	info->hwif = hwif;
fd238232	351	link->dev_node = &info->node;
70294b46 DB	352	printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
70294b46 DB	353	info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
1da177e4	354
1da177e4	355	kfree(stk);
15b99ac1	356	return 0;
1da177e4 LT	357
	358	err_mem:
	359	printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
	360	goto failed;
	361
	362	cs_failed:
fba395ee	363	cs_error(link, last_fn, last_ret);
1da177e4 LT	364	failed:
	365	kfree(stk);
	366	ide_release(link);
15b99ac1	367	return -ENODEV;
1da177e4 LT	368	} /* ide_config */
	369
	370	/*======================================================================
	371
	372	After a card is removed, ide_release() will unregister the net
	373	device, and release the PCMCIA configuration. If the device is
	374	still open, this will be postponed until it is closed.
7b1dec59	375
1da177e4 LT	376	======================================================================*/
1da177e4 LT	377
fba395ee	378	void ide_release(struct pcmcia_device *link)
1da177e4 LT	379	{
1da177e4 LT	380	ide_info_t *info = link->priv;
d703b79e	381	ide_hwif_t *hwif = info->hwif;
7b1dec59	382
1da177e4 LT	383	DEBUG(0, "ide_release(0x%p)\n", link);
	384
	385	if (info->ndev) {
	386	/* FIXME: if this fails we need to queue the cleanup somehow
	387	-- need to investigate the required PCMCIA magic */
387750c3	388	ide_unregister(hwif);
1da177e4 LT	389	}
1da177e4 LT	390	info->ndev = 0;
1da177e4	391
fba395ee	392	pcmcia_disable_device(link);
1da177e4 LT	393	} /* ide_release */
1da177e4 LT	394
98e4c28b	395
1da177e4 LT	396	/*======================================================================
	397
	398	The card status event handler. Mostly, this schedules other
	399	stuff to run after an event is received. A CARD_REMOVAL event
	400	also sets some flags to discourage the ide drivers from
	401	talking to the ports.
7b1dec59	402
1da177e4 LT	403	======================================================================*/
1da177e4 LT	404
f70b7d40 DB	405	static struct pcmcia_device_id ide_ids[] = {
f70b7d40 DB	406	PCMCIA_DEVICE_FUNC_ID(4),
7b1dec59	407	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */
725a6abf	408	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
ed896167 MD	409	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */
ed896167 MD	410	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */
f70b7d40	411	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
ed896167	412	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */
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),
4fa902a9	442	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
2570b746	443	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
f70b7d40 DB	444	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	445	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	446	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
4fa902a9 MJ	447	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	448	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	449	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
f70b7d40	450	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
42935656	451	PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443),
bf4e1829	452	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
aa12b284	453	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
4fa902a9	454	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
f70b7d40	455	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
0517793f	456	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
f70b7d40	457	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
d3feb184	458	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
698e22c4	459	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
f70b7d40 DB	460	PCMCIA_DEVICE_NULL,
	461	};
	462	MODULE_DEVICE_TABLE(pcmcia, ide_ids);
	463
1da177e4 LT	464	static struct pcmcia_driver ide_cs_driver = {
	465	.owner = THIS_MODULE,
	466	.drv = {
	467	.name = "ide-cs",
	468	},
15b99ac1	469	.probe = ide_probe,
cc3b4866	470	.remove = ide_detach,
f70b7d40	471	.id_table = ide_ids,
1da177e4 LT	472	};
	473
	474	static int __init init_ide_cs(void)
	475	{
	476	return pcmcia_register_driver(&ide_cs_driver);
	477	}
	478
	479	static void __exit exit_ide_cs(void)
	480	{
	481	pcmcia_unregister_driver(&ide_cs_driver);
1da177e4 LT	482	}
1da177e4 LT	483
2b8d4669	484	late_initcall(init_ide_cs);
1da177e4	485	module_exit(exit_ide_cs);