root/dev/pcmcia/esp_pcmcia.c

DEFINITIONS

1. esp_pcmcia_match
2. esp_pcmcia_attach
3. esp_pcmcia_init
4. esp_pcmcia_detach
5. esp_pcmcia_enable
6. esp_pcmcia_poll
7. esp_pcmcia_read_reg
8. esp_pcmcia_write_reg
9. esp_pcmcia_dma_isintr
10. esp_pcmcia_dma_reset
11. esp_pcmcia_dma_intr
12. esp_pcmcia_dma_setup
13. esp_pcmcia_dma_go
14. esp_pcmcia_dma_stop
15. esp_pcmcia_dma_isactive

    1 /*      $OpenBSD: esp_pcmcia.c,v 1.6 2006/04/20 20:30:28 miod Exp $     */
    2 /*      $NetBSD: esp_pcmcia.c,v 1.8 2000/06/05 15:36:45 tsutsui Exp $   */
    4 /*-
    5  * Copyright (c) 2000 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Charles M. Hannum.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/device.h>
   43 #include <sys/buf.h>
   45 #include <machine/bus.h>
   46 #include <machine/intr.h>
   48 #include <scsi/scsi_all.h>
   49 #include <scsi/scsiconf.h>
   51 #include <dev/pcmcia/pcmciareg.h>
   52 #include <dev/pcmcia/pcmciavar.h>
   53 #include <dev/pcmcia/pcmciadevs.h>
   55 #include <dev/ic/ncr53c9xreg.h>
   56 #include <dev/ic/ncr53c9xvar.h>
   58 struct esp_pcmcia_softc {
   59         struct ncr53c9x_softc   sc_ncr53c9x;    /* glue to MI code */
   61         int             sc_active;              /* Pseudo-DMA state vars */
   62         int             sc_tc;
   63         int             sc_datain;
size_t          sc_dmasize;
size_t          sc_dmatrans;
   66         char            **sc_dmaaddr;
size_t          *sc_pdmalen;
   69         /* PCMCIA-specific goo. */
   70         struct pcmcia_io_handle sc_pcioh;       /* PCMCIA i/o space info */
   71         int sc_io_window;                       /* our i/o window */
   72         struct pcmcia_function *sc_pf;          /* our PCMCIA function */
   73         void *sc_ih;                            /* interrupt handler */
   74 #ifdef ESP_PCMCIA_POLL
   75         struct callout sc_poll_ch;
   76 #endif
   77         int sc_flags;
   78 #define ESP_PCMCIA_ATTACHED     1               /* attach completed */
   79 #define ESP_PCMCIA_ATTACHING    2               /* attach in progress */
   80 };
   82 int     esp_pcmcia_match(struct device *, void *, void *); 
   83 void    esp_pcmcia_attach(struct device *, struct device *, void *);  
   84 void    esp_pcmcia_init(struct esp_pcmcia_softc *);
   85 int     esp_pcmcia_detach(struct device *, int);
   86 int     esp_pcmcia_enable(void *, int);
   88 struct scsi_adapter esp_pcmcia_adapter = {
ncr53c9x_scsi_cmd,      /* cmd */
minphys,                /* minphys */
   91         0,                      /* open */
   92         0,                      /* close */
   93 };
   95 struct cfattach esp_pcmcia_ca = {
   96         sizeof(struct esp_pcmcia_softc), esp_pcmcia_match, esp_pcmcia_attach
   97 };
   99 /*
  100  * Functions and the switch for the MI code.
  101  */
  102 #ifdef ESP_PCMCIA_POLL
  103 void    esp_pcmcia_poll(void *);
  104 #endif
u_char  esp_pcmcia_read_reg(struct ncr53c9x_softc *, int);
  106 void    esp_pcmcia_write_reg(struct ncr53c9x_softc *, int, u_char);
  107 int     esp_pcmcia_dma_isintr(struct ncr53c9x_softc *);
  108 void    esp_pcmcia_dma_reset(struct ncr53c9x_softc *);
  109 int     esp_pcmcia_dma_intr(struct ncr53c9x_softc *);
  110 int     esp_pcmcia_dma_setup(struct ncr53c9x_softc *, caddr_t *,
size_t *, int, size_t *);
  112 void    esp_pcmcia_dma_go(struct ncr53c9x_softc *);
  113 void    esp_pcmcia_dma_stop(struct ncr53c9x_softc *);
  114 int     esp_pcmcia_dma_isactive(struct ncr53c9x_softc *);
  116 struct ncr53c9x_glue esp_pcmcia_glue = {
esp_pcmcia_read_reg,
esp_pcmcia_write_reg,
esp_pcmcia_dma_isintr,
esp_pcmcia_dma_reset,
esp_pcmcia_dma_intr,
esp_pcmcia_dma_setup,
esp_pcmcia_dma_go,
esp_pcmcia_dma_stop,
esp_pcmcia_dma_isactive,
NULL,                   /* gl_clear_latched_intr */
  127 };
  129 struct esp_pcmcia_product {
u_int16_t       app_vendor;             /* PCMCIA vendor ID */
u_int16_t       app_product;            /* PCMCIA product ID */
  132         int             app_expfunc;            /* expected function number */
  133 } esp_pcmcia_prod[] = {
  134         { PCMCIA_VENDOR_PANASONIC, PCMCIA_PRODUCT_PANASONIC_KXLC002, 0 },
  135         { PCMCIA_VENDOR_PANASONIC, PCMCIA_PRODUCT_PANASONIC_KME, 0 },
  136         { PCMCIA_VENDOR_NEWMEDIA2, PCMCIA_PRODUCT_NEWMEDIA2_BUSTOASTER, 0 }
  137 };
  139 int
