1 // SPDX-License-Identifier: GPL-2.0-only
3 * ds.c -- 16-bit PCMCIA core support
5 * The initial developer of the original code is David A. Hinds
6 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
7 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
9 * (C) 1999 David A. Hinds
10 * (C) 2003 - 2010 Dominik Brodowski
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>
26 #include <pcmcia/cistpl.h>
27 #include <pcmcia/ds.h>
28 #include <pcmcia/ss.h>
30 #include "cs_internal.h"
32 /*====================================================================*/
34 /* Module parameters */
36 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
37 MODULE_DESCRIPTION("PCMCIA Driver Services");
38 MODULE_LICENSE("GPL");
41 /*====================================================================*/
43 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
45 const struct pcmcia_device_id *did = p_drv->id_table;
49 if (!p_drv->probe || !p_drv->remove)
50 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
51 "function\n", p_drv->name);
53 while (did && did->match_flags) {
54 for (i = 0; i < 4; i++) {
58 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
59 if (hash == did->prod_id_hash[i])
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 "
77 /*======================================================================*/
81 struct list_head node;
82 struct pcmcia_device_id id;
86 * new_id_store() - add a new PCMCIA device ID to this driver and re-probe devices
87 * @driver: target device driver
88 * @buf: buffer for scanning device ID data
91 * Adds a new dynamic PCMCIA device ID to this driver,
92 * and causes the driver to probe for all devices again.
95 new_id_store(struct device_driver *driver, const char *buf, size_t count)
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};
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]);
111 dynid = kzalloc(sizeof(struct pcmcia_dynid), GFP_KERNEL);
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);
123 mutex_lock(&pdrv->dynids.lock);
124 list_add_tail(&dynid->node, &pdrv->dynids.list);
125 mutex_unlock(&pdrv->dynids.lock);
127 retval = driver_attach(&pdrv->drv);
133 static DRIVER_ATTR_WO(new_id);
136 pcmcia_free_dynids(struct pcmcia_driver *drv)
138 struct pcmcia_dynid *dynid, *n;
140 mutex_lock(&drv->dynids.lock);
141 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
142 list_del(&dynid->node);
145 mutex_unlock(&drv->dynids.lock);
149 pcmcia_create_newid_file(struct pcmcia_driver *drv)
152 if (drv->probe != NULL)
153 error = driver_create_file(&drv->drv, &driver_attr_new_id);
158 pcmcia_remove_newid_file(struct pcmcia_driver *drv)
160 driver_remove_file(&drv->drv, &driver_attr_new_id);
164 * pcmcia_register_driver - register a PCMCIA driver with the bus core
165 * @driver: the &driver being registered
167 * Registers a PCMCIA driver with the PCMCIA bus core.
169 int pcmcia_register_driver(struct pcmcia_driver *driver)
176 pcmcia_check_driver(driver);
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);
185 pr_debug("registering driver %s\n", driver->name);
187 error = driver_register(&driver->drv);
191 error = pcmcia_create_newid_file(driver);
193 driver_unregister(&driver->drv);
197 EXPORT_SYMBOL(pcmcia_register_driver);
200 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
201 * @driver: the &driver being unregistered
203 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
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);
210 EXPORT_SYMBOL(pcmcia_unregister_driver);
213 /* pcmcia_device handling */
215 static struct pcmcia_device *pcmcia_get_dev(struct pcmcia_device *p_dev)
217 struct device *tmp_dev;
218 tmp_dev = get_device(&p_dev->dev);
221 return to_pcmcia_dev(tmp_dev);
224 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
227 put_device(&p_dev->dev);
230 static void pcmcia_release_function(struct kref *ref)
232 struct config_t *c = container_of(ref, struct config_t, ref);
233 pr_debug("releasing config_t\n");
237 static void pcmcia_release_dev(struct device *dev)
239 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
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);
251 static int pcmcia_device_probe(struct device *dev)
253 struct pcmcia_device *p_dev;
254 struct pcmcia_driver *p_drv;
255 struct pcmcia_socket *s;
256 cistpl_config_t cis_config;
259 dev = get_device(dev);
263 p_dev = to_pcmcia_dev(dev);
264 p_drv = to_pcmcia_drv(dev->driver);
267 dev_dbg(dev, "trying to bind to %s\n", p_drv->name);
269 if ((!p_drv->probe) || (!p_dev->function_config) ||
270 (!try_module_get(p_drv->owner))) {
275 /* set up some more device information */
276 ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,
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,
285 "pcmcia: could not parse base and rmask0 of CIS\n");
286 p_dev->config_base = 0;
287 p_dev->config_regs = 0;
290 ret = p_drv->probe(p_dev);
292 dev_dbg(dev, "binding to %s failed with %d\n",
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]);
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);
310 module_put(p_drv->owner);
319 * Removes a PCMCIA card from the device tree and socket list.
321 static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)
323 struct pcmcia_device *p_dev;
324 struct pcmcia_device *tmp;
326 dev_dbg(leftover ? &leftover->dev : &s->dev,
327 "pcmcia_card_remove(%d) %s\n", s->sock,
328 leftover ? leftover->devname : "");
330 mutex_lock(&s->ops_mutex);
335 mutex_unlock(&s->ops_mutex);
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)
342 mutex_lock(&s->ops_mutex);
343 list_del(&p_dev->socket_device_list);
344 mutex_unlock(&s->ops_mutex);
346 dev_dbg(&p_dev->dev, "unregistering device\n");
347 device_unregister(&p_dev->dev);
353 static void pcmcia_device_remove(struct device *dev)
355 struct pcmcia_device *p_dev;
356 struct pcmcia_driver *p_drv;
359 p_dev = to_pcmcia_dev(dev);
360 p_drv = to_pcmcia_drv(dev->driver);
362 dev_dbg(dev, "removing device\n");
364 /* If we're removing the primary module driving a
365 * pseudo multi-function card, we need to unbind
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);
373 /* detach the "instance" */
375 p_drv->remove(p_dev);
377 /* check for proper unloading */
378 if (p_dev->_irq || p_dev->_io || p_dev->_locked)
380 "pcmcia: driver %s did not release config properly\n",
383 for (i = 0; i < MAX_WIN; i++)
384 if (p_dev->_win & CLIENT_WIN_REQ(i))
386 "pcmcia: driver %s did not release window properly\n",
389 /* references from pcmcia_device_probe */
390 pcmcia_put_dev(p_dev);
391 module_put(p_drv->owner);
396 * pcmcia_device_query -- determine information about a pcmcia device
398 static int pcmcia_device_query(struct pcmcia_device *p_dev)
400 cistpl_manfid_t manf_id;
401 cistpl_funcid_t func_id;
402 cistpl_vers_1_t *vers1;
405 vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
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);
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);
426 /* rule of thumb: cards with no FUNCID, but with
427 * common memory device geometry information, are
428 * probably memory cards (from pcmcia-cs) */
429 cistpl_device_geo_t *devgeo;
431 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
436 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
437 CISTPL_DEVICE_GEO, devgeo)) {
439 "mem device geometry probably means "
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);
449 if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,
451 mutex_lock(&p_dev->socket->ops_mutex);
452 for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {
457 tmp = vers1->str + vers1->ofs[i];
459 length = strlen(tmp) + 1;
460 if ((length < 2) || (length > 255))
463 new = kstrdup(tmp, GFP_KERNEL);
467 tmp = p_dev->prod_id[i];
468 p_dev->prod_id[i] = new;
471 mutex_unlock(&p_dev->socket->ops_mutex);
479 static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
480 unsigned int function)
482 struct pcmcia_device *p_dev, *tmp_dev;
485 s = pcmcia_get_socket(s);
489 pr_debug("adding device to %d, function %d\n", s->sock, function);
491 p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
495 mutex_lock(&s->ops_mutex);
496 p_dev->device_no = (s->device_count++);
497 mutex_unlock(&s->ops_mutex);
499 /* max of 2 PFC devices */
500 if ((p_dev->device_no >= 2) && (function == 0))
503 /* max of 4 devices overall */
504 if (p_dev->device_no >= 4)
508 p_dev->func = function;
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 */
515 p_dev->dev.dma_mask = &p_dev->dma_mask;
516 dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
517 if (!dev_name(&p_dev->dev))
519 p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
522 dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
524 mutex_lock(&s->ops_mutex);
527 * p_dev->function_config must be the same for all card functions.
528 * Note that this is serialized by ops_mutex, so that only one
529 * such struct will be created.
531 list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
532 if (p_dev->func == tmp_dev->func) {
533 p_dev->function_config = tmp_dev->function_config;
534 p_dev->irq = tmp_dev->irq;
535 kref_get(&p_dev->function_config->ref);
538 /* Add to the list in pcmcia_bus_socket */
539 list_add(&p_dev->socket_device_list, &s->devices_list);
541 if (pcmcia_setup_irq(p_dev))
542 dev_warn(&p_dev->dev,
543 "IRQ setup failed -- device might not work\n");
545 if (!p_dev->function_config) {
547 dev_dbg(&p_dev->dev, "creating config_t\n");
548 c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
550 mutex_unlock(&s->ops_mutex);
553 p_dev->function_config = c;
555 for (i = 0; i < MAX_IO_WIN; i++) {
556 c->io[i].name = p_dev->devname;
557 c->io[i].flags = IORESOURCE_IO;
559 for (i = 0; i < MAX_WIN; i++) {
560 c->mem[i].name = p_dev->devname;
561 c->mem[i].flags = IORESOURCE_MEM;
564 for (i = 0; i < MAX_IO_WIN; i++)
565 p_dev->resource[i] = &p_dev->function_config->io[i];
566 for (; i < (MAX_IO_WIN + MAX_WIN); i++)
567 p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
569 mutex_unlock(&s->ops_mutex);
571 dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
572 p_dev->devname, p_dev->irq);
574 pcmcia_device_query(p_dev);
576 if (device_register(&p_dev->dev))
582 mutex_lock(&s->ops_mutex);
583 list_del(&p_dev->socket_device_list);
584 mutex_unlock(&s->ops_mutex);
587 mutex_lock(&s->ops_mutex);
589 mutex_unlock(&s->ops_mutex);
591 for (i = 0; i < 4; i++)
592 kfree(p_dev->prod_id[i]);
593 kfree(p_dev->devname);
596 pcmcia_put_socket(s);
602 static int pcmcia_card_add(struct pcmcia_socket *s)
604 cistpl_longlink_mfc_t mfc;
605 unsigned int no_funcs, i, no_chains;
608 mutex_lock(&s->ops_mutex);
609 if (!(s->resource_setup_done)) {
611 "no resources available, delaying card_add\n");
612 mutex_unlock(&s->ops_mutex);
613 return -EAGAIN; /* try again, but later... */
616 if (pcmcia_validate_mem(s)) {
617 dev_dbg(&s->dev, "validating mem resources failed, "
618 "delaying card_add\n");
619 mutex_unlock(&s->ops_mutex);
620 return -EAGAIN; /* try again, but later... */
622 mutex_unlock(&s->ops_mutex);
624 ret = pccard_validate_cis(s, &no_chains);
625 if (ret || !no_chains) {
626 #if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)
627 /* Set up as an anonymous card. If we don't have anonymous
628 memory support then just error the card as there is no
629 point trying to second guess.
631 Note: some cards have just a device entry, it may be
632 worth extending support to cover these in future */
634 dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
635 pcmcia_replace_cis(s, "\xFF", 1);
641 dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
646 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
650 s->functions = no_funcs;
652 for (i = 0; i < no_funcs; i++)
653 pcmcia_device_add(s, i);
659 static int pcmcia_requery_callback(struct device *dev, void *_data)
661 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
662 if (!p_dev->dev.driver) {
663 dev_dbg(dev, "update device information\n");
664 pcmcia_device_query(p_dev);
671 static void pcmcia_requery(struct pcmcia_socket *s)
675 if (!(s->state & SOCKET_PRESENT))
678 if (s->functions == 0) {
683 /* some device information might have changed because of a CIS
684 * update or because we can finally read it correctly... so
685 * determine it again, overwriting old values if necessary. */
686 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);
688 /* if the CIS changed, we need to check whether the number of
689 * functions changed. */
691 int old_funcs, new_funcs;
692 cistpl_longlink_mfc_t mfc;
694 /* does this cis override add or remove functions? */
695 old_funcs = s->functions;
697 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
702 if (old_funcs != new_funcs) {
703 /* we need to re-start */
704 pcmcia_card_remove(s, NULL);
710 /* If the PCMCIA device consists of two pseudo devices,
711 * call pcmcia_device_add() -- which will fail if both
712 * devices are already registered. */
713 mutex_lock(&s->ops_mutex);
714 has_pfc = s->pcmcia_pfc;
715 mutex_unlock(&s->ops_mutex);
717 pcmcia_device_add(s, 0);
719 /* we re-scan all devices, not just the ones connected to this
720 * socket. This does not matter, though. */
721 if (bus_rescan_devices(&pcmcia_bus_type))
722 dev_warn(&s->dev, "rescanning the bus failed\n");
726 #ifdef CONFIG_PCMCIA_LOAD_CIS
729 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
730 * @dev: the pcmcia device which needs a CIS override
731 * @filename: requested filename in /lib/firmware/
733 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
734 * the one provided by the card is broken. The firmware files reside in
735 * /lib/firmware/ in userspace.
737 static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
739 struct pcmcia_socket *s = dev->socket;
740 const struct firmware *fw;
742 cistpl_longlink_mfc_t mfc;
743 int old_funcs, new_funcs = 1;
748 dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
750 if (request_firmware(&fw, filename, &dev->dev) == 0) {
751 if (fw->size >= CISTPL_MAX_CIS_SIZE) {
753 dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
757 if (!pcmcia_replace_cis(s, fw->data, fw->size))
760 dev_err(&dev->dev, "pcmcia: CIS override failed\n");
764 /* we need to re-start if the number of functions changed */
765 old_funcs = s->functions;
766 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
770 if (old_funcs != new_funcs)
773 /* update information */
774 pcmcia_device_query(dev);
776 /* requery (as number of functions might have changed) */
777 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
780 release_firmware(fw);
785 #else /* !CONFIG_PCMCIA_LOAD_CIS */
787 static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
796 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
797 const struct pcmcia_device_id *did)
799 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
800 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
804 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
805 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
809 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
810 if (dev->func != did->function)
814 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
815 if (!dev->prod_id[0])
817 if (strcmp(did->prod_id[0], dev->prod_id[0]))
821 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
822 if (!dev->prod_id[1])
824 if (strcmp(did->prod_id[1], dev->prod_id[1]))
828 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
829 if (!dev->prod_id[2])
831 if (strcmp(did->prod_id[2], dev->prod_id[2]))
835 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
836 if (!dev->prod_id[3])
838 if (strcmp(did->prod_id[3], dev->prod_id[3]))
842 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
843 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
844 mutex_lock(&dev->socket->ops_mutex);
845 dev->socket->pcmcia_pfc = 1;
846 mutex_unlock(&dev->socket->ops_mutex);
847 if (dev->device_no != did->device_no)
851 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
854 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
857 /* if this is a pseudo-multi-function device,
858 * we need explicit matches */
859 if (dev->socket->pcmcia_pfc)
864 /* also, FUNC_ID matching needs to be activated by userspace
865 * after it has re-checked that there is no possible module
866 * with a prod_id/manf_id/card_id match.
868 mutex_lock(&dev->socket->ops_mutex);
869 ret = dev->allow_func_id_match;
870 mutex_unlock(&dev->socket->ops_mutex);
874 "skipping FUNC_ID match until userspace ACK\n");
879 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
880 dev_dbg(&dev->dev, "device needs a fake CIS\n");
881 if (!dev->socket->fake_cis)
882 if (pcmcia_load_firmware(dev, did->cisfile))
886 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
888 for (i = 0; i < 4; i++)
891 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
899 static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
901 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
902 struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
903 const struct pcmcia_device_id *did = p_drv->id_table;
904 struct pcmcia_dynid *dynid;
906 /* match dynamic devices first */
907 mutex_lock(&p_drv->dynids.lock);
908 list_for_each_entry(dynid, &p_drv->dynids.list, node) {
909 dev_dbg(dev, "trying to match to %s\n", drv->name);
910 if (pcmcia_devmatch(p_dev, &dynid->id)) {
911 dev_dbg(dev, "matched to %s\n", drv->name);
912 mutex_unlock(&p_drv->dynids.lock);
916 mutex_unlock(&p_drv->dynids.lock);
918 while (did && did->match_flags) {
919 dev_dbg(dev, "trying to match to %s\n", drv->name);
920 if (pcmcia_devmatch(p_dev, did)) {
921 dev_dbg(dev, "matched to %s\n", drv->name);
930 static int pcmcia_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
932 const struct pcmcia_device *p_dev;
934 u32 hash[4] = { 0, 0, 0, 0};
939 p_dev = to_pcmcia_dev(dev);
941 /* calculate hashes */
942 for (i = 0; i < 4; i++) {
943 if (!p_dev->prod_id[i])
945 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
948 if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
951 if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
954 if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
955 "pa%08Xpb%08Xpc%08Xpd%08X",
956 p_dev->has_manf_id ? p_dev->manf_id : 0,
957 p_dev->has_card_id ? p_dev->card_id : 0,
958 p_dev->has_func_id ? p_dev->func_id : 0,
970 /************************ runtime PM support ***************************/
972 static int pcmcia_dev_suspend(struct device *dev);
973 static int pcmcia_dev_resume(struct device *dev);
975 static int runtime_suspend(struct device *dev)
980 rc = pcmcia_dev_suspend(dev);
985 static int runtime_resume(struct device *dev)
990 rc = pcmcia_dev_resume(dev);
995 /************************ per-device sysfs output ***************************/
997 #define pcmcia_device_attr(field, test, format) \
998 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
1000 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
1001 return p_dev->test ? sysfs_emit(buf, format, p_dev->field) : -ENODEV; \
1003 static DEVICE_ATTR_RO(field);
1005 #define pcmcia_device_stringattr(name, field) \
1006 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
1008 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
1009 return p_dev->field ? sysfs_emit(buf, "%s\n", p_dev->field) : -ENODEV; \
1011 static DEVICE_ATTR_RO(name);
1013 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
1014 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
1015 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
1016 pcmcia_device_stringattr(prod_id1, prod_id[0]);
1017 pcmcia_device_stringattr(prod_id2, prod_id[1]);
1018 pcmcia_device_stringattr(prod_id3, prod_id[2]);
1019 pcmcia_device_stringattr(prod_id4, prod_id[3]);
1021 static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1024 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1025 return p_dev->socket ? sysfs_emit(buf, "0x%02x\n", p_dev->func) : -ENODEV;
1027 static DEVICE_ATTR_RO(function);
1029 static ssize_t resources_show(struct device *dev,
1030 struct device_attribute *attr, char *buf)
1032 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1035 for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1036 at += sysfs_emit_at(buf, at, "%pr\n", p_dev->resource[i]);
1040 static DEVICE_ATTR_RO(resources);
1042 static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1044 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1046 if (p_dev->suspended)
1047 return sysfs_emit(buf, "off\n");
1049 return sysfs_emit(buf, "on\n");
1052 static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1053 const char *buf, size_t count)
1055 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1061 if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
1062 ret = runtime_suspend(dev);
1063 else if (p_dev->suspended && !strncmp(buf, "on", 2))
1064 ret = runtime_resume(dev);
1066 return ret ? ret : count;
1068 static DEVICE_ATTR_RW(pm_state);
1070 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1072 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1074 u32 hash[4] = { 0, 0, 0, 0};
1076 /* calculate hashes */
1077 for (i = 0; i < 4; i++) {
1078 if (!p_dev->prod_id[i])
1080 hash[i] = crc32(0, p_dev->prod_id[i],
1081 strlen(p_dev->prod_id[i]));
1083 return sysfs_emit(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02Xpa%08Xpb%08Xpc%08Xpd%08X\n",
1084 p_dev->has_manf_id ? p_dev->manf_id : 0,
1085 p_dev->has_card_id ? p_dev->card_id : 0,
1086 p_dev->has_func_id ? p_dev->func_id : 0,
1087 p_dev->func, p_dev->device_no,
1088 hash[0], hash[1], hash[2], hash[3]);
1090 static DEVICE_ATTR_RO(modalias);
1092 static ssize_t allow_func_id_match_store(struct device *dev,
1093 struct device_attribute *attr, const char *buf, size_t count)
1095 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1100 mutex_lock(&p_dev->socket->ops_mutex);
1101 p_dev->allow_func_id_match = 1;
1102 mutex_unlock(&p_dev->socket->ops_mutex);
1103 pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY);
1107 static DEVICE_ATTR_WO(allow_func_id_match);
1109 static struct attribute *pcmcia_dev_attrs[] = {
1110 &dev_attr_resources.attr,
1111 &dev_attr_pm_state.attr,
1112 &dev_attr_function.attr,
1113 &dev_attr_func_id.attr,
1114 &dev_attr_manf_id.attr,
1115 &dev_attr_card_id.attr,
1116 &dev_attr_prod_id1.attr,
1117 &dev_attr_prod_id2.attr,
1118 &dev_attr_prod_id3.attr,
1119 &dev_attr_prod_id4.attr,
1120 &dev_attr_modalias.attr,
1121 &dev_attr_allow_func_id_match.attr,
1124 ATTRIBUTE_GROUPS(pcmcia_dev);
1126 /* PM support, also needed for reset */
1128 static int pcmcia_dev_suspend(struct device *dev)
1130 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1131 struct pcmcia_driver *p_drv = NULL;
1134 mutex_lock(&p_dev->socket->ops_mutex);
1135 if (p_dev->suspended) {
1136 mutex_unlock(&p_dev->socket->ops_mutex);
1139 p_dev->suspended = 1;
1140 mutex_unlock(&p_dev->socket->ops_mutex);
1142 dev_dbg(dev, "suspending\n");
1145 p_drv = to_pcmcia_drv(dev->driver);
1150 if (p_drv->suspend) {
1151 ret = p_drv->suspend(p_dev);
1154 "pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n",
1155 p_dev->devname, p_drv->name, ret);
1156 mutex_lock(&p_dev->socket->ops_mutex);
1157 p_dev->suspended = 0;
1158 mutex_unlock(&p_dev->socket->ops_mutex);
1163 if (p_dev->device_no == p_dev->func) {
1164 dev_dbg(dev, "releasing configuration\n");
1165 pcmcia_release_configuration(p_dev);
1173 static int pcmcia_dev_resume(struct device *dev)
1175 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1176 struct pcmcia_driver *p_drv = NULL;
1179 mutex_lock(&p_dev->socket->ops_mutex);
1180 if (!p_dev->suspended) {
1181 mutex_unlock(&p_dev->socket->ops_mutex);
1184 p_dev->suspended = 0;
1185 mutex_unlock(&p_dev->socket->ops_mutex);
1187 dev_dbg(dev, "resuming\n");
1190 p_drv = to_pcmcia_drv(dev->driver);
1195 if (p_dev->device_no == p_dev->func) {
1196 dev_dbg(dev, "requesting configuration\n");
1197 ret = pcmcia_enable_device(p_dev);
1203 ret = p_drv->resume(p_dev);
1210 static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)
1212 struct pcmcia_socket *skt = _data;
1213 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1215 if (p_dev->socket != skt || p_dev->suspended)
1218 return runtime_suspend(dev);
1221 static int pcmcia_bus_resume_callback(struct device *dev, void *_data)
1223 struct pcmcia_socket *skt = _data;
1224 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1226 if (p_dev->socket != skt || !p_dev->suspended)
1229 runtime_resume(dev);
1234 static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1236 dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock);
1237 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);
1241 static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1243 dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock);
1244 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,
1245 pcmcia_bus_suspend_callback)) {
1246 pcmcia_bus_resume(skt);
1252 static int pcmcia_bus_remove(struct pcmcia_socket *skt)
1254 atomic_set(&skt->present, 0);
1255 pcmcia_card_remove(skt, NULL);
1257 mutex_lock(&skt->ops_mutex);
1258 destroy_cis_cache(skt);
1259 pcmcia_cleanup_irq(skt);
1260 mutex_unlock(&skt->ops_mutex);
1265 static int pcmcia_bus_add(struct pcmcia_socket *skt)
1267 atomic_set(&skt->present, 1);
1269 mutex_lock(&skt->ops_mutex);
1270 skt->pcmcia_pfc = 0;
1271 destroy_cis_cache(skt); /* to be on the safe side... */
1272 mutex_unlock(&skt->ops_mutex);
1274 pcmcia_card_add(skt);
1279 static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
1281 if (!verify_cis_cache(skt))
1284 dev_dbg(&skt->dev, "cis mismatch - different card\n");
1286 /* first, remove the card */
1287 pcmcia_bus_remove(skt);
1289 mutex_lock(&skt->ops_mutex);
1290 destroy_cis_cache(skt);
1291 kfree(skt->fake_cis);
1292 skt->fake_cis = NULL;
1294 mutex_unlock(&skt->ops_mutex);
1296 /* now, add the new card */
1297 pcmcia_bus_add(skt);
1303 * NOTE: This is racy. There's no guarantee the card will still be
1304 * physically present, even if the call to this function returns
1305 * non-NULL. Furthermore, the device driver most likely is unbound
1306 * almost immediately, so the timeframe where pcmcia_dev_present
1307 * returns NULL is probably really really small.
1309 struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)
1311 struct pcmcia_device *p_dev;
1312 struct pcmcia_device *ret = NULL;
1314 p_dev = pcmcia_get_dev(_p_dev);
1318 if (atomic_read(&p_dev->socket->present) != 0)
1321 pcmcia_put_dev(p_dev);
1324 EXPORT_SYMBOL(pcmcia_dev_present);
1327 static struct pcmcia_callback pcmcia_bus_callback = {
1328 .owner = THIS_MODULE,
1329 .add = pcmcia_bus_add,
1330 .remove = pcmcia_bus_remove,
1331 .requery = pcmcia_requery,
1332 .validate = pccard_validate_cis,
1333 .suspend = pcmcia_bus_suspend,
1334 .early_resume = pcmcia_bus_early_resume,
1335 .resume = pcmcia_bus_resume,
1338 static int pcmcia_bus_add_socket(struct device *dev,
1339 struct class_interface *class_intf)
1341 struct pcmcia_socket *socket = dev_get_drvdata(dev);
1344 socket = pcmcia_get_socket(socket);
1346 dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1350 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1352 dev_err(dev, "PCMCIA registration failed\n");
1353 pcmcia_put_socket(socket);
1357 INIT_LIST_HEAD(&socket->devices_list);
1358 socket->pcmcia_pfc = 0;
1359 socket->device_count = 0;
1360 atomic_set(&socket->present, 0);
1362 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1364 dev_err(dev, "PCMCIA registration failed\n");
1365 pcmcia_put_socket(socket);
1372 static void pcmcia_bus_remove_socket(struct device *dev,
1373 struct class_interface *class_intf)
1375 struct pcmcia_socket *socket = dev_get_drvdata(dev);
1380 pccard_register_pcmcia(socket, NULL);
1382 /* unregister any unbound devices */
1383 mutex_lock(&socket->skt_mutex);
1384 pcmcia_card_remove(socket, NULL);
1385 release_cis_mem(socket);
1386 mutex_unlock(&socket->skt_mutex);
1388 sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
1390 pcmcia_put_socket(socket);
1396 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1397 static struct class_interface pcmcia_bus_interface __refdata = {
1398 .class = &pcmcia_socket_class,
1399 .add_dev = &pcmcia_bus_add_socket,
1400 .remove_dev = &pcmcia_bus_remove_socket,
1403 static const struct dev_pm_ops pcmcia_bus_pm_ops = {
1404 SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)
1407 struct bus_type pcmcia_bus_type = {
1409 .uevent = pcmcia_bus_uevent,
1410 .match = pcmcia_bus_match,
1411 .dev_groups = pcmcia_dev_groups,
1412 .probe = pcmcia_device_probe,
1413 .remove = pcmcia_device_remove,
1414 .pm = &pcmcia_bus_pm_ops,
1418 static int __init init_pcmcia_bus(void)
1422 ret = bus_register(&pcmcia_bus_type);
1424 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);
1427 ret = class_interface_register(&pcmcia_bus_interface);
1430 "pcmcia: class_interface_register error: %d\n", ret);
1431 bus_unregister(&pcmcia_bus_type);
1437 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1438 * pcmcia_socket_class is already registered */
1441 static void __exit exit_pcmcia_bus(void)
1443 class_interface_unregister(&pcmcia_bus_interface);
1445 bus_unregister(&pcmcia_bus_type);
1447 module_exit(exit_pcmcia_bus);