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