[deliverable/linux.git] / drivers / net / pcmcia / ibmtr_cs.c

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

    A PCMCIA token-ring driver for IBM-based cards

    This driver supports the IBM PCMCIA Token-Ring Card.
    Written by Steve Kipisz, kipisz@vnet.ibm.com or
                             bungy@ibm.net

    Written 1995,1996.

    This code is based on pcnet_cs.c from David Hinds.
    
    V2.2.0 February 1999 - Mike Phillips phillim@amtrak.com

    Linux V2.2.x presented significant changes to the underlying
    ibmtr.c code.  Mainly the code became a lot more organized and
    modular.

    This caused the old PCMCIA Token Ring driver to give up and go 
    home early. Instead of just patching the old code to make it 
    work, the PCMCIA code has been streamlined, updated and possibly
    improved.

    This code now only contains code required for the Card Services.
    All we do here is set the card up enough so that the real ibmtr.c
    driver can find it and work with it properly.

    i.e. We set up the io port, irq, mmio memory and shared ram
    memory.  This enables ibmtr_probe in ibmtr.c to find the card and
    configure it as though it was a normal ISA and/or PnP card.

    CHANGES

    v2.2.5 April 1999 Mike Phillips (phillim@amtrak.com)
    Obscure bug fix, required changed to ibmtr.c not ibmtr_cs.c
    
    v2.2.7 May 1999 Mike Phillips (phillim@amtrak.com)
    Updated to version 2.2.7 to match the first version of the kernel
    that the modification to ibmtr.c were incorporated into.
    
    v2.2.17 July 2000 Burt Silverman (burts@us.ibm.com)
    Address translation feature of PCMCIA controller is usable so
    memory windows can be placed in High memory (meaning above
    0xFFFFF.)

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

#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/module.h>
#include <linux/ethtool.h>
#include <linux/netdevice.h>
#include <linux/trdevice.h>
#include <linux/ibmtr.h>

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

#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/system.h>

#define PCMCIA
#include "../tokenring/ibmtr.c"

#ifdef PCMCIA_DEBUG
static int pc_debug = PCMCIA_DEBUG;
module_param(pc_debug, int, 0);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
static char *version =
"ibmtr_cs.c 1.10   1996/01/06 05:19:00 (Steve Kipisz)\n"
"           2.2.7  1999/05/03 12:00:00 (Mike Phillips)\n"
"           2.4.2  2001/30/28 Midnight (Burt Silverman)\n";
#else
#define DEBUG(n, args...)
#endif

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

/* Parameters that can be set with 'insmod' */

/* MMIO base address */
static u_long mmiobase = 0xce000;

/* SRAM base address */
static u_long srambase = 0xd0000;

/* SRAM size 8,16,32,64 */
static u_long sramsize = 64;

/* Ringspeed 4,16 */
static int ringspeed = 16;

module_param(mmiobase, ulong, 0);
module_param(srambase, ulong, 0);
module_param(sramsize, ulong, 0);
module_param(ringspeed, int, 0);
MODULE_LICENSE("GPL");

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

static void ibmtr_config(dev_link_t *link);
static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase);
static void ibmtr_release(dev_link_t *link);
static void ibmtr_detach(struct pcmcia_device *p_dev);

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

typedef struct ibmtr_dev_t {
    dev_link_t		link;
    struct net_device	*dev;
    dev_node_t          node;
    window_handle_t     sram_win_handle;
    struct tok_info	*ti;
} ibmtr_dev_t;

static void netdev_get_drvinfo(struct net_device *dev,
			       struct ethtool_drvinfo *info)
{
	strcpy(info->driver, "ibmtr_cs");
}

static struct ethtool_ops netdev_ethtool_ops = {
	.get_drvinfo		= netdev_get_drvinfo,
};

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

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

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

