[PATCH] DRIVER MODEL: Get rid of the obsolete tri-level suspend/resume callbacks
[linux-2.6.git] / drivers / pcmcia / tcic.c
1 /*======================================================================
2
3     Device driver for Databook TCIC-2 PCMCIA controller
4
5     tcic.c 1.111 2000/02/15 04:13:12
6
7     The contents of this file are subject to the Mozilla Public
8     License Version 1.1 (the "License"); you may not use this file
9     except in compliance with the License. You may obtain a copy of
10     the License at http://www.mozilla.org/MPL/
11
12     Software distributed under the License is distributed on an "AS
13     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14     implied. See the License for the specific language governing
15     rights and limitations under the License.
16
17     The initial developer of the original code is David A. Hinds
18     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
19     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
20
21     Alternatively, the contents of this file may be used under the
22     terms of the GNU General Public License version 2 (the "GPL"), in which
23     case the provisions of the GPL are applicable instead of the
24     above.  If you wish to allow the use of your version of this file
25     only under the terms of the GPL and not to allow others to use
26     your version of this file under the MPL, indicate your decision
27     by deleting the provisions above and replace them with the notice
28     and other provisions required by the GPL.  If you do not delete
29     the provisions above, a recipient may use your version of this
30     file under either the MPL or the GPL.
31     
32 ======================================================================*/
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/init.h>
37 #include <linux/types.h>
38 #include <linux/fcntl.h>
39 #include <linux/string.h>
40 #include <linux/errno.h>
41 #include <linux/interrupt.h>
42 #include <linux/slab.h>
43 #include <linux/timer.h>
44 #include <linux/ioport.h>
45 #include <linux/delay.h>
46 #include <linux/workqueue.h>
47 #include <linux/device.h>
48 #include <linux/bitops.h>
49
50 #include <asm/io.h>
51 #include <asm/system.h>
52
53 #include <pcmcia/cs_types.h>
54 #include <pcmcia/cs.h>
55 #include <pcmcia/ss.h>
56 #include "tcic.h"
57
58 #ifdef DEBUG
59 static int pc_debug;
60
61 module_param(pc_debug, int, 0644);
62 static const char version[] =
63 "tcic.c 1.111 2000/02/15 04:13:12 (David Hinds)";
64
65 #define debug(lvl, fmt, arg...) do {                            \
66         if (pc_debug > (lvl))                                   \
67                 printk(KERN_DEBUG "tcic: " fmt , ## arg);       \
68 } while (0)
69 #else
70 #define debug(lvl, fmt, arg...) do { } while (0)
71 #endif
72
73 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
74 MODULE_DESCRIPTION("Databook TCIC-2 PCMCIA socket driver");
75 MODULE_LICENSE("Dual MPL/GPL");
76
77 /*====================================================================*/
78
79 /* Parameters that can be set with 'insmod' */
80
81 /* The base port address of the TCIC-2 chip */
82 static unsigned long tcic_base = TCIC_BASE;
83
84 /* Specify a socket number to ignore */
85 static int ignore = -1;
86
87 /* Probe for safe interrupts? */
88 static int do_scan = 1;
89
90 /* Bit map of interrupts to choose from */
91 static u_int irq_mask = 0xffff;
92 static int irq_list[16];
93 static int irq_list_count;
94
95 /* The card status change interrupt -- 0 means autoselect */
96 static int cs_irq;
97
98 /* Poll status interval -- 0 means default to interrupt */
99 static int poll_interval;
100
101 /* Delay for card status double-checking */
102 static int poll_quick = HZ/20;
103
104 /* CCLK external clock time, in nanoseconds.  70 ns = 14.31818 MHz */
105 static int cycle_time = 70;
106
107 module_param(tcic_base, ulong, 0444);
108 module_param(ignore, int, 0444);
109 module_param(do_scan, int, 0444);
110 module_param(irq_mask, int, 0444);
111 module_param_array(irq_list, int, &irq_list_count, 0444);
112 module_param(cs_irq, int, 0444);
113 module_param(poll_interval, int, 0444);
114 module_param(poll_quick, int, 0444);
115 module_param(cycle_time, int, 0444);
116
117 /*====================================================================*/
118
119 static irqreturn_t tcic_interrupt(int irq, void *dev, struct pt_regs *regs);
120 static void tcic_timer(u_long data);
121 static struct pccard_operations tcic_operations;
122
123 struct tcic_socket {
124     u_short     psock;
125     u_char      last_sstat;
126     u_char      id;
127     struct pcmcia_socket        socket;
128 };
129
130 static struct timer_list poll_timer;
131 static int tcic_timer_pending;
132
133 static int sockets;
134 static struct tcic_socket socket_table[2];
135
136 /*====================================================================*/
137
138 /* Trick when selecting interrupts: the TCIC sktirq pin is supposed
139    to map to irq 11, but is coded as 0 or 1 in the irq registers. */
140 #define TCIC_IRQ(x) ((x) ? (((x) == 11) ? 1 : (x)) : 15)
141
142 #ifdef DEBUG_X
143 static u_char tcic_getb(u_char reg)
144 {
145     u_char val = inb(tcic_base+reg);
146     printk(KERN_DEBUG "tcic_getb(%#lx) = %#x\n", tcic_base+reg, val);
147     return val;
148 }
149
150 static u_short tcic_getw(u_char reg)
151 {
152     u_short val = inw(tcic_base+reg);
153     printk(KERN_DEBUG "tcic_getw(%#lx) = %#x\n", tcic_base+reg, val);
154     return val;
155 }
156
157 static void tcic_setb(u_char reg, u_char data)
158 {
159     printk(KERN_DEBUG "tcic_setb(%#lx, %#x)\n", tcic_base+reg, data);
160     outb(data, tcic_base+reg);
161 }
162
163 static void tcic_setw(u_char reg, u_short data)
164 {
165     printk(KERN_DEBUG "tcic_setw(%#lx, %#x)\n", tcic_base+reg, data);
166     outw(data, tcic_base+reg);
167 }
168 #else
169 #define tcic_getb(reg) inb(tcic_base+reg)
170 #define tcic_getw(reg) inw(tcic_base+reg)
171 #define tcic_setb(reg, data) outb(data, tcic_base+reg)
172 #define tcic_setw(reg, data) outw(data, tcic_base+reg)
173 #endif
174
175 static void tcic_setl(u_char reg, u_int data)
176 {
177 #ifdef DEBUG_X
178     printk(KERN_DEBUG "tcic_setl(%#x, %#lx)\n", tcic_base+reg, data);
179 #endif
180     outw(data & 0xffff, tcic_base+reg);
181     outw(data >> 16, tcic_base+reg+2);
182 }
183
184 static u_char tcic_aux_getb(u_short reg)
185 {
186     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
187     tcic_setb(TCIC_MODE, mode);
188     return tcic_getb(TCIC_AUX);
189 }
190
191 static void tcic_aux_setb(u_short reg, u_char data)
192 {
193     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
194     tcic_setb(TCIC_MODE, mode);
195     tcic_setb(TCIC_AUX, data);
196 }
197
198 static u_short tcic_aux_getw(u_short reg)
199 {
200     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
201     tcic_setb(TCIC_MODE, mode);
202     return tcic_getw(TCIC_AUX);
203 }
204
205 static void tcic_aux_setw(u_short reg, u_short data)
206 {
207     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
208     tcic_setb(TCIC_MODE, mode);
209     tcic_setw(TCIC_AUX, data);
210 }
211
212 /*====================================================================*/
213
214 /* Time conversion functions */
215
216 static int to_cycles(int ns)
217 {
218     if (ns < 14)
219         return 0;
220     else
221         return 2*(ns-14)/cycle_time;
222 }
223
224 /*====================================================================*/
225
226 static volatile u_int irq_hits;
227
228 static irqreturn_t __init tcic_irq_count(int irq, void *dev, struct pt_regs *regs)
229 {
230     irq_hits++;
231     return IRQ_HANDLED;
232 }
233
234 static u_int __init try_irq(int irq)
235 {
236     u_short cfg;
237
238     irq_hits = 0;
239     if (request_irq(irq, tcic_irq_count, 0, "irq scan", tcic_irq_count) != 0)
240         return -1;
241     mdelay(10);
242     if (irq_hits) {
243         free_irq(irq, tcic_irq_count);
244         return -1;
245     }
246
247     /* Generate one interrupt */
248     cfg = TCIC_SYSCFG_AUTOBUSY | 0x0a00;
249     tcic_aux_setw(TCIC_AUX_SYSCFG, cfg | TCIC_IRQ(irq));
250     tcic_setb(TCIC_IENA, TCIC_IENA_ERR | TCIC_IENA_CFG_HIGH);
251     tcic_setb(TCIC_ICSR, TCIC_ICSR_ERR | TCIC_ICSR_JAM);
252
253     udelay(1000);
254     free_irq(irq, tcic_irq_count);
255
256     /* Turn off interrupts */
257     tcic_setb(TCIC_IENA, TCIC_IENA_CFG_OFF);
258     while (tcic_getb(TCIC_ICSR))
259         tcic_setb(TCIC_ICSR, TCIC_ICSR_JAM);
260     tcic_aux_setw(TCIC_AUX_SYSCFG, cfg);
261     
262     return (irq_hits != 1);
263 }
264
265 static u_int __init irq_scan(u_int mask0)
266 {
267     u_int mask1;
268     int i;
269
270 #ifdef __alpha__
271 #define PIC 0x4d0
272     /* Don't probe level-triggered interrupts -- reserved for PCI */
273     int level_mask = inb_p(PIC) | (inb_p(PIC+1) << 8);
274     if (level_mask)
275         mask0 &= ~level_mask;
276 #endif
277
278     mask1 = 0;
279     if (do_scan) {
280         for (i = 0; i < 16; i++)
281             if ((mask0 & (1 << i)) && (try_irq(i) == 0))
282                 mask1 |= (1 << i);
283         for (i = 0; i < 16; i++)
284             if ((mask1 & (1 << i)) && (try_irq(i) != 0)) {
285                 mask1 ^= (1 << i);
286             }
287     }
288     
289     if (mask1) {
290         printk("scanned");
291     } else {
292         /* Fallback: just find interrupts that aren't in use */
293         for (i = 0; i < 16; i++)
294             if ((mask0 & (1 << i)) &&
295                 (request_irq(i, tcic_irq_count, 0, "x", tcic_irq_count) == 0)) {
296                 mask1 |= (1 << i);
297                 free_irq(i, tcic_irq_count);
298             }
299         printk("default");
300     }
301     
302     printk(") = ");
303     for (i = 0; i < 16; i++)
304         if (mask1 & (1<<i))
305             printk("%s%d", ((mask1 & ((1<<i)-1)) ? "," : ""), i);
306     printk(" ");
307     
308     return mask1;
309 }
310
311 /*======================================================================
312
313     See if a card is present, powered up, in IO mode, and already
314     bound to a (non-PCMCIA) Linux driver.
315
316     We make an exception for cards that look like serial devices.
317     
318 ======================================================================*/
319
320 static int __init is_active(int s)
321 {
322     u_short scf1, ioctl, base, num;
323     u_char pwr, sstat;
324     u_int addr;
325     
326     tcic_setl(TCIC_ADDR, (s << TCIC_ADDR_SS_SHFT)
327               | TCIC_ADDR_INDREG | TCIC_SCF1(s));
328     scf1 = tcic_getw(TCIC_DATA);
329     pwr = tcic_getb(TCIC_PWR);
330     sstat = tcic_getb(TCIC_SSTAT);
331     addr = TCIC_IWIN(s, 0);
332     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
333     base = tcic_getw(TCIC_DATA);
334     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
335     ioctl = tcic_getw(TCIC_DATA);
336
337     if (ioctl & TCIC_ICTL_TINY)
338         num = 1;
339     else {
340         num = (base ^ (base-1));
341         base = base & (base-1);
342     }
343
344     if ((sstat & TCIC_SSTAT_CD) && (pwr & TCIC_PWR_VCC(s)) &&
345         (scf1 & TCIC_SCF1_IOSTS) && (ioctl & TCIC_ICTL_ENA) &&
346         ((base & 0xfeef) != 0x02e8)) {
347         struct resource *res = request_region(base, num, "tcic-2");
348         if (!res) /* region is busy */
349             return 1;
350         release_region(base, num);
351     }
352
353     return 0;
354 }
355
356 /*======================================================================
357
358     This returns the revision code for the specified socket.
359     
360 ======================================================================*/
361
362 static int __init get_tcic_id(void)
363 {
364     u_short id;
365     
366     tcic_aux_setw(TCIC_AUX_TEST, TCIC_TEST_DIAG);
367     id = tcic_aux_getw(TCIC_AUX_ILOCK);
368     id = (id & TCIC_ILOCKTEST_ID_MASK) >> TCIC_ILOCKTEST_ID_SH;
369     tcic_aux_setw(TCIC_AUX_TEST, 0);
370     return id;
371 }
372
373 /*====================================================================*/
374
375 static struct device_driver tcic_driver = {
376         .name = "tcic-pcmcia",
377         .bus = &platform_bus_type,
378         .suspend = pcmcia_socket_dev_suspend,
379         .resume = pcmcia_socket_dev_resume,
380 };
381
382 static struct platform_device tcic_device = {
383         .name = "tcic-pcmcia",
384         .id = 0,
385 };
386
387
388 static int __init init_tcic(void)
389 {
390     int i, sock, ret = 0;
391     u_int mask, scan;
392
393     if (driver_register(&tcic_driver))
394         return -1;
395     
396     printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
397     sock = 0;
398
399     if (!request_region(tcic_base, 16, "tcic-2")) {
400         printk("could not allocate ports,\n ");
401         driver_unregister(&tcic_driver);
402         return -ENODEV;
403     }
404     else {
405         tcic_setw(TCIC_ADDR, 0);
406         if (tcic_getw(TCIC_ADDR) == 0) {
407             tcic_setw(TCIC_ADDR, 0xc3a5);
408             if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
409         }
410         if (sock == 0) {
411             /* See if resetting the controller does any good */
412             tcic_setb(TCIC_SCTRL, TCIC_SCTRL_RESET);
413             tcic_setb(TCIC_SCTRL, 0);
414             tcic_setw(TCIC_ADDR, 0);
415             if (tcic_getw(TCIC_ADDR) == 0) {
416                 tcic_setw(TCIC_ADDR, 0xc3a5);
417                 if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
418             }
419         }
420     }
421     if (sock == 0) {
422         printk("not found.\n");
423         release_region(tcic_base, 16);
424         driver_unregister(&tcic_driver);
425         return -ENODEV;
426     }
427
428     sockets = 0;
429     for (i = 0; i < sock; i++) {
430         if ((i == ignore) || is_active(i)) continue;
431         socket_table[sockets].psock = i;
432         socket_table[sockets].id = get_tcic_id();
433
434         socket_table[sockets].socket.owner = THIS_MODULE;
435         /* only 16-bit cards, memory windows must be size-aligned */
436         /* No PCI or CardBus support */
437         socket_table[sockets].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN;
438         /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
439         socket_table[sockets].socket.irq_mask = 0x4cf8;
440         /* 4K minimum window size */
441         socket_table[sockets].socket.map_size = 0x1000;         
442         sockets++;
443     }
444
445     switch (socket_table[0].id) {
446     case TCIC_ID_DB86082:
447         printk("DB86082"); break;
448     case TCIC_ID_DB86082A:
449         printk("DB86082A"); break;
450     case TCIC_ID_DB86084:
451         printk("DB86084"); break;
452     case TCIC_ID_DB86084A:
453         printk("DB86084A"); break;
454     case TCIC_ID_DB86072:
455         printk("DB86072"); break;
456     case TCIC_ID_DB86184:
457         printk("DB86184"); break;
458     case TCIC_ID_DB86082B:
459         printk("DB86082B"); break;
460     default:
461         printk("Unknown ID 0x%02x", socket_table[0].id);
462     }
463     
464     /* Set up polling */
465     poll_timer.function = &tcic_timer;
466     poll_timer.data = 0;
467     init_timer(&poll_timer);
468
469     /* Build interrupt mask */
470     printk(", %d sockets\n" KERN_INFO "  irq list (", sockets);
471     if (irq_list_count == 0)
472         mask = irq_mask;
473     else
474         for (i = mask = 0; i < irq_list_count; i++)
475             mask |= (1<<irq_list[i]);
476
477     /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
478     mask &= 0x4cf8;
479     /* Scan interrupts */
480     mask = irq_scan(mask);
481     for (i=0;i<sockets;i++)
482             socket_table[i].socket.irq_mask = mask;
483     
484     /* Check for only two interrupts available */
485     scan = (mask & (mask-1));
486     if (((scan & (scan-1)) == 0) && (poll_interval == 0))
487         poll_interval = HZ;
488     
489     if (poll_interval == 0) {
490         /* Avoid irq 12 unless it is explicitly requested */
491         u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
492         for (i = 15; i > 0; i--)
493             if ((cs_mask & (1 << i)) &&
494                 (request_irq(i, tcic_interrupt, 0, "tcic",
495                              tcic_interrupt) == 0))
496                 break;
497         cs_irq = i;
498         if (cs_irq == 0) poll_interval = HZ;
499     }
500     
501     if (socket_table[0].socket.irq_mask & (1 << 11))
502         printk("sktirq is irq 11, ");
503     if (cs_irq != 0)
504         printk("status change on irq %d\n", cs_irq);
505     else
506         printk("polled status, interval = %d ms\n",
507                poll_interval * 1000 / HZ);
508     
509     for (i = 0; i < sockets; i++) {
510         tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT);
511         socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT);
512     }
513     
514     /* jump start interrupt handler, if needed */
515     tcic_interrupt(0, NULL, NULL);
516
517     platform_device_register(&tcic_device);
518
519     for (i = 0; i < sockets; i++) {
520             socket_table[i].socket.ops = &tcic_operations;
521             socket_table[i].socket.resource_ops = &pccard_nonstatic_ops;
522             socket_table[i].socket.dev.dev = &tcic_device.dev;
523             ret = pcmcia_register_socket(&socket_table[i].socket);
524             if (ret && i)
525                     pcmcia_unregister_socket(&socket_table[0].socket);
526     }
527     
528     return ret;
529
530     return 0;
531     
532 } /* init_tcic */
533
534 /*====================================================================*/
535
536 static void __exit exit_tcic(void)
537 {
538     int i;
539
540     del_timer_sync(&poll_timer);
541     if (cs_irq != 0) {
542         tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00);
543         free_irq(cs_irq, tcic_interrupt);
544     }
545     release_region(tcic_base, 16);
546
547     for (i = 0; i < sockets; i++) {
548             pcmcia_unregister_socket(&socket_table[i].socket);      
549     }
550
551     platform_device_unregister(&tcic_device);
552     driver_unregister(&tcic_driver);
553 } /* exit_tcic */
554
555 /*====================================================================*/
556
557 static irqreturn_t tcic_interrupt(int irq, void *dev, struct pt_regs *regs)
558 {
559     int i, quick = 0;
560     u_char latch, sstat;
561     u_short psock;
562     u_int events;
563     static volatile int active = 0;
564
565     if (active) {
566         printk(KERN_NOTICE "tcic: reentered interrupt handler!\n");
567         return IRQ_NONE;
568     } else
569         active = 1;
570
571     debug(2, "tcic_interrupt()\n");
572     
573     for (i = 0; i < sockets; i++) {
574         psock = socket_table[i].psock;
575         tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
576                   | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
577         sstat = tcic_getb(TCIC_SSTAT);
578         latch = sstat ^ socket_table[psock].last_sstat;
579         socket_table[i].last_sstat = sstat;
580         if (tcic_getb(TCIC_ICSR) & TCIC_ICSR_CDCHG) {
581             tcic_setb(TCIC_ICSR, TCIC_ICSR_CLEAR);
582             quick = 1;
583         }
584         if (latch == 0)
585             continue;
586         events = (latch & TCIC_SSTAT_CD) ? SS_DETECT : 0;
587         events |= (latch & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
588         if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
589             events |= (latch & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
590         } else {
591             events |= (latch & TCIC_SSTAT_RDY) ? SS_READY : 0;
592             events |= (latch & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
593             events |= (latch & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
594         }
595         if (events) {
596                 pcmcia_parse_events(&socket_table[i].socket, events);
597         }
598     }
599
600     /* Schedule next poll, if needed */
601     if (((cs_irq == 0) || quick) && (!tcic_timer_pending)) {
602         poll_timer.expires = jiffies + (quick ? poll_quick : poll_interval);
603         add_timer(&poll_timer);
604         tcic_timer_pending = 1;
605     }
606     active = 0;
607     
608     debug(2, "interrupt done\n");
609     return IRQ_HANDLED;
610 } /* tcic_interrupt */
611
612 static void tcic_timer(u_long data)
613 {
614     debug(2, "tcic_timer()\n");
615     tcic_timer_pending = 0;
616     tcic_interrupt(0, NULL, NULL);
617 } /* tcic_timer */
618
619 /*====================================================================*/
620
621 static int tcic_get_status(struct pcmcia_socket *sock, u_int *value)
622 {
623     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
624     u_char reg;
625
626     tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
627               | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
628     reg = tcic_getb(TCIC_SSTAT);
629     *value  = (reg & TCIC_SSTAT_CD) ? SS_DETECT : 0;
630     *value |= (reg & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
631     if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
632         *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
633     } else {
634         *value |= (reg & TCIC_SSTAT_RDY) ? SS_READY : 0;
635         *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
636         *value |= (reg & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
637     }
638     reg = tcic_getb(TCIC_PWR);
639     if (reg & (TCIC_PWR_VCC(psock)|TCIC_PWR_VPP(psock)))
640         *value |= SS_POWERON;
641     debug(1, "GetStatus(%d) = %#2.2x\n", psock, *value);
642     return 0;
643 } /* tcic_get_status */
644   
645 /*====================================================================*/
646
647 static int tcic_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
648 {
649     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
650     u_char reg;
651     u_short scf1, scf2;
652     
653     tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
654               | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
655     scf1 = tcic_getw(TCIC_DATA);
656     state->flags = (scf1 & TCIC_SCF1_IOSTS) ? SS_IOCARD : 0;
657     state->flags |= (scf1 & TCIC_SCF1_DMA_MASK) ? SS_DMA_MODE : 0;
658     state->flags |= (scf1 & TCIC_SCF1_SPKR) ? SS_SPKR_ENA : 0;
659     if (tcic_getb(TCIC_SCTRL) & TCIC_SCTRL_ENA)
660         state->flags |= SS_OUTPUT_ENA;
661     state->io_irq = scf1 & TCIC_SCF1_IRQ_MASK;
662     if (state->io_irq == 1) state->io_irq = 11;
663
664     reg = tcic_getb(TCIC_PWR);
665     state->Vcc = state->Vpp = 0;
666     if (reg & TCIC_PWR_VCC(psock)) {
667         if (reg & TCIC_PWR_VPP(psock))
668             state->Vcc = 50;
669         else
670             state->Vcc = state->Vpp = 50;
671     } else {
672         if (reg & TCIC_PWR_VPP(psock)) {
673             state->Vcc = 50;
674             state->Vpp = 120;
675         }
676     }
677     reg = tcic_aux_getb(TCIC_AUX_ILOCK);
678     state->flags |= (reg & TCIC_ILOCK_CRESET) ? SS_RESET : 0;
679
680     /* Card status change interrupt mask */
681     tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
682     scf2 = tcic_getw(TCIC_DATA);
683     state->csc_mask = (scf2 & TCIC_SCF2_MCD) ? 0 : SS_DETECT;
684     if (state->flags & SS_IOCARD) {
685         state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_STSCHG;
686     } else {
687         state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_BATDEAD;
688         state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT2) ? 0 : SS_BATWARN;
689         state->csc_mask |= (scf2 & TCIC_SCF2_MRDY) ? 0 : SS_READY;
690     }
691
692     debug(1, "GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
693           "io_irq %d, csc_mask %#2.2x\n", psock, state->flags,
694           state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
695     return 0;
696 } /* tcic_get_socket */
697
698 /*====================================================================*/
699
700 static int tcic_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
701 {
702     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
703     u_char reg;
704     u_short scf1, scf2;
705
706     debug(1, "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
707           "io_irq %d, csc_mask %#2.2x)\n", psock, state->flags,
708           state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
709     tcic_setw(TCIC_ADDR+2, (psock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
710
711     reg = tcic_getb(TCIC_PWR);
712     reg &= ~(TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock));
713
714     if (state->Vcc == 50) {
715         switch (state->Vpp) {
716         case 0:   reg |= TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock); break;
717         case 50:  reg |= TCIC_PWR_VCC(psock); break;
718         case 120: reg |= TCIC_PWR_VPP(psock); break;
719         default:  return -EINVAL;
720         }
721     } else if (state->Vcc != 0)
722         return -EINVAL;
723
724     if (reg != tcic_getb(TCIC_PWR))
725         tcic_setb(TCIC_PWR, reg);
726
727     reg = TCIC_ILOCK_HOLD_CCLK | TCIC_ILOCK_CWAIT;
728     if (state->flags & SS_OUTPUT_ENA) {
729         tcic_setb(TCIC_SCTRL, TCIC_SCTRL_ENA);
730         reg |= TCIC_ILOCK_CRESENA;
731     } else
732         tcic_setb(TCIC_SCTRL, 0);
733     if (state->flags & SS_RESET)
734         reg |= TCIC_ILOCK_CRESET;
735     tcic_aux_setb(TCIC_AUX_ILOCK, reg);
736     
737     tcic_setw(TCIC_ADDR, TCIC_SCF1(psock));
738     scf1 = TCIC_SCF1_FINPACK;
739     scf1 |= TCIC_IRQ(state->io_irq);
740     if (state->flags & SS_IOCARD) {
741         scf1 |= TCIC_SCF1_IOSTS;
742         if (state->flags & SS_SPKR_ENA)
743             scf1 |= TCIC_SCF1_SPKR;
744         if (state->flags & SS_DMA_MODE)
745             scf1 |= TCIC_SCF1_DREQ2 << TCIC_SCF1_DMA_SHIFT;
746     }
747     tcic_setw(TCIC_DATA, scf1);
748
749     /* Some general setup stuff, and configure status interrupt */
750     reg = TCIC_WAIT_ASYNC | TCIC_WAIT_SENSE | to_cycles(250);
751     tcic_aux_setb(TCIC_AUX_WCTL, reg);
752     tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00|
753                   TCIC_IRQ(cs_irq));
754     
755     /* Card status change interrupt mask */
756     tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
757     scf2 = TCIC_SCF2_MALL;
758     if (state->csc_mask & SS_DETECT) scf2 &= ~TCIC_SCF2_MCD;
759     if (state->flags & SS_IOCARD) {
760         if (state->csc_mask & SS_STSCHG) reg &= ~TCIC_SCF2_MLBAT1;
761     } else {
762         if (state->csc_mask & SS_BATDEAD) reg &= ~TCIC_SCF2_MLBAT1;
763         if (state->csc_mask & SS_BATWARN) reg &= ~TCIC_SCF2_MLBAT2;
764         if (state->csc_mask & SS_READY) reg &= ~TCIC_SCF2_MRDY;
765     }
766     tcic_setw(TCIC_DATA, scf2);
767     /* For the ISA bus, the irq should be active-high totem-pole */
768     tcic_setb(TCIC_IENA, TCIC_IENA_CDCHG | TCIC_IENA_CFG_HIGH);
769
770     return 0;
771 } /* tcic_set_socket */
772   
773 /*====================================================================*/
774
775 static int tcic_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
776 {
777     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
778     u_int addr;
779     u_short base, len, ioctl;
780     
781     debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
782           "%#lx-%#lx)\n", psock, io->map, io->flags,
783           io->speed, io->start, io->stop);
784     if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
785         (io->stop < io->start)) return -EINVAL;
786     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
787     addr = TCIC_IWIN(psock, io->map);
788
789     base = io->start; len = io->stop - io->start;
790     /* Check to see that len+1 is power of two, etc */
791     if ((len & (len+1)) || (base & len)) return -EINVAL;
792     base |= (len+1)>>1;
793     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
794     tcic_setw(TCIC_DATA, base);
795     
796     ioctl  = (psock << TCIC_ICTL_SS_SHFT);
797     ioctl |= (len == 0) ? TCIC_ICTL_TINY : 0;
798     ioctl |= (io->flags & MAP_ACTIVE) ? TCIC_ICTL_ENA : 0;
799     ioctl |= to_cycles(io->speed) & TCIC_ICTL_WSCNT_MASK;
800     if (!(io->flags & MAP_AUTOSZ)) {
801         ioctl |= TCIC_ICTL_QUIET;
802         ioctl |= (io->flags & MAP_16BIT) ? TCIC_ICTL_BW_16 : TCIC_ICTL_BW_8;
803     }
804     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
805     tcic_setw(TCIC_DATA, ioctl);
806     
807     return 0;
808 } /* tcic_set_io_map */
809
810 /*====================================================================*/
811
812 static int tcic_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
813 {
814     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
815     u_short addr, ctl;
816     u_long base, len, mmap;
817
818     debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, "
819           "%#lx-%#lx, %#x)\n", psock, mem->map, mem->flags,
820           mem->speed, mem->res->start, mem->res->end, mem->card_start);
821     if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
822         (mem->res->start > 0xffffff) || (mem->res->end > 0xffffff) ||
823         (mem->res->start > mem->res->end) || (mem->speed > 1000))
824         return -EINVAL;
825     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
826     addr = TCIC_MWIN(psock, mem->map);
827
828     base = mem->res->start; len = mem->res->end - mem->res->start;
829     if ((len & (len+1)) || (base & len)) return -EINVAL;
830     if (len == 0x0fff)
831         base = (base >> TCIC_MBASE_HA_SHFT) | TCIC_MBASE_4K_BIT;
832     else
833         base = (base | (len+1)>>1) >> TCIC_MBASE_HA_SHFT;
834     tcic_setw(TCIC_ADDR, addr + TCIC_MBASE_X);
835     tcic_setw(TCIC_DATA, base);
836     
837     mmap = mem->card_start - mem->res->start;
838     mmap = (mmap >> TCIC_MMAP_CA_SHFT) & TCIC_MMAP_CA_MASK;
839     if (mem->flags & MAP_ATTRIB) mmap |= TCIC_MMAP_REG;
840     tcic_setw(TCIC_ADDR, addr + TCIC_MMAP_X);
841     tcic_setw(TCIC_DATA, mmap);
842
843     ctl  = TCIC_MCTL_QUIET | (psock << TCIC_MCTL_SS_SHFT);
844     ctl |= to_cycles(mem->speed) & TCIC_MCTL_WSCNT_MASK;
845     ctl |= (mem->flags & MAP_16BIT) ? 0 : TCIC_MCTL_B8;
846     ctl |= (mem->flags & MAP_WRPROT) ? TCIC_MCTL_WP : 0;
847     ctl |= (mem->flags & MAP_ACTIVE) ? TCIC_MCTL_ENA : 0;
848     tcic_setw(TCIC_ADDR, addr + TCIC_MCTL_X);
849     tcic_setw(TCIC_DATA, ctl);
850     
851     return 0;
852 } /* tcic_set_mem_map */
853
854 /*====================================================================*/
855
856 static int tcic_init(struct pcmcia_socket *s)
857 {
858         int i;
859         struct resource res = { .start = 0, .end = 0x1000 };
860         pccard_io_map io = { 0, 0, 0, 0, 1 };
861         pccard_mem_map mem = { .res = &res, };
862
863         for (i = 0; i < 2; i++) {
864                 io.map = i;
865                 tcic_set_io_map(s, &io);
866         }
867         for (i = 0; i < 5; i++) {
868                 mem.map = i;
869                 tcic_set_mem_map(s, &mem);
870         }
871         return 0;
872 }
873
874 static struct pccard_operations tcic_operations = {
875         .init              = tcic_init,
876         .get_status        = tcic_get_status,
877         .get_socket        = tcic_get_socket,
878         .set_socket        = tcic_set_socket,
879         .set_io_map        = tcic_set_io_map,
880         .set_mem_map       = tcic_set_mem_map,
881 };
882
883 /*====================================================================*/
884
885 module_init(init_tcic);
886 module_exit(exit_tcic);