2 * Device driver for the PCMCIA controller module of the
3 * Hitachi HD64465 handheld companion chip.
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.
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.
20 * This driver currently supports only the following configuration:
21 * SH7750 CPU, HD64465, TPS2206 voltage control chip.
23 * by Greg Banks <gbanks@pocketpenguins.com>
24 * (c) 2000 PocketPenguins Inc
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>
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>
41 #include <asm/hd64465/hd64465.h>
42 #include <asm/hd64465/io.h>
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>
50 #define MODNAME "hd64465_ss"
52 /* #define HD64465_DEBUG 1 */
55 #define DPRINTK(args...) printk(MODNAME ": " args)
57 #define DPRINTK(args...)
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
);
64 /*============================================================*/
66 #define HS_IO_MAP_SIZE (64*1024)
68 typedef struct hs_socket_t
77 pccard_io_map io_maps
[MAX_IO_WIN
];
78 pccard_mem_map mem_maps
[MAX_WIN
];
79 struct pcmcia_socket socket
;
84 #define HS_MAX_SOCKETS 2
85 static hs_socket_t hs_sockets
[HS_MAX_SOCKETS
];
87 #define hs_in(sp, r) inb((sp)->ctrl_base + (r))
88 #define hs_out(sp, v, r) outb(v, (sp)->ctrl_base + (r))
91 /* translate a boolean value to a bit in a register */
92 #define bool_to_regbit(sp, r, bi, bo) \
94 unsigned short v = hs_in(sp, r); \
102 /* register offsets from HD64465_REG_PCC[01]ISR */
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 */
115 /*============================================================*/
117 #if HD64465_DEBUG > 10
119 static void cis_hex_dump(const unsigned char *x
, int len
)
123 for (i
=0 ; i
<len
; i
++)
126 printk("\n%08x", (unsigned)(x
+ i
));
127 printk(" %02x", *(volatile unsigned short*)x
);
134 /*============================================================*/
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.
148 #define HS_NUM_MAPPED_IRQS 16 /* Limitation of the PCMCIA code */
151 /* index is mapped irq number */
153 hw_irq_controller
*old_handler
;
154 } hs_mapped_irq
[HS_NUM_MAPPED_IRQS
];
156 static void hs_socket_enable_ireq(hs_socket_t
*sp
)
158 unsigned short cscier
;
160 DPRINTK("hs_socket_enable_ireq(sock=%d)\n", sp
->number
);
162 cscier
= hs_in(sp
, CSCIER
);
163 cscier
&= ~HD64465_PCCCSCIER_PIREQE_MASK
;
164 cscier
|= HD64465_PCCCSCIER_PIREQE_LEVEL
;
165 hs_out(sp
, cscier
, CSCIER
);
168 static void hs_socket_disable_ireq(hs_socket_t
*sp
)
170 unsigned short cscier
;
172 DPRINTK("hs_socket_disable_ireq(sock=%d)\n", sp
->number
);
174 cscier
= hs_in(sp
, CSCIER
);
175 cscier
&= ~HD64465_PCCCSCIER_PIREQE_MASK
;
176 hs_out(sp
, cscier
, CSCIER
);
179 static unsigned int hs_startup_irq(unsigned int irq
)
181 hs_socket_enable_ireq(hs_mapped_irq
[irq
].sock
);
182 hs_mapped_irq
[irq
].old_handler
->startup(irq
);
186 static void hs_shutdown_irq(unsigned int irq
)
188 hs_socket_disable_ireq(hs_mapped_irq
[irq
].sock
);
189 hs_mapped_irq
[irq
].old_handler
->shutdown(irq
);
192 static void hs_enable_irq(unsigned int irq
)
194 hs_socket_enable_ireq(hs_mapped_irq
[irq
].sock
);
195 hs_mapped_irq
[irq
].old_handler
->enable(irq
);
198 static void hs_disable_irq(unsigned int irq
)
200 hs_socket_disable_ireq(hs_mapped_irq
[irq
].sock
);
201 hs_mapped_irq
[irq
].old_handler
->disable(irq
);
204 extern struct hw_interrupt_type no_irq_type
;
206 static void hs_mask_and_ack_irq(unsigned int irq
)
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
);
214 static void hs_end_irq(unsigned int irq
)
216 hs_socket_enable_ireq(hs_mapped_irq
[irq
].sock
);
217 hs_mapped_irq
[irq
].old_handler
->end(irq
);
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
,
232 * This function should only ever be called with interrupts disabled.
234 static void hs_map_irq(hs_socket_t
*sp
, unsigned int irq
)
236 struct irq_desc
*desc
;
238 DPRINTK("hs_map_irq(sock=%d irq=%d)\n", sp
->number
, irq
);
240 if (irq
>= HS_NUM_MAPPED_IRQS
)
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
;
252 * This function should only ever be called with interrupts disabled.
254 static void hs_unmap_irq(hs_socket_t
*sp
, unsigned int irq
)
256 struct irq_desc
*desc
;
258 DPRINTK("hs_unmap_irq(sock=%d irq=%d)\n", sp
->number
, irq
);
260 if (irq
>= HS_NUM_MAPPED_IRQS
)
263 desc
= irq_to_desc(irq
);
264 /* restore the original irq controller */
265 desc
->chip
= hs_mapped_irq
[irq
].old_handler
;
268 /*============================================================*/
272 * Set Vpp and Vcc (in tenths of a Volt). Does not
273 * support the hi-Z state.
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.
281 static const u_char hs_tps2206_avcc
[3] = { 0x00, 0x04, 0x08 };
282 static const u_char hs_tps2206_bvcc
[3] = { 0x00, 0x80, 0x40 };
284 static int hs_set_voltages(hs_socket_t
*sp
, int Vcc
, int Vpp
)
288 u_int sock
= sp
->number
;
290 DPRINTK("hs_set_voltage(%d, %d, %d)\n", sock
, Vcc
, Vpp
);
294 case 0: vcci
= 0; break;
295 case 33: vcci
= 1; break;
296 case 50: vcci
= 2; break;
300 /* Note: Vpp = 120 not supported -- Greg Banks */
301 if (Vpp
!= 0 && Vpp
!= Vcc
)
304 /* The PSR register holds 8 of the 9 bits which control
305 * the TPS2206 via its serial interface.
307 psr
= inw(HD64465_REG_PCCPSR
);
312 psr
|= hs_tps2206_avcc
[vcci
];
313 psr
|= (Vpp
== 0 ? 0x00 : 0x02);
317 psr
|= hs_tps2206_bvcc
[vcci
];
318 psr
|= (Vpp
== 0 ? 0x00 : 0x20);
321 outw(psr
, HD64465_REG_PCCPSR
);
327 /*============================================================*/
330 * Drive the RESET line to the card.
332 static void hs_reset_socket(hs_socket_t
*sp
, int on
)
338 v
|= HD64465_PCCGCR_PCCR
;
340 v
&= ~HD64465_PCCGCR_PCCR
;
344 /*============================================================*/
346 static int hs_init(struct pcmcia_socket
*s
)
348 hs_socket_t
*sp
= container_of(s
, struct hs_socket_t
, socket
);
350 DPRINTK("hs_init(%d)\n", sp
->number
);
355 /*============================================================*/
358 static int hs_get_status(struct pcmcia_socket
*s
, u_int
*value
)
360 hs_socket_t
*sp
= container_of(s
, struct hs_socket_t
, socket
);
365 isr
= hs_in(sp
, ISR
);
367 /* Card is seated and powered when *both* CD pins are low */
368 if ((isr
& HD64465_PCCISR_PCD_MASK
) == 0)
370 status
|= SS_DETECT
; /* card present */
372 switch (isr
& HD64465_PCCISR_PBVD_MASK
)
374 case HD64465_PCCISR_PBVD_BATGOOD
:
376 case HD64465_PCCISR_PBVD_BATWARN
:
377 status
|= SS_BATWARN
;
380 status
|= SS_BATDEAD
;
384 if (isr
& HD64465_PCCISR_PREADY
)
387 if (isr
& HD64465_PCCISR_PMWP
)
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".
394 switch (isr
& (HD64465_PCCISR_PVS2
|HD64465_PCCISR_PVS1
))
396 case HD64465_PCCISR_PVS1
:
397 printk(KERN_NOTICE MODNAME
": cannot handle X.XV card, ignored\n");
401 case HD64465_PCCISR_PVS2
:
405 case HD64465_PCCISR_PVS2
|HD64465_PCCISR_PVS1
:
410 /* TODO: SS_POWERON */
411 /* TODO: SS_STSCHG */
414 DPRINTK("hs_get_status(%d) = %x\n", sock
, status
);
420 /*============================================================*/
422 static int hs_set_socket(struct pcmcia_socket
*s
, socket_state_t
*state
)
424 hs_socket_t
*sp
= container_of(s
, struct hs_socket_t
, socket
);
427 unsigned short cscier
;
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
);
432 local_irq_save(flags
); /* Don't want interrupts happening here */
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
);
442 /* hd64465_io_debug = 1; */
444 * Handle changes in the Card Status Change mask,
445 * by propagating to the CSCR register
447 changed
= sp
->state
.csc_mask
^ state
->csc_mask
;
448 cscier
= hs_in(sp
, CSCIER
);
450 if (changed
& SS_DETECT
) {
451 if (state
->csc_mask
& SS_DETECT
)
452 cscier
|= HD64465_PCCCSCIER_PCDE
;
454 cscier
&= ~HD64465_PCCCSCIER_PCDE
;
457 if (changed
& SS_READY
) {
458 if (state
->csc_mask
& SS_READY
)
459 cscier
|= HD64465_PCCCSCIER_PRE
;
461 cscier
&= ~HD64465_PCCCSCIER_PRE
;
464 if (changed
& SS_BATDEAD
) {
465 if (state
->csc_mask
& SS_BATDEAD
)
466 cscier
|= HD64465_PCCCSCIER_PBDE
;
468 cscier
&= ~HD64465_PCCCSCIER_PBDE
;
471 if (changed
& SS_BATWARN
) {
472 if (state
->csc_mask
& SS_BATWARN
)
473 cscier
|= HD64465_PCCCSCIER_PBWE
;
475 cscier
&= ~HD64465_PCCCSCIER_PBWE
;
478 if (changed
& SS_STSCHG
) {
479 if (state
->csc_mask
& SS_STSCHG
)
480 cscier
|= HD64465_PCCCSCIER_PSCE
;
482 cscier
&= ~HD64465_PCCCSCIER_PSCE
;
485 hs_out(sp
, cscier
, CSCIER
);
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
);
494 * Handle changes in the flags field,
495 * by propagating to config registers.
497 changed
= sp
->state
.flags
^ state
->flags
;
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
);
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
);
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
);
520 /* TODO: SS_SPKR_ENA */
522 /* hd64465_io_debug = 0; */
525 local_irq_restore(flags
);
527 #if HD64465_DEBUG > 10
528 if (state
->flags
& SS_OUTPUT_ENA
)
529 cis_hex_dump((const unsigned char*)sp
->mem_base
, 0x100);
534 /*============================================================*/
536 static int hs_set_io_map(struct pcmcia_socket
*s
, struct pccard_io_map
*io
)
538 hs_socket_t
*sp
= container_of(s
, struct hs_socket_t
, socket
);
540 int sock
= sp
->number
;
541 struct pccard_io_map
*sio
;
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
)
548 sio
= &sp
->io_maps
[map
];
550 /* check for null changes */
551 if (io
->flags
== sio
->flags
&&
552 io
->start
== sio
->start
&&
553 io
->stop
== sio
->stop
)
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
);
561 prot
= PAGE_KERNEL_PCC(sock
, _PAGE_PCC_IO8
);
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");
576 if (io
->flags
& MAP_ACTIVE
) {
577 unsigned long pstart
, psize
, paddrbase
;
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
;
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.
590 sp
->io_base
= p3_ioremap(paddrbase
+ pstart
, psize
, pgprot_val(prot
));
593 * Change the mapping used by inb() outb() etc
595 hd64465_port_map(io
->start
,
596 io
->stop
- io
->start
+ 1,
597 (unsigned long)sp
->io_base
+ io
->start
, 0);
599 hd64465_port_unmap(sio
->start
, sio
->stop
- sio
->start
+ 1);
600 p3_iounmap(sp
->io_base
);
607 /*============================================================*/
609 static int hs_set_mem_map(struct pcmcia_socket
*s
, struct pccard_mem_map
*mem
)
611 hs_socket_t
*sp
= container_of(s
, struct hs_socket_t
, socket
);
612 struct pccard_mem_map
*smem
;
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
);
623 smem
= &sp
->mem_maps
[map
];
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
;
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.
636 mem
->static_start
= paddr
;
643 /* TODO: do we need to use the MMU to access Common memory ??? */
645 /*============================================================*/
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.
653 static int hs_irq_demux(int irq
, void *dev
)
655 hs_socket_t
*sp
= dev
;
658 DPRINTK("hs_irq_demux(irq=%d)\n", irq
);
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
;
670 /*============================================================*/
673 * Interrupt handling routine.
676 static irqreturn_t
hs_interrupt(int irq
, void *dev
)
678 hs_socket_t
*sp
= dev
;
682 cscr
= hs_in(sp
, CSCR
);
684 DPRINTK("hs_interrupt, cscr=%04x\n", cscr
);
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",
693 /* Don't do the rest unless a card is present */
694 cscr
&= ~(HD64465_PCCCSCR_PCDC
|
698 HD64465_PCCCSCR_PSC
);
700 cscr
&= ~HD64465_PCCCSCR_PCDC
;
701 events
|= SS_DETECT
; /* card insertion or removal */
704 if (cscr
& HD64465_PCCCSCR_PRC
) {
705 cscr
&= ~HD64465_PCCCSCR_PRC
;
706 events
|= SS_READY
; /* ready signal changed */
708 if (cscr
& HD64465_PCCCSCR_PBW
) {
709 cscr
&= ~HD64465_PCCCSCR_PSC
;
710 events
|= SS_BATWARN
; /* battery warning */
712 if (cscr
& HD64465_PCCCSCR_PBD
) {
713 cscr
&= ~HD64465_PCCCSCR_PSC
;
714 events
|= SS_BATDEAD
; /* battery dead */
716 if (cscr
& HD64465_PCCCSCR_PSC
) {
717 cscr
&= ~HD64465_PCCCSCR_PSC
;
718 events
|= SS_STSCHG
; /* STSCHG (status changed) signal */
721 if (cscr
& HD64465_PCCCSCR_PIREQ
) {
722 cscr
&= ~HD64465_PCCCSCR_PIREQ
;
724 /* This should have been dealt with during irq demux */
725 printk(KERN_NOTICE MODNAME
": unexpected IREQ from card\n");
728 hs_out(sp
, cscr
, CSCR
);
731 pcmcia_parse_events(&sp
->socket
, events
);
736 /*============================================================*/
738 static struct pccard_operations hs_operations
= {
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
,
746 static int hs_init_socket(hs_socket_t
*sp
, int irq
, unsigned long mem_base
,
747 unsigned int ctrl_base
)
752 memset(sp
, 0, sizeof(*sp
));
754 sp
->mem_base
= mem_base
;
755 sp
->mem_length
= 4*HD64465_PCC_WINDOW
; /* 16MB */
756 sp
->ctrl_base
= ctrl_base
;
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
;
763 hd64465_register_irq_demux(sp
->irq
, hs_irq_demux
, sp
);
765 if ((err
= request_irq(sp
->irq
, hs_interrupt
, IRQF_DISABLED
, MODNAME
, sp
)) < 0)
767 if (request_mem_region(sp
->mem_base
, sp
->mem_length
, MODNAME
) == 0) {
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.
777 /*hs_set_voltages(sp, 0, 0);*/
779 /* hi-Z the outputs to the card and set 16MB map mode */
781 v
&= ~HD64465_PCCGCR_PCCT
; /* memory-only card */
785 v
|= HD64465_PCCGCR_PDRV
; /* enable outputs to card */
789 v
|= HD64465_PCCGCR_PMMOD
; /* 16MB mapping mode */
793 /* lowest 16MB of Common */
794 v
&= ~(HD64465_PCCGCR_PPA25
|HD64465_PCCGCR_PPA24
);
797 hs_reset_socket(sp
, 1);
799 printk(KERN_INFO
"HD64465 PCMCIA bridge socket %d at 0x%08lx irq %d\n",
800 i
, sp
->mem_base
, sp
->irq
);
805 static void hs_exit_socket(hs_socket_t
*sp
)
807 unsigned short cscier
, gcr
;
810 local_irq_save(flags
);
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
);
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
);
822 /* power the card down */
823 hs_set_voltages(sp
, 0, 0);
825 if (sp
->mem_base
!= 0)
826 release_mem_region(sp
->mem_base
, sp
->mem_length
);
828 free_irq(sp
->irq
, hs_interrupt
);
829 hd64465_unregister_irq_demux(sp
->irq
);
832 local_irq_restore(flags
);
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
,
842 static struct platform_device hd64465_device
= {
843 .name
= "hd64465-pcmcia",
847 static int __init
init_hs(void)
852 /* hd64465_io_debug = 1; */
853 if (driver_register(&hd64465_driver
))
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
);
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
);
867 /* use serial (TPS2206) power controller */
868 v
= inb(HD64465_REG_PCC0CSCR
);
869 v
|= HD64465_PCCCSCR_PSWSEL
;
870 outb(v
, HD64465_REG_PCC0CSCR
);
873 * Setup hs_sockets[] structures and request system resources.
874 * TODO: on memory allocation failure, power down the socket
877 for (i
=0; i
<HS_MAX_SOCKETS
; i
++) {
878 hs_set_voltages(&hs_sockets
[i
], 0, 0);
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 */
885 hs_sockets
[i
].socket
.owner
= THIS_MODULE
;
886 hs_sockets
[i
].socket
.ss_entry
= &hs_operations
;
889 i
= hs_init_socket(&hs_sockets
[0],
892 HD64465_REG_PCC0ISR
);
894 unregister_driver(&hd64465_driver
);
897 i
= hs_init_socket(&hs_sockets
[1],
900 HD64465_REG_PCC1ISR
);
902 unregister_driver(&hd64465_driver
);
906 /* hd64465_io_debug = 0; */
908 platform_device_register(&hd64465_device
);
910 for (i
=0; i
<HS_MAX_SOCKETS
; i
++) {
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
);
916 pcmcia_unregister_socket(&hs_sockets
[0].socket
);
922 static void __exit
exit_hs(void)
926 for (i
=0 ; i
<HS_MAX_SOCKETS
; i
++) {
927 pcmcia_unregister_socket(&hs_sockets
[i
].socket
);
928 hs_exit_socket(&hs_sockets
[i
]);
931 platform_device_unregister(&hd64465_device
);
932 unregister_driver(&hd64465_driver
);
935 module_init(init_hs
);
936 module_exit(exit_hs
);
938 /*============================================================*/