static int ibmtr_attach(struct pcmcia_device *p_dev)
{
    ibmtr_dev_t *info;
    dev_link_t *link;
    struct net_device *dev;
    
    DEBUG(0, "ibmtr_attach()\n");

    /* Create new token-ring device */
    info = kmalloc(sizeof(*info), GFP_KERNEL); 
    if (!info) return -ENOMEM;
    memset(info,0,sizeof(*info));
    dev = alloc_trdev(sizeof(struct tok_info));
    if (!dev) {
	kfree(info);
	return -ENOMEM;
    }

    link = &info->link;
    link->priv = info;
    info->ti = netdev_priv(dev);

    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    link->io.NumPorts1 = 4;
    link->io.IOAddrLines = 16;
    link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
    link->irq.IRQInfo1 = IRQ_LEVEL_ID;
    link->irq.Handler = &tok_interrupt;
    link->conf.Attributes = CONF_ENABLE_IRQ;
    link->conf.Vcc = 50;
    link->conf.IntType = INT_MEMORY_AND_IO;
    link->conf.Present = PRESENT_OPTION;

    link->irq.Instance = info->dev = dev;
    
    SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);

    link->handle = p_dev;
    p_dev->instance = link;

    link->state |= DEV_PRESENT;
    ibmtr_config(link);

    return 0;
} /* ibmtr_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 ibmtr_detach(struct pcmcia_device *p_dev)
{
    dev_link_t *link = dev_to_instance(p_dev);
    struct ibmtr_dev_t *info = link->priv;
    struct net_device *dev = info->dev;

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

    if (link->dev)
	unregister_netdev(dev);

    {
	struct tok_info *ti = netdev_priv(dev);
	del_timer_sync(&(ti->tr_timer));
    }
    if (link->state & DEV_CONFIG)
        ibmtr_release(link);

    free_netdev(dev);
    kfree(info);
} /* ibmtr_detach */

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

    ibmtr_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    token-ring 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 void ibmtr_config(dev_link_t *link)
{
    client_handle_t handle = link->handle;
    ibmtr_dev_t *info = link->priv;
    struct net_device *dev = info->dev;
    struct tok_info *ti = netdev_priv(dev);
    tuple_t tuple;
    cisparse_t parse;
    win_req_t req;
    memreq_t mem;
    int i, last_ret, last_fn;
    u_char buf[64];

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

    tuple.Attributes = 0;
    tuple.TupleData = buf;
    tuple.TupleDataMax = 64;
    tuple.TupleOffset = 0;
    tuple.DesiredTuple = CISTPL_CONFIG;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
    CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
    CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
    link->conf.ConfigBase = parse.config.base;

    /* Configure card */
    link->state |= DEV_CONFIG;

    link->conf.ConfigIndex = 0x61;

    /* Determine if this is PRIMARY or ALTERNATE. */

    /* Try PRIMARY card at 0xA20-0xA23 */
    link->io.BasePort1 = 0xA20;
    i = pcmcia_request_io(link->handle, &link->io);
    if (i != CS_SUCCESS) {
	/* Couldn't get 0xA20-0xA23.  Try ALTERNATE at 0xA24-0xA27. */
	link->io.BasePort1 = 0xA24;
	CS_CHECK(RequestIO, pcmcia_request_io(link->handle, &link->io));
    }
    dev->base_addr = link->io.BasePort1;

    CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
    dev->irq = link->irq.AssignedIRQ;
    ti->irq = link->irq.AssignedIRQ;
    ti->global_int_enable=GLOBAL_INT_ENABLE+((dev->irq==9) ? 2 : dev->irq);

    /* Allocate the MMIO memory window */
    req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
    req.Attributes |= WIN_USE_WAIT;
    req.Base = 0; 
    req.Size = 0x2000;
    req.AccessSpeed = 250;
    CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));

    mem.CardOffset = mmiobase;
    mem.Page = 0;
    CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
    ti->mmio = ioremap(req.Base, req.Size);

    /* Allocate the SRAM memory window */
    req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
    req.Attributes |= WIN_USE_WAIT;
    req.Base = 0;
    req.Size = sramsize * 1024;
    req.AccessSpeed = 250;
    CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &info->sram_win_handle));

    mem.CardOffset = srambase;
    mem.Page = 0;
    CS_CHECK(MapMemPage, pcmcia_map_mem_page(info->sram_win_handle, &mem));

    ti->sram_base = mem.CardOffset >> 12;
    ti->sram_virt = ioremap(req.Base, req.Size);
    ti->sram_phys = req.Base;

    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));

    /*  Set up the Token-Ring Controller Configuration Register and
        turn on the card.  Check the "Local Area Network Credit Card
        Adapters Technical Reference"  SC30-3585 for this info.  */
    ibmtr_hw_setup(dev, mmiobase);

    link->dev = &info->node;
    link->state &= ~DEV_CONFIG_PENDING;
    SET_NETDEV_DEV(dev, &handle_to_dev(handle));

    i = ibmtr_probe_card(dev);
    if (i != 0) {
	printk(KERN_NOTICE "ibmtr_cs: register_netdev() failed\n");
	link->dev = NULL;
	goto failed;
    }

    strcpy(info->node.dev_name, dev->name);

    printk(KERN_INFO "%s: port %#3lx, irq %d,",
           dev->name, dev->base_addr, dev->irq);
    printk (" mmio %#5lx,", (u_long)ti->mmio);
    printk (" sram %#5lx,", (u_long)ti->sram_base << 12);
    printk ("\n" KERN_INFO "  hwaddr=");
    for (i = 0; i < TR_ALEN; i++)
        printk("%02X", dev->dev_addr[i]);
    printk("\n");
    return;

