]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/pcmcia/ds.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] pcmcia: add a config option for the PCMICA ioctl
[mirror_ubuntu-artful-kernel.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 - 2004 Dominik Brodowski
14 */
15
16 #include <linux/config.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/major.h>
22 #include <linux/string.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <linux/mm.h>
26 #include <linux/fcntl.h>
27 #include <linux/sched.h>
28 #include <linux/smp_lock.h>
29 #include <linux/timer.h>
30 #include <linux/ioctl.h>
31 #include <linux/proc_fs.h>
32 #include <linux/poll.h>
33 #include <linux/pci.h>
34 #include <linux/list.h>
35 #include <linux/delay.h>
36 #include <linux/kref.h>
37 #include <linux/workqueue.h>
38 #include <linux/crc32.h>
39 #include <linux/firmware.h>
40
41 #include <asm/atomic.h>
42
43 #define IN_CARD_SERVICES
44 #include <pcmcia/version.h>
45 #include <pcmcia/cs_types.h>
46 #include <pcmcia/cs.h>
47 #include <pcmcia/bulkmem.h>
48 #include <pcmcia/cistpl.h>
49 #include <pcmcia/ds.h>
50 #include <pcmcia/ss.h>
51
52 #include "cs_internal.h"
53
54 /*====================================================================*/
55
56 /* Module parameters */
57
58 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
59 MODULE_DESCRIPTION("PCMCIA Driver Services");
60 MODULE_LICENSE("GPL");
61
62 #ifdef DEBUG
63 static int ds_pc_debug;
64
65 module_param_named(pc_debug, ds_pc_debug, int, 0644);
66
67 #define ds_dbg(lvl, fmt, arg...) do { \
68 if (ds_pc_debug > (lvl)) \
69 printk(KERN_DEBUG "ds: " fmt , ## arg); \
70 } while (0)
71 #else
72 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
73 #endif
74
75 /*====================================================================*/
76
77 /* Device user information */
78 #define MAX_EVENTS 32
79 #define USER_MAGIC 0x7ea4
80 #define CHECK_USER(u) \
81 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
82 typedef struct user_info_t {
83 u_int user_magic;
84 int event_head, event_tail;
85 event_t event[MAX_EVENTS];
86 struct user_info_t *next;
87 struct pcmcia_bus_socket *socket;
88 } user_info_t;
89
90 /* Socket state information */
91 struct pcmcia_bus_socket {
92 struct kref refcount;
93 struct pcmcia_callback callback;
94 int state;
95 user_info_t *user;
96 wait_queue_head_t queue;
97 struct pcmcia_socket *parent;
98
99 /* the PCMCIA devices connected to this socket (normally one, more
100 * for multifunction devices: */
101 struct list_head devices_list;
102 u8 device_count; /* the number of devices, used
103 * only internally and subject
104 * to incorrectness and change */
105
106 u8 device_add_pending;
107 struct work_struct device_add;
108 };
109 static spinlock_t pcmcia_dev_list_lock;
110
111 static struct bus_type pcmcia_bus_type;
112
113 #define DS_SOCKET_PRESENT 0x01
114 #define DS_SOCKET_BUSY 0x02
115 #define DS_SOCKET_REMOVAL_PENDING 0x10
116 #define DS_SOCKET_DEAD 0x80
117
118 /*====================================================================*/
119 #ifdef CONFIG_PCMCIA_IOCTL
120
121 static int major_dev = -1;
122 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr);
123 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info);
124
125 #endif
126
127 static int unbind_request(struct pcmcia_bus_socket *s);
128
129 /*====================================================================*/
130
131 /* code which was in cs.c before */
132
133 /* String tables for error messages */
134
135 typedef struct lookup_t {
136 int key;
137 char *msg;
138 } lookup_t;
139
140 static const lookup_t error_table[] = {
141 { CS_SUCCESS, "Operation succeeded" },
142 { CS_BAD_ADAPTER, "Bad adapter" },
143 { CS_BAD_ATTRIBUTE, "Bad attribute", },
144 { CS_BAD_BASE, "Bad base address" },
145 { CS_BAD_EDC, "Bad EDC" },
146 { CS_BAD_IRQ, "Bad IRQ" },
147 { CS_BAD_OFFSET, "Bad offset" },
148 { CS_BAD_PAGE, "Bad page number" },
149 { CS_READ_FAILURE, "Read failure" },
150 { CS_BAD_SIZE, "Bad size" },
151 { CS_BAD_SOCKET, "Bad socket" },
152 { CS_BAD_TYPE, "Bad type" },
153 { CS_BAD_VCC, "Bad Vcc" },
154 { CS_BAD_VPP, "Bad Vpp" },
155 { CS_BAD_WINDOW, "Bad window" },
156 { CS_WRITE_FAILURE, "Write failure" },
157 { CS_NO_CARD, "No card present" },
158 { CS_UNSUPPORTED_FUNCTION, "Usupported function" },
159 { CS_UNSUPPORTED_MODE, "Unsupported mode" },
160 { CS_BAD_SPEED, "Bad speed" },
161 { CS_BUSY, "Resource busy" },
162 { CS_GENERAL_FAILURE, "General failure" },
163 { CS_WRITE_PROTECTED, "Write protected" },
164 { CS_BAD_ARG_LENGTH, "Bad argument length" },
165 { CS_BAD_ARGS, "Bad arguments" },
166 { CS_CONFIGURATION_LOCKED, "Configuration locked" },
167 { CS_IN_USE, "Resource in use" },
168 { CS_NO_MORE_ITEMS, "No more items" },
169 { CS_OUT_OF_RESOURCE, "Out of resource" },
170 { CS_BAD_HANDLE, "Bad handle" },
171 { CS_BAD_TUPLE, "Bad CIS tuple" }
172 };
173
174
175 static const lookup_t service_table[] = {
176 { AccessConfigurationRegister, "AccessConfigurationRegister" },
177 { AddSocketServices, "AddSocketServices" },
178 { AdjustResourceInfo, "AdjustResourceInfo" },
179 { CheckEraseQueue, "CheckEraseQueue" },
180 { CloseMemory, "CloseMemory" },
181 { DeregisterClient, "DeregisterClient" },
182 { DeregisterEraseQueue, "DeregisterEraseQueue" },
183 { GetCardServicesInfo, "GetCardServicesInfo" },
184 { GetClientInfo, "GetClientInfo" },
185 { GetConfigurationInfo, "GetConfigurationInfo" },
186 { GetEventMask, "GetEventMask" },
187 { GetFirstClient, "GetFirstClient" },
188 { GetFirstRegion, "GetFirstRegion" },
189 { GetFirstTuple, "GetFirstTuple" },
190 { GetNextClient, "GetNextClient" },
191 { GetNextRegion, "GetNextRegion" },
192 { GetNextTuple, "GetNextTuple" },
193 { GetStatus, "GetStatus" },
194 { GetTupleData, "GetTupleData" },
195 { MapMemPage, "MapMemPage" },
196 { ModifyConfiguration, "ModifyConfiguration" },
197 { ModifyWindow, "ModifyWindow" },
198 { OpenMemory, "OpenMemory" },
199 { ParseTuple, "ParseTuple" },
200 { ReadMemory, "ReadMemory" },
201 { RegisterClient, "RegisterClient" },
202 { RegisterEraseQueue, "RegisterEraseQueue" },
203 { RegisterMTD, "RegisterMTD" },
204 { ReleaseConfiguration, "ReleaseConfiguration" },
205 { ReleaseIO, "ReleaseIO" },
206 { ReleaseIRQ, "ReleaseIRQ" },
207 { ReleaseWindow, "ReleaseWindow" },
208 { RequestConfiguration, "RequestConfiguration" },
209 { RequestIO, "RequestIO" },
210 { RequestIRQ, "RequestIRQ" },
211 { RequestSocketMask, "RequestSocketMask" },
212 { RequestWindow, "RequestWindow" },
213 { ResetCard, "ResetCard" },
214 { SetEventMask, "SetEventMask" },
215 { ValidateCIS, "ValidateCIS" },
216 { WriteMemory, "WriteMemory" },
217 { BindDevice, "BindDevice" },
218 { BindMTD, "BindMTD" },
219 { ReportError, "ReportError" },
220 { SuspendCard, "SuspendCard" },
221 { ResumeCard, "ResumeCard" },
222 { EjectCard, "EjectCard" },
223 { InsertCard, "InsertCard" },
224 { ReplaceCIS, "ReplaceCIS" }
225 };
226
227
228 static int pcmcia_report_error(client_handle_t handle, error_info_t *err)
229 {
230 int i;
231 char *serv;
232
233 if (CHECK_HANDLE(handle))
234 printk(KERN_NOTICE);
235 else {
236 struct pcmcia_device *p_dev = handle_to_pdev(handle);
237 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
238 }
239
240 for (i = 0; i < ARRAY_SIZE(service_table); i++)
241 if (service_table[i].key == err->func)
242 break;
243 if (i < ARRAY_SIZE(service_table))
244 serv = service_table[i].msg;
245 else
246 serv = "Unknown service number";
247
248 for (i = 0; i < ARRAY_SIZE(error_table); i++)
249 if (error_table[i].key == err->retcode)
250 break;
251 if (i < ARRAY_SIZE(error_table))
252 printk("%s: %s\n", serv, error_table[i].msg);
253 else
254 printk("%s: Unknown error code %#x\n", serv, err->retcode);
255
256 return CS_SUCCESS;
257 } /* report_error */
258
259 /* end of code which was in cs.c before */
260
261 /*======================================================================*/
262
263 void cs_error(client_handle_t handle, int func, int ret)
264 {
265 error_info_t err = { func, ret };
266 pcmcia_report_error(handle, &err);
267 }
268 EXPORT_SYMBOL(cs_error);
269
270
271 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
272 {
273 struct pcmcia_device_id *did = p_drv->id_table;
274 unsigned int i;
275 u32 hash;
276
277 while (did && did->match_flags) {
278 for (i=0; i<4; i++) {
279 if (!did->prod_id[i])
280 continue;
281
282 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
283 if (hash == did->prod_id_hash[i])
284 continue;
285
286 printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
287 "product string \"%s\": is 0x%x, should "
288 "be 0x%x\n", p_drv->drv.name, did->prod_id[i],
289 did->prod_id_hash[i], hash);
290 printk(KERN_DEBUG "pcmcia: see "
291 "Documentation/pcmcia/devicetable.txt for "
292 "details\n");
293 }
294 did++;
295 }
296
297 return;
298 }
299
300
301 #ifdef CONFIG_PCMCIA_LOAD_CIS
302
303 /**
304 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
305 * @dev - the pcmcia device which needs a CIS override
306 * @filename - requested filename in /lib/firmware/cis/
307 *
308 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
309 * the one provided by the card is broken. The firmware files reside in
310 * /lib/firmware/cis/ in userspace.
311 */
312 static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
313 {
314 struct pcmcia_socket *s = dev->socket;
315 const struct firmware *fw;
316 char path[20];
317 int ret=-ENOMEM;
318 cisdump_t *cis;
319
320 if (!filename)
321 return -EINVAL;
322
323 ds_dbg(1, "trying to load firmware %s\n", filename);
324
325 if (strlen(filename) > 14)
326 return -EINVAL;
327
328 snprintf(path, 20, "%s", filename);
329
330 if (request_firmware(&fw, path, &dev->dev) == 0) {
331 if (fw->size >= CISTPL_MAX_CIS_SIZE)
332 goto release;
333
334 cis = kmalloc(sizeof(cisdump_t), GFP_KERNEL);
335 if (!cis)
336 goto release;
337
338 memset(cis, 0, sizeof(cisdump_t));
339
340 cis->Length = fw->size + 1;
341 memcpy(cis->Data, fw->data, fw->size);
342
343 if (!pcmcia_replace_cis(s, cis))
344 ret = 0;
345 }
346 release:
347 release_firmware(fw);
348
349 return (ret);
350 }
351
352 #else /* !CONFIG_PCMCIA_LOAD_CIS */
353
354 static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
355 {
356 return -ENODEV;
357 }
358
359 #endif
360
361
362 /*======================================================================*/
363
364
365 static void pcmcia_release_bus_socket(struct kref *refcount)
366 {
367 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
368 pcmcia_put_socket(s->parent);
369 kfree(s);
370 }
371
372 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
373 {
374 kref_put(&s->refcount, pcmcia_release_bus_socket);
375 }
376
377 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
378 {
379 kref_get(&s->refcount);
380 return (s);
381 }
382
383 /**
384 * pcmcia_register_driver - register a PCMCIA driver with the bus core
385 *
386 * Registers a PCMCIA driver with the PCMCIA bus core.
387 */
388 static int pcmcia_device_probe(struct device *dev);
389 static int pcmcia_device_remove(struct device * dev);
390
391 int pcmcia_register_driver(struct pcmcia_driver *driver)
392 {
393 if (!driver)
394 return -EINVAL;
395
396 pcmcia_check_driver(driver);
397
398 /* initialize common fields */
399 driver->drv.bus = &pcmcia_bus_type;
400 driver->drv.owner = driver->owner;
401 driver->drv.probe = pcmcia_device_probe;
402 driver->drv.remove = pcmcia_device_remove;
403
404 return driver_register(&driver->drv);
405 }
406 EXPORT_SYMBOL(pcmcia_register_driver);
407
408 /**
409 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
410 */
411 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
412 {
413 driver_unregister(&driver->drv);
414 }
415 EXPORT_SYMBOL(pcmcia_unregister_driver);
416
417 #ifdef CONFIG_PCMCIA_IOCTL
418 #ifdef CONFIG_PROC_FS
419 static struct proc_dir_entry *proc_pccard = NULL;
420
421 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
422 {
423 char **p = d;
424 struct pcmcia_driver *p_drv = container_of(driver,
425 struct pcmcia_driver, drv);
426
427 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
428 #ifdef CONFIG_MODULE_UNLOAD
429 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
430 #else
431 1
432 #endif
433 );
434 d = (void *) p;
435
436 return 0;
437 }
438
439 static int proc_read_drivers(char *buf, char **start, off_t pos,
440 int count, int *eof, void *data)
441 {
442 char *p = buf;
443
444 bus_for_each_drv(&pcmcia_bus_type, NULL,
445 (void *) &p, proc_read_drivers_callback);
446
447 return (p - buf);
448 }
449 #endif
450 #endif
451
452 /* pcmcia_device handling */
453
454 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
455 {
456 struct device *tmp_dev;
457 tmp_dev = get_device(&p_dev->dev);
458 if (!tmp_dev)
459 return NULL;
460 return to_pcmcia_dev(tmp_dev);
461 }
462
463 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
464 {
465 if (p_dev)
466 put_device(&p_dev->dev);
467 }
468
469 static void pcmcia_release_dev(struct device *dev)
470 {
471 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
472 ds_dbg(1, "releasing dev %p\n", p_dev);
473 pcmcia_put_bus_socket(p_dev->socket->pcmcia);
474 kfree(p_dev);
475 }
476
477
478 static int pcmcia_device_probe(struct device * dev)
479 {
480 struct pcmcia_device *p_dev;
481 struct pcmcia_driver *p_drv;
482 int ret = 0;
483
484 dev = get_device(dev);
485 if (!dev)
486 return -ENODEV;
487
488 p_dev = to_pcmcia_dev(dev);
489 p_drv = to_pcmcia_drv(dev->driver);
490
491 if (!try_module_get(p_drv->owner)) {
492 ret = -EINVAL;
493 goto put_dev;
494 }
495
496 if (p_drv->attach) {
497 p_dev->instance = p_drv->attach();
498 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) {
499 printk(KERN_NOTICE "ds: unable to create instance "
500 "of '%s'!\n", p_drv->drv.name);
501 ret = -EINVAL;
502 }
503 }
504
505 if (ret)
506 module_put(p_drv->owner);
507 put_dev:
508 if ((ret) || !(p_drv->attach))
509 put_device(dev);
510 return (ret);
511 }
512
513
514 static int pcmcia_device_remove(struct device * dev)
515 {
516 struct pcmcia_device *p_dev;
517 struct pcmcia_driver *p_drv;
518
519 /* detach the "instance" */
520 p_dev = to_pcmcia_dev(dev);
521 p_drv = to_pcmcia_drv(dev->driver);
522
523 if (p_drv) {
524 if ((p_drv->detach) && (p_dev->instance)) {
525 p_drv->detach(p_dev->instance);
526 /* from pcmcia_probe_device */
527 put_device(&p_dev->dev);
528 }
529 module_put(p_drv->owner);
530 }
531
532 return 0;
533 }
534
535
536
537 /*
538 * pcmcia_device_query -- determine information about a pcmcia device
539 */
540 static int pcmcia_device_query(struct pcmcia_device *p_dev)
541 {
542 cistpl_manfid_t manf_id;
543 cistpl_funcid_t func_id;
544 cistpl_vers_1_t vers1;
545 unsigned int i;
546
547 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
548 CISTPL_MANFID, &manf_id)) {
549 p_dev->manf_id = manf_id.manf;
550 p_dev->card_id = manf_id.card;
551 p_dev->has_manf_id = 1;
552 p_dev->has_card_id = 1;
553 }
554
555 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
556 CISTPL_FUNCID, &func_id)) {
557 p_dev->func_id = func_id.func;
558 p_dev->has_func_id = 1;
559 } else {
560 /* rule of thumb: cards with no FUNCID, but with
561 * common memory device geometry information, are
562 * probably memory cards (from pcmcia-cs) */
563 cistpl_device_geo_t devgeo;
564 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
565 CISTPL_DEVICE_GEO, &devgeo)) {
566 ds_dbg(0, "mem device geometry probably means "
567 "FUNCID_MEMORY\n");
568 p_dev->func_id = CISTPL_FUNCID_MEMORY;
569 p_dev->has_func_id = 1;
570 }
571 }
572
573 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
574 &vers1)) {
575 for (i=0; i < vers1.ns; i++) {
576 char *tmp;
577 unsigned int length;
578
579 tmp = vers1.str + vers1.ofs[i];
580
581 length = strlen(tmp) + 1;
582 if ((length < 3) || (length > 255))
583 continue;
584
585 p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
586 GFP_KERNEL);
587 if (!p_dev->prod_id[i])
588 continue;
589
590 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
591 tmp, length);
592 }
593 }
594
595 return 0;
596 }
597
598
599 /* device_add_lock is needed to avoid double registration by cardmgr and kernel.
600 * Serializes pcmcia_device_add; will most likely be removed in future.
601 *
602 * While it has the caveat that adding new PCMCIA devices inside(!) device_register()
603 * won't work, this doesn't matter much at the moment: the driver core doesn't
604 * support it either.
605 */
606 static DECLARE_MUTEX(device_add_lock);
607
608 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function)
609 {
610 struct pcmcia_device *p_dev;
611 unsigned long flags;
612
613 s = pcmcia_get_bus_socket(s);
614 if (!s)
615 return NULL;
616
617 down(&device_add_lock);
618
619 /* max of 2 devices per card */
620 if (s->device_count == 2)
621 goto err_put;
622
623 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
624 if (!p_dev)
625 goto err_put;
626 memset(p_dev, 0, sizeof(struct pcmcia_device));
627
628 p_dev->socket = s->parent;
629 p_dev->device_no = (s->device_count++);
630 p_dev->func = function;
631
632 p_dev->dev.bus = &pcmcia_bus_type;
633 p_dev->dev.parent = s->parent->dev.dev;
634 p_dev->dev.release = pcmcia_release_dev;
635 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
636
637 /* compat */
638 p_dev->client.client_magic = CLIENT_MAGIC;
639 p_dev->client.Socket = s->parent;
640 p_dev->client.Function = function;
641 p_dev->client.state = CLIENT_UNBOUND;
642
643 /* Add to the list in pcmcia_bus_socket */
644 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
645 list_add_tail(&p_dev->socket_device_list, &s->devices_list);
646 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
647
648 pcmcia_device_query(p_dev);
649
650 if (device_register(&p_dev->dev)) {
651 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
652 list_del(&p_dev->socket_device_list);
653 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
654
655 goto err_free;
656 }
657
658 up(&device_add_lock);
659
660 return p_dev;
661
662 err_free:
663 kfree(p_dev);
664 s->device_count--;
665 err_put:
666 up(&device_add_lock);
667 pcmcia_put_bus_socket(s);
668
669 return NULL;
670 }
671
672
673 static int pcmcia_card_add(struct pcmcia_socket *s)
674 {
675 cisinfo_t cisinfo;
676 cistpl_longlink_mfc_t mfc;
677 unsigned int no_funcs, i;
678 int ret = 0;
679
680 if (!(s->resource_setup_done))
681 return -EAGAIN; /* try again, but later... */
682
683 pcmcia_validate_mem(s);
684 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo);
685 if (ret || !cisinfo.Chains) {
686 ds_dbg(0, "invalid CIS or invalid resources\n");
687 return -ENODEV;
688 }
689
690 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
691 no_funcs = mfc.nfn;
692 else
693 no_funcs = 1;
694
695 /* this doesn't handle multifunction devices on one pcmcia function
696 * yet. */
697 for (i=0; i < no_funcs; i++)
698 pcmcia_device_add(s->pcmcia, i);
699
700 return (ret);
701 }
702
703
704 static void pcmcia_delayed_add_pseudo_device(void *data)
705 {
706 struct pcmcia_bus_socket *s = data;
707 pcmcia_device_add(s, 0);
708 s->device_add_pending = 0;
709 }
710
711 static inline void pcmcia_add_pseudo_device(struct pcmcia_bus_socket *s)
712 {
713 if (!s->device_add_pending) {
714 schedule_work(&s->device_add);
715 s->device_add_pending = 1;
716 }
717 return;
718 }
719
720 static int pcmcia_requery(struct device *dev, void * _data)
721 {
722 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
723 if (!p_dev->dev.driver)
724 pcmcia_device_query(p_dev);
725
726 return 0;
727 }
728
729 static void pcmcia_bus_rescan(struct pcmcia_socket *skt)
730 {
731 int no_devices=0;
732 unsigned long flags;
733
734 /* must be called with skt_sem held */
735 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
736 if (list_empty(&skt->pcmcia->devices_list))
737 no_devices=1;
738 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
739
740 /* if no devices were added for this socket yet because of
741 * missing resource information or other trouble, we need to
742 * do this now. */
743 if (no_devices) {
744 int ret = pcmcia_card_add(skt);
745 if (ret)
746 return;
747 }
748
749 /* some device information might have changed because of a CIS
750 * update or because we can finally read it correctly... so
751 * determine it again, overwriting old values if necessary. */
752 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery);
753
754 /* we re-scan all devices, not just the ones connected to this
755 * socket. This does not matter, though. */
756 bus_rescan_devices(&pcmcia_bus_type);
757 }
758
759 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
760 struct pcmcia_device_id *did)
761 {
762 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
763 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
764 return 0;
765 }
766
767 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
768 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
769 return 0;
770 }
771
772 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
773 if (dev->func != did->function)
774 return 0;
775 }
776
777 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
778 if (!dev->prod_id[0])
779 return 0;
780 if (strcmp(did->prod_id[0], dev->prod_id[0]))
781 return 0;
782 }
783
784 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
785 if (!dev->prod_id[1])
786 return 0;
787 if (strcmp(did->prod_id[1], dev->prod_id[1]))
788 return 0;
789 }
790
791 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
792 if (!dev->prod_id[2])
793 return 0;
794 if (strcmp(did->prod_id[2], dev->prod_id[2]))
795 return 0;
796 }
797
798 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
799 if (!dev->prod_id[3])
800 return 0;
801 if (strcmp(did->prod_id[3], dev->prod_id[3]))
802 return 0;
803 }
804
805 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
806 /* handle pseudo multifunction devices:
807 * there are at most two pseudo multifunction devices.
808 * if we're matching against the first, schedule a
809 * call which will then check whether there are two
810 * pseudo devices, and if not, add the second one.
811 */
812 if (dev->device_no == 0)
813 pcmcia_add_pseudo_device(dev->socket->pcmcia);
814
815 if (dev->device_no != did->device_no)
816 return 0;
817 }
818
819 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
820 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
821 return 0;
822
823 /* if this is a pseudo-multi-function device,
824 * we need explicit matches */
825 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO)
826 return 0;
827 if (dev->device_no)
828 return 0;
829
830 /* also, FUNC_ID matching needs to be activated by userspace
831 * after it has re-checked that there is no possible module
832 * with a prod_id/manf_id/card_id match.
833 */
834 if (!dev->allow_func_id_match)
835 return 0;
836 }
837
838 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
839 if (!dev->socket->fake_cis)
840 pcmcia_load_firmware(dev, did->cisfile);
841
842 if (!dev->socket->fake_cis)
843 return 0;
844 }
845
846 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
847 int i;
848 for (i=0; i<4; i++)
849 if (dev->prod_id[i])
850 return 0;
851 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
852 return 0;
853 }
854
855 dev->dev.driver_data = (void *) did;
856
857 return 1;
858 }
859
860
861 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
862 struct pcmcia_device * p_dev = to_pcmcia_dev(dev);
863 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
864 struct pcmcia_device_id *did = p_drv->id_table;
865
866 /* matching by cardmgr */
867 if (p_dev->cardmgr == p_drv)
868 return 1;
869
870 while (did && did->match_flags) {
871 if (pcmcia_devmatch(p_dev, did))
872 return 1;
873 did++;
874 }
875
876 return 0;
877 }
878
879 #ifdef CONFIG_HOTPLUG
880
881 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
882 char *buffer, int buffer_size)
883 {
884 struct pcmcia_device *p_dev;
885 int i, length = 0;
886 u32 hash[4] = { 0, 0, 0, 0};
887
888 if (!dev)
889 return -ENODEV;
890
891 p_dev = to_pcmcia_dev(dev);
892
893 /* calculate hashes */
894 for (i=0; i<4; i++) {
895 if (!p_dev->prod_id[i])
896 continue;
897 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
898 }
899
900 i = 0;
901
902 if (add_hotplug_env_var(envp, num_envp, &i,
903 buffer, buffer_size, &length,
904 "SOCKET_NO=%u",
905 p_dev->socket->sock))
906 return -ENOMEM;
907
908 if (add_hotplug_env_var(envp, num_envp, &i,
909 buffer, buffer_size, &length,
910 "DEVICE_NO=%02X",
911 p_dev->device_no))
912 return -ENOMEM;
913
914 if (add_hotplug_env_var(envp, num_envp, &i,
915 buffer, buffer_size, &length,
916 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
917 "pa%08Xpb%08Xpc%08Xpd%08X",
918 p_dev->has_manf_id ? p_dev->manf_id : 0,
919 p_dev->has_card_id ? p_dev->card_id : 0,
920 p_dev->has_func_id ? p_dev->func_id : 0,
921 p_dev->func,
922 p_dev->device_no,
923 hash[0],
924 hash[1],
925 hash[2],
926 hash[3]))
927 return -ENOMEM;
928
929 envp[i] = NULL;
930
931 return 0;
932 }
933
934 #else
935
936 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
937 char *buffer, int buffer_size)
938 {
939 return -ENODEV;
940 }
941
942 #endif
943
944 /************************ per-device sysfs output ***************************/
945
946 #define pcmcia_device_attr(field, test, format) \
947 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
948 { \
949 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
950 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
951 }
952
953 #define pcmcia_device_stringattr(name, field) \
954 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
955 { \
956 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
957 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
958 }
959
960 pcmcia_device_attr(func, socket, "0x%02x\n");
961 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
962 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
963 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
964 pcmcia_device_stringattr(prod_id1, prod_id[0]);
965 pcmcia_device_stringattr(prod_id2, prod_id[1]);
966 pcmcia_device_stringattr(prod_id3, prod_id[2]);
967 pcmcia_device_stringattr(prod_id4, prod_id[3]);
968
969
970 static ssize_t pcmcia_store_allow_func_id_match (struct device * dev, struct device_attribute *attr,
971 const char * buf, size_t count)
972 {
973 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
974 if (!count)
975 return -EINVAL;
976
977 down(&p_dev->socket->skt_sem);
978 p_dev->allow_func_id_match = 1;
979 up(&p_dev->socket->skt_sem);
980
981 bus_rescan_devices(&pcmcia_bus_type);
982
983 return count;
984 }
985
986 static struct device_attribute pcmcia_dev_attrs[] = {
987 __ATTR(function, 0444, func_show, NULL),
988 __ATTR_RO(func_id),
989 __ATTR_RO(manf_id),
990 __ATTR_RO(card_id),
991 __ATTR_RO(prod_id1),
992 __ATTR_RO(prod_id2),
993 __ATTR_RO(prod_id3),
994 __ATTR_RO(prod_id4),
995 __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match),
996 __ATTR_NULL,
997 };
998
999
1000 /*======================================================================
1001
1002 These manage a ring buffer of events pending for one user process
1003
1004 ======================================================================*/
1005
1006 #ifdef CONFIG_PCMCIA_IOCTL
1007
1008 static int queue_empty(user_info_t *user)
1009 {
1010 return (user->event_head == user->event_tail);
1011 }
1012
1013 static event_t get_queued_event(user_info_t *user)
1014 {
1015 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
1016 return user->event[user->event_tail];
1017 }
1018
1019 static void queue_event(user_info_t *user, event_t event)
1020 {
1021 user->event_head = (user->event_head+1) % MAX_EVENTS;
1022 if (user->event_head == user->event_tail)
1023 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
1024 user->event[user->event_head] = event;
1025 }
1026
1027 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
1028 {
1029 user_info_t *user;
1030 for (user = s->user; user; user = user->next)
1031 queue_event(user, event);
1032 wake_up_interruptible(&s->queue);
1033 }
1034 #else
1035 static inline void handle_event(struct pcmcia_bus_socket *s, event_t event) { return; }
1036 static inline int handle_request(struct pcmcia_bus_socket *s, event_t event) { return CS_SUCCESS; }
1037 #endif
1038
1039
1040
1041 /*======================================================================
1042
1043 The card status event handler.
1044
1045 ======================================================================*/
1046
1047 struct send_event_data {
1048 struct pcmcia_socket *skt;
1049 event_t event;
1050 int priority;
1051 };
1052
1053 static int send_event_callback(struct device *dev, void * _data)
1054 {
1055 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1056 struct send_event_data *data = _data;
1057
1058 /* we get called for all sockets, but may only pass the event
1059 * for drivers _on the affected socket_ */
1060 if (p_dev->socket != data->skt)
1061 return 0;
1062
1063 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
1064 return 0;
1065
1066 if (p_dev->client.EventMask & data->event)
1067 return EVENT(&p_dev->client, data->event, data->priority);
1068
1069 return 0;
1070 }
1071
1072 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
1073 {
1074 int ret = 0;
1075 struct send_event_data private;
1076 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
1077
1078 if (!skt)
1079 return 0;
1080
1081 private.skt = s;
1082 private.event = event;
1083 private.priority = priority;
1084
1085 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
1086
1087 pcmcia_put_bus_socket(skt);
1088 return ret;
1089 } /* send_event */
1090
1091
1092 /* Normally, the event is passed to individual drivers after
1093 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
1094 * is inversed to maintain historic compatibility.
1095 */
1096
1097 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
1098 {
1099 struct pcmcia_bus_socket *s = skt->pcmcia;
1100 int ret = 0;
1101
1102 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
1103 event, priority, s);
1104
1105 switch (event) {
1106
1107 case CS_EVENT_CARD_REMOVAL:
1108 s->state &= ~DS_SOCKET_PRESENT;
1109 send_event(skt, event, priority);
1110 unbind_request(s);
1111 handle_event(s, event);
1112 break;
1113
1114 case CS_EVENT_CARD_INSERTION:
1115 s->state |= DS_SOCKET_PRESENT;
1116 pcmcia_card_add(skt);
1117 handle_event(s, event);
1118 break;
1119
1120 case CS_EVENT_EJECTION_REQUEST:
1121 ret = send_event(skt, event, priority);
1122 break;
1123
1124 default:
1125 handle_event(s, event);
1126 send_event(skt, event, priority);
1127 break;
1128 }
1129
1130 return 0;
1131 } /* ds_event */
1132
1133
1134 /*======================================================================
1135
1136 bind_request() and bind_device() are merged by now. Register_client()
1137 is called right at the end of bind_request(), during the driver's
1138 ->attach() call. Individual descriptions:
1139
1140 bind_request() connects a socket to a particular client driver.
1141 It looks up the specified device ID in the list of registered
1142 drivers, binds it to the socket, and tries to create an instance
1143 of the device. unbind_request() deletes a driver instance.
1144
1145 Bind_device() associates a device driver with a particular socket.
1146 It is normally called by Driver Services after it has identified
1147 a newly inserted card. An instance of that driver will then be
1148 eligible to register as a client of this socket.
1149
1150 Register_client() uses the dev_info_t handle to match the
1151 caller with a socket. The driver must have already been bound
1152 to a socket with bind_device() -- in fact, bind_device()
1153 allocates the client structure that will be used.
1154
1155 ======================================================================*/
1156
1157 #ifdef CONFIG_PCMCIA_IOCTL
1158
1159 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1160 {
1161 struct pcmcia_driver *p_drv;
1162 struct pcmcia_device *p_dev;
1163 int ret = 0;
1164 unsigned long flags;
1165
1166 s = pcmcia_get_bus_socket(s);
1167 if (!s)
1168 return -EINVAL;
1169
1170 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1171 (char *)bind_info->dev_info);
1172
1173 p_drv = get_pcmcia_driver(&bind_info->dev_info);
1174 if (!p_drv) {
1175 ret = -EINVAL;
1176 goto err_put;
1177 }
1178
1179 if (!try_module_get(p_drv->owner)) {
1180 ret = -EINVAL;
1181 goto err_put_driver;
1182 }
1183
1184 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1185 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1186 if (p_dev->func == bind_info->function) {
1187 if ((p_dev->dev.driver == &p_drv->drv)) {
1188 if (p_dev->cardmgr) {
1189 /* if there's already a device
1190 * registered, and it was registered
1191 * by userspace before, we need to
1192 * return the "instance". */
1193 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1194 bind_info->instance = p_dev->instance;
1195 ret = -EBUSY;
1196 goto err_put_module;
1197 } else {
1198 /* the correct driver managed to bind
1199 * itself magically to the correct
1200 * device. */
1201 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1202 p_dev->cardmgr = p_drv;
1203 ret = 0;
1204 goto err_put_module;
1205 }
1206 } else if (!p_dev->dev.driver) {
1207 /* there's already a device available where
1208 * no device has been bound to yet. So we don't
1209 * need to register a device! */
1210 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1211 goto rescan;
1212 }
1213 }
1214 }
1215 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1216
1217 p_dev = pcmcia_device_add(s, bind_info->function);
1218 if (!p_dev) {
1219 ret = -EIO;
1220 goto err_put_module;
1221 }
1222
1223 rescan:
1224 p_dev->cardmgr = p_drv;
1225
1226 /* if a driver is already running, we can abort */
1227 if (p_dev->dev.driver)
1228 goto err_put_module;
1229
1230 /*
1231 * Prevent this racing with a card insertion.
1232 */
1233 down(&s->parent->skt_sem);
1234 bus_rescan_devices(&pcmcia_bus_type);
1235 up(&s->parent->skt_sem);
1236
1237 /* check whether the driver indeed matched. I don't care if this
1238 * is racy or not, because it can only happen on cardmgr access
1239 * paths...
1240 */
1241 if (!(p_dev->dev.driver == &p_drv->drv))
1242 p_dev->cardmgr = NULL;
1243
1244 err_put_module:
1245 module_put(p_drv->owner);
1246 err_put_driver:
1247 put_driver(&p_drv->drv);
1248 err_put:
1249 pcmcia_put_bus_socket(s);
1250
1251 return (ret);
1252 } /* bind_request */
1253
1254 #endif
1255
1256
1257 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1258 {
1259 client_t *client = NULL;
1260 struct pcmcia_socket *s;
1261 struct pcmcia_bus_socket *skt = NULL;
1262 struct pcmcia_device *p_dev = NULL;
1263
1264 /* Look for unbound client with matching dev_info */
1265 down_read(&pcmcia_socket_list_rwsem);
1266 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1267 unsigned long flags;
1268
1269 if (s->state & SOCKET_CARDBUS)
1270 continue;
1271
1272 skt = s->pcmcia;
1273 if (!skt)
1274 continue;
1275 skt = pcmcia_get_bus_socket(skt);
1276 if (!skt)
1277 continue;
1278 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1279 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1280 struct pcmcia_driver *p_drv;
1281 p_dev = pcmcia_get_dev(p_dev);
1282 if (!p_dev)
1283 continue;
1284 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1285 (!p_dev->dev.driver)) {
1286 pcmcia_put_dev(p_dev);
1287 continue;
1288 }
1289 p_drv = to_pcmcia_drv(p_dev->dev.driver);
1290 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1291 client = &p_dev->client;
1292 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1293 goto found;
1294 }
1295 pcmcia_put_dev(p_dev);
1296 }
1297 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1298 pcmcia_put_bus_socket(skt);
1299 }
1300 found:
1301 up_read(&pcmcia_socket_list_rwsem);
1302 if (!p_dev || !client)
1303 return -ENODEV;
1304
1305 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1306
1307 *handle = client;
1308 client->state &= ~CLIENT_UNBOUND;
1309 client->Socket = s;
1310 client->EventMask = req->EventMask;
1311 client->event_handler = req->event_handler;
1312 client->event_callback_args = req->event_callback_args;
1313 client->event_callback_args.client_handle = client;
1314
1315 if (s->state & SOCKET_CARDBUS)
1316 client->state |= CLIENT_CARDBUS;
1317
1318 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1319 (client->Function != BIND_FN_ALL)) {
1320 cistpl_longlink_mfc_t mfc;
1321 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1322 == CS_SUCCESS)
1323 s->functions = mfc.nfn;
1324 else
1325 s->functions = 1;
1326 s->config = kmalloc(sizeof(config_t) * s->functions,
1327 GFP_KERNEL);
1328 if (!s->config)
1329 goto out_no_resource;
1330 memset(s->config, 0, sizeof(config_t) * s->functions);
1331 }
1332
1333 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1334 client, p_dev->dev.bus_id);
1335 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1336 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1337
1338 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1339 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1340 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1341 }
1342
1343 return CS_SUCCESS;
1344
1345 out_no_resource:
1346 pcmcia_put_dev(p_dev);
1347 return CS_OUT_OF_RESOURCE;
1348 } /* register_client */
1349 EXPORT_SYMBOL(pcmcia_register_client);
1350
1351
1352 /*====================================================================*/
1353 #ifdef CONFIG_PCMCIA_IOCTL
1354
1355 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1356
1357 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1358 {
1359 dev_node_t *node;
1360 struct pcmcia_device *p_dev;
1361 unsigned long flags;
1362 int ret = 0;
1363
1364 #ifdef CONFIG_CARDBUS
1365 /*
1366 * Some unbelievably ugly code to associate the PCI cardbus
1367 * device and its driver with the PCMCIA "bind" information.
1368 */
1369 {
1370 struct pci_bus *bus;
1371
1372 bus = pcmcia_lookup_bus(s->parent);
1373 if (bus) {
1374 struct list_head *list;
1375 struct pci_dev *dev = NULL;
1376
1377 list = bus->devices.next;
1378 while (list != &bus->devices) {
1379 struct pci_dev *pdev = pci_dev_b(list);
1380 list = list->next;
1381
1382 if (first) {
1383 dev = pdev;
1384 break;
1385 }
1386
1387 /* Try to handle "next" here some way? */
1388 }
1389 if (dev && dev->driver) {
1390 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1391 bind_info->major = 0;
1392 bind_info->minor = 0;
1393 bind_info->next = NULL;
1394 return 0;
1395 }
1396 }
1397 }
1398 #endif
1399
1400 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1401 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1402 if (p_dev->func == bind_info->function) {
1403 p_dev = pcmcia_get_dev(p_dev);
1404 if (!p_dev)
1405 continue;
1406 goto found;
1407 }
1408 }
1409 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1410 return -ENODEV;
1411
1412 found:
1413 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1414
1415 if ((!p_dev->instance) ||
1416 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1417 ret = -EAGAIN;
1418 goto err_put;
1419 }
1420
1421 if (first)
1422 node = p_dev->instance->dev;
1423 else
1424 for (node = p_dev->instance->dev; node; node = node->next)
1425 if (node == bind_info->next)
1426 break;
1427 if (!node) {
1428 ret = -ENODEV;
1429 goto err_put;
1430 }
1431
1432 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1433 bind_info->major = node->major;
1434 bind_info->minor = node->minor;
1435 bind_info->next = node->next;
1436
1437 err_put:
1438 pcmcia_put_dev(p_dev);
1439 return (ret);
1440 } /* get_device_info */
1441
1442 #endif
1443
1444 /*====================================================================*/
1445
1446 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1447 * drivers have been called with EVENT_CARD_REMOVAL before.
1448 */
1449 static int unbind_request(struct pcmcia_bus_socket *s)
1450 {
1451 struct pcmcia_device *p_dev;
1452 unsigned long flags;
1453
1454 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1455
1456 s->device_count = 0;
1457
1458 for (;;) {
1459 /* unregister all pcmcia_devices registered with this socket*/
1460 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1461 if (list_empty(&s->devices_list)) {
1462 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1463 return 0;
1464 }
1465 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1466 list_del(&p_dev->socket_device_list);
1467 p_dev->client.state |= CLIENT_STALE;
1468 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1469
1470 device_unregister(&p_dev->dev);
1471 }
1472
1473 return 0;
1474 } /* unbind_request */
1475
1476 int pcmcia_deregister_client(client_handle_t handle)
1477 {
1478 struct pcmcia_socket *s;
1479 int i;
1480 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1481
1482 if (CHECK_HANDLE(handle))
1483 return CS_BAD_HANDLE;
1484
1485 s = SOCKET(handle);
1486 ds_dbg(1, "deregister_client(%p)\n", handle);
1487
1488 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1489 goto warn_out;
1490 for (i = 0; i < MAX_WIN; i++)
1491 if (handle->state & CLIENT_WIN_REQ(i))
1492 goto warn_out;
1493
1494 if (handle->state & CLIENT_STALE) {
1495 handle->client_magic = 0;
1496 handle->state &= ~CLIENT_STALE;
1497 pcmcia_put_dev(p_dev);
1498 } else {
1499 handle->state = CLIENT_UNBOUND;
1500 handle->event_handler = NULL;
1501 }
1502
1503 return CS_SUCCESS;
1504 warn_out:
1505 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1506 return CS_IN_USE;
1507 } /* deregister_client */
1508 EXPORT_SYMBOL(pcmcia_deregister_client);
1509
1510
1511 /*======================================================================
1512
1513 The user-mode PC Card device interface
1514
1515 ======================================================================*/
1516
1517 #ifdef CONFIG_PCMCIA_IOCTL
1518
1519 static int ds_open(struct inode *inode, struct file *file)
1520 {
1521 socket_t i = iminor(inode);
1522 struct pcmcia_bus_socket *s;
1523 user_info_t *user;
1524
1525 ds_dbg(0, "ds_open(socket %d)\n", i);
1526
1527 s = get_socket_info_by_nr(i);
1528 if (!s)
1529 return -ENODEV;
1530 s = pcmcia_get_bus_socket(s);
1531 if (!s)
1532 return -ENODEV;
1533
1534 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1535 if (s->state & DS_SOCKET_BUSY) {
1536 pcmcia_put_bus_socket(s);
1537 return -EBUSY;
1538 }
1539 else
1540 s->state |= DS_SOCKET_BUSY;
1541 }
1542
1543 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1544 if (!user) {
1545 pcmcia_put_bus_socket(s);
1546 return -ENOMEM;
1547 }
1548 user->event_tail = user->event_head = 0;
1549 user->next = s->user;
1550 user->user_magic = USER_MAGIC;
1551 user->socket = s;
1552 s->user = user;
1553 file->private_data = user;
1554
1555 if (s->state & DS_SOCKET_PRESENT)
1556 queue_event(user, CS_EVENT_CARD_INSERTION);
1557 return 0;
1558 } /* ds_open */
1559
1560 /*====================================================================*/
1561
1562 static int ds_release(struct inode *inode, struct file *file)
1563 {
1564 struct pcmcia_bus_socket *s;
1565 user_info_t *user, **link;
1566
1567 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1568
1569 user = file->private_data;
1570 if (CHECK_USER(user))
1571 goto out;
1572
1573 s = user->socket;
1574
1575 /* Unlink user data structure */
1576 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1577 s->state &= ~DS_SOCKET_BUSY;
1578 }
1579 file->private_data = NULL;
1580 for (link = &s->user; *link; link = &(*link)->next)
1581 if (*link == user) break;
1582 if (link == NULL)
1583 goto out;
1584 *link = user->next;
1585 user->user_magic = 0;
1586 kfree(user);
1587 pcmcia_put_bus_socket(s);
1588 out:
1589 return 0;
1590 } /* ds_release */
1591
1592 /*====================================================================*/
1593
1594 static ssize_t ds_read(struct file *file, char __user *buf,
1595 size_t count, loff_t *ppos)
1596 {
1597 struct pcmcia_bus_socket *s;
1598 user_info_t *user;
1599 int ret;
1600
1601 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1602
1603 if (count < 4)
1604 return -EINVAL;
1605
1606 user = file->private_data;
1607 if (CHECK_USER(user))
1608 return -EIO;
1609
1610 s = user->socket;
1611 if (s->state & DS_SOCKET_DEAD)
1612 return -EIO;
1613
1614 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1615 if (ret == 0)
1616 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1617
1618 return ret;
1619 } /* ds_read */
1620
1621 /*====================================================================*/
1622
1623 static ssize_t ds_write(struct file *file, const char __user *buf,
1624 size_t count, loff_t *ppos)
1625 {
1626 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1627
1628 if (count != 4)
1629 return -EINVAL;
1630 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1631 return -EBADF;
1632
1633 return -EIO;
1634 } /* ds_write */
1635
1636 /*====================================================================*/
1637
1638 /* No kernel lock - fine */
1639 static u_int ds_poll(struct file *file, poll_table *wait)
1640 {
1641 struct pcmcia_bus_socket *s;
1642 user_info_t *user;
1643
1644 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1645
1646 user = file->private_data;
1647 if (CHECK_USER(user))
1648 return POLLERR;
1649 s = user->socket;
1650 /*
1651 * We don't check for a dead socket here since that
1652 * will send cardmgr into an endless spin.
1653 */
1654 poll_wait(file, &s->queue, wait);
1655 if (!queue_empty(user))
1656 return POLLIN | POLLRDNORM;
1657 return 0;
1658 } /* ds_poll */
1659
1660 /*====================================================================*/
1661
1662 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1663
1664 static int ds_ioctl(struct inode * inode, struct file * file,
1665 u_int cmd, u_long arg)
1666 {
1667 struct pcmcia_bus_socket *s;
1668 void __user *uarg = (char __user *)arg;
1669 u_int size;
1670 int ret, err;
1671 ds_ioctl_arg_t *buf;
1672 user_info_t *user;
1673
1674 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1675
1676 user = file->private_data;
1677 if (CHECK_USER(user))
1678 return -EIO;
1679
1680 s = user->socket;
1681 if (s->state & DS_SOCKET_DEAD)
1682 return -EIO;
1683
1684 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1685 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1686
1687 /* Permission check */
1688 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1689 return -EPERM;
1690
1691 if (cmd & IOC_IN) {
1692 if (!access_ok(VERIFY_READ, uarg, size)) {
1693 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1694 return -EFAULT;
1695 }
1696 }
1697 if (cmd & IOC_OUT) {
1698 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1699 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1700 return -EFAULT;
1701 }
1702 }
1703 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1704 if (!buf)
1705 return -ENOMEM;
1706
1707 err = ret = 0;
1708
1709 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1710
1711 switch (cmd) {
1712 case DS_ADJUST_RESOURCE_INFO:
1713 ret = pcmcia_adjust_resource_info(&buf->adjust);
1714 break;
1715 case DS_GET_CARD_SERVICES_INFO:
1716 ret = pcmcia_get_card_services_info(&buf->servinfo);
1717 break;
1718 case DS_GET_CONFIGURATION_INFO:
1719 if (buf->config.Function &&
1720 (buf->config.Function >= s->parent->functions))
1721 ret = CS_BAD_ARGS;
1722 else
1723 ret = pccard_get_configuration_info(s->parent,
1724 buf->config.Function, &buf->config);
1725 break;
1726 case DS_GET_FIRST_TUPLE:
1727 down(&s->parent->skt_sem);
1728 pcmcia_validate_mem(s->parent);
1729 up(&s->parent->skt_sem);
1730 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1731 break;
1732 case DS_GET_NEXT_TUPLE:
1733 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1734 break;
1735 case DS_GET_TUPLE_DATA:
1736 buf->tuple.TupleData = buf->tuple_parse.data;
1737 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1738 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1739 break;
1740 case DS_PARSE_TUPLE:
1741 buf->tuple.TupleData = buf->tuple_parse.data;
1742 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1743 break;
1744 case DS_RESET_CARD:
1745 ret = pccard_reset_card(s->parent);
1746 break;
1747 case DS_GET_STATUS:
1748 if (buf->status.Function &&
1749 (buf->status.Function >= s->parent->functions))
1750 ret = CS_BAD_ARGS;
1751 else
1752 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1753 break;
1754 case DS_VALIDATE_CIS:
1755 down(&s->parent->skt_sem);
1756 pcmcia_validate_mem(s->parent);
1757 up(&s->parent->skt_sem);
1758 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1759 break;
1760 case DS_SUSPEND_CARD:
1761 ret = pcmcia_suspend_card(s->parent);
1762 break;
1763 case DS_RESUME_CARD:
1764 ret = pcmcia_resume_card(s->parent);
1765 break;
1766 case DS_EJECT_CARD:
1767 err = pcmcia_eject_card(s->parent);
1768 break;
1769 case DS_INSERT_CARD:
1770 err = pcmcia_insert_card(s->parent);
1771 break;
1772 case DS_ACCESS_CONFIGURATION_REGISTER:
1773 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1774 err = -EPERM;
1775 goto free_out;
1776 }
1777 if (buf->conf_reg.Function &&
1778 (buf->conf_reg.Function >= s->parent->functions))
1779 ret = CS_BAD_ARGS;
1780 else
1781 ret = pccard_access_configuration_register(s->parent,
1782 buf->conf_reg.Function, &buf->conf_reg);
1783 break;
1784 case DS_GET_FIRST_REGION:
1785 case DS_GET_NEXT_REGION:
1786 case DS_BIND_MTD:
1787 if (!capable(CAP_SYS_ADMIN)) {
1788 err = -EPERM;
1789 goto free_out;
1790 } else {
1791 static int printed = 0;
1792 if (!printed) {
1793 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1794 printk(KERN_WARNING "MTD handling any more.\n");
1795 printed++;
1796 }
1797 }
1798 err = -EINVAL;
1799 goto free_out;
1800 break;
1801 case DS_GET_FIRST_WINDOW:
1802 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1803 &buf->win_info.window);
1804 break;
1805 case DS_GET_NEXT_WINDOW:
1806 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1807 buf->win_info.handle->index + 1, &buf->win_info.window);
1808 break;
1809 case DS_GET_MEM_PAGE:
1810 ret = pcmcia_get_mem_page(buf->win_info.handle,
1811 &buf->win_info.map);
1812 break;
1813 case DS_REPLACE_CIS:
1814 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1815 break;
1816 case DS_BIND_REQUEST:
1817 if (!capable(CAP_SYS_ADMIN)) {
1818 err = -EPERM;
1819 goto free_out;
1820 }
1821 err = bind_request(s, &buf->bind_info);
1822 break;
1823 case DS_GET_DEVICE_INFO:
1824 err = get_device_info(s, &buf->bind_info, 1);
1825 break;
1826 case DS_GET_NEXT_DEVICE:
1827 err = get_device_info(s, &buf->bind_info, 0);
1828 break;
1829 case DS_UNBIND_REQUEST:
1830 err = 0;
1831 break;
1832 default:
1833 err = -EINVAL;
1834 }
1835
1836 if ((err == 0) && (ret != CS_SUCCESS)) {
1837 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1838 switch (ret) {
1839 case CS_BAD_SOCKET: case CS_NO_CARD:
1840 err = -ENODEV; break;
1841 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1842 case CS_BAD_TUPLE:
1843 err = -EINVAL; break;
1844 case CS_IN_USE:
1845 err = -EBUSY; break;
1846 case CS_OUT_OF_RESOURCE:
1847 err = -ENOSPC; break;
1848 case CS_NO_MORE_ITEMS:
1849 err = -ENODATA; break;
1850 case CS_UNSUPPORTED_FUNCTION:
1851 err = -ENOSYS; break;
1852 default:
1853 err = -EIO; break;
1854 }
1855 }
1856
1857 if (cmd & IOC_OUT) {
1858 if (__copy_to_user(uarg, (char *)buf, size))
1859 err = -EFAULT;
1860 }
1861
1862 free_out:
1863 kfree(buf);
1864 return err;
1865 } /* ds_ioctl */
1866
1867 /*====================================================================*/
1868
1869 static struct file_operations ds_fops = {
1870 .owner = THIS_MODULE,
1871 .open = ds_open,
1872 .release = ds_release,
1873 .ioctl = ds_ioctl,
1874 .read = ds_read,
1875 .write = ds_write,
1876 .poll = ds_poll,
1877 };
1878
1879 #endif
1880
1881 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1882 {
1883 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1884 struct pcmcia_bus_socket *s;
1885 int ret;
1886
1887 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1888 if(!s)
1889 return -ENOMEM;
1890 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1891
1892 /* get reference to parent socket */
1893 s->parent = pcmcia_get_socket(socket);
1894 if (!s->parent) {
1895 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1896 kfree (s);
1897 return -ENODEV;
1898 }
1899
1900 kref_init(&s->refcount);
1901
1902 /*
1903 * Ugly. But we want to wait for the socket threads to have started up.
1904 * We really should let the drivers themselves drive some of this..
1905 */
1906 msleep(250);
1907
1908 init_waitqueue_head(&s->queue);
1909 INIT_LIST_HEAD(&s->devices_list);
1910 INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1911
1912 /* Set up hotline to Card Services */
1913 s->callback.owner = THIS_MODULE;
1914 s->callback.event = &ds_event;
1915 s->callback.requery = &pcmcia_bus_rescan;
1916 socket->pcmcia = s;
1917
1918 ret = pccard_register_pcmcia(socket, &s->callback);
1919 if (ret) {
1920 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1921 pcmcia_put_bus_socket(s);
1922 socket->pcmcia = NULL;
1923 return (ret);
1924 }
1925
1926 return 0;
1927 }
1928
1929
1930 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1931 {
1932 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1933
1934 if (!socket || !socket->pcmcia)
1935 return;
1936
1937 pccard_register_pcmcia(socket, NULL);
1938
1939 socket->pcmcia->state |= DS_SOCKET_DEAD;
1940 pcmcia_put_bus_socket(socket->pcmcia);
1941 socket->pcmcia = NULL;
1942
1943 return;
1944 }
1945
1946
1947 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1948 static struct class_interface pcmcia_bus_interface = {
1949 .class = &pcmcia_socket_class,
1950 .add = &pcmcia_bus_add_socket,
1951 .remove = &pcmcia_bus_remove_socket,
1952 };
1953
1954
1955 static struct bus_type pcmcia_bus_type = {
1956 .name = "pcmcia",
1957 .hotplug = pcmcia_bus_hotplug,
1958 .match = pcmcia_bus_match,
1959 .dev_attrs = pcmcia_dev_attrs,
1960 };
1961
1962
1963 static int __init init_pcmcia_bus(void)
1964 {
1965 #ifdef CONFIG_PCMCIA_IOCTL
1966 int i;
1967 #endif
1968
1969 spin_lock_init(&pcmcia_dev_list_lock);
1970
1971 bus_register(&pcmcia_bus_type);
1972 class_interface_register(&pcmcia_bus_interface);
1973
1974 #ifdef CONFIG_PCMCIA_IOCTL
1975 /* Set up character device for user mode clients */
1976 i = register_chrdev(0, "pcmcia", &ds_fops);
1977 if (i < 0)
1978 printk(KERN_NOTICE "unable to find a free device # for "
1979 "Driver Services (error=%d)\n", i);
1980 else
1981 major_dev = i;
1982
1983 #ifdef CONFIG_PROC_FS
1984 proc_pccard = proc_mkdir("pccard", proc_bus);
1985 if (proc_pccard)
1986 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1987 #endif
1988 #endif
1989
1990 return 0;
1991 }
1992 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1993 * pcmcia_socket_class is already registered */
1994
1995
1996 static void __exit exit_pcmcia_bus(void)
1997 {
1998 class_interface_unregister(&pcmcia_bus_interface);
1999
2000 #ifdef CONFIG_PCMCIA_IOCTL
2001 #ifdef CONFIG_PROC_FS
2002 if (proc_pccard) {
2003 remove_proc_entry("drivers", proc_pccard);
2004 remove_proc_entry("pccard", proc_bus);
2005 }
2006 #endif
2007 if (major_dev != -1)
2008 unregister_chrdev(major_dev, "pcmcia");
2009 #endif
2010
2011 bus_unregister(&pcmcia_bus_type);
2012 }
2013 module_exit(exit_pcmcia_bus);
2014
2015
2016
2017 /* helpers for backwards-compatible functions */
2018 #ifdef CONFIG_PCMCIA_IOCTL
2019 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
2020 {
2021 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
2022 if (s && s->pcmcia)
2023 return s->pcmcia;
2024 else
2025 return NULL;
2026 }
2027
2028 /* backwards-compatible accessing of driver --- by name! */
2029
2030 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
2031 {
2032 struct device_driver *drv;
2033 struct pcmcia_driver *p_drv;
2034
2035 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
2036 if (!drv)
2037 return NULL;
2038
2039 p_drv = container_of(drv, struct pcmcia_driver, drv);
2040
2041 return (p_drv);
2042 }
2043 #endif
2044
2045 MODULE_ALIAS("ds");
Ubuntu Artful kernel mirror