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