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