crime.c revision 1.32
1 /* $NetBSD: crime.c,v 1.32 2008/08/07 14:44:29 tsutsui Exp $ */ 2 3 /* 4 * Copyright (c) 2004 Christopher SEKIYA 5 * Copyright (c) 2000 Soren S. Jorvang 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed for the 19 * NetBSD Project. See http://www.NetBSD.org/ for 20 * information about NetBSD. 21 * 4. The name of the author may not be used to endorse or promote products 22 * derived from this software without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 26 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 27 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 29 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 33 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 /* 37 * O2 CRIME 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: crime.c,v 1.32 2008/08/07 14:44:29 tsutsui Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/device.h> 45 #include <sys/systm.h> 46 #include <sys/kernel.h> 47 #include <sys/cpu.h> 48 49 #include <machine/locore.h> 50 #include <machine/autoconf.h> 51 #include <machine/bus.h> 52 #include <machine/intr.h> 53 #include <machine/machtype.h> 54 #include <machine/sysconf.h> 55 56 #include <sgimips/dev/crimevar.h> 57 #include <sgimips/dev/crimereg.h> 58 #include <sgimips/mace/macevar.h> 59 60 #include "locators.h" 61 62 #define DISABLE_CRIME_WATCHDOG 63 64 static int crime_match(struct device *, struct cfdata *, void *); 65 static void crime_attach(struct device *, struct device *, void *); 66 void crime_bus_reset(void); 67 void crime_watchdog_reset(void); 68 void crime_watchdog_disable(void); 69 void crime_intr(u_int32_t, u_int32_t, u_int32_t, u_int32_t); 70 void *crime_intr_establish(int, int, int (*)(void *), void *); 71 extern void mace_intr(int); /* XXX */ 72 73 static bus_space_tag_t crm_iot; 74 static bus_space_handle_t crm_ioh; 75 76 CFATTACH_DECL(crime, sizeof(struct crime_softc), 77 crime_match, crime_attach, NULL, NULL); 78 79 #define CRIME_NINTR 32 /* XXX */ 80 81 struct { 82 int (*func)(void *); 83 void *arg; 84 } crime[CRIME_NINTR]; 85 86 static int 87 crime_match(struct device *parent, struct cfdata *match, void *aux) 88 { 89 90 /* 91 * The CRIME is in the O2. 92 */ 93 if (mach_type == MACH_SGI_IP32) 94 return (1); 95 96 return (0); 97 } 98 99 static void 100 crime_attach(struct device *parent, struct device *self, void *aux) 101 { 102 struct mainbus_attach_args *ma = aux; 103 u_int64_t crm_id; 104 u_int64_t baseline, endline; 105 u_int32_t startctr, endctr, cps; 106 107 crm_iot = SGIMIPS_BUS_SPACE_CRIME; 108 109 if (bus_space_map(crm_iot, ma->ma_addr, 0 /* XXX */, 110 BUS_SPACE_MAP_LINEAR, &crm_ioh)) 111 panic("crime_attach: can't map I/O space"); 112 113 crm_id = bus_space_read_8(crm_iot, crm_ioh, CRIME_REV); 114 115 aprint_naive(": system ASIC"); 116 117 switch ((crm_id & CRIME_ID_IDBITS) >> CRIME_ID_IDSHIFT) { 118 case 0x0b: 119 aprint_normal(": rev 1.5"); 120 break; 121 122 case 0x0a: 123 if ((crm_id >> 32) == 0) 124 aprint_normal(": rev 1.1"); 125 else if ((crm_id >> 32) == 1) 126 aprint_normal(": rev 1.3"); 127 else 128 aprint_normal(": rev 1.4"); 129 break; 130 131 case 0x00: 132 aprint_normal(": Petty CRIME"); 133 break; 134 135 default: 136 aprint_normal(": Unknown CRIME"); 137 break; 138 } 139 140 aprint_normal(" (CRIME_ID: %llx)\n", crm_id); 141 142 /* reset CRIME CPU & memory error registers */ 143 crime_bus_reset(); 144 145 crime_watchdog_disable(); 146 147 #define CRIME_TIMER_FREQ 66666666 /* crime clock is 66.7MHz */ 148 149 baseline = bus_space_read_8(crm_iot, crm_ioh, CRIME_TIME) 150 & CRIME_TIME_MASK; 151 startctr = mips3_cp0_count_read(); 152 153 /* read both cp0 and crime counters for 100ms */ 154 do { 155 endline = bus_space_read_8(crm_iot, crm_ioh, CRIME_TIME) 156 & CRIME_TIME_MASK; 157 endctr = mips3_cp0_count_read(); 158 } while (endline - baseline < (CRIME_TIMER_FREQ / 10)); 159 160 cps = (endctr - startctr) * 10; 161 curcpu()->ci_cpu_freq = cps; 162 if (mips_cpu_flags & CPU_MIPS_DOUBLE_COUNT) 163 curcpu()->ci_cpu_freq *= 2; 164 curcpu()->ci_cycles_per_hz = (cps + (hz / 2)) / hz; 165 curcpu()->ci_divisor_delay = (cps + (1000000 / 2)) / 1000000; 166 167 /* Turn on memory error and crime error interrupts. 168 All others turned on as devices are registered. */ 169 bus_space_write_8(crm_iot, crm_ioh, CRIME_INTMASK, 170 CRIME_INT_MEMERR | 171 CRIME_INT_CRMERR | 172 CRIME_INT_VICE | 173 CRIME_INT_VID_OUT | 174 CRIME_INT_VID_IN2 | 175 CRIME_INT_VID_IN1); 176 bus_space_write_8(crm_iot, crm_ioh, CRIME_INTSTAT, 0); 177 bus_space_write_8(crm_iot, crm_ioh, CRIME_SOFTINT, 0); 178 bus_space_write_8(crm_iot, crm_ioh, CRIME_HARDINT, 0); 179 180 platform.bus_reset = crime_bus_reset; 181 platform.watchdog_reset = crime_watchdog_reset; 182 platform.watchdog_disable = crime_watchdog_disable; 183 platform.watchdog_enable = crime_watchdog_reset; 184 platform.intr_establish = crime_intr_establish; 185 platform.intr0 = crime_intr; 186 } 187 188 /* 189 * XXX: sharing interrupts? 190 */ 191 192 void * 193 crime_intr_establish(int irq, int level, int (*func)(void *), void *arg) 194 { 195 if (irq < 16) 196 return mace_intr_establish(irq, level, func, arg); 197 198 if (crime[irq].func != NULL) 199 return NULL; /* panic("Cannot share CRIME interrupts!"); */ 200 201 crime[irq].func = func; 202 crime[irq].arg = arg; 203 204 crime_intr_mask(irq); 205 206 return (void *)&crime[irq]; 207 } 208 209 void 210 crime_intr(u_int32_t status, u_int32_t cause, u_int32_t pc, u_int32_t ipending) 211 { 212 u_int64_t crime_intmask; 213 u_int64_t crime_intstat; 214 u_int64_t crime_ipending; 215 int i; 216 217 crime_intmask = bus_space_read_8(crm_iot, crm_ioh, CRIME_INTMASK); 218 crime_intstat = bus_space_read_8(crm_iot, crm_ioh, CRIME_INTSTAT); 219 crime_ipending = (crime_intstat & crime_intmask); 220 221 if (crime_ipending & 0xffff) 222 mace_intr(crime_ipending & 0xffff); 223 224 if (crime_ipending & 0xffff0000) { 225 /* 226 * CRIME interrupts for CPU and memory errors 227 */ 228 if (crime_ipending & CRIME_INT_MEMERR) { 229 u_int64_t address = 230 bus_space_read_8(crm_iot, crm_ioh, CRIME_MEM_ERROR_ADDR); 231 u_int64_t status1 = 232 bus_space_read_8(crm_iot, crm_ioh, CRIME_MEM_ERROR_STAT); 233 printf("crime: memory error address %llx" 234 " status %llx\n", address << 2, status1); 235 crime_bus_reset(); 236 } 237 238 if (crime_ipending & CRIME_INT_CRMERR) { 239 u_int64_t stat = 240 bus_space_read_8(crm_iot, crm_ioh, CRIME_CPU_ERROR_STAT); 241 printf("crime: cpu error %llx at" 242 " address %llx\n", stat, 243 bus_space_read_8(crm_iot, crm_ioh, CRIME_CPU_ERROR_ADDR)); 244 crime_bus_reset(); 245 } 246 } 247 248 crime_ipending &= ~0xffff; 249 250 if (crime_ipending) 251 for (i = 16; i < CRIME_NINTR; i++) { 252 if ((crime_ipending & (1 << i)) && crime[i].func != NULL) 253 (*crime[i].func)(crime[i].arg); 254 } 255 } 256 257 void 258 crime_intr_mask(unsigned int intr) 259 { 260 u_int64_t mask; 261 262 mask = bus_space_read_8(crm_iot, crm_ioh, CRIME_INTMASK); 263 mask |= (1 << intr); 264 bus_space_write_8(crm_iot, crm_ioh, CRIME_INTMASK, mask); 265 } 266 267 void 268 crime_intr_unmask(unsigned int intr) 269 { 270 u_int64_t mask; 271 272 mask = bus_space_read_8(crm_iot, crm_ioh, CRIME_INTMASK); 273 mask &= ~(1 << intr); 274 bus_space_write_8(crm_iot, crm_ioh, CRIME_INTMASK, mask); 275 } 276 277 void 278 crime_bus_reset(void) 279 { 280 bus_space_write_8(crm_iot, crm_ioh, CRIME_CPU_ERROR_STAT, 0); 281 bus_space_write_8(crm_iot, crm_ioh, CRIME_MEM_ERROR_STAT, 0); 282 } 283 284 void 285 crime_watchdog_reset(void) 286 { 287 #ifdef DISABLE_CRIME_WATCHDOG 288 bus_space_write_8(crm_iot, crm_ioh, CRIME_WATCHDOG, 0); 289 #else 290 /* enable watchdog timer, clear it */ 291 bus_space_write_8(crm_iot, crm_ioh, 292 CRIME_CONTROL, CRIME_CONTROL_DOG_ENABLE); 293 bus_space_write_8(crm_iot, crm_ioh, CRIME_WATCHDOG, 0); 294 #endif 295 } 296 297 void 298 crime_watchdog_disable(void) 299 { 300 u_int64_t reg; 301 302 bus_space_write_8(crm_iot, crm_ioh, CRIME_WATCHDOG, 0); 303 reg = bus_space_read_8(crm_iot, crm_ioh, CRIME_CONTROL) 304 & ~CRIME_CONTROL_DOG_ENABLE; 305 bus_space_write_8(crm_iot, crm_ioh, CRIME_CONTROL, reg); 306 } 307 308 void 309 crime_reboot() 310 { 311 312 bus_space_write_8(crm_iot, crm_ioh, CRIME_CONTROL, 313 CRIME_CONTROL_HARD_RESET); 314 while(1); 315 } 316
Indexes created Sun Oct 19 02:09:48 GMT 2025