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