自学教程：C++ CardServices函数代码示例

static void avma1cs_detach(dev_link_t *link){    dev_link_t **linkp;    DEBUG(0, "avma1cs_detach(0x%p)/n", link);        /* Locate device structure */    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)	if (*linkp == link) break;    if (*linkp == NULL)	return;    /*       If the device is currently configured and active, we won't       actually delete it yet.  Instead, it is marked so that when       the release() function is called, that will trigger a proper       detach().    */    if (link->state & DEV_CONFIG) {#ifdef PCMCIA_DEBUG	printk(KERN_DEBUG "avma1_cs: detach postponed, '%s' "	       "still locked/n", link->dev->dev_name);#endif	link->state |= DEV_STALE_LINK;	return;    }    /* Break the link with Card Services */    if (link->handle)	CardServices(DeregisterClient, link->handle);        /* Unlink device structure, free pieces */    *linkp = link->next;    if (link->priv) {	kfree(link->priv);    }    kfree(link);    } /* avma1cs_detach */

static void mc2_detach(dev_link_t *link){  dev_link_t **linkp;  DEBUG(0, "mc2_detach(0x%p)/n", link);      /* Locate device structure */  for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)    if (*linkp == link) break;  if (*linkp == NULL)    return;  del_timer(&link->release);  if (link->state & DEV_CONFIG) {    /* try to release first */    mc2_release((u_long)link);    if (link->state & DEV_STALE_CONFIG) {      DEBUG(0, "mc2: detach postponed, '%s' "            "still locked/n", link->dev->dev_name);      link->state |= DEV_STALE_LINK;      return;    }  }      /* Break the link with Card Services */  if (link->handle)    CardServices(DeregisterClient, link->handle);      /* Unlink device structure, and free it */  *linkp = link->next;      if (link->priv) {    /* stop the device and dealloc buffers alloced in wl24_card_init() */    wl24n_card_stop(((local_info_t *)link->priv)->mc2_priv);    kfree(link->priv);  }} /* mc2_detach */

static void aha152x_detach(dev_link_t *link){    dev_link_t **linkp;    DEBUG(0, "aha152x_detach(0x%p)/n", link);        /* Locate device structure */    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)	if (*linkp == link) break;    if (*linkp == NULL)	return;    if (link->state & DEV_CONFIG)	aha152x_release_cs(link);    if (link->handle)	CardServices(DeregisterClient, link->handle);        /* Unlink device structure, free bits */    *linkp = link->next;    kfree(link->priv);    } /* aha152x_detach */

