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

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

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;

    dev_dbg(&link->dev, "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->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;

    dev_dbg(&link->dev, "ide_detach(0x%p)\n", link);

    ide_release(link);

    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.

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

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 ret = 0, is_kme = 0;
    unsigned long io_base, ctl_base;
    struct ide_host *host;

    dev_dbg(&link->dev, "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;

    ret = pcmcia_request_irq(link, &link->irq);
    if (ret)
	    goto failed;
    ret = pcmcia_request_configuration(link, &link->conf);
    if (ret)
	    goto failed;

    /* 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;

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;

    dev_dbg(&link->dev, "ide_release(0x%p)\n", link);

    if (info->ndev) {
	ide_hwif_t *hwif = host->ports[0];
	unsigned long data_addr, ctl_addr;

	data_addr = hwif->io_ports.data_addr;
	ctl_addr = hwif->io_ports.ctl_addr;

	ide_host_remove(host);
	info->ndev = 0;

	release_region(ctl_addr, 1);
	release_region(data_addr, 8);
    }

    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", "CF CARD 1GB", 0x2e6d1829, 0x55d5bffb),
	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 4GB", 0x2e6d1829, 0x531e7d10),
	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("TRANSCEND", "TS4GCF133", 0x709b1bf1, 0x7558f133),
	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS8GCF133", 0x709b1bf1, 0xb2f89b47),
	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
1da177e4 LT	63	/====================================================================/
1da177e4 LT	64
1da177e4	65	typedef struct ide_info_t {
fd238232	66	struct pcmcia_device *p_dev;
48c3c107	67	struct ide_host *host;
1da177e4 LT	68	int ndev;
1da177e4 LT	69	dev_node_t node;
1da177e4 LT	70	} ide_info_t;
1da177e4 LT	71
fba395ee	72	static void ide_release(struct pcmcia_device *);
15b99ac1	73	static int ide_config(struct pcmcia_device *);
1da177e4	74
cc3b4866	75	static void ide_detach(struct pcmcia_device *p_dev);
1da177e4	76
b4635811 DB	77
b4635811 DB	78
1da177e4 LT	79
	80	/*======================================================================
	81
	82	ide_attach() creates an "instance" of the driver, allocating
	83	local data structures for one device. The device is registered
	84	with Card Services.
	85
	86	======================================================================*/
	87
15b99ac1	88	static int ide_probe(struct pcmcia_device *link)
1da177e4 LT	89	{
1da177e4 LT	90	ide_info_t *info;
f8cfa618	91
444486a5	92	dev_dbg(&link->dev, "ide_attach()\n");
1da177e4 LT	93
1da177e4 LT	94	/* Create new ide device */
f5e3c2fa	95	info = kzalloc(sizeof(*info), GFP_KERNEL);
f8cfa618 DB	96	if (!info)
f8cfa618 DB	97	return -ENOMEM;
fd238232	98
fba395ee	99	info->p_dev = link;
fd238232	100	link->priv = info;
1da177e4 LT	101
	102	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	103	link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
	104	link->io.IOAddrLines = 3;
53a04c6f	105	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
1da177e4	106	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4	107	link->conf.IntType = INT_MEMORY_AND_IO;
f8cfa618	108
15b99ac1	109	return ide_config(link);
1da177e4 LT	110	} /* ide_attach */
	111
	112	/*======================================================================
	113
	114	This deletes a driver "instance". The device is de-registered
	115	with Card Services. If it has been released, all local data
	116	structures are freed. Otherwise, the structures will be freed
	117	when the device is released.
	118
	119	======================================================================*/
	120
fba395ee	121	static void ide_detach(struct pcmcia_device *link)
1da177e4	122	{
d703b79e	123	ide_info_t *info = link->priv;
d703b79e	124
444486a5	125	dev_dbg(&link->dev, "ide_detach(0x%p)\n", link);
1da177e4	126
e2d40963	127	ide_release(link);
b4635811	128
d703b79e	129	kfree(info);
1da177e4 LT	130	} /* ide_detach */
1da177e4 LT	131
ac95beed BZ	132	static const struct ide_port_ops idecs_port_ops = {
	133	.quirkproc = ide_undecoded_slave,
	134	};
	135
dccdf527 BZ	136	static const struct ide_port_info idecs_port_info = {
	137	.port_ops = &idecs_port_ops,
	138	.host_flags = IDE_HFLAG_NO_DMA,
255115fb	139	.irq_flags = IRQF_SHARED,
29e52cf7	140	.chipset = ide_pci,
dccdf527 BZ	141	};
dccdf527 BZ	142
48c3c107	143	static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
d703b79e	144	unsigned long irq, struct pcmcia_device *handle)
1da177e4	145	{
48c3c107	146	struct ide_host *host;
9e016a71	147	ide_hwif_t *hwif;
6f904d01	148	int i, rc;
9f36d314	149	struct ide_hw hw, *hws[] = { &hw };
9e016a71	150
d703b79e BZ	151	if (!request_region(io, 8, DRV_NAME)) {
	152	printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
	153	DRV_NAME, io, io + 7);
	154	return NULL;
	155	}
	156
	157	if (!request_region(ctl, 1, DRV_NAME)) {
	158	printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
	159	DRV_NAME, ctl);
	160	release_region(io, 8);
	161	return NULL;
	162	}
	163
