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