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