root/dev/pcmcia/pcmcia.c

DEFINITIONS

1. pcmcia_ccr_read
2. pcmcia_ccr_write
3. pcmcia_match
4. pcmcia_attach
5. pcmcia_power
6. pcmcia_card_attach
7. pcmcia_card_detach
8. pcmcia_card_deactivate
9. pcmcia_submatch
10. pcmcia_print
11. pcmcia_card_gettype
12. pcmcia_function_init
13. pcmcia_socket_enable
14. pcmcia_socket_disable
15. pcmcia_function_enable
16. pcmcia_function_disable
17. pcmcia_io_map
18. pcmcia_intr_establish
19. pcmcia_intr_disestablish
20. pcmcia_intr_string
21. pcmcia_card_intr

    1 /*      $OpenBSD: pcmcia.c,v 1.37 2006/04/16 20:43:12 miod Exp $        */
    2 /*      $NetBSD: pcmcia.c,v 1.9 1998/08/13 02:10:55 eeh Exp $   */
    4 /*
    5  * Copyright (c) 1997 Marc Horowitz.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Marc Horowitz.
   18  * 4. The name of the author may not be used to endorse or promote products
   19  *    derived from this software without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   33 #include <sys/types.h>
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/device.h>
   37 #include <sys/malloc.h>
   39 #include <dev/pcmcia/pcmciareg.h>
   40 #include <dev/pcmcia/pcmciachip.h>
   41 #include <dev/pcmcia/pcmciavar.h>
   43 #ifdef PCMCIADEBUG
   44 #define DPRINTF(arg) printf arg
   45 #else
   46 #define DPRINTF(arg)
   47 #endif
   49 #ifdef PCMCIAVERBOSE
   50 int     pcmcia_verbose = 1;
   51 #else
   52 int     pcmcia_verbose = 0;
   53 #endif
   55 int     pcmcia_match(struct device *, void *, void *);
   56 int     pcmcia_submatch(struct device *, void *, void *);
   57 void    pcmcia_attach(struct device *, struct device *, void *);
   58 int     pcmcia_print(void *, const char *);
   59 void    pcmcia_card_detach_notify(struct device *, void *);
   60 void    pcmcia_power(int why, void *arg);
   62 static inline void pcmcia_socket_enable(pcmcia_chipset_tag_t,
pcmcia_chipset_handle_t *);
   64 static inline void pcmcia_socket_disable(pcmcia_chipset_tag_t,
pcmcia_chipset_handle_t *);
   67 int pcmcia_card_intr(void *);
   69 struct cfdriver pcmcia_cd = {
NULL, "pcmcia", DV_DULL
   71 };
   73 struct cfattach pcmcia_ca = {
   74         sizeof(struct pcmcia_softc), pcmcia_match, pcmcia_attach
   75 };
   77 int
pcmcia_ccr_read(pf, ccr)
   79         struct pcmcia_function *pf;
   80         int ccr;
   81 {
   83         return (bus_space_read_1(pf->pf_ccrt, pf->pf_ccrh,
pf->pf_ccr_offset + ccr));
   85 }
   87 void
pcmcia_ccr_write(pf, ccr, val)
   89         struct pcmcia_function *pf;
   90         int ccr;
   91         int val;
   92 {
   94         if ((pf->ccr_mask) & (1 << (ccr / 2))) {
bus_space_write_1(pf->pf_ccrt, pf->pf_ccrh,
pf->pf_ccr_offset + ccr, val);
   97         }
   98 }
  100 int
pcmcia_match(parent, match, aux)
  102         struct device *parent;
  103         void *match, *aux;
  104 {
  105         struct cfdata *cf = match;
  106         struct pcmciabus_attach_args *paa = aux;
  108         if (strcmp(paa->paa_busname, cf->cf_driver->cd_name))
  109                 return 0;
  111         /* If the autoconfiguration got this far, there's a socket here. */
  112         return (1);
  113 }
  115 void
pcmcia_attach(parent, self, aux)
  117         struct device *parent, *self;
  118         void *aux;
  119 {
  120         struct pcmciabus_attach_args *paa = aux;
  121         struct pcmcia_softc *sc = (struct pcmcia_softc *) self;
printf("\n");
sc->pct = paa->pct;
sc->pch = paa->pch;
sc->iobase = paa->iobase;
sc->iosize = paa->iosize;
sc->ih = NULL;
powerhook_establish(pcmcia_power, sc);
  132 }
  134 void
