[deliverable/linux.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;

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

    ide_release(link);

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