1da177e4	164	memset(&hw, 0, sizeof(hw));
dcb425f5	165	ide_std_init_ports(&hw, io, ctl);
1da177e4	166	hw.irq = irq;
4349d5cd	167	hw.dev = &handle->dev;
9e016a71	168
dca39830	169	rc = ide_host_add(&idecs_port_info, hws, 1, &host);
6f904d01	170	if (rc)
d703b79e	171	goto out_release;
9e016a71	172
48c3c107	173	hwif = host->ports[0];
9e016a71	174
d703b79e	175	if (hwif->present)
48c3c107	176	return host;
d703b79e	177
792a1a98 BZ	178	/* retry registration in case device is still spinning up */
	179	for (i = 0; i < 10; i++) {
	180	msleep(100);
	181	ide_port_scan(hwif);
	182	if (hwif->present)
48c3c107	183	return host;
792a1a98 BZ	184	}
792a1a98 BZ	185
48c3c107	186	return host;
792a1a98	187
d703b79e BZ	188	out_release:
	189	release_region(ctl, 1);
	190	release_region(io, 8);
	191	return NULL;
1da177e4 LT	192	}
	193
	194	/*======================================================================
	195
	196	ide_config() is scheduled to run after a CARD_INSERTION event
	197	is received, to configure the PCMCIA socket, and to make the
	198	ide device available to the system.
	199
	200	======================================================================*/
	201
0bac660a	202	struct pcmcia_config_check {
0bac660a DB	203	unsigned long ctl_base;
	204	int skip_vcc;
	205	int is_kme;
	206	};
	207
	208	static int pcmcia_check_one_config(struct pcmcia_device *pdev,
	209	cistpl_cftable_entry_t *cfg,
8e2fc39d	210	cistpl_cftable_entry_t *dflt,
ad913c11	211	unsigned int vcc,
0bac660a DB	212	void *priv_data)
	213	{
	214	struct pcmcia_config_check *stk = priv_data;
	215
	216	/* Check for matching Vcc, unless we're desperate */
	217	if (!stk->skip_vcc) {
	218	if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
ad913c11	219	if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
8e2fc39d DB	220	return -ENODEV;
8e2fc39d DB	221	} else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
ad913c11	222	if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
8e2fc39d	223	return -ENODEV;
0bac660a DB	224	}
	225	}
	226
	227	if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
	228	pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
8e2fc39d DB	229	else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
8e2fc39d DB	230	pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
0bac660a	231
8e2fc39d DB	232	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
8e2fc39d DB	233	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
0bac660a DB	234	pdev->conf.ConfigIndex = cfg->index;
	235	pdev->io.BasePort1 = io->win[0].base;
	236	pdev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	237	if (!(io->flags & CISTPL_IO_16BIT))
	238	pdev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	239	if (io->nwin == 2) {
	240	pdev->io.NumPorts1 = 8;
	241	pdev->io.BasePort2 = io->win[1].base;
	242	pdev->io.NumPorts2 = (stk->is_kme) ? 2 : 1;
	243	if (pcmcia_request_io(pdev, &pdev->io) != 0)
8e2fc39d	244	return -ENODEV;
0bac660a DB	245	stk->ctl_base = pdev->io.BasePort2;
	246	} else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
	247	pdev->io.NumPorts1 = io->win[0].len;
	248	pdev->io.NumPorts2 = 0;
	249	if (pcmcia_request_io(pdev, &pdev->io) != 0)
