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