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 static void socket_remove_drivers(struct pcmcia_socket
*skt
)
434 cs_dbg(skt
, 4, "remove_drivers\n");
436 send_event(skt
, CS_EVENT_CARD_REMOVAL
, CS_EVENT_PRI_HIGH
);
438 for (client
= skt
->clients
; client
; client
= client
->next
)
439 if (!(client
->Attributes
& INFO_MASTER_CLIENT
))
440 client
->state
|= CLIENT_STALE
;
443 static void socket_shutdown(struct pcmcia_socket
*skt
)
445 cs_dbg(skt
, 4, "shutdown\n");
447 socket_remove_drivers(skt
);
448 skt
->state
&= SOCKET_INUSE
|SOCKET_PRESENT
;
449 msleep(shutdown_delay
* 10);
450 skt
->state
&= SOCKET_INUSE
;
451 shutdown_socket(skt
);
454 static int socket_reset(struct pcmcia_socket
*skt
)
458 cs_dbg(skt
, 4, "reset\n");
460 skt
->socket
.flags
|= SS_OUTPUT_ENA
| SS_RESET
;
461 skt
->ops
->set_socket(skt
, &skt
->socket
);
462 udelay((long)reset_time
);
464 skt
->socket
.flags
&= ~SS_RESET
;
465 skt
->ops
->set_socket(skt
, &skt
->socket
);
467 msleep(unreset_delay
* 10);
468 for (i
= 0; i
< unreset_limit
; i
++) {
469 skt
->ops
->get_status(skt
, &status
);
471 if (!(status
& SS_DETECT
))
474 if (status
& SS_READY
)
477 msleep(unreset_check
* 10);
480 cs_err(skt
, "time out after reset.\n");
481 return CS_GENERAL_FAILURE
;
484 static int socket_setup(struct pcmcia_socket
*skt
, int initial_delay
)
488 cs_dbg(skt
, 4, "setup\n");
490 skt
->ops
->get_status(skt
, &status
);
491 if (!(status
& SS_DETECT
))
494 msleep(initial_delay
* 10);
496 for (i
= 0; i
< 100; i
++) {
497 skt
->ops
->get_status(skt
, &status
);
498 if (!(status
& SS_DETECT
))
501 if (!(status
& SS_PENDING
))
507 if (status
& SS_PENDING
) {
508 cs_err(skt
, "voltage interrogation timed out.\n");
509 return CS_GENERAL_FAILURE
;
512 if (status
& SS_CARDBUS
) {
513 skt
->state
|= SOCKET_CARDBUS
;
514 #ifndef CONFIG_CARDBUS
515 cs_err(skt
, "cardbus cards are not supported.\n");
521 * Decode the card voltage requirements, and apply power to the card.
523 if (status
& SS_3VCARD
)
524 skt
->socket
.Vcc
= skt
->socket
.Vpp
= 33;
525 else if (!(status
& SS_XVCARD
))
526 skt
->socket
.Vcc
= skt
->socket
.Vpp
= 50;
528 cs_err(skt
, "unsupported voltage key.\n");
531 skt
->socket
.flags
= 0;
532 skt
->ops
->set_socket(skt
, &skt
->socket
);
535 * Wait "vcc_settle" for the supply to stabilise.
537 msleep(vcc_settle
* 10);
539 skt
->ops
->get_status(skt
, &status
);
540 if (!(status
& SS_POWERON
)) {
541 cs_err(skt
, "unable to apply power.\n");
545 return socket_reset(skt
);
549 * Handle card insertion. Setup the socket, reset the card,
550 * and then tell the rest of PCMCIA that a card is present.
552 static int socket_insert(struct pcmcia_socket
*skt
)
556 cs_dbg(skt
, 4, "insert\n");
558 if (!cs_socket_get(skt
))
561 ret
= socket_setup(skt
, setup_delay
);
562 if (ret
== CS_SUCCESS
) {
563 skt
->state
|= SOCKET_PRESENT
;
564 #ifdef CONFIG_CARDBUS
565 if (skt
->state
& SOCKET_CARDBUS
) {
567 skt
->state
|= SOCKET_CARDBUS_CONFIG
;
570 cs_dbg(skt
, 4, "insert done\n");
572 send_event(skt
, CS_EVENT_CARD_INSERTION
, CS_EVENT_PRI_LOW
);
574 socket_shutdown(skt
);
581 static int socket_suspend(struct pcmcia_socket
*skt
)
583 if (skt
->state
& SOCKET_SUSPEND
)
586 send_event(skt
, CS_EVENT_PM_SUSPEND
, CS_EVENT_PRI_LOW
);
587 skt
->socket
= dead_socket
;
588 skt
->ops
->suspend(skt
);
589 skt
->state
|= SOCKET_SUSPEND
;
595 * Resume a socket. If a card is present, verify its CIS against
596 * our cached copy. If they are different, the card has been
597 * replaced, and we need to tell the drivers.
599 static int socket_resume(struct pcmcia_socket
*skt
)
603 if (!(skt
->state
& SOCKET_SUSPEND
))
606 skt
->socket
= dead_socket
;
608 skt
->ops
->set_socket(skt
, &skt
->socket
);
610 ret
= socket_setup(skt
, resume_delay
);
611 if (ret
== CS_SUCCESS
) {
613 * FIXME: need a better check here for cardbus cards.
615 if (verify_cis_cache(skt
) != 0) {
616 socket_remove_drivers(skt
);
617 destroy_cis_cache(skt
);
618 send_event(skt
, CS_EVENT_CARD_INSERTION
, CS_EVENT_PRI_LOW
);
620 send_event(skt
, CS_EVENT_PM_RESUME
, CS_EVENT_PRI_LOW
);
623 socket_shutdown(skt
);
627 skt
->state
&= ~SOCKET_SUSPEND
;
632 static void socket_remove(struct pcmcia_socket
*skt
)
634 socket_shutdown(skt
);
639 * Process a socket card detect status change.
641 * If we don't have a card already present, delay the detect event for
642 * about 20ms (to be on the safe side) before reading the socket status.
644 * Some i82365-based systems send multiple SS_DETECT events during card
645 * insertion, and the "card present" status bit seems to bounce. This
646 * will probably be true with GPIO-based card detection systems after
647 * the product has aged.
649 static void socket_detect_change(struct pcmcia_socket
*skt
)
651 if (!(skt
->state
& SOCKET_SUSPEND
)) {
654 if (!(skt
->state
& SOCKET_PRESENT
))
657 skt
->ops
->get_status(skt
, &status
);
658 if ((skt
->state
& SOCKET_PRESENT
) &&
659 !(status
& SS_DETECT
))
661 if (!(skt
->state
& SOCKET_PRESENT
) &&
662 (status
& SS_DETECT
))
667 static int pccardd(void *__skt
)
669 struct pcmcia_socket
*skt
= __skt
;
670 DECLARE_WAITQUEUE(wait
, current
);
673 daemonize("pccardd");
675 skt
->thread
= current
;
676 skt
->socket
= dead_socket
;
678 skt
->ops
->set_socket(skt
, &skt
->socket
);
680 /* register with the device core */
681 ret
= class_device_register(&skt
->dev
);
683 printk(KERN_WARNING
"PCMCIA: unable to register socket 0x%p\n",
686 complete_and_exit(&skt
->thread_done
, 0);
688 complete(&skt
->thread_done
);
690 add_wait_queue(&skt
->thread_wait
, &wait
);
695 set_current_state(TASK_INTERRUPTIBLE
);
697 spin_lock_irqsave(&skt
->thread_lock
, flags
);
698 events
= skt
->thread_events
;
699 skt
->thread_events
= 0;
700 spin_unlock_irqrestore(&skt
->thread_lock
, flags
);
704 if (events
& SS_DETECT
)
705 socket_detect_change(skt
);
706 if (events
& SS_BATDEAD
)
707 send_event(skt
, CS_EVENT_BATTERY_DEAD
, CS_EVENT_PRI_LOW
);
708 if (events
& SS_BATWARN
)
709 send_event(skt
, CS_EVENT_BATTERY_LOW
, CS_EVENT_PRI_LOW
);
710 if (events
& SS_READY
)
711 send_event(skt
, CS_EVENT_READY_CHANGE
, CS_EVENT_PRI_LOW
);
717 if (current
->flags
& PF_FREEZE
)
718 refrigerator(PF_FREEZE
);
723 remove_wait_queue(&skt
->thread_wait
, &wait
);
725 /* remove from the device core */
726 class_device_unregister(&skt
->dev
);
728 complete_and_exit(&skt
->thread_done
, 0);
732 * Yenta (at least) probes interrupts before registering the socket and
733 * starting the handler thread.
735 void pcmcia_parse_events(struct pcmcia_socket
*s
, u_int events
)
737 cs_dbg(s
, 4, "parse_events: events %08x\n", events
);
739 spin_lock(&s
->thread_lock
);
740 s
->thread_events
|= events
;
741 spin_unlock(&s
->thread_lock
);
743 wake_up(&s
->thread_wait
);
745 } /* pcmcia_parse_events */
748 /*======================================================================
750 Special stuff for managing IO windows, because they are scarce.
752 ======================================================================*/
754 static int alloc_io_space(struct pcmcia_socket
*s
, u_int attr
, ioaddr_t
*base
,
755 ioaddr_t num
, u_int lines
, char *name
)
760 align
= (*base
) ? (lines
? 1<<lines
: 0) : 1;
761 if (align
&& (align
< num
)) {
763 cs_dbg(s
, 0, "odd IO request: num %04x align %04x\n",
767 while (align
&& (align
< num
)) align
<<= 1;
769 if (*base
& ~(align
-1)) {
770 cs_dbg(s
, 0, "odd IO request: base %04x align %04x\n",
774 if ((s
->features
& SS_CAP_STATIC_MAP
) && s
->io_offset
) {
775 *base
= s
->io_offset
| (*base
& 0x0fff);
778 /* Check for an already-allocated window that must conflict with
779 what was asked for. It is a hack because it does not catch all
780 potential conflicts, just the most obvious ones. */
781 for (i
= 0; i
< MAX_IO_WIN
; i
++)
782 if ((s
->io
[i
].NumPorts
!= 0) &&
783 ((s
->io
[i
].BasePort
& (align
-1)) == *base
))
785 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
786 if (s
->io
[i
].NumPorts
== 0) {
787 s
->io
[i
].res
= find_io_region(*base
, num
, align
, name
, s
);
789 s
->io
[i
].Attributes
= attr
;
790 s
->io
[i
].BasePort
= *base
= s
->io
[i
].res
->start
;
791 s
->io
[i
].NumPorts
= s
->io
[i
].InUse
= num
;
795 } else if (s
->io
[i
].Attributes
!= attr
)
797 /* Try to extend top of window */
798 try = s
->io
[i
].BasePort
+ s
->io
[i
].NumPorts
;
799 if ((*base
== 0) || (*base
== try))
800 if (adjust_io_region(s
->io
[i
].res
, s
->io
[i
].res
->start
,
801 s
->io
[i
].res
->end
+ num
, s
) == 0) {
803 s
->io
[i
].NumPorts
+= num
;
804 s
->io
[i
].InUse
+= num
;
807 /* Try to extend bottom of window */
808 try = s
->io
[i
].BasePort
- num
;
809 if ((*base
== 0) || (*base
== try))
810 if (adjust_io_region(s
->io
[i
].res
, s
->io
[i
].res
->start
- num
,
811 s
->io
[i
].res
->end
, s
) == 0) {
812 s
->io
[i
].BasePort
= *base
= try;
813 s
->io
[i
].NumPorts
+= num
;
814 s
->io
[i
].InUse
+= num
;
818 return (i
== MAX_IO_WIN
);
819 } /* alloc_io_space */
821 static void release_io_space(struct pcmcia_socket
*s
, ioaddr_t base
,
826 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
827 if ((s
->io
[i
].BasePort
<= base
) &&
828 (s
->io
[i
].BasePort
+s
->io
[i
].NumPorts
>= base
+num
)) {
829 s
->io
[i
].InUse
-= num
;
830 /* Free the window if no one else is using it */
831 if (s
->io
[i
].InUse
== 0) {
832 s
->io
[i
].NumPorts
= 0;
833 release_resource(s
->io
[i
].res
);
841 /*======================================================================
843 Access_configuration_register() reads and writes configuration
844 registers in attribute memory. Memory window 0 is reserved for
845 this and the tuple reading services.
847 ======================================================================*/
849 int pcmcia_access_configuration_register(client_handle_t handle
,
852 struct pcmcia_socket
*s
;
857 if (CHECK_HANDLE(handle
))
858 return CS_BAD_HANDLE
;
860 if (handle
->Function
== BIND_FN_ALL
) {
861 if (reg
->Function
>= s
->functions
)
863 c
= &s
->config
[reg
->Function
];
870 if (!(c
->state
& CONFIG_LOCKED
))
871 return CS_CONFIGURATION_LOCKED
;
873 addr
= (c
->ConfigBase
+ reg
->Offset
) >> 1;
875 switch (reg
->Action
) {
877 read_cis_mem(s
, 1, addr
, 1, &val
);
882 write_cis_mem(s
, 1, addr
, 1, &val
);
889 } /* access_configuration_register */
892 /*====================================================================*/
894 int pcmcia_deregister_client(client_handle_t handle
)
897 struct pcmcia_socket
*s
;
898 memory_handle_t region
;
902 if (CHECK_HANDLE(handle
))
903 return CS_BAD_HANDLE
;
906 cs_dbg(s
, 1, "deregister_client(%p)\n", handle
);
909 (CLIENT_IRQ_REQ
|CLIENT_IO_REQ
|CLIENT_CONFIG_LOCKED
))
911 for (i
= 0; i
< MAX_WIN
; i
++)
912 if (handle
->state
& CLIENT_WIN_REQ(i
))
915 /* Disconnect all MTD links */
916 if (handle
->mtd_count
) {
917 for (region
= s
->a_region
; region
; region
= region
->info
.next
)
918 if (region
->mtd
== handle
) region
->mtd
= NULL
;
919 for (region
= s
->c_region
; region
; region
= region
->info
.next
)
920 if (region
->mtd
== handle
) region
->mtd
= NULL
;
923 if ((handle
->state
& CLIENT_STALE
) ||
924 (handle
->Attributes
& INFO_MASTER_CLIENT
)) {
925 spin_lock_irqsave(&s
->lock
, flags
);
926 client
= &s
->clients
;
927 while ((*client
) && ((*client
) != handle
))
928 client
= &(*client
)->next
;
929 if (*client
== NULL
) {
930 spin_unlock_irqrestore(&s
->lock
, flags
);
931 return CS_BAD_HANDLE
;
933 *client
= handle
->next
;
934 handle
->client_magic
= 0;
936 spin_unlock_irqrestore(&s
->lock
, flags
);
938 handle
->state
= CLIENT_UNBOUND
;
939 handle
->mtd_count
= 0;
940 handle
->event_handler
= NULL
;
944 } /* deregister_client */
946 /*====================================================================*/
948 int pcmcia_get_configuration_info(client_handle_t handle
,
949 config_info_t
*config
)
951 struct pcmcia_socket
*s
;
954 if (CHECK_HANDLE(handle
))
955 return CS_BAD_HANDLE
;
957 if (!(s
->state
& SOCKET_PRESENT
))
960 if (handle
->Function
== BIND_FN_ALL
) {
961 if (config
->Function
&& (config
->Function
>= s
->functions
))
964 config
->Function
= handle
->Function
;
966 #ifdef CONFIG_CARDBUS
967 if (s
->state
& SOCKET_CARDBUS
) {
968 u_char fn
= config
->Function
;
969 memset(config
, 0, sizeof(config_info_t
));
970 config
->Function
= fn
;
971 config
->Vcc
= s
->socket
.Vcc
;
972 config
->Vpp1
= config
->Vpp2
= s
->socket
.Vpp
;
973 config
->Option
= s
->cb_dev
->subordinate
->number
;
974 if (s
->state
& SOCKET_CARDBUS_CONFIG
) {
975 config
->Attributes
= CONF_VALID_CLIENT
;
976 config
->IntType
= INT_CARDBUS
;
977 config
->AssignedIRQ
= s
->irq
.AssignedIRQ
;
978 if (config
->AssignedIRQ
)
979 config
->Attributes
|= CONF_ENABLE_IRQ
;
980 config
->BasePort1
= s
->io
[0].BasePort
;
981 config
->NumPorts1
= s
->io
[0].NumPorts
;
987 c
= (s
->config
!= NULL
) ? &s
->config
[config
->Function
] : NULL
;
989 if ((c
== NULL
) || !(c
->state
& CONFIG_LOCKED
)) {
990 config
->Attributes
= 0;
991 config
->Vcc
= s
->socket
.Vcc
;
992 config
->Vpp1
= config
->Vpp2
= s
->socket
.Vpp
;
996 /* !!! This is a hack !!! */
997 memcpy(&config
->Attributes
, &c
->Attributes
, sizeof(config_t
));
998 config
->Attributes
|= CONF_VALID_CLIENT
;
999 config
->CardValues
= c
->CardValues
;
1000 config
->IRQAttributes
= c
->irq
.Attributes
;
1001 config
->AssignedIRQ
= s
->irq
.AssignedIRQ
;
1002 config
->BasePort1
= c
->io
.BasePort1
;
1003 config
->NumPorts1
= c
->io
.NumPorts1
;
1004 config
->Attributes1
= c
->io
.Attributes1
;
1005 config
->BasePort2
= c
->io
.BasePort2
;
1006 config
->NumPorts2
= c
->io
.NumPorts2
;
1007 config
->Attributes2
= c
->io
.Attributes2
;
1008 config
->IOAddrLines
= c
->io
.IOAddrLines
;
1011 } /* get_configuration_info */
1013 /*======================================================================
1015 Return information about this version of Card Services.
1017 ======================================================================*/
1019 int pcmcia_get_card_services_info(servinfo_t
*info
)
1021 unsigned int socket_count
= 0;
1022 struct list_head
*tmp
;
1023 info
->Signature
[0] = 'C';
1024 info
->Signature
[1] = 'S';
1025 down_read(&pcmcia_socket_list_rwsem
);
1026 list_for_each(tmp
, &pcmcia_socket_list
)
1028 up_read(&pcmcia_socket_list_rwsem
);
1029 info
->Count
= socket_count
;
1030 info
->Revision
= CS_RELEASE_CODE
;
1031 info
->CSLevel
= 0x0210;
1032 info
->VendorString
= (char *)release
;
1034 } /* get_card_services_info */
1036 /*======================================================================
1038 Note that get_first_client() *does* recognize the Socket field
1039 in the request structure.
1041 ======================================================================*/
1043 int pcmcia_get_first_client(client_handle_t
*handle
, client_req_t
*req
)
1046 struct pcmcia_socket
*socket
;
1047 if (req
->Attributes
& CLIENT_THIS_SOCKET
)
1051 socket
= pcmcia_get_socket_by_nr(s
);
1053 return CS_BAD_SOCKET
;
1054 if (socket
->clients
== NULL
)
1055 return CS_NO_MORE_ITEMS
;
1056 *handle
= socket
->clients
;
1058 } /* get_first_client */
1060 /*====================================================================*/
1062 int pcmcia_get_next_client(client_handle_t
*handle
, client_req_t
*req
)
1064 struct pcmcia_socket
*s
;
1065 if ((handle
== NULL
) || CHECK_HANDLE(*handle
))
1066 return CS_BAD_HANDLE
;
1067 if ((*handle
)->next
== NULL
) {
1068 if (req
->Attributes
& CLIENT_THIS_SOCKET
)
1069 return CS_NO_MORE_ITEMS
;
1070 s
= (*handle
)->Socket
;
1071 if (s
->clients
== NULL
)
1072 return CS_NO_MORE_ITEMS
;
1073 *handle
= s
->clients
;
1075 *handle
= (*handle
)->next
;
1077 } /* get_next_client */
1079 /*====================================================================*/
1081 int pcmcia_get_window(window_handle_t
*handle
, int idx
, win_req_t
*req
)
1083 struct pcmcia_socket
*s
;
1088 s
= ((client_handle_t
)*handle
)->Socket
;
1090 s
= (*handle
)->sock
;
1091 if (!(s
->state
& SOCKET_PRESENT
))
1093 for (w
= idx
; w
< MAX_WIN
; w
++)
1094 if (s
->state
& SOCKET_WIN_REQ(w
)) break;
1096 return CS_NO_MORE_ITEMS
;
1098 req
->Base
= win
->ctl
.res
->start
;
1099 req
->Size
= win
->ctl
.res
->end
- win
->ctl
.res
->start
+ 1;
1100 req
->AccessSpeed
= win
->ctl
.speed
;
1101 req
->Attributes
= 0;
1102 if (win
->ctl
.flags
& MAP_ATTRIB
)
1103 req
->Attributes
|= WIN_MEMORY_TYPE_AM
;
1104 if (win
->ctl
.flags
& MAP_ACTIVE
)
1105 req
->Attributes
|= WIN_ENABLE
;
1106 if (win
->ctl
.flags
& MAP_16BIT
)
1107 req
->Attributes
|= WIN_DATA_WIDTH_16
;
1108 if (win
->ctl
.flags
& MAP_USE_WAIT
)
1109 req
->Attributes
|= WIN_USE_WAIT
;
1114 int pcmcia_get_first_window(window_handle_t
*win
, win_req_t
*req
)
1116 if ((win
== NULL
) || ((*win
)->magic
!= WINDOW_MAGIC
))
1117 return CS_BAD_HANDLE
;
1118 return pcmcia_get_window(win
, 0, req
);
1121 int pcmcia_get_next_window(window_handle_t
*win
, win_req_t
*req
)
1123 if ((win
== NULL
) || ((*win
)->magic
!= WINDOW_MAGIC
))
1124 return CS_BAD_HANDLE
;
1125 return pcmcia_get_window(win
, (*win
)->index
+1, req
);
1128 /*=====================================================================
1130 Return the PCI device associated with a card..
1132 ======================================================================*/
1134 #ifdef CONFIG_CARDBUS
1136 struct pci_bus
*pcmcia_lookup_bus(client_handle_t handle
)
1138 struct pcmcia_socket
*s
;
1140 if (CHECK_HANDLE(handle
))
1143 if (!(s
->state
& SOCKET_CARDBUS
))
1146 return s
->cb_dev
->subordinate
;
1149 EXPORT_SYMBOL(pcmcia_lookup_bus
);
1153 /*======================================================================
1155 Get the current socket state bits. We don't support the latched
1156 SocketState yet: I haven't seen any point for it.
1158 ======================================================================*/
1160 int pcmcia_get_status(client_handle_t handle
, cs_status_t
*status
)
1162 struct pcmcia_socket
*s
;
1166 if (CHECK_HANDLE(handle
))
1167 return CS_BAD_HANDLE
;
1169 s
->ops
->get_status(s
, &val
);
1170 status
->CardState
= status
->SocketState
= 0;
1171 status
->CardState
|= (val
& SS_DETECT
) ? CS_EVENT_CARD_DETECT
: 0;
1172 status
->CardState
|= (val
& SS_CARDBUS
) ? CS_EVENT_CB_DETECT
: 0;
1173 status
->CardState
|= (val
& SS_3VCARD
) ? CS_EVENT_3VCARD
: 0;
1174 status
->CardState
|= (val
& SS_XVCARD
) ? CS_EVENT_XVCARD
: 0;
1175 if (s
->state
& SOCKET_SUSPEND
)
1176 status
->CardState
|= CS_EVENT_PM_SUSPEND
;
1177 if (!(s
->state
& SOCKET_PRESENT
))
1180 /* Get info from the PRR, if necessary */
1181 if (handle
->Function
== BIND_FN_ALL
) {
1182 if (status
->Function
&& (status
->Function
>= s
->functions
))
1184 c
= (s
->config
!= NULL
) ? &s
->config
[status
->Function
] : NULL
;
1187 if ((c
!= NULL
) && (c
->state
& CONFIG_LOCKED
) &&
1188 (c
->IntType
& (INT_MEMORY_AND_IO
| INT_ZOOMED_VIDEO
))) {
1190 if (c
->Present
& PRESENT_PIN_REPLACE
) {
1191 read_cis_mem(s
, 1, (c
->ConfigBase
+CISREG_PRR
)>>1, 1, ®
);
1192 status
->CardState
|=
1193 (reg
& PRR_WP_STATUS
) ? CS_EVENT_WRITE_PROTECT
: 0;
1194 status
->CardState
|=
1195 (reg
& PRR_READY_STATUS
) ? CS_EVENT_READY_CHANGE
: 0;
1196 status
->CardState
|=
1197 (reg
& PRR_BVD2_STATUS
) ? CS_EVENT_BATTERY_LOW
: 0;
1198 status
->CardState
|=
1199 (reg
& PRR_BVD1_STATUS
) ? CS_EVENT_BATTERY_DEAD
: 0;
1201 /* No PRR? Then assume we're always ready */
1202 status
->CardState
|= CS_EVENT_READY_CHANGE
;
1204 if (c
->Present
& PRESENT_EXT_STATUS
) {
1205 read_cis_mem(s
, 1, (c
->ConfigBase
+CISREG_ESR
)>>1, 1, ®
);
1206 status
->CardState
|=
1207 (reg
& ESR_REQ_ATTN
) ? CS_EVENT_REQUEST_ATTENTION
: 0;
1211 status
->CardState
|=
1212 (val
& SS_WRPROT
) ? CS_EVENT_WRITE_PROTECT
: 0;
1213 status
->CardState
|=
1214 (val
& SS_BATDEAD
) ? CS_EVENT_BATTERY_DEAD
: 0;
1215 status
->CardState
|=
1216 (val
& SS_BATWARN
) ? CS_EVENT_BATTERY_LOW
: 0;
1217 status
->CardState
|=
1218 (val
& SS_READY
) ? CS_EVENT_READY_CHANGE
: 0;
1222 /*======================================================================
1224 Change the card address of an already open memory window.
1226 ======================================================================*/
1228 int pcmcia_get_mem_page(window_handle_t win
, memreq_t
*req
)
1230 if ((win
== NULL
) || (win
->magic
!= WINDOW_MAGIC
))
1231 return CS_BAD_HANDLE
;
1233 req
->CardOffset
= win
->ctl
.card_start
;
1235 } /* get_mem_page */
1237 int pcmcia_map_mem_page(window_handle_t win
, memreq_t
*req
)
1239 struct pcmcia_socket
*s
;
1240 if ((win
== NULL
) || (win
->magic
!= WINDOW_MAGIC
))
1241 return CS_BAD_HANDLE
;
1245 win
->ctl
.card_start
= req
->CardOffset
;
1246 if (s
->ops
->set_mem_map(s
, &win
->ctl
) != 0)
1247 return CS_BAD_OFFSET
;
1249 } /* map_mem_page */
1251 /*======================================================================
1253 Modify a locked socket configuration
1255 ======================================================================*/
1257 int pcmcia_modify_configuration(client_handle_t handle
,
1260 struct pcmcia_socket
*s
;
1263 if (CHECK_HANDLE(handle
))
1264 return CS_BAD_HANDLE
;
1265 s
= SOCKET(handle
); c
= CONFIG(handle
);
1266 if (!(s
->state
& SOCKET_PRESENT
))
1268 if (!(c
->state
& CONFIG_LOCKED
))
1269 return CS_CONFIGURATION_LOCKED
;
1271 if (mod
->Attributes
& CONF_IRQ_CHANGE_VALID
) {
1272 if (mod
->Attributes
& CONF_ENABLE_IRQ
) {
1273 c
->Attributes
|= CONF_ENABLE_IRQ
;
1274 s
->socket
.io_irq
= s
->irq
.AssignedIRQ
;
1276 c
->Attributes
&= ~CONF_ENABLE_IRQ
;
1277 s
->socket
.io_irq
= 0;
1279 s
->ops
->set_socket(s
, &s
->socket
);
1282 if (mod
->Attributes
& CONF_VCC_CHANGE_VALID
)
1285 /* We only allow changing Vpp1 and Vpp2 to the same value */
1286 if ((mod
->Attributes
& CONF_VPP1_CHANGE_VALID
) &&
1287 (mod
->Attributes
& CONF_VPP2_CHANGE_VALID
)) {
1288 if (mod
->Vpp1
!= mod
->Vpp2
)
1290 c
->Vpp1
= c
->Vpp2
= s
->socket
.Vpp
= mod
->Vpp1
;
1291 if (s
->ops
->set_socket(s
, &s
->socket
))
1293 } else if ((mod
->Attributes
& CONF_VPP1_CHANGE_VALID
) ||
1294 (mod
->Attributes
& CONF_VPP2_CHANGE_VALID
))
1298 } /* modify_configuration */
1300 /*======================================================================
1302 Modify the attributes of a window returned by RequestWindow.
1304 ======================================================================*/
1306 int pcmcia_modify_window(window_handle_t win
, modwin_t
*req
)
1308 if ((win
== NULL
) || (win
->magic
!= WINDOW_MAGIC
))
1309 return CS_BAD_HANDLE
;
1311 win
->ctl
.flags
&= ~(MAP_ATTRIB
|MAP_ACTIVE
);
1312 if (req
->Attributes
& WIN_MEMORY_TYPE
)
1313 win
->ctl
.flags
|= MAP_ATTRIB
;
1314 if (req
->Attributes
& WIN_ENABLE
)
1315 win
->ctl
.flags
|= MAP_ACTIVE
;
1316 if (req
->Attributes
& WIN_DATA_WIDTH_16
)
1317 win
->ctl
.flags
|= MAP_16BIT
;
1318 if (req
->Attributes
& WIN_USE_WAIT
)
1319 win
->ctl
.flags
|= MAP_USE_WAIT
;
1320 win
->ctl
.speed
= req
->AccessSpeed
;
1321 win
->sock
->ops
->set_mem_map(win
->sock
, &win
->ctl
);
1324 } /* modify_window */
1326 /*======================================================================
1328 Register_client() uses the dev_info_t handle to match the
1329 caller with a socket. The driver must have already been bound
1330 to a socket with bind_device() -- in fact, bind_device()
1331 allocates the client structure that will be used.
1333 ======================================================================*/
1335 int pcmcia_register_client(client_handle_t
*handle
, client_reg_t
*req
)
1337 client_t
*client
= NULL
;
1338 struct pcmcia_socket
*s
;
1340 /* Look for unbound client with matching dev_info */
1341 down_read(&pcmcia_socket_list_rwsem
);
1342 list_for_each_entry(s
, &pcmcia_socket_list
, socket_list
) {
1343 client
= s
->clients
;
1344 while (client
!= NULL
) {
1345 if ((strcmp(client
->dev_info
, (char *)req
->dev_info
) == 0)
1346 && (client
->state
& CLIENT_UNBOUND
)) break;
1347 client
= client
->next
;
1349 if (client
!= NULL
) break;
1351 up_read(&pcmcia_socket_list_rwsem
);
1353 return CS_OUT_OF_RESOURCE
;
1356 * Prevent this racing with a card insertion.
1360 client
->state
&= ~CLIENT_UNBOUND
;
1362 client
->Attributes
= req
->Attributes
;
1363 client
->EventMask
= req
->EventMask
;
1364 client
->event_handler
= req
->event_handler
;
1365 client
->event_callback_args
= req
->event_callback_args
;
1366 client
->event_callback_args
.client_handle
= client
;
1368 if (s
->state
& SOCKET_CARDBUS
)
1369 client
->state
|= CLIENT_CARDBUS
;
1371 if ((!(s
->state
& SOCKET_CARDBUS
)) && (s
->functions
== 0) &&
1372 (client
->Function
!= BIND_FN_ALL
)) {
1373 cistpl_longlink_mfc_t mfc
;
1374 if (read_tuple(client
, CISTPL_LONGLINK_MFC
, &mfc
)
1376 s
->functions
= mfc
.nfn
;
1379 s
->config
= kmalloc(sizeof(config_t
) * s
->functions
,
1382 goto out_no_resource
;
1383 memset(s
->config
, 0, sizeof(config_t
) * s
->functions
);
1386 cs_dbg(s
, 1, "register_client(): client 0x%p, dev %s\n",
1387 client
, client
->dev_info
);
1388 if (client
->EventMask
& CS_EVENT_REGISTRATION_COMPLETE
)
1389 EVENT(client
, CS_EVENT_REGISTRATION_COMPLETE
, CS_EVENT_PRI_LOW
);
1391 if ((s
->state
& (SOCKET_PRESENT
|SOCKET_CARDBUS
)) == SOCKET_PRESENT
) {
1392 if (client
->EventMask
& CS_EVENT_CARD_INSERTION
)
1393 EVENT(client
, CS_EVENT_CARD_INSERTION
, CS_EVENT_PRI_LOW
);
1395 client
->PendingEvents
|= CS_EVENT_CARD_INSERTION
;
1403 return CS_OUT_OF_RESOURCE
;
1404 } /* register_client */
1406 /*====================================================================*/
1408 int pcmcia_release_configuration(client_handle_t handle
)
1410 pccard_io_map io
= { 0, 0, 0, 0, 1 };
1411 struct pcmcia_socket
*s
;
1414 if (CHECK_HANDLE(handle
) ||
1415 !(handle
->state
& CLIENT_CONFIG_LOCKED
))
1416 return CS_BAD_HANDLE
;
1417 handle
->state
&= ~CLIENT_CONFIG_LOCKED
;
1420 #ifdef CONFIG_CARDBUS
1421 if (handle
->state
& CLIENT_CARDBUS
)
1425 if (!(handle
->state
& CLIENT_STALE
)) {
1426 config_t
*c
= CONFIG(handle
);
1427 if (--(s
->lock_count
) == 0) {
1428 s
->socket
.flags
= SS_OUTPUT_ENA
; /* Is this correct? */
1430 s
->socket
.io_irq
= 0;
1431 s
->ops
->set_socket(s
, &s
->socket
);
1433 if (c
->state
& CONFIG_IO_REQ
)
1434 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
1435 if (s
->io
[i
].NumPorts
== 0)
1438 if (s
->io
[i
].Config
!= 0)
1441 s
->ops
->set_io_map(s
, &io
);
1443 c
->state
&= ~CONFIG_LOCKED
;
1447 } /* release_configuration */
1449 /*======================================================================
1451 Release_io() releases the I/O ranges allocated by a client. This
1452 may be invoked some time after a card ejection has already dumped
1453 the actual socket configuration, so if the client is "stale", we
1454 don't bother checking the port ranges against the current socket
1457 ======================================================================*/
1459 int pcmcia_release_io(client_handle_t handle
, io_req_t
*req
)
1461 struct pcmcia_socket
*s
;
1463 if (CHECK_HANDLE(handle
) || !(handle
->state
& CLIENT_IO_REQ
))
1464 return CS_BAD_HANDLE
;
1465 handle
->state
&= ~CLIENT_IO_REQ
;
1468 #ifdef CONFIG_CARDBUS
1469 if (handle
->state
& CLIENT_CARDBUS
)
1473 if (!(handle
->state
& CLIENT_STALE
)) {
1474 config_t
*c
= CONFIG(handle
);
1475 if (c
->state
& CONFIG_LOCKED
)
1476 return CS_CONFIGURATION_LOCKED
;
1477 if ((c
->io
.BasePort1
!= req
->BasePort1
) ||
1478 (c
->io
.NumPorts1
!= req
->NumPorts1
) ||
1479 (c
->io
.BasePort2
!= req
->BasePort2
) ||
1480 (c
->io
.NumPorts2
!= req
->NumPorts2
))
1482 c
->state
&= ~CONFIG_IO_REQ
;
1485 release_io_space(s
, req
->BasePort1
, req
->NumPorts1
);
1487 release_io_space(s
, req
->BasePort2
, req
->NumPorts2
);
1492 /*====================================================================*/
1494 int pcmcia_release_irq(client_handle_t handle
, irq_req_t
*req
)
1496 struct pcmcia_socket
*s
;
1497 if (CHECK_HANDLE(handle
) || !(handle
->state
& CLIENT_IRQ_REQ
))
1498 return CS_BAD_HANDLE
;
1499 handle
->state
&= ~CLIENT_IRQ_REQ
;
1502 if (!(handle
->state
& CLIENT_STALE
)) {
1503 config_t
*c
= CONFIG(handle
);
1504 if (c
->state
& CONFIG_LOCKED
)
1505 return CS_CONFIGURATION_LOCKED
;
1506 if (c
->irq
.Attributes
!= req
->Attributes
)
1507 return CS_BAD_ATTRIBUTE
;
1508 if (s
->irq
.AssignedIRQ
!= req
->AssignedIRQ
)
1510 if (--s
->irq
.Config
== 0) {
1511 c
->state
&= ~CONFIG_IRQ_REQ
;
1512 s
->irq
.AssignedIRQ
= 0;
1516 if (req
->Attributes
& IRQ_HANDLE_PRESENT
) {
1517 free_irq(req
->AssignedIRQ
, req
->Instance
);
1520 #ifdef CONFIG_PCMCIA_PROBE
1521 if (req
->AssignedIRQ
!= s
->pci_irq
)
1522 undo_irq(req
->Attributes
, req
->AssignedIRQ
);
1526 } /* cs_release_irq */
1528 /*====================================================================*/
1530 int pcmcia_release_window(window_handle_t win
)
1532 struct pcmcia_socket
*s
;
1534 if ((win
== NULL
) || (win
->magic
!= WINDOW_MAGIC
))
1535 return CS_BAD_HANDLE
;
1537 if (!(win
->handle
->state
& CLIENT_WIN_REQ(win
->index
)))
1538 return CS_BAD_HANDLE
;
1540 /* Shut down memory window */
1541 win
->ctl
.flags
&= ~MAP_ACTIVE
;
1542 s
->ops
->set_mem_map(s
, &win
->ctl
);
1543 s
->state
&= ~SOCKET_WIN_REQ(win
->index
);
1545 /* Release system memory */
1547 release_resource(win
->ctl
.res
);
1548 kfree(win
->ctl
.res
);
1549 win
->ctl
.res
= NULL
;
1551 win
->handle
->state
&= ~CLIENT_WIN_REQ(win
->index
);
1556 } /* release_window */
1558 /*====================================================================*/
1560 int pcmcia_request_configuration(client_handle_t handle
,
1565 struct pcmcia_socket
*s
;
1567 pccard_io_map iomap
;
1569 if (CHECK_HANDLE(handle
))
1570 return CS_BAD_HANDLE
;
1572 if (!(s
->state
& SOCKET_PRESENT
))
1575 #ifdef CONFIG_CARDBUS
1576 if (handle
->state
& CLIENT_CARDBUS
)
1577 return CS_UNSUPPORTED_MODE
;
1580 if (req
->IntType
& INT_CARDBUS
)
1581 return CS_UNSUPPORTED_MODE
;
1583 if (c
->state
& CONFIG_LOCKED
)
1584 return CS_CONFIGURATION_LOCKED
;
1586 /* Do power control. We don't allow changes in Vcc. */
1587 if (s
->socket
.Vcc
!= req
->Vcc
)
1589 if (req
->Vpp1
!= req
->Vpp2
)
1591 s
->socket
.Vpp
= req
->Vpp1
;
1592 if (s
->ops
->set_socket(s
, &s
->socket
))
1595 c
->Vcc
= req
->Vcc
; c
->Vpp1
= c
->Vpp2
= req
->Vpp1
;
1597 /* Pick memory or I/O card, DMA mode, interrupt */
1598 c
->IntType
= req
->IntType
;
1599 c
->Attributes
= req
->Attributes
;
1600 if (req
->IntType
& INT_MEMORY_AND_IO
)
1601 s
->socket
.flags
|= SS_IOCARD
;
1602 if (req
->IntType
& INT_ZOOMED_VIDEO
)
1603 s
->socket
.flags
|= SS_ZVCARD
| SS_IOCARD
;
1604 if (req
->Attributes
& CONF_ENABLE_DMA
)
1605 s
->socket
.flags
|= SS_DMA_MODE
;
1606 if (req
->Attributes
& CONF_ENABLE_SPKR
)
1607 s
->socket
.flags
|= SS_SPKR_ENA
;
1608 if (req
->Attributes
& CONF_ENABLE_IRQ
)
1609 s
->socket
.io_irq
= s
->irq
.AssignedIRQ
;
1611 s
->socket
.io_irq
= 0;
1612 s
->ops
->set_socket(s
, &s
->socket
);
1615 /* Set up CIS configuration registers */
1616 base
= c
->ConfigBase
= req
->ConfigBase
;
1617 c
->Present
= c
->CardValues
= req
->Present
;
1618 if (req
->Present
& PRESENT_COPY
) {
1619 c
->Copy
= req
->Copy
;
1620 write_cis_mem(s
, 1, (base
+ CISREG_SCR
)>>1, 1, &c
->Copy
);
1622 if (req
->Present
& PRESENT_OPTION
) {
1623 if (s
->functions
== 1) {
1624 c
->Option
= req
->ConfigIndex
& COR_CONFIG_MASK
;
1626 c
->Option
= req
->ConfigIndex
& COR_MFC_CONFIG_MASK
;
1627 c
->Option
|= COR_FUNC_ENA
|COR_IREQ_ENA
;
1628 if (req
->Present
& PRESENT_IOBASE_0
)
1629 c
->Option
|= COR_ADDR_DECODE
;
1631 if (c
->state
& CONFIG_IRQ_REQ
)
1632 if (!(c
->irq
.Attributes
& IRQ_FORCED_PULSE
))
1633 c
->Option
|= COR_LEVEL_REQ
;
1634 write_cis_mem(s
, 1, (base
+ CISREG_COR
)>>1, 1, &c
->Option
);
1637 if (req
->Present
& PRESENT_STATUS
) {
1638 c
->Status
= req
->Status
;
1639 write_cis_mem(s
, 1, (base
+ CISREG_CCSR
)>>1, 1, &c
->Status
);
1641 if (req
->Present
& PRESENT_PIN_REPLACE
) {
1643 write_cis_mem(s
, 1, (base
+ CISREG_PRR
)>>1, 1, &c
->Pin
);
1645 if (req
->Present
& PRESENT_EXT_STATUS
) {
1646 c
->ExtStatus
= req
->ExtStatus
;
1647 write_cis_mem(s
, 1, (base
+ CISREG_ESR
)>>1, 1, &c
->ExtStatus
);
1649 if (req
->Present
& PRESENT_IOBASE_0
) {
1650 u_char b
= c
->io
.BasePort1
& 0xff;
1651 write_cis_mem(s
, 1, (base
+ CISREG_IOBASE_0
)>>1, 1, &b
);
1652 b
= (c
->io
.BasePort1
>> 8) & 0xff;
1653 write_cis_mem(s
, 1, (base
+ CISREG_IOBASE_1
)>>1, 1, &b
);
1655 if (req
->Present
& PRESENT_IOSIZE
) {
1656 u_char b
= c
->io
.NumPorts1
+ c
->io
.NumPorts2
- 1;
1657 write_cis_mem(s
, 1, (base
+ CISREG_IOSIZE
)>>1, 1, &b
);
1660 /* Configure I/O windows */
1661 if (c
->state
& CONFIG_IO_REQ
) {
1662 iomap
.speed
= io_speed
;
1663 for (i
= 0; i
< MAX_IO_WIN
; i
++)
1664 if (s
->io
[i
].NumPorts
!= 0) {
1666 iomap
.flags
= MAP_ACTIVE
;
1667 switch (s
->io
[i
].Attributes
& IO_DATA_PATH_WIDTH
) {
1668 case IO_DATA_PATH_WIDTH_16
:
1669 iomap
.flags
|= MAP_16BIT
; break;
1670 case IO_DATA_PATH_WIDTH_AUTO
:
1671 iomap
.flags
|= MAP_AUTOSZ
; break;
1675 iomap
.start
= s
->io
[i
].BasePort
;
1676 iomap
.stop
= iomap
.start
+ s
->io
[i
].NumPorts
- 1;
1677 s
->ops
->set_io_map(s
, &iomap
);
1682 c
->state
|= CONFIG_LOCKED
;
1683 handle
->state
|= CLIENT_CONFIG_LOCKED
;
1685 } /* request_configuration */
1687 /*======================================================================
1689 Request_io() reserves ranges of port addresses for a socket.
1690 I have not implemented range sharing or alias addressing.
1692 ======================================================================*/
1694 int pcmcia_request_io(client_handle_t handle
, io_req_t
*req
)
1696 struct pcmcia_socket
*s
;
1699 if (CHECK_HANDLE(handle
))
1700 return CS_BAD_HANDLE
;
1702 if (!(s
->state
& SOCKET_PRESENT
))
1705 if (handle
->state
& CLIENT_CARDBUS
) {
1706 #ifdef CONFIG_CARDBUS
1707 handle
->state
|= CLIENT_IO_REQ
;
1710 return CS_UNSUPPORTED_FUNCTION
;
1715 return CS_UNSUPPORTED_MODE
;
1717 if (c
->state
& CONFIG_LOCKED
)
1718 return CS_CONFIGURATION_LOCKED
;
1719 if (c
->state
& CONFIG_IO_REQ
)
1721 if (req
->Attributes1
& (IO_SHARED
| IO_FORCE_ALIAS_ACCESS
))
1722 return CS_BAD_ATTRIBUTE
;
1723 if ((req
->NumPorts2
> 0) &&
1724 (req
->Attributes2
& (IO_SHARED
| IO_FORCE_ALIAS_ACCESS
)))
1725 return CS_BAD_ATTRIBUTE
;
1727 if (alloc_io_space(s
, req
->Attributes1
, &req
->BasePort1
,
1728 req
->NumPorts1
, req
->IOAddrLines
,
1732 if (req
->NumPorts2
) {
1733 if (alloc_io_space(s
, req
->Attributes2
, &req
->BasePort2
,
1734 req
->NumPorts2
, req
->IOAddrLines
,
1735 handle
->dev_info
)) {
1736 release_io_space(s
, req
->BasePort1
, req
->NumPorts1
);
1742 c
->state
|= CONFIG_IO_REQ
;
1743 handle
->state
|= CLIENT_IO_REQ
;
1747 /*======================================================================
1749 Request_irq() reserves an irq for this client.
1751 Also, since Linux only reserves irq's when they are actually
1752 hooked, we don't guarantee that an irq will still be available
1753 when the configuration is locked. Now that I think about it,
1754 there might be a way to fix this using a dummy handler.
1756 ======================================================================*/
1758 int pcmcia_request_irq(client_handle_t handle
, irq_req_t
*req
)
1760 struct pcmcia_socket
*s
;
1762 int ret
= CS_IN_USE
, irq
= 0;
1764 if (CHECK_HANDLE(handle
))
1765 return CS_BAD_HANDLE
;
1767 if (!(s
->state
& SOCKET_PRESENT
))
1770 if (c
->state
& CONFIG_LOCKED
)
1771 return CS_CONFIGURATION_LOCKED
;
1772 if (c
->state
& CONFIG_IRQ_REQ
)
1775 #ifdef CONFIG_PCMCIA_PROBE
1776 if (s
->irq
.AssignedIRQ
!= 0) {
1777 /* If the interrupt is already assigned, it must match */
1778 irq
= s
->irq
.AssignedIRQ
;
1779 if (req
->IRQInfo1
& IRQ_INFO2_VALID
) {
1780 u_int mask
= req
->IRQInfo2
& s
->irq_mask
;
1781 ret
= ((mask
>> irq
) & 1) ? 0 : CS_BAD_ARGS
;
1783 ret
= ((req
->IRQInfo1
&IRQ_MASK
) == irq
) ? 0 : CS_BAD_ARGS
;
1785 if (req
->IRQInfo1
& IRQ_INFO2_VALID
) {
1786 u_int
try, mask
= req
->IRQInfo2
& s
->irq_mask
;
1787 for (try = 0; try < 2; try++) {
1788 for (irq
= 0; irq
< 32; irq
++)
1789 if ((mask
>> irq
) & 1) {
1790 ret
= try_irq(req
->Attributes
, irq
, try);
1791 if (ret
== 0) break;
1793 if (ret
== 0) break;
1796 irq
= req
->IRQInfo1
& IRQ_MASK
;
1797 ret
= try_irq(req
->Attributes
, irq
, 1);
1807 if (req
->Attributes
& IRQ_HANDLE_PRESENT
) {
1808 if (request_irq(irq
, req
->Handler
,
1809 ((req
->Attributes
& IRQ_TYPE_DYNAMIC_SHARING
) ||
1810 (s
->functions
> 1) ||
1811 (irq
== s
->pci_irq
)) ? SA_SHIRQ
: 0,
1812 handle
->dev_info
, req
->Instance
))
1816 c
->irq
.Attributes
= req
->Attributes
;
1817 s
->irq
.AssignedIRQ
= req
->AssignedIRQ
= irq
;
1820 c
->state
|= CONFIG_IRQ_REQ
;
1821 handle
->state
|= CLIENT_IRQ_REQ
;
1823 } /* pcmcia_request_irq */
1825 /*======================================================================
1827 Request_window() establishes a mapping between card memory space
1828 and system memory space.
1830 ======================================================================*/
1832 int pcmcia_request_window(client_handle_t
*handle
, win_req_t
*req
, window_handle_t
*wh
)
1834 struct pcmcia_socket
*s
;
1839 if (CHECK_HANDLE(*handle
))
1840 return CS_BAD_HANDLE
;
1841 s
= (*handle
)->Socket
;
1842 if (!(s
->state
& SOCKET_PRESENT
))
1844 if (req
->Attributes
& (WIN_PAGED
| WIN_SHARED
))
1845 return CS_BAD_ATTRIBUTE
;
1847 /* Window size defaults to smallest available */
1849 req
->Size
= s
->map_size
;
1850 align
= (((s
->features
& SS_CAP_MEM_ALIGN
) ||
1851 (req
->Attributes
& WIN_STRICT_ALIGN
)) ?
1852 req
->Size
: s
->map_size
);
1853 if (req
->Size
& (s
->map_size
-1))
1855 if ((req
->Base
&& (s
->features
& SS_CAP_STATIC_MAP
)) ||
1856 (req
->Base
& (align
-1)))
1861 /* Allocate system memory window */
1862 for (w
= 0; w
< MAX_WIN
; w
++)
1863 if (!(s
->state
& SOCKET_WIN_REQ(w
))) break;
1865 return CS_OUT_OF_RESOURCE
;
1868 win
->magic
= WINDOW_MAGIC
;
1870 win
->handle
= *handle
;
1873 if (!(s
->features
& SS_CAP_STATIC_MAP
)) {
1874 win
->ctl
.res
= find_mem_region(req
->Base
, req
->Size
, align
,
1875 (req
->Attributes
& WIN_MAP_BELOW_1MB
),
1876 (*handle
)->dev_info
, s
);
1880 (*handle
)->state
|= CLIENT_WIN_REQ(w
);
1882 /* Configure the socket controller */
1885 win
->ctl
.speed
= req
->AccessSpeed
;
1886 if (req
->Attributes
& WIN_MEMORY_TYPE
)
1887 win
->ctl
.flags
|= MAP_ATTRIB
;
1888 if (req
->Attributes
& WIN_ENABLE
)
1889 win
->ctl
.flags
|= MAP_ACTIVE
;
1890 if (req
->Attributes
& WIN_DATA_WIDTH_16
)
1891 win
->ctl
.flags
|= MAP_16BIT
;
1892 if (req
->Attributes
& WIN_USE_WAIT
)
1893 win
->ctl
.flags
|= MAP_USE_WAIT
;
1894 win
->ctl
.card_start
= 0;
1895 if (s
->ops
->set_mem_map(s
, &win
->ctl
) != 0)
1897 s
->state
|= SOCKET_WIN_REQ(w
);
1899 /* Return window handle */
1900 if (s
->features
& SS_CAP_STATIC_MAP
) {
1901 req
->Base
= win
->ctl
.static_start
;
1903 req
->Base
= win
->ctl
.res
->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
);
2046 int pcmcia_insert_card(struct pcmcia_socket
*skt
)
2050 cs_dbg(skt
, 1, "user insert request\n");
2052 down(&skt
->skt_sem
);
2054 if (skt
->state
& SOCKET_PRESENT
) {
2058 if (socket_insert(skt
) == CS_NO_CARD
) {
2069 /*======================================================================
2071 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2072 haven't sent one to this client yet?
2074 ======================================================================*/
2076 int pcmcia_set_event_mask(client_handle_t handle
, eventmask_t
*mask
)
2079 if (CHECK_HANDLE(handle
))
2080 return CS_BAD_HANDLE
;
2081 if (handle
->Attributes
& CONF_EVENT_MASK_VALID
)
2082 return CS_BAD_SOCKET
;
2083 handle
->EventMask
= mask
->EventMask
;
2084 events
= handle
->PendingEvents
& handle
->EventMask
;
2085 handle
->PendingEvents
-= events
;
2086 while (events
!= 0) {
2087 bit
= ((events
^ (events
-1)) + 1) >> 1;
2088 EVENT(handle
, bit
, CS_EVENT_PRI_LOW
);
2092 } /* set_event_mask */
2094 /*======================================================================
2096 OS-specific module glue goes here
2098 ======================================================================*/
2099 /* in alpha order */
2100 EXPORT_SYMBOL(pcmcia_access_configuration_register
);
2101 EXPORT_SYMBOL(pcmcia_adjust_resource_info
);
2102 EXPORT_SYMBOL(pcmcia_check_erase_queue
);
2103 EXPORT_SYMBOL(pcmcia_close_memory
);
2104 EXPORT_SYMBOL(pcmcia_copy_memory
);
2105 EXPORT_SYMBOL(pcmcia_deregister_client
);
2106 EXPORT_SYMBOL(pcmcia_deregister_erase_queue
);
2107 EXPORT_SYMBOL(pcmcia_eject_card
);
2108 EXPORT_SYMBOL(pcmcia_get_first_client
);
2109 EXPORT_SYMBOL(pcmcia_get_card_services_info
);
2110 EXPORT_SYMBOL(pcmcia_get_configuration_info
);
2111 EXPORT_SYMBOL(pcmcia_get_mem_page
);
2112 EXPORT_SYMBOL(pcmcia_get_next_client
);
2113 EXPORT_SYMBOL(pcmcia_get_first_region
);
2114 EXPORT_SYMBOL(pcmcia_get_first_tuple
);
2115 EXPORT_SYMBOL(pcmcia_get_first_window
);
2116 EXPORT_SYMBOL(pcmcia_get_next_region
);
2117 EXPORT_SYMBOL(pcmcia_get_next_tuple
);
2118 EXPORT_SYMBOL(pcmcia_get_next_window
);
2119 EXPORT_SYMBOL(pcmcia_get_status
);
2120 EXPORT_SYMBOL(pcmcia_get_tuple_data
);
2121 EXPORT_SYMBOL(pcmcia_insert_card
);
2122 EXPORT_SYMBOL(pcmcia_map_mem_page
);
2123 EXPORT_SYMBOL(pcmcia_modify_configuration
);
2124 EXPORT_SYMBOL(pcmcia_modify_window
);
2125 EXPORT_SYMBOL(pcmcia_open_memory
);
2126 EXPORT_SYMBOL(pcmcia_parse_tuple
);
2127 EXPORT_SYMBOL(pcmcia_read_memory
);
2128 EXPORT_SYMBOL(pcmcia_register_client
);
2129 EXPORT_SYMBOL(pcmcia_register_erase_queue
);
2130 EXPORT_SYMBOL(pcmcia_register_mtd
);
2131 EXPORT_SYMBOL(pcmcia_release_configuration
);
2132 EXPORT_SYMBOL(pcmcia_release_io
);
2133 EXPORT_SYMBOL(pcmcia_release_irq
);
2134 EXPORT_SYMBOL(pcmcia_release_window
);
2135 EXPORT_SYMBOL(pcmcia_replace_cis
);
2136 EXPORT_SYMBOL(pcmcia_request_configuration
);
2137 EXPORT_SYMBOL(pcmcia_request_io
);
2138 EXPORT_SYMBOL(pcmcia_request_irq
);
2139 EXPORT_SYMBOL(pcmcia_request_window
);
2140 EXPORT_SYMBOL(pcmcia_reset_card
);
2141 EXPORT_SYMBOL(pcmcia_resume_card
);
2142 EXPORT_SYMBOL(pcmcia_set_event_mask
);
2143 EXPORT_SYMBOL(pcmcia_suspend_card
);
2144 EXPORT_SYMBOL(pcmcia_validate_cis
);
2145 EXPORT_SYMBOL(pcmcia_write_memory
);
2147 EXPORT_SYMBOL(dead_socket
);
2148 EXPORT_SYMBOL(MTDHelperEntry
);
2149 EXPORT_SYMBOL(pcmcia_parse_events
);
2151 struct class pcmcia_socket_class
= {
2152 .name
= "pcmcia_socket",
2153 .release
= pcmcia_release_socket
,
2155 EXPORT_SYMBOL(pcmcia_socket_class
);
2158 static int __init
init_pcmcia_cs(void)
2161 printk(KERN_INFO
"%s\n", release
);
2162 printk(KERN_INFO
" %s\n", options
);
2164 ret
= class_register(&pcmcia_socket_class
);
2167 return class_interface_register(&pccard_sysfs_interface
);
2170 static void __exit
exit_pcmcia_cs(void)
2172 printk(KERN_INFO
"unloading Kernel Card Services\n");
2173 release_resource_db();
2174 class_interface_unregister(&pccard_sysfs_interface
);
2175 class_unregister(&pcmcia_socket_class
);
2178 subsys_initcall(init_pcmcia_cs
);
2179 module_exit(exit_pcmcia_cs
);
2181 /*====================================================================*/