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