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

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

    A driver for PCMCIA IDE/ATA disk cards

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

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

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

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

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

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

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

#define DRV_NAME "ide-cs"

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

/* Module parameters */

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

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

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

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

typedef struct ide_info_t {
	struct pcmcia_device	*p_dev;
	struct ide_host		*host;
    int		ndev;
    dev_node_t	node;
} ide_info_t;

static void ide_release(struct pcmcia_device *);
static int ide_config(struct pcmcia_device *);

static void ide_detach(struct pcmcia_device *p_dev);


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

    ide_attach() creates an "instance" of the driver, allocating
    local data structures for one device.  The device is registered
    with Card Services.

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

static int ide_probe(struct pcmcia_device *link)
{
    ide_info_t *info;

    DEBUG(0, "ide_attach()\n");

    /* Create new ide device */
    info = kzalloc(sizeof(*info), GFP_KERNEL);
    if (!info)
	return -ENOMEM;

    info->p_dev = link;
    link->priv = info;

    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
    link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
    link->io.IOAddrLines = 3;
    link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
    link->irq.IRQInfo1 = IRQ_LEVEL_ID;
    link->conf.Attributes = CONF_ENABLE_IRQ;
    link->conf.IntType = INT_MEMORY_AND_IO;

    return ide_config(link);
} /* ide_attach */

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

    This deletes a driver "instance".  The device is de-registered
    with Card Services.  If it has been released, all local data
    structures are freed.  Otherwise, the structures will be freed
    when the device is released.

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

static void ide_detach(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    ide_hwif_t *hwif = info->host->ports[0];
    unsigned long data_addr, ctl_addr;

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

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

    ide_release(link);

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

    kfree(info);
} /* ide_detach */

static const struct ide_port_ops idecs_port_ops = {
	.quirkproc		= ide_undecoded_slave,
};

static const struct ide_port_info idecs_port_info = {
	.port_ops		= &idecs_port_ops,
	.host_flags		= IDE_HFLAG_NO_DMA,
};

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

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

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

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

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

    hwif = host->ports[0];

    if (hwif->present)
	return host;

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

    return host;

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

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

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

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

#define CS_CHECK(fn, ret) \
do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)

static int ide_config(struct pcmcia_device *link)
{
    ide_info_t *info = link->priv;
    tuple_t tuple;
    struct {
	u_short		buf[128];
	cisparse_t	parse;
	config_info_t	conf;
	cistpl_cftable_entry_t dflt;
    } *stk = NULL;
    cistpl_cftable_entry_t *cfg;
    int pass, last_ret = 0, last_fn = 0, is_kme = 0;
    unsigned long io_base, ctl_base;
    struct ide_host *host;

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

    stk = kzalloc(sizeof(*stk), GFP_KERNEL);
    if (!stk) goto err_mem;
    cfg = &stk->parse.cftable_entry;

    tuple.TupleData = (cisdata_t *)&stk->buf;
    tuple.TupleOffset = 0;
    tuple.TupleDataMax = 255;
    tuple.Attributes = 0;

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

    /* Not sure if this is right... look up the current Vcc */
    CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));

    pass = io_base = ctl_base = 0;
    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
    tuple.Attributes = 0;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
    while (1) {
    	if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
	if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;

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

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

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

    next_entry:
	if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
	    memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
	if (pass) {
	    CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
	} else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
	    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	    memset(&stk->dflt, 0, sizeof(stk->dflt));
	    pass++;
	}
    }

    CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));

    /* disable drive interrupts during IDE probe */
    outb(0x02, ctl_base);

    /* special setup for KXLC005 card */
    if (is_kme)
	outb(0x81, ctl_base+1);

     host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
     if (host == NULL && link->io.NumPorts1 == 0x20) {
	    outb(0x02, ctl_base + 0x10);
	    host = idecs_register(io_base + 0x10, ctl_base + 0x10,
				  link->irq.AssignedIRQ, link);
    }

    if (host == NULL)
	goto failed;

    info->ndev = 1;
    sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
    info->node.major = host->ports[0]->major;
    info->node.minor = 0;
    info->host = host;
    link->dev_node = &info->node;
    printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
	   info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);

    kfree(stk);
    return 0;

err_mem:
    printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
    goto failed;

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

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

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

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

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

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

    if (info->ndev)
	/* FIXME: if this fails we need to queue the cleanup somehow
	   -- need to investigate the required PCMCIA magic */
	ide_host_remove(host);

    info->ndev = 0;

    pcmcia_disable_device(link);
} /* ide_release */


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

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.  A CARD_REMOVAL event
    also sets some flags to discourage the ide drivers from
    talking to the ports.

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

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

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

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

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

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