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 int __init
init_orinoco_cs(void)
{
servinfo_t serv;
TRACE_ENTER("orinoco");
printk(KERN_DEBUG "%s\n", version);
CardServices(GetCardServicesInfo, &serv);
if (serv.Revision != CS_RELEASE_CODE) {
printk(KERN_NOTICE "orinoco_cs: Card Services release "
"does not match!\n");
return -1;
}
register_pccard_driver(&dev_info, &orinoco_cs_attach, &orinoco_cs_detach);
TRACE_EXIT("orinoco");
return 0;
}
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 */
/* allocate local data and register with CardServices
* initialize dev_link structure, but do not configure the card yet */
static dev_link_t *prism2_attach(void)
{
dev_link_t *link;
local_info_t *local;
client_reg_t client_reg;
int ret;
struct net_device *dev;
struct hostap_interface *iface;
for (link = dev_list; link; link = link->next) {
if (link->state & DEV_STALE_LINK) {
printk("%s: flushing stale link\n", dev_info);
prism2_detach(link);
}
}
link = kmalloc(sizeof(dev_link_t), GFP_KERNEL);
if (link == NULL)
return NULL;
memset(link, 0, sizeof(dev_link_t));
dev = prism2_init_local_data(&prism2_pccard_funcs, 0);
if (dev == NULL) {
kfree(link);
return NULL;
}
iface = dev->priv;
local = iface->local;
link->priv = dev;
local->link = link;
#ifdef HOSTAP_USE_RELEASE_TIMER
init_timer(&link->release);
link->release.function = &prism2_release;
link->release.data = (u_long)link;
#endif /* HOSTAP_USE_RELEASE_TIMER */
PDEBUG(DEBUG_HW, "%s: setting Vcc=33 (constant)\n", dev_info);
link->conf.Vcc = 33;
link->conf.IntType = INT_MEMORY_AND_IO;
/* register with CardServices */
link->next = dev_list;
dev_list = link;
client_reg.dev_info = &dev_info;
client_reg.Attributes = INFO_IO_CLIENT;
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 = &prism2_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);
prism2_detach(link);
return NULL;
}
return link;
}
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);
CardServices(ReleaseIO, link->handle, &link->io);
CardServices(ReleaseIRQ, link->handle, &link->irq);
break;
}
} while (0);
/* At this point, the dev_node_t structure(s) should be
initialized and arranged in a linked list at link->dev. */
if (devname[0]) {
char *s = strrchr(devname, ' ');
if (!s)
s = devname;
else s++;
strcpy(dev->node.dev_name, s);
if (strcmp("M1", s) == 0) {
cardtype = AVM_CARDTYPE_M1;
} else if (strcmp("M2", s) == 0) {
cardtype = AVM_CARDTYPE_M2;
} else {
cardtype = AVM_CARDTYPE_B1;
}
} else {
strcpy(dev->node.dev_name, "b1");
cardtype = AVM_CARDTYPE_B1;
}
dev->node.major = 64;
dev->node.minor = 0;
link->dev = &dev->node;
link->state &= ~DEV_CONFIG_PENDING;
/* If any step failed, release any partially configured state */
if (i != 0) {
avmcs_release(link);
return;
}
switch (cardtype) {
case AVM_CARDTYPE_M1: addcard = b1pcmcia_addcard_m1; break;
case AVM_CARDTYPE_M2: addcard = b1pcmcia_addcard_m2; break;
default:
case AVM_CARDTYPE_B1: addcard = b1pcmcia_addcard_b1; break;
}
if ((i = (*addcard)(link->io.BasePort1, link->irq.AssignedIRQ)) < 0) {
printk(KERN_ERR "avm_cs: failed to add AVM-%s-Controller at i/o %#x, irq %d\n",
dev->node.dev_name, link->io.BasePort1, link->irq.AssignedIRQ);
avmcs_release(link);
return;
}
dev->node.minor = i;
} /* avmcs_config */
static void prism2_pccard_genesis_reset(local_info_t *local, int hcr)
{
int res;
conf_reg_t reg;
int old_cor;
if (!prism2_pccard_card_present(local))
return;
reg.Function = 0;
reg.Action = CS_READ;
reg.Offset = CISREG_COR;
reg.Value = 0;
res = CardServices(AccessConfigurationRegister, local->link->handle,
®);
if (res != CS_SUCCESS) {
printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 1 "
"(%d)\n", res);
return;
}
printk(KERN_DEBUG "prism2_pccard_genesis_sreset: original COR %02x\n",
reg.Value);
old_cor = reg.Value;
reg.Action = CS_WRITE;
reg.Value |= COR_SOFT_RESET;
res = CardServices(AccessConfigurationRegister, local->link->handle,
®);
if (res != CS_SUCCESS) {
printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 2 "
"(%d)\n", res);
return;
}
mdelay(10);
/* Setup Genesis mode */
reg.Action = CS_WRITE;
reg.Value = hcr;
reg.Offset = CISREG_CCSR;
res = CardServices(AccessConfigurationRegister, local->link->handle,
®);
if (res != CS_SUCCESS) {
printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 3 "
"(%d)\n", res);
return;
}
mdelay(10);
reg.Action = CS_WRITE;
reg.Offset = CISREG_COR;
reg.Value = old_cor & ~COR_SOFT_RESET;
res = CardServices(AccessConfigurationRegister, local->link->handle,
®);
if (res != CS_SUCCESS) {
printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 4 "
"(%d)\n", res);
return;
}
mdelay(10);
}
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;
if(force_size) {
dev->pcmcia_map.size = force_size << 20;
DEBUG(2, "size forced to %dM", force_size);
}
if(buswidth) {
dev->pcmcia_map.buswidth = buswidth;
DEBUG(2, "buswidth forced to %d", buswidth);
}
dev->pcmcia_map.name = dev->mtd_name;
if(!dev->mtd_name[0]) {
strcpy(dev->mtd_name, "PCMCIA Memory card");
*new_name = 1;
}
DEBUG(1, "Device: Size: %lu Width:%d Name: %s",
dev->pcmcia_map.size, dev->pcmcia_map.buswidth << 3, dev->mtd_name);
}
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;
}
static dev_link_t *
orinoco_cs_attach(void)
{
struct orinoco_pccard *card;
struct orinoco_private *priv;
dev_link_t *link;
struct net_device *ndev;
client_reg_t client_reg;
int ret, i;
TRACE_ENTER("orinoco");
/* A bit of cleanup */
flush_stale_links();
/* Allocate space for private device-specific data */
card = kmalloc(sizeof(*card), GFP_KERNEL);
if (! card) {
link = NULL;
goto out;
}
memset(card, 0, sizeof(*card));
/* Link both structure together */
priv = &(card->priv);
priv->card = card;
link = &card->link;
ndev = &priv->ndev;
link->priv = priv;
/* Initialize the dev_link_t structure */
link->release.function = &orinoco_cs_release;
link->release.data = (u_long) link;
/* 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.IntType = INT_MEMORY_AND_IO;
/* Setup the common part */
if(orinoco_setup(priv) < 0) {
kfree(card);
return NULL;
}
/* Overrides */
ndev->open = orinoco_cs_open;
ndev->stop = orinoco_cs_stop;
priv->card_reset_handler = orinoco_cs_cor_reset;
/* 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 = &orinoco_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);
orinoco_cs_detach(link);
link = NULL;
goto out;
}
out:
TRACE_EXIT("orinoco");
return link;
} /* orinoco_cs_attach */
static void
orinoco_cs_config(dev_link_t * link)
{
client_handle_t handle = link->handle;
struct orinoco_private *priv = link->priv;
struct orinoco_pccard *card = (struct orinoco_pccard *)priv->card;
hermes_t *hw = &priv->hw;
struct net_device *ndev = &priv->ndev;
tuple_t tuple;
cisparse_t parse;
int last_fn, last_ret;
u_char buf[64];
config_info_t conf;
cistpl_cftable_entry_t dflt = { 0 };
cisinfo_t info;
TRACE_ENTER("orinoco");
CS_CHECK(ValidateCIS, handle, &info);
/*
This reads the card's CONFIG tuple to find its configuration
registers.
*/
tuple.DesiredTuple = CISTPL_CONFIG;
tuple.Attributes = 0;
tuple.TupleData = buf;
tuple.TupleDataMax = sizeof(buf);
tuple.TupleOffset = 0;
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;
/* Look up the current Vcc */
CS_CHECK(GetConfigurationInfo, handle, &conf);
link->conf.Vcc = conf.Vcc;
DEBUG(0, "orinoco_cs_config: ConfigBase = 0x%x link->conf.Vcc = %d\n",
link->conf.ConfigBase, link->conf.Vcc);
/*
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;
CS_CHECK(GetFirstTuple, handle, &tuple);
while (1) {
cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
CFG_CHECK(GetTupleData, handle, &tuple);
CFG_CHECK(ParseTuple, handle, &tuple, &parse);
DEBUG(0, "orinoco_cs_config: index = 0x%x, flags = 0x%x\n",
cfg->index, cfg->flags);
if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
dflt = *cfg;
if (cfg->index == 0)
goto next_entry;
link->conf.ConfigIndex = cfg->index;
/* Does this card need audio output? */
if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
link->conf.Attributes |= CONF_ENABLE_SPKR;
link->conf.Status = CCSR_AUDIO_ENA;
}
/* Use power settings for Vcc and Vpp if present */
/* Note that the CIS values need to be rescaled */
if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
if (conf.Vcc !=
cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
DEBUG(2, "orinoco_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
if(!ignore_cis_vcc)
goto next_entry;
}
} else if (dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
if (conf.Vcc !=
dflt.vcc.param[CISTPL_POWER_VNOM] / 10000) {
DEBUG(2, "orinoco_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, dflt.vcc.param[CISTPL_POWER_VNOM] / 10000);
if(!ignore_cis_vcc)
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;
DEBUG(0, "orinoco_cs_config: We seem to have configured Vcc and Vpp\n");
/* Do we need to allocate an interrupt? */
if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
link->conf.Attributes |= CONF_ENABLE_IRQ;
/* IO window settings */
link->io.NumPorts1 = link->io.NumPorts2 = 0;
if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
cistpl_io_t *io =
(cfg->io.nwin) ? &cfg->io : &dflt.io;
link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
if (!(io->flags & CISTPL_IO_8BIT))
link->io.Attributes1 =
IO_DATA_PATH_WIDTH_16;
if (!(io->flags & CISTPL_IO_16BIT))
link->io.Attributes1 =
IO_DATA_PATH_WIDTH_8;
link->io.IOAddrLines =
io->flags & CISTPL_IO_LINES_MASK;
link->io.BasePort1 = io->win[0].base;
link->io.NumPorts1 = io->win[0].len;
if (io->nwin > 1) {
link->io.Attributes2 =
link->io.Attributes1;
link->io.BasePort2 = io->win[1].base;
link->io.NumPorts2 = io->win[1].len;
}
/* This reserves IO space but doesn't actually enable it */
CFG_CHECK(RequestIO, link->handle, &link->io);
}
/* If we got this far, we're cool! */
break;
next_entry:
if (link->io.NumPorts1)
CardServices(ReleaseIO, link->handle, &link->io);
CS_CHECK(GetNextTuple, handle, &tuple);
}
/*
Allocate an interrupt line. Note that this does not assign a
handler to the interrupt, unless the 'Handler' member of the
irq structure is initialized.
*/
if (link->conf.Attributes & CONF_ENABLE_IRQ) {
int i;
link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
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 = orinoco_interrupt;
link->irq.Instance = priv;
CS_CHECK(RequestIRQ, link->handle, &link->irq);
}
/* We initialize the hermes structure before completing PCMCIA
configuration just in case the interrupt handler gets
called. */
hermes_struct_init(hw, link->io.BasePort1);
/*
This actually configures the PCMCIA socket -- setting up
the I/O windows and the interrupt mapping, and putting the
card and host interface into "Memory and IO" mode.
*/
CS_CHECK(RequestConfiguration, link->handle, &link->conf);
ndev->base_addr = link->io.BasePort1;
ndev->irq = link->irq.AssignedIRQ;
/* register_netdev will give us an ethX name */
ndev->name[0] = '\0';
/* Tell the stack we exist */
if (register_netdev(ndev) != 0) {
printk(KERN_ERR "orinoco_cs: register_netdev() failed\n");
goto failed;
}
strcpy(card->node.dev_name, ndev->name);
/* Finally, report what we've done */
printk(KERN_DEBUG "%s: index 0x%02x: Vcc %d.%d",
ndev->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");
/* And give us the proc nodes for debugging */
if (orinoco_proc_dev_init(priv) != 0) {
printk(KERN_ERR "orinoco_cs: Failed to create /proc node for %s\n",
ndev->name);
goto failed;
}
/* Note to myself : this replace MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT */
SET_MODULE_OWNER(ndev);
/* Allow cor_reset, /proc & ioctls to act */
priv->hw_ready = 1;
/* Do a Pcmcia soft reset of the card (optional) */
if(reset_cor)
orinoco_cs_cor_reset(priv);
/*
At this point, the dev_node_t structure(s) need to be
initialized and arranged in a linked list at link->dev.
*/
card->node.major = card->node.minor = 0;
link->dev = &card->node;
link->state &= ~DEV_CONFIG_PENDING;
TRACE_EXIT("orinoco");
return;
cs_failed:
cs_error(link->handle, last_fn, last_ret);
failed:
orinoco_cs_release((u_long) link);
TRACE_EXIT("orinoco");
} /* orinoco_cs_config */
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++;
}
}
CS_CHECK(RequestIRQ, handle, &link->irq);
CS_CHECK(RequestConfiguration, handle, &link->conf);
/* deal with brain dead IDE resource management */
release_region(link->io.BasePort1, link->io.NumPorts1);
if (link->io.NumPorts2)
release_region(link->io.BasePort2, link->io.NumPorts2);
/* disable drive interrupts during IDE probe */
outb(0x02, ctl_base);
/* special setup for KXLC005 card */
if (is_kme) outb(0x81, ctl_base+1);
/* retry registration in case device is still spinning up */
for (hd = -1, i = 0; i < 10; i++) {
hd = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ);
if (hd >= 0) break;
if (link->io.NumPorts1 == 0x20) {
outb(0x02, ctl_base+0x10);
hd = idecs_register(io_base+0x10, ctl_base+0x10,
link->irq.AssignedIRQ);
if (hd >= 0) {
io_base += 0x10; ctl_base += 0x10;
break;
}
}
__set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(HZ/10);
}
if (hd < 0) {
printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx"
", irq %u failed\n", io_base, ctl_base,
link->irq.AssignedIRQ);
goto failed;
}
MOD_INC_USE_COUNT;
info->ndev = 1;
sprintf(info->node.dev_name, "hd%c", 'a'+(hd*2));
info->node.major = ide_major[hd];
info->node.minor = 0;
info->hd = hd;
link->dev = &info->node;
printk(KERN_INFO "ide-cs: %s: Vcc = %d.%d, Vpp = %d.%d\n",
info->node.dev_name, link->conf.Vcc/10, link->conf.Vcc%10,
link->conf.Vpp1/10, link->conf.Vpp1%10);
link->state &= ~DEV_CONFIG_PENDING;
return;
cs_failed:
cs_error(link->handle, last_fn, last_ret);
failed:
ide_release(link);
link->state &= ~DEV_CONFIG_PENDING;
} /* ide_config */
/*
* 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
ret = cpufreq_register_notifier(&sa1100_pcmcia_notifier_block);
if (ret < 0) {
printk(KERN_ERR "Unable to register CPU frequency change notifier (%d)\n", ret);
goto out_err;
}
#endif
/* Only advertise as many sockets as we can detect */
ret = register_ss_entry(sa1100_pcmcia_socket_count,
&sa1100_pcmcia_operations);
if (ret < 0) {
printk(KERN_ERR "Unable to register sockets\n");
goto out_err;
}
/*
* Start the event poll timer. It will reschedule by itself afterwards.
*/
sa1100_pcmcia_poll_event(0);
return 0;
out_err:
for (i = 0; i < sa1100_pcmcia_socket_count; i++) {
iounmap(sa1100_pcmcia_socket[i].virt_io);
release_mem_region(_PCMCIA(i), PCMCIASp);
}
pcmcia_low_level->shutdown();
return ret;
} /* sa1100_pcmcia_driver_init() */
/* 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.
*
* 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 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;
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 -1;
}
if(machine_is_assabet()){
#ifdef CONFIG_SA1100_ASSABET
if(machine_has_neponset()){
#ifdef CONFIG_ASSABET_NEPONSET
pcmcia_low_level=&neponset_pcmcia_ops;
#else
printk(KERN_ERR "Card Services disabled: missing Neponset support\n");
return -1;
#endif
}else{
pcmcia_low_level=&assabet_pcmcia_ops;
}
#endif
} else if (machine_is_freebird()) {
#ifdef CONFIG_SA1100_FREEBIRD
pcmcia_low_level = &freebird_pcmcia_ops;
#endif
} else if (machine_is_h3xxx()) {
#ifdef CONFIG_SA1100_H3XXX
pcmcia_low_level = &h3600_pcmcia_ops;
#endif
} else if (machine_is_cerf()) {
#ifdef CONFIG_SA1100_CERF
pcmcia_low_level = &cerf_pcmcia_ops;
#endif
} else if (machine_is_graphicsclient()) {
#ifdef CONFIG_SA1100_GRAPHICSCLIENT
pcmcia_low_level = &gcplus_pcmcia_ops;
#endif
} else if (machine_is_xp860()) {
#ifdef CONFIG_SA1100_XP860
pcmcia_low_level = &xp860_pcmcia_ops;
#endif
} else if (machine_is_yopy()) {
#ifdef CONFIG_SA1100_YOPY
pcmcia_low_level = &yopy_pcmcia_ops;
#endif
} else if (machine_is_shannon()) {
#ifdef CONFIG_SA1100_SHANNON
pcmcia_low_level = &shannon_pcmcia_ops;
#endif
} else if (machine_is_pangolin()) {
#ifdef CONFIG_SA1100_PANGOLIN
pcmcia_low_level = &pangolin_pcmcia_ops;
#endif
} else if (machine_is_jornada720()) {
#ifdef CONFIG_SA1100_JORNADA720
pcmcia_low_level = &jornada720_pcmcia_ops;
#endif
} else if(machine_is_pfs168()){
#ifdef CONFIG_SA1100_PFS168
pcmcia_low_level=&pfs168_pcmcia_ops;
#endif
} else if(machine_is_flexanet()){
#ifdef CONFIG_SA1100_FLEXANET
pcmcia_low_level=&flexanet_pcmcia_ops;
#endif
} else if(machine_is_simpad()){
#ifdef CONFIG_SA1100_SIMPAD
pcmcia_low_level=&simpad_pcmcia_ops;
#endif
} else if(machine_is_graphicsmaster()) {
#ifdef CONFIG_SA1100_GRAPHICSMASTER
pcmcia_low_level=&graphicsmaster_pcmcia_ops;
#endif
} else if(machine_is_adsbitsy()) {
#ifdef CONFIG_SA1100_ADSBITSY
pcmcia_low_level=&adsbitsy_pcmcia_ops;
#endif
} else if(machine_is_stork()) {
#ifdef CONFIG_SA1100_STORK
pcmcia_low_level=&stork_pcmcia_ops;
#endif
}
if (!pcmcia_low_level) {
printk(KERN_ERR "This hardware is not supported by the SA1100 Card Service driver\n");
return -ENODEV;
}
pcmcia_init.handler=sa1100_pcmcia_interrupt;
if((sa1100_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=sa1100_pcmcia_socket_count;
state_array.state=state;
if(pcmcia_low_level->socket_state(&state_array)<0){
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=0;
clock = cpufreq_get(0);
for(i=0; i<sa1100_pcmcia_socket_count; ++i){
sa1100_pcmcia_socket[i].k_state=state[i];
/* This is an interim fix. Apparently, SetSocket is no longer
* called to initialize each socket (prior to the first detect
* event). For now, we'll just manually set up the mask.
*/
sa1100_pcmcia_socket[i].cs_state.csc_mask=SS_DETECT;
sa1100_pcmcia_socket[i].virt_io=(i==0)?PCMCIA_IO_0_BASE:PCMCIA_IO_1_BASE;
sa1100_pcmcia_socket[i].phys_attr=_PCMCIAAttr(i);
sa1100_pcmcia_socket[i].phys_mem=_PCMCIAMem(i);
MECR_FAST_SET(mecr, i, 0);
MECR_BSIO_SET(mecr, i,
sa1100_pcmcia_mecr_bs(SA1100_PCMCIA_IO_ACCESS, clock));
MECR_BSA_SET(mecr, i,
sa1100_pcmcia_mecr_bs(SA1100_PCMCIA_5V_MEM_ACCESS, clock));
MECR_BSM_SET(mecr, i,
sa1100_pcmcia_mecr_bs(SA1100_PCMCIA_5V_MEM_ACCESS, clock));
sa1100_pcmcia_socket[i].speed_io=SA1100_PCMCIA_IO_ACCESS;
sa1100_pcmcia_socket[i].speed_attr=SA1100_PCMCIA_5V_MEM_ACCESS;
sa1100_pcmcia_socket[i].speed_mem=SA1100_PCMCIA_5V_MEM_ACCESS;
}
MECR=mecr;
#ifdef CONFIG_CPU_FREQ
if(cpufreq_register_notifier(&sa1100_pcmcia_notifier_block) < 0){
printk(KERN_ERR "Unable to register CPU frequency change notifier\n");
return -ENXIO;
}
#endif
/* Only advertise as many sockets as we can detect: */
if(register_ss_entry(sa1100_pcmcia_socket_count,
&sa1100_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. */
sa1100_pcmcia_poll_event(0);
DEBUG(1, "sa1100: initialization complete\n");
return 0;
} /* sa1100_pcmcia_driver_init() */
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 prism2_event(event_t event, int priority,
event_callback_args_t *args)
{
dev_link_t *link = args->client_data;
struct net_device *dev = (struct net_device *) link->priv;
switch (event) {
case CS_EVENT_CARD_INSERTION:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_INSERTION\n", dev_info);
link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
if (prism2_config(link))
dev->irq = 0;
break;
case CS_EVENT_CARD_REMOVAL:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_REMOVAL\n", dev_info);
link->state &= ~DEV_PRESENT;
if (link->state & DEV_CONFIG) {
hostap_netif_stop_queues(dev);
netif_device_detach(dev);
#ifdef HOSTAP_USE_RELEASE_TIMER
mod_timer(&link->release, jiffies + HZ / 20);
#else /* HOSTAP_USE_RELEASE_TIMER */
prism2_release((u_long) link);
#endif /* HOSTAP_USE_RELEASE_TIMER */
}
break;
case CS_EVENT_PM_SUSPEND:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_SUSPEND\n", dev_info);
link->state |= DEV_SUSPEND;
/* fall through */
case CS_EVENT_RESET_PHYSICAL:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_RESET_PHYSICAL\n", dev_info);
if (link->state & DEV_CONFIG) {
if (link->open) {
hostap_netif_stop_queues(dev);
netif_device_detach(dev);
}
CardServices(ReleaseConfiguration, link->handle);
}
break;
case CS_EVENT_PM_RESUME:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_RESUME\n", dev_info);
link->state &= ~DEV_SUSPEND;
/* fall through */
case CS_EVENT_CARD_RESET:
PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_RESET\n", dev_info);
if (link->state & DEV_CONFIG) {
CardServices(RequestConfiguration, link->handle,
&link->conf);
if (link->open) {
prism2_hw_shutdown(dev, 1);
prism2_hw_config(dev, 0);
netif_device_attach(dev);
netif_start_queue(dev);
}
}
break;
default:
PDEBUG(DEBUG_EXTRA, "%s: prism2_event() - unknown event %d\n",
dev_info, event);
break;
}
return 0;
}
static int
orinoco_cs_event(event_t event, int priority,
event_callback_args_t * args)
{
dev_link_t *link = args->client_data;
struct orinoco_private *priv = (struct orinoco_private *)link->priv;
struct net_device *dev = &priv->ndev;
TRACE_ENTER("orinoco");
switch (event) {
case CS_EVENT_CARD_REMOVAL:
/* FIXME: Erg.. this whole hw_ready thing looks racy
to me. this may not be fixable without changin the
PCMCIA subsystem, though */
priv->hw_ready = 0;
orinoco_shutdown(priv);
link->state &= ~DEV_PRESENT;
if (link->state & DEV_CONFIG) {
netif_stop_queue(dev);
netif_device_detach(dev);
mod_timer(&link->release, jiffies + HZ / 20);
}
break;
case CS_EVENT_CARD_INSERTION:
link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
orinoco_cs_config(link);
break;
case CS_EVENT_PM_SUSPEND:
link->state |= DEV_SUSPEND;
/* Fall through... */
case CS_EVENT_RESET_PHYSICAL:
orinoco_shutdown(priv);
/* Mark the device as stopped, to block IO until later */
if (link->state & DEV_CONFIG) {
if (link->open) {
netif_stop_queue(dev);
netif_device_detach(dev);
}
CardServices(ReleaseConfiguration, link->handle);
}
break;
case CS_EVENT_PM_RESUME:
link->state &= ~DEV_SUSPEND;
/* Fall through... */
case CS_EVENT_CARD_RESET:
if (link->state & DEV_CONFIG) {
CardServices(RequestConfiguration, link->handle,
&link->conf);
if (link->open) {
if (orinoco_reset(priv) == 0) {
netif_device_attach(dev);
netif_start_queue(dev);
} else {
printk(KERN_ERR "%s: Error resetting device on PCMCIA event\n",
dev->name);
orinoco_cs_stop(dev);
}
}
}
/*
In a normal driver, additional code may go here to restore
the device state and restart IO.
*/
break;
}
TRACE_EXIT("orinoco");
return 0;
} /* orinoco_cs_event */
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);
DEBUG(1, "au1000: initialization complete\n");
return 0;
} /* au1000_pcmcia_driver_init() */
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;
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;
case DS_BIND_REQUEST:
if (!capable(CAP_SYS_ADMIN)) return -EPERM;
err = bind_request(i, &buf.bind_info);
break;
case DS_GET_DEVICE_INFO:
err = get_device_info(i, &buf.bind_info, 1);
break;
case DS_GET_NEXT_DEVICE:
err = get_device_info(i, &buf.bind_info, 0);
break;
case DS_UNBIND_REQUEST:
err = unbind_request(i, &buf.bind_info);
break;
case DS_BIND_MTD:
if (!capable(CAP_SYS_ADMIN)) return -EPERM;
err = bind_mtd(i, &buf.mtd_info);
break;
default:
err = -EINVAL;
}
if ((err == 0) && (ret != CS_SUCCESS)) {
DEBUG(2, "ds_ioctl: ret = %d\n", ret);
switch (ret) {
case CS_BAD_SOCKET: case CS_NO_CARD:
err = -ENODEV; break;
case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
case CS_BAD_TUPLE:
err = -EINVAL; break;
case CS_IN_USE:
err = -EBUSY; break;
case CS_OUT_OF_RESOURCE:
err = -ENOSPC; break;
case CS_NO_MORE_ITEMS:
err = -ENODATA; break;
case CS_UNSUPPORTED_FUNCTION:
err = -ENOSYS; break;
default:
err = -EIO; break;
}
}
if (cmd & IOC_OUT) copy_to_user((char *)arg, (char *)&buf, size);
return err;
} /* ds_ioctl */
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");
link->state &= ~DEV_CONFIG_PENDING;
elsa_init_pcmcia(link->io.BasePort1, link->irq.AssignedIRQ,
&(((local_info_t*)link->priv)->busy),
protocol);
return;
cs_failed:
cs_error(link->handle, last_fn, i);
elsa_cs_release((u_long)link);
} /* elsa_cs_config */
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;
CS_CHECK(GetFirstTuple, handle, &tuple);
while (1) {
cistpl_cftable_entry_t dflt = { 0 };
cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
CFG_CHECK(GetTupleData, handle, &tuple);
CFG_CHECK(ParseTuple, handle, &tuple, &parse);
if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
if (cfg->index == 0) goto next_entry;
link->conf.ConfigIndex = cfg->index;
/* Does this card need audio output? */
if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
link->conf.Attributes |= CONF_ENABLE_SPKR;
link->conf.Status = CCSR_AUDIO_ENA;
}
/* Use power settings for Vcc and Vpp if present */
/* Note that the CIS values need to be rescaled */
if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM))
link->conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000;
else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM))
link->conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000;
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;
/* Do we need to allocate an interrupt? */
if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
link->conf.Attributes |= CONF_ENABLE_IRQ;
/* IO window settings */
link->io.NumPorts1 = link->io.NumPorts2 = 0;
if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
if (!(io->flags & CISTPL_IO_8BIT))
link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
if (!(io->flags & CISTPL_IO_16BIT))
link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
link->io.BasePort1 = io->win[0].base;
link->io.NumPorts1 = io->win[0].len;
if (io->nwin > 1) {
link->io.Attributes2 = link->io.Attributes1;
link->io.BasePort2 = io->win[1].base;
link->io.NumPorts2 = io->win[1].len;
}
}
/* This reserves IO space but doesn't actually enable it */
CFG_CHECK(RequestIO, link->handle, &link->io);
/* If we got this far, we're cool! */
break;
next_entry:
CS_CHECK(GetNextTuple, handle, &tuple);
}
/*
Allocate an interrupt line. Note that this does not assign a
handler to the interrupt, unless the 'Handler' member of the
irq structure is initialized.
*/
if (link->conf.Attributes & CONF_ENABLE_IRQ)
CS_CHECK(RequestIRQ, link->handle, &link->irq);
/*
This actually configures the PCMCIA socket -- setting up
the I/O windows and the interrupt mapping, and putting the
card and host interface into "Memory and IO" mode.
*/
CS_CHECK(RequestConfiguration, link->handle, &link->conf);
if (link->irq.AssignedIRQ == 0) {
printk(KERN_ALERT
"atmel: cannot assign IRQ: check that CONFIG_ISA is set in kernel config.");
goto cs_failed;
}
((local_info_t*)link->priv)->eth_dev =
init_atmel_card(link->irq.AssignedIRQ,
link->io.BasePort1,
card_index == -1 ? NULL : card_table[card_index].firmware,
card_index == -1 ? 0 : (card_table[card_index].manf == MANFID_3COM),
&atmel_device,
card_present,
link);
if (!((local_info_t*)link->priv)->eth_dev)
goto cs_failed;
/*
At this point, the dev_node_t structure(s) need to be
initialized and arranged in a linked list at link->dev.
*/
strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
dev->node.major = dev->node.minor = 0;
link->dev = &dev->node;
/* Finally, report what we've done */
printk(KERN_INFO "%s: %s%sindex 0x%02x: Vcc %d.%d",
dev->node.dev_name,
card_index == -1 ? "" : card_table[card_index].name,
card_index == -1 ? "" : " ",
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");
link->state &= ~DEV_CONFIG_PENDING;
return;
cs_failed:
cs_error(link->handle, last_fn, last_ret);
atmel_release(link);
}
/* 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;
}
/* Well, it looks good to go. So we can now enable the PCMCIA
* controller.
*/
MECR |= GPIO_bit(1);
/* We need to initialize the MCXX registers to default values
* here because we're not guaranteed to see a SetIOMap operation
* at runtime.
*/
clock = get_lclk_frequency_10khz();
for(i=0; i<pxa_pcmcia_socket_count; ++i){
pxa_pcmcia_socket[i].k_state=state[i];
/* This is an interim fix. Apparently, SetSocket is no longer
* called to initialize each socket (prior to the first detect
* event). For now, we'll just manually set up the mask.
*/
pxa_pcmcia_socket[i].cs_state.csc_mask=SS_DETECT;
pxa_pcmcia_socket[i].virt_io=(i==0)?PCMCIA_IO_0_BASE:PCMCIA_IO_1_BASE;
pxa_pcmcia_socket[i].phys_attr=_PCMCIAAttr(i);
pxa_pcmcia_socket[i].phys_mem=_PCMCIAMem(i);
/* REVISIT: cleanup these macros */
//MCIO_SET(i, PXA_PCMCIA_IO_ACCESS, clock);
//MCATTR_SET(i, PXA_PCMCIA_5V_MEM_ACCESS, clock);
//MCMEM_SET(i, PXA_PCMCIA_5V_MEM_ACCESS, clock);
pxa_pcmcia_socket[i].speed_io=PXA_PCMCIA_IO_ACCESS;
pxa_pcmcia_socket[i].speed_attr=PXA_PCMCIA_5V_MEM_ACCESS;
pxa_pcmcia_socket[i].speed_mem=PXA_PCMCIA_5V_MEM_ACCESS;
}
/* REVISIT: cleanup these macros */
MCMEM0 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
MCMEM1 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
MCATT0 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
MCATT1 = ((pxa_mcxx_setup(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_5V_MEM_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
MCIO0 = ((pxa_mcxx_setup(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
MCIO1 = ((pxa_mcxx_setup(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
| ((pxa_mcxx_asst(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
| ((pxa_mcxx_hold(PXA_PCMCIA_IO_ACCESS, clock)
& MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
#ifdef CONFIG_CPU_FREQ
if(cpufreq_register_notifier(&pxa_pcmcia_notifier_block) < 0){
printk(KERN_ERR "Unable to register CPU frequency change notifier\n");
return -ENXIO;
}
#endif
/* Only advertise as many sockets as we can detect: */
if(register_ss_entry(pxa_pcmcia_socket_count,
&pxa_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. */
pxa_pcmcia_poll_event(0);
DEBUG(1, "pxa_cs: initialization complete\n");
return 0;
} /* pxa_pcmcia_driver_init() */
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);
switch (cmd) {
case DS_ADJUST_RESOURCE_INFO:
ret = CardServices(AdjustResourceInfo, h, &buf.adjust);
break;
case DS_GET_CARD_SERVICES_INFO:
ret = CardServices(GetCardServicesInfo, &buf.servinfo);
break;
case DS_GET_CONFIGURATION_INFO:
ret = CardServices(GetConfigurationInfo, h, &buf.config);
break;
case DS_GET_FIRST_TUPLE:
ret = CardServices(GetFirstTuple, h, &buf.tuple);
break;
case DS_GET_NEXT_TUPLE:
ret = CardServices(GetNextTuple, h, &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, h, &buf.tuple);
break;
case DS_PARSE_TUPLE:
buf.tuple.TupleData = buf.tuple_parse.data;
ret = CardServices(ParseTuple, h, &buf.tuple,
&buf.tuple_parse.parse);
break;
case DS_RESET_CARD:
ret = CardServices(ResetCard, h, NULL);
break;
case DS_GET_STATUS:
ret = CardServices(GetStatus, h, &buf.status);
break;
case DS_VALIDATE_CIS:
ret = CardServices(ValidateCIS, h, &buf.cisinfo);
break;
case DS_SUSPEND_CARD:
ret = CardServices(SuspendCard, h, NULL);
break;
case DS_RESUME_CARD:
ret = CardServices(ResumeCard, h, NULL);
break;
case DS_EJECT_CARD:
ret = CardServices(EjectCard, h, NULL);
break;
case DS_INSERT_CARD:
ret = CardServices(InsertCard, h, NULL);
break;
/* case DS_ACCESS_CONFIGURATION_REGISTER:
if ((buf.conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN))
return -EPERM;
ret = CardServices(AccessConfigurationRegister, h,
&buf.conf_reg);
break;
case DS_GET_FIRST_REGION:
ret = CardServices(GetFirstRegion, h, &buf.region);
break;
case DS_GET_NEXT_REGION:
ret = CardServices(GetNextRegion, h, &buf.region);
break;
case DS_GET_FIRST_WINDOW:
buf.win_info.handle = (window_handle_t)h;
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, h, &buf.cisdump);
break;
/* case DS_BIND_REQUEST:
if (!capable(CAP_SYS_ADMIN)) return -EPERM;
err = bind_request(i, &buf.bind_info);
break;
case DS_GET_DEVICE_INFO:
err = get_device_info(i, &buf.bind_info, 1);
break;
case DS_GET_NEXT_DEVICE:
err = get_device_info(i, &buf.bind_info, 0);
break;
case DS_UNBIND_REQUEST:
err = unbind_request(i, &buf.bind_info);
break;
case DS_BIND_MTD:
if (!capable(CAP_SYS_ADMIN)) return -EPERM;
err = bind_mtd(i, &buf.mtd_info);
break;*/
default:
err = -EINVAL;
}
if ((err == 0) && (ret != CS_SUCCESS)) {
switch (ret) {
case CS_BAD_SOCKET: case CS_NO_CARD:
err = ENODEV; break;
case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
case CS_BAD_TUPLE:
err = EINVAL; break;
case CS_IN_USE:
err = EBUSY; break;
case CS_OUT_OF_RESOURCE:
err = ENOSPC; break;
case CS_NO_MORE_ITEMS:
err = ENODATA; break;
case CS_UNSUPPORTED_FUNCTION:
err = ENOSYS; break;
default:
err = EIO; break;
}
}
if (cmd & IOC_OUT) copy_to_user((char *)arg, (char *)&buf, size);
return err;
} /* ds_ioctl */