8e2fc39d	250	return -ENODEV;
0bac660a DB	251	stk->ctl_base = pdev->io.BasePort1 + 0x0e;
0bac660a DB	252	} else
8e2fc39d	253	return -ENODEV;
0bac660a DB	254	/* If we've got this far, we're done */
	255	return 0;
	256	}
0bac660a DB	257	return -ENODEV;
	258	}
	259
15b99ac1	260	static int ide_config(struct pcmcia_device *link)
1da177e4	261	{
1da177e4	262	ide_info_t *info = link->priv;
0bac660a	263	struct pcmcia_config_check *stk = NULL;
444486a5	264	int ret = 0, is_kme = 0;
2f1b9250	265	unsigned long io_base, ctl_base;
48c3c107	266	struct ide_host *host;
1da177e4	267
444486a5	268	dev_dbg(&link->dev, "ide_config(0x%p)\n", link);
1da177e4	269
efd50585 DB	270	is_kme = ((link->manf_id == MANFID_KME) &&
	271	((link->card_id == PRODID_KME_KXLC005_A) \|\|
	272	(link->card_id == PRODID_KME_KXLC005_B)));
1da177e4	273
0bac660a DB	274	stk = kzalloc(sizeof(*stk), GFP_KERNEL);
	275	if (!stk)
	276	goto err_mem;
	277	stk->is_kme = is_kme;
0bac660a	278	stk->skip_vcc = io_base = ctl_base = 0;
ad913c11	279
0bac660a	280	if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
0bac660a DB	281	stk->skip_vcc = 1;
	282	if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
	283	goto failed; /* No suitable config found */
1da177e4	284	}
0bac660a DB	285	io_base = link->io.BasePort1;
0bac660a DB	286	ctl_base = stk->ctl_base;
1da177e4	287
444486a5 DB	288	ret = pcmcia_request_irq(link, &link->irq);
	289	if (ret)
	290	goto failed;
	291	ret = pcmcia_request_configuration(link, &link->conf);
	292	if (ret)
	293	goto failed;
1da177e4 LT	294
1da177e4 LT	295	/* disable drive interrupts during IDE probe */
2f1b9250	296	outb(0x02, ctl_base);
1da177e4 LT	297
	298	/* special setup for KXLC005 card */
	299	if (is_kme)
2f1b9250	300	outb(0x81, ctl_base+1);
1da177e4	301
48c3c107 BZ	302	host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
48c3c107 BZ	303	if (host == NULL && link->io.NumPorts1 == 0x20) {
2f1b9250	304	outb(0x02, ctl_base + 0x10);
48c3c107	305	host = idecs_register(io_base + 0x10, ctl_base + 0x10,
d703b79e	306	link->irq.AssignedIRQ, link);
1da177e4 LT	307	}
1da177e4 LT	308
48c3c107	309	if (host == NULL)
1da177e4	310	goto failed;
1da177e4 LT	311
1da177e4 LT	312	info->ndev = 1;
48c3c107 BZ	313	sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
48c3c107 BZ	314	info->node.major = host->ports[0]->major;
1da177e4	315	info->node.minor = 0;
48c3c107	316	info->host = host;
fd238232	317	link->dev_node = &info->node;
70294b46 DB	318	printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
70294b46 DB	319	info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
1da177e4	320
1da177e4	321	kfree(stk);
15b99ac1	322	return 0;
1da177e4 LT	323
	324	err_mem:
	325	printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
	326	goto failed;
	327
1da177e4 LT	328	failed:
	329	kfree(stk);
	330	ide_release(link);
