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>
49 #include <pcmcia/bulkmem.h>
50 #include "cs_internal.h"
52 #define MODNAME "hd64465_ss"
54 /* #define HD64465_DEBUG 1 */
57 #define DPRINTK(args...) printk(MODNAME ": " args)
59 #define DPRINTK(args...)
62 extern int hd64465_io_debug;
63 extern void * p3_ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags);
64 extern void p3_iounmap(void *addr);
66 /*============================================================*/
68 #define HS_IO_MAP_SIZE (64*1024)
70 typedef struct hs_socket_t
79 pccard_io_map io_maps[MAX_IO_WIN];
80 pccard_mem_map mem_maps[MAX_WIN];
81 struct pcmcia_socket socket;
86 #define HS_MAX_SOCKETS 2
87 static hs_socket_t hs_sockets[HS_MAX_SOCKETS];
89 #define hs_in(sp, r) inb((sp)->ctrl_base + (r))
90 #define hs_out(sp, v, r) outb(v, (sp)->ctrl_base + (r))
93 /* translate a boolean value to a bit in a register */
94 #define bool_to_regbit(sp, r, bi, bo) \
96 unsigned short v = hs_in(sp, r); \
104 /* register offsets from HD64465_REG_PCC[01]ISR */
112 /* Mask and values for CSCIER register */
113 #define IER_MASK 0x80
114 #define IER_ON 0x3f /* interrupts on */
115 #define IER_OFF 0x00 /* interrupts off */
117 /*============================================================*/
119 #if HD64465_DEBUG > 10
121 static void cis_hex_dump(const unsigned char *x, int len)
125 for (i=0 ; i<len ; i++)
128 printk("\n%08x", (unsigned)(x + i));
129 printk(" %02x", *(volatile unsigned short*)x);
136 /*============================================================*/
139 * This code helps create the illusion that the IREQ line from
140 * the PC card is mapped to one of the CPU's IRQ lines by the
141 * host bridge hardware (which is how every host bridge *except*
142 * the HD64465 works). In particular, it supports enabling
143 * and disabling the IREQ line by code which knows nothing
144 * about the host bridge (e.g. device drivers, IDE code) using
145 * the request_irq(), free_irq(), probe_irq_on() and probe_irq_off()
146 * functions. Also, it supports sharing the mapped IRQ with
147 * real hardware IRQs from the -IRL0-3 lines.
150 #define HS_NUM_MAPPED_IRQS 16 /* Limitation of the PCMCIA code */
153 /* index is mapped irq number */
155 hw_irq_controller *old_handler;
156 } hs_mapped_irq[HS_NUM_MAPPED_IRQS];
158 static void hs_socket_enable_ireq(hs_socket_t *sp)
160 unsigned short cscier;
162 DPRINTK("hs_socket_enable_ireq(sock=%d)\n", sp->number);
164 cscier = hs_in(sp, CSCIER);
165 cscier &= ~HD64465_PCCCSCIER_PIREQE_MASK;
166 cscier |= HD64465_PCCCSCIER_PIREQE_LEVEL;
167 hs_out(sp, cscier, CSCIER);
170 static void hs_socket_disable_ireq(hs_socket_t *sp)
172 unsigned short cscier;
174 DPRINTK("hs_socket_disable_ireq(sock=%d)\n", sp->number);
176 cscier = hs_in(sp, CSCIER);
177 cscier &= ~HD64465_PCCCSCIER_PIREQE_MASK;
178 hs_out(sp, cscier, CSCIER);
181 static unsigned int hs_startup_irq(unsigned int irq)
183 hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
184 hs_mapped_irq[irq].old_handler->startup(irq);
188 static void hs_shutdown_irq(unsigned int irq)
190 hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
191 hs_mapped_irq[irq].old_handler->shutdown(irq);
194 static void hs_enable_irq(unsigned int irq)
196 hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
197 hs_mapped_irq[irq].old_handler->enable(irq);
200 static void hs_disable_irq(unsigned int irq)
202 hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
203 hs_mapped_irq[irq].old_handler->disable(irq);
206 extern struct hw_interrupt_type no_irq_type;
208 static void hs_mask_and_ack_irq(unsigned int irq)
210 hs_socket_disable_ireq(hs_mapped_irq[irq].sock);
211 /* ack_none() spuriously complains about an unexpected IRQ */
212 if (hs_mapped_irq[irq].old_handler != &no_irq_type)
213 hs_mapped_irq[irq].old_handler->ack(irq);
216 static void hs_end_irq(unsigned int irq)
218 hs_socket_enable_ireq(hs_mapped_irq[irq].sock);
219 hs_mapped_irq[irq].old_handler->end(irq);
223 static struct hw_interrupt_type hd64465_ss_irq_type = {
224 .typename = "PCMCIA-IRQ",
225 .startup = hs_startup_irq,
226 .shutdown = hs_shutdown_irq,
227 .enable = hs_enable_irq,
228 .disable = hs_disable_irq,
229 .ack = hs_mask_and_ack_irq,
234 * This function should only ever be called with interrupts disabled.
236 static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
238 DPRINTK("hs_map_irq(sock=%d irq=%d)\n", sp->number, irq);
240 if (irq >= HS_NUM_MAPPED_IRQS)
243 hs_mapped_irq[irq].sock = sp;
244 /* insert ourselves as the irq controller */
245 hs_mapped_irq[irq].old_handler = irq_desc[irq].chip;
246 irq_desc[irq].chip = &hd64465_ss_irq_type;
251 * This function should only ever be called with interrupts disabled.
253 static void hs_unmap_irq(hs_socket_t *sp, unsigned int irq)
255 DPRINTK("hs_unmap_irq(sock=%d irq=%d)\n", sp->number, irq);
257 if (irq >= HS_NUM_MAPPED_IRQS)
260 /* restore the original irq controller */
261 irq_desc[irq].chip = hs_mapped_irq[irq].old_handler;
264 /*============================================================*/
268 * Set Vpp and Vcc (in tenths of a Volt). Does not
269 * support the hi-Z state.
271 * Note, this assumes the board uses a TPS2206 chip to control
272 * the Vcc and Vpp voltages to the hs_sockets. If your board
273 * uses the MIC2563 (also supported by the HD64465) then you
274 * will have to modify this function.
277 static const u_char hs_tps2206_avcc[3] = { 0x00, 0x04, 0x08 };
278 static const u_char hs_tps2206_bvcc[3] = { 0x00, 0x80, 0x40 };
280 static int hs_set_voltages(hs_socket_t *sp, int Vcc, int Vpp)
284 u_int sock = sp->number;
286 DPRINTK("hs_set_voltage(%d, %d, %d)\n", sock, Vcc, Vpp);
290 case 0: vcci = 0; break;
291 case 33: vcci = 1; break;
292 case 50: vcci = 2; break;
296 /* Note: Vpp = 120 not supported -- Greg Banks */
297 if (Vpp != 0 && Vpp != Vcc)
300 /* The PSR register holds 8 of the 9 bits which control
301 * the TPS2206 via its serial interface.
303 psr = inw(HD64465_REG_PCCPSR);
308 psr |= hs_tps2206_avcc[vcci];
309 psr |= (Vpp == 0 ? 0x00 : 0x02);
313 psr |= hs_tps2206_bvcc[vcci];
314 psr |= (Vpp == 0 ? 0x00 : 0x20);
317 outw(psr, HD64465_REG_PCCPSR);
323 /*============================================================*/
326 * Drive the RESET line to the card.
328 static void hs_reset_socket(hs_socket_t *sp, int on)
334 v |= HD64465_PCCGCR_PCCR;
336 v &= ~HD64465_PCCGCR_PCCR;
340 /*============================================================*/
342 static int hs_init(struct pcmcia_socket *s)
344 hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
346 DPRINTK("hs_init(%d)\n", sp->number);
351 /*============================================================*/
354 static int hs_get_status(struct pcmcia_socket *s, u_int *value)
356 hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
361 isr = hs_in(sp, ISR);
363 /* Card is seated and powered when *both* CD pins are low */
364 if ((isr & HD64465_PCCISR_PCD_MASK) == 0)
366 status |= SS_DETECT; /* card present */
368 switch (isr & HD64465_PCCISR_PBVD_MASK)
370 case HD64465_PCCISR_PBVD_BATGOOD:
372 case HD64465_PCCISR_PBVD_BATWARN:
373 status |= SS_BATWARN;
376 status |= SS_BATDEAD;
380 if (isr & HD64465_PCCISR_PREADY)
383 if (isr & HD64465_PCCISR_PMWP)
386 /* Voltage Select pins interpreted as per Table 4-5 of the std.
387 * Assuming we have the TPS2206, the socket is a "Low Voltage
388 * key, 3.3V and 5V available, no X.XV available".
390 switch (isr & (HD64465_PCCISR_PVS2|HD64465_PCCISR_PVS1))
392 case HD64465_PCCISR_PVS1:
393 printk(KERN_NOTICE MODNAME ": cannot handle X.XV card, ignored\n");
397 case HD64465_PCCISR_PVS2:
401 case HD64465_PCCISR_PVS2|HD64465_PCCISR_PVS1:
406 /* TODO: SS_POWERON */
407 /* TODO: SS_STSCHG */
410 DPRINTK("hs_get_status(%d) = %x\n", sock, status);
416 /*============================================================*/
418 static int hs_set_socket(struct pcmcia_socket *s, socket_state_t *state)
420 hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
423 unsigned short cscier;
425 DPRINTK("hs_set_socket(sock=%d, flags=%x, csc_mask=%x, Vcc=%d, Vpp=%d, io_irq=%d)\n",
426 sock, state->flags, state->csc_mask, state->Vcc, state->Vpp, state->io_irq);
428 local_irq_save(flags); /* Don't want interrupts happening here */
430 if (state->Vpp != sp->state.Vpp ||
431 state->Vcc != sp->state.Vcc) {
432 if (!hs_set_voltages(sp, state->Vcc, state->Vpp)) {
433 local_irq_restore(flags);
438 /* hd64465_io_debug = 1; */
440 * Handle changes in the Card Status Change mask,
441 * by propagating to the CSCR register
443 changed = sp->state.csc_mask ^ state->csc_mask;
444 cscier = hs_in(sp, CSCIER);
446 if (changed & SS_DETECT) {
447 if (state->csc_mask & SS_DETECT)
448 cscier |= HD64465_PCCCSCIER_PCDE;
450 cscier &= ~HD64465_PCCCSCIER_PCDE;
453 if (changed & SS_READY) {
454 if (state->csc_mask & SS_READY)
455 cscier |= HD64465_PCCCSCIER_PRE;
457 cscier &= ~HD64465_PCCCSCIER_PRE;
460 if (changed & SS_BATDEAD) {
461 if (state->csc_mask & SS_BATDEAD)
462 cscier |= HD64465_PCCCSCIER_PBDE;
464 cscier &= ~HD64465_PCCCSCIER_PBDE;
467 if (changed & SS_BATWARN) {
468 if (state->csc_mask & SS_BATWARN)
469 cscier |= HD64465_PCCCSCIER_PBWE;
471 cscier &= ~HD64465_PCCCSCIER_PBWE;
474 if (changed & SS_STSCHG) {
475 if (state->csc_mask & SS_STSCHG)
476 cscier |= HD64465_PCCCSCIER_PSCE;
478 cscier &= ~HD64465_PCCCSCIER_PSCE;
481 hs_out(sp, cscier, CSCIER);
483 if (sp->state.io_irq && !state->io_irq)
484 hs_unmap_irq(sp, sp->state.io_irq);
485 else if (!sp->state.io_irq && state->io_irq)
486 hs_map_irq(sp, state->io_irq);
490 * Handle changes in the flags field,
491 * by propagating to config registers.
493 changed = sp->state.flags ^ state->flags;
495 if (changed & SS_IOCARD) {
496 DPRINTK("card type: %s\n",
497 (state->flags & SS_IOCARD ? "i/o" : "memory" ));
498 bool_to_regbit(sp, GCR, HD64465_PCCGCR_PCCT,
499 state->flags & SS_IOCARD);
502 if (changed & SS_RESET) {
503 DPRINTK("%s reset card\n",
504 (state->flags & SS_RESET ? "start" : "stop"));
505 bool_to_regbit(sp, GCR, HD64465_PCCGCR_PCCR,
506 state->flags & SS_RESET);
509 if (changed & SS_OUTPUT_ENA) {
510 DPRINTK("%sabling card output\n",
511 (state->flags & SS_OUTPUT_ENA ? "en" : "dis"));
512 bool_to_regbit(sp, GCR, HD64465_PCCGCR_PDRV,
513 state->flags & SS_OUTPUT_ENA);
516 /* TODO: SS_SPKR_ENA */
518 /* hd64465_io_debug = 0; */
521 local_irq_restore(flags);
523 #if HD64465_DEBUG > 10
524 if (state->flags & SS_OUTPUT_ENA)
525 cis_hex_dump((const unsigned char*)sp->mem_base, 0x100);
530 /*============================================================*/
532 static int hs_set_io_map(struct pcmcia_socket *s, struct pccard_io_map *io)
534 hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
536 int sock = sp->number;
537 struct pccard_io_map *sio;
540 DPRINTK("hs_set_io_map(sock=%d, map=%d, flags=0x%x, speed=%dns, start=%#lx, stop=%#lx)\n",
541 sock, map, io->flags, io->speed, io->start, io->stop);
542 if (map >= MAX_IO_WIN)
544 sio = &sp->io_maps[map];
546 /* check for null changes */
547 if (io->flags == sio->flags &&
548 io->start == sio->start &&
549 io->stop == sio->stop)
552 if (io->flags & MAP_AUTOSZ)
553 prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IODYN);
554 else if (io->flags & MAP_16BIT)
555 prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IO16);
557 prot = PAGE_KERNEL_PCC(sock, _PAGE_PCC_IO8);
559 /* TODO: handle MAP_USE_WAIT */
560 if (io->flags & MAP_USE_WAIT)
561 printk(KERN_INFO MODNAME ": MAP_USE_WAIT unimplemented\n");
562 /* TODO: handle MAP_PREFETCH */
563 if (io->flags & MAP_PREFETCH)
564 printk(KERN_INFO MODNAME ": MAP_PREFETCH unimplemented\n");
565 /* TODO: handle MAP_WRPROT */
566 if (io->flags & MAP_WRPROT)
567 printk(KERN_INFO MODNAME ": MAP_WRPROT unimplemented\n");
568 /* TODO: handle MAP_0WS */
569 if (io->flags & MAP_0WS)
570 printk(KERN_INFO MODNAME ": MAP_0WS unimplemented\n");
572 if (io->flags & MAP_ACTIVE) {
573 unsigned long pstart, psize, paddrbase;
575 paddrbase = virt_to_phys((void*)(sp->mem_base + 2 * HD64465_PCC_WINDOW));
576 pstart = io->start & PAGE_MASK;
577 psize = ((io->stop + PAGE_SIZE) & PAGE_MASK) - pstart;
580 * Change PTEs in only that portion of the mapping requested
581 * by the caller. This means that most of the time, most of
582 * the PTEs in the io_vma will be unmapped and only the bottom
583 * page will be mapped. But the code allows for weird cards
584 * that might want IO ports > 4K.
586 sp->io_base = p3_ioremap(paddrbase + pstart, psize, pgprot_val(prot));
589 * Change the mapping used by inb() outb() etc
591 hd64465_port_map(io->start,
592 io->stop - io->start + 1,
593 (unsigned long)sp->io_base + io->start, 0);
595 hd64465_port_unmap(sio->start, sio->stop - sio->start + 1);
596 p3_iounmap(sp->io_base);
603 /*============================================================*/
605 static int hs_set_mem_map(struct pcmcia_socket *s, struct pccard_mem_map *mem)
607 hs_socket_t *sp = container_of(s, struct hs_socket_t, socket);
608 struct pccard_mem_map *smem;
613 DPRINTK("hs_set_mem_map(sock=%d, map=%d, flags=0x%x, card_start=0x%08x)\n",
614 sock, map, mem->flags, mem->card_start);
619 smem = &sp->mem_maps[map];
621 paddr = sp->mem_base; /* base of Attribute mapping */
622 if (!(mem->flags & MAP_ATTRIB))
623 paddr += HD64465_PCC_WINDOW; /* base of Common mapping */
624 paddr += mem->card_start;
626 /* Because we specified SS_CAP_STATIC_MAP, we are obliged
627 * at this time to report the system address corresponding
628 * to the card address requested. This is how Socket Services
629 * queries our fixed mapping. I wish this fact had been
630 * documented - Greg Banks.
632 mem->static_start = paddr;
639 /* TODO: do we need to use the MMU to access Common memory ??? */
641 /*============================================================*/
644 * This function is registered with the HD64465 glue code to do a
645 * secondary demux step on the PCMCIA interrupts. It handles
646 * mapping the IREQ request from the card to a standard Linux
647 * IRQ, as requested by SocketServices.
649 static int hs_irq_demux(int irq, void *dev)
651 hs_socket_t *sp = dev;
654 DPRINTK("hs_irq_demux(irq=%d)\n", irq);
656 if (sp->state.io_irq &&
657 (cscr = hs_in(sp, CSCR)) & HD64465_PCCCSCR_PIREQ) {
658 cscr &= ~HD64465_PCCCSCR_PIREQ;
659 hs_out(sp, cscr, CSCR);
660 return sp->state.io_irq;
666 /*============================================================*/
669 * Interrupt handling routine.
672 static irqreturn_t hs_interrupt(int irq, void *dev)
674 hs_socket_t *sp = dev;
678 cscr = hs_in(sp, CSCR);
680 DPRINTK("hs_interrupt, cscr=%04x\n", cscr);
682 /* check for bus-related changes to be reported to Socket Services */
683 if (cscr & HD64465_PCCCSCR_PCDC) {
684 /* double-check for a 16-bit card, as we don't support CardBus */
685 if ((hs_in(sp, ISR) & HD64465_PCCISR_PCD_MASK) != 0) {
686 printk(KERN_NOTICE MODNAME
687 ": socket %d, card not a supported card type or not inserted correctly\n",
689 /* Don't do the rest unless a card is present */
690 cscr &= ~(HD64465_PCCCSCR_PCDC|
694 HD64465_PCCCSCR_PSC);
696 cscr &= ~HD64465_PCCCSCR_PCDC;
697 events |= SS_DETECT; /* card insertion or removal */
700 if (cscr & HD64465_PCCCSCR_PRC) {
701 cscr &= ~HD64465_PCCCSCR_PRC;
702 events |= SS_READY; /* ready signal changed */
704 if (cscr & HD64465_PCCCSCR_PBW) {
705 cscr &= ~HD64465_PCCCSCR_PSC;
706 events |= SS_BATWARN; /* battery warning */
708 if (cscr & HD64465_PCCCSCR_PBD) {
709 cscr &= ~HD64465_PCCCSCR_PSC;
710 events |= SS_BATDEAD; /* battery dead */
712 if (cscr & HD64465_PCCCSCR_PSC) {
713 cscr &= ~HD64465_PCCCSCR_PSC;
714 events |= SS_STSCHG; /* STSCHG (status changed) signal */
717 if (cscr & HD64465_PCCCSCR_PIREQ) {
718 cscr &= ~HD64465_PCCCSCR_PIREQ;
720 /* This should have been dealt with during irq demux */
721 printk(KERN_NOTICE MODNAME ": unexpected IREQ from card\n");
724 hs_out(sp, cscr, CSCR);
727 pcmcia_parse_events(&sp->socket, events);
732 /*============================================================*/
734 static struct pccard_operations hs_operations = {
736 .get_status = hs_get_status,
737 .set_socket = hs_set_socket,
738 .set_io_map = hs_set_io_map,
739 .set_mem_map = hs_set_mem_map,
742 static int hs_init_socket(hs_socket_t *sp, int irq, unsigned long mem_base,
743 unsigned int ctrl_base)
748 memset(sp, 0, sizeof(*sp));
750 sp->mem_base = mem_base;
751 sp->mem_length = 4*HD64465_PCC_WINDOW; /* 16MB */
752 sp->ctrl_base = ctrl_base;
754 for (i=0 ; i<MAX_IO_WIN ; i++)
755 sp->io_maps[i].map = i;
756 for (i=0 ; i<MAX_WIN ; i++)
757 sp->mem_maps[i].map = i;
759 hd64465_register_irq_demux(sp->irq, hs_irq_demux, sp);
761 if ((err = request_irq(sp->irq, hs_interrupt, IRQF_DISABLED, MODNAME, sp)) < 0)
763 if (request_mem_region(sp->mem_base, sp->mem_length, MODNAME) == 0) {
769 /* According to section 3.2 of the PCMCIA standard, low-voltage
770 * capable cards must implement cold insertion, i.e. Vpp and
771 * Vcc set to 0 before card is inserted.
773 /*hs_set_voltages(sp, 0, 0);*/
775 /* hi-Z the outputs to the card and set 16MB map mode */
777 v &= ~HD64465_PCCGCR_PCCT; /* memory-only card */
781 v |= HD64465_PCCGCR_PDRV; /* enable outputs to card */
785 v |= HD64465_PCCGCR_PMMOD; /* 16MB mapping mode */
789 /* lowest 16MB of Common */
790 v &= ~(HD64465_PCCGCR_PPA25|HD64465_PCCGCR_PPA24);
793 hs_reset_socket(sp, 1);
795 printk(KERN_INFO "HD64465 PCMCIA bridge socket %d at 0x%08lx irq %d\n",
796 i, sp->mem_base, sp->irq);
801 static void hs_exit_socket(hs_socket_t *sp)
803 unsigned short cscier, gcr;
806 local_irq_save(flags);
808 /* turn off interrupts in hardware */
809 cscier = hs_in(sp, CSCIER);
810 cscier = (cscier & IER_MASK) | IER_OFF;
811 hs_out(sp, cscier, CSCIER);
813 /* hi-Z the outputs to the card */
814 gcr = hs_in(sp, GCR);
815 gcr &= HD64465_PCCGCR_PDRV;
816 hs_out(sp, gcr, GCR);
818 /* power the card down */
819 hs_set_voltages(sp, 0, 0);
821 if (sp->mem_base != 0)
822 release_mem_region(sp->mem_base, sp->mem_length);
824 free_irq(sp->irq, hs_interrupt);
825 hd64465_unregister_irq_demux(sp->irq);
828 local_irq_restore(flags);
831 static struct device_driver hd64465_driver = {
832 .name = "hd64465-pcmcia",
833 .bus = &platform_bus_type,
834 .suspend = pcmcia_socket_dev_suspend,
835 .resume = pcmcia_socket_dev_resume,
838 static struct platform_device hd64465_device = {
839 .name = "hd64465-pcmcia",
843 static int __init init_hs(void)
848 /* hd64465_io_debug = 1; */
849 if (driver_register(&hd64465_driver))
852 /* Wake both sockets out of STANDBY mode */
853 /* TODO: wait 15ms */
854 v = inw(HD64465_REG_SMSCR);
855 v &= ~(HD64465_SMSCR_PC0ST|HD64465_SMSCR_PC1ST);
856 outw(v, HD64465_REG_SMSCR);
858 /* keep power controller out of shutdown mode */
859 v = inb(HD64465_REG_PCC0SCR);
860 v |= HD64465_PCCSCR_SHDN;
861 outb(v, HD64465_REG_PCC0SCR);
863 /* use serial (TPS2206) power controller */
864 v = inb(HD64465_REG_PCC0CSCR);
865 v |= HD64465_PCCCSCR_PSWSEL;
866 outb(v, HD64465_REG_PCC0CSCR);
869 * Setup hs_sockets[] structures and request system resources.
870 * TODO: on memory allocation failure, power down the socket
873 for (i=0; i<HS_MAX_SOCKETS; i++) {
874 hs_set_voltages(&hs_sockets[i], 0, 0);
876 hs_sockets[i].socket.features |= SS_CAP_PCCARD | SS_CAP_STATIC_MAP; /* mappings are fixed in host memory */
877 hs_sockets[i].socket.resource_ops = &pccard_static_ops;
878 hs_sockets[i].socket.irq_mask = 0xffde;/*0xffff*/ /* IRQs mapped in s/w so can do any, really */
879 hs_sockets[i].socket.map_size = HD64465_PCC_WINDOW; /* 16MB fixed window size */
881 hs_sockets[i].socket.owner = THIS_MODULE;
882 hs_sockets[i].socket.ss_entry = &hs_operations;
885 i = hs_init_socket(&hs_sockets[0],
888 HD64465_REG_PCC0ISR);
890 unregister_driver(&hd64465_driver);
893 i = hs_init_socket(&hs_sockets[1],
896 HD64465_REG_PCC1ISR);
898 unregister_driver(&hd64465_driver);
902 /* hd64465_io_debug = 0; */
904 platform_device_register(&hd64465_device);
906 for (i=0; i<HS_MAX_SOCKETS; i++) {
908 hs_sockets[i].socket.dev.parent = &hd64465_device.dev;
909 hs_sockets[i].number = i;
910 ret = pcmcia_register_socket(&hs_sockets[i].socket);
912 pcmcia_unregister_socket(&hs_sockets[0].socket);
918 static void __exit exit_hs(void)
922 for (i=0 ; i<HS_MAX_SOCKETS ; i++) {
923 pcmcia_unregister_socket(&hs_sockets[i].socket);
924 hs_exit_socket(&hs_sockets[i]);
927 platform_device_unregister(&hd64465_device);
928 unregister_driver(&hd64465_driver);
931 module_init(init_hs);
932 module_exit(exit_hs);
934 /*============================================================*/