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

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

    A driver for PCMCIA IDE/ATA disk cards

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

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

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

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

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

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

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

#define DRV_NAME "ide-cs"

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

/* Module parameters */

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

#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,
	.irq_flags		= IRQF_SHARED,
	.chipset		= ide_pci,
};

static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
				unsigned long irq, struct pcmcia_device *handle)
{
    struct ide_host *host;
    ide_hwif_t *hwif;
    int i, rc;
    struct ide_hw hw, *hws[] = { &hw };

    if (!request_region(io, 8, DRV_NAME)) {
	printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
			DRV_NAME, io, io + 7);
	return NULL;
    }

    if (!request_region(ctl, 1, DRV_NAME)) {
	printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
			DRV_NAME, ctl);
	release_region(io, 8);
	return NULL;
    }

    memset(&hw, 0, sizeof(hw));
    ide_std_init_ports(&hw, io, ctl);
    hw.irq = irq;
    hw.dev = &handle->dev;

    rc = ide_host_add(&idecs_port_info, hws, 1, &host);
    if (rc)
	goto out_release;

    hwif = host->ports[0];

    if (hwif->present)
	return host;

    /* retry registration in case device is still spinning up */
    for (i = 0; i < 10; i++) {
	msleep(100);
	ide_port_scan(hwif);
	if (hwif->present)
	    return host;
    }

    return host;

out_release:
    release_region(ctl, 1);
    release_region(io, 8);
    return NULL;
}

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

    ide_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    ide device available to the system.

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

#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-ROM", 0x46d7db81, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
	PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, ide_ids);

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

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

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

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