esp_pcmcia_match(parent, match, aux)
  141         struct device *parent;
  142         void *match, *aux;
  143 {
  144         struct pcmcia_attach_args *pa = aux;
  145         int i;
  147         for (i = 0; i < sizeof(esp_pcmcia_prod)/sizeof(esp_pcmcia_prod[0]); i++)
  148                 if (pa->manufacturer == esp_pcmcia_prod[i].app_vendor &&
pa->product == esp_pcmcia_prod[i].app_product &&
pa->pf->number == esp_pcmcia_prod[i].app_expfunc)
  151                         return (1);
  152         return (0);
  153 }
  155 void
esp_pcmcia_attach(parent, self, aux)
  157         struct device *parent, *self;
  158         void *aux;
  159 {
  160         struct esp_pcmcia_softc *esc = (void *)self;
  161         struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
  162         struct pcmcia_attach_args *pa = aux;
  163         struct pcmcia_config_entry *cfe;
  164         struct pcmcia_function *pf = pa->pf;
  165         const char *intrstr;
esc->sc_pf = pf;
  169         for (cfe = SIMPLEQ_FIRST(&pf->cfe_head); cfe != NULL;
cfe = SIMPLEQ_NEXT(cfe, cfe_list)) {
  171                 if (cfe->num_memspace != 0 ||
cfe->num_iospace != 1)
  173                         continue;
  175                 if (pcmcia_io_alloc(pa->pf, cfe->iospace[0].start,
cfe->iospace[0].length, 0, &esc->sc_pcioh) == 0)
  177                         break;
  178         }
  180         if (cfe == 0) {
printf(": can't alloc i/o space\n");
  182                 goto no_config_entry;
  183         }
  185         /* Enable the card. */
pcmcia_function_init(pf, cfe);
  187         if (pcmcia_function_enable(pf)) {
printf(": function enable failed\n");
  189                 goto enable_failed;
  190         }
  192         /* Map in the I/O space */
  193         if (pcmcia_io_map(pa->pf, PCMCIA_WIDTH_AUTO, 0, esc->sc_pcioh.size,
  194             &esc->sc_pcioh, &esc->sc_io_window)) {
printf(": can't map i/o space\n");
  196                 goto iomap_failed;
  197         }
printf(" port 0x%lx/%lu", esc->sc_pcioh.addr,
  200             (u_long)esc->sc_pcioh.size);
esp_pcmcia_init(esc);
esc->sc_ih = pcmcia_intr_establish(esc->sc_pf, IPL_BIO,
ncr53c9x_intr, &esc->sc_ncr53c9x, sc->sc_dev.dv_xname);
intrstr = pcmcia_intr_string(esc->sc_pf, esc->sc_ih);
  207         if (esc->sc_ih == NULL) {
printf(", %s\n", intrstr);
  209                 goto iomap_failed;
  210         }
  211         if (*intrstr)
printf(", %s", intrstr);
  214         /*
  215          *  Initialize nca board itself.
  216          */
esc->sc_flags |= ESP_PCMCIA_ATTACHING;
ncr53c9x_attach(sc, &esp_pcmcia_adapter, NULL);
esc->sc_flags &= ~ESP_PCMCIA_ATTACHING;
esc->sc_flags |= ESP_PCMCIA_ATTACHED;
  221         return;
iomap_failed:
  224         /* Disable the device. */
pcmcia_function_disable(esc->sc_pf);
enable_failed:
  228         /* Unmap our I/O space. */
pcmcia_io_free(esc->sc_pf, &esc->sc_pcioh);
no_config_entry:
  232         return;
  233 }
  235 void