static void avmcs_config(dev_link_t *link){    client_handle_t handle;    tuple_t tuple;    cisparse_t parse;    cistpl_cftable_entry_t *cf = &parse.cftable_entry;    local_info_t *dev;    int i;    u_char buf[64];    char devname[128];    int cardtype;    int (*addcard)(unsigned int port, unsigned irq);        handle = link->handle;    dev = link->priv;    /*       This reads the card's CONFIG tuple to find its configuration       registers.    */    do {	tuple.DesiredTuple = CISTPL_CONFIG;	i = CardServices(GetFirstTuple, handle, &tuple);	if (i != CS_SUCCESS) break;	tuple.TupleData = buf;	tuple.TupleDataMax = 64;	tuple.TupleOffset = 0;	i = CardServices(GetTupleData, handle, &tuple);	if (i != CS_SUCCESS) break;	i = CardServices(ParseTuple, handle, &tuple, &parse);	if (i != CS_SUCCESS) break;	link->conf.ConfigBase = parse.config.base;    } while (0);    if (i != CS_SUCCESS) {	cs_error(link->handle, ParseTuple, i);	link->state &= ~DEV_CONFIG_PENDING;	return;    }        /* Configure card */    link->state |= DEV_CONFIG;    do {	tuple.Attributes = 0;	tuple.TupleData = buf;	tuple.TupleDataMax = 254;	tuple.TupleOffset = 0;	tuple.DesiredTuple = CISTPL_VERS_1;	devname[0] = 0;	if( !first_tuple(handle, &tuple, &parse) && parse.version_1.ns > 1 ) {	    strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1], 			sizeof(devname));	}	/*         * find IO port         */	tuple.TupleData = (cisdata_t *)buf;	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;	tuple.Attributes = 0;	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;	i = first_tuple(handle, &tuple, &parse);	while (i == CS_SUCCESS) {	    if (cf->io.nwin > 0) {		link->conf.ConfigIndex = cf->index;		link->io.BasePort1 = cf->io.win[0].base;		link->io.NumPorts1 = cf->io.win[0].len;		link->io.NumPorts2 = 0;                printk(KERN_INFO "avm_cs: testing i/o %#x-%#x/n",			link->io.BasePort1,		        link->io.BasePort1+link->io.NumPorts1-1);		i = CardServices(RequestIO, link->handle, &link->io);		if (i == CS_SUCCESS) goto found_port;	    }	    i = next_tuple(handle, &tuple, &parse);	}found_port:	if (i != CS_SUCCESS) {	    cs_error(link->handle, RequestIO, i);	    break;	}		/*	 * allocate an interrupt line	 */	i = CardServices(RequestIRQ, link->handle, &link->irq);	if (i != CS_SUCCESS) {	    cs_error(link->handle, RequestIRQ, i);	    CardServices(ReleaseIO, link->handle, &link->io);	    break;	}		/*         * configure the PCMCIA socket	  */	i = CardServices(RequestConfiguration, link->handle, &link->conf);	if (i != CS_SUCCESS) {	    cs_error(link->handle, RequestConfiguration, i);//.........这里部分代码省略.........

static dev_link_t *elsa_cs_attach(void){    client_reg_t client_reg;    dev_link_t *link;    local_info_t *local;    int ret, i;    void elsa_interrupt(int, void *, struct pt_regs *);    DEBUG(0, "elsa_cs_attach()/n");    /* Allocate space for private device-specific data */    local = kmalloc(sizeof(local_info_t), GFP_KERNEL);    if (!local) return NULL;    memset(local, 0, sizeof(local_info_t));    link = &local->link; link->priv = local;    /* Initialize the dev_link_t structure */    link->release.function = &elsa_cs_release;    link->release.data = (u_long)link;    /* Interrupt setup */    link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;    link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID|IRQ_SHARE_ID;    if (irq_list[0] == -1)        link->irq.IRQInfo2 = irq_mask;    else        for (i = 0; i < 4; i++)            link->irq.IRQInfo2 |= 1 << irq_list[i];    link->irq.Handler = NULL;    /*      General socket configuration defaults can go here.  In this      client, we assume very little, and rely on the CIS for almost      everything.  In most clients, many details (i.e., number, sizes,      and attributes of IO windows) are fixed by the nature of the      device, and can be hard-wired here.    */    link->io.NumPorts1 = 8;    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;    link->io.IOAddrLines = 3;    link->conf.Attributes = CONF_ENABLE_IRQ;    link->conf.Vcc = 50;    link->conf.IntType = INT_MEMORY_AND_IO;    /* Register with Card Services */    link->next = dev_list;    dev_list = link;    client_reg.dev_info = &dev_info;    client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;    client_reg.EventMask =        CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |        CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |        CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;    client_reg.event_handler = &elsa_cs_event;    client_reg.Version = 0x0210;    client_reg.event_callback_args.client_data = link;    ret = CardServices(RegisterClient, &link->handle, &client_reg);    if (ret != CS_SUCCESS) {        cs_error(link->handle, RegisterClient, ret);        elsa_cs_detach(link);        return NULL;    }    return link;} /* elsa_cs_attach */

static void card_settings(struct pcmciamtd_dev *dev, dev_link_t *link, int *new_name){	int rc;	tuple_t tuple;	cisparse_t parse;	u_char buf[64];	tuple.Attributes = 0;	tuple.TupleData = (cisdata_t *)buf;	tuple.TupleDataMax = sizeof(buf);	tuple.TupleOffset = 0;	tuple.DesiredTuple = RETURN_FIRST_TUPLE;	rc = CardServices(GetFirstTuple, link->handle, &tuple);	while(rc == CS_SUCCESS) {		rc = CardServices(GetTupleData, link->handle, &tuple);		if(rc != CS_SUCCESS) {			cs_error(link->handle, GetTupleData, rc);			break;		}		rc = CardServices(ParseTuple, link->handle, &tuple, &parse);		if(rc != CS_SUCCESS) {			cs_error(link->handle, ParseTuple, rc);			break;		}				switch(tuple.TupleCode) {		case  CISTPL_FORMAT: {			cistpl_format_t *t = &parse.format;			(void)t; /* Shut up, gcc */			DEBUG(2, "Format type: %u, Error Detection: %u, offset = %u, length =%u",			      t->type, t->edc, t->offset, t->length);			break;					}					case CISTPL_DEVICE: {			cistpl_device_t *t = &parse.device;			int i;			DEBUG(2, "Common memory:");			dev->pcmcia_map.size = t->dev[0].size;			for(i = 0; i < t->ndev; i++) {				DEBUG(2, "Region %d, type = %u", i, t->dev[i].type);				DEBUG(2, "Region %d, wp = %u", i, t->dev[i].wp);				DEBUG(2, "Region %d, speed = %u ns", i, t->dev[i].speed);				DEBUG(2, "Region %d, size = %u bytes", i, t->dev[i].size);			}			break;		}					case CISTPL_VERS_1: {			cistpl_vers_1_t *t = &parse.version_1;			int i;			if(t->ns) {				dev->mtd_name[0] = '/0';				for(i = 0; i < t->ns; i++) {					if(i)						strcat(dev->mtd_name, " ");					strcat(dev->mtd_name, t->str+t->ofs[i]);				}			}			DEBUG(2, "Found name: %s", dev->mtd_name);			break;		}					case CISTPL_JEDEC_C: {			cistpl_jedec_t *t = &parse.jedec;			int i;			for(i = 0; i < t->nid; i++) {				DEBUG(2, "JEDEC: 0x%02x 0x%02x", t->id[i].mfr, t->id[i].info);			}			break;		}					case CISTPL_DEVICE_GEO: {			cistpl_device_geo_t *t = &parse.device_geo;			int i;			dev->pcmcia_map.buswidth = t->geo[0].buswidth;			for(i = 0; i < t->ngeo; i++) {				DEBUG(2, "region: %d buswidth = %u", i, t->geo[i].buswidth);				DEBUG(2, "region: %d erase_block = %u", i, t->geo[i].erase_block);				DEBUG(2, "region: %d read_block = %u", i, t->geo[i].read_block);				DEBUG(2, "region: %d write_block = %u", i, t->geo[i].write_block);				DEBUG(2, "region: %d partition = %u", i, t->geo[i].partition);				DEBUG(2, "region: %d interleave = %u", i, t->geo[i].interleave);			}			break;		}					default:			DEBUG(2, "Unknown tuple code %d", tuple.TupleCode);		}				rc = CardServices(GetNextTuple, link->handle, &tuple, &parse);	}	if(!dev->pcmcia_map.size)		dev->pcmcia_map.size = MAX_PCMCIA_ADDR;	if(!dev->pcmcia_map.buswidth)		dev->pcmcia_map.buswidth = 2;//.........这里部分代码省略.........

static int bind_request(int i, bind_info_t *bind_info){    struct driver_info_t *driver;    socket_bind_t *b;    bind_req_t bind_req;    socket_info_t *s = &socket_table[i];    int ret;    DEBUG(2, "bind_request(%d, '%s')/n", i,	  (char *)bind_info->dev_info);    for (driver = root_driver; driver; driver = driver->next)	if (strcmp((char *)driver->dev_info,		   (char *)bind_info->dev_info) == 0)	    break;    if (driver == NULL) {	driver = kmalloc(sizeof(driver_info_t), GFP_KERNEL);	if (!driver) return -ENOMEM;	strncpy(driver->dev_info, bind_info->dev_info, DEV_NAME_LEN);	driver->use_count = 0;	driver->next = root_driver;	driver->attach = NULL; driver->detach = NULL;	root_driver = driver;    }    for (b = s->bind; b; b = b->next)	if ((driver == b->driver) &&	    (bind_info->function == b->function))	    break;    if (b != NULL) {	bind_info->instance = b->instance;	return -EBUSY;    }    b = kmalloc(sizeof(socket_bind_t), GFP_KERNEL);    if (!b)	return -ENOMEM;    bind_req.Socket = i;    bind_req.Function = bind_info->function;    bind_req.dev_info = &driver->dev_info;    ret = CardServices(BindDevice, &bind_req);    if (ret != CS_SUCCESS) {	cs_error(NULL, BindDevice, ret);	printk(KERN_NOTICE "ds: unable to bind '%s' to socket %d/n",	       (char *)dev_info, i);	kfree(b);	return -ENODEV;    }    /* Add binding to list for this socket */    driver->use_count++;    b->driver = driver;    b->function = bind_info->function;    b->instance = NULL;    b->next = s->bind;    s->bind = b;        if (driver->attach) {	b->instance = driver->attach();	if (b->instance == NULL) {	    printk(KERN_NOTICE "ds: unable to create instance "		   "of '%s'!/n", (char *)bind_info->dev_info);	    return -ENODEV;	}    }        return 0;} /* bind_request */

int __init init_pcmcia_ds(void){    client_reg_t client_reg;    servinfo_t serv;    bind_req_t bind;    socket_info_t *s;    int i, ret;        DEBUG(0, "%s/n", version);        CardServices(GetCardServicesInfo, &serv);    if (serv.Revision != CS_RELEASE_CODE) {	printk(KERN_NOTICE "ds: Card Services release does not match!/n");	return -1;    }    if (serv.Count == 0) {	printk(KERN_NOTICE "ds: no socket drivers loaded!/n");	return -1;    }        sockets = serv.Count;    socket_table = kmalloc(sockets*sizeof(socket_info_t), GFP_KERNEL);    if (!socket_table) return -1;    for (i = 0, s = socket_table; i < sockets; i++, s++) {	s->state = 0;	s->user = NULL;	s->req_pending = 0;	init_waitqueue_head(&s->queue);	init_waitqueue_head(&s->request);	s->handle = NULL;	init_timer(&s->removal);	s->removal.data = i;	s->removal.function = &handle_removal;	s->bind = NULL;    }        /* Set up hotline to Card Services */    client_reg.dev_info = bind.dev_info = &dev_info;    client_reg.Attributes = INFO_MASTER_CLIENT;    client_reg.EventMask =	CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |	CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |	CS_EVENT_EJECTION_REQUEST | CS_EVENT_INSERTION_REQUEST |        CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;    client_reg.event_handler = &ds_event;    client_reg.Version = 0x0210;    for (i = 0; i < sockets; i++) {	bind.Socket = i;	bind.Function = BIND_FN_ALL;	ret = CardServices(BindDevice, &bind);	if (ret != CS_SUCCESS) {	    cs_error(NULL, BindDevice, ret);	    break;	}	client_reg.event_callback_args.client_data = &socket_table[i];	ret = CardServices(RegisterClient, &socket_table[i].handle,			   &client_reg);	if (ret != CS_SUCCESS) {	    cs_error(NULL, RegisterClient, ret);	    break;	}    }        /* Set up character device for user mode clients */    i = register_chrdev(0, "pcmcia", &ds_fops);    if (i == -EBUSY)	printk(KERN_NOTICE "unable to find a free device # for "	       "Driver Services/n");    else	major_dev = i;    register_symtab(&ds_symtab);#ifdef HAS_PROC_BUS    if (proc_pccard)	create_proc_read_entry("drivers", 0, proc_pccard,			       proc_read_drivers, NULL);    init_status = 0;#endif    return 0;}

void ide_config(dev_link_t *link){    client_handle_t handle = link->handle;    ide_info_t *info = link->priv;    tuple_t tuple;    u_short buf[128];    cisparse_t parse;    config_info_t conf;    cistpl_cftable_entry_t *cfg = &parse.cftable_entry;    cistpl_cftable_entry_t dflt = { 0 };    int i, pass, last_ret, last_fn, hd, is_kme = 0;    unsigned long io_base, ctl_base;    DEBUG(0, "ide_config(0x%p)/n", link);        tuple.TupleData = (cisdata_t *)buf;    tuple.TupleOffset = 0; tuple.TupleDataMax = 255;    tuple.Attributes = 0;    tuple.DesiredTuple = CISTPL_CONFIG;    CS_CHECK(GetFirstTuple, handle, &tuple);    CS_CHECK(GetTupleData, handle, &tuple);    CS_CHECK(ParseTuple, handle, &tuple, &parse);    link->conf.ConfigBase = parse.config.base;    link->conf.Present = parse.config.rmask[0];    tuple.DesiredTuple = CISTPL_MANFID;    if (!CardServices(GetFirstTuple, handle, &tuple) &&	!CardServices(GetTupleData, handle, &tuple) &&	!CardServices(ParseTuple, handle, &tuple, &parse))	is_kme = ((parse.manfid.manf == MANFID_KME) &&		  ((parse.manfid.card == PRODID_KME_KXLC005_A) ||		   (parse.manfid.card == PRODID_KME_KXLC005_B)));    /* Configure card */    link->state |= DEV_CONFIG;    /* Not sure if this is right... look up the current Vcc */    CS_CHECK(GetConfigurationInfo, handle, &conf);    link->conf.Vcc = conf.Vcc;        pass = io_base = ctl_base = 0;    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;    tuple.Attributes = 0;    CS_CHECK(GetFirstTuple, handle, &tuple);    while (1) {	CFG_CHECK(GetTupleData, handle, &tuple);	CFG_CHECK(ParseTuple, handle, &tuple, &parse);	/* Check for matching Vcc, unless we're desperate */	if (!pass) {	    if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {		if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)		    goto next_entry;	    } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {		if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000)		    goto next_entry;	    }	}		if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))	    link->conf.Vpp1 = link->conf.Vpp2 =		cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;	else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))	    link->conf.Vpp1 = link->conf.Vpp2 =		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;	    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;		CFG_CHECK(RequestIO, link->handle, &link->io);		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;		CFG_CHECK(RequestIO, link->handle, &link->io);		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) dflt = *cfg;	if (pass) {	    CS_CHECK(GetNextTuple, handle, &tuple);	} else if (CardServices(GetNextTuple, handle, &tuple) != 0) {	    CS_CHECK(GetFirstTuple, handle, &tuple);	    memset(&dflt, 0, sizeof(dflt));	    pass++;	}//.........这里部分代码省略.........

