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 
pcmcia_check_driver(struct pcmcia_driver * p_drv)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
new_id_store(struct device_driver * driver,const char * buf,size_t count)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
pcmcia_free_dynids(struct pcmcia_driver * drv)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
pcmcia_create_newid_file(struct pcmcia_driver * drv)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
pcmcia_remove_newid_file(struct pcmcia_driver * drv)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  */
pcmcia_register_driver(struct pcmcia_driver * driver)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  */
pcmcia_unregister_driver(struct pcmcia_driver * driver)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 
pcmcia_get_dev(struct pcmcia_device * p_dev)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 
pcmcia_put_dev(struct pcmcia_device * p_dev)224 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
225 {
226 	if (p_dev)
227 		put_device(&p_dev->dev);
228 }
229 
pcmcia_release_function(struct kref * ref)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 
pcmcia_release_dev(struct device * dev)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 
pcmcia_device_probe(struct device * dev)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  */
pcmcia_card_remove(struct pcmcia_socket * s,struct pcmcia_device * leftover)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 
pcmcia_device_remove(struct device * dev)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  */
pcmcia_device_query(struct pcmcia_device * p_dev)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 
pcmcia_device_add(struct pcmcia_socket * s,unsigned int function)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 
pcmcia_card_add(struct pcmcia_socket * s)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 
pcmcia_requery_callback(struct device * dev,void * _data)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 
pcmcia_requery(struct pcmcia_socket * s)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  */
pcmcia_load_firmware(struct pcmcia_device * dev,char * filename)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 
pcmcia_load_firmware(struct pcmcia_device * dev,char * filename)787 static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
788 				       char *filename)
789 {
790 	return -ENODEV;
791 }
792 
793 #endif
794 
795 
pcmcia_devmatch(struct pcmcia_device * dev,const struct pcmcia_device_id * did)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 
pcmcia_bus_match(struct device * dev,struct device_driver * drv)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 
pcmcia_bus_uevent(struct device * dev,struct kobj_uevent_env * env)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 
runtime_suspend(struct device * dev)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 
runtime_resume(struct device * dev)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 
function_show(struct device * dev,struct device_attribute * attr,char * buf)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 
resources_show(struct device * dev,struct device_attribute * attr,char * buf)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 
pm_state_show(struct device * dev,struct device_attribute * attr,char * buf)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 
pm_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)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 
allow_func_id_match_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 
pcmcia_dev_suspend(struct device * dev)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 
pcmcia_dev_resume(struct device * dev)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 
pcmcia_bus_suspend_callback(struct device * dev,void * _data)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 
pcmcia_bus_resume_callback(struct device * dev,void * _data)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 
pcmcia_bus_resume(struct pcmcia_socket * skt)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 
pcmcia_bus_suspend(struct pcmcia_socket * skt)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 
pcmcia_bus_remove(struct pcmcia_socket * skt)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 
pcmcia_bus_add(struct pcmcia_socket * skt)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 
pcmcia_bus_early_resume(struct pcmcia_socket * skt)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  */
pcmcia_dev_present(struct pcmcia_device * _p_dev)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 
pcmcia_bus_add_socket(struct device * dev,struct class_interface * class_intf)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 
pcmcia_bus_remove_socket(struct device * dev,struct class_interface * class_intf)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 
init_pcmcia_bus(void)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 
exit_pcmcia_bus(void)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