esp_pcmcia_init(esc)
  237         struct esp_pcmcia_softc *esc;
  238 {
  239         struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
bus_space_tag_t iot = esc->sc_pcioh.iot;
bus_space_handle_t ioh = esc->sc_pcioh.ioh;
  243         /* id 7, clock 40M, parity ON, sync OFF, fast ON, slow ON */
sc->sc_glue = &esp_pcmcia_glue;
  247 #ifdef ESP_PCMCIA_POLL
callout_init(&esc->sc_poll_ch);
  249 #endif
sc->sc_rev = NCR_VARIANT_ESP406;
sc->sc_id = 7;
sc->sc_freq = 40;
  254         /* try -PARENB -SLOW */
sc->sc_cfg1 = sc->sc_id | NCRCFG1_PARENB | NCRCFG1_SLOW;
  256         /* try +FE */
sc->sc_cfg2 = NCRCFG2_SCSI2;
  258         /* try -IDM -FSCSI -FCLK */
sc->sc_cfg3 = NCRESPCFG3_CDB | NCRESPCFG3_FCLK | NCRESPCFG3_IDM |
NCRESPCFG3_FSCSI;
sc->sc_cfg4 = NCRCFG4_ACTNEG;
  262         /* try +INTP */
sc->sc_cfg5 = NCRCFG5_CRS1 | NCRCFG5_AADDR | NCRCFG5_PTRINC;
sc->sc_minsync = 0;
sc->sc_maxxfer = 64 * 1024;
bus_space_write_1(iot, ioh, NCR_CFG5, sc->sc_cfg5);
bus_space_write_1(iot, ioh, NCR_PIOI, 0);
bus_space_write_1(iot, ioh, NCR_PSTAT, 0);
bus_space_write_1(iot, ioh, 0x09, 0x24);
bus_space_write_1(iot, ioh, NCR_CFG4, sc->sc_cfg4);
  274 }
  276 #ifdef notyet
  277 int
esp_pcmcia_detach(self, flags)
  279         struct device *self;
  280         int flags;
  281 {
  282         struct esp_pcmcia_softc *esc = (void *)self;
  283         int error;
  285         if ((esc->sc_flags & ESP_PCMCIA_ATTACHED) == 0) {
  286                 /* Nothing to detach. */
  287                 return (0);
  288         }
error = ncr53c9x_detach(&esc->sc_ncr53c9x, flags);
  291         if (error)
  292                 return (error);
  294         /* Unmap our i/o window and i/o space. */
pcmcia_io_unmap(esc->sc_pf, esc->sc_io_window);
pcmcia_io_free(esc->sc_pf, &esc->sc_pcioh);
  298         return (0);
  299 }
  300 #endif
  302 int
esp_pcmcia_enable(arg, onoff)
  304         void *arg;
  305         int onoff;
  306 {
  307         struct esp_pcmcia_softc *esc = arg;
  309         if (onoff) {
  310 #ifdef ESP_PCMCIA_POLL
callout_reset(&esc->sc_poll_ch, 1, esp_pcmcia_poll, esc);
  312 #else
  313                 /* Establish the interrupt handler. */
esc->sc_ih = pcmcia_intr_establish(esc->sc_pf, IPL_BIO,
ncr53c9x_intr, &esc->sc_ncr53c9x,
esc->sc_ncr53c9x.sc_dev.dv_xname);
  317                 if (esc->sc_ih == NULL) {
printf("%s: couldn't establish interrupt handler\n",
esc->sc_ncr53c9x.sc_dev.dv_xname);
  320                         return (EIO);
  321                 }
  322 #endif
  324                 /*
  325                  * If attach is in progress, we know that card power is
  326                  * enabled and chip will be initialized later.
  327                  * Otherwise, enable and reset now.
  328                  */
  329                 if ((esc->sc_flags & ESP_PCMCIA_ATTACHING) == 0) {
  330                         if (pcmcia_function_enable(esc->sc_pf)) {
printf("%s: couldn't enable PCMCIA function\n",
esc->sc_ncr53c9x.sc_dev.dv_xname);
pcmcia_intr_disestablish(esc->sc_pf,
esc->sc_ih);
  335                                 return (EIO);
  336                         }
  338                         /* Initialize only chip.  */
ncr53c9x_init(&esc->sc_ncr53c9x, 0);
  340                 }
  341         } else {
pcmcia_function_disable(esc->sc_pf);
  343 #ifdef ESP_PCMCIA_POLL
callout_stop(&esc->sc_poll_ch);
  345 #else
pcmcia_intr_disestablish(esc->sc_pf, esc->sc_ih);
  347 #endif
  348         }
  350         return (0);
  351 }
  353 #ifdef ESP_PCMCIA_POLL
  354 void