pcmcia_power(why, arg)
  136         int why;
  137         void *arg;
  138 {
  139         struct pcmcia_softc *sc = (struct pcmcia_softc *) arg;
  140         struct pcmcia_function *pf;
  141         struct device *d;
  142         int act = DVACT_ACTIVATE;
  144         if (why != PWR_RESUME)
act = DVACT_DEACTIVATE;
  147         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
  149                 if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
  150                         continue;
d = pf->child;
  152                 if (d == NULL)
  153                         continue;
  154                 if (act == DVACT_ACTIVATE)
config_activate(pf->child);
  156                 else
config_deactivate(pf->child);
  158         }
  159 }
  161 int
pcmcia_card_attach(dev)
  163         struct device *dev;
  164 {
  165         struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
  166         struct pcmcia_function *pf;
  167         struct pcmcia_attach_args paa;
  168         int attached;
  170         /*
  171          * this is here so that when socket_enable calls gettype, trt happens
  172          */
SIMPLEQ_FIRST(&sc->card.pf_head) = NULL;
pcmcia_chip_socket_enable(sc->pct, sc->pch);
pcmcia_read_cis(sc);
pcmcia_chip_socket_disable(sc->pct, sc->pch);
pcmcia_check_cis_quirks(sc);
  183         /*
  184          * Bail now if there was an error in the CIS.
  185          */
  187         if (sc->card.error)
  188                 return (1);
  190 #if 0
  191         if (SIMPLEQ_EMPTY(&sc->card.pf_head))
  192                 return (1);
  193 #endif
  195         if (pcmcia_verbose)
pcmcia_print_cis(sc);
  198         /*
  199          * If there was no function, this might be CIS-less card we still
  200          * want to probe.  Fixup a function element for it.
  201          */
  202         if (SIMPLEQ_FIRST(&sc->card.pf_head) == NULL) {
pf = malloc(sizeof *pf, M_DEVBUF, M_NOWAIT);
  204                 if (pf == NULL)
panic("pcmcia_card_attach");
bzero(pf, sizeof *pf);
pf->number = 0;
pf->pf_flags = PFF_FAKE;
pf->last_config_index = -1;
SIMPLEQ_INIT(&pf->cfe_head);
SIMPLEQ_INSERT_TAIL(&sc->card.pf_head, pf, pf_list);
  212         }
attached = 0;
  216         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
pf->sc = sc;
pf->child = NULL;
pf->cfe = NULL;
pf->ih_fct = NULL;
pf->ih_arg = NULL;
  223         }
  225         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
paa.manufacturer = sc->card.manufacturer;
paa.product = sc->card.product;
paa.card = &sc->card;
paa.pf = pf;
pf->child = config_found_sm(&sc->dev, &paa, pcmcia_print,
pcmcia_submatch);
  234                 if (pf->child) {
attached++;
  237                         if ((pf->pf_flags & PFF_FAKE) == 0)
DPRINTF(("%s: function %d CCR at %d offset %lx"
  239                                         ": %x %x %x %x, %x %x %x %x, %x\n",
sc->dev.dv_xname, pf->number,
pf->pf_ccr_window, pf->pf_ccr_offset,
pcmcia_ccr_read(pf, 0x00),
pcmcia_ccr_read(pf, 0x02),
pcmcia_ccr_read(pf, 0x04),
pcmcia_ccr_read(pf, 0x06),
pcmcia_ccr_read(pf, 0x0A),
pcmcia_ccr_read(pf, 0x0C),
pcmcia_ccr_read(pf, 0x0E),
pcmcia_ccr_read(pf, 0x10),
pcmcia_ccr_read(pf, 0x12)));
  251                 }
  252         }
  253         return (attached ? 0 : 1);
  254 }
  256 void
pcmcia_card_detach(dev, flags)
  258         struct device *dev;
  259         int flags;              /* DETACH_* flags */
  260 {
  261         struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
  262         struct pcmcia_function *pf;
  263         int error;
  265         /*
  266          * We are running on either the PCMCIA socket's event thread
  267          * or in user context detaching a device by user request.
  268          */
  269         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
  271                 if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
  272                         continue;
  273                 if (pf->child == NULL)
  274                         continue;
DPRINTF(("%s: detaching %s (function %d)\n",
sc->dev.dv_xname, pf->child->dv_xname, pf->number));
  277                 if ((error = config_detach(pf->child, flags)) != 0) {
printf("%s: error %d detaching %s (function %d)\n",
sc->dev.dv_xname, error, pf->child->dv_xname,
pf->number);
  281                 } else
pf->child = NULL;
  283         }
  284 }
  286 void