cs_failed:
    cs_error(link->handle, last_fn, last_ret);
failed:
    ibmtr_release(link);
} /* ibmtr_config */

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

    After a card is removed, ibmtr_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 ibmtr_release(dev_link_t *link)
{
    ibmtr_dev_t *info = link->priv;
    struct net_device *dev = info->dev;

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

    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);
    if (link->win) {
	struct tok_info *ti = netdev_priv(dev);
	iounmap(ti->mmio);
	pcmcia_release_window(link->win);
	pcmcia_release_window(info->sram_win_handle);
    }

    link->state &= ~DEV_CONFIG;
}

static int ibmtr_suspend(struct pcmcia_device *p_dev)
{
	dev_link_t *link = dev_to_instance(p_dev);
	ibmtr_dev_t *info = link->priv;
	struct net_device *dev = info->dev;

	link->state |= DEV_SUSPEND;
        if (link->state & DEV_CONFIG) {
		if (link->open)
			netif_device_detach(dev);
		pcmcia_release_configuration(link->handle);
        }

	return 0;
}

static int ibmtr_resume(struct pcmcia_device *p_dev)
{
	dev_link_t *link = dev_to_instance(p_dev);
	ibmtr_dev_t *info = link->priv;
	struct net_device *dev = info->dev;

	link->state &= ~DEV_SUSPEND;
        if (link->state & DEV_CONFIG) {
		pcmcia_request_configuration(link->handle, &link->conf);
		if (link->open) {
			ibmtr_probe(dev);	/* really? */
			netif_device_attach(dev);
		}
        }

	return 0;
}


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

static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase)
{
    int i;

    /* Bizarre IBM behavior, there are 16 bits of information we
       need to set, but the card only allows us to send 4 bits at a 
       time.  For each byte sent to base_addr, bits 7-4 tell the
       card which part of the 16 bits we are setting, bits 3-0 contain 
       the actual information */

    /* First nibble provides 4 bits of mmio */
    i = (mmiobase >> 16) & 0x0F;
    outb(i, dev->base_addr);

    /* Second nibble provides 3 bits of mmio */
    i = 0x10 | ((mmiobase >> 12) & 0x0E);
    outb(i, dev->base_addr);

    /* Third nibble, hard-coded values */
    i = 0x26;
    outb(i, dev->base_addr);

    /* Fourth nibble sets shared ram page size */

    /* 8 = 00, 16 = 01, 32 = 10, 64 = 11 */          
    i = (sramsize >> 4) & 0x07;
    i = ((i == 4) ? 3 : i) << 2;
    i |= 0x30;

    if (ringspeed == 16)
	i |= 2;
    if (dev->base_addr == 0xA24)
	i |= 1;
    outb(i, dev->base_addr);

    /* 0x40 will release the card for use */
    outb(0x40, dev->base_addr);

    return;
}

