sys/arch/mipsco/obio/rambo.c

   1 /*      $NetBSD: rambo.c,v 1.11 2009/03/14 15:36:10 dsl Exp $   */
   2
   3 /*
   4  * Copyright (c) 2000 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Wayne Knowles
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: rambo.c,v 1.11 2009/03/14 15:36:10 dsl Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/kernel.h>
  37 #include <sys/device.h>
  38 #include <sys/systm.h>
  39 #include <sys/timetc.h>
  40
  41 #include <machine/cpu.h>
  42 #include <machine/mainboard.h>
  43 #include <machine/autoconf.h>
  44 #include <machine/sysconf.h>
  45 #include <machine/bus.h>
  46
  47 #include <mipsco/obio/rambo.h>
  48
  49 /*
  50  * Timer & Interrupt manipulation routines for the Rambo Custom ASIC
  51  */
  52
  53 static int      rambo_match(struct device *, struct cfdata *, void *);
  54 static void     rambo_attach(struct device *, struct device *, void *);
  55 static unsigned rambo_get_timecount(struct timecounter *);
  56 void rambo_clkintr(struct clockframe *);
  57 static void rambo_tc_init(void);
  58
  59 struct rambo_softc {
  60         struct device           dev;
  61         struct evcnt            sc_intrcnt;
  62         bus_space_tag_t         sc_bst;
  63         bus_space_handle_t      sc_bsh;
  64         u_int32_t               sc_tclast;
  65         u_int32_t               sc_hzticks;
  66 };
  67
  68 static struct rambo_softc *rambo;
  69
  70 CFATTACH_DECL(rambo, sizeof(struct rambo_softc),
  71     rambo_match, rambo_attach, NULL, NULL);
  72
  73 static int
  74 rambo_match(struct device *parent, struct cfdata *cf, void *aux)
  75 {
  76         return 1;
  77 }
  78
  79 static void
  80 rambo_attach(struct device *parent, struct device *self, void *aux)
  81 {
  82         struct confargs *ca = aux;
  83         struct rambo_softc *sc = (void *)self;
  84
  85         sc->sc_bst = ca->ca_bustag;
  86
  87         if (bus_space_map(ca->ca_bustag, ca->ca_addr, 256,
  88                           BUS_SPACE_MAP_LINEAR,
  89                           &sc->sc_bsh) != 0) {
  90                 printf(": cannot map registers\n");
  91                 return;
  92         }
  93         evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
  94                              "timer", "intr");
  95
  96         /* Setup RAMBO Timer to generate timer interrupts */
  97         sc->sc_hzticks = HZ_TO_TICKS(hz);
  98
  99         sc->sc_tclast = 0;
 100         bus_space_write_4(sc->sc_bst, sc->sc_bsh, RB_TCOUNT, 0);
 101         bus_space_write_4(sc->sc_bst, sc->sc_bsh, RB_TBREAK, sc->sc_hzticks);
 102
 103         bus_space_write_4(sc->sc_bst, sc->sc_bsh, RB_CTLREG,
 104                           RB_PARITY_EN | RB_BUZZOFF | RB_CLR_IOERR);
 105
 106         printf(": parity enabled\n");
 107         rambo = sc;
 108         platform.clkinit = rambo_tc_init;
 109 }
 110
 111 void
 112 rambo_clkintr(struct clockframe *cf)
 113 {
 114         register u_int32_t tbreak, tcount;
 115         register int delta;
 116
 117         rambo->sc_intrcnt.ev_count++;
 118         tbreak = bus_space_read_4(rambo->sc_bst, rambo->sc_bsh, RB_TBREAK);
 119         tcount = bus_space_read_4(rambo->sc_bst, rambo->sc_bsh, RB_TCOUNT);
 120         delta  = tcount - tbreak;
 121
 122         if (delta > (rambo->sc_hzticks>>1)) {
 123                 /*
 124                  * Either tcount may overtake the updated tbreak value
 125                  * or we have missed several interrupt's
 126                  */
 127                 int cycles = 10 * hz;
 128                 while (cycles && tbreak < tcount) {
 129                         hardclock(cf);
 130                         rambo->sc_tclast = tbreak;
 131                         tbreak += rambo->sc_hzticks;
 132                         cycles--;
 133                 }
 134                 if (cycles == 0) { /* catchup failed - assume we are in sync */
 135                         tcount = bus_space_read_4(rambo->sc_bst,
 136                                                   rambo->sc_bsh, RB_TCOUNT);
 137                         rambo->sc_tclast = tbreak = tcount;
 138                 }
 139         } else {
 140                 hardclock(cf);
 141                 rambo->sc_tclast = tbreak;
 142         }
 143
 144         tbreak += rambo->sc_hzticks;
 145
 146         bus_space_write_4(rambo->sc_bst, rambo->sc_bsh, RB_TBREAK, tbreak);
 147 }
 148
 149 /*
 150  * Calculate the number of microseconds since the last clock tick
 151  */
 152 static unsigned
 153 rambo_get_timecount(struct timecounter *tc)
 154 {
 155
 156         return (bus_space_read_4(rambo->sc_bst, rambo->sc_bsh, RB_TCOUNT));
 157 }
 158
 159 static void
 160 rambo_tc_init(void)
 161 {
 162         static struct timecounter tc = {
 163                 .tc_get_timecount = rambo_get_timecount,
 164                 .tc_frequency = RB_FREQUENCY,
 165                 .tc_quality = 100,
 166                 .tc_name = "rambo_tcount",
 167                 .tc_counter_mask = ~0
 168         };
 169
 170         tc_init(&tc);
 171 }