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