pcmcia_card_deactivate(dev)
  288         struct device *dev;
  289 {
  290         struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
  291         struct pcmcia_function *pf;
  293         /*
  294          * We're in the chip's card removal interrupt handler.
  295          * Deactivate the child driver.  The PCMCIA socket's
  296          * event thread will run later to finish the detach.
  297          */
  298         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
  300                 if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
  301                         continue;
  302                 if (pf->child == NULL)
  303                         continue;
DPRINTF(("%s: deactivating %s (function %d)\n",
sc->dev.dv_xname, pf->child->dv_xname, pf->number));
config_deactivate(pf->child);
  307         }
  308 }
  310 int
pcmcia_submatch(parent, match, aux)
  312         struct device *parent;
  313         void *match, *aux;
  314 {
  315         struct cfdata *cf = match;
  316         struct pcmcia_attach_args *paa = aux;
  318         if (cf->cf_loc[0 /* PCMCIACF_FUNCTION */] !=
  319             -1 /* PCMCIACF_FUNCTION_DEFAULT */ &&
cf->cf_loc[0 /* PCMCIACF_FUNCTION */] != paa->pf->number)
  321                 return (0);
  323         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  324 }
  326 int
pcmcia_print(arg, pnp)
  328         void *arg;
  329         const char *pnp;
  330 {
  331         struct pcmcia_attach_args *pa = arg;
  332         struct pcmcia_softc *sc = pa->pf->sc;
  333         struct pcmcia_card *card = &sc->card;
  334         int i;
  336         if (pnp) {
  337                 for (i = 0; i < 4 && card->cis1_info[i]; i++)
printf("%s%s", i ? ", " : "\"", card->cis1_info[i]);
  339                 if (i != 0)
printf("\"");
  342                 if (card->manufacturer != PCMCIA_VENDOR_INVALID &&
card->product != PCMCIA_PRODUCT_INVALID) {
  344                         if (i != 0)
printf(" ");
printf("(");
  347                         if (card->manufacturer != PCMCIA_VENDOR_INVALID)
printf("manufacturer 0x%x%s",
card->manufacturer,
card->product == PCMCIA_PRODUCT_INVALID ?
  351                                     "" : ", ");
  352                         if (card->product != PCMCIA_PRODUCT_INVALID)
printf("product 0x%x",
card->product);
printf(")");
  356                 }
  357                 if (i != 0)
printf(" ");
printf("at %s", pnp);
  360         }
printf(" function %d", pa->pf->number);
  363         if (!pnp) {
  364                 for (i = 0; i < 3 && card->cis1_info[i]; i++)
printf("%s%s", i ? ", " : " \"", card->cis1_info[i]);
  366                 if (i != 0)
printf("\"");
  368         }
  370         return (UNCONF);
  371 }
  373 int
pcmcia_card_gettype(dev)
  375         struct device  *dev;
  376 {
  377         struct pcmcia_softc *sc = (struct pcmcia_softc *)dev;
  378         struct pcmcia_function *pf;
  380         /*
  381          * Set the iftype to memory if this card has no functions (not yet
  382          * probed), or only one function, and that is not initialized yet or
  383          * that is memory.
  384          */
pf = SIMPLEQ_FIRST(&sc->card.pf_head);
  386         if (pf == NULL || (SIMPLEQ_NEXT(pf, pf_list) == NULL &&
  387             ((pf->pf_flags & PFF_FAKE) ||
pf->cfe == NULL || pf->cfe->iftype == PCMCIA_IFTYPE_MEMORY)))
  389                 return (PCMCIA_IFTYPE_MEMORY);
  390         else
  391                 return (PCMCIA_IFTYPE_IO);
  392 }
  394 /*
  395  * Initialize a PCMCIA function.  May be called as long as the function is
  396  * disabled.
  397  */
  398 void
pcmcia_function_init(pf, cfe)
  400         struct pcmcia_function *pf;
  401         struct pcmcia_config_entry *cfe;
  402 {
  403         if (pf->pf_flags & PFF_ENABLED)
panic("pcmcia_function_init: function is enabled");
  406         /* Remember which configuration entry we are using. */
pf->cfe = cfe;
  408 }
  410 static inline void pcmcia_socket_enable(pct, pch)