15b99ac1	331	return -ENODEV;
1da177e4 LT	332	} /* ide_config */
	333
	334	/*======================================================================
	335
	336	After a card is removed, ide_release() will unregister the net
	337	device, and release the PCMCIA configuration. If the device is
	338	still open, this will be postponed until it is closed.
7b1dec59	339
1da177e4 LT	340	======================================================================*/
1da177e4 LT	341
727c6742	342	static void ide_release(struct pcmcia_device *link)
1da177e4 LT	343	{
1da177e4 LT	344	ide_info_t *info = link->priv;
48c3c107	345	struct ide_host *host = info->host;
7b1dec59	346
444486a5	347	dev_dbg(&link->dev, "ide_release(0x%p)\n", link);
1da177e4	348
d4ae5415 WS	349	if (info->ndev) {
	350	ide_hwif_t *hwif = host->ports[0];
	351	unsigned long data_addr, ctl_addr;
	352
	353	data_addr = hwif->io_ports.data_addr;
	354	ctl_addr = hwif->io_ports.ctl_addr;
	355
48c3c107	356	ide_host_remove(host);
d4ae5415	357	info->ndev = 0;
48c3c107	358
d4ae5415 WS	359	release_region(ctl_addr, 1);
	360	release_region(data_addr, 8);
	361	}
1da177e4	362
fba395ee	363	pcmcia_disable_device(link);
1da177e4 LT	364	} /* ide_release */
1da177e4 LT	365
98e4c28b	366
1da177e4 LT	367	/*======================================================================
	368
	369	The card status event handler. Mostly, this schedules other
	370	stuff to run after an event is received. A CARD_REMOVAL event
	371	also sets some flags to discourage the ide drivers from
	372	talking to the ports.
7b1dec59	373
1da177e4 LT	374	======================================================================*/
1da177e4 LT	375
f70b7d40 DB	376	static struct pcmcia_device_id ide_ids[] = {
f70b7d40 DB	377	PCMCIA_DEVICE_FUNC_ID(4),
7b1dec59	378	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */
725a6abf	379	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
ed896167 MD	380	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */
ed896167 MD	381	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */
f70b7d40	382	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
795659ef	383	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
ed896167	384	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */
a49c06bf	385	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000), /* Kingston */
795659ef	386	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), /* TI emulated */
d3feb184	387	PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */
f70b7d40	388	PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
d3feb184	389	PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */
7b1dec59	390	PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */
f70b7d40	391	PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
ed896167 MD	392	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100), /* Viking CFA */
ed896167 MD	393	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar, Viking CFA */
f70b7d40 DB	394	PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
	395	PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
	396	PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
	397	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
	398	PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
c9a2bfd1	399	PCMCIA_DEVICE_PROD_ID12("CNF ", "CD-ROM", 0x46d7db81, 0x66536591),
f70b7d40 DB	400	PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
	401	PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
	402	PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
d277ad0e	403	PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
f70b7d40 DB	404	PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591),
	405	PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
	406	PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
725a6abf RP	407	PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
725a6abf RP	408	PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
7b1dec59	409	PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
264a3412	410	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
f70b7d40	411	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
85ea2d3f	412	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 1GB", 0x2e6d1829, 0x55d5bffb),
f25798ed	413	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 4GB", 0x2e6d1829, 0x531e7d10),
363f7e42	414	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
f70b7d40 DB	415	PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b),
	416	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
	417	PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
	418	PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b),
74e23386	419	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
4fa902a9	420	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
2570b746	421	PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
f70b7d40 DB	422	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
	423	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
	424	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
4fa902a9 MJ	425	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
	426	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
	427	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
f70b7d40	428	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
42935656	429	PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443),
a17bf220	430	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
bf4e1829	431	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
aa12b284	432	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
4fa902a9	433	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
85ea2d3f	434	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF133", 0x709b1bf1, 0x7558f133),
f25798ed	435	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS8GCF133", 0x709b1bf1, 0xb2f89b47),
f70b7d40	436	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
0517793f	437	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
f70b7d40	438	PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
d3feb184	439	PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
698e22c4	440	PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
980fc29f	441	PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506),
f70b7d40 DB	442	PCMCIA_DEVICE_NULL,
	443	};
	444	MODULE_DEVICE_TABLE(pcmcia, ide_ids);
	445
1da177e4 LT	446	static struct pcmcia_driver ide_cs_driver = {
	447	.owner = THIS_MODULE,
	448	.drv = {
	449	.name = "ide-cs",
	450	},
15b99ac1	451	.probe = ide_probe,
cc3b4866	452	.remove = ide_detach,
f70b7d40	453	.id_table = ide_ids,
1da177e4 LT	454	};
	455
	456	static int __init init_ide_cs(void)
	457	{
	458	return pcmcia_register_driver(&ide_cs_driver);
	459	}
	460
	461	static void __exit exit_ide_cs(void)
	462	{
	463	pcmcia_unregister_driver(&ide_cs_driver);
1da177e4 LT	464	}
1da177e4 LT	465
2b8d4669	466	late_initcall(init_ide_cs);
1da177e4	467	module_exit(exit_ide_cs);