2 * ds.c -- 16-bit PCMCIA core support
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.
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.
12 * (C) 1999 David A. Hinds
13 * (C) 2003 - 2004 Dominik Brodowski
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>
26 #include <linux/fcntl.h>
27 #include <linux/sched.h>
28 #include <linux/smp_lock.h>
29 #include <linux/timer.h>
30 #include <linux/ioctl.h>
31 #include <linux/proc_fs.h>
32 #include <linux/poll.h>
33 #include <linux/pci.h>
34 #include <linux/list.h>
35 #include <linux/delay.h>
36 #include <linux/kref.h>
37 #include <linux/workqueue.h>
38 #include <linux/crc32.h>
40 #include <asm/atomic.h>
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>
51 #include "cs_internal.h"
53 /*====================================================================*/
55 /* Module parameters */
57 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
58 MODULE_DESCRIPTION("PCMCIA Driver Services");
59 MODULE_LICENSE("GPL");
64 module_param_named(pc_debug, ds_pc_debug, int, 0644);
66 #define ds_dbg(lvl, fmt, arg...) do { \
67 if (ds_pc_debug > (lvl)) \
68 printk(KERN_DEBUG "ds: " fmt , ## arg); \
71 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
74 /*====================================================================*/
76 /* Device user information */
78 #define USER_MAGIC 0x7ea4
79 #define CHECK_USER(u) \
80 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
81 typedef struct user_info_t {
83 int event_head, event_tail;
84 event_t event[MAX_EVENTS];
85 struct user_info_t *next;
86 struct pcmcia_bus_socket *socket;
89 /* Socket state information */
90 struct pcmcia_bus_socket {
92 struct pcmcia_callback callback;
95 wait_queue_head_t queue;
96 struct pcmcia_socket *parent;
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 */
105 u8 device_add_pending;
106 struct work_struct device_add;
108 static spinlock_t pcmcia_dev_list_lock;
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
115 /*====================================================================*/
117 static int major_dev = -1;
119 static int unbind_request(struct pcmcia_bus_socket *s);
121 /*====================================================================*/
123 /* code which was in cs.c before */
125 /* String tables for error messages */
127 typedef struct lookup_t {
132 static 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" }
167 static 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" }
220 int pcmcia_report_error(client_handle_t handle, error_info_t *err)
225 if (CHECK_HANDLE(handle))
228 struct pcmcia_device *p_dev = handle_to_pdev(handle);
229 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
232 for (i = 0; i < ARRAY_SIZE(service_table); i++)
233 if (service_table[i].key == err->func)
235 if (i < ARRAY_SIZE(service_table))
236 serv = service_table[i].msg;
238 serv = "Unknown service number";
240 for (i = 0; i < ARRAY_SIZE(error_table); i++)
241 if (error_table[i].key == err->retcode)
243 if (i < ARRAY_SIZE(error_table))
244 printk("%s: %s\n", serv, error_table[i].msg);
246 printk("%s: Unknown error code %#x\n", serv, err->retcode);
250 EXPORT_SYMBOL(pcmcia_report_error);
252 /* end of code which was in cs.c before */
254 /*======================================================================*/
256 void cs_error(client_handle_t handle, int func, int ret)
258 error_info_t err = { func, ret };
259 pcmcia_report_error(handle, &err);
261 EXPORT_SYMBOL(cs_error);
263 #ifdef CONFIG_PCMCIA_DEBUG
266 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
268 struct pcmcia_device_id *did = p_drv->id_table;
272 while (did && did->match_flags) {
273 for (i=0; i<4; i++) {
274 if (!did->prod_id[i])
277 hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
278 if (hash == did->prod_id_hash[i])
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);
293 static inline void pcmcia_check_driver(struct pcmcia_driver *p_drv) {
298 /*======================================================================*/
300 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info);
301 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr);
303 static void pcmcia_release_bus_socket(struct kref *refcount)
305 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
306 pcmcia_put_socket(s->parent);
310 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
312 kref_put(&s->refcount, pcmcia_release_bus_socket);
315 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
317 kref_get(&s->refcount);
322 * pcmcia_register_driver - register a PCMCIA driver with the bus core
324 * Registers a PCMCIA driver with the PCMCIA bus core.
326 static int pcmcia_device_probe(struct device *dev);
327 static int pcmcia_device_remove(struct device * dev);
329 int pcmcia_register_driver(struct pcmcia_driver *driver)
334 pcmcia_check_driver(driver);
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;
342 return driver_register(&driver->drv);
344 EXPORT_SYMBOL(pcmcia_register_driver);
347 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
349 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
351 driver_unregister(&driver->drv);
353 EXPORT_SYMBOL(pcmcia_unregister_driver);
355 #ifdef CONFIG_PROC_FS
356 static struct proc_dir_entry *proc_pccard = NULL;
358 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
361 struct pcmcia_driver *p_drv = container_of(driver,
362 struct pcmcia_driver, drv);
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
376 static int proc_read_drivers(char *buf, char **start, off_t pos,
377 int count, int *eof, void *data)
381 bus_for_each_drv(&pcmcia_bus_type, NULL,
382 (void *) &p, proc_read_drivers_callback);
388 /* pcmcia_device handling */
390 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
392 struct device *tmp_dev;
393 tmp_dev = get_device(&p_dev->dev);
396 return to_pcmcia_dev(tmp_dev);
399 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
402 put_device(&p_dev->dev);
405 static void pcmcia_release_dev(struct device *dev)
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);
414 static int pcmcia_device_probe(struct device * dev)
416 struct pcmcia_device *p_dev;
417 struct pcmcia_driver *p_drv;
420 dev = get_device(dev);
424 p_dev = to_pcmcia_dev(dev);
425 p_drv = to_pcmcia_drv(dev->driver);
427 if (!try_module_get(p_drv->owner)) {
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);
442 module_put(p_drv->owner);
444 if ((ret) || !(p_drv->attach))
450 static int pcmcia_device_remove(struct device * dev)
452 struct pcmcia_device *p_dev;
453 struct pcmcia_driver *p_drv;
455 /* detach the "instance" */
456 p_dev = to_pcmcia_dev(dev);
457 p_drv = to_pcmcia_drv(dev->driver);
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);
465 module_put(p_drv->owner);
474 * pcmcia_device_query -- determine information about a pcmcia device
476 static int pcmcia_device_query(struct pcmcia_device *p_dev)
478 cistpl_manfid_t manf_id;
479 cistpl_funcid_t func_id;
480 cistpl_vers_1_t vers1;
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;
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;
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 "
504 p_dev->func_id = CISTPL_FUNCID_MEMORY;
505 p_dev->has_func_id = 1;
509 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
511 for (i=0; i < vers1.ns; i++) {
515 tmp = vers1.str + vers1.ofs[i];
517 length = strlen(tmp) + 1;
518 if ((length < 3) || (length > 255))
521 p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
523 if (!p_dev->prod_id[i])
526 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
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.
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
542 static DECLARE_MUTEX(device_add_lock);
544 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function)
546 struct pcmcia_device *p_dev;
549 s = pcmcia_get_bus_socket(s);
553 down(&device_add_lock);
555 /* max of 2 devices per card */
556 if (s->device_count == 2)
559 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
562 memset(p_dev, 0, sizeof(struct pcmcia_device));
564 p_dev->socket = s->parent;
565 p_dev->device_no = (s->device_count++);
566 p_dev->func = function;
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);
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;
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);
584 pcmcia_device_query(p_dev);
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);
594 up(&device_add_lock);
602 up(&device_add_lock);
603 pcmcia_put_bus_socket(s);
609 static int pcmcia_card_add(struct pcmcia_socket *s)
612 cistpl_longlink_mfc_t mfc;
613 unsigned int no_funcs, i;
616 if (!(s->resource_setup_done))
617 return -EAGAIN; /* try again, but later... */
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");
626 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
631 /* this doesn't handle multifunction devices on one pcmcia function
633 for (i=0; i < no_funcs; i++)
634 pcmcia_device_add(s->pcmcia, i);
640 static void pcmcia_delayed_add_pseudo_device(void *data)
642 struct pcmcia_bus_socket *s = data;
643 pcmcia_device_add(s, 0);
644 s->device_add_pending = 0;
647 static inline void pcmcia_add_pseudo_device(struct pcmcia_bus_socket *s)
649 if (!s->device_add_pending) {
650 schedule_work(&s->device_add);
651 s->device_add_pending = 1;
656 static void pcmcia_bus_rescan(void)
658 /* must be called with skt_sem held */
659 bus_rescan_devices(&pcmcia_bus_type);
662 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
663 struct pcmcia_device_id *did)
665 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
666 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
670 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
671 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
675 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
676 if (dev->func != did->function)
680 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
681 if (!dev->prod_id[0])
683 if (strcmp(did->prod_id[0], dev->prod_id[0]))
687 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
688 if (!dev->prod_id[1])
690 if (strcmp(did->prod_id[1], dev->prod_id[1]))
694 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
695 if (!dev->prod_id[2])
697 if (strcmp(did->prod_id[2], dev->prod_id[2]))
701 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
702 if (!dev->prod_id[3])
704 if (strcmp(did->prod_id[3], dev->prod_id[3]))
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.
715 if (dev->device_no == 0)
716 pcmcia_add_pseudo_device(dev->socket->pcmcia);
718 if (dev->device_no != did->device_no)
722 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
723 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
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)
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.
737 if (!dev->allow_func_id_match)
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 */
749 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
754 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
758 dev->dev.driver_data = (void *) did;
764 static 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);
767 struct pcmcia_device_id *did = p_drv->id_table;
769 /* matching by cardmgr */
770 if (p_dev->cardmgr == p_drv)
773 while (did && did->match_flags) {
774 if (pcmcia_devmatch(p_dev, did))
782 #ifdef CONFIG_HOTPLUG
784 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
785 char *buffer, int buffer_size)
787 struct pcmcia_device *p_dev;
789 u32 hash[4] = { 0, 0, 0, 0};
794 p_dev = to_pcmcia_dev(dev);
796 /* calculate hashes */
797 for (i=0; i<4; i++) {
798 if (!p_dev->prod_id[i])
800 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
805 if (add_hotplug_env_var(envp, num_envp, &i,
806 buffer, buffer_size, &length,
808 p_dev->socket->sock))
811 if (add_hotplug_env_var(envp, num_envp, &i,
812 buffer, buffer_size, &length,
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,
839 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
840 char *buffer, int buffer_size)
847 /************************ per-device sysfs output ***************************/
849 #define pcmcia_device_attr(field, test, format) \
850 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
852 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
853 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
856 #define pcmcia_device_stringattr(name, field) \
857 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
859 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
860 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
863 pcmcia_device_attr(func, socket, "0x%02x\n");
864 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
865 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
866 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
867 pcmcia_device_stringattr(prod_id1, prod_id[0]);
868 pcmcia_device_stringattr(prod_id2, prod_id[1]);
869 pcmcia_device_stringattr(prod_id3, prod_id[2]);
870 pcmcia_device_stringattr(prod_id4, prod_id[3]);
873 static ssize_t pcmcia_store_allow_func_id_match (struct device * dev, struct device_attribute *attr,
874 const char * buf, size_t count)
876 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
880 down(&p_dev->socket->skt_sem);
881 p_dev->allow_func_id_match = 1;
882 up(&p_dev->socket->skt_sem);
884 bus_rescan_devices(&pcmcia_bus_type);
889 static struct device_attribute pcmcia_dev_attrs[] = {
890 __ATTR(function, 0444, func_show, NULL),
898 __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match),
903 /*======================================================================
905 These manage a ring buffer of events pending for one user process
907 ======================================================================*/
909 static int queue_empty(user_info_t *user)
911 return (user->event_head == user->event_tail);
914 static event_t get_queued_event(user_info_t *user)
916 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
917 return user->event[user->event_tail];
920 static void queue_event(user_info_t *user, event_t event)
922 user->event_head = (user->event_head+1) % MAX_EVENTS;
923 if (user->event_head == user->event_tail)
924 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
925 user->event[user->event_head] = event;
928 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
931 for (user = s->user; user; user = user->next)
932 queue_event(user, event);
933 wake_up_interruptible(&s->queue);
937 /*======================================================================
939 The card status event handler.
941 ======================================================================*/
943 struct send_event_data {
944 struct pcmcia_socket *skt;
949 static int send_event_callback(struct device *dev, void * _data)
951 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
952 struct send_event_data *data = _data;
954 /* we get called for all sockets, but may only pass the event
955 * for drivers _on the affected socket_ */
956 if (p_dev->socket != data->skt)
959 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
962 if (p_dev->client.EventMask & data->event)
963 return EVENT(&p_dev->client, data->event, data->priority);
968 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
971 struct send_event_data private;
972 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
978 private.event = event;
979 private.priority = priority;
981 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
983 pcmcia_put_bus_socket(skt);
988 /* Normally, the event is passed to individual drivers after
989 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
990 * is inversed to maintain historic compatibility.
993 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
995 struct pcmcia_bus_socket *s = skt->pcmcia;
998 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
1003 case CS_EVENT_CARD_REMOVAL:
1004 s->state &= ~DS_SOCKET_PRESENT;
1005 send_event(skt, event, priority);
1007 handle_event(s, event);
1010 case CS_EVENT_CARD_INSERTION:
1011 s->state |= DS_SOCKET_PRESENT;
1012 pcmcia_card_add(skt);
1013 handle_event(s, event);
1016 case CS_EVENT_EJECTION_REQUEST:
1017 ret = send_event(skt, event, priority);
1021 handle_event(s, event);
1022 send_event(skt, event, priority);
1030 /*======================================================================
1032 bind_request() and bind_device() are merged by now. Register_client()
1033 is called right at the end of bind_request(), during the driver's
1034 ->attach() call. Individual descriptions:
1036 bind_request() connects a socket to a particular client driver.
1037 It looks up the specified device ID in the list of registered
1038 drivers, binds it to the socket, and tries to create an instance
1039 of the device. unbind_request() deletes a driver instance.
1041 Bind_device() associates a device driver with a particular socket.
1042 It is normally called by Driver Services after it has identified
1043 a newly inserted card. An instance of that driver will then be
1044 eligible to register as a client of this socket.
1046 Register_client() uses the dev_info_t handle to match the
1047 caller with a socket. The driver must have already been bound
1048 to a socket with bind_device() -- in fact, bind_device()
1049 allocates the client structure that will be used.
1051 ======================================================================*/
1053 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1055 struct pcmcia_driver *p_drv;
1056 struct pcmcia_device *p_dev;
1058 unsigned long flags;
1060 s = pcmcia_get_bus_socket(s);
1064 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1065 (char *)bind_info->dev_info);
1067 p_drv = get_pcmcia_driver(&bind_info->dev_info);
1073 if (!try_module_get(p_drv->owner)) {
1075 goto err_put_driver;
1078 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1079 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1080 if (p_dev->func == bind_info->function) {
1081 if ((p_dev->dev.driver == &p_drv->drv)) {
1082 if (p_dev->cardmgr) {
1083 /* if there's already a device
1084 * registered, and it was registered
1085 * by userspace before, we need to
1086 * return the "instance". */
1087 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1088 bind_info->instance = p_dev->instance;
1090 goto err_put_module;
1092 /* the correct driver managed to bind
1093 * itself magically to the correct
1095 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1096 p_dev->cardmgr = p_drv;
1098 goto err_put_module;
1100 } else if (!p_dev->dev.driver) {
1101 /* there's already a device available where
1102 * no device has been bound to yet. So we don't
1103 * need to register a device! */
1104 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1109 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1111 p_dev = pcmcia_device_add(s, bind_info->function);
1114 goto err_put_module;
1118 p_dev->cardmgr = p_drv;
1120 /* if a driver is already running, we can abort */
1121 if (p_dev->dev.driver)
1122 goto err_put_module;
1125 * Prevent this racing with a card insertion.
1127 down(&s->parent->skt_sem);
1128 bus_rescan_devices(&pcmcia_bus_type);
1129 up(&s->parent->skt_sem);
1131 /* check whether the driver indeed matched. I don't care if this
1132 * is racy or not, because it can only happen on cardmgr access
1135 if (!(p_dev->dev.driver == &p_drv->drv))
1136 p_dev->cardmgr = NULL;
1139 module_put(p_drv->owner);
1141 put_driver(&p_drv->drv);
1143 pcmcia_put_bus_socket(s);
1146 } /* bind_request */
1149 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1151 client_t *client = NULL;
1152 struct pcmcia_socket *s;
1153 struct pcmcia_bus_socket *skt = NULL;
1154 struct pcmcia_device *p_dev = NULL;
1156 /* Look for unbound client with matching dev_info */
1157 down_read(&pcmcia_socket_list_rwsem);
1158 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1159 unsigned long flags;
1161 if (s->state & SOCKET_CARDBUS)
1167 skt = pcmcia_get_bus_socket(skt);
1170 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1171 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1172 struct pcmcia_driver *p_drv;
1173 p_dev = pcmcia_get_dev(p_dev);
1176 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1177 (!p_dev->dev.driver)) {
1178 pcmcia_put_dev(p_dev);
1181 p_drv = to_pcmcia_drv(p_dev->dev.driver);
1182 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1183 client = &p_dev->client;
1184 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1187 pcmcia_put_dev(p_dev);
1189 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1190 pcmcia_put_bus_socket(skt);
1193 up_read(&pcmcia_socket_list_rwsem);
1194 if (!p_dev || !client)
1197 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1200 client->state &= ~CLIENT_UNBOUND;
1202 client->EventMask = req->EventMask;
1203 client->event_handler = req->event_handler;
1204 client->event_callback_args = req->event_callback_args;
1205 client->event_callback_args.client_handle = client;
1207 if (s->state & SOCKET_CARDBUS)
1208 client->state |= CLIENT_CARDBUS;
1210 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1211 (client->Function != BIND_FN_ALL)) {
1212 cistpl_longlink_mfc_t mfc;
1213 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1215 s->functions = mfc.nfn;
1218 s->config = kmalloc(sizeof(config_t) * s->functions,
1221 goto out_no_resource;
1222 memset(s->config, 0, sizeof(config_t) * s->functions);
1225 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1226 client, p_dev->dev.bus_id);
1227 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1228 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1230 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1231 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1232 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1238 pcmcia_put_dev(p_dev);
1239 return CS_OUT_OF_RESOURCE;
1240 } /* register_client */
1241 EXPORT_SYMBOL(pcmcia_register_client);
1244 /*====================================================================*/
1246 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1248 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1251 struct pcmcia_device *p_dev;
1252 unsigned long flags;
1255 #ifdef CONFIG_CARDBUS
1257 * Some unbelievably ugly code to associate the PCI cardbus
1258 * device and its driver with the PCMCIA "bind" information.
1261 struct pci_bus *bus;
1263 bus = pcmcia_lookup_bus(s->parent);
1265 struct list_head *list;
1266 struct pci_dev *dev = NULL;
1268 list = bus->devices.next;
1269 while (list != &bus->devices) {
1270 struct pci_dev *pdev = pci_dev_b(list);
1278 /* Try to handle "next" here some way? */
1280 if (dev && dev->driver) {
1281 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1282 bind_info->major = 0;
1283 bind_info->minor = 0;
1284 bind_info->next = NULL;
1291 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1292 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1293 if (p_dev->func == bind_info->function) {
1294 p_dev = pcmcia_get_dev(p_dev);
1300 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1304 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1306 if ((!p_dev->instance) ||
1307 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1313 node = p_dev->instance->dev;
1315 for (node = p_dev->instance->dev; node; node = node->next)
1316 if (node == bind_info->next)
1323 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1324 bind_info->major = node->major;
1325 bind_info->minor = node->minor;
1326 bind_info->next = node->next;
1329 pcmcia_put_dev(p_dev);
1331 } /* get_device_info */
1333 /*====================================================================*/
1335 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1336 * drivers have been called with EVENT_CARD_REMOVAL before.
1338 static int unbind_request(struct pcmcia_bus_socket *s)
1340 struct pcmcia_device *p_dev;
1341 unsigned long flags;
1343 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1345 s->device_count = 0;
1348 /* unregister all pcmcia_devices registered with this socket*/
1349 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1350 if (list_empty(&s->devices_list)) {
1351 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1354 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1355 list_del(&p_dev->socket_device_list);
1356 p_dev->client.state |= CLIENT_STALE;
1357 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1359 device_unregister(&p_dev->dev);
1363 } /* unbind_request */
1365 int pcmcia_deregister_client(client_handle_t handle)
1367 struct pcmcia_socket *s;
1369 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1371 if (CHECK_HANDLE(handle))
1372 return CS_BAD_HANDLE;
1375 ds_dbg(1, "deregister_client(%p)\n", handle);
1377 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1379 for (i = 0; i < MAX_WIN; i++)
1380 if (handle->state & CLIENT_WIN_REQ(i))
1383 if (handle->state & CLIENT_STALE) {
1384 handle->client_magic = 0;
1385 handle->state &= ~CLIENT_STALE;
1386 pcmcia_put_dev(p_dev);
1388 handle->state = CLIENT_UNBOUND;
1389 handle->event_handler = NULL;
1394 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1396 } /* deregister_client */
1397 EXPORT_SYMBOL(pcmcia_deregister_client);
1400 /*======================================================================
1402 The user-mode PC Card device interface
1404 ======================================================================*/
1406 static int ds_open(struct inode *inode, struct file *file)
1408 socket_t i = iminor(inode);
1409 struct pcmcia_bus_socket *s;
1412 ds_dbg(0, "ds_open(socket %d)\n", i);
1414 s = get_socket_info_by_nr(i);
1417 s = pcmcia_get_bus_socket(s);
1421 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1422 if (s->state & DS_SOCKET_BUSY) {
1423 pcmcia_put_bus_socket(s);
1427 s->state |= DS_SOCKET_BUSY;
1430 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1432 pcmcia_put_bus_socket(s);
1435 user->event_tail = user->event_head = 0;
1436 user->next = s->user;
1437 user->user_magic = USER_MAGIC;
1440 file->private_data = user;
1442 if (s->state & DS_SOCKET_PRESENT)
1443 queue_event(user, CS_EVENT_CARD_INSERTION);
1447 /*====================================================================*/
1449 static int ds_release(struct inode *inode, struct file *file)
1451 struct pcmcia_bus_socket *s;
1452 user_info_t *user, **link;
1454 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1456 user = file->private_data;
1457 if (CHECK_USER(user))
1462 /* Unlink user data structure */
1463 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1464 s->state &= ~DS_SOCKET_BUSY;
1466 file->private_data = NULL;
1467 for (link = &s->user; *link; link = &(*link)->next)
1468 if (*link == user) break;
1472 user->user_magic = 0;
1474 pcmcia_put_bus_socket(s);
1479 /*====================================================================*/
1481 static ssize_t ds_read(struct file *file, char __user *buf,
1482 size_t count, loff_t *ppos)
1484 struct pcmcia_bus_socket *s;
1488 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1493 user = file->private_data;
1494 if (CHECK_USER(user))
1498 if (s->state & DS_SOCKET_DEAD)
1501 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1503 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1508 /*====================================================================*/
1510 static ssize_t ds_write(struct file *file, const char __user *buf,
1511 size_t count, loff_t *ppos)
1513 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1517 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1523 /*====================================================================*/
1525 /* No kernel lock - fine */
1526 static u_int ds_poll(struct file *file, poll_table *wait)
1528 struct pcmcia_bus_socket *s;
1531 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1533 user = file->private_data;
1534 if (CHECK_USER(user))
1538 * We don't check for a dead socket here since that
1539 * will send cardmgr into an endless spin.
1541 poll_wait(file, &s->queue, wait);
1542 if (!queue_empty(user))
1543 return POLLIN | POLLRDNORM;
1547 /*====================================================================*/
1549 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1551 static int ds_ioctl(struct inode * inode, struct file * file,
1552 u_int cmd, u_long arg)
1554 struct pcmcia_bus_socket *s;
1555 void __user *uarg = (char __user *)arg;
1558 ds_ioctl_arg_t *buf;
1561 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1563 user = file->private_data;
1564 if (CHECK_USER(user))
1568 if (s->state & DS_SOCKET_DEAD)
1571 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1572 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1574 /* Permission check */
1575 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1579 if (!access_ok(VERIFY_READ, uarg, size)) {
1580 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1584 if (cmd & IOC_OUT) {
1585 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1586 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1590 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1596 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1599 case DS_ADJUST_RESOURCE_INFO:
1600 ret = pcmcia_adjust_resource_info(&buf->adjust);
1602 case DS_GET_CARD_SERVICES_INFO:
1603 ret = pcmcia_get_card_services_info(&buf->servinfo);
1605 case DS_GET_CONFIGURATION_INFO:
1606 if (buf->config.Function &&
1607 (buf->config.Function >= s->parent->functions))
1610 ret = pccard_get_configuration_info(s->parent,
1611 buf->config.Function, &buf->config);
1613 case DS_GET_FIRST_TUPLE:
1614 down(&s->parent->skt_sem);
1615 pcmcia_validate_mem(s->parent);
1616 up(&s->parent->skt_sem);
1617 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1619 case DS_GET_NEXT_TUPLE:
1620 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1622 case DS_GET_TUPLE_DATA:
1623 buf->tuple.TupleData = buf->tuple_parse.data;
1624 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1625 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1627 case DS_PARSE_TUPLE:
1628 buf->tuple.TupleData = buf->tuple_parse.data;
1629 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1632 ret = pccard_reset_card(s->parent);
1635 if (buf->status.Function &&
1636 (buf->status.Function >= s->parent->functions))
1639 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1641 case DS_VALIDATE_CIS:
1642 down(&s->parent->skt_sem);
1643 pcmcia_validate_mem(s->parent);
1644 up(&s->parent->skt_sem);
1645 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1647 case DS_SUSPEND_CARD:
1648 ret = pcmcia_suspend_card(s->parent);
1650 case DS_RESUME_CARD:
1651 ret = pcmcia_resume_card(s->parent);
1654 err = pcmcia_eject_card(s->parent);
1656 case DS_INSERT_CARD:
1657 err = pcmcia_insert_card(s->parent);
1659 case DS_ACCESS_CONFIGURATION_REGISTER:
1660 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1664 if (buf->conf_reg.Function &&
1665 (buf->conf_reg.Function >= s->parent->functions))
1668 ret = pccard_access_configuration_register(s->parent,
1669 buf->conf_reg.Function, &buf->conf_reg);
1671 case DS_GET_FIRST_REGION:
1672 case DS_GET_NEXT_REGION:
1674 if (!capable(CAP_SYS_ADMIN)) {
1678 static int printed = 0;
1680 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1681 printk(KERN_WARNING "MTD handling any more.\n");
1688 case DS_GET_FIRST_WINDOW:
1689 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1690 &buf->win_info.window);
1692 case DS_GET_NEXT_WINDOW:
1693 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1694 buf->win_info.handle->index + 1, &buf->win_info.window);
1696 case DS_GET_MEM_PAGE:
1697 ret = pcmcia_get_mem_page(buf->win_info.handle,
1698 &buf->win_info.map);
1700 case DS_REPLACE_CIS:
1701 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1703 case DS_BIND_REQUEST:
1704 if (!capable(CAP_SYS_ADMIN)) {
1708 err = bind_request(s, &buf->bind_info);
1710 case DS_GET_DEVICE_INFO:
1711 err = get_device_info(s, &buf->bind_info, 1);
1713 case DS_GET_NEXT_DEVICE:
1714 err = get_device_info(s, &buf->bind_info, 0);
1716 case DS_UNBIND_REQUEST:
1723 if ((err == 0) && (ret != CS_SUCCESS)) {
1724 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1726 case CS_BAD_SOCKET: case CS_NO_CARD:
1727 err = -ENODEV; break;
1728 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1730 err = -EINVAL; break;
1732 err = -EBUSY; break;
1733 case CS_OUT_OF_RESOURCE:
1734 err = -ENOSPC; break;
1735 case CS_NO_MORE_ITEMS:
1736 err = -ENODATA; break;
1737 case CS_UNSUPPORTED_FUNCTION:
1738 err = -ENOSYS; break;
1744 if (cmd & IOC_OUT) {
1745 if (__copy_to_user(uarg, (char *)buf, size))
1754 /*====================================================================*/
1756 static struct file_operations ds_fops = {
1757 .owner = THIS_MODULE,
1759 .release = ds_release,
1766 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1768 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1769 struct pcmcia_bus_socket *s;
1772 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1775 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1777 /* get reference to parent socket */
1778 s->parent = pcmcia_get_socket(socket);
1780 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1785 kref_init(&s->refcount);
1788 * Ugly. But we want to wait for the socket threads to have started up.
1789 * We really should let the drivers themselves drive some of this..
1793 init_waitqueue_head(&s->queue);
1794 INIT_LIST_HEAD(&s->devices_list);
1795 INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1797 /* Set up hotline to Card Services */
1798 s->callback.owner = THIS_MODULE;
1799 s->callback.event = &ds_event;
1800 s->callback.resources_done = &pcmcia_card_add;
1801 s->callback.replace_cis = &pcmcia_bus_rescan;
1804 ret = pccard_register_pcmcia(socket, &s->callback);
1806 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1807 pcmcia_put_bus_socket(s);
1808 socket->pcmcia = NULL;
1816 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1818 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1820 if (!socket || !socket->pcmcia)
1823 pccard_register_pcmcia(socket, NULL);
1825 socket->pcmcia->state |= DS_SOCKET_DEAD;
1826 pcmcia_put_bus_socket(socket->pcmcia);
1827 socket->pcmcia = NULL;
1833 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1834 static struct class_interface pcmcia_bus_interface = {
1835 .class = &pcmcia_socket_class,
1836 .add = &pcmcia_bus_add_socket,
1837 .remove = &pcmcia_bus_remove_socket,
1841 struct bus_type pcmcia_bus_type = {
1843 .hotplug = pcmcia_bus_hotplug,
1844 .match = pcmcia_bus_match,
1845 .dev_attrs = pcmcia_dev_attrs,
1847 EXPORT_SYMBOL(pcmcia_bus_type);
1850 static int __init init_pcmcia_bus(void)
1854 spin_lock_init(&pcmcia_dev_list_lock);
1856 bus_register(&pcmcia_bus_type);
1857 class_interface_register(&pcmcia_bus_interface);
1859 /* Set up character device for user mode clients */
1860 i = register_chrdev(0, "pcmcia", &ds_fops);
1862 printk(KERN_NOTICE "unable to find a free device # for "
1863 "Driver Services (error=%d)\n", i);
1867 #ifdef CONFIG_PROC_FS
1868 proc_pccard = proc_mkdir("pccard", proc_bus);
1870 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1875 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1876 * pcmcia_socket_class is already registered */
1879 static void __exit exit_pcmcia_bus(void)
1881 class_interface_unregister(&pcmcia_bus_interface);
1883 #ifdef CONFIG_PROC_FS
1885 remove_proc_entry("drivers", proc_pccard);
1886 remove_proc_entry("pccard", proc_bus);
1889 if (major_dev != -1)
1890 unregister_chrdev(major_dev, "pcmcia");
1892 bus_unregister(&pcmcia_bus_type);
1894 module_exit(exit_pcmcia_bus);
1898 /* helpers for backwards-compatible functions */
1900 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1902 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1909 /* backwards-compatible accessing of driver --- by name! */
1911 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1913 struct device_driver *drv;
1914 struct pcmcia_driver *p_drv;
1916 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1920 p_drv = container_of(drv, struct pcmcia_driver, drv);