static struct pcmcia_device_id ibmtr_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("3Com", "TokenLink Velocity PC Card", 0x41240e5b, 0x82c3734e),
	PCMCIA_DEVICE_PROD_ID12("IBM", "TOKEN RING", 0xb569a6e5, 0xbf8eed47),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, ibmtr_ids);

static struct pcmcia_driver ibmtr_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "ibmtr_cs",
	},
	.probe		= ibmtr_attach,
	.remove		= ibmtr_detach,
	.id_table       = ibmtr_ids,
	.suspend	= ibmtr_suspend,
	.resume		= ibmtr_resume,
};

static int __init init_ibmtr_cs(void)
{
	return pcmcia_register_driver(&ibmtr_cs_driver);
}

static void __exit exit_ibmtr_cs(void)
{
	pcmcia_unregister_driver(&ibmtr_cs_driver);
}

module_init(init_ibmtr_cs);
module_exit(exit_ibmtr_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A PCMCIA token-ring driver for IBM-based cards
	4
	5	This driver supports the IBM PCMCIA Token-Ring Card.
	6	Written by Steve Kipisz, kipisz@vnet.ibm.com or
	7	bungy@ibm.net
	8
	9	Written 1995,1996.
	10
	11	This code is based on pcnet_cs.c from David Hinds.
	12
	13	V2.2.0 February 1999 - Mike Phillips phillim@amtrak.com
	14
	15	Linux V2.2.x presented significant changes to the underlying
	16	ibmtr.c code. Mainly the code became a lot more organized and
	17	modular.
	18
	19	This caused the old PCMCIA Token Ring driver to give up and go
	20	home early. Instead of just patching the old code to make it
	21	work, the PCMCIA code has been streamlined, updated and possibly
	22	improved.
	23
	24	This code now only contains code required for the Card Services.
	25	All we do here is set the card up enough so that the real ibmtr.c
	26	driver can find it and work with it properly.
	27
	28	i.e. We set up the io port, irq, mmio memory and shared ram
	29	memory. This enables ibmtr_probe in ibmtr.c to find the card and
	30	configure it as though it was a normal ISA and/or PnP card.
	31
	32	CHANGES
	33
	34	v2.2.5 April 1999 Mike Phillips (phillim@amtrak.com)
	35	Obscure bug fix, required changed to ibmtr.c not ibmtr_cs.c
	36
	37	v2.2.7 May 1999 Mike Phillips (phillim@amtrak.com)
	38	Updated to version 2.2.7 to match the first version of the kernel
	39	that the modification to ibmtr.c were incorporated into.
	40
	41	v2.2.17 July 2000 Burt Silverman (burts@us.ibm.com)
	42	Address translation feature of PCMCIA controller is usable so
	43	memory windows can be placed in High memory (meaning above
	44	0xFFFFF.)
	45
	46	======================================================================*/
	47
	48	#include <linux/kernel.h>
	49	#include <linux/init.h>
	50	#include <linux/ptrace.h>
	51	#include <linux/slab.h>
	52	#include <linux/string.h>
	53	#include <linux/timer.h>
	54	#include <linux/module.h>
	55	#include <linux/ethtool.h>
	56	#include <linux/netdevice.h>
	57	#include <linux/trdevice.h>
	58	#include <linux/ibmtr.h>
	59
1da177e4 LT	60	#include <pcmcia/cs_types.h>
	61	#include <pcmcia/cs.h>
	62	#include <pcmcia/cistpl.h>
	63	#include <pcmcia/ds.h>
	64
	65	#include <asm/uaccess.h>
	66	#include <asm/io.h>
	67	#include <asm/system.h>
	68
	69	#define PCMCIA
	70	#include "../tokenring/ibmtr.c"
	71
	72	#ifdef PCMCIA_DEBUG
	73	static int pc_debug = PCMCIA_DEBUG;
	74	module_param(pc_debug, int, 0);
	75	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	76	static char *version =
	77	"ibmtr_cs.c 1.10 1996/01/06 05:19:00 (Steve Kipisz)\n"
	78	" 2.2.7 1999/05/03 12:00:00 (Mike Phillips)\n"
	79	" 2.4.2 2001/30/28 Midnight (Burt Silverman)\n";
	80	#else
	81	#define DEBUG(n, args...)
	82	#endif
	83
	84	/====================================================================/
	85
	86	/* Parameters that can be set with 'insmod' */
	87
	88	/* MMIO base address */
	89	static u_long mmiobase = 0xce000;
	90
	91	/* SRAM base address */
	92	static u_long srambase = 0xd0000;
	93
	94	/* SRAM size 8,16,32,64 */
	95	static u_long sramsize = 64;
	96
	97	/* Ringspeed 4,16 */
	98	static int ringspeed = 16;
	99
	100	module_param(mmiobase, ulong, 0);
	101	module_param(srambase, ulong, 0);
	102	module_param(sramsize, ulong, 0);
	103	module_param(ringspeed, int, 0);
	104	MODULE_LICENSE("GPL");
	105
	106	/====================================================================/
	107
	108	static void ibmtr_config(dev_link_t *link);
	109	static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase);
	110	static void ibmtr_release(dev_link_t *link);
