root/dev/tc/tc.c

DEFINITIONS

1. tcmatch
2. tcattach
3. tcprint
4. tcsubmatch
5. tc_checkslot
6. tc_intr_establish
7. tc_intr_disestablish
8. tc_devinfo

    1 /*      $OpenBSD: tc.c,v 1.17 2007/06/25 14:13:40 tom Exp $     */
    2 /*      $NetBSD: tc.c,v 1.29 2001/11/13 06:26:10 lukem Exp $    */
    4 /*
    5  * Copyright (c) 1994, 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: Chris G. Demetriou
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/device.h>
   35 #include <dev/tc/tcreg.h>
   36 #include <dev/tc/tcvar.h>
   39 /* Definition of the driver for autoconfig. */
   40 int     tcmatch(struct device *, void *, void *);
   41 void    tcattach(struct device *, struct device *, void *);
   43 struct cfattach tc_ca = {
   44         sizeof(struct tc_softc), tcmatch, tcattach
   45 };
   47 struct cfdriver tc_cd = {
NULL, "tc", DV_DULL
   49 };
   51 int     tcprint(void *, const char *);
   52 int     tcsubmatch(struct device *, void *, void *);
   53 int     tc_checkslot(tc_addr_t, char *);
   54 void    tc_devinfo(const char *, char *, size_t);
   56 int
tcmatch(parent, vcf, aux)
   58         struct device *parent;
   59         void *vcf, *aux;
   60 {
   61         struct tcbus_attach_args *tba = aux;
   62         struct cfdata *cf = vcf;
   64         if (strcmp(tba->tba_busname, cf->cf_driver->cd_name))
   65                 return (0);
   67         return (1);
   68 }
   70 void
tcattach(parent, self, aux)
   72         struct device *parent;
   73         struct device *self;
   74         void *aux;
   75 {
   76         struct tc_softc *sc = (struct tc_softc *)self;
   77         struct tcbus_attach_args *tba = aux;
   78         struct tc_attach_args ta;
   79         const struct tc_builtin *builtin;
   80         struct tc_slotdesc *slot;
tc_addr_t tcaddr;
   82         int i;
printf(": %s MHz clock\n",
tba->tba_speed == TC_SPEED_25_MHZ ? "25" : "12.5");
   87         /*
   88          * Save important CPU/chipset information.
   89          */
sc->sc_speed = tba->tba_speed;
sc->sc_nslots = tba->tba_nslots;
sc->sc_slots = tba->tba_slots;
sc->sc_intr_establish = tba->tba_intr_establish;
sc->sc_intr_disestablish = tba->tba_intr_disestablish;
sc->sc_get_dma_tag = tba->tba_get_dma_tag;
   97         /*
   98          * Try to configure each built-in device
   99          */
  100         for (i = 0; i < tba->tba_nbuiltins; i++) {
builtin = &tba->tba_builtins[i];
  103                 /* sanity check! */
  104                 if (builtin->tcb_slot > sc->sc_nslots)
panic("tcattach: builtin %d slot > nslots", i);
  107                 /*
  108                  * Make sure device is really there, because some
  109                  * built-in devices are really optional.
  110                  */
tcaddr = sc->sc_slots[builtin->tcb_slot].tcs_addr +
builtin->tcb_offset;
  113                 if (tc_badaddr(tcaddr))
  114                         continue;
  116                 /*
  117                  * Set up the device attachment information.
  118                  */
strncpy(ta.ta_modname, builtin->tcb_modname, TC_ROM_LLEN);
ta.ta_memt = tba->tba_memt;
ta.ta_dmat = (*sc->sc_get_dma_tag)(builtin->tcb_slot);
ta.ta_modname[TC_ROM_LLEN] = '\0';
ta.ta_slot = builtin->tcb_slot;
ta.ta_offset = builtin->tcb_offset;
ta.ta_addr = tcaddr;
ta.ta_cookie = builtin->tcb_cookie;
ta.ta_busspeed = sc->sc_speed;
  129                 /*
  130                  * Mark the slot as used, so we don't check it later.
  131                  */
sc->sc_slots[builtin->tcb_slot].tcs_used = 1;
  134                 /*
  135                  * Attach the device.
  136                  */
config_found_sm(self, &ta, tcprint, tcsubmatch);
  138         }
  140         /*
  141          * Try to configure each unused slot, last to first.
  142          */
  143         for (i = sc->sc_nslots - 1; i >= 0; i--) {
slot = &sc->sc_slots[i];
  146                 /* If already checked above, don't look again now. */
  147                 if (slot->tcs_used)
  148                         continue;
  150                 /*
  151                  * Make sure something is there, and find out what it is.
  152                  */
tcaddr = slot->tcs_addr;
  154                 if (tc_badaddr(tcaddr))
  155                         continue;
  156                 if (tc_checkslot(tcaddr, ta.ta_modname) == 0)
  157                         continue;
  159                 /*
  160                  * Set up the rest of the attachment information.
  161                  */
ta.ta_memt = tba->tba_memt;
ta.ta_dmat = (*sc->sc_get_dma_tag)(i);
ta.ta_slot = i;
ta.ta_offset = 0;
ta.ta_addr = tcaddr;
ta.ta_cookie = slot->tcs_cookie;
  169                 /*
  170                  * Mark the slot as used.
  171                  */
slot->tcs_used = 1;
  174                 /*
  175                  * Attach the device.
  176                  */
config_found_sm(self, &ta, tcprint, tcsubmatch);
  178         }
  179 }
  181 int