pcmcia_chipset_tag_t pct;
pcmcia_chipset_handle_t *pch;
  413 {
pcmcia_chip_socket_enable(pct, pch);
  415 }
  417 static inline void pcmcia_socket_disable(pct, pch)
pcmcia_chipset_tag_t pct;
pcmcia_chipset_handle_t *pch;
  420 {
pcmcia_chip_socket_disable(pct, pch);
  422 }
  424 /* Enable a PCMCIA function */
  425 int
pcmcia_function_enable(pf)
  427         struct pcmcia_function *pf;
  428 {
  429         struct pcmcia_function *tmp;
  430         int reg;
  432         if (pf->cfe == NULL)
panic("pcmcia_function_enable: function not initialized");
  435         /*
  436          * Increase the reference count on the socket, enabling power, if
  437          * necessary.
  438          */
  439         if (pf->sc->sc_enabled_count++ == 0)
pcmcia_chip_socket_enable(pf->sc->pct, pf->sc->pch);
DPRINTF(("%s: ++enabled_count = %d\n", pf->sc->dev.dv_xname,
pf->sc->sc_enabled_count));
  444         if (pf->pf_flags & PFF_ENABLED) {
  445                 /*
  446                  * Don't do anything if we're already enabled.
  447                  */
DPRINTF(("%s: pcmcia_function_enable on enabled func\n"));
  449                 return (0);
  450         }
  452         /* If there was no CIS don't mess with CCR */
  453         if (pf->pf_flags & PFF_FAKE)
  454                 goto done;
  456         /*
  457          * It's possible for different functions' CCRs to be in the same
  458          * underlying page.  Check for that.
  459          */
SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
  461                 if ((tmp->pf_flags & PFF_ENABLED) &&
  462                     (pf->ccr_base >= (tmp->ccr_base - tmp->pf_ccr_offset)) &&
  463                     ((pf->ccr_base + PCMCIA_CCR_SIZE) <=
  464                      (tmp->ccr_base - tmp->pf_ccr_offset +
tmp->pf_ccr_realsize))) {
pf->pf_ccrt = tmp->pf_ccrt;
pf->pf_ccrh = tmp->pf_ccrh;
pf->pf_ccr_realsize = tmp->pf_ccr_realsize;
  470                         /*
  471                          * pf->pf_ccr_offset = (tmp->pf_ccr_offset -
  472                          * tmp->ccr_base) + pf->ccr_base;
  473                          */
pf->pf_ccr_offset =
  475                             (tmp->pf_ccr_offset + pf->ccr_base) -
tmp->ccr_base;
pf->pf_ccr_window = tmp->pf_ccr_window;
  478                         break;
  479                 }
  480         }
  482         if (tmp == NULL) {
  483                 if (pcmcia_mem_alloc(pf, PCMCIA_CCR_SIZE, &pf->pf_pcmh))
  484                         goto bad;
  486                 if (pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, pf->ccr_base,
PCMCIA_CCR_SIZE, &pf->pf_pcmh, &pf->pf_ccr_offset,
  488                     &pf->pf_ccr_window)) {
pcmcia_mem_free(pf, &pf->pf_pcmh);
  490                         goto bad;
  491                 }
  492         }
reg = (pf->cfe->number & PCMCIA_CCR_OPTION_CFINDEX);
reg |= PCMCIA_CCR_OPTION_LEVIREQ;
  496         if (pcmcia_mfc(pf->sc)) {
reg |= PCMCIA_CCR_OPTION_FUNC_ENABLE;
  498                 if (pf->ccr_mask & (1 << (PCMCIA_CCR_IOBASE0 / 2)))
reg |= PCMCIA_CCR_OPTION_ADDR_DECODE;
  500                 if (pf->ih_fct)
reg |= PCMCIA_CCR_OPTION_IREQ_ENABLE;
  503         }
pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
reg = 0;
  509         if ((pf->cfe->flags & PCMCIA_CFE_IO16) == 0)
reg |= PCMCIA_CCR_STATUS_IOIS8;
  511         if (pf->cfe->flags & PCMCIA_CFE_AUDIO)
