[deliverable/linux.git] / drivers / ide / ide-cs.c

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

    A driver for PCMCIA IDE/ATA disk cards

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

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

    The initial developer of the original code is David A. Hinds
    <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)

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

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

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

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

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

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

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

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

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

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

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

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

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

late_initcall(init_ide_cs);
module_exit(exit_ide_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for PCMCIA IDE/ATA disk cards
	4
1da177e4 LT	5	The contents of this file are subject to the Mozilla Public
	6	License Version 1.1 (the "License"); you may not use this file
	7	except in compliance with the License. You may obtain a copy of
	8	the License at http://www.mozilla.org/MPL/
	9
	10	Software distributed under the License is distributed on an "AS
	11	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	12	implied. See the License for the specific language governing
	13	rights and limitations under the License.
	14
	15	The initial developer of the original code is David A. Hinds
	16	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	17	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	18
	19	Alternatively, the contents of this file may be used under the
	20	terms of the GNU General Public License version 2 (the "GPL"), in
	21	which case the provisions of the GPL are applicable instead of the
	22	above. If you wish to allow the use of your version of this file
	23	only under the terms of the GPL and not to allow others to use
	24	your version of this file under the MPL, indicate your decision
	25	by deleting the provisions above and replace them with the notice
	26	and other provisions required by the GPL. If you do not delete
	27	the provisions above, a recipient may use your version of this
	28	file under either the MPL or the GPL.
7b1dec59	29
1da177e4 LT	30	======================================================================*/
	31
	32	#include <linux/module.h>
	33	#include <linux/kernel.h>
	34	#include <linux/init.h>
1da177e4 LT	35	#include <linux/ptrace.h>
	36	#include <linux/slab.h>
	37	#include <linux/string.h>
	38	#include <linux/timer.h>
	39	#include <linux/ioport.h>
	40	#include <linux/ide.h>
1da177e4	41	#include <linux/major.h>
2aad5f03	42	#include <linux/delay.h>
1da177e4 LT	43	#include <asm/io.h>
	44	#include <asm/system.h>
	45
1da177e4 LT	46	#include <pcmcia/cs_types.h>
	47	#include <pcmcia/cs.h>
	48	#include <pcmcia/cistpl.h>
	49	#include <pcmcia/ds.h>
	50	#include <pcmcia/cisreg.h>
	51	#include <pcmcia/ciscode.h>
	52
d703b79e BZ	53	#define DRV_NAME "ide-cs"
d703b79e BZ	54
1da177e4 LT	55	/====================================================================/
	56
	57	/* Module parameters */
	58
	59	MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
	60	MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
	61	MODULE_LICENSE("Dual MPL/GPL");
	62
	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
0bac660a	222	struct pcmcia_config_check {
0bac660a DB	223	unsigned long ctl_base;
	224	int skip_vcc;
	225	int is_kme;
	226	};
	227
	228	static int pcmcia_check_one_config(struct pcmcia_device *pdev,
	229	cistpl_cftable_entry_t *cfg,
8e2fc39d	230	cistpl_cftable_entry_t *dflt,
ad913c11	231	unsigned int vcc,
0bac660a DB	232	void *priv_data)
	233	{
	234	struct pcmcia_config_check *stk = priv_data;
	235
	236	/* Check for matching Vcc, unless we're desperate */
	237	if (!stk->skip_vcc) {
	238	if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
ad913c11	239	if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
8e2fc39d DB	240	return -ENODEV;
8e2fc39d DB	241	} else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
ad913c11	242	if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
8e2fc39d	243	return -ENODEV;
0bac660a DB	244	}
	245	}
	246
	247	if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
	248	pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
