drivers/pcmcia/hd64465_ss.c

   1 /*
   2  * Device driver for the PCMCIA controller module of the
   3  * Hitachi HD64465 handheld companion chip.
   4  *
   5  * Note that the HD64465 provides a very thin PCMCIA host bridge
   6  * layer, requiring a lot of the work of supporting cards to be
   7  * performed by the processor.  For example: mapping of card
   8  * interrupts to processor IRQs is done by IRQ demuxing software;
   9  * IO and memory mappings are fixed; setting voltages according
  10  * to card Voltage Select pins etc is done in software.
  11  *
  12  * Note also that this driver uses only the simple, fixed,
  13  * 16MB, 16-bit wide mappings to PCMCIA spaces defined by the
  14  * HD64465.  Larger mappings, smaller mappings, or mappings of
  15  * different width to the same socket, are all possible only by
  16  * involving the SH7750's MMU, which is considered unnecessary here.
  17  * The downside is that it may be possible for some drivers to
  18  * break because they need or expect 8-bit mappings.
  19  *
  20  * This driver currently supports only the following configuration:
  21  * SH7750 CPU, HD64465, TPS2206 voltage control chip.
  22  *
  23  * by Greg Banks <gbanks@pocketpenguins.com>
  24  * (c) 2000 PocketPenguins Inc
  25  */
  26
  27 #include <linux/types.h>
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/string.h>
  31 #include <linux/kernel.h>
  32 #include <linux/ioport.h>
  33 #include <linux/mm.h>
  34 #include <linux/vmalloc.h>
  35 #include <asm/errno.h>
  36 #include <linux/irq.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/platform_device.h>
  39
  40 #include <asm/io.h>
  41 #include <asm/hd64465/hd64465.h>
  42 #include <asm/hd64465/io.h>
  43
  44 #include <pcmcia/cs_types.h>
  45 #include <pcmcia/cs.h>
  46 #include <pcmcia/cistpl.h>
  47 #include <pcmcia/ds.h>
  48 #include <pcmcia/ss.h>
  49 #include <pcmcia/bulkmem.h>
  50 #include "cs_internal.h"
  51
  52 #define MODNAME "hd64465_ss"
  53
  54 /* #define HD64465_DEBUG 1 */
  55
  56 #if HD64465_DEBUG
  57 #define DPRINTK(args...)        printk(MODNAME ": " args)
  58 #else
  59 #define DPRINTK(args...)
  60 #endif
  61
  62 extern int hd64465_io_debug;
  63 extern void * p3_ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags);
  64 extern void p3_iounmap(void *addr);
  65
  66 /*============================================================*/
  67
  68 #define HS_IO_MAP_SIZE  (64*1024)
  69
  70 typedef struct hs_socket_t
  71 {
  72     unsigned int        number;
  73     u_int               irq;
  74     u_long              mem_base;
  75     void                *io_base;
  76     u_long              mem_length;
  77     u_int               ctrl_base;
  78     socket_state_t      state;
  79     pccard_io_map       io_maps[MAX_IO_WIN];
  80     pccard_mem_map      mem_maps[MAX_WIN];
  81     struct pcmcia_socket        socket;
  82 } hs_socket_t;
  83
  84
  85
  86 #define HS_MAX_SOCKETS 2
  87 static hs_socket_t hs_sockets[HS_MAX_SOCKETS];
  88
  89 #define hs_in(sp, r)        inb((sp)->ctrl_base + (r))
  90 #define hs_out(sp, v, r)    outb(v, (sp)->ctrl_base + (r))
  91
  92
  93 /* translate a boolean value to a bit in a register */
  94 #define bool_to_regbit(sp, r, bi, bo)           \
  95     do {                                        \
  96         unsigned short v = hs_in(sp, r);        \
  97         if (bo)                                 \
  98             v |= (bi);                          \
  99         else                                    \
 100             v &= ~(bi);                         \
 101         hs_out(sp, v, r);                       \
 102     } while(0)
 103
 104 /* register offsets from HD64465_REG_PCC[01]ISR */
 105 #define ISR     0x0
 106 #define GCR     0x2
 107 #define CSCR    0x4
 108 #define CSCIER  0x6
 109 #define SCR     0x8
 110
 111
 112 /* Mask and values for CSCIER register */
 113 #define IER_MASK    0x80
 114 #define IER_ON      0x3f        /* interrupts on */
 115 #define IER_OFF     0x00        /* interrupts off */
 116
 117 /*============================================================*/
 118
 119 #if HD64465_DEBUG > 10
 120
 121 static void cis_hex_dump(const unsigned char *x, int len)
 122 {
 123         int i;
 124
 125         for (i=0 ; i<len ; i++)
 126         {
 127             if (!(i & 0xf))
 128                 printk("\n%08x", (unsigned)(x + i));
 129             printk(" %02x", *(volatile unsigned short*)x);
 130             x += 2;
 131         }
 132         printk("\n");
 133 }
 134
 135 #endif
 136 /*============================================================*/
 137
 138 /*
 139  * This code helps create the illusion that the IREQ line from
 140  * the PC card is mapped to one of the CPU's IRQ lines by the
 141  * host bridge hardware (which is how every host bridge *except*
 142  * the HD64465 works).  In particular, it supports enabling
 143  * and disabling the IREQ line by code which knows nothing
 144  * about the host bridge (e.g. device drivers, IDE code) using
 145  * the request_irq(), free_irq(), probe_irq_on() and probe_irq_off()
 146  * functions.  Also, it supports sharing the mapped IRQ with
 147  * real hardware IRQs from the -IRL0-3 lines.
 148  */
 149
 150 #define HS_NUM_MAPPED_IRQS  16  /* Limitation of the PCMCIA code */
 151 static struct
 152 {
 153     /* index is mapped irq number */
 154     hs_socket_t *sock;
 155     hw_irq_controller *old_handler;
 156 } hs_mapped_irq[HS_NUM_MAPPED_IRQS];
 157
 158 static void hs_socket_enable_ireq(hs_socket_t *sp)
 159 {
 160         unsigned short cscier;
 161
 162         DPRINTK("hs_socket_enable_ireq(sock=%d)\n", sp->number);
 163
 164         cscier = hs_in(sp, CSCIER);
 165         cscier &= ~HD64465_PCCCSCIER_PIREQE_MASK;
 166         cscier |= HD64465_PCCCSCIER_PIREQE_LEVEL;
 167         hs_out(sp, cscier, CSCIER);
 168 }
 169
 170 static void hs_socket_disable_ireq(hs_socket_t *sp)
 171 {
 172         unsigned short cscier;
 173
 174         DPRINTK("hs_socket_disable_ireq(sock=%d)\n", sp->number);
 175
 176         cscier = hs_in(sp, CSCIER);
 177         cscier &= ~HD64465_PCCCSCIER_PIREQE_MASK;
 178         hs_out(sp, cscier, CSCIER);
 179 }
 180
 181 static unsigned int hs_startup_irq(unsigned int irq)
 182 {
 183         hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
 184         hs_mapped_irq[irq].old_handler->startup(irq);
 185         return 0;
 186 }
 187
 188 static void hs_shutdown_irq(unsigned int irq)
 189 {
 190         hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
 191         hs_mapped_irq[irq].old_handler->shutdown(irq);
 192 }
 193
 194 static void hs_enable_irq(unsigned int irq)
 195 {
 196         hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
 197         hs_mapped_irq[irq].old_handler->enable(irq);
 198 }
 199
 200 static void hs_disable_irq(unsigned int irq)
 201 {
 202         hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
 203         hs_mapped_irq[irq].old_handler->disable(irq);
 204 }
 205
 206 extern struct hw_interrupt_type no_irq_type;
 207
 208 static void hs_mask_and_ack_irq(unsigned int irq)
 209 {
 210         hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
 211         /* ack_none() spuriously complains about an unexpected IRQ */
 212         if (hs_mapped_irq[irq].old_handler != &no_irq_type)
 213             hs_mapped_irq[irq].old_handler->ack(irq);
 214 }
 215
 216 static void hs_end_irq(unsigned int irq)
 217 {
 218         hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
 219         hs_mapped_irq[irq].old_handler->end(irq);
 220 }
 221
 222
 223 static struct hw_interrupt_type hd64465_ss_irq_type = {
 224         .typename       = "PCMCIA-IRQ",
 225         .startup        = hs_startup_irq,
 226         .shutdown       = hs_shutdown_irq,
 227         .enable         = hs_enable_irq,
 228         .disable        = hs_disable_irq,
 229         .ack            = hs_mask_and_ack_irq,
 230         .end            = hs_end_irq
 231 };
 232
 233 /*
 234  * This function should only ever be called with interrupts disabled.
 235  */
 236 static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
 237 {
 238         DPRINTK("hs_map_irq(sock=%d irq=%d)\n", sp->number, irq);
 239
 240         if (irq >= HS_NUM_MAPPED_IRQS)
 241             return;
 242
 243         hs_mapped_irq[irq].sock = sp;
 244         /* insert ourselves as the irq controller */
 245         hs_mapped_irq[irq].old_handler = irq_desc[irq].chip;
 246         irq_desc[irq].chip = &hd64465_ss_irq_type;
 247 }
 248
 249
 250 /*
 251  * This function should only ever be called with interrupts disabled.
 252  */
 253 static void hs_unmap_irq(hs_socket_t *sp, unsigned int irq)
 254 {
 255         DPRINTK("hs_unmap_irq(sock=%d irq=%d)\n", sp->number, irq);
 256
 257         if (irq >= HS_NUM_MAPPED_IRQS)
 258             return;
 259
 260         /* restore the original irq controller */
 261         irq_desc[irq].chip = hs_mapped_irq[irq].old_handler;
 262 }
 263
 264 /*============================================================*/
 265
 266
 267 /*
 268  * Set Vpp and Vcc (in tenths of a Volt).  Does not
 269  * support the hi-Z state.
 270  *
 271  * Note, this assumes the board uses a TPS2206 chip to control
 272  * the Vcc and Vpp voltages to the hs_sockets.  If your board
 273  * uses the MIC2563 (also supported by the HD64465) then you
 274  * will have to modify this function.
 275  */
 276                                          /* 0V   3.3V  5.5V */
 277 static const u_char hs_tps2206_avcc[3] = { 0x00, 0x04, 0x08 };
 278 static const u_char hs_tps2206_bvcc[3] = { 0x00, 0x80, 0x40 };
 279
 280 static int hs_set_voltages(hs_socket_t *sp, int Vcc, int Vpp)
 281 {
 282         u_int psr;
 283         u_int vcci = 0;
 284         u_int sock = sp->number;
 285
 286         DPRINTK("hs_set_voltage(%d, %d, %d)\n", sock, Vcc, Vpp);
 287
 288         switch (Vcc)
 289         {
 290         case 0:  vcci = 0; break;
 291         case 33: vcci = 1; break;
 292         case 50: vcci = 2; break;
 293         default: return 0;
 294         }
 295
 296         /* Note: Vpp = 120 not supported -- Greg Banks */
 297         if (Vpp != 0 && Vpp != Vcc)
 298             return 0;
 299
 300         /* The PSR register holds 8 of the 9 bits which control
 301          * the TPS2206 via its serial interface.
 302          */
 303         psr = inw(HD64465_REG_PCCPSR);
 304         switch (sock)
 305         {
 306         case 0:
 307             psr &= 0x0f;
 308             psr |= hs_tps2206_avcc[vcci];
 309             psr |= (Vpp == 0 ? 0x00 : 0x02);
 310             break;
 311         case 1:
 312             psr &= 0xf0;
 313             psr |= hs_tps2206_bvcc[vcci];
 314             psr |= (Vpp == 0 ? 0x00 : 0x20);
 315             break;
 316         };
 317         outw(psr, HD64465_REG_PCCPSR);
 318
 319         return 1;
 320 }
 321
 322
 323 /*============================================================*/
 324
 325 /*
 326  * Drive the RESET line to the card.
 327  */
 328 static void hs_reset_socket(hs_socket_t *sp, int on)
 329 {
 330         unsigned short v;
 331
 332         v = hs_in(sp, GCR);
 333         if (on)
 334             v |= HD64465_PCCGCR_PCCR;
 335         else
 336             v &= ~HD64465_PCCGCR_PCCR;
 337         hs_out(sp, v, GCR);
 338 }
 339
 340 /*============================================================*/
 341
 342 static int hs_init(struct pcmcia_socket *s)
 343 {
 344         hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
 345
 346         DPRINTK("hs_init(%d)\n", sp->number);
 347
 348         return 0;
 349 }
 350
 351 /*============================================================*/
 352
 353
 354 static int hs_get_status(struct pcmcia_socket *s, u_int *value)
 355 {
 356         hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
 357         unsigned int isr;
 358         u_int status = 0;
 359
 360
 361         isr = hs_in(sp, ISR);
 362
 363         /* Card is seated and powered when *both* CD pins are low */
 364         if ((isr & HD64465_PCCISR_PCD_MASK) == 0)
 365         {
 366             status |= SS_DETECT;    /* card present */
 367
 368             switch (isr & HD64465_PCCISR_PBVD_MASK)
 369             {
 370             case HD64465_PCCISR_PBVD_BATGOOD:
 371                 break;
 372             case HD64465_PCCISR_PBVD_BATWARN:
 373                 status |= SS_BATWARN;
 374                 break;
 375             default:
 376                 status |= SS_BATDEAD;
 377                 break;
 378             }
 379
 380             if (isr & HD64465_PCCISR_PREADY)
 381                 status |= SS_READY;
 382
 383             if (isr & HD64465_PCCISR_PMWP)
 384                 status |= SS_WRPROT;
 385
 386             /* Voltage Select pins interpreted as per Table 4-5 of the std.
 387              * Assuming we have the TPS2206, the socket is a "Low Voltage
 388              * key, 3.3V and 5V available, no X.XV available".
 389              */
 390             switch (isr & (HD64465_PCCISR_PVS2|HD64465_PCCISR_PVS1))
 391             {
 392             case HD64465_PCCISR_PVS1:
 393                 printk(KERN_NOTICE MODNAME ": cannot handle X.XV card, ignored\n");
 394                 status = 0;
 395                 break;
 396             case 0:
 397             case HD64465_PCCISR_PVS2:
 398                 /* 3.3V */
 399                 status |= SS_3VCARD;
 400                 break;
 401             case HD64465_PCCISR_PVS2|HD64465_PCCISR_PVS1:
 402                 /* 5V */
 403                 break;
 404             }
 405
 406             /* TODO: SS_POWERON */
 407             /* TODO: SS_STSCHG */
 408         }
 409
 410         DPRINTK("hs_get_status(%d) = %x\n", sock, status);
 411
 412         *value = status;
 413         return 0;
 414 }
 415
 416 /*============================================================*/
 417
 418 static int hs_set_socket(struct pcmcia_socket *s, socket_state_t *state)
 419 {
 420         hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
 421         u_long flags;
 422         u_int changed;
 423         unsigned short cscier;
 424
 425         DPRINTK("hs_set_socket(sock=%d, flags=%x, csc_mask=%x, Vcc=%d, Vpp=%d, io_irq=%d)\n",
 426             sock, state->flags, state->csc_mask, state->Vcc, state->Vpp, state->io_irq);
 427
 428         local_irq_save(flags);  /* Don't want interrupts happening here */
 429
 430         if (state->Vpp != sp->state.Vpp ||
 431             state->Vcc != sp->state.Vcc) {
 432             if (!hs_set_voltages(sp, state->Vcc, state->Vpp)) {
 433                 local_irq_restore(flags);
 434                 return -EINVAL;
 435             }
 436         }
 437
 438 /*      hd64465_io_debug = 1; */
 439         /*
 440          * Handle changes in the Card Status Change mask,
 441          * by propagating to the CSCR register
 442          */
 443         changed = sp->state.csc_mask ^ state->csc_mask;
 444         cscier = hs_in(sp, CSCIER);
 445
 446         if (changed & SS_DETECT) {
 447             if (state->csc_mask & SS_DETECT)
 448                 cscier |= HD64465_PCCCSCIER_PCDE;
 449             else
 450                 cscier &= ~HD64465_PCCCSCIER_PCDE;
 451         }
 452
 453         if (changed & SS_READY) {
 454             if (state->csc_mask & SS_READY)
 455                 cscier |= HD64465_PCCCSCIER_PRE;
 456             else
 457                 cscier &= ~HD64465_PCCCSCIER_PRE;
 458         }
 459
 460         if (changed & SS_BATDEAD) {
 461             if (state->csc_mask & SS_BATDEAD)
 462                 cscier |= HD64465_PCCCSCIER_PBDE;
 463             else
 464                 cscier &= ~HD64465_PCCCSCIER_PBDE;
 465         }
 466
 467         if (changed & SS_BATWARN) {
 468             if (state->csc_mask & SS_BATWARN)
 469                 cscier |= HD64465_PCCCSCIER_PBWE;
 470             else
 471                 cscier &= ~HD64465_PCCCSCIER_PBWE;
 472         }
 473
 474         if (changed & SS_STSCHG) {
 475             if (state->csc_mask & SS_STSCHG)
 476                 cscier |= HD64465_PCCCSCIER_PSCE;
 477             else
 478                 cscier &= ~HD64465_PCCCSCIER_PSCE;
 479         }
 480
 481         hs_out(sp, cscier, CSCIER);
 482
 483         if (sp->state.io_irq && !state->io_irq)
 484             hs_unmap_irq(sp, sp->state.io_irq);
 485         else if (!sp->state.io_irq && state->io_irq)
 486             hs_map_irq(sp, state->io_irq);
 487
 488
 489         /*
 490          * Handle changes in the flags field,
 491          * by propagating to config registers.
 492          */
 493         changed = sp->state.flags ^ state->flags;
 494
 495         if (changed & SS_IOCARD) {
 496             DPRINTK("card type: %s\n",
 497                     (state->flags & SS_IOCARD ? "i/o" : "memory" ));
 498             bool_to_regbit(sp, GCR, HD64465_PCCGCR_PCCT,
 499                 state->flags & SS_IOCARD);
 500         }
 501
 502         if (changed & SS_RESET) {
 503             DPRINTK("%s reset card\n",
 504                 (state->flags & SS_RESET ? "start" : "stop"));
 505             bool_to_regbit(sp, GCR, HD64465_PCCGCR_PCCR,
 506                 state->flags & SS_RESET);
 507         }
 508
 509         if (changed & SS_OUTPUT_ENA) {
 510             DPRINTK("%sabling card output\n",
 511                 (state->flags & SS_OUTPUT_ENA ? "en" : "dis"));
 512             bool_to_regbit(sp, GCR, HD64465_PCCGCR_PDRV,
 513                 state->flags & SS_OUTPUT_ENA);
 514         }
 515
 516         /* TODO: SS_SPKR_ENA */
 517
 518 /*      hd64465_io_debug = 0; */
 519         sp->state = *state;
 520
 521         local_irq_restore(flags);
 522
 523 #if HD64465_DEBUG > 10
 524         if (state->flags & SS_OUTPUT_ENA)
 525             cis_hex_dump((const unsigned char*)sp->mem_base, 0x100);
 526 #endif
 527         return 0;
 528 }
 529
 530 /*============================================================*/
 531
 532 static int hs_set_io_map(struct pcmcia_socket *s, struct pccard_io_map *io)
 533 {
 534         hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
 535         int map = io->map;
 536         int sock = sp->number;
 537         struct pccard_io_map *sio;
 538         pgprot_t prot;
 539
 540         DPRINTK("hs_set_io_map(sock=%d, map=%d, flags=0x%x, speed=%dns, start=%#lx, stop=%#lx)\n",
 541             sock, map, io->flags, io->speed, io->start, io->stop);
 542         if (map >= MAX_IO_WIN)
 543             return -EINVAL;
 544         sio = &sp->io_maps[map];
 545
 546         /* check for null changes */
 547         if (io->flags == sio->flags &&
 548             io->start == sio->start &&
 549             io->stop == sio->stop)
 550             return 0;
 551
 552         if (io->flags & MAP_AUTOSZ)
 553             prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IODYN);
 554         else if (io->flags & MAP_16BIT)
 555             prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IO16);
 556         else
 557             prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IO8);
 558
 559         /* TODO: handle MAP_USE_WAIT */
 560         if (io->flags & MAP_USE_WAIT)
 561             printk(KERN_INFO MODNAME ": MAP_USE_WAIT unimplemented\n");
 562         /* TODO: handle MAP_PREFETCH */
 563         if (io->flags & MAP_PREFETCH)
 564             printk(KERN_INFO MODNAME ": MAP_PREFETCH unimplemented\n");
 565         /* TODO: handle MAP_WRPROT */
 566         if (io->flags & MAP_WRPROT)
 567             printk(KERN_INFO MODNAME ": MAP_WRPROT unimplemented\n");
 568         /* TODO: handle MAP_0WS */
 569         if (io->flags & MAP_0WS)
 570             printk(KERN_INFO MODNAME ": MAP_0WS unimplemented\n");
 571
 572         if (io->flags & MAP_ACTIVE) {
 573             unsigned long pstart, psize, paddrbase;
 574
 575             paddrbase = virt_to_phys((void*)(sp->mem_base + 2 * HD64465_PCC_WINDOW));
 576             pstart = io->start & PAGE_MASK;
 577             psize = ((io->stop + PAGE_SIZE) & PAGE_MASK) - pstart;
 578
 579             /*
 580              * Change PTEs in only that portion of the mapping requested
 581              * by the caller.  This means that most of the time, most of
 582              * the PTEs in the io_vma will be unmapped and only the bottom
 583              * page will be mapped.  But the code allows for weird cards
 584              * that might want IO ports > 4K.
 585              */
 586             sp->io_base = p3_ioremap(paddrbase + pstart, psize, pgprot_val(prot));
 587
 588             /*
 589              * Change the mapping used by inb() outb() etc
 590              */
 591             hd64465_port_map(io->start,
 592                 io->stop - io->start + 1,
 593                 (unsigned long)sp->io_base + io->start, 0);
 594         } else {
 595             hd64465_port_unmap(sio->start, sio->stop - sio->start + 1);
 596             p3_iounmap(sp->io_base);
 597         }
 598
 599         *sio = *io;
 600         return 0;
 601 }
 602
 603 /*============================================================*/
 604
 605 static int hs_set_mem_map(struct pcmcia_socket *s, struct pccard_mem_map *mem)
 606 {
 607         hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
 608         struct pccard_mem_map *smem;
 609         int map = mem->map;
 610         unsigned long paddr;
 611
 612 #if 0
 613         DPRINTK("hs_set_mem_map(sock=%d, map=%d, flags=0x%x, card_start=0x%08x)\n",
 614             sock, map, mem->flags, mem->card_start);
 615 #endif
 616
 617         if (map >= MAX_WIN)
 618             return -EINVAL;
 619         smem = &sp->mem_maps[map];
 620
 621         paddr = sp->mem_base;               /* base of Attribute mapping */
 622         if (!(mem->flags & MAP_ATTRIB))
 623             paddr += HD64465_PCC_WINDOW;    /* base of Common mapping */
 624         paddr += mem->card_start;
 625
 626         /* Because we specified SS_CAP_STATIC_MAP, we are obliged
 627          * at this time to report the system address corresponding
 628          * to the card address requested.  This is how Socket Services
 629          * queries our fixed mapping.  I wish this fact had been
 630          * documented - Greg Banks.
 631          */
 632         mem->static_start = paddr;
 633
 634         *smem = *mem;
 635
 636         return 0;
 637 }
 638
 639 /* TODO: do we need to use the MMU to access Common memory ??? */
 640
 641 /*============================================================*/
 642
 643 /*
 644  * This function is registered with the HD64465 glue code to do a
 645  * secondary demux step on the PCMCIA interrupts.  It handles
 646  * mapping the IREQ request from the card to a standard Linux
 647  * IRQ, as requested by SocketServices.
 648  */
 649 static int hs_irq_demux(int irq, void *dev)
 650 {
 651         hs_socket_t *sp = dev;
 652         u_int cscr;
 653
 654         DPRINTK("hs_irq_demux(irq=%d)\n", irq);
 655
 656         if (sp->state.io_irq &&
 657             (cscr = hs_in(sp, CSCR)) & HD64465_PCCCSCR_PIREQ) {
 658             cscr &= ~HD64465_PCCCSCR_PIREQ;
 659             hs_out(sp, cscr, CSCR);
 660             return sp->state.io_irq;
 661         }
 662
 663         return irq;
 664 }
 665
 666 /*============================================================*/
 667
 668 /*
 669  * Interrupt handling routine.
 670  */
 671
 672 static irqreturn_t hs_interrupt(int irq, void *dev)
 673 {
 674         hs_socket_t *sp = dev;
 675         u_int events = 0;
 676         u_int cscr;
 677
 678         cscr = hs_in(sp, CSCR);
 679
 680         DPRINTK("hs_interrupt, cscr=%04x\n", cscr);
 681
 682         /* check for bus-related changes to be reported to Socket Services */
 683         if (cscr & HD64465_PCCCSCR_PCDC) {
 684             /* double-check for a 16-bit card, as we don't support CardBus */
 685             if ((hs_in(sp, ISR) & HD64465_PCCISR_PCD_MASK) != 0) {
 686                 printk(KERN_NOTICE MODNAME
 687                     ": socket %d, card not a supported card type or not inserted correctly\n",
 688                     sp->number);
 689                 /* Don't do the rest unless a card is present */
 690                 cscr &= ~(HD64465_PCCCSCR_PCDC|
 691                           HD64465_PCCCSCR_PRC|
 692                           HD64465_PCCCSCR_PBW|
 693                           HD64465_PCCCSCR_PBD|
 694                           HD64465_PCCCSCR_PSC);
 695             } else {
 696                 cscr &= ~HD64465_PCCCSCR_PCDC;
 697                 events |= SS_DETECT;            /* card insertion or removal */
 698             }
 699         }
 700         if (cscr & HD64465_PCCCSCR_PRC) {
 701             cscr &= ~HD64465_PCCCSCR_PRC;
 702             events |= SS_READY;         /* ready signal changed */
 703         }
 704         if (cscr & HD64465_PCCCSCR_PBW) {
 705             cscr &= ~HD64465_PCCCSCR_PSC;
 706             events |= SS_BATWARN;       /* battery warning */
 707         }
 708         if (cscr & HD64465_PCCCSCR_PBD) {
 709             cscr &= ~HD64465_PCCCSCR_PSC;
 710             events |= SS_BATDEAD;       /* battery dead */
 711         }
 712         if (cscr & HD64465_PCCCSCR_PSC) {
 713             cscr &= ~HD64465_PCCCSCR_PSC;
 714             events |= SS_STSCHG;        /* STSCHG (status changed) signal */
 715         }
 716
 717         if (cscr & HD64465_PCCCSCR_PIREQ) {
 718             cscr &= ~HD64465_PCCCSCR_PIREQ;
 719
 720             /* This should have been dealt with during irq demux */
 721             printk(KERN_NOTICE MODNAME ": unexpected IREQ from card\n");
 722         }
 723
 724         hs_out(sp, cscr, CSCR);
 725
 726         if (events)
 727                 pcmcia_parse_events(&sp->socket, events);
 728
 729         return IRQ_HANDLED;
 730 }
 731
 732 /*============================================================*/
 733
 734 static struct pccard_operations hs_operations = {
 735         .init                   = hs_init,
 736         .get_status             = hs_get_status,
 737         .set_socket             = hs_set_socket,
 738         .set_io_map             = hs_set_io_map,
 739         .set_mem_map            = hs_set_mem_map,
 740 };
 741
 742 static int hs_init_socket(hs_socket_t *sp, int irq, unsigned long mem_base,
 743             unsigned int ctrl_base)
 744 {
 745         unsigned short v;
 746         int i, err;
 747
 748         memset(sp, 0, sizeof(*sp));
 749         sp->irq = irq;
 750         sp->mem_base = mem_base;
 751         sp->mem_length = 4*HD64465_PCC_WINDOW;  /* 16MB */
 752         sp->ctrl_base = ctrl_base;
 753
 754         for (i=0 ; i<MAX_IO_WIN ; i++)
 755             sp->io_maps[i].map = i;
 756         for (i=0 ; i<MAX_WIN ; i++)
 757             sp->mem_maps[i].map = i;
 758
 759         hd64465_register_irq_demux(sp->irq, hs_irq_demux, sp);
 760
 761         if ((err = request_irq(sp->irq, hs_interrupt, IRQF_DISABLED, MODNAME, sp)) < 0)
 762             return err;
 763         if (request_mem_region(sp->mem_base, sp->mem_length, MODNAME) == 0) {
 764             sp->mem_base = 0;
 765             return -ENOMEM;
 766         }
 767
 768
 769         /* According to section 3.2 of the PCMCIA standard, low-voltage
 770          * capable cards must implement cold insertion, i.e. Vpp and
 771          * Vcc set to 0 before card is inserted.
 772          */
 773         /*hs_set_voltages(sp, 0, 0);*/
 774
 775         /* hi-Z the outputs to the card and set 16MB map mode */
 776         v = hs_in(sp, GCR);
 777         v &= ~HD64465_PCCGCR_PCCT;      /* memory-only card */
 778         hs_out(sp, v, GCR);
 779
 780         v = hs_in(sp, GCR);
 781         v |= HD64465_PCCGCR_PDRV;       /* enable outputs to card */
 782         hs_out(sp, v, GCR);
 783
 784         v = hs_in(sp, GCR);
 785         v |= HD64465_PCCGCR_PMMOD;      /* 16MB mapping mode */
 786         hs_out(sp, v, GCR);
 787
 788         v = hs_in(sp, GCR);
 789         /* lowest 16MB of Common */
 790         v &= ~(HD64465_PCCGCR_PPA25|HD64465_PCCGCR_PPA24);
 791         hs_out(sp, v, GCR);
 792
 793         hs_reset_socket(sp, 1);
 794
 795         printk(KERN_INFO "HD64465 PCMCIA bridge socket %d at 0x%08lx irq %d\n",
 796                 i, sp->mem_base, sp->irq);
 797
 798         return 0;
 799 }
 800
 801 static void hs_exit_socket(hs_socket_t *sp)
 802 {
 803         unsigned short cscier, gcr;
 804         unsigned long flags;
 805
 806         local_irq_save(flags);
 807
 808         /* turn off interrupts in hardware */
 809         cscier = hs_in(sp, CSCIER);
 810         cscier = (cscier & IER_MASK) | IER_OFF;
 811         hs_out(sp, cscier, CSCIER);
 812
 813         /* hi-Z the outputs to the card */
 814         gcr = hs_in(sp, GCR);
 815         gcr &= HD64465_PCCGCR_PDRV;
 816         hs_out(sp, gcr, GCR);
 817
 818         /* power the card down */
 819         hs_set_voltages(sp, 0, 0);
 820
 821         if (sp->mem_base != 0)
 822             release_mem_region(sp->mem_base, sp->mem_length);
 823         if (sp->irq != 0) {
 824             free_irq(sp->irq, hs_interrupt);
 825             hd64465_unregister_irq_demux(sp->irq);
 826         }
 827
 828         local_irq_restore(flags);
 829 }
 830
 831 static struct device_driver hd64465_driver = {
 832         .name = "hd64465-pcmcia",
 833         .bus = &platform_bus_type,
 834         .suspend = pcmcia_socket_dev_suspend,
 835         .resume = pcmcia_socket_dev_resume,
 836 };
 837
 838 static struct platform_device hd64465_device = {
 839         .name = "hd64465-pcmcia",
 840         .id = 0,
 841 };
 842
 843 static int __init init_hs(void)
 844 {
 845         int i;
 846         unsigned short v;
 847
 848 /*      hd64465_io_debug = 1; */
 849         if (driver_register(&hd64465_driver))
 850                 return -EINVAL;
 851
 852         /* Wake both sockets out of STANDBY mode */
 853         /* TODO: wait 15ms */
 854         v = inw(HD64465_REG_SMSCR);
 855         v &= ~(HD64465_SMSCR_PC0ST|HD64465_SMSCR_PC1ST);
 856         outw(v, HD64465_REG_SMSCR);
 857
 858         /* keep power controller out of shutdown mode */
 859         v = inb(HD64465_REG_PCC0SCR);
 860         v |= HD64465_PCCSCR_SHDN;
 861         outb(v, HD64465_REG_PCC0SCR);
 862
 863         /* use serial (TPS2206) power controller */
 864         v = inb(HD64465_REG_PCC0CSCR);
 865         v |= HD64465_PCCCSCR_PSWSEL;
 866         outb(v, HD64465_REG_PCC0CSCR);
 867
 868         /*
 869          * Setup hs_sockets[] structures and request system resources.
 870          * TODO: on memory allocation failure, power down the socket
 871          *       before quitting.
 872          */
 873         for (i=0; i<HS_MAX_SOCKETS; i++) {
 874                 hs_set_voltages(&hs_sockets[i], 0, 0);
 875
 876                 hs_sockets[i].socket.features |=  SS_CAP_PCCARD | SS_CAP_STATIC_MAP;      /* mappings are fixed in host memory */
 877                 hs_sockets[i].socket.resource_ops = &pccard_static_ops;
 878                 hs_sockets[i].socket.irq_mask =  0xffde;/*0xffff*/          /* IRQs mapped in s/w so can do any, really */
 879                 hs_sockets[i].socket.map_size = HD64465_PCC_WINDOW;     /* 16MB fixed window size */
 880
 881                 hs_sockets[i].socket.owner = THIS_MODULE;
 882                 hs_sockets[i].socket.ss_entry = &hs_operations;
 883         }
 884
 885         i = hs_init_socket(&hs_sockets[0],
 886             HD64465_IRQ_PCMCIA0,
 887             HD64465_PCC0_BASE,
 888             HD64465_REG_PCC0ISR);
 889         if (i < 0) {
 890                 unregister_driver(&hd64465_driver);
 891                 return i;
 892         }
 893         i = hs_init_socket(&hs_sockets[1],
 894             HD64465_IRQ_PCMCIA1,
 895             HD64465_PCC1_BASE,
 896             HD64465_REG_PCC1ISR);
 897         if (i < 0) {
 898                 unregister_driver(&hd64465_driver);
 899                 return i;
 900         }
 901
 902 /*      hd64465_io_debug = 0; */
 903
 904         platform_device_register(&hd64465_device);
 905
 906         for (i=0; i<HS_MAX_SOCKETS; i++) {
 907                 unsigned int ret;
 908                 hs_sockets[i].socket.dev.parent = &hd64465_device.dev;
 909                 hs_sockets[i].number = i;
 910                 ret = pcmcia_register_socket(&hs_sockets[i].socket);
 911                 if (ret && i)
 912                         pcmcia_unregister_socket(&hs_sockets[0].socket);
 913         }
 914
 915         return 0;
 916 }
 917
 918 static void __exit exit_hs(void)
 919 {
 920         int i;
 921
 922         for (i=0 ; i<HS_MAX_SOCKETS ; i++) {
 923                 pcmcia_unregister_socket(&hs_sockets[i].socket);
 924                 hs_exit_socket(&hs_sockets[i]);
 925         }
 926
 927         platform_device_unregister(&hd64465_device);
 928         unregister_driver(&hd64465_driver);
 929 }
 930
 931 module_init(init_hs);
 932 module_exit(exit_hs);
 933
 934 /*============================================================*/
 935 /*END*/