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