2 * cs.c -- Kernel Card Services - core services
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
12 * (C) 1999 David A. Hinds
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/config.h>
20 #include <linux/string.h>
21 #include <linux/major.h>
22 #include <linux/errno.h>
23 #include <linux/slab.h>
25 #include <linux/interrupt.h>
26 #include <linux/timer.h>
27 #include <linux/ioport.h>
28 #include <linux/delay.h>
30 #include <linux/pci.h>
31 #include <linux/device.h>
32 #include <asm/system.h>
35 #define IN_CARD_SERVICES
36 #include <pcmcia/version.h>
37 #include <pcmcia/cs_types.h>
38 #include <pcmcia/ss.h>
39 #include <pcmcia/cs.h>
40 #include <pcmcia/bulkmem.h>
41 #include <pcmcia/cistpl.h>
42 #include <pcmcia/cisreg.h>
43 #include <pcmcia/ds.h>
44 #include "cs_internal.h"
47 #define PCI_OPT " [pci]"
52 #define CB_OPT " [cardbus]"
57 #define PM_OPT " [pm]"
61 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
62 #define OPTIONS " none"
64 #define OPTIONS PCI_OPT CB_OPT PM_OPT
67 static const char *release = "Linux Kernel Card Services";
68 static const char *options = "options: " OPTIONS;
70 /*====================================================================*/
72 /* Module parameters */
74 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
75 MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
76 MODULE_LICENSE("GPL");
78 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
80 INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
81 INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
82 INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
83 INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
84 INT_MODULE_PARM(reset_time, 10); /* usecs */
85 INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
86 INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
87 INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
89 /* Access speed for attribute memory windows */
90 INT_MODULE_PARM(cis_speed, 300); /* ns */
92 /* Access speed for IO windows */
93 INT_MODULE_PARM(io_speed, 0); /* ns */
98 module_param(pc_debug, int, 0644);
100 int cs_debug_level(int level)
102 return pc_debug > level;
106 /*====================================================================*/
108 socket_state_t dead_socket = {
109 .csc_mask = SS_DETECT,
113 /* List of all sockets, protected by a rwsem */
114 LIST_HEAD(pcmcia_socket_list);
115 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
116 EXPORT_SYMBOL(pcmcia_socket_list);
117 EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
120 #ifdef CONFIG_PCMCIA_PROBE
121 /* mask ofIRQs already reserved by other cards, we should avoid using them */
122 static u8 pcmcia_used_irq[NR_IRQS];
125 /*====================================================================
127 Low-level PC Card interface drivers need to register with Card
128 Services using these calls.
130 ======================================================================*/
133 * socket drivers are expected to use the following callbacks in their
135 * - pcmcia_socket_dev_suspend
136 * - pcmcia_socket_dev_resume
137 * These functions check for the appropriate struct pcmcia_soket arrays,
138 * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
140 static int socket_resume(struct pcmcia_socket *skt);
141 static int socket_suspend(struct pcmcia_socket *skt);
143 int pcmcia_socket_dev_suspend(struct device *dev, u32 state)
145 struct pcmcia_socket *socket;
147 down_read(&pcmcia_socket_list_rwsem);
148 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
149 if (socket->dev.dev != dev)
151 down(&socket->skt_sem);
152 socket_suspend(socket);
153 up(&socket->skt_sem);
155 up_read(&pcmcia_socket_list_rwsem);
159 EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
161 int pcmcia_socket_dev_resume(struct device *dev)
163 struct pcmcia_socket *socket;
165 down_read(&pcmcia_socket_list_rwsem);
166 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
167 if (socket->dev.dev != dev)
169 down(&socket->skt_sem);
170 socket_resume(socket);
171 up(&socket->skt_sem);
173 up_read(&pcmcia_socket_list_rwsem);
177 EXPORT_SYMBOL(pcmcia_socket_dev_resume);
180 struct pcmcia_socket * pcmcia_get_socket(struct pcmcia_socket *skt)
182 struct class_device *cl_dev = class_device_get(&skt->dev);
185 skt = class_get_devdata(cl_dev);
186 if (!try_module_get(skt->owner)) {
187 class_device_put(&skt->dev);
192 EXPORT_SYMBOL(pcmcia_get_socket);
195 void pcmcia_put_socket(struct pcmcia_socket *skt)
197 module_put(skt->owner);
198 class_device_put(&skt->dev);
200 EXPORT_SYMBOL(pcmcia_put_socket);
203 static void pcmcia_release_socket(struct class_device *class_dev)
205 struct pcmcia_socket *socket = class_get_devdata(class_dev);
207 complete(&socket->socket_released);
210 static int pccardd(void *__skt);
213 * pcmcia_register_socket - add a new pcmcia socket device
215 int pcmcia_register_socket(struct pcmcia_socket *socket)
219 if (!socket || !socket->ops || !socket->dev.dev || !socket->resource_ops)
222 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
224 if (socket->resource_ops->init) {
225 ret = socket->resource_ops->init(socket);
230 /* try to obtain a socket number [yes, it gets ugly if we
231 * register more than 2^sizeof(unsigned int) pcmcia
232 * sockets... but the socket number is deprecated
233 * anyways, so I don't care] */
234 down_write(&pcmcia_socket_list_rwsem);
235 if (list_empty(&pcmcia_socket_list))
238 unsigned int found, i = 1;
239 struct pcmcia_socket *tmp;
242 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
248 socket->sock = i - 1;
250 list_add_tail(&socket->socket_list, &pcmcia_socket_list);
251 up_write(&pcmcia_socket_list_rwsem);
254 /* set proper values in socket->dev */
255 socket->dev.class_data = socket;
256 socket->dev.class = &pcmcia_socket_class;
257 snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
259 /* base address = 0, map = 0 */
260 socket->cis_mem.flags = 0;
261 socket->cis_mem.speed = cis_speed;
263 INIT_LIST_HEAD(&socket->cis_cache);
264 spin_lock_init(&socket->lock);
266 init_completion(&socket->socket_released);
267 init_completion(&socket->thread_done);
268 init_waitqueue_head(&socket->thread_wait);
269 init_MUTEX(&socket->skt_sem);
270 spin_lock_init(&socket->thread_lock);
272 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
276 wait_for_completion(&socket->thread_done);
277 if(!socket->thread) {
278 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
281 pcmcia_parse_events(socket, SS_DETECT);
286 down_write(&pcmcia_socket_list_rwsem);
287 list_del(&socket->socket_list);
288 up_write(&pcmcia_socket_list_rwsem);
290 } /* pcmcia_register_socket */
291 EXPORT_SYMBOL(pcmcia_register_socket);
295 * pcmcia_unregister_socket - remove a pcmcia socket device
297 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
302 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
304 if (socket->thread) {
305 init_completion(&socket->thread_done);
306 socket->thread = NULL;
307 wake_up(&socket->thread_wait);
308 wait_for_completion(&socket->thread_done);
310 release_cis_mem(socket);
312 /* remove from our own list */
313 down_write(&pcmcia_socket_list_rwsem);
314 list_del(&socket->socket_list);
315 up_write(&pcmcia_socket_list_rwsem);
317 /* wait for sysfs to drop all references */
318 release_resource_db(socket);
319 wait_for_completion(&socket->socket_released);
320 } /* pcmcia_unregister_socket */
321 EXPORT_SYMBOL(pcmcia_unregister_socket);
324 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
326 struct pcmcia_socket *s;
328 down_read(&pcmcia_socket_list_rwsem);
329 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
331 up_read(&pcmcia_socket_list_rwsem);
334 up_read(&pcmcia_socket_list_rwsem);
339 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
342 /*======================================================================
344 socket_setup() and shutdown_socket() are called by the main event
345 handler when card insertion and removal events are received.
346 socket_setup() turns on socket power and resets the socket, in two stages.
347 shutdown_socket() unconfigures a socket and turns off socket power.
349 ======================================================================*/
351 static void shutdown_socket(struct pcmcia_socket *s)
353 cs_dbg(s, 1, "shutdown_socket\n");
355 /* Blank out the socket state */
356 s->socket = dead_socket;
358 s->ops->set_socket(s, &s->socket);
359 s->irq.AssignedIRQ = s->irq.Config = 0;
361 destroy_cis_cache(s);
362 #ifdef CONFIG_CARDBUS
373 s->ops->get_status(s, &status);
374 if (status & SS_POWERON) {
375 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
378 } /* shutdown_socket */
380 /*======================================================================
382 The central event handler. Send_event() sends an event to the
383 16-bit subsystem, which then calls the relevant device drivers.
384 Parse_events() interprets the event bits from
385 a card status change report. Do_shutdown() handles the high
386 priority stuff associated with a card removal.
388 ======================================================================*/
391 /* NOTE: send_event needs to be called with skt->sem held. */
393 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
397 if (s->state & SOCKET_CARDBUS)
400 cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n",
401 event, priority, s->callback);
405 if (!try_module_get(s->callback->owner))
408 ret = s->callback->event(s, event, priority);
410 module_put(s->callback->owner);
415 static void socket_remove_drivers(struct pcmcia_socket *skt)
417 cs_dbg(skt, 4, "remove_drivers\n");
419 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
422 static void socket_shutdown(struct pcmcia_socket *skt)
424 cs_dbg(skt, 4, "shutdown\n");
426 socket_remove_drivers(skt);
427 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
428 msleep(shutdown_delay * 10);
429 skt->state &= SOCKET_INUSE;
430 shutdown_socket(skt);
433 static int socket_reset(struct pcmcia_socket *skt)
437 cs_dbg(skt, 4, "reset\n");
439 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
440 skt->ops->set_socket(skt, &skt->socket);
441 udelay((long)reset_time);
443 skt->socket.flags &= ~SS_RESET;
444 skt->ops->set_socket(skt, &skt->socket);
446 msleep(unreset_delay * 10);
447 for (i = 0; i < unreset_limit; i++) {
448 skt->ops->get_status(skt, &status);
450 if (!(status & SS_DETECT))
453 if (status & SS_READY)
456 msleep(unreset_check * 10);
459 cs_err(skt, "time out after reset.\n");
460 return CS_GENERAL_FAILURE;
463 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
467 cs_dbg(skt, 4, "setup\n");
469 skt->ops->get_status(skt, &status);
470 if (!(status & SS_DETECT))
473 msleep(initial_delay * 10);
475 for (i = 0; i < 100; i++) {
476 skt->ops->get_status(skt, &status);
477 if (!(status & SS_DETECT))
480 if (!(status & SS_PENDING))
486 if (status & SS_PENDING) {
487 cs_err(skt, "voltage interrogation timed out.\n");
488 return CS_GENERAL_FAILURE;
491 if (status & SS_CARDBUS) {
492 skt->state |= SOCKET_CARDBUS;
493 #ifndef CONFIG_CARDBUS
494 cs_err(skt, "cardbus cards are not supported.\n");
500 * Decode the card voltage requirements, and apply power to the card.
502 if (status & SS_3VCARD)
503 skt->socket.Vcc = skt->socket.Vpp = 33;
504 else if (!(status & SS_XVCARD))
505 skt->socket.Vcc = skt->socket.Vpp = 50;
507 cs_err(skt, "unsupported voltage key.\n");
510 skt->socket.flags = 0;
511 skt->ops->set_socket(skt, &skt->socket);
514 * Wait "vcc_settle" for the supply to stabilise.
516 msleep(vcc_settle * 10);
518 skt->ops->get_status(skt, &status);
519 if (!(status & SS_POWERON)) {
520 cs_err(skt, "unable to apply power.\n");
524 return socket_reset(skt);
528 * Handle card insertion. Setup the socket, reset the card,
529 * and then tell the rest of PCMCIA that a card is present.
531 static int socket_insert(struct pcmcia_socket *skt)
535 cs_dbg(skt, 4, "insert\n");
537 if (!cs_socket_get(skt))
540 ret = socket_setup(skt, setup_delay);
541 if (ret == CS_SUCCESS) {
542 skt->state |= SOCKET_PRESENT;
543 #ifdef CONFIG_CARDBUS
544 if (skt->state & SOCKET_CARDBUS) {
546 skt->state |= SOCKET_CARDBUS_CONFIG;
549 cs_dbg(skt, 4, "insert done\n");
551 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
553 socket_shutdown(skt);
560 static int socket_suspend(struct pcmcia_socket *skt)
562 if (skt->state & SOCKET_SUSPEND)
565 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
566 skt->socket = dead_socket;
567 skt->ops->suspend(skt);
568 skt->state |= SOCKET_SUSPEND;
574 * Resume a socket. If a card is present, verify its CIS against
575 * our cached copy. If they are different, the card has been
576 * replaced, and we need to tell the drivers.
578 static int socket_resume(struct pcmcia_socket *skt)
582 if (!(skt->state & SOCKET_SUSPEND))
585 skt->socket = dead_socket;
587 skt->ops->set_socket(skt, &skt->socket);
589 ret = socket_setup(skt, resume_delay);
590 if (ret == CS_SUCCESS) {
592 * FIXME: need a better check here for cardbus cards.
594 if (verify_cis_cache(skt) != 0) {
595 cs_dbg(skt, 4, "cis mismatch - different card\n");
596 socket_remove_drivers(skt);
597 destroy_cis_cache(skt);
599 * Workaround: give DS time to schedule removal.
600 * Remove me once the 100ms delay is eliminated
604 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
606 cs_dbg(skt, 4, "cis matches cache\n");
607 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
610 socket_shutdown(skt);
614 skt->state &= ~SOCKET_SUSPEND;
619 static void socket_remove(struct pcmcia_socket *skt)
621 socket_shutdown(skt);
626 * Process a socket card detect status change.
628 * If we don't have a card already present, delay the detect event for
629 * about 20ms (to be on the safe side) before reading the socket status.
631 * Some i82365-based systems send multiple SS_DETECT events during card
632 * insertion, and the "card present" status bit seems to bounce. This
633 * will probably be true with GPIO-based card detection systems after
634 * the product has aged.
636 static void socket_detect_change(struct pcmcia_socket *skt)
638 if (!(skt->state & SOCKET_SUSPEND)) {
641 if (!(skt->state & SOCKET_PRESENT))
644 skt->ops->get_status(skt, &status);
645 if ((skt->state & SOCKET_PRESENT) &&
646 !(status & SS_DETECT))
648 if (!(skt->state & SOCKET_PRESENT) &&
649 (status & SS_DETECT))
654 static int pccardd(void *__skt)
656 struct pcmcia_socket *skt = __skt;
657 DECLARE_WAITQUEUE(wait, current);
660 daemonize("pccardd");
662 skt->thread = current;
663 skt->socket = dead_socket;
665 skt->ops->set_socket(skt, &skt->socket);
667 /* register with the device core */
668 ret = class_device_register(&skt->dev);
670 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
673 complete_and_exit(&skt->thread_done, 0);
675 complete(&skt->thread_done);
677 add_wait_queue(&skt->thread_wait, &wait);
682 set_current_state(TASK_INTERRUPTIBLE);
684 spin_lock_irqsave(&skt->thread_lock, flags);
685 events = skt->thread_events;
686 skt->thread_events = 0;
687 spin_unlock_irqrestore(&skt->thread_lock, flags);
691 if (events & SS_DETECT)
692 socket_detect_change(skt);
693 if (events & SS_BATDEAD)
694 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
695 if (events & SS_BATWARN)
696 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
697 if (events & SS_READY)
698 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
704 try_to_freeze(PF_FREEZE);
709 remove_wait_queue(&skt->thread_wait, &wait);
711 /* remove from the device core */
712 class_device_unregister(&skt->dev);
714 complete_and_exit(&skt->thread_done, 0);
718 * Yenta (at least) probes interrupts before registering the socket and
719 * starting the handler thread.
721 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
723 cs_dbg(s, 4, "parse_events: events %08x\n", events);
725 spin_lock(&s->thread_lock);
726 s->thread_events |= events;
727 spin_unlock(&s->thread_lock);
729 wake_up(&s->thread_wait);
731 } /* pcmcia_parse_events */
734 /*======================================================================
736 Special stuff for managing IO windows, because they are scarce.
738 ======================================================================*/
740 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
741 ioaddr_t num, u_int lines)
744 kio_addr_t try, align;
746 align = (*base) ? (lines ? 1<<lines : 0) : 1;
747 if (align && (align < num)) {
749 cs_dbg(s, 0, "odd IO request: num %#x align %#lx\n",
753 while (align && (align < num)) align <<= 1;
755 if (*base & ~(align-1)) {
756 cs_dbg(s, 0, "odd IO request: base %#x align %#lx\n",
760 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
761 *base = s->io_offset | (*base & 0x0fff);
764 /* Check for an already-allocated window that must conflict with
765 what was asked for. It is a hack because it does not catch all
766 potential conflicts, just the most obvious ones. */
767 for (i = 0; i < MAX_IO_WIN; i++)
768 if ((s->io[i].NumPorts != 0) &&
769 ((s->io[i].BasePort & (align-1)) == *base))
771 for (i = 0; i < MAX_IO_WIN; i++) {
772 if (s->io[i].NumPorts == 0) {
773 s->io[i].res = find_io_region(*base, num, align, s);
775 s->io[i].Attributes = attr;
776 s->io[i].BasePort = *base = s->io[i].res->start;
777 s->io[i].NumPorts = s->io[i].InUse = num;
781 } else if (s->io[i].Attributes != attr)
783 /* Try to extend top of window */
784 try = s->io[i].BasePort + s->io[i].NumPorts;
785 if ((*base == 0) || (*base == try))
786 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
787 s->io[i].res->end + num, s) == 0) {
789 s->io[i].NumPorts += num;
790 s->io[i].InUse += num;
793 /* Try to extend bottom of window */
794 try = s->io[i].BasePort - num;
795 if ((*base == 0) || (*base == try))
796 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
797 s->io[i].res->end, s) == 0) {
798 s->io[i].BasePort = *base = try;
799 s->io[i].NumPorts += num;
800 s->io[i].InUse += num;
804 return (i == MAX_IO_WIN);
805 } /* alloc_io_space */
807 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
812 for (i = 0; i < MAX_IO_WIN; i++) {
813 if ((s->io[i].BasePort <= base) &&
814 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
815 s->io[i].InUse -= num;
816 /* Free the window if no one else is using it */
817 if (s->io[i].InUse == 0) {
818 s->io[i].NumPorts = 0;
819 release_resource(s->io[i].res);
827 /*======================================================================
829 Access_configuration_register() reads and writes configuration
830 registers in attribute memory. Memory window 0 is reserved for
831 this and the tuple reading services.
833 ======================================================================*/
835 int pccard_access_configuration_register(struct pcmcia_socket *s,
836 unsigned int function,
843 if (!s || !s->config)
846 c = &s->config[function];
851 if (!(c->state & CONFIG_LOCKED))
852 return CS_CONFIGURATION_LOCKED;
854 addr = (c->ConfigBase + reg->Offset) >> 1;
856 switch (reg->Action) {
858 read_cis_mem(s, 1, addr, 1, &val);
863 write_cis_mem(s, 1, addr, 1, &val);
870 } /* access_configuration_register */
871 EXPORT_SYMBOL(pccard_access_configuration_register);
874 /*====================================================================*/
876 int pccard_get_configuration_info(struct pcmcia_socket *s,
877 unsigned int function,
878 config_info_t *config)
882 if (!(s->state & SOCKET_PRESENT))
885 config->Function = function;
887 #ifdef CONFIG_CARDBUS
888 if (s->state & SOCKET_CARDBUS) {
889 memset(config, 0, sizeof(config_info_t));
890 config->Vcc = s->socket.Vcc;
891 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
892 config->Option = s->cb_dev->subordinate->number;
893 if (s->state & SOCKET_CARDBUS_CONFIG) {
894 config->Attributes = CONF_VALID_CLIENT;
895 config->IntType = INT_CARDBUS;
896 config->AssignedIRQ = s->irq.AssignedIRQ;
897 if (config->AssignedIRQ)
898 config->Attributes |= CONF_ENABLE_IRQ;
899 config->BasePort1 = s->io[0].BasePort;
900 config->NumPorts1 = s->io[0].NumPorts;
906 c = (s->config != NULL) ? &s->config[function] : NULL;
908 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
909 config->Attributes = 0;
910 config->Vcc = s->socket.Vcc;
911 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
915 /* !!! This is a hack !!! */
916 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
917 config->Attributes |= CONF_VALID_CLIENT;
918 config->CardValues = c->CardValues;
919 config->IRQAttributes = c->irq.Attributes;
920 config->AssignedIRQ = s->irq.AssignedIRQ;
921 config->BasePort1 = c->io.BasePort1;
922 config->NumPorts1 = c->io.NumPorts1;
923 config->Attributes1 = c->io.Attributes1;
924 config->BasePort2 = c->io.BasePort2;
925 config->NumPorts2 = c->io.NumPorts2;
926 config->Attributes2 = c->io.Attributes2;
927 config->IOAddrLines = c->io.IOAddrLines;
930 } /* get_configuration_info */
931 EXPORT_SYMBOL(pccard_get_configuration_info);
933 /*======================================================================
935 Return information about this version of Card Services.
937 ======================================================================*/
939 int pcmcia_get_card_services_info(servinfo_t *info)
941 unsigned int socket_count = 0;
942 struct list_head *tmp;
943 info->Signature[0] = 'C';
944 info->Signature[1] = 'S';
945 down_read(&pcmcia_socket_list_rwsem);
946 list_for_each(tmp, &pcmcia_socket_list)
948 up_read(&pcmcia_socket_list_rwsem);
949 info->Count = socket_count;
950 info->Revision = CS_RELEASE_CODE;
951 info->CSLevel = 0x0210;
952 info->VendorString = (char *)release;
954 } /* get_card_services_info */
957 /*====================================================================*/
959 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
964 if (!s || !(s->state & SOCKET_PRESENT))
966 for (w = idx; w < MAX_WIN; w++)
967 if (s->state & SOCKET_WIN_REQ(w)) break;
969 return CS_NO_MORE_ITEMS;
971 req->Base = win->ctl.res->start;
972 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
973 req->AccessSpeed = win->ctl.speed;
975 if (win->ctl.flags & MAP_ATTRIB)
976 req->Attributes |= WIN_MEMORY_TYPE_AM;
977 if (win->ctl.flags & MAP_ACTIVE)
978 req->Attributes |= WIN_ENABLE;
979 if (win->ctl.flags & MAP_16BIT)
980 req->Attributes |= WIN_DATA_WIDTH_16;
981 if (win->ctl.flags & MAP_USE_WAIT)
982 req->Attributes |= WIN_USE_WAIT;
986 EXPORT_SYMBOL(pcmcia_get_window);
988 /*=====================================================================
990 Return the PCI device associated with a card..
992 ======================================================================*/
994 #ifdef CONFIG_CARDBUS
996 struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
998 if (!s || !(s->state & SOCKET_CARDBUS))
1001 return s->cb_dev->subordinate;
1004 EXPORT_SYMBOL(pcmcia_lookup_bus);
1008 /*======================================================================
1010 Get the current socket state bits. We don't support the latched
1011 SocketState yet: I haven't seen any point for it.
1013 ======================================================================*/
1015 int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
1020 s->ops->get_status(s, &val);
1021 status->CardState = status->SocketState = 0;
1022 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1023 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1024 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1025 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1026 if (s->state & SOCKET_SUSPEND)
1027 status->CardState |= CS_EVENT_PM_SUSPEND;
1028 if (!(s->state & SOCKET_PRESENT))
1031 c = (s->config != NULL) ? &s->config[function] : NULL;
1032 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1033 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1035 if (c->Present & PRESENT_PIN_REPLACE) {
1036 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1037 status->CardState |=
1038 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1039 status->CardState |=
1040 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1041 status->CardState |=
1042 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1043 status->CardState |=
1044 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1046 /* No PRR? Then assume we're always ready */
1047 status->CardState |= CS_EVENT_READY_CHANGE;
1049 if (c->Present & PRESENT_EXT_STATUS) {
1050 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1051 status->CardState |=
1052 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1056 status->CardState |=
1057 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1058 status->CardState |=
1059 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1060 status->CardState |=
1061 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1062 status->CardState |=
1063 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1066 EXPORT_SYMBOL(pccard_get_status);
1068 /*======================================================================
1070 Change the card address of an already open memory window.
1072 ======================================================================*/
1074 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1076 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1077 return CS_BAD_HANDLE;
1079 req->CardOffset = win->ctl.card_start;
1081 } /* get_mem_page */
1083 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1085 struct pcmcia_socket *s;
1086 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1087 return CS_BAD_HANDLE;
1091 win->ctl.card_start = req->CardOffset;
1092 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1093 return CS_BAD_OFFSET;
1095 } /* map_mem_page */
1097 /*======================================================================
1099 Modify a locked socket configuration
1101 ======================================================================*/
1103 int pcmcia_modify_configuration(client_handle_t handle,
1106 struct pcmcia_socket *s;
1109 if (CHECK_HANDLE(handle))
1110 return CS_BAD_HANDLE;
1111 s = SOCKET(handle); c = CONFIG(handle);
1112 if (!(s->state & SOCKET_PRESENT))
1114 if (!(c->state & CONFIG_LOCKED))
1115 return CS_CONFIGURATION_LOCKED;
1117 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1118 if (mod->Attributes & CONF_ENABLE_IRQ) {
1119 c->Attributes |= CONF_ENABLE_IRQ;
1120 s->socket.io_irq = s->irq.AssignedIRQ;
1122 c->Attributes &= ~CONF_ENABLE_IRQ;
1123 s->socket.io_irq = 0;
1125 s->ops->set_socket(s, &s->socket);
1128 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1131 /* We only allow changing Vpp1 and Vpp2 to the same value */
1132 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1133 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1134 if (mod->Vpp1 != mod->Vpp2)
1136 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1137 if (s->ops->set_socket(s, &s->socket))
1139 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1140 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1144 } /* modify_configuration */
1146 /* register pcmcia_callback */
1147 int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
1151 /* s->skt_sem also protects s->callback */
1163 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
1164 send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1172 EXPORT_SYMBOL(pccard_register_pcmcia);
1174 /*====================================================================*/
1176 int pcmcia_release_configuration(client_handle_t handle)
1178 pccard_io_map io = { 0, 0, 0, 0, 1 };
1179 struct pcmcia_socket *s;
1182 if (CHECK_HANDLE(handle) ||
1183 !(handle->state & CLIENT_CONFIG_LOCKED))
1184 return CS_BAD_HANDLE;
1185 handle->state &= ~CLIENT_CONFIG_LOCKED;
1188 #ifdef CONFIG_CARDBUS
1189 if (handle->state & CLIENT_CARDBUS)
1193 if (!(handle->state & CLIENT_STALE)) {
1194 config_t *c = CONFIG(handle);
1195 if (--(s->lock_count) == 0) {
1196 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1198 s->socket.io_irq = 0;
1199 s->ops->set_socket(s, &s->socket);
1201 if (c->state & CONFIG_IO_REQ)
1202 for (i = 0; i < MAX_IO_WIN; i++) {
1203 if (s->io[i].NumPorts == 0)
1206 if (s->io[i].Config != 0)
1209 s->ops->set_io_map(s, &io);
1211 c->state &= ~CONFIG_LOCKED;
1215 } /* release_configuration */
1217 /*======================================================================
1219 Release_io() releases the I/O ranges allocated by a client. This
1220 may be invoked some time after a card ejection has already dumped
1221 the actual socket configuration, so if the client is "stale", we
1222 don't bother checking the port ranges against the current socket
1225 ======================================================================*/
1227 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1229 struct pcmcia_socket *s;
1231 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1232 return CS_BAD_HANDLE;
1233 handle->state &= ~CLIENT_IO_REQ;
1236 #ifdef CONFIG_CARDBUS
1237 if (handle->state & CLIENT_CARDBUS)
1241 if (!(handle->state & CLIENT_STALE)) {
1242 config_t *c = CONFIG(handle);
1243 if (c->state & CONFIG_LOCKED)
1244 return CS_CONFIGURATION_LOCKED;
1245 if ((c->io.BasePort1 != req->BasePort1) ||
1246 (c->io.NumPorts1 != req->NumPorts1) ||
1247 (c->io.BasePort2 != req->BasePort2) ||
1248 (c->io.NumPorts2 != req->NumPorts2))
1250 c->state &= ~CONFIG_IO_REQ;
1253 release_io_space(s, req->BasePort1, req->NumPorts1);
1255 release_io_space(s, req->BasePort2, req->NumPorts2);
1260 /*====================================================================*/
1262 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1264 struct pcmcia_socket *s;
1265 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1266 return CS_BAD_HANDLE;
1267 handle->state &= ~CLIENT_IRQ_REQ;
1270 if (!(handle->state & CLIENT_STALE)) {
1271 config_t *c = CONFIG(handle);
1272 if (c->state & CONFIG_LOCKED)
1273 return CS_CONFIGURATION_LOCKED;
1274 if (c->irq.Attributes != req->Attributes)
1275 return CS_BAD_ATTRIBUTE;
1276 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1278 if (--s->irq.Config == 0) {
1279 c->state &= ~CONFIG_IRQ_REQ;
1280 s->irq.AssignedIRQ = 0;
1284 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1285 free_irq(req->AssignedIRQ, req->Instance);
1288 #ifdef CONFIG_PCMCIA_PROBE
1289 pcmcia_used_irq[req->AssignedIRQ]--;
1293 } /* cs_release_irq */
1295 /*====================================================================*/
1297 int pcmcia_release_window(window_handle_t win)
1299 struct pcmcia_socket *s;
1301 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1302 return CS_BAD_HANDLE;
1304 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1305 return CS_BAD_HANDLE;
1307 /* Shut down memory window */
1308 win->ctl.flags &= ~MAP_ACTIVE;
1309 s->ops->set_mem_map(s, &win->ctl);
1310 s->state &= ~SOCKET_WIN_REQ(win->index);
1312 /* Release system memory */
1314 release_resource(win->ctl.res);
1315 kfree(win->ctl.res);
1316 win->ctl.res = NULL;
1318 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1323 } /* release_window */
1325 /*====================================================================*/
1327 int pcmcia_request_configuration(client_handle_t handle,
1332 struct pcmcia_socket *s;
1334 pccard_io_map iomap;
1336 if (CHECK_HANDLE(handle))
1337 return CS_BAD_HANDLE;
1339 if (!(s->state & SOCKET_PRESENT))
1342 #ifdef CONFIG_CARDBUS
1343 if (handle->state & CLIENT_CARDBUS)
1344 return CS_UNSUPPORTED_MODE;
1347 if (req->IntType & INT_CARDBUS)
1348 return CS_UNSUPPORTED_MODE;
1350 if (c->state & CONFIG_LOCKED)
1351 return CS_CONFIGURATION_LOCKED;
1353 /* Do power control. We don't allow changes in Vcc. */
1354 if (s->socket.Vcc != req->Vcc)
1356 if (req->Vpp1 != req->Vpp2)
1358 s->socket.Vpp = req->Vpp1;
1359 if (s->ops->set_socket(s, &s->socket))
1362 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1364 /* Pick memory or I/O card, DMA mode, interrupt */
1365 c->IntType = req->IntType;
1366 c->Attributes = req->Attributes;
1367 if (req->IntType & INT_MEMORY_AND_IO)
1368 s->socket.flags |= SS_IOCARD;
1369 if (req->IntType & INT_ZOOMED_VIDEO)
1370 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1371 if (req->Attributes & CONF_ENABLE_DMA)
1372 s->socket.flags |= SS_DMA_MODE;
1373 if (req->Attributes & CONF_ENABLE_SPKR)
1374 s->socket.flags |= SS_SPKR_ENA;
1375 if (req->Attributes & CONF_ENABLE_IRQ)
1376 s->socket.io_irq = s->irq.AssignedIRQ;
1378 s->socket.io_irq = 0;
1379 s->ops->set_socket(s, &s->socket);
1382 /* Set up CIS configuration registers */
1383 base = c->ConfigBase = req->ConfigBase;
1384 c->Present = c->CardValues = req->Present;
1385 if (req->Present & PRESENT_COPY) {
1386 c->Copy = req->Copy;
1387 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1389 if (req->Present & PRESENT_OPTION) {
1390 if (s->functions == 1) {
1391 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1393 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1394 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1395 if (req->Present & PRESENT_IOBASE_0)
1396 c->Option |= COR_ADDR_DECODE;
1398 if (c->state & CONFIG_IRQ_REQ)
1399 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1400 c->Option |= COR_LEVEL_REQ;
1401 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1404 if (req->Present & PRESENT_STATUS) {
1405 c->Status = req->Status;
1406 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1408 if (req->Present & PRESENT_PIN_REPLACE) {
1410 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1412 if (req->Present & PRESENT_EXT_STATUS) {
1413 c->ExtStatus = req->ExtStatus;
1414 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1416 if (req->Present & PRESENT_IOBASE_0) {
1417 u_char b = c->io.BasePort1 & 0xff;
1418 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1419 b = (c->io.BasePort1 >> 8) & 0xff;
1420 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1422 if (req->Present & PRESENT_IOSIZE) {
1423 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1424 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1427 /* Configure I/O windows */
1428 if (c->state & CONFIG_IO_REQ) {
1429 iomap.speed = io_speed;
1430 for (i = 0; i < MAX_IO_WIN; i++)
1431 if (s->io[i].NumPorts != 0) {
1433 iomap.flags = MAP_ACTIVE;
1434 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1435 case IO_DATA_PATH_WIDTH_16:
1436 iomap.flags |= MAP_16BIT; break;
1437 case IO_DATA_PATH_WIDTH_AUTO:
1438 iomap.flags |= MAP_AUTOSZ; break;
1442 iomap.start = s->io[i].BasePort;
1443 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1444 s->ops->set_io_map(s, &iomap);
1449 c->state |= CONFIG_LOCKED;
1450 handle->state |= CLIENT_CONFIG_LOCKED;
1452 } /* request_configuration */
1454 /*======================================================================
1456 Request_io() reserves ranges of port addresses for a socket.
1457 I have not implemented range sharing or alias addressing.
1459 ======================================================================*/
1461 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1463 struct pcmcia_socket *s;
1466 if (CHECK_HANDLE(handle))
1467 return CS_BAD_HANDLE;
1469 if (!(s->state & SOCKET_PRESENT))
1472 if (handle->state & CLIENT_CARDBUS) {
1473 #ifdef CONFIG_CARDBUS
1474 handle->state |= CLIENT_IO_REQ;
1477 return CS_UNSUPPORTED_FUNCTION;
1482 return CS_UNSUPPORTED_MODE;
1484 if (c->state & CONFIG_LOCKED)
1485 return CS_CONFIGURATION_LOCKED;
1486 if (c->state & CONFIG_IO_REQ)
1488 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1489 return CS_BAD_ATTRIBUTE;
1490 if ((req->NumPorts2 > 0) &&
1491 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1492 return CS_BAD_ATTRIBUTE;
1494 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1495 req->NumPorts1, req->IOAddrLines))
1498 if (req->NumPorts2) {
1499 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1500 req->NumPorts2, req->IOAddrLines)) {
1501 release_io_space(s, req->BasePort1, req->NumPorts1);
1507 c->state |= CONFIG_IO_REQ;
1508 handle->state |= CLIENT_IO_REQ;
1512 /*======================================================================
1514 Request_irq() reserves an irq for this client.
1516 Also, since Linux only reserves irq's when they are actually
1517 hooked, we don't guarantee that an irq will still be available
1518 when the configuration is locked. Now that I think about it,
1519 there might be a way to fix this using a dummy handler.
1521 ======================================================================*/
1523 #ifdef CONFIG_PCMCIA_PROBE
1524 static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs)
1530 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1532 struct pcmcia_socket *s;
1534 int ret = CS_IN_USE, irq = 0;
1535 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1537 if (CHECK_HANDLE(handle))
1538 return CS_BAD_HANDLE;
1540 if (!(s->state & SOCKET_PRESENT))
1543 if (c->state & CONFIG_LOCKED)
1544 return CS_CONFIGURATION_LOCKED;
1545 if (c->state & CONFIG_IRQ_REQ)
1548 #ifdef CONFIG_PCMCIA_PROBE
1549 if (s->irq.AssignedIRQ != 0) {
1550 /* If the interrupt is already assigned, it must be the same */
1551 irq = s->irq.AssignedIRQ;
1554 u32 mask = s->irq_mask;
1557 for (try = 0; try < 64; try++) {
1560 /* marked as available by driver, and not blocked by userspace? */
1561 if (!((mask >> irq) & 1))
1564 /* avoid an IRQ which is already used by a PCMCIA card */
1565 if ((try < 32) && pcmcia_used_irq[irq])
1568 /* register the correct driver, if possible, of check whether
1569 * registering a dummy handle works, i.e. if the IRQ isn't
1570 * marked as used by the kernel resource management core */
1571 ret = request_irq(irq,
1572 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action,
1573 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1574 (s->functions > 1) ||
1575 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1577 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
1579 if (!(req->Attributes & IRQ_HANDLE_PRESENT))
1580 free_irq(irq, data);
1592 if (ret && req->Attributes & IRQ_HANDLE_PRESENT) {
1593 if (request_irq(irq, req->Handler,
1594 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1595 (s->functions > 1) ||
1596 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1597 p_dev->dev.bus_id, req->Instance))
1601 c->irq.Attributes = req->Attributes;
1602 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1605 c->state |= CONFIG_IRQ_REQ;
1606 handle->state |= CLIENT_IRQ_REQ;
1608 #ifdef CONFIG_PCMCIA_PROBE
1609 pcmcia_used_irq[irq]++;
1613 } /* pcmcia_request_irq */
1615 /*======================================================================
1617 Request_window() establishes a mapping between card memory space
1618 and system memory space.
1620 ======================================================================*/
1622 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1624 struct pcmcia_socket *s;
1629 if (CHECK_HANDLE(*handle))
1630 return CS_BAD_HANDLE;
1631 s = (*handle)->Socket;
1632 if (!(s->state & SOCKET_PRESENT))
1634 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1635 return CS_BAD_ATTRIBUTE;
1637 /* Window size defaults to smallest available */
1639 req->Size = s->map_size;
1640 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1641 (req->Attributes & WIN_STRICT_ALIGN)) ?
1642 req->Size : s->map_size);
1643 if (req->Size & (s->map_size-1))
1645 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1646 (req->Base & (align-1)))
1651 /* Allocate system memory window */
1652 for (w = 0; w < MAX_WIN; w++)
1653 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1655 return CS_OUT_OF_RESOURCE;
1658 win->magic = WINDOW_MAGIC;
1660 win->handle = *handle;
1663 if (!(s->features & SS_CAP_STATIC_MAP)) {
1664 win->ctl.res = find_mem_region(req->Base, req->Size, align,
1665 (req->Attributes & WIN_MAP_BELOW_1MB), s);
1669 (*handle)->state |= CLIENT_WIN_REQ(w);
1671 /* Configure the socket controller */
1674 win->ctl.speed = req->AccessSpeed;
1675 if (req->Attributes & WIN_MEMORY_TYPE)
1676 win->ctl.flags |= MAP_ATTRIB;
1677 if (req->Attributes & WIN_ENABLE)
1678 win->ctl.flags |= MAP_ACTIVE;
1679 if (req->Attributes & WIN_DATA_WIDTH_16)
1680 win->ctl.flags |= MAP_16BIT;
1681 if (req->Attributes & WIN_USE_WAIT)
1682 win->ctl.flags |= MAP_USE_WAIT;
1683 win->ctl.card_start = 0;
1684 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1686 s->state |= SOCKET_WIN_REQ(w);
1688 /* Return window handle */
1689 if (s->features & SS_CAP_STATIC_MAP) {
1690 req->Base = win->ctl.static_start;
1692 req->Base = win->ctl.res->start;
1697 } /* request_window */
1699 /*======================================================================
1701 I'm not sure which "reset" function this is supposed to use,
1702 but for now, it uses the low-level interface's reset, not the
1705 ======================================================================*/
1707 int pccard_reset_card(struct pcmcia_socket *skt)
1711 cs_dbg(skt, 1, "resetting socket\n");
1713 down(&skt->skt_sem);
1715 if (!(skt->state & SOCKET_PRESENT)) {
1719 if (skt->state & SOCKET_SUSPEND) {
1723 if (skt->state & SOCKET_CARDBUS) {
1724 ret = CS_UNSUPPORTED_FUNCTION;
1728 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1730 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1731 if (socket_reset(skt) == CS_SUCCESS)
1732 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1741 EXPORT_SYMBOL(pccard_reset_card);
1743 /*======================================================================
1745 These shut down or wake up a socket. They are sort of user
1746 initiated versions of the APM suspend and resume actions.
1748 ======================================================================*/
1750 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1754 cs_dbg(skt, 1, "suspending socket\n");
1756 down(&skt->skt_sem);
1758 if (!(skt->state & SOCKET_PRESENT)) {
1762 if (skt->state & SOCKET_CARDBUS) {
1763 ret = CS_UNSUPPORTED_FUNCTION;
1766 ret = socket_suspend(skt);
1771 } /* suspend_card */
1773 int pcmcia_resume_card(struct pcmcia_socket *skt)
1777 cs_dbg(skt, 1, "waking up socket\n");
1779 down(&skt->skt_sem);
1781 if (!(skt->state & SOCKET_PRESENT)) {
1785 if (skt->state & SOCKET_CARDBUS) {
1786 ret = CS_UNSUPPORTED_FUNCTION;
1789 ret = socket_resume(skt);
1796 /*======================================================================
1798 These handle user requests to eject or insert a card.
1800 ======================================================================*/
1802 int pcmcia_eject_card(struct pcmcia_socket *skt)
1806 cs_dbg(skt, 1, "user eject request\n");
1808 down(&skt->skt_sem);
1810 if (!(skt->state & SOCKET_PRESENT)) {
1815 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
1829 int pcmcia_insert_card(struct pcmcia_socket *skt)
1833 cs_dbg(skt, 1, "user insert request\n");
1835 down(&skt->skt_sem);
1837 if (skt->state & SOCKET_PRESENT) {
1841 if (socket_insert(skt) == CS_NO_CARD) {
1852 /*======================================================================
1854 OS-specific module glue goes here
1856 ======================================================================*/
1857 /* in alpha order */
1858 EXPORT_SYMBOL(pcmcia_eject_card);
1859 EXPORT_SYMBOL(pcmcia_get_card_services_info);
1860 EXPORT_SYMBOL(pcmcia_get_mem_page);
1861 EXPORT_SYMBOL(pcmcia_insert_card);
1862 EXPORT_SYMBOL(pcmcia_map_mem_page);
1863 EXPORT_SYMBOL(pcmcia_modify_configuration);
1864 EXPORT_SYMBOL(pcmcia_release_configuration);
1865 EXPORT_SYMBOL(pcmcia_release_io);
1866 EXPORT_SYMBOL(pcmcia_release_irq);
1867 EXPORT_SYMBOL(pcmcia_release_window);
1868 EXPORT_SYMBOL(pcmcia_replace_cis);
1869 EXPORT_SYMBOL(pcmcia_request_configuration);
1870 EXPORT_SYMBOL(pcmcia_request_io);
1871 EXPORT_SYMBOL(pcmcia_request_irq);
1872 EXPORT_SYMBOL(pcmcia_request_window);
1873 EXPORT_SYMBOL(pcmcia_resume_card);
1874 EXPORT_SYMBOL(pcmcia_suspend_card);
1876 EXPORT_SYMBOL(dead_socket);
1877 EXPORT_SYMBOL(pcmcia_parse_events);
1879 struct class pcmcia_socket_class = {
1880 .name = "pcmcia_socket",
1881 .release = pcmcia_release_socket,
1883 EXPORT_SYMBOL(pcmcia_socket_class);
1886 static int __init init_pcmcia_cs(void)
1889 printk(KERN_INFO "%s\n", release);
1890 printk(KERN_INFO " %s\n", options);
1892 ret = class_register(&pcmcia_socket_class);
1895 return class_interface_register(&pccard_sysfs_interface);
1898 static void __exit exit_pcmcia_cs(void)
1900 printk(KERN_INFO "unloading Kernel Card Services\n");
1901 class_interface_unregister(&pccard_sysfs_interface);
1902 class_unregister(&pcmcia_socket_class);
1905 subsys_initcall(init_pcmcia_cs);
1906 module_exit(exit_pcmcia_cs);
1908 /*====================================================================*/