4c1f4c70e21cd22680d6806cf0f4ac24228d0d87
[dragonfly.git] / sys / bus / pccard / pcic.c
1 /*
2  *  Intel PCIC or compatible Controller driver
3  *-------------------------------------------------------------------------
4  *
5  * Copyright (c) 2001 M. Warner Losh.  All rights reserved.
6  * Copyright (c) 1995 Andrew McRae.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. The name of the author may not be used to endorse or promote products
17  *    derived from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * $FreeBSD: src/sys/pccard/pcic.c,v 1.89.2.28 2003/02/26 18:42:00 imp Exp $
31  * $DragonFly: src/sys/bus/pccard/Attic/pcic.c,v 1.4 2004/01/08 10:06:29 joerg Exp $
32  */
33
34 #include <sys/param.h>
35 #include <sys/bus.h>
36 #include <sys/kernel.h>
37 #include <sys/module.h>
38 #include <sys/sysctl.h>
39 #include <sys/systm.h>
40
41 #include <machine/clock.h>
42 #include "i82365.h"
43 #include "pcic_pci.h"
44 #include "cardinfo.h"
45 #include "slot.h"
46 #include "pcicvar.h"
47
48 /* Get pnp IDs */
49 #include <bus/isa/isavar.h>
50 #include <dev/misc/pcic/i82365reg.h>
51 #include "pccardvar.h"
52 #include "card_if.h"
53
54 /*
55  *      Prototypes for interrupt handler.
56  */
57 static int              pcic_ioctl(struct slot *, int, caddr_t);
58 static int              pcic_power(struct slot *);
59 static void             pcic_mapirq(struct slot *, int);
60 static timeout_t        pcic_reset;
61 static void             pcic_resume(struct slot *);
62 static void             pcic_disable(struct slot *);
63 static int              pcic_memory(struct slot *, int);
64 static int              pcic_io(struct slot *, int);
65
66 devclass_t      pcic_devclass;
67
68 static struct slot_ctrl pcic_cinfo = {
69         pcic_mapirq,
70         pcic_memory,
71         pcic_io,
72         pcic_reset,
73         pcic_disable,
74         pcic_power,
75         pcic_ioctl,
76         pcic_resume,
77         PCIC_MEM_WIN,
78         PCIC_IO_WIN
79 };
80
81 /* sysctl vars */
82 SYSCTL_NODE(_hw, OID_AUTO, pcic, CTLFLAG_RD, 0, "PCIC parameters");
83
84 int pcic_override_irq = 0;
85 TUNABLE_INT("machdep.pccard.pcic_irq", &pcic_override_irq);
86 TUNABLE_INT("hw.pcic.irq", &pcic_override_irq);
87 SYSCTL_INT(_hw_pcic, OID_AUTO, irq, CTLFLAG_RD,
88     &pcic_override_irq, 0,
89     "Override the IRQ configured by the config system for all pcic devices");
90
91 int pcic_boot_deactivated = 0;
92 TUNABLE_INT("hw.pcic.boot_deactivated", &pcic_boot_deactivated);
93 SYSCTL_INT(_hw_pcic, OID_AUTO, boot_deactivated, CTLFLAG_RD,
94     &pcic_boot_deactivated, 0,
95     "Override the automatic powering up of pccards at boot.  This works\n\
96 around what turns out to be an old bug in the code that has since been\n\
97 corrected.  It is now deprecated and will be removed completely before\n\
98 FreeBSD 4.8.");
99
100 /*
101  * CL-PD6722's VSENSE method
102  *     0: NO VSENSE (assume a 5.0V card)
103  *     1: 6710's method (default)
104  *     2: 6729's method
105  */
106 int pcic_pd6722_vsense = 1;
107 TUNABLE_INT("hw.pcic.pd6722_vsense", &pcic_pd6722_vsense);
108 SYSCTL_INT(_hw_pcic, OID_AUTO, pd6722_vsense, CTLFLAG_RD,
109     &pcic_pd6722_vsense, 1,
110     "Select CL-PD6722's VSENSE method.  VSENSE is used to determine the\n\
111 volatage of inserted cards.  The CL-PD6722 has two methods to determine the\n\
112 voltage of the card.  0 means assume a 5.0V card and do not check.  1 means\n\
113 use the same method that the CL-PD6710 uses (default).  2 means use the\n\
114 same method as the CL-PD6729.  2 is documented in the datasheet as being\n\
115 the correct way, but 1 seems to give better results on more laptops.");
116
117 /*
118  * Read a register from the PCIC.
119  */
120 unsigned char
121 pcic_getb_io(struct pcic_slot *sp, int reg)
122 {
123         bus_space_write_1(sp->bst, sp->bsh, PCIC_INDEX, sp->offset + reg);
124         return (bus_space_read_1(sp->bst, sp->bsh, PCIC_DATA));
125 }
126
127 /*
128  * Write a register on the PCIC
129  */
130 void
131 pcic_putb_io(struct pcic_slot *sp, int reg, unsigned char val)
132 {
133         /*
134          * Many datasheets recommend using outw rather than outb to save 
135          * a microsecond.  Maybe we should do this, but we'd likely only
136          * save 20-30us on card activation.
137          */
138         bus_space_write_1(sp->bst, sp->bsh, PCIC_INDEX, sp->offset + reg);
139         bus_space_write_1(sp->bst, sp->bsh, PCIC_DATA, val);
140 }
141
142 /*
143  * Clear bit(s) of a register.
144  */
145 __inline void
146 pcic_clrb(struct pcic_slot *sp, int reg, unsigned char mask)
147 {
148         sp->putb(sp, reg, sp->getb(sp, reg) & ~mask);
149 }
150
151 /*
152  * Set bit(s) of a register
153  */
154 __inline void
155 pcic_setb(struct pcic_slot *sp, int reg, unsigned char mask)
156 {
157         sp->putb(sp, reg, sp->getb(sp, reg) | mask);
158 }
159
160 /*
161  * Write a 16 bit value to 2 adjacent PCIC registers
162  */
163 static __inline void
164 pcic_putw(struct pcic_slot *sp, int reg, unsigned short word)
165 {
166         sp->putb(sp, reg, word & 0xFF);
167         sp->putb(sp, reg + 1, (word >> 8) & 0xff);
168 }
169
170 /*
171  * pc98 cbus cards introduce a slight wrinkle here.  They route the irq7 pin
172  * from the pcic chip to INT 2 on the cbus.  INT 2 is normally mapped to
173  * irq 6 on the pc98 architecture, so if we get a request for irq 6
174  * lie to the hardware and say it is 7.  All the other usual mappings for
175  * cbus INT into irq space are the same as the rest of the system.
176  */
177 static __inline int
178 host_irq_to_pcic(int irq)
179 {
180 #ifdef PC98
181         if (irq == 6)
182                 irq = 7;
183 #endif
184         return (irq);
185 }
186
187 /*
188  * Free up resources allocated so far.
189  */
190 void
191 pcic_dealloc(device_t dev)
192 {
193         struct pcic_softc *sc;
194
195         sc = (struct pcic_softc *) device_get_softc(dev);
196         if (sc->slot_poll)
197                 untimeout(sc->slot_poll, sc, sc->timeout_ch);
198         if (sc->iores)
199                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid,
200                     sc->iores);
201         if (sc->memres)
202                 bus_release_resource(dev, SYS_RES_MEMORY, sc->memrid,
203                     sc->memres);
204         if (sc->ih)
205                 bus_teardown_intr(dev, sc->irqres, sc->ih);
206         if (sc->irqres)
207                 bus_release_resource(dev, SYS_RES_IRQ, sc->irqrid, sc->irqres);
208 }
209
210 /*
211  *      entry point from main code to map/unmap memory context.
212  */
213 static int
214 pcic_memory(struct slot *slt, int win)
215 {
216         struct pcic_slot *sp = slt->cdata;
217         struct mem_desc *mp = &slt->mem[win];
218         int reg = win * PCIC_MEMSIZE + PCIC_MEMBASE;
219
220         if (win < 0 || win >= slt->ctrl->maxmem) {
221                 printf("Illegal PCIC MEMORY window request %d\n", win);
222                 return (ENXIO);
223         }
224         if (mp->flags & MDF_ACTIVE) {
225                 unsigned long sys_addr = (uintptr_t)(void *)mp->start >> 12;
226                 if ((sys_addr >> 12) != 0 && 
227                     (sp->sc->flags & PCIC_YENTA_HIGH_MEMORY) == 0) {
228                         printf("This pcic does not support mapping > 24M\n");
229                         return (ENXIO);
230                 }
231                 /*
232                  * Write the addresses, card offsets and length.
233                  * The values are all stored as the upper 12 bits of the
234                  * 24 bit address i.e everything is allocated as 4 Kb chunks.
235                  * Memory mapped cardbus bridges extend this slightly to allow
236                  * one to set the upper 8 bits of the 32bit address as well.
237                  * If the chip supports it, then go ahead and write those
238                  * upper 8 bits.
239                  */
240                 pcic_putw(sp, reg, sys_addr & 0xFFF);
241                 pcic_putw(sp, reg+2, (sys_addr + (mp->size >> 12) - 1) & 0xFFF);
242                 pcic_putw(sp, reg+4, ((mp->card >> 12) - sys_addr) & 0x3FFF);
243                 if (sp->sc->flags & PCIC_YENTA_HIGH_MEMORY)
244                     sp->putb(sp, PCIC_MEMORY_HIGH0 + win, sys_addr >> 12);
245                 /*
246                  *      Each 16 bit register has some flags in the upper bits.
247                  */
248                 if (mp->flags & MDF_16BITS)
249                         pcic_setb(sp, reg+1, PCIC_DATA16);
250                 if (mp->flags & MDF_ZEROWS)
251                         pcic_setb(sp, reg+1, PCIC_ZEROWS);
252                 if (mp->flags & MDF_WS0)
253                         pcic_setb(sp, reg+3, PCIC_MW0);
254                 if (mp->flags & MDF_WS1)
255                         pcic_setb(sp, reg+3, PCIC_MW1);
256                 if (mp->flags & MDF_ATTR)
257                         pcic_setb(sp, reg+5, PCIC_REG);
258                 if (mp->flags & MDF_WP)
259                         pcic_setb(sp, reg+5, PCIC_WP);
260                 /*
261                  * Enable the memory window. By experiment, we need a delay.
262                  */
263                 pcic_setb(sp, PCIC_ADDRWINE, (1<<win) | PCIC_MEMCS16);
264                 DELAY(50);
265         } else {
266                 pcic_clrb(sp, PCIC_ADDRWINE, 1<<win);
267                 pcic_putw(sp, reg, 0);
268                 pcic_putw(sp, reg+2, 0);
269                 pcic_putw(sp, reg+4, 0);
270         }
271         return (0);
272 }
273
274 /*
275  *      pcic_io - map or unmap I/O context
276  */
277 static int
278 pcic_io(struct slot *slt, int win)
279 {
280         int     mask, reg;
281         struct pcic_slot *sp = slt->cdata;
282         struct io_desc *ip = &slt->io[win];
283         if (bootverbose) {
284                 printf("pcic: I/O win %d flags %x %x-%x\n", win, ip->flags,
285                     ip->start, ip->start + ip->size - 1);
286         }
287
288         switch (win) {
289         case 0:
290                 mask = PCIC_IO0_EN;
291                 reg = PCIC_IO0;
292                 break;
293         case 1:
294                 mask = PCIC_IO1_EN;
295                 reg = PCIC_IO1;
296                 break;
297         default:
298                 printf("Illegal PCIC I/O window request %d\n", win);
299                 return (ENXIO);
300         }
301         if (ip->flags & IODF_ACTIVE) {
302                 unsigned char x, ioctlv;
303
304                 pcic_putw(sp, reg, ip->start);
305                 pcic_putw(sp, reg+2, ip->start + ip->size - 1);
306                 x = 0;
307                 if (ip->flags & IODF_ZEROWS)
308                         x |= PCIC_IO_0WS;
309                 if (ip->flags & IODF_WS)
310                         x |= PCIC_IO_WS;
311                 if (ip->flags & IODF_CS16)
312                         x |= PCIC_IO_CS16;
313                 if (ip->flags & IODF_16BIT)
314                         x |= PCIC_IO_16BIT;
315                 /*
316                  * Extract the current flags and merge with new flags.
317                  * Flags for window 0 in lower nybble, and in upper nybble
318                  * for window 1.
319                  */
320                 ioctlv = sp->getb(sp, PCIC_IOCTL);
321                 DELAY(100);
322                 switch (win) {
323                 case 0:
324                         sp->putb(sp, PCIC_IOCTL, x | (ioctlv & 0xf0));
325                         break;
326                 case 1:
327                         sp->putb(sp, PCIC_IOCTL, (x << 4) | (ioctlv & 0xf));
328                         break;
329                 }
330                 DELAY(100);
331                 pcic_setb(sp, PCIC_ADDRWINE, mask);
332                 DELAY(100);
333         } else {
334                 pcic_clrb(sp, PCIC_ADDRWINE, mask);
335                 DELAY(100);
336                 pcic_putw(sp, reg, 0);
337                 pcic_putw(sp, reg + 2, 0);
338         }
339         return (0);
340 }
341
342 static void
343 pcic_do_mgt_irq(struct pcic_slot *sp, int irq)
344 {
345         u_int32_t       reg;
346
347         if (sp->sc->csc_route == pcic_iw_pci) {
348                 /* Do the PCI side of things: Enable the Card Change int */
349                 reg = CB_SM_CD;
350                 bus_space_write_4(sp->bst, sp->bsh, CB_SOCKET_MASK, reg);
351                 /*
352                  * TI Chips need us to set the following.  We tell the
353                  * controller to route things via PCI interrupts.  Also
354                  * we clear the interrupt number in the STAT_INT register
355                  * as well.  The TI-12xx and newer chips require one or the
356                  * other of these to happen, depending on what is set in the
357                  * diagnostic register.  I do both on the theory that other
358                  * chips might need one or the other and that no harm will
359                  * come from it.  If there is harm, then I'll make it a bit
360                  * in the tables.
361                  */
362                 pcic_setb(sp, PCIC_INT_GEN, PCIC_INTR_ENA);
363                 pcic_clrb(sp, PCIC_STAT_INT, PCIC_CSCSELECT);
364         } else {
365                 /* Management IRQ changes */
366                 /*
367                  * The PCIC_INTR_ENA bit means either "tie the function
368                  * and csc interrupts together" or "Route csc interrupts
369                  * via PCI" or "Reserved".  In any case, we want to clear
370                  * it since we're using ISA interrupts.
371                  */
372                 pcic_clrb(sp, PCIC_INT_GEN, PCIC_INTR_ENA);
373                 irq = host_irq_to_pcic(irq);
374                 sp->putb(sp, PCIC_STAT_INT, (irq << PCIC_SI_IRQ_SHIFT) | 
375                     PCIC_CDEN);
376         }
377 }
378
379 int
380 pcic_attach(device_t dev)
381 {
382         int             i;
383         device_t        kid;
384         struct pcic_softc *sc;
385         struct slot     *slt;
386         struct pcic_slot *sp;
387         
388         sc = (struct pcic_softc *) device_get_softc(dev);
389         callout_handle_init(&sc->timeout_ch);
390         sp = &sc->slots[0];
391         for (i = 0; i < PCIC_CARD_SLOTS; i++, sp++) {
392                 if (!sp->slt)
393                         continue;
394                 sp->slt = 0;
395                 kid = device_add_child(dev, NULL, -1);
396                 if (kid == NULL) {
397                         device_printf(dev, "Can't add pccard bus slot %d", i);
398                         return (ENXIO);
399                 }
400                 device_probe_and_attach(kid);
401                 slt = pccard_init_slot(kid, &pcic_cinfo);
402                 if (slt == 0) {
403                         device_printf(dev, "Can't get pccard info slot %d", i);
404                         return (ENXIO);
405                 }
406                 sc->slotmask |= (1 << i);
407                 slt->cdata = sp;
408                 sp->slt = slt;
409                 sp->sc = sc;
410         }
411
412         sp = &sc->slots[0];
413         for (i = 0; i < PCIC_CARD_SLOTS; i++, sp++) {
414                 if (sp->slt == NULL)
415                         continue;
416
417                 pcic_do_mgt_irq(sp, sc->irq);
418                 sp->slt->irq = sc->irq;
419
420                 /* Check for changes */
421                 sp->slt->laststate = sp->slt->state = empty;
422                 if (pcic_boot_deactivated) {
423                         sp->putb(sp, PCIC_POWER, 0);
424                         if ((sp->getb(sp, PCIC_STATUS) & PCIC_CD) == PCIC_CD) {
425                                 sp->slt->state = inactive;
426                                 pccard_event(sp->slt, card_deactivated);
427                         }
428                 } else {
429                         pcic_do_stat_delta(sp);
430                 }
431         }
432
433         return (bus_generic_attach(dev));
434 }
435
436
437 static int
438 pcic_sresource(struct slot *slt, caddr_t data)
439 {
440         struct pccard_resource *pr;
441         struct resource *r;
442         int flags;
443         int rid = 0;
444         device_t bridgedev = slt->dev;
445         struct pcic_slot *sp = slt->cdata;
446
447         pr = (struct pccard_resource *)data;
448         pr->resource_addr = ~0ul;
449
450         /*
451          * If we're using PCI interrupt routing, then force the IRQ to
452          * use and to heck with what the user requested.  If they want
453          * to be able to request IRQs, they must use ISA interrupt
454          * routing.  If we don't give them an irq, and it is the
455          * pccardd 0,0 case, then just return (giving the "bad resource"
456          * return in pr->resource_addr).
457          */
458         if (pr->type == SYS_RES_IRQ) {
459                 if (sp->sc->func_route >= pcic_iw_pci) {
460                         pr->resource_addr = sp->sc->irq;
461                         return (0);
462                 }
463                 if (pr->min == 0 && pr->max == 0)
464                         return (0);
465         }
466
467         /*
468          * Make sure we grok this type.
469          */
470         switch(pr->type) {
471         default:
472                 return (EINVAL);
473         case SYS_RES_MEMORY:
474         case SYS_RES_IRQ:
475         case SYS_RES_IOPORT:
476                 break;
477         }
478
479         /*
480          * Allocate the resource, and align it to the most natural
481          * size.  If we get it, then tell userland what we actually got
482          * in the range they requested.
483          */
484         flags = rman_make_alignment_flags(pr->size);
485         r = bus_alloc_resource(bridgedev, pr->type, &rid, pr->min, pr->max,
486            pr->size, flags);
487         if (r != NULL) {
488                 pr->resource_addr = (u_long)rman_get_start(r);
489                 bus_release_resource(bridgedev, pr->type, rid, r);
490         }
491         return (0);
492 }
493
494 /*
495  *      ioctl calls - Controller specific ioctls
496  */
497 static int
498 pcic_ioctl(struct slot *slt, int cmd, caddr_t data)
499 {
500         struct pcic_slot *sp = slt->cdata;
501         struct pcic_reg *preg = (struct pcic_reg *) data;
502
503         switch(cmd) {
504         default:
505                 return (ENOTTY);
506         case PIOCGREG:                  /* Get pcic register */
507                 preg->value = sp->getb(sp, preg->reg);
508                 break;                  /* Set pcic register */
509         case PIOCSREG:
510                 sp->putb(sp, preg->reg, preg->value);
511                 break;
512         case PIOCSRESOURCE:             /* Can I use this resource? */
513                 pcic_sresource(slt, data);
514                 break;
515         }
516         return (0);
517 }
518
519 /*
520  *      pcic_cardbus_power
521  *
522  *      Power the card up, as specified, using the cardbus power
523  *      registers to control power.  Microsoft recommends that cardbus
524  *      vendors support powering the card via cardbus registers because
525  *      there is no standard for 3.3V cards.  Since at least a few of the
526  *      cardbus bridges have minor issues with power via the ExCA registers,
527  *      go ahead and do it all via cardbus registers.
528  *
529  *      An expamination of the code will show the relative ease that we do
530  *      Vpp in comparison to the ExCA case (which may be partially broken).
531  */
532 static int
533 pcic_cardbus_power(struct pcic_slot *sp, struct slot *slt)
534 {
535         uint32_t power;
536         uint32_t state;
537
538         /*
539          * If we're doing an auto-detect, and we're in a badvcc state, then
540          * we need to force the socket to rescan the card.  We don't do this
541          * all the time because the socket can take up to 200ms to do the deed,
542          * and that's too long to busy wait.  Since this is a relatively rare
543          * event (some BIOSes, and earlier versions of OLDCARD caused it), we
544          * test for it special.
545          */
546         state =  bus_space_read_4(sp->bst, sp->bsh, CB_SOCKET_STATE);
547         if (slt->pwr.vcc == -1 && (state & CB_SS_BADVCC)) {
548                 /*
549                  * Force the bridge to scan the card for the proper voltages
550                  * that it supports.
551                  */
552                 bus_space_write_4(sp->bst, sp->bsh, CB_SOCKET_FORCE,
553                     CB_SF_INTCVS);
554                 state =  bus_space_read_4(sp->bst, sp->bsh, CB_SOCKET_STATE);
555                 /* This while loop can take 100-150ms */
556                 while ((state & CB_SS_CARD_MASK) == 0) {
557                         DELAY(10 * 1000);
558                         state =  bus_space_read_4(sp->bst, sp->bsh,
559                             CB_SOCKET_STATE);
560                 }
561         }
562  
563  
564         /*
565          * Preserve the clock stop bit of the socket power register.  Not
566          * sure that we want to do that, but maybe we should set it based
567          * on the power state.
568          */
569         power = bus_space_read_4(sp->bst, sp->bsh, CB_SOCKET_POWER);
570         power = 0;
571
572         /*
573          * vcc == -1 means automatically detect the voltage of the card.
574          * Do so and apply the right amount of power.
575          */
576         if (slt->pwr.vcc == -1) {
577                 if (state & CB_SS_5VCARD)
578                         slt->pwr.vcc = 50;
579                 else if (state & CB_SS_3VCARD)
580                         slt->pwr.vcc = 33;
581                 else if (state & CB_SS_XVCARD)
582                         slt->pwr.vcc = 22;
583                 else if (state & CB_SS_YVCARD)
584                         slt->pwr.vcc = 11;
585                 if (bootverbose && slt->pwr.vcc != -1)
586                         device_printf(sp->sc->dev,
587                             "Autodetected %d.%dV card\n",
588                             slt->pwr.vcc / 10, slt->pwr.vcc % 10);
589         }
590
591         switch(slt->pwr.vcc) {
592         default:
593                 return (EINVAL);
594         case 0:
595                 power |= CB_SP_VCC_0V;
596                 break;
597         case 11:
598                 power |= CB_SP_VCC_YV;
599                 break;
600         case 22:
601                 power |= CB_SP_VCC_XV;
602                 break;
603         case 33:
604                 power |= CB_SP_VCC_3V;
605                 break;
606         case 50:
607                 power |= CB_SP_VCC_5V;
608                 break;
609         }
610
611         /*
612          * vpp == -1 means use vcc voltage.
613          */
614         if (slt->pwr.vpp == -1)
615                 slt->pwr.vpp = slt->pwr.vcc;
616         switch(slt->pwr.vpp) {
617         default:
618                 return (EINVAL);
619         case 0:
620                 power |= CB_SP_VPP_0V;
621                 break;
622         case 11:
623                 power |= CB_SP_VPP_YV;
624                 break;
625         case 22:
626                 power |= CB_SP_VPP_XV;
627                 break;
628         case 33:
629                 power |= CB_SP_VPP_3V;
630                 break;
631         case 50:
632                 power |= CB_SP_VPP_5V;
633                 break;
634         case 120:
635                 power |= CB_SP_VPP_12V;
636                 break;
637         }
638         bus_space_write_4(sp->bst, sp->bsh, CB_SOCKET_POWER, power);
639
640         /*
641          * OK.  We need to bring the card out of reset.  Let the power
642          * stabilize for 300ms (why 300?) and then enable the outputs
643          * and then wait 100ms (why 100?) for it to stabilize.  These numbers
644          * were stolen from the dim, dark past of OLDCARD and I have no clue
645          * how they were derived.  I also use the bit setting routines here
646          * as a measure of conservatism.
647          */
648         if (power) {
649                 pcic_setb(sp, PCIC_POWER, PCIC_DISRST);
650                 DELAY(300*1000);
651                 pcic_setb(sp, PCIC_POWER, PCIC_DISRST | PCIC_OUTENA);
652                 DELAY(100*1000);
653         } else {
654                 pcic_clrb(sp, PCIC_POWER, PCIC_DISRST | PCIC_OUTENA);
655         }
656  
657         return (0);
658 }
659
660 /*
661  *      pcic_power - Enable the power of the slot according to
662  *      the parameters in the power structure(s).
663  */
664 static int
665 pcic_power(struct slot *slt)
666 {
667         unsigned char c, c2;
668         unsigned char reg = PCIC_DISRST | PCIC_PCPWRE;
669         struct pcic_slot *sp = slt->cdata;
670         struct pcic_slot *sp2;
671         struct pcic_softc *sc = sp->sc;
672         int dodefault = 0;
673         char controller;
674         
675         /*
676          * Cardbus power registers are completely different.
677          */
678         if (sc->flags & PCIC_CARDBUS_POWER)
679                 return (pcic_cardbus_power(sp, slt));
680
681         if (bootverbose)
682                 device_printf(sc->dev, "Power: Vcc=%d Vpp=%d\n", slt->pwr.vcc,
683                     slt->pwr.vpp);
684         /*
685          * If we're automatically detecting what voltage to use, then we need
686          * to ask the bridge what type (voltage-wise) the card is.
687          */
688         if (slt->pwr.vcc == -1) {
689                 if (sc->flags & PCIC_DF_POWER) {
690                         /* 
691                          * Look at the VS[12]# bits on the card.  If VS1 is
692                          * clear then the card needs 3.3V instead of 5.0V.
693                          */
694                         c = sp->getb(sp, PCIC_CDGC);
695                         if ((c & PCIC_VS1STAT) == 0)
696                                 slt->pwr.vcc = 33;
697                         else
698                                 slt->pwr.vcc = 50;
699                 }
700                 if (sc->flags & PCIC_PD_POWER) {
701                         /*
702                          * The 6710 does it one way, and the '22 and '29 do it
703                          * another.  The '22 can also do it the same way as a
704                          * '10 does it, despite what the datasheets say.  Some
705                          * laptops with '22 don't seem to have the signals
706                          * wired right for the '29 method to work.  The
707                          * laptops that don't work hang solid when the pccard
708                          * memory is accessed.
709                          *
710                          * To allow for both types of laptops,
711                          * hw.pcic.pd6722_vsense will select which one to use.
712                          * 0 - none, 1 - the '10 way and 2 - the '29 way.
713                          */
714                         controller = sp->controller;
715                         if (controller == PCIC_PD6722) {
716                                 switch (pcic_pd6722_vsense) {
717                                 case 1:
718                                         controller = PCIC_PD6710;
719                                         break;
720                                 case 2:
721                                         controller = PCIC_PD6729;
722                                         break;
723                                 }
724                         }
725
726                         switch (controller) {
727                         case PCIC_PD6710:
728                                 c = sp->getb(sp, PCIC_MISC1);
729                                 if ((c & PCIC_MISC1_5V_DETECT) == 0)
730                                         slt->pwr.vcc = 33;
731                                 else
732                                         slt->pwr.vcc = 50;
733                                 break;
734                         case PCIC_PD6722:       /* see above for why we do */
735                                 break;          /* none here */
736                         case PCIC_PD6729:
737                                 /*
738                                  * VS[12] signals are in slot1's
739                                  * extended reg 0xa for both slots.
740                                  */
741                                 sp2 = &sc->slots[1];
742                                 sp2->putb(sp2, PCIC_EXT_IND, PCIC_EXT_DATA);
743                                 c = sp2->getb(sp2, PCIC_EXTENDED);
744                                 if (sp == sp2)          /* slot 1 */
745                                         c >>= 2;
746                                 if ((c & PCIC_VS1A) == 0)
747                                         slt->pwr.vcc = 33;
748                                 else
749                                         slt->pwr.vcc = 50;
750                                 break;
751                         default:
752                                 /* I have no idea how to do this for others */
753                                 break;
754                         }
755
756                         /*
757                          * Regardless of the above, setting the Auto Power
758                          * Switch Enable appears to help.
759                          */
760                         reg |= PCIC_APSENA;
761                 }
762                 if (sc->flags & PCIC_RICOH_POWER) {
763                         /*
764                          * The ISA bridge have the 5V/3.3V in register
765                          * 1, bit 7.  However, 3.3V cards can only be
766                          * detected if GPI_EN is disabled.
767                          */
768                         c = sp->getb(sp, PCIC_STATUS);
769                         c2 = sp->getb(sp, PCIC_CDGC);
770                         if ((c & PCIC_RICOH_5VCARD) && (c2 & PCIC_GPI_EN) == 0)
771                                 slt->pwr.vcc = 33;
772                         else
773                                 slt->pwr.vcc = 50;
774                 }
775                 /* Other power schemes here */
776
777                 if (bootverbose && slt->pwr.vcc != -1)
778                         device_printf(sc->dev, "Autodetected %d.%dV card\n",
779                             slt->pwr.vcc / 10, slt->pwr.vcc %10);
780         }
781         if (slt->pwr.vcc == -1) {
782                 if (bootverbose)
783                         device_printf(sc->dev,
784                             "Couldn't autodetect voltage, assuming 5.0V\n");
785                 dodefault = 1;
786                 slt->pwr.vcc = 50;
787         }
788
789         /*
790          * XXX Note: The Vpp controls varies quit a bit between bridge chips
791          * and the following might not be right in all cases.  The Linux
792          * code and wildboar code bases are more complex.  However, most
793          * applications want vpp == vcc and the following code does appear
794          * to do that for all bridge sets.
795          */
796         if (slt->pwr.vpp == -1)
797                 slt->pwr.vpp = slt->pwr.vcc;
798         switch(slt->pwr.vpp) {
799         default:
800                 return (EINVAL);
801         case 0:
802                 break;
803         case 50:
804         case 33:
805                 reg |= PCIC_VPP_5V;
806                 break;
807         case 120:
808                 reg |= PCIC_VPP_12V;
809                 break;
810         }
811
812         if (slt->pwr.vcc)
813                 reg |= PCIC_VCC_ON;             /* Turn on Vcc */
814         switch(slt->pwr.vcc) {
815         default:
816                 return (EINVAL);
817         case 0:
818                 break;
819         case 33:
820                 /*
821                  * The wildboar code has comments that state that
822                  * the IBM KING controller doesn't support 3.3V
823                  * on the "IBM Smart PC card drive".  The code
824                  * intemates that's the only place they have seen
825                  * it used and that there's a boatload of issues
826                  * with it.  I'm not even sure this is right because
827                  * the only docs I've been able to find say this is for
828                  * 5V power.  Of course, this "doc" is just code comments
829                  * so who knows for sure.
830                  */
831                 if (sc->flags & PCIC_KING_POWER) {
832                         reg |= PCIC_VCC_5V_KING;
833                         break;
834                 }
835                 if (sc->flags & PCIC_VG_POWER) {
836                         pcic_setb(sp, PCIC_CVSR, PCIC_CVSR_VS);
837                         break;
838                 }
839                 if (sc->flags & PCIC_PD_POWER) {
840                         pcic_setb(sp, PCIC_MISC1, PCIC_MISC1_VCC_33);
841                         break;
842                 }
843                 if (sc->flags & PCIC_RICOH_POWER) {
844                         pcic_setb(sp, PCIC_RICOH_MCR2, PCIC_MCR2_VCC_33);
845                         break;
846                 }
847                 if (sc->flags & PCIC_DF_POWER)
848                         reg |= PCIC_VCC_3V;
849                 break;
850         case 50:
851                 if (sc->flags & PCIC_KING_POWER)
852                         reg |= PCIC_VCC_5V_KING;
853                 /*
854                  * For all of the variant power schemes for 3.3V go
855                  * ahead and turn off the 3.3V enable bit.  For all
856                  * bridges, the setting the Vcc on bit does the rest.
857                  * Note that we don't have to turn off the 3.3V bit
858                  * for the '365 step D since with the reg assigments
859                  * to this point it doesn't get turned on.
860                  */
861                 if (sc->flags & PCIC_VG_POWER)
862                         pcic_clrb(sp, PCIC_CVSR, PCIC_CVSR_VS);
863                 if (sc->flags & PCIC_PD_POWER)
864                         pcic_clrb(sp, PCIC_MISC1, PCIC_MISC1_VCC_33);
865                 if (sc->flags & PCIC_RICOH_POWER)
866                         pcic_clrb(sp, PCIC_RICOH_MCR2, PCIC_MCR2_VCC_33);
867                 break;
868         }
869         sp->putb(sp, PCIC_POWER, reg);
870         if (bootverbose)
871                 device_printf(sc->dev, "Power applied\n");
872         DELAY(300*1000);
873         if (slt->pwr.vcc) {
874                 reg |= PCIC_OUTENA;
875                 sp->putb(sp, PCIC_POWER, reg);
876                 if (bootverbose)
877                         device_printf(sc->dev, "Output enabled\n");
878                 DELAY(100*1000);
879                 if (bootverbose)
880                         device_printf(sc->dev, "Settling complete\n");
881         }
882
883         /*
884          * Some chipsets will attempt to preclude us from supplying
885          * 5.0V to cards that only handle 3.3V.  We seem to need to
886          * try 3.3V to paper over some power handling issues in other
887          * parts of the system.  Maybe the proper detection of 3.3V cards
888          * now obviates the need for this hack, so put a printf in to
889          * warn the world about it.
890          */
891         if (!(sp->getb(sp, PCIC_STATUS) & PCIC_POW) && dodefault) {
892                 slt->pwr.vcc = 33;
893                 slt->pwr.vpp = 0;
894                 device_printf(sc->dev,
895                     "Failed at 5.0V.  Trying 3.3V.  Please report message to mobile@freebsd.org\n");
896                 return (pcic_power(slt));
897         }
898         if (bootverbose)
899                 printf("Power complete.\n");
900         return (0);
901 }
902
903 /*
904  * tell the PCIC which irq we want to use.  only the following are legal:
905  * 3, 4, 5, 7, 9, 10, 11, 12, 14, 15.  We require the callers of this
906  * routine to do the check for legality.
907  */
908 static void
909 pcic_mapirq(struct slot *slt, int irq)
910 {
911         struct pcic_slot *sp = slt->cdata;
912
913         sp->sc->chip->map_irq(sp, irq);
914 }
915
916 /*
917  *      pcic_reset - Reset the card and enable initial power.  This may
918  *      need to be interrupt driven in the future.  We should likely turn
919  *      the reset on, DELAY for a period of time < 250ms, turn it off and
920  *      tsleep for a while and check it when we're woken up.  I think that
921  *      we're running afoul of the card status interrupt glitching, causing
922  *      an interrupt storm because the card doesn't seem to be able to
923  *      clear this pin while in reset.
924  */
925 static void
926 pcic_reset(void *chan)
927 {
928         struct slot *slt = chan;
929         struct pcic_slot *sp = slt->cdata;
930
931         if (bootverbose)
932                 device_printf(sp->sc->dev, "reset %d ", slt->insert_seq);
933         switch (slt->insert_seq) {
934         case 0: /* Something funny happended on the way to the pub... */
935                 if (bootverbose)
936                         printf("\n");
937                 return;
938         case 1: /* Assert reset */
939                 pcic_clrb(sp, PCIC_INT_GEN, PCIC_CARDRESET);
940                 if (bootverbose)
941                         printf("int is %x stat is %x\n",
942                             sp->getb(sp, PCIC_INT_GEN),
943                             sp->getb(sp, PCIC_STATUS));
944                 slt->insert_seq = 2;
945                 timeout(pcic_reset, (void *)slt, hz/4);
946                 return;
947         case 2: /* Deassert it again */
948                 pcic_setb(sp, PCIC_INT_GEN, PCIC_CARDRESET | PCIC_IOCARD);
949                 if (bootverbose)
950                         printf("int is %x stat is %x\n",
951                             sp->getb(sp, PCIC_INT_GEN),
952                             sp->getb(sp, PCIC_STATUS));
953                 slt->insert_seq = 3;
954                 timeout(pcic_reset, (void *)slt, hz/4);
955                 return;
956         case 3: /* Wait if card needs more time */
957                 if (bootverbose)
958                         printf("int is %x stat is %x\n",
959                             sp->getb(sp, PCIC_INT_GEN),
960                             sp->getb(sp, PCIC_STATUS));
961                 if ((sp->getb(sp, PCIC_STATUS) & PCIC_READY) == 0) {
962                         timeout(pcic_reset, (void *)slt, hz/10);
963                         return;
964                 }
965         }
966         slt->insert_seq = 0;
967         if (sp->controller == PCIC_PD6722 || sp->controller == PCIC_PD6710) {
968                 sp->putb(sp, PCIC_TIME_SETUP0, 0x1);
969                 sp->putb(sp, PCIC_TIME_CMD0, 0x6);
970                 sp->putb(sp, PCIC_TIME_RECOV0, 0x0);
971                 sp->putb(sp, PCIC_TIME_SETUP1, 1);
972                 sp->putb(sp, PCIC_TIME_CMD1, 0xf);
973                 sp->putb(sp, PCIC_TIME_RECOV1, 0);
974         }
975         selwakeup(&slt->selp);
976 }
977
978 /*
979  *      pcic_disable - Disable the slot.  I wonder if these operations can
980  *      cause an interrupt we need to acknowledge? XXX
981  */
982 static void
983 pcic_disable(struct slot *slt)
984 {
985         struct pcic_slot *sp = slt->cdata;
986
987         pcic_clrb(sp, PCIC_INT_GEN, PCIC_CARDTYPE | PCIC_CARDRESET);
988         pcic_mapirq(slt, 0);
989         slt->pwr.vcc = slt->pwr.vpp = 0;
990         pcic_power(slt);
991 }
992
993 /*
994  *      pcic_resume - Suspend/resume support for PCIC
995  */
996 static void
997 pcic_resume(struct slot *slt)
998 {
999         struct pcic_slot *sp = slt->cdata;
1000
1001         pcic_do_mgt_irq(sp, slt->irq);
1002         if (sp->controller == PCIC_PD6722) {
1003                 pcic_setb(sp, PCIC_MISC1, PCIC_MISC1_SPEAKER);
1004                 pcic_setb(sp, PCIC_MISC2, PCIC_LPDM_EN);
1005         }
1006         if (sp->slt->state != inactive)
1007                 pcic_do_stat_delta(sp);
1008 }
1009
1010 int
1011 pcic_activate_resource(device_t dev, device_t child, int type, int rid,
1012     struct resource *r)
1013 {
1014         struct pccard_devinfo *devi = device_get_ivars(child);
1015         int err;
1016
1017         if (dev != device_get_parent(device_get_parent(child)) || devi == NULL)
1018                 return (bus_generic_activate_resource(dev, child, type,
1019                     rid, r));
1020
1021         switch (type) {
1022         case SYS_RES_IOPORT: {
1023                 struct io_desc *ip;
1024                 ip = &devi->slt->io[rid];
1025                 if (ip->flags == 0) {
1026                         if (rid == 0)
1027                                 ip->flags = IODF_WS | IODF_16BIT | IODF_CS16;
1028                         else
1029                                 ip->flags = devi->slt->io[0].flags;
1030                 }
1031                 ip->flags |= IODF_ACTIVE;
1032                 ip->start = rman_get_start(r);
1033                 ip->size = rman_get_end(r) - rman_get_start(r) + 1;
1034                 err = pcic_io(devi->slt, rid);
1035                 if (err)
1036                         return (err);
1037                 break;
1038         }
1039         case SYS_RES_IRQ:
1040                 /*
1041                  * We actually defer the activation of the IRQ resource
1042                  * until the interrupt is registered to avoid stray
1043                  * interrupt messages.
1044                  */
1045                 break;
1046         case SYS_RES_MEMORY: {
1047                 struct mem_desc *mp;
1048                 if (rid >= NUM_MEM_WINDOWS)
1049                         return (EINVAL);
1050                 mp = &devi->slt->mem[rid];
1051                 mp->flags |= MDF_ACTIVE;
1052                 mp->start = (caddr_t) rman_get_start(r);
1053                 mp->size = rman_get_end(r) - rman_get_start(r) + 1;
1054                 err = pcic_memory(devi->slt, rid);
1055                 if (err)
1056                         return (err);
1057                 break;
1058         }
1059         default:
1060                 break;
1061         }
1062         err = bus_generic_activate_resource(dev, child, type, rid, r);
1063         return (err);
1064 }
1065
1066 int
1067 pcic_deactivate_resource(device_t dev, device_t child, int type, int rid,
1068     struct resource *r)
1069 {
1070         struct pccard_devinfo *devi = device_get_ivars(child);
1071         int err;
1072
1073         if (dev != device_get_parent(device_get_parent(child)) || devi == NULL)
1074                 return (bus_generic_deactivate_resource(dev, child, type,
1075                     rid, r));
1076
1077         switch (type) {
1078         case SYS_RES_IOPORT: {
1079                 struct io_desc *ip = &devi->slt->io[rid];
1080                 ip->flags &= ~IODF_ACTIVE;
1081                 err = pcic_io(devi->slt, rid);
1082                 if (err)
1083                         return (err);
1084                 break;
1085         }
1086         case SYS_RES_IRQ:
1087                 break;
1088         case SYS_RES_MEMORY: {
1089                 struct mem_desc *mp = &devi->slt->mem[rid];
1090                 mp->flags &= ~(MDF_ACTIVE | MDF_ATTR);
1091                 err = pcic_memory(devi->slt, rid);
1092                 if (err)
1093                         return (err);
1094                 break;
1095         }
1096         default:
1097                 break;
1098         }
1099         err = bus_generic_deactivate_resource(dev, child, type, rid, r);
1100         return (err);
1101 }
1102
1103 int
1104 pcic_setup_intr(device_t dev, device_t child, struct resource *irq,
1105     int flags, driver_intr_t *intr, void *arg, void **cookiep)
1106 {
1107         struct pccard_devinfo *devi = device_get_ivars(child);
1108         int err;
1109
1110         if (((1 << rman_get_start(irq)) & PCIC_INT_MASK_ALLOWED) == 0) {
1111                 device_printf(dev, "Hardware does not support irq %ld.\n",
1112                     rman_get_start(irq));
1113                 return (EINVAL);
1114         }
1115
1116         err = bus_generic_setup_intr(dev, child, irq, flags, intr, arg,
1117             cookiep);
1118         if (err == 0)
1119                 pcic_mapirq(devi->slt, rman_get_start(irq));
1120         else
1121                 device_printf(dev, "Error %d irq %ld\n", err,
1122                     rman_get_start(irq));
1123         return (err);
1124 }
1125
1126 int
1127 pcic_teardown_intr(device_t dev, device_t child, struct resource *irq,
1128     void *cookie)
1129 {
1130         struct pccard_devinfo *devi = device_get_ivars(child);
1131
1132         pcic_mapirq(devi->slt, 0);
1133         return (bus_generic_teardown_intr(dev, child, irq, cookie));
1134 }
1135
1136 int
1137 pcic_set_res_flags(device_t bus, device_t child, int restype, int rid,
1138     u_long value)
1139 {
1140         struct pccard_devinfo *devi = device_get_ivars(child);
1141         int err = 0;
1142
1143         switch (restype) {
1144         case SYS_RES_MEMORY: {
1145                 struct mem_desc *mp = &devi->slt->mem[rid];
1146                 switch (value) {
1147                 case PCCARD_A_MEM_COM:
1148                         mp->flags &= ~MDF_ATTR;
1149                         break;
1150                 case PCCARD_A_MEM_ATTR:
1151                         mp->flags |= MDF_ATTR;
1152                         break;
1153                 case PCCARD_A_MEM_8BIT:
1154                         mp->flags &= ~MDF_16BITS;
1155                         break;
1156                 case PCCARD_A_MEM_16BIT:
1157                         mp->flags |= MDF_16BITS;
1158                         break;
1159                 }
1160                 err = pcic_memory(devi->slt, rid);
1161                 break;
1162         }
1163         default:
1164                 err = EOPNOTSUPP;
1165         }
1166         return (err);
1167 }
1168
1169 int
1170 pcic_get_res_flags(device_t bus, device_t child, int restype, int rid,
1171     u_long *value)
1172 {
1173         struct pccard_devinfo *devi = device_get_ivars(child);
1174         int err = 0;
1175
1176         if (value == 0)
1177                 return (ENOMEM);
1178
1179         switch (restype) {
1180         case SYS_RES_IOPORT: {
1181                 struct io_desc *ip = &devi->slt->io[rid];
1182                 *value = ip->flags;
1183                 break;
1184         }
1185         case SYS_RES_MEMORY: {
1186                 struct mem_desc *mp = &devi->slt->mem[rid];
1187                 *value = mp->flags;
1188                 break;
1189         }
1190         default:
1191                 err = EOPNOTSUPP;
1192         }
1193         return (err);
1194 }
1195
1196 int
1197 pcic_set_memory_offset(device_t bus, device_t child, int rid,
1198     u_int32_t offset, u_int32_t *deltap)
1199 {
1200         struct pccard_devinfo *devi = device_get_ivars(child);
1201         struct mem_desc *mp = &devi->slt->mem[rid];
1202
1203         mp->card = offset;
1204         if (deltap)
1205                 *deltap = 0;                    /* XXX BAD XXX */
1206         return (pcic_memory(devi->slt, rid));
1207 }
1208
1209 int
1210 pcic_get_memory_offset(device_t bus, device_t child, int rid, u_int32_t *offset)
1211 {
1212         struct pccard_devinfo *devi = device_get_ivars(child);
1213         struct mem_desc *mp = &devi->slt->mem[rid];
1214
1215         if (offset == 0)
1216                 return (ENOMEM);
1217
1218         *offset = mp->card;
1219
1220         return (0);
1221 }
1222
1223 struct resource *
1224 pcic_alloc_resource(device_t dev, device_t child, int type, int *rid,
1225     u_long start, u_long end, u_long count, u_int flags)
1226 {
1227         struct pcic_softc *sc = device_get_softc(dev);
1228
1229         /*
1230          * If we're routing via pci, we can share.
1231          */
1232         if (sc->func_route == pcic_iw_pci && type == SYS_RES_IRQ) {
1233                 if (bootverbose)
1234                         device_printf(child, "Forcing IRQ to %d\n", sc->irq);
1235                 start = end = sc->irq;
1236                 flags |= RF_SHAREABLE;
1237         }
1238
1239         return (bus_generic_alloc_resource(dev, child, type, rid, start, end,
1240             count, flags));
1241 }
1242
1243 void
1244 pcic_do_stat_delta(struct pcic_slot *sp)
1245 {
1246         if ((sp->getb(sp, PCIC_STATUS) & PCIC_CD) != PCIC_CD)
1247                 pccard_event(sp->slt, card_removed);
1248         else
1249                 pccard_event(sp->slt, card_inserted);
1250 }
1251 /*
1252  * Wrapper function for pcicintr so that signatures match.
1253  */
1254 void
1255 pcic_isa_intr(void *arg)
1256 {
1257         pcic_isa_intr1(arg);
1258 }
1259
1260 /*
1261  *      PCIC timer.  If the controller doesn't have a free IRQ to use
1262  *      or if interrupt steering doesn't work, poll the controller for
1263  *      insertion/removal events.
1264  */
1265 void
1266 pcic_timeout(void *chan)
1267 {
1268         struct pcic_softc *sc = (struct pcic_softc *) chan;
1269
1270         if (pcic_isa_intr1(chan) != 0) {
1271                 device_printf(sc->dev, 
1272                     "Static bug detected, ignoring hardware.");
1273                 sc->slot_poll = 0;
1274                 return;
1275         }
1276         sc->timeout_ch = timeout(sc->slot_poll, chan, hz/2);
1277 }
1278
1279 /*
1280  *      PCIC Interrupt handler.
1281  *      Check each slot in turn, and read the card status change
1282  *      register. If this is non-zero, then a change has occurred
1283  *      on this card, so send an event to the main code.
1284  */
1285 int
1286 pcic_isa_intr1(void *arg)
1287 {
1288         int     slot, s;
1289         u_int8_t chg;
1290         struct pcic_softc *sc = (struct pcic_softc *) arg;
1291         struct pcic_slot *sp = &sc->slots[0];
1292
1293         s = splhigh();
1294         for (slot = 0; slot < PCIC_CARD_SLOTS; slot++, sp++) {
1295                 if (sp->slt == NULL)
1296                         continue;
1297                 if ((chg = sp->getb(sp, PCIC_STAT_CHG)) != 0) {
1298                         /*
1299                          * if chg is 0xff, then we know that we've hit
1300                          * the famous "static bug" for some desktop
1301                          * pcmcia cards.  This is caused by static
1302                          * discharge frying the poor card's mind and
1303                          * it starts return 0xff forever.  We return
1304                          * an error and stop polling the card.  When
1305                          * we're interrupt based, we never see this.
1306                          * The card just goes away silently.
1307                          */
1308                         if (chg == 0xff) {
1309                                 splx(s);
1310                                 return (EIO);
1311                         }
1312                         if (chg & PCIC_CDTCH)
1313                                 pcic_do_stat_delta(sp);
1314                 }
1315         }
1316         splx(s);
1317         return (0);
1318 }
1319
1320 int
1321 pcic_isa_mapirq(struct pcic_slot *sp, int irq)
1322 {
1323         irq = host_irq_to_pcic(irq);
1324         if (irq == 0)
1325                 pcic_clrb(sp, PCIC_INT_GEN, 0xF);
1326         else
1327                 sp->putb(sp, PCIC_INT_GEN,
1328                     (sp->getb(sp, PCIC_INT_GEN) & 0xF0) | irq);
1329         return (0);
1330 }