cc3b4866	111	static void ibmtr_detach(struct pcmcia_device *p_dev);
1da177e4	112
1da177e4 LT	113	/====================================================================/
	114
	115	typedef struct ibmtr_dev_t {
	116	dev_link_t link;
	117	struct net_device *dev;
	118	dev_node_t node;
	119	window_handle_t sram_win_handle;
	120	struct tok_info *ti;
	121	} ibmtr_dev_t;
	122
	123	static void netdev_get_drvinfo(struct net_device *dev,
	124	struct ethtool_drvinfo *info)
	125	{
	126	strcpy(info->driver, "ibmtr_cs");
	127	}
	128
	129	static struct ethtool_ops netdev_ethtool_ops = {
	130	.get_drvinfo = netdev_get_drvinfo,
	131	};
	132
	133	/*======================================================================
	134
	135	ibmtr_attach() creates an "instance" of the driver, allocating
	136	local data structures for one device. The device is registered
	137	with Card Services.
	138
	139	======================================================================*/
	140
f8cfa618	141	static int ibmtr_attach(struct pcmcia_device *p_dev)
1da177e4 LT	142	{
	143	ibmtr_dev_t *info;
	144	dev_link_t *link;
	145	struct net_device *dev;
1da177e4 LT	146
	147	DEBUG(0, "ibmtr_attach()\n");
	148
	149	/* Create new token-ring device */
	150	info = kmalloc(sizeof(*info), GFP_KERNEL);
f8cfa618	151	if (!info) return -ENOMEM;
1da177e4 LT	152	memset(info,0,sizeof(*info));
1da177e4 LT	153	dev = alloc_trdev(sizeof(struct tok_info));
f8cfa618 DB	154	if (!dev) {
	155	kfree(info);
	156	return -ENOMEM;
	157	}
1da177e4 LT	158
	159	link = &info->link;
	160	link->priv = info;
	161	info->ti = netdev_priv(dev);
	162
	163	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	164	link->io.NumPorts1 = 4;
	165	link->io.IOAddrLines = 16;
	166	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	167	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	168	link->irq.Handler = &tok_interrupt;
	169	link->conf.Attributes = CONF_ENABLE_IRQ;
	170	link->conf.Vcc = 50;
	171	link->conf.IntType = INT_MEMORY_AND_IO;
	172	link->conf.Present = PRESENT_OPTION;
	173
	174	link->irq.Instance = info->dev = dev;
	175
	176	SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
	177
f8cfa618 DB	178	link->handle = p_dev;
f8cfa618 DB	179	p_dev->instance = link;
1da177e4	180
f8cfa618 DB	181	link->state \|= DEV_PRESENT;
f8cfa618 DB	182	ibmtr_config(link);
1da177e4	183
f8cfa618	184	return 0;
1da177e4 LT	185	} /* ibmtr_attach */
	186
	187	/*======================================================================
	188
	189	This deletes a driver "instance". The device is de-registered
	190	with Card Services. If it has been released, all local data
	191	structures are freed. Otherwise, the structures will be freed
	192	when the device is released.
	193
	194	======================================================================*/
	195
