sys/arch/alpha/jensenio/jensenio.c

   1 /* $NetBSD: jensenio.c,v 1.18 2009/08/19 14:29:53 dyoung Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1999, 2000 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   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 /*
  33  * Driver for the Jensen I/O bus.
  34  *
  35  * The Jensen I/O `bus' is comprised of two things:
  36  *
  37  *      - VLSI VL82C106 junk I/O chip
  38  *      - Intel EISA bus interface
  39  *
  40  * Access to the 82C106 is different than to the rest of EISA space, even
  41  * though it is a single address space.
  42  */
  43
  44 #include <sys/cdefs.h>                  /* RCS ID & Copyright macro defns */
  45
  46 __KERNEL_RCSID(0, "$NetBSD: jensenio.c,v 1.18 2009/08/19 14:29:53 dyoung Exp $");
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/device.h>
  51
  52 #include <machine/autoconf.h>
  53
  54 #include <dev/eisa/eisavar.h>
  55
  56 #include <dev/isa/isareg.h>
  57 #include <dev/isa/isavar.h>
  58
  59 #include <alpha/jensenio/jensenioreg.h>
  60 #include <alpha/jensenio/jenseniovar.h>
  61
  62 #include "locators.h"
  63
  64 #include "eisa.h"
  65
  66 /*
  67  * The devices built-in to the VLSI VL82C106 junk I/O chip.
  68  */
  69 static const struct jensenio_dev {
  70         const char *jd_name;            /* device name */
  71         bus_addr_t jd_ioaddr;           /* I/O space address */
  72         int jd_irq[2];                  /* Jensen IRQs */
  73 } jensenio_devs[] = {
  74         { "pckbc",      IO_KBD,         { 0x980, 0x990 } },
  75         { "com",        IO_COM1,        { 0x900, -1 } },
  76         { "com",        IO_COM2,        { 0x920, -1 } },
  77         { "lpt",        IO_LPT3,        { 1, -1 } },
  78         { "mcclock",    0x170,          { -1, -1 } },
  79         { NULL,         0,              { -1, -1 } },
  80 };
  81
  82 static int      jensenio_match(device_t, cfdata_t, void *);
  83 static void     jensenio_attach(device_t, device_t, void *);
  84
  85 CFATTACH_DECL_NEW(jensenio, 0, jensenio_match, jensenio_attach, NULL, NULL);
  86
  87 static int      jensenio_print(void *, const char *);
  88
  89 static int      jensenio_attached;
  90
  91 struct jensenio_config jensenio_configuration;
  92
  93 static void     jensenio_eisa_attach_hook(device_t, device_t,
  94             struct eisabus_attach_args *);
  95 static int      jensenio_eisa_maxslots(void *);
  96
  97 static void     jensenio_isa_attach_hook(device_t, device_t,
  98             struct isabus_attach_args *);
  99
 100 static void     jensenio_isa_detach_hook(isa_chipset_tag_t, device_t);
 101
 102 /*
 103  * Set up the Jensen's function pointers.
 104  */
 105 void
 106 jensenio_init(struct jensenio_config *jcp, int mallocsafe)
 107 {
 108
 109         /*
 110          * Initialize the Host Address Extension register to 0
 111          * (the firmware should have already done this).  We will
 112          * disallow mapping of any device who's address would
 113          * require a non-0 HAE.  This should be safe as the final
 114          * draft of the Jensen system specification states that
 115          * applications should follow this little rule.
 116          *
 117          * There's a good reason for this; actually using HAE would
 118          * require a mutex around *every* EISA cycle!  Gross!
 119          */
 120         REGVAL(JENSEN_HAE) = 0;
 121         alpha_mb();
 122
 123         if (jcp->jc_initted == 0) {
 124                 /* don't do these twice since they set up extents */
 125                 jensenio_bus_io_init(&jcp->jc_eisa_iot, jcp);
 126                 jensenio_bus_intio_init(&jcp->jc_internal_iot, jcp);
 127                 jensenio_bus_mem_init(&jcp->jc_eisa_memt, jcp);
 128         }
 129         jcp->jc_mallocsafe = mallocsafe;
 130 }
 131
 132 static int
 133 jensenio_match(device_t parent, cfdata_t cf, void *aux)
 134 {
 135         struct mainbus_attach_args *ma = aux;
 136
 137         if (strcmp(ma->ma_name, cf->cf_name) != 0)
 138                 return (0);
 139
 140         /* There can be only one. */
 141         if (jensenio_attached)
 142                 return (0);
 143
 144         return (1);
 145 }
 146
 147 static void
 148 jensenio_attach(device_t parent, device_t self, void *aux)
 149 {
 150         struct jensenio_attach_args ja;
 151         struct jensenio_config *jcp = &jensenio_configuration;
 152         int i;
 153         int locs[JENSENIOCF_NLOCS];
 154
 155         printf("\n");
 156
 157         jensenio_attached = 1;
 158
 159         /*
 160          * Done once at console init time, but we might need to do
 161          * additional work this time.
 162          */
 163         jensenio_init(jcp, 1);
 164
 165         /*
 166          * Initialize DMA.
 167          */
 168         jensenio_dma_init(jcp);
 169
 170         /*
 171          * Initialize interrupts.
 172          */
 173         jensenio_intr_init(jcp);
 174
 175         /*
 176          * First attach all of the built-in devices.
 177          */
 178         for (i = 0; jensenio_devs[i].jd_name != NULL; i++) {
 179                 ja.ja_name = jensenio_devs[i].jd_name;
 180                 ja.ja_ioaddr = jensenio_devs[i].jd_ioaddr;
 181                 ja.ja_irq[0] = jensenio_devs[i].jd_irq[0];
 182                 ja.ja_irq[1] = jensenio_devs[i].jd_irq[1];
 183
 184                 ja.ja_iot = &jcp->jc_internal_iot;
 185                 ja.ja_ec = &jcp->jc_ec;
 186
 187                 locs[JENSENIOCF_PORT] = jensenio_devs[i].jd_ioaddr;
 188                 (void) config_found_sm_loc(self, "jensenio", locs, &ja,
 189                     jensenio_print, config_stdsubmatch);
 190         }
 191
 192         /*
 193          * Attach the EISA bus.
 194          */
 195         jcp->jc_ec.ec_attach_hook = jensenio_eisa_attach_hook;
 196         jcp->jc_ec.ec_maxslots = jensenio_eisa_maxslots;
 197
 198         ja.ja_eisa.eba_iot = &jcp->jc_eisa_iot;
 199         ja.ja_eisa.eba_memt = &jcp->jc_eisa_memt;
 200         ja.ja_eisa.eba_dmat = &jcp->jc_dmat_eisa;
 201         ja.ja_eisa.eba_ec = &jcp->jc_ec;
 202         (void) config_found_ia(self, "eisabus", &ja.ja_eisa, eisabusprint);
 203
 204         /*
 205          * Attach the ISA bus.
 206          */
 207         jcp->jc_ic.ic_attach_hook = jensenio_isa_attach_hook;
 208         jcp->jc_ic.ic_detach_hook = jensenio_isa_detach_hook;
 209
 210         ja.ja_isa.iba_iot = &jcp->jc_eisa_iot;
 211         ja.ja_isa.iba_memt = &jcp->jc_eisa_memt;
 212         ja.ja_isa.iba_dmat = &jcp->jc_dmat_isa;
 213         ja.ja_isa.iba_ic = &jcp->jc_ic;
 214         (void) config_found_ia(self, "isabus", &ja.ja_isa, isabusprint);
 215 }
 216
 217 static int
 218 jensenio_print(void *aux, const char *pnp)
 219 {
 220         struct jensenio_attach_args *ja = aux;
 221
 222         if (pnp != NULL)
 223                 aprint_normal("%s at %s", ja->ja_name, pnp);
 224
 225         aprint_normal(" port 0x%lx", ja->ja_ioaddr);
 226
 227         return (UNCONF);
 228 }
 229
 230 static void
 231 jensenio_eisa_attach_hook(device_t parent, device_t self,
 232     struct eisabus_attach_args *eba)
 233 {
 234
 235 #if NEISA > 0
 236         /*
 237          * Jensen's EISA config info is sparse, and is mapped at a
 238          * different location that on other EISA systems.
 239          */
 240         eisa_config_stride = 0x200;
 241         eisa_config_addr = JENSEN_FEPROM1;
 242         eisa_init(eba->eba_ec);
 243 #endif
 244 }
 245
 246 static int
 247 jensenio_eisa_maxslots(void *v)
 248 {
 249
 250         return (8);     /* jensen seems to have only 8 valid slots */
 251 }
 252
 253 static void
 254 jensenio_isa_attach_hook(device_t parent, device_t self,
 255     struct isabus_attach_args *iba)
 256 {
 257
 258         /* Nothing to do. */
 259 }
 260
 261 static void
 262 jensenio_isa_detach_hook(isa_chipset_tag_t ic, device_t self)
 263 {
 264
 265         /* Nothing to do. */
 266 }