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