reg |= PCMCIA_CCR_STATUS_AUDIO;
pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS, reg);
pcmcia_ccr_write(pf, PCMCIA_CCR_SOCKETCOPY, 0);
  517         if (pcmcia_mfc(pf->sc)) {
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE0,
  519                                  (pf->pf_mfc_iobase >>  0) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE1,
  521                                  (pf->pf_mfc_iobase >>  8) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE2,
  523                                  (pf->pf_mfc_iobase >> 16) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE3,
  525                                  (pf->pf_mfc_iobase >> 24) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOSIZE,
pf->pf_mfc_iomax - pf->pf_mfc_iobase);
  528         }
  530 #ifdef PCMCIADEBUG
SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
printf("%s: function %d CCR at %d offset %lx: "
  533                        "%x %x %x %x, %x %x %x %x, %x\n",
tmp->sc->dev.dv_xname, tmp->number,
tmp->pf_ccr_window, tmp->pf_ccr_offset,
pcmcia_ccr_read(tmp, 0x00),
pcmcia_ccr_read(tmp, 0x02),
pcmcia_ccr_read(tmp, 0x04),
pcmcia_ccr_read(tmp, 0x06),
pcmcia_ccr_read(tmp, 0x0A),
pcmcia_ccr_read(tmp, 0x0C),
pcmcia_ccr_read(tmp, 0x0E),
pcmcia_ccr_read(tmp, 0x10),
pcmcia_ccr_read(tmp, 0x12));
  547         }
  548 #endif
done:
pf->pf_flags |= PFF_ENABLED;
delay(1000);
  553         return (0);
bad:
  556         /*
  557          * Decrement the reference count, and power down the socket, if
  558          * necessary.
  559          */
  560         if (--pf->sc->sc_enabled_count == 0)
pcmcia_chip_socket_disable(pf->sc->pct, pf->sc->pch);
DPRINTF(("%s: --enabled_count = %d\n", pf->sc->dev.dv_xname,
pf->sc->sc_enabled_count));
  565         return (1);
  566 }
  568 /* Disable PCMCIA function. */
  569 void
pcmcia_function_disable(pf)
  571         struct pcmcia_function *pf;
  572 {
  573         struct pcmcia_function *tmp;
  575         if (pf->cfe == NULL)
panic("pcmcia_function_enable: function not initialized");
  578         if ((pf->pf_flags & PFF_ENABLED) == 0) {
  579                 /*
  580                  * Don't do anything if we're already disabled.
  581                  */
  582                 return;
  583         }
  585         /* If there was no CIS don't mess with CCR */
  586         if (pf->pf_flags & PFF_FAKE) {
pf->pf_flags &= ~PFF_ENABLED;
  588                 goto done;
  589         }
  591         /*
  592          * it's possible for different functions' CCRs to be in the same
  593          * underlying page.  Check for that.  Note we mark us as disabled
  594          * first to avoid matching ourself.
  595          */
pf->pf_flags &= ~PFF_ENABLED;
SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
  598                 if ((tmp->pf_flags & PFF_ENABLED) &&
  599                     (pf->ccr_base >= (tmp->ccr_base - tmp->pf_ccr_offset)) &&
  600                     ((pf->ccr_base + PCMCIA_CCR_SIZE) <=
  601                 (tmp->ccr_base - tmp->pf_ccr_offset + tmp->pf_ccr_realsize)))
  602                         break;
  603         }
  605         /* Not used by anyone else; unmap the CCR. */
  606         if (tmp == NULL) {
pcmcia_mem_unmap(pf, pf->pf_ccr_window);
pcmcia_mem_free(pf, &pf->pf_pcmh);
  609         }
done:
  612         /*
  613          * Decrement the reference count, and power down the socket, if
  614          * necessary.
  615          */
  616         if (--pf->sc->sc_enabled_count == 0)
pcmcia_chip_socket_disable(pf->sc->pct, pf->sc->pch);
DPRINTF(("%s: --enabled_count = %d\n", pf->sc->dev.dv_xname,
pf->sc->sc_enabled_count));
  620 }
  622 int
pcmcia_io_map(pf, width, offset, size, pcihp, windowp)
  624         struct pcmcia_function *pf;
  625         int width;