tcprint(aux, pnp)
  183         void *aux;
  184         const char *pnp;
  185 {
  186         struct tc_attach_args *ta = aux;
  187         char devinfo[256];
  189         if (pnp) {
tc_devinfo(ta->ta_modname, devinfo, sizeof devinfo);
printf("%s at %s", devinfo, pnp);
  192         }
printf(" slot %d offset 0x%lx", ta->ta_slot,
  194             (long)ta->ta_offset);
  195         return (UNCONF);
  196 }
  198 int
tcsubmatch(parent, vcf, aux)
  200         struct device *parent;
  201         void *vcf, *aux;
  202 {
  203         struct tc_attach_args *d = aux;
  204         struct cfdata *cf = vcf;
  206         if ((cf->tccf_slot != TCCF_SLOT_UNKNOWN) &&
  207             (cf->tccf_slot != d->ta_slot))
  208                 return 0;
  209         if ((cf->tccf_offset != TCCF_SLOT_UNKNOWN) &&
  210             (cf->tccf_offset != d->ta_offset))
  211                 return 0;
  213         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  214 }
  217 #define NTC_ROMOFFS     2
  218 static tc_offset_t tc_slot_romoffs[NTC_ROMOFFS] = {
TC_SLOT_ROM,
TC_SLOT_PROTOROM,
  221 };
  223 int
tc_checkslot(slotbase, namep)
tc_addr_t slotbase;
  226         char *namep;
  227 {
  228         struct tc_rommap *romp;
  229         int i, j;
  231         for (i = 0; i < NTC_ROMOFFS; i++) {
romp = (struct tc_rommap *)
  233                     (slotbase + tc_slot_romoffs[i]);
  235                 switch (romp->tcr_width.v) {
  236                 case 1:
  237                 case 2:
  238                 case 4:
  239                         break;
  241                 default:
  242                         continue;
  243                 }
  245                 if (romp->tcr_stride.v != 4)
  246                         continue;
  248                 for (j = 0; j < 4; j++)
  249                         if (romp->tcr_test[j+0*romp->tcr_stride.v] != 0x55 ||
romp->tcr_test[j+1*romp->tcr_stride.v] != 0x00 ||
romp->tcr_test[j+2*romp->tcr_stride.v] != 0xaa ||
romp->tcr_test[j+3*romp->tcr_stride.v] != 0xff)
  253                                 continue;
  255                 for (j = 0; j < TC_ROM_LLEN; j++)
namep[j] = romp->tcr_modname[j].v;
namep[j] = '\0';
  258                 return (1);
  259         }
  260         return (0);
  261 }
  263 void
tc_intr_establish(dev, cookie, level, handler, arg)
  265         struct device *dev;
  266         void *cookie, *arg;
  267         int level;
  268         int (*handler)(void *);
  269 {
  270         struct tc_softc *sc = tc_cd.cd_devs[0];
  272         (*sc->sc_intr_establish)(dev, cookie, level, handler, arg);
  273 }
  275 void
tc_intr_disestablish(dev, cookie)
  277         struct device *dev;
  278         void *cookie;
  279 {
  280         struct tc_softc *sc = tc_cd.cd_devs[0];
  282         (*sc->sc_intr_disestablish)(dev, cookie);
  283 }
  285 #ifdef TCVERBOSE
  286 /*
  287  * Descriptions of known devices.
  288  */
  289 struct tc_knowndev {
  290         const char *id, *description;
  291 };
  293 #include <dev/tc/tcdevs_data.h>
  294 #endif /* TCVERBOSE */
  296 void
tc_devinfo(const char *id, char *cp, size_t cp_len)
  298 {
  299 #ifdef TCVERBOSE
  300         struct tc_knowndev *tdp;
  301         const char *description;
  303         /* find the device in the table, if possible. */
description = NULL;
  305         for (tdp = tc_knowndevs; tdp->id != NULL; tdp++) {
  306                 /* check this entry for a match */
  307                 if (strcmp(tdp->id, id) == 0) {
description = tdp->description;
  309                         break;
  310                 }
  311         }
  312         if (description != NULL)
snprintf(cp, cp_len, "\"%s\" (%s)", id, description);
  314         else
  315 #endif
snprintf(cp, cp_len, "\"%s\"", id);
  317 }