xref: /openbmc/linux/drivers/pcmcia/ds.c (revision f1288bdb)
1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   * ds.c -- 16-bit PCMCIA core support
4   *
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.
8   *
9   * (C) 1999		David A. Hinds
10   * (C) 2003 - 2010	Dominik Brodowski
11   */
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  
36  MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
37  MODULE_DESCRIPTION("PCMCIA Driver Services");
38  MODULE_LICENSE("GPL");
39  
40  
41  /*====================================================================*/
42  
43  static 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  
80  struct 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 devices
87   * @driver: target device driver
88   * @buf: buffer for scanning device ID data
89   * @count: input size
90   *
91   * Adds a new dynamic PCMCIA device ID to this driver,
92   * and causes the driver to probe for all devices again.
93   */
94  static ssize_t
95  new_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  }
133  static DRIVER_ATTR_WO(new_id);
134  
135  static void
136  pcmcia_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  
148  static int
149  pcmcia_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  
157  static void
158  pcmcia_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 core
165   * @driver: the &driver being registered
166   *
167   * Registers a PCMCIA driver with the PCMCIA bus core.
168   */
169  int 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  }
197  EXPORT_SYMBOL(pcmcia_register_driver);
198  
199  /**
200   * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
201   * @driver: the &driver being unregistered
202   */
203  void 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  }
210  EXPORT_SYMBOL(pcmcia_unregister_driver);
211  
212  
213  /* pcmcia_device handling */
214  
215  static 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  
224  static void pcmcia_put_dev(struct pcmcia_device *p_dev)
225  {
226  	if (p_dev)
227  		put_device(&p_dev->dev);
228  }
229  
230  static 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  
237  static 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  
251  static 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  
308  put_module:
309  	if (ret)
310  		module_put(p_drv->owner);
311  put_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   */
321  static 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  	else
334  		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  
353  static 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 a
365  	 * pseudo multi-function card, we need to unbind
366  	 * all devices
367  	 */
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 device
397   */
398  static 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 with
427  		 * common memory device geometry information, are
428  		 * 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  
479  static 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  	dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
517  	if (!dev_name(&p_dev->dev))
518  		goto err_free;
519  	p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
520  	if (!p_dev->devname)
521  		goto err_free;
522  	dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
523  
524  	mutex_lock(&s->ops_mutex);
525  
526  	/*
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.
530  	 */
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);
536  		}
537  
538  	/* Add to the list in pcmcia_bus_socket */
539  	list_add(&p_dev->socket_device_list, &s->devices_list);
540  
541  	if (pcmcia_setup_irq(p_dev))
542  		dev_warn(&p_dev->dev,
543  			"IRQ setup failed -- device might not work\n");
544  
545  	if (!p_dev->function_config) {
546  		config_t *c;
547  		dev_dbg(&p_dev->dev, "creating config_t\n");
548  		c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
549  		if (!c) {
550  			mutex_unlock(&s->ops_mutex);
551  			goto err_unreg;
552  		}
553  		p_dev->function_config = c;
554  		kref_init(&c->ref);
555  		for (i = 0; i < MAX_IO_WIN; i++) {
556  			c->io[i].name = p_dev->devname;
557  			c->io[i].flags = IORESOURCE_IO;
558  		}
559  		for (i = 0; i < MAX_WIN; i++) {
560  			c->mem[i].name = p_dev->devname;
561  			c->mem[i].flags = IORESOURCE_MEM;
562  		}
563  	}
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];
568  
569  	mutex_unlock(&s->ops_mutex);
570  
571  	dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
572  		   p_dev->devname, p_dev->irq);
573  
574  	pcmcia_device_query(p_dev);
575  
576  	if (device_register(&p_dev->dev))
577  		goto err_unreg;
578  
579  	return p_dev;
580  
581   err_unreg:
582  	mutex_lock(&s->ops_mutex);
583  	list_del(&p_dev->socket_device_list);
584  	mutex_unlock(&s->ops_mutex);
585  
586   err_free:
587  	mutex_lock(&s->ops_mutex);
588  	s->device_count--;
589  	mutex_unlock(&s->ops_mutex);
590  
591  	for (i = 0; i < 4; i++)
592  		kfree(p_dev->prod_id[i]);
593  	kfree(p_dev->devname);
594  	kfree(p_dev);
595   err_put:
596  	pcmcia_put_socket(s);
597  
598  	return NULL;
599  }
600  
601  
602  static int pcmcia_card_add(struct pcmcia_socket *s)
603  {
604  	cistpl_longlink_mfc_t mfc;
605  	unsigned int no_funcs, i, no_chains;
606  	int ret = -EAGAIN;
607  
608  	mutex_lock(&s->ops_mutex);
609  	if (!(s->resource_setup_done)) {
610  		dev_dbg(&s->dev,
611  			   "no resources available, delaying card_add\n");
612  		mutex_unlock(&s->ops_mutex);
613  		return -EAGAIN; /* try again, but later... */
614  	}
615  
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... */
621  	}
622  	mutex_unlock(&s->ops_mutex);
623  
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.
630  
631  		   Note: some cards have just a device entry, it may be
632  		   worth extending support to cover these in future */
633  		if (ret == -EIO) {
634  			dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
635  			pcmcia_replace_cis(s, "\xFF", 1);
636  			no_chains = 1;
637  			ret = 0;
638  		} else
639  #endif
640  		{
641  			dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
642  			return -ENODEV;
643  		}
644  	}
645  
646  	if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
647  		no_funcs = mfc.nfn;
648  	else
649  		no_funcs = 1;
650  	s->functions = no_funcs;
651  
652  	for (i = 0; i < no_funcs; i++)
653  		pcmcia_device_add(s, i);
654  
655  	return ret;
656  }
657  
658  
659  static int pcmcia_requery_callback(struct device *dev, void *_data)
660  {
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);
665  	}
666  
667  	return 0;
668  }
669  
670  
671  static void pcmcia_requery(struct pcmcia_socket *s)
672  {
673  	int has_pfc;
674  
675  	if (!(s->state & SOCKET_PRESENT))
676  		return;
677  
678  	if (s->functions == 0) {
679  		pcmcia_card_add(s);
680  		return;
681  	}
682  
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);
687  
688  	/* if the CIS changed, we need to check whether the number of
689  	 * functions changed. */
690  	if (s->fake_cis) {
691  		int old_funcs, new_funcs;
692  		cistpl_longlink_mfc_t mfc;
693  
694  		/* does this cis override add or remove functions? */
695  		old_funcs = s->functions;
696  
697  		if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
698  					&mfc))
699  			new_funcs = mfc.nfn;
700  		else
701  			new_funcs = 1;
702  		if (old_funcs != new_funcs) {
703  			/* we need to re-start */
704  			pcmcia_card_remove(s, NULL);
705  			s->functions = 0;
706  			pcmcia_card_add(s);
707  		}
708  	}
709  
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);
716  	if (has_pfc)
717  		pcmcia_device_add(s, 0);
718  
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");
723  }
724  
725  
726  #ifdef CONFIG_PCMCIA_LOAD_CIS
727  
728  /**
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/
732   *
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.
736   */
737  static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
738  {
739  	struct pcmcia_socket *s = dev->socket;
740  	const struct firmware *fw;
741  	int ret = -ENOMEM;
742  	cistpl_longlink_mfc_t mfc;
743  	int old_funcs, new_funcs = 1;
744  
745  	if (!filename)
746  		return -EINVAL;
747  
748  	dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
749  
750  	if (request_firmware(&fw, filename, &dev->dev) == 0) {
751  		if (fw->size >= CISTPL_MAX_CIS_SIZE) {
752  			ret = -EINVAL;
753  			dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
754  			goto release;
755  		}
756  
757  		if (!pcmcia_replace_cis(s, fw->data, fw->size))
758  			ret = 0;
759  		else {
760  			dev_err(&dev->dev, "pcmcia: CIS override failed\n");
761  			goto release;
762  		}
763  
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,
767  					&mfc))
768  			new_funcs = mfc.nfn;
769  
770  		if (old_funcs != new_funcs)
771  			ret = -EBUSY;
772  
773  		/* update information */
774  		pcmcia_device_query(dev);
775  
776  		/* requery (as number of functions might have changed) */
777  		pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
778  	}
779   release:
780  	release_firmware(fw);
781  
782  	return ret;
783  }
784  
785  #else /* !CONFIG_PCMCIA_LOAD_CIS */
786  
787  static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
788  				       char *filename)
789  {
790  	return -ENODEV;
791  }
792  
793  #endif
794  
795  
796  static inline int pcmcia_devmatch(struct pcmcia_device *dev,
797  				  const struct pcmcia_device_id *did)
798  {
799  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
800  		if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
801  			return 0;
802  	}
803  
804  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
805  		if ((!dev->has_card_id) || (dev->card_id != did->card_id))
806  			return 0;
807  	}
808  
809  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
810  		if (dev->func != did->function)
811  			return 0;
812  	}
813  
814  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
815  		if (!dev->prod_id[0])
816  			return 0;
817  		if (strcmp(did->prod_id[0], dev->prod_id[0]))
818  			return 0;
819  	}
820  
821  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
822  		if (!dev->prod_id[1])
823  			return 0;
824  		if (strcmp(did->prod_id[1], dev->prod_id[1]))
825  			return 0;
826  	}
827  
828  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
829  		if (!dev->prod_id[2])
830  			return 0;
831  		if (strcmp(did->prod_id[2], dev->prod_id[2]))
832  			return 0;
833  	}
834  
835  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
836  		if (!dev->prod_id[3])
837  			return 0;
838  		if (strcmp(did->prod_id[3], dev->prod_id[3]))
839  			return 0;
840  	}
841  
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)
848  			return 0;
849  	}
850  
851  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
852  		int ret;
853  
854  		if ((!dev->has_func_id) || (dev->func_id != did->func_id))
855  			return 0;
856  
857  		/* if this is a pseudo-multi-function device,
858  		 * we need explicit matches */
859  		if (dev->socket->pcmcia_pfc)
860  			return 0;
861  		if (dev->device_no)
862  			return 0;
863  
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.
867  		 */
868  		mutex_lock(&dev->socket->ops_mutex);
869  		ret = dev->allow_func_id_match;
870  		mutex_unlock(&dev->socket->ops_mutex);
871  
872  		if (!ret) {
873  			dev_dbg(&dev->dev,
874  				"skipping FUNC_ID match until userspace ACK\n");
875  			return 0;
876  		}
877  	}
878  
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))
883  				return 0;
884  	}
885  
886  	if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
887  		int i;
888  		for (i = 0; i < 4; i++)
889  			if (dev->prod_id[i])
890  				return 0;
891  		if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
892  			return 0;
893  	}
894  
895  	return 1;
896  }
897  
898  
899  static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
900  {
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;
905  
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);
913  			return 1;
914  		}
915  	}
916  	mutex_unlock(&p_drv->dynids.lock);
917  
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);
922  			return 1;
923  		}
924  		did++;
925  	}
926  
927  	return 0;
928  }
929  
930  static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
931  {
932  	struct pcmcia_device *p_dev;
933  	int i;
934  	u32 hash[4] = { 0, 0, 0, 0};
935  
936  	if (!dev)
937  		return -ENODEV;
938  
939  	p_dev = to_pcmcia_dev(dev);
940  
941  	/* calculate hashes */
942  	for (i = 0; i < 4; i++) {
943  		if (!p_dev->prod_id[i])
944  			continue;
945  		hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
946  	}
947  
948  	if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
949  		return -ENOMEM;
950  
951  	if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
952  		return -ENOMEM;
953  
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,
959  			   p_dev->func,
960  			   p_dev->device_no,
961  			   hash[0],
962  			   hash[1],
963  			   hash[2],
964  			   hash[3]))
965  		return -ENOMEM;
966  
967  	return 0;
968  }
969  
970  /************************ runtime PM support ***************************/
971  
972  static int pcmcia_dev_suspend(struct device *dev);
973  static int pcmcia_dev_resume(struct device *dev);
974  
975  static int runtime_suspend(struct device *dev)
976  {
977  	int rc;
978  
979  	device_lock(dev);
980  	rc = pcmcia_dev_suspend(dev);
981  	device_unlock(dev);
982  	return rc;
983  }
984  
985  static int runtime_resume(struct device *dev)
986  {
987  	int rc;
988  
989  	device_lock(dev);
990  	rc = pcmcia_dev_resume(dev);
991  	device_unlock(dev);
992  	return rc;
993  }
994  
995  /************************ per-device sysfs output ***************************/
996  
997  #define pcmcia_device_attr(field, test, format)				\
998  static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)		\
999  {									\
1000  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);		\
1001  	return p_dev->test ? sysfs_emit(buf, format, p_dev->field) : -ENODEV; \
1002  }									\
1003  static DEVICE_ATTR_RO(field);
1004  
1005  #define pcmcia_device_stringattr(name, field)					\
1006  static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)		\
1007  {									\
1008  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);		\
1009  	return p_dev->field ? sysfs_emit(buf, "%s\n", p_dev->field) : -ENODEV; \
1010  }									\
1011  static DEVICE_ATTR_RO(name);
1012  
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]);
1020  
1021  static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1022  			     char *buf)
1023  {
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;
1026  }
1027  static DEVICE_ATTR_RO(function);
1028  
1029  static ssize_t resources_show(struct device *dev,
1030  			      struct device_attribute *attr, char *buf)
1031  {
1032  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1033  	int i, at = 0;
1034  
1035  	for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1036  		at += sysfs_emit_at(buf, at, "%pr\n", p_dev->resource[i]);
1037  
1038  	return at;
1039  }
1040  static DEVICE_ATTR_RO(resources);
1041  
1042  static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1043  {
1044  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1045  
1046  	if (p_dev->suspended)
1047  		return sysfs_emit(buf, "off\n");
1048  	else
1049  		return sysfs_emit(buf, "on\n");
1050  }
1051  
1052  static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1053  			      const char *buf, size_t count)
1054  {
1055  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1056  	int ret = 0;
1057  
1058  	if (!count)
1059  		return -EINVAL;
1060  
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);
1065  
1066  	return ret ? ret : count;
1067  }
1068  static DEVICE_ATTR_RW(pm_state);
1069  
1070  static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1071  {
1072  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1073  	int i;
1074  	u32 hash[4] = { 0, 0, 0, 0};
1075  
1076  	/* calculate hashes */
1077  	for (i = 0; i < 4; i++) {
1078  		if (!p_dev->prod_id[i])
1079  			continue;
1080  		hash[i] = crc32(0, p_dev->prod_id[i],
1081  				strlen(p_dev->prod_id[i]));
1082  	}
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]);
1089  }
1090  static DEVICE_ATTR_RO(modalias);
1091  
1092  static ssize_t allow_func_id_match_store(struct device *dev,
1093  		struct device_attribute *attr, const char *buf, size_t count)
1094  {
1095  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1096  
1097  	if (!count)
1098  		return -EINVAL;
1099  
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);
1104  
1105  	return count;
1106  }
1107  static DEVICE_ATTR_WO(allow_func_id_match);
1108  
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,
1122  	NULL,
1123  };
1124  ATTRIBUTE_GROUPS(pcmcia_dev);
1125  
1126  /* PM support, also needed for reset */
1127  
1128  static int pcmcia_dev_suspend(struct device *dev)
1129  {
1130  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1131  	struct pcmcia_driver *p_drv = NULL;
1132  	int ret = 0;
1133  
1134  	mutex_lock(&p_dev->socket->ops_mutex);
1135  	if (p_dev->suspended) {
1136  		mutex_unlock(&p_dev->socket->ops_mutex);
1137  		return 0;
1138  	}
1139  	p_dev->suspended = 1;
1140  	mutex_unlock(&p_dev->socket->ops_mutex);
1141  
1142  	dev_dbg(dev, "suspending\n");
1143  
1144  	if (dev->driver)
1145  		p_drv = to_pcmcia_drv(dev->driver);
1146  
1147  	if (!p_drv)
1148  		goto out;
1149  
1150  	if (p_drv->suspend) {
1151  		ret = p_drv->suspend(p_dev);
1152  		if (ret) {
1153  			dev_err(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);
1159  			goto out;
1160  		}
1161  	}
1162  
1163  	if (p_dev->device_no == p_dev->func) {
1164  		dev_dbg(dev, "releasing configuration\n");
1165  		pcmcia_release_configuration(p_dev);
1166  	}
1167  
1168   out:
1169  	return ret;
1170  }
1171  
1172  
1173  static int pcmcia_dev_resume(struct device *dev)
1174  {
1175  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1176  	struct pcmcia_driver *p_drv = NULL;
1177  	int ret = 0;
1178  
1179  	mutex_lock(&p_dev->socket->ops_mutex);
1180  	if (!p_dev->suspended) {
1181  		mutex_unlock(&p_dev->socket->ops_mutex);
1182  		return 0;
1183  	}
1184  	p_dev->suspended = 0;
1185  	mutex_unlock(&p_dev->socket->ops_mutex);
1186  
1187  	dev_dbg(dev, "resuming\n");
1188  
1189  	if (dev->driver)
1190  		p_drv = to_pcmcia_drv(dev->driver);
1191  
1192  	if (!p_drv)
1193  		goto out;
1194  
1195  	if (p_dev->device_no == p_dev->func) {
1196  		dev_dbg(dev, "requesting configuration\n");
1197  		ret = pcmcia_enable_device(p_dev);
1198  		if (ret)
1199  			goto out;
1200  	}
1201  
1202  	if (p_drv->resume)
1203  		ret = p_drv->resume(p_dev);
1204  
1205   out:
1206  	return ret;
1207  }
1208  
1209  
1210  static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)
1211  {
1212  	struct pcmcia_socket *skt = _data;
1213  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1214  
1215  	if (p_dev->socket != skt || p_dev->suspended)
1216  		return 0;
1217  
1218  	return runtime_suspend(dev);
1219  }
1220  
1221  static int pcmcia_bus_resume_callback(struct device *dev, void *_data)
1222  {
1223  	struct pcmcia_socket *skt = _data;
1224  	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1225  
1226  	if (p_dev->socket != skt || !p_dev->suspended)
1227  		return 0;
1228  
1229  	runtime_resume(dev);
1230  
1231  	return 0;
1232  }
1233  
1234  static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1235  {
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);
1238  	return 0;
1239  }
1240  
1241  static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1242  {
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);
1247  		return -EIO;
1248  	}
1249  	return 0;
1250  }
1251  
1252  static int pcmcia_bus_remove(struct pcmcia_socket *skt)
1253  {
1254  	atomic_set(&skt->present, 0);
1255  	pcmcia_card_remove(skt, NULL);
1256  
1257  	mutex_lock(&skt->ops_mutex);
1258  	destroy_cis_cache(skt);
1259  	pcmcia_cleanup_irq(skt);
1260  	mutex_unlock(&skt->ops_mutex);
1261  
1262  	return 0;
1263  }
1264  
1265  static int pcmcia_bus_add(struct pcmcia_socket *skt)
1266  {
1267  	atomic_set(&skt->present, 1);
1268  
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);
1273  
1274  	pcmcia_card_add(skt);
1275  
1276  	return 0;
1277  }
1278  
1279  static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
1280  {
1281  	if (!verify_cis_cache(skt))
1282  		return 0;
1283  
1284  	dev_dbg(&skt->dev, "cis mismatch - different card\n");
1285  
1286  	/* first, remove the card */
1287  	pcmcia_bus_remove(skt);
1288  
1289  	mutex_lock(&skt->ops_mutex);
1290  	destroy_cis_cache(skt);
1291  	kfree(skt->fake_cis);
1292  	skt->fake_cis = NULL;
1293  	skt->functions = 0;
1294  	mutex_unlock(&skt->ops_mutex);
1295  
1296  	/* now, add the new card */
1297  	pcmcia_bus_add(skt);
1298  	return 0;
1299  }
1300  
1301  
1302  /*
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.
1308   */
1309  struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)
1310  {
1311  	struct pcmcia_device *p_dev;
1312  	struct pcmcia_device *ret = NULL;
1313  
1314  	p_dev = pcmcia_get_dev(_p_dev);
1315  	if (!p_dev)
1316  		return NULL;
1317  
1318  	if (atomic_read(&p_dev->socket->present) != 0)
1319  		ret = p_dev;
1320  
1321  	pcmcia_put_dev(p_dev);
1322  	return ret;
1323  }
1324  EXPORT_SYMBOL(pcmcia_dev_present);
1325  
1326  
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,
1336  };
1337  
1338  static int pcmcia_bus_add_socket(struct device *dev,
1339  					   struct class_interface *class_intf)
1340  {
1341  	struct pcmcia_socket *socket = dev_get_drvdata(dev);
1342  	int ret;
1343  
1344  	socket = pcmcia_get_socket(socket);
1345  	if (!socket) {
1346  		dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1347  		return -ENODEV;
1348  	}
1349  
1350  	ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1351  	if (ret) {
1352  		dev_err(dev, "PCMCIA registration failed\n");
1353  		pcmcia_put_socket(socket);
1354  		return ret;
1355  	}
1356  
1357  	INIT_LIST_HEAD(&socket->devices_list);
1358  	socket->pcmcia_pfc = 0;
1359  	socket->device_count = 0;
1360  	atomic_set(&socket->present, 0);
1361  
1362  	ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1363  	if (ret) {
1364  		dev_err(dev, "PCMCIA registration failed\n");
1365  		pcmcia_put_socket(socket);
1366  		return ret;
1367  	}
1368  
1369  	return 0;
1370  }
1371  
1372  static void pcmcia_bus_remove_socket(struct device *dev,
1373  				     struct class_interface *class_intf)
1374  {
1375  	struct pcmcia_socket *socket = dev_get_drvdata(dev);
1376  
1377  	if (!socket)
1378  		return;
1379  
1380  	pccard_register_pcmcia(socket, NULL);
1381  
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);
1387  
1388  	sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
1389  
1390  	pcmcia_put_socket(socket);
1391  
1392  	return;
1393  }
1394  
1395  
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,
1401  };
1402  
1403  static const struct dev_pm_ops pcmcia_bus_pm_ops = {
1404  	SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)
1405  };
1406  
1407  struct bus_type pcmcia_bus_type = {
1408  	.name = "pcmcia",
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,
1415  };
1416  
1417  
1418  static int __init init_pcmcia_bus(void)
1419  {
1420  	int ret;
1421  
1422  	ret = bus_register(&pcmcia_bus_type);
1423  	if (ret < 0) {
1424  		printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);
1425  		return ret;
1426  	}
1427  	ret = class_interface_register(&pcmcia_bus_interface);
1428  	if (ret < 0) {
1429  		printk(KERN_WARNING
1430  			"pcmcia: class_interface_register error: %d\n", ret);
1431  		bus_unregister(&pcmcia_bus_type);
1432  		return ret;
1433  	}
1434  
1435  	return 0;
1436  }
1437  fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1438  			       * pcmcia_socket_class is already registered */
1439  
1440  
1441  static void __exit exit_pcmcia_bus(void)
1442  {
1443  	class_interface_unregister(&pcmcia_bus_interface);
1444  
1445  	bus_unregister(&pcmcia_bus_type);
1446  }
1447  module_exit(exit_pcmcia_bus);
1448  
1449  
1450  MODULE_ALIAS("ds");
1451