8e2fc39d DB	249	else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
8e2fc39d DB	250	pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
0bac660a	251
8e2fc39d DB	252	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
8e2fc39d DB	253	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
0bac660a DB	254	pdev->conf.ConfigIndex = cfg->index;
	255	pdev->io.BasePort1 = io->win[0].base;
	256	pdev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	257	if (!(io->flags & CISTPL_IO_16BIT))
	258	pdev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	259	if (io->nwin == 2) {
	260	pdev->io.NumPorts1 = 8;
	261	pdev->io.BasePort2 = io->win[1].base;
	262	pdev->io.NumPorts2 = (stk->is_kme) ? 2 : 1;
	263	if (pcmcia_request_io(pdev, &pdev->io) != 0)
8e2fc39d	264	return -ENODEV;
0bac660a DB	265	stk->ctl_base = pdev->io.BasePort2;
	266	} else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
	267	pdev->io.NumPorts1 = io->win[0].len;
	268	pdev->io.NumPorts2 = 0;
	269	if (pcmcia_request_io(pdev, &pdev->io) != 0)
8e2fc39d	270	return -ENODEV;
0bac660a DB	271	stk->ctl_base = pdev->io.BasePort1 + 0x0e;
0bac660a DB	272	} else
8e2fc39d	273	return -ENODEV;
0bac660a DB	274	/* If we've got this far, we're done */
	275	return 0;
	276	}
0bac660a DB	277	return -ENODEV;
	278	}
	279
15b99ac1	280	static int ide_config(struct pcmcia_device *link)
1da177e4	281	{
1da177e4	282	ide_info_t *info = link->priv;
0bac660a DB	283	struct pcmcia_config_check *stk = NULL;
0bac660a DB	284	int last_ret = 0, last_fn = 0, is_kme = 0;
2f1b9250	285	unsigned long io_base, ctl_base;
48c3c107	286	struct ide_host *host;
1da177e4 LT	287
	288	DEBUG(0, "ide_config(0x%p)\n", link);
	289
efd50585 DB	290	is_kme = ((link->manf_id == MANFID_KME) &&
	291	((link->card_id == PRODID_KME_KXLC005_A) \|\|
	292	(link->card_id == PRODID_KME_KXLC005_B)));
1da177e4	293
0bac660a DB	294	stk = kzalloc(sizeof(*stk), GFP_KERNEL);
	295	if (!stk)
	296	goto err_mem;
	297	stk->is_kme = is_kme;
0bac660a	298	stk->skip_vcc = io_base = ctl_base = 0;
ad913c11	299
0bac660a	300	if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
0bac660a DB	301	stk->skip_vcc = 1;
	302	if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
	303	goto failed; /* No suitable config found */
1da177e4	304	}
0bac660a DB	305	io_base = link->io.BasePort1;
0bac660a DB	306	ctl_base = stk->ctl_base;
1da177e4	307
fba395ee DB	308	CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
fba395ee DB	309	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1da177e4 LT	310
1da177e4 LT	311	/* disable drive interrupts during IDE probe */
2f1b9250	312	outb(0x02, ctl_base);
1da177e4 LT	313
	314	/* special setup for KXLC005 card */
	315	if (is_kme)
2f1b9250	316	outb(0x81, ctl_base+1);
1da177e4	317
48c3c107 BZ	318	host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
48c3c107 BZ	319	if (host == NULL && link->io.NumPorts1 == 0x20) {
2f1b9250	320	outb(0x02, ctl_base + 0x10);
48c3c107	321	host = idecs_register(io_base + 0x10, ctl_base + 0x10,
d703b79e	322	link->irq.AssignedIRQ, link);
1da177e4 LT	323	}
1da177e4 LT	324
48c3c107	325	if (host == NULL)
1da177e4	326	goto failed;
1da177e4 LT	327
1da177e4 LT	328	info->ndev = 1;
48c3c107 BZ	329	sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
48c3c107 BZ	330	info->node.major = host->ports[0]->major;
1da177e4	331	info->node.minor = 0;
48c3c107	332	info->host = host;
fd238232	333	link->dev_node = &info->node;
70294b46 DB	334	printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
70294b46 DB	335	info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
1da177e4	336
1da177e4	337	kfree(stk);
15b99ac1	338	return 0;
1da177e4 LT	339
	340	err_mem:
	341	printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
	342	goto failed;
	343
	344	cs_failed:
fba395ee	345	cs_error(link, last_fn, last_ret);
1da177e4 LT	346	failed:
	347	kfree(stk);
	348	ide_release(link);