bus_addr_t offset;
bus_size_t size;
  628         struct pcmcia_io_handle *pcihp;
  629         int *windowp;
  630 {
  631         int reg;
  633         if (pcmcia_chip_io_map(pf->sc->pct, pf->sc->pch,
width, offset, size, pcihp, windowp))
  635                 return (1);
  637         /*
  638          * XXX In the multifunction multi-iospace-per-function case, this
  639          * needs to cooperate with io_alloc to make sure that the spaces
  640          * don't overlap, and that the ccr's are set correctly.
  641          */
  643         if (pcmcia_mfc(pf->sc) &&
  644             (pf->ccr_mask & (1 << (PCMCIA_CCR_IOBASE0 / 2)))) {
bus_addr_t iobase = pcihp->addr;
bus_addr_t iomax = pcihp->addr + pcihp->size - 1;
  648                 if (pf->pf_mfc_iomax == 0) {
pf->pf_mfc_iobase = iobase;
pf->pf_mfc_iomax = iomax;
  651                 } else {
  652                         if (iobase < pf->pf_mfc_iobase)
pf->pf_mfc_iobase = iobase;
  654                         if (iomax > pf->pf_mfc_iomax)
pf->pf_mfc_iomax = iomax;
  656                 }
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE0,
  659                                  (pf->pf_mfc_iobase >>  0) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE1,
  661                                  (pf->pf_mfc_iobase >>  8) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE2,
  663                                  (pf->pf_mfc_iobase >> 16) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE3,
  665                                  (pf->pf_mfc_iobase >> 24) & 0xff);
pcmcia_ccr_write(pf, PCMCIA_CCR_IOSIZE,
pf->pf_mfc_iomax - pf->pf_mfc_iobase);
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
reg |= PCMCIA_CCR_OPTION_ADDR_DECODE;
pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
  672         }
  673         return (0);
  674 }
  676 void *
pcmcia_intr_establish(pf, ipl, ih_fct, ih_arg, xname)
  678         struct pcmcia_function *pf;
  679         int ipl;
  680         int (*ih_fct)(void *);
  681         void *ih_arg;
  682         char *xname;
  683 {
  684         void *ret;
  685         int s, ihcnt, hiipl, reg;
  686         struct pcmcia_function *pf2;
  688         /* Behave differently if this is a multifunction card. */
  689         if (pcmcia_mfc(pf->sc)) {
  690                 /*
  691                  * Mask all the ipl's which are already used by this card,
  692                  * and find the highest ipl number (lowest priority).
  693                  */
ihcnt = 0;
SIMPLEQ_FOREACH(pf2, &pf->sc->card.pf_head, pf_list) {
  696                         if (pf2->ih_fct) {
DPRINTF(("%s: function %d has ih_fct %p\n",
pf->sc->dev.dv_xname, pf2->number,
pf2->ih_fct));
  701                                 if (ihcnt == 0)
hiipl = pf2->ih_ipl;
  703                                 else if (pf2->ih_ipl > hiipl)
hiipl = pf2->ih_ipl;
ihcnt++;
  707                         }
  708                 }
  710                 /*
  711                  * Establish the real interrupt, changing the ipl if
  712                  * necessary.
  713                  */
  714                 if (ihcnt == 0) {
  715 #ifdef DIAGNOSTIC
  716                         if (pf->sc->ih != NULL)
panic("card has intr handler, "
  718                                     "but no function does");
  719 #endif
s = spltty();
  722                         /* Set up the handler for the new function. */
pf->ih_fct = ih_fct;
pf->ih_arg = ih_arg;
pf->ih_ipl = ipl;
pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
pf->sc->pch, pf, ipl, pcmcia_card_intr, pf->sc,
xname);
splx(s);
  731                 } else if (ipl > hiipl) {
  732 #ifdef DIAGNOSTIC
  733                         if (pf->sc->ih == NULL)
panic("functions have ih, "
  735                                     "but the card does not");
  736 #endif
s = spltty();
pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
pf->sc->ih);
  743                         /* set up the handler for the new function */
pf->ih_fct = ih_fct;
pf->ih_arg = ih_arg;
pf->ih_ipl = ipl;
pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
pf->sc->pch, pf, ipl, pcmcia_card_intr, pf->sc,
xname);
splx(s);
  753                 } else {
s = spltty();
  756                         /* Set up the handler for the new function. */
pf->ih_fct = ih_fct;
pf->ih_arg = ih_arg;
pf->ih_ipl = ipl;
splx(s);
  762                 }
ret = pf->sc->ih;
  766                 if (ret != NULL) {
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
reg |= PCMCIA_CCR_OPTION_IREQ_ENABLE;
pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
reg |= PCMCIA_CCR_STATUS_INTRACK;
pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS, reg);
  774                 }
  775         } else