esp_pcmcia_poll(arg)
  356         void *arg;
  357 {
  358         struct esp_pcmcia_softc *esc = arg;
  360         (void) ncr53c9x_intr(&esc->sc_ncr53c9x);
callout_reset(&esc->sc_poll_ch, 1, esp_pcmcia_poll, esc);
  362 }
  363 #endif
  365 /*
  366  * Glue functions.
  367  */
u_char
esp_pcmcia_read_reg(sc, reg)
  370         struct ncr53c9x_softc *sc;
  371         int reg;
  372 {
  373         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
u_char v;
v = bus_space_read_1(esc->sc_pcioh.iot, esc->sc_pcioh.ioh, reg);
  377         return v;
  378 }
  380 void
esp_pcmcia_write_reg(sc, reg, val)
  382         struct ncr53c9x_softc *sc;
  383         int reg;
u_char val;
  385 {
  386         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
u_char v = val;
  389         if (reg == NCR_CMD && v == (NCRCMD_TRANS|NCRCMD_DMA))
v = NCRCMD_TRANS;
bus_space_write_1(esc->sc_pcioh.iot, esc->sc_pcioh.ioh, reg, v);
  392 }
  394 int
esp_pcmcia_dma_isintr(sc)
  396         struct ncr53c9x_softc *sc;
  397 {
  399         return NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT;
  400 }
  402 void
esp_pcmcia_dma_reset(sc)
  404         struct ncr53c9x_softc *sc;
  405 {
  406         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
esc->sc_active = 0;
esc->sc_tc = 0;
  410 }
  412 int
esp_pcmcia_dma_intr(sc)
  414         struct ncr53c9x_softc *sc;
  415 {
  416         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
u_char  *p;
u_int   espphase, espstat, espintr;
  419         int     cnt;
  421         if (esc->sc_active == 0) {
printf("%s: dma_intr--inactive DMA\n", sc->sc_dev.dv_xname);
  423                 return -1;
  424         }
  426         if ((sc->sc_espintr & NCRINTR_BS) == 0) {
esc->sc_active = 0;
  428                 return 0;
  429         }
cnt = *esc->sc_pdmalen;
  432         if (*esc->sc_pdmalen == 0) {
printf("%s: data interrupt, but no count left\n",
sc->sc_dev.dv_xname);
  435         }
p = *esc->sc_dmaaddr;
espphase = sc->sc_phase;
espstat = (u_int) sc->sc_espstat;
espintr = (u_int) sc->sc_espintr;
  441         do {
  442                 if (esc->sc_datain) {
  443                         *p++ = NCR_READ_REG(sc, NCR_FIFO);
cnt--;
  445                         if (espphase == DATA_IN_PHASE)
NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
  447                         else
esc->sc_active = 0;
  449                 } else {
  450                         if (espphase == DATA_OUT_PHASE ||
espphase == MESSAGE_OUT_PHASE) {
NCR_WRITE_REG(sc, NCR_FIFO, *p++);
cnt--;
NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
  455                         } else
esc->sc_active = 0;
  457                 }
  459                 if (esc->sc_active) {
  460                         while (!(NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT));
espstat = NCR_READ_REG(sc, NCR_STAT);
espintr = NCR_READ_REG(sc, NCR_INTR);
espphase = (espintr & NCRINTR_DIS)
  464                                     ? /* Disconnected */ BUSFREE_PHASE
  465                                     : espstat & PHASE_MASK;
  466                 }
  467         } while (esc->sc_active && espintr);
sc->sc_phase = espphase;
sc->sc_espstat = (u_char) espstat;
sc->sc_espintr = (u_char) espintr;
  471         *esc->sc_dmaaddr = p;
  472         *esc->sc_pdmalen = cnt;
  474         if (*esc->sc_pdmalen == 0)
esc->sc_tc = NCRSTAT_TC;
sc->sc_espstat |= esc->sc_tc;
  477         return 0;
  478 }
  480 int
esp_pcmcia_dma_setup(sc, addr, len, datain, dmasize)
  482         struct ncr53c9x_softc *sc;
caddr_t *addr;
size_t *len;
  485         int datain;
size_t *dmasize;
  487 {
  488         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
esc->sc_dmaaddr = addr;
esc->sc_pdmalen = len;
esc->sc_datain = datain;
esc->sc_dmasize = *dmasize;
esc->sc_tc = 0;
  496         return 0;
  497 }
  499 void
esp_pcmcia_dma_go(sc)
  501         struct ncr53c9x_softc *sc;
  502 {
  503         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
esc->sc_active = 1;
  506 }
  508 void
esp_pcmcia_dma_stop(sc)
  510         struct ncr53c9x_softc *sc;
  511 {
  512 }
  514 int
esp_pcmcia_dma_isactive(sc)
  516         struct ncr53c9x_softc *sc;
  517 {
  518         struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
  520         return (esc->sc_active);
  521 }