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 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);
371 #ifdef CONFIG_CARDBUS
379 for (c = &s->clients; *c; ) {
380 if ((*c)->state & CLIENT_UNBOUND) {
388 free_regions(&s->a_region);
389 free_regions(&s->c_region);
393 s->ops->get_status(s, &status);
394 if (status & SS_POWERON) {
395 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
398 } /* shutdown_socket */
400 /*======================================================================
402 The central event handler. Send_event() sends an event to all
403 valid clients. Parse_events() interprets the event bits from
404 a card status change report. Do_shutdown() handles the high
405 priority stuff associated with a card removal.
407 ======================================================================*/
409 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
411 client_t *client = s->clients;
413 cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
416 if (s->state & SOCKET_CARDBUS)
418 for (; client; client = client->next) {
419 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
421 if (client->EventMask & event) {
422 ret = EVENT(client, event, priority);
430 #define cs_to_timeout(cs) (((cs) * HZ + 99) / 100)
432 static void socket_remove_drivers(struct pcmcia_socket *skt)
436 cs_dbg(skt, 4, "remove_drivers\n");
438 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
440 for (client = skt->clients; client; client = client->next)
441 if (!(client->Attributes & INFO_MASTER_CLIENT))
442 client->state |= CLIENT_STALE;
445 static void socket_shutdown(struct pcmcia_socket *skt)
447 cs_dbg(skt, 4, "shutdown\n");
449 socket_remove_drivers(skt);
450 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
451 set_current_state(TASK_UNINTERRUPTIBLE);
452 schedule_timeout(cs_to_timeout(shutdown_delay));
453 skt->state &= SOCKET_INUSE;
454 shutdown_socket(skt);
457 static int socket_reset(struct pcmcia_socket *skt)
461 cs_dbg(skt, 4, "reset\n");
463 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
464 skt->ops->set_socket(skt, &skt->socket);
465 udelay((long)reset_time);
467 skt->socket.flags &= ~SS_RESET;
468 skt->ops->set_socket(skt, &skt->socket);
470 set_current_state(TASK_UNINTERRUPTIBLE);
471 schedule_timeout(cs_to_timeout(unreset_delay));
472 for (i = 0; i < unreset_limit; i++) {
473 skt->ops->get_status(skt, &status);
475 if (!(status & SS_DETECT))
478 if (status & SS_READY)
481 set_current_state(TASK_UNINTERRUPTIBLE);
482 schedule_timeout(cs_to_timeout(unreset_check));
485 cs_err(skt, "time out after reset.\n");
486 return CS_GENERAL_FAILURE;
489 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
493 cs_dbg(skt, 4, "setup\n");
495 skt->ops->get_status(skt, &status);
496 if (!(status & SS_DETECT))
499 set_current_state(TASK_UNINTERRUPTIBLE);
500 schedule_timeout(cs_to_timeout(initial_delay));
502 for (i = 0; i < 100; i++) {
503 skt->ops->get_status(skt, &status);
504 if (!(status & SS_DETECT))
507 if (!(status & SS_PENDING))
510 set_current_state(TASK_UNINTERRUPTIBLE);
511 schedule_timeout(cs_to_timeout(10));
514 if (status & SS_PENDING) {
515 cs_err(skt, "voltage interrogation timed out.\n");
516 return CS_GENERAL_FAILURE;
519 if (status & SS_CARDBUS) {
520 skt->state |= SOCKET_CARDBUS;
521 #ifndef CONFIG_CARDBUS
522 cs_err(skt, "cardbus cards are not supported.\n");
528 * Decode the card voltage requirements, and apply power to the card.
530 if (status & SS_3VCARD)
531 skt->socket.Vcc = skt->socket.Vpp = 33;
532 else if (!(status & SS_XVCARD))
533 skt->socket.Vcc = skt->socket.Vpp = 50;
535 cs_err(skt, "unsupported voltage key.\n");
538 skt->socket.flags = 0;
539 skt->ops->set_socket(skt, &skt->socket);
542 * Wait "vcc_settle" for the supply to stabilise.
544 set_current_state(TASK_UNINTERRUPTIBLE);
545 schedule_timeout(cs_to_timeout(vcc_settle));
547 skt->ops->get_status(skt, &status);
548 if (!(status & SS_POWERON)) {
549 cs_err(skt, "unable to apply power.\n");
553 return socket_reset(skt);
557 * Handle card insertion. Setup the socket, reset the card,
558 * and then tell the rest of PCMCIA that a card is present.
560 static int socket_insert(struct pcmcia_socket *skt)
564 cs_dbg(skt, 4, "insert\n");
566 if (!cs_socket_get(skt))
569 ret = socket_setup(skt, setup_delay);
570 if (ret == CS_SUCCESS) {
571 skt->state |= SOCKET_PRESENT;
572 #ifdef CONFIG_CARDBUS
573 if (skt->state & SOCKET_CARDBUS) {
575 skt->state |= SOCKET_CARDBUS_CONFIG;
578 cs_dbg(skt, 4, "insert done\n");
580 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
582 socket_shutdown(skt);
589 static int socket_suspend(struct pcmcia_socket *skt)
591 if (skt->state & SOCKET_SUSPEND)
594 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
595 skt->socket = dead_socket;
596 skt->ops->suspend(skt);
597 skt->state |= SOCKET_SUSPEND;
603 * Resume a socket. If a card is present, verify its CIS against
604 * our cached copy. If they are different, the card has been
605 * replaced, and we need to tell the drivers.
607 static int socket_resume(struct pcmcia_socket *skt)
611 if (!(skt->state & SOCKET_SUSPEND))
614 skt->socket = dead_socket;
616 skt->ops->set_socket(skt, &skt->socket);
618 ret = socket_setup(skt, resume_delay);
619 if (ret == CS_SUCCESS) {
621 * FIXME: need a better check here for cardbus cards.
623 if (verify_cis_cache(skt) != 0) {
624 socket_remove_drivers(skt);
625 destroy_cis_cache(skt);
626 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
628 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
631 socket_shutdown(skt);
635 skt->state &= ~SOCKET_SUSPEND;
640 static void socket_remove(struct pcmcia_socket *skt)
642 socket_shutdown(skt);
647 * Process a socket card detect status change.
649 * If we don't have a card already present, delay the detect event for
650 * about 20ms (to be on the safe side) before reading the socket status.
652 * Some i82365-based systems send multiple SS_DETECT events during card
653 * insertion, and the "card present" status bit seems to bounce. This
654 * will probably be true with GPIO-based card detection systems after
655 * the product has aged.
657 static void socket_detect_change(struct pcmcia_socket *skt)
659 if (!(skt->state & SOCKET_SUSPEND)) {
662 if (!(skt->state & SOCKET_PRESENT)) {
663 set_current_state(TASK_UNINTERRUPTIBLE);
664 schedule_timeout(cs_to_timeout(2));
667 skt->ops->get_status(skt, &status);
668 if ((skt->state & SOCKET_PRESENT) &&
669 !(status & SS_DETECT))
671 if (!(skt->state & SOCKET_PRESENT) &&
672 (status & SS_DETECT))
677 static int pccardd(void *__skt)
679 struct pcmcia_socket *skt = __skt;
680 DECLARE_WAITQUEUE(wait, current);
683 daemonize("pccardd");
685 skt->thread = current;
686 skt->socket = dead_socket;
688 skt->ops->set_socket(skt, &skt->socket);
690 /* register with the device core */
691 ret = class_device_register(&skt->dev);
693 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
696 complete_and_exit(&skt->thread_done, 0);
698 complete(&skt->thread_done);
700 add_wait_queue(&skt->thread_wait, &wait);
705 set_current_state(TASK_INTERRUPTIBLE);
707 spin_lock_irqsave(&skt->thread_lock, flags);
708 events = skt->thread_events;
709 skt->thread_events = 0;
710 spin_unlock_irqrestore(&skt->thread_lock, flags);
714 if (events & SS_DETECT)
715 socket_detect_change(skt);
716 if (events & SS_BATDEAD)
717 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
718 if (events & SS_BATWARN)
719 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
720 if (events & SS_READY)
721 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
727 if (current->flags & PF_FREEZE)
728 refrigerator(PF_FREEZE);
733 remove_wait_queue(&skt->thread_wait, &wait);
735 /* remove from the device core */
736 class_device_unregister(&skt->dev);
738 complete_and_exit(&skt->thread_done, 0);
742 * Yenta (at least) probes interrupts before registering the socket and
743 * starting the handler thread.
745 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
747 cs_dbg(s, 4, "parse_events: events %08x\n", events);
749 spin_lock(&s->thread_lock);
750 s->thread_events |= events;
751 spin_unlock(&s->thread_lock);
753 wake_up(&s->thread_wait);
755 } /* pcmcia_parse_events */
758 /*======================================================================
760 Special stuff for managing IO windows, because they are scarce.
762 ======================================================================*/
764 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
765 ioaddr_t num, u_int lines, char *name)
770 align = (*base) ? (lines ? 1<<lines : 0) : 1;
771 if (align && (align < num)) {
773 cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
777 while (align && (align < num)) align <<= 1;
779 if (*base & ~(align-1)) {
780 cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
784 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
785 *base = s->io_offset | (*base & 0x0fff);
788 /* Check for an already-allocated window that must conflict with
789 what was asked for. It is a hack because it does not catch all
790 potential conflicts, just the most obvious ones. */
791 for (i = 0; i < MAX_IO_WIN; i++)
792 if ((s->io[i].NumPorts != 0) &&
793 ((s->io[i].BasePort & (align-1)) == *base))
795 for (i = 0; i < MAX_IO_WIN; i++) {
796 if (s->io[i].NumPorts == 0) {
797 s->io[i].res = find_io_region(*base, num, align, name, s);
799 s->io[i].Attributes = attr;
800 s->io[i].BasePort = *base = s->io[i].res->start;
801 s->io[i].NumPorts = s->io[i].InUse = num;
805 } else if (s->io[i].Attributes != attr)
807 /* Try to extend top of window */
808 try = s->io[i].BasePort + s->io[i].NumPorts;
809 if ((*base == 0) || (*base == try))
810 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
811 s->io[i].res->end + num, s) == 0) {
813 s->io[i].NumPorts += num;
814 s->io[i].InUse += num;
817 /* Try to extend bottom of window */
818 try = s->io[i].BasePort - num;
819 if ((*base == 0) || (*base == try))
820 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
821 s->io[i].res->end, s) == 0) {
822 s->io[i].BasePort = *base = try;
823 s->io[i].NumPorts += num;
824 s->io[i].InUse += num;
828 return (i == MAX_IO_WIN);
829 } /* alloc_io_space */
831 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
836 for (i = 0; i < MAX_IO_WIN; i++) {
837 if ((s->io[i].BasePort <= base) &&
838 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
839 s->io[i].InUse -= num;
840 /* Free the window if no one else is using it */
841 if (s->io[i].InUse == 0) {
842 s->io[i].NumPorts = 0;
843 release_resource(s->io[i].res);
851 /*======================================================================
853 Access_configuration_register() reads and writes configuration
854 registers in attribute memory. Memory window 0 is reserved for
855 this and the tuple reading services.
857 ======================================================================*/
859 int pcmcia_access_configuration_register(client_handle_t handle,
862 struct pcmcia_socket *s;
867 if (CHECK_HANDLE(handle))
868 return CS_BAD_HANDLE;
870 if (handle->Function == BIND_FN_ALL) {
871 if (reg->Function >= s->functions)
873 c = &s->config[reg->Function];
880 if (!(c->state & CONFIG_LOCKED))
881 return CS_CONFIGURATION_LOCKED;
883 addr = (c->ConfigBase + reg->Offset) >> 1;
885 switch (reg->Action) {
887 read_cis_mem(s, 1, addr, 1, &val);
892 write_cis_mem(s, 1, addr, 1, &val);
899 } /* access_configuration_register */
902 /*====================================================================*/
904 int pcmcia_deregister_client(client_handle_t handle)
907 struct pcmcia_socket *s;
908 memory_handle_t region;
912 if (CHECK_HANDLE(handle))
913 return CS_BAD_HANDLE;
916 cs_dbg(s, 1, "deregister_client(%p)\n", handle);
919 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
921 for (i = 0; i < MAX_WIN; i++)
922 if (handle->state & CLIENT_WIN_REQ(i))
925 /* Disconnect all MTD links */
926 if (handle->mtd_count) {
927 for (region = s->a_region; region; region = region->info.next)
928 if (region->mtd == handle) region->mtd = NULL;
929 for (region = s->c_region; region; region = region->info.next)
930 if (region->mtd == handle) region->mtd = NULL;
933 if ((handle->state & CLIENT_STALE) ||
934 (handle->Attributes & INFO_MASTER_CLIENT)) {
935 spin_lock_irqsave(&s->lock, flags);
936 client = &s->clients;
937 while ((*client) && ((*client) != handle))
938 client = &(*client)->next;
939 if (*client == NULL) {
940 spin_unlock_irqrestore(&s->lock, flags);
941 return CS_BAD_HANDLE;
943 *client = handle->next;
944 handle->client_magic = 0;
946 spin_unlock_irqrestore(&s->lock, flags);
948 handle->state = CLIENT_UNBOUND;
949 handle->mtd_count = 0;
950 handle->event_handler = NULL;
954 } /* deregister_client */
956 /*====================================================================*/
958 int pcmcia_get_configuration_info(client_handle_t handle,
959 config_info_t *config)
961 struct pcmcia_socket *s;
964 if (CHECK_HANDLE(handle))
965 return CS_BAD_HANDLE;
967 if (!(s->state & SOCKET_PRESENT))
970 if (handle->Function == BIND_FN_ALL) {
971 if (config->Function && (config->Function >= s->functions))
974 config->Function = handle->Function;
976 #ifdef CONFIG_CARDBUS
977 if (s->state & SOCKET_CARDBUS) {
978 u_char fn = config->Function;
979 memset(config, 0, sizeof(config_info_t));
980 config->Function = fn;
981 config->Vcc = s->socket.Vcc;
982 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
983 config->Option = s->cb_dev->subordinate->number;
984 if (s->state & SOCKET_CARDBUS_CONFIG) {
985 config->Attributes = CONF_VALID_CLIENT;
986 config->IntType = INT_CARDBUS;
987 config->AssignedIRQ = s->irq.AssignedIRQ;
988 if (config->AssignedIRQ)
989 config->Attributes |= CONF_ENABLE_IRQ;
990 config->BasePort1 = s->io[0].BasePort;
991 config->NumPorts1 = s->io[0].NumPorts;
997 c = (s->config != NULL) ? &s->config[config->Function] : NULL;
999 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
1000 config->Attributes = 0;
1001 config->Vcc = s->socket.Vcc;
1002 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
1006 /* !!! This is a hack !!! */
1007 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
1008 config->Attributes |= CONF_VALID_CLIENT;
1009 config->CardValues = c->CardValues;
1010 config->IRQAttributes = c->irq.Attributes;
1011 config->AssignedIRQ = s->irq.AssignedIRQ;
1012 config->BasePort1 = c->io.BasePort1;
1013 config->NumPorts1 = c->io.NumPorts1;
1014 config->Attributes1 = c->io.Attributes1;
1015 config->BasePort2 = c->io.BasePort2;
1016 config->NumPorts2 = c->io.NumPorts2;
1017 config->Attributes2 = c->io.Attributes2;
1018 config->IOAddrLines = c->io.IOAddrLines;
1021 } /* get_configuration_info */
1023 /*======================================================================
1025 Return information about this version of Card Services.
1027 ======================================================================*/
1029 int pcmcia_get_card_services_info(servinfo_t *info)
1031 unsigned int socket_count = 0;
1032 struct list_head *tmp;
1033 info->Signature[0] = 'C';
1034 info->Signature[1] = 'S';
1035 down_read(&pcmcia_socket_list_rwsem);
1036 list_for_each(tmp, &pcmcia_socket_list)
1038 up_read(&pcmcia_socket_list_rwsem);
1039 info->Count = socket_count;
1040 info->Revision = CS_RELEASE_CODE;
1041 info->CSLevel = 0x0210;
1042 info->VendorString = (char *)release;
1044 } /* get_card_services_info */
1046 /*======================================================================
1048 Note that get_first_client() *does* recognize the Socket field
1049 in the request structure.
1051 ======================================================================*/
1053 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1056 struct pcmcia_socket *socket;
1057 if (req->Attributes & CLIENT_THIS_SOCKET)
1061 socket = pcmcia_get_socket_by_nr(s);
1063 return CS_BAD_SOCKET;
1064 if (socket->clients == NULL)
1065 return CS_NO_MORE_ITEMS;
1066 *handle = socket->clients;
1068 } /* get_first_client */
1070 /*====================================================================*/
1072 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1074 struct pcmcia_socket *s;
1075 if ((handle == NULL) || CHECK_HANDLE(*handle))
1076 return CS_BAD_HANDLE;
1077 if ((*handle)->next == NULL) {
1078 if (req->Attributes & CLIENT_THIS_SOCKET)
1079 return CS_NO_MORE_ITEMS;
1080 s = (*handle)->Socket;
1081 if (s->clients == NULL)
1082 return CS_NO_MORE_ITEMS;
1083 *handle = s->clients;
1085 *handle = (*handle)->next;
1087 } /* get_next_client */
1089 /*====================================================================*/
1091 int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req)
1093 struct pcmcia_socket *s;
1098 s = ((client_handle_t)*handle)->Socket;
1100 s = (*handle)->sock;
1101 if (!(s->state & SOCKET_PRESENT))
1103 for (w = idx; w < MAX_WIN; w++)
1104 if (s->state & SOCKET_WIN_REQ(w)) break;
1106 return CS_NO_MORE_ITEMS;
1108 req->Base = win->ctl.res->start;
1109 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
1110 req->AccessSpeed = win->ctl.speed;
1111 req->Attributes = 0;
1112 if (win->ctl.flags & MAP_ATTRIB)
1113 req->Attributes |= WIN_MEMORY_TYPE_AM;
1114 if (win->ctl.flags & MAP_ACTIVE)
1115 req->Attributes |= WIN_ENABLE;
1116 if (win->ctl.flags & MAP_16BIT)
1117 req->Attributes |= WIN_DATA_WIDTH_16;
1118 if (win->ctl.flags & MAP_USE_WAIT)
1119 req->Attributes |= WIN_USE_WAIT;
1124 int pcmcia_get_first_window(window_handle_t *win, win_req_t *req)
1126 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1127 return CS_BAD_HANDLE;
1128 return pcmcia_get_window(win, 0, req);
1131 int pcmcia_get_next_window(window_handle_t *win, win_req_t *req)
1133 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1134 return CS_BAD_HANDLE;
1135 return pcmcia_get_window(win, (*win)->index+1, req);
1138 /*=====================================================================
1140 Return the PCI device associated with a card..
1142 ======================================================================*/
1144 #ifdef CONFIG_CARDBUS
1146 struct pci_bus *pcmcia_lookup_bus(client_handle_t handle)
1148 struct pcmcia_socket *s;
1150 if (CHECK_HANDLE(handle))
1153 if (!(s->state & SOCKET_CARDBUS))
1156 return s->cb_dev->subordinate;
1159 EXPORT_SYMBOL(pcmcia_lookup_bus);
1163 /*======================================================================
1165 Get the current socket state bits. We don't support the latched
1166 SocketState yet: I haven't seen any point for it.
1168 ======================================================================*/
1170 int pcmcia_get_status(client_handle_t handle, cs_status_t *status)
1172 struct pcmcia_socket *s;
1176 if (CHECK_HANDLE(handle))
1177 return CS_BAD_HANDLE;
1179 s->ops->get_status(s, &val);
1180 status->CardState = status->SocketState = 0;
1181 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1182 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1183 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1184 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1185 if (s->state & SOCKET_SUSPEND)
1186 status->CardState |= CS_EVENT_PM_SUSPEND;
1187 if (!(s->state & SOCKET_PRESENT))
1190 /* Get info from the PRR, if necessary */
1191 if (handle->Function == BIND_FN_ALL) {
1192 if (status->Function && (status->Function >= s->functions))
1194 c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1197 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1198 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1200 if (c->Present & PRESENT_PIN_REPLACE) {
1201 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1202 status->CardState |=
1203 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1204 status->CardState |=
1205 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1206 status->CardState |=
1207 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1208 status->CardState |=
1209 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1211 /* No PRR? Then assume we're always ready */
1212 status->CardState |= CS_EVENT_READY_CHANGE;
1214 if (c->Present & PRESENT_EXT_STATUS) {
1215 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1216 status->CardState |=
1217 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1221 status->CardState |=
1222 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1223 status->CardState |=
1224 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1225 status->CardState |=
1226 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1227 status->CardState |=
1228 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1232 /*======================================================================
1234 Change the card address of an already open memory window.
1236 ======================================================================*/
1238 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1240 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1241 return CS_BAD_HANDLE;
1243 req->CardOffset = win->ctl.card_start;
1245 } /* get_mem_page */
1247 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1249 struct pcmcia_socket *s;
1250 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1251 return CS_BAD_HANDLE;
1255 win->ctl.card_start = req->CardOffset;
1256 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1257 return CS_BAD_OFFSET;
1259 } /* map_mem_page */
1261 /*======================================================================
1263 Modify a locked socket configuration
1265 ======================================================================*/
1267 int pcmcia_modify_configuration(client_handle_t handle,
1270 struct pcmcia_socket *s;
1273 if (CHECK_HANDLE(handle))
1274 return CS_BAD_HANDLE;
1275 s = SOCKET(handle); c = CONFIG(handle);
1276 if (!(s->state & SOCKET_PRESENT))
1278 if (!(c->state & CONFIG_LOCKED))
1279 return CS_CONFIGURATION_LOCKED;
1281 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1282 if (mod->Attributes & CONF_ENABLE_IRQ) {
1283 c->Attributes |= CONF_ENABLE_IRQ;
1284 s->socket.io_irq = s->irq.AssignedIRQ;
1286 c->Attributes &= ~CONF_ENABLE_IRQ;
1287 s->socket.io_irq = 0;
1289 s->ops->set_socket(s, &s->socket);
1292 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1295 /* We only allow changing Vpp1 and Vpp2 to the same value */
1296 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1297 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1298 if (mod->Vpp1 != mod->Vpp2)
1300 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1301 if (s->ops->set_socket(s, &s->socket))
1303 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1304 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1308 } /* modify_configuration */
1310 /*======================================================================
1312 Modify the attributes of a window returned by RequestWindow.
1314 ======================================================================*/
1316 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1318 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1319 return CS_BAD_HANDLE;
1321 win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1322 if (req->Attributes & WIN_MEMORY_TYPE)
1323 win->ctl.flags |= MAP_ATTRIB;
1324 if (req->Attributes & WIN_ENABLE)
1325 win->ctl.flags |= MAP_ACTIVE;
1326 if (req->Attributes & WIN_DATA_WIDTH_16)
1327 win->ctl.flags |= MAP_16BIT;
1328 if (req->Attributes & WIN_USE_WAIT)
1329 win->ctl.flags |= MAP_USE_WAIT;
1330 win->ctl.speed = req->AccessSpeed;
1331 win->sock->ops->set_mem_map(win->sock, &win->ctl);
1334 } /* modify_window */
1336 /*======================================================================
1338 Register_client() uses the dev_info_t handle to match the
1339 caller with a socket. The driver must have already been bound
1340 to a socket with bind_device() -- in fact, bind_device()
1341 allocates the client structure that will be used.
1343 ======================================================================*/
1345 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1347 client_t *client = NULL;
1348 struct pcmcia_socket *s;
1350 /* Look for unbound client with matching dev_info */
1351 down_read(&pcmcia_socket_list_rwsem);
1352 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1353 client = s->clients;
1354 while (client != NULL) {
1355 if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1356 && (client->state & CLIENT_UNBOUND)) break;
1357 client = client->next;
1359 if (client != NULL) break;
1361 up_read(&pcmcia_socket_list_rwsem);
1363 return CS_OUT_OF_RESOURCE;
1366 * Prevent this racing with a card insertion.
1370 client->state &= ~CLIENT_UNBOUND;
1372 client->Attributes = req->Attributes;
1373 client->EventMask = req->EventMask;
1374 client->event_handler = req->event_handler;
1375 client->event_callback_args = req->event_callback_args;
1376 client->event_callback_args.client_handle = client;
1378 if (s->state & SOCKET_CARDBUS)
1379 client->state |= CLIENT_CARDBUS;
1381 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1382 (client->Function != BIND_FN_ALL)) {
1383 cistpl_longlink_mfc_t mfc;
1384 if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc)
1386 s->functions = mfc.nfn;
1389 s->config = kmalloc(sizeof(config_t) * s->functions,
1392 goto out_no_resource;
1393 memset(s->config, 0, sizeof(config_t) * s->functions);
1396 cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1397 client, client->dev_info);
1398 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1399 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1401 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1402 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1403 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1405 client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1413 return CS_OUT_OF_RESOURCE;
1414 } /* register_client */
1416 /*====================================================================*/
1418 int pcmcia_release_configuration(client_handle_t handle)
1420 pccard_io_map io = { 0, 0, 0, 0, 1 };
1421 struct pcmcia_socket *s;
1424 if (CHECK_HANDLE(handle) ||
1425 !(handle->state & CLIENT_CONFIG_LOCKED))
1426 return CS_BAD_HANDLE;
1427 handle->state &= ~CLIENT_CONFIG_LOCKED;
1430 #ifdef CONFIG_CARDBUS
1431 if (handle->state & CLIENT_CARDBUS)
1435 if (!(handle->state & CLIENT_STALE)) {
1436 config_t *c = CONFIG(handle);
1437 if (--(s->lock_count) == 0) {
1438 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1440 s->socket.io_irq = 0;
1441 s->ops->set_socket(s, &s->socket);
1443 if (c->state & CONFIG_IO_REQ)
1444 for (i = 0; i < MAX_IO_WIN; i++) {
1445 if (s->io[i].NumPorts == 0)
1448 if (s->io[i].Config != 0)
1451 s->ops->set_io_map(s, &io);
1453 c->state &= ~CONFIG_LOCKED;
1457 } /* release_configuration */
1459 /*======================================================================
1461 Release_io() releases the I/O ranges allocated by a client. This
1462 may be invoked some time after a card ejection has already dumped
1463 the actual socket configuration, so if the client is "stale", we
1464 don't bother checking the port ranges against the current socket
1467 ======================================================================*/
1469 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1471 struct pcmcia_socket *s;
1473 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1474 return CS_BAD_HANDLE;
1475 handle->state &= ~CLIENT_IO_REQ;
1478 #ifdef CONFIG_CARDBUS
1479 if (handle->state & CLIENT_CARDBUS)
1483 if (!(handle->state & CLIENT_STALE)) {
1484 config_t *c = CONFIG(handle);
1485 if (c->state & CONFIG_LOCKED)
1486 return CS_CONFIGURATION_LOCKED;
1487 if ((c->io.BasePort1 != req->BasePort1) ||
1488 (c->io.NumPorts1 != req->NumPorts1) ||
1489 (c->io.BasePort2 != req->BasePort2) ||
1490 (c->io.NumPorts2 != req->NumPorts2))
1492 c->state &= ~CONFIG_IO_REQ;
1495 release_io_space(s, req->BasePort1, req->NumPorts1);
1497 release_io_space(s, req->BasePort2, req->NumPorts2);
1502 /*====================================================================*/
1504 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1506 struct pcmcia_socket *s;
1507 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1508 return CS_BAD_HANDLE;
1509 handle->state &= ~CLIENT_IRQ_REQ;
1512 if (!(handle->state & CLIENT_STALE)) {
1513 config_t *c = CONFIG(handle);
1514 if (c->state & CONFIG_LOCKED)
1515 return CS_CONFIGURATION_LOCKED;
1516 if (c->irq.Attributes != req->Attributes)
1517 return CS_BAD_ATTRIBUTE;
1518 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1520 if (--s->irq.Config == 0) {
1521 c->state &= ~CONFIG_IRQ_REQ;
1522 s->irq.AssignedIRQ = 0;
1526 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1527 free_irq(req->AssignedIRQ, req->Instance);
1530 #ifdef CONFIG_PCMCIA_PROBE
1531 if (req->AssignedIRQ != s->pci_irq)
1532 undo_irq(req->Attributes, req->AssignedIRQ);
1536 } /* cs_release_irq */
1538 /*====================================================================*/
1540 int pcmcia_release_window(window_handle_t win)
1542 struct pcmcia_socket *s;
1544 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1545 return CS_BAD_HANDLE;
1547 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1548 return CS_BAD_HANDLE;
1550 /* Shut down memory window */
1551 win->ctl.flags &= ~MAP_ACTIVE;
1552 s->ops->set_mem_map(s, &win->ctl);
1553 s->state &= ~SOCKET_WIN_REQ(win->index);
1555 /* Release system memory */
1557 release_resource(win->ctl.res);
1558 kfree(win->ctl.res);
1559 win->ctl.res = NULL;
1561 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1566 } /* release_window */
1568 /*====================================================================*/
1570 int pcmcia_request_configuration(client_handle_t handle,
1575 struct pcmcia_socket *s;
1577 pccard_io_map iomap;
1579 if (CHECK_HANDLE(handle))
1580 return CS_BAD_HANDLE;
1582 if (!(s->state & SOCKET_PRESENT))
1585 #ifdef CONFIG_CARDBUS
1586 if (handle->state & CLIENT_CARDBUS)
1587 return CS_UNSUPPORTED_MODE;
1590 if (req->IntType & INT_CARDBUS)
1591 return CS_UNSUPPORTED_MODE;
1593 if (c->state & CONFIG_LOCKED)
1594 return CS_CONFIGURATION_LOCKED;
1596 /* Do power control. We don't allow changes in Vcc. */
1597 if (s->socket.Vcc != req->Vcc)
1599 if (req->Vpp1 != req->Vpp2)
1601 s->socket.Vpp = req->Vpp1;
1602 if (s->ops->set_socket(s, &s->socket))
1605 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1607 /* Pick memory or I/O card, DMA mode, interrupt */
1608 c->IntType = req->IntType;
1609 c->Attributes = req->Attributes;
1610 if (req->IntType & INT_MEMORY_AND_IO)
1611 s->socket.flags |= SS_IOCARD;
1612 if (req->IntType & INT_ZOOMED_VIDEO)
1613 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1614 if (req->Attributes & CONF_ENABLE_DMA)
1615 s->socket.flags |= SS_DMA_MODE;
1616 if (req->Attributes & CONF_ENABLE_SPKR)
1617 s->socket.flags |= SS_SPKR_ENA;
1618 if (req->Attributes & CONF_ENABLE_IRQ)
1619 s->socket.io_irq = s->irq.AssignedIRQ;
1621 s->socket.io_irq = 0;
1622 s->ops->set_socket(s, &s->socket);
1625 /* Set up CIS configuration registers */
1626 base = c->ConfigBase = req->ConfigBase;
1627 c->Present = c->CardValues = req->Present;
1628 if (req->Present & PRESENT_COPY) {
1629 c->Copy = req->Copy;
1630 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1632 if (req->Present & PRESENT_OPTION) {
1633 if (s->functions == 1) {
1634 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1636 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1637 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1638 if (req->Present & PRESENT_IOBASE_0)
1639 c->Option |= COR_ADDR_DECODE;
1641 if (c->state & CONFIG_IRQ_REQ)
1642 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1643 c->Option |= COR_LEVEL_REQ;
1644 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1647 if (req->Present & PRESENT_STATUS) {
1648 c->Status = req->Status;
1649 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1651 if (req->Present & PRESENT_PIN_REPLACE) {
1653 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1655 if (req->Present & PRESENT_EXT_STATUS) {
1656 c->ExtStatus = req->ExtStatus;
1657 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1659 if (req->Present & PRESENT_IOBASE_0) {
1660 u_char b = c->io.BasePort1 & 0xff;
1661 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1662 b = (c->io.BasePort1 >> 8) & 0xff;
1663 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1665 if (req->Present & PRESENT_IOSIZE) {
1666 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1667 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1670 /* Configure I/O windows */
1671 if (c->state & CONFIG_IO_REQ) {
1672 iomap.speed = io_speed;
1673 for (i = 0; i < MAX_IO_WIN; i++)
1674 if (s->io[i].NumPorts != 0) {
1676 iomap.flags = MAP_ACTIVE;
1677 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1678 case IO_DATA_PATH_WIDTH_16:
1679 iomap.flags |= MAP_16BIT; break;
1680 case IO_DATA_PATH_WIDTH_AUTO:
1681 iomap.flags |= MAP_AUTOSZ; break;
1685 iomap.start = s->io[i].BasePort;
1686 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1687 s->ops->set_io_map(s, &iomap);
1692 c->state |= CONFIG_LOCKED;
1693 handle->state |= CLIENT_CONFIG_LOCKED;
1695 } /* request_configuration */
1697 /*======================================================================
1699 Request_io() reserves ranges of port addresses for a socket.
1700 I have not implemented range sharing or alias addressing.
1702 ======================================================================*/
1704 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1706 struct pcmcia_socket *s;
1709 if (CHECK_HANDLE(handle))
1710 return CS_BAD_HANDLE;
1712 if (!(s->state & SOCKET_PRESENT))
1715 if (handle->state & CLIENT_CARDBUS) {
1716 #ifdef CONFIG_CARDBUS
1717 handle->state |= CLIENT_IO_REQ;
1720 return CS_UNSUPPORTED_FUNCTION;
1725 return CS_UNSUPPORTED_MODE;
1727 if (c->state & CONFIG_LOCKED)
1728 return CS_CONFIGURATION_LOCKED;
1729 if (c->state & CONFIG_IO_REQ)
1731 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1732 return CS_BAD_ATTRIBUTE;
1733 if ((req->NumPorts2 > 0) &&
1734 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1735 return CS_BAD_ATTRIBUTE;
1737 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1738 req->NumPorts1, req->IOAddrLines,
1742 if (req->NumPorts2) {
1743 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1744 req->NumPorts2, req->IOAddrLines,
1745 handle->dev_info)) {
1746 release_io_space(s, req->BasePort1, req->NumPorts1);
1752 c->state |= CONFIG_IO_REQ;
1753 handle->state |= CLIENT_IO_REQ;
1757 /*======================================================================
1759 Request_irq() reserves an irq for this client.
1761 Also, since Linux only reserves irq's when they are actually
1762 hooked, we don't guarantee that an irq will still be available
1763 when the configuration is locked. Now that I think about it,
1764 there might be a way to fix this using a dummy handler.
1766 ======================================================================*/
1768 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1770 struct pcmcia_socket *s;
1772 int ret = CS_IN_USE, irq = 0;
1774 if (CHECK_HANDLE(handle))
1775 return CS_BAD_HANDLE;
1777 if (!(s->state & SOCKET_PRESENT))
1780 if (c->state & CONFIG_LOCKED)
1781 return CS_CONFIGURATION_LOCKED;
1782 if (c->state & CONFIG_IRQ_REQ)
1785 #ifdef CONFIG_PCMCIA_PROBE
1786 if (s->irq.AssignedIRQ != 0) {
1787 /* If the interrupt is already assigned, it must match */
1788 irq = s->irq.AssignedIRQ;
1789 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1790 u_int mask = req->IRQInfo2 & s->irq_mask;
1791 ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1793 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1795 if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1796 u_int try, mask = req->IRQInfo2 & s->irq_mask;
1797 for (try = 0; try < 2; try++) {
1798 for (irq = 0; irq < 32; irq++)
1799 if ((mask >> irq) & 1) {
1800 ret = try_irq(req->Attributes, irq, try);
1801 if (ret == 0) break;
1803 if (ret == 0) break;
1806 irq = req->IRQInfo1 & IRQ_MASK;
1807 ret = try_irq(req->Attributes, irq, 1);
1817 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1818 if (request_irq(irq, req->Handler,
1819 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1820 (s->functions > 1) ||
1821 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1822 handle->dev_info, req->Instance))
1826 c->irq.Attributes = req->Attributes;
1827 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1830 c->state |= CONFIG_IRQ_REQ;
1831 handle->state |= CLIENT_IRQ_REQ;
1833 } /* pcmcia_request_irq */
1835 /*======================================================================
1837 Request_window() establishes a mapping between card memory space
1838 and system memory space.
1840 ======================================================================*/
1842 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1844 struct pcmcia_socket *s;
1849 if (CHECK_HANDLE(*handle))
1850 return CS_BAD_HANDLE;
1851 s = (*handle)->Socket;
1852 if (!(s->state & SOCKET_PRESENT))
1854 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1855 return CS_BAD_ATTRIBUTE;
1857 /* Window size defaults to smallest available */
1859 req->Size = s->map_size;
1860 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1861 (req->Attributes & WIN_STRICT_ALIGN)) ?
1862 req->Size : s->map_size);
1863 if (req->Size & (s->map_size-1))
1865 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1866 (req->Base & (align-1)))
1871 /* Allocate system memory window */
1872 for (w = 0; w < MAX_WIN; w++)
1873 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1875 return CS_OUT_OF_RESOURCE;
1878 win->magic = WINDOW_MAGIC;
1880 win->handle = *handle;
1883 if (!(s->features & SS_CAP_STATIC_MAP)) {
1884 win->ctl.res = find_mem_region(req->Base, req->Size, align,
1885 (req->Attributes & WIN_MAP_BELOW_1MB),
1886 (*handle)->dev_info, s);
1889 win->ctl.sys_start = win->ctl.res->start;
1890 win->ctl.sys_stop = win->ctl.res->end;
1892 win->ctl.sys_start = req->Base;
1893 win->ctl.sys_stop = req->Base + req->Size - 1;
1895 (*handle)->state |= CLIENT_WIN_REQ(w);
1897 /* Configure the socket controller */
1900 win->ctl.speed = req->AccessSpeed;
1901 if (req->Attributes & WIN_MEMORY_TYPE)
1902 win->ctl.flags |= MAP_ATTRIB;
1903 if (req->Attributes & WIN_ENABLE)
1904 win->ctl.flags |= MAP_ACTIVE;
1905 if (req->Attributes & WIN_DATA_WIDTH_16)
1906 win->ctl.flags |= MAP_16BIT;
1907 if (req->Attributes & WIN_USE_WAIT)
1908 win->ctl.flags |= MAP_USE_WAIT;
1909 win->ctl.card_start = 0;
1910 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1912 s->state |= SOCKET_WIN_REQ(w);
1914 /* Return window handle */
1915 req->Base = win->ctl.sys_start;
1919 } /* request_window */
1921 /*======================================================================
1923 I'm not sure which "reset" function this is supposed to use,
1924 but for now, it uses the low-level interface's reset, not the
1927 ======================================================================*/
1929 int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
1931 struct pcmcia_socket *skt;
1934 if (CHECK_HANDLE(handle))
1935 return CS_BAD_HANDLE;
1936 skt = SOCKET(handle);
1937 cs_dbg(skt, 1, "resetting socket\n");
1939 down(&skt->skt_sem);
1941 if (!(skt->state & SOCKET_PRESENT)) {
1945 if (skt->state & SOCKET_SUSPEND) {
1949 if (skt->state & SOCKET_CARDBUS) {
1950 ret = CS_UNSUPPORTED_FUNCTION;
1954 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1956 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1957 if (socket_reset(skt) == CS_SUCCESS)
1958 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1961 handle->event_callback_args.info = (void *)(u_long)ret;
1962 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1971 /*======================================================================
1973 These shut down or wake up a socket. They are sort of user
1974 initiated versions of the APM suspend and resume actions.
1976 ======================================================================*/
1978 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1982 cs_dbg(skt, 1, "suspending socket\n");
1984 down(&skt->skt_sem);
1986 if (!(skt->state & SOCKET_PRESENT)) {
1990 if (skt->state & SOCKET_CARDBUS) {
1991 ret = CS_UNSUPPORTED_FUNCTION;
1994 ret = socket_suspend(skt);
1999 } /* suspend_card */
2001 int pcmcia_resume_card(struct pcmcia_socket *skt)
2005 cs_dbg(skt, 1, "waking up socket\n");
2007 down(&skt->skt_sem);
2009 if (!(skt->state & SOCKET_PRESENT)) {
2013 if (skt->state & SOCKET_CARDBUS) {
2014 ret = CS_UNSUPPORTED_FUNCTION;
2017 ret = socket_resume(skt);
2024 /*======================================================================
2026 These handle user requests to eject or insert a card.
2028 ======================================================================*/
2030 int pcmcia_eject_card(struct pcmcia_socket *skt)
2034 cs_dbg(skt, 1, "user eject request\n");
2036 down(&skt->skt_sem);
2038 if (!(skt->state & SOCKET_PRESENT)) {
2043 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2057 int pcmcia_insert_card(struct pcmcia_socket *skt)
2061 cs_dbg(skt, 1, "user insert request\n");
2063 down(&skt->skt_sem);
2065 if (skt->state & SOCKET_PRESENT) {
2069 if (socket_insert(skt) == CS_NO_CARD) {
2080 /*======================================================================
2082 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2083 haven't sent one to this client yet?
2085 ======================================================================*/
2087 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2090 if (CHECK_HANDLE(handle))
2091 return CS_BAD_HANDLE;
2092 if (handle->Attributes & CONF_EVENT_MASK_VALID)
2093 return CS_BAD_SOCKET;
2094 handle->EventMask = mask->EventMask;
2095 events = handle->PendingEvents & handle->EventMask;
2096 handle->PendingEvents -= events;
2097 while (events != 0) {
2098 bit = ((events ^ (events-1)) + 1) >> 1;
2099 EVENT(handle, bit, CS_EVENT_PRI_LOW);
2103 } /* set_event_mask */
2105 /*======================================================================
2107 OS-specific module glue goes here
2109 ======================================================================*/
2110 /* in alpha order */
2111 EXPORT_SYMBOL(pcmcia_access_configuration_register);
2112 EXPORT_SYMBOL(pcmcia_adjust_resource_info);
2113 EXPORT_SYMBOL(pcmcia_check_erase_queue);
2114 EXPORT_SYMBOL(pcmcia_close_memory);
2115 EXPORT_SYMBOL(pcmcia_copy_memory);
2116 EXPORT_SYMBOL(pcmcia_deregister_client);
2117 EXPORT_SYMBOL(pcmcia_deregister_erase_queue);
2118 EXPORT_SYMBOL(pcmcia_eject_card);
2119 EXPORT_SYMBOL(pcmcia_get_first_client);
2120 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2121 EXPORT_SYMBOL(pcmcia_get_configuration_info);
2122 EXPORT_SYMBOL(pcmcia_get_mem_page);
2123 EXPORT_SYMBOL(pcmcia_get_next_client);
2124 EXPORT_SYMBOL(pcmcia_get_first_region);
2125 EXPORT_SYMBOL(pcmcia_get_first_tuple);
2126 EXPORT_SYMBOL(pcmcia_get_first_window);
2127 EXPORT_SYMBOL(pcmcia_get_next_region);
2128 EXPORT_SYMBOL(pcmcia_get_next_tuple);
2129 EXPORT_SYMBOL(pcmcia_get_next_window);
2130 EXPORT_SYMBOL(pcmcia_get_status);
2131 EXPORT_SYMBOL(pcmcia_get_tuple_data);
2132 EXPORT_SYMBOL(pcmcia_insert_card);
2133 EXPORT_SYMBOL(pcmcia_map_mem_page);
2134 EXPORT_SYMBOL(pcmcia_modify_configuration);
2135 EXPORT_SYMBOL(pcmcia_modify_window);
2136 EXPORT_SYMBOL(pcmcia_open_memory);
2137 EXPORT_SYMBOL(pcmcia_parse_tuple);
2138 EXPORT_SYMBOL(pcmcia_read_memory);
2139 EXPORT_SYMBOL(pcmcia_register_client);
2140 EXPORT_SYMBOL(pcmcia_register_erase_queue);
2141 EXPORT_SYMBOL(pcmcia_register_mtd);
2142 EXPORT_SYMBOL(pcmcia_release_configuration);
2143 EXPORT_SYMBOL(pcmcia_release_io);
2144 EXPORT_SYMBOL(pcmcia_release_irq);
2145 EXPORT_SYMBOL(pcmcia_release_window);
2146 EXPORT_SYMBOL(pcmcia_replace_cis);
2147 EXPORT_SYMBOL(pcmcia_request_configuration);
2148 EXPORT_SYMBOL(pcmcia_request_io);
2149 EXPORT_SYMBOL(pcmcia_request_irq);
2150 EXPORT_SYMBOL(pcmcia_request_window);
2151 EXPORT_SYMBOL(pcmcia_reset_card);
2152 EXPORT_SYMBOL(pcmcia_resume_card);
2153 EXPORT_SYMBOL(pcmcia_set_event_mask);
2154 EXPORT_SYMBOL(pcmcia_suspend_card);
2155 EXPORT_SYMBOL(pcmcia_validate_cis);
2156 EXPORT_SYMBOL(pcmcia_write_memory);
2158 EXPORT_SYMBOL(dead_socket);
2159 EXPORT_SYMBOL(MTDHelperEntry);
2160 EXPORT_SYMBOL(pcmcia_parse_events);
2162 struct class pcmcia_socket_class = {
2163 .name = "pcmcia_socket",
2164 .release = pcmcia_release_socket,
2166 EXPORT_SYMBOL(pcmcia_socket_class);
2169 static int __init init_pcmcia_cs(void)
2172 printk(KERN_INFO "%s\n", release);
2173 printk(KERN_INFO " %s\n", options);
2175 ret = class_register(&pcmcia_socket_class);
2178 return class_interface_register(&pccard_sysfs_interface);
2181 static void __exit exit_pcmcia_cs(void)
2183 printk(KERN_INFO "unloading Kernel Card Services\n");
2184 release_resource_db();
2185 class_interface_unregister(&pccard_sysfs_interface);
2186 class_unregister(&pcmcia_socket_class);
2189 subsys_initcall(init_pcmcia_cs);
2190 module_exit(exit_pcmcia_cs);
2192 /*====================================================================*/