1 /*
2 * cs.c -- Kernel Card Services - core services
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
11 *
12 * (C) 1999 David A. Hinds
13 */
14
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/config.h>
20 #include <linux/string.h>
21 #include <linux/major.h>
22 #include <linux/errno.h>
23 #include <linux/slab.h>
24 #include <linux/mm.h>
25 #include <linux/interrupt.h>
26 #include <linux/timer.h>
27 #include <linux/ioport.h>
28 #include <linux/delay.h>
29 #include <linux/pm.h>
30 #include <linux/pci.h>
31 #include <linux/device.h>
32 #include <asm/system.h>
33 #include <asm/irq.h>
34
35 #define IN_CARD_SERVICES
36 #include <pcmcia/version.h>
37 #include <pcmcia/cs_types.h>
38 #include <pcmcia/ss.h>
39 #include <pcmcia/cs.h>
40 #include <pcmcia/bulkmem.h>
41 #include <pcmcia/cistpl.h>
42 #include <pcmcia/cisreg.h>
43 #include <pcmcia/ds.h>
44 #include "cs_internal.h"
45
46 #ifdef CONFIG_PCI
47 #define PCI_OPT " [pci]"
48 #else
49 #define PCI_OPT ""
50 #endif
51 #ifdef CONFIG_CARDBUS
52 #define CB_OPT " [cardbus]"
53 #else
54 #define CB_OPT ""
55 #endif
56 #ifdef CONFIG_PM
57 #define PM_OPT " [pm]"
58 #else
59 #define PM_OPT ""
60 #endif
61 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
62 #define OPTIONS " none"
63 #else
64 #define OPTIONS PCI_OPT CB_OPT PM_OPT
65 #endif
66
67 static const char *release = "Linux Kernel Card Services";
68 static const char *options = "options: " OPTIONS;
69
70 /*====================================================================*/
71
72 /* Module parameters */
73
74 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
75 MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
76 MODULE_LICENSE("GPL");
77
78 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
79
80 INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
81 INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
82 INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
83 INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
84 INT_MODULE_PARM(reset_time, 10); /* usecs */
85 INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
86 INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
87 INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
88
89 /* Access speed for attribute memory windows */
90 INT_MODULE_PARM(cis_speed, 300); /* ns */
91
92 /* Access speed for IO windows */
93 INT_MODULE_PARM(io_speed, 0); /* ns */
94
95 #ifdef DEBUG
96 static int pc_debug;
97
98 module_param(pc_debug, int, 0644);
99
100 int cs_debug_level(int level)
101 {
102 return pc_debug > level;
103 }
104 #endif
105
106 /*====================================================================*/
107
108 socket_state_t dead_socket = {
109 .csc_mask = SS_DETECT,
110 };
111
112
113 /* List of all sockets, protected by a rwsem */
114 LIST_HEAD(pcmcia_socket_list);
115 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
116 EXPORT_SYMBOL(pcmcia_socket_list);
117 EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
118
119
120 #ifdef CONFIG_PCMCIA_PROBE
121 /* mask ofIRQs already reserved by other cards, we should avoid using them */
122 static u8 pcmcia_used_irq[NR_IRQS];
123 #endif
124
125 /*====================================================================
126
127 Low-level PC Card interface drivers need to register with Card
128 Services using these calls.
129
130 ======================================================================*/
131
132 /**
133 * socket drivers are expected to use the following callbacks in their
134 * .drv struct:
135 * - pcmcia_socket_dev_suspend
136 * - pcmcia_socket_dev_resume
137 * These functions check for the appropriate struct pcmcia_soket arrays,
138 * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
139 */
140 static int socket_resume(struct pcmcia_socket *skt);
141 static int socket_suspend(struct pcmcia_socket *skt);
142
143 int pcmcia_socket_dev_suspend(struct device *dev, u32 state)
144 {
145 struct pcmcia_socket *socket;
146
147 down_read(&pcmcia_socket_list_rwsem);
148 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
149 if (socket->dev.dev != dev)
150 continue;
151 down(&socket->skt_sem);
152 socket_suspend(socket);
153 up(&socket->skt_sem);
154 }
155 up_read(&pcmcia_socket_list_rwsem);
156
157 return 0;
158 }
159 EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
160
161 int pcmcia_socket_dev_resume(struct device *dev)
162 {
163 struct pcmcia_socket *socket;
164
165 down_read(&pcmcia_socket_list_rwsem);
166 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
167 if (socket->dev.dev != dev)
168 continue;
169 down(&socket->skt_sem);
170 socket_resume(socket);
171 up(&socket->skt_sem);
172 }
173 up_read(&pcmcia_socket_list_rwsem);
174
175 return 0;
176 }
177 EXPORT_SYMBOL(pcmcia_socket_dev_resume);
178
179
180 struct pcmcia_socket * pcmcia_get_socket(struct pcmcia_socket *skt)
181 {
182 struct class_device *cl_dev = class_device_get(&skt->dev);
183 if (!cl_dev)
184 return NULL;
185 skt = class_get_devdata(cl_dev);
186 if (!try_module_get(skt->owner)) {
187 class_device_put(&skt->dev);
188 return NULL;
189 }
190 return (skt);
191 }
192 EXPORT_SYMBOL(pcmcia_get_socket);
193
194
195 void pcmcia_put_socket(struct pcmcia_socket *skt)
196 {
197 module_put(skt->owner);
198 class_device_put(&skt->dev);
199 }
200 EXPORT_SYMBOL(pcmcia_put_socket);
201
202
203 static void pcmcia_release_socket(struct class_device *class_dev)
204 {
205 struct pcmcia_socket *socket = class_get_devdata(class_dev);
206
207 complete(&socket->socket_released);
208 }
209
210 static int pccardd(void *__skt);
211
212 /**
213 * pcmcia_register_socket - add a new pcmcia socket device
214 */
215 int pcmcia_register_socket(struct pcmcia_socket *socket)
216 {
217 int ret;
218
219 if (!socket || !socket->ops || !socket->dev.dev || !socket->resource_ops)
220 return -EINVAL;
221
222 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
223
224 if (socket->resource_ops->init) {
225 ret = socket->resource_ops->init(socket);
226 if (ret)
227 return (ret);
228 }
229
230 /* try to obtain a socket number [yes, it gets ugly if we
231 * register more than 2^sizeof(unsigned int) pcmcia
232 * sockets... but the socket number is deprecated
233 * anyways, so I don't care] */
234 down_write(&pcmcia_socket_list_rwsem);
235 if (list_empty(&pcmcia_socket_list))
236 socket->sock = 0;
237 else {
238 unsigned int found, i = 1;
239 struct pcmcia_socket *tmp;
240 do {
241 found = 1;
242 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
243 if (tmp->sock == i)
244 found = 0;
245 }
246 i++;
247 } while (!found);
248 socket->sock = i - 1;
249 }
250 list_add_tail(&socket->socket_list, &pcmcia_socket_list);
251 up_write(&pcmcia_socket_list_rwsem);
252
253
254 /* set proper values in socket->dev */
255 socket->dev.class_data = socket;
256 socket->dev.class = &pcmcia_socket_class;
257 snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
258
259 /* base address = 0, map = 0 */
260 socket->cis_mem.flags = 0;
261 socket->cis_mem.speed = cis_speed;
262
263 INIT_LIST_HEAD(&socket->cis_cache);
264 spin_lock_init(&socket->lock);
265
266 init_completion(&socket->socket_released);
267 init_completion(&socket->thread_done);
268 init_waitqueue_head(&socket->thread_wait);
269 init_MUTEX(&socket->skt_sem);
270 spin_lock_init(&socket->thread_lock);
271
272 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
273 if (ret < 0)
274 goto err;
275
276 wait_for_completion(&socket->thread_done);
277 if(!socket->thread) {
278 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
279 return -EIO;
280 }
281 pcmcia_parse_events(socket, SS_DETECT);
282
283 return 0;
284
285 err:
286 down_write(&pcmcia_socket_list_rwsem);
287 list_del(&socket->socket_list);
288 up_write(&pcmcia_socket_list_rwsem);
289 return ret;
290 } /* pcmcia_register_socket */
291 EXPORT_SYMBOL(pcmcia_register_socket);
292
293
294 /**
295 * pcmcia_unregister_socket - remove a pcmcia socket device
296 */
297 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
298 {
299 if (!socket)
300 return;
301
302 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
303
304 if (socket->thread) {
305 init_completion(&socket->thread_done);
306 socket->thread = NULL;
307 wake_up(&socket->thread_wait);
308 wait_for_completion(&socket->thread_done);
309 }
310 release_cis_mem(socket);
311
312 /* remove from our own list */
313 down_write(&pcmcia_socket_list_rwsem);
314 list_del(&socket->socket_list);
315 up_write(&pcmcia_socket_list_rwsem);
316
317 /* wait for sysfs to drop all references */
318 release_resource_db(socket);
319 wait_for_completion(&socket->socket_released);
320 } /* pcmcia_unregister_socket */
321 EXPORT_SYMBOL(pcmcia_unregister_socket);
322
323
324 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
325 {
326 struct pcmcia_socket *s;
327
328 down_read(&pcmcia_socket_list_rwsem);
329 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
330 if (s->sock == nr) {
331 up_read(&pcmcia_socket_list_rwsem);
332 return s;
333 }
334 up_read(&pcmcia_socket_list_rwsem);
335
336 return NULL;
337
338 }
339 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
340
341
342 /*======================================================================
343
344 socket_setup() and shutdown_socket() are called by the main event
345 handler when card insertion and removal events are received.
346 socket_setup() turns on socket power and resets the socket, in two stages.
347 shutdown_socket() unconfigures a socket and turns off socket power.
348
349 ======================================================================*/
350
351 static void shutdown_socket(struct pcmcia_socket *s)
352 {
353 cs_dbg(s, 1, "shutdown_socket\n");
354
355 /* Blank out the socket state */
356 s->socket = dead_socket;
357 s->ops->init(s);
358 s->ops->set_socket(s, &s->socket);
359 s->irq.AssignedIRQ = s->irq.Config = 0;
360 s->lock_count = 0;
361 destroy_cis_cache(s);
362 #ifdef CONFIG_CARDBUS
363 cb_free(s);
364 #endif
365 s->functions = 0;
366 if (s->config) {
367 kfree(s->config);
368 s->config = NULL;
369 }
370
371 {
372 int status;
373 s->ops->get_status(s, &status);
374 if (status & SS_POWERON) {
375 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
376 }
377 }
378 } /* shutdown_socket */
379
380 /*======================================================================
381
382 The central event handler. Send_event() sends an event to the
383 16-bit subsystem, which then calls the relevant device drivers.
384 Parse_events() interprets the event bits from
385 a card status change report. Do_shutdown() handles the high
386 priority stuff associated with a card removal.
387
388 ======================================================================*/
389
390
391 /* NOTE: send_event needs to be called with skt->sem held. */
392
393 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
394 {
395 int ret;
396
397 if (s->state & SOCKET_CARDBUS)
398 return 0;
399
400 cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n",
401 event, priority, s->callback);
402
403 if (!s->callback)
404 return 0;
405 if (!try_module_get(s->callback->owner))
406 return 0;
407
408 ret = s->callback->event(s, event, priority);
409
410 module_put(s->callback->owner);
411
412 return ret;
413 }
414
415 static void socket_remove_drivers(struct pcmcia_socket *skt)
416 {
417 cs_dbg(skt, 4, "remove_drivers\n");
418
419 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
420 }
421
422 static void socket_shutdown(struct pcmcia_socket *skt)
423 {
424 cs_dbg(skt, 4, "shutdown\n");
425
426 socket_remove_drivers(skt);
427 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
428 msleep(shutdown_delay * 10);
429 skt->state &= SOCKET_INUSE;
430 shutdown_socket(skt);
431 }
432
433 static int socket_reset(struct pcmcia_socket *skt)
434 {
435 int status, i;
436
437 cs_dbg(skt, 4, "reset\n");
438
439 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
440 skt->ops->set_socket(skt, &skt->socket);
441 udelay((long)reset_time);
442
443 skt->socket.flags &= ~SS_RESET;
444 skt->ops->set_socket(skt, &skt->socket);
445
446 msleep(unreset_delay * 10);
447 for (i = 0; i < unreset_limit; i++) {
448 skt->ops->get_status(skt, &status);
449
450 if (!(status & SS_DETECT))
451 return CS_NO_CARD;
452
453 if (status & SS_READY)
454 return CS_SUCCESS;
455
456 msleep(unreset_check * 10);
457 }
458
459 cs_err(skt, "time out after reset.\n");
460 return CS_GENERAL_FAILURE;
461 }
462
463 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
464 {
465 int status, i;
466
467 cs_dbg(skt, 4, "setup\n");
468
469 skt->ops->get_status(skt, &status);
470 if (!(status & SS_DETECT))
471 return CS_NO_CARD;
472
473 msleep(initial_delay * 10);
474
475 for (i = 0; i < 100; i++) {
476 skt->ops->get_status(skt, &status);
477 if (!(status & SS_DETECT))
478 return CS_NO_CARD;
479
480 if (!(status & SS_PENDING))
481 break;
482
483 msleep(100);
484 }
485
486 if (status & SS_PENDING) {
487 cs_err(skt, "voltage interrogation timed out.\n");
488 return CS_GENERAL_FAILURE;
489 }
490
491 if (status & SS_CARDBUS) {
492 skt->state |= SOCKET_CARDBUS;
493 #ifndef CONFIG_CARDBUS
494 cs_err(skt, "cardbus cards are not supported.\n");
495 return CS_BAD_TYPE;
496 #endif
497 }
498
499 /*
500 * Decode the card voltage requirements, and apply power to the card.
501 */
502 if (status & SS_3VCARD)
503 skt->socket.Vcc = skt->socket.Vpp = 33;
504 else if (!(status & SS_XVCARD))
505 skt->socket.Vcc = skt->socket.Vpp = 50;
506 else {
507 cs_err(skt, "unsupported voltage key.\n");
508 return CS_BAD_TYPE;
509 }
510 skt->socket.flags = 0;
511 skt->ops->set_socket(skt, &skt->socket);
512
513 /*
514 * Wait "vcc_settle" for the supply to stabilise.
515 */
516 msleep(vcc_settle * 10);
517
518 skt->ops->get_status(skt, &status);
519 if (!(status & SS_POWERON)) {
520 cs_err(skt, "unable to apply power.\n");
521 return CS_BAD_TYPE;
522 }
523
524 return socket_reset(skt);
525 }
526
527 /*
528 * Handle card insertion. Setup the socket, reset the card,
529 * and then tell the rest of PCMCIA that a card is present.
530 */
531 static int socket_insert(struct pcmcia_socket *skt)
532 {
533 int ret;
534
535 cs_dbg(skt, 4, "insert\n");
536
537 if (!cs_socket_get(skt))
538 return CS_NO_CARD;
539
540 ret = socket_setup(skt, setup_delay);
541 if (ret == CS_SUCCESS) {
542 skt->state |= SOCKET_PRESENT;
543 #ifdef CONFIG_CARDBUS
544 if (skt->state & SOCKET_CARDBUS) {
545 cb_alloc(skt);
546 skt->state |= SOCKET_CARDBUS_CONFIG;
547 }
548 #endif
549 cs_dbg(skt, 4, "insert done\n");
550
551 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
552 } else {
553 socket_shutdown(skt);
554 cs_socket_put(skt);
555 }
556
557 return ret;
558 }
559
560 static int socket_suspend(struct pcmcia_socket *skt)
561 {
562 if (skt->state & SOCKET_SUSPEND)
563 return CS_IN_USE;
564
565 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
566 skt->socket = dead_socket;
567 skt->ops->suspend(skt);
568 skt->state |= SOCKET_SUSPEND;
569
570 return CS_SUCCESS;
571 }
572
573 /*
574 * Resume a socket. If a card is present, verify its CIS against
575 * our cached copy. If they are different, the card has been
576 * replaced, and we need to tell the drivers.
577 */
578 static int socket_resume(struct pcmcia_socket *skt)
579 {
580 int ret;
581
582 if (!(skt->state & SOCKET_SUSPEND))
583 return CS_IN_USE;
584
585 skt->socket = dead_socket;
586 skt->ops->init(skt);
587 skt->ops->set_socket(skt, &skt->socket);
588
589 ret = socket_setup(skt, resume_delay);
590 if (ret == CS_SUCCESS) {
591 /*
592 * FIXME: need a better check here for cardbus cards.
593 */
594 if (verify_cis_cache(skt) != 0) {
595 cs_dbg(skt, 4, "cis mismatch - different card\n");
596 socket_remove_drivers(skt);
597 destroy_cis_cache(skt);
598 /*
599 * Workaround: give DS time to schedule removal.
600 * Remove me once the 100ms delay is eliminated
601 * in ds.c
602 */
603 msleep(200);
604 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
605 } else {
606 cs_dbg(skt, 4, "cis matches cache\n");
607 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
608 }
609 } else {
610 socket_shutdown(skt);
611 cs_socket_put(skt);
612 }
613
614 skt->state &= ~SOCKET_SUSPEND;
615
616 return CS_SUCCESS;
617 }
618
619 static void socket_remove(struct pcmcia_socket *skt)
620 {
621 socket_shutdown(skt);
622 cs_socket_put(skt);
623 }
624
625 /*
626 * Process a socket card detect status change.
627 *
628 * If we don't have a card already present, delay the detect event for
629 * about 20ms (to be on the safe side) before reading the socket status.
630 *
631 * Some i82365-based systems send multiple SS_DETECT events during card
632 * insertion, and the "card present" status bit seems to bounce. This
633 * will probably be true with GPIO-based card detection systems after
634 * the product has aged.
635 */
636 static void socket_detect_change(struct pcmcia_socket *skt)
637 {
638 if (!(skt->state & SOCKET_SUSPEND)) {
639 int status;
640
641 if (!(skt->state & SOCKET_PRESENT))
642 msleep(20);
643
644 skt->ops->get_status(skt, &status);
645 if ((skt->state & SOCKET_PRESENT) &&
646 !(status & SS_DETECT))
647 socket_remove(skt);
648 if (!(skt->state & SOCKET_PRESENT) &&
649 (status & SS_DETECT))
650 socket_insert(skt);
651 }
652 }
653
654 static int pccardd(void *__skt)
655 {
656 struct pcmcia_socket *skt = __skt;
657 DECLARE_WAITQUEUE(wait, current);
658 int ret;
659
660 daemonize("pccardd");
661
662 skt->thread = current;
663 skt->socket = dead_socket;
664 skt->ops->init(skt);
665 skt->ops->set_socket(skt, &skt->socket);
666
667 /* register with the device core */
668 ret = class_device_register(&skt->dev);
669 if (ret) {
670 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
671 skt);
672 skt->thread = NULL;
673 complete_and_exit(&skt->thread_done, 0);
674 }
675 complete(&skt->thread_done);
676
677 add_wait_queue(&skt->thread_wait, &wait);
678 for (;;) {
679 unsigned long flags;
680 unsigned int events;
681
682 set_current_state(TASK_INTERRUPTIBLE);
683
684 spin_lock_irqsave(&skt->thread_lock, flags);
685 events = skt->thread_events;
686 skt->thread_events = 0;
687 spin_unlock_irqrestore(&skt->thread_lock, flags);
688
689 if (events) {
690 down(&skt->skt_sem);
691 if (events & SS_DETECT)
692 socket_detect_change(skt);
693 if (events & SS_BATDEAD)
694 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
695 if (events & SS_BATWARN)
696 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
697 if (events & SS_READY)
698 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
699 up(&skt->skt_sem);
700 continue;
701 }
702
703 schedule();
704 try_to_freeze(PF_FREEZE);
705
706 if (!skt->thread)
707 break;
708 }
709 remove_wait_queue(&skt->thread_wait, &wait);
710
711 /* remove from the device core */
712 class_device_unregister(&skt->dev);
713
714 complete_and_exit(&skt->thread_done, 0);
715 }
716
717 /*
718 * Yenta (at least) probes interrupts before registering the socket and
719 * starting the handler thread.
720 */
721 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
722 {
723 cs_dbg(s, 4, "parse_events: events %08x\n", events);
724 if (s->thread) {
725 spin_lock(&s->thread_lock);
726 s->thread_events |= events;
727 spin_unlock(&s->thread_lock);
728
729 wake_up(&s->thread_wait);
730 }
731 } /* pcmcia_parse_events */
732
733
734 /*======================================================================
735
736 Special stuff for managing IO windows, because they are scarce.
737
738 ======================================================================*/
739
740 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
741 ioaddr_t num, u_int lines)
742 {
743 int i;
744 kio_addr_t try, align;
745
746 align = (*base) ? (lines ? 1<<lines : 0) : 1;
747 if (align && (align < num)) {
748 if (*base) {
749 cs_dbg(s, 0, "odd IO request: num %#x align %#lx\n",
750 num, align);
751 align = 0;
752 } else
753 while (align && (align < num)) align <<= 1;
754 }
755 if (*base & ~(align-1)) {
756 cs_dbg(s, 0, "odd IO request: base %#x align %#lx\n",
757 *base, align);
758 align = 0;
759 }
760 if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
761 *base = s->io_offset | (*base & 0x0fff);
762 return 0;
763 }
764 /* Check for an already-allocated window that must conflict with
765 what was asked for. It is a hack because it does not catch all
766 potential conflicts, just the most obvious ones. */
767 for (i = 0; i < MAX_IO_WIN; i++)
768 if ((s->io[i].NumPorts != 0) &&
769 ((s->io[i].BasePort & (align-1)) == *base))
770 return 1;
771 for (i = 0; i < MAX_IO_WIN; i++) {
772 if (s->io[i].NumPorts == 0) {
773 s->io[i].res = find_io_region(*base, num, align, s);
774 if (s->io[i].res) {
775 s->io[i].Attributes = attr;
776 s->io[i].BasePort = *base = s->io[i].res->start;
777 s->io[i].NumPorts = s->io[i].InUse = num;
778 break;
779 } else
780 return 1;
781 } else if (s->io[i].Attributes != attr)
782 continue;
783 /* Try to extend top of window */
784 try = s->io[i].BasePort + s->io[i].NumPorts;
785 if ((*base == 0) || (*base == try))
786 if (adjust_io_region(s->io[i].res, s->io[i].res->start,
787 s->io[i].res->end + num, s) == 0) {
788 *base = try;
789 s->io[i].NumPorts += num;
790 s->io[i].InUse += num;
791 break;
792 }
793 /* Try to extend bottom of window */
794 try = s->io[i].BasePort - num;
795 if ((*base == 0) || (*base == try))
796 if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
797 s->io[i].res->end, s) == 0) {
798 s->io[i].BasePort = *base = try;
799 s->io[i].NumPorts += num;
800 s->io[i].InUse += num;
801 break;
802 }
803 }
804 return (i == MAX_IO_WIN);
805 } /* alloc_io_space */
806
807 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
808 ioaddr_t num)
809 {
810 int i;
811
812 for (i = 0; i < MAX_IO_WIN; i++) {
813 if ((s->io[i].BasePort <= base) &&
814 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
815 s->io[i].InUse -= num;
816 /* Free the window if no one else is using it */
817 if (s->io[i].InUse == 0) {
818 s->io[i].NumPorts = 0;
819 release_resource(s->io[i].res);
820 kfree(s->io[i].res);
821 s->io[i].res = NULL;
822 }
823 }
824 }
825 }
826
827 /*======================================================================
828
829 Access_configuration_register() reads and writes configuration
830 registers in attribute memory. Memory window 0 is reserved for
831 this and the tuple reading services.
832
833 ======================================================================*/
834
835 int pccard_access_configuration_register(struct pcmcia_socket *s,
836 unsigned int function,
837 conf_reg_t *reg)
838 {
839 config_t *c;
840 int addr;
841 u_char val;
842
843 if (!s || !s->config)
844 return CS_NO_CARD;
845
846 c = &s->config[function];
847
848 if (c == NULL)
849 return CS_NO_CARD;
850
851 if (!(c->state & CONFIG_LOCKED))
852 return CS_CONFIGURATION_LOCKED;
853
854 addr = (c->ConfigBase + reg->Offset) >> 1;
855
856 switch (reg->Action) {
857 case CS_READ:
858 read_cis_mem(s, 1, addr, 1, &val);
859 reg->Value = val;
860 break;
861 case CS_WRITE:
862 val = reg->Value;
863 write_cis_mem(s, 1, addr, 1, &val);
864 break;
865 default:
866 return CS_BAD_ARGS;
867 break;
868 }
869 return CS_SUCCESS;
870 } /* access_configuration_register */
871 EXPORT_SYMBOL(pccard_access_configuration_register);
872
873
874 /*====================================================================*/
875
876 int pccard_get_configuration_info(struct pcmcia_socket *s,
877 unsigned int function,
878 config_info_t *config)
879 {
880 config_t *c;
881
882 if (!(s->state & SOCKET_PRESENT))
883 return CS_NO_CARD;
884
885 config->Function = function;
886
887 #ifdef CONFIG_CARDBUS
888 if (s->state & SOCKET_CARDBUS) {
889 memset(config, 0, sizeof(config_info_t));
890 config->Vcc = s->socket.Vcc;
891 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
892 config->Option = s->cb_dev->subordinate->number;
893 if (s->state & SOCKET_CARDBUS_CONFIG) {
894 config->Attributes = CONF_VALID_CLIENT;
895 config->IntType = INT_CARDBUS;
896 config->AssignedIRQ = s->irq.AssignedIRQ;
897 if (config->AssignedIRQ)
898 config->Attributes |= CONF_ENABLE_IRQ;
899 config->BasePort1 = s->io[0].BasePort;
900 config->NumPorts1 = s->io[0].NumPorts;
901 }
902 return CS_SUCCESS;
903 }
904 #endif
905
906 c = (s->config != NULL) ? &s->config[function] : NULL;
907
908 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
909 config->Attributes = 0;
910 config->Vcc = s->socket.Vcc;
911 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
912 return CS_SUCCESS;
913 }
914
915 /* !!! This is a hack !!! */
916 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
917 config->Attributes |= CONF_VALID_CLIENT;
918 config->CardValues = c->CardValues;
919 config->IRQAttributes = c->irq.Attributes;
920 config->AssignedIRQ = s->irq.AssignedIRQ;
921 config->BasePort1 = c->io.BasePort1;
922 config->NumPorts1 = c->io.NumPorts1;
923 config->Attributes1 = c->io.Attributes1;
924 config->BasePort2 = c->io.BasePort2;
925 config->NumPorts2 = c->io.NumPorts2;
926 config->Attributes2 = c->io.Attributes2;
927 config->IOAddrLines = c->io.IOAddrLines;
928
929 return CS_SUCCESS;
930 } /* get_configuration_info */
931 EXPORT_SYMBOL(pccard_get_configuration_info);
932
933 /*======================================================================
934
935 Return information about this version of Card Services.
936
937 ======================================================================*/
938
939 int pcmcia_get_card_services_info(servinfo_t *info)
940 {
941 unsigned int socket_count = 0;
942 struct list_head *tmp;
943 info->Signature[0] = 'C';
944 info->Signature[1] = 'S';
945 down_read(&pcmcia_socket_list_rwsem);
946 list_for_each(tmp, &pcmcia_socket_list)
947 socket_count++;
948 up_read(&pcmcia_socket_list_rwsem);
949 info->Count = socket_count;
950 info->Revision = CS_RELEASE_CODE;
951 info->CSLevel = 0x0210;
952 info->VendorString = (char *)release;
953 return CS_SUCCESS;
954 } /* get_card_services_info */
955
956
957 /*====================================================================*/
958
959 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
960 {
961 window_t *win;
962 int w;
963
964 if (!s || !(s->state & SOCKET_PRESENT))
965 return CS_NO_CARD;
966 for (w = idx; w < MAX_WIN; w++)
967 if (s->state & SOCKET_WIN_REQ(w)) break;
968 if (w == MAX_WIN)
969 return CS_NO_MORE_ITEMS;
970 win = &s->win[w];
971 req->Base = win->ctl.res->start;
972 req->Size = win->ctl.res->end - win->ctl.res->start + 1;
973 req->AccessSpeed = win->ctl.speed;
974 req->Attributes = 0;
975 if (win->ctl.flags & MAP_ATTRIB)
976 req->Attributes |= WIN_MEMORY_TYPE_AM;
977 if (win->ctl.flags & MAP_ACTIVE)
978 req->Attributes |= WIN_ENABLE;
979 if (win->ctl.flags & MAP_16BIT)
980 req->Attributes |= WIN_DATA_WIDTH_16;
981 if (win->ctl.flags & MAP_USE_WAIT)
982 req->Attributes |= WIN_USE_WAIT;
983 *handle = win;
984 return CS_SUCCESS;
985 } /* get_window */
986 EXPORT_SYMBOL(pcmcia_get_window);
987
988 /*=====================================================================
989
990 Return the PCI device associated with a card..
991
992 ======================================================================*/
993
994 #ifdef CONFIG_CARDBUS
995
996 struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
997 {
998 if (!s || !(s->state & SOCKET_CARDBUS))
999 return NULL;
1000
1001 return s->cb_dev->subordinate;
1002 }
1003
1004 EXPORT_SYMBOL(pcmcia_lookup_bus);
1005
1006 #endif
1007
1008 /*======================================================================
1009
1010 Get the current socket state bits. We don't support the latched
1011 SocketState yet: I haven't seen any point for it.
1012
1013 ======================================================================*/
1014
1015 int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
1016 {
1017 config_t *c;
1018 int val;
1019
1020 s->ops->get_status(s, &val);
1021 status->CardState = status->SocketState = 0;
1022 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1023 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1024 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1025 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1026 if (s->state & SOCKET_SUSPEND)
1027 status->CardState |= CS_EVENT_PM_SUSPEND;
1028 if (!(s->state & SOCKET_PRESENT))
1029 return CS_NO_CARD;
1030
1031 c = (s->config != NULL) ? &s->config[function] : NULL;
1032 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1033 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1034 u_char reg;
1035 if (c->Present & PRESENT_PIN_REPLACE) {
1036 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1037 status->CardState |=
1038 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1039 status->CardState |=
1040 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1041 status->CardState |=
1042 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1043 status->CardState |=
1044 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1045 } else {
1046 /* No PRR? Then assume we're always ready */
1047 status->CardState |= CS_EVENT_READY_CHANGE;
1048 }
1049 if (c->Present & PRESENT_EXT_STATUS) {
1050 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1051 status->CardState |=
1052 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1053 }
1054 return CS_SUCCESS;
1055 }
1056 status->CardState |=
1057 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1058 status->CardState |=
1059 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1060 status->CardState |=
1061 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1062 status->CardState |=
1063 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1064 return CS_SUCCESS;
1065 } /* get_status */
1066 EXPORT_SYMBOL(pccard_get_status);
1067
1068 /*======================================================================
1069
1070 Change the card address of an already open memory window.
1071
1072 ======================================================================*/
1073
1074 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1075 {
1076 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1077 return CS_BAD_HANDLE;
1078 req->Page = 0;
1079 req->CardOffset = win->ctl.card_start;
1080 return CS_SUCCESS;
1081 } /* get_mem_page */
1082
1083 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1084 {
1085 struct pcmcia_socket *s;
1086 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1087 return CS_BAD_HANDLE;
1088 if (req->Page != 0)
1089 return CS_BAD_PAGE;
1090 s = win->sock;
1091 win->ctl.card_start = req->CardOffset;
1092 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1093 return CS_BAD_OFFSET;
1094 return CS_SUCCESS;
1095 } /* map_mem_page */
1096
1097 /*======================================================================
1098
1099 Modify a locked socket configuration
1100
1101 ======================================================================*/
1102
1103 int pcmcia_modify_configuration(client_handle_t handle,
1104 modconf_t *mod)
1105 {
1106 struct pcmcia_socket *s;
1107 config_t *c;
1108
1109 if (CHECK_HANDLE(handle))
1110 return CS_BAD_HANDLE;
1111 s = SOCKET(handle); c = CONFIG(handle);
1112 if (!(s->state & SOCKET_PRESENT))
1113 return CS_NO_CARD;
1114 if (!(c->state & CONFIG_LOCKED))
1115 return CS_CONFIGURATION_LOCKED;
1116
1117 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1118 if (mod->Attributes & CONF_ENABLE_IRQ) {
1119 c->Attributes |= CONF_ENABLE_IRQ;
1120 s->socket.io_irq = s->irq.AssignedIRQ;
1121 } else {
1122 c->Attributes &= ~CONF_ENABLE_IRQ;
1123 s->socket.io_irq = 0;
1124 }
1125 s->ops->set_socket(s, &s->socket);
1126 }
1127
1128 if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1129 return CS_BAD_VCC;
1130
1131 /* We only allow changing Vpp1 and Vpp2 to the same value */
1132 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1133 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1134 if (mod->Vpp1 != mod->Vpp2)
1135 return CS_BAD_VPP;
1136 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1137 if (s->ops->set_socket(s, &s->socket))
1138 return CS_BAD_VPP;
1139 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1140 (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1141 return CS_BAD_VPP;
1142
1143 return CS_SUCCESS;
1144 } /* modify_configuration */
1145
1146 /* register pcmcia_callback */
1147 int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
1148 {
1149 int ret = 0;
1150
1151 /* s->skt_sem also protects s->callback */
1152 down(&s->skt_sem);
1153
1154 if (c) {
1155 /* registration */
1156 if (s->callback) {
1157 ret = -EBUSY;
1158 goto err;
1159 }
1160
1161 s->callback = c;
1162
1163 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
1164 send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1165 } else
1166 s->callback = NULL;
1167 err:
1168 up(&s->skt_sem);
1169
1170 return ret;
1171 }
1172 EXPORT_SYMBOL(pccard_register_pcmcia);
1173
1174 /*====================================================================*/
1175
1176 int pcmcia_release_configuration(client_handle_t handle)
1177 {
1178 pccard_io_map io = { 0, 0, 0, 0, 1 };
1179 struct pcmcia_socket *s;
1180 int i;
1181
1182 if (CHECK_HANDLE(handle) ||
1183 !(handle->state & CLIENT_CONFIG_LOCKED))
1184 return CS_BAD_HANDLE;
1185 handle->state &= ~CLIENT_CONFIG_LOCKED;
1186 s = SOCKET(handle);
1187
1188 #ifdef CONFIG_CARDBUS
1189 if (handle->state & CLIENT_CARDBUS)
1190 return CS_SUCCESS;
1191 #endif
1192
1193 if (!(handle->state & CLIENT_STALE)) {
1194 config_t *c = CONFIG(handle);
1195 if (--(s->lock_count) == 0) {
1196 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
1197 s->socket.Vpp = 0;
1198 s->socket.io_irq = 0;
1199 s->ops->set_socket(s, &s->socket);
1200 }
1201 if (c->state & CONFIG_IO_REQ)
1202 for (i = 0; i < MAX_IO_WIN; i++) {
1203 if (s->io[i].NumPorts == 0)
1204 continue;
1205 s->io[i].Config--;
1206 if (s->io[i].Config != 0)
1207 continue;
1208 io.map = i;
1209 s->ops->set_io_map(s, &io);
1210 }
1211 c->state &= ~CONFIG_LOCKED;
1212 }
1213
1214 return CS_SUCCESS;
1215 } /* release_configuration */
1216
1217 /*======================================================================
1218
1219 Release_io() releases the I/O ranges allocated by a client. This
1220 may be invoked some time after a card ejection has already dumped
1221 the actual socket configuration, so if the client is "stale", we
1222 don't bother checking the port ranges against the current socket
1223 values.
1224
1225 ======================================================================*/
1226
1227 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1228 {
1229 struct pcmcia_socket *s;
1230
1231 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1232 return CS_BAD_HANDLE;
1233 handle->state &= ~CLIENT_IO_REQ;
1234 s = SOCKET(handle);
1235
1236 #ifdef CONFIG_CARDBUS
1237 if (handle->state & CLIENT_CARDBUS)
1238 return CS_SUCCESS;
1239 #endif
1240
1241 if (!(handle->state & CLIENT_STALE)) {
1242 config_t *c = CONFIG(handle);
1243 if (c->state & CONFIG_LOCKED)
1244 return CS_CONFIGURATION_LOCKED;
1245 if ((c->io.BasePort1 != req->BasePort1) ||
1246 (c->io.NumPorts1 != req->NumPorts1) ||
1247 (c->io.BasePort2 != req->BasePort2) ||
1248 (c->io.NumPorts2 != req->NumPorts2))
1249 return CS_BAD_ARGS;
1250 c->state &= ~CONFIG_IO_REQ;
1251 }
1252
1253 release_io_space(s, req->BasePort1, req->NumPorts1);
1254 if (req->NumPorts2)
1255 release_io_space(s, req->BasePort2, req->NumPorts2);
1256
1257 return CS_SUCCESS;
1258 } /* release_io */
1259
1260 /*====================================================================*/
1261
1262 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1263 {
1264 struct pcmcia_socket *s;
1265 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1266 return CS_BAD_HANDLE;
1267 handle->state &= ~CLIENT_IRQ_REQ;
1268 s = SOCKET(handle);
1269
1270 if (!(handle->state & CLIENT_STALE)) {
1271 config_t *c = CONFIG(handle);
1272 if (c->state & CONFIG_LOCKED)
1273 return CS_CONFIGURATION_LOCKED;
1274 if (c->irq.Attributes != req->Attributes)
1275 return CS_BAD_ATTRIBUTE;
1276 if (s->irq.AssignedIRQ != req->AssignedIRQ)
1277 return CS_BAD_IRQ;
1278 if (--s->irq.Config == 0) {
1279 c->state &= ~CONFIG_IRQ_REQ;
1280 s->irq.AssignedIRQ = 0;
1281 }
1282 }
1283
1284 if (req->Attributes & IRQ_HANDLE_PRESENT) {
1285 free_irq(req->AssignedIRQ, req->Instance);
1286 }
1287
1288 #ifdef CONFIG_PCMCIA_PROBE
1289 pcmcia_used_irq[req->AssignedIRQ]--;
1290 #endif
1291
1292 return CS_SUCCESS;
1293 } /* cs_release_irq */
1294
1295 /*====================================================================*/
1296
1297 int pcmcia_release_window(window_handle_t win)
1298 {
1299 struct pcmcia_socket *s;
1300
1301 if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1302 return CS_BAD_HANDLE;
1303 s = win->sock;
1304 if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1305 return CS_BAD_HANDLE;
1306
1307 /* Shut down memory window */
1308 win->ctl.flags &= ~MAP_ACTIVE;
1309 s->ops->set_mem_map(s, &win->ctl);
1310 s->state &= ~SOCKET_WIN_REQ(win->index);
1311
1312 /* Release system memory */
1313 if (win->ctl.res) {
1314 release_resource(win->ctl.res);
1315 kfree(win->ctl.res);
1316 win->ctl.res = NULL;
1317 }
1318 win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1319
1320 win->magic = 0;
1321
1322 return CS_SUCCESS;
1323 } /* release_window */
1324
1325 /*====================================================================*/
1326
1327 int pcmcia_request_configuration(client_handle_t handle,
1328 config_req_t *req)
1329 {
1330 int i;
1331 u_int base;
1332 struct pcmcia_socket *s;
1333 config_t *c;
1334 pccard_io_map iomap;
1335
1336 if (CHECK_HANDLE(handle))
1337 return CS_BAD_HANDLE;
1338 s = SOCKET(handle);
1339 if (!(s->state & SOCKET_PRESENT))
1340 return CS_NO_CARD;
1341
1342 #ifdef CONFIG_CARDBUS
1343 if (handle->state & CLIENT_CARDBUS)
1344 return CS_UNSUPPORTED_MODE;
1345 #endif
1346
1347 if (req->IntType & INT_CARDBUS)
1348 return CS_UNSUPPORTED_MODE;
1349 c = CONFIG(handle);
1350 if (c->state & CONFIG_LOCKED)
1351 return CS_CONFIGURATION_LOCKED;
1352
1353 /* Do power control. We don't allow changes in Vcc. */
1354 if (s->socket.Vcc != req->Vcc)
1355 return CS_BAD_VCC;
1356 if (req->Vpp1 != req->Vpp2)
1357 return CS_BAD_VPP;
1358 s->socket.Vpp = req->Vpp1;
1359 if (s->ops->set_socket(s, &s->socket))
1360 return CS_BAD_VPP;
1361
1362 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1363
1364 /* Pick memory or I/O card, DMA mode, interrupt */
1365 c->IntType = req->IntType;
1366 c->Attributes = req->Attributes;
1367 if (req->IntType & INT_MEMORY_AND_IO)
1368 s->socket.flags |= SS_IOCARD;
1369 if (req->IntType & INT_ZOOMED_VIDEO)
1370 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1371 if (req->Attributes & CONF_ENABLE_DMA)
1372 s->socket.flags |= SS_DMA_MODE;
1373 if (req->Attributes & CONF_ENABLE_SPKR)
1374 s->socket.flags |= SS_SPKR_ENA;
1375 if (req->Attributes & CONF_ENABLE_IRQ)
1376 s->socket.io_irq = s->irq.AssignedIRQ;
1377 else
1378 s->socket.io_irq = 0;
1379 s->ops->set_socket(s, &s->socket);
1380 s->lock_count++;
1381
1382 /* Set up CIS configuration registers */
1383 base = c->ConfigBase = req->ConfigBase;
1384 c->Present = c->CardValues = req->Present;
1385 if (req->Present & PRESENT_COPY) {
1386 c->Copy = req->Copy;
1387 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1388 }
1389 if (req->Present & PRESENT_OPTION) {
1390 if (s->functions == 1) {
1391 c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1392 } else {
1393 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1394 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1395 if (req->Present & PRESENT_IOBASE_0)
1396 c->Option |= COR_ADDR_DECODE;
1397 }
1398 if (c->state & CONFIG_IRQ_REQ)
1399 if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1400 c->Option |= COR_LEVEL_REQ;
1401 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1402 mdelay(40);
1403 }
1404 if (req->Present & PRESENT_STATUS) {
1405 c->Status = req->Status;
1406 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1407 }
1408 if (req->Present & PRESENT_PIN_REPLACE) {
1409 c->Pin = req->Pin;
1410 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1411 }
1412 if (req->Present & PRESENT_EXT_STATUS) {
1413 c->ExtStatus = req->ExtStatus;
1414 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1415 }
1416 if (req->Present & PRESENT_IOBASE_0) {
1417 u_char b = c->io.BasePort1 & 0xff;
1418 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1419 b = (c->io.BasePort1 >> 8) & 0xff;
1420 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1421 }
1422 if (req->Present & PRESENT_IOSIZE) {
1423 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1424 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1425 }
1426
1427 /* Configure I/O windows */
1428 if (c->state & CONFIG_IO_REQ) {
1429 iomap.speed = io_speed;
1430 for (i = 0; i < MAX_IO_WIN; i++)
1431 if (s->io[i].NumPorts != 0) {
1432 iomap.map = i;
1433 iomap.flags = MAP_ACTIVE;
1434 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1435 case IO_DATA_PATH_WIDTH_16:
1436 iomap.flags |= MAP_16BIT; break;
1437 case IO_DATA_PATH_WIDTH_AUTO:
1438 iomap.flags |= MAP_AUTOSZ; break;
1439 default:
1440 break;
1441 }
1442 iomap.start = s->io[i].BasePort;
1443 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1444 s->ops->set_io_map(s, &iomap);
1445 s->io[i].Config++;
1446 }
1447 }
1448
1449 c->state |= CONFIG_LOCKED;
1450 handle->state |= CLIENT_CONFIG_LOCKED;
1451 return CS_SUCCESS;
1452 } /* request_configuration */
1453
1454 /*======================================================================
1455
1456 Request_io() reserves ranges of port addresses for a socket.
1457 I have not implemented range sharing or alias addressing.
1458
1459 ======================================================================*/
1460
1461 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1462 {
1463 struct pcmcia_socket *s;
1464 config_t *c;
1465
1466 if (CHECK_HANDLE(handle))
1467 return CS_BAD_HANDLE;
1468 s = SOCKET(handle);
1469 if (!(s->state & SOCKET_PRESENT))
1470 return CS_NO_CARD;
1471
1472 if (handle->state & CLIENT_CARDBUS) {
1473 #ifdef CONFIG_CARDBUS
1474 handle->state |= CLIENT_IO_REQ;
1475 return CS_SUCCESS;
1476 #else
1477 return CS_UNSUPPORTED_FUNCTION;
1478 #endif
1479 }
1480
1481 if (!req)
1482 return CS_UNSUPPORTED_MODE;
1483 c = CONFIG(handle);
1484 if (c->state & CONFIG_LOCKED)
1485 return CS_CONFIGURATION_LOCKED;
1486 if (c->state & CONFIG_IO_REQ)
1487 return CS_IN_USE;
1488 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1489 return CS_BAD_ATTRIBUTE;
1490 if ((req->NumPorts2 > 0) &&
1491 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1492 return CS_BAD_ATTRIBUTE;
1493
1494 if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1495 req->NumPorts1, req->IOAddrLines))
1496 return CS_IN_USE;
1497
1498 if (req->NumPorts2) {
1499 if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1500 req->NumPorts2, req->IOAddrLines)) {
1501 release_io_space(s, req->BasePort1, req->NumPorts1);
1502 return CS_IN_USE;
1503 }
1504 }
1505
1506 c->io = *req;
1507 c->state |= CONFIG_IO_REQ;
1508 handle->state |= CLIENT_IO_REQ;
1509 return CS_SUCCESS;
1510 } /* request_io */
1511
1512 /*======================================================================
1513
1514 Request_irq() reserves an irq for this client.
1515
1516 Also, since Linux only reserves irq's when they are actually
1517 hooked, we don't guarantee that an irq will still be available
1518 when the configuration is locked. Now that I think about it,
1519 there might be a way to fix this using a dummy handler.
1520
1521 ======================================================================*/
1522
1523 #ifdef CONFIG_PCMCIA_PROBE
1524 static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs)
1525 {
1526 return IRQ_NONE;
1527 }
1528 #endif
1529
1530 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1531 {
1532 struct pcmcia_socket *s;
1533 config_t *c;
1534 int ret = CS_IN_USE, irq = 0;
1535 struct pcmcia_device *p_dev = handle_to_pdev(handle);
1536
1537 if (CHECK_HANDLE(handle))
1538 return CS_BAD_HANDLE;
1539 s = SOCKET(handle);
1540 if (!(s->state & SOCKET_PRESENT))
1541 return CS_NO_CARD;
1542 c = CONFIG(handle);
1543 if (c->state & CONFIG_LOCKED)
1544 return CS_CONFIGURATION_LOCKED;
1545 if (c->state & CONFIG_IRQ_REQ)
1546 return CS_IN_USE;
1547
1548 #ifdef CONFIG_PCMCIA_PROBE
1549 if (s->irq.AssignedIRQ != 0) {
1550 /* If the interrupt is already assigned, it must be the same */
1551 irq = s->irq.AssignedIRQ;
1552 } else {
1553 int try;
1554 u32 mask = s->irq_mask;
1555 void *data = NULL;
1556
1557 for (try = 0; try < 64; try++) {
1558 irq = try % 32;
1559
1560 /* marked as available by driver, and not blocked by userspace? */
1561 if (!((mask >> irq) & 1))
1562 continue;
1563
1564 /* avoid an IRQ which is already used by a PCMCIA card */
1565 if ((try < 32) && pcmcia_used_irq[irq])
1566 continue;
1567
1568 /* register the correct driver, if possible, of check whether
1569 * registering a dummy handle works, i.e. if the IRQ isn't
1570 * marked as used by the kernel resource management core */
1571 ret = request_irq(irq,
1572 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action,
1573 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1574 (s->functions > 1) ||
1575 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1576 p_dev->dev.bus_id,
1577 (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
1578 if (!ret) {
1579 if (!(req->Attributes & IRQ_HANDLE_PRESENT))
1580 free_irq(irq, data);
1581 break;
1582 }
1583 }
1584 }
1585 #endif
1586 if (ret) {
1587 if (!s->pci_irq)
1588 return ret;
1589 irq = s->pci_irq;
1590 }
1591
1592 if (ret && req->Attributes & IRQ_HANDLE_PRESENT) {
1593 if (request_irq(irq, req->Handler,
1594 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1595 (s->functions > 1) ||
1596 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1597 p_dev->dev.bus_id, req->Instance))
1598 return CS_IN_USE;
1599 }
1600
1601 c->irq.Attributes = req->Attributes;
1602 s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1603 s->irq.Config++;
1604
1605 c->state |= CONFIG_IRQ_REQ;
1606 handle->state |= CLIENT_IRQ_REQ;
1607
1608 #ifdef CONFIG_PCMCIA_PROBE
1609 pcmcia_used_irq[irq]++;
1610 #endif
1611
1612 return CS_SUCCESS;
1613 } /* pcmcia_request_irq */
1614
1615 /*======================================================================
1616
1617 Request_window() establishes a mapping between card memory space
1618 and system memory space.
1619
1620 ======================================================================*/
1621
1622 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1623 {
1624 struct pcmcia_socket *s;
1625 window_t *win;
1626 u_long align;
1627 int w;
1628
1629 if (CHECK_HANDLE(*handle))
1630 return CS_BAD_HANDLE;
1631 s = (*handle)->Socket;
1632 if (!(s->state & SOCKET_PRESENT))
1633 return CS_NO_CARD;
1634 if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1635 return CS_BAD_ATTRIBUTE;
1636
1637 /* Window size defaults to smallest available */
1638 if (req->Size == 0)
1639 req->Size = s->map_size;
1640 align = (((s->features & SS_CAP_MEM_ALIGN) ||
1641 (req->Attributes & WIN_STRICT_ALIGN)) ?
1642 req->Size : s->map_size);
1643 if (req->Size & (s->map_size-1))
1644 return CS_BAD_SIZE;
1645 if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1646 (req->Base & (align-1)))
1647 return CS_BAD_BASE;
1648 if (req->Base)
1649 align = 0;
1650
1651 /* Allocate system memory window */
1652 for (w = 0; w < MAX_WIN; w++)
1653 if (!(s->state & SOCKET_WIN_REQ(w))) break;
1654 if (w == MAX_WIN)
1655 return CS_OUT_OF_RESOURCE;
1656
1657 win = &s->win[w];
1658 win->magic = WINDOW_MAGIC;
1659 win->index = w;
1660 win->handle = *handle;
1661 win->sock = s;
1662
1663 if (!(s->features & SS_CAP_STATIC_MAP)) {
1664 win->ctl.res = find_mem_region(req->Base, req->Size, align,
1665 (req->Attributes & WIN_MAP_BELOW_1MB), s);
1666 if (!win->ctl.res)
1667 return CS_IN_USE;
1668 }
1669 (*handle)->state |= CLIENT_WIN_REQ(w);
1670
1671 /* Configure the socket controller */
1672 win->ctl.map = w+1;
1673 win->ctl.flags = 0;
1674 win->ctl.speed = req->AccessSpeed;
1675 if (req->Attributes & WIN_MEMORY_TYPE)
1676 win->ctl.flags |= MAP_ATTRIB;
1677 if (req->Attributes & WIN_ENABLE)
1678 win->ctl.flags |= MAP_ACTIVE;
1679 if (req->Attributes & WIN_DATA_WIDTH_16)
1680 win->ctl.flags |= MAP_16BIT;
1681 if (req->Attributes & WIN_USE_WAIT)
1682 win->ctl.flags |= MAP_USE_WAIT;
1683 win->ctl.card_start = 0;
1684 if (s->ops->set_mem_map(s, &win->ctl) != 0)
1685 return CS_BAD_ARGS;
1686 s->state |= SOCKET_WIN_REQ(w);
1687
1688 /* Return window handle */
1689 if (s->features & SS_CAP_STATIC_MAP) {
1690 req->Base = win->ctl.static_start;
1691 } else {
1692 req->Base = win->ctl.res->start;
1693 }
1694 *wh = win;
1695
1696 return CS_SUCCESS;
1697 } /* request_window */
1698
1699 /*======================================================================
1700
1701 I'm not sure which "reset" function this is supposed to use,
1702 but for now, it uses the low-level interface's reset, not the
1703 CIS register.
1704
1705 ======================================================================*/
1706
1707 int pccard_reset_card(struct pcmcia_socket *skt)
1708 {
1709 int ret;
1710
1711 cs_dbg(skt, 1, "resetting socket\n");
1712
1713 down(&skt->skt_sem);
1714 do {
1715 if (!(skt->state & SOCKET_PRESENT)) {
1716 ret = CS_NO_CARD;
1717 break;
1718 }
1719 if (skt->state & SOCKET_SUSPEND) {
1720 ret = CS_IN_USE;
1721 break;
1722 }
1723 if (skt->state & SOCKET_CARDBUS) {
1724 ret = CS_UNSUPPORTED_FUNCTION;
1725 break;
1726 }
1727
1728 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1729 if (ret == 0) {
1730 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1731 if (socket_reset(skt) == CS_SUCCESS)
1732 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1733 }
1734
1735 ret = CS_SUCCESS;
1736 } while (0);
1737 up(&skt->skt_sem);
1738
1739 return ret;
1740 } /* reset_card */
1741 EXPORT_SYMBOL(pccard_reset_card);
1742
1743 /*======================================================================
1744
1745 These shut down or wake up a socket. They are sort of user
1746 initiated versions of the APM suspend and resume actions.
1747
1748 ======================================================================*/
1749
1750 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1751 {
1752 int ret;
1753
1754 cs_dbg(skt, 1, "suspending socket\n");
1755
1756 down(&skt->skt_sem);
1757 do {
1758 if (!(skt->state & SOCKET_PRESENT)) {
1759 ret = CS_NO_CARD;
1760 break;
1761 }
1762 if (skt->state & SOCKET_CARDBUS) {
1763 ret = CS_UNSUPPORTED_FUNCTION;
1764 break;
1765 }
1766 ret = socket_suspend(skt);
1767 } while (0);
1768 up(&skt->skt_sem);
1769
1770 return ret;
1771 } /* suspend_card */
1772
1773 int pcmcia_resume_card(struct pcmcia_socket *skt)
1774 {
1775 int ret;
1776
1777 cs_dbg(skt, 1, "waking up socket\n");
1778
1779 down(&skt->skt_sem);
1780 do {
1781 if (!(skt->state & SOCKET_PRESENT)) {
1782 ret = CS_NO_CARD;
1783 break;
1784 }
1785 if (skt->state & SOCKET_CARDBUS) {
1786 ret = CS_UNSUPPORTED_FUNCTION;
1787 break;
1788 }
1789 ret = socket_resume(skt);
1790 } while (0);
1791 up(&skt->skt_sem);
1792
1793 return ret;
1794 } /* resume_card */
1795
1796 /*======================================================================
1797
1798 These handle user requests to eject or insert a card.
1799
1800 ======================================================================*/
1801
1802 int pcmcia_eject_card(struct pcmcia_socket *skt)
1803 {
1804 int ret;
1805
1806 cs_dbg(skt, 1, "user eject request\n");
1807
1808 down(&skt->skt_sem);
1809 do {
1810 if (!(skt->state & SOCKET_PRESENT)) {
1811 ret = -ENODEV;
1812 break;
1813 }
1814
1815 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
1816 if (ret != 0) {
1817 ret = -EINVAL;
1818 break;
1819 }
1820
1821 socket_remove(skt);
1822 ret = 0;
1823 } while (0);
1824 up(&skt->skt_sem);
1825
1826 return ret;
1827 } /* eject_card */
1828
1829 int pcmcia_insert_card(struct pcmcia_socket *skt)
1830 {
1831 int ret;
1832
1833 cs_dbg(skt, 1, "user insert request\n");
1834
1835 down(&skt->skt_sem);
1836 do {
1837 if (skt->state & SOCKET_PRESENT) {
1838 ret = -EBUSY;
1839 break;
1840 }
1841 if (socket_insert(skt) == CS_NO_CARD) {
1842 ret = -ENODEV;
1843 break;
1844 }
1845 ret = 0;
1846 } while (0);
1847 up(&skt->skt_sem);
1848
1849 return ret;
1850 } /* insert_card */
1851
1852 /*======================================================================
1853
1854 OS-specific module glue goes here
1855
1856 ======================================================================*/
1857 /* in alpha order */
1858 EXPORT_SYMBOL(pcmcia_eject_card);
1859 EXPORT_SYMBOL(pcmcia_get_card_services_info);
1860 EXPORT_SYMBOL(pcmcia_get_mem_page);
1861 EXPORT_SYMBOL(pcmcia_insert_card);
1862 EXPORT_SYMBOL(pcmcia_map_mem_page);
1863 EXPORT_SYMBOL(pcmcia_modify_configuration);
1864 EXPORT_SYMBOL(pcmcia_release_configuration);
1865 EXPORT_SYMBOL(pcmcia_release_io);
1866 EXPORT_SYMBOL(pcmcia_release_irq);
1867 EXPORT_SYMBOL(pcmcia_release_window);
1868 EXPORT_SYMBOL(pcmcia_replace_cis);
1869 EXPORT_SYMBOL(pcmcia_request_configuration);
1870 EXPORT_SYMBOL(pcmcia_request_io);
1871 EXPORT_SYMBOL(pcmcia_request_irq);
1872 EXPORT_SYMBOL(pcmcia_request_window);
1873 EXPORT_SYMBOL(pcmcia_resume_card);
1874 EXPORT_SYMBOL(pcmcia_suspend_card);
1875
1876 EXPORT_SYMBOL(dead_socket);
1877 EXPORT_SYMBOL(pcmcia_parse_events);
1878
1879 struct class pcmcia_socket_class = {
1880 .name = "pcmcia_socket",
1881 .release = pcmcia_release_socket,
1882 };
1883 EXPORT_SYMBOL(pcmcia_socket_class);
1884
1885
1886 static int __init init_pcmcia_cs(void)
1887 {
1888 int ret;
1889 printk(KERN_INFO "%s\n", release);
1890 printk(KERN_INFO " %s\n", options);
1891
1892 ret = class_register(&pcmcia_socket_class);
1893 if (ret)
1894 return (ret);
1895 return class_interface_register(&pccard_sysfs_interface);
1896 }
1897
1898 static void __exit exit_pcmcia_cs(void)
1899 {
1900 printk(KERN_INFO "unloading Kernel Card Services\n");
1901 class_interface_unregister(&pccard_sysfs_interface);
1902 class_unregister(&pcmcia_socket_class);
1903 }
1904
1905 subsys_initcall(init_pcmcia_cs);
1906 module_exit(exit_pcmcia_cs);
1907
1908 /*====================================================================*/
1909
1910
|
This page was automatically generated by the
LXR engine.
|