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