cc3b4866	196	static void ibmtr_detach(struct pcmcia_device *p_dev)
1da177e4	197	{
cc3b4866	198	dev_link_t *link = dev_to_instance(p_dev);
1da177e4	199	struct ibmtr_dev_t *info = link->priv;
b4635811	200	struct net_device *dev = info->dev;
1da177e4 LT	201
	202	DEBUG(0, "ibmtr_detach(0x%p)\n", link);
	203
1da177e4 LT	204	if (link->dev)
	205	unregister_netdev(dev);
	206
	207	{
	208	struct tok_info *ti = netdev_priv(dev);
	209	del_timer_sync(&(ti->tr_timer));
	210	}
	211	if (link->state & DEV_CONFIG)
	212	ibmtr_release(link);
	213
1da177e4	214	free_netdev(dev);
b4635811	215	kfree(info);
1da177e4 LT	216	} /* ibmtr_detach */
	217
	218	/*======================================================================
	219
	220	ibmtr_config() is scheduled to run after a CARD_INSERTION event
	221	is received, to configure the PCMCIA socket, and to make the
	222	token-ring device available to the system.
	223
	224	======================================================================*/
	225
	226	#define CS_CHECK(fn, ret) \
	227	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	228
	229	static void ibmtr_config(dev_link_t *link)
	230	{
	231	client_handle_t handle = link->handle;
	232	ibmtr_dev_t *info = link->priv;
	233	struct net_device *dev = info->dev;
	234	struct tok_info *ti = netdev_priv(dev);
	235	tuple_t tuple;
	236	cisparse_t parse;
	237	win_req_t req;
	238	memreq_t mem;
	239	int i, last_ret, last_fn;
	240	u_char buf[64];
	241
	242	DEBUG(0, "ibmtr_config(0x%p)\n", link);
	243
	244	tuple.Attributes = 0;
	245	tuple.TupleData = buf;
	246	tuple.TupleDataMax = 64;
	247	tuple.TupleOffset = 0;
	248	tuple.DesiredTuple = CISTPL_CONFIG;
	249	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	250	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	251	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	252	link->conf.ConfigBase = parse.config.base;
	253
	254	/* Configure card */
	255	link->state \|= DEV_CONFIG;
	256
	257	link->conf.ConfigIndex = 0x61;
	258
	259	/* Determine if this is PRIMARY or ALTERNATE. */
	260
	261	/* Try PRIMARY card at 0xA20-0xA23 */
	262	link->io.BasePort1 = 0xA20;
	263	i = pcmcia_request_io(link->handle, &link->io);
	264	if (i != CS_SUCCESS) {
	265	/* Couldn't get 0xA20-0xA23. Try ALTERNATE at 0xA24-0xA27. */
	266	link->io.BasePort1 = 0xA24;
	267	CS_CHECK(RequestIO, pcmcia_request_io(link->handle, &link->io));
	268	}
	269	dev->base_addr = link->io.BasePort1;
	270
	271	CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
	272	dev->irq = link->irq.AssignedIRQ;
	273	ti->irq = link->irq.AssignedIRQ;
	274	ti->global_int_enable=GLOBAL_INT_ENABLE+((dev->irq==9) ? 2 : dev->irq);
	275
	276	/* Allocate the MMIO memory window */
	277	req.Attributes = WIN_DATA_WIDTH_16\|WIN_MEMORY_TYPE_CM\|WIN_ENABLE;
	278	req.Attributes \|= WIN_USE_WAIT;
	279	req.Base = 0;
280	req.Size = 0x2000;
281	req.AccessSpeed = 250;
282	CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));
283
284	mem.CardOffset = mmiobase;
285	mem.Page = 0;
286	CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
287	ti->mmio = ioremap(req.Base, req.Size);
288
289	/* Allocate the SRAM memory window */
290	req.Attributes = WIN_DATA_WIDTH_16\|WIN_MEMORY_TYPE_CM\|WIN_ENABLE;
291	req.Attributes \|= WIN_USE_WAIT;
292	req.Base = 0;
293	req.Size = sramsize * 1024;
294	req.AccessSpeed = 250;
295	CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &info->sram_win_handle));
296
297	mem.CardOffset = srambase;
298	mem.Page = 0;
299	CS_CHECK(MapMemPage, pcmcia_map_mem_page(info->sram_win_handle, &mem));
300
301	ti->sram_base = mem.CardOffset >> 12;
302	ti->sram_virt = ioremap(req.Base, req.Size);
303	ti->sram_phys = req.Base;
304
305	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
306
307	/* Set up the Token-Ring Controller Configuration Register and
308	turn on the card. Check the "Local Area Network Credit Card
309	Adapters Technical Reference" SC30-3585 for this info. */
310	ibmtr_hw_setup(dev, mmiobase);
311
312	link->dev = &info->node;
313	link->state &= ~DEV_CONFIG_PENDING;
314	SET_NETDEV_DEV(dev, &handle_to_dev(handle));
315
316	i = ibmtr_probe_card(dev);
317	if (i != 0) {
318	printk(KERN_NOTICE "ibmtr_cs: register_netdev() failed\n");
319	link->dev = NULL;
320	goto failed;
321	}
322
323	strcpy(info->node.dev_name, dev->name);
324
325	printk(KERN_INFO "%s: port %#3lx, irq %d,",
326	dev->name, dev->base_addr, dev->irq);
327	printk (" mmio %#5lx,", (u_long)ti->mmio);
328	printk (" sram %#5lx,", (u_long)ti->sram_base << 12);
329	printk ("\n" KERN_INFO " hwaddr=");
330	for (i = 0; i < TR_ALEN; i++)
331	printk("%02X", dev->dev_addr[i]);
332	printk("\n");
333	return;
334
335	cs_failed:
336	cs_error(link->handle, last_fn, last_ret);
337	failed:
338	ibmtr_release(link);
339	} /* ibmtr_config */
340
341	/*======================================================================
342
343	After a card is removed, ibmtr_release() will unregister the net
344	device, and release the PCMCIA configuration. If the device is
345	still open, this will be postponed until it is closed.
346
347	======================================================================*/
348
349	static void ibmtr_release(dev_link_t *link)
350	{
351	ibmtr_dev_t *info = link->priv;
352	struct net_device *dev = info->dev;
353
354	DEBUG(0, "ibmtr_release(0x%p)\n", link);
355
356	pcmcia_release_configuration(link->handle);
357	pcmcia_release_io(link->handle, &link->io);
358	pcmcia_release_irq(link->handle, &link->irq);
359	if (link->win) {
360	struct tok_info *ti = netdev_priv(dev);
361	iounmap(ti->mmio);
362	pcmcia_release_window(link->win);
363	pcmcia_release_window(info->sram_win_handle);
364	}
365
366	link->state &= ~DEV_CONFIG;
367	}
368
98e4c28b DB	369	static int ibmtr_suspend(struct pcmcia_device *p_dev)
	370	{
	371	dev_link_t *link = dev_to_instance(p_dev);
	372	ibmtr_dev_t *info = link->priv;
	373	struct net_device *dev = info->dev;
	374
	375	link->state \|= DEV_SUSPEND;
	376	if (link->state & DEV_CONFIG) {
	377	if (link->open)
	378	netif_device_detach(dev);
	379	pcmcia_release_configuration(link->handle);
	380	}
	381
	382	return 0;
	383	}
	384
	385	static int ibmtr_resume(struct pcmcia_device *p_dev)
	386	{
	387	dev_link_t *link = dev_to_instance(p_dev);
	388	ibmtr_dev_t *info = link->priv;
	389	struct net_device *dev = info->dev;
	390
	391	link->state &= ~DEV_SUSPEND;
	392	if (link->state & DEV_CONFIG) {
	393	pcmcia_request_configuration(link->handle, &link->conf);
	394	if (link->open) {
	395	ibmtr_probe(dev); /* really? */
	396	netif_device_attach(dev);
	397	}
	398	}
	399
	400	return 0;
	401	}
	402
	403
