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