1453 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * ds.c -- 16-bit PCMCIA core support4 *5 * The initial developer of the original code is David A. Hinds6 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds7 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.8 *9 * (C) 1999 David A. Hinds10 * (C) 2003 - 2010 Dominik Brodowski11 */12 13#include <linux/kernel.h>14#include <linux/module.h>15#include <linux/init.h>16#include <linux/errno.h>17#include <linux/list.h>18#include <linux/delay.h>19#include <linux/workqueue.h>20#include <linux/crc32.h>21#include <linux/firmware.h>22#include <linux/kref.h>23#include <linux/dma-mapping.h>24#include <linux/slab.h>25 26#include <pcmcia/cistpl.h>27#include <pcmcia/ds.h>28#include <pcmcia/ss.h>29 30#include "cs_internal.h"31 32/*====================================================================*/33 34/* Module parameters */35 36MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");37MODULE_DESCRIPTION("PCMCIA Driver Services");38MODULE_LICENSE("GPL");39 40 41/*====================================================================*/42 43static void pcmcia_check_driver(struct pcmcia_driver *p_drv)44{45 const struct pcmcia_device_id *did = p_drv->id_table;46 unsigned int i;47 u32 hash;48 49 if (!p_drv->probe || !p_drv->remove)50 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "51 "function\n", p_drv->name);52 53 while (did && did->match_flags) {54 for (i = 0; i < 4; i++) {55 if (!did->prod_id[i])56 continue;57 58 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));59 if (hash == did->prod_id_hash[i])60 continue;61 62 printk(KERN_DEBUG "pcmcia: %s: invalid hash for "63 "product string \"%s\": is 0x%x, should "64 "be 0x%x\n", p_drv->name, did->prod_id[i],65 did->prod_id_hash[i], hash);66 printk(KERN_DEBUG "pcmcia: see "67 "Documentation/pcmcia/devicetable.rst for "68 "details\n");69 }70 did++;71 }72 73 return;74}75 76 77/*======================================================================*/78 79 80struct pcmcia_dynid {81 struct list_head node;82 struct pcmcia_device_id id;83};84 85/**86 * new_id_store() - add a new PCMCIA device ID to this driver and re-probe devices87 * @driver: target device driver88 * @buf: buffer for scanning device ID data89 * @count: input size90 *91 * Adds a new dynamic PCMCIA device ID to this driver,92 * and causes the driver to probe for all devices again.93 */94static ssize_t95new_id_store(struct device_driver *driver, const char *buf, size_t count)96{97 struct pcmcia_dynid *dynid;98 struct pcmcia_driver *pdrv = to_pcmcia_drv(driver);99 __u16 match_flags, manf_id, card_id;100 __u8 func_id, function, device_no;101 __u32 prod_id_hash[4] = {0, 0, 0, 0};102 int fields = 0;103 int retval = 0;104 105 fields = sscanf(buf, "%hx %hx %hx %hhx %hhx %hhx %x %x %x %x",106 &match_flags, &manf_id, &card_id, &func_id, &function, &device_no,107 &prod_id_hash[0], &prod_id_hash[1], &prod_id_hash[2], &prod_id_hash[3]);108 if (fields < 6)109 return -EINVAL;110 111 dynid = kzalloc(sizeof(struct pcmcia_dynid), GFP_KERNEL);112 if (!dynid)113 return -ENOMEM;114 115 dynid->id.match_flags = match_flags;116 dynid->id.manf_id = manf_id;117 dynid->id.card_id = card_id;118 dynid->id.func_id = func_id;119 dynid->id.function = function;120 dynid->id.device_no = device_no;121 memcpy(dynid->id.prod_id_hash, prod_id_hash, sizeof(__u32) * 4);122 123 mutex_lock(&pdrv->dynids.lock);124 list_add_tail(&dynid->node, &pdrv->dynids.list);125 mutex_unlock(&pdrv->dynids.lock);126 127 retval = driver_attach(&pdrv->drv);128 129 if (retval)130 return retval;131 return count;132}133static DRIVER_ATTR_WO(new_id);134 135static void136pcmcia_free_dynids(struct pcmcia_driver *drv)137{138 struct pcmcia_dynid *dynid, *n;139 140 mutex_lock(&drv->dynids.lock);141 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {142 list_del(&dynid->node);143 kfree(dynid);144 }145 mutex_unlock(&drv->dynids.lock);146}147 148static int149pcmcia_create_newid_file(struct pcmcia_driver *drv)150{151 int error = 0;152 if (drv->probe != NULL)153 error = driver_create_file(&drv->drv, &driver_attr_new_id);154 return error;155}156 157static void158pcmcia_remove_newid_file(struct pcmcia_driver *drv)159{160 driver_remove_file(&drv->drv, &driver_attr_new_id);161}162 163/**164 * pcmcia_register_driver - register a PCMCIA driver with the bus core165 * @driver: the &driver being registered166 *167 * Registers a PCMCIA driver with the PCMCIA bus core.168 */169int pcmcia_register_driver(struct pcmcia_driver *driver)170{171 int error;172 173 if (!driver)174 return -EINVAL;175 176 pcmcia_check_driver(driver);177 178 /* initialize common fields */179 driver->drv.bus = &pcmcia_bus_type;180 driver->drv.owner = driver->owner;181 driver->drv.name = driver->name;182 mutex_init(&driver->dynids.lock);183 INIT_LIST_HEAD(&driver->dynids.list);184 185 pr_debug("registering driver %s\n", driver->name);186 187 error = driver_register(&driver->drv);188 if (error < 0)189 return error;190 191 error = pcmcia_create_newid_file(driver);192 if (error)193 driver_unregister(&driver->drv);194 195 return error;196}197EXPORT_SYMBOL(pcmcia_register_driver);198 199/**200 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core201 * @driver: the &driver being unregistered202 */203void pcmcia_unregister_driver(struct pcmcia_driver *driver)204{205 pr_debug("unregistering driver %s\n", driver->name);206 pcmcia_remove_newid_file(driver);207 driver_unregister(&driver->drv);208 pcmcia_free_dynids(driver);209}210EXPORT_SYMBOL(pcmcia_unregister_driver);211 212 213/* pcmcia_device handling */214 215static struct pcmcia_device *pcmcia_get_dev(struct pcmcia_device *p_dev)216{217 struct device *tmp_dev;218 tmp_dev = get_device(&p_dev->dev);219 if (!tmp_dev)220 return NULL;221 return to_pcmcia_dev(tmp_dev);222}223 224static void pcmcia_put_dev(struct pcmcia_device *p_dev)225{226 if (p_dev)227 put_device(&p_dev->dev);228}229 230static void pcmcia_release_function(struct kref *ref)231{232 struct config_t *c = container_of(ref, struct config_t, ref);233 pr_debug("releasing config_t\n");234 kfree(c);235}236 237static void pcmcia_release_dev(struct device *dev)238{239 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);240 int i;241 dev_dbg(dev, "releasing device\n");242 pcmcia_put_socket(p_dev->socket);243 for (i = 0; i < 4; i++)244 kfree(p_dev->prod_id[i]);245 kfree(p_dev->devname);246 kref_put(&p_dev->function_config->ref, pcmcia_release_function);247 kfree(p_dev);248}249 250 251static int pcmcia_device_probe(struct device *dev)252{253 struct pcmcia_device *p_dev;254 struct pcmcia_driver *p_drv;255 struct pcmcia_socket *s;256 cistpl_config_t cis_config;257 int ret = 0;258 259 dev = get_device(dev);260 if (!dev)261 return -ENODEV;262 263 p_dev = to_pcmcia_dev(dev);264 p_drv = to_pcmcia_drv(dev->driver);265 s = p_dev->socket;266 267 dev_dbg(dev, "trying to bind to %s\n", p_drv->name);268 269 if ((!p_drv->probe) || (!p_dev->function_config) ||270 (!try_module_get(p_drv->owner))) {271 ret = -EINVAL;272 goto put_dev;273 }274 275 /* set up some more device information */276 ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,277 &cis_config);278 if (!ret) {279 p_dev->config_base = cis_config.base;280 p_dev->config_regs = cis_config.rmask[0];281 dev_dbg(dev, "base %x, regs %x", p_dev->config_base,282 p_dev->config_regs);283 } else {284 dev_info(dev,285 "pcmcia: could not parse base and rmask0 of CIS\n");286 p_dev->config_base = 0;287 p_dev->config_regs = 0;288 }289 290 ret = p_drv->probe(p_dev);291 if (ret) {292 dev_dbg(dev, "binding to %s failed with %d\n",293 p_drv->name, ret);294 goto put_module;295 }296 dev_dbg(dev, "%s bound: Vpp %d.%d, idx %x, IRQ %d", p_drv->name,297 p_dev->vpp/10, p_dev->vpp%10, p_dev->config_index, p_dev->irq);298 dev_dbg(dev, "resources: ioport %pR %pR iomem %pR %pR %pR",299 p_dev->resource[0], p_dev->resource[1], p_dev->resource[2],300 p_dev->resource[3], p_dev->resource[4]);301 302 mutex_lock(&s->ops_mutex);303 if ((s->pcmcia_pfc) &&304 (p_dev->socket->device_count == 1) && (p_dev->device_no == 0))305 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);306 mutex_unlock(&s->ops_mutex);307 308put_module:309 if (ret)310 module_put(p_drv->owner);311put_dev:312 if (ret)313 put_device(dev);314 return ret;315}316 317 318/*319 * Removes a PCMCIA card from the device tree and socket list.320 */321static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)322{323 struct pcmcia_device *p_dev;324 struct pcmcia_device *tmp;325 326 dev_dbg(leftover ? &leftover->dev : &s->dev,327 "pcmcia_card_remove(%d) %s\n", s->sock,328 leftover ? leftover->devname : "");329 330 mutex_lock(&s->ops_mutex);331 if (!leftover)332 s->device_count = 0;333 else334 s->device_count = 1;335 mutex_unlock(&s->ops_mutex);336 337 /* unregister all pcmcia_devices registered with this socket, except leftover */338 list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) {339 if (p_dev == leftover)340 continue;341 342 mutex_lock(&s->ops_mutex);343 list_del(&p_dev->socket_device_list);344 mutex_unlock(&s->ops_mutex);345 346 dev_dbg(&p_dev->dev, "unregistering device\n");347 device_unregister(&p_dev->dev);348 }349 350 return;351}352 353static void pcmcia_device_remove(struct device *dev)354{355 struct pcmcia_device *p_dev;356 struct pcmcia_driver *p_drv;357 int i;358 359 p_dev = to_pcmcia_dev(dev);360 p_drv = to_pcmcia_drv(dev->driver);361 362 dev_dbg(dev, "removing device\n");363 364 /* If we're removing the primary module driving a365 * pseudo multi-function card, we need to unbind366 * all devices367 */368 if ((p_dev->socket->pcmcia_pfc) &&369 (p_dev->socket->device_count > 0) &&370 (p_dev->device_no == 0))371 pcmcia_card_remove(p_dev->socket, p_dev);372 373 /* detach the "instance" */374 if (p_drv->remove)375 p_drv->remove(p_dev);376 377 /* check for proper unloading */378 if (p_dev->_irq || p_dev->_io || p_dev->_locked)379 dev_info(dev,380 "pcmcia: driver %s did not release config properly\n",381 p_drv->name);382 383 for (i = 0; i < MAX_WIN; i++)384 if (p_dev->_win & CLIENT_WIN_REQ(i))385 dev_info(dev,386 "pcmcia: driver %s did not release window properly\n",387 p_drv->name);388 389 /* references from pcmcia_device_probe */390 pcmcia_put_dev(p_dev);391 module_put(p_drv->owner);392}393 394 395/*396 * pcmcia_device_query -- determine information about a pcmcia device397 */398static int pcmcia_device_query(struct pcmcia_device *p_dev)399{400 cistpl_manfid_t manf_id;401 cistpl_funcid_t func_id;402 cistpl_vers_1_t *vers1;403 unsigned int i;404 405 vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);406 if (!vers1)407 return -ENOMEM;408 409 if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL,410 CISTPL_MANFID, &manf_id)) {411 mutex_lock(&p_dev->socket->ops_mutex);412 p_dev->manf_id = manf_id.manf;413 p_dev->card_id = manf_id.card;414 p_dev->has_manf_id = 1;415 p_dev->has_card_id = 1;416 mutex_unlock(&p_dev->socket->ops_mutex);417 }418 419 if (!pccard_read_tuple(p_dev->socket, p_dev->func,420 CISTPL_FUNCID, &func_id)) {421 mutex_lock(&p_dev->socket->ops_mutex);422 p_dev->func_id = func_id.func;423 p_dev->has_func_id = 1;424 mutex_unlock(&p_dev->socket->ops_mutex);425 } else {426 /* rule of thumb: cards with no FUNCID, but with427 * common memory device geometry information, are428 * probably memory cards (from pcmcia-cs) */429 cistpl_device_geo_t *devgeo;430 431 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);432 if (!devgeo) {433 kfree(vers1);434 return -ENOMEM;435 }436 if (!pccard_read_tuple(p_dev->socket, p_dev->func,437 CISTPL_DEVICE_GEO, devgeo)) {438 dev_dbg(&p_dev->dev,439 "mem device geometry probably means "440 "FUNCID_MEMORY\n");441 mutex_lock(&p_dev->socket->ops_mutex);442 p_dev->func_id = CISTPL_FUNCID_MEMORY;443 p_dev->has_func_id = 1;444 mutex_unlock(&p_dev->socket->ops_mutex);445 }446 kfree(devgeo);447 }448 449 if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,450 vers1)) {451 mutex_lock(&p_dev->socket->ops_mutex);452 for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {453 char *tmp;454 unsigned int length;455 char *new;456 457 tmp = vers1->str + vers1->ofs[i];458 459 length = strlen(tmp) + 1;460 if ((length < 2) || (length > 255))461 continue;462 463 new = kstrdup(tmp, GFP_KERNEL);464 if (!new)465 continue;466 467 tmp = p_dev->prod_id[i];468 p_dev->prod_id[i] = new;469 kfree(tmp);470 }471 mutex_unlock(&p_dev->socket->ops_mutex);472 }473 474 kfree(vers1);475 return 0;476}477 478 479static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,480 unsigned int function)481{482 struct pcmcia_device *p_dev, *tmp_dev;483 int i;484 485 s = pcmcia_get_socket(s);486 if (!s)487 return NULL;488 489 pr_debug("adding device to %d, function %d\n", s->sock, function);490 491 p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);492 if (!p_dev)493 goto err_put;494 495 mutex_lock(&s->ops_mutex);496 p_dev->device_no = (s->device_count++);497 mutex_unlock(&s->ops_mutex);498 499 /* max of 2 PFC devices */500 if ((p_dev->device_no >= 2) && (function == 0))501 goto err_free;502 503 /* max of 4 devices overall */504 if (p_dev->device_no >= 4)505 goto err_free;506 507 p_dev->socket = s;508 p_dev->func = function;509 510 p_dev->dev.bus = &pcmcia_bus_type;511 p_dev->dev.parent = s->dev.parent;512 p_dev->dev.release = pcmcia_release_dev;513 /* by default don't allow DMA */514 p_dev->dma_mask = 0;515 p_dev->dev.dma_mask = &p_dev->dma_mask;516 p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));517 if (!p_dev->devname)518 goto err_free;519 dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);520 521 mutex_lock(&s->ops_mutex);522 523 /*524 * p_dev->function_config must be the same for all card functions.525 * Note that this is serialized by ops_mutex, so that only one526 * such struct will be created.527 */528 list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)529 if (p_dev->func == tmp_dev->func) {530 p_dev->function_config = tmp_dev->function_config;531 p_dev->irq = tmp_dev->irq;532 kref_get(&p_dev->function_config->ref);533 }534 535 /* Add to the list in pcmcia_bus_socket */536 list_add(&p_dev->socket_device_list, &s->devices_list);537 538 if (pcmcia_setup_irq(p_dev))539 dev_warn(&p_dev->dev,540 "IRQ setup failed -- device might not work\n");541 542 if (!p_dev->function_config) {543 config_t *c;544 dev_dbg(&p_dev->dev, "creating config_t\n");545 c = kzalloc(sizeof(struct config_t), GFP_KERNEL);546 if (!c) {547 mutex_unlock(&s->ops_mutex);548 goto err_unreg;549 }550 p_dev->function_config = c;551 kref_init(&c->ref);552 for (i = 0; i < MAX_IO_WIN; i++) {553 c->io[i].name = p_dev->devname;554 c->io[i].flags = IORESOURCE_IO;555 }556 for (i = 0; i < MAX_WIN; i++) {557 c->mem[i].name = p_dev->devname;558 c->mem[i].flags = IORESOURCE_MEM;559 }560 }561 for (i = 0; i < MAX_IO_WIN; i++)562 p_dev->resource[i] = &p_dev->function_config->io[i];563 for (; i < (MAX_IO_WIN + MAX_WIN); i++)564 p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];565 566 mutex_unlock(&s->ops_mutex);567 568 dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",569 p_dev->devname, p_dev->irq);570 571 pcmcia_device_query(p_dev);572 573 dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);574 if (device_register(&p_dev->dev)) {575 mutex_lock(&s->ops_mutex);576 list_del(&p_dev->socket_device_list);577 s->device_count--;578 mutex_unlock(&s->ops_mutex);579 put_device(&p_dev->dev);580 return NULL;581 }582 583 return p_dev;584 585 err_unreg:586 mutex_lock(&s->ops_mutex);587 list_del(&p_dev->socket_device_list);588 mutex_unlock(&s->ops_mutex);589 590 err_free:591 mutex_lock(&s->ops_mutex);592 s->device_count--;593 mutex_unlock(&s->ops_mutex);594 595 for (i = 0; i < 4; i++)596 kfree(p_dev->prod_id[i]);597 kfree(p_dev->devname);598 kfree(p_dev);599 err_put:600 pcmcia_put_socket(s);601 602 return NULL;603}604 605 606static int pcmcia_card_add(struct pcmcia_socket *s)607{608 cistpl_longlink_mfc_t mfc;609 unsigned int no_funcs, i, no_chains;610 int ret = -EAGAIN;611 612 mutex_lock(&s->ops_mutex);613 if (!(s->resource_setup_done)) {614 dev_dbg(&s->dev,615 "no resources available, delaying card_add\n");616 mutex_unlock(&s->ops_mutex);617 return -EAGAIN; /* try again, but later... */618 }619 620 if (pcmcia_validate_mem(s)) {621 dev_dbg(&s->dev, "validating mem resources failed, "622 "delaying card_add\n");623 mutex_unlock(&s->ops_mutex);624 return -EAGAIN; /* try again, but later... */625 }626 mutex_unlock(&s->ops_mutex);627 628 ret = pccard_validate_cis(s, &no_chains);629 if (ret || !no_chains) {630#if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)631 /* Set up as an anonymous card. If we don't have anonymous632 memory support then just error the card as there is no633 point trying to second guess.634 635 Note: some cards have just a device entry, it may be636 worth extending support to cover these in future */637 if (ret == -EIO) {638 dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");639 pcmcia_replace_cis(s, "\xFF", 1);640 no_chains = 1;641 ret = 0;642 } else643#endif644 {645 dev_dbg(&s->dev, "invalid CIS or invalid resources\n");646 return -ENODEV;647 }648 }649 650 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))651 no_funcs = mfc.nfn;652 else653 no_funcs = 1;654 s->functions = no_funcs;655 656 for (i = 0; i < no_funcs; i++)657 pcmcia_device_add(s, i);658 659 return ret;660}661 662 663static int pcmcia_requery_callback(struct device *dev, void *_data)664{665 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);666 if (!p_dev->dev.driver) {667 dev_dbg(dev, "update device information\n");668 pcmcia_device_query(p_dev);669 }670 671 return 0;672}673 674 675static void pcmcia_requery(struct pcmcia_socket *s)676{677 int has_pfc;678 679 if (!(s->state & SOCKET_PRESENT))680 return;681 682 if (s->functions == 0) {683 pcmcia_card_add(s);684 return;685 }686 687 /* some device information might have changed because of a CIS688 * update or because we can finally read it correctly... so689 * determine it again, overwriting old values if necessary. */690 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);691 692 /* if the CIS changed, we need to check whether the number of693 * functions changed. */694 if (s->fake_cis) {695 int old_funcs, new_funcs;696 cistpl_longlink_mfc_t mfc;697 698 /* does this cis override add or remove functions? */699 old_funcs = s->functions;700 701 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,702 &mfc))703 new_funcs = mfc.nfn;704 else705 new_funcs = 1;706 if (old_funcs != new_funcs) {707 /* we need to re-start */708 pcmcia_card_remove(s, NULL);709 s->functions = 0;710 pcmcia_card_add(s);711 }712 }713 714 /* If the PCMCIA device consists of two pseudo devices,715 * call pcmcia_device_add() -- which will fail if both716 * devices are already registered. */717 mutex_lock(&s->ops_mutex);718 has_pfc = s->pcmcia_pfc;719 mutex_unlock(&s->ops_mutex);720 if (has_pfc)721 pcmcia_device_add(s, 0);722 723 /* we re-scan all devices, not just the ones connected to this724 * socket. This does not matter, though. */725 if (bus_rescan_devices(&pcmcia_bus_type))726 dev_warn(&s->dev, "rescanning the bus failed\n");727}728 729 730#ifdef CONFIG_PCMCIA_LOAD_CIS731 732/**733 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken734 * @dev: the pcmcia device which needs a CIS override735 * @filename: requested filename in /lib/firmware/736 *737 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if738 * the one provided by the card is broken. The firmware files reside in739 * /lib/firmware/ in userspace.740 */741static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)742{743 struct pcmcia_socket *s = dev->socket;744 const struct firmware *fw;745 int ret = -ENOMEM;746 cistpl_longlink_mfc_t mfc;747 int old_funcs, new_funcs = 1;748 749 if (!filename)750 return -EINVAL;751 752 dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);753 754 if (request_firmware(&fw, filename, &dev->dev) == 0) {755 if (fw->size >= CISTPL_MAX_CIS_SIZE) {756 ret = -EINVAL;757 dev_err(&dev->dev, "pcmcia: CIS override is too big\n");758 goto release;759 }760 761 if (!pcmcia_replace_cis(s, fw->data, fw->size))762 ret = 0;763 else {764 dev_err(&dev->dev, "pcmcia: CIS override failed\n");765 goto release;766 }767 768 /* we need to re-start if the number of functions changed */769 old_funcs = s->functions;770 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,771 &mfc))772 new_funcs = mfc.nfn;773 774 if (old_funcs != new_funcs)775 ret = -EBUSY;776 777 /* update information */778 pcmcia_device_query(dev);779 780 /* requery (as number of functions might have changed) */781 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);782 }783 release:784 release_firmware(fw);785 786 return ret;787}788 789#else /* !CONFIG_PCMCIA_LOAD_CIS */790 791static inline int pcmcia_load_firmware(struct pcmcia_device *dev,792 char *filename)793{794 return -ENODEV;795}796 797#endif798 799 800static inline int pcmcia_devmatch(struct pcmcia_device *dev,801 const struct pcmcia_device_id *did)802{803 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {804 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))805 return 0;806 }807 808 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {809 if ((!dev->has_card_id) || (dev->card_id != did->card_id))810 return 0;811 }812 813 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {814 if (dev->func != did->function)815 return 0;816 }817 818 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {819 if (!dev->prod_id[0])820 return 0;821 if (strcmp(did->prod_id[0], dev->prod_id[0]))822 return 0;823 }824 825 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {826 if (!dev->prod_id[1])827 return 0;828 if (strcmp(did->prod_id[1], dev->prod_id[1]))829 return 0;830 }831 832 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {833 if (!dev->prod_id[2])834 return 0;835 if (strcmp(did->prod_id[2], dev->prod_id[2]))836 return 0;837 }838 839 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {840 if (!dev->prod_id[3])841 return 0;842 if (strcmp(did->prod_id[3], dev->prod_id[3]))843 return 0;844 }845 846 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {847 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");848 mutex_lock(&dev->socket->ops_mutex);849 dev->socket->pcmcia_pfc = 1;850 mutex_unlock(&dev->socket->ops_mutex);851 if (dev->device_no != did->device_no)852 return 0;853 }854 855 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {856 int ret;857 858 if ((!dev->has_func_id) || (dev->func_id != did->func_id))859 return 0;860 861 /* if this is a pseudo-multi-function device,862 * we need explicit matches */863 if (dev->socket->pcmcia_pfc)864 return 0;865 if (dev->device_no)866 return 0;867 868 /* also, FUNC_ID matching needs to be activated by userspace869 * after it has re-checked that there is no possible module870 * with a prod_id/manf_id/card_id match.871 */872 mutex_lock(&dev->socket->ops_mutex);873 ret = dev->allow_func_id_match;874 mutex_unlock(&dev->socket->ops_mutex);875 876 if (!ret) {877 dev_dbg(&dev->dev,878 "skipping FUNC_ID match until userspace ACK\n");879 return 0;880 }881 }882 883 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {884 dev_dbg(&dev->dev, "device needs a fake CIS\n");885 if (!dev->socket->fake_cis)886 if (pcmcia_load_firmware(dev, did->cisfile))887 return 0;888 }889 890 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {891 int i;892 for (i = 0; i < 4; i++)893 if (dev->prod_id[i])894 return 0;895 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)896 return 0;897 }898 899 return 1;900}901 902 903static int pcmcia_bus_match(struct device *dev, const struct device_driver *drv)904{905 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);906 struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);907 const struct pcmcia_device_id *did = p_drv->id_table;908 struct pcmcia_dynid *dynid;909 910 /* match dynamic devices first */911 mutex_lock(&p_drv->dynids.lock);912 list_for_each_entry(dynid, &p_drv->dynids.list, node) {913 dev_dbg(dev, "trying to match to %s\n", drv->name);914 if (pcmcia_devmatch(p_dev, &dynid->id)) {915 dev_dbg(dev, "matched to %s\n", drv->name);916 mutex_unlock(&p_drv->dynids.lock);917 return 1;918 }919 }920 mutex_unlock(&p_drv->dynids.lock);921 922 while (did && did->match_flags) {923 dev_dbg(dev, "trying to match to %s\n", drv->name);924 if (pcmcia_devmatch(p_dev, did)) {925 dev_dbg(dev, "matched to %s\n", drv->name);926 return 1;927 }928 did++;929 }930 931 return 0;932}933 934static int pcmcia_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)935{936 const struct pcmcia_device *p_dev;937 int i;938 u32 hash[4] = { 0, 0, 0, 0};939 940 if (!dev)941 return -ENODEV;942 943 p_dev = to_pcmcia_dev(dev);944 945 /* calculate hashes */946 for (i = 0; i < 4; i++) {947 if (!p_dev->prod_id[i])948 continue;949 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));950 }951 952 if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))953 return -ENOMEM;954 955 if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))956 return -ENOMEM;957 958 if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"959 "pa%08Xpb%08Xpc%08Xpd%08X",960 p_dev->has_manf_id ? p_dev->manf_id : 0,961 p_dev->has_card_id ? p_dev->card_id : 0,962 p_dev->has_func_id ? p_dev->func_id : 0,963 p_dev->func,964 p_dev->device_no,965 hash[0],966 hash[1],967 hash[2],968 hash[3]))969 return -ENOMEM;970 971 return 0;972}973 974/************************ runtime PM support ***************************/975 976static int pcmcia_dev_suspend(struct device *dev);977static int pcmcia_dev_resume(struct device *dev);978 979static int runtime_suspend(struct device *dev)980{981 int rc;982 983 device_lock(dev);984 rc = pcmcia_dev_suspend(dev);985 device_unlock(dev);986 return rc;987}988 989static int runtime_resume(struct device *dev)990{991 int rc;992 993 device_lock(dev);994 rc = pcmcia_dev_resume(dev);995 device_unlock(dev);996 return rc;997}998 999/************************ per-device sysfs output ***************************/1000 1001#define pcmcia_device_attr(field, test, format) \1002static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \1003{ \1004 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \1005 return p_dev->test ? sysfs_emit(buf, format, p_dev->field) : -ENODEV; \1006} \1007static DEVICE_ATTR_RO(field);1008 1009#define pcmcia_device_stringattr(name, field) \1010static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \1011{ \1012 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \1013 return p_dev->field ? sysfs_emit(buf, "%s\n", p_dev->field) : -ENODEV; \1014} \1015static DEVICE_ATTR_RO(name);1016 1017pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");1018pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");1019pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");1020pcmcia_device_stringattr(prod_id1, prod_id[0]);1021pcmcia_device_stringattr(prod_id2, prod_id[1]);1022pcmcia_device_stringattr(prod_id3, prod_id[2]);1023pcmcia_device_stringattr(prod_id4, prod_id[3]);1024 1025static ssize_t function_show(struct device *dev, struct device_attribute *attr,1026 char *buf)1027{1028 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1029 return p_dev->socket ? sysfs_emit(buf, "0x%02x\n", p_dev->func) : -ENODEV;1030}1031static DEVICE_ATTR_RO(function);1032 1033static ssize_t resources_show(struct device *dev,1034 struct device_attribute *attr, char *buf)1035{1036 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1037 int i, at = 0;1038 1039 for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)1040 at += sysfs_emit_at(buf, at, "%pr\n", p_dev->resource[i]);1041 1042 return at;1043}1044static DEVICE_ATTR_RO(resources);1045 1046static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)1047{1048 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1049 1050 if (p_dev->suspended)1051 return sysfs_emit(buf, "off\n");1052 else1053 return sysfs_emit(buf, "on\n");1054}1055 1056static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,1057 const char *buf, size_t count)1058{1059 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1060 int ret = 0;1061 1062 if (!count)1063 return -EINVAL;1064 1065 if ((!p_dev->suspended) && !strncmp(buf, "off", 3))1066 ret = runtime_suspend(dev);1067 else if (p_dev->suspended && !strncmp(buf, "on", 2))1068 ret = runtime_resume(dev);1069 1070 return ret ? ret : count;1071}1072static DEVICE_ATTR_RW(pm_state);1073 1074static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)1075{1076 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1077 int i;1078 u32 hash[4] = { 0, 0, 0, 0};1079 1080 /* calculate hashes */1081 for (i = 0; i < 4; i++) {1082 if (!p_dev->prod_id[i])1083 continue;1084 hash[i] = crc32(0, p_dev->prod_id[i],1085 strlen(p_dev->prod_id[i]));1086 }1087 return sysfs_emit(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02Xpa%08Xpb%08Xpc%08Xpd%08X\n",1088 p_dev->has_manf_id ? p_dev->manf_id : 0,1089 p_dev->has_card_id ? p_dev->card_id : 0,1090 p_dev->has_func_id ? p_dev->func_id : 0,1091 p_dev->func, p_dev->device_no,1092 hash[0], hash[1], hash[2], hash[3]);1093}1094static DEVICE_ATTR_RO(modalias);1095 1096static ssize_t allow_func_id_match_store(struct device *dev,1097 struct device_attribute *attr, const char *buf, size_t count)1098{1099 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1100 1101 if (!count)1102 return -EINVAL;1103 1104 mutex_lock(&p_dev->socket->ops_mutex);1105 p_dev->allow_func_id_match = 1;1106 mutex_unlock(&p_dev->socket->ops_mutex);1107 pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY);1108 1109 return count;1110}1111static DEVICE_ATTR_WO(allow_func_id_match);1112 1113static struct attribute *pcmcia_dev_attrs[] = {1114 &dev_attr_resources.attr,1115 &dev_attr_pm_state.attr,1116 &dev_attr_function.attr,1117 &dev_attr_func_id.attr,1118 &dev_attr_manf_id.attr,1119 &dev_attr_card_id.attr,1120 &dev_attr_prod_id1.attr,1121 &dev_attr_prod_id2.attr,1122 &dev_attr_prod_id3.attr,1123 &dev_attr_prod_id4.attr,1124 &dev_attr_modalias.attr,1125 &dev_attr_allow_func_id_match.attr,1126 NULL,1127};1128ATTRIBUTE_GROUPS(pcmcia_dev);1129 1130/* PM support, also needed for reset */1131 1132static int pcmcia_dev_suspend(struct device *dev)1133{1134 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1135 struct pcmcia_driver *p_drv = NULL;1136 int ret = 0;1137 1138 mutex_lock(&p_dev->socket->ops_mutex);1139 if (p_dev->suspended) {1140 mutex_unlock(&p_dev->socket->ops_mutex);1141 return 0;1142 }1143 p_dev->suspended = 1;1144 mutex_unlock(&p_dev->socket->ops_mutex);1145 1146 dev_dbg(dev, "suspending\n");1147 1148 if (dev->driver)1149 p_drv = to_pcmcia_drv(dev->driver);1150 1151 if (!p_drv)1152 goto out;1153 1154 if (p_drv->suspend) {1155 ret = p_drv->suspend(p_dev);1156 if (ret) {1157 dev_err(dev,1158 "pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n",1159 p_dev->devname, p_drv->name, ret);1160 mutex_lock(&p_dev->socket->ops_mutex);1161 p_dev->suspended = 0;1162 mutex_unlock(&p_dev->socket->ops_mutex);1163 goto out;1164 }1165 }1166 1167 if (p_dev->device_no == p_dev->func) {1168 dev_dbg(dev, "releasing configuration\n");1169 pcmcia_release_configuration(p_dev);1170 }1171 1172 out:1173 return ret;1174}1175 1176 1177static int pcmcia_dev_resume(struct device *dev)1178{1179 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1180 struct pcmcia_driver *p_drv = NULL;1181 int ret = 0;1182 1183 mutex_lock(&p_dev->socket->ops_mutex);1184 if (!p_dev->suspended) {1185 mutex_unlock(&p_dev->socket->ops_mutex);1186 return 0;1187 }1188 p_dev->suspended = 0;1189 mutex_unlock(&p_dev->socket->ops_mutex);1190 1191 dev_dbg(dev, "resuming\n");1192 1193 if (dev->driver)1194 p_drv = to_pcmcia_drv(dev->driver);1195 1196 if (!p_drv)1197 goto out;1198 1199 if (p_dev->device_no == p_dev->func) {1200 dev_dbg(dev, "requesting configuration\n");1201 ret = pcmcia_enable_device(p_dev);1202 if (ret)1203 goto out;1204 }1205 1206 if (p_drv->resume)1207 ret = p_drv->resume(p_dev);1208 1209 out:1210 return ret;1211}1212 1213 1214static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)1215{1216 struct pcmcia_socket *skt = _data;1217 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1218 1219 if (p_dev->socket != skt || p_dev->suspended)1220 return 0;1221 1222 return runtime_suspend(dev);1223}1224 1225static int pcmcia_bus_resume_callback(struct device *dev, void *_data)1226{1227 struct pcmcia_socket *skt = _data;1228 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);1229 1230 if (p_dev->socket != skt || !p_dev->suspended)1231 return 0;1232 1233 runtime_resume(dev);1234 1235 return 0;1236}1237 1238static int pcmcia_bus_resume(struct pcmcia_socket *skt)1239{1240 dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock);1241 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);1242 return 0;1243}1244 1245static int pcmcia_bus_suspend(struct pcmcia_socket *skt)1246{1247 dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock);1248 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,1249 pcmcia_bus_suspend_callback)) {1250 pcmcia_bus_resume(skt);1251 return -EIO;1252 }1253 return 0;1254}1255 1256static int pcmcia_bus_remove(struct pcmcia_socket *skt)1257{1258 atomic_set(&skt->present, 0);1259 pcmcia_card_remove(skt, NULL);1260 1261 mutex_lock(&skt->ops_mutex);1262 destroy_cis_cache(skt);1263 pcmcia_cleanup_irq(skt);1264 mutex_unlock(&skt->ops_mutex);1265 1266 return 0;1267}1268 1269static int pcmcia_bus_add(struct pcmcia_socket *skt)1270{1271 atomic_set(&skt->present, 1);1272 1273 mutex_lock(&skt->ops_mutex);1274 skt->pcmcia_pfc = 0;1275 destroy_cis_cache(skt); /* to be on the safe side... */1276 mutex_unlock(&skt->ops_mutex);1277 1278 pcmcia_card_add(skt);1279 1280 return 0;1281}1282 1283static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)1284{1285 if (!verify_cis_cache(skt))1286 return 0;1287 1288 dev_dbg(&skt->dev, "cis mismatch - different card\n");1289 1290 /* first, remove the card */1291 pcmcia_bus_remove(skt);1292 1293 mutex_lock(&skt->ops_mutex);1294 destroy_cis_cache(skt);1295 kfree(skt->fake_cis);1296 skt->fake_cis = NULL;1297 skt->functions = 0;1298 mutex_unlock(&skt->ops_mutex);1299 1300 /* now, add the new card */1301 pcmcia_bus_add(skt);1302 return 0;1303}1304 1305 1306/*1307 * NOTE: This is racy. There's no guarantee the card will still be1308 * physically present, even if the call to this function returns1309 * non-NULL. Furthermore, the device driver most likely is unbound1310 * almost immediately, so the timeframe where pcmcia_dev_present1311 * returns NULL is probably really really small.1312 */1313struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)1314{1315 struct pcmcia_device *p_dev;1316 struct pcmcia_device *ret = NULL;1317 1318 p_dev = pcmcia_get_dev(_p_dev);1319 if (!p_dev)1320 return NULL;1321 1322 if (atomic_read(&p_dev->socket->present) != 0)1323 ret = p_dev;1324 1325 pcmcia_put_dev(p_dev);1326 return ret;1327}1328EXPORT_SYMBOL(pcmcia_dev_present);1329 1330 1331static struct pcmcia_callback pcmcia_bus_callback = {1332 .owner = THIS_MODULE,1333 .add = pcmcia_bus_add,1334 .remove = pcmcia_bus_remove,1335 .requery = pcmcia_requery,1336 .validate = pccard_validate_cis,1337 .suspend = pcmcia_bus_suspend,1338 .early_resume = pcmcia_bus_early_resume,1339 .resume = pcmcia_bus_resume,1340};1341 1342static int pcmcia_bus_add_socket(struct device *dev)1343{1344 struct pcmcia_socket *socket = dev_get_drvdata(dev);1345 int ret;1346 1347 socket = pcmcia_get_socket(socket);1348 if (!socket) {1349 dev_err(dev, "PCMCIA obtaining reference to socket failed\n");1350 return -ENODEV;1351 }1352 1353 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);1354 if (ret) {1355 dev_err(dev, "PCMCIA registration failed\n");1356 pcmcia_put_socket(socket);1357 return ret;1358 }1359 1360 INIT_LIST_HEAD(&socket->devices_list);1361 socket->pcmcia_pfc = 0;1362 socket->device_count = 0;1363 atomic_set(&socket->present, 0);1364 1365 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);1366 if (ret) {1367 dev_err(dev, "PCMCIA registration failed\n");1368 pcmcia_put_socket(socket);1369 return ret;1370 }1371 1372 return 0;1373}1374 1375static void pcmcia_bus_remove_socket(struct device *dev)1376{1377 struct pcmcia_socket *socket = dev_get_drvdata(dev);1378 1379 if (!socket)1380 return;1381 1382 pccard_register_pcmcia(socket, NULL);1383 1384 /* unregister any unbound devices */1385 mutex_lock(&socket->skt_mutex);1386 pcmcia_card_remove(socket, NULL);1387 release_cis_mem(socket);1388 mutex_unlock(&socket->skt_mutex);1389 1390 sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);1391 1392 pcmcia_put_socket(socket);1393 1394 return;1395}1396 1397 1398/* the pcmcia_bus_interface is used to handle pcmcia socket devices */1399static struct class_interface pcmcia_bus_interface __refdata = {1400 .class = &pcmcia_socket_class,1401 .add_dev = &pcmcia_bus_add_socket,1402 .remove_dev = &pcmcia_bus_remove_socket,1403};1404 1405static const struct dev_pm_ops pcmcia_bus_pm_ops = {1406 SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)1407};1408 1409const struct bus_type pcmcia_bus_type = {1410 .name = "pcmcia",1411 .uevent = pcmcia_bus_uevent,1412 .match = pcmcia_bus_match,1413 .dev_groups = pcmcia_dev_groups,1414 .probe = pcmcia_device_probe,1415 .remove = pcmcia_device_remove,1416 .pm = &pcmcia_bus_pm_ops,1417};1418 1419 1420static int __init init_pcmcia_bus(void)1421{1422 int ret;1423 1424 ret = bus_register(&pcmcia_bus_type);1425 if (ret < 0) {1426 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);1427 return ret;1428 }1429 ret = class_interface_register(&pcmcia_bus_interface);1430 if (ret < 0) {1431 printk(KERN_WARNING1432 "pcmcia: class_interface_register error: %d\n", ret);1433 bus_unregister(&pcmcia_bus_type);1434 return ret;1435 }1436 1437 return 0;1438}1439fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that1440 * pcmcia_socket_class is already registered */1441 1442 1443static void __exit exit_pcmcia_bus(void)1444{1445 class_interface_unregister(&pcmcia_bus_interface);1446 1447 bus_unregister(&pcmcia_bus_type);1448}1449module_exit(exit_pcmcia_bus);1450 1451 1452MODULE_ALIAS("ds");1453