1da177e4 LT	404	/====================================================================/
	405
	406	static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase)
	407	{
	408	int i;
	409
	410	/* Bizarre IBM behavior, there are 16 bits of information we
	411	need to set, but the card only allows us to send 4 bits at a
	412	time. For each byte sent to base_addr, bits 7-4 tell the
	413	card which part of the 16 bits we are setting, bits 3-0 contain
	414	the actual information */
	415
	416	/* First nibble provides 4 bits of mmio */
	417	i = (mmiobase >> 16) & 0x0F;
	418	outb(i, dev->base_addr);
	419
	420	/* Second nibble provides 3 bits of mmio */
	421	i = 0x10 \| ((mmiobase >> 12) & 0x0E);
	422	outb(i, dev->base_addr);
	423
	424	/* Third nibble, hard-coded values */
	425	i = 0x26;
	426	outb(i, dev->base_addr);
	427
	428	/* Fourth nibble sets shared ram page size */
	429
	430	/* 8 = 00, 16 = 01, 32 = 10, 64 = 11 */
	431	i = (sramsize >> 4) & 0x07;
	432	i = ((i == 4) ? 3 : i) << 2;
	433	i \|= 0x30;
	434
	435	if (ringspeed == 16)
	436	i \|= 2;
	437	if (dev->base_addr == 0xA24)
	438	i \|= 1;
	439	outb(i, dev->base_addr);
	440
	441	/* 0x40 will release the card for use */
	442	outb(0x40, dev->base_addr);
	443
	444	return;
	445	}
	446
