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 /*======================================================================*/
265 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info);
266 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr);
268 static void pcmcia_release_bus_socket(struct kref *refcount)
270 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
271 pcmcia_put_socket(s->parent);
275 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
277 kref_put(&s->refcount, pcmcia_release_bus_socket);
280 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
282 kref_get(&s->refcount);
287 * pcmcia_register_driver - register a PCMCIA driver with the bus core
289 * Registers a PCMCIA driver with the PCMCIA bus core.
291 static int pcmcia_device_probe(struct device *dev);
292 static int pcmcia_device_remove(struct device * dev);
294 int pcmcia_register_driver(struct pcmcia_driver *driver)
299 /* initialize common fields */
300 driver->drv.bus = &pcmcia_bus_type;
301 driver->drv.owner = driver->owner;
302 driver->drv.probe = pcmcia_device_probe;
303 driver->drv.remove = pcmcia_device_remove;
305 return driver_register(&driver->drv);
307 EXPORT_SYMBOL(pcmcia_register_driver);
310 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
312 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
314 driver_unregister(&driver->drv);
316 EXPORT_SYMBOL(pcmcia_unregister_driver);
318 #ifdef CONFIG_PROC_FS
319 static struct proc_dir_entry *proc_pccard = NULL;
321 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
324 struct pcmcia_driver *p_drv = container_of(driver,
325 struct pcmcia_driver, drv);
327 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
328 #ifdef CONFIG_MODULE_UNLOAD
329 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
339 static int proc_read_drivers(char *buf, char **start, off_t pos,
340 int count, int *eof, void *data)
344 bus_for_each_drv(&pcmcia_bus_type, NULL,
345 (void *) &p, proc_read_drivers_callback);
351 /* pcmcia_device handling */
353 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
355 struct device *tmp_dev;
356 tmp_dev = get_device(&p_dev->dev);
359 return to_pcmcia_dev(tmp_dev);
362 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
365 put_device(&p_dev->dev);
368 static void pcmcia_release_dev(struct device *dev)
370 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
371 ds_dbg(1, "releasing dev %p\n", p_dev);
372 pcmcia_put_bus_socket(p_dev->socket->pcmcia);
377 static int pcmcia_device_probe(struct device * dev)
379 struct pcmcia_device *p_dev;
380 struct pcmcia_driver *p_drv;
383 dev = get_device(dev);
387 p_dev = to_pcmcia_dev(dev);
388 p_drv = to_pcmcia_drv(dev->driver);
390 if (!try_module_get(p_drv->owner)) {
396 p_dev->instance = p_drv->attach();
397 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) {
398 printk(KERN_NOTICE "ds: unable to create instance "
399 "of '%s'!\n", p_drv->drv.name);
405 module_put(p_drv->owner);
407 if ((ret) || !(p_drv->attach))
413 static int pcmcia_device_remove(struct device * dev)
415 struct pcmcia_device *p_dev;
416 struct pcmcia_driver *p_drv;
418 /* detach the "instance" */
419 p_dev = to_pcmcia_dev(dev);
420 p_drv = to_pcmcia_drv(dev->driver);
423 if ((p_drv->detach) && (p_dev->instance)) {
424 p_drv->detach(p_dev->instance);
425 /* from pcmcia_probe_device */
426 put_device(&p_dev->dev);
428 module_put(p_drv->owner);
437 * pcmcia_device_query -- determine information about a pcmcia device
439 static int pcmcia_device_query(struct pcmcia_device *p_dev)
441 cistpl_manfid_t manf_id;
442 cistpl_funcid_t func_id;
443 cistpl_vers_1_t vers1;
446 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
447 CISTPL_MANFID, &manf_id)) {
448 p_dev->manf_id = manf_id.manf;
449 p_dev->card_id = manf_id.card;
450 p_dev->has_manf_id = 1;
451 p_dev->has_card_id = 1;
454 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
455 CISTPL_FUNCID, &func_id)) {
456 p_dev->func_id = func_id.func;
457 p_dev->has_func_id = 1;
459 /* rule of thumb: cards with no FUNCID, but with
460 * common memory device geometry information, are
461 * probably memory cards (from pcmcia-cs) */
462 cistpl_device_geo_t devgeo;
463 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
464 CISTPL_DEVICE_GEO, &devgeo)) {
465 ds_dbg(0, "mem device geometry probably means "
467 p_dev->func_id = CISTPL_FUNCID_MEMORY;
468 p_dev->has_func_id = 1;
472 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
474 for (i=0; i < vers1.ns; i++) {
478 tmp = vers1.str + vers1.ofs[i];
480 length = strlen(tmp) + 1;
481 if ((length < 3) || (length > 255))
484 p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
486 if (!p_dev->prod_id[i])
489 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
498 /* device_add_lock is needed to avoid double registration by cardmgr and kernel.
499 * Serializes pcmcia_device_add; will most likely be removed in future.
501 * While it has the caveat that adding new PCMCIA devices inside(!) device_register()
502 * won't work, this doesn't matter much at the moment: the driver core doesn't
505 static DECLARE_MUTEX(device_add_lock);
507 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function)
509 struct pcmcia_device *p_dev;
512 s = pcmcia_get_bus_socket(s);
516 down(&device_add_lock);
518 /* max of 2 devices per card */
519 if (s->device_count == 2)
522 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
525 memset(p_dev, 0, sizeof(struct pcmcia_device));
527 p_dev->socket = s->parent;
528 p_dev->device_no = (s->device_count++);
529 p_dev->func = function;
531 p_dev->dev.bus = &pcmcia_bus_type;
532 p_dev->dev.parent = s->parent->dev.dev;
533 p_dev->dev.release = pcmcia_release_dev;
534 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
537 p_dev->client.client_magic = CLIENT_MAGIC;
538 p_dev->client.Socket = s->parent;
539 p_dev->client.Function = function;
540 p_dev->client.state = CLIENT_UNBOUND;
542 /* Add to the list in pcmcia_bus_socket */
543 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
544 list_add_tail(&p_dev->socket_device_list, &s->devices_list);
545 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
547 pcmcia_device_query(p_dev);
549 if (device_register(&p_dev->dev)) {
550 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
551 list_del(&p_dev->socket_device_list);
552 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
557 up(&device_add_lock);
565 up(&device_add_lock);
566 pcmcia_put_bus_socket(s);
572 static int pcmcia_card_add(struct pcmcia_socket *s)
575 cistpl_longlink_mfc_t mfc;
576 unsigned int no_funcs, i;
579 if (!(s->resource_setup_done))
580 return -EAGAIN; /* try again, but later... */
582 pcmcia_validate_mem(s);
583 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo);
584 if (ret || !cisinfo.Chains) {
585 ds_dbg(0, "invalid CIS or invalid resources\n");
589 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
594 /* this doesn't handle multifunction devices on one pcmcia function
596 for (i=0; i < no_funcs; i++)
597 pcmcia_device_add(s->pcmcia, i);
603 static void pcmcia_delayed_add_pseudo_device(void *data)
605 struct pcmcia_bus_socket *s = data;
606 pcmcia_device_add(s, 0);
607 s->device_add_pending = 0;
610 static inline void pcmcia_add_pseudo_device(struct pcmcia_bus_socket *s)
612 if (!s->device_add_pending) {
613 schedule_work(&s->device_add);
614 s->device_add_pending = 1;
620 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
621 struct pcmcia_device_id *did)
623 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
624 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
628 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
629 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
633 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
634 if (dev->func != did->function)
638 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
639 if (!dev->prod_id[0])
641 if (strcmp(did->prod_id[0], dev->prod_id[0]))
645 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
646 if (!dev->prod_id[1])
648 if (strcmp(did->prod_id[1], dev->prod_id[1]))
652 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
653 if (!dev->prod_id[2])
655 if (strcmp(did->prod_id[2], dev->prod_id[2]))
659 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
660 if (!dev->prod_id[3])
662 if (strcmp(did->prod_id[3], dev->prod_id[3]))
666 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
667 /* handle pseudo multifunction devices:
668 * there are at most two pseudo multifunction devices.
669 * if we're matching against the first, schedule a
670 * call which will then check whether there are two
671 * pseudo devices, and if not, add the second one.
673 if (dev->device_no == 0)
674 pcmcia_add_pseudo_device(dev->socket->pcmcia);
676 if (dev->device_no != did->device_no)
680 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
681 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
684 /* if this is a pseudo-multi-function device,
685 * we need explicit matches */
686 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO)
691 /* also, FUNC_ID matching needs to be activated by userspace
692 * after it has re-checked that there is no possible module
693 * with a prod_id/manf_id/card_id match.
695 if (!dev->allow_func_id_match)
699 dev->dev.driver_data = (void *) did;
705 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
706 struct pcmcia_device * p_dev = to_pcmcia_dev(dev);
707 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
708 struct pcmcia_device_id *did = p_drv->id_table;
710 /* matching by cardmgr */
711 if (p_dev->cardmgr == p_drv)
714 while (did && did->match_flags) {
715 if (pcmcia_devmatch(p_dev, did))
723 #ifdef CONFIG_HOTPLUG
725 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
726 char *buffer, int buffer_size)
728 struct pcmcia_device *p_dev;
730 u32 hash[4] = { 0, 0, 0, 0};
735 p_dev = to_pcmcia_dev(dev);
737 /* calculate hashes */
738 for (i=0; i<4; i++) {
739 if (!p_dev->prod_id[i])
741 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
746 if (add_hotplug_env_var(envp, num_envp, &i,
747 buffer, buffer_size, &length,
749 p_dev->socket->sock))
752 if (add_hotplug_env_var(envp, num_envp, &i,
753 buffer, buffer_size, &length,
758 if (add_hotplug_env_var(envp, num_envp, &i,
759 buffer, buffer_size, &length,
760 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
761 "pa%08Xpb%08Xpc%08Xpd%08X",
762 p_dev->has_manf_id ? p_dev->manf_id : 0,
763 p_dev->has_card_id ? p_dev->card_id : 0,
764 p_dev->has_func_id ? p_dev->func_id : 0,
780 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
781 char *buffer, int buffer_size)
788 /************************ per-device sysfs output ***************************/
790 #define pcmcia_device_attr(field, test, format) \
791 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
793 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
794 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
797 #define pcmcia_device_stringattr(name, field) \
798 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
800 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
801 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
804 pcmcia_device_attr(func, socket, "0x%02x\n");
805 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
806 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
807 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
808 pcmcia_device_stringattr(prod_id1, prod_id[0]);
809 pcmcia_device_stringattr(prod_id2, prod_id[1]);
810 pcmcia_device_stringattr(prod_id3, prod_id[2]);
811 pcmcia_device_stringattr(prod_id4, prod_id[3]);
813 static struct device_attribute pcmcia_dev_attrs[] = {
814 __ATTR(function, 0444, func_show, NULL),
826 /*======================================================================
828 These manage a ring buffer of events pending for one user process
830 ======================================================================*/
832 static int queue_empty(user_info_t *user)
834 return (user->event_head == user->event_tail);
837 static event_t get_queued_event(user_info_t *user)
839 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
840 return user->event[user->event_tail];
843 static void queue_event(user_info_t *user, event_t event)
845 user->event_head = (user->event_head+1) % MAX_EVENTS;
846 if (user->event_head == user->event_tail)
847 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
848 user->event[user->event_head] = event;
851 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
854 for (user = s->user; user; user = user->next)
855 queue_event(user, event);
856 wake_up_interruptible(&s->queue);
860 /*======================================================================
862 The card status event handler.
864 ======================================================================*/
866 struct send_event_data {
867 struct pcmcia_socket *skt;
872 static int send_event_callback(struct device *dev, void * _data)
874 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
875 struct send_event_data *data = _data;
877 /* we get called for all sockets, but may only pass the event
878 * for drivers _on the affected socket_ */
879 if (p_dev->socket != data->skt)
882 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
885 if (p_dev->client.EventMask & data->event)
886 return EVENT(&p_dev->client, data->event, data->priority);
891 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
894 struct send_event_data private;
895 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
901 private.event = event;
902 private.priority = priority;
904 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
906 pcmcia_put_bus_socket(skt);
911 /* Normally, the event is passed to individual drivers after
912 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
913 * is inversed to maintain historic compatibility.
916 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
918 struct pcmcia_bus_socket *s = skt->pcmcia;
921 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
926 case CS_EVENT_CARD_REMOVAL:
927 s->state &= ~DS_SOCKET_PRESENT;
928 send_event(skt, event, priority);
930 handle_event(s, event);
933 case CS_EVENT_CARD_INSERTION:
934 s->state |= DS_SOCKET_PRESENT;
935 pcmcia_card_add(skt);
936 handle_event(s, event);
939 case CS_EVENT_EJECTION_REQUEST:
940 ret = send_event(skt, event, priority);
944 handle_event(s, event);
945 send_event(skt, event, priority);
953 /*======================================================================
955 bind_request() and bind_device() are merged by now. Register_client()
956 is called right at the end of bind_request(), during the driver's
957 ->attach() call. Individual descriptions:
959 bind_request() connects a socket to a particular client driver.
960 It looks up the specified device ID in the list of registered
961 drivers, binds it to the socket, and tries to create an instance
962 of the device. unbind_request() deletes a driver instance.
964 Bind_device() associates a device driver with a particular socket.
965 It is normally called by Driver Services after it has identified
966 a newly inserted card. An instance of that driver will then be
967 eligible to register as a client of this socket.
969 Register_client() uses the dev_info_t handle to match the
970 caller with a socket. The driver must have already been bound
971 to a socket with bind_device() -- in fact, bind_device()
972 allocates the client structure that will be used.
974 ======================================================================*/
976 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
978 struct pcmcia_driver *p_drv;
979 struct pcmcia_device *p_dev;
983 s = pcmcia_get_bus_socket(s);
987 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
988 (char *)bind_info->dev_info);
990 p_drv = get_pcmcia_driver(&bind_info->dev_info);
996 if (!try_module_get(p_drv->owner)) {
1001 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1002 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1003 if (p_dev->func == bind_info->function) {
1004 if ((p_dev->dev.driver == &p_drv->drv)) {
1005 if (p_dev->cardmgr) {
1006 /* if there's already a device
1007 * registered, and it was registered
1008 * by userspace before, we need to
1009 * return the "instance". */
1010 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1011 bind_info->instance = p_dev->instance;
1013 goto err_put_module;
1015 /* the correct driver managed to bind
1016 * itself magically to the correct
1018 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1019 p_dev->cardmgr = p_drv;
1021 goto err_put_module;
1023 } else if (!p_dev->dev.driver) {
1024 /* there's already a device available where
1025 * no device has been bound to yet. So we don't
1026 * need to register a device! */
1027 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1032 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1034 p_dev = pcmcia_device_add(s, bind_info->function);
1037 goto err_put_module;
1041 p_dev->cardmgr = p_drv;
1043 /* if a driver is already running, we can abort */
1044 if (p_dev->dev.driver)
1045 goto err_put_module;
1048 * Prevent this racing with a card insertion.
1050 down(&s->parent->skt_sem);
1051 bus_rescan_devices(&pcmcia_bus_type);
1052 up(&s->parent->skt_sem);
1054 /* check whether the driver indeed matched. I don't care if this
1055 * is racy or not, because it can only happen on cardmgr access
1058 if (!(p_dev->dev.driver == &p_drv->drv))
1059 p_dev->cardmgr = NULL;
1062 module_put(p_drv->owner);
1064 put_driver(&p_drv->drv);
1066 pcmcia_put_bus_socket(s);
1069 } /* bind_request */
1072 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1074 client_t *client = NULL;
1075 struct pcmcia_socket *s;
1076 struct pcmcia_bus_socket *skt = NULL;
1077 struct pcmcia_device *p_dev = NULL;
1079 /* Look for unbound client with matching dev_info */
1080 down_read(&pcmcia_socket_list_rwsem);
1081 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1082 unsigned long flags;
1084 if (s->state & SOCKET_CARDBUS)
1090 skt = pcmcia_get_bus_socket(skt);
1093 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1094 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1095 struct pcmcia_driver *p_drv;
1096 p_dev = pcmcia_get_dev(p_dev);
1099 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1100 (!p_dev->dev.driver)) {
1101 pcmcia_put_dev(p_dev);
1104 p_drv = to_pcmcia_drv(p_dev->dev.driver);
1105 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1106 client = &p_dev->client;
1107 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1110 pcmcia_put_dev(p_dev);
1112 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1113 pcmcia_put_bus_socket(skt);
1116 up_read(&pcmcia_socket_list_rwsem);
1117 if (!p_dev || !client)
1120 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1123 client->state &= ~CLIENT_UNBOUND;
1125 client->EventMask = req->EventMask;
1126 client->event_handler = req->event_handler;
1127 client->event_callback_args = req->event_callback_args;
1128 client->event_callback_args.client_handle = client;
1130 if (s->state & SOCKET_CARDBUS)
1131 client->state |= CLIENT_CARDBUS;
1133 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1134 (client->Function != BIND_FN_ALL)) {
1135 cistpl_longlink_mfc_t mfc;
1136 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1138 s->functions = mfc.nfn;
1141 s->config = kmalloc(sizeof(config_t) * s->functions,
1144 goto out_no_resource;
1145 memset(s->config, 0, sizeof(config_t) * s->functions);
1148 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1149 client, p_dev->dev.bus_id);
1150 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1151 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1153 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1154 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1155 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1161 pcmcia_put_dev(p_dev);
1162 return CS_OUT_OF_RESOURCE;
1163 } /* register_client */
1164 EXPORT_SYMBOL(pcmcia_register_client);
1167 /*====================================================================*/
1169 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1171 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1174 struct pcmcia_device *p_dev;
1175 unsigned long flags;
1178 #ifdef CONFIG_CARDBUS
1180 * Some unbelievably ugly code to associate the PCI cardbus
1181 * device and its driver with the PCMCIA "bind" information.
1184 struct pci_bus *bus;
1186 bus = pcmcia_lookup_bus(s->parent);
1188 struct list_head *list;
1189 struct pci_dev *dev = NULL;
1191 list = bus->devices.next;
1192 while (list != &bus->devices) {
1193 struct pci_dev *pdev = pci_dev_b(list);
1201 /* Try to handle "next" here some way? */
1203 if (dev && dev->driver) {
1204 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1205 bind_info->major = 0;
1206 bind_info->minor = 0;
1207 bind_info->next = NULL;
1214 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1215 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1216 if (p_dev->func == bind_info->function) {
1217 p_dev = pcmcia_get_dev(p_dev);
1223 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1227 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1229 if ((!p_dev->instance) ||
1230 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1236 node = p_dev->instance->dev;
1238 for (node = p_dev->instance->dev; node; node = node->next)
1239 if (node == bind_info->next)
1246 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1247 bind_info->major = node->major;
1248 bind_info->minor = node->minor;
1249 bind_info->next = node->next;
1252 pcmcia_put_dev(p_dev);
1254 } /* get_device_info */
1256 /*====================================================================*/
1258 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1259 * drivers have been called with EVENT_CARD_REMOVAL before.
1261 static int unbind_request(struct pcmcia_bus_socket *s)
1263 struct pcmcia_device *p_dev;
1264 unsigned long flags;
1266 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1268 s->device_count = 0;
1271 /* unregister all pcmcia_devices registered with this socket*/
1272 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1273 if (list_empty(&s->devices_list)) {
1274 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1277 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1278 list_del(&p_dev->socket_device_list);
1279 p_dev->client.state |= CLIENT_STALE;
1280 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1282 device_unregister(&p_dev->dev);
1286 } /* unbind_request */
1288 int pcmcia_deregister_client(client_handle_t handle)
1290 struct pcmcia_socket *s;
1292 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1294 if (CHECK_HANDLE(handle))
1295 return CS_BAD_HANDLE;
1298 ds_dbg(1, "deregister_client(%p)\n", handle);
1300 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1302 for (i = 0; i < MAX_WIN; i++)
1303 if (handle->state & CLIENT_WIN_REQ(i))
1306 if (handle->state & CLIENT_STALE) {
1307 handle->client_magic = 0;
1308 handle->state &= ~CLIENT_STALE;
1309 pcmcia_put_dev(p_dev);
1311 handle->state = CLIENT_UNBOUND;
1312 handle->event_handler = NULL;
1317 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1319 } /* deregister_client */
1320 EXPORT_SYMBOL(pcmcia_deregister_client);
1323 /*======================================================================
1325 The user-mode PC Card device interface
1327 ======================================================================*/
1329 static int ds_open(struct inode *inode, struct file *file)
1331 socket_t i = iminor(inode);
1332 struct pcmcia_bus_socket *s;
1335 ds_dbg(0, "ds_open(socket %d)\n", i);
1337 s = get_socket_info_by_nr(i);
1340 s = pcmcia_get_bus_socket(s);
1344 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1345 if (s->state & DS_SOCKET_BUSY) {
1346 pcmcia_put_bus_socket(s);
1350 s->state |= DS_SOCKET_BUSY;
1353 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1355 pcmcia_put_bus_socket(s);
1358 user->event_tail = user->event_head = 0;
1359 user->next = s->user;
1360 user->user_magic = USER_MAGIC;
1363 file->private_data = user;
1365 if (s->state & DS_SOCKET_PRESENT)
1366 queue_event(user, CS_EVENT_CARD_INSERTION);
1370 /*====================================================================*/
1372 static int ds_release(struct inode *inode, struct file *file)
1374 struct pcmcia_bus_socket *s;
1375 user_info_t *user, **link;
1377 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1379 user = file->private_data;
1380 if (CHECK_USER(user))
1385 /* Unlink user data structure */
1386 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1387 s->state &= ~DS_SOCKET_BUSY;
1389 file->private_data = NULL;
1390 for (link = &s->user; *link; link = &(*link)->next)
1391 if (*link == user) break;
1395 user->user_magic = 0;
1397 pcmcia_put_bus_socket(s);
1402 /*====================================================================*/
1404 static ssize_t ds_read(struct file *file, char __user *buf,
1405 size_t count, loff_t *ppos)
1407 struct pcmcia_bus_socket *s;
1411 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1416 user = file->private_data;
1417 if (CHECK_USER(user))
1421 if (s->state & DS_SOCKET_DEAD)
1424 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1426 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1431 /*====================================================================*/
1433 static ssize_t ds_write(struct file *file, const char __user *buf,
1434 size_t count, loff_t *ppos)
1436 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1440 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1446 /*====================================================================*/
1448 /* No kernel lock - fine */
1449 static u_int ds_poll(struct file *file, poll_table *wait)
1451 struct pcmcia_bus_socket *s;
1454 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1456 user = file->private_data;
1457 if (CHECK_USER(user))
1461 * We don't check for a dead socket here since that
1462 * will send cardmgr into an endless spin.
1464 poll_wait(file, &s->queue, wait);
1465 if (!queue_empty(user))
1466 return POLLIN | POLLRDNORM;
1470 /*====================================================================*/
1472 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1474 static int ds_ioctl(struct inode * inode, struct file * file,
1475 u_int cmd, u_long arg)
1477 struct pcmcia_bus_socket *s;
1478 void __user *uarg = (char __user *)arg;
1481 ds_ioctl_arg_t *buf;
1484 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1486 user = file->private_data;
1487 if (CHECK_USER(user))
1491 if (s->state & DS_SOCKET_DEAD)
1494 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1495 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1497 /* Permission check */
1498 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1502 if (!access_ok(VERIFY_READ, uarg, size)) {
1503 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1507 if (cmd & IOC_OUT) {
1508 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1509 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1513 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1519 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1522 case DS_ADJUST_RESOURCE_INFO:
1523 ret = pcmcia_adjust_resource_info(&buf->adjust);
1525 case DS_GET_CARD_SERVICES_INFO:
1526 ret = pcmcia_get_card_services_info(&buf->servinfo);
1528 case DS_GET_CONFIGURATION_INFO:
1529 if (buf->config.Function &&
1530 (buf->config.Function >= s->parent->functions))
1533 ret = pccard_get_configuration_info(s->parent,
1534 buf->config.Function, &buf->config);
1536 case DS_GET_FIRST_TUPLE:
1537 down(&s->parent->skt_sem);
1538 pcmcia_validate_mem(s->parent);
1539 up(&s->parent->skt_sem);
1540 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1542 case DS_GET_NEXT_TUPLE:
1543 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1545 case DS_GET_TUPLE_DATA:
1546 buf->tuple.TupleData = buf->tuple_parse.data;
1547 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1548 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1550 case DS_PARSE_TUPLE:
1551 buf->tuple.TupleData = buf->tuple_parse.data;
1552 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1555 ret = pccard_reset_card(s->parent);
1558 if (buf->status.Function &&
1559 (buf->status.Function >= s->parent->functions))
1562 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1564 case DS_VALIDATE_CIS:
1565 down(&s->parent->skt_sem);
1566 pcmcia_validate_mem(s->parent);
1567 up(&s->parent->skt_sem);
1568 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1570 case DS_SUSPEND_CARD:
1571 ret = pcmcia_suspend_card(s->parent);
1573 case DS_RESUME_CARD:
1574 ret = pcmcia_resume_card(s->parent);
1577 err = pcmcia_eject_card(s->parent);
1579 case DS_INSERT_CARD:
1580 err = pcmcia_insert_card(s->parent);
1582 case DS_ACCESS_CONFIGURATION_REGISTER:
1583 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1587 if (buf->conf_reg.Function &&
1588 (buf->conf_reg.Function >= s->parent->functions))
1591 ret = pccard_access_configuration_register(s->parent,
1592 buf->conf_reg.Function, &buf->conf_reg);
1594 case DS_GET_FIRST_REGION:
1595 case DS_GET_NEXT_REGION:
1597 if (!capable(CAP_SYS_ADMIN)) {
1601 static int printed = 0;
1603 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1604 printk(KERN_WARNING "MTD handling any more.\n");
1611 case DS_GET_FIRST_WINDOW:
1612 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1613 &buf->win_info.window);
1615 case DS_GET_NEXT_WINDOW:
1616 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1617 buf->win_info.handle->index + 1, &buf->win_info.window);
1619 case DS_GET_MEM_PAGE:
1620 ret = pcmcia_get_mem_page(buf->win_info.handle,
1621 &buf->win_info.map);
1623 case DS_REPLACE_CIS:
1624 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1626 case DS_BIND_REQUEST:
1627 if (!capable(CAP_SYS_ADMIN)) {
1631 err = bind_request(s, &buf->bind_info);
1633 case DS_GET_DEVICE_INFO:
1634 err = get_device_info(s, &buf->bind_info, 1);
1636 case DS_GET_NEXT_DEVICE:
1637 err = get_device_info(s, &buf->bind_info, 0);
1639 case DS_UNBIND_REQUEST:
1646 if ((err == 0) && (ret != CS_SUCCESS)) {
1647 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1649 case CS_BAD_SOCKET: case CS_NO_CARD:
1650 err = -ENODEV; break;
1651 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1653 err = -EINVAL; break;
1655 err = -EBUSY; break;
1656 case CS_OUT_OF_RESOURCE:
1657 err = -ENOSPC; break;
1658 case CS_NO_MORE_ITEMS:
1659 err = -ENODATA; break;
1660 case CS_UNSUPPORTED_FUNCTION:
1661 err = -ENOSYS; break;
1667 if (cmd & IOC_OUT) {
1668 if (__copy_to_user(uarg, (char *)buf, size))
1677 /*====================================================================*/
1679 static struct file_operations ds_fops = {
1680 .owner = THIS_MODULE,
1682 .release = ds_release,
1689 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1691 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1692 struct pcmcia_bus_socket *s;
1695 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1698 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1700 /* get reference to parent socket */
1701 s->parent = pcmcia_get_socket(socket);
1703 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1708 kref_init(&s->refcount);
1711 * Ugly. But we want to wait for the socket threads to have started up.
1712 * We really should let the drivers themselves drive some of this..
1716 init_waitqueue_head(&s->queue);
1717 INIT_LIST_HEAD(&s->devices_list);
1718 INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1720 /* Set up hotline to Card Services */
1721 s->callback.owner = THIS_MODULE;
1722 s->callback.event = &ds_event;
1723 s->callback.resources_done = &pcmcia_card_add;
1726 ret = pccard_register_pcmcia(socket, &s->callback);
1728 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1729 pcmcia_put_bus_socket(s);
1730 socket->pcmcia = NULL;
1738 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1740 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1742 if (!socket || !socket->pcmcia)
1745 pccard_register_pcmcia(socket, NULL);
1747 socket->pcmcia->state |= DS_SOCKET_DEAD;
1748 pcmcia_put_bus_socket(socket->pcmcia);
1749 socket->pcmcia = NULL;
1755 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1756 static struct class_interface pcmcia_bus_interface = {
1757 .class = &pcmcia_socket_class,
1758 .add = &pcmcia_bus_add_socket,
1759 .remove = &pcmcia_bus_remove_socket,
1763 struct bus_type pcmcia_bus_type = {
1765 .hotplug = pcmcia_bus_hotplug,
1766 .match = pcmcia_bus_match,
1767 .dev_attrs = pcmcia_dev_attrs,
1769 EXPORT_SYMBOL(pcmcia_bus_type);
1772 static int __init init_pcmcia_bus(void)
1776 spin_lock_init(&pcmcia_dev_list_lock);
1778 bus_register(&pcmcia_bus_type);
1779 class_interface_register(&pcmcia_bus_interface);
1781 /* Set up character device for user mode clients */
1782 i = register_chrdev(0, "pcmcia", &ds_fops);
1784 printk(KERN_NOTICE "unable to find a free device # for "
1785 "Driver Services (error=%d)\n", i);
1789 #ifdef CONFIG_PROC_FS
1790 proc_pccard = proc_mkdir("pccard", proc_bus);
1792 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1797 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1798 * pcmcia_socket_class is already registered */
1801 static void __exit exit_pcmcia_bus(void)
1803 class_interface_unregister(&pcmcia_bus_interface);
1805 #ifdef CONFIG_PROC_FS
1807 remove_proc_entry("drivers", proc_pccard);
1808 remove_proc_entry("pccard", proc_bus);
1811 if (major_dev != -1)
1812 unregister_chrdev(major_dev, "pcmcia");
1814 bus_unregister(&pcmcia_bus_type);
1816 module_exit(exit_pcmcia_bus);
1820 /* helpers for backwards-compatible functions */
1822 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1824 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1831 /* backwards-compatible accessing of driver --- by name! */
1833 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1835 struct device_driver *drv;
1836 struct pcmcia_driver *p_drv;
1838 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1842 p_drv = container_of(drv, struct pcmcia_driver, drv);