[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/major.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/system.h>

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

#define DRV_NAME "ide-cs"

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

/* Module parameters */

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

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

#ifdef CONFIG_PCMCIA_DEBUG
INT_MODULE_PARM(pc_debug, 0);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
#else
#define DEBUG(n, args...)
#endif

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

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;

    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->host->ports[0];
    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 const struct ide_port_info idecs_port_info = {
	.port_ops		= &idecs_port_ops,
	.host_flags		= IDE_HFLAG_NO_DMA,
};

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;
    hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };

    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;

    rc = ide_host_add(&idecs_port_info, hws, &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.

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

#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;
    struct ide_host *host;

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

     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;

cs_failed:
    cs_error(link, last_fn, last_ret);
failed:
    kfree(stk);
    ide_release(link);
    return -ENODEV;
} /* ide_config */

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

    After a card is removed, ide_release() will unregister the net
    device, and release the PCMCIA configuration.  If the device is
    still open, this will be postponed until it is closed.

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

static void ide_release(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    struct ide_host *host = info->host;

    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_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(0x0045, 0x0401),	/* SanDisk CFA */
	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),	/* Kingston */
	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),	/* Toshiba */
	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),	/* Samsung */
	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),	/* Hitachi */
	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),	/* Viking CFA */
	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),	/* Lexar, Viking CFA */
	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, ide_ids);

static struct pcmcia_driver ide_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "ide-cs",
	},
	.probe		= ide_probe,
	.remove		= ide_detach,
	.id_table       = ide_ids,
};

static int __init init_ide_cs(void)
{
	return pcmcia_register_driver(&ide_cs_driver);
}

static void __exit exit_ide_cs(void)
{
	pcmcia_unregister_driver(&ide_cs_driver);
}

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