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