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 static spinlock_t pcmcia_dev_list_lock;
107 #define DS_SOCKET_PRESENT 0x01
108 #define DS_SOCKET_BUSY 0x02
109 #define DS_SOCKET_REMOVAL_PENDING 0x10
110 #define DS_SOCKET_DEAD 0x80
112 /*====================================================================*/
114 static int major_dev = -1;
116 static int unbind_request(struct pcmcia_bus_socket *s);
118 /*====================================================================*/
120 /* code which was in cs.c before */
122 /* String tables for error messages */
124 typedef struct lookup_t {
129 static const lookup_t error_table[] = {
130 { CS_SUCCESS, "Operation succeeded" },
131 { CS_BAD_ADAPTER, "Bad adapter" },
132 { CS_BAD_ATTRIBUTE, "Bad attribute", },
133 { CS_BAD_BASE, "Bad base address" },
134 { CS_BAD_EDC, "Bad EDC" },
135 { CS_BAD_IRQ, "Bad IRQ" },
136 { CS_BAD_OFFSET, "Bad offset" },
137 { CS_BAD_PAGE, "Bad page number" },
138 { CS_READ_FAILURE, "Read failure" },
139 { CS_BAD_SIZE, "Bad size" },
140 { CS_BAD_SOCKET, "Bad socket" },
141 { CS_BAD_TYPE, "Bad type" },
142 { CS_BAD_VCC, "Bad Vcc" },
143 { CS_BAD_VPP, "Bad Vpp" },
144 { CS_BAD_WINDOW, "Bad window" },
145 { CS_WRITE_FAILURE, "Write failure" },
146 { CS_NO_CARD, "No card present" },
147 { CS_UNSUPPORTED_FUNCTION, "Usupported function" },
148 { CS_UNSUPPORTED_MODE, "Unsupported mode" },
149 { CS_BAD_SPEED, "Bad speed" },
150 { CS_BUSY, "Resource busy" },
151 { CS_GENERAL_FAILURE, "General failure" },
152 { CS_WRITE_PROTECTED, "Write protected" },
153 { CS_BAD_ARG_LENGTH, "Bad argument length" },
154 { CS_BAD_ARGS, "Bad arguments" },
155 { CS_CONFIGURATION_LOCKED, "Configuration locked" },
156 { CS_IN_USE, "Resource in use" },
157 { CS_NO_MORE_ITEMS, "No more items" },
158 { CS_OUT_OF_RESOURCE, "Out of resource" },
159 { CS_BAD_HANDLE, "Bad handle" },
160 { CS_BAD_TUPLE, "Bad CIS tuple" }
164 static const lookup_t service_table[] = {
165 { AccessConfigurationRegister, "AccessConfigurationRegister" },
166 { AddSocketServices, "AddSocketServices" },
167 { AdjustResourceInfo, "AdjustResourceInfo" },
168 { CheckEraseQueue, "CheckEraseQueue" },
169 { CloseMemory, "CloseMemory" },
170 { DeregisterClient, "DeregisterClient" },
171 { DeregisterEraseQueue, "DeregisterEraseQueue" },
172 { GetCardServicesInfo, "GetCardServicesInfo" },
173 { GetClientInfo, "GetClientInfo" },
174 { GetConfigurationInfo, "GetConfigurationInfo" },
175 { GetEventMask, "GetEventMask" },
176 { GetFirstClient, "GetFirstClient" },
177 { GetFirstRegion, "GetFirstRegion" },
178 { GetFirstTuple, "GetFirstTuple" },
179 { GetNextClient, "GetNextClient" },
180 { GetNextRegion, "GetNextRegion" },
181 { GetNextTuple, "GetNextTuple" },
182 { GetStatus, "GetStatus" },
183 { GetTupleData, "GetTupleData" },
184 { MapMemPage, "MapMemPage" },
185 { ModifyConfiguration, "ModifyConfiguration" },
186 { ModifyWindow, "ModifyWindow" },
187 { OpenMemory, "OpenMemory" },
188 { ParseTuple, "ParseTuple" },
189 { ReadMemory, "ReadMemory" },
190 { RegisterClient, "RegisterClient" },
191 { RegisterEraseQueue, "RegisterEraseQueue" },
192 { RegisterMTD, "RegisterMTD" },
193 { ReleaseConfiguration, "ReleaseConfiguration" },
194 { ReleaseIO, "ReleaseIO" },
195 { ReleaseIRQ, "ReleaseIRQ" },
196 { ReleaseWindow, "ReleaseWindow" },
197 { RequestConfiguration, "RequestConfiguration" },
198 { RequestIO, "RequestIO" },
199 { RequestIRQ, "RequestIRQ" },
200 { RequestSocketMask, "RequestSocketMask" },
201 { RequestWindow, "RequestWindow" },
202 { ResetCard, "ResetCard" },
203 { SetEventMask, "SetEventMask" },
204 { ValidateCIS, "ValidateCIS" },
205 { WriteMemory, "WriteMemory" },
206 { BindDevice, "BindDevice" },
207 { BindMTD, "BindMTD" },
208 { ReportError, "ReportError" },
209 { SuspendCard, "SuspendCard" },
210 { ResumeCard, "ResumeCard" },
211 { EjectCard, "EjectCard" },
212 { InsertCard, "InsertCard" },
213 { ReplaceCIS, "ReplaceCIS" }
217 int pcmcia_report_error(client_handle_t handle, error_info_t *err)
222 if (CHECK_HANDLE(handle))
225 struct pcmcia_device *p_dev = handle_to_pdev(handle);
226 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
229 for (i = 0; i < ARRAY_SIZE(service_table); i++)
230 if (service_table[i].key == err->func)
232 if (i < ARRAY_SIZE(service_table))
233 serv = service_table[i].msg;
235 serv = "Unknown service number";
237 for (i = 0; i < ARRAY_SIZE(error_table); i++)
238 if (error_table[i].key == err->retcode)
240 if (i < ARRAY_SIZE(error_table))
241 printk("%s: %s\n", serv, error_table[i].msg);
243 printk("%s: Unknown error code %#x\n", serv, err->retcode);
247 EXPORT_SYMBOL(pcmcia_report_error);
249 /* end of code which was in cs.c before */
251 /*======================================================================*/
253 void cs_error(client_handle_t handle, int func, int ret)
255 error_info_t err = { func, ret };
256 pcmcia_report_error(handle, &err);
258 EXPORT_SYMBOL(cs_error);
260 /*======================================================================*/
262 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info);
263 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr);
265 static void pcmcia_release_bus_socket(struct kref *refcount)
267 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
268 pcmcia_put_socket(s->parent);
272 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
274 kref_put(&s->refcount, pcmcia_release_bus_socket);
277 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
279 kref_get(&s->refcount);
284 * pcmcia_register_driver - register a PCMCIA driver with the bus core
286 * Registers a PCMCIA driver with the PCMCIA bus core.
288 static int pcmcia_device_probe(struct device *dev);
289 static int pcmcia_device_remove(struct device * dev);
291 int pcmcia_register_driver(struct pcmcia_driver *driver)
296 /* initialize common fields */
297 driver->drv.bus = &pcmcia_bus_type;
298 driver->drv.owner = driver->owner;
299 driver->drv.probe = pcmcia_device_probe;
300 driver->drv.remove = pcmcia_device_remove;
302 return driver_register(&driver->drv);
304 EXPORT_SYMBOL(pcmcia_register_driver);
307 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
309 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
311 driver_unregister(&driver->drv);
313 EXPORT_SYMBOL(pcmcia_unregister_driver);
315 #ifdef CONFIG_PROC_FS
316 static struct proc_dir_entry *proc_pccard = NULL;
318 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
321 struct pcmcia_driver *p_drv = container_of(driver,
322 struct pcmcia_driver, drv);
324 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
325 #ifdef CONFIG_MODULE_UNLOAD
326 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
336 static int proc_read_drivers(char *buf, char **start, off_t pos,
337 int count, int *eof, void *data)
341 bus_for_each_drv(&pcmcia_bus_type, NULL,
342 (void *) &p, proc_read_drivers_callback);
348 /* pcmcia_device handling */
350 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
352 struct device *tmp_dev;
353 tmp_dev = get_device(&p_dev->dev);
356 return to_pcmcia_dev(tmp_dev);
359 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
362 put_device(&p_dev->dev);
365 static void pcmcia_release_dev(struct device *dev)
367 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
368 ds_dbg(1, "releasing dev %p\n", p_dev);
369 pcmcia_put_bus_socket(p_dev->socket->pcmcia);
374 static int pcmcia_device_probe(struct device * dev)
376 struct pcmcia_device *p_dev;
377 struct pcmcia_driver *p_drv;
380 dev = get_device(dev);
384 p_dev = to_pcmcia_dev(dev);
385 p_drv = to_pcmcia_drv(dev->driver);
387 if (!try_module_get(p_drv->owner)) {
393 p_dev->instance = p_drv->attach();
394 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) {
395 printk(KERN_NOTICE "ds: unable to create instance "
396 "of '%s'!\n", p_drv->drv.name);
402 module_put(p_drv->owner);
404 if ((ret) || !(p_drv->attach))
410 static int pcmcia_device_remove(struct device * dev)
412 struct pcmcia_device *p_dev;
413 struct pcmcia_driver *p_drv;
415 /* detach the "instance" */
416 p_dev = to_pcmcia_dev(dev);
417 p_drv = to_pcmcia_drv(dev->driver);
420 if ((p_drv->detach) && (p_dev->instance)) {
421 p_drv->detach(p_dev->instance);
422 /* from pcmcia_probe_device */
423 put_device(&p_dev->dev);
425 module_put(p_drv->owner);
434 * pcmcia_device_query -- determine information about a pcmcia device
436 static int pcmcia_device_query(struct pcmcia_device *p_dev)
438 cistpl_manfid_t manf_id;
439 cistpl_funcid_t func_id;
440 cistpl_vers_1_t vers1;
443 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
444 CISTPL_MANFID, &manf_id)) {
445 p_dev->manf_id = manf_id.manf;
446 p_dev->card_id = manf_id.card;
447 p_dev->has_manf_id = 1;
448 p_dev->has_card_id = 1;
451 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
452 CISTPL_FUNCID, &func_id)) {
453 p_dev->func_id = func_id.func;
454 p_dev->has_func_id = 1;
456 /* rule of thumb: cards with no FUNCID, but with
457 * common memory device geometry information, are
458 * probably memory cards (from pcmcia-cs) */
459 cistpl_device_geo_t devgeo;
460 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
461 CISTPL_DEVICE_GEO, &devgeo)) {
462 ds_dbg(0, "mem device geometry probably means "
464 p_dev->func_id = CISTPL_FUNCID_MEMORY;
465 p_dev->has_func_id = 1;
469 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
471 for (i=0; i < vers1.ns; i++) {
475 tmp = vers1.str + vers1.ofs[i];
477 length = strlen(tmp) + 1;
478 if ((length < 3) || (length > 255))
481 p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
483 if (!p_dev->prod_id[i])
486 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
495 /* device_add_lock is needed to avoid double registration by cardmgr and kernel.
496 * Serializes pcmcia_device_add; will most likely be removed in future.
498 * While it has the caveat that adding new PCMCIA devices inside(!) device_register()
499 * won't work, this doesn't matter much at the moment: the driver core doesn't
502 static DECLARE_MUTEX(device_add_lock);
504 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function)
506 struct pcmcia_device *p_dev;
509 s = pcmcia_get_bus_socket(s);
513 down(&device_add_lock);
515 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
518 memset(p_dev, 0, sizeof(struct pcmcia_device));
520 p_dev->socket = s->parent;
521 p_dev->device_no = (s->device_count++);
522 p_dev->func = function;
524 p_dev->dev.bus = &pcmcia_bus_type;
525 p_dev->dev.parent = s->parent->dev.dev;
526 p_dev->dev.release = pcmcia_release_dev;
527 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
530 p_dev->client.client_magic = CLIENT_MAGIC;
531 p_dev->client.Socket = s->parent;
532 p_dev->client.Function = function;
533 p_dev->client.state = CLIENT_UNBOUND;
535 /* Add to the list in pcmcia_bus_socket */
536 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
537 list_add_tail(&p_dev->socket_device_list, &s->devices_list);
538 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
540 if (device_register(&p_dev->dev)) {
541 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
542 list_del(&p_dev->socket_device_list);
543 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
548 up(&device_add_lock);
556 up(&device_add_lock);
557 pcmcia_put_bus_socket(s);
563 static int pcmcia_card_add(struct pcmcia_socket *s)
566 cistpl_longlink_mfc_t mfc;
567 unsigned int no_funcs, i;
570 if (!(s->resource_setup_done))
571 return -EAGAIN; /* try again, but later... */
573 pcmcia_validate_mem(s);
574 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo);
575 if (ret || !cisinfo.Chains) {
576 ds_dbg(0, "invalid CIS or invalid resources\n");
580 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
585 /* this doesn't handle multifunction devices on one pcmcia function
587 for (i=0; i < no_funcs; i++)
588 pcmcia_device_add(s->pcmcia, i);
594 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
595 struct pcmcia_device * p_dev = to_pcmcia_dev(dev);
596 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
598 /* matching by cardmgr */
599 if (p_dev->cardmgr == p_drv)
605 #ifdef CONFIG_HOTPLUG
607 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
608 char *buffer, int buffer_size)
610 struct pcmcia_device *p_dev;
612 u32 hash[4] = { 0, 0, 0, 0};
617 p_dev = to_pcmcia_dev(dev);
619 /* calculate hashes */
620 for (i=0; i<4; i++) {
621 if (!p_dev->prod_id[i])
623 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
628 if (add_hotplug_env_var(envp, num_envp, &i,
629 buffer, buffer_size, &length,
631 p_dev->socket->sock))
634 if (add_hotplug_env_var(envp, num_envp, &i,
635 buffer, buffer_size, &length,
640 if (add_hotplug_env_var(envp, num_envp, &i,
641 buffer, buffer_size, &length,
642 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
643 "pa%08Xpb%08Xpc%08Xpd%08X",
644 p_dev->has_manf_id ? p_dev->manf_id : 0,
645 p_dev->has_card_id ? p_dev->card_id : 0,
646 p_dev->has_func_id ? p_dev->func_id : 0,
662 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
663 char *buffer, int buffer_size)
670 /************************ per-device sysfs output ***************************/
672 #define pcmcia_device_attr(field, test, format) \
673 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \
675 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
676 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
679 #define pcmcia_device_stringattr(name, field) \
680 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
682 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \
683 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
686 pcmcia_device_attr(func, socket, "0x%02x\n");
687 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
688 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
689 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
690 pcmcia_device_stringattr(prod_id1, prod_id[0]);
691 pcmcia_device_stringattr(prod_id2, prod_id[1]);
692 pcmcia_device_stringattr(prod_id3, prod_id[2]);
693 pcmcia_device_stringattr(prod_id4, prod_id[3]);
695 static struct device_attribute pcmcia_dev_attrs[] = {
696 __ATTR(function, 0444, func_show, NULL),
708 /*======================================================================
710 These manage a ring buffer of events pending for one user process
712 ======================================================================*/
714 static int queue_empty(user_info_t *user)
716 return (user->event_head == user->event_tail);
719 static event_t get_queued_event(user_info_t *user)
721 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
722 return user->event[user->event_tail];
725 static void queue_event(user_info_t *user, event_t event)
727 user->event_head = (user->event_head+1) % MAX_EVENTS;
728 if (user->event_head == user->event_tail)
729 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
730 user->event[user->event_head] = event;
733 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
736 for (user = s->user; user; user = user->next)
737 queue_event(user, event);
738 wake_up_interruptible(&s->queue);
742 /*======================================================================
744 The card status event handler.
746 ======================================================================*/
748 struct send_event_data {
749 struct pcmcia_socket *skt;
754 static int send_event_callback(struct device *dev, void * _data)
756 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
757 struct send_event_data *data = _data;
759 /* we get called for all sockets, but may only pass the event
760 * for drivers _on the affected socket_ */
761 if (p_dev->socket != data->skt)
764 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
767 if (p_dev->client.EventMask & data->event)
768 return EVENT(&p_dev->client, data->event, data->priority);
773 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
776 struct send_event_data private;
777 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
783 private.event = event;
784 private.priority = priority;
786 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
788 pcmcia_put_bus_socket(skt);
793 /* Normally, the event is passed to individual drivers after
794 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
795 * is inversed to maintain historic compatibility.
798 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
800 struct pcmcia_bus_socket *s = skt->pcmcia;
803 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
808 case CS_EVENT_CARD_REMOVAL:
809 s->state &= ~DS_SOCKET_PRESENT;
810 send_event(skt, event, priority);
812 handle_event(s, event);
815 case CS_EVENT_CARD_INSERTION:
816 s->state |= DS_SOCKET_PRESENT;
817 pcmcia_card_add(skt);
818 handle_event(s, event);
821 case CS_EVENT_EJECTION_REQUEST:
822 ret = send_event(skt, event, priority);
826 handle_event(s, event);
827 send_event(skt, event, priority);
835 /*======================================================================
837 bind_request() and bind_device() are merged by now. Register_client()
838 is called right at the end of bind_request(), during the driver's
839 ->attach() call. Individual descriptions:
841 bind_request() connects a socket to a particular client driver.
842 It looks up the specified device ID in the list of registered
843 drivers, binds it to the socket, and tries to create an instance
844 of the device. unbind_request() deletes a driver instance.
846 Bind_device() associates a device driver with a particular socket.
847 It is normally called by Driver Services after it has identified
848 a newly inserted card. An instance of that driver will then be
849 eligible to register as a client of this socket.
851 Register_client() uses the dev_info_t handle to match the
852 caller with a socket. The driver must have already been bound
853 to a socket with bind_device() -- in fact, bind_device()
854 allocates the client structure that will be used.
856 ======================================================================*/
858 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
860 struct pcmcia_driver *p_drv;
861 struct pcmcia_device *p_dev;
865 s = pcmcia_get_bus_socket(s);
869 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
870 (char *)bind_info->dev_info);
872 p_drv = get_pcmcia_driver(&bind_info->dev_info);
878 if (!try_module_get(p_drv->owner)) {
883 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
884 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
885 if (p_dev->func == bind_info->function) {
886 if ((p_dev->dev.driver == &p_drv->drv)) {
887 if (p_dev->cardmgr) {
888 /* if there's already a device
889 * registered, and it was registered
890 * by userspace before, we need to
891 * return the "instance". */
892 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
893 bind_info->instance = p_dev->instance;
897 /* the correct driver managed to bind
898 * itself magically to the correct
900 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
901 p_dev->cardmgr = p_drv;
905 } else if (!p_dev->dev.driver) {
906 /* there's already a device available where
907 * no device has been bound to yet. So we don't
908 * need to register a device! */
909 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
914 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
916 p_dev = pcmcia_device_add(s, bind_info->function);
923 p_dev->cardmgr = p_drv;
925 pcmcia_device_query(p_dev);
928 * Prevent this racing with a card insertion.
930 down(&s->parent->skt_sem);
931 bus_rescan_devices(&pcmcia_bus_type);
932 up(&s->parent->skt_sem);
934 /* check whether the driver indeed matched. I don't care if this
935 * is racy or not, because it can only happen on cardmgr access
938 if (!(p_dev->dev.driver == &p_drv->drv))
939 p_dev->cardmgr = NULL;
942 module_put(p_drv->owner);
944 put_driver(&p_drv->drv);
946 pcmcia_put_bus_socket(s);
952 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
954 client_t *client = NULL;
955 struct pcmcia_socket *s;
956 struct pcmcia_bus_socket *skt = NULL;
957 struct pcmcia_device *p_dev = NULL;
959 /* Look for unbound client with matching dev_info */
960 down_read(&pcmcia_socket_list_rwsem);
961 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
964 if (s->state & SOCKET_CARDBUS)
970 skt = pcmcia_get_bus_socket(skt);
973 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
974 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
975 struct pcmcia_driver *p_drv;
976 p_dev = pcmcia_get_dev(p_dev);
979 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
980 (!p_dev->dev.driver)) {
981 pcmcia_put_dev(p_dev);
984 p_drv = to_pcmcia_drv(p_dev->dev.driver);
985 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
986 client = &p_dev->client;
987 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
990 pcmcia_put_dev(p_dev);
992 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
993 pcmcia_put_bus_socket(skt);
996 up_read(&pcmcia_socket_list_rwsem);
997 if (!p_dev || !client)
1000 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1003 client->state &= ~CLIENT_UNBOUND;
1005 client->EventMask = req->EventMask;
1006 client->event_handler = req->event_handler;
1007 client->event_callback_args = req->event_callback_args;
1008 client->event_callback_args.client_handle = client;
1010 if (s->state & SOCKET_CARDBUS)
1011 client->state |= CLIENT_CARDBUS;
1013 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1014 (client->Function != BIND_FN_ALL)) {
1015 cistpl_longlink_mfc_t mfc;
1016 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1018 s->functions = mfc.nfn;
1021 s->config = kmalloc(sizeof(config_t) * s->functions,
1024 goto out_no_resource;
1025 memset(s->config, 0, sizeof(config_t) * s->functions);
1028 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1029 client, p_dev->dev.bus_id);
1030 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1031 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1033 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1034 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1035 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1041 pcmcia_put_dev(p_dev);
1042 return CS_OUT_OF_RESOURCE;
1043 } /* register_client */
1044 EXPORT_SYMBOL(pcmcia_register_client);
1047 /*====================================================================*/
1049 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1051 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1054 struct pcmcia_device *p_dev;
1055 unsigned long flags;
1058 #ifdef CONFIG_CARDBUS
1060 * Some unbelievably ugly code to associate the PCI cardbus
1061 * device and its driver with the PCMCIA "bind" information.
1064 struct pci_bus *bus;
1066 bus = pcmcia_lookup_bus(s->parent);
1068 struct list_head *list;
1069 struct pci_dev *dev = NULL;
1071 list = bus->devices.next;
1072 while (list != &bus->devices) {
1073 struct pci_dev *pdev = pci_dev_b(list);
1081 /* Try to handle "next" here some way? */
1083 if (dev && dev->driver) {
1084 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1085 bind_info->major = 0;
1086 bind_info->minor = 0;
1087 bind_info->next = NULL;
1094 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1095 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1096 if (p_dev->func == bind_info->function) {
1097 p_dev = pcmcia_get_dev(p_dev);
1103 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1107 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1109 if ((!p_dev->instance) ||
1110 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1116 node = p_dev->instance->dev;
1118 for (node = p_dev->instance->dev; node; node = node->next)
1119 if (node == bind_info->next)
1126 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1127 bind_info->major = node->major;
1128 bind_info->minor = node->minor;
1129 bind_info->next = node->next;
1132 pcmcia_put_dev(p_dev);
1134 } /* get_device_info */
1136 /*====================================================================*/
1138 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1139 * drivers have been called with EVENT_CARD_REMOVAL before.
1141 static int unbind_request(struct pcmcia_bus_socket *s)
1143 struct pcmcia_device *p_dev;
1144 unsigned long flags;
1146 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1148 s->device_count = 0;
1151 /* unregister all pcmcia_devices registered with this socket*/
1152 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1153 if (list_empty(&s->devices_list)) {
1154 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1157 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1158 list_del(&p_dev->socket_device_list);
1159 p_dev->client.state |= CLIENT_STALE;
1160 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1162 device_unregister(&p_dev->dev);
1166 } /* unbind_request */
1168 int pcmcia_deregister_client(client_handle_t handle)
1170 struct pcmcia_socket *s;
1172 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1174 if (CHECK_HANDLE(handle))
1175 return CS_BAD_HANDLE;
1178 ds_dbg(1, "deregister_client(%p)\n", handle);
1180 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1182 for (i = 0; i < MAX_WIN; i++)
1183 if (handle->state & CLIENT_WIN_REQ(i))
1186 if (handle->state & CLIENT_STALE) {
1187 handle->client_magic = 0;
1188 handle->state &= ~CLIENT_STALE;
1189 pcmcia_put_dev(p_dev);
1191 handle->state = CLIENT_UNBOUND;
1192 handle->event_handler = NULL;
1197 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1199 } /* deregister_client */
1200 EXPORT_SYMBOL(pcmcia_deregister_client);
1203 /*======================================================================
1205 The user-mode PC Card device interface
1207 ======================================================================*/
1209 static int ds_open(struct inode *inode, struct file *file)
1211 socket_t i = iminor(inode);
1212 struct pcmcia_bus_socket *s;
1215 ds_dbg(0, "ds_open(socket %d)\n", i);
1217 s = get_socket_info_by_nr(i);
1220 s = pcmcia_get_bus_socket(s);
1224 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1225 if (s->state & DS_SOCKET_BUSY) {
1226 pcmcia_put_bus_socket(s);
1230 s->state |= DS_SOCKET_BUSY;
1233 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1235 pcmcia_put_bus_socket(s);
1238 user->event_tail = user->event_head = 0;
1239 user->next = s->user;
1240 user->user_magic = USER_MAGIC;
1243 file->private_data = user;
1245 if (s->state & DS_SOCKET_PRESENT)
1246 queue_event(user, CS_EVENT_CARD_INSERTION);
1250 /*====================================================================*/
1252 static int ds_release(struct inode *inode, struct file *file)
1254 struct pcmcia_bus_socket *s;
1255 user_info_t *user, **link;
1257 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1259 user = file->private_data;
1260 if (CHECK_USER(user))
1265 /* Unlink user data structure */
1266 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1267 s->state &= ~DS_SOCKET_BUSY;
1269 file->private_data = NULL;
1270 for (link = &s->user; *link; link = &(*link)->next)
1271 if (*link == user) break;
1275 user->user_magic = 0;
1277 pcmcia_put_bus_socket(s);
1282 /*====================================================================*/
1284 static ssize_t ds_read(struct file *file, char __user *buf,
1285 size_t count, loff_t *ppos)
1287 struct pcmcia_bus_socket *s;
1291 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1296 user = file->private_data;
1297 if (CHECK_USER(user))
1301 if (s->state & DS_SOCKET_DEAD)
1304 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1306 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1311 /*====================================================================*/
1313 static ssize_t ds_write(struct file *file, const char __user *buf,
1314 size_t count, loff_t *ppos)
1316 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1320 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1326 /*====================================================================*/
1328 /* No kernel lock - fine */
1329 static u_int ds_poll(struct file *file, poll_table *wait)
1331 struct pcmcia_bus_socket *s;
1334 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1336 user = file->private_data;
1337 if (CHECK_USER(user))
1341 * We don't check for a dead socket here since that
1342 * will send cardmgr into an endless spin.
1344 poll_wait(file, &s->queue, wait);
1345 if (!queue_empty(user))
1346 return POLLIN | POLLRDNORM;
1350 /*====================================================================*/
1352 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1354 static int ds_ioctl(struct inode * inode, struct file * file,
1355 u_int cmd, u_long arg)
1357 struct pcmcia_bus_socket *s;
1358 void __user *uarg = (char __user *)arg;
1361 ds_ioctl_arg_t *buf;
1364 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1366 user = file->private_data;
1367 if (CHECK_USER(user))
1371 if (s->state & DS_SOCKET_DEAD)
1374 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1375 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1377 /* Permission check */
1378 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1382 if (!access_ok(VERIFY_READ, uarg, size)) {
1383 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1387 if (cmd & IOC_OUT) {
1388 if (!access_ok(VERIFY_WRITE, uarg, size)) {
1389 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1393 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1399 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1402 case DS_ADJUST_RESOURCE_INFO:
1403 ret = pcmcia_adjust_resource_info(&buf->adjust);
1405 case DS_GET_CARD_SERVICES_INFO:
1406 ret = pcmcia_get_card_services_info(&buf->servinfo);
1408 case DS_GET_CONFIGURATION_INFO:
1409 if (buf->config.Function &&
1410 (buf->config.Function >= s->parent->functions))
1413 ret = pccard_get_configuration_info(s->parent,
1414 buf->config.Function, &buf->config);
1416 case DS_GET_FIRST_TUPLE:
1417 down(&s->parent->skt_sem);
1418 pcmcia_validate_mem(s->parent);
1419 up(&s->parent->skt_sem);
1420 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1422 case DS_GET_NEXT_TUPLE:
1423 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1425 case DS_GET_TUPLE_DATA:
1426 buf->tuple.TupleData = buf->tuple_parse.data;
1427 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1428 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1430 case DS_PARSE_TUPLE:
1431 buf->tuple.TupleData = buf->tuple_parse.data;
1432 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1435 ret = pccard_reset_card(s->parent);
1438 if (buf->status.Function &&
1439 (buf->status.Function >= s->parent->functions))
1442 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1444 case DS_VALIDATE_CIS:
1445 down(&s->parent->skt_sem);
1446 pcmcia_validate_mem(s->parent);
1447 up(&s->parent->skt_sem);
1448 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1450 case DS_SUSPEND_CARD:
1451 ret = pcmcia_suspend_card(s->parent);
1453 case DS_RESUME_CARD:
1454 ret = pcmcia_resume_card(s->parent);
1457 err = pcmcia_eject_card(s->parent);
1459 case DS_INSERT_CARD:
1460 err = pcmcia_insert_card(s->parent);
1462 case DS_ACCESS_CONFIGURATION_REGISTER:
1463 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1467 if (buf->conf_reg.Function &&
1468 (buf->conf_reg.Function >= s->parent->functions))
1471 ret = pccard_access_configuration_register(s->parent,
1472 buf->conf_reg.Function, &buf->conf_reg);
1474 case DS_GET_FIRST_REGION:
1475 case DS_GET_NEXT_REGION:
1477 if (!capable(CAP_SYS_ADMIN)) {
1481 static int printed = 0;
1483 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1484 printk(KERN_WARNING "MTD handling any more.\n");
1491 case DS_GET_FIRST_WINDOW:
1492 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1493 &buf->win_info.window);
1495 case DS_GET_NEXT_WINDOW:
1496 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1497 buf->win_info.handle->index + 1, &buf->win_info.window);
1499 case DS_GET_MEM_PAGE:
1500 ret = pcmcia_get_mem_page(buf->win_info.handle,
1501 &buf->win_info.map);
1503 case DS_REPLACE_CIS:
1504 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1506 case DS_BIND_REQUEST:
1507 if (!capable(CAP_SYS_ADMIN)) {
1511 err = bind_request(s, &buf->bind_info);
1513 case DS_GET_DEVICE_INFO:
1514 err = get_device_info(s, &buf->bind_info, 1);
1516 case DS_GET_NEXT_DEVICE:
1517 err = get_device_info(s, &buf->bind_info, 0);
1519 case DS_UNBIND_REQUEST:
1526 if ((err == 0) && (ret != CS_SUCCESS)) {
1527 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1529 case CS_BAD_SOCKET: case CS_NO_CARD:
1530 err = -ENODEV; break;
1531 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1533 err = -EINVAL; break;
1535 err = -EBUSY; break;
1536 case CS_OUT_OF_RESOURCE:
1537 err = -ENOSPC; break;
1538 case CS_NO_MORE_ITEMS:
1539 err = -ENODATA; break;
1540 case CS_UNSUPPORTED_FUNCTION:
1541 err = -ENOSYS; break;
1547 if (cmd & IOC_OUT) {
1548 if (__copy_to_user(uarg, (char *)buf, size))
1557 /*====================================================================*/
1559 static struct file_operations ds_fops = {
1560 .owner = THIS_MODULE,
1562 .release = ds_release,
1569 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1571 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1572 struct pcmcia_bus_socket *s;
1575 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1578 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1580 /* get reference to parent socket */
1581 s->parent = pcmcia_get_socket(socket);
1583 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1588 kref_init(&s->refcount);
1591 * Ugly. But we want to wait for the socket threads to have started up.
1592 * We really should let the drivers themselves drive some of this..
1596 init_waitqueue_head(&s->queue);
1597 INIT_LIST_HEAD(&s->devices_list);
1599 /* Set up hotline to Card Services */
1600 s->callback.owner = THIS_MODULE;
1601 s->callback.event = &ds_event;
1602 s->callback.resources_done = &pcmcia_card_add;
1605 ret = pccard_register_pcmcia(socket, &s->callback);
1607 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1608 pcmcia_put_bus_socket(s);
1609 socket->pcmcia = NULL;
1617 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1619 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1621 if (!socket || !socket->pcmcia)
1624 pccard_register_pcmcia(socket, NULL);
1626 socket->pcmcia->state |= DS_SOCKET_DEAD;
1627 pcmcia_put_bus_socket(socket->pcmcia);
1628 socket->pcmcia = NULL;
1634 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1635 static struct class_interface pcmcia_bus_interface = {
1636 .class = &pcmcia_socket_class,
1637 .add = &pcmcia_bus_add_socket,
1638 .remove = &pcmcia_bus_remove_socket,
1642 struct bus_type pcmcia_bus_type = {
1644 .hotplug = pcmcia_bus_hotplug,
1645 .match = pcmcia_bus_match,
1646 .dev_attrs = pcmcia_dev_attrs,
1648 EXPORT_SYMBOL(pcmcia_bus_type);
1651 static int __init init_pcmcia_bus(void)
1655 spin_lock_init(&pcmcia_dev_list_lock);
1657 bus_register(&pcmcia_bus_type);
1658 class_interface_register(&pcmcia_bus_interface);
1660 /* Set up character device for user mode clients */
1661 i = register_chrdev(0, "pcmcia", &ds_fops);
1663 printk(KERN_NOTICE "unable to find a free device # for "
1664 "Driver Services (error=%d)\n", i);
1668 #ifdef CONFIG_PROC_FS
1669 proc_pccard = proc_mkdir("pccard", proc_bus);
1671 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1676 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1677 * pcmcia_socket_class is already registered */
1680 static void __exit exit_pcmcia_bus(void)
1682 class_interface_unregister(&pcmcia_bus_interface);
1684 #ifdef CONFIG_PROC_FS
1686 remove_proc_entry("drivers", proc_pccard);
1687 remove_proc_entry("pccard", proc_bus);
1690 if (major_dev != -1)
1691 unregister_chrdev(major_dev, "pcmcia");
1693 bus_unregister(&pcmcia_bus_type);
1695 module_exit(exit_pcmcia_bus);
1699 /* helpers for backwards-compatible functions */
1701 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1703 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1710 /* backwards-compatible accessing of driver --- by name! */
1712 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1714 struct device_driver *drv;
1715 struct pcmcia_driver *p_drv;
1717 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1721 p_drv = container_of(drv, struct pcmcia_driver, drv);