1 /*
2 * ds.c -- 16-bit PCMCIA core support
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
11 *
12 * (C) 1999 David A. Hinds
13 * (C) 2003 - 2004 Dominik Brodowski
14 */
15
16 #include <linux/config.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/major.h>
22 #include <linux/string.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <linux/mm.h>
26 #include <linux/fcntl.h>
27 #include <linux/sched.h>
28 #include <linux/smp_lock.h>
29 #include <linux/timer.h>
30 #include <linux/ioctl.h>
31 #include <linux/proc_fs.h>
32 #include <linux/poll.h>
33 #include <linux/pci.h>
34 #include <linux/list.h>
35 #include <linux/delay.h>
36 #include <linux/kref.h>
37 #include <linux/workqueue.h>
38
39 #include <asm/atomic.h>
40
41 #define IN_CARD_SERVICES
42 #include <pcmcia/version.h>
43 #include <pcmcia/cs_types.h>
44 #include <pcmcia/cs.h>
45 #include <pcmcia/bulkmem.h>
46 #include <pcmcia/cistpl.h>
47 #include <pcmcia/ds.h>
48 #include <pcmcia/ss.h>
49
50 #include "cs_internal.h"
51
52 /*====================================================================*/
53
54 /* Module parameters */
55
56 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
57 MODULE_DESCRIPTION("PCMCIA Driver Services");
58 MODULE_LICENSE("GPL");
59
60 #ifdef DEBUG
61 int ds_pc_debug;
62
63 module_param_named(pc_debug, ds_pc_debug, int, 0644);
64
65 #define ds_dbg(lvl, fmt, arg...) do { \
66 if (ds_pc_debug > (lvl)) \
67 printk(KERN_DEBUG "ds: " fmt , ## arg); \
68 } while (0)
69 #else
70 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
71 #endif
72
73 /*====================================================================*/
74
75 /* Device user information */
76 #define MAX_EVENTS 32
77 #define USER_MAGIC 0x7ea4
78 #define CHECK_USER(u) \
79 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
80 typedef struct user_info_t {
81 u_int user_magic;
82 int event_head, event_tail;
83 event_t event[MAX_EVENTS];
84 struct user_info_t *next;
85 struct pcmcia_bus_socket *socket;
86 } user_info_t;
87
88 /* Socket state information */
89 struct pcmcia_bus_socket {
90 struct kref refcount;
91 struct pcmcia_callback callback;
92 int state;
93 user_info_t *user;
94 int req_pending, req_result;
95 wait_queue_head_t queue, request;
96 struct pcmcia_socket *parent;
97
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 */
104 };
105 static spinlock_t pcmcia_dev_list_lock;
106
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
111
112 /*====================================================================*/
113
114 static int major_dev = -1;
115
116 static int unbind_request(struct pcmcia_bus_socket *s);
117
118 /*====================================================================*/
119
120 /* code which was in cs.c before */
121
122 /* String tables for error messages */
123
124 typedef struct lookup_t {
125 int key;
126 char *msg;
127 } lookup_t;
128
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" }
161 };
162
163
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" }
214 };
215
216
217 int pcmcia_report_error(client_handle_t handle, error_info_t *err)
218 {
219 int i;
220 char *serv;
221
222 if (CHECK_HANDLE(handle))
223 printk(KERN_NOTICE);
224 else {
225 struct pcmcia_device *p_dev = handle_to_pdev(handle);
226 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
227 }
228
229 for (i = 0; i < ARRAY_SIZE(service_table); i++)
230 if (service_table[i].key == err->func)
231 break;
232 if (i < ARRAY_SIZE(service_table))
233 serv = service_table[i].msg;
234 else
235 serv = "Unknown service number";
236
237 for (i = 0; i < ARRAY_SIZE(error_table); i++)
238 if (error_table[i].key == err->retcode)
239 break;
240 if (i < ARRAY_SIZE(error_table))
241 printk("%s: %s\n", serv, error_table[i].msg);
242 else
243 printk("%s: Unknown error code %#x\n", serv, err->retcode);
244
245 return CS_SUCCESS;
246 } /* report_error */
247 EXPORT_SYMBOL(pcmcia_report_error);
248
249 /* end of code which was in cs.c before */
250
251 /*======================================================================*/
252
253 void cs_error(client_handle_t handle, int func, int ret)
254 {
255 error_info_t err = { func, ret };
256 pcmcia_report_error(handle, &err);
257 }
258 EXPORT_SYMBOL(cs_error);
259
260 /*======================================================================*/
261
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);
264
265 static void pcmcia_release_bus_socket(struct kref *refcount)
266 {
267 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
268 pcmcia_put_socket(s->parent);
269 kfree(s);
270 }
271
272 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
273 {
274 kref_put(&s->refcount, pcmcia_release_bus_socket);
275 }
276
277 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
278 {
279 kref_get(&s->refcount);
280 return (s);
281 }
282
283 /**
284 * pcmcia_register_driver - register a PCMCIA driver with the bus core
285 *
286 * Registers a PCMCIA driver with the PCMCIA bus core.
287 */
288 int pcmcia_register_driver(struct pcmcia_driver *driver)
289 {
290 if (!driver)
291 return -EINVAL;
292
293 driver->drv.bus = &pcmcia_bus_type;
294 driver->drv.owner = driver->owner;
295
296 return driver_register(&driver->drv);
297 }
298 EXPORT_SYMBOL(pcmcia_register_driver);
299
300 /**
301 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
302 */
303 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
304 {
305 driver_unregister(&driver->drv);
306 }
307 EXPORT_SYMBOL(pcmcia_unregister_driver);
308
309 #ifdef CONFIG_PROC_FS
310 static struct proc_dir_entry *proc_pccard = NULL;
311
312 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
313 {
314 char **p = d;
315 struct pcmcia_driver *p_drv = container_of(driver,
316 struct pcmcia_driver, drv);
317
318 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
319 #ifdef CONFIG_MODULE_UNLOAD
320 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
321 #else
322 1
323 #endif
324 );
325 d = (void *) p;
326
327 return 0;
328 }
329
330 static int proc_read_drivers(char *buf, char **start, off_t pos,
331 int count, int *eof, void *data)
332 {
333 char *p = buf;
334
335 bus_for_each_drv(&pcmcia_bus_type, NULL,
336 (void *) &p, proc_read_drivers_callback);
337
338 return (p - buf);
339 }
340 #endif
341
342 /* pcmcia_device handling */
343
344 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
345 {
346 struct device *tmp_dev;
347 tmp_dev = get_device(&p_dev->dev);
348 if (!tmp_dev)
349 return NULL;
350 return to_pcmcia_dev(tmp_dev);
351 }
352
353 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
354 {
355 put_device(&p_dev->dev);
356 }
357
358 static void pcmcia_release_dev(struct device *dev)
359 {
360 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
361 ds_dbg(1, "releasing dev %p\n", p_dev);
362 pcmcia_put_bus_socket(p_dev->socket->pcmcia);
363 kfree(p_dev);
364 }
365
366
367 /*======================================================================
368
369 These manage a ring buffer of events pending for one user process
370
371 ======================================================================*/
372
373 static int queue_empty(user_info_t *user)
374 {
375 return (user->event_head == user->event_tail);
376 }
377
378 static event_t get_queued_event(user_info_t *user)
379 {
380 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
381 return user->event[user->event_tail];
382 }
383
384 static void queue_event(user_info_t *user, event_t event)
385 {
386 user->event_head = (user->event_head+1) % MAX_EVENTS;
387 if (user->event_head == user->event_tail)
388 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
389 user->event[user->event_head] = event;
390 }
391
392 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
393 {
394 user_info_t *user;
395 for (user = s->user; user; user = user->next)
396 queue_event(user, event);
397 wake_up_interruptible(&s->queue);
398 }
399
400 static int handle_request(struct pcmcia_bus_socket *s, event_t event)
401 {
402 if (s->req_pending != 0)
403 return CS_IN_USE;
404 if (s->state & DS_SOCKET_BUSY)
405 s->req_pending = 1;
406 handle_event(s, event);
407 if (wait_event_interruptible(s->request, s->req_pending <= 0))
408 return CS_IN_USE;
409 if (s->state & DS_SOCKET_BUSY)
410 return s->req_result;
411 return CS_SUCCESS;
412 }
413
414 /*======================================================================
415
416 The card status event handler.
417
418 ======================================================================*/
419
420 struct send_event_data {
421 struct pcmcia_socket *skt;
422 event_t event;
423 int priority;
424 };
425
426 static int send_event_callback(struct device *dev, void * _data)
427 {
428 struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
429 struct send_event_data *data = _data;
430
431 /* we get called for all sockets, but may only pass the event
432 * for drivers _on the affected socket_ */
433 if (p_dev->socket != data->skt)
434 return 0;
435
436 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
437 return 0;
438
439 if (p_dev->client.EventMask & data->event)
440 return EVENT(&p_dev->client, data->event, data->priority);
441
442 return 0;
443 }
444
445 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
446 {
447 int ret = 0;
448 struct send_event_data private;
449 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
450
451 if (!skt)
452 return 0;
453
454 private.skt = s;
455 private.event = event;
456 private.priority = priority;
457
458 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
459
460 pcmcia_put_bus_socket(skt);
461 return ret;
462 } /* send_event */
463
464
465 /* Normally, the event is passed to individual drivers after
466 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
467 * is inversed to maintain historic compatibility.
468 */
469
470 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
471 {
472 struct pcmcia_bus_socket *s = skt->pcmcia;
473 int ret = 0;
474
475 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
476 event, priority, s);
477
478 switch (event) {
479
480 case CS_EVENT_CARD_REMOVAL:
481 s->state &= ~DS_SOCKET_PRESENT;
482 send_event(skt, event, priority);
483 unbind_request(s);
484 handle_event(s, event);
485 break;
486
487 case CS_EVENT_CARD_INSERTION:
488 s->state |= DS_SOCKET_PRESENT;
489 handle_event(s, event);
490 send_event(skt, event, priority);
491 break;
492
493 case CS_EVENT_EJECTION_REQUEST:
494 ret = handle_request(s, event);
495 if (ret)
496 break;
497 ret = send_event(skt, event, priority);
498 break;
499
500 default:
501 handle_event(s, event);
502 send_event(skt, event, priority);
503 break;
504 }
505
506 return 0;
507 } /* ds_event */
508
509
510 /*======================================================================
511
512 bind_request() and bind_device() are merged by now. Register_client()
513 is called right at the end of bind_request(), during the driver's
514 ->attach() call. Individual descriptions:
515
516 bind_request() connects a socket to a particular client driver.
517 It looks up the specified device ID in the list of registered
518 drivers, binds it to the socket, and tries to create an instance
519 of the device. unbind_request() deletes a driver instance.
520
521 Bind_device() associates a device driver with a particular socket.
522 It is normally called by Driver Services after it has identified
523 a newly inserted card. An instance of that driver will then be
524 eligible to register as a client of this socket.
525
526 Register_client() uses the dev_info_t handle to match the
527 caller with a socket. The driver must have already been bound
528 to a socket with bind_device() -- in fact, bind_device()
529 allocates the client structure that will be used.
530
531 ======================================================================*/
532
533 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
534 {
535 struct pcmcia_driver *p_drv;
536 struct pcmcia_device *p_dev, *tmp_dev;
537 unsigned long flags;
538 int ret = 0;
539
540 s = pcmcia_get_bus_socket(s);
541 if (!s)
542 return -EINVAL;
543
544 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
545 (char *)bind_info->dev_info);
546
547 p_drv = get_pcmcia_driver(&bind_info->dev_info);
548 if (!p_drv) {
549 ret = -EINVAL;
550 goto err_put;
551 }
552
553 if (!try_module_get(p_drv->owner)) {
554 ret = -EINVAL;
555 goto err_put_driver;
556 }
557
558 /* Currently, the userspace pcmcia cardmgr detects pcmcia devices.
559 * Here this information is translated into a kernel
560 * struct pcmcia_device.
561 */
562
563 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
564 if (!p_dev) {
565 ret = -ENOMEM;
566 goto err_put_module;
567 }
568 memset(p_dev, 0, sizeof(struct pcmcia_device));
569
570 p_dev->socket = s->parent;
571 p_dev->device_no = (s->device_count++);
572 p_dev->func = bind_info->function;
573
574 p_dev->dev.bus = &pcmcia_bus_type;
575 p_dev->dev.parent = s->parent->dev.dev;
576 p_dev->dev.release = pcmcia_release_dev;
577 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
578 p_dev->dev.driver = &p_drv->drv;
579
580 /* compat */
581 p_dev->client.client_magic = CLIENT_MAGIC;
582 p_dev->client.Socket = s->parent;
583 p_dev->client.Function = bind_info->function;
584 p_dev->client.state = CLIENT_UNBOUND;
585
586 ret = device_register(&p_dev->dev);
587 if (ret) {
588 kfree(p_dev);
589 goto err_put_module;
590 }
591
592 /* Add to the list in pcmcia_bus_socket, but only if no device
593 * with the same func _and_ driver exists */
594 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
595 list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list) {
596 if ((tmp_dev->func == bind_info->function) &&
597 (tmp_dev->dev.driver == p_dev->dev.driver)){
598 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
599 bind_info->instance = tmp_dev->instance;
600 ret = -EBUSY;
601 goto err_unregister;
602 }
603 }
604 list_add_tail(&p_dev->socket_device_list, &s->devices_list);
605 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
606
607 if (p_drv->attach) {
608 p_dev->instance = p_drv->attach();
609 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) {
610 printk(KERN_NOTICE "ds: unable to create instance "
611 "of '%s'!\n", (char *)bind_info->dev_info);
612 ret = -ENODEV;
613 goto err_unregister;
614 }
615 }
616
617 put_driver(&p_drv->drv);
618
619 return 0;
620
621 err_unregister:
622 device_unregister(&p_dev->dev);
623 module_put(p_drv->owner);
624 put_driver(&p_drv->drv);
625 return (ret);
626
627 err_put_module:
628 module_put(p_drv->owner);
629 err_put_driver:
630 put_driver(&p_drv->drv);
631 err_put:
632 pcmcia_put_bus_socket(s);
633 return (ret);
634 } /* bind_request */
635
636 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
637 {
638 client_t *client = NULL;
639 struct pcmcia_socket *s;
640 struct pcmcia_bus_socket *skt = NULL;
641 struct pcmcia_device *p_dev = NULL;
642
643 /* Look for unbound client with matching dev_info */
644 down_read(&pcmcia_socket_list_rwsem);
645 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
646 unsigned long flags;
647
648 if (s->state & SOCKET_CARDBUS)
649 continue;
650
651 skt = s->pcmcia;
652 if (!skt)
653 continue;
654 skt = pcmcia_get_bus_socket(skt);
655 if (!skt)
656 continue;
657 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
658 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
659 struct pcmcia_driver *p_drv;
660 p_dev = pcmcia_get_dev(p_dev);
661 if (!p_dev)
662 continue;
663 if (!(p_dev->client.state & CLIENT_UNBOUND) ||
664 (!p_dev->dev.driver)) {
665 pcmcia_put_dev(p_dev);
666 continue;
667 }
668 p_drv = to_pcmcia_drv(p_dev->dev.driver);
669 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
670 client = &p_dev->client;
671 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
672 goto found;
673 }
674 pcmcia_put_dev(p_dev);
675 }
676 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
677 pcmcia_put_bus_socket(skt);
678 }
679 found:
680 up_read(&pcmcia_socket_list_rwsem);
681 if (!p_dev || !client)
682 return -ENODEV;
683
684 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
685
686 /*
687 * Prevent this racing with a card insertion.
688 */
689 down(&s->skt_sem);
690 *handle = client;
691 client->state &= ~CLIENT_UNBOUND;
692 client->Socket = s;
693 client->EventMask = req->EventMask;
694 client->event_handler = req->event_handler;
695 client->event_callback_args = req->event_callback_args;
696 client->event_callback_args.client_handle = client;
697
698 if (s->state & SOCKET_CARDBUS)
699 client->state |= CLIENT_CARDBUS;
700
701 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
702 (client->Function != BIND_FN_ALL)) {
703 cistpl_longlink_mfc_t mfc;
704 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
705 == CS_SUCCESS)
706 s->functions = mfc.nfn;
707 else
708 s->functions = 1;
709 s->config = kmalloc(sizeof(config_t) * s->functions,
710 GFP_KERNEL);
711 if (!s->config)
712 goto out_no_resource;
713 memset(s->config, 0, sizeof(config_t) * s->functions);
714 }
715
716 ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
717 client, p_dev->dev.bus_id);
718 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
719 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
720
721 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
722 if (client->EventMask & CS_EVENT_CARD_INSERTION)
723 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
724 }
725
726 up(&s->skt_sem);
727 return CS_SUCCESS;
728
729 out_no_resource:
730 up(&s->skt_sem);
731 pcmcia_put_dev(p_dev);
732 return CS_OUT_OF_RESOURCE;
733 } /* register_client */
734 EXPORT_SYMBOL(pcmcia_register_client);
735
736
737 /*====================================================================*/
738
739 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
740
741 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
742 {
743 dev_node_t *node;
744 struct pcmcia_device *p_dev;
745 unsigned long flags;
746 int ret = 0;
747
748 #ifdef CONFIG_CARDBUS
749 /*
750 * Some unbelievably ugly code to associate the PCI cardbus
751 * device and its driver with the PCMCIA "bind" information.
752 */
753 {
754 struct pci_bus *bus;
755
756 bus = pcmcia_lookup_bus(s->parent);
757 if (bus) {
758 struct list_head *list;
759 struct pci_dev *dev = NULL;
760
761 list = bus->devices.next;
762 while (list != &bus->devices) {
763 struct pci_dev *pdev = pci_dev_b(list);
764 list = list->next;
765
766 if (first) {
767 dev = pdev;
768 break;
769 }
770
771 /* Try to handle "next" here some way? */
772 }
773 if (dev && dev->driver) {
774 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
775 bind_info->major = 0;
776 bind_info->minor = 0;
777 bind_info->next = NULL;
778 return 0;
779 }
780 }
781 }
782 #endif
783
784 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
785 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
786 if (p_dev->func == bind_info->function) {
787 p_dev = pcmcia_get_dev(p_dev);
788 if (!p_dev)
789 continue;
790 goto found;
791 }
792 }
793 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
794 return -ENODEV;
795
796 found:
797 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
798
799 if ((!p_dev->instance) ||
800 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
801 ret = -EAGAIN;
802 goto err_put;
803 }
804
805 if (first)
806 node = p_dev->instance->dev;
807 else
808 for (node = p_dev->instance->dev; node; node = node->next)
809 if (node == bind_info->next)
810 break;
811 if (!node) {
812 ret = -ENODEV;
813 goto err_put;
814 }
815
816 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
817 bind_info->major = node->major;
818 bind_info->minor = node->minor;
819 bind_info->next = node->next;
820
821 err_put:
822 pcmcia_put_dev(p_dev);
823 return (ret);
824 } /* get_device_info */
825
826 /*====================================================================*/
827
828 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
829 * drivers have been called with EVENT_CARD_REMOVAL before.
830 */
831 static int unbind_request(struct pcmcia_bus_socket *s)
832 {
833 struct pcmcia_device *p_dev;
834 struct pcmcia_driver *p_drv;
835 unsigned long flags;
836
837 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
838
839 s->device_count = 0;
840
841 for (;;) {
842 /* unregister all pcmcia_devices registered with this socket*/
843 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
844 if (list_empty(&s->devices_list)) {
845 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
846 return 0;
847 }
848 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
849 list_del(&p_dev->socket_device_list);
850 p_dev->client.state |= CLIENT_STALE;
851 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
852
853 /* detach the "instance" */
854 p_drv = to_pcmcia_drv(p_dev->dev.driver);
855 if (p_drv) {
856 if ((p_drv->detach) && (p_dev->instance))
857 p_drv->detach(p_dev->instance);
858 module_put(p_drv->owner);
859 }
860
861 device_unregister(&p_dev->dev);
862 }
863
864 return 0;
865 } /* unbind_request */
866
867 int pcmcia_deregister_client(client_handle_t handle)
868 {
869 struct pcmcia_socket *s;
870 int i;
871 struct pcmcia_device *p_dev = handle_to_pdev(handle);
872
873 if (CHECK_HANDLE(handle))
874 return CS_BAD_HANDLE;
875
876 s = SOCKET(handle);
877 ds_dbg(1, "deregister_client(%p)\n", handle);
878
879 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
880 goto warn_out;
881 for (i = 0; i < MAX_WIN; i++)
882 if (handle->state & CLIENT_WIN_REQ(i))
883 goto warn_out;
884
885 if (handle->state & CLIENT_STALE) {
886 handle->client_magic = 0;
887 handle->state &= ~CLIENT_STALE;
888 pcmcia_put_dev(p_dev);
889 } else {
890 handle->state = CLIENT_UNBOUND;
891 handle->event_handler = NULL;
892 }
893
894 return CS_SUCCESS;
895 warn_out:
896 printk(KERN_WARNING "ds: deregister_client was called too early.\n");
897 return CS_IN_USE;
898 } /* deregister_client */
899 EXPORT_SYMBOL(pcmcia_deregister_client);
900
901
902 /*======================================================================
903
904 The user-mode PC Card device interface
905
906 ======================================================================*/
907
908 static int ds_open(struct inode *inode, struct file *file)
909 {
910 socket_t i = iminor(inode);
911 struct pcmcia_bus_socket *s;
912 user_info_t *user;
913
914 ds_dbg(0, "ds_open(socket %d)\n", i);
915
916 s = get_socket_info_by_nr(i);
917 if (!s)
918 return -ENODEV;
919 s = pcmcia_get_bus_socket(s);
920 if (!s)
921 return -ENODEV;
922
923 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
924 if (s->state & DS_SOCKET_BUSY) {
925 pcmcia_put_bus_socket(s);
926 return -EBUSY;
927 }
928 else
929 s->state |= DS_SOCKET_BUSY;
930 }
931
932 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
933 if (!user) {
934 pcmcia_put_bus_socket(s);
935 return -ENOMEM;
936 }
937 user->event_tail = user->event_head = 0;
938 user->next = s->user;
939 user->user_magic = USER_MAGIC;
940 user->socket = s;
941 s->user = user;
942 file->private_data = user;
943
944 if (s->state & DS_SOCKET_PRESENT)
945 queue_event(user, CS_EVENT_CARD_INSERTION);
946 return 0;
947 } /* ds_open */
948
949 /*====================================================================*/
950
951 static int ds_release(struct inode *inode, struct file *file)
952 {
953 struct pcmcia_bus_socket *s;
954 user_info_t *user, **link;
955
956 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
957
958 user = file->private_data;
959 if (CHECK_USER(user))
960 goto out;
961
962 s = user->socket;
963
964 /* Unlink user data structure */
965 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
966 s->state &= ~DS_SOCKET_BUSY;
967 s->req_pending = 0;
968 wake_up_interruptible(&s->request);
969 }
970 file->private_data = NULL;
971 for (link = &s->user; *link; link = &(*link)->next)
972 if (*link == user) break;
973 if (link == NULL)
974 goto out;
975 *link = user->next;
976 user->user_magic = 0;
977 kfree(user);
978 pcmcia_put_bus_socket(s);
979 out:
980 return 0;
981 } /* ds_release */
982
983 /*====================================================================*/
984
985 static ssize_t ds_read(struct file *file, char __user *buf,
986 size_t count, loff_t *ppos)
987 {
988 struct pcmcia_bus_socket *s;
989 user_info_t *user;
990 int ret;
991
992 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
993
994 if (count < 4)
995 return -EINVAL;
996
997 user = file->private_data;
998 if (CHECK_USER(user))
999 return -EIO;
1000
1001 s = user->socket;
1002 if (s->state & DS_SOCKET_DEAD)
1003 return -EIO;
1004
1005 ret = wait_event_interruptible(s->queue, !queue_empty(user));
1006 if (ret == 0)
1007 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1008
1009 return ret;
1010 } /* ds_read */
1011
1012 /*====================================================================*/
1013
1014 static ssize_t ds_write(struct file *file, const char __user *buf,
1015 size_t count, loff_t *ppos)
1016 {
1017 struct pcmcia_bus_socket *s;
1018 user_info_t *user;
1019
1020 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1021
1022 if (count != 4)
1023 return -EINVAL;
1024 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1025 return -EBADF;
1026
1027 user = file->private_data;
1028 if (CHECK_USER(user))
1029 return -EIO;
1030
1031 s = user->socket;
1032 if (s->state & DS_SOCKET_DEAD)
1033 return -EIO;
1034
1035 if (s->req_pending) {
1036 s->req_pending--;
1037 get_user(s->req_result, (int __user *)buf);
1038 if ((s->req_result != 0) || (s->req_pending == 0))
1039 wake_up_interruptible(&s->request);
1040 } else
1041 return -EIO;
1042
1043 return 4;
1044 } /* ds_write */
1045
1046 /*====================================================================*/
1047
1048 /* No kernel lock - fine */
1049 static u_int ds_poll(struct file *file, poll_table *wait)
1050 {
1051 struct pcmcia_bus_socket *s;
1052 user_info_t *user;
1053
1054 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1055
1056 user = file->private_data;
1057 if (CHECK_USER(user))
1058 return POLLERR;
1059 s = user->socket;
1060 /*
1061 * We don't check for a dead socket here since that
1062 * will send cardmgr into an endless spin.
1063 */
1064 poll_wait(file, &s->queue, wait);
1065 if (!queue_empty(user))
1066 return POLLIN | POLLRDNORM;
1067 return 0;
1068 } /* ds_poll */
1069
1070 /*====================================================================*/
1071
1072 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1073
1074 static int ds_ioctl(struct inode * inode, struct file * file,
1075 u_int cmd, u_long arg)
1076 {
1077 struct pcmcia_bus_socket *s;
1078 void __user *uarg = (char __user *)arg;
1079 u_int size;
1080 int ret, err;
1081 ds_ioctl_arg_t *buf;
1082 user_info_t *user;
1083
1084 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1085
1086 user = file->private_data;
1087 if (CHECK_USER(user))
1088 return -EIO;
1089
1090 s = user->socket;
1091 if (s->state & DS_SOCKET_DEAD)
1092 return -EIO;
1093
1094 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1095 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1096
1097 /* Permission check */
1098 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1099 return -EPERM;
1100
1101 if (cmd & IOC_IN) {
1102 err = verify_area(VERIFY_READ, uarg, size);
1103 if (err) {
1104 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", err);
1105 return err;
1106 }
1107 }
1108 if (cmd & IOC_OUT) {
1109 err = verify_area(VERIFY_WRITE, uarg, size);
1110 if (err) {
1111 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", err);
1112 return err;
1113 }
1114 }
1115 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1116 if (!buf)
1117 return -ENOMEM;
1118
1119 err = ret = 0;
1120
1121 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1122
1123 switch (cmd) {
1124 case DS_ADJUST_RESOURCE_INFO:
1125 ret = pcmcia_adjust_resource_info(&buf->adjust);
1126 break;
1127 case DS_GET_CARD_SERVICES_INFO:
1128 ret = pcmcia_get_card_services_info(&buf->servinfo);
1129 break;
1130 case DS_GET_CONFIGURATION_INFO:
1131 if (buf->config.Function &&
1132 (buf->config.Function >= s->parent->functions))
1133 ret = CS_BAD_ARGS;
1134 else
1135 ret = pccard_get_configuration_info(s->parent,
1136 buf->config.Function, &buf->config);
1137 break;
1138 case DS_GET_FIRST_TUPLE:
1139 pcmcia_validate_mem(s->parent);
1140 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1141 break;
1142 case DS_GET_NEXT_TUPLE:
1143 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1144 break;
1145 case DS_GET_TUPLE_DATA:
1146 buf->tuple.TupleData = buf->tuple_parse.data;
1147 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1148 ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1149 break;
1150 case DS_PARSE_TUPLE:
1151 buf->tuple.TupleData = buf->tuple_parse.data;
1152 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1153 break;
1154 case DS_RESET_CARD:
1155 ret = pccard_reset_card(s->parent);
1156 break;
1157 case DS_GET_STATUS:
1158 if (buf->status.Function &&
1159 (buf->status.Function >= s->parent->functions))
1160 ret = CS_BAD_ARGS;
1161 else
1162 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1163 break;
1164 case DS_VALIDATE_CIS:
1165 pcmcia_validate_mem(s->parent);
1166 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1167 break;
1168 case DS_SUSPEND_CARD:
1169 ret = pcmcia_suspend_card(s->parent);
1170 break;
1171 case DS_RESUME_CARD:
1172 ret = pcmcia_resume_card(s->parent);
1173 break;
1174 case DS_EJECT_CARD:
1175 err = pcmcia_eject_card(s->parent);
1176 break;
1177 case DS_INSERT_CARD:
1178 err = pcmcia_insert_card(s->parent);
1179 break;
1180 case DS_ACCESS_CONFIGURATION_REGISTER:
1181 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1182 err = -EPERM;
1183 goto free_out;
1184 }
1185 if (buf->conf_reg.Function &&
1186 (buf->conf_reg.Function >= s->parent->functions))
1187 ret = CS_BAD_ARGS;
1188 else
1189 ret = pccard_access_configuration_register(s->parent,
1190 buf->conf_reg.Function, &buf->conf_reg);
1191 break;
1192 case DS_GET_FIRST_REGION:
1193 case DS_GET_NEXT_REGION:
1194 case DS_BIND_MTD:
1195 if (!capable(CAP_SYS_ADMIN)) {
1196 err = -EPERM;
1197 goto free_out;
1198 } else {
1199 static int printed = 0;
1200 if (!printed) {
1201 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1202 printk(KERN_WARNING "MTD handling any more.\n");
1203 printed++;
1204 }
1205 }
1206 ret = -EINVAL;
1207 goto free_out;
1208 break;
1209 case DS_GET_FIRST_WINDOW:
1210 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1211 &buf->win_info.window);
1212 break;
1213 case DS_GET_NEXT_WINDOW:
1214 ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1215 buf->win_info.handle->index + 1, &buf->win_info.window);
1216 break;
1217 case DS_GET_MEM_PAGE:
1218 ret = pcmcia_get_mem_page(buf->win_info.handle,
1219 &buf->win_info.map);
1220 break;
1221 case DS_REPLACE_CIS:
1222 ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1223 break;
1224 case DS_BIND_REQUEST:
1225 if (!capable(CAP_SYS_ADMIN)) {
1226 err = -EPERM;
1227 goto free_out;
1228 }
1229 err = bind_request(s, &buf->bind_info);
1230 break;
1231 case DS_GET_DEVICE_INFO:
1232 err = get_device_info(s, &buf->bind_info, 1);
1233 break;
1234 case DS_GET_NEXT_DEVICE:
1235 err = get_device_info(s, &buf->bind_info, 0);
1236 break;
1237 case DS_UNBIND_REQUEST:
1238 err = 0;
1239 break;
1240 default:
1241 err = -EINVAL;
1242 }
1243
1244 if ((err == 0) && (ret != CS_SUCCESS)) {
1245 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1246 switch (ret) {
1247 case CS_BAD_SOCKET: case CS_NO_CARD:
1248 err = -ENODEV; break;
1249 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1250 case CS_BAD_TUPLE:
1251 err = -EINVAL; break;
1252 case CS_IN_USE:
1253 err = -EBUSY; break;
1254 case CS_OUT_OF_RESOURCE:
1255 err = -ENOSPC; break;
1256 case CS_NO_MORE_ITEMS:
1257 err = -ENODATA; break;
1258 case CS_UNSUPPORTED_FUNCTION:
1259 err = -ENOSYS; break;
1260 default:
1261 err = -EIO; break;
1262 }
1263 }
1264
1265 if (cmd & IOC_OUT) {
1266 if (__copy_to_user(uarg, (char *)buf, size))
1267 err = -EFAULT;
1268 }
1269
1270 free_out:
1271 kfree(buf);
1272 return err;
1273 } /* ds_ioctl */
1274
1275 /*====================================================================*/
1276
1277 static struct file_operations ds_fops = {
1278 .owner = THIS_MODULE,
1279 .open = ds_open,
1280 .release = ds_release,
1281 .ioctl = ds_ioctl,
1282 .read = ds_read,
1283 .write = ds_write,
1284 .poll = ds_poll,
1285 };
1286
1287 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1288 {
1289 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1290 struct pcmcia_bus_socket *s;
1291 int ret;
1292
1293 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1294 if(!s)
1295 return -ENOMEM;
1296 memset(s, 0, sizeof(struct pcmcia_bus_socket));
1297
1298 /* get reference to parent socket */
1299 s->parent = pcmcia_get_socket(socket);
1300 if (!s->parent) {
1301 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1302 kfree (s);
1303 return -ENODEV;
1304 }
1305
1306 kref_init(&s->refcount);
1307
1308 /*
1309 * Ugly. But we want to wait for the socket threads to have started up.
1310 * We really should let the drivers themselves drive some of this..
1311 */
1312 msleep(250);
1313
1314 init_waitqueue_head(&s->queue);
1315 init_waitqueue_head(&s->request);
1316 INIT_LIST_HEAD(&s->devices_list);
1317
1318 /* Set up hotline to Card Services */
1319 s->callback.owner = THIS_MODULE;
1320 s->callback.event = &ds_event;
1321 socket->pcmcia = s;
1322
1323 ret = pccard_register_pcmcia(socket, &s->callback);
1324 if (ret) {
1325 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1326 pcmcia_put_bus_socket(s);
1327 socket->pcmcia = NULL;
1328 return (ret);
1329 }
1330
1331 return 0;
1332 }
1333
1334
1335 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1336 {
1337 struct pcmcia_socket *socket = class_get_devdata(class_dev);
1338
1339 if (!socket || !socket->pcmcia)
1340 return;
1341
1342 pccard_register_pcmcia(socket, NULL);
1343
1344 socket->pcmcia->state |= DS_SOCKET_DEAD;
1345 pcmcia_put_bus_socket(socket->pcmcia);
1346 socket->pcmcia = NULL;
1347
1348 return;
1349 }
1350
1351
1352 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1353 static struct class_interface pcmcia_bus_interface = {
1354 .class = &pcmcia_socket_class,
1355 .add = &pcmcia_bus_add_socket,
1356 .remove = &pcmcia_bus_remove_socket,
1357 };
1358
1359
1360 struct bus_type pcmcia_bus_type = {
1361 .name = "pcmcia",
1362 };
1363 EXPORT_SYMBOL(pcmcia_bus_type);
1364
1365
1366 static int __init init_pcmcia_bus(void)
1367 {
1368 int i;
1369
1370 spin_lock_init(&pcmcia_dev_list_lock);
1371
1372 bus_register(&pcmcia_bus_type);
1373 class_interface_register(&pcmcia_bus_interface);
1374
1375 /* Set up character device for user mode clients */
1376 i = register_chrdev(0, "pcmcia", &ds_fops);
1377 if (i == -EBUSY)
1378 printk(KERN_NOTICE "unable to find a free device # for "
1379 "Driver Services\n");
1380 else
1381 major_dev = i;
1382
1383 #ifdef CONFIG_PROC_FS
1384 proc_pccard = proc_mkdir("pccard", proc_bus);
1385 if (proc_pccard)
1386 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1387 #endif
1388
1389 return 0;
1390 }
1391 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1392 * pcmcia_socket_class is already registered */
1393
1394
1395 static void __exit exit_pcmcia_bus(void)
1396 {
1397 class_interface_unregister(&pcmcia_bus_interface);
1398
1399 #ifdef CONFIG_PROC_FS
1400 if (proc_pccard) {
1401 remove_proc_entry("drivers", proc_pccard);
1402 remove_proc_entry("pccard", proc_bus);
1403 }
1404 #endif
1405 if (major_dev != -1)
1406 unregister_chrdev(major_dev, "pcmcia");
1407
1408 bus_unregister(&pcmcia_bus_type);
1409 }
1410 module_exit(exit_pcmcia_bus);
1411
1412
1413
1414 /* helpers for backwards-compatible functions */
1415
1416 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1417 {
1418 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1419 if (s && s->pcmcia)
1420 return s->pcmcia;
1421 else
1422 return NULL;
1423 }
1424
1425 /* backwards-compatible accessing of driver --- by name! */
1426
1427 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1428 {
1429 struct device_driver *drv;
1430 struct pcmcia_driver *p_drv;
1431
1432 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1433 if (!drv)
1434 return NULL;
1435
1436 p_drv = container_of(drv, struct pcmcia_driver, drv);
1437
1438 return (p_drv);
1439 }
1440
1441 MODULE_ALIAS("ds");
1442
|
This page was automatically generated by the
LXR engine.
|