15b99ac1	349	return -ENODEV;
1da177e4 LT	350	} /* ide_config */
	351
	352	/*======================================================================
	353
	354	After a card is removed, ide_release() will unregister the net
	355	device, and release the PCMCIA configuration. If the device is
	356	still open, this will be postponed until it is closed.
7b1dec59	357
1da177e4 LT	358	======================================================================*/
1da177e4 LT	359
727c6742	360	static void ide_release(struct pcmcia_device *link)
1da177e4 LT	361	{
1da177e4 LT	362	ide_info_t *info = link->priv;
48c3c107	363	struct ide_host *host = info->host;
7b1dec59	364
1da177e4 LT	365	DEBUG(0, "ide_release(0x%p)\n", link);
1da177e4 LT	366
48c3c107	367	if (info->ndev)
1da177e4 LT	368	/* FIXME: if this fails we need to queue the cleanup somehow
1da177e4 LT	369	-- need to investigate the required PCMCIA magic */
48c3c107 BZ	370	ide_host_remove(host);
48c3c107 BZ	371
1da177e4	372	info->ndev = 0;
1da177e4	373
fba395ee	374	pcmcia_disable_device(link);
1da177e4 LT	375	} /* ide_release */
1da177e4 LT	376
98e4c28b	377
1da177e4 LT	378	/*======================================================================
	379
	380	The card status event handler. Mostly, this schedules other
	381	stuff to run after an event is received. A CARD_REMOVAL event
	382	also sets some flags to discourage the ide drivers from
	383	talking to the ports.
7b1dec59	384
1da177e4 LT	385	======================================================================*/
1da177e4 LT	386
f70b7d40 DB	387	static struct pcmcia_device_id ide_ids[] = {
f70b7d40 DB	388	PCMCIA_DEVICE_FUNC_ID(4),
7b1dec59	389	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */
725a6abf	390	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
ed896167 MD	391	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */
ed896167 MD	392	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */
f70b7d40	393	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
795659ef	394	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
ed896167	395	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */
a49c06bf	396	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000), /* Kingston */
795659ef	397	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), /* TI emulated */
d3feb184	398	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */
f70b7d40	399	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
d3feb184	400	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */
7b1dec59	401	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */
f70b7d40	402	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
ed896167 MD	403	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100), /* Viking CFA */
ed896167 MD	404	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar, Viking CFA */
f70b7d40 DB	405	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	406	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	407	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	408	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	409	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
	410	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	411	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	412	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
d277ad0e	413	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
f70b7d40 DB	414	PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	415	PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	416	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
725a6abf RP	417	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
725a6abf RP	418	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
7b1dec59	419	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
264a3412	420	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
f70b7d40	421	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
363f7e42	422	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
f70b7d40 DB	423	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b),
	424	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	425	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	426	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b),
74e23386	427	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
4fa902a9	428	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
2570b746	429	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
f70b7d40 DB	430	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	431	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	432	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
4fa902a9 MJ	433	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	434	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	435	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
f70b7d40	436	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
42935656	437	PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443),
a17bf220	438	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
bf4e1829	439	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
aa12b284	440	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
4fa902a9	441	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
f70b7d40	442	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
0517793f	443	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
f70b7d40	444	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
d3feb184	445	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
698e22c4	446	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
980fc29f	447	PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506),
f70b7d40 DB	448	PCMCIA_DEVICE_NULL,
	449	};
	450	MODULE_DEVICE_TABLE(pcmcia, ide_ids);
	451
1da177e4 LT	452	static struct pcmcia_driver ide_cs_driver = {
	453	.owner = THIS_MODULE,
	454	.drv = {
	455	.name = "ide-cs",
	456	},
15b99ac1	457	.probe = ide_probe,
cc3b4866	458	.remove = ide_detach,
f70b7d40	459	.id_table = ide_ids,
1da177e4 LT	460	};
	461
	462	static int __init init_ide_cs(void)
	463	{
	464	return pcmcia_register_driver(&ide_cs_driver);
	465	}
	466
	467	static void __exit exit_ide_cs(void)
	468	{
	469	pcmcia_unregister_driver(&ide_cs_driver);
1da177e4 LT	470	}
1da177e4 LT	471
2b8d4669	472	late_initcall(init_ide_cs);
1da177e4	473	module_exit(exit_ide_cs);