![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules|
Return to cs.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules |
1.1 root 1: /*======================================================================
2:
3: PCMCIA Card Services -- core services
4:
5: cs.c 1.287 2004/04/09 03:54:25
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: <[email protected]>. 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
23: which 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/init.h>
36: #include <linux/kernel.h>
37: #include <linux/config.h>
38: #include <linux/string.h>
39: #include <linux/major.h>
40: #include <linux/errno.h>
41: #include <linux/slab.h>
42: #include <linux/mm.h>
43: #include <linux/sched.h>
44: #include <linux/timer.h>
45: #include <linux/ioport.h>
46: #include <linux/delay.h>
47: #include <linux/proc_fs.h>
48: #include <linux/pm.h>
49: #include <linux/pci.h>
50: #include <linux/spinlock.h>
51: #include <asm/system.h>
52: #include <asm/irq.h>
53:
54: #define IN_CARD_SERVICES
55: #include <pcmcia/version.h>
56: #include <pcmcia/cs_types.h>
57: #include <pcmcia/ss.h>
58: #include <pcmcia/cs.h>
59: #include <pcmcia/bulkmem.h>
60: #include <pcmcia/cistpl.h>
61: #include <pcmcia/cisreg.h>
62: #include <pcmcia/bus_ops.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 " [apm]"
77: #else
78: #define PM_OPT ""
79: #endif
80: #ifdef CONFIG_PNP_BIOS
81: #define PNP_OPT " [pnp]"
82: #else
83: #define PNP_OPT ""
84: #endif
85: #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && \
86: !defined(CONFIG_PM) && !defined(CONFIG_PNP_BIOS)
87: #define OPTIONS " none"
88: #else
89: #define OPTIONS PCI_OPT CB_OPT PM_OPT PNP_OPT
90: #endif
91:
92: static const char *release = "Linux PCMCIA Card Services " CS_RELEASE;
93: #ifdef UTS_RELEASE
94: static const char *kernel = "kernel build: " UTS_RELEASE " " UTS_VERSION;
95: #endif
96: static const char *options = "options: " OPTIONS;
97:
98: /*====================================================================*/
99:
100: /* Module parameters */
101:
102: MODULE_AUTHOR("David Hinds <[email protected]>");
103: MODULE_DESCRIPTION("Linux PCMCIA Card Services " CS_RELEASE
104: "\n options:" OPTIONS);
105: MODULE_LICENSE("Dual MPL/GPL");
106:
107: #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
108:
109: INT_MODULE_PARM(setup_delay, HZ/20); /* ticks */
110: INT_MODULE_PARM(resume_delay, HZ/5); /* ticks */
111: INT_MODULE_PARM(shutdown_delay, HZ/40); /* ticks */
112: INT_MODULE_PARM(vcc_settle, HZ*4/10); /* ticks */
113: INT_MODULE_PARM(reset_time, 10); /* usecs */
114: INT_MODULE_PARM(unreset_delay, HZ/10); /* ticks */
115: INT_MODULE_PARM(unreset_check, HZ/10); /* ticks */
116: INT_MODULE_PARM(unreset_limit, 50); /* unreset_check's */
117:
118: /* Access speed for attribute memory windows */
119: INT_MODULE_PARM(cis_speed, 300); /* ns */
120:
121: /* Access speed for IO windows */
122: INT_MODULE_PARM(io_speed, 0); /* ns */
123:
124: /* Optional features */
125: #ifdef CONFIG_PM
126: INT_MODULE_PARM(do_apm, 1);
127: #endif
128: #ifdef CONFIG_PNP_BIOS
129: INT_MODULE_PARM(do_pnp, 1);
130: #endif
131:
132: #ifdef PCMCIA_DEBUG
133: int pc_debug=PCMCIA_DEBUG;
134: MODULE_PARM(pc_debug, "i");
135: static const char *version =
136: "cs.c 1.287 2004/04/09 03:54:25 (David Hinds)";
137: #endif
138:
139: /*====================================================================*/
140:
141: static socket_state_t dead_socket = {
142: 0, SS_DETECT, 0, 0, 0
143: };
144:
145: /* Table of sockets */
146: socket_t sockets = 0;
147: socket_info_t *socket_table[MAX_SOCK];
148:
149: #ifdef HAS_PROC_BUS
150: struct proc_dir_entry *proc_pccard = NULL;
151: #endif
152:
153: /*====================================================================*/
154:
155: /* String tables for error messages */
156:
157: typedef struct lookup_t {
158: int key;
159: char *msg;
160: } lookup_t;
161:
162: static const lookup_t error_table[] = {
163: { CS_SUCCESS, "Operation succeeded" },
164: { CS_BAD_ADAPTER, "Bad adapter" },
165: { CS_BAD_ATTRIBUTE, "Bad attribute", },
166: { CS_BAD_BASE, "Bad base address" },
167: { CS_BAD_EDC, "Bad EDC" },
168: { CS_BAD_IRQ, "Bad IRQ" },
169: { CS_BAD_OFFSET, "Bad offset" },
170: { CS_BAD_PAGE, "Bad page number" },
171: { CS_READ_FAILURE, "Read failure" },
172: { CS_BAD_SIZE, "Bad size" },
173: { CS_BAD_SOCKET, "Bad socket" },
174: { CS_BAD_TYPE, "Bad type" },
175: { CS_BAD_VCC, "Bad Vcc" },
176: { CS_BAD_VPP, "Bad Vpp" },
177: { CS_BAD_WINDOW, "Bad window" },
178: { CS_WRITE_FAILURE, "Write failure" },
179: { CS_NO_CARD, "No card present" },
180: { CS_UNSUPPORTED_FUNCTION, "Usupported function" },
181: { CS_UNSUPPORTED_MODE, "Unsupported mode" },
182: { CS_BAD_SPEED, "Bad speed" },
183: { CS_BUSY, "Resource busy" },
184: { CS_GENERAL_FAILURE, "General failure" },
185: { CS_WRITE_PROTECTED, "Write protected" },
186: { CS_BAD_ARG_LENGTH, "Bad argument length" },
187: { CS_BAD_ARGS, "Bad arguments" },
188: { CS_CONFIGURATION_LOCKED, "Configuration locked" },
189: { CS_IN_USE, "Resource in use" },
190: { CS_NO_MORE_ITEMS, "No more items" },
191: { CS_OUT_OF_RESOURCE, "Out of resource" },
192: { CS_BAD_HANDLE, "Bad handle" },
193: { CS_BAD_TUPLE, "Bad CIS tuple" }
194: };
195: #define ERROR_COUNT (sizeof(error_table)/sizeof(lookup_t))
196:
197: static const lookup_t service_table[] = {
198: { AccessConfigurationRegister, "AccessConfigurationRegister" },
199: { AddSocketServices, "AddSocketServices" },
200: { AdjustResourceInfo, "AdjustResourceInfo" },
201: { CheckEraseQueue, "CheckEraseQueue" },
202: { CloseMemory, "CloseMemory" },
203: { DeregisterClient, "DeregisterClient" },
204: { DeregisterEraseQueue, "DeregisterEraseQueue" },
205: { GetCardServicesInfo, "GetCardServicesInfo" },
206: { GetClientInfo, "GetClientInfo" },
207: { GetConfigurationInfo, "GetConfigurationInfo" },
208: { GetEventMask, "GetEventMask" },
209: { GetFirstClient, "GetFirstClient" },
210: { GetFirstRegion, "GetFirstRegion" },
211: { GetFirstTuple, "GetFirstTuple" },
212: { GetNextClient, "GetNextClient" },
213: { GetNextRegion, "GetNextRegion" },
214: { GetNextTuple, "GetNextTuple" },
215: { GetStatus, "GetStatus" },
216: { GetTupleData, "GetTupleData" },
217: { MapMemPage, "MapMemPage" },
218: { ModifyConfiguration, "ModifyConfiguration" },
219: { ModifyWindow, "ModifyWindow" },
220: { OpenMemory, "OpenMemory" },
221: { ParseTuple, "ParseTuple" },
222: { ReadMemory, "ReadMemory" },
223: { RegisterClient, "RegisterClient" },
224: { RegisterEraseQueue, "RegisterEraseQueue" },
225: { RegisterMTD, "RegisterMTD" },
226: { ReleaseConfiguration, "ReleaseConfiguration" },
227: { ReleaseIO, "ReleaseIO" },
228: { ReleaseIRQ, "ReleaseIRQ" },
229: { ReleaseWindow, "ReleaseWindow" },
230: { RequestConfiguration, "RequestConfiguration" },
231: { RequestIO, "RequestIO" },
232: { RequestIRQ, "RequestIRQ" },
233: { RequestSocketMask, "RequestSocketMask" },
234: { RequestWindow, "RequestWindow" },
235: { ResetCard, "ResetCard" },
236: { SetEventMask, "SetEventMask" },
237: { ValidateCIS, "ValidateCIS" },
238: { WriteMemory, "WriteMemory" },
239: { BindDevice, "BindDevice" },
240: { BindMTD, "BindMTD" },
241: { ReportError, "ReportError" },
242: { SuspendCard, "SuspendCard" },
243: { ResumeCard, "ResumeCard" },
244: { EjectCard, "EjectCard" },
245: { InsertCard, "InsertCard" },
246: { ReplaceCIS, "ReplaceCIS" }
247: };
248: #define SERVICE_COUNT (sizeof(service_table)/sizeof(lookup_t))
249:
250: /*======================================================================
251:
252: Reset a socket to the default state
253:
254: ======================================================================*/
255:
256: static void init_socket(socket_info_t *s)
257: {
258: int i;
259: pccard_io_map io = { 0, 0, 0, 0, 1 };
260: pccard_mem_map mem = { 0, 0, 0, 0, 0, 0 };
261:
262: mem.sys_stop = s->cap.map_size;
263: s->socket = dead_socket;
264: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
265: for (i = 0; i < 2; i++) {
266: io.map = i;
267: s->ss_entry(s->sock, SS_SetIOMap, &io);
268: }
269: for (i = 0; i < 5; i++) {
270: mem.map = i;
271: s->ss_entry(s->sock, SS_SetMemMap, &mem);
272: }
273: }
274:
275: /*====================================================================*/
276:
277: #if defined(HAS_PROC_BUS) && defined(PCMCIA_DEBUG)
278: static int proc_read_clients(char *buf, char **start, off_t pos,
279: int count, int *eof, void *data)
280: {
281: socket_info_t *s = data;
282: client_handle_t c;
283: char *p = buf;
284:
285: for (c = s->clients; c; c = c->next)
286: p += sprintf(p, "fn %x: '%s' [attr 0x%04x] [state 0x%04x]\n",
287: c->Function, c->dev_info, c->Attributes, c->state);
288: return (p - buf);
289: }
290: #endif
291:
292: /*======================================================================
293:
294: Low-level PC Card interface drivers need to register with Card
295: Services using these calls.
296:
297: ======================================================================*/
298:
299: static void setup_socket(u_long i);
300: static void shutdown_socket(u_long i);
301: static void reset_socket(u_long i);
302: static void unreset_socket(u_long i);
303: static void parse_events(void *info, u_int events);
304:
305: int register_ss_entry(int nsock, ss_entry_t ss_entry)
306: {
307: int i, ns;
308: socket_info_t *s;
309:
310: DEBUG(0, "cs: register_ss_entry(%d, 0x%p)\n", nsock, ss_entry);
311:
312: for (ns = 0; ns < nsock; ns++) {
313: s = kmalloc(sizeof(struct socket_info_t), GFP_KERNEL);
314: if (!s) {
315: printk(KERN_NOTICE "cs: memory allocation failure!\n");
316: return (!ns);
317: }
318: memset(s, 0, sizeof(socket_info_t));
319:
320: s->ss_entry = ss_entry;
321: s->sock = ns;
322: s->setup.data = sockets;
323: s->setup.function = &setup_socket;
324: s->shutdown.data = sockets;
325: s->shutdown.function = &shutdown_socket;
326: /* base address = 0, map = 0 */
327: s->cis_mem.flags = 0;
328: s->cis_mem.speed = cis_speed;
329: s->erase_busy.next = s->erase_busy.prev = &s->erase_busy;
330: spin_lock_init(&s->lock);
331:
332: for (i = 0; i < sockets; i++)
333: if (socket_table[i] == NULL) break;
334: socket_table[i] = s;
335: if (i == sockets) sockets++;
336:
337: init_socket(s);
338: ss_entry(ns, SS_InquireSocket, &s->cap);
339: #ifdef HAS_PROC_BUS
340: if (proc_pccard) {
341: char name[3];
342: sprintf(name, "%02d", i);
343: s->proc = proc_mkdir(name, proc_pccard);
344: if (s->proc)
345: ss_entry(ns, SS_ProcSetup, s->proc);
346: #ifdef PCMCIA_DEBUG
347: if (s->proc)
348: create_proc_read_entry("clients", 0, s->proc,
349: proc_read_clients, s);
350: #endif
351: }
352: #endif
353: }
354:
355: return 0;
356: } /* register_ss_entry */
357:
358: /*====================================================================*/
359:
360: void unregister_ss_entry(ss_entry_t ss_entry)
361: {
362: int i, j;
363: socket_info_t *s = NULL;
364: client_t *client;
365:
366: #ifdef HAS_PROC_BUS
367: for (i = 0; i < sockets; i++) {
368: s = socket_table[i];
369: if (s->ss_entry != ss_entry) continue;
370: if (proc_pccard) {
371: char name[3];
372: sprintf(name, "%02d", i);
373: #ifdef PCMCIA_DEBUG
374: remove_proc_entry("clients", s->proc);
375: #endif
376: remove_proc_entry(name, proc_pccard);
377: }
378: }
379: #endif
380:
381: for (;;) {
382: for (i = 0; i < sockets; i++) {
383: s = socket_table[i];
384: if (s->ss_entry == ss_entry) break;
385: }
386: if (i == sockets)
387: break;
388: shutdown_socket(i);
389: release_cis_mem(s);
390: while (s->clients) {
391: client = s->clients;
392: s->clients = s->clients->next;
393: kfree(client);
394: }
395: s->ss_entry = NULL;
396: kfree(s);
397: socket_table[i] = NULL;
398: for (j = i; j < sockets-1; j++)
399: socket_table[j] = socket_table[j+1];
400: sockets--;
401: }
402:
403: } /* unregister_ss_entry */
404:
405: /*======================================================================
406:
407: Shutdown_Socket() and setup_socket() are scheduled using add_timer
408: calls by the main event handler when card insertion and removal
409: events are received. Shutdown_Socket() unconfigures a socket and
410: turns off socket power. Setup_socket() turns on socket power
411: and resets the socket, in two stages.
412:
413: ======================================================================*/
414:
415: static void free_regions(memory_handle_t *list)
416: {
417: memory_handle_t tmp;
418: while (*list != NULL) {
419: tmp = *list;
420: *list = tmp->info.next;
421: tmp->region_magic = 0;
422: kfree(tmp);
423: }
424: }
425:
426: static int send_event(socket_info_t *s, event_t event, int priority);
427:
428: static void shutdown_socket(u_long i)
429: {
430: socket_info_t *s = socket_table[i];
431: client_t **c;
432:
433: DEBUG(1, "cs: shutdown_socket(%ld)\n", i);
434:
435: /* Blank out the socket state */
436: s->state &= SOCKET_PRESENT|SOCKET_SETUP_PENDING;
437: init_socket(s);
438: s->irq.AssignedIRQ = s->irq.Config = 0;
439: s->lock_count = 0;
440: s->cis_used = 0;
441: if (s->fake_cis) {
442: kfree(s->fake_cis);
443: s->fake_cis = NULL;
444: }
445: #ifdef CONFIG_CARDBUS
446: cb_release_cis_mem(s);
447: cb_free(s);
448: #endif
449: s->functions = 0;
450: if (s->config) {
451: kfree(s->config);
452: s->config = NULL;
453: }
454: for (c = &s->clients; *c; ) {
455: if ((*c)->state & CLIENT_UNBOUND) {
456: client_t *d = *c;
457: *c = (*c)->next;
458: kfree(d);
459: } else {
460: c = &((*c)->next);
461: }
462: }
463: free_regions(&s->a_region);
464: free_regions(&s->c_region);
465: } /* shutdown_socket */
466:
467: static void setup_socket(u_long i)
468: {
469: int val;
470: socket_info_t *s = socket_table[i];
471:
472: s->ss_entry(s->sock, SS_GetStatus, &val);
473: if (val & SS_PENDING) {
474: /* Does the socket need more time? */
475: DEBUG(2, "cs: setup_socket(%ld): status pending\n", i);
476: if (++s->setup_timeout > 100) {
477: printk(KERN_NOTICE "cs: socket %ld voltage interrogation"
478: " timed out\n", i);
479: } else {
480: mod_timer(&s->setup, jiffies + HZ/10);
481: }
482: } else if (val & SS_DETECT) {
483: DEBUG(1, "cs: setup_socket(%ld): applying power\n", i);
484: s->state |= SOCKET_PRESENT;
485: s->socket.flags = 0;
486: if (val & SS_3VCARD)
487: s->socket.Vcc = s->socket.Vpp = 33;
488: else if (!(val & SS_XVCARD))
489: s->socket.Vcc = s->socket.Vpp = 50;
490: else {
491: printk(KERN_NOTICE "cs: socket %ld: unsupported "
492: "voltage key\n", i);
493: s->socket.Vcc = 0;
494: }
495: if (val & SS_CARDBUS) {
496: s->state |= SOCKET_CARDBUS;
497: #ifndef CONFIG_CARDBUS
498: printk(KERN_NOTICE "cs: unsupported card type detected!\n");
499: #endif
500: }
501: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
502: s->setup.function = &reset_socket;
503: mod_timer(&s->setup, jiffies + vcc_settle);
504: } else
505: DEBUG(0, "cs: setup_socket(%ld): no card!\n", i);
506: } /* setup_socket */
507:
508: /*======================================================================
509:
510: Reset_socket() and unreset_socket() handle hard resets. Resets
511: have several causes: card insertion, a call to reset_socket, or
512: recovery from a suspend/resume cycle. Unreset_socket() sends
513: a CS event that matches the cause of the reset.
514:
515: ======================================================================*/
516:
517: static void reset_socket(u_long i)
518: {
519: socket_info_t *s = socket_table[i];
520:
521: DEBUG(1, "cs: resetting socket %ld\n", i);
522: s->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
523: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
524: udelay((long)reset_time);
525: s->socket.flags &= ~SS_RESET;
526: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
527: s->setup_timeout = 0;
528: s->setup.function = &unreset_socket;
529: mod_timer(&s->setup, jiffies + unreset_delay);
530: } /* reset_socket */
531:
532: #define EVENT_MASK \
533: (SOCKET_SETUP_PENDING|SOCKET_SUSPEND|SOCKET_RESET_PENDING)
534:
535: static void unreset_socket(u_long i)
536: {
537: socket_info_t *s = socket_table[i];
538: int val;
539:
540: s->ss_entry(s->sock, SS_GetStatus, &val);
541: if (val & SS_READY) {
542: DEBUG(1, "cs: reset done on socket %ld\n", i);
543: if (s->state & SOCKET_SUSPEND) {
544: s->state &= ~EVENT_MASK;
545: if (verify_cis_cache(s) != 0)
546: parse_events(s, SS_DETECT);
547: else
548: send_event(s, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
549: } else if (s->state & SOCKET_SETUP_PENDING) {
550: #ifdef CONFIG_CARDBUS
551: if (s->state & SOCKET_CARDBUS)
552: cb_alloc(s);
553: #endif
554: send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
555: s->state &= ~SOCKET_SETUP_PENDING;
556: } else {
557: send_event(s, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
558: if (s->reset_handle) {
559: s->reset_handle->event_callback_args.info = NULL;
560: EVENT(s->reset_handle, CS_EVENT_RESET_COMPLETE,
561: CS_EVENT_PRI_LOW);
562: s->state &= ~EVENT_MASK;
563: }
564: }
565: } else {
566: DEBUG(2, "cs: socket %ld not ready yet\n", i);
567: if (++s->setup_timeout > unreset_limit) {
568: printk(KERN_NOTICE "cs: socket %ld timed out during"
569: " reset\n", i);
570: s->state &= ~EVENT_MASK;
571: } else {
572: mod_timer(&s->setup, jiffies + unreset_check);
573: }
574: }
575: } /* unreset_socket */
576:
577: /*======================================================================
578:
579: The central event handler. Send_event() sends an event to all
580: valid clients. Parse_events() interprets the event bits from
581: a card status change report. Do_shotdown() handles the high
582: priority stuff associated with a card removal.
583:
584: ======================================================================*/
585:
586: static int send_event(socket_info_t *s, event_t event, int priority)
587: {
588: client_t *client = s->clients;
589: int ret;
590: DEBUG(1, "cs: send_event(sock %d, event %d, pri %d)\n",
591: s->sock, event, priority);
592: ret = 0;
593: for (; client; client = client->next) {
594: if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
595: continue;
596: if (client->EventMask & event) {
597: ret = EVENT(client, event, priority);
598: if (ret != 0)
599: return ret;
600: }
601: }
602: return ret;
603: } /* send_event */
604:
605: static void do_shutdown(socket_info_t *s)
606: {
607: client_t *client;
608: if (s->state & SOCKET_SHUTDOWN_PENDING)
609: return;
610: s->state |= SOCKET_SHUTDOWN_PENDING;
611: send_event(s, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
612: for (client = s->clients; client; client = client->next)
613: if (!(client->Attributes & INFO_MASTER_CLIENT))
614: client->state |= CLIENT_STALE;
615: if (s->state & (SOCKET_SETUP_PENDING|SOCKET_RESET_PENDING)) {
616: DEBUG(0, "cs: flushing pending setup\n");
617: del_timer(&s->setup);
618: s->state &= ~EVENT_MASK;
619: }
620: mod_timer(&s->shutdown, jiffies + shutdown_delay);
621: s->state &= ~SOCKET_PRESENT;
622: }
623:
624: static void parse_events(void *info, u_int events)
625: {
626: socket_info_t *s = info;
627: if (events & SS_DETECT) {
628: int status;
629: u_long flags;
630: spin_lock_irqsave(&s->lock, flags);
631: s->ss_entry(s->sock, SS_GetStatus, &status);
632: if ((s->state & SOCKET_PRESENT) &&
633: (!(s->state & SOCKET_SUSPEND) ||
634: !(status & SS_DETECT)))
635: do_shutdown(s);
636: if (status & SS_DETECT) {
637: if (s->state & SOCKET_SETUP_PENDING) {
638: del_timer(&s->setup);
639: DEBUG(1, "cs: delaying pending setup\n");
640: }
641: s->state |= SOCKET_SETUP_PENDING;
642: s->setup.function = &setup_socket;
643: s->setup_timeout = 0;
644: if (s->state & SOCKET_SUSPEND)
645: s->setup.expires = jiffies + resume_delay;
646: else
647: s->setup.expires = jiffies + setup_delay;
648: add_timer(&s->setup);
649: }
650: spin_unlock_irqrestore(&s->lock, flags);
651: }
652: if (events & SS_BATDEAD)
653: send_event(s, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
654: if (events & SS_BATWARN)
655: send_event(s, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
656: if (events & SS_READY) {
657: if (!(s->state & SOCKET_RESET_PENDING))
658: send_event(s, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
659: else DEBUG(1, "cs: ready change during reset\n");
660: }
661: } /* parse_events */
662:
663: /*======================================================================
664:
665: Another event handler, for power management events.
666:
667: This does not comply with the latest PC Card spec for handling
668: power management events.
669:
670: ======================================================================*/
671:
672: #ifdef CONFIG_PM
673: #if (LINUX_VERSION_CODE < VERSION(2,3,43))
674: static int handle_pm_event(apm_event_t rqst)
675: #else
676: static int handle_pm_event(struct pm_dev *dev, pm_request_t rqst,
677: void *data)
678: #endif
679: {
680: int i, stat;
681: socket_info_t *s;
682: static int down = 0;
683:
684: /* <linux/pm.h> hides a hack so this works with old APM support */
685: switch (rqst) {
686: case PM_SUSPEND:
687: DEBUG(1, "cs: received suspend notification\n");
688: if (down) {
689: printk(KERN_DEBUG "cs: received extra suspend event\n");
690: break;
691: }
692: down = 1;
693: for (i = 0; i < sockets; i++) {
694: s = socket_table[i];
695: if ((s->state & SOCKET_PRESENT) &&
696: !(s->state & SOCKET_SUSPEND)){
697: send_event(s, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
698: s->ss_entry(s->sock, SS_SetSocket, &dead_socket);
699: s->state |= SOCKET_SUSPEND;
700: }
701: }
702: break;
703: case PM_RESUME:
704: DEBUG(1, "cs: received resume notification\n");
705: if (!down) {
706: printk(KERN_DEBUG "cs: received bogus resume event\n");
707: break;
708: }
709: down = 0;
710: for (i = 0; i < sockets; i++) {
711: s = socket_table[i];
712: /* Do this just to reinitialize the socket */
713: init_socket(s);
714: s->ss_entry(s->sock, SS_GetStatus, &stat);
715: /* If there was or is a card here, we need to do something
716: about it... but parse_events will sort it all out. */
717: if ((s->state & SOCKET_PRESENT) || (stat & SS_DETECT))
718: parse_events(s, SS_DETECT);
719: }
720: break;
721: }
722: return 0;
723: } /* handle_pm_event */
724: #endif
725:
726: /*======================================================================
727:
728: Special stuff for managing IO windows, because they are scarce.
729:
730: ======================================================================*/
731:
732: static int alloc_io_space(socket_info_t *s, u_int attr, ioaddr_t *base,
733: ioaddr_t num, u_int lines, char *name)
734: {
735: int i;
736: ioaddr_t try, align;
737:
738: align = (*base) ? (lines ? 1<<lines : 0) : 1;
739: if (align && (align < num)) {
740: if (*base) {
741: DEBUG(0, "odd IO request: num %04x align %04x\n",
742: num, align);
743: align = 0;
744: } else
745: while (align && (align < num)) align <<= 1;
746: }
747: if (*base & ~(align-1)) {
748: DEBUG(0, "odd IO request: base %04x align %04x\n",
749: *base, align);
750: while (*base & ~(align-1)) align <<= 1;
751: }
752: /* Check for an already-allocated window that must conflict with
753: what was asked for. It is a hack because it does not catch all
754: potential conflicts, just the most obvious ones. */
755: for (i = 0; i < MAX_IO_WIN; i++)
756: if ((s->io[i].NumPorts != 0) &&
757: ((s->io[i].BasePort & (align-1)) == *base))
758: return 1;
759: for (i = 0; i < MAX_IO_WIN; i++) {
760: if (s->io[i].NumPorts == 0) {
761: if (find_io_region(base, num, align, name) == 0) {
762: s->io[i].Attributes = attr;
763: s->io[i].BasePort = *base;
764: s->io[i].NumPorts = s->io[i].InUse = num;
765: break;
766: } else
767: return 1;
768: } else if (s->io[i].Attributes != attr)
769: continue;
770: /* Try to extend top of window */
771: try = s->io[i].BasePort + s->io[i].NumPorts;
772: if ((*base == 0) || (*base == try))
773: if (find_io_region(&try, num, 0, name) == 0) {
774: *base = try;
775: s->io[i].NumPorts += num;
776: s->io[i].InUse += num;
777: break;
778: }
779: /* Try to extend bottom of window */
780: try = s->io[i].BasePort - num;
781: if ((*base == 0) || (*base == try))
782: if (find_io_region(&try, num, 0, name) == 0) {
783: s->io[i].BasePort = *base = try;
784: s->io[i].NumPorts += num;
785: s->io[i].InUse += num;
786: break;
787: }
788: }
789: return (i == MAX_IO_WIN);
790: } /* alloc_io_space */
791:
792: static void release_io_space(socket_info_t *s, ioaddr_t base,
793: ioaddr_t num)
794: {
795: int i;
796: release_region(base, num);
797: for (i = 0; i < MAX_IO_WIN; i++) {
798: if ((s->io[i].BasePort <= base) &&
799: (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
800: s->io[i].InUse -= num;
801: /* Free the window if no one else is using it */
802: if (s->io[i].InUse == 0)
803: s->io[i].NumPorts = 0;
804: }
805: }
806: }
807:
808: /*======================================================================
809:
810: Access_configuration_register() reads and writes configuration
811: registers in attribute memory. Memory window 0 is reserved for
812: this and the tuple reading services.
813:
814: ======================================================================*/
815:
816: static int access_configuration_register(client_handle_t handle,
817: conf_reg_t *reg)
818: {
819: socket_info_t *s;
820: config_t *c;
821: int addr;
822: u_char val;
823:
824: if (CHECK_HANDLE(handle))
825: return CS_BAD_HANDLE;
826: s = SOCKET(handle);
827: if (!(s->state & SOCKET_PRESENT))
828: return CS_NO_CARD;
829: if (handle->Function == BIND_FN_ALL) {
830: if (reg->Function >= s->functions)
831: return CS_BAD_ARGS;
832: c = &s->config[reg->Function];
833: } else
834: c = CONFIG(handle);
835: if (!(c->state & CONFIG_LOCKED))
836: return CS_CONFIGURATION_LOCKED;
837:
838: addr = (c->ConfigBase + reg->Offset) >> 1;
839:
840: switch (reg->Action) {
841: case CS_READ:
842: read_cis_mem(s, 1, addr, 1, &val);
843: reg->Value = val;
844: break;
845: case CS_WRITE:
846: val = reg->Value;
847: write_cis_mem(s, 1, addr, 1, &val);
848: break;
849: default:
850: return CS_BAD_ARGS;
851: break;
852: }
853: return CS_SUCCESS;
854: } /* access_configuration_register */
855:
856: /*======================================================================
857:
858: Bind_device() associates a device driver with a particular socket.
859: It is normally called by Driver Services after it has identified
860: a newly inserted card. An instance of that driver will then be
861: eligible to register as a client of this socket.
862:
863: ======================================================================*/
864:
865: static int bind_device(bind_req_t *req)
866: {
867: client_t *client;
868: socket_info_t *s;
869:
870: if (CHECK_SOCKET(req->Socket))
871: return CS_BAD_SOCKET;
872: s = SOCKET(req);
873:
874: client = (client_t *)kmalloc(sizeof(client_t), GFP_KERNEL);
875: if (!client) return CS_OUT_OF_RESOURCE;
876: memset(client, '\0', sizeof(client_t));
877: client->client_magic = CLIENT_MAGIC;
878: strncpy(client->dev_info, (char *)req->dev_info, DEV_NAME_LEN);
879: client->Socket = req->Socket;
880: client->Function = req->Function;
881: client->state = CLIENT_UNBOUND;
882: client->erase_busy.next = &client->erase_busy;
883: client->erase_busy.prev = &client->erase_busy;
884: init_waitqueue_head(&client->mtd_req);
885: client->next = s->clients;
886: s->clients = client;
887: DEBUG(1, "cs: bind_device(): client 0x%p, sock %d, dev %s\n",
888: client, client->Socket, client->dev_info);
889: return CS_SUCCESS;
890: } /* bind_device */
891:
892: /*======================================================================
893:
894: Bind_mtd() associates a device driver with a particular memory
895: region. It is normally called by Driver Services after it has
896: identified a memory device type. An instance of the corresponding
897: driver will then be able to register to control this region.
898:
899: ======================================================================*/
900:
901: static int bind_mtd(mtd_bind_t *req)
902: {
903: socket_info_t *s;
904: memory_handle_t region;
905:
906: if (CHECK_SOCKET(req->Socket))
907: return CS_BAD_SOCKET;
908: s = SOCKET(req);
909:
910: if (req->Attributes & REGION_TYPE_AM)
911: region = s->a_region;
912: else
913: region = s->c_region;
914:
915: while (region) {
916: if (region->info.CardOffset == req->CardOffset) break;
917: region = region->info.next;
918: }
919: if (!region || (region->mtd != NULL))
920: return CS_BAD_OFFSET;
921: strncpy(region->dev_info, (char *)req->dev_info, DEV_NAME_LEN);
922:
923: DEBUG(1, "cs: bind_mtd(): attr 0x%x, offset 0x%x, dev %s\n",
924: req->Attributes, req->CardOffset, (char *)req->dev_info);
925: return CS_SUCCESS;
926: } /* bind_mtd */
927:
928: /*====================================================================*/
929:
930: static int deregister_client(client_handle_t handle)
931: {
932: client_t **client;
933: socket_info_t *s;
934: memory_handle_t region;
935: u_long flags;
936: int i, sn;
937:
938: DEBUG(1, "cs: deregister_client(%p)\n", handle);
939: if (CHECK_HANDLE(handle))
940: return CS_BAD_HANDLE;
941: if (handle->state &
942: (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
943: return CS_IN_USE;
944: for (i = 0; i < MAX_WIN; i++)
945: if (handle->state & CLIENT_WIN_REQ(i))
946: return CS_IN_USE;
947:
948: /* Disconnect all MTD links */
949: s = SOCKET(handle);
950: if (handle->mtd_count) {
951: for (region = s->a_region; region; region = region->info.next)
952: if (region->mtd == handle) region->mtd = NULL;
953: for (region = s->c_region; region; region = region->info.next)
954: if (region->mtd == handle) region->mtd = NULL;
955: }
956:
957: sn = handle->Socket; s = socket_table[sn];
958:
959: if ((handle->state & CLIENT_STALE) ||
960: (handle->Attributes & INFO_MASTER_CLIENT)) {
961: spin_lock_irqsave(&s->lock, flags);
962: client = &s->clients;
963: while ((*client) && ((*client) != handle))
964: client = &(*client)->next;
965: if (*client == NULL) {
966: spin_unlock_irqrestore(&s->lock, flags);
967: return CS_BAD_HANDLE;
968: }
969: *client = handle->next;
970: handle->client_magic = 0;
971: kfree(handle);
972: spin_unlock_irqrestore(&s->lock, flags);
973: } else {
974: handle->state = CLIENT_UNBOUND;
975: handle->mtd_count = 0;
976: handle->event_handler = NULL;
977: }
978:
979: if (--s->real_clients == 0)
980: s->ss_entry(sn, SS_RegisterCallback, NULL);
981:
982: return CS_SUCCESS;
983: } /* deregister_client */
984:
985: /*====================================================================*/
986:
987: static int get_configuration_info(client_handle_t handle,
988: config_info_t *config)
989: {
990: socket_info_t *s;
991: config_t *c;
992:
993: if (CHECK_HANDLE(handle))
994: return CS_BAD_HANDLE;
995: s = SOCKET(handle);
996: if (!(s->state & SOCKET_PRESENT))
997: return CS_NO_CARD;
998:
999: if (handle->Function == BIND_FN_ALL) {
1000: if (config->Function && (config->Function >= s->functions))
1001: return CS_BAD_ARGS;
1002: } else
1003: config->Function = handle->Function;
1004:
1005: #ifdef CONFIG_CARDBUS
1006: if (s->state & SOCKET_CARDBUS) {
1007: u_char fn = config->Function;
1008: memset(config, 0, sizeof(config_info_t));
1009: config->Function = fn;
1010: config->Vcc = s->socket.Vcc;
1011: config->Vpp1 = config->Vpp2 = s->socket.Vpp;
1012: config->Option = s->cap.cardbus;
1013: config->IntType = INT_CARDBUS;
1014: /* This is a nasty hack */
1015: pcibios_read_config_dword(s->cap.cardbus, 0, 0, &config->ConfigBase);
1016: if (s->cb_config) {
1017: config->Attributes = CONF_VALID_CLIENT;
1018: config->AssignedIRQ = s->irq.AssignedIRQ;
1019: if (config->AssignedIRQ)
1020: config->Attributes |= CONF_ENABLE_IRQ;
1021: config->BasePort1 = s->io[0].BasePort;
1022: config->NumPorts1 = s->io[0].NumPorts;
1023: }
1024: return CS_SUCCESS;
1025: }
1026: #endif
1027:
1028: c = (s->config != NULL) ? &s->config[config->Function] : NULL;
1029:
1030: if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
1031: config->Attributes = 0;
1032: config->Vcc = s->socket.Vcc;
1033: config->Vpp1 = config->Vpp2 = s->socket.Vpp;
1034: return CS_SUCCESS;
1035: }
1036:
1037: /* !!! This is a hack !!! */
1038: memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
1039: config->Attributes |= CONF_VALID_CLIENT;
1040: config->CardValues = c->CardValues;
1041: config->IRQAttributes = c->irq.Attributes;
1042: config->AssignedIRQ = s->irq.AssignedIRQ;
1043: config->BasePort1 = c->io.BasePort1;
1044: config->NumPorts1 = c->io.NumPorts1;
1045: config->Attributes1 = c->io.Attributes1;
1046: config->BasePort2 = c->io.BasePort2;
1047: config->NumPorts2 = c->io.NumPorts2;
1048: config->Attributes2 = c->io.Attributes2;
1049: config->IOAddrLines = c->io.IOAddrLines;
1050:
1051: return CS_SUCCESS;
1052: } /* get_configuration_info */
1053:
1054: /*======================================================================
1055:
1056: Return information about this version of Card Services.
1057:
1058: ======================================================================*/
1059:
1060: static int get_card_services_info(servinfo_t *info)
1061: {
1062: info->Signature[0] = 'C';
1063: info->Signature[1] = 'S';
1064: info->Count = sockets;
1065: info->Revision = CS_RELEASE_CODE;
1066: info->CSLevel = 0x0210;
1067: info->VendorString = (char *)release;
1068: return CS_SUCCESS;
1069: } /* get_card_services_info */
1070:
1071: /*======================================================================
1072:
1073: Note that get_first_client() *does* recognize the Socket field
1074: in the request structure.
1075:
1076: ======================================================================*/
1077:
1078: static int get_first_client(client_handle_t *handle, client_req_t *req)
1079: {
1080: socket_t s;
1081: if (req->Attributes & CLIENT_THIS_SOCKET)
1082: s = req->Socket;
1083: else
1084: s = 0;
1085: if (CHECK_SOCKET(req->Socket))
1086: return CS_BAD_SOCKET;
1087: if (socket_table[s]->clients == NULL)
1088: return CS_NO_MORE_ITEMS;
1089: *handle = socket_table[s]->clients;
1090: return CS_SUCCESS;
1091: } /* get_first_client */
1092:
1093: /*====================================================================*/
1094:
1095: static int get_next_client(client_handle_t *handle, client_req_t *req)
1096: {
1097: socket_info_t *s;
1098: if ((handle == NULL) || CHECK_HANDLE(*handle))
1099: return CS_BAD_HANDLE;
1100: if ((*handle)->next == NULL) {
1101: if (req->Attributes & CLIENT_THIS_SOCKET)
1102: return CS_NO_MORE_ITEMS;
1103: s = SOCKET(*handle);
1104: if (s->clients == NULL)
1105: return CS_NO_MORE_ITEMS;
1106: *handle = s->clients;
1107: } else
1108: *handle = (*handle)->next;
1109: return CS_SUCCESS;
1110: } /* get_next_client */
1111:
1112: /*====================================================================*/
1113:
1114: static int get_window(window_handle_t *handle, int idx, win_req_t *req)
1115: {
1116: socket_info_t *s;
1117: window_t *win;
1118: int w;
1119:
1120: if (idx == 0)
1121: s = SOCKET((client_handle_t)*handle);
1122: else
1123: s = (*handle)->sock;
1124: if (!(s->state & SOCKET_PRESENT))
1125: return CS_NO_CARD;
1126: for (w = idx; w < MAX_WIN; w++)
1127: if (s->state & SOCKET_WIN_REQ(w)) break;
1128: if (w == MAX_WIN)
1129: return CS_NO_MORE_ITEMS;
1130: win = &s->win[w];
1131: req->Base = win->ctl.sys_start;
1132: req->Size = win->ctl.sys_stop - win->ctl.sys_start + 1;
1133: req->AccessSpeed = win->ctl.speed;
1134: req->Attributes = 0;
1135: if (win->ctl.flags & MAP_ATTRIB)
1136: req->Attributes |= WIN_MEMORY_TYPE_AM;
1137: if (win->ctl.flags & MAP_ACTIVE)
1138: req->Attributes |= WIN_ENABLE;
1139: if (win->ctl.flags & MAP_16BIT)
1140: req->Attributes |= WIN_DATA_WIDTH_16;
1141: if (win->ctl.flags & MAP_USE_WAIT)
1142: req->Attributes |= WIN_USE_WAIT;
1143: *handle = win;
1144: return CS_SUCCESS;
1145: } /* get_window */
1146:
1147: static int get_first_window(client_handle_t *handle, win_req_t *req)
1148: {
1149: if ((handle == NULL) || CHECK_HANDLE(*handle))
1150: return CS_BAD_HANDLE;
1151: return get_window((window_handle_t *)handle, 0, req);
1152: }
1153:
1154: static int get_next_window(window_handle_t *win, win_req_t *req)
1155: {
1156: if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1157: return CS_BAD_HANDLE;
1158: return get_window(win, (*win)->index+1, req);
1159: }
1160:
1161: /*======================================================================
1162:
1163: Get the current socket state bits. We don't support the latched
1164: SocketState yet: I haven't seen any point for it.
1165:
1166: ======================================================================*/
1167:
1168: static int cs_get_status(client_handle_t handle, cs_status_t *status)
1169: {
1170: socket_info_t *s;
1171: config_t *c;
1172: int val;
1173:
1174: if (CHECK_HANDLE(handle))
1175: return CS_BAD_HANDLE;
1176: s = SOCKET(handle);
1177: s->ss_entry(s->sock, SS_GetStatus, &val);
1178: status->CardState = status->SocketState = 0;
1179: status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1180: status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1181: status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1182: status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1183: if (s->state & SOCKET_SUSPEND)
1184: status->CardState |= CS_EVENT_PM_SUSPEND;
1185: if (!(s->state & SOCKET_PRESENT))
1186: return CS_NO_CARD;
1187: if (s->state & SOCKET_SETUP_PENDING)
1188: status->CardState |= CS_EVENT_CARD_INSERTION;
1189:
1190: /* Get info from the PRR, if necessary */
1191: if (handle->Function == BIND_FN_ALL) {
1192: if (status->Function && (status->Function >= s->functions))
1193: return CS_BAD_ARGS;
1194: c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1195: } else
1196: c = CONFIG(handle);
1197: if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1198: (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1199: u_char reg;
1200: if (c->Present & PRESENT_PIN_REPLACE) {
1201: read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
1202: status->CardState |=
1203: (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1204: status->CardState |=
1205: (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1206: status->CardState |=
1207: (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1208: status->CardState |=
1209: (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1210: } else {
1211: /* No PRR? Then assume we're always ready */
1212: status->CardState |= CS_EVENT_READY_CHANGE;
1213: }
1214: if (c->Present & PRESENT_EXT_STATUS) {
1215: read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
1216: status->CardState |=
1217: (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1218: }
1219: return CS_SUCCESS;
1220: }
1221: status->CardState |=
1222: (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1223: status->CardState |=
1224: (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1225: status->CardState |=
1226: (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1227: status->CardState |=
1228: (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1229: return CS_SUCCESS;
1230: } /* cs_get_status */
1231:
1232: /*======================================================================
1233:
1234: Change the card address of an already open memory window.
1235:
1236: ======================================================================*/
1237:
1238: static int get_mem_page(window_handle_t win, memreq_t *req)
1239: {
1240: if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1241: return CS_BAD_HANDLE;
1242: req->Page = 0;
1243: req->CardOffset = win->ctl.card_start;
1244: return CS_SUCCESS;
1245: } /* get_mem_page */
1246:
1247: static int map_mem_page(window_handle_t win, memreq_t *req)
1248: {
1249: socket_info_t *s;
1250: if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1251: return CS_BAD_HANDLE;
1252: if (req->Page != 0)
1253: return CS_BAD_PAGE;
1254: s = win->sock;
1255: win->ctl.card_start = req->CardOffset;
1256: if (s->ss_entry(s->sock, SS_SetMemMap, &win->ctl) != 0)
1257: return CS_BAD_OFFSET;
1258: return CS_SUCCESS;
1259: } /* map_mem_page */
1260:
1261: /*======================================================================
1262:
1263: Modify a locked socket configuration
1264:
1265: ======================================================================*/
1266:
1267: static int modify_configuration(client_handle_t handle,
1268: modconf_t *mod)
1269: {
1270: socket_info_t *s;
1271: config_t *c;
1272:
1273: if (CHECK_HANDLE(handle))
1274: return CS_BAD_HANDLE;
1275: s = SOCKET(handle); c = CONFIG(handle);
1276: if (!(s->state & SOCKET_PRESENT))
1277: return CS_NO_CARD;
1278: if (!(c->state & CONFIG_LOCKED))
1279: return CS_CONFIGURATION_LOCKED;
1280:
1281: if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1282: if (mod->Attributes & CONF_ENABLE_IRQ) {
1283: c->Attributes |= CONF_ENABLE_IRQ;
1284: s->socket.io_irq = s->irq.AssignedIRQ;
1285: } else {
1286: c->Attributes &= ~CONF_ENABLE_IRQ;
1287: s->socket.io_irq = 0;
1288: }
1289: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
1290: }
1291:
1292: if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1293: return CS_BAD_VCC;
1294:
1295: /* We only allow changing Vpp1 and Vpp2 to the same value */
1296: if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1297: (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1298: if (mod->Vpp1 != mod->Vpp2)
1299: return CS_BAD_VPP;
1300: c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1301: if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))
1302: return CS_BAD_VPP;
1303: } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1304: (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1305: return CS_BAD_VPP;
1306:
1307: return CS_SUCCESS;
1308: } /* modify_configuration */
1309:
1310: /*======================================================================
1311:
1312: Modify the attributes of a window returned by RequestWindow.
1313:
1314: ======================================================================*/
1315:
1316: static int modify_window(window_handle_t win, modwin_t *req)
1317: {
1318: if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1319: return CS_BAD_HANDLE;
1320:
1321: win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1322: if (req->Attributes & WIN_MEMORY_TYPE)
1323: win->ctl.flags |= MAP_ATTRIB;
1324: if (req->Attributes & WIN_ENABLE)
1325: win->ctl.flags |= MAP_ACTIVE;
1326: if (req->Attributes & WIN_DATA_WIDTH_16)
1327: win->ctl.flags |= MAP_16BIT;
1328: if (req->Attributes & WIN_USE_WAIT)
1329: win->ctl.flags |= MAP_USE_WAIT;
1330: win->ctl.speed = req->AccessSpeed;
1331: win->sock->ss_entry(win->sock->sock, SS_SetMemMap, &win->ctl);
1332:
1333: return CS_SUCCESS;
1334: } /* modify_window */
1335:
1336: /*======================================================================
1337:
1338: Register_client() uses the dev_info_t handle to match the
1339: caller with a socket. The driver must have already been bound
1340: to a socket with bind_device() -- in fact, bind_device()
1341: allocates the client structure that will be used.
1342:
1343: ======================================================================*/
1344:
1345: static int register_client(client_handle_t *handle, client_reg_t *req)
1346: {
1347: client_t *client;
1348: socket_info_t *s;
1349: socket_t ns;
1350:
1351: /* Look for unbound client with matching dev_info */
1352: client = NULL;
1353: for (ns = 0; ns < sockets; ns++) {
1354: client = socket_table[ns]->clients;
1355: while (client != NULL) {
1356: if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1357: && (client->state & CLIENT_UNBOUND)) break;
1358: client = client->next;
1359: }
1360: if (client != NULL) break;
1361: }
1362: if (client == NULL)
1363: return CS_OUT_OF_RESOURCE;
1364:
1365: s = socket_table[ns];
1366: if (++s->real_clients == 1) {
1367: ss_callback_t call;
1368: int status;
1369: call.handler = &parse_events;
1370: call.info = s;
1371: s->ss_entry(ns, SS_RegisterCallback, &call);
1372: s->ss_entry(ns, SS_GetStatus, &status);
1373: if ((status & SS_DETECT) &&
1374: !(s->state & SOCKET_SETUP_PENDING)) {
1375: s->state |= SOCKET_SETUP_PENDING;
1376: setup_socket(ns);
1377: }
1378: }
1379:
1380: *handle = client;
1381: client->state &= ~CLIENT_UNBOUND;
1382: client->Socket = ns;
1383: client->Attributes = req->Attributes;
1384: client->EventMask = req->EventMask;
1385: client->event_handler = req->event_handler;
1386: client->event_callback_args = req->event_callback_args;
1387: client->event_callback_args.client_handle = client;
1388: client->event_callback_args.bus = s->cap.bus;
1389:
1390: if (s->state & SOCKET_CARDBUS)
1391: client->state |= CLIENT_CARDBUS;
1392:
1393: if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1394: (client->Function != BIND_FN_ALL)) {
1395: cistpl_longlink_mfc_t mfc;
1396: if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc)
1397: == CS_SUCCESS)
1398: s->functions = mfc.nfn;
1399: else
1400: s->functions = 1;
1401: s->config = kmalloc(sizeof(config_t) * s->functions,
1402: GFP_KERNEL);
1403: memset(s->config, 0, sizeof(config_t) * s->functions);
1404: }
1405:
1406: DEBUG(1, "cs: register_client(): client 0x%p, sock %d, dev %s\n",
1407: client, client->Socket, client->dev_info);
1408: if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1409: EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1410: if ((socket_table[ns]->state & SOCKET_PRESENT) &&
1411: !(socket_table[ns]->state & SOCKET_SETUP_PENDING)) {
1412: if (client->EventMask & CS_EVENT_CARD_INSERTION)
1413: EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1414: else
1415: client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1416: }
1417: return CS_SUCCESS;
1418: } /* register_client */
1419:
1420: /*====================================================================*/
1421:
1422: static int release_configuration(client_handle_t handle,
1423: config_req_t *req)
1424: {
1425: socket_info_t *s;
1426: pccard_io_map io = { 0, 0, 0, 0, 1 };
1427: int i;
1428:
1429: if (CHECK_HANDLE(handle) ||
1430: !(handle->state & CLIENT_CONFIG_LOCKED))
1431: return CS_BAD_HANDLE;
1432: handle->state &= ~CLIENT_CONFIG_LOCKED;
1433: s = SOCKET(handle);
1434:
1435: #ifdef CONFIG_CARDBUS
1436: if (handle->state & CLIENT_CARDBUS) {
1437: cb_disable(s);
1438: s->lock_count = 0;
1439: return CS_SUCCESS;
1440: }
1441: #endif
1442:
1443: if (!(handle->state & CLIENT_STALE)) {
1444: config_t *c = CONFIG(handle);
1445: if (--(s->lock_count) == 0) {
1446: s->socket.flags = SS_OUTPUT_ENA;
1447: s->socket.Vpp = 0;
1448: s->socket.io_irq = 0;
1449: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
1450: }
1451: if (c->state & CONFIG_IO_REQ)
1452: for (i = 0; i < MAX_IO_WIN; i++) {
1453: if (s->io[i].NumPorts == 0)
1454: continue;
1455: s->io[i].Config--;
1456: if (s->io[i].Config != 0)
1457: continue;
1458: io.map = i;
1459: s->ss_entry(s->sock, SS_SetIOMap, &io);
1460: }
1461: c->state &= ~CONFIG_LOCKED;
1462: }
1463:
1464: return CS_SUCCESS;
1465: } /* release_configuration */
1466:
1467: /*======================================================================
1468:
1469: Release_io() releases the I/O ranges allocated by a client. This
1470: may be invoked some time after a card ejection has already dumped
1471: the actual socket configuration, so if the client is "stale", we
1472: don't bother checking the port ranges against the current socket
1473: values.
1474:
1475: ======================================================================*/
1476:
1477: static int release_io(client_handle_t handle, io_req_t *req)
1478: {
1479: socket_info_t *s;
1480:
1481: if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1482: return CS_BAD_HANDLE;
1483: handle->state &= ~CLIENT_IO_REQ;
1484: s = SOCKET(handle);
1485:
1486: #ifdef CONFIG_CARDBUS
1487: if (handle->state & CLIENT_CARDBUS) {
1488: cb_release(s);
1489: return CS_SUCCESS;
1490: }
1491: #endif
1492:
1493: if (!(handle->state & CLIENT_STALE)) {
1494: config_t *c = CONFIG(handle);
1495: if (c->state & CONFIG_LOCKED)
1496: return CS_CONFIGURATION_LOCKED;
1497: if ((c->io.BasePort1 != req->BasePort1) ||
1498: (c->io.NumPorts1 != req->NumPorts1) ||
1499: (c->io.BasePort2 != req->BasePort2) ||
1500: (c->io.NumPorts2 != req->NumPorts2))
1501: return CS_BAD_ARGS;
1502: c->state &= ~CONFIG_IO_REQ;
1503: }
1504:
1505: release_io_space(s, req->BasePort1, req->NumPorts1);
1506: if (req->NumPorts2)
1507: release_io_space(s, req->BasePort2, req->NumPorts2);
1508:
1509: return CS_SUCCESS;
1510: } /* release_io */
1511:
1512: /*====================================================================*/
1513:
1514: static int cs_release_irq(client_handle_t handle, irq_req_t *req)
1515: {
1516: socket_info_t *s;
1517: if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1518: return CS_BAD_HANDLE;
1519: handle->state &= ~CLIENT_IRQ_REQ;
1520: s = SOCKET(handle);
1521:
1522: if (!(handle->state & CLIENT_STALE)) {
1523: config_t *c = CONFIG(handle);
1524: if (c->state & CONFIG_LOCKED)
1525: return CS_CONFIGURATION_LOCKED;
1526: if (c->irq.Attributes != req->Attributes)
1527: return CS_BAD_ATTRIBUTE;
1528: if (s->irq.AssignedIRQ != req->AssignedIRQ)
1529: return CS_BAD_IRQ;
1530: if (--s->irq.Config == 0) {
1531: c->state &= ~CONFIG_IRQ_REQ;
1532: s->irq.AssignedIRQ = 0;
1533: }
1534: }
1535:
1536: if (req->Attributes & IRQ_HANDLE_PRESENT) {
1537: bus_free_irq(s->cap.bus, req->AssignedIRQ, req->Instance);
1538: }
1539:
1540: #ifdef CONFIG_ISA
1541: if (req->AssignedIRQ != s->cap.pci_irq)
1542: undo_irq(req->Attributes, req->AssignedIRQ);
1543: #endif
1544:
1545: return CS_SUCCESS;
1546: } /* cs_release_irq */
1547:
1548: /*====================================================================*/
1549:
1550: static int release_window(window_handle_t win)
1551: {
1552: socket_info_t *s;
1553:
1554: if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1555: return CS_BAD_HANDLE;
1556: s = win->sock;
1557: if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1558: return CS_BAD_HANDLE;
1559:
1560: /* Shut down memory window */
1561: win->ctl.flags &= ~MAP_ACTIVE;
1562: s->ss_entry(s->sock, SS_SetMemMap, &win->ctl);
1563: s->state &= ~SOCKET_WIN_REQ(win->index);
1564:
1565: /* Release system memory */
1566: release_mem_region(win->base, win->size);
1567: win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1568:
1569: win->magic = 0;
1570:
1571: return CS_SUCCESS;
1572: } /* release_window */
1573:
1574: /*====================================================================*/
1575:
1576: static int request_configuration(client_handle_t handle,
1577: config_req_t *req)
1578: {
1579: int i;
1580: u_int base;
1581: socket_info_t *s;
1582: config_t *c;
1583: pccard_io_map iomap;
1584:
1585: if (CHECK_HANDLE(handle))
1586: return CS_BAD_HANDLE;
1587: i = handle->Socket; s = socket_table[i];
1588: if (!(s->state & SOCKET_PRESENT))
1589: return CS_NO_CARD;
1590:
1591: #ifdef CONFIG_CARDBUS
1592: if (handle->state & CLIENT_CARDBUS) {
1593: if (!(req->IntType & INT_CARDBUS))
1594: return CS_UNSUPPORTED_MODE;
1595: if (s->lock_count != 0)
1596: return CS_CONFIGURATION_LOCKED;
1597: cb_enable(s);
1598: handle->state |= CLIENT_CONFIG_LOCKED;
1599: s->lock_count++;
1600: return CS_SUCCESS;
1601: }
1602: #endif
1603:
1604: if (req->IntType & INT_CARDBUS)
1605: return CS_UNSUPPORTED_MODE;
1606: c = CONFIG(handle);
1607: if (c->state & CONFIG_LOCKED)
1608: return CS_CONFIGURATION_LOCKED;
1609:
1610: /* Do power control. We don't allow changes in Vcc. */
1611: if (s->socket.Vcc != req->Vcc)
1612: printk(KERN_DEBUG "cs: ignoring requested Vcc\n");
1613: if (req->Vpp1 != req->Vpp2)
1614: return CS_BAD_VPP;
1615: s->socket.Vpp = req->Vpp1;
1616: if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))
1617: return CS_BAD_VPP;
1618:
1619: c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1620:
1621: /* Pick memory or I/O card, DMA mode, interrupt */
1622: c->IntType = req->IntType;
1623: c->Attributes = req->Attributes;
1624: if (req->IntType & INT_MEMORY_AND_IO)
1625: s->socket.flags |= SS_IOCARD;
1626: if (req->IntType & INT_ZOOMED_VIDEO)
1627: s->socket.flags |= SS_ZVCARD;
1628: if (req->Attributes & CONF_ENABLE_DMA)
1629: s->socket.flags |= SS_DMA_MODE;
1630: if (req->Attributes & CONF_ENABLE_SPKR)
1631: s->socket.flags |= SS_SPKR_ENA;
1632: if (req->Attributes & CONF_ENABLE_IRQ)
1633: s->socket.io_irq = s->irq.AssignedIRQ;
1634: else
1635: s->socket.io_irq = 0;
1636: s->ss_entry(s->sock, SS_SetSocket, &s->socket);
1637: s->lock_count++;
1638:
1639: /* Set up CIS configuration registers */
1640: base = c->ConfigBase = req->ConfigBase;
1641: c->Present = c->CardValues = req->Present;
1642: if (req->Present & PRESENT_COPY) {
1643: c->Copy = req->Copy;
1644: write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1645: }
1646: if (req->Present & PRESENT_OPTION) {
1647: if (s->functions == 1) {
1648: c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1649: } else {
1650: c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1651: c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1652: if (req->Present & PRESENT_IOBASE_0)
1653: c->Option |= COR_ADDR_DECODE;
1654: }
1655: if (c->state & CONFIG_IRQ_REQ)
1656: if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1657: c->Option |= COR_LEVEL_REQ;
1658: write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1659: mdelay(40);
1660: }
1661: if (req->Present & PRESENT_STATUS) {
1662: c->Status = req->Status;
1663: write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1664: }
1665: if (req->Present & PRESENT_PIN_REPLACE) {
1666: c->Pin = req->Pin;
1667: write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1668: }
1669: if (req->Present & PRESENT_EXT_STATUS) {
1670: c->ExtStatus = req->ExtStatus;
1671: write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1672: }
1673: if (req->Present & PRESENT_IOBASE_0) {
1674: u_char b = c->io.BasePort1 & 0xff;
1675: write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1676: b = (c->io.BasePort1 >> 8) & 0xff;
1677: write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1678: }
1679: if (req->Present & PRESENT_IOSIZE) {
1680: u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1681: write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1682: }
1683:
1684: /* Configure I/O windows */
1685: if (c->state & CONFIG_IO_REQ) {
1686: iomap.speed = io_speed;
1687: for (i = 0; i < MAX_IO_WIN; i++)
1688: if (s->io[i].NumPorts != 0) {
1689: iomap.map = i;
1690: iomap.flags = MAP_ACTIVE;
1691: switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1692: case IO_DATA_PATH_WIDTH_16:
1693: iomap.flags |= MAP_16BIT; break;
1694: case IO_DATA_PATH_WIDTH_AUTO:
1695: iomap.flags |= MAP_AUTOSZ; break;
1696: default:
1697: break;
1698: }
1699: iomap.start = s->io[i].BasePort;
1700: iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1701: s->ss_entry(s->sock, SS_SetIOMap, &iomap);
1702: s->io[i].Config++;
1703: }
1704: }
1705:
1706: c->state |= CONFIG_LOCKED;
1707: handle->state |= CLIENT_CONFIG_LOCKED;
1708: return CS_SUCCESS;
1709: } /* request_configuration */
1710:
1711: /*======================================================================
1712:
1713: Request_io() reserves ranges of port addresses for a socket.
1714: I have not implemented range sharing or alias addressing.
1715:
1716: ======================================================================*/
1717:
1718: static int request_io(client_handle_t handle, io_req_t *req)
1719: {
1720: socket_info_t *s;
1721: config_t *c;
1722:
1723: if (CHECK_HANDLE(handle))
1724: return CS_BAD_HANDLE;
1725: s = SOCKET(handle);
1726: if (!(s->state & SOCKET_PRESENT))
1727: return CS_NO_CARD;
1728:
1729: if (handle->state & CLIENT_CARDBUS) {
1730: #ifdef CONFIG_CARDBUS
1731: int ret = cb_config(s);
1732: if (ret == CS_SUCCESS)
1733: handle->state |= CLIENT_IO_REQ;
1734: return ret;
1735: #else
1736: return CS_UNSUPPORTED_FUNCTION;
1737: #endif
1738: }
1739:
1740: if (!req)
1741: return CS_UNSUPPORTED_MODE;
1742: c = CONFIG(handle);
1743: if (c->state & CONFIG_LOCKED)
1744: return CS_CONFIGURATION_LOCKED;
1745: if (c->state & CONFIG_IO_REQ)
1746: return CS_IN_USE;
1747: if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1748: return CS_BAD_ATTRIBUTE;
1749: if ((req->NumPorts2 > 0) &&
1750: (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1751: return CS_BAD_ATTRIBUTE;
1752:
1753: if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1754: req->NumPorts1, req->IOAddrLines,
1755: handle->dev_info))
1756: return CS_IN_USE;
1757:
1758: if (req->NumPorts2) {
1759: if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1760: req->NumPorts2, req->IOAddrLines,
1761: handle->dev_info)) {
1762: release_io_space(s, req->BasePort1, req->NumPorts1);
1763: return CS_IN_USE;
1764: }
1765: }
1766:
1767: c->io = *req;
1768: c->state |= CONFIG_IO_REQ;
1769: handle->state |= CLIENT_IO_REQ;
1770: return CS_SUCCESS;
1771: } /* request_io */
1772:
1773: /*======================================================================
1774:
1775: Request_irq() reserves an irq for this client.
1776:
1777: Also, since Linux only reserves irq's when they are actually
1778: hooked, we don't guarantee that an irq will still be available
1779: when the configuration is locked. Now that I think about it,
1780: there might be a way to fix this using a dummy handler.
1781:
1782: ======================================================================*/
1783:
1784: static int cs_request_irq(client_handle_t handle, irq_req_t *req)
1785: {
1786: socket_info_t *s;
1787: config_t *c;
1788: int ret = CS_IN_USE, irq = 0;
1789:
1790: if (CHECK_HANDLE(handle))
1791: return CS_BAD_HANDLE;
1792: s = SOCKET(handle);
1793: if (!(s->state & SOCKET_PRESENT))
1794: return CS_NO_CARD;
1795: c = CONFIG(handle);
1796: if (c->state & CONFIG_LOCKED)
1797: return CS_CONFIGURATION_LOCKED;
1798: if (c->state & CONFIG_IRQ_REQ)
1799: return CS_IN_USE;
1800:
1801: #ifdef CONFIG_ISA
1802: if (s->irq.AssignedIRQ != 0) {
1803: /* If the interrupt is already assigned, it must match */
1804: irq = s->irq.AssignedIRQ;
1805: if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1806: u_int mask = req->IRQInfo2 & s->cap.irq_mask;
1807: ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1808: } else
1809: ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1810: } else {
1811: if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1812: u_int try, mask = req->IRQInfo2 & s->cap.irq_mask;
1813: for (try = 0; try < 2; try++) {
1814: for (irq = 0; irq < 16; irq++)
1815: if ((mask >> irq) & 1) {
1816: ret = try_irq(req->Attributes, irq, try);
1817: if (ret == 0) break;
1818: }
1819: if (ret == 0) break;
1820: }
1821: } else {
1822: irq = req->IRQInfo1 & IRQ_MASK;
1823: ret = try_irq(req->Attributes, irq, 1);
1824: }
1825: }
1826: #endif
1827: if (ret != 0) {
1828: if (!s->cap.pci_irq)
1829: return ret;
1830: irq = s->cap.pci_irq;
1831: }
1832:
1833: if (req->Attributes & IRQ_HANDLE_PRESENT) {
1834: if (bus_request_irq(s->cap.bus, irq, req->Handler,
1835: ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1836: (s->functions > 1) ||
1837: (irq == s->cap.pci_irq)) ? SA_SHIRQ : 0,
1838: handle->dev_info, req->Instance))
1839: return CS_IN_USE;
1840: }
1841:
1842: c->irq.Attributes = req->Attributes;
1843: s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1844: s->irq.Config++;
1845:
1846: c->state |= CONFIG_IRQ_REQ;
1847: handle->state |= CLIENT_IRQ_REQ;
1848: return CS_SUCCESS;
1849: } /* cs_request_irq */
1850:
1851: /*======================================================================
1852:
1853: Request_window() establishes a mapping between card memory space
1854: and system memory space.
1855:
1856: ======================================================================*/
1857:
1858: static int request_window(client_handle_t *handle, win_req_t *req)
1859: {
1860: socket_info_t *s;
1861: window_t *win;
1862: u_long align;
1863: int w;
1864:
1865: if (CHECK_HANDLE(*handle))
1866: return CS_BAD_HANDLE;
1867: s = SOCKET(*handle);
1868: if (!(s->state & SOCKET_PRESENT))
1869: return CS_NO_CARD;
1870: if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1871: return CS_BAD_ATTRIBUTE;
1872:
1873: /* Window size defaults to smallest available */
1874: if (req->Size == 0)
1875: req->Size = s->cap.map_size;
1876: align = (((s->cap.features & SS_CAP_MEM_ALIGN) ||
1877: (req->Attributes & WIN_STRICT_ALIGN)) ?
1878: req->Size : s->cap.map_size);
1879: if (req->Size & (s->cap.map_size-1))
1880: return CS_BAD_SIZE;
1881: if ((req->Base && (s->cap.features & SS_CAP_STATIC_MAP)) ||
1882: (req->Base & (align-1)))
1883: return CS_BAD_BASE;
1884: if (req->Base)
1885: align = 0;
1886:
1887: /* Allocate system memory window */
1888: for (w = 0; w < MAX_WIN; w++)
1889: if (!(s->state & SOCKET_WIN_REQ(w))) break;
1890: if (w == MAX_WIN)
1891: return CS_OUT_OF_RESOURCE;
1892:
1893: win = &s->win[w];
1894: win->magic = WINDOW_MAGIC;
1895: win->index = w;
1896: win->handle = *handle;
1897: win->sock = s;
1898: win->base = req->Base;
1899: win->size = req->Size;
1900:
1901: if (!(s->cap.features & SS_CAP_STATIC_MAP) &&
1902: find_mem_region(&win->base, win->size, align,
1903: (req->Attributes & WIN_MAP_BELOW_1MB) ||
1904: !(s->cap.features & SS_CAP_PAGE_REGS),
1905: (*handle)->dev_info))
1906: return CS_IN_USE;
1907: (*handle)->state |= CLIENT_WIN_REQ(w);
1908:
1909: /* Configure the socket controller */
1910: win->ctl.map = w+1;
1911: win->ctl.flags = 0;
1912: win->ctl.speed = req->AccessSpeed;
1913: if (req->Attributes & WIN_MEMORY_TYPE)
1914: win->ctl.flags |= MAP_ATTRIB;
1915: if (req->Attributes & WIN_ENABLE)
1916: win->ctl.flags |= MAP_ACTIVE;
1917: if (req->Attributes & WIN_DATA_WIDTH_16)
1918: win->ctl.flags |= MAP_16BIT;
1919: if (req->Attributes & WIN_USE_WAIT)
1920: win->ctl.flags |= MAP_USE_WAIT;
1921: win->ctl.sys_start = win->base;
1922: win->ctl.sys_stop = win->base + win->size-1;
1923: win->ctl.card_start = 0;
1924: if (s->ss_entry(s->sock, SS_SetMemMap, &win->ctl) != 0)
1925: return CS_BAD_ARGS;
1926: s->state |= SOCKET_WIN_REQ(w);
1927:
1928: /* Return window handle */
1929: req->Base = win->ctl.sys_start;
1930: *handle = (client_handle_t)win;
1931:
1932: return CS_SUCCESS;
1933: } /* request_window */
1934:
1935: /*======================================================================
1936:
1937: I'm not sure which "reset" function this is supposed to use,
1938: but for now, it uses the low-level interface's reset, not the
1939: CIS register.
1940:
1941: ======================================================================*/
1942:
1943: static int reset_card(client_handle_t handle, client_req_t *req)
1944: {
1945: int i, ret;
1946: socket_info_t *s;
1947:
1948: if (CHECK_HANDLE(handle))
1949: return CS_BAD_HANDLE;
1950: i = handle->Socket; s = socket_table[i];
1951: if (!(s->state & SOCKET_PRESENT))
1952: return CS_NO_CARD;
1953: if (s->state & SOCKET_RESET_PENDING)
1954: return CS_IN_USE;
1955: s->state |= SOCKET_RESET_PENDING;
1956:
1957: ret = send_event(s, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1958: if (ret != 0) {
1959: s->state &= ~SOCKET_RESET_PENDING;
1960: handle->event_callback_args.info = (void *)(u_long)ret;
1961: EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1962: } else {
1963: DEBUG(1, "cs: resetting socket %d\n", i);
1964: send_event(s, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1965: s->reset_handle = handle;
1966: reset_socket(i);
1967: }
1968: return CS_SUCCESS;
1969: } /* reset_card */
1970:
1971: /*======================================================================
1972:
1973: These shut down or wake up a socket. They are sort of user
1974: initiated versions of the APM suspend and resume actions.
1975:
1976: ======================================================================*/
1977:
1978: static int suspend_card(client_handle_t handle, client_req_t *req)
1979: {
1980: int i;
1981: socket_info_t *s;
1982:
1983: if (CHECK_HANDLE(handle))
1984: return CS_BAD_HANDLE;
1985: i = handle->Socket; s = socket_table[i];
1986: if (!(s->state & SOCKET_PRESENT))
1987: return CS_NO_CARD;
1988: if (s->state & SOCKET_SUSPEND)
1989: return CS_IN_USE;
1990:
1991: DEBUG(1, "cs: suspending socket %d\n", i);
1992: send_event(s, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
1993: s->ss_entry(s->sock, SS_SetSocket, &dead_socket);
1994: s->state |= SOCKET_SUSPEND;
1995:
1996: return CS_SUCCESS;
1997: } /* suspend_card */
1998:
1999: static int resume_card(client_handle_t handle, client_req_t *req)
2000: {
2001: int i;
2002: socket_info_t *s;
2003:
2004: if (CHECK_HANDLE(handle))
2005: return CS_BAD_HANDLE;
2006: i = handle->Socket; s = socket_table[i];
2007: if (!(s->state & SOCKET_PRESENT))
2008: return CS_NO_CARD;
2009: if (!(s->state & SOCKET_SUSPEND))
2010: return CS_IN_USE;
2011:
2012: DEBUG(1, "cs: waking up socket %d\n", i);
2013: setup_socket(i);
2014:
2015: return CS_SUCCESS;
2016: } /* resume_card */
2017:
2018: /*======================================================================
2019:
2020: These handle user requests to eject or insert a card.
2021:
2022: ======================================================================*/
2023:
2024: static int eject_card(client_handle_t handle, client_req_t *req)
2025: {
2026: int i, ret;
2027: socket_info_t *s;
2028: u_long flags;
2029:
2030: if (CHECK_HANDLE(handle))
2031: return CS_BAD_HANDLE;
2032: i = handle->Socket; s = socket_table[i];
2033: if (!(s->state & SOCKET_PRESENT))
2034: return CS_NO_CARD;
2035:
2036: DEBUG(1, "cs: user eject request on socket %d\n", i);
2037:
2038: ret = send_event(s, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2039: if (ret != 0)
2040: return ret;
2041:
2042: spin_lock_irqsave(&s->lock, flags);
2043: do_shutdown(s);
2044: spin_unlock_irqrestore(&s->lock, flags);
2045:
2046: return CS_SUCCESS;
2047:
2048: } /* eject_card */
2049:
2050: static int insert_card(client_handle_t handle, client_req_t *req)
2051: {
2052: int i, status;
2053: socket_info_t *s;
2054: u_long flags;
2055:
2056: if (CHECK_HANDLE(handle))
2057: return CS_BAD_HANDLE;
2058: i = handle->Socket; s = socket_table[i];
2059: if (s->state & SOCKET_PRESENT)
2060: return CS_IN_USE;
2061:
2062: DEBUG(1, "cs: user insert request on socket %d\n", i);
2063:
2064: spin_lock_irqsave(&s->lock, flags);
2065: if (!(s->state & SOCKET_SETUP_PENDING)) {
2066: s->state |= SOCKET_SETUP_PENDING;
2067: spin_unlock_irqrestore(&s->lock, flags);
2068: s->ss_entry(i, SS_GetStatus, &status);
2069: if (status & SS_DETECT)
2070: setup_socket(i);
2071: else {
2072: s->state &= ~SOCKET_SETUP_PENDING;
2073: return CS_NO_CARD;
2074: }
2075: } else
2076: spin_unlock_irqrestore(&s->lock, flags);
2077:
2078: return CS_SUCCESS;
2079: } /* insert_card */
2080:
2081: /*======================================================================
2082:
2083: Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2084: haven't sent one to this client yet?
2085:
2086: ======================================================================*/
2087:
2088: static int set_event_mask(client_handle_t handle, eventmask_t *mask)
2089: {
2090: u_int events, bit;
2091: if (CHECK_HANDLE(handle))
2092: return CS_BAD_HANDLE;
2093: if (handle->Attributes & CONF_EVENT_MASK_VALID)
2094: return CS_BAD_SOCKET;
2095: handle->EventMask = mask->EventMask;
2096: events = handle->PendingEvents & handle->EventMask;
2097: handle->PendingEvents -= events;
2098: while (events != 0) {
2099: bit = ((events ^ (events-1)) + 1) >> 1;
2100: EVENT(handle, bit, CS_EVENT_PRI_LOW);
2101: events -= bit;
2102: }
2103: return CS_SUCCESS;
2104: } /* set_event_mask */
2105:
2106: /*====================================================================*/
2107:
2108: static int report_error(client_handle_t handle, error_info_t *err)
2109: {
2110: int i;
2111: char *serv;
2112:
2113: if (CHECK_HANDLE(handle))
2114: printk(KERN_NOTICE);
2115: else
2116: printk(KERN_NOTICE "%s: ", handle->dev_info);
2117:
2118: for (i = 0; i < SERVICE_COUNT; i++)
2119: if (service_table[i].key == err->func) break;
2120: if (i < SERVICE_COUNT)
2121: serv = service_table[i].msg;
2122: else
2123: serv = "Unknown service number";
2124:
2125: for (i = 0; i < ERROR_COUNT; i++)
2126: if (error_table[i].key == err->retcode) break;
2127: if (i < ERROR_COUNT)
2128: printk("%s: %s\n", serv, error_table[i].msg);
2129: else
2130: printk("%s: Unknown error code %#x\n", serv, err->retcode);
2131:
2132: return CS_SUCCESS;
2133: } /* report_error */
2134:
2135: /*====================================================================*/
2136:
2137: int CardServices(int func, void *a1, void *a2, void *a3)
2138: {
2139:
2140: #ifdef PCMCIA_DEBUG
2141: if (pc_debug > 2) {
2142: int i;
2143: for (i = 0; i < SERVICE_COUNT; i++)
2144: if (service_table[i].key == func) break;
2145: if (i < SERVICE_COUNT)
2146: printk(KERN_DEBUG "cs: CardServices(%s, 0x%p, 0x%p)\n",
2147: service_table[i].msg, a1, a2);
2148: else
2149: printk(KERN_DEBUG "cs: CardServices(Unknown func %d, "
2150: "0x%p, 0x%p)\n", func, a1, a2);
2151: }
2152: #endif
2153: switch (func) {
2154: case AccessConfigurationRegister:
2155: return access_configuration_register(a1, a2); break;
2156: case AdjustResourceInfo:
2157: return adjust_resource_info(a1, a2); break;
2158: case CheckEraseQueue:
2159: return check_erase_queue(a1); break;
2160: case CloseMemory:
2161: return close_memory(a1); break;
2162: case CopyMemory:
2163: return copy_memory(a1, a2); break;
2164: case DeregisterClient:
2165: return deregister_client(a1); break;
2166: case DeregisterEraseQueue:
2167: return deregister_erase_queue(a1); break;
2168: case GetFirstClient:
2169: return get_first_client(a1, a2); break;
2170: case GetCardServicesInfo:
2171: return get_card_services_info(a1); break;
2172: case GetConfigurationInfo:
2173: return get_configuration_info(a1, a2); break;
2174: case GetNextClient:
2175: return get_next_client(a1, a2); break;
2176: case GetFirstRegion:
2177: return get_first_region(a1, a2); break;
2178: case GetFirstTuple:
2179: return get_first_tuple(a1, a2); break;
2180: case GetNextRegion:
2181: return get_next_region(a1, a2); break;
2182: case GetNextTuple:
2183: return get_next_tuple(a1, a2); break;
2184: case GetStatus:
2185: return cs_get_status(a1, a2); break;
2186: case GetTupleData:
2187: return get_tuple_data(a1, a2); break;
2188: case MapMemPage:
2189: return map_mem_page(a1, a2); break;
2190: case ModifyConfiguration:
2191: return modify_configuration(a1, a2); break;
2192: case ModifyWindow:
2193: return modify_window(a1, a2); break;
2194: case OpenMemory:
2195: return open_memory(a1, a2);
2196: case ParseTuple:
2197: return parse_tuple(a1, a2, a3); break;
2198: case ReadMemory:
2199: return read_memory(a1, a2, a3); break;
2200: case RegisterClient:
2201: return register_client(a1, a2); break;
2202: case RegisterEraseQueue:
2203: return register_erase_queue(a1, a2); break;
2204: case RegisterMTD:
2205: return register_mtd(a1, a2); break;
2206: case ReleaseConfiguration:
2207: return release_configuration(a1, a2); break;
2208: case ReleaseIO:
2209: return release_io(a1, a2); break;
2210: case ReleaseIRQ:
2211: return cs_release_irq(a1, a2); break;
2212: case ReleaseWindow:
2213: return release_window(a1); break;
2214: case RequestConfiguration:
2215: return request_configuration(a1, a2); break;
2216: case RequestIO:
2217: return request_io(a1, a2); break;
2218: case RequestIRQ:
2219: return cs_request_irq(a1, a2); break;
2220: case RequestWindow:
2221: return request_window(a1, a2); break;
2222: case ResetCard:
2223: return reset_card(a1, a2); break;
2224: case SetEventMask:
2225: return set_event_mask(a1, a2); break;
2226: case ValidateCIS:
2227: return validate_cis(a1, a2); break;
2228: case WriteMemory:
2229: return write_memory(a1, a2, a3); break;
2230: case BindDevice:
2231: return bind_device(a1); break;
2232: case BindMTD:
2233: return bind_mtd(a1); break;
2234: case ReportError:
2235: return report_error(a1, a2); break;
2236: case SuspendCard:
2237: return suspend_card(a1, a2); break;
2238: case ResumeCard:
2239: return resume_card(a1, a2); break;
2240: case EjectCard:
2241: return eject_card(a1, a2); break;
2242: case InsertCard:
2243: return insert_card(a1, a2); break;
2244: case ReplaceCIS:
2245: return replace_cis(a1, a2); break;
2246: case GetFirstWindow:
2247: return get_first_window(a1, a2); break;
2248: case GetNextWindow:
2249: return get_next_window(a1, a2); break;
2250: case GetMemPage:
2251: return get_mem_page(a1, a2); break;
2252: default:
2253: return CS_UNSUPPORTED_FUNCTION; break;
2254: }
2255:
2256: } /* CardServices */
2257:
2258: /*======================================================================
2259:
2260: OS-specific module glue goes here
2261:
2262: ======================================================================*/
2263:
2264: #include <linux/pci.h>
2265:
2266: #if (LINUX_VERSION_CODE <= VERSION(2,1,17))
2267:
2268: #undef CONFIG_MODVERSIONS
2269: static struct symbol_table cs_symtab = {
2270: #include <linux/symtab_begin.h>
2271: #undef X
2272: #define X(sym) { (void *)&sym, SYMBOL_NAME_STR(sym) }
2273: X(register_ss_entry),
2274: X(unregister_ss_entry),
2275: X(CardServices),
2276: X(MTDHelperEntry),
2277: #ifdef HAS_PROC_BUS
2278: X(proc_pccard),
2279: #endif
2280: #ifndef HAVE_MEMRESERVE
2281: X(request_mem_region),
2282: X(release_mem_region),
2283: #endif
2284: #ifdef CONFIG_PNP_BIOS
2285: X(check_pnp_irq),
2286: #endif
2287: #ifdef CONFIG_PCI
2288: X(pci_irq_mask),
2289: X(pci_devices),
2290: X(pci_root),
2291: X(pci_find_slot),
2292: X(pci_find_class),
2293: X(pci_enable_device),
2294: X(pci_set_power_state),
2295: #endif
2296: #include <linux/symtab_end.h>
2297: };
2298:
2299: #else
2300:
2301: EXPORT_SYMBOL(register_ss_entry);
2302: EXPORT_SYMBOL(unregister_ss_entry);
2303: EXPORT_SYMBOL(CardServices);
2304: EXPORT_SYMBOL(MTDHelperEntry);
2305: #ifdef HAS_PROC_BUS
2306: EXPORT_SYMBOL(proc_pccard);
2307: #endif
2308: #ifndef HAVE_MEMRESERVE
2309: EXPORT_SYMBOL(request_mem_region);
2310: EXPORT_SYMBOL(release_mem_region);
2311: #endif
2312: #ifdef CONFIG_PNP_BIOS
2313: EXPORT_SYMBOL(check_pnp_irq);
2314: #endif
2315: #ifdef CONFIG_PCI
2316: EXPORT_SYMBOL(pci_irq_mask);
2317: #if (LINUX_VERSION_CODE < VERSION(2,3,24))
2318: EXPORT_SYMBOL(pci_enable_device);
2319: EXPORT_SYMBOL(pci_set_power_state);
2320: #endif
2321: #endif
2322:
2323: #endif
2324:
2325: int __init init_pcmcia_cs(void)
2326: {
2327: printk(KERN_INFO "%s\n", release);
2328: #ifdef UTS_RELEASE
2329: printk(KERN_INFO " %s\n", kernel);
2330: #endif
2331: printk(KERN_INFO " %s\n", options);
2332: DEBUG(0, "%s\n", version);
2333: #ifdef CONFIG_PM
2334: if (do_apm)
2335: pm_register(PM_SYS_DEV, PM_SYS_PCMCIA, handle_pm_event);
2336: #endif
2337: #ifdef CONFIG_PCI
2338: pci_fixup_init();
2339: #endif
2340: #ifdef CONFIG_PNP_BIOS
2341: if (do_pnp) {
2342: pnp_bios_init();
2343: pnp_proc_init();
2344: pnp_rsrc_init();
2345: }
2346: #endif
2347: register_symtab(&cs_symtab);
2348: #ifdef HAS_PROC_BUS
2349: proc_pccard = proc_mkdir("pccard", proc_bus);
2350: #ifdef CONFIG_PNP_BIOS
2351: if (proc_pccard) {
2352: create_proc_read_entry("ioport", 0, proc_pccard,
2353: proc_read_io, NULL);
2354: create_proc_read_entry("irq", 0, proc_pccard,
2355: proc_read_irq, NULL);
2356: }
2357: #endif
2358: #ifndef HAVE_MEMRESERVE
2359: if (proc_pccard)
2360: create_proc_read_entry("memory", 0, proc_pccard,
2361: proc_read_mem, NULL);
2362: #endif
2363: #endif
2364: return 0;
2365: }
2366:
2367: static void __exit exit_pcmcia_cs(void)
2368: {
2369: printk(KERN_INFO "unloading PCMCIA Card Services\n");
2370: #ifdef HAS_PROC_BUS
2371: if (proc_pccard) {
2372: #ifdef CONFIG_PNP_BIOS
2373: remove_proc_entry("ioport", proc_pccard);
2374: remove_proc_entry("irq", proc_pccard);
2375: #endif
2376: #ifndef HAVE_MEMRESERVE
2377: remove_proc_entry("memory", proc_pccard);
2378: #endif
2379: remove_proc_entry("pccard", proc_bus);
2380: }
2381: #endif
2382: #ifdef CONFIG_PM
2383: if (do_apm)
2384: pm_unregister_all(handle_pm_event);
2385: #endif
2386: #ifdef CONFIG_PCI
2387: pci_fixup_done();
2388: #endif
2389: #ifdef CONFIG_PNP_BIOS
2390: if (do_pnp) {
2391: pnp_proc_done();
2392: pnp_rsrc_done();
2393: }
2394: #endif
2395: release_resource_db();
2396: }
2397:
2398: module_init(init_pcmcia_cs);
2399: module_exit(exit_pcmcia_cs);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.