projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] pcmcia: match "anonymous" cards
[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 */
659 bus_rescan_devices(&pcmcia_bus_type);
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
872static struct device_attribute pcmcia_dev_attrs[] = {
873 __ATTR(function, 0444, func_show, NULL),
874 __ATTR_RO(func_id),
875 __ATTR_RO(manf_id),
876 __ATTR_RO(card_id),
877 __ATTR_RO(prod_id1),
878 __ATTR_RO(prod_id2),
879 __ATTR_RO(prod_id3),
880 __ATTR_RO(prod_id4),
881 __ATTR_NULL,
882};
883
884
885/*======================================================================
886
887 These manage a ring buffer of events pending for one user process
888
889======================================================================*/
890
891static int queue_empty(user_info_t *user)
892{
893 return (user->event_head == user->event_tail);
894}
895
896static event_t get_queued_event(user_info_t *user)
897{
898 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
899 return user->event[user->event_tail];
900}
901
902static void queue_event(user_info_t *user, event_t event)
903{
904 user->event_head = (user->event_head+1) % MAX_EVENTS;
905 if (user->event_head == user->event_tail)
906 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
907 user->event[user->event_head] = event;
908}
909
910static void handle_event(struct pcmcia_bus_socket *s, event_t event)
911{
912 user_info_t *user;
913 for (user = s->user; user; user = user->next)
914 queue_event(user, event);
915 wake_up_interruptible(&s->queue);
916}
917
918
919/*======================================================================
920
921 The card status event handler.
922
923======================================================================*/
924
925struct send_event_data {
926 struct pcmcia_socket *skt;
927 event_t event;
928 int priority;
929};
930
931static int send_event_callback(struct device *dev, void * _data)
932{
933 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
934 struct send_event_data *data = _data;
935
936 /* we get called for all sockets, but may only pass the event
937 * for drivers _on the affected socket_ */
938 if (p_dev->socket != data->skt)
939 return 0;
940
941 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
942 return 0;
943
944 if (p_dev->client.EventMask & data->event)
945 return EVENT(&p_dev->client, data->event, data->priority);
946
947 return 0;
948}
949
950static int send_event(struct pcmcia_socket *s, event_t event, int priority)
951{
952 int ret = 0;
953 struct send_event_data private;
954 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
955
956 if (!skt)
957 return 0;
958
959 private.skt = s;
960 private.event = event;
961 private.priority = priority;
962
963 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
964
965 pcmcia_put_bus_socket(skt);
966 return ret;
967} /* send_event */
968
969
970/* Normally, the event is passed to individual drivers after
971 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
972 * is inversed to maintain historic compatibility.
973 */
974
975static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
976{
977 struct pcmcia_bus_socket *s = skt->pcmcia;
978 int ret = 0;
979
980 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
981 event, priority, s);
982
983 switch (event) {
984
985 case CS_EVENT_CARD_REMOVAL:
986 s->state &= ~DS_SOCKET_PRESENT;
987 send_event(skt, event, priority);
988 unbind_request(s);
989 handle_event(s, event);
990 break;
991
992 case CS_EVENT_CARD_INSERTION:
993 s->state |= DS_SOCKET_PRESENT;
994 pcmcia_card_add(skt);
995 handle_event(s, event);
996 break;
997
998 case CS_EVENT_EJECTION_REQUEST:
999 ret = send_event(skt, event, priority);
1000 break;
1001
1002 default:
1003 handle_event(s, event);
1004 send_event(skt, event, priority);
1005 break;
1006 }
1007
1008 return 0;
1009} /* ds_event */
1010
1011
1012/*======================================================================
1013
1014 bind_request() and bind_device() are merged by now. Register_client()
1015 is called right at the end of bind_request(), during the driver's
1016 ->attach() call. Individual descriptions:
1017
1018 bind_request() connects a socket to a particular client driver.
1019 It looks up the specified device ID in the list of registered
1020 drivers, binds it to the socket, and tries to create an instance
1021 of the device. unbind_request() deletes a driver instance.
1022
1023 Bind_device() associates a device driver with a particular socket.
1024 It is normally called by Driver Services after it has identified
1025 a newly inserted card. An instance of that driver will then be
1026 eligible to register as a client of this socket.
1027
1028 Register_client() uses the dev_info_t handle to match the
1029 caller with a socket. The driver must have already been bound
1030 to a socket with bind_device() -- in fact, bind_device()
1031 allocates the client structure that will be used.
1032
1033======================================================================*/
1034
1035static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1036{
1037 struct pcmcia_driver *p_drv;
1038 struct pcmcia_device *p_dev;
1039 int ret = 0;
1040 unsigned long flags;
1041
1042 s = pcmcia_get_bus_socket(s);
1043 if (!s)
1044 return -EINVAL;
1045
1046 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1047 (char *)bind_info->dev_info);
1048
1049 p_drv = get_pcmcia_driver(&bind_info->dev_info);
1050 if (!p_drv) {
1051 ret = -EINVAL;
1052 goto err_put;
1053 }
1054
1055 if (!try_module_get(p_drv->owner)) {
1056 ret = -EINVAL;
1057 goto err_put_driver;
1058 }
1059
1060 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1061 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1062 if (p_dev->func == bind_info->function) {
1063 if ((p_dev->dev.driver == &p_drv->drv)) {
1064 if (p_dev->cardmgr) {
1065 /* if there's already a device
1066 * registered, and it was registered
1067 * by userspace before, we need to
1068 * return the "instance". */
1069 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1070 bind_info->instance = p_dev->instance;
1071 ret = -EBUSY;
1072 goto err_put_module;
1073 } else {
1074 /* the correct driver managed to bind
1075 * itself magically to the correct
1076 * device. */
1077 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1078 p_dev->cardmgr = p_drv;
1079 ret = 0;
1080 goto err_put_module;
1081 }
1082 } else if (!p_dev->dev.driver) {
1083 /* there's already a device available where
1084 * no device has been bound to yet. So we don't
1085 * need to register a device! */
1086 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1087 goto rescan;
1088 }
1089 }
1090 }
1091 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1092
1093 p_dev = pcmcia_device_add(s, bind_info->function);
1094 if (!p_dev) {
1095 ret = -EIO;
1096 goto err_put_module;
1097 }
1098
1099rescan:
1100 p_dev->cardmgr = p_drv;
1101
1ad275e3
DB		 1102 /* if a driver is already running, we can abort */
1103 if (p_dev->dev.driver)
1104 goto err_put_module;
1da177e4
LT		 1105
1106 /*
1107 * Prevent this racing with a card insertion.
1108 */
1109 down(&s->parent->skt_sem);
1110 bus_rescan_devices(&pcmcia_bus_type);
1111 up(&s->parent->skt_sem);
1112
1113 /* check whether the driver indeed matched. I don't care if this
1114 * is racy or not, because it can only happen on cardmgr access
1115 * paths...
1116 */
1117 if (!(p_dev->dev.driver == &p_drv->drv))
1118 p_dev->cardmgr = NULL;
1119
1120 err_put_module:
1121 module_put(p_drv->owner);
1122 err_put_driver:
1123 put_driver(&p_drv->drv);
1124 err_put:
1125 pcmcia_put_bus_socket(s);
1126
1127 return (ret);
1128} /* bind_request */
1129
1130
1131int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1132{
1133 client_t *client = NULL;
1134 struct pcmcia_socket *s;
1135 struct pcmcia_bus_socket *skt = NULL;
1136 struct pcmcia_device *p_dev = NULL;
1137
1138 /* Look for unbound client with matching dev_info */
1139 down_read(&pcmcia_socket_list_rwsem);
1140 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1141 unsigned long flags;
1142
1143 if (s->state & SOCKET_CARDBUS)
1144 continue;
1145
1146 skt = s->pcmcia;
1147 if (!skt)
1148 continue;
1149 skt = pcmcia_get_bus_socket(skt);
1150 if (!skt)
1151 continue;
1152 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1153 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1154 struct pcmcia_driver *p_drv;
1155 p_dev = pcmcia_get_dev(p_dev);
1156 if (!p_dev)
1157 continue;
1158 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1159 (!p_dev->dev.driver)) {
1160 pcmcia_put_dev(p_dev);
1161 continue;
1162 }
1163 p_drv = to_pcmcia_drv(p_dev->dev.driver);
1164 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1165 client = &p_dev->client;
1166 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1167 goto found;
1168 }
1169 pcmcia_put_dev(p_dev);
1170 }
1171 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1172 pcmcia_put_bus_socket(skt);
1173 }
1174 found:
1175 up_read(&pcmcia_socket_list_rwsem);
1176 if (!p_dev || !client)
1177 return -ENODEV;
1178
1179 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1180
1181 *handle = client;
1182 client->state &= ~CLIENT_UNBOUND;
1183 client->Socket = s;
1184 client->EventMask = req->EventMask;
1185 client->event_handler = req->event_handler;
1186 client->event_callback_args = req->event_callback_args;
1187 client->event_callback_args.client_handle = client;
1188
1189 if (s->state & SOCKET_CARDBUS)
1190 client->state |= CLIENT_CARDBUS;
1191
1192 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1193 (client->Function != BIND_FN_ALL)) {
1194 cistpl_longlink_mfc_t mfc;
1195 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1196 == CS_SUCCESS)
1197 s->functions = mfc.nfn;
1198 else
1199 s->functions = 1;
1200 s->config = kmalloc(sizeof(config_t) * s->functions,
1201 GFP_KERNEL);
1202 if (!s->config)
1203 goto out_no_resource;
1204 memset(s->config, 0, sizeof(config_t) * s->functions);
1205 }
1206
1207 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1208 client, p_dev->dev.bus_id);
1209 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1210 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1211
1212 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1213 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1214 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1215 }
1216
1217 return CS_SUCCESS;
1218
1219 out_no_resource:
1220 pcmcia_put_dev(p_dev);
1221 return CS_OUT_OF_RESOURCE;
1222} /* register_client */
1223EXPORT_SYMBOL(pcmcia_register_client);
1224
1225
1226/*====================================================================*/
1227
1228extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1229
1230static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1231{
1232 dev_node_t *node;
1233 struct pcmcia_device *p_dev;
1234 unsigned long flags;
1235 int ret = 0;
1236
1237#ifdef CONFIG_CARDBUS
1238 /*
1239 * Some unbelievably ugly code to associate the PCI cardbus
1240 * device and its driver with the PCMCIA "bind" information.
1241 */
1242 {
1243 struct pci_bus *bus;
1244
1245 bus = pcmcia_lookup_bus(s->parent);
1246 if (bus) {
1247 struct list_head *list;
1248 struct pci_dev *dev = NULL;
1249
1250 list = bus->devices.next;
1251 while (list != &bus->devices) {
1252 struct pci_dev *pdev = pci_dev_b(list);
1253 list = list->next;
1254
1255 if (first) {
1256 dev = pdev;
1257 break;
1258 }
1259
1260 /* Try to handle "next" here some way? */
1261 }
1262 if (dev && dev->driver) {
1263 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1264 bind_info->major = 0;
1265 bind_info->minor = 0;
1266 bind_info->next = NULL;
1267 return 0;
1268 }
1269 }
1270 }
1271#endif
1272
1273 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1274 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1275 if (p_dev->func == bind_info->function) {
1276 p_dev = pcmcia_get_dev(p_dev);
1277 if (!p_dev)
1278 continue;
1279 goto found;
1280 }
1281 }
1282 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1283 return -ENODEV;
1284
1285 found:
1286 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1287
1288 if ((!p_dev->instance) ||
1289 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1290 ret = -EAGAIN;
1291 goto err_put;
1292 }
1293
1294 if (first)
1295 node = p_dev->instance->dev;
1296 else
1297 for (node = p_dev->instance->dev; node; node = node->next)
1298 if (node == bind_info->next)
1299 break;
1300 if (!node) {
1301 ret = -ENODEV;
1302 goto err_put;
1303 }
1304
1305 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1306 bind_info->major = node->major;
1307 bind_info->minor = node->minor;
1308 bind_info->next = node->next;
1309
1310 err_put:
1311 pcmcia_put_dev(p_dev);
1312 return (ret);
1313} /* get_device_info */
1314
1315/*====================================================================*/
1316
1317/* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1318 * drivers have been called with EVENT_CARD_REMOVAL before.
1319 */
1320static int unbind_request(struct pcmcia_bus_socket *s)
1321{
1322 struct pcmcia_device *p_dev;
1323 unsigned long flags;
1324
1325 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1326
1327 s->device_count = 0;
1328
1329 for (;;) {
1330 /* unregister all pcmcia_devices registered with this socket*/
1331 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1332 if (list_empty(&s->devices_list)) {
1333 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1334 return 0;
1335 }
1336 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1337 list_del(&p_dev->socket_device_list);
1338 p_dev->client.state |= CLIENT_STALE;
1339 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1340
1341 device_unregister(&p_dev->dev);
1342 }
1343
1344 return 0;
1345} /* unbind_request */
1346
1347int pcmcia_deregister_client(client_handle_t handle)
1348{
1349 struct pcmcia_socket *s;
1350 int i;
1351 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1352
1353 if (CHECK_HANDLE(handle))
1354 return CS_BAD_HANDLE;
1355
1356 s = SOCKET(handle);
1357 ds_dbg(1, "deregister_client(%p)\n", handle);
1358
1359 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1360 goto warn_out;
1361 for (i = 0; i < MAX_WIN; i++)
1362 if (handle->state & CLIENT_WIN_REQ(i))
1363 goto warn_out;
1364
1365 if (handle->state & CLIENT_STALE) {
1366 handle->client_magic = 0;
1367 handle->state &= ~CLIENT_STALE;
1368 pcmcia_put_dev(p_dev);
1369 } else {
1370 handle->state = CLIENT_UNBOUND;
1371 handle->event_handler = NULL;
1372 }
1373
1374 return CS_SUCCESS;
1375 warn_out:
1376 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1377 return CS_IN_USE;
1378} /* deregister_client */
1379EXPORT_SYMBOL(pcmcia_deregister_client);
1380
1381
1382/*======================================================================
1383
1384 The user-mode PC Card device interface
1385
1386======================================================================*/
1387
1388static int ds_open(struct inode *inode, struct file *file)
1389{
1390 socket_t i = iminor(inode);
1391 struct pcmcia_bus_socket *s;
1392 user_info_t *user;
1393
1394 ds_dbg(0, "ds_open(socket %d)\n", i);
1395
1396 s = get_socket_info_by_nr(i);
1397 if (!s)
1398 return -ENODEV;
1399 s = pcmcia_get_bus_socket(s);
1400 if (!s)
1401 return -ENODEV;
1402
1403 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1404 if (s->state & DS_SOCKET_BUSY) {
1405 pcmcia_put_bus_socket(s);
1406 return -EBUSY;
1407 }
1408 else
1409 s->state |= DS_SOCKET_BUSY;
1410 }
1411
1412 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1413 if (!user) {
1414 pcmcia_put_bus_socket(s);
1415 return -ENOMEM;
1416 }
1417 user->event_tail = user->event_head = 0;
1418 user->next = s->user;
1419 user->user_magic = USER_MAGIC;
1420 user->socket = s;
1421 s->user = user;
1422 file->private_data = user;
1423
1424 if (s->state & DS_SOCKET_PRESENT)
1425 queue_event(user, CS_EVENT_CARD_INSERTION);
1426 return 0;
1427} /* ds_open */
1428
1429/*====================================================================*/
1430
1431static int ds_release(struct inode *inode, struct file *file)
1432{
1433 struct pcmcia_bus_socket *s;
1434 user_info_t *user, **link;
1435
1436 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1437
1438 user = file->private_data;
1439 if (CHECK_USER(user))
1440 goto out;
1441
1442 s = user->socket;
1443
1444 /* Unlink user data structure */
1445 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1446 s->state &= ~DS_SOCKET_BUSY;
1447 }
1448 file->private_data = NULL;
1449 for (link = &s->user; *link; link = &(*link)->next)
1450 if (*link == user) break;
1451 if (link == NULL)
1452 goto out;
1453 *link = user->next;
1454 user->user_magic = 0;
1455 kfree(user);
1456 pcmcia_put_bus_socket(s);
1457out:
1458 return 0;
1459} /* ds_release */
1460
1461/*====================================================================*/
1462
1463static ssize_t ds_read(struct file *file, char __user *buf,
1464 size_t count, loff_t *ppos)
1465{
1466 struct pcmcia_bus_socket *s;
1467 user_info_t *user;
1468 int ret;
1469
1470 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1471
1472 if (count < 4)
1473 return -EINVAL;
1474
1475 user = file->private_data;
1476 if (CHECK_USER(user))
1477 return -EIO;
1478
1479 s = user->socket;
1480 if (s->state & DS_SOCKET_DEAD)
1481 return -EIO;
1482
1483 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1484 if (ret == 0)
1485 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1486
1487 return ret;
1488} /* ds_read */
1489
1490/*====================================================================*/
1491
1492static ssize_t ds_write(struct file *file, const char __user *buf,
1493 size_t count, loff_t *ppos)
1494{
1495 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1496
1497 if (count != 4)
1498 return -EINVAL;
1499 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1500 return -EBADF;
1501
1502 return -EIO;
1503} /* ds_write */
1504
1505/*====================================================================*/
1506
1507/* No kernel lock - fine */
1508static u_int ds_poll(struct file *file, poll_table *wait)
1509{
1510 struct pcmcia_bus_socket *s;
1511 user_info_t *user;
1512
1513 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1514
1515 user = file->private_data;
1516 if (CHECK_USER(user))
1517 return POLLERR;
1518 s = user->socket;
1519 /*
1520 * We don't check for a dead socket here since that
1521 * will send cardmgr into an endless spin.
1522 */
1523 poll_wait(file, &s->queue, wait);
1524 if (!queue_empty(user))
1525 return POLLIN | POLLRDNORM;
1526 return 0;
1527} /* ds_poll */
1528
1529/*====================================================================*/
1530
1531extern int pcmcia_adjust_resource_info(adjust_t *adj);
1532
1533static int ds_ioctl(struct inode * inode, struct file * file,
1534 u_int cmd, u_long arg)
1535{
1536 struct pcmcia_bus_socket *s;
1537 void __user *uarg = (char __user *)arg;
1538 u_int size;
1539 int ret, err;
1540 ds_ioctl_arg_t *buf;
1541 user_info_t *user;
1542
1543 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1544
1545 user = file->private_data;
1546 if (CHECK_USER(user))
1547 return -EIO;
1548
1549 s = user->socket;
1550 if (s->state & DS_SOCKET_DEAD)
1551 return -EIO;
1552
1553 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1554 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1555
1556 /* Permission check */
1557 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1558 return -EPERM;
1559
1560 if (cmd & IOC_IN) {
1561 if (!access_ok(VERIFY_READ, uarg, size)) {
1562 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1563 return -EFAULT;
1564 }
1565 }
1566 if (cmd & IOC_OUT) {
1567 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1568 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1569 return -EFAULT;
1570 }
1571 }
1572 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1573 if (!buf)
1574 return -ENOMEM;
1575
1576 err = ret = 0;
1577
1578 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1579
1580 switch (cmd) {
1581 case DS_ADJUST_RESOURCE_INFO:
1582 ret = pcmcia_adjust_resource_info(&buf->adjust);
1583 break;
1584 case DS_GET_CARD_SERVICES_INFO:
1585 ret = pcmcia_get_card_services_info(&buf->servinfo);
1586 break;
1587 case DS_GET_CONFIGURATION_INFO:
1588 if (buf->config.Function &&
1589 (buf->config.Function >= s->parent->functions))
1590 ret = CS_BAD_ARGS;
1591 else
1592 ret = pccard_get_configuration_info(s->parent,
1593 buf->config.Function, &buf->config);
1594 break;
1595 case DS_GET_FIRST_TUPLE:
1596 down(&s->parent->skt_sem);
1597 pcmcia_validate_mem(s->parent);
1598 up(&s->parent->skt_sem);
1599 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1600 break;
1601 case DS_GET_NEXT_TUPLE:
1602 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1603 break;
1604 case DS_GET_TUPLE_DATA:
1605 buf->tuple.TupleData = buf->tuple_parse.data;
1606 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1607 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1608 break;
1609 case DS_PARSE_TUPLE:
1610 buf->tuple.TupleData = buf->tuple_parse.data;
1611 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1612 break;
1613 case DS_RESET_CARD:
1614 ret = pccard_reset_card(s->parent);
1615 break;
1616 case DS_GET_STATUS:
1617 if (buf->status.Function &&
1618 (buf->status.Function >= s->parent->functions))
1619 ret = CS_BAD_ARGS;
1620 else
1621 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1622 break;
1623 case DS_VALIDATE_CIS:
1624 down(&s->parent->skt_sem);
1625 pcmcia_validate_mem(s->parent);
1626 up(&s->parent->skt_sem);
1627 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1628 break;
1629 case DS_SUSPEND_CARD:
1630 ret = pcmcia_suspend_card(s->parent);
1631 break;
1632 case DS_RESUME_CARD:
1633 ret = pcmcia_resume_card(s->parent);
1634 break;
1635 case DS_EJECT_CARD:
1636 err = pcmcia_eject_card(s->parent);
1637 break;
1638 case DS_INSERT_CARD:
1639 err = pcmcia_insert_card(s->parent);
1640 break;
1641 case DS_ACCESS_CONFIGURATION_REGISTER:
1642 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1643 err = -EPERM;
1644 goto free_out;
1645 }
1646 if (buf->conf_reg.Function &&
1647 (buf->conf_reg.Function >= s->parent->functions))
1648 ret = CS_BAD_ARGS;
1649 else
1650 ret = pccard_access_configuration_register(s->parent,
1651 buf->conf_reg.Function, &buf->conf_reg);
1652 break;
1653 case DS_GET_FIRST_REGION:
1654 case DS_GET_NEXT_REGION:
1655 case DS_BIND_MTD:
1656 if (!capable(CAP_SYS_ADMIN)) {
1657 err = -EPERM;
1658 goto free_out;
1659 } else {
1660 static int printed = 0;
1661 if (!printed) {
1662 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1663 printk(KERN_WARNING "MTD handling any more.\n");
1664 printed++;
1665 }
1666 }
1667 err = -EINVAL;
1668 goto free_out;
1669 break;
1670 case DS_GET_FIRST_WINDOW:
1671 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1672 &buf->win_info.window);
1673 break;
1674 case DS_GET_NEXT_WINDOW:
1675 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1676 buf->win_info.handle->index + 1, &buf->win_info.window);
1677 break;
1678 case DS_GET_MEM_PAGE:
1679 ret = pcmcia_get_mem_page(buf->win_info.handle,
1680 &buf->win_info.map);
1681 break;
1682 case DS_REPLACE_CIS:
1683 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1684 break;
1685 case DS_BIND_REQUEST:
1686 if (!capable(CAP_SYS_ADMIN)) {
1687 err = -EPERM;
1688 goto free_out;
1689 }
1690 err = bind_request(s, &buf->bind_info);
1691 break;
1692 case DS_GET_DEVICE_INFO:
1693 err = get_device_info(s, &buf->bind_info, 1);
1694 break;
1695 case DS_GET_NEXT_DEVICE:
1696 err = get_device_info(s, &buf->bind_info, 0);
1697 break;
1698 case DS_UNBIND_REQUEST:
1699 err = 0;
1700 break;
1701 default:
1702 err = -EINVAL;
1703 }
1704
1705 if ((err == 0) && (ret != CS_SUCCESS)) {
1706 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1707 switch (ret) {
1708 case CS_BAD_SOCKET: case CS_NO_CARD:
1709 err = -ENODEV; break;
1710 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1711 case CS_BAD_TUPLE:
1712 err = -EINVAL; break;
1713 case CS_IN_USE:
1714 err = -EBUSY; break;
1715 case CS_OUT_OF_RESOURCE:
1716 err = -ENOSPC; break;
1717 case CS_NO_MORE_ITEMS:
1718 err = -ENODATA; break;
1719 case CS_UNSUPPORTED_FUNCTION:
1720 err = -ENOSYS; break;
1721 default:
1722 err = -EIO; break;
1723 }
1724 }
1725
1726 if (cmd & IOC_OUT) {
1727 if (__copy_to_user(uarg, (char *)buf, size))
1728 err = -EFAULT;
1729 }
1730
1731free_out:
1732 kfree(buf);
1733 return err;
1734} /* ds_ioctl */
1735
1736/*====================================================================*/
1737
1738static struct file_operations ds_fops = {
1739 .owner = THIS_MODULE,
1740 .open = ds_open,
1741 .release = ds_release,
1742 .ioctl = ds_ioctl,
1743 .read = ds_read,
1744 .write = ds_write,
1745 .poll = ds_poll,
1746};
1747
1748static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1749{
1750 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1751 struct pcmcia_bus_socket *s;
1752 int ret;
1753
1754 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1755 if(!s)
1756 return -ENOMEM;
1757 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1758
1759 /* get reference to parent socket */
1760 s->parent = pcmcia_get_socket(socket);
1761 if (!s->parent) {
1762 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1763 kfree (s);
1764 return -ENODEV;
1765 }
1766
1767 kref_init(&s->refcount);
1768
1769 /*
1770 * Ugly. But we want to wait for the socket threads to have started up.
1771 * We really should let the drivers themselves drive some of this..
1772 */
1773 msleep(250);
1774
1775 init_waitqueue_head(&s->queue);
1776 INIT_LIST_HEAD(&s->devices_list);
1ad275e3 1777 INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1da177e4
LT		 1778
1779 /* Set up hotline to Card Services */
1780 s->callback.owner = THIS_MODULE;
1781 s->callback.event = &ds_event;
1782 s->callback.resources_done = &pcmcia_card_add;
ff1fa9ef 1783 s->callback.replace_cis = &pcmcia_bus_rescan;
1da177e4
LT		 1784 socket->pcmcia = s;
1785
1786 ret = pccard_register_pcmcia(socket, &s->callback);
1787 if (ret) {
1788 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1789 pcmcia_put_bus_socket(s);
1790 socket->pcmcia = NULL;
1791 return (ret);
1792 }
1793
1794 return 0;
1795}
1796
1797
1798static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1799{
1800 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1801
1802 if (!socket || !socket->pcmcia)
1803 return;
1804
1805 pccard_register_pcmcia(socket, NULL);
1806
1807 socket->pcmcia->state |= DS_SOCKET_DEAD;
1808 pcmcia_put_bus_socket(socket->pcmcia);
1809 socket->pcmcia = NULL;
1810
1811 return;
1812}
1813
1814
1815/* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1816static struct class_interface pcmcia_bus_interface = {
1817 .class = &pcmcia_socket_class,
1818 .add = &pcmcia_bus_add_socket,
1819 .remove = &pcmcia_bus_remove_socket,
1820};
1821
1822
1823struct bus_type pcmcia_bus_type = {
1824 .name = "pcmcia",
840c2ac5 1825 .hotplug = pcmcia_bus_hotplug,
1da177e4
LT		 1826 .match = pcmcia_bus_match,
1827 .dev_attrs = pcmcia_dev_attrs,
1828};
1829EXPORT_SYMBOL(pcmcia_bus_type);
1830
1831
1832static int __init init_pcmcia_bus(void)
1833{
1834 int i;
1835
1836 spin_lock_init(&pcmcia_dev_list_lock);
1837
1838 bus_register(&pcmcia_bus_type);
1839 class_interface_register(&pcmcia_bus_interface);
1840
1841 /* Set up character device for user mode clients */
1842 i = register_chrdev(0, "pcmcia", &ds_fops);
afbf510d 1843 if (i < 0)
1da177e4 1844 printk(KERN_NOTICE "unable to find a free device # for "
afbf510d 1845 "Driver Services (error=%d)\n", i);
1da177e4
LT		 1846 else
1847 major_dev = i;
1848
1849#ifdef CONFIG_PROC_FS
1850 proc_pccard = proc_mkdir("pccard", proc_bus);
1851 if (proc_pccard)
1852 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1853#endif
1854
1855 return 0;
1856}
1857fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1858 * pcmcia_socket_class is already registered */
1859
1860
1861static void __exit exit_pcmcia_bus(void)
1862{
1863 class_interface_unregister(&pcmcia_bus_interface);
1864
1865#ifdef CONFIG_PROC_FS
1866 if (proc_pccard) {
1867 remove_proc_entry("drivers", proc_pccard);
1868 remove_proc_entry("pccard", proc_bus);
1869 }
1870#endif
1871 if (major_dev != -1)
1872 unregister_chrdev(major_dev, "pcmcia");
1873
1874 bus_unregister(&pcmcia_bus_type);
1875}
1876module_exit(exit_pcmcia_bus);
1877
1878
1879
1880/* helpers for backwards-compatible functions */
1881
1882static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1883{
1884 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1885 if (s && s->pcmcia)
1886 return s->pcmcia;
1887 else
1888 return NULL;
1889}
1890
1891/* backwards-compatible accessing of driver --- by name! */
1892
1893static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1894{
1895 struct device_driver *drv;
1896 struct pcmcia_driver *p_drv;
1897
1898 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1899 if (!drv)
1900 return NULL;
1901
1902 p_drv = container_of(drv, struct pcmcia_driver, drv);
1903
1904 return (p_drv);
1905}
1906
1907MODULE_ALIAS("ds");
Linux kernel - Deliverables
This page took 0.119704 seconds and 5 git commands to generate.