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;
252 socket->erase_busy.next = socket->erase_busy.prev = &socket->erase_busy;
253 INIT_LIST_HEAD(&socket->cis_cache);
254 spin_lock_init(&socket->lock);
256 init_completion(&socket->socket_released);
257 init_completion(&socket->thread_done);
258 init_waitqueue_head(&socket->thread_wait);
259 init_MUTEX(&socket->skt_sem);
260 spin_lock_init(&socket->thread_lock);
262 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
266 wait_for_completion(&socket->thread_done);
267 BUG_ON(!socket->thread);
268 pcmcia_parse_events(socket, SS_DETECT);
273 down_write(&pcmcia_socket_list_rwsem);
274 list_del(&socket->socket_list);
275 up_write(&pcmcia_socket_list_rwsem);
277 } /* pcmcia_register_socket */
278 EXPORT_SYMBOL(pcmcia_register_socket);
282 * pcmcia_unregister_socket - remove a pcmcia socket device
284 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
289 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
291 if (socket->thread) {
292 init_completion(&socket->thread_done);
293 socket->thread = NULL;
294 wake_up(&socket->thread_wait);
295 wait_for_completion(&socket->thread_done);
297 release_cis_mem(socket);
299 /* remove from our own list */
300 down_write(&pcmcia_socket_list_rwsem);
301 list_del(&socket->socket_list);
302 up_write(&pcmcia_socket_list_rwsem);
304 /* wait for sysfs to drop all references */
305 wait_for_completion(&socket->socket_released);
306 } /* pcmcia_unregister_socket */
307 EXPORT_SYMBOL(pcmcia_unregister_socket);
310 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
312 struct pcmcia_socket *s;
314 down_read(&pcmcia_socket_list_rwsem);
315 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
317 up_read(&pcmcia_socket_list_rwsem);
320 up_read(&pcmcia_socket_list_rwsem);
325 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
328 /*======================================================================
330 Shutdown_Socket() and setup_socket() are scheduled using add_timer
331 calls by the main event handler when card insertion and removal
332 events are received. Shutdown_Socket() unconfigures a socket and
333 turns off socket power. Setup_socket() turns on socket power
334 and resets the socket, in two stages.
336 ======================================================================*/
338 static void free_regions(memory_handle_t *list)
341 while (*list != NULL) {
343 *list = tmp->info.next;
344 tmp->region_magic = 0;
349 static int send_event(struct pcmcia_socket *s, event_t event, int priority);
351 static void shutdown_socket(struct pcmcia_socket *s)
355 cs_dbg(s, 1, "shutdown_socket\n");
357 /* Blank out the socket state */
358 s->socket = dead_socket;
360 s->ops->set_socket(s, &s->socket);
361 s->irq.AssignedIRQ = s->irq.Config = 0;
363 destroy_cis_cache(s);
368 #ifdef CONFIG_CARDBUS
376 for (c = &s->clients; *c; ) {
377 if ((*c)->state & CLIENT_UNBOUND) {
385 free_regions(&s->a_region);
386 free_regions(&s->c_region);
390 s->ops->get_status(s, &status);
391 if (status & SS_POWERON) {
392 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
395 } /* shutdown_socket */
397 /*======================================================================
399 The central event handler. Send_event() sends an event to all
400 valid clients. Parse_events() interprets the event bits from
401 a card status change report. Do_shutdown() handles the high
402 priority stuff associated with a card removal.
404 ======================================================================*/
406 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
408 client_t *client = s->clients;
410 cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
413 if (s->state & SOCKET_CARDBUS)
415 for (; client; client = client->next) {
416 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
418 if (client->EventMask & event) {
419 ret = EVENT(client, event, priority);
427 #define cs_to_timeout(cs) (((cs) * HZ + 99) / 100)
429 static void socket_remove_drivers(struct pcmcia_socket *skt)
433 cs_dbg(skt, 4, "remove_drivers\n");
435 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
437 for (client = skt->clients; client; client = client->next)
438 if (!(client->Attributes & INFO_MASTER_CLIENT))
439 client->state |= CLIENT_STALE;
442 static void socket_shutdown(struct pcmcia_socket *skt)
444 cs_dbg(skt, 4, "shutdown\n");
446 socket_remove_drivers(skt);
447 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
448 set_current_state(TASK_UNINTERRUPTIBLE);
449 schedule_timeout(cs_to_timeout(shutdown_delay));
450 skt->state &= SOCKET_INUSE;
451 shutdown_socket(skt);
454 static int socket_reset(struct pcmcia_socket *skt)
458 cs_dbg(skt, 4, "reset\n");
460 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
461 skt->ops->set_socket(skt, &skt->socket);
462 udelay((long)reset_time);
464 skt->socket.flags &= ~SS_RESET;
465 skt->ops->set_socket(skt, &skt->socket);
467 set_current_state(TASK_UNINTERRUPTIBLE);
468 schedule_timeout(cs_to_timeout(unreset_delay));
469 for (i = 0; i < unreset_limit; i++) {
470 skt->ops->get_status(skt, &status);
472 if (!(status & SS_DETECT))
475 if (status & SS_READY)
478 set_current_state(TASK_UNINTERRUPTIBLE);
479 schedule_timeout(cs_to_timeout(unreset_check));
482 cs_err(skt, "time out after reset.\n");
483 return CS_GENERAL_FAILURE;
486 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
490 cs_dbg(skt, 4, "setup\n");
492 skt->ops->get_status(skt, &status);
493 if (!(status & SS_DETECT))
496 set_current_state(TASK_UNINTERRUPTIBLE);
497 schedule_timeout(cs_to_timeout(initial_delay));
499 for (i = 0; i < 100; i++) {
500 skt->ops->get_status(skt, &status);
501 if (!(status & SS_DETECT))
504 if (!(status & SS_PENDING))
507 set_current_state(TASK_UNINTERRUPTIBLE);
508 schedule_timeout(cs_to_timeout(10));
511 if (status & SS_PENDING) {
512 cs_err(skt, "voltage interrogation timed out.\n");
513 return CS_GENERAL_FAILURE;
516 if (status & SS_CARDBUS) {
517 skt->state |= SOCKET_CARDBUS;
518 #ifndef CONFIG_CARDBUS
519 cs_err(skt, "cardbus cards are not supported.\n");
525 * Decode the card voltage requirements, and apply power to the card.
527 if (status & SS_3VCARD)
528 skt->socket.Vcc = skt->socket.Vpp = 33;
529 else if (!(status & SS_XVCARD))
530 skt->socket.Vcc = skt->socket.Vpp = 50;
532 cs_err(skt, "unsupported voltage key.\n");
535 skt->socket.flags = 0;
536 skt->ops->set_socket(skt, &skt->socket);
539 * Wait "vcc_settle" for the supply to stabilise.
541 set_current_state(TASK_UNINTERRUPTIBLE);
542 schedule_timeout(cs_to_timeout(vcc_settle));
544 skt->ops->get_status(skt, &status);
545 if (!(status & SS_POWERON)) {
546 cs_err(skt, "unable to apply power.\n");
550 return socket_reset(skt);
554 * Handle card insertion. Setup the socket, reset the card,
555 * and then tell the rest of PCMCIA that a card is present.
557 static int socket_insert(struct pcmcia_socket *skt)
561 cs_dbg(skt, 4, "insert\n");
563 if (!cs_socket_get(skt))
566 ret = socket_setup(skt, setup_delay);
567 if (ret == CS_SUCCESS) {
568 skt->state |= SOCKET_PRESENT;
569 #ifdef CONFIG_CARDBUS
570 if (skt->state & SOCKET_CARDBUS) {
572 skt->state |= SOCKET_CARDBUS_CONFIG;
575 cs_dbg(skt, 4, "insert done\n");
577 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
579 socket_shutdown(skt);
586 static int socket_suspend(struct pcmcia_socket *skt)
588 if (skt->state & SOCKET_SUSPEND)
591 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
592 skt->socket = dead_socket;
593 skt->ops->suspend(skt);
594 skt->state |= SOCKET_SUSPEND;
600 * Resume a socket. If a card is present, verify its CIS against
601 * our cached copy. If they are different, the card has been
602 * replaced, and we need to tell the drivers.
604 static int socket_resume(struct pcmcia_socket *skt)
608 if (!(skt->state & SOCKET_SUSPEND))
611 skt->socket = dead_socket;
613 skt->ops->set_socket(skt, &skt->socket);
615 ret = socket_setup(skt, resume_delay);
616 if (ret == CS_SUCCESS) {
618 * FIXME: need a better check here for cardbus cards.
620 if (verify_cis_cache(skt) != 0) {
621 socket_remove_drivers(skt);
622 destroy_cis_cache(skt);
623 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
625 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
628 socket_shutdown(skt);
632 skt->state &= ~SOCKET_SUSPEND;
637 static void socket_remove(struct pcmcia_socket *skt)
639 socket_shutdown(skt);
644 * Process a socket card detect status change.
646 * If we don't have a card already present, delay the detect event for
647 * about 20ms (to be on the safe side) before reading the socket status.
649 * Some i82365-based systems send multiple SS_DETECT events during card
650 * insertion, and the "card present" status bit seems to bounce. This
651 * will probably be true with GPIO-based card detection systems after
652 * the product has aged.
654 static void socket_detect_change(struct pcmcia_socket *skt)
656 if (!(skt->state & SOCKET_SUSPEND)) {
659 if (!(skt->state & SOCKET_PRESENT)) {
660 set_current_state(TASK_UNINTERRUPTIBLE);
661 schedule_timeout(cs_to_timeout(2));
664 skt->ops->get_status(skt, &status);
665 if ((skt->state & SOCKET_PRESENT) &&
666 !(status & SS_DETECT))
668 if (!(skt->state & SOCKET_PRESENT) &&
669 (status & SS_DETECT))
674 static int pccardd(void *__skt)
676 struct pcmcia_socket *skt = __skt;
677 DECLARE_WAITQUEUE(wait, current);
680 daemonize("pccardd");
681 skt->thread = current;
682 complete(&skt->thread_done);
684 skt->socket = dead_socket;
686 skt->ops->set_socket(skt, &skt->socket);
688 /* register with the device core */
689 ret = class_device_register(&skt->dev);
691 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
695 add_wait_queue(&skt->thread_wait, &wait);
700 set_current_state(TASK_INTERRUPTIBLE);
702 spin_lock_irqsave(&skt->thread_lock, flags);
703 events = skt->thread_events;
704 skt->thread_events = 0;
705 spin_unlock_irqrestore(&skt->thread_lock, flags);
709 if (events & SS_DETECT)
710 socket_detect_change(skt);
711 if (events & SS_BATDEAD)
712 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
713 if (events & SS_BATWARN)
714 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
715 if (events & SS_READY)
716 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
722 if (current->flags & PF_FREEZE)
723 refrigerator(PF_FREEZE);
728 remove_wait_queue(&skt->thread_wait, &wait);
730 /* remove from the device core */
731 class_device_unregister(&skt->dev);
733 complete_and_exit(&skt->thread_done, 0);
737 * Yenta (at least) probes interrupts before registering the socket and
738 * starting the handler thread.
740 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
742 cs_dbg(s, 4, "parse_events: events %08x\n", events);
744 spin_lock(&s->thread_lock);
745 s->thread_events |= events;
746 spin_unlock(&s->thread_lock);
748 wake_up(&s->thread_wait);
750 } /* pcmcia_parse_events */
753 /*======================================================================
755 Special stuff for managing IO windows, because they are scarce.
757 ======================================================================*/
759 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
760 ioaddr_t num, u_int lines, char *name)
765 align = (*base) ? (lines ? 1<<lines : 0) : 1;
766 if (align && (align < num)) {
768 cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
772 while (align && (align < num)) align <<= 1;
774 if (*base & ~(align-1)) {
775 cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
779 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
780 *base = s->io_offset | (*base & 0x0fff);
783 /* Check for an already-allocated window that must conflict with
784 what was asked for. It is a hack because it does not catch all
785 potential conflicts, just the most obvious ones. */
786 for (i = 0; i < MAX_IO_WIN; i++)
787 if ((s->io[i].NumPorts != 0) &&
788 ((s->io[i].BasePort & (align-1)) == *base))
790 for (i = 0; i < MAX_IO_WIN; i++) {
791 if (s->io[i].NumPorts == 0) {
792 s->io[i].res = find_io_region(*base, num, align, name, s);
794 s->io[i].Attributes = attr;
795 s->io[i].BasePort = *base = s->io[i].res->start;
796 s->io[i].NumPorts = s->io[i].InUse = num;
800 } else if (s->io[i].Attributes != attr)
802 /* Try to extend top of window */
803 try = s->io[i].BasePort + s->io[i].NumPorts;
804 if ((*base == 0) || (*base == try))
805 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
806 s->io[i].res->end + num, s) == 0) {
808 s->io[i].NumPorts += num;
809 s->io[i].InUse += num;
812 /* Try to extend bottom of window */
813 try = s->io[i].BasePort - num;
814 if ((*base == 0) || (*base == try))
815 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
816 s->io[i].res->end, s) == 0) {
817 s->io[i].BasePort = *base = try;
818 s->io[i].NumPorts += num;
819 s->io[i].InUse += num;
823 return (i == MAX_IO_WIN);
824 } /* alloc_io_space */
826 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
831 for (i = 0; i < MAX_IO_WIN; i++) {
832 if ((s->io[i].BasePort <= base) &&
833 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
834 s->io[i].InUse -= num;
835 /* Free the window if no one else is using it */
836 if (s->io[i].InUse == 0) {
837 s->io[i].NumPorts = 0;
838 release_resource(s->io[i].res);
846 /*======================================================================
848 Access_configuration_register() reads and writes configuration
849 registers in attribute memory. Memory window 0 is reserved for
850 this and the tuple reading services.
852 ======================================================================*/
854 int pcmcia_access_configuration_register(client_handle_t handle,
857 struct pcmcia_socket *s;
862 if (CHECK_HANDLE(handle))
863 return CS_BAD_HANDLE;
865 if (handle->Function == BIND_FN_ALL) {
866 if (reg->Function >= s->functions)
868 c = &s->config[reg->Function];
875 if (!(c->state & CONFIG_LOCKED))
876 return CS_CONFIGURATION_LOCKED;
878 addr = (c->ConfigBase + reg->Offset) >> 1;
880 switch (reg->Action) {
882 read_cis_mem(s, 1, addr, 1, &val);
887 write_cis_mem(s, 1, addr, 1, &val);
894 } /* access_configuration_register */
897 /*====================================================================*/
899 int pcmcia_deregister_client(client_handle_t handle)
902 struct pcmcia_socket *s;
903 memory_handle_t region;
907 if (CHECK_HANDLE(handle))
908 return CS_BAD_HANDLE;
911 cs_dbg(s, 1, "deregister_client(%p)\n", handle);
914 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
916 for (i = 0; i < MAX_WIN; i++)
917 if (handle->state & CLIENT_WIN_REQ(i))
920 /* Disconnect all MTD links */
921 if (handle->mtd_count) {
922 for (region = s->a_region; region; region = region->info.next)
923 if (region->mtd == handle) region->mtd = NULL;
924 for (region = s->c_region; region; region = region->info.next)
925 if (region->mtd == handle) region->mtd = NULL;
928 if ((handle->state & CLIENT_STALE) ||
929 (handle->Attributes & INFO_MASTER_CLIENT)) {
930 spin_lock_irqsave(&s->lock, flags);
931 client = &s->clients;
932 while ((*client) && ((*client) != handle))
933 client = &(*client)->next;
934 if (*client == NULL) {
935 spin_unlock_irqrestore(&s->lock, flags);
936 return CS_BAD_HANDLE;
938 *client = handle->next;
939 handle->client_magic = 0;
941 spin_unlock_irqrestore(&s->lock, flags);
943 handle->state = CLIENT_UNBOUND;
944 handle->mtd_count = 0;
945 handle->event_handler = NULL;
949 } /* deregister_client */
951 /*====================================================================*/
953 int pcmcia_get_configuration_info(client_handle_t handle,
954 config_info_t *config)
956 struct pcmcia_socket *s;
959 if (CHECK_HANDLE(handle))
960 return CS_BAD_HANDLE;
962 if (!(s->state & SOCKET_PRESENT))
965 if (handle->Function == BIND_FN_ALL) {
966 if (config->Function && (config->Function >= s->functions))
969 config->Function = handle->Function;
971 #ifdef CONFIG_CARDBUS
972 if (s->state & SOCKET_CARDBUS) {
973 u_char fn = config->Function;
974 memset(config, 0, sizeof(config_info_t));
975 config->Function = fn;
976 config->Vcc = s->socket.Vcc;
977 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
978 config->Option = s->cb_dev->subordinate->number;
979 if (s->state & SOCKET_CARDBUS_CONFIG) {
980 config->Attributes = CONF_VALID_CLIENT;
981 config->IntType = INT_CARDBUS;
982 config->AssignedIRQ = s->irq.AssignedIRQ;
983 if (config->AssignedIRQ)
984 config->Attributes |= CONF_ENABLE_IRQ;
985 config->BasePort1 = s->io[0].BasePort;
986 config->NumPorts1 = s->io[0].NumPorts;
992 c = (s->config != NULL) ? &s->config[config->Function] : NULL;
994 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
995 config->Attributes = 0;
996 config->Vcc = s->socket.Vcc;
997 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
1001 /* !!! This is a hack !!! */
1002 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
1003 config->Attributes |= CONF_VALID_CLIENT;
1004 config->CardValues = c->CardValues;
1005 config->IRQAttributes = c->irq.Attributes;
1006 config->AssignedIRQ = s->irq.AssignedIRQ;
1007 config->BasePort1 = c->io.BasePort1;
1008 config->NumPorts1 = c->io.NumPorts1;
1009 config->Attributes1 = c->io.Attributes1;
1010 config->BasePort2 = c->io.BasePort2;
1011 config->NumPorts2 = c->io.NumPorts2;
1012 config->Attributes2 = c->io.Attributes2;
1013 config->IOAddrLines = c->io.IOAddrLines;
1016 } /* get_configuration_info */
1018 /*======================================================================
1020 Return information about this version of Card Services.
1022 ======================================================================*/
1024 int pcmcia_get_card_services_info(servinfo_t *info)
1026 unsigned int socket_count = 0;
1027 struct list_head *tmp;
1028 info->Signature[0] = 'C';
1029 info->Signature[1] = 'S';
1030 down_read(&pcmcia_socket_list_rwsem);
1031 list_for_each(tmp, &pcmcia_socket_list)
1033 up_read(&pcmcia_socket_list_rwsem);
1034 info->Count = socket_count;
1035 info->Revision = CS_RELEASE_CODE;
1036 info->CSLevel = 0x0210;
1037 info->VendorString = (char *)release;
1039 } /* get_card_services_info */
1041 /*======================================================================
1043 Note that get_first_client() *does* recognize the Socket field
1044 in the request structure.
1046 ======================================================================*/
1048 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1051 struct pcmcia_socket *socket;
1052 if (req->Attributes & CLIENT_THIS_SOCKET)
1056 socket = pcmcia_get_socket_by_nr(s);
1058 return CS_BAD_SOCKET;
1059 if (socket->clients == NULL)
1060 return CS_NO_MORE_ITEMS;
1061 *handle = socket->clients;
1063 } /* get_first_client */
1065 /*====================================================================*/
1067 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1069 struct pcmcia_socket *s;
1070 if ((handle == NULL) || CHECK_HANDLE(*handle))
1071 return CS_BAD_HANDLE;
1072 if ((*handle)->next == NULL) {
1073 if (req->Attributes & CLIENT_THIS_SOCKET)
1074 return CS_NO_MORE_ITEMS;
1075 s = (*handle)->Socket;
1076 if (s->clients == NULL)
1077 return CS_NO_MORE_ITEMS;
1078 *handle = s->clients;
1080 *handle = (*handle)->next;
1082 } /* get_next_client */
1084 /*====================================================================*/
1086 int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req)
1088 struct pcmcia_socket *s;
1093 s = ((client_handle_t)*handle)->Socket;
1095 s = (*handle)->sock;
1096 if (!(s->state & SOCKET_PRESENT))
1098 for (w = idx; w < MAX_WIN; w++)
1099 if (s->state & SOCKET_WIN_REQ(w)) break;
1101 return CS_NO_MORE_ITEMS;
1103 req->Base = win->ctl.sys_start;
1104 req->Size = win->ctl.sys_stop - win->ctl.sys_start + 1;
1105 req->AccessSpeed = win->ctl.speed;
1106 req->Attributes = 0;
1107 if (win->ctl.flags & MAP_ATTRIB)
1108 req->Attributes |= WIN_MEMORY_TYPE_AM;
1109 if (win->ctl.flags & MAP_ACTIVE)
1110 req->Attributes |= WIN_ENABLE;
1111 if (win->ctl.flags & MAP_16BIT)
1112 req->Attributes |= WIN_DATA_WIDTH_16;
1113 if (win->ctl.flags & MAP_USE_WAIT)
1114 req->Attributes |= WIN_USE_WAIT;
1119 int pcmcia_get_first_window(window_handle_t *win, win_req_t *req)
1121 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1122 return CS_BAD_HANDLE;
1123 return pcmcia_get_window(win, 0, req);
1126 int pcmcia_get_next_window(window_handle_t *win, win_req_t *req)
1128 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1129 return CS_BAD_HANDLE;
1130 return pcmcia_get_window(win, (*win)->index+1, req);
1133 /*=====================================================================
1135 Return the PCI device associated with a card..
1137 ======================================================================*/
1139 #ifdef CONFIG_CARDBUS
1141 struct pci_bus *pcmcia_lookup_bus(client_handle_t handle)
1143 struct pcmcia_socket *s;
1145 if (CHECK_HANDLE(handle))
1148 if (!(s->state & SOCKET_CARDBUS))
1151 return s->cb_dev->subordinate;
1154 EXPORT_SYMBOL(pcmcia_lookup_bus);
1158 /*======================================================================
1160 Get the current socket state bits. We don't support the latched
1161 SocketState yet: I haven't seen any point for it.
1163 ======================================================================*/
1165 int pcmcia_get_status(client_handle_t handle, cs_status_t *status)
1167 struct pcmcia_socket *s;
1171 if (CHECK_HANDLE(handle))
1172 return CS_BAD_HANDLE;
1174 s->ops->get_status(s, &val);
1175 status->CardState = status->SocketState = 0;
1176 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1177 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1178 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1179 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1180 if (s->state & SOCKET_SUSPEND)
1181 status->CardState |= CS_EVENT_PM_SUSPEND;
1182 if (!(s->state & SOCKET_PRESENT))
1185 /* Get info from the PRR, if necessary */
1186 if (handle->Function == BIND_FN_ALL) {
1187 if (status->Function && (status->Function >= s->functions))
1189 c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1192 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1193 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1195 if (c->Present & PRESENT_PIN_REPLACE) {
1196 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1197 status->CardState |=
1198 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1199 status->CardState |=
1200 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1201 status->CardState |=
1202 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1203 status->CardState |=
1204 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1206 /* No PRR? Then assume we're always ready */
1207 status->CardState |= CS_EVENT_READY_CHANGE;
1209 if (c->Present & PRESENT_EXT_STATUS) {
1210 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1211 status->CardState |=
1212 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1216 status->CardState |=
1217 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1218 status->CardState |=
1219 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1220 status->CardState |=
1221 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1222 status->CardState |=
1223 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1227 /*======================================================================
1229 Change the card address of an already open memory window.
1231 ======================================================================*/
1233 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1235 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1236 return CS_BAD_HANDLE;
1238 req->CardOffset = win->ctl.card_start;
1240 } /* get_mem_page */
1242 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1244 struct pcmcia_socket *s;
1245 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1246 return CS_BAD_HANDLE;
1250 win->ctl.card_start = req->CardOffset;
1251 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1252 return CS_BAD_OFFSET;
1254 } /* map_mem_page */
1256 /*======================================================================
1258 Modify a locked socket configuration
1260 ======================================================================*/
1262 int pcmcia_modify_configuration(client_handle_t handle,
1265 struct pcmcia_socket *s;
1268 if (CHECK_HANDLE(handle))
1269 return CS_BAD_HANDLE;
1270 s = SOCKET(handle); c = CONFIG(handle);
1271 if (!(s->state & SOCKET_PRESENT))
1273 if (!(c->state & CONFIG_LOCKED))
1274 return CS_CONFIGURATION_LOCKED;
1276 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1277 if (mod->Attributes & CONF_ENABLE_IRQ) {
1278 c->Attributes |= CONF_ENABLE_IRQ;
1279 s->socket.io_irq = s->irq.AssignedIRQ;
1281 c->Attributes &= ~CONF_ENABLE_IRQ;
1282 s->socket.io_irq = 0;
1284 s->ops->set_socket(s, &s->socket);
1287 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1290 /* We only allow changing Vpp1 and Vpp2 to the same value */
1291 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1292 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1293 if (mod->Vpp1 != mod->Vpp2)
1295 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1296 if (s->ops->set_socket(s, &s->socket))
1298 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1299 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1303 } /* modify_configuration */
1305 /*======================================================================
1307 Modify the attributes of a window returned by RequestWindow.
1309 ======================================================================*/
1311 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1313 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1314 return CS_BAD_HANDLE;
1316 win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1317 if (req->Attributes & WIN_MEMORY_TYPE)
1318 win->ctl.flags |= MAP_ATTRIB;
1319 if (req->Attributes & WIN_ENABLE)
1320 win->ctl.flags |= MAP_ACTIVE;
1321 if (req->Attributes & WIN_DATA_WIDTH_16)
1322 win->ctl.flags |= MAP_16BIT;
1323 if (req->Attributes & WIN_USE_WAIT)
1324 win->ctl.flags |= MAP_USE_WAIT;
1325 win->ctl.speed = req->AccessSpeed;
1326 win->sock->ops->set_mem_map(win->sock, &win->ctl);
1329 } /* modify_window */
1331 /*======================================================================
1333 Register_client() uses the dev_info_t handle to match the
1334 caller with a socket. The driver must have already been bound
1335 to a socket with bind_device() -- in fact, bind_device()
1336 allocates the client structure that will be used.
1338 ======================================================================*/
1340 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1342 client_t *client = NULL;
1343 struct pcmcia_socket *s;
1345 /* Look for unbound client with matching dev_info */
1346 down_read(&pcmcia_socket_list_rwsem);
1347 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1348 client = s->clients;
1349 while (client != NULL) {
1350 if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1351 && (client->state & CLIENT_UNBOUND)) break;
1352 client = client->next;
1354 if (client != NULL) break;
1356 up_read(&pcmcia_socket_list_rwsem);
1358 return CS_OUT_OF_RESOURCE;
1361 * Prevent this racing with a card insertion.
1365 client->state &= ~CLIENT_UNBOUND;
1367 client->Attributes = req->Attributes;
1368 client->EventMask = req->EventMask;
1369 client->event_handler = req->event_handler;
1370 client->event_callback_args = req->event_callback_args;
1371 client->event_callback_args.client_handle = client;
1373 if (s->state & SOCKET_CARDBUS)
1374 client->state |= CLIENT_CARDBUS;
1376 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1377 (client->Function != BIND_FN_ALL)) {
1378 cistpl_longlink_mfc_t mfc;
1379 if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc)
1381 s->functions = mfc.nfn;
1384 s->config = kmalloc(sizeof(config_t) * s->functions,
1387 goto out_no_resource;
1388 memset(s->config, 0, sizeof(config_t) * s->functions);
1391 cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1392 client, client->dev_info);
1393 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1394 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1396 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1397 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1398 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1400 client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1408 return CS_OUT_OF_RESOURCE;
1409 } /* register_client */
1411 /*====================================================================*/
1413 int pcmcia_release_configuration(client_handle_t handle)
1415 pccard_io_map io = { 0, 0, 0, 0, 1 };
1416 struct pcmcia_socket *s;
1419 if (CHECK_HANDLE(handle) ||
1420 !(handle->state & CLIENT_CONFIG_LOCKED))
1421 return CS_BAD_HANDLE;
1422 handle->state &= ~CLIENT_CONFIG_LOCKED;
1425 #ifdef CONFIG_CARDBUS
1426 if (handle->state & CLIENT_CARDBUS)
1430 if (!(handle->state & CLIENT_STALE)) {
1431 config_t *c = CONFIG(handle);
1432 if (--(s->lock_count) == 0) {
1433 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1435 s->socket.io_irq = 0;
1436 s->ops->set_socket(s, &s->socket);
1438 if (c->state & CONFIG_IO_REQ)
1439 for (i = 0; i < MAX_IO_WIN; i++) {
1440 if (s->io[i].NumPorts == 0)
1443 if (s->io[i].Config != 0)
1446 s->ops->set_io_map(s, &io);
1448 c->state &= ~CONFIG_LOCKED;
1452 } /* release_configuration */
1454 /*======================================================================
1456 Release_io() releases the I/O ranges allocated by a client. This
1457 may be invoked some time after a card ejection has already dumped
1458 the actual socket configuration, so if the client is "stale", we
1459 don't bother checking the port ranges against the current socket
1462 ======================================================================*/
1464 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1466 struct pcmcia_socket *s;
1468 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1469 return CS_BAD_HANDLE;
1470 handle->state &= ~CLIENT_IO_REQ;
1473 #ifdef CONFIG_CARDBUS
1474 if (handle->state & CLIENT_CARDBUS)
1478 if (!(handle->state & CLIENT_STALE)) {
1479 config_t *c = CONFIG(handle);
1480 if (c->state & CONFIG_LOCKED)
1481 return CS_CONFIGURATION_LOCKED;
1482 if ((c->io.BasePort1 != req->BasePort1) ||
1483 (c->io.NumPorts1 != req->NumPorts1) ||
1484 (c->io.BasePort2 != req->BasePort2) ||
1485 (c->io.NumPorts2 != req->NumPorts2))
1487 c->state &= ~CONFIG_IO_REQ;
1490 release_io_space(s, req->BasePort1, req->NumPorts1);
1492 release_io_space(s, req->BasePort2, req->NumPorts2);
1497 /*====================================================================*/
1499 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1501 struct pcmcia_socket *s;
1502 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1503 return CS_BAD_HANDLE;
1504 handle->state &= ~CLIENT_IRQ_REQ;
1507 if (!(handle->state & CLIENT_STALE)) {
1508 config_t *c = CONFIG(handle);
1509 if (c->state & CONFIG_LOCKED)
1510 return CS_CONFIGURATION_LOCKED;
1511 if (c->irq.Attributes != req->Attributes)
1512 return CS_BAD_ATTRIBUTE;
1513 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1515 if (--s->irq.Config == 0) {
1516 c->state &= ~CONFIG_IRQ_REQ;
1517 s->irq.AssignedIRQ = 0;
1521 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1522 free_irq(req->AssignedIRQ, req->Instance);
1525 #ifdef CONFIG_PCMCIA_PROBE
1526 if (req->AssignedIRQ != s->pci_irq)
1527 undo_irq(req->Attributes, req->AssignedIRQ);
1531 } /* cs_release_irq */
1533 /*====================================================================*/
1535 int pcmcia_release_window(window_handle_t win)
1537 struct pcmcia_socket *s;
1539 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1540 return CS_BAD_HANDLE;
1542 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1543 return CS_BAD_HANDLE;
1545 /* Shut down memory window */
1546 win->ctl.flags &= ~MAP_ACTIVE;
1547 s->ops->set_mem_map(s, &win->ctl);
1548 s->state &= ~SOCKET_WIN_REQ(win->index);
1550 /* Release system memory */
1551 if(!(s->features & SS_CAP_STATIC_MAP))
1552 release_mem_region(win->base, win->size);
1553 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1558 } /* release_window */
1560 /*====================================================================*/
1562 int pcmcia_request_configuration(client_handle_t handle,
1567 struct pcmcia_socket *s;
1569 pccard_io_map iomap;
1571 if (CHECK_HANDLE(handle))
1572 return CS_BAD_HANDLE;
1574 if (!(s->state & SOCKET_PRESENT))
1577 #ifdef CONFIG_CARDBUS
1578 if (handle->state & CLIENT_CARDBUS)
1579 return CS_UNSUPPORTED_MODE;
1582 if (req->IntType & INT_CARDBUS)
1583 return CS_UNSUPPORTED_MODE;
1585 if (c->state & CONFIG_LOCKED)
1586 return CS_CONFIGURATION_LOCKED;
1588 /* Do power control. We don't allow changes in Vcc. */
1589 if (s->socket.Vcc != req->Vcc)
1591 if (req->Vpp1 != req->Vpp2)
1593 s->socket.Vpp = req->Vpp1;
1594 if (s->ops->set_socket(s, &s->socket))
1597 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1599 /* Pick memory or I/O card, DMA mode, interrupt */
1600 c->IntType = req->IntType;
1601 c->Attributes = req->Attributes;
1602 if (req->IntType & INT_MEMORY_AND_IO)
1603 s->socket.flags |= SS_IOCARD;
1604 if (req->IntType & INT_ZOOMED_VIDEO)
1605 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1606 if (req->Attributes & CONF_ENABLE_DMA)
1607 s->socket.flags |= SS_DMA_MODE;
1608 if (req->Attributes & CONF_ENABLE_SPKR)
1609 s->socket.flags |= SS_SPKR_ENA;
1610 if (req->Attributes & CONF_ENABLE_IRQ)
1611 s->socket.io_irq = s->irq.AssignedIRQ;
1613 s->socket.io_irq = 0;
1614 s->ops->set_socket(s, &s->socket);
1617 /* Set up CIS configuration registers */
1618 base = c->ConfigBase = req->ConfigBase;
1619 c->Present = c->CardValues = req->Present;
1620 if (req->Present & PRESENT_COPY) {
1621 c->Copy = req->Copy;
1622 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1624 if (req->Present & PRESENT_OPTION) {
1625 if (s->functions == 1) {
1626 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1628 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1629 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1630 if (req->Present & PRESENT_IOBASE_0)
1631 c->Option |= COR_ADDR_DECODE;
1633 if (c->state & CONFIG_IRQ_REQ)
1634 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1635 c->Option |= COR_LEVEL_REQ;
1636 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1639 if (req->Present & PRESENT_STATUS) {
1640 c->Status = req->Status;
1641 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1643 if (req->Present & PRESENT_PIN_REPLACE) {
1645 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1647 if (req->Present & PRESENT_EXT_STATUS) {
1648 c->ExtStatus = req->ExtStatus;
1649 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1651 if (req->Present & PRESENT_IOBASE_0) {
1652 u_char b = c->io.BasePort1 & 0xff;
1653 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1654 b = (c->io.BasePort1 >> 8) & 0xff;
1655 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1657 if (req->Present & PRESENT_IOSIZE) {
1658 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1659 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1662 /* Configure I/O windows */
1663 if (c->state & CONFIG_IO_REQ) {
1664 iomap.speed = io_speed;
1665 for (i = 0; i < MAX_IO_WIN; i++)
1666 if (s->io[i].NumPorts != 0) {
1668 iomap.flags = MAP_ACTIVE;
1669 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1670 case IO_DATA_PATH_WIDTH_16:
1671 iomap.flags |= MAP_16BIT; break;
1672 case IO_DATA_PATH_WIDTH_AUTO:
1673 iomap.flags |= MAP_AUTOSZ; break;
1677 iomap.start = s->io[i].BasePort;
1678 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1679 s->ops->set_io_map(s, &iomap);
1684 c->state |= CONFIG_LOCKED;
1685 handle->state |= CLIENT_CONFIG_LOCKED;
1687 } /* request_configuration */
1689 /*======================================================================
1691 Request_io() reserves ranges of port addresses for a socket.
1692 I have not implemented range sharing or alias addressing.
1694 ======================================================================*/
1696 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1698 struct pcmcia_socket *s;
1701 if (CHECK_HANDLE(handle))
1702 return CS_BAD_HANDLE;
1704 if (!(s->state & SOCKET_PRESENT))
1707 if (handle->state & CLIENT_CARDBUS) {
1708 #ifdef CONFIG_CARDBUS
1709 handle->state |= CLIENT_IO_REQ;
1712 return CS_UNSUPPORTED_FUNCTION;
1717 return CS_UNSUPPORTED_MODE;
1719 if (c->state & CONFIG_LOCKED)
1720 return CS_CONFIGURATION_LOCKED;
1721 if (c->state & CONFIG_IO_REQ)
1723 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1724 return CS_BAD_ATTRIBUTE;
1725 if ((req->NumPorts2 > 0) &&
1726 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1727 return CS_BAD_ATTRIBUTE;
1729 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1730 req->NumPorts1, req->IOAddrLines,
1734 if (req->NumPorts2) {
1735 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1736 req->NumPorts2, req->IOAddrLines,
1737 handle->dev_info)) {
1738 release_io_space(s, req->BasePort1, req->NumPorts1);
1744 c->state |= CONFIG_IO_REQ;
1745 handle->state |= CLIENT_IO_REQ;
1749 /*======================================================================
1751 Request_irq() reserves an irq for this client.
1753 Also, since Linux only reserves irq's when they are actually
1754 hooked, we don't guarantee that an irq will still be available
1755 when the configuration is locked. Now that I think about it,
1756 there might be a way to fix this using a dummy handler.
1758 ======================================================================*/
1760 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1762 struct pcmcia_socket *s;
1764 int ret = CS_IN_USE, irq = 0;
1766 if (CHECK_HANDLE(handle))
1767 return CS_BAD_HANDLE;
1769 if (!(s->state & SOCKET_PRESENT))
1772 if (c->state & CONFIG_LOCKED)
1773 return CS_CONFIGURATION_LOCKED;
1774 if (c->state & CONFIG_IRQ_REQ)
1777 #ifdef CONFIG_PCMCIA_PROBE
1778 if (s->irq.AssignedIRQ != 0) {
1779 /* If the interrupt is already assigned, it must match */
1780 irq = s->irq.AssignedIRQ;
1781 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1782 u_int mask = req->IRQInfo2 & s->irq_mask;
1783 ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1785 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1787 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1788 u_int try, mask = req->IRQInfo2 & s->irq_mask;
1789 for (try = 0; try < 2; try++) {
1790 for (irq = 0; irq < 32; irq++)
1791 if ((mask >> irq) & 1) {
1792 ret = try_irq(req->Attributes, irq, try);
1793 if (ret == 0) break;
1795 if (ret == 0) break;
1798 irq = req->IRQInfo1 & IRQ_MASK;
1799 ret = try_irq(req->Attributes, irq, 1);
1809 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1810 if (request_irq(irq, req->Handler,
1811 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1812 (s->functions > 1) ||
1813 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1814 handle->dev_info, req->Instance))
1818 c->irq.Attributes = req->Attributes;
1819 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1822 c->state |= CONFIG_IRQ_REQ;
1823 handle->state |= CLIENT_IRQ_REQ;
1825 } /* pcmcia_request_irq */
1827 /*======================================================================
1829 Request_window() establishes a mapping between card memory space
1830 and system memory space.
1832 ======================================================================*/
1834 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1836 struct pcmcia_socket *s;
1841 if (CHECK_HANDLE(*handle))
1842 return CS_BAD_HANDLE;
1843 s = (*handle)->Socket;
1844 if (!(s->state & SOCKET_PRESENT))
1846 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1847 return CS_BAD_ATTRIBUTE;
1849 /* Window size defaults to smallest available */
1851 req->Size = s->map_size;
1852 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1853 (req->Attributes & WIN_STRICT_ALIGN)) ?
1854 req->Size : s->map_size);
1855 if (req->Size & (s->map_size-1))
1857 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1858 (req->Base & (align-1)))
1863 /* Allocate system memory window */
1864 for (w = 0; w < MAX_WIN; w++)
1865 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1867 return CS_OUT_OF_RESOURCE;
1870 win->magic = WINDOW_MAGIC;
1872 win->handle = *handle;
1874 win->base = req->Base;
1875 win->size = req->Size;
1877 if (!(s->features & SS_CAP_STATIC_MAP) &&
1878 find_mem_region(&win->base, win->size, align,
1879 (req->Attributes & WIN_MAP_BELOW_1MB),
1880 (*handle)->dev_info, s))
1882 (*handle)->state |= CLIENT_WIN_REQ(w);
1884 /* Configure the socket controller */
1887 win->ctl.speed = req->AccessSpeed;
1888 if (req->Attributes & WIN_MEMORY_TYPE)
1889 win->ctl.flags |= MAP_ATTRIB;
1890 if (req->Attributes & WIN_ENABLE)
1891 win->ctl.flags |= MAP_ACTIVE;
1892 if (req->Attributes & WIN_DATA_WIDTH_16)
1893 win->ctl.flags |= MAP_16BIT;
1894 if (req->Attributes & WIN_USE_WAIT)
1895 win->ctl.flags |= MAP_USE_WAIT;
1896 win->ctl.sys_start = win->base;
1897 win->ctl.sys_stop = win->base + win->size-1;
1898 win->ctl.card_start = 0;
1899 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1901 s->state |= SOCKET_WIN_REQ(w);
1903 /* Return window handle */
1904 req->Base = win->ctl.sys_start;
1908 } /* request_window */
1910 /*======================================================================
1912 I'm not sure which "reset" function this is supposed to use,
1913 but for now, it uses the low-level interface's reset, not the
1916 ======================================================================*/
1918 int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
1920 struct pcmcia_socket *skt;
1923 if (CHECK_HANDLE(handle))
1924 return CS_BAD_HANDLE;
1925 skt = SOCKET(handle);
1926 cs_dbg(skt, 1, "resetting socket\n");
1928 down(&skt->skt_sem);
1930 if (!(skt->state & SOCKET_PRESENT)) {
1934 if (skt->state & SOCKET_SUSPEND) {
1938 if (skt->state & SOCKET_CARDBUS) {
1939 ret = CS_UNSUPPORTED_FUNCTION;
1943 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1945 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1946 if (socket_reset(skt) == CS_SUCCESS)
1947 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1950 handle->event_callback_args.info = (void *)(u_long)ret;
1951 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1960 /*======================================================================
1962 These shut down or wake up a socket. They are sort of user
1963 initiated versions of the APM suspend and resume actions.
1965 ======================================================================*/
1967 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1971 cs_dbg(skt, 1, "suspending socket\n");
1973 down(&skt->skt_sem);
1975 if (!(skt->state & SOCKET_PRESENT)) {
1979 if (skt->state & SOCKET_CARDBUS) {
1980 ret = CS_UNSUPPORTED_FUNCTION;
1983 ret = socket_suspend(skt);
1988 } /* suspend_card */
1990 int pcmcia_resume_card(struct pcmcia_socket *skt)
1994 cs_dbg(skt, 1, "waking up socket\n");
1996 down(&skt->skt_sem);
1998 if (!(skt->state & SOCKET_PRESENT)) {
2002 if (skt->state & SOCKET_CARDBUS) {
2003 ret = CS_UNSUPPORTED_FUNCTION;
2006 ret = socket_resume(skt);
2013 /*======================================================================
2015 These handle user requests to eject or insert a card.
2017 ======================================================================*/
2019 int pcmcia_eject_card(struct pcmcia_socket *skt)
2023 cs_dbg(skt, 1, "user eject request\n");
2025 down(&skt->skt_sem);
2027 if (!(skt->state & SOCKET_PRESENT)) {
2032 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2044 int pcmcia_insert_card(struct pcmcia_socket *skt)
2048 cs_dbg(skt, 1, "user insert request\n");
2050 down(&skt->skt_sem);
2052 if (skt->state & SOCKET_PRESENT) {
2056 if (socket_insert(skt) == CS_NO_CARD) {
2067 /*======================================================================
2069 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2070 haven't sent one to this client yet?
2072 ======================================================================*/
2074 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2077 if (CHECK_HANDLE(handle))
2078 return CS_BAD_HANDLE;
2079 if (handle->Attributes & CONF_EVENT_MASK_VALID)
2080 return CS_BAD_SOCKET;
2081 handle->EventMask = mask->EventMask;
2082 events = handle->PendingEvents & handle->EventMask;
2083 handle->PendingEvents -= events;
2084 while (events != 0) {
2085 bit = ((events ^ (events-1)) + 1) >> 1;
2086 EVENT(handle, bit, CS_EVENT_PRI_LOW);
2090 } /* set_event_mask */
2092 /*======================================================================
2094 OS-specific module glue goes here
2096 ======================================================================*/
2097 /* in alpha order */
2098 EXPORT_SYMBOL(pcmcia_access_configuration_register);
2099 EXPORT_SYMBOL(pcmcia_adjust_resource_info);
2100 EXPORT_SYMBOL(pcmcia_check_erase_queue);
2101 EXPORT_SYMBOL(pcmcia_close_memory);
2102 EXPORT_SYMBOL(pcmcia_copy_memory);
2103 EXPORT_SYMBOL(pcmcia_deregister_client);
2104 EXPORT_SYMBOL(pcmcia_deregister_erase_queue);
2105 EXPORT_SYMBOL(pcmcia_eject_card);
2106 EXPORT_SYMBOL(pcmcia_get_first_client);
2107 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2108 EXPORT_SYMBOL(pcmcia_get_configuration_info);
2109 EXPORT_SYMBOL(pcmcia_get_mem_page);
2110 EXPORT_SYMBOL(pcmcia_get_next_client);
2111 EXPORT_SYMBOL(pcmcia_get_first_region);
2112 EXPORT_SYMBOL(pcmcia_get_first_tuple);
2113 EXPORT_SYMBOL(pcmcia_get_first_window);
2114 EXPORT_SYMBOL(pcmcia_get_next_region);
2115 EXPORT_SYMBOL(pcmcia_get_next_tuple);
2116 EXPORT_SYMBOL(pcmcia_get_next_window);
2117 EXPORT_SYMBOL(pcmcia_get_status);
2118 EXPORT_SYMBOL(pcmcia_get_tuple_data);
2119 EXPORT_SYMBOL(pcmcia_insert_card);
2120 EXPORT_SYMBOL(pcmcia_map_mem_page);
2121 EXPORT_SYMBOL(pcmcia_modify_configuration);
2122 EXPORT_SYMBOL(pcmcia_modify_window);
2123 EXPORT_SYMBOL(pcmcia_open_memory);
2124 EXPORT_SYMBOL(pcmcia_parse_tuple);
2125 EXPORT_SYMBOL(pcmcia_read_memory);
2126 EXPORT_SYMBOL(pcmcia_register_client);
2127 EXPORT_SYMBOL(pcmcia_register_erase_queue);
2128 EXPORT_SYMBOL(pcmcia_register_mtd);
2129 EXPORT_SYMBOL(pcmcia_release_configuration);
2130 EXPORT_SYMBOL(pcmcia_release_io);
2131 EXPORT_SYMBOL(pcmcia_release_irq);
2132 EXPORT_SYMBOL(pcmcia_release_window);
2133 EXPORT_SYMBOL(pcmcia_replace_cis);
2134 EXPORT_SYMBOL(pcmcia_request_configuration);
2135 EXPORT_SYMBOL(pcmcia_request_io);
2136 EXPORT_SYMBOL(pcmcia_request_irq);
2137 EXPORT_SYMBOL(pcmcia_request_window);
2138 EXPORT_SYMBOL(pcmcia_reset_card);
2139 EXPORT_SYMBOL(pcmcia_resume_card);
2140 EXPORT_SYMBOL(pcmcia_set_event_mask);
2141 EXPORT_SYMBOL(pcmcia_suspend_card);
2142 EXPORT_SYMBOL(pcmcia_validate_cis);
2143 EXPORT_SYMBOL(pcmcia_write_memory);
2145 EXPORT_SYMBOL(dead_socket);
2146 EXPORT_SYMBOL(MTDHelperEntry);
2147 EXPORT_SYMBOL(pcmcia_parse_events);
2149 struct class pcmcia_socket_class = {
2150 .name = "pcmcia_socket",
2151 .release = pcmcia_release_socket,
2153 EXPORT_SYMBOL(pcmcia_socket_class);
2156 static int __init init_pcmcia_cs(void)
2158 printk(KERN_INFO "%s\n", release);
2159 printk(KERN_INFO " %s\n", options);
2161 return class_register(&pcmcia_socket_class);
2164 static void __exit exit_pcmcia_cs(void)
2166 printk(KERN_INFO "unloading Kernel Card Services\n");
2167 release_resource_db();
2168 class_unregister(&pcmcia_socket_class);
2171 subsys_initcall(init_pcmcia_cs);
2172 module_exit(exit_pcmcia_cs);
2174 /*====================================================================*/