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]);
872 static struct device_attribute pcmcia_dev_attrs[] = {
873 __ATTR(function, 0444, func_show, NULL),
885 /*======================================================================
887 These manage a ring buffer of events pending for one user process
889 ======================================================================*/
891 static int queue_empty(user_info_t *user)
893 return (user->event_head == user->event_tail);
896 static event_t get_queued_event(user_info_t *user)
898 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
899 return user->event[user->event_tail];
902 static void queue_event(user_info_t *user, event_t event)
904 user->event_head = (user->event_head+1) % MAX_EVENTS;
905 if (user->event_head == user->event_tail)
906 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
907 user->event[user->event_head] = event;
910 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
913 for (user = s->user; user; user = user->next)
914 queue_event(user, event);
915 wake_up_interruptible(&s->queue);
919 /*======================================================================
921 The card status event handler.
923 ======================================================================*/
925 struct send_event_data {
926 struct pcmcia_socket *skt;
931 static int send_event_callback(struct device *dev, void * _data)
933 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
934 struct send_event_data *data = _data;
936 /* we get called for all sockets, but may only pass the event
937 * for drivers _on the affected socket_ */
938 if (p_dev->socket != data->skt)
941 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
944 if (p_dev->client.EventMask & data->event)
945 return EVENT(&p_dev->client, data->event, data->priority);
950 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
953 struct send_event_data private;
954 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
960 private.event = event;
961 private.priority = priority;
963 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
965 pcmcia_put_bus_socket(skt);
970 /* Normally, the event is passed to individual drivers after
971 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
972 * is inversed to maintain historic compatibility.
975 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
977 struct pcmcia_bus_socket *s = skt->pcmcia;
980 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
985 case CS_EVENT_CARD_REMOVAL:
986 s->state &= ~DS_SOCKET_PRESENT;
987 send_event(skt, event, priority);
989 handle_event(s, event);
992 case CS_EVENT_CARD_INSERTION:
993 s->state |= DS_SOCKET_PRESENT;
994 pcmcia_card_add(skt);
995 handle_event(s, event);
998 case CS_EVENT_EJECTION_REQUEST:
999 ret = send_event(skt, event, priority);
1003 handle_event(s, event);
1004 send_event(skt, event, priority);
1012 /*======================================================================
1014 bind_request() and bind_device() are merged by now. Register_client()
1015 is called right at the end of bind_request(), during the driver's
1016 ->attach() call. Individual descriptions:
1018 bind_request() connects a socket to a particular client driver.
1019 It looks up the specified device ID in the list of registered
1020 drivers, binds it to the socket, and tries to create an instance
1021 of the device. unbind_request() deletes a driver instance.
1023 Bind_device() associates a device driver with a particular socket.
1024 It is normally called by Driver Services after it has identified
1025 a newly inserted card. An instance of that driver will then be
1026 eligible to register as a client of this socket.
1028 Register_client() uses the dev_info_t handle to match the
1029 caller with a socket. The driver must have already been bound
1030 to a socket with bind_device() -- in fact, bind_device()
1031 allocates the client structure that will be used.
1033 ======================================================================*/
1035 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1037 struct pcmcia_driver *p_drv;
1038 struct pcmcia_device *p_dev;
1040 unsigned long flags;
1042 s = pcmcia_get_bus_socket(s);
1046 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1047 (char *)bind_info->dev_info);
1049 p_drv = get_pcmcia_driver(&bind_info->dev_info);
1055 if (!try_module_get(p_drv->owner)) {
1057 goto err_put_driver;
1060 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1061 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1062 if (p_dev->func == bind_info->function) {
1063 if ((p_dev->dev.driver == &p_drv->drv)) {
1064 if (p_dev->cardmgr) {
1065 /* if there's already a device
1066 * registered, and it was registered
1067 * by userspace before, we need to
1068 * return the "instance". */
1069 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1070 bind_info->instance = p_dev->instance;
1072 goto err_put_module;
1074 /* the correct driver managed to bind
1075 * itself magically to the correct
1077 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1078 p_dev->cardmgr = p_drv;
1080 goto err_put_module;
1082 } else if (!p_dev->dev.driver) {
1083 /* there's already a device available where
1084 * no device has been bound to yet. So we don't
1085 * need to register a device! */
1086 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1091 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1093 p_dev = pcmcia_device_add(s, bind_info->function);
1096 goto err_put_module;
1100 p_dev->cardmgr = p_drv;
1102 /* if a driver is already running, we can abort */
1103 if (p_dev->dev.driver)
1104 goto err_put_module;
1107 * Prevent this racing with a card insertion.
1109 down(&s->parent->skt_sem);
1110 bus_rescan_devices(&pcmcia_bus_type);
1111 up(&s->parent->skt_sem);
1113 /* check whether the driver indeed matched. I don't care if this
1114 * is racy or not, because it can only happen on cardmgr access
1117 if (!(p_dev->dev.driver == &p_drv->drv))
1118 p_dev->cardmgr = NULL;
1121 module_put(p_drv->owner);
1123 put_driver(&p_drv->drv);
1125 pcmcia_put_bus_socket(s);
1128 } /* bind_request */
1131 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1133 client_t *client = NULL;
1134 struct pcmcia_socket *s;
1135 struct pcmcia_bus_socket *skt = NULL;
1136 struct pcmcia_device *p_dev = NULL;
1138 /* Look for unbound client with matching dev_info */
1139 down_read(&pcmcia_socket_list_rwsem);
1140 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1141 unsigned long flags;
1143 if (s->state & SOCKET_CARDBUS)
1149 skt = pcmcia_get_bus_socket(skt);
1152 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1153 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1154 struct pcmcia_driver *p_drv;
1155 p_dev = pcmcia_get_dev(p_dev);
1158 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1159 (!p_dev->dev.driver)) {
1160 pcmcia_put_dev(p_dev);
1163 p_drv = to_pcmcia_drv(p_dev->dev.driver);
1164 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1165 client = &p_dev->client;
1166 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1169 pcmcia_put_dev(p_dev);
1171 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1172 pcmcia_put_bus_socket(skt);
1175 up_read(&pcmcia_socket_list_rwsem);
1176 if (!p_dev || !client)
1179 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1182 client->state &= ~CLIENT_UNBOUND;
1184 client->EventMask = req->EventMask;
1185 client->event_handler = req->event_handler;
1186 client->event_callback_args = req->event_callback_args;
1187 client->event_callback_args.client_handle = client;
1189 if (s->state & SOCKET_CARDBUS)
1190 client->state |= CLIENT_CARDBUS;
1192 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1193 (client->Function != BIND_FN_ALL)) {
1194 cistpl_longlink_mfc_t mfc;
1195 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1197 s->functions = mfc.nfn;
1200 s->config = kmalloc(sizeof(config_t) * s->functions,
1203 goto out_no_resource;
1204 memset(s->config, 0, sizeof(config_t) * s->functions);
1207 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1208 client, p_dev->dev.bus_id);
1209 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1210 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1212 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1213 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1214 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1220 pcmcia_put_dev(p_dev);
1221 return CS_OUT_OF_RESOURCE;
1222 } /* register_client */
1223 EXPORT_SYMBOL(pcmcia_register_client);
1226 /*====================================================================*/
1228 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1230 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1233 struct pcmcia_device *p_dev;
1234 unsigned long flags;
1237 #ifdef CONFIG_CARDBUS
1239 * Some unbelievably ugly code to associate the PCI cardbus
1240 * device and its driver with the PCMCIA "bind" information.
1243 struct pci_bus *bus;
1245 bus = pcmcia_lookup_bus(s->parent);
1247 struct list_head *list;
1248 struct pci_dev *dev = NULL;
1250 list = bus->devices.next;
1251 while (list != &bus->devices) {
1252 struct pci_dev *pdev = pci_dev_b(list);
1260 /* Try to handle "next" here some way? */
1262 if (dev && dev->driver) {
1263 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1264 bind_info->major = 0;
1265 bind_info->minor = 0;
1266 bind_info->next = NULL;
1273 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1274 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1275 if (p_dev->func == bind_info->function) {
1276 p_dev = pcmcia_get_dev(p_dev);
1282 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1286 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1288 if ((!p_dev->instance) ||
1289 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1295 node = p_dev->instance->dev;
1297 for (node = p_dev->instance->dev; node; node = node->next)
1298 if (node == bind_info->next)
1305 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1306 bind_info->major = node->major;
1307 bind_info->minor = node->minor;
1308 bind_info->next = node->next;
1311 pcmcia_put_dev(p_dev);
1313 } /* get_device_info */
1315 /*====================================================================*/
1317 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1318 * drivers have been called with EVENT_CARD_REMOVAL before.
1320 static int unbind_request(struct pcmcia_bus_socket *s)
1322 struct pcmcia_device *p_dev;
1323 unsigned long flags;
1325 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1327 s->device_count = 0;
1330 /* unregister all pcmcia_devices registered with this socket*/
1331 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1332 if (list_empty(&s->devices_list)) {
1333 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1336 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1337 list_del(&p_dev->socket_device_list);
1338 p_dev->client.state |= CLIENT_STALE;
1339 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1341 device_unregister(&p_dev->dev);
1345 } /* unbind_request */
1347 int pcmcia_deregister_client(client_handle_t handle)
1349 struct pcmcia_socket *s;
1351 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1353 if (CHECK_HANDLE(handle))
1354 return CS_BAD_HANDLE;
1357 ds_dbg(1, "deregister_client(%p)\n", handle);
1359 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1361 for (i = 0; i < MAX_WIN; i++)
1362 if (handle->state & CLIENT_WIN_REQ(i))
1365 if (handle->state & CLIENT_STALE) {
1366 handle->client_magic = 0;
1367 handle->state &= ~CLIENT_STALE;
1368 pcmcia_put_dev(p_dev);
1370 handle->state = CLIENT_UNBOUND;
1371 handle->event_handler = NULL;
1376 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1378 } /* deregister_client */
1379 EXPORT_SYMBOL(pcmcia_deregister_client);
1382 /*======================================================================
1384 The user-mode PC Card device interface
1386 ======================================================================*/
1388 static int ds_open(struct inode *inode, struct file *file)
1390 socket_t i = iminor(inode);
1391 struct pcmcia_bus_socket *s;
1394 ds_dbg(0, "ds_open(socket %d)\n", i);
1396 s = get_socket_info_by_nr(i);
1399 s = pcmcia_get_bus_socket(s);
1403 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1404 if (s->state & DS_SOCKET_BUSY) {
1405 pcmcia_put_bus_socket(s);
1409 s->state |= DS_SOCKET_BUSY;
1412 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1414 pcmcia_put_bus_socket(s);
1417 user->event_tail = user->event_head = 0;
1418 user->next = s->user;
1419 user->user_magic = USER_MAGIC;
1422 file->private_data = user;
1424 if (s->state & DS_SOCKET_PRESENT)
1425 queue_event(user, CS_EVENT_CARD_INSERTION);
1429 /*====================================================================*/
1431 static int ds_release(struct inode *inode, struct file *file)
1433 struct pcmcia_bus_socket *s;
1434 user_info_t *user, **link;
1436 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1438 user = file->private_data;
1439 if (CHECK_USER(user))
1444 /* Unlink user data structure */
1445 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1446 s->state &= ~DS_SOCKET_BUSY;
1448 file->private_data = NULL;
1449 for (link = &s->user; *link; link = &(*link)->next)
1450 if (*link == user) break;
1454 user->user_magic = 0;
1456 pcmcia_put_bus_socket(s);
1461 /*====================================================================*/
1463 static ssize_t ds_read(struct file *file, char __user *buf,
1464 size_t count, loff_t *ppos)
1466 struct pcmcia_bus_socket *s;
1470 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1475 user = file->private_data;
1476 if (CHECK_USER(user))
1480 if (s->state & DS_SOCKET_DEAD)
1483 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1485 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1490 /*====================================================================*/
1492 static ssize_t ds_write(struct file *file, const char __user *buf,
1493 size_t count, loff_t *ppos)
1495 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1499 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1505 /*====================================================================*/
1507 /* No kernel lock - fine */
1508 static u_int ds_poll(struct file *file, poll_table *wait)
1510 struct pcmcia_bus_socket *s;
1513 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1515 user = file->private_data;
1516 if (CHECK_USER(user))
1520 * We don't check for a dead socket here since that
1521 * will send cardmgr into an endless spin.
1523 poll_wait(file, &s->queue, wait);
1524 if (!queue_empty(user))
1525 return POLLIN | POLLRDNORM;
1529 /*====================================================================*/
1531 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1533 static int ds_ioctl(struct inode * inode, struct file * file,
1534 u_int cmd, u_long arg)
1536 struct pcmcia_bus_socket *s;
1537 void __user *uarg = (char __user *)arg;
1540 ds_ioctl_arg_t *buf;
1543 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1545 user = file->private_data;
1546 if (CHECK_USER(user))
1550 if (s->state & DS_SOCKET_DEAD)
1553 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1554 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1556 /* Permission check */
1557 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1561 if (!access_ok(VERIFY_READ, uarg, size)) {
1562 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1566 if (cmd & IOC_OUT) {
1567 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1568 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1572 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1578 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1581 case DS_ADJUST_RESOURCE_INFO:
1582 ret = pcmcia_adjust_resource_info(&buf->adjust);
1584 case DS_GET_CARD_SERVICES_INFO:
1585 ret = pcmcia_get_card_services_info(&buf->servinfo);
1587 case DS_GET_CONFIGURATION_INFO:
1588 if (buf->config.Function &&
1589 (buf->config.Function >= s->parent->functions))
1592 ret = pccard_get_configuration_info(s->parent,
1593 buf->config.Function, &buf->config);
1595 case DS_GET_FIRST_TUPLE:
1596 down(&s->parent->skt_sem);
1597 pcmcia_validate_mem(s->parent);
1598 up(&s->parent->skt_sem);
1599 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1601 case DS_GET_NEXT_TUPLE:
1602 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1604 case DS_GET_TUPLE_DATA:
1605 buf->tuple.TupleData = buf->tuple_parse.data;
1606 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1607 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1609 case DS_PARSE_TUPLE:
1610 buf->tuple.TupleData = buf->tuple_parse.data;
1611 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1614 ret = pccard_reset_card(s->parent);
1617 if (buf->status.Function &&
1618 (buf->status.Function >= s->parent->functions))
1621 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1623 case DS_VALIDATE_CIS:
1624 down(&s->parent->skt_sem);
1625 pcmcia_validate_mem(s->parent);
1626 up(&s->parent->skt_sem);
1627 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1629 case DS_SUSPEND_CARD:
1630 ret = pcmcia_suspend_card(s->parent);
1632 case DS_RESUME_CARD:
1633 ret = pcmcia_resume_card(s->parent);
1636 err = pcmcia_eject_card(s->parent);
1638 case DS_INSERT_CARD:
1639 err = pcmcia_insert_card(s->parent);
1641 case DS_ACCESS_CONFIGURATION_REGISTER:
1642 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1646 if (buf->conf_reg.Function &&
1647 (buf->conf_reg.Function >= s->parent->functions))
1650 ret = pccard_access_configuration_register(s->parent,
1651 buf->conf_reg.Function, &buf->conf_reg);
1653 case DS_GET_FIRST_REGION:
1654 case DS_GET_NEXT_REGION:
1656 if (!capable(CAP_SYS_ADMIN)) {
1660 static int printed = 0;
1662 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1663 printk(KERN_WARNING "MTD handling any more.\n");
1670 case DS_GET_FIRST_WINDOW:
1671 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1672 &buf->win_info.window);
1674 case DS_GET_NEXT_WINDOW:
1675 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1676 buf->win_info.handle->index + 1, &buf->win_info.window);
1678 case DS_GET_MEM_PAGE:
1679 ret = pcmcia_get_mem_page(buf->win_info.handle,
1680 &buf->win_info.map);
1682 case DS_REPLACE_CIS:
1683 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1685 case DS_BIND_REQUEST:
1686 if (!capable(CAP_SYS_ADMIN)) {
1690 err = bind_request(s, &buf->bind_info);
1692 case DS_GET_DEVICE_INFO:
1693 err = get_device_info(s, &buf->bind_info, 1);
1695 case DS_GET_NEXT_DEVICE:
1696 err = get_device_info(s, &buf->bind_info, 0);
1698 case DS_UNBIND_REQUEST:
1705 if ((err == 0) && (ret != CS_SUCCESS)) {
1706 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1708 case CS_BAD_SOCKET: case CS_NO_CARD:
1709 err = -ENODEV; break;
1710 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1712 err = -EINVAL; break;
1714 err = -EBUSY; break;
1715 case CS_OUT_OF_RESOURCE:
1716 err = -ENOSPC; break;
1717 case CS_NO_MORE_ITEMS:
1718 err = -ENODATA; break;
1719 case CS_UNSUPPORTED_FUNCTION:
1720 err = -ENOSYS; break;
1726 if (cmd & IOC_OUT) {
1727 if (__copy_to_user(uarg, (char *)buf, size))
1736 /*====================================================================*/
1738 static struct file_operations ds_fops = {
1739 .owner = THIS_MODULE,
1741 .release = ds_release,
1748 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1750 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1751 struct pcmcia_bus_socket *s;
1754 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1757 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1759 /* get reference to parent socket */
1760 s->parent = pcmcia_get_socket(socket);
1762 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1767 kref_init(&s->refcount);
1770 * Ugly. But we want to wait for the socket threads to have started up.
1771 * We really should let the drivers themselves drive some of this..
1775 init_waitqueue_head(&s->queue);
1776 INIT_LIST_HEAD(&s->devices_list);
1777 INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1779 /* Set up hotline to Card Services */
1780 s->callback.owner = THIS_MODULE;
1781 s->callback.event = &ds_event;
1782 s->callback.resources_done = &pcmcia_card_add;
1783 s->callback.replace_cis = &pcmcia_bus_rescan;
1786 ret = pccard_register_pcmcia(socket, &s->callback);
1788 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1789 pcmcia_put_bus_socket(s);
1790 socket->pcmcia = NULL;
1798 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1800 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1802 if (!socket || !socket->pcmcia)
1805 pccard_register_pcmcia(socket, NULL);
1807 socket->pcmcia->state |= DS_SOCKET_DEAD;
1808 pcmcia_put_bus_socket(socket->pcmcia);
1809 socket->pcmcia = NULL;
1815 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1816 static struct class_interface pcmcia_bus_interface = {
1817 .class = &pcmcia_socket_class,
1818 .add = &pcmcia_bus_add_socket,
1819 .remove = &pcmcia_bus_remove_socket,
1823 struct bus_type pcmcia_bus_type = {
1825 .hotplug = pcmcia_bus_hotplug,
1826 .match = pcmcia_bus_match,
1827 .dev_attrs = pcmcia_dev_attrs,
1829 EXPORT_SYMBOL(pcmcia_bus_type);
1832 static int __init init_pcmcia_bus(void)
1836 spin_lock_init(&pcmcia_dev_list_lock);
1838 bus_register(&pcmcia_bus_type);
1839 class_interface_register(&pcmcia_bus_interface);
1841 /* Set up character device for user mode clients */
1842 i = register_chrdev(0, "pcmcia", &ds_fops);
1844 printk(KERN_NOTICE "unable to find a free device # for "
1845 "Driver Services (error=%d)\n", i);
1849 #ifdef CONFIG_PROC_FS
1850 proc_pccard = proc_mkdir("pccard", proc_bus);
1852 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1857 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1858 * pcmcia_socket_class is already registered */
1861 static void __exit exit_pcmcia_bus(void)
1863 class_interface_unregister(&pcmcia_bus_interface);
1865 #ifdef CONFIG_PROC_FS
1867 remove_proc_entry("drivers", proc_pccard);
1868 remove_proc_entry("pccard", proc_bus);
1871 if (major_dev != -1)
1872 unregister_chrdev(major_dev, "pcmcia");
1874 bus_unregister(&pcmcia_bus_type);
1876 module_exit(exit_pcmcia_bus);
1880 /* helpers for backwards-compatible functions */
1882 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1884 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1891 /* backwards-compatible accessing of driver --- by name! */
1893 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1895 struct device_driver *drv;
1896 struct pcmcia_driver *p_drv;
1898 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1902 p_drv = container_of(drv, struct pcmcia_driver, drv);