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