ret = pcmcia_chip_intr_establish(pf->sc->pct, pf->sc->pch,
pf, ipl, ih_fct, ih_arg, xname);
  779         return (ret);
  780 }
  782 void
pcmcia_intr_disestablish(pf, ih)
  784         struct pcmcia_function *pf;
  785         void *ih;
  786 {
  787         int s, reg, ihcnt, hiipl;
  788         struct pcmcia_function *pf2;
  790         /* Behave differently if this is a multifunction card.  */
  791         if (pcmcia_mfc(pf->sc)) {
  792                 /*
  793                  * Mask all the ipl's which are already used by this card,
  794                  * and find the highest ipl number (lowest priority).  Skip
  795                  * the current function.
  796                  */
ihcnt = 0;
SIMPLEQ_FOREACH(pf2, &pf->sc->card.pf_head, pf_list) {
  799                         if (pf2 == pf)
  800                                 continue;
  802                         if (pf2->ih_fct) {
  803                                 if (ihcnt == 0)
hiipl = pf2->ih_ipl;
  805                                 else if (pf2->ih_ipl > hiipl)
hiipl = pf2->ih_ipl;
ihcnt++;
  808                         }
  809                 }
  811                 /*
  812                  * If the ih being removed is lower priority than the lowest
  813                  * priority remaining interrupt, up the priority.
  814                  */
  816                 /*
  817                  * ihcnt is the number of interrupt handlers *not* including
  818                  * the one about to be removed.
  819                  */
  820                 if (ihcnt == 0) {
  821 #ifdef DIAGNOSTIC
  822                         if (pf->sc->ih == NULL)
panic("disestablishing last function, but card has no ih");
  824 #endif
pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
pf->sc->ih);
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
reg &= ~PCMCIA_CCR_OPTION_IREQ_ENABLE;
pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
pf->ih_fct = NULL;
pf->ih_arg = NULL;
pf->sc->ih = NULL;
  836                 } else if (pf->ih_ipl > hiipl) {
  837 #ifdef DIAGNOSTIC
  838                         if (pf->sc->ih == NULL)
panic("changing ih ipl, but card has no ih");
  840 #endif
s = spltty();
pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
pf->sc->ih);
pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
pf->sc->pch, pf, hiipl, pcmcia_card_intr, pf->sc,
NULL);
  849                         /* Null out the handler for this function. */
pf->ih_fct = NULL;
pf->ih_arg = NULL;
splx(s);
  854                 } else {
s = spltty();
pf->ih_fct = NULL;
pf->ih_arg = NULL;
splx(s);
  861                 }
  862         } else
pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch, ih);
  864 }
  866 const char *
pcmcia_intr_string(pf, ih)
  868         struct pcmcia_function *pf;
  869         void *ih;
  870 {
  871         return pcmcia_chip_intr_string(pf->sc->pct, pf->sc->pch, ih);
  872 }
  874 int
pcmcia_card_intr(arg)
  876         void *arg;
  877 {
  878         struct pcmcia_softc *sc = arg;
  879         struct pcmcia_function *pf;
  880         int reg, ret, ret2;
ret = 0;
  884         for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
pf = SIMPLEQ_NEXT(pf, pf_list)) {
  886 #ifdef PCMCIADEBUG
printf("%s: intr flags=%x fct=%d cor=%02x csr=%02x pin=%02x",
sc->dev.dv_xname, pf->pf_flags, pf->number,
pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION),
pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS),
pcmcia_ccr_read(pf, PCMCIA_CCR_PIN));
  892 #endif
  893                 if (pf->ih_fct != NULL &&
  894                     (pf->ccr_mask & (1 << (PCMCIA_CCR_STATUS / 2)))) {
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
  896                         if (reg & PCMCIA_CCR_STATUS_INTR) {
ret2 = (*pf->ih_fct)(pf->ih_arg);
  898                                 if (ret2 != 0 && ret == 0)
ret = ret2;
reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
  901 #ifdef PCMCIADEBUG
printf("; csr %02x->%02x",
reg, reg & ~PCMCIA_CCR_STATUS_INTR);
  904 #endif
pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS,
reg & ~PCMCIA_CCR_STATUS_INTR);
  907                         }
  908                 }
  909 #ifdef PCMCIADEBUG
printf("\n");
  911 #endif
  912         }
  914         return (ret);
  915 }