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(", %d sockets\n" KERN_INFO "  irq list (", sockets);
 476     if (irq_list_count == 0)
 477         mask = irq_mask;
 478     else
 479         for (i = mask = 0; i < irq_list_count; i++)
 480             mask |= (1<<irq_list[i]);
 481
 482     /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
 483     mask &= 0x4cf8;
 484     /* Scan interrupts */
 485     mask = irq_scan(mask);
 486     for (i=0;i<sockets;i++)
 487             socket_table[i].socket.irq_mask = mask;
 488
 489     /* Check for only two interrupts available */
 490     scan = (mask & (mask-1));
 491     if (((scan & (scan-1)) == 0) && (poll_interval == 0))
 492         poll_interval = HZ;
 493
 494     if (poll_interval == 0) {
 495         /* Avoid irq 12 unless it is explicitly requested */
 496         u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
 497         for (i = 15; i > 0; i--)
 498             if ((cs_mask & (1 << i)) &&
 499                 (request_irq(i, tcic_interrupt, 0, "tcic",
 500                              tcic_interrupt) == 0))
 501                 break;
 502         cs_irq = i;
 503         if (cs_irq == 0) poll_interval = HZ;
 504     }
 505
 506     if (socket_table[0].socket.irq_mask & (1 << 11))
 507         printk("sktirq is irq 11, ");
 508     if (cs_irq != 0)
 509         printk("status change on irq %d\n", cs_irq);
 510     else
 511         printk("polled status, interval = %d ms\n",
 512                poll_interval * 1000 / HZ);
 513
 514     for (i = 0; i < sockets; i++) {
 515         tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT);
 516         socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT);
 517     }
 518
 519     /* jump start interrupt handler, if needed */
 520     tcic_interrupt(0, NULL);
 521
 522     platform_device_register(&tcic_device);
 523
 524     for (i = 0; i < sockets; i++) {
 525             socket_table[i].socket.ops = &tcic_operations;
 526             socket_table[i].socket.resource_ops = &pccard_nonstatic_ops;
 527             socket_table[i].socket.dev.parent = &tcic_device.dev;
 528             ret = pcmcia_register_socket(&socket_table[i].socket);
 529             if (ret && i)
 530                     pcmcia_unregister_socket(&socket_table[0].socket);
 531     }
 532
 533     return ret;
 534
 535     return 0;
 536
 537 } /* init_tcic */
 538
 539 /*====================================================================*/
 540
 541 static void __exit exit_tcic(void)
 542 {
 543     int i;
 544
 545     del_timer_sync(&poll_timer);
 546     if (cs_irq != 0) {
 547         tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00);
 548         free_irq(cs_irq, tcic_interrupt);
 549     }
 550     release_region(tcic_base, 16);
 551
 552     for (i = 0; i < sockets; i++) {
 553             pcmcia_unregister_socket(&socket_table[i].socket);
 554     }
 555
 556     platform_device_unregister(&tcic_device);
 557     platform_driver_unregister(&tcic_driver);
 558 } /* exit_tcic */
 559
 560 /*====================================================================*/
 561
 562 static irqreturn_t tcic_interrupt(int irq, void *dev)
 563 {
 564     int i, quick = 0;
 565     u_char latch, sstat;
 566     u_short psock;
 567     u_int events;
 568     static volatile int active = 0;
 569
 570     if (active) {
 571         printk(KERN_NOTICE "tcic: reentered interrupt handler!\n");
 572         return IRQ_NONE;
 573     } else
 574         active = 1;
 575
 576     debug(2, "tcic_interrupt()\n");
 577
 578     for (i = 0; i < sockets; i++) {
 579         psock = socket_table[i].psock;
 580         tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
 581                   | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
 582         sstat = tcic_getb(TCIC_SSTAT);
 583         latch = sstat ^ socket_table[psock].last_sstat;
 584         socket_table[i].last_sstat = sstat;
 585         if (tcic_getb(TCIC_ICSR) & TCIC_ICSR_CDCHG) {
 586             tcic_setb(TCIC_ICSR, TCIC_ICSR_CLEAR);
 587             quick = 1;
 588         }
 589         if (latch == 0)
 590             continue;
 591         events = (latch & TCIC_SSTAT_CD) ? SS_DETECT : 0;
 592         events |= (latch & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
 593         if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
 594             events |= (latch & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
 595         } else {
 596             events |= (latch & TCIC_SSTAT_RDY) ? SS_READY : 0;
 597             events |= (latch & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
 598             events |= (latch & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
 599         }
 600         if (events) {
 601                 pcmcia_parse_events(&socket_table[i].socket, events);
 602         }
 603     }
 604
 605     /* Schedule next poll, if needed */
 606     if (((cs_irq == 0) || quick) && (!tcic_timer_pending)) {
 607         poll_timer.expires = jiffies + (quick ? poll_quick : poll_interval);
 608         add_timer(&poll_timer);
 609         tcic_timer_pending = 1;
 610     }
 611     active = 0;
 612
 613     debug(2, "interrupt done\n");
 614     return IRQ_HANDLED;
 615 } /* tcic_interrupt */
 616
 617 static void tcic_timer(u_long data)
 618 {
 619     debug(2, "tcic_timer()\n");
 620     tcic_timer_pending = 0;
 621     tcic_interrupt(0, NULL);
 622 } /* tcic_timer */
 623
 624 /*====================================================================*/
 625
 626 static int tcic_get_status(struct pcmcia_socket *sock, u_int *value)
 627 {
 628     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
 629     u_char reg;
 630
 631     tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
 632               | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
 633     reg = tcic_getb(TCIC_SSTAT);
 634     *value  = (reg & TCIC_SSTAT_CD) ? SS_DETECT : 0;
 635     *value |= (reg & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
 636     if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
 637         *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
 638     } else {
 639         *value |= (reg & TCIC_SSTAT_RDY) ? SS_READY : 0;
 640         *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
 641         *value |= (reg & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
 642     }
 643     reg = tcic_getb(TCIC_PWR);
 644     if (reg & (TCIC_PWR_VCC(psock)|TCIC_PWR_VPP(psock)))
 645         *value |= SS_POWERON;
 646     debug(1, "GetStatus(%d) = %#2.2x\n", psock, *value);
 647     return 0;
 648 } /* tcic_get_status */
 649
 650 /*====================================================================*/
 651
 652 static int tcic_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 653 {
 654     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
 655     u_char reg;
 656     u_short scf1, scf2;
 657
 658     debug(1, "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
 659           "io_irq %d, csc_mask %#2.2x)\n", psock, state->flags,
 660           state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
 661     tcic_setw(TCIC_ADDR+2, (psock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
 662
 663     reg = tcic_getb(TCIC_PWR);
 664     reg &= ~(TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock));
 665
 666     if (state->Vcc == 50) {
 667         switch (state->Vpp) {
 668         case 0:   reg |= TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock); break;
 669         case 50:  reg |= TCIC_PWR_VCC(psock); break;
 670         case 120: reg |= TCIC_PWR_VPP(psock); break;
 671         default:  return -EINVAL;
 672         }
 673     } else if (state->Vcc != 0)
 674         return -EINVAL;
 675
 676     if (reg != tcic_getb(TCIC_PWR))
 677         tcic_setb(TCIC_PWR, reg);
 678
 679     reg = TCIC_ILOCK_HOLD_CCLK | TCIC_ILOCK_CWAIT;
 680     if (state->flags & SS_OUTPUT_ENA) {
 681         tcic_setb(TCIC_SCTRL, TCIC_SCTRL_ENA);
 682         reg |= TCIC_ILOCK_CRESENA;
 683     } else
 684         tcic_setb(TCIC_SCTRL, 0);
 685     if (state->flags & SS_RESET)
 686         reg |= TCIC_ILOCK_CRESET;
 687     tcic_aux_setb(TCIC_AUX_ILOCK, reg);
 688
 689     tcic_setw(TCIC_ADDR, TCIC_SCF1(psock));
 690     scf1 = TCIC_SCF1_FINPACK;
 691     scf1 |= TCIC_IRQ(state->io_irq);
 692     if (state->flags & SS_IOCARD) {
 693         scf1 |= TCIC_SCF1_IOSTS;
 694         if (state->flags & SS_SPKR_ENA)
 695             scf1 |= TCIC_SCF1_SPKR;
 696         if (state->flags & SS_DMA_MODE)
 697             scf1 |= TCIC_SCF1_DREQ2 << TCIC_SCF1_DMA_SHIFT;
 698     }
 699     tcic_setw(TCIC_DATA, scf1);
 700
 701     /* Some general setup stuff, and configure status interrupt */
 702     reg = TCIC_WAIT_ASYNC | TCIC_WAIT_SENSE | to_cycles(250);
 703     tcic_aux_setb(TCIC_AUX_WCTL, reg);
 704     tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00|
 705                   TCIC_IRQ(cs_irq));
 706
 707     /* Card status change interrupt mask */
 708     tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
 709     scf2 = TCIC_SCF2_MALL;
 710     if (state->csc_mask & SS_DETECT) scf2 &= ~TCIC_SCF2_MCD;
 711     if (state->flags & SS_IOCARD) {
 712         if (state->csc_mask & SS_STSCHG) reg &= ~TCIC_SCF2_MLBAT1;
 713     } else {
 714         if (state->csc_mask & SS_BATDEAD) reg &= ~TCIC_SCF2_MLBAT1;
 715         if (state->csc_mask & SS_BATWARN) reg &= ~TCIC_SCF2_MLBAT2;
 716         if (state->csc_mask & SS_READY) reg &= ~TCIC_SCF2_MRDY;
 717     }
 718     tcic_setw(TCIC_DATA, scf2);
 719     /* For the ISA bus, the irq should be active-high totem-pole */
 720     tcic_setb(TCIC_IENA, TCIC_IENA_CDCHG | TCIC_IENA_CFG_HIGH);
 721
 722     return 0;
 723 } /* tcic_set_socket */
 724
 725 /*====================================================================*/
 726
 727 static int tcic_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
 728 {
 729     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
 730     u_int addr;
 731     u_short base, len, ioctl;
 732
 733     debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
 734           "%#x-%#x)\n", psock, io->map, io->flags,
 735           io->speed, io->start, io->stop);
 736     if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
 737         (io->stop < io->start)) return -EINVAL;
 738     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
 739     addr = TCIC_IWIN(psock, io->map);
 740
 741     base = io->start; len = io->stop - io->start;
 742     /* Check to see that len+1 is power of two, etc */
 743     if ((len & (len+1)) || (base & len)) return -EINVAL;
 744     base |= (len+1)>>1;
 745     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
 746     tcic_setw(TCIC_DATA, base);
 747
 748     ioctl  = (psock << TCIC_ICTL_SS_SHFT);
 749     ioctl |= (len == 0) ? TCIC_ICTL_TINY : 0;
 750     ioctl |= (io->flags & MAP_ACTIVE) ? TCIC_ICTL_ENA : 0;
 751     ioctl |= to_cycles(io->speed) & TCIC_ICTL_WSCNT_MASK;
 752     if (!(io->flags & MAP_AUTOSZ)) {
 753         ioctl |= TCIC_ICTL_QUIET;
 754         ioctl |= (io->flags & MAP_16BIT) ? TCIC_ICTL_BW_16 : TCIC_ICTL_BW_8;
 755     }
 756     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
 757     tcic_setw(TCIC_DATA, ioctl);
 758
 759     return 0;
 760 } /* tcic_set_io_map */
 761
 762 /*====================================================================*/
 763
 764 static int tcic_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
 765 {
 766     u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
 767     u_short addr, ctl;
 768     u_long base, len, mmap;
 769
 770     debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, "
 771           "%#llx-%#llx, %#x)\n", psock, mem->map, mem->flags,
 772           mem->speed, (unsigned long long)mem->res->start,
 773           (unsigned long long)mem->res->end, mem->card_start);
 774     if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
 775         (mem->res->start > 0xffffff) || (mem->res->end > 0xffffff) ||
 776         (mem->res->start > mem->res->end) || (mem->speed > 1000))
 777         return -EINVAL;
 778     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
 779     addr = TCIC_MWIN(psock, mem->map);
 780
 781     base = mem->res->start; len = mem->res->end - mem->res->start;
 782     if ((len & (len+1)) || (base & len)) return -EINVAL;
 783     if (len == 0x0fff)
 784         base = (base >> TCIC_MBASE_HA_SHFT) | TCIC_MBASE_4K_BIT;
 785     else
 786         base = (base | (len+1)>>1) >> TCIC_MBASE_HA_SHFT;
 787     tcic_setw(TCIC_ADDR, addr + TCIC_MBASE_X);
 788     tcic_setw(TCIC_DATA, base);
 789
 790     mmap = mem->card_start - mem->res->start;
 791     mmap = (mmap >> TCIC_MMAP_CA_SHFT) & TCIC_MMAP_CA_MASK;
 792     if (mem->flags & MAP_ATTRIB) mmap |= TCIC_MMAP_REG;
 793     tcic_setw(TCIC_ADDR, addr + TCIC_MMAP_X);
 794     tcic_setw(TCIC_DATA, mmap);
 795
 796     ctl  = TCIC_MCTL_QUIET | (psock << TCIC_MCTL_SS_SHFT);
 797     ctl |= to_cycles(mem->speed) & TCIC_MCTL_WSCNT_MASK;
 798     ctl |= (mem->flags & MAP_16BIT) ? 0 : TCIC_MCTL_B8;
 799     ctl |= (mem->flags & MAP_WRPROT) ? TCIC_MCTL_WP : 0;
 800     ctl |= (mem->flags & MAP_ACTIVE) ? TCIC_MCTL_ENA : 0;
 801     tcic_setw(TCIC_ADDR, addr + TCIC_MCTL_X);
 802     tcic_setw(TCIC_DATA, ctl);
 803
 804     return 0;
 805 } /* tcic_set_mem_map */
 806
 807 /*====================================================================*/
 808
 809 static int tcic_init(struct pcmcia_socket *s)
 810 {
 811         int i;
 812         struct resource res = { .start = 0, .end = 0x1000 };
 813         pccard_io_map io = { 0, 0, 0, 0, 1 };
 814         pccard_mem_map mem = { .res = &res, };
 815
 816         for (i = 0; i < 2; i++) {
 817                 io.map = i;
 818                 tcic_set_io_map(s, &io);
 819         }
 820         for (i = 0; i < 5; i++) {
 821                 mem.map = i;
 822                 tcic_set_mem_map(s, &mem);
 823         }
 824         return 0;
 825 }
 826
 827 static struct pccard_operations tcic_operations = {
 828         .init              = tcic_init,
 829         .get_status        = tcic_get_status,
 830         .set_socket        = tcic_set_socket,
 831         .set_io_map        = tcic_set_io_map,
 832         .set_mem_map       = tcic_set_mem_map,
 833 };
 834
 835 /*====================================================================*/
 836
 837 module_init(init_tcic);
 838 module_exit(exit_tcic);