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