initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / pcmcia / cs.c
blobc33ac27567dce64ff5cff9829be69e640c11d84b
1 /*======================================================================
3 Kernel Card Services -- core services
5 cs.c 1.271 2000/10/02 20:27:49
7 The contents of this file are subject to the Mozilla Public
8 License Version 1.1 (the "License"); you may not use this file
9 except in compliance with the License. You may obtain a copy of
10 the License at http://www.mozilla.org/MPL/
12 Software distributed under the License is distributed on an "AS
13 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14 implied. See the License for the specific language governing
15 rights and limitations under the License.
17 The initial developer of the original code is David A. Hinds
18 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
19 are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
21 Alternatively, the contents of this file may be used under the
22 terms of the GNU General Public License version 2 (the "GPL"), in which
23 case the provisions of the GPL are applicable instead of the
24 above. If you wish to allow the use of your version of this file
25 only under the terms of the GPL and not to allow others to use
26 your version of this file under the MPL, indicate your decision
27 by deleting the provisions above and replace them with the notice
28 and other provisions required by the GPL. If you do not delete
29 the provisions above, a recipient may use your version of this
30 file under either the MPL or the GPL.
32 ======================================================================*/
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/init.h>
37 #include <linux/kernel.h>
38 #include <linux/config.h>
39 #include <linux/string.h>
40 #include <linux/major.h>
41 #include <linux/errno.h>
42 #include <linux/slab.h>
43 #include <linux/mm.h>
44 #include <linux/interrupt.h>
45 #include <linux/timer.h>
46 #include <linux/ioport.h>
47 #include <linux/delay.h>
48 #include <linux/pm.h>
49 #include <linux/pci.h>
50 #include <linux/device.h>
51 #include <linux/suspend.h>
52 #include <asm/system.h>
53 #include <asm/irq.h>
55 #define IN_CARD_SERVICES
56 #include <pcmcia/version.h>
57 #include <pcmcia/cs_types.h>
58 #include <pcmcia/ss.h>
59 #include <pcmcia/cs.h>
60 #include <pcmcia/bulkmem.h>
61 #include <pcmcia/cistpl.h>
62 #include <pcmcia/cisreg.h>
63 #include "cs_internal.h"
65 #ifdef CONFIG_PCI
66 #define PCI_OPT " [pci]"
67 #else
68 #define PCI_OPT ""
69 #endif
70 #ifdef CONFIG_CARDBUS
71 #define CB_OPT " [cardbus]"
72 #else
73 #define CB_OPT ""
74 #endif
75 #ifdef CONFIG_PM
76 #define PM_OPT " [pm]"
77 #else
78 #define PM_OPT ""
79 #endif
80 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
81 #define OPTIONS " none"
82 #else
83 #define OPTIONS PCI_OPT CB_OPT PM_OPT
84 #endif
86 static const char *release = "Linux Kernel Card Services";
87 static const char *options = "options: " OPTIONS;
89 /*====================================================================*/
91 /* Module parameters */
93 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
94 MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
95 MODULE_LICENSE("Dual MPL/GPL");
97 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
99 INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
100 INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
101 INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
102 INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
103 INT_MODULE_PARM(reset_time, 10); /* usecs */
104 INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
105 INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
106 INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
108 /* Access speed for attribute memory windows */
109 INT_MODULE_PARM(cis_speed, 300); /* ns */
111 /* Access speed for IO windows */
112 INT_MODULE_PARM(io_speed, 0); /* ns */
114 #ifdef DEBUG
115 static int pc_debug;
117 module_param(pc_debug, int, 0644);
119 int cs_debug_level(int level)
121 return pc_debug > level;
123 #endif
125 /*====================================================================*/
127 socket_state_t dead_socket = {
128 .csc_mask = SS_DETECT,
132 /* List of all sockets, protected by a rwsem */
133 LIST_HEAD(pcmcia_socket_list);
134 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
137 /*====================================================================
139 Low-level PC Card interface drivers need to register with Card
140 Services using these calls.
142 ======================================================================*/
145 * socket drivers are expected to use the following callbacks in their
146 * .drv struct:
147 * - pcmcia_socket_dev_suspend
148 * - pcmcia_socket_dev_resume
149 * These functions check for the appropriate struct pcmcia_soket arrays,
150 * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
152 static int socket_resume(struct pcmcia_socket *skt);
153 static int socket_suspend(struct pcmcia_socket *skt);
155 int pcmcia_socket_dev_suspend(struct device *dev, u32 state)
157 struct pcmcia_socket *socket;
159 down_read(&pcmcia_socket_list_rwsem);
160 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
161 if (socket->dev.dev != dev)
162 continue;
163 down(&socket->skt_sem);
164 socket_suspend(socket);
165 up(&socket->skt_sem);
167 up_read(&pcmcia_socket_list_rwsem);
169 return 0;
171 EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
173 int pcmcia_socket_dev_resume(struct device *dev)
175 struct pcmcia_socket *socket;
177 down_read(&pcmcia_socket_list_rwsem);
178 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
179 if (socket->dev.dev != dev)
180 continue;
181 down(&socket->skt_sem);
182 socket_resume(socket);
183 up(&socket->skt_sem);
185 up_read(&pcmcia_socket_list_rwsem);
187 return 0;
189 EXPORT_SYMBOL(pcmcia_socket_dev_resume);
192 static void pcmcia_release_socket(struct class_device *class_dev)
194 struct pcmcia_socket *socket = class_get_devdata(class_dev);
195 client_t *client;
197 while (socket->clients) {
198 client = socket->clients;
199 socket->clients = socket->clients->next;
200 kfree(client);
203 complete(&socket->socket_released);
206 static int pccardd(void *__skt);
209 * pcmcia_register_socket - add a new pcmcia socket device
211 int pcmcia_register_socket(struct pcmcia_socket *socket)
213 int ret;
215 if (!socket || !socket->ops || !socket->dev.dev)
216 return -EINVAL;
218 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
220 /* try to obtain a socket number [yes, it gets ugly if we
221 * register more than 2^sizeof(unsigned int) pcmcia
222 * sockets... but the socket number is deprecated
223 * anyways, so I don't care] */
224 down_write(&pcmcia_socket_list_rwsem);
225 if (list_empty(&pcmcia_socket_list))
226 socket->sock = 0;
227 else {
228 unsigned int found, i = 1;
229 struct pcmcia_socket *tmp;
230 do {
231 found = 1;
232 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
233 if (tmp->sock == i)
234 found = 0;
236 i++;
237 } while (!found);
238 socket->sock = i - 1;
240 list_add_tail(&socket->socket_list, &pcmcia_socket_list);
241 up_write(&pcmcia_socket_list_rwsem);
244 /* set proper values in socket->dev */
245 socket->dev.class_data = socket;
246 socket->dev.class = &pcmcia_socket_class;
247 snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
249 /* base address = 0, map = 0 */
250 socket->cis_mem.flags = 0;
251 socket->cis_mem.speed = cis_speed;
252 socket->erase_busy.next = socket->erase_busy.prev = &socket->erase_busy;
253 INIT_LIST_HEAD(&socket->cis_cache);
254 spin_lock_init(&socket->lock);
256 init_completion(&socket->socket_released);
257 init_completion(&socket->thread_done);
258 init_waitqueue_head(&socket->thread_wait);
259 init_MUTEX(&socket->skt_sem);
260 spin_lock_init(&socket->thread_lock);
262 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
263 if (ret < 0)
264 goto err;
266 wait_for_completion(&socket->thread_done);
267 if(!socket->thread) {
268 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
269 return -EIO;
271 pcmcia_parse_events(socket, SS_DETECT);
273 return 0;
275 err:
276 down_write(&pcmcia_socket_list_rwsem);
277 list_del(&socket->socket_list);
278 up_write(&pcmcia_socket_list_rwsem);
279 return ret;
280 } /* pcmcia_register_socket */
281 EXPORT_SYMBOL(pcmcia_register_socket);
285 * pcmcia_unregister_socket - remove a pcmcia socket device
287 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
289 if (!socket)
290 return;
292 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
294 if (socket->thread) {
295 init_completion(&socket->thread_done);
296 socket->thread = NULL;
297 wake_up(&socket->thread_wait);
298 wait_for_completion(&socket->thread_done);
300 release_cis_mem(socket);
302 /* remove from our own list */
303 down_write(&pcmcia_socket_list_rwsem);
304 list_del(&socket->socket_list);
305 up_write(&pcmcia_socket_list_rwsem);
307 /* wait for sysfs to drop all references */
308 wait_for_completion(&socket->socket_released);
309 } /* pcmcia_unregister_socket */
310 EXPORT_SYMBOL(pcmcia_unregister_socket);
313 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
315 struct pcmcia_socket *s;
317 down_read(&pcmcia_socket_list_rwsem);
318 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
319 if (s->sock == nr) {
320 up_read(&pcmcia_socket_list_rwsem);
321 return s;
323 up_read(&pcmcia_socket_list_rwsem);
325 return NULL;
328 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
331 /*======================================================================
333 Shutdown_Socket() and setup_socket() are scheduled using add_timer
334 calls by the main event handler when card insertion and removal
335 events are received. Shutdown_Socket() unconfigures a socket and
336 turns off socket power. Setup_socket() turns on socket power
337 and resets the socket, in two stages.
339 ======================================================================*/
341 static void free_regions(memory_handle_t *list)
343 memory_handle_t tmp;
344 while (*list != NULL) {
345 tmp = *list;
346 *list = tmp->info.next;
347 tmp->region_magic = 0;
348 kfree(tmp);
352 static int send_event(struct pcmcia_socket *s, event_t event, int priority);
354 static void shutdown_socket(struct pcmcia_socket *s)
356 client_t **c;
358 cs_dbg(s, 1, "shutdown_socket\n");
360 /* Blank out the socket state */
361 s->socket = dead_socket;
362 s->ops->init(s);
363 s->ops->set_socket(s, &s->socket);
364 s->irq.AssignedIRQ = s->irq.Config = 0;
365 s->lock_count = 0;
366 destroy_cis_cache(s);
367 if (s->fake_cis) {
368 kfree(s->fake_cis);
369 s->fake_cis = NULL;
371 #ifdef CONFIG_CARDBUS
372 cb_free(s);
373 #endif
374 s->functions = 0;
375 if (s->config) {
376 kfree(s->config);
377 s->config = NULL;
379 for (c = &s->clients; *c; ) {
380 if ((*c)->state & CLIENT_UNBOUND) {
381 client_t *d = *c;
382 *c = (*c)->next;
383 kfree(d);
384 } else {
385 c = &((*c)->next);
388 free_regions(&s->a_region);
389 free_regions(&s->c_region);
392 int status;
393 s->ops->get_status(s, &status);
394 if (status & SS_POWERON) {
395 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
398 } /* shutdown_socket */
400 /*======================================================================
402 The central event handler. Send_event() sends an event to all
403 valid clients. Parse_events() interprets the event bits from
404 a card status change report. Do_shutdown() handles the high
405 priority stuff associated with a card removal.
407 ======================================================================*/
409 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
411 client_t *client = s->clients;
412 int ret;
413 cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
414 event, priority);
415 ret = 0;
416 if (s->state & SOCKET_CARDBUS)
417 return 0;
418 for (; client; client = client->next) {
419 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
420 continue;
421 if (client->EventMask & event) {
422 ret = EVENT(client, event, priority);
423 if (ret != 0)
424 return ret;
427 return ret;
428 } /* send_event */
430 static void socket_remove_drivers(struct pcmcia_socket *skt)
432 client_t *client;
434 cs_dbg(skt, 4, "remove_drivers\n");
436 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
438 for (client = skt->clients; client; client = client->next)
439 if (!(client->Attributes & INFO_MASTER_CLIENT))
440 client->state |= CLIENT_STALE;
443 static void socket_shutdown(struct pcmcia_socket *skt)
445 cs_dbg(skt, 4, "shutdown\n");
447 socket_remove_drivers(skt);
448 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
449 msleep(shutdown_delay * 10);
450 skt->state &= SOCKET_INUSE;
451 shutdown_socket(skt);
454 static int socket_reset(struct pcmcia_socket *skt)
456 int status, i;
458 cs_dbg(skt, 4, "reset\n");
460 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
461 skt->ops->set_socket(skt, &skt->socket);
462 udelay((long)reset_time);
464 skt->socket.flags &= ~SS_RESET;
465 skt->ops->set_socket(skt, &skt->socket);
467 msleep(unreset_delay * 10);
468 for (i = 0; i < unreset_limit; i++) {
469 skt->ops->get_status(skt, &status);
471 if (!(status & SS_DETECT))
472 return CS_NO_CARD;
474 if (status & SS_READY)
475 return CS_SUCCESS;
477 msleep(unreset_check * 10);
480 cs_err(skt, "time out after reset.\n");
481 return CS_GENERAL_FAILURE;
484 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
486 int status, i;
488 cs_dbg(skt, 4, "setup\n");
490 skt->ops->get_status(skt, &status);
491 if (!(status & SS_DETECT))
492 return CS_NO_CARD;
494 msleep(initial_delay * 10);
496 for (i = 0; i < 100; i++) {
497 skt->ops->get_status(skt, &status);
498 if (!(status & SS_DETECT))
499 return CS_NO_CARD;
501 if (!(status & SS_PENDING))
502 break;
504 msleep(100);
507 if (status & SS_PENDING) {
508 cs_err(skt, "voltage interrogation timed out.\n");
509 return CS_GENERAL_FAILURE;
512 if (status & SS_CARDBUS) {
513 skt->state |= SOCKET_CARDBUS;
514 #ifndef CONFIG_CARDBUS
515 cs_err(skt, "cardbus cards are not supported.\n");
516 return CS_BAD_TYPE;
517 #endif
521 * Decode the card voltage requirements, and apply power to the card.
523 if (status & SS_3VCARD)
524 skt->socket.Vcc = skt->socket.Vpp = 33;
525 else if (!(status & SS_XVCARD))
526 skt->socket.Vcc = skt->socket.Vpp = 50;
527 else {
528 cs_err(skt, "unsupported voltage key.\n");
529 return CS_BAD_TYPE;
531 skt->socket.flags = 0;
532 skt->ops->set_socket(skt, &skt->socket);
535 * Wait "vcc_settle" for the supply to stabilise.
537 msleep(vcc_settle * 10);
539 skt->ops->get_status(skt, &status);
540 if (!(status & SS_POWERON)) {
541 cs_err(skt, "unable to apply power.\n");
542 return CS_BAD_TYPE;
545 return socket_reset(skt);
549 * Handle card insertion. Setup the socket, reset the card,
550 * and then tell the rest of PCMCIA that a card is present.
552 static int socket_insert(struct pcmcia_socket *skt)
554 int ret;
556 cs_dbg(skt, 4, "insert\n");
558 if (!cs_socket_get(skt))
559 return CS_NO_CARD;
561 ret = socket_setup(skt, setup_delay);
562 if (ret == CS_SUCCESS) {
563 skt->state |= SOCKET_PRESENT;
564 #ifdef CONFIG_CARDBUS
565 if (skt->state & SOCKET_CARDBUS) {
566 cb_alloc(skt);
567 skt->state |= SOCKET_CARDBUS_CONFIG;
569 #endif
570 cs_dbg(skt, 4, "insert done\n");
572 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
573 } else {
574 socket_shutdown(skt);
575 cs_socket_put(skt);
578 return ret;
581 static int socket_suspend(struct pcmcia_socket *skt)
583 if (skt->state & SOCKET_SUSPEND)
584 return CS_IN_USE;
586 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
587 skt->socket = dead_socket;
588 skt->ops->suspend(skt);
589 skt->state |= SOCKET_SUSPEND;
591 return CS_SUCCESS;
595 * Resume a socket. If a card is present, verify its CIS against
596 * our cached copy. If they are different, the card has been
597 * replaced, and we need to tell the drivers.
599 static int socket_resume(struct pcmcia_socket *skt)
601 int ret;
603 if (!(skt->state & SOCKET_SUSPEND))
604 return CS_IN_USE;
606 skt->socket = dead_socket;
607 skt->ops->init(skt);
608 skt->ops->set_socket(skt, &skt->socket);
610 ret = socket_setup(skt, resume_delay);
611 if (ret == CS_SUCCESS) {
613 * FIXME: need a better check here for cardbus cards.
615 if (verify_cis_cache(skt) != 0) {
616 socket_remove_drivers(skt);
617 destroy_cis_cache(skt);
618 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
619 } else {
620 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
622 } else {
623 socket_shutdown(skt);
624 cs_socket_put(skt);
627 skt->state &= ~SOCKET_SUSPEND;
629 return CS_SUCCESS;
632 static void socket_remove(struct pcmcia_socket *skt)
634 socket_shutdown(skt);
635 cs_socket_put(skt);
639 * Process a socket card detect status change.
641 * If we don't have a card already present, delay the detect event for
642 * about 20ms (to be on the safe side) before reading the socket status.
644 * Some i82365-based systems send multiple SS_DETECT events during card
645 * insertion, and the "card present" status bit seems to bounce. This
646 * will probably be true with GPIO-based card detection systems after
647 * the product has aged.
649 static void socket_detect_change(struct pcmcia_socket *skt)
651 if (!(skt->state & SOCKET_SUSPEND)) {
652 int status;
654 if (!(skt->state & SOCKET_PRESENT))
655 msleep(20);
657 skt->ops->get_status(skt, &status);
658 if ((skt->state & SOCKET_PRESENT) &&
659 !(status & SS_DETECT))
660 socket_remove(skt);
661 if (!(skt->state & SOCKET_PRESENT) &&
662 (status & SS_DETECT))
663 socket_insert(skt);
667 static int pccardd(void *__skt)
669 struct pcmcia_socket *skt = __skt;
670 DECLARE_WAITQUEUE(wait, current);
671 int ret;
673 daemonize("pccardd");
675 skt->thread = current;
676 skt->socket = dead_socket;
677 skt->ops->init(skt);
678 skt->ops->set_socket(skt, &skt->socket);
680 /* register with the device core */
681 ret = class_device_register(&skt->dev);
682 if (ret) {
683 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
684 skt);
685 skt->thread = NULL;
686 complete_and_exit(&skt->thread_done, 0);
688 complete(&skt->thread_done);
690 add_wait_queue(&skt->thread_wait, &wait);
691 for (;;) {
692 unsigned long flags;
693 unsigned int events;
695 set_current_state(TASK_INTERRUPTIBLE);
697 spin_lock_irqsave(&skt->thread_lock, flags);
698 events = skt->thread_events;
699 skt->thread_events = 0;
700 spin_unlock_irqrestore(&skt->thread_lock, flags);
702 if (events) {
703 down(&skt->skt_sem);
704 if (events & SS_DETECT)
705 socket_detect_change(skt);
706 if (events & SS_BATDEAD)
707 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
708 if (events & SS_BATWARN)
709 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
710 if (events & SS_READY)
711 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
712 up(&skt->skt_sem);
713 continue;
716 schedule();
717 if (current->flags & PF_FREEZE)
718 refrigerator(PF_FREEZE);
720 if (!skt->thread)
721 break;
723 remove_wait_queue(&skt->thread_wait, &wait);
725 /* remove from the device core */
726 class_device_unregister(&skt->dev);
728 complete_and_exit(&skt->thread_done, 0);
732 * Yenta (at least) probes interrupts before registering the socket and
733 * starting the handler thread.
735 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
737 cs_dbg(s, 4, "parse_events: events %08x\n", events);
738 if (s->thread) {
739 spin_lock(&s->thread_lock);
740 s->thread_events |= events;
741 spin_unlock(&s->thread_lock);
743 wake_up(&s->thread_wait);
745 } /* pcmcia_parse_events */
748 /*======================================================================
750 Special stuff for managing IO windows, because they are scarce.
752 ======================================================================*/
754 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
755 ioaddr_t num, u_int lines, char *name)
757 int i;
758 ioaddr_t try, align;
760 align = (*base) ? (lines ? 1<<lines : 0) : 1;
761 if (align && (align < num)) {
762 if (*base) {
763 cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
764 num, align);
765 align = 0;
766 } else
767 while (align && (align < num)) align <<= 1;
769 if (*base & ~(align-1)) {
770 cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
771 *base, align);
772 align = 0;
774 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
775 *base = s->io_offset | (*base & 0x0fff);
776 return 0;
778 /* Check for an already-allocated window that must conflict with
779 what was asked for. It is a hack because it does not catch all
780 potential conflicts, just the most obvious ones. */
781 for (i = 0; i < MAX_IO_WIN; i++)
782 if ((s->io[i].NumPorts != 0) &&
783 ((s->io[i].BasePort & (align-1)) == *base))
784 return 1;
785 for (i = 0; i < MAX_IO_WIN; i++) {
786 if (s->io[i].NumPorts == 0) {
787 s->io[i].res = find_io_region(*base, num, align, name, s);
788 if (s->io[i].res) {
789 s->io[i].Attributes = attr;
790 s->io[i].BasePort = *base = s->io[i].res->start;
791 s->io[i].NumPorts = s->io[i].InUse = num;
792 break;
793 } else
794 return 1;
795 } else if (s->io[i].Attributes != attr)
796 continue;
797 /* Try to extend top of window */
798 try = s->io[i].BasePort + s->io[i].NumPorts;
799 if ((*base == 0) || (*base == try))
800 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
801 s->io[i].res->end + num, s) == 0) {
802 *base = try;
803 s->io[i].NumPorts += num;
804 s->io[i].InUse += num;
805 break;
807 /* Try to extend bottom of window */
808 try = s->io[i].BasePort - num;
809 if ((*base == 0) || (*base == try))
810 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
811 s->io[i].res->end, s) == 0) {
812 s->io[i].BasePort = *base = try;
813 s->io[i].NumPorts += num;
814 s->io[i].InUse += num;
815 break;
818 return (i == MAX_IO_WIN);
819 } /* alloc_io_space */
821 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
822 ioaddr_t num)
824 int i;
826 for (i = 0; i < MAX_IO_WIN; i++) {
827 if ((s->io[i].BasePort <= base) &&
828 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
829 s->io[i].InUse -= num;
830 /* Free the window if no one else is using it */
831 if (s->io[i].InUse == 0) {
832 s->io[i].NumPorts = 0;
833 release_resource(s->io[i].res);
834 kfree(s->io[i].res);
835 s->io[i].res = NULL;
841 /*======================================================================
843 Access_configuration_register() reads and writes configuration
844 registers in attribute memory. Memory window 0 is reserved for
845 this and the tuple reading services.
847 ======================================================================*/
849 int pcmcia_access_configuration_register(client_handle_t handle,
850 conf_reg_t *reg)
852 struct pcmcia_socket *s;
853 config_t *c;
854 int addr;
855 u_char val;
857 if (CHECK_HANDLE(handle))
858 return CS_BAD_HANDLE;
859 s = SOCKET(handle);
860 if (handle->Function == BIND_FN_ALL) {
861 if (reg->Function >= s->functions)
862 return CS_BAD_ARGS;
863 c = &s->config[reg->Function];
864 } else
865 c = CONFIG(handle);
867 if (c == NULL)
868 return CS_NO_CARD;
870 if (!(c->state & CONFIG_LOCKED))
871 return CS_CONFIGURATION_LOCKED;
873 addr = (c->ConfigBase + reg->Offset) >> 1;
875 switch (reg->Action) {
876 case CS_READ:
877 read_cis_mem(s, 1, addr, 1, &val);
878 reg->Value = val;
879 break;
880 case CS_WRITE:
881 val = reg->Value;
882 write_cis_mem(s, 1, addr, 1, &val);
883 break;
884 default:
885 return CS_BAD_ARGS;
886 break;
888 return CS_SUCCESS;
889 } /* access_configuration_register */
892 /*====================================================================*/
894 int pcmcia_deregister_client(client_handle_t handle)
896 client_t **client;
897 struct pcmcia_socket *s;
898 memory_handle_t region;
899 u_long flags;
900 int i;
902 if (CHECK_HANDLE(handle))
903 return CS_BAD_HANDLE;
905 s = SOCKET(handle);
906 cs_dbg(s, 1, "deregister_client(%p)\n", handle);
908 if (handle->state &
909 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
910 return CS_IN_USE;
911 for (i = 0; i < MAX_WIN; i++)
912 if (handle->state & CLIENT_WIN_REQ(i))
913 return CS_IN_USE;
915 /* Disconnect all MTD links */
916 if (handle->mtd_count) {
917 for (region = s->a_region; region; region = region->info.next)
918 if (region->mtd == handle) region->mtd = NULL;
919 for (region = s->c_region; region; region = region->info.next)
920 if (region->mtd == handle) region->mtd = NULL;
923 if ((handle->state & CLIENT_STALE) ||
924 (handle->Attributes & INFO_MASTER_CLIENT)) {
925 spin_lock_irqsave(&s->lock, flags);
926 client = &s->clients;
927 while ((*client) && ((*client) != handle))
928 client = &(*client)->next;
929 if (*client == NULL) {
930 spin_unlock_irqrestore(&s->lock, flags);
931 return CS_BAD_HANDLE;
933 *client = handle->next;
934 handle->client_magic = 0;
935 kfree(handle);
936 spin_unlock_irqrestore(&s->lock, flags);
937 } else {
938 handle->state = CLIENT_UNBOUND;
939 handle->mtd_count = 0;
940 handle->event_handler = NULL;
943 return CS_SUCCESS;
944 } /* deregister_client */
946 /*====================================================================*/
948 int pcmcia_get_configuration_info(client_handle_t handle,
949 config_info_t *config)
951 struct pcmcia_socket *s;
952 config_t *c;
954 if (CHECK_HANDLE(handle))
955 return CS_BAD_HANDLE;
956 s = SOCKET(handle);
957 if (!(s->state & SOCKET_PRESENT))
958 return CS_NO_CARD;
960 if (handle->Function == BIND_FN_ALL) {
961 if (config->Function && (config->Function >= s->functions))
962 return CS_BAD_ARGS;
963 } else
964 config->Function = handle->Function;
966 #ifdef CONFIG_CARDBUS
967 if (s->state & SOCKET_CARDBUS) {
968 u_char fn = config->Function;
969 memset(config, 0, sizeof(config_info_t));
970 config->Function = fn;
971 config->Vcc = s->socket.Vcc;
972 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
973 config->Option = s->cb_dev->subordinate->number;
974 if (s->state & SOCKET_CARDBUS_CONFIG) {
975 config->Attributes = CONF_VALID_CLIENT;
976 config->IntType = INT_CARDBUS;
977 config->AssignedIRQ = s->irq.AssignedIRQ;
978 if (config->AssignedIRQ)
979 config->Attributes |= CONF_ENABLE_IRQ;
980 config->BasePort1 = s->io[0].BasePort;
981 config->NumPorts1 = s->io[0].NumPorts;
983 return CS_SUCCESS;
985 #endif
987 c = (s->config != NULL) ? &s->config[config->Function] : NULL;
989 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
990 config->Attributes = 0;
991 config->Vcc = s->socket.Vcc;
992 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
993 return CS_SUCCESS;
996 /* !!! This is a hack !!! */
997 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
998 config->Attributes |= CONF_VALID_CLIENT;
999 config->CardValues = c->CardValues;
1000 config->IRQAttributes = c->irq.Attributes;
1001 config->AssignedIRQ = s->irq.AssignedIRQ;
1002 config->BasePort1 = c->io.BasePort1;
1003 config->NumPorts1 = c->io.NumPorts1;
1004 config->Attributes1 = c->io.Attributes1;
1005 config->BasePort2 = c->io.BasePort2;
1006 config->NumPorts2 = c->io.NumPorts2;
1007 config->Attributes2 = c->io.Attributes2;
1008 config->IOAddrLines = c->io.IOAddrLines;
1010 return CS_SUCCESS;
1011 } /* get_configuration_info */
1013 /*======================================================================
1015 Return information about this version of Card Services.
1017 ======================================================================*/
1019 int pcmcia_get_card_services_info(servinfo_t *info)
1021 unsigned int socket_count = 0;
1022 struct list_head *tmp;
1023 info->Signature[0] = 'C';
1024 info->Signature[1] = 'S';
1025 down_read(&pcmcia_socket_list_rwsem);
1026 list_for_each(tmp, &pcmcia_socket_list)
1027 socket_count++;
1028 up_read(&pcmcia_socket_list_rwsem);
1029 info->Count = socket_count;
1030 info->Revision = CS_RELEASE_CODE;
1031 info->CSLevel = 0x0210;
1032 info->VendorString = (char *)release;
1033 return CS_SUCCESS;
1034 } /* get_card_services_info */
1036 /*======================================================================
1038 Note that get_first_client() *does* recognize the Socket field
1039 in the request structure.
1041 ======================================================================*/
1043 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1045 socket_t s;
1046 struct pcmcia_socket *socket;
1047 if (req->Attributes & CLIENT_THIS_SOCKET)
1048 s = req->Socket;
1049 else
1050 s = 0;
1051 socket = pcmcia_get_socket_by_nr(s);
1052 if (!socket)
1053 return CS_BAD_SOCKET;
1054 if (socket->clients == NULL)
1055 return CS_NO_MORE_ITEMS;
1056 *handle = socket->clients;
1057 return CS_SUCCESS;
1058 } /* get_first_client */
1060 /*====================================================================*/
1062 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1064 struct pcmcia_socket *s;
1065 if ((handle == NULL) || CHECK_HANDLE(*handle))
1066 return CS_BAD_HANDLE;
1067 if ((*handle)->next == NULL) {
1068 if (req->Attributes & CLIENT_THIS_SOCKET)
1069 return CS_NO_MORE_ITEMS;
1070 s = (*handle)->Socket;
1071 if (s->clients == NULL)
1072 return CS_NO_MORE_ITEMS;
1073 *handle = s->clients;
1074 } else
1075 *handle = (*handle)->next;
1076 return CS_SUCCESS;
1077 } /* get_next_client */
1079 /*====================================================================*/
1081 int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req)
1083 struct pcmcia_socket *s;
1084 window_t *win;
1085 int w;
1087 if (idx == 0)
1088 s = ((client_handle_t)*handle)->Socket;
1089 else
1090 s = (*handle)->sock;
1091 if (!(s->state & SOCKET_PRESENT))
1092 return CS_NO_CARD;
1093 for (w = idx; w < MAX_WIN; w++)
1094 if (s->state & SOCKET_WIN_REQ(w)) break;
1095 if (w == MAX_WIN)
1096 return CS_NO_MORE_ITEMS;
1097 win = &s->win[w];
1098 req->Base = win->ctl.res->start;
1099 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
1100 req->AccessSpeed = win->ctl.speed;
1101 req->Attributes = 0;
1102 if (win->ctl.flags & MAP_ATTRIB)
1103 req->Attributes |= WIN_MEMORY_TYPE_AM;
1104 if (win->ctl.flags & MAP_ACTIVE)
1105 req->Attributes |= WIN_ENABLE;
1106 if (win->ctl.flags & MAP_16BIT)
1107 req->Attributes |= WIN_DATA_WIDTH_16;
1108 if (win->ctl.flags & MAP_USE_WAIT)
1109 req->Attributes |= WIN_USE_WAIT;
1110 *handle = win;
1111 return CS_SUCCESS;
1112 } /* get_window */
1114 int pcmcia_get_first_window(window_handle_t *win, win_req_t *req)
1116 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1117 return CS_BAD_HANDLE;
1118 return pcmcia_get_window(win, 0, req);
1121 int pcmcia_get_next_window(window_handle_t *win, win_req_t *req)
1123 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1124 return CS_BAD_HANDLE;
1125 return pcmcia_get_window(win, (*win)->index+1, req);
1128 /*=====================================================================
1130 Return the PCI device associated with a card..
1132 ======================================================================*/
1134 #ifdef CONFIG_CARDBUS
1136 struct pci_bus *pcmcia_lookup_bus(client_handle_t handle)
1138 struct pcmcia_socket *s;
1140 if (CHECK_HANDLE(handle))
1141 return NULL;
1142 s = SOCKET(handle);
1143 if (!(s->state & SOCKET_CARDBUS))
1144 return NULL;
1146 return s->cb_dev->subordinate;
1149 EXPORT_SYMBOL(pcmcia_lookup_bus);
1151 #endif
1153 /*======================================================================
1155 Get the current socket state bits. We don't support the latched
1156 SocketState yet: I haven't seen any point for it.
1158 ======================================================================*/
1160 int pcmcia_get_status(client_handle_t handle, cs_status_t *status)
1162 struct pcmcia_socket *s;
1163 config_t *c;
1164 int val;
1166 if (CHECK_HANDLE(handle))
1167 return CS_BAD_HANDLE;
1168 s = SOCKET(handle);
1169 s->ops->get_status(s, &val);
1170 status->CardState = status->SocketState = 0;
1171 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1172 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1173 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1174 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1175 if (s->state & SOCKET_SUSPEND)
1176 status->CardState |= CS_EVENT_PM_SUSPEND;
1177 if (!(s->state & SOCKET_PRESENT))
1178 return CS_NO_CARD;
1180 /* Get info from the PRR, if necessary */
1181 if (handle->Function == BIND_FN_ALL) {
1182 if (status->Function && (status->Function >= s->functions))
1183 return CS_BAD_ARGS;
1184 c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1185 } else
1186 c = CONFIG(handle);
1187 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1188 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1189 u_char reg;
1190 if (c->Present & PRESENT_PIN_REPLACE) {
1191 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
1192 status->CardState |=
1193 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1194 status->CardState |=
1195 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1196 status->CardState |=
1197 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1198 status->CardState |=
1199 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1200 } else {
1201 /* No PRR? Then assume we're always ready */
1202 status->CardState |= CS_EVENT_READY_CHANGE;
1204 if (c->Present & PRESENT_EXT_STATUS) {
1205 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
1206 status->CardState |=
1207 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1209 return CS_SUCCESS;
1211 status->CardState |=
1212 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1213 status->CardState |=
1214 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1215 status->CardState |=
1216 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1217 status->CardState |=
1218 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1219 return CS_SUCCESS;
1220 } /* get_status */
1222 /*======================================================================
1224 Change the card address of an already open memory window.
1226 ======================================================================*/
1228 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1230 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1231 return CS_BAD_HANDLE;
1232 req->Page = 0;
1233 req->CardOffset = win->ctl.card_start;
1234 return CS_SUCCESS;
1235 } /* get_mem_page */
1237 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1239 struct pcmcia_socket *s;
1240 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1241 return CS_BAD_HANDLE;
1242 if (req->Page != 0)
1243 return CS_BAD_PAGE;
1244 s = win->sock;
1245 win->ctl.card_start = req->CardOffset;
1246 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1247 return CS_BAD_OFFSET;
1248 return CS_SUCCESS;
1249 } /* map_mem_page */
1251 /*======================================================================
1253 Modify a locked socket configuration
1255 ======================================================================*/
1257 int pcmcia_modify_configuration(client_handle_t handle,
1258 modconf_t *mod)
1260 struct pcmcia_socket *s;
1261 config_t *c;
1263 if (CHECK_HANDLE(handle))
1264 return CS_BAD_HANDLE;
1265 s = SOCKET(handle); c = CONFIG(handle);
1266 if (!(s->state & SOCKET_PRESENT))
1267 return CS_NO_CARD;
1268 if (!(c->state & CONFIG_LOCKED))
1269 return CS_CONFIGURATION_LOCKED;
1271 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1272 if (mod->Attributes & CONF_ENABLE_IRQ) {
1273 c->Attributes |= CONF_ENABLE_IRQ;
1274 s->socket.io_irq = s->irq.AssignedIRQ;
1275 } else {
1276 c->Attributes &= ~CONF_ENABLE_IRQ;
1277 s->socket.io_irq = 0;
1279 s->ops->set_socket(s, &s->socket);
1282 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1283 return CS_BAD_VCC;
1285 /* We only allow changing Vpp1 and Vpp2 to the same value */
1286 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1287 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1288 if (mod->Vpp1 != mod->Vpp2)
1289 return CS_BAD_VPP;
1290 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1291 if (s->ops->set_socket(s, &s->socket))
1292 return CS_BAD_VPP;
1293 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1294 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1295 return CS_BAD_VPP;
1297 return CS_SUCCESS;
1298 } /* modify_configuration */
1300 /*======================================================================
1302 Modify the attributes of a window returned by RequestWindow.
1304 ======================================================================*/
1306 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1308 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1309 return CS_BAD_HANDLE;
1311 win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1312 if (req->Attributes & WIN_MEMORY_TYPE)
1313 win->ctl.flags |= MAP_ATTRIB;
1314 if (req->Attributes & WIN_ENABLE)
1315 win->ctl.flags |= MAP_ACTIVE;
1316 if (req->Attributes & WIN_DATA_WIDTH_16)
1317 win->ctl.flags |= MAP_16BIT;
1318 if (req->Attributes & WIN_USE_WAIT)
1319 win->ctl.flags |= MAP_USE_WAIT;
1320 win->ctl.speed = req->AccessSpeed;
1321 win->sock->ops->set_mem_map(win->sock, &win->ctl);
1323 return CS_SUCCESS;
1324 } /* modify_window */
1326 /*======================================================================
1328 Register_client() uses the dev_info_t handle to match the
1329 caller with a socket. The driver must have already been bound
1330 to a socket with bind_device() -- in fact, bind_device()
1331 allocates the client structure that will be used.
1333 ======================================================================*/
1335 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1337 client_t *client = NULL;
1338 struct pcmcia_socket *s;
1340 /* Look for unbound client with matching dev_info */
1341 down_read(&pcmcia_socket_list_rwsem);
1342 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1343 client = s->clients;
1344 while (client != NULL) {
1345 if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1346 && (client->state & CLIENT_UNBOUND)) break;
1347 client = client->next;
1349 if (client != NULL) break;
1351 up_read(&pcmcia_socket_list_rwsem);
1352 if (client == NULL)
1353 return CS_OUT_OF_RESOURCE;
1356 * Prevent this racing with a card insertion.
1358 down(&s->skt_sem);
1359 *handle = client;
1360 client->state &= ~CLIENT_UNBOUND;
1361 client->Socket = s;
1362 client->Attributes = req->Attributes;
1363 client->EventMask = req->EventMask;
1364 client->event_handler = req->event_handler;
1365 client->event_callback_args = req->event_callback_args;
1366 client->event_callback_args.client_handle = client;
1368 if (s->state & SOCKET_CARDBUS)
1369 client->state |= CLIENT_CARDBUS;
1371 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1372 (client->Function != BIND_FN_ALL)) {
1373 cistpl_longlink_mfc_t mfc;
1374 if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc)
1375 == CS_SUCCESS)
1376 s->functions = mfc.nfn;
1377 else
1378 s->functions = 1;
1379 s->config = kmalloc(sizeof(config_t) * s->functions,
1380 GFP_KERNEL);
1381 if (!s->config)
1382 goto out_no_resource;
1383 memset(s->config, 0, sizeof(config_t) * s->functions);
1386 cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1387 client, client->dev_info);
1388 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1389 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1391 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1392 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1393 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1394 else
1395 client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1398 up(&s->skt_sem);
1399 return CS_SUCCESS;
1401 out_no_resource:
1402 up(&s->skt_sem);
1403 return CS_OUT_OF_RESOURCE;
1404 } /* register_client */
1406 /*====================================================================*/
1408 int pcmcia_release_configuration(client_handle_t handle)
1410 pccard_io_map io = { 0, 0, 0, 0, 1 };
1411 struct pcmcia_socket *s;
1412 int i;
1414 if (CHECK_HANDLE(handle) ||
1415 !(handle->state & CLIENT_CONFIG_LOCKED))
1416 return CS_BAD_HANDLE;
1417 handle->state &= ~CLIENT_CONFIG_LOCKED;
1418 s = SOCKET(handle);
1420 #ifdef CONFIG_CARDBUS
1421 if (handle->state & CLIENT_CARDBUS)
1422 return CS_SUCCESS;
1423 #endif
1425 if (!(handle->state & CLIENT_STALE)) {
1426 config_t *c = CONFIG(handle);
1427 if (--(s->lock_count) == 0) {
1428 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1429 s->socket.Vpp = 0;
1430 s->socket.io_irq = 0;
1431 s->ops->set_socket(s, &s->socket);
1433 if (c->state & CONFIG_IO_REQ)
1434 for (i = 0; i < MAX_IO_WIN; i++) {
1435 if (s->io[i].NumPorts == 0)
1436 continue;
1437 s->io[i].Config--;
1438 if (s->io[i].Config != 0)
1439 continue;
1440 io.map = i;
1441 s->ops->set_io_map(s, &io);
1443 c->state &= ~CONFIG_LOCKED;
1446 return CS_SUCCESS;
1447 } /* release_configuration */
1449 /*======================================================================
1451 Release_io() releases the I/O ranges allocated by a client. This
1452 may be invoked some time after a card ejection has already dumped
1453 the actual socket configuration, so if the client is "stale", we
1454 don't bother checking the port ranges against the current socket
1455 values.
1457 ======================================================================*/
1459 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1461 struct pcmcia_socket *s;
1463 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1464 return CS_BAD_HANDLE;
1465 handle->state &= ~CLIENT_IO_REQ;
1466 s = SOCKET(handle);
1468 #ifdef CONFIG_CARDBUS
1469 if (handle->state & CLIENT_CARDBUS)
1470 return CS_SUCCESS;
1471 #endif
1473 if (!(handle->state & CLIENT_STALE)) {
1474 config_t *c = CONFIG(handle);
1475 if (c->state & CONFIG_LOCKED)
1476 return CS_CONFIGURATION_LOCKED;
1477 if ((c->io.BasePort1 != req->BasePort1) ||
1478 (c->io.NumPorts1 != req->NumPorts1) ||
1479 (c->io.BasePort2 != req->BasePort2) ||
1480 (c->io.NumPorts2 != req->NumPorts2))
1481 return CS_BAD_ARGS;
1482 c->state &= ~CONFIG_IO_REQ;
1485 release_io_space(s, req->BasePort1, req->NumPorts1);
1486 if (req->NumPorts2)
1487 release_io_space(s, req->BasePort2, req->NumPorts2);
1489 return CS_SUCCESS;
1490 } /* release_io */
1492 /*====================================================================*/
1494 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1496 struct pcmcia_socket *s;
1497 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1498 return CS_BAD_HANDLE;
1499 handle->state &= ~CLIENT_IRQ_REQ;
1500 s = SOCKET(handle);
1502 if (!(handle->state & CLIENT_STALE)) {
1503 config_t *c = CONFIG(handle);
1504 if (c->state & CONFIG_LOCKED)
1505 return CS_CONFIGURATION_LOCKED;
1506 if (c->irq.Attributes != req->Attributes)
1507 return CS_BAD_ATTRIBUTE;
1508 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1509 return CS_BAD_IRQ;
1510 if (--s->irq.Config == 0) {
1511 c->state &= ~CONFIG_IRQ_REQ;
1512 s->irq.AssignedIRQ = 0;
1516 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1517 free_irq(req->AssignedIRQ, req->Instance);
1520 #ifdef CONFIG_PCMCIA_PROBE
1521 if (req->AssignedIRQ != s->pci_irq)
1522 undo_irq(req->Attributes, req->AssignedIRQ);
1523 #endif
1525 return CS_SUCCESS;
1526 } /* cs_release_irq */
1528 /*====================================================================*/
1530 int pcmcia_release_window(window_handle_t win)
1532 struct pcmcia_socket *s;
1534 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1535 return CS_BAD_HANDLE;
1536 s = win->sock;
1537 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1538 return CS_BAD_HANDLE;
1540 /* Shut down memory window */
1541 win->ctl.flags &= ~MAP_ACTIVE;
1542 s->ops->set_mem_map(s, &win->ctl);
1543 s->state &= ~SOCKET_WIN_REQ(win->index);
1545 /* Release system memory */
1546 if (win->ctl.res) {
1547 release_resource(win->ctl.res);
1548 kfree(win->ctl.res);
1549 win->ctl.res = NULL;
1551 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1553 win->magic = 0;
1555 return CS_SUCCESS;
1556 } /* release_window */
1558 /*====================================================================*/
1560 int pcmcia_request_configuration(client_handle_t handle,
1561 config_req_t *req)
1563 int i;
1564 u_int base;
1565 struct pcmcia_socket *s;
1566 config_t *c;
1567 pccard_io_map iomap;
1569 if (CHECK_HANDLE(handle))
1570 return CS_BAD_HANDLE;
1571 s = SOCKET(handle);
1572 if (!(s->state & SOCKET_PRESENT))
1573 return CS_NO_CARD;
1575 #ifdef CONFIG_CARDBUS
1576 if (handle->state & CLIENT_CARDBUS)
1577 return CS_UNSUPPORTED_MODE;
1578 #endif
1580 if (req->IntType & INT_CARDBUS)
1581 return CS_UNSUPPORTED_MODE;
1582 c = CONFIG(handle);
1583 if (c->state & CONFIG_LOCKED)
1584 return CS_CONFIGURATION_LOCKED;
1586 /* Do power control. We don't allow changes in Vcc. */
1587 if (s->socket.Vcc != req->Vcc)
1588 return CS_BAD_VCC;
1589 if (req->Vpp1 != req->Vpp2)
1590 return CS_BAD_VPP;
1591 s->socket.Vpp = req->Vpp1;
1592 if (s->ops->set_socket(s, &s->socket))
1593 return CS_BAD_VPP;
1595 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1597 /* Pick memory or I/O card, DMA mode, interrupt */
1598 c->IntType = req->IntType;
1599 c->Attributes = req->Attributes;
1600 if (req->IntType & INT_MEMORY_AND_IO)
1601 s->socket.flags |= SS_IOCARD;
1602 if (req->IntType & INT_ZOOMED_VIDEO)
1603 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1604 if (req->Attributes & CONF_ENABLE_DMA)
1605 s->socket.flags |= SS_DMA_MODE;
1606 if (req->Attributes & CONF_ENABLE_SPKR)
1607 s->socket.flags |= SS_SPKR_ENA;
1608 if (req->Attributes & CONF_ENABLE_IRQ)
1609 s->socket.io_irq = s->irq.AssignedIRQ;
1610 else
1611 s->socket.io_irq = 0;
1612 s->ops->set_socket(s, &s->socket);
1613 s->lock_count++;
1615 /* Set up CIS configuration registers */
1616 base = c->ConfigBase = req->ConfigBase;
1617 c->Present = c->CardValues = req->Present;
1618 if (req->Present & PRESENT_COPY) {
1619 c->Copy = req->Copy;
1620 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1622 if (req->Present & PRESENT_OPTION) {
1623 if (s->functions == 1) {
1624 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1625 } else {
1626 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1627 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1628 if (req->Present & PRESENT_IOBASE_0)
1629 c->Option |= COR_ADDR_DECODE;
1631 if (c->state & CONFIG_IRQ_REQ)
1632 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1633 c->Option |= COR_LEVEL_REQ;
1634 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1635 mdelay(40);
1637 if (req->Present & PRESENT_STATUS) {
1638 c->Status = req->Status;
1639 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1641 if (req->Present & PRESENT_PIN_REPLACE) {
1642 c->Pin = req->Pin;
1643 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1645 if (req->Present & PRESENT_EXT_STATUS) {
1646 c->ExtStatus = req->ExtStatus;
1647 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1649 if (req->Present & PRESENT_IOBASE_0) {
1650 u_char b = c->io.BasePort1 & 0xff;
1651 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1652 b = (c->io.BasePort1 >> 8) & 0xff;
1653 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1655 if (req->Present & PRESENT_IOSIZE) {
1656 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1657 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1660 /* Configure I/O windows */
1661 if (c->state & CONFIG_IO_REQ) {
1662 iomap.speed = io_speed;
1663 for (i = 0; i < MAX_IO_WIN; i++)
1664 if (s->io[i].NumPorts != 0) {
1665 iomap.map = i;
1666 iomap.flags = MAP_ACTIVE;
1667 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1668 case IO_DATA_PATH_WIDTH_16:
1669 iomap.flags |= MAP_16BIT; break;
1670 case IO_DATA_PATH_WIDTH_AUTO:
1671 iomap.flags |= MAP_AUTOSZ; break;
1672 default:
1673 break;
1675 iomap.start = s->io[i].BasePort;
1676 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1677 s->ops->set_io_map(s, &iomap);
1678 s->io[i].Config++;
1682 c->state |= CONFIG_LOCKED;
1683 handle->state |= CLIENT_CONFIG_LOCKED;
1684 return CS_SUCCESS;
1685 } /* request_configuration */
1687 /*======================================================================
1689 Request_io() reserves ranges of port addresses for a socket.
1690 I have not implemented range sharing or alias addressing.
1692 ======================================================================*/
1694 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1696 struct pcmcia_socket *s;
1697 config_t *c;
1699 if (CHECK_HANDLE(handle))
1700 return CS_BAD_HANDLE;
1701 s = SOCKET(handle);
1702 if (!(s->state & SOCKET_PRESENT))
1703 return CS_NO_CARD;
1705 if (handle->state & CLIENT_CARDBUS) {
1706 #ifdef CONFIG_CARDBUS
1707 handle->state |= CLIENT_IO_REQ;
1708 return CS_SUCCESS;
1709 #else
1710 return CS_UNSUPPORTED_FUNCTION;
1711 #endif
1714 if (!req)
1715 return CS_UNSUPPORTED_MODE;
1716 c = CONFIG(handle);
1717 if (c->state & CONFIG_LOCKED)
1718 return CS_CONFIGURATION_LOCKED;
1719 if (c->state & CONFIG_IO_REQ)
1720 return CS_IN_USE;
1721 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1722 return CS_BAD_ATTRIBUTE;
1723 if ((req->NumPorts2 > 0) &&
1724 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1725 return CS_BAD_ATTRIBUTE;
1727 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1728 req->NumPorts1, req->IOAddrLines,
1729 handle->dev_info))
1730 return CS_IN_USE;
1732 if (req->NumPorts2) {
1733 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1734 req->NumPorts2, req->IOAddrLines,
1735 handle->dev_info)) {
1736 release_io_space(s, req->BasePort1, req->NumPorts1);
1737 return CS_IN_USE;
1741 c->io = *req;
1742 c->state |= CONFIG_IO_REQ;
1743 handle->state |= CLIENT_IO_REQ;
1744 return CS_SUCCESS;
1745 } /* request_io */
1747 /*======================================================================
1749 Request_irq() reserves an irq for this client.
1751 Also, since Linux only reserves irq's when they are actually
1752 hooked, we don't guarantee that an irq will still be available
1753 when the configuration is locked. Now that I think about it,
1754 there might be a way to fix this using a dummy handler.
1756 ======================================================================*/
1758 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1760 struct pcmcia_socket *s;
1761 config_t *c;
1762 int ret = CS_IN_USE, irq = 0;
1764 if (CHECK_HANDLE(handle))
1765 return CS_BAD_HANDLE;
1766 s = SOCKET(handle);
1767 if (!(s->state & SOCKET_PRESENT))
1768 return CS_NO_CARD;
1769 c = CONFIG(handle);
1770 if (c->state & CONFIG_LOCKED)
1771 return CS_CONFIGURATION_LOCKED;
1772 if (c->state & CONFIG_IRQ_REQ)
1773 return CS_IN_USE;
1775 #ifdef CONFIG_PCMCIA_PROBE
1776 if (s->irq.AssignedIRQ != 0) {
1777 /* If the interrupt is already assigned, it must match */
1778 irq = s->irq.AssignedIRQ;
1779 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1780 u_int mask = req->IRQInfo2 & s->irq_mask;
1781 ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1782 } else
1783 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1784 } else {
1785 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1786 u_int try, mask = req->IRQInfo2 & s->irq_mask;
1787 for (try = 0; try < 2; try++) {
1788 for (irq = 0; irq < 32; irq++)
1789 if ((mask >> irq) & 1) {
1790 ret = try_irq(req->Attributes, irq, try);
1791 if (ret == 0) break;
1793 if (ret == 0) break;
1795 } else {
1796 irq = req->IRQInfo1 & IRQ_MASK;
1797 ret = try_irq(req->Attributes, irq, 1);
1800 #endif
1801 if (ret != 0) {
1802 if (!s->pci_irq)
1803 return ret;
1804 irq = s->pci_irq;
1807 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1808 if (request_irq(irq, req->Handler,
1809 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1810 (s->functions > 1) ||
1811 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1812 handle->dev_info, req->Instance))
1813 return CS_IN_USE;
1816 c->irq.Attributes = req->Attributes;
1817 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1818 s->irq.Config++;
1820 c->state |= CONFIG_IRQ_REQ;
1821 handle->state |= CLIENT_IRQ_REQ;
1822 return CS_SUCCESS;
1823 } /* pcmcia_request_irq */
1825 /*======================================================================
1827 Request_window() establishes a mapping between card memory space
1828 and system memory space.
1830 ======================================================================*/
1832 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1834 struct pcmcia_socket *s;
1835 window_t *win;
1836 u_long align;
1837 int w;
1839 if (CHECK_HANDLE(*handle))
1840 return CS_BAD_HANDLE;
1841 s = (*handle)->Socket;
1842 if (!(s->state & SOCKET_PRESENT))
1843 return CS_NO_CARD;
1844 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1845 return CS_BAD_ATTRIBUTE;
1847 /* Window size defaults to smallest available */
1848 if (req->Size == 0)
1849 req->Size = s->map_size;
1850 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1851 (req->Attributes & WIN_STRICT_ALIGN)) ?
1852 req->Size : s->map_size);
1853 if (req->Size & (s->map_size-1))
1854 return CS_BAD_SIZE;
1855 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1856 (req->Base & (align-1)))
1857 return CS_BAD_BASE;
1858 if (req->Base)
1859 align = 0;
1861 /* Allocate system memory window */
1862 for (w = 0; w < MAX_WIN; w++)
1863 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1864 if (w == MAX_WIN)
1865 return CS_OUT_OF_RESOURCE;
1867 win = &s->win[w];
1868 win->magic = WINDOW_MAGIC;
1869 win->index = w;
1870 win->handle = *handle;
1871 win->sock = s;
1873 if (!(s->features & SS_CAP_STATIC_MAP)) {
1874 win->ctl.res = find_mem_region(req->Base, req->Size, align,
1875 (req->Attributes & WIN_MAP_BELOW_1MB),
1876 (*handle)->dev_info, s);
1877 if (!win->ctl.res)
1878 return CS_IN_USE;
1880 (*handle)->state |= CLIENT_WIN_REQ(w);
1882 /* Configure the socket controller */
1883 win->ctl.map = w+1;
1884 win->ctl.flags = 0;
1885 win->ctl.speed = req->AccessSpeed;
1886 if (req->Attributes & WIN_MEMORY_TYPE)
1887 win->ctl.flags |= MAP_ATTRIB;
1888 if (req->Attributes & WIN_ENABLE)
1889 win->ctl.flags |= MAP_ACTIVE;
1890 if (req->Attributes & WIN_DATA_WIDTH_16)
1891 win->ctl.flags |= MAP_16BIT;
1892 if (req->Attributes & WIN_USE_WAIT)
1893 win->ctl.flags |= MAP_USE_WAIT;
1894 win->ctl.card_start = 0;
1895 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1896 return CS_BAD_ARGS;
1897 s->state |= SOCKET_WIN_REQ(w);
1899 /* Return window handle */
1900 if (s->features & SS_CAP_STATIC_MAP) {
1901 req->Base = win->ctl.static_start;
1902 } else {
1903 req->Base = win->ctl.res->start;
1905 *wh = win;
1907 return CS_SUCCESS;
1908 } /* request_window */
1910 /*======================================================================
1912 I'm not sure which "reset" function this is supposed to use,
1913 but for now, it uses the low-level interface's reset, not the
1914 CIS register.
1916 ======================================================================*/
1918 int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
1920 struct pcmcia_socket *skt;
1921 int ret;
1923 if (CHECK_HANDLE(handle))
1924 return CS_BAD_HANDLE;
1925 skt = SOCKET(handle);
1926 cs_dbg(skt, 1, "resetting socket\n");
1928 down(&skt->skt_sem);
1929 do {
1930 if (!(skt->state & SOCKET_PRESENT)) {
1931 ret = CS_NO_CARD;
1932 break;
1934 if (skt->state & SOCKET_SUSPEND) {
1935 ret = CS_IN_USE;
1936 break;
1938 if (skt->state & SOCKET_CARDBUS) {
1939 ret = CS_UNSUPPORTED_FUNCTION;
1940 break;
1943 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1944 if (ret == 0) {
1945 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1946 if (socket_reset(skt) == CS_SUCCESS)
1947 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1950 handle->event_callback_args.info = (void *)(u_long)ret;
1951 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1953 ret = CS_SUCCESS;
1954 } while (0);
1955 up(&skt->skt_sem);
1957 return ret;
1958 } /* reset_card */
1960 /*======================================================================
1962 These shut down or wake up a socket. They are sort of user
1963 initiated versions of the APM suspend and resume actions.
1965 ======================================================================*/
1967 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1969 int ret;
1971 cs_dbg(skt, 1, "suspending socket\n");
1973 down(&skt->skt_sem);
1974 do {
1975 if (!(skt->state & SOCKET_PRESENT)) {
1976 ret = CS_NO_CARD;
1977 break;
1979 if (skt->state & SOCKET_CARDBUS) {
1980 ret = CS_UNSUPPORTED_FUNCTION;
1981 break;
1983 ret = socket_suspend(skt);
1984 } while (0);
1985 up(&skt->skt_sem);
1987 return ret;
1988 } /* suspend_card */
1990 int pcmcia_resume_card(struct pcmcia_socket *skt)
1992 int ret;
1994 cs_dbg(skt, 1, "waking up socket\n");
1996 down(&skt->skt_sem);
1997 do {
1998 if (!(skt->state & SOCKET_PRESENT)) {
1999 ret = CS_NO_CARD;
2000 break;
2002 if (skt->state & SOCKET_CARDBUS) {
2003 ret = CS_UNSUPPORTED_FUNCTION;
2004 break;
2006 ret = socket_resume(skt);
2007 } while (0);
2008 up(&skt->skt_sem);
2010 return ret;
2011 } /* resume_card */
2013 /*======================================================================
2015 These handle user requests to eject or insert a card.
2017 ======================================================================*/
2019 int pcmcia_eject_card(struct pcmcia_socket *skt)
2021 int ret;
2023 cs_dbg(skt, 1, "user eject request\n");
2025 down(&skt->skt_sem);
2026 do {
2027 if (!(skt->state & SOCKET_PRESENT)) {
2028 ret = -ENODEV;
2029 break;
2032 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2033 if (ret != 0) {
2034 ret = -EINVAL;
2035 break;
2038 socket_remove(skt);
2039 ret = 0;
2040 } while (0);
2041 up(&skt->skt_sem);
2043 return ret;
2044 } /* eject_card */
2046 int pcmcia_insert_card(struct pcmcia_socket *skt)
2048 int ret;
2050 cs_dbg(skt, 1, "user insert request\n");
2052 down(&skt->skt_sem);
2053 do {
2054 if (skt->state & SOCKET_PRESENT) {
2055 ret = -EBUSY;
2056 break;
2058 if (socket_insert(skt) == CS_NO_CARD) {
2059 ret = -ENODEV;
2060 break;
2062 ret = 0;
2063 } while (0);
2064 up(&skt->skt_sem);
2066 return ret;
2067 } /* insert_card */
2069 /*======================================================================
2071 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2072 haven't sent one to this client yet?
2074 ======================================================================*/
2076 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2078 u_int events, bit;
2079 if (CHECK_HANDLE(handle))
2080 return CS_BAD_HANDLE;
2081 if (handle->Attributes & CONF_EVENT_MASK_VALID)
2082 return CS_BAD_SOCKET;
2083 handle->EventMask = mask->EventMask;
2084 events = handle->PendingEvents & handle->EventMask;
2085 handle->PendingEvents -= events;
2086 while (events != 0) {
2087 bit = ((events ^ (events-1)) + 1) >> 1;
2088 EVENT(handle, bit, CS_EVENT_PRI_LOW);
2089 events -= bit;
2091 return CS_SUCCESS;
2092 } /* set_event_mask */
2094 /*======================================================================
2096 OS-specific module glue goes here
2098 ======================================================================*/
2099 /* in alpha order */
2100 EXPORT_SYMBOL(pcmcia_access_configuration_register);
2101 EXPORT_SYMBOL(pcmcia_adjust_resource_info);
2102 EXPORT_SYMBOL(pcmcia_check_erase_queue);
2103 EXPORT_SYMBOL(pcmcia_close_memory);
2104 EXPORT_SYMBOL(pcmcia_copy_memory);
2105 EXPORT_SYMBOL(pcmcia_deregister_client);
2106 EXPORT_SYMBOL(pcmcia_deregister_erase_queue);
2107 EXPORT_SYMBOL(pcmcia_eject_card);
2108 EXPORT_SYMBOL(pcmcia_get_first_client);
2109 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2110 EXPORT_SYMBOL(pcmcia_get_configuration_info);
2111 EXPORT_SYMBOL(pcmcia_get_mem_page);
2112 EXPORT_SYMBOL(pcmcia_get_next_client);
2113 EXPORT_SYMBOL(pcmcia_get_first_region);
2114 EXPORT_SYMBOL(pcmcia_get_first_tuple);
2115 EXPORT_SYMBOL(pcmcia_get_first_window);
2116 EXPORT_SYMBOL(pcmcia_get_next_region);
2117 EXPORT_SYMBOL(pcmcia_get_next_tuple);
2118 EXPORT_SYMBOL(pcmcia_get_next_window);
2119 EXPORT_SYMBOL(pcmcia_get_status);
2120 EXPORT_SYMBOL(pcmcia_get_tuple_data);
2121 EXPORT_SYMBOL(pcmcia_insert_card);
2122 EXPORT_SYMBOL(pcmcia_map_mem_page);
2123 EXPORT_SYMBOL(pcmcia_modify_configuration);
2124 EXPORT_SYMBOL(pcmcia_modify_window);
2125 EXPORT_SYMBOL(pcmcia_open_memory);
2126 EXPORT_SYMBOL(pcmcia_parse_tuple);
2127 EXPORT_SYMBOL(pcmcia_read_memory);
2128 EXPORT_SYMBOL(pcmcia_register_client);
2129 EXPORT_SYMBOL(pcmcia_register_erase_queue);
2130 EXPORT_SYMBOL(pcmcia_register_mtd);
2131 EXPORT_SYMBOL(pcmcia_release_configuration);
2132 EXPORT_SYMBOL(pcmcia_release_io);
2133 EXPORT_SYMBOL(pcmcia_release_irq);
2134 EXPORT_SYMBOL(pcmcia_release_window);
2135 EXPORT_SYMBOL(pcmcia_replace_cis);
2136 EXPORT_SYMBOL(pcmcia_request_configuration);
2137 EXPORT_SYMBOL(pcmcia_request_io);
2138 EXPORT_SYMBOL(pcmcia_request_irq);
2139 EXPORT_SYMBOL(pcmcia_request_window);
2140 EXPORT_SYMBOL(pcmcia_reset_card);
2141 EXPORT_SYMBOL(pcmcia_resume_card);
2142 EXPORT_SYMBOL(pcmcia_set_event_mask);
2143 EXPORT_SYMBOL(pcmcia_suspend_card);
2144 EXPORT_SYMBOL(pcmcia_validate_cis);
2145 EXPORT_SYMBOL(pcmcia_write_memory);
2147 EXPORT_SYMBOL(dead_socket);
2148 EXPORT_SYMBOL(MTDHelperEntry);
2149 EXPORT_SYMBOL(pcmcia_parse_events);
2151 struct class pcmcia_socket_class = {
2152 .name = "pcmcia_socket",
2153 .release = pcmcia_release_socket,
2155 EXPORT_SYMBOL(pcmcia_socket_class);
2158 static int __init init_pcmcia_cs(void)
2160 int ret;
2161 printk(KERN_INFO "%s\n", release);
2162 printk(KERN_INFO " %s\n", options);
2164 ret = class_register(&pcmcia_socket_class);
2165 if (ret)
2166 return (ret);
2167 return class_interface_register(&pccard_sysfs_interface);
2170 static void __exit exit_pcmcia_cs(void)
2172 printk(KERN_INFO "unloading Kernel Card Services\n");
2173 release_resource_db();
2174 class_interface_unregister(&pccard_sysfs_interface);
2175 class_unregister(&pcmcia_socket_class);
2178 subsys_initcall(init_pcmcia_cs);
2179 module_exit(exit_pcmcia_cs);
2181 /*====================================================================*/