/* * bcm47xx_pcmcia_driver_init() * * This routine performs a basic sanity check to ensure that this * kernel has been built with the appropriate board-specific low-level * PCMCIA support, performs low-level PCMCIA initialization, registers * this socket driver with Card Services, and then spawns the daemon * thread which is the real workhorse of the socket driver. * * Please see linux/Documentation/arm/SA1100/PCMCIA for more information * on the low-level kernel interface. * * Returns: 0 on success, -1 on error */static int __init bcm47xx_pcmcia_driver_init(void){	servinfo_t info;	struct pcmcia_init pcmcia_init;	struct pcmcia_state state;	unsigned int i;	unsigned long tmp;	printk("/nBCM47XX PCMCIA (CS release %s)/n", CS_RELEASE);	CardServices(GetCardServicesInfo, &info);	if (info.Revision != CS_RELEASE_CODE) {		printk(KERN_ERR "Card Services release codes do not match/n");		return -1;	}#ifdef CONFIG_BCM4710	pcmcia_low_level=&bcm4710_pcmcia_ops;#else#error Unsupported Broadcom BCM47XX board.#endif	pcmcia_init.handler=bcm47xx_pcmcia_interrupt;	if ((socket_count = pcmcia_low_level->init(&pcmcia_init)) < 0) {		printk(KERN_ERR "Unable to initialize PCMCIA service./n");		return -EIO;	} else {		printk("/t%d PCMCIA sockets initialized./n", socket_count);	}	pcmcia_socket = 		kmalloc(sizeof(struct bcm47xx_pcmcia_socket) * socket_count, 				GFP_KERNEL);	memset(pcmcia_socket, 0, 			sizeof(struct bcm47xx_pcmcia_socket) * socket_count);	if (!pcmcia_socket) {		printk(KERN_ERR "Card Services can't get memory /n");		return -1;	}				for (i = 0; i < socket_count; i++) {		if (pcmcia_low_level->socket_state(i, &state) < 0) {			printk(KERN_ERR "Unable to get PCMCIA status/n");			return -EIO;		}		pcmcia_socket[i].k_state = state;		pcmcia_socket[i].cs_state.csc_mask = SS_DETECT;				if (i == 0) {			pcmcia_socket[i].virt_io =				(unsigned long)ioremap_nocache(EXTIF_PCMCIA_IOBASE(BCM4710_EXTIF), 0x1000);			/* Substract ioport base which gets added by in/out */			pcmcia_socket[i].virt_io -= mips_io_port_base;			pcmcia_socket[i].phys_attr =				(unsigned long)EXTIF_PCMCIA_CFGBASE(BCM4710_EXTIF);			pcmcia_socket[i].phys_mem =				(unsigned long)EXTIF_PCMCIA_MEMBASE(BCM4710_EXTIF);		} else  {			printk(KERN_ERR "bcm4710: socket 1 not supported/n");			return 1;		}	}	/* Only advertise as many sockets as we can detect: */	if (register_ss_entry(socket_count, &bcm47xx_pcmcia_operations) < 0) {		printk(KERN_ERR "Unable to register socket service routine/n");		return -ENXIO;	}	/* Start the event poll timer.  	 * It will reschedule by itself afterwards. 	 */	bcm47xx_pcmcia_poll_event(0);	DEBUG(1, "bcm4710: initialization complete/n");	return 0;}

/* sa1100_pcmcia_driver_init() * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ * * This routine performs a basic sanity check to ensure that this * kernel has been built with the appropriate board-specific low-level * PCMCIA support, performs low-level PCMCIA initialization, registers * this socket driver with Card Services, and then spawns the daemon * thread which is the real workhorse of the socket driver. * * Returns: 0 on success, -1 on error */static int __init sa1100_pcmcia_driver_init(void){  servinfo_t info;  struct pcmcia_init pcmcia_init;  struct pcmcia_state state[SA1100_PCMCIA_MAX_SOCK];  struct pcmcia_state_array state_array;  unsigned int i, clock;  unsigned long mecr;  int ret;  printk(KERN_INFO "SA-1100 PCMCIA (CS release %s)/n", CS_RELEASE);  CardServices(GetCardServicesInfo, &info);  if (info.Revision != CS_RELEASE_CODE) {    printk(KERN_ERR "Card Services release codes do not match/n");    return -EINVAL;  }  ret = sa1100_pcmcia_machine_init();  if (ret)    return ret;  pcmcia_init.handler = sa1100_pcmcia_interrupt;  ret = pcmcia_low_level->init(&pcmcia_init);  if (ret < 0) {    printk(KERN_ERR "Unable to initialize kernel PCMCIA service (%d)./n", ret);    return ret == -1 ? -EIO : ret;  }  sa1100_pcmcia_socket_count = ret;  state_array.size  = sa1100_pcmcia_socket_count;  state_array.state = state;  memset(state, 0, sizeof(state));  if (pcmcia_low_level->socket_state(&state_array) < 0) {    pcmcia_low_level->shutdown();    printk(KERN_ERR "Unable to get PCMCIA status from kernel./n");    return -EIO;  }  /*   * We initialize the MECR to default values here, because we are   * not guaranteed to see a SetIOMap operation at runtime.   */  mecr = MECR;  clock = cpufreq_get(0);  for (i = 0; i < sa1100_pcmcia_socket_count; i++) {    struct sa1100_pcmcia_socket *skt = PCMCIA_SOCKET(i);    struct pcmcia_irq_info irq_info;    if (!request_mem_region(_PCMCIA(i), PCMCIASp, "PCMCIA")) {      ret = -EBUSY;      goto out_err;    }    irq_info.sock = i;    irq_info.irq  = -1;    ret = pcmcia_low_level->get_irq_info(&irq_info);    if (ret < 0)      printk(KERN_ERR "Unable to get IRQ for socket %u (%d)/n", i, ret);    skt->irq        = irq_info.irq;    skt->k_state    = state[i];    skt->speed_io   = SA1100_PCMCIA_IO_ACCESS;    skt->speed_attr = SA1100_PCMCIA_5V_MEM_ACCESS;    skt->speed_mem  = SA1100_PCMCIA_5V_MEM_ACCESS;    skt->phys_attr  = _PCMCIAAttr(i);    skt->phys_mem   = _PCMCIAMem(i);    skt->virt_io    = ioremap(_PCMCIAIO(i), 0x10000);    if (skt->virt_io == NULL) {      ret = -ENOMEM;      goto out_err;    }    MECR_FAST_SET(mecr, i, 0);    MECR_BSIO_SET(mecr, i, sa1100_pcmcia_mecr_bs(skt->speed_io, clock));    MECR_BSA_SET(mecr, i, sa1100_pcmcia_mecr_bs(skt->speed_attr, clock));    MECR_BSM_SET(mecr, i, sa1100_pcmcia_mecr_bs(skt->speed_mem, clock));  }  MECR = mecr;#ifdef CONFIG_CPU_FREQ//.........这里部分代码省略.........

static void pcmciamtd_config(dev_link_t *link){	struct pcmciamtd_dev *dev = link->priv;	struct mtd_info *mtd = NULL;	cs_status_t status;	win_req_t req;	int last_ret = 0, last_fn = 0;	int ret;	int i;	config_info_t t;	static char *probes[] = { "jedec_probe", "cfi_probe" };	cisinfo_t cisinfo;	int new_name = 0;	DEBUG(3, "link=0x%p", link);	/* Configure card */	link->state |= DEV_CONFIG;	DEBUG(2, "Validating CIS");	ret = CardServices(ValidateCIS, link->handle, &cisinfo);	if(ret != CS_SUCCESS) {		cs_error(link->handle, GetTupleData, ret);	} else {		DEBUG(2, "ValidateCIS found %d chains", cisinfo.Chains);	}	card_settings(dev, link, &new_name);	dev->pcmcia_map.read8 = pcmcia_read8_remap;	dev->pcmcia_map.read16 = pcmcia_read16_remap;	dev->pcmcia_map.copy_from = pcmcia_copy_from_remap;	dev->pcmcia_map.write8 = pcmcia_write8_remap;	dev->pcmcia_map.write16 = pcmcia_write16_remap;	dev->pcmcia_map.copy_to = pcmcia_copy_to_remap;	if(setvpp == 1)		dev->pcmcia_map.set_vpp = pcmciamtd_set_vpp;	/* Request a memory window for PCMCIA. Some architeures can map windows upto the maximum	   that PCMCIA can support (64Mb) - this is ideal and we aim for a window the size of the	   whole card - otherwise we try smaller windows until we succeed */	req.Attributes =  WIN_MEMORY_TYPE_CM | WIN_ENABLE;	req.Attributes |= (dev->pcmcia_map.buswidth == 1) ? WIN_DATA_WIDTH_8 : WIN_DATA_WIDTH_16;	req.Base = 0;	req.AccessSpeed = mem_speed;	link->win = (window_handle_t)link->handle;	req.Size = (force_size) ? force_size << 20 : MAX_PCMCIA_ADDR;	dev->win_size = 0;	do {		int ret;		DEBUG(2, "requesting window with size = %dKB memspeed = %d",		      req.Size >> 10, req.AccessSpeed);		link->win = (window_handle_t)link->handle;		ret = CardServices(RequestWindow, &link->win, &req);		DEBUG(2, "ret = %d dev->win_size = %d", ret, dev->win_size);		if(ret) {			req.Size >>= 1;		} else {			DEBUG(2, "Got window of size %dKB", req.Size >> 10);			dev->win_size = req.Size;			break;		}	} while(req.Size >= 0x1000);

static int __init au1000_pcmcia_driver_init(void){	servinfo_t info;	struct pcmcia_init pcmcia_init;	struct pcmcia_state state;	unsigned int i;	printk("/nAu1x00 PCMCIA (CS release %s)/n", CS_RELEASE);#ifndef CONFIG_64BIT_PHYS_ADDR	printk(KERN_ERR "Au1x00 PCMCIA 36 bit IO support not enabled/n");	return -1;#endif	CardServices(GetCardServicesInfo, &info);	if(info.Revision!=CS_RELEASE_CODE){		printk(KERN_ERR "Card Services release codes do not match/n");		return -1;	}#if defined(CONFIG_MIPS_PB1000) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_PB1500)	pcmcia_low_level=&pb1x00_pcmcia_ops;#elif defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100) || defined(CONFIG_MIPS_DB1500)	pcmcia_low_level=&db1x00_pcmcia_ops;#elif defined(CONFIG_MIPS_XXS1500)	pcmcia_low_level=&xxs1500_pcmcia_ops;#else#error Unsupported AU1000 board.#endif	pcmcia_init.handler=au1000_pcmcia_interrupt;	if((socket_count=pcmcia_low_level->init(&pcmcia_init))<0) {		printk(KERN_ERR "Unable to initialize PCMCIA service./n");		return -EIO;	}	/* NOTE: the chip select must already be setup */	pcmcia_socket = 		kmalloc(sizeof(struct au1000_pcmcia_socket) * socket_count, 				GFP_KERNEL);	if (!pcmcia_socket) {		printk(KERN_ERR "Card Services can't get memory /n");		return -1;	}	memset(pcmcia_socket, 0,			sizeof(struct au1000_pcmcia_socket) * socket_count);				/* 	 * Assuming max of 2 sockets, which the Au1000 supports.	 * WARNING: the Pb1000 has two sockets, and both work, but you	 * can't use them both at the same time due to glue logic conflicts.	 */	for(i=0; i < socket_count; i++) {		if(pcmcia_low_level->socket_state(i, &state)<0){			printk(KERN_ERR "Unable to get PCMCIA status/n");			return -EIO;		}		pcmcia_socket[i].k_state=state;		pcmcia_socket[i].cs_state.csc_mask=SS_DETECT;				/*		 * PCMCIA drivers use the inb/outb macros to access the		 * IO registers. Since mips_io_port_base is added to the		 * access address, we need to subtract it here.		 */		if (i == 0) {			pcmcia_socket[i].virt_io = 				(u32)ioremap((ioaddr_t)AU1X_SOCK0_IO, 0x1000) -				mips_io_port_base;			pcmcia_socket[i].phys_attr = 				(ioaddr_t)AU1X_SOCK0_PHYS_ATTR;			pcmcia_socket[i].phys_mem = 				(ioaddr_t)AU1X_SOCK0_PHYS_MEM;		}#ifndef CONFIG_MIPS_XXS1500		else  {			pcmcia_socket[i].virt_io = 				(u32)ioremap((ioaddr_t)AU1X_SOCK1_IO, 0x1000) -				mips_io_port_base;			pcmcia_socket[i].phys_attr = 				(ioaddr_t)AU1X_SOCK1_PHYS_ATTR;			pcmcia_socket[i].phys_mem = 				(ioaddr_t)AU1X_SOCK1_PHYS_MEM;		}#endif	}	/* Only advertise as many sockets as we can detect: */	if(register_ss_entry(socket_count, &au1000_pcmcia_operations)<0){		printk(KERN_ERR "Unable to register socket service routine/n");		return -ENXIO;	}	/* Start the event poll timer.  	 * It will reschedule by itself afterwards. 	 */	au1000_pcmcia_poll_event(0);//.........这里部分代码省略.........

static int __init au1000_pcmcia_driver_init(void){	servinfo_t info;	struct pcmcia_init pcmcia_init;	struct pcmcia_state state;	unsigned int i;	unsigned long timing3;	printk("/nAu1x00 PCMCIA (CS release %s)/n", CS_RELEASE);	CardServices(GetCardServicesInfo, &info);	if(info.Revision!=CS_RELEASE_CODE){		printk(KERN_ERR "Card Services release codes do not match/n");		return -1;	}#ifdef CONFIG_MIPS_PB1000	pcmcia_low_level=&pb1000_pcmcia_ops;#elif defined(CONFIG_MIPS_PB1500)	pcmcia_low_level=&pb1500_pcmcia_ops;#else#error Unsupported AU1000 board.#endif	pcmcia_init.handler=au1000_pcmcia_interrupt;	if((socket_count=pcmcia_low_level->init(&pcmcia_init))<0) {		printk(KERN_ERR "Unable to initialize PCMCIA service./n");		return -EIO;	}	/* setup the static bus controller */	timing3 = 0x100e3a07;	writel(0x00000002, MEM_STCFG3);  /* type = PCMCIA */	writel(timing3, MEM_STTIME3); 	writel(0x10000000, MEM_STADDR3); /* any PCMCIA select */	au_sync_delay(1);	pcmcia_socket = 		kmalloc(sizeof(struct au1000_pcmcia_socket) * socket_count, 				GFP_KERNEL);	if (!pcmcia_socket) {		printk(KERN_ERR "Card Services can't get memory /n");		return -1;	}	memset(pcmcia_socket, 0,			sizeof(struct au1000_pcmcia_socket) * socket_count);				for(i=0; i < socket_count; i++) {		if(pcmcia_low_level->socket_state(i, &state)<0){			printk(KERN_ERR "Unable to get PCMCIA status/n");			return -EIO;		}		pcmcia_socket[i].k_state=state;		pcmcia_socket[i].cs_state.csc_mask=SS_DETECT;				if (i == 0) {			pcmcia_socket[i].virt_io = 				(u32)ioremap(0xC0000000, 0x1000);			pcmcia_socket[i].phys_attr = 0xC4000000;			pcmcia_socket[i].phys_mem = 0xC8000000;		}		else  {			printk(KERN_ERR "au1000: socket 1 not supported/n");			return 1;		}	}	/* Only advertise as many sockets as we can detect: */	if(register_ss_entry(socket_count, &au1000_pcmcia_operations)<0){		printk(KERN_ERR "Unable to register socket service routine/n");		return -ENXIO;	}	/* Start the event poll timer.  	 * It will reschedule by itself afterwards. 	 */	au1000_pcmcia_poll_event(0);	DEBUG(1, "au1000: initialization complete/n");	return 0;}  /* au1000_pcmcia_driver_init() */

static int ds_ioctl(struct inode * inode, struct file * file,		    u_int cmd, u_long arg){    socket_t i = MINOR(inode->i_rdev);    socket_info_t *s;    u_int size;    int ret, err;    ds_ioctl_arg_t buf;    DEBUG(2, "ds_ioctl(socket %d, %#x, %#lx)/n", i, cmd, arg);        if ((i >= sockets) || (sockets == 0))	return -ENODEV;    s = &socket_table[i];        size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;    if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;    /* Permission check */    if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))	return -EPERM;	    if (cmd & IOC_IN) {	err = verify_area(VERIFY_READ, (char *)arg, size);	if (err) {	    DEBUG(3, "ds_ioctl(): verify_read = %d/n", err);	    return err;	}    }    if (cmd & IOC_OUT) {	err = verify_area(VERIFY_WRITE, (char *)arg, size);	if (err) {	    DEBUG(3, "ds_ioctl(): verify_write = %d/n", err);	    return err;	}    }        err = ret = 0;        if (cmd & IOC_IN) copy_from_user((char *)&buf, (char *)arg, size);        switch (cmd) {    case DS_ADJUST_RESOURCE_INFO:	ret = CardServices(AdjustResourceInfo, s->handle, &buf.adjust);	break;    case DS_GET_CARD_SERVICES_INFO:	ret = CardServices(GetCardServicesInfo, &buf.servinfo);	break;    case DS_GET_CONFIGURATION_INFO:	ret = CardServices(GetConfigurationInfo, s->handle, &buf.config);	break;    case DS_GET_FIRST_TUPLE:	ret = CardServices(GetFirstTuple, s->handle, &buf.tuple);	break;    case DS_GET_NEXT_TUPLE:	ret = CardServices(GetNextTuple, s->handle, &buf.tuple);	break;    case DS_GET_TUPLE_DATA:	buf.tuple.TupleData = buf.tuple_parse.data;	buf.tuple.TupleDataMax = sizeof(buf.tuple_parse.data);	ret = CardServices(GetTupleData, s->handle, &buf.tuple);	break;    case DS_PARSE_TUPLE:	buf.tuple.TupleData = buf.tuple_parse.data;	ret = CardServices(ParseTuple, s->handle, &buf.tuple,			   &buf.tuple_parse.parse);	break;    case DS_RESET_CARD:	ret = CardServices(ResetCard, s->handle, NULL);	break;    case DS_GET_STATUS:	ret = CardServices(GetStatus, s->handle, &buf.status);	break;    case DS_VALIDATE_CIS:	ret = CardServices(ValidateCIS, s->handle, &buf.cisinfo);	break;    case DS_SUSPEND_CARD:	ret = CardServices(SuspendCard, s->handle, NULL);	break;    case DS_RESUME_CARD:	ret = CardServices(ResumeCard, s->handle, NULL);	break;    case DS_EJECT_CARD:	ret = CardServices(EjectCard, s->handle, NULL);	break;    case DS_INSERT_CARD:	ret = CardServices(InsertCard, s->handle, NULL);	break;    case DS_ACCESS_CONFIGURATION_REGISTER:	if ((buf.conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN))	    return -EPERM;	ret = CardServices(AccessConfigurationRegister, s->handle,			   &buf.conf_reg);	break;    case DS_GET_FIRST_REGION:        ret = CardServices(GetFirstRegion, s->handle, &buf.region);	break;    case DS_GET_NEXT_REGION:	ret = CardServices(GetNextRegion, s->handle, &buf.region);	break;//.........这里部分代码省略.........

static dev_link_t *atmel_attach(void){	client_reg_t client_reg;	dev_link_t *link;	local_info_t *local;	int ret, i;		DEBUG(0, "atmel_attach()/n");	/* Initialize the dev_link_t structure */	link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);	if (!link) {		printk(KERN_ERR "atmel_cs: no memory for new device/n");		return NULL;	}	memset(link, 0, sizeof(struct dev_link_t));		/* Interrupt setup */	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;	link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;	if (irq_list[0] == -1)		link->irq.IRQInfo2 = irq_mask;	else		for (i = 0; i < 4; i++)			link->irq.IRQInfo2 |= 1 << irq_list[i];	link->irq.Handler = NULL;		/*	  General socket configuration defaults can go here.  In this	  client, we assume very little, and rely on the CIS for almost	  everything.  In most clients, many details (i.e., number, sizes,	  and attributes of IO windows) are fixed by the nature of the	  device, and can be hard-wired here.	*/	link->conf.Attributes = 0;	link->conf.Vcc = 50;	link->conf.IntType = INT_MEMORY_AND_IO;		/* Allocate space for private device-specific data */	local = kmalloc(sizeof(local_info_t), GFP_KERNEL);	if (!local) {		printk(KERN_ERR "atmel_cs: no memory for new device/n");		kfree (link);		return NULL;	}	memset(local, 0, sizeof(local_info_t));	link->priv = local;		/* Register with Card Services */	link->next = dev_list;	dev_list = link;	client_reg.dev_info = &dev_info;	client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;	client_reg.EventMask =		CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |		CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |		CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;	client_reg.event_handler = &atmel_event;	client_reg.Version = 0x0210;	client_reg.event_callback_args.client_data = link;	ret = CardServices(RegisterClient, &link->handle, &client_reg);	if (ret != 0) {		cs_error(link->handle, RegisterClient, ret);		atmel_detach(link);		return NULL;	}		return link;} /* atmel_attach */

static void cs_error(client_handle_t handle, int func, int ret){    error_info_t err = { func, ret};    CardServices(ReportError, handle, &err);}

static dev_link_t *avmcs_attach(void){    client_reg_t client_reg;    dev_link_t *link;    local_info_t *local;    int ret, i;        /* Initialize the dev_link_t structure */    link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);    if (!link)        goto err;    memset(link, 0, sizeof(struct dev_link_t));    /* The io structure describes IO port mapping */    link->io.NumPorts1 = 16;    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;    link->io.NumPorts2 = 0;    /* Interrupt setup */    link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;    link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;    link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;    if (irq_list[0] != -1) {	    for (i = 0; i < 10 && irq_list[i] > 0; i++)	       link->irq.IRQInfo2 |= 1 << irq_list[i];    } else {	    for (i = 0; i < 10 && default_irq_list[i] > 0; i++)	       link->irq.IRQInfo2 |= 1 << default_irq_list[i];    }        /* General socket configuration */    link->conf.Attributes = CONF_ENABLE_IRQ;    link->conf.Vcc = 50;    link->conf.IntType = INT_MEMORY_AND_IO;    link->conf.ConfigIndex = 1;    link->conf.Present = PRESENT_OPTION;    /* Allocate space for private device-specific data */    local = kmalloc(sizeof(local_info_t), GFP_KERNEL);    if (!local)        goto err_kfree;    memset(local, 0, sizeof(local_info_t));    link->priv = local;        /* Register with Card Services */    link->next = dev_list;    dev_list = link;    client_reg.dev_info = &dev_info;    client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;    client_reg.EventMask =	CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |	CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |	CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;    client_reg.event_handler = &avmcs_event;    client_reg.Version = 0x0210;    client_reg.event_callback_args.client_data = link;    ret = CardServices(RegisterClient, &link->handle, &client_reg);    if (ret != 0) {	cs_error(link->handle, RegisterClient, ret);	avmcs_detach(link);	goto err;    }    return link; err_kfree:    kfree(link); err:    return NULL;} /* avmcs_attach */

static void elsa_cs_config(dev_link_t *link){    client_handle_t handle;    tuple_t tuple;    cisparse_t parse;    local_info_t *dev;    int i, j, last_fn;    u_short buf[128];    cistpl_cftable_entry_t *cf = &parse.cftable_entry;    DEBUG(0, "elsa_config(0x%p)/n", link);    handle = link->handle;    dev = link->priv;    /*       This reads the card's CONFIG tuple to find its configuration       registers.    */    tuple.DesiredTuple = CISTPL_CONFIG;    tuple.TupleData = (cisdata_t *)buf;    tuple.TupleDataMax = 255;    tuple.TupleOffset = 0;    tuple.Attributes = 0;    i = first_tuple(handle, &tuple, &parse);    if (i != CS_SUCCESS) {        last_fn = ParseTuple;	goto cs_failed;    }    link->conf.ConfigBase = parse.config.base;    link->conf.Present = parse.config.rmask[0];    /* Configure card */    link->state |= DEV_CONFIG;    tuple.TupleData = (cisdata_t *)buf;    tuple.TupleOffset = 0; tuple.TupleDataMax = 255;    tuple.Attributes = 0;    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;    i = first_tuple(handle, &tuple, &parse);    while (i == CS_SUCCESS) {        if ( (cf->io.nwin > 0) && cf->io.win[0].base) {            printk(KERN_INFO "(elsa_cs: looks like the 96 model)/n");            link->conf.ConfigIndex = cf->index;            link->io.BasePort1 = cf->io.win[0].base;            i = CardServices(RequestIO, link->handle, &link->io);            if (i == CS_SUCCESS) break;        } else {          printk(KERN_INFO "(elsa_cs: looks like the 97 model)/n");          link->conf.ConfigIndex = cf->index;          for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {            link->io.BasePort1 = j;            i = CardServices(RequestIO, link->handle, &link->io);            if (i == CS_SUCCESS) break;          }          break;        }        i = next_tuple(handle, &tuple, &parse);    }    if (i != CS_SUCCESS) {	last_fn = RequestIO;	goto cs_failed;    }    i = CardServices(RequestIRQ, link->handle, &link->irq);    if (i != CS_SUCCESS) {        link->irq.AssignedIRQ = 0;	last_fn = RequestIRQ;        goto cs_failed;    }    i = CardServices(RequestConfiguration, link->handle, &link->conf);    if (i != CS_SUCCESS) {      last_fn = RequestConfiguration;      goto cs_failed;    }    /* At this point, the dev_node_t structure(s) should be       initialized and arranged in a linked list at link->dev. *//*  */    sprintf(dev->node.dev_name, "elsa");    dev->node.major = dev->node.minor = 0x0;    link->dev = &dev->node;    /* Finally, report what we've done */    printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",           dev->node.dev_name, link->conf.ConfigIndex,           link->conf.Vcc/10, link->conf.Vcc%10);    if (link->conf.Vpp1)        printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);    if (link->conf.Attributes & CONF_ENABLE_IRQ)        printk(", irq %d", link->irq.AssignedIRQ);    if (link->io.NumPorts1)        printk(", io 0x%04x-0x%04x", link->io.BasePort1,               link->io.BasePort1+link->io.NumPorts1-1);    if (link->io.NumPorts2)        printk(" & 0x%04x-0x%04x", link->io.BasePort2,               link->io.BasePort2+link->io.NumPorts2-1);    printk("/n");//.........这里部分代码省略.........

static void atmel_config(dev_link_t *link){	client_handle_t handle;	tuple_t tuple;	cisparse_t parse;	local_info_t *dev;	int last_fn, last_ret;	u_char buf[64];	int card_index = -1, done = 0;		handle = link->handle;	dev = link->priv;	DEBUG(0, "atmel_config(0x%p)/n", link);		tuple.Attributes = 0;	tuple.TupleData = buf;	tuple.TupleDataMax = sizeof(buf);	tuple.TupleOffset = 0;		tuple.DesiredTuple = CISTPL_MANFID;	if (CardServices(GetFirstTuple, handle, &tuple) == 0) {		int i;		cistpl_manfid_t *manfid;		CS_CHECK(GetTupleData, handle, &tuple);		CS_CHECK(ParseTuple, handle, &tuple, &parse);		manfid = &(parse.manfid);		for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) {			if (!card_table[i].ver1 &&			    manfid->manf == card_table[i].manf &&			    manfid->card == card_table[i].card) {				card_index = i;				done = 1;			}		}	}	tuple.DesiredTuple = CISTPL_VERS_1;	if (!done && (CardServices(GetFirstTuple, handle, &tuple) == 0)) {		int i, j, k;		cistpl_vers_1_t *ver1;		CS_CHECK(GetTupleData, handle, &tuple);		CS_CHECK(ParseTuple, handle, &tuple, &parse);		ver1 = &(parse.version_1);				for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) {			for (j = 0; j < ver1->ns; j++) {				char *p = card_table[i].ver1;				char *q = &ver1->str[ver1->ofs[j]];				if (!p)					goto mismatch;				for (k = 0; k < j; k++) {					while ((*p != '/0') && (*p != '/')) p++;					if (*p == '/0') {						if (*q != '/0')							goto mismatch;					} else {						p++;					}				}				while((*q != '/0') && (*p != '/0') && 				      (*p != '/') && (*p == *q)) p++, q++;				if (((*p != '/0') && *p != '/') || *q != '/0')					goto mismatch;			}			card_index = i;			break;	/* done */					mismatch:			j = 0; /* dummy stmt to shut up compiler */		}	}			/*	  This reads the card's CONFIG tuple to find its configuration	  registers.	*/	tuple.DesiredTuple = CISTPL_CONFIG;	CS_CHECK(GetFirstTuple, handle, &tuple);	CS_CHECK(GetTupleData, handle, &tuple);	CS_CHECK(ParseTuple, handle, &tuple, &parse);	link->conf.ConfigBase = parse.config.base;	link->conf.Present = parse.config.rmask[0];		/* Configure card */	link->state |= DEV_CONFIG;		/*	  In this loop, we scan the CIS for configuration table entries,	  each of which describes a valid card configuration, including	  voltage, IO window, memory window, and interrupt settings.	  	  We make no assumptions about the card to be configured: we use	  just the information available in the CIS.  In an ideal world,	  this would work for any PCMCIA card, but it requires a complete	  and accurate CIS.  In practice, a driver usually "knows" most of	  these things without consulting the CIS, and most client drivers	  will only use the CIS to fill in implementation-defined details.	*/	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;//.........这里部分代码省略.........

/* pxa_pcmcia_driver_init() * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ * * This routine performs a basic sanity check to ensure that this * kernel has been built with the appropriate board-specific low-level * PCMCIA support, performs low-level PCMCIA initialization, registers * this socket driver with Card Services, and then spawns the daemon * thread which is the real workhorse of the socket driver. * * Please see linux/Documentation/arm/SA1100/PCMCIA for more information * on the low-level kernel interface. * * Returns: 0 on success, -1 on error */static int __init pxa_pcmcia_driver_init(void){  servinfo_t info;  struct pcmcia_init pcmcia_init;  struct pcmcia_state state[PXA_PCMCIA_MAX_SOCK];  struct pcmcia_state_array state_array;  unsigned int i, clock;  unsigned long mecr;  printk(KERN_INFO "Intel PXA250/210 PCMCIA (CS release %s)/n", CS_RELEASE);  CardServices(GetCardServicesInfo, &info);  if(info.Revision!=CS_RELEASE_CODE){    printk(KERN_ERR "Card Services release codes do not match/n");    return -1;  }  /* Setup GPIOs for PCMCIA/CF alternate function mode.   *   * It would be nice if set_GPIO_mode included support   * for driving GPIO outputs to default high/low state   * before programming GPIOs as outputs. Setting GPIO   * outputs to default high/low state via GPSR/GPCR   * before defining them as outputs should reduce   * the possibility of glitching outputs during GPIO   * setup. This of course assumes external terminators   * are present to hold GPIOs in a defined state.   *   * In the meantime, setup default state of GPIO   * outputs before we enable them as outputs.   */  GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |                      GPIO_bit(GPIO49_nPWE) |                      GPIO_bit(GPIO50_nPIOR) |                      GPIO_bit(GPIO51_nPIOW) |                      GPIO_bit(GPIO52_nPCE_1) |                      GPIO_bit(GPIO53_nPCE_2);  set_GPIO_mode(GPIO48_nPOE_MD);  set_GPIO_mode(GPIO49_nPWE_MD);  set_GPIO_mode(GPIO50_nPIOR_MD);  set_GPIO_mode(GPIO51_nPIOW_MD);  set_GPIO_mode(GPIO52_nPCE_1_MD);  set_GPIO_mode(GPIO53_nPCE_2_MD);  set_GPIO_mode(GPIO54_pSKTSEL_MD); /* REVISIT: s/b dependent on num sockets */  set_GPIO_mode(GPIO55_nPREG_MD);  set_GPIO_mode(GPIO56_nPWAIT_MD);  set_GPIO_mode(GPIO57_nIOIS16_MD);  if(machine_is_lubbock()){#ifdef CONFIG_ARCH_LUBBOCK    pcmcia_low_level=&lubbock_pcmcia_ops;#endif  } else if (machine_is_pxa_idp()) {    pcmcia_low_level=&pxa_idp_pcmcia_ops;  } else if( machine_is_pxa_cerf()){    pcmcia_low_level=&cerf_pcmcia_ops;  }  if (!pcmcia_low_level) {    printk(KERN_ERR "This hardware is not supported by the PXA250/210 Card Service driver/n");    return -ENODEV;  }  pcmcia_init.handler=pxa_pcmcia_interrupt;  if((pxa_pcmcia_socket_count=pcmcia_low_level->init(&pcmcia_init))<0){    printk(KERN_ERR "Unable to initialize kernel PCMCIA service./n");    return -EIO;  }  state_array.size=pxa_pcmcia_socket_count;  state_array.state=state;  /* Configure MECR based on the number of sockets present. */  if (pxa_pcmcia_socket_count == 2) {    MECR |= GPIO_bit(0);  } else {    MECR &= ~GPIO_bit(0);  }  if(pcmcia_low_level->socket_state(&state_array)<0){    printk(KERN_ERR "Unable to get PCMCIA status from kernel./n");    return -EIO;//.........这里部分代码省略.........

static status_t ds_ioctl(void *cookie, uint32 cmd, void *arg, size_t len){	/*socket_info_t *s = (socket_info_t *) cookie;    u_int size = IOCPARM_LEN(cmd);    status_t ret, err;    ds_ioctl_arg_t buf;        if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;    	err = ret = 0;        if (cmd & IOC_IN) copy_from_user((char *)&buf, (char *)arg, size);        switch (cmd) {    case DS_ADJUST_RESOURCE_INFO:	ret = CardServices(AdjustResourceInfo, s->handle, &buf.adjust);	break;    case DS_GET_CARD_SERVICES_INFO:	ret = CardServices(GetCardServicesInfo, &buf.servinfo);	break;    case DS_GET_CONFIGURATION_INFO:	ret = CardServices(GetConfigurationInfo, s->handle, &buf.config);	break;    case DS_GET_FIRST_TUPLE:	ret = CardServices(GetFirstTuple, s->handle, &buf.tuple);	break;    case DS_GET_NEXT_TUPLE:	ret = CardServices(GetNextTuple, s->handle, &buf.tuple);	break;    case DS_GET_TUPLE_DATA:	buf.tuple.TupleData = buf.tuple_parse.data;	buf.tuple.TupleDataMax = sizeof(buf.tuple_parse.data);	ret = CardServices(GetTupleData, s->handle, &buf.tuple);	break;    case DS_PARSE_TUPLE:	buf.tuple.TupleData = buf.tuple_parse.data;	ret = CardServices(ParseTuple, s->handle, &buf.tuple,			   &buf.tuple_parse.parse);	break;    case DS_RESET_CARD:	ret = CardServices(ResetCard, s->handle, NULL);	break;    case DS_GET_STATUS:	ret = CardServices(GetStatus, s->handle, &buf.status);	break;    case DS_VALIDATE_CIS:	ret = CardServices(ValidateCIS, s->handle, &buf.cisinfo);	break;    case DS_SUSPEND_CARD:	ret = CardServices(SuspendCard, s->handle, NULL);	break;    case DS_RESUME_CARD:	ret = CardServices(ResumeCard, s->handle, NULL);	break;    case DS_EJECT_CARD:	ret = CardServices(EjectCard, s->handle, NULL);	break;    case DS_INSERT_CARD:	ret = CardServices(InsertCard, s->handle, NULL);	break;    case DS_ACCESS_CONFIGURATION_REGISTER:	if ((buf.conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN))	    return -EPERM;	ret = CardServices(AccessConfigurationRegister, s->handle,			   &buf.conf_reg);	break;    case DS_GET_FIRST_REGION:        ret = CardServices(GetFirstRegion, s->handle, &buf.region);	break;    case DS_GET_NEXT_REGION:	ret = CardServices(GetNextRegion, s->handle, &buf.region);	break;    case DS_GET_FIRST_WINDOW:	buf.win_info.handle = (window_handle_t)s->handle;	ret = CardServices(GetFirstWindow, &buf.win_info.handle,			   &buf.win_info.window);	break;    case DS_GET_NEXT_WINDOW:	ret = CardServices(GetNextWindow, &buf.win_info.handle,			   &buf.win_info.window);	break;    case DS_GET_MEM_PAGE:	ret = CardServices(GetMemPage, buf.win_info.handle,			   &buf.win_info.map);	break;    case DS_REPLACE_CIS:	ret = CardServices(ReplaceCIS, s->handle, &buf.cisdump);	break;	*/	client_handle_t h = (client_handle_t) cookie;    u_int size = IOCPARM_LEN(cmd);    status_t ret, err;    ds_ioctl_arg_t buf;        if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;    	err = ret = 0;	    if (cmd & IOC_IN) copy_from_user((char *)&buf, (char *)arg, size);//.........这里部分代码省略.........