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>
44 #include <linux/interrupt.h>
45 #include <linux/timer.h>
46 #include <linux/ioport.h>
47 #include <linux/delay.h>
49 #include <linux/pci.h>
50 #include <linux/device.h>
51 #include <linux/suspend.h>
52 #include <asm/system.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"
66 #define PCI_OPT " [pci]"
71 #define CB_OPT " [cardbus]"
76 #define PM_OPT " [pm]"
80 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
81 #define OPTIONS " none"
83 #define OPTIONS PCI_OPT CB_OPT PM_OPT
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 */
117 module_param(pc_debug, int, 0644);
119 int cs_debug_level(int level)
121 return pc_debug > level;
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
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)
163 down(&socket->skt_sem);
164 socket_suspend(socket);
165 up(&socket->skt_sem);
167 up_read(&pcmcia_socket_list_rwsem);
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)
181 down(&socket->skt_sem);
182 socket_resume(socket);
183 up(&socket->skt_sem);
185 up_read(&pcmcia_socket_list_rwsem);
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);
197 while (socket->clients) {
198 client = socket->clients;
199 socket->clients = socket->clients->next;
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)
215 if (!socket || !socket->ops || !socket->dev.dev)
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))
228 unsigned int found, i = 1;
229 struct pcmcia_socket *tmp;
232 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
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;
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);
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);
271 pcmcia_parse_events(socket, SS_DETECT);
276 down_write(&pcmcia_socket_list_rwsem);
277 list_del(&socket->socket_list);
278 up_write(&pcmcia_socket_list_rwsem);
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)
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)
320 up_read(&pcmcia_socket_list_rwsem);
323 up_read(&pcmcia_socket_list_rwsem);
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)
344 while (*list != NULL) {
346 *list = tmp->info.next;
347 tmp->region_magic = 0;
352 static int send_event(struct pcmcia_socket *s, event_t event, int priority);
354 static void shutdown_socket(struct pcmcia_socket *s)
358 cs_dbg(s, 1, "shutdown_socket\n");
360 /* Blank out the socket state */
361 s->socket = dead_socket;
363 s->ops->set_socket(s, &s->socket);
364 s->irq.AssignedIRQ = s->irq.Config = 0;
366 destroy_cis_cache(s);
367 #ifdef CONFIG_CARDBUS
375 for (c = &s->clients; *c; ) {
376 if ((*c)->state & CLIENT_UNBOUND) {
384 free_regions(&s->a_region);
385 free_regions(&s->c_region);
389 s->ops->get_status(s, &status);
390 if (status & SS_POWERON) {
391 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
394 } /* shutdown_socket */
396 /*======================================================================
398 The central event handler. Send_event() sends an event to all
399 valid clients. Parse_events() interprets the event bits from
400 a card status change report. Do_shutdown() handles the high
401 priority stuff associated with a card removal.
403 ======================================================================*/
405 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
407 client_t *client = s->clients;
409 cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
412 if (s->state & SOCKET_CARDBUS)
414 for (; client; client = client->next) {
415 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
417 if (client->EventMask & event) {
418 ret = EVENT(client, event, priority);
426 static void socket_remove_drivers(struct pcmcia_socket *skt)
430 cs_dbg(skt, 4, "remove_drivers\n");
432 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
434 for (client = skt->clients; client; client = client->next)
435 if (!(client->Attributes & INFO_MASTER_CLIENT))
436 client->state |= CLIENT_STALE;
439 static void socket_shutdown(struct pcmcia_socket *skt)
441 cs_dbg(skt, 4, "shutdown\n");
443 socket_remove_drivers(skt);
444 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
445 msleep(shutdown_delay * 10);
446 skt->state &= SOCKET_INUSE;
447 shutdown_socket(skt);
450 static int socket_reset(struct pcmcia_socket *skt)
454 cs_dbg(skt, 4, "reset\n");
456 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
457 skt->ops->set_socket(skt, &skt->socket);
458 udelay((long)reset_time);
460 skt->socket.flags &= ~SS_RESET;
461 skt->ops->set_socket(skt, &skt->socket);
463 msleep(unreset_delay * 10);
464 for (i = 0; i < unreset_limit; i++) {
465 skt->ops->get_status(skt, &status);
467 if (!(status & SS_DETECT))
470 if (status & SS_READY)
473 msleep(unreset_check * 10);
476 cs_err(skt, "time out after reset.\n");
477 return CS_GENERAL_FAILURE;
480 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
484 cs_dbg(skt, 4, "setup\n");
486 skt->ops->get_status(skt, &status);
487 if (!(status & SS_DETECT))
490 msleep(initial_delay * 10);
492 for (i = 0; i < 100; i++) {
493 skt->ops->get_status(skt, &status);
494 if (!(status & SS_DETECT))
497 if (!(status & SS_PENDING))
503 if (status & SS_PENDING) {
504 cs_err(skt, "voltage interrogation timed out.\n");
505 return CS_GENERAL_FAILURE;
508 if (status & SS_CARDBUS) {
509 skt->state |= SOCKET_CARDBUS;
510 #ifndef CONFIG_CARDBUS
511 cs_err(skt, "cardbus cards are not supported.\n");
517 * Decode the card voltage requirements, and apply power to the card.
519 if (status & SS_3VCARD)
520 skt->socket.Vcc = skt->socket.Vpp = 33;
521 else if (!(status & SS_XVCARD))
522 skt->socket.Vcc = skt->socket.Vpp = 50;
524 cs_err(skt, "unsupported voltage key.\n");
527 skt->socket.flags = 0;
528 skt->ops->set_socket(skt, &skt->socket);
531 * Wait "vcc_settle" for the supply to stabilise.
533 msleep(vcc_settle * 10);
535 skt->ops->get_status(skt, &status);
536 if (!(status & SS_POWERON)) {
537 cs_err(skt, "unable to apply power.\n");
541 return socket_reset(skt);
545 * Handle card insertion. Setup the socket, reset the card,
546 * and then tell the rest of PCMCIA that a card is present.
548 static int socket_insert(struct pcmcia_socket *skt)
552 cs_dbg(skt, 4, "insert\n");
554 if (!cs_socket_get(skt))
557 ret = socket_setup(skt, setup_delay);
558 if (ret == CS_SUCCESS) {
559 skt->state |= SOCKET_PRESENT;
560 #ifdef CONFIG_CARDBUS
561 if (skt->state & SOCKET_CARDBUS) {
563 skt->state |= SOCKET_CARDBUS_CONFIG;
566 cs_dbg(skt, 4, "insert done\n");
568 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
570 socket_shutdown(skt);
577 static int socket_suspend(struct pcmcia_socket *skt)
579 if (skt->state & SOCKET_SUSPEND)
582 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
583 skt->socket = dead_socket;
584 skt->ops->suspend(skt);
585 skt->state |= SOCKET_SUSPEND;
591 * Resume a socket. If a card is present, verify its CIS against
592 * our cached copy. If they are different, the card has been
593 * replaced, and we need to tell the drivers.
595 static int socket_resume(struct pcmcia_socket *skt)
599 if (!(skt->state & SOCKET_SUSPEND))
602 skt->socket = dead_socket;
604 skt->ops->set_socket(skt, &skt->socket);
606 ret = socket_setup(skt, resume_delay);
607 if (ret == CS_SUCCESS) {
609 * FIXME: need a better check here for cardbus cards.
611 if (verify_cis_cache(skt) != 0) {
612 cs_dbg(skt, 4, "cis mismatch - different card\n");
613 socket_remove_drivers(skt);
614 destroy_cis_cache(skt);
616 * Workaround: give DS time to schedule removal.
617 * Remove me once the 100ms delay is eliminated
621 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
623 cs_dbg(skt, 4, "cis matches cache\n");
624 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
627 socket_shutdown(skt);
631 skt->state &= ~SOCKET_SUSPEND;
636 static void socket_remove(struct pcmcia_socket *skt)
638 socket_shutdown(skt);
643 * Process a socket card detect status change.
645 * If we don't have a card already present, delay the detect event for
646 * about 20ms (to be on the safe side) before reading the socket status.
648 * Some i82365-based systems send multiple SS_DETECT events during card
649 * insertion, and the "card present" status bit seems to bounce. This
650 * will probably be true with GPIO-based card detection systems after
651 * the product has aged.
653 static void socket_detect_change(struct pcmcia_socket *skt)
655 if (!(skt->state & SOCKET_SUSPEND)) {
658 if (!(skt->state & SOCKET_PRESENT))
661 skt->ops->get_status(skt, &status);
662 if ((skt->state & SOCKET_PRESENT) &&
663 !(status & SS_DETECT))
665 if (!(skt->state & SOCKET_PRESENT) &&
666 (status & SS_DETECT))
671 static int pccardd(void *__skt)
673 struct pcmcia_socket *skt = __skt;
674 DECLARE_WAITQUEUE(wait, current);
677 daemonize("pccardd");
679 skt->thread = current;
680 skt->socket = dead_socket;
682 skt->ops->set_socket(skt, &skt->socket);
684 /* register with the device core */
685 ret = class_device_register(&skt->dev);
687 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
690 complete_and_exit(&skt->thread_done, 0);
692 complete(&skt->thread_done);
694 add_wait_queue(&skt->thread_wait, &wait);
699 set_current_state(TASK_INTERRUPTIBLE);
701 spin_lock_irqsave(&skt->thread_lock, flags);
702 events = skt->thread_events;
703 skt->thread_events = 0;
704 spin_unlock_irqrestore(&skt->thread_lock, flags);
708 if (events & SS_DETECT)
709 socket_detect_change(skt);
710 if (events & SS_BATDEAD)
711 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
712 if (events & SS_BATWARN)
713 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
714 if (events & SS_READY)
715 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
721 if (current->flags & PF_FREEZE)
722 refrigerator(PF_FREEZE);
727 remove_wait_queue(&skt->thread_wait, &wait);
729 /* remove from the device core */
730 class_device_unregister(&skt->dev);
732 complete_and_exit(&skt->thread_done, 0);
736 * Yenta (at least) probes interrupts before registering the socket and
737 * starting the handler thread.
739 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
741 cs_dbg(s, 4, "parse_events: events %08x\n", events);
743 spin_lock(&s->thread_lock);
744 s->thread_events |= events;
745 spin_unlock(&s->thread_lock);
747 wake_up(&s->thread_wait);
749 } /* pcmcia_parse_events */
752 /*======================================================================
754 Special stuff for managing IO windows, because they are scarce.
756 ======================================================================*/
758 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
759 ioaddr_t num, u_int lines, char *name)
764 align = (*base) ? (lines ? 1<<lines : 0) : 1;
765 if (align && (align < num)) {
767 cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
771 while (align && (align < num)) align <<= 1;
773 if (*base & ~(align-1)) {
774 cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
778 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
779 *base = s->io_offset | (*base & 0x0fff);
782 /* Check for an already-allocated window that must conflict with
783 what was asked for. It is a hack because it does not catch all
784 potential conflicts, just the most obvious ones. */
785 for (i = 0; i < MAX_IO_WIN; i++)
786 if ((s->io[i].NumPorts != 0) &&
787 ((s->io[i].BasePort & (align-1)) == *base))
789 for (i = 0; i < MAX_IO_WIN; i++) {
790 if (s->io[i].NumPorts == 0) {
791 s->io[i].res = find_io_region(*base, num, align, name, s);
793 s->io[i].Attributes = attr;
794 s->io[i].BasePort = *base = s->io[i].res->start;
795 s->io[i].NumPorts = s->io[i].InUse = num;
799 } else if (s->io[i].Attributes != attr)
801 /* Try to extend top of window */
802 try = s->io[i].BasePort + s->io[i].NumPorts;
803 if ((*base == 0) || (*base == try))
804 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
805 s->io[i].res->end + num, s) == 0) {
807 s->io[i].NumPorts += num;
808 s->io[i].InUse += num;
811 /* Try to extend bottom of window */
812 try = s->io[i].BasePort - num;
813 if ((*base == 0) || (*base == try))
814 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
815 s->io[i].res->end, s) == 0) {
816 s->io[i].BasePort = *base = try;
817 s->io[i].NumPorts += num;
818 s->io[i].InUse += num;
822 return (i == MAX_IO_WIN);
823 } /* alloc_io_space */
825 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
830 for (i = 0; i < MAX_IO_WIN; i++) {
831 if ((s->io[i].BasePort <= base) &&
832 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
833 s->io[i].InUse -= num;
834 /* Free the window if no one else is using it */
835 if (s->io[i].InUse == 0) {
836 s->io[i].NumPorts = 0;
837 release_resource(s->io[i].res);
845 /*======================================================================
847 Access_configuration_register() reads and writes configuration
848 registers in attribute memory. Memory window 0 is reserved for
849 this and the tuple reading services.
851 ======================================================================*/
853 int pccard_access_configuration_register(struct pcmcia_socket *s,
854 unsigned int function,
861 if (!s || !s->config)
864 c = &s->config[function];
869 if (!(c->state & CONFIG_LOCKED))
870 return CS_CONFIGURATION_LOCKED;
872 addr = (c->ConfigBase + reg->Offset) >> 1;
874 switch (reg->Action) {
876 read_cis_mem(s, 1, addr, 1, &val);
881 write_cis_mem(s, 1, addr, 1, &val);
888 } /* access_configuration_register */
889 EXPORT_SYMBOL(pccard_access_configuration_register);
891 /*====================================================================*/
893 int pcmcia_deregister_client(client_handle_t handle)
896 struct pcmcia_socket *s;
900 if (CHECK_HANDLE(handle))
901 return CS_BAD_HANDLE;
904 cs_dbg(s, 1, "deregister_client(%p)\n", handle);
907 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
909 for (i = 0; i < MAX_WIN; i++)
910 if (handle->state & CLIENT_WIN_REQ(i))
913 if ((handle->state & CLIENT_STALE) ||
914 (handle->Attributes & INFO_MASTER_CLIENT)) {
915 spin_lock_irqsave(&s->lock, flags);
916 client = &s->clients;
917 while ((*client) && ((*client) != handle))
918 client = &(*client)->next;
919 if (*client == NULL) {
920 spin_unlock_irqrestore(&s->lock, flags);
921 return CS_BAD_HANDLE;
923 *client = handle->next;
924 handle->client_magic = 0;
926 spin_unlock_irqrestore(&s->lock, flags);
928 handle->state = CLIENT_UNBOUND;
929 handle->event_handler = NULL;
933 } /* deregister_client */
935 /*====================================================================*/
937 int pccard_get_configuration_info(struct pcmcia_socket *s,
938 unsigned int function,
939 config_info_t *config)
943 if (!(s->state & SOCKET_PRESENT))
946 config->Function = function;
948 #ifdef CONFIG_CARDBUS
949 if (s->state & SOCKET_CARDBUS) {
950 memset(config, 0, sizeof(config_info_t));
951 config->Vcc = s->socket.Vcc;
952 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
953 config->Option = s->cb_dev->subordinate->number;
954 if (s->state & SOCKET_CARDBUS_CONFIG) {
955 config->Attributes = CONF_VALID_CLIENT;
956 config->IntType = INT_CARDBUS;
957 config->AssignedIRQ = s->irq.AssignedIRQ;
958 if (config->AssignedIRQ)
959 config->Attributes |= CONF_ENABLE_IRQ;
960 config->BasePort1 = s->io[0].BasePort;
961 config->NumPorts1 = s->io[0].NumPorts;
967 c = (s->config != NULL) ? &s->config[function] : NULL;
969 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
970 config->Attributes = 0;
971 config->Vcc = s->socket.Vcc;
972 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
976 /* !!! This is a hack !!! */
977 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
978 config->Attributes |= CONF_VALID_CLIENT;
979 config->CardValues = c->CardValues;
980 config->IRQAttributes = c->irq.Attributes;
981 config->AssignedIRQ = s->irq.AssignedIRQ;
982 config->BasePort1 = c->io.BasePort1;
983 config->NumPorts1 = c->io.NumPorts1;
984 config->Attributes1 = c->io.Attributes1;
985 config->BasePort2 = c->io.BasePort2;
986 config->NumPorts2 = c->io.NumPorts2;
987 config->Attributes2 = c->io.Attributes2;
988 config->IOAddrLines = c->io.IOAddrLines;
991 } /* get_configuration_info */
992 EXPORT_SYMBOL(pccard_get_configuration_info);
994 /*======================================================================
996 Return information about this version of Card Services.
998 ======================================================================*/
1000 int pcmcia_get_card_services_info(servinfo_t *info)
1002 unsigned int socket_count = 0;
1003 struct list_head *tmp;
1004 info->Signature[0] = 'C';
1005 info->Signature[1] = 'S';
1006 down_read(&pcmcia_socket_list_rwsem);
1007 list_for_each(tmp, &pcmcia_socket_list)
1009 up_read(&pcmcia_socket_list_rwsem);
1010 info->Count = socket_count;
1011 info->Revision = CS_RELEASE_CODE;
1012 info->CSLevel = 0x0210;
1013 info->VendorString = (char *)release;
1015 } /* get_card_services_info */
1017 #ifdef CONFIG_PCMCIA_OBSOLETE
1019 /*======================================================================
1021 Note that get_first_client() *does* recognize the Socket field
1022 in the request structure.
1024 ======================================================================*/
1026 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1029 struct pcmcia_socket *socket;
1030 if (req->Attributes & CLIENT_THIS_SOCKET)
1034 socket = pcmcia_get_socket_by_nr(s);
1036 return CS_BAD_SOCKET;
1037 if (socket->clients == NULL)
1038 return CS_NO_MORE_ITEMS;
1039 *handle = socket->clients;
1041 } /* get_first_client */
1042 EXPORT_SYMBOL(pcmcia_get_first_client);
1044 /*====================================================================*/
1046 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1048 struct pcmcia_socket *s;
1049 if ((handle == NULL) || CHECK_HANDLE(*handle))
1050 return CS_BAD_HANDLE;
1051 if ((*handle)->next == NULL) {
1052 if (req->Attributes & CLIENT_THIS_SOCKET)
1053 return CS_NO_MORE_ITEMS;
1054 s = (*handle)->Socket;
1055 if (s->clients == NULL)
1056 return CS_NO_MORE_ITEMS;
1057 *handle = s->clients;
1059 *handle = (*handle)->next;
1061 } /* get_next_client */
1062 EXPORT_SYMBOL(pcmcia_get_next_client);
1063 #endif /* CONFIG_PCMCIA_OBSOLETE */
1065 /*====================================================================*/
1067 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
1072 if (!s || !(s->state & SOCKET_PRESENT))
1074 for (w = idx; w < MAX_WIN; w++)
1075 if (s->state & SOCKET_WIN_REQ(w)) break;
1077 return CS_NO_MORE_ITEMS;
1079 req->Base = win->ctl.res->start;
1080 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
1081 req->AccessSpeed = win->ctl.speed;
1082 req->Attributes = 0;
1083 if (win->ctl.flags & MAP_ATTRIB)
1084 req->Attributes |= WIN_MEMORY_TYPE_AM;
1085 if (win->ctl.flags & MAP_ACTIVE)
1086 req->Attributes |= WIN_ENABLE;
1087 if (win->ctl.flags & MAP_16BIT)
1088 req->Attributes |= WIN_DATA_WIDTH_16;
1089 if (win->ctl.flags & MAP_USE_WAIT)
1090 req->Attributes |= WIN_USE_WAIT;
1094 EXPORT_SYMBOL(pcmcia_get_window);
1096 /*=====================================================================
1098 Return the PCI device associated with a card..
1100 ======================================================================*/
1102 #ifdef CONFIG_CARDBUS
1104 struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
1106 if (!s || !(s->state & SOCKET_CARDBUS))
1109 return s->cb_dev->subordinate;
1112 EXPORT_SYMBOL(pcmcia_lookup_bus);
1116 /*======================================================================
1118 Get the current socket state bits. We don't support the latched
1119 SocketState yet: I haven't seen any point for it.
1121 ======================================================================*/
1123 int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
1128 s->ops->get_status(s, &val);
1129 status->CardState = status->SocketState = 0;
1130 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1131 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1132 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1133 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1134 if (s->state & SOCKET_SUSPEND)
1135 status->CardState |= CS_EVENT_PM_SUSPEND;
1136 if (!(s->state & SOCKET_PRESENT))
1139 c = (s->config != NULL) ? &s->config[function] : NULL;
1140 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1141 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1143 if (c->Present & PRESENT_PIN_REPLACE) {
1144 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1145 status->CardState |=
1146 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1147 status->CardState |=
1148 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1149 status->CardState |=
1150 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1151 status->CardState |=
1152 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1154 /* No PRR? Then assume we're always ready */
1155 status->CardState |= CS_EVENT_READY_CHANGE;
1157 if (c->Present & PRESENT_EXT_STATUS) {
1158 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1159 status->CardState |=
1160 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1164 status->CardState |=
1165 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1166 status->CardState |=
1167 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1168 status->CardState |=
1169 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1170 status->CardState |=
1171 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1174 EXPORT_SYMBOL(pccard_get_status);
1176 /*======================================================================
1178 Change the card address of an already open memory window.
1180 ======================================================================*/
1182 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1184 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1185 return CS_BAD_HANDLE;
1187 req->CardOffset = win->ctl.card_start;
1189 } /* get_mem_page */
1191 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1193 struct pcmcia_socket *s;
1194 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1195 return CS_BAD_HANDLE;
1199 win->ctl.card_start = req->CardOffset;
1200 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1201 return CS_BAD_OFFSET;
1203 } /* map_mem_page */
1205 /*======================================================================
1207 Modify a locked socket configuration
1209 ======================================================================*/
1211 int pcmcia_modify_configuration(client_handle_t handle,
1214 struct pcmcia_socket *s;
1217 if (CHECK_HANDLE(handle))
1218 return CS_BAD_HANDLE;
1219 s = SOCKET(handle); c = CONFIG(handle);
1220 if (!(s->state & SOCKET_PRESENT))
1222 if (!(c->state & CONFIG_LOCKED))
1223 return CS_CONFIGURATION_LOCKED;
1225 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1226 if (mod->Attributes & CONF_ENABLE_IRQ) {
1227 c->Attributes |= CONF_ENABLE_IRQ;
1228 s->socket.io_irq = s->irq.AssignedIRQ;
1230 c->Attributes &= ~CONF_ENABLE_IRQ;
1231 s->socket.io_irq = 0;
1233 s->ops->set_socket(s, &s->socket);
1236 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1239 /* We only allow changing Vpp1 and Vpp2 to the same value */
1240 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1241 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1242 if (mod->Vpp1 != mod->Vpp2)
1244 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1245 if (s->ops->set_socket(s, &s->socket))
1247 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1248 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1252 } /* modify_configuration */
1254 #ifdef CONFIG_PCMCIA_OBSOLETE
1256 /*======================================================================
1258 Modify the attributes of a window returned by RequestWindow.
1260 ======================================================================*/
1262 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1264 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1265 return CS_BAD_HANDLE;
1267 win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1268 if (req->Attributes & WIN_MEMORY_TYPE)
1269 win->ctl.flags |= MAP_ATTRIB;
1270 if (req->Attributes & WIN_ENABLE)
1271 win->ctl.flags |= MAP_ACTIVE;
1272 if (req->Attributes & WIN_DATA_WIDTH_16)
1273 win->ctl.flags |= MAP_16BIT;
1274 if (req->Attributes & WIN_USE_WAIT)
1275 win->ctl.flags |= MAP_USE_WAIT;
1276 win->ctl.speed = req->AccessSpeed;
1277 win->sock->ops->set_mem_map(win->sock, &win->ctl);
1280 } /* modify_window */
1281 EXPORT_SYMBOL(pcmcia_modify_window);
1283 #endif /* CONFIG_PCMCIA_OBSOLETE */
1286 /*======================================================================
1288 Register_client() uses the dev_info_t handle to match the
1289 caller with a socket. The driver must have already been bound
1290 to a socket with bind_device() -- in fact, bind_device()
1291 allocates the client structure that will be used.
1293 ======================================================================*/
1295 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1297 client_t *client = NULL;
1298 struct pcmcia_socket *s;
1300 /* Look for unbound client with matching dev_info */
1301 down_read(&pcmcia_socket_list_rwsem);
1302 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1303 client = s->clients;
1304 while (client != NULL) {
1305 if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1306 && (client->state & CLIENT_UNBOUND)) break;
1307 client = client->next;
1309 if (client != NULL) break;
1311 up_read(&pcmcia_socket_list_rwsem);
1313 return CS_OUT_OF_RESOURCE;
1316 * Prevent this racing with a card insertion.
1320 client->state &= ~CLIENT_UNBOUND;
1322 client->Attributes = req->Attributes;
1323 client->EventMask = req->EventMask;
1324 client->event_handler = req->event_handler;
1325 client->event_callback_args = req->event_callback_args;
1326 client->event_callback_args.client_handle = client;
1328 if (s->state & SOCKET_CARDBUS)
1329 client->state |= CLIENT_CARDBUS;
1331 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1332 (client->Function != BIND_FN_ALL)) {
1333 cistpl_longlink_mfc_t mfc;
1334 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1336 s->functions = mfc.nfn;
1339 s->config = kmalloc(sizeof(config_t) * s->functions,
1342 goto out_no_resource;
1343 memset(s->config, 0, sizeof(config_t) * s->functions);
1346 cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1347 client, client->dev_info);
1348 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1349 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1351 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1352 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1353 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1355 client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1363 return CS_OUT_OF_RESOURCE;
1364 } /* register_client */
1366 /*====================================================================*/
1368 int pcmcia_release_configuration(client_handle_t handle)
1370 pccard_io_map io = { 0, 0, 0, 0, 1 };
1371 struct pcmcia_socket *s;
1374 if (CHECK_HANDLE(handle) ||
1375 !(handle->state & CLIENT_CONFIG_LOCKED))
1376 return CS_BAD_HANDLE;
1377 handle->state &= ~CLIENT_CONFIG_LOCKED;
1380 #ifdef CONFIG_CARDBUS
1381 if (handle->state & CLIENT_CARDBUS)
1385 if (!(handle->state & CLIENT_STALE)) {
1386 config_t *c = CONFIG(handle);
1387 if (--(s->lock_count) == 0) {
1388 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1390 s->socket.io_irq = 0;
1391 s->ops->set_socket(s, &s->socket);
1393 if (c->state & CONFIG_IO_REQ)
1394 for (i = 0; i < MAX_IO_WIN; i++) {
1395 if (s->io[i].NumPorts == 0)
1398 if (s->io[i].Config != 0)
1401 s->ops->set_io_map(s, &io);
1403 c->state &= ~CONFIG_LOCKED;
1407 } /* release_configuration */
1409 /*======================================================================
1411 Release_io() releases the I/O ranges allocated by a client. This
1412 may be invoked some time after a card ejection has already dumped
1413 the actual socket configuration, so if the client is "stale", we
1414 don't bother checking the port ranges against the current socket
1417 ======================================================================*/
1419 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1421 struct pcmcia_socket *s;
1423 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1424 return CS_BAD_HANDLE;
1425 handle->state &= ~CLIENT_IO_REQ;
1428 #ifdef CONFIG_CARDBUS
1429 if (handle->state & CLIENT_CARDBUS)
1433 if (!(handle->state & CLIENT_STALE)) {
1434 config_t *c = CONFIG(handle);
1435 if (c->state & CONFIG_LOCKED)
1436 return CS_CONFIGURATION_LOCKED;
1437 if ((c->io.BasePort1 != req->BasePort1) ||
1438 (c->io.NumPorts1 != req->NumPorts1) ||
1439 (c->io.BasePort2 != req->BasePort2) ||
1440 (c->io.NumPorts2 != req->NumPorts2))
1442 c->state &= ~CONFIG_IO_REQ;
1445 release_io_space(s, req->BasePort1, req->NumPorts1);
1447 release_io_space(s, req->BasePort2, req->NumPorts2);
1452 /*====================================================================*/
1454 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1456 struct pcmcia_socket *s;
1457 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1458 return CS_BAD_HANDLE;
1459 handle->state &= ~CLIENT_IRQ_REQ;
1462 if (!(handle->state & CLIENT_STALE)) {
1463 config_t *c = CONFIG(handle);
1464 if (c->state & CONFIG_LOCKED)
1465 return CS_CONFIGURATION_LOCKED;
1466 if (c->irq.Attributes != req->Attributes)
1467 return CS_BAD_ATTRIBUTE;
1468 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1470 if (--s->irq.Config == 0) {
1471 c->state &= ~CONFIG_IRQ_REQ;
1472 s->irq.AssignedIRQ = 0;
1476 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1477 free_irq(req->AssignedIRQ, req->Instance);
1480 #ifdef CONFIG_PCMCIA_PROBE
1481 if (req->AssignedIRQ != s->pci_irq)
1482 undo_irq(req->Attributes, req->AssignedIRQ);
1486 } /* cs_release_irq */
1488 /*====================================================================*/
1490 int pcmcia_release_window(window_handle_t win)
1492 struct pcmcia_socket *s;
1494 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1495 return CS_BAD_HANDLE;
1497 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1498 return CS_BAD_HANDLE;
1500 /* Shut down memory window */
1501 win->ctl.flags &= ~MAP_ACTIVE;
1502 s->ops->set_mem_map(s, &win->ctl);
1503 s->state &= ~SOCKET_WIN_REQ(win->index);
1505 /* Release system memory */
1507 release_resource(win->ctl.res);
1508 kfree(win->ctl.res);
1509 win->ctl.res = NULL;
1511 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1516 } /* release_window */
1518 /*====================================================================*/
1520 int pcmcia_request_configuration(client_handle_t handle,
1525 struct pcmcia_socket *s;
1527 pccard_io_map iomap;
1529 if (CHECK_HANDLE(handle))
1530 return CS_BAD_HANDLE;
1532 if (!(s->state & SOCKET_PRESENT))
1535 #ifdef CONFIG_CARDBUS
1536 if (handle->state & CLIENT_CARDBUS)
1537 return CS_UNSUPPORTED_MODE;
1540 if (req->IntType & INT_CARDBUS)
1541 return CS_UNSUPPORTED_MODE;
1543 if (c->state & CONFIG_LOCKED)
1544 return CS_CONFIGURATION_LOCKED;
1546 /* Do power control. We don't allow changes in Vcc. */
1547 if (s->socket.Vcc != req->Vcc)
1549 if (req->Vpp1 != req->Vpp2)
1551 s->socket.Vpp = req->Vpp1;
1552 if (s->ops->set_socket(s, &s->socket))
1555 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1557 /* Pick memory or I/O card, DMA mode, interrupt */
1558 c->IntType = req->IntType;
1559 c->Attributes = req->Attributes;
1560 if (req->IntType & INT_MEMORY_AND_IO)
1561 s->socket.flags |= SS_IOCARD;
1562 if (req->IntType & INT_ZOOMED_VIDEO)
1563 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1564 if (req->Attributes & CONF_ENABLE_DMA)
1565 s->socket.flags |= SS_DMA_MODE;
1566 if (req->Attributes & CONF_ENABLE_SPKR)
1567 s->socket.flags |= SS_SPKR_ENA;
1568 if (req->Attributes & CONF_ENABLE_IRQ)
1569 s->socket.io_irq = s->irq.AssignedIRQ;
1571 s->socket.io_irq = 0;
1572 s->ops->set_socket(s, &s->socket);
1575 /* Set up CIS configuration registers */
1576 base = c->ConfigBase = req->ConfigBase;
1577 c->Present = c->CardValues = req->Present;
1578 if (req->Present & PRESENT_COPY) {
1579 c->Copy = req->Copy;
1580 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1582 if (req->Present & PRESENT_OPTION) {
1583 if (s->functions == 1) {
1584 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1586 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1587 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1588 if (req->Present & PRESENT_IOBASE_0)
1589 c->Option |= COR_ADDR_DECODE;
1591 if (c->state & CONFIG_IRQ_REQ)
1592 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1593 c->Option |= COR_LEVEL_REQ;
1594 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1597 if (req->Present & PRESENT_STATUS) {
1598 c->Status = req->Status;
1599 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1601 if (req->Present & PRESENT_PIN_REPLACE) {
1603 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1605 if (req->Present & PRESENT_EXT_STATUS) {
1606 c->ExtStatus = req->ExtStatus;
1607 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1609 if (req->Present & PRESENT_IOBASE_0) {
1610 u_char b = c->io.BasePort1 & 0xff;
1611 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1612 b = (c->io.BasePort1 >> 8) & 0xff;
1613 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1615 if (req->Present & PRESENT_IOSIZE) {
1616 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1617 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1620 /* Configure I/O windows */
1621 if (c->state & CONFIG_IO_REQ) {
1622 iomap.speed = io_speed;
1623 for (i = 0; i < MAX_IO_WIN; i++)
1624 if (s->io[i].NumPorts != 0) {
1626 iomap.flags = MAP_ACTIVE;
1627 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1628 case IO_DATA_PATH_WIDTH_16:
1629 iomap.flags |= MAP_16BIT; break;
1630 case IO_DATA_PATH_WIDTH_AUTO:
1631 iomap.flags |= MAP_AUTOSZ; break;
1635 iomap.start = s->io[i].BasePort;
1636 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1637 s->ops->set_io_map(s, &iomap);
1642 c->state |= CONFIG_LOCKED;
1643 handle->state |= CLIENT_CONFIG_LOCKED;
1645 } /* request_configuration */
1647 /*======================================================================
1649 Request_io() reserves ranges of port addresses for a socket.
1650 I have not implemented range sharing or alias addressing.
1652 ======================================================================*/
1654 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1656 struct pcmcia_socket *s;
1659 if (CHECK_HANDLE(handle))
1660 return CS_BAD_HANDLE;
1662 if (!(s->state & SOCKET_PRESENT))
1665 if (handle->state & CLIENT_CARDBUS) {
1666 #ifdef CONFIG_CARDBUS
1667 handle->state |= CLIENT_IO_REQ;
1670 return CS_UNSUPPORTED_FUNCTION;
1675 return CS_UNSUPPORTED_MODE;
1677 if (c->state & CONFIG_LOCKED)
1678 return CS_CONFIGURATION_LOCKED;
1679 if (c->state & CONFIG_IO_REQ)
1681 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1682 return CS_BAD_ATTRIBUTE;
1683 if ((req->NumPorts2 > 0) &&
1684 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1685 return CS_BAD_ATTRIBUTE;
1687 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1688 req->NumPorts1, req->IOAddrLines,
1692 if (req->NumPorts2) {
1693 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1694 req->NumPorts2, req->IOAddrLines,
1695 handle->dev_info)) {
1696 release_io_space(s, req->BasePort1, req->NumPorts1);
1702 c->state |= CONFIG_IO_REQ;
1703 handle->state |= CLIENT_IO_REQ;
1707 /*======================================================================
1709 Request_irq() reserves an irq for this client.
1711 Also, since Linux only reserves irq's when they are actually
1712 hooked, we don't guarantee that an irq will still be available
1713 when the configuration is locked. Now that I think about it,
1714 there might be a way to fix this using a dummy handler.
1716 ======================================================================*/
1718 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1720 struct pcmcia_socket *s;
1722 int ret = CS_IN_USE, irq = 0;
1724 if (CHECK_HANDLE(handle))
1725 return CS_BAD_HANDLE;
1727 if (!(s->state & SOCKET_PRESENT))
1730 if (c->state & CONFIG_LOCKED)
1731 return CS_CONFIGURATION_LOCKED;
1732 if (c->state & CONFIG_IRQ_REQ)
1735 #ifdef CONFIG_PCMCIA_PROBE
1736 if (s->irq.AssignedIRQ != 0) {
1737 /* If the interrupt is already assigned, it must match */
1738 irq = s->irq.AssignedIRQ;
1739 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1740 u_int mask = req->IRQInfo2 & s->irq_mask;
1741 ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1743 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1745 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1746 u_int try, mask = req->IRQInfo2 & s->irq_mask;
1747 for (try = 0; try < 2; try++) {
1748 for (irq = 0; irq < 32; irq++)
1749 if ((mask >> irq) & 1) {
1750 ret = try_irq(req->Attributes, irq, try);
1751 if (ret == 0) break;
1753 if (ret == 0) break;
1756 irq = req->IRQInfo1 & IRQ_MASK;
1757 ret = try_irq(req->Attributes, irq, 1);
1767 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1768 if (request_irq(irq, req->Handler,
1769 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1770 (s->functions > 1) ||
1771 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1772 handle->dev_info, req->Instance))
1776 c->irq.Attributes = req->Attributes;
1777 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1780 c->state |= CONFIG_IRQ_REQ;
1781 handle->state |= CLIENT_IRQ_REQ;
1783 } /* pcmcia_request_irq */
1785 /*======================================================================
1787 Request_window() establishes a mapping between card memory space
1788 and system memory space.
1790 ======================================================================*/
1792 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1794 struct pcmcia_socket *s;
1799 if (CHECK_HANDLE(*handle))
1800 return CS_BAD_HANDLE;
1801 s = (*handle)->Socket;
1802 if (!(s->state & SOCKET_PRESENT))
1804 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1805 return CS_BAD_ATTRIBUTE;
1807 /* Window size defaults to smallest available */
1809 req->Size = s->map_size;
1810 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1811 (req->Attributes & WIN_STRICT_ALIGN)) ?
1812 req->Size : s->map_size);
1813 if (req->Size & (s->map_size-1))
1815 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1816 (req->Base & (align-1)))
1821 /* Allocate system memory window */
1822 for (w = 0; w < MAX_WIN; w++)
1823 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1825 return CS_OUT_OF_RESOURCE;
1828 win->magic = WINDOW_MAGIC;
1830 win->handle = *handle;
1833 if (!(s->features & SS_CAP_STATIC_MAP)) {
1834 win->ctl.res = find_mem_region(req->Base, req->Size, align,
1835 (req->Attributes & WIN_MAP_BELOW_1MB),
1836 (*handle)->dev_info, s);
1840 (*handle)->state |= CLIENT_WIN_REQ(w);
1842 /* Configure the socket controller */
1845 win->ctl.speed = req->AccessSpeed;
1846 if (req->Attributes & WIN_MEMORY_TYPE)
1847 win->ctl.flags |= MAP_ATTRIB;
1848 if (req->Attributes & WIN_ENABLE)
1849 win->ctl.flags |= MAP_ACTIVE;
1850 if (req->Attributes & WIN_DATA_WIDTH_16)
1851 win->ctl.flags |= MAP_16BIT;
1852 if (req->Attributes & WIN_USE_WAIT)
1853 win->ctl.flags |= MAP_USE_WAIT;
1854 win->ctl.card_start = 0;
1855 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1857 s->state |= SOCKET_WIN_REQ(w);
1859 /* Return window handle */
1860 if (s->features & SS_CAP_STATIC_MAP) {
1861 req->Base = win->ctl.static_start;
1863 req->Base = win->ctl.res->start;
1868 } /* request_window */
1870 /*======================================================================
1872 I'm not sure which "reset" function this is supposed to use,
1873 but for now, it uses the low-level interface's reset, not the
1876 ======================================================================*/
1878 int pccard_reset_card(struct pcmcia_socket *skt)
1882 cs_dbg(skt, 1, "resetting socket\n");
1884 down(&skt->skt_sem);
1886 if (!(skt->state & SOCKET_PRESENT)) {
1890 if (skt->state & SOCKET_SUSPEND) {
1894 if (skt->state & SOCKET_CARDBUS) {
1895 ret = CS_UNSUPPORTED_FUNCTION;
1899 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1901 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1902 if (socket_reset(skt) == CS_SUCCESS)
1903 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1912 EXPORT_SYMBOL(pccard_reset_card);
1914 /*======================================================================
1916 These shut down or wake up a socket. They are sort of user
1917 initiated versions of the APM suspend and resume actions.
1919 ======================================================================*/
1921 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1925 cs_dbg(skt, 1, "suspending socket\n");
1927 down(&skt->skt_sem);
1929 if (!(skt->state & SOCKET_PRESENT)) {
1933 if (skt->state & SOCKET_CARDBUS) {
1934 ret = CS_UNSUPPORTED_FUNCTION;
1937 ret = socket_suspend(skt);
1942 } /* suspend_card */
1944 int pcmcia_resume_card(struct pcmcia_socket *skt)
1948 cs_dbg(skt, 1, "waking up socket\n");
1950 down(&skt->skt_sem);
1952 if (!(skt->state & SOCKET_PRESENT)) {
1956 if (skt->state & SOCKET_CARDBUS) {
1957 ret = CS_UNSUPPORTED_FUNCTION;
1960 ret = socket_resume(skt);
1967 /*======================================================================
1969 These handle user requests to eject or insert a card.
1971 ======================================================================*/
1973 int pcmcia_eject_card(struct pcmcia_socket *skt)
1977 cs_dbg(skt, 1, "user eject request\n");
1979 down(&skt->skt_sem);
1981 if (!(skt->state & SOCKET_PRESENT)) {
1986 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2000 int pcmcia_insert_card(struct pcmcia_socket *skt)
2004 cs_dbg(skt, 1, "user insert request\n");
2006 down(&skt->skt_sem);
2008 if (skt->state & SOCKET_PRESENT) {
2012 if (socket_insert(skt) == CS_NO_CARD) {
2023 /*======================================================================
2025 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2026 haven't sent one to this client yet?
2028 ======================================================================*/
2030 #ifdef CONFIG_PCMCIA_OBSOLETE
2031 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2034 if (CHECK_HANDLE(handle))
2035 return CS_BAD_HANDLE;
2036 if (handle->Attributes & CONF_EVENT_MASK_VALID)
2037 return CS_BAD_SOCKET;
2038 handle->EventMask = mask->EventMask;
2039 events = handle->PendingEvents & handle->EventMask;
2040 handle->PendingEvents -= events;
2041 while (events != 0) {
2042 bit = ((events ^ (events-1)) + 1) >> 1;
2043 EVENT(handle, bit, CS_EVENT_PRI_LOW);
2047 } /* set_event_mask */
2048 EXPORT_SYMBOL(pcmcia_set_event_mask);
2050 #endif /* CONFIG_PCMCIA_OBSOLETE */
2052 /*======================================================================
2054 OS-specific module glue goes here
2056 ======================================================================*/
2057 /* in alpha order */
2058 EXPORT_SYMBOL(pcmcia_deregister_client);
2059 EXPORT_SYMBOL(pcmcia_eject_card);
2060 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2061 EXPORT_SYMBOL(pcmcia_get_mem_page);
2062 EXPORT_SYMBOL(pcmcia_insert_card);
2063 EXPORT_SYMBOL(pcmcia_map_mem_page);
2064 EXPORT_SYMBOL(pcmcia_modify_configuration);
2065 EXPORT_SYMBOL(pcmcia_register_client);
2066 EXPORT_SYMBOL(pcmcia_release_configuration);
2067 EXPORT_SYMBOL(pcmcia_release_io);
2068 EXPORT_SYMBOL(pcmcia_release_irq);
2069 EXPORT_SYMBOL(pcmcia_release_window);
2070 EXPORT_SYMBOL(pcmcia_replace_cis);
2071 EXPORT_SYMBOL(pcmcia_request_configuration);
2072 EXPORT_SYMBOL(pcmcia_request_io);
2073 EXPORT_SYMBOL(pcmcia_request_irq);
2074 EXPORT_SYMBOL(pcmcia_request_window);
2075 EXPORT_SYMBOL(pcmcia_resume_card);
2076 EXPORT_SYMBOL(pcmcia_suspend_card);
2078 EXPORT_SYMBOL(dead_socket);
2079 EXPORT_SYMBOL(pcmcia_parse_events);
2081 struct class pcmcia_socket_class = {
2082 .name = "pcmcia_socket",
2083 .release = pcmcia_release_socket,
2085 EXPORT_SYMBOL(pcmcia_socket_class);
2088 static int __init init_pcmcia_cs(void)
2091 printk(KERN_INFO "%s\n", release);
2092 printk(KERN_INFO " %s\n", options);
2094 ret = class_register(&pcmcia_socket_class);
2097 return class_interface_register(&pccard_sysfs_interface);
2100 static void __exit exit_pcmcia_cs(void)
2102 printk(KERN_INFO "unloading Kernel Card Services\n");
2103 release_resource_db();
2104 class_interface_unregister(&pccard_sysfs_interface);
2105 class_unregister(&pcmcia_socket_class);
2108 subsys_initcall(init_pcmcia_cs);
2109 module_exit(exit_pcmcia_cs);
2111 /*====================================================================*/