?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / pcmcia / cs.c
blobc33ac27567dce64ff5cff9829be69e640c11d84b
1 /*======================================================================
2
3 Kernel Card Services -- core services
4
5 cs.c 1.271 2000/10/02 20:27:49
6
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/
11
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.
16
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.
20
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.
31
32 ======================================================================*/
33
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>
43 #include <linux/mm.h>
44 #include <linux/interrupt.h>
45 #include <linux/timer.h>
46 #include <linux/ioport.h>
47 #include <linux/delay.h>
48 #include <linux/pm.h>
49 #include <linux/pci.h>
50 #include <linux/device.h>
51 #include <linux/suspend.h>
52 #include <asm/system.h>
53 #include <asm/irq.h>
54
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"
64
65 #ifdef CONFIG_PCI
66 #define PCI_OPT " [pci]"
67 #else
68 #define PCI_OPT ""
69 #endif
70 #ifdef CONFIG_CARDBUS
71 #define CB_OPT " [cardbus]"
72 #else
73 #define CB_OPT ""
74 #endif
75 #ifdef CONFIG_PM
76 #define PM_OPT " [pm]"
77 #else
78 #define PM_OPT ""
79 #endif
80 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
81 #define OPTIONS " none"
82 #else
83 #define OPTIONS PCI_OPT CB_OPT PM_OPT
84 #endif
85
86 static const char *release = "Linux Kernel Card Services";
87 static const char *options = "options: " OPTIONS;
88
89 /*====================================================================*/
90
91 /* Module parameters */
92
93 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
94 MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
95 MODULE_LICENSE("Dual MPL/GPL");
96
97 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
98
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 */
107
108 /* Access speed for attribute memory windows */
109 INT_MODULE_PARM(cis_speed, 300); /* ns */
110
111 /* Access speed for IO windows */
112 INT_MODULE_PARM(io_speed, 0); /* ns */
113
114 #ifdef DEBUG
115 static int pc_debug;
116
117 module_param(pc_debug, int, 0644);
118
119 int cs_debug_level(int level)
120 {
121 return pc_debug > level;
122 }
123 #endif
124
125 /*====================================================================*/
126
127 socket_state_t dead_socket = {
128 .csc_mask = SS_DETECT,
129 };
130
131
132 /* List of all sockets, protected by a rwsem */
133 LIST_HEAD(pcmcia_socket_list);
134 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
135
136
137 /*====================================================================
138
139 Low-level PC Card interface drivers need to register with Card
140 Services using these calls.
141
142 ======================================================================*/
143
144 /**
145 * socket drivers are expected to use the following callbacks in their
146 * .drv struct:
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
151 */
152 static int socket_resume(struct pcmcia_socket *skt);
153 static int socket_suspend(struct pcmcia_socket *skt);
154
155 int pcmcia_socket_dev_suspend(struct device *dev, u32 state)
156 {
157 struct pcmcia_socket *socket;
158
159 down_read(&pcmcia_socket_list_rwsem);
160 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
161 if (socket->dev.dev != dev)
162 continue;
163 down(&socket->skt_sem);
164 socket_suspend(socket);
165 up(&socket->skt_sem);
166 }
167 up_read(&pcmcia_socket_list_rwsem);
168
169 return 0;
170 }
171 EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
172
173 int pcmcia_socket_dev_resume(struct device *dev)
174 {
175 struct pcmcia_socket *socket;
176
177 down_read(&pcmcia_socket_list_rwsem);
178 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
179 if (socket->dev.dev != dev)
180 continue;
181 down(&socket->skt_sem);
182 socket_resume(socket);
183 up(&socket->skt_sem);
184 }
185 up_read(&pcmcia_socket_list_rwsem);
186
187 return 0;
188 }
189 EXPORT_SYMBOL(pcmcia_socket_dev_resume);
190
191
192 static void pcmcia_release_socket(struct class_device *class_dev)
193 {
194 struct pcmcia_socket *socket = class_get_devdata(class_dev);
195 client_t *client;
196
197 while (socket->clients) {
198 client = socket->clients;
199 socket->clients = socket->clients->next;
200 kfree(client);
201 }
202
203 complete(&socket->socket_released);
204 }
205
206 static int pccardd(void *__skt);
207
208 /**
209 * pcmcia_register_socket - add a new pcmcia socket device
210 */
211 int pcmcia_register_socket(struct pcmcia_socket *socket)
212 {
213 int ret;
214
215 if (!socket || !socket->ops || !socket->dev.dev)
216 return -EINVAL;
217
218 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
219
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))
226 socket->sock = 0;
227 else {
228 unsigned int found, i = 1;
229 struct pcmcia_socket *tmp;
230 do {
231 found = 1;
232 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
233 if (tmp->sock == i)
234 found = 0;
235 }
236 i++;
237 } while (!found);
238 socket->sock = i - 1;
239 }
240 list_add_tail(&socket->socket_list, &pcmcia_socket_list);
241 up_write(&pcmcia_socket_list_rwsem);
242
243
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);
248
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);
255
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);
261
262 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
263 if (ret < 0)
264 goto err;
265
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);
269 return -EIO;
270 }
271 pcmcia_parse_events(socket, SS_DETECT);
272
273 return 0;
274
275 err:
276 down_write(&pcmcia_socket_list_rwsem);
277 list_del(&socket->socket_list);
278 up_write(&pcmcia_socket_list_rwsem);
279 return ret;
280 } /* pcmcia_register_socket */
281 EXPORT_SYMBOL(pcmcia_register_socket);
282
283
284 /**
285 * pcmcia_unregister_socket - remove a pcmcia socket device
286 */
287 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
288 {
289 if (!socket)
290 return;
291
292 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
293
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);
299 }
300 release_cis_mem(socket);
301
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);
306
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);
311
312
313 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
314 {
315 struct pcmcia_socket *s;
316
317 down_read(&pcmcia_socket_list_rwsem);
318 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
319 if (s->sock == nr) {
320 up_read(&pcmcia_socket_list_rwsem);
321 return s;
322 }
323 up_read(&pcmcia_socket_list_rwsem);
324
325 return NULL;
326
327 }
328 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
329
330
331 /*======================================================================
332
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.
338
339 ======================================================================*/
340
341 static void free_regions(memory_handle_t *list)
342 {
343 memory_handle_t tmp;
344 while (*list != NULL) {
345 tmp = *list;
346 *list = tmp->info.next;
347 tmp->region_magic = 0;
348 kfree(tmp);
349 }
350 }
351
352 static int send_event(struct pcmcia_socket *s, event_t event, int priority);
353
354 static void shutdown_socket(struct pcmcia_socket *s)
355 {
356 client_t **c;
357
358 cs_dbg(s, 1, "shutdown_socket\n");
359
360 /* Blank out the socket state */
361 s->socket = dead_socket;
362 s->ops->init(s);
363 s->ops->set_socket(s, &s->socket);
364 s->irq.AssignedIRQ = s->irq.Config = 0;
365 s->lock_count = 0;
366 destroy_cis_cache(s);
367 if (s->fake_cis) {
368 kfree(s->fake_cis);
369 s->fake_cis = NULL;
370 }
371 #ifdef CONFIG_CARDBUS
372 cb_free(s);
373 #endif
374 s->functions = 0;
375 if (s->config) {
376 kfree(s->config);
377 s->config = NULL;
378 }
379 for (c = &s->clients; *c; ) {
380 if ((*c)->state & CLIENT_UNBOUND) {
381 client_t *d = *c;
382 *c = (*c)->next;
383 kfree(d);
384 } else {
385 c = &((*c)->next);
386 }
387 }
388 free_regions(&s->a_region);
389 free_regions(&s->c_region);
390
391 {
392 int status;
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);
396 }
397 }
398 } /* shutdown_socket */
399
400 /*======================================================================
401
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.
406
407 ======================================================================*/
408
409 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
410 {
411 client_t *client = s->clients;
412 int ret;
413 cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
414 event, priority);
415 ret = 0;
416 if (s->state & SOCKET_CARDBUS)
417 return 0;
418 for (; client; client = client->next) {
419 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
420 continue;
421 if (client->EventMask & event) {
422 ret = EVENT(client, event, priority);
423 if (ret != 0)
424 return ret;
425 }
426 }
427 return ret;
428 } /* send_event */
429
430 static void socket_remove_drivers(struct pcmcia_socket *skt)
431 {
432 client_t *client;
433
434 cs_dbg(skt, 4, "remove_drivers\n");
435
436 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
437
438 for (client = skt->clients; client; client = client->next)
439 if (!(client->Attributes & INFO_MASTER_CLIENT))
440 client->state |= CLIENT_STALE;
441 }
442
443 static void socket_shutdown(struct pcmcia_socket *skt)
444 {
445 cs_dbg(skt, 4, "shutdown\n");
446
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);
452 }
453
454 static int socket_reset(struct pcmcia_socket *skt)
455 {
456 int status, i;
457
458 cs_dbg(skt, 4, "reset\n");
459
460 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
461 skt->ops->set_socket(skt, &skt->socket);
462 udelay((long)reset_time);
463
464 skt->socket.flags &= ~SS_RESET;
465 skt->ops->set_socket(skt, &skt->socket);
466
467 msleep(unreset_delay * 10);
468 for (i = 0; i < unreset_limit; i++) {
469 skt->ops->get_status(skt, &status);
470
471 if (!(status & SS_DETECT))
472 return CS_NO_CARD;
473
474 if (status & SS_READY)
475 return CS_SUCCESS;
476
477 msleep(unreset_check * 10);
478 }
479
480 cs_err(skt, "time out after reset.\n");
481 return CS_GENERAL_FAILURE;
482 }
483
484 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
485 {
486 int status, i;
487
488 cs_dbg(skt, 4, "setup\n");
489
490 skt->ops->get_status(skt, &status);
491 if (!(status & SS_DETECT))
492 return CS_NO_CARD;
493
494 msleep(initial_delay * 10);
495
496 for (i = 0; i < 100; i++) {
497 skt->ops->get_status(skt, &status);
498 if (!(status & SS_DETECT))
499 return CS_NO_CARD;
500
501 if (!(status & SS_PENDING))
502 break;
503
504 msleep(100);
505 }
506
507 if (status & SS_PENDING) {
508 cs_err(skt, "voltage interrogation timed out.\n");
509 return CS_GENERAL_FAILURE;
510 }
511
512 if (status & SS_CARDBUS) {
513 skt->state |= SOCKET_CARDBUS;
514 #ifndef CONFIG_CARDBUS
515 cs_err(skt, "cardbus cards are not supported.\n");
516 return CS_BAD_TYPE;
517 #endif
518 }
519
520 /*
521 * Decode the card voltage requirements, and apply power to the card.
522 */
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;
527 else {
528 cs_err(skt, "unsupported voltage key.\n");
529 return CS_BAD_TYPE;
530 }
531 skt->socket.flags = 0;
532 skt->ops->set_socket(skt, &skt->socket);
533
534 /*
535 * Wait "vcc_settle" for the supply to stabilise.
536 */
537 msleep(vcc_settle * 10);
538
539 skt->ops->get_status(skt, &status);
540 if (!(status & SS_POWERON)) {
541 cs_err(skt, "unable to apply power.\n");
542 return CS_BAD_TYPE;
543 }
544
545 return socket_reset(skt);
546 }
547
548 /*
549 * Handle card insertion. Setup the socket, reset the card,
550 * and then tell the rest of PCMCIA that a card is present.
551 */
552 static int socket_insert(struct pcmcia_socket *skt)
553 {
554 int ret;
555
556 cs_dbg(skt, 4, "insert\n");
557
558 if (!cs_socket_get(skt))
559 return CS_NO_CARD;
560
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) {
566 cb_alloc(skt);
567 skt->state |= SOCKET_CARDBUS_CONFIG;
568 }
569 #endif
570 cs_dbg(skt, 4, "insert done\n");
571
572 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
573 } else {
574 socket_shutdown(skt);
575 cs_socket_put(skt);
576 }
577
578 return ret;
579 }
580
581 static int socket_suspend(struct pcmcia_socket *skt)
582 {
583 if (skt->state & SOCKET_SUSPEND)
584 return CS_IN_USE;
585
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;
590
591 return CS_SUCCESS;
592 }
593
594 /*
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.
598 */
599 static int socket_resume(struct pcmcia_socket *skt)
600 {
601 int ret;
602
603 if (!(skt->state & SOCKET_SUSPEND))
604 return CS_IN_USE;
605
606 skt->socket = dead_socket;
607 skt->ops->init(skt);
608 skt->ops->set_socket(skt, &skt->socket);
609
610 ret = socket_setup(skt, resume_delay);
611 if (ret == CS_SUCCESS) {
612 /*
613 * FIXME: need a better check here for cardbus cards.
614 */
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);
619 } else {
620 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
621 }
622 } else {
623 socket_shutdown(skt);
624 cs_socket_put(skt);
625 }
626
627 skt->state &= ~SOCKET_SUSPEND;
628
629 return CS_SUCCESS;
630 }
631
632 static void socket_remove(struct pcmcia_socket *skt)
633 {
634 socket_shutdown(skt);
635 cs_socket_put(skt);
636 }
637
638 /*
639 * Process a socket card detect status change.
640 *
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.
643 *
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.
648 */
649 static void socket_detect_change(struct pcmcia_socket *skt)
650 {
651 if (!(skt->state & SOCKET_SUSPEND)) {
652 int status;
653
654 if (!(skt->state & SOCKET_PRESENT))
655 msleep(20);
656
657 skt->ops->get_status(skt, &status);
658 if ((skt->state & SOCKET_PRESENT) &&
659 !(status & SS_DETECT))
660 socket_remove(skt);
661 if (!(skt->state & SOCKET_PRESENT) &&
662 (status & SS_DETECT))
663 socket_insert(skt);
664 }
665 }
666
667 static int pccardd(void *__skt)
668 {
669 struct pcmcia_socket *skt = __skt;
670 DECLARE_WAITQUEUE(wait, current);
671 int ret;
672
673 daemonize("pccardd");
674
675 skt->thread = current;
676 skt->socket = dead_socket;
677 skt->ops->init(skt);
678 skt->ops->set_socket(skt, &skt->socket);
679
680 /* register with the device core */
681 ret = class_device_register(&skt->dev);
682 if (ret) {
683 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
684 skt);
685 skt->thread = NULL;
686 complete_and_exit(&skt->thread_done, 0);
687 }
688 complete(&skt->thread_done);
689
690 add_wait_queue(&skt->thread_wait, &wait);
691 for (;;) {
692 unsigned long flags;
693 unsigned int events;
694
695 set_current_state(TASK_INTERRUPTIBLE);
696
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);
701
702 if (events) {
703 down(&skt->skt_sem);
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);
712 up(&skt->skt_sem);
713 continue;
714 }
715
716 schedule();
717 if (current->flags & PF_FREEZE)
718 refrigerator(PF_FREEZE);
719
720 if (!skt->thread)
721 break;
722 }
723 remove_wait_queue(&skt->thread_wait, &wait);
724
725 /* remove from the device core */
726 class_device_unregister(&skt->dev);
727
728 complete_and_exit(&skt->thread_done, 0);
729 }
730
731 /*
732 * Yenta (at least) probes interrupts before registering the socket and
733 * starting the handler thread.
734 */
735 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
736 {
737 cs_dbg(s, 4, "parse_events: events %08x\n", events);
738 if (s->thread) {
739 spin_lock(&s->thread_lock);
740 s->thread_events |= events;
741 spin_unlock(&s->thread_lock);
742
743 wake_up(&s->thread_wait);
744 }
745 } /* pcmcia_parse_events */
746
747
748 /*======================================================================
749
750 Special stuff for managing IO windows, because they are scarce.
751
752 ======================================================================*/
753
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)
756 {
757 int i;
758 ioaddr_t try, align;
759
760 align = (*base) ? (lines ? 1<<lines : 0) : 1;
761 if (align && (align < num)) {
762 if (*base) {
763 cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
764 num, align);
765 align = 0;
766 } else
767 while (align && (align < num)) align <<= 1;
768 }
769 if (*base & ~(align-1)) {
770 cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
771 *base, align);
772 align = 0;
773 }
774 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
775 *base = s->io_offset | (*base & 0x0fff);
776 return 0;
777 }
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))
784 return 1;
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);
788 if (s->io[i].res) {
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;
792 break;
793 } else
794 return 1;
795 } else if (s->io[i].Attributes != attr)
796 continue;
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) {
802 *base = try;
803 s->io[i].NumPorts += num;
804 s->io[i].InUse += num;
805 break;
806 }
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;
815 break;
816 }
817 }
818 return (i == MAX_IO_WIN);
819 } /* alloc_io_space */
820
821 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
822 ioaddr_t num)
823 {
824 int i;
825
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);
834 kfree(s->io[i].res);
835 s->io[i].res = NULL;
836 }
837 }
838 }
839 }
840
841 /*======================================================================
842
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.
846
847 ======================================================================*/
848
849 int pcmcia_access_configuration_register(client_handle_t handle,
850 conf_reg_t *reg)
851 {
852 struct pcmcia_socket *s;
853 config_t *c;
854 int addr;
855 u_char val;
856
857 if (CHECK_HANDLE(handle))
858 return CS_BAD_HANDLE;
859 s = SOCKET(handle);
860 if (handle->Function == BIND_FN_ALL) {
861 if (reg->Function >= s->functions)
862 return CS_BAD_ARGS;
863 c = &s->config[reg->Function];
864 } else
865 c = CONFIG(handle);
866
867 if (c == NULL)
868 return CS_NO_CARD;
869
870 if (!(c->state & CONFIG_LOCKED))
871 return CS_CONFIGURATION_LOCKED;
872
873 addr = (c->ConfigBase + reg->Offset) >> 1;
874
875 switch (reg->Action) {
876 case CS_READ:
877 read_cis_mem(s, 1, addr, 1, &val);
878 reg->Value = val;
879 break;
880 case CS_WRITE:
881 val = reg->Value;
882 write_cis_mem(s, 1, addr, 1, &val);
883 break;
884 default:
885 return CS_BAD_ARGS;
886 break;
887 }
888 return CS_SUCCESS;
889 } /* access_configuration_register */
890
891
892 /*====================================================================*/
893
894 int pcmcia_deregister_client(client_handle_t handle)
895 {
896 client_t **client;
897 struct pcmcia_socket *s;
898 memory_handle_t region;
899 u_long flags;
900 int i;
901
902 if (CHECK_HANDLE(handle))
903 return CS_BAD_HANDLE;
904
905 s = SOCKET(handle);
906 cs_dbg(s, 1, "deregister_client(%p)\n", handle);
907
908 if (handle->state &
909 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
910 return CS_IN_USE;
911 for (i = 0; i < MAX_WIN; i++)
912 if (handle->state & CLIENT_WIN_REQ(i))
913 return CS_IN_USE;
914
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;
921 }
922
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;
932 }
933 *client = handle->next;
934 handle->client_magic = 0;
935 kfree(handle);
936 spin_unlock_irqrestore(&s->lock, flags);
937 } else {
938 handle->state = CLIENT_UNBOUND;
939 handle->mtd_count = 0;
940 handle->event_handler = NULL;
941 }
942
943 return CS_SUCCESS;
944 } /* deregister_client */
945
946 /*====================================================================*/
947
948 int pcmcia_get_configuration_info(client_handle_t handle,
949 config_info_t *config)
950 {
951 struct pcmcia_socket *s;
952 config_t *c;
953
954 if (CHECK_HANDLE(handle))
955 return CS_BAD_HANDLE;
956 s = SOCKET(handle);
957 if (!(s->state & SOCKET_PRESENT))
958 return CS_NO_CARD;
959
960 if (handle->Function == BIND_FN_ALL) {
961 if (config->Function && (config->Function >= s->functions))
962 return CS_BAD_ARGS;
963 } else
964 config->Function = handle->Function;
965
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;
982 }
983 return CS_SUCCESS;
984 }
985 #endif
986
987 c = (s->config != NULL) ? &s->config[config->Function] : NULL;
988
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;
993 return CS_SUCCESS;
994 }
995
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;
1009
1010 return CS_SUCCESS;
1011 } /* get_configuration_info */
1012
1013 /*======================================================================
1014
1015 Return information about this version of Card Services.
1016
1017 ======================================================================*/
1018
1019 int pcmcia_get_card_services_info(servinfo_t *info)
1020 {
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)
1027 socket_count++;
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;
1033 return CS_SUCCESS;
1034 } /* get_card_services_info */
1035
1036 /*======================================================================
1037
1038 Note that get_first_client() *does* recognize the Socket field
1039 in the request structure.
1040
1041 ======================================================================*/
1042
1043 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1044 {
1045 socket_t s;
1046 struct pcmcia_socket *socket;
1047 if (req->Attributes & CLIENT_THIS_SOCKET)
1048 s = req->Socket;
1049 else
1050 s = 0;
1051 socket = pcmcia_get_socket_by_nr(s);
1052 if (!socket)
1053 return CS_BAD_SOCKET;
1054 if (socket->clients == NULL)
1055 return CS_NO_MORE_ITEMS;
1056 *handle = socket->clients;
1057 return CS_SUCCESS;
1058 } /* get_first_client */
1059
1060 /*====================================================================*/
1061
1062 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1063 {
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;
1074 } else
1075 *handle = (*handle)->next;
1076 return CS_SUCCESS;
1077 } /* get_next_client */
1078
1079 /*====================================================================*/
1080
1081 int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req)
1082 {
1083 struct pcmcia_socket *s;
1084 window_t *win;
1085 int w;
1086
1087 if (idx == 0)
1088 s = ((client_handle_t)*handle)->Socket;
1089 else
1090 s = (*handle)->sock;
1091 if (!(s->state & SOCKET_PRESENT))
1092 return CS_NO_CARD;
1093 for (w = idx; w < MAX_WIN; w++)
1094 if (s->state & SOCKET_WIN_REQ(w)) break;
1095 if (w == MAX_WIN)
1096 return CS_NO_MORE_ITEMS;
1097 win = &s->win[w];
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;
1110 *handle = win;
1111 return CS_SUCCESS;
1112 } /* get_window */
1113
1114 int pcmcia_get_first_window(window_handle_t *win, win_req_t *req)
1115 {
1116 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1117 return CS_BAD_HANDLE;
1118 return pcmcia_get_window(win, 0, req);
1119 }
1120
1121 int pcmcia_get_next_window(window_handle_t *win, win_req_t *req)
1122 {
1123 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1124 return CS_BAD_HANDLE;
1125 return pcmcia_get_window(win, (*win)->index+1, req);
1126 }
1127
1128 /*=====================================================================
1129
1130 Return the PCI device associated with a card..
1131
1132 ======================================================================*/
1133
1134 #ifdef CONFIG_CARDBUS
1135
1136 struct pci_bus *pcmcia_lookup_bus(client_handle_t handle)
1137 {
1138 struct pcmcia_socket *s;
1139
1140 if (CHECK_HANDLE(handle))
1141 return NULL;
1142 s = SOCKET(handle);
1143 if (!(s->state & SOCKET_CARDBUS))
1144 return NULL;
1145
1146 return s->cb_dev->subordinate;
1147 }
1148
1149 EXPORT_SYMBOL(pcmcia_lookup_bus);
1150
1151 #endif
1152
1153 /*======================================================================
1154
1155 Get the current socket state bits. We don't support the latched
1156 SocketState yet: I haven't seen any point for it.
1157
1158 ======================================================================*/
1159
1160 int pcmcia_get_status(client_handle_t handle, cs_status_t *status)
1161 {
1162 struct pcmcia_socket *s;
1163 config_t *c;
1164 int val;
1165
1166 if (CHECK_HANDLE(handle))
1167 return CS_BAD_HANDLE;
1168 s = SOCKET(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))
1178 return CS_NO_CARD;
1179
1180 /* Get info from the PRR, if necessary */
1181 if (handle->Function == BIND_FN_ALL) {
1182 if (status->Function && (status->Function >= s->functions))
1183 return CS_BAD_ARGS;
1184 c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1185 } else
1186 c = CONFIG(handle);
1187 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1188 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1189 u_char reg;
1190 if (c->Present & PRESENT_PIN_REPLACE) {
1191 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
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;
1200 } else {
1201 /* No PRR? Then assume we're always ready */
1202 status->CardState |= CS_EVENT_READY_CHANGE;
1203 }
1204 if (c->Present & PRESENT_EXT_STATUS) {
1205 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
1206 status->CardState |=
1207 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1208 }
1209 return CS_SUCCESS;
1210 }
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;
1219 return CS_SUCCESS;
1220 } /* get_status */
1221
1222 /*======================================================================
1223
1224 Change the card address of an already open memory window.
1225
1226 ======================================================================*/
1227
1228 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1229 {
1230 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1231 return CS_BAD_HANDLE;
1232 req->Page = 0;
1233 req->CardOffset = win->ctl.card_start;
1234 return CS_SUCCESS;
1235 } /* get_mem_page */
1236
1237 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1238 {
1239 struct pcmcia_socket *s;
1240 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1241 return CS_BAD_HANDLE;
1242 if (req->Page != 0)
1243 return CS_BAD_PAGE;
1244 s = win->sock;
1245 win->ctl.card_start = req->CardOffset;
1246 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1247 return CS_BAD_OFFSET;
1248 return CS_SUCCESS;
1249 } /* map_mem_page */
1250
1251 /*======================================================================
1252
1253 Modify a locked socket configuration
1254
1255 ======================================================================*/
1256
1257 int pcmcia_modify_configuration(client_handle_t handle,
1258 modconf_t *mod)
1259 {
1260 struct pcmcia_socket *s;
1261 config_t *c;
1262
1263 if (CHECK_HANDLE(handle))
1264 return CS_BAD_HANDLE;
1265 s = SOCKET(handle); c = CONFIG(handle);
1266 if (!(s->state & SOCKET_PRESENT))
1267 return CS_NO_CARD;
1268 if (!(c->state & CONFIG_LOCKED))
1269 return CS_CONFIGURATION_LOCKED;
1270
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;
1275 } else {
1276 c->Attributes &= ~CONF_ENABLE_IRQ;
1277 s->socket.io_irq = 0;
1278 }
1279 s->ops->set_socket(s, &s->socket);
1280 }
1281
1282 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1283 return CS_BAD_VCC;
1284
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)
1289 return CS_BAD_VPP;
1290 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1291 if (s->ops->set_socket(s, &s->socket))
1292 return CS_BAD_VPP;
1293 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1294 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1295 return CS_BAD_VPP;
1296
1297 return CS_SUCCESS;
1298 } /* modify_configuration */
1299
1300 /*======================================================================
1301
1302 Modify the attributes of a window returned by RequestWindow.
1303
1304 ======================================================================*/
1305
1306 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1307 {
1308 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1309 return CS_BAD_HANDLE;
1310
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);
1322
1323 return CS_SUCCESS;
1324 } /* modify_window */
1325
1326 /*======================================================================
1327
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.
1332
1333 ======================================================================*/
1334
1335 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1336 {
1337 client_t *client = NULL;
1338 struct pcmcia_socket *s;
1339
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;
1348 }
1349 if (client != NULL) break;
1350 }
1351 up_read(&pcmcia_socket_list_rwsem);
1352 if (client == NULL)
1353 return CS_OUT_OF_RESOURCE;
1354
1355 /*
1356 * Prevent this racing with a card insertion.
1357 */
1358 down(&s->skt_sem);
1359 *handle = client;
1360 client->state &= ~CLIENT_UNBOUND;
1361 client->Socket = s;
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;
1367
1368 if (s->state & SOCKET_CARDBUS)
1369 client->state |= CLIENT_CARDBUS;
1370
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)
1375 == CS_SUCCESS)
1376 s->functions = mfc.nfn;
1377 else
1378 s->functions = 1;
1379 s->config = kmalloc(sizeof(config_t) * s->functions,
1380 GFP_KERNEL);
1381 if (!s->config)
1382 goto out_no_resource;
1383 memset(s->config, 0, sizeof(config_t) * s->functions);
1384 }
1385
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);
1390
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);
1394 else
1395 client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1396 }
1397
1398 up(&s->skt_sem);
1399 return CS_SUCCESS;
1400
1401 out_no_resource:
1402 up(&s->skt_sem);
1403 return CS_OUT_OF_RESOURCE;
1404 } /* register_client */
1405
1406 /*====================================================================*/
1407
1408 int pcmcia_release_configuration(client_handle_t handle)
1409 {
1410 pccard_io_map io = { 0, 0, 0, 0, 1 };
1411 struct pcmcia_socket *s;
1412 int i;
1413
1414 if (CHECK_HANDLE(handle) ||
1415 !(handle->state & CLIENT_CONFIG_LOCKED))
1416 return CS_BAD_HANDLE;
1417 handle->state &= ~CLIENT_CONFIG_LOCKED;
1418 s = SOCKET(handle);
1419
1420 #ifdef CONFIG_CARDBUS
1421 if (handle->state & CLIENT_CARDBUS)
1422 return CS_SUCCESS;
1423 #endif
1424
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? */
1429 s->socket.Vpp = 0;
1430 s->socket.io_irq = 0;
1431 s->ops->set_socket(s, &s->socket);
1432 }
1433 if (c->state & CONFIG_IO_REQ)
1434 for (i = 0; i < MAX_IO_WIN; i++) {
1435 if (s->io[i].NumPorts == 0)
1436 continue;
1437 s->io[i].Config--;
1438 if (s->io[i].Config != 0)
1439 continue;
1440 io.map = i;
1441 s->ops->set_io_map(s, &io);
1442 }
1443 c->state &= ~CONFIG_LOCKED;
1444 }
1445
1446 return CS_SUCCESS;
1447 } /* release_configuration */
1448
1449 /*======================================================================
1450
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
1455 values.
1456
1457 ======================================================================*/
1458
1459 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1460 {
1461 struct pcmcia_socket *s;
1462
1463 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1464 return CS_BAD_HANDLE;
1465 handle->state &= ~CLIENT_IO_REQ;
1466 s = SOCKET(handle);
1467
1468 #ifdef CONFIG_CARDBUS
1469 if (handle->state & CLIENT_CARDBUS)
1470 return CS_SUCCESS;
1471 #endif
1472
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))
1481 return CS_BAD_ARGS;
1482 c->state &= ~CONFIG_IO_REQ;
1483 }
1484
1485 release_io_space(s, req->BasePort1, req->NumPorts1);
1486 if (req->NumPorts2)
1487 release_io_space(s, req->BasePort2, req->NumPorts2);
1488
1489 return CS_SUCCESS;
1490 } /* release_io */
1491
1492 /*====================================================================*/
1493
1494 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1495 {
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;
1500 s = SOCKET(handle);
1501
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)
1509 return CS_BAD_IRQ;
1510 if (--s->irq.Config == 0) {
1511 c->state &= ~CONFIG_IRQ_REQ;
1512 s->irq.AssignedIRQ = 0;
1513 }
1514 }
1515
1516 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1517 free_irq(req->AssignedIRQ, req->Instance);
1518 }
1519
1520 #ifdef CONFIG_PCMCIA_PROBE
1521 if (req->AssignedIRQ != s->pci_irq)
1522 undo_irq(req->Attributes, req->AssignedIRQ);
1523 #endif
1524
1525 return CS_SUCCESS;
1526 } /* cs_release_irq */
1527
1528 /*====================================================================*/
1529
1530 int pcmcia_release_window(window_handle_t win)
1531 {
1532 struct pcmcia_socket *s;
1533
1534 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1535 return CS_BAD_HANDLE;
1536 s = win->sock;
1537 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1538 return CS_BAD_HANDLE;
1539
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);
1544
1545 /* Release system memory */
1546 if (win->ctl.res) {
1547 release_resource(win->ctl.res);
1548 kfree(win->ctl.res);
1549 win->ctl.res = NULL;
1550 }
1551 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1552
1553 win->magic = 0;
1554
1555 return CS_SUCCESS;
1556 } /* release_window */
1557
1558 /*====================================================================*/
1559
1560 int pcmcia_request_configuration(client_handle_t handle,
1561 config_req_t *req)
1562 {
1563 int i;
1564 u_int base;
1565 struct pcmcia_socket *s;
1566 config_t *c;
1567 pccard_io_map iomap;
1568
1569 if (CHECK_HANDLE(handle))
1570 return CS_BAD_HANDLE;
1571 s = SOCKET(handle);
1572 if (!(s->state & SOCKET_PRESENT))
1573 return CS_NO_CARD;
1574
1575 #ifdef CONFIG_CARDBUS
1576 if (handle->state & CLIENT_CARDBUS)
1577 return CS_UNSUPPORTED_MODE;
1578 #endif
1579
1580 if (req->IntType & INT_CARDBUS)
1581 return CS_UNSUPPORTED_MODE;
1582 c = CONFIG(handle);
1583 if (c->state & CONFIG_LOCKED)
1584 return CS_CONFIGURATION_LOCKED;
1585
1586 /* Do power control. We don't allow changes in Vcc. */
1587 if (s->socket.Vcc != req->Vcc)
1588 return CS_BAD_VCC;
1589 if (req->Vpp1 != req->Vpp2)
1590 return CS_BAD_VPP;
1591 s->socket.Vpp = req->Vpp1;
1592 if (s->ops->set_socket(s, &s->socket))
1593 return CS_BAD_VPP;
1594
1595 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1596
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;
1610 else
1611 s->socket.io_irq = 0;
1612 s->ops->set_socket(s, &s->socket);
1613 s->lock_count++;
1614
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);
1621 }
1622 if (req->Present & PRESENT_OPTION) {
1623 if (s->functions == 1) {
1624 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1625 } else {
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;
1630 }
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);
1635 mdelay(40);
1636 }
1637 if (req->Present & PRESENT_STATUS) {
1638 c->Status = req->Status;
1639 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1640 }
1641 if (req->Present & PRESENT_PIN_REPLACE) {
1642 c->Pin = req->Pin;
1643 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1644 }
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);
1648 }
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);
1654 }
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);
1658 }
1659
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) {
1665 iomap.map = i;
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;
1672 default:
1673 break;
1674 }
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);
1678 s->io[i].Config++;
1679 }
1680 }
1681
1682 c->state |= CONFIG_LOCKED;
1683 handle->state |= CLIENT_CONFIG_LOCKED;
1684 return CS_SUCCESS;
1685 } /* request_configuration */
1686
1687 /*======================================================================
1688
1689 Request_io() reserves ranges of port addresses for a socket.
1690 I have not implemented range sharing or alias addressing.
1691
1692 ======================================================================*/
1693
1694 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1695 {
1696 struct pcmcia_socket *s;
1697 config_t *c;
1698
1699 if (CHECK_HANDLE(handle))
1700 return CS_BAD_HANDLE;
1701 s = SOCKET(handle);
1702 if (!(s->state & SOCKET_PRESENT))
1703 return CS_NO_CARD;
1704
1705 if (handle->state & CLIENT_CARDBUS) {
1706 #ifdef CONFIG_CARDBUS
1707 handle->state |= CLIENT_IO_REQ;
1708 return CS_SUCCESS;
1709 #else
1710 return CS_UNSUPPORTED_FUNCTION;
1711 #endif
1712 }
1713
1714 if (!req)
1715 return CS_UNSUPPORTED_MODE;
1716 c = CONFIG(handle);
1717 if (c->state & CONFIG_LOCKED)
1718 return CS_CONFIGURATION_LOCKED;
1719 if (c->state & CONFIG_IO_REQ)
1720 return CS_IN_USE;
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;
1726
1727 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1728 req->NumPorts1, req->IOAddrLines,
1729 handle->dev_info))
1730 return CS_IN_USE;
1731
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);
1737 return CS_IN_USE;
1738 }
1739 }
1740
1741 c->io = *req;
1742 c->state |= CONFIG_IO_REQ;
1743 handle->state |= CLIENT_IO_REQ;
1744 return CS_SUCCESS;
1745 } /* request_io */
1746
1747 /*======================================================================
1748
1749 Request_irq() reserves an irq for this client.
1750
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.
1755
1756 ======================================================================*/
1757
1758 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1759 {
1760 struct pcmcia_socket *s;
1761 config_t *c;
1762 int ret = CS_IN_USE, irq = 0;
1763
1764 if (CHECK_HANDLE(handle))
1765 return CS_BAD_HANDLE;
1766 s = SOCKET(handle);
1767 if (!(s->state & SOCKET_PRESENT))
1768 return CS_NO_CARD;
1769 c = CONFIG(handle);
1770 if (c->state & CONFIG_LOCKED)
1771 return CS_CONFIGURATION_LOCKED;
1772 if (c->state & CONFIG_IRQ_REQ)
1773 return CS_IN_USE;
1774
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;
1782 } else
1783 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1784 } else {
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;
1792 }
1793 if (ret == 0) break;
1794 }
1795 } else {
1796 irq = req->IRQInfo1 & IRQ_MASK;
1797 ret = try_irq(req->Attributes, irq, 1);
1798 }
1799 }
1800 #endif
1801 if (ret != 0) {
1802 if (!s->pci_irq)
1803 return ret;
1804 irq = s->pci_irq;
1805 }
1806
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))
1813 return CS_IN_USE;
1814 }
1815
1816 c->irq.Attributes = req->Attributes;
1817 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1818 s->irq.Config++;
1819
1820 c->state |= CONFIG_IRQ_REQ;
1821 handle->state |= CLIENT_IRQ_REQ;
1822 return CS_SUCCESS;
1823 } /* pcmcia_request_irq */
1824
1825 /*======================================================================
1826
1827 Request_window() establishes a mapping between card memory space
1828 and system memory space.
1829
1830 ======================================================================*/
1831
1832 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1833 {
1834 struct pcmcia_socket *s;
1835 window_t *win;
1836 u_long align;
1837 int w;
1838
1839 if (CHECK_HANDLE(*handle))
1840 return CS_BAD_HANDLE;
1841 s = (*handle)->Socket;
1842 if (!(s->state & SOCKET_PRESENT))
1843 return CS_NO_CARD;
1844 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1845 return CS_BAD_ATTRIBUTE;
1846
1847 /* Window size defaults to smallest available */
1848 if (req->Size == 0)
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))
1854 return CS_BAD_SIZE;
1855 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1856 (req->Base & (align-1)))
1857 return CS_BAD_BASE;
1858 if (req->Base)
1859 align = 0;
1860
1861 /* Allocate system memory window */
1862 for (w = 0; w < MAX_WIN; w++)
1863 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1864 if (w == MAX_WIN)
1865 return CS_OUT_OF_RESOURCE;
1866
1867 win = &s->win[w];
1868 win->magic = WINDOW_MAGIC;
1869 win->index = w;
1870 win->handle = *handle;
1871 win->sock = s;
1872
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);
1877 if (!win->ctl.res)
1878 return CS_IN_USE;
1879 }
1880 (*handle)->state |= CLIENT_WIN_REQ(w);
1881
1882 /* Configure the socket controller */
1883 win->ctl.map = w+1;
1884 win->ctl.flags = 0;
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)
1896 return CS_BAD_ARGS;
1897 s->state |= SOCKET_WIN_REQ(w);
1898
1899 /* Return window handle */
1900 if (s->features & SS_CAP_STATIC_MAP) {
1901 req->Base = win->ctl.static_start;
1902 } else {
1903 req->Base = win->ctl.res->start;
1904 }
1905 *wh = win;
1906
1907 return CS_SUCCESS;
1908 } /* request_window */
1909
1910 /*======================================================================
1911
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
1914 CIS register.
1915
1916 ======================================================================*/
1917
1918 int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
1919 {
1920 struct pcmcia_socket *skt;
1921 int ret;
1922
1923 if (CHECK_HANDLE(handle))
1924 return CS_BAD_HANDLE;
1925 skt = SOCKET(handle);
1926 cs_dbg(skt, 1, "resetting socket\n");
1927
1928 down(&skt->skt_sem);
1929 do {
1930 if (!(skt->state & SOCKET_PRESENT)) {
1931 ret = CS_NO_CARD;
1932 break;
1933 }
1934 if (skt->state & SOCKET_SUSPEND) {
1935 ret = CS_IN_USE;
1936 break;
1937 }
1938 if (skt->state & SOCKET_CARDBUS) {
1939 ret = CS_UNSUPPORTED_FUNCTION;
1940 break;
1941 }
1942
1943 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1944 if (ret == 0) {
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);
1948 }
1949
1950 handle->event_callback_args.info = (void *)(u_long)ret;
1951 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1952
1953 ret = CS_SUCCESS;
1954 } while (0);
1955 up(&skt->skt_sem);
1956
1957 return ret;
1958 } /* reset_card */
1959
1960 /*======================================================================
1961
1962 These shut down or wake up a socket. They are sort of user
1963 initiated versions of the APM suspend and resume actions.
1964
1965 ======================================================================*/
1966
1967 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1968 {
1969 int ret;
1970
1971 cs_dbg(skt, 1, "suspending socket\n");
1972
1973 down(&skt->skt_sem);
1974 do {
1975 if (!(skt->state & SOCKET_PRESENT)) {
1976 ret = CS_NO_CARD;
1977 break;
1978 }
1979 if (skt->state & SOCKET_CARDBUS) {
1980 ret = CS_UNSUPPORTED_FUNCTION;
1981 break;
1982 }
1983 ret = socket_suspend(skt);
1984 } while (0);
1985 up(&skt->skt_sem);
1986
1987 return ret;
1988 } /* suspend_card */
1989
1990 int pcmcia_resume_card(struct pcmcia_socket *skt)
1991 {
1992 int ret;
1993
1994 cs_dbg(skt, 1, "waking up socket\n");
1995
1996 down(&skt->skt_sem);
1997 do {
1998 if (!(skt->state & SOCKET_PRESENT)) {
1999 ret = CS_NO_CARD;
2000 break;
2001 }
2002 if (skt->state & SOCKET_CARDBUS) {
2003 ret = CS_UNSUPPORTED_FUNCTION;
2004 break;
2005 }
2006 ret = socket_resume(skt);
2007 } while (0);
2008 up(&skt->skt_sem);
2009
2010 return ret;
2011 } /* resume_card */
2012
2013 /*======================================================================
2014
2015 These handle user requests to eject or insert a card.
2016
2017 ======================================================================*/
2018
2019 int pcmcia_eject_card(struct pcmcia_socket *skt)
2020 {
2021 int ret;
2022
2023 cs_dbg(skt, 1, "user eject request\n");
2024
2025 down(&skt->skt_sem);
2026 do {
2027 if (!(skt->state & SOCKET_PRESENT)) {
2028 ret = -ENODEV;
2029 break;
2030 }
2031
2032 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2033 if (ret != 0) {
2034 ret = -EINVAL;
2035 break;
2036 }
2037
2038 socket_remove(skt);
2039 ret = 0;
2040 } while (0);
2041 up(&skt->skt_sem);
2042
2043 return ret;
2044 } /* eject_card */
2045
2046 int pcmcia_insert_card(struct pcmcia_socket *skt)
2047 {
2048 int ret;
2049
2050 cs_dbg(skt, 1, "user insert request\n");
2051
2052 down(&skt->skt_sem);
2053 do {
2054 if (skt->state & SOCKET_PRESENT) {
2055 ret = -EBUSY;
2056 break;
2057 }
2058 if (socket_insert(skt) == CS_NO_CARD) {
2059 ret = -ENODEV;
2060 break;
2061 }
2062 ret = 0;
2063 } while (0);
2064 up(&skt->skt_sem);
2065
2066 return ret;
2067 } /* insert_card */
2068
2069 /*======================================================================
2070
2071 Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2072 haven't sent one to this client yet?
2073
2074 ======================================================================*/
2075
2076 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2077 {
2078 u_int events, bit;
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);
2089 events -= bit;
2090 }
2091 return CS_SUCCESS;
2092 } /* set_event_mask */
2093
2094 /*======================================================================
2095
2096 OS-specific module glue goes here
2097
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);
2146
2147 EXPORT_SYMBOL(dead_socket);
2148 EXPORT_SYMBOL(MTDHelperEntry);
2149 EXPORT_SYMBOL(pcmcia_parse_events);
2150
2151 struct class pcmcia_socket_class = {
2152 .name = "pcmcia_socket",
2153 .release = pcmcia_release_socket,
2154 };
2155 EXPORT_SYMBOL(pcmcia_socket_class);
2156
2157
2158 static int __init init_pcmcia_cs(void)
2159 {
2160 int ret;
2161 printk(KERN_INFO "%s\n", release);
2162 printk(KERN_INFO " %s\n", options);
2163
2164 ret = class_register(&pcmcia_socket_class);
2165 if (ret)
2166 return (ret);
2167 return class_interface_register(&pccard_sysfs_interface);
2168 }
2169
2170 static void __exit exit_pcmcia_cs(void)
2171 {
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);
2176 }
2177
2178 subsys_initcall(init_pcmcia_cs);
2179 module_exit(exit_pcmcia_cs);
2180
2181 /*====================================================================*/
2182
MOXA 2.6.9 from sdlinux-moxaart.tgz