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