1 /* $NetBSD: jazzio.c,v 1.20 2008/07/05 08:46:25 tsutsui Exp $ */ 2 /* $OpenBSD: picabus.c,v 1.11 1999/01/11 05:11:10 millert Exp $ */ 3 /* NetBSD: tc.c,v 1.2 1995/03/08 00:39:05 cgd Exp */ 4 5 /* 6 * Copyright (c) 1994, 1995 Carnegie-Mellon University. 7 * All rights reserved. 8 * 9 * Author: Chris G. Demetriou 10 * Author: Per Fogelstrom. (Mips R4x00) 11 * 12 * Permission to use, copy, modify and distribute this software and 13 * its documentation is hereby granted, provided that both the copyright 14 * notice and this permission notice appear in all copies of the 15 * software, derivative works or modified versions, and any portions 16 * thereof, and that both notices appear in supporting documentation. 17 * 18 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 19 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 20 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 21 * 22 * Carnegie Mellon requests users of this software to return to 23 * 24 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 25 * School of Computer Science 26 * Carnegie Mellon University 27 * Pittsburgh PA 15213-3890 28 * 29 * any improvements or extensions that they make and grant Carnegie the 30 * rights to redistribute these changes. 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: jazzio.c,v 1.20 2008/07/05 08:46:25 tsutsui Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/device.h> 39 40 #include <machine/bus.h> 41 #include <machine/pio.h> 42 #include <machine/autoconf.h> 43 #include <machine/platform.h> 44 45 #include <arc/jazz/jazziovar.h> 46 #include <arc/jazz/pica.h> 47 #include <arc/jazz/jazzdmatlbreg.h> 48 #include <arc/jazz/jazzdmatlbvar.h> 49 #include <arc/jazz/dma.h> 50 #include <arc/jazz/pckbc_jazzioreg.h> 51 52 #include "ioconf.h" 53 54 void arc_sysreset(bus_addr_t, bus_size_t); 55 56 struct jazzio_softc { 57 device_t sc_dev; 58 struct arc_bus_dma_tag sc_dmat; 59 struct pica_dev *sc_devs; 60 }; 61 62 /* Definition of the driver for autoconfig. */ 63 static int jazziomatch(device_t, cfdata_t, void *); 64 static void jazzioattach(device_t, device_t, void *); 65 static int jazzioprint(void *, const char *); 66 67 CFATTACH_DECL_NEW(jazzio, sizeof(struct jazzio_softc), 68 jazziomatch, jazzioattach, NULL, NULL); 69 70 static uint32_t jazzio_intr(uint32_t, struct clockframe *); 71 static int jazzio_no_handler(void *); 72 73 /* 74 * Interrupt dispatch table for jazz i/o bus. 75 */ 76 struct jazzio_intrhand { 77 intr_handler_t ih_func; /* Interrupt handler */ 78 void *ih_arg; /* Parameter to send to handler */ 79 struct evcnt ih_evcnt; /* interrupt counter */ 80 char ih_evname[32]; /* event counter name */ 81 }; 82 83 static struct jazzio_intrhand jazzio_intrtab[16]; 84 85 86 struct jazzio_config *jazzio_conf = NULL; 87 struct pica_dev *jazzio_devconfig = NULL; 88 int jazzio_int_mask = 0; /* jazz i/o interrupt enable mask */ 89 struct arc_bus_space jazzio_bus; 90 91 static int jazzio_found = 0; 92 93 static int 94 jazziomatch(device_t parent, cfdata_t cf, void *aux) 95 { 96 struct confargs *ca = aux; 97 98 /* Make sure that we're looking for a jazzio bus. */ 99 if (strcmp(ca->ca_name, jazzio_cd.cd_name) != 0) 100 return 0; 101 102 return 1; 103 } 104 105 static void 106 jazzioattach(device_t parent, device_t self, void *aux) 107 { 108 struct jazzio_softc *sc = device_private(self); 109 struct jazzio_attach_args ja; 110 int i; 111 112 sc->sc_dev = self; 113 114 if (jazzio_conf == NULL) 115 panic("jazzio_conf isn't initialized"); 116 if (jazzio_devconfig == NULL) 117 panic("jazzio_devconfig isn't initialized"); 118 119 jazzio_found = 1; 120 121 aprint_normal("\n"); 122 123 /* keep our CPU device description handy */ 124 sc->sc_devs = jazzio_devconfig; 125 126 /* initialize interrupt handler table */ 127 for (i = 0; i < __arraycount(jazzio_intrtab); i++) { 128 jazzio_intrtab[i].ih_func = jazzio_no_handler; 129 jazzio_intrtab[i].ih_arg = NULL; 130 } 131 132 /* set up interrupt handlers */ 133 (*platform->set_intr)(MIPS_INT_MASK_1, jazzio_intr, ARC_INTPRI_JAZZ); 134 135 /* Initialize jazzio DMA mapping register area and pool */ 136 jazz_dmatlb_init(&jazzio_bus, jazzio_conf->jc_dmatlbreg); 137 138 /* Create bus_dma_tag */ 139 jazz_bus_dma_tag_init(&sc->sc_dmat); 140 141 /* Try to configure each jazzio attached device */ 142 for (i = 0; sc->sc_devs[i].ps_ca.ca_name != NULL; i++) { 143 144 ja.ja_name = sc->sc_devs[i].ps_ca.ca_name; 145 ja.ja_bust = &jazzio_bus; 146 ja.ja_dmat = &sc->sc_dmat; 147 ja.ja_addr = (bus_addr_t)sc->sc_devs[i].ps_base; 148 ja.ja_intr = sc->sc_devs[i].ps_ca.ca_slot; 149 ja.ja_dma = 0; 150 151 /* Tell the autoconfig machinery we've found the hardware. */ 152 config_found(self, &ja, jazzioprint); 153 } 154 } 155 156 static int 157 jazzioprint(void *aux, const char *pnp) 158 { 159 struct jazzio_attach_args *ja = aux; 160 161 if (pnp) 162 aprint_normal("%s at %s", ja->ja_name, pnp); 163 aprint_normal(" addr 0x%lx", ja->ja_addr); 164 if (ja->ja_intr != -1) 165 aprint_normal(" intr %d", ja->ja_intr); 166 return UNCONF; 167 } 168 169 void 170 jazzio_intr_establish(int intr, intr_handler_t handler, void *val) 171 { 172 struct jazzio_intrhand *jirp; 173 174 if (intr < 0 || intr >= __arraycount(jazzio_intrtab)) 175 panic("jazzio intr %d out of range", intr); 176 jirp = &jazzio_intrtab[intr]; 177 if (jirp->ih_func != jazzio_no_handler) 178 panic("jazzio intr %d already set to %p", intr, jirp->ih_func); 179 180 jazzio_int_mask |= 1 << intr; 181 jirp->ih_func = handler; 182 jirp->ih_arg = val; 183 snprintf(jirp->ih_evname, sizeof(jirp->ih_evname), "intr %d", intr); 184 evcnt_attach_dynamic(&jirp->ih_evcnt, EVCNT_TYPE_INTR, 185 NULL, "jazzio", jirp->ih_evname); 186 187 (*jazzio_conf->jc_set_iointr_mask)(jazzio_int_mask); 188 } 189 190 void 191 jazzio_intr_disestablish(int intr) 192 { 193 struct jazzio_intrhand *jirp; 194 195 jazzio_int_mask &= ~(1 << intr); 196 jirp = &jazzio_intrtab[intr]; 197 jirp->ih_func = jazzio_no_handler; 198 jirp->ih_arg = NULL; 199 evcnt_detach(&jirp->ih_evcnt); 200 201 (*jazzio_conf->jc_set_iointr_mask)(jazzio_int_mask); 202 } 203 204 static int 205 jazzio_no_handler(void *arg) 206 { 207 208 panic("uncaught jazzio interrupt with arg %p", arg); 209 } 210 211 /* 212 * Handle jazz i/o interrupt. 213 */ 214 uint32_t 215 jazzio_intr(uint32_t mask, struct clockframe *cf) 216 { 217 unsigned int vector; 218 struct jazzio_intrhand *jirp; 219 220 while ((vector = inb(jazzio_conf->jc_iointr_status_reg)) != 0) { 221 jirp = &jazzio_intrtab[(vector >> 2) - 1]; 222 (*jirp->ih_func)(jirp->ih_arg); 223 jirp->ih_evcnt.ev_count++; 224 } 225 return MIPS_INT_MASK_1; 226 } 227 228 void 229 jazzio_reset(void) 230 { 231 232 arc_sysreset(PICA_SYS_KBD, JAZZIO_KBCMDP); 233 } 234