469bf2b9 DB	447	static struct pcmcia_device_id ibmtr_ids[] = {
	448	PCMCIA_DEVICE_PROD_ID12("3Com", "TokenLink Velocity PC Card", 0x41240e5b, 0x82c3734e),
	449	PCMCIA_DEVICE_PROD_ID12("IBM", "TOKEN RING", 0xb569a6e5, 0xbf8eed47),
	450	PCMCIA_DEVICE_NULL,
	451	};
	452	MODULE_DEVICE_TABLE(pcmcia, ibmtr_ids);
	453
1da177e4 LT	454	static struct pcmcia_driver ibmtr_cs_driver = {
	455	.owner = THIS_MODULE,
	456	.drv = {
	457	.name = "ibmtr_cs",
	458	},
f8cfa618	459	.probe = ibmtr_attach,
cc3b4866	460	.remove = ibmtr_detach,
469bf2b9	461	.id_table = ibmtr_ids,
98e4c28b DB	462	.suspend = ibmtr_suspend,
98e4c28b DB	463	.resume = ibmtr_resume,
1da177e4 LT	464	};
	465
	466	static int __init init_ibmtr_cs(void)
	467	{
	468	return pcmcia_register_driver(&ibmtr_cs_driver);
	469	}
	470
	471	static void __exit exit_ibmtr_cs(void)
	472	{
	473	pcmcia_unregister_driver(&ibmtr_cs_driver);
1da177e4 LT	474	}
	475
	476	module_init(init_ibmtr_cs);
	477	module_exit(exit_ibmtr_cs);