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