1 /* 2 * SuperH interrupt controller module 3 * 4 * Copyright (c) 2007 Magnus Damm 5 * Based on sh_timer.c and arm_timer.c by Paul Brook 6 * Copyright (c) 2005-2006 CodeSourcery. 7 * 8 * This code is licensed under the GPL. 9 */ 10 11 #include "qemu/osdep.h" 12 #include "qemu/log.h" 13 #include "cpu.h" 14 #include "hw/sh4/sh_intc.h" 15 #include "hw/irq.h" 16 #include "hw/sh4/sh.h" 17 #include "trace.h" 18 19 void sh_intc_toggle_source(struct intc_source *source, 20 int enable_adj, int assert_adj) 21 { 22 int enable_changed = 0; 23 int pending_changed = 0; 24 int old_pending; 25 26 if (source->enable_count == source->enable_max && enable_adj == -1) { 27 enable_changed = -1; 28 } 29 source->enable_count += enable_adj; 30 31 if (source->enable_count == source->enable_max) { 32 enable_changed = 1; 33 } 34 source->asserted += assert_adj; 35 36 old_pending = source->pending; 37 source->pending = source->asserted && 38 (source->enable_count == source->enable_max); 39 40 if (old_pending != source->pending) { 41 pending_changed = 1; 42 } 43 if (pending_changed) { 44 if (source->pending) { 45 source->parent->pending++; 46 if (source->parent->pending == 1) { 47 cpu_interrupt(first_cpu, CPU_INTERRUPT_HARD); 48 } 49 } else { 50 source->parent->pending--; 51 if (source->parent->pending == 0) { 52 cpu_reset_interrupt(first_cpu, CPU_INTERRUPT_HARD); 53 } 54 } 55 } 56 57 if (enable_changed || assert_adj || pending_changed) { 58 trace_sh_intc_sources(source->parent->pending, source->asserted, 59 source->enable_count, source->enable_max, 60 source->vect, source->asserted ? "asserted " : 61 assert_adj ? "deasserted" : "", 62 enable_changed == 1 ? "enabled " : 63 enable_changed == -1 ? "disabled " : "", 64 source->pending ? "pending" : ""); 65 } 66 } 67 68 static void sh_intc_set_irq(void *opaque, int n, int level) 69 { 70 struct intc_desc *desc = opaque; 71 struct intc_source *source = &desc->sources[n]; 72 73 if (level && !source->asserted) { 74 sh_intc_toggle_source(source, 0, 1); 75 } else if (!level && source->asserted) { 76 sh_intc_toggle_source(source, 0, -1); 77 } 78 } 79 80 int sh_intc_get_pending_vector(struct intc_desc *desc, int imask) 81 { 82 unsigned int i; 83 84 /* slow: use a linked lists of pending sources instead */ 85 /* wrong: take interrupt priority into account (one list per priority) */ 86 87 if (imask == 0x0f) { 88 return -1; /* FIXME, update code to include priority per source */ 89 } 90 91 for (i = 0; i < desc->nr_sources; i++) { 92 struct intc_source *source = desc->sources + i; 93 94 if (source->pending) { 95 trace_sh_intc_pending(desc->pending, source->vect); 96 return source->vect; 97 } 98 } 99 100 abort(); 101 } 102 103 typedef enum { 104 INTC_MODE_NONE, 105 INTC_MODE_DUAL_SET, 106 INTC_MODE_DUAL_CLR, 107 INTC_MODE_ENABLE_REG, 108 INTC_MODE_MASK_REG, 109 } SHIntCMode; 110 #define INTC_MODE_IS_PRIO 0x80 111 112 static SHIntCMode sh_intc_mode(unsigned long address, unsigned long set_reg, 113 unsigned long clr_reg) 114 { 115 if (address != A7ADDR(set_reg) && address != A7ADDR(clr_reg)) { 116 return INTC_MODE_NONE; 117 } 118 if (set_reg && clr_reg) { 119 return address == A7ADDR(set_reg) ? 120 INTC_MODE_DUAL_SET : INTC_MODE_DUAL_CLR; 121 } 122 return set_reg ? INTC_MODE_ENABLE_REG : INTC_MODE_MASK_REG; 123 } 124 125 static void sh_intc_locate(struct intc_desc *desc, 126 unsigned long address, 127 unsigned long **datap, 128 intc_enum **enums, 129 unsigned int *first, 130 unsigned int *width, 131 unsigned int *modep) 132 { 133 SHIntCMode mode; 134 unsigned int i; 135 136 /* this is slow but works for now */ 137 138 if (desc->mask_regs) { 139 for (i = 0; i < desc->nr_mask_regs; i++) { 140 struct intc_mask_reg *mr = desc->mask_regs + i; 141 142 mode = sh_intc_mode(address, mr->set_reg, mr->clr_reg); 143 if (mode == INTC_MODE_NONE) { 144 continue; 145 } 146 *modep = mode; 147 *datap = &mr->value; 148 *enums = mr->enum_ids; 149 *first = mr->reg_width - 1; 150 *width = 1; 151 return; 152 } 153 } 154 155 if (desc->prio_regs) { 156 for (i = 0; i < desc->nr_prio_regs; i++) { 157 struct intc_prio_reg *pr = desc->prio_regs + i; 158 159 mode = sh_intc_mode(address, pr->set_reg, pr->clr_reg); 160 if (mode == INTC_MODE_NONE) { 161 continue; 162 } 163 *modep = mode | INTC_MODE_IS_PRIO; 164 *datap = &pr->value; 165 *enums = pr->enum_ids; 166 *first = pr->reg_width / pr->field_width - 1; 167 *width = pr->field_width; 168 return; 169 } 170 } 171 172 abort(); 173 } 174 175 static void sh_intc_toggle_mask(struct intc_desc *desc, intc_enum id, 176 int enable, int is_group) 177 { 178 struct intc_source *source = desc->sources + id; 179 180 if (!id) { 181 return; 182 } 183 if (!source->next_enum_id && (!source->enable_max || !source->vect)) { 184 qemu_log_mask(LOG_UNIMP, 185 "sh_intc: reserved interrupt source %d modified\n", id); 186 return; 187 } 188 189 if (source->vect) { 190 sh_intc_toggle_source(source, enable ? 1 : -1, 0); 191 } 192 193 if ((is_group || !source->vect) && source->next_enum_id) { 194 sh_intc_toggle_mask(desc, source->next_enum_id, enable, 1); 195 } 196 197 if (!source->vect) { 198 trace_sh_intc_set(id, !!enable); 199 } 200 } 201 202 static uint64_t sh_intc_read(void *opaque, hwaddr offset, 203 unsigned size) 204 { 205 struct intc_desc *desc = opaque; 206 intc_enum *enum_ids = NULL; 207 unsigned int first = 0; 208 unsigned int width = 0; 209 unsigned int mode = 0; 210 unsigned long *valuep; 211 212 sh_intc_locate(desc, (unsigned long)offset, &valuep, 213 &enum_ids, &first, &width, &mode); 214 trace_sh_intc_read(size, (uint64_t)offset, *valuep); 215 return *valuep; 216 } 217 218 static void sh_intc_write(void *opaque, hwaddr offset, 219 uint64_t value, unsigned size) 220 { 221 struct intc_desc *desc = opaque; 222 intc_enum *enum_ids = NULL; 223 unsigned int first = 0; 224 unsigned int width = 0; 225 unsigned int mode = 0; 226 unsigned int k; 227 unsigned long *valuep; 228 unsigned long mask; 229 230 trace_sh_intc_write(size, (uint64_t)offset, value); 231 sh_intc_locate(desc, (unsigned long)offset, &valuep, 232 &enum_ids, &first, &width, &mode); 233 switch (mode) { 234 case INTC_MODE_ENABLE_REG | INTC_MODE_IS_PRIO: 235 break; 236 case INTC_MODE_DUAL_SET: 237 value |= *valuep; 238 break; 239 case INTC_MODE_DUAL_CLR: 240 value = *valuep & ~value; 241 break; 242 default: 243 abort(); 244 } 245 246 for (k = 0; k <= first; k++) { 247 mask = (1 << width) - 1; 248 mask <<= (first - k) * width; 249 250 if ((*valuep & mask) == (value & mask)) { 251 continue; 252 } 253 sh_intc_toggle_mask(desc, enum_ids[k], value & mask, 0); 254 } 255 256 *valuep = value; 257 } 258 259 static const MemoryRegionOps sh_intc_ops = { 260 .read = sh_intc_read, 261 .write = sh_intc_write, 262 .endianness = DEVICE_NATIVE_ENDIAN, 263 }; 264 265 struct intc_source *sh_intc_source(struct intc_desc *desc, intc_enum id) 266 { 267 if (id) { 268 return desc->sources + id; 269 } 270 return NULL; 271 } 272 273 static void sh_intc_register_source(struct intc_desc *desc, 274 intc_enum source, 275 struct intc_group *groups, 276 int nr_groups) 277 { 278 unsigned int i, k; 279 struct intc_source *s; 280 281 if (desc->mask_regs) { 282 for (i = 0; i < desc->nr_mask_regs; i++) { 283 struct intc_mask_reg *mr = desc->mask_regs + i; 284 285 for (k = 0; k < ARRAY_SIZE(mr->enum_ids); k++) { 286 if (mr->enum_ids[k] != source) { 287 continue; 288 } 289 s = sh_intc_source(desc, mr->enum_ids[k]); 290 if (s) { 291 s->enable_max++; 292 } 293 } 294 } 295 } 296 297 if (desc->prio_regs) { 298 for (i = 0; i < desc->nr_prio_regs; i++) { 299 struct intc_prio_reg *pr = desc->prio_regs + i; 300 301 for (k = 0; k < ARRAY_SIZE(pr->enum_ids); k++) { 302 if (pr->enum_ids[k] != source) { 303 continue; 304 } 305 s = sh_intc_source(desc, pr->enum_ids[k]); 306 if (s) { 307 s->enable_max++; 308 } 309 } 310 } 311 } 312 313 if (groups) { 314 for (i = 0; i < nr_groups; i++) { 315 struct intc_group *gr = groups + i; 316 317 for (k = 0; k < ARRAY_SIZE(gr->enum_ids); k++) { 318 if (gr->enum_ids[k] != source) { 319 continue; 320 } 321 s = sh_intc_source(desc, gr->enum_ids[k]); 322 if (s) { 323 s->enable_max++; 324 } 325 } 326 } 327 } 328 329 } 330 331 void sh_intc_register_sources(struct intc_desc *desc, 332 struct intc_vect *vectors, 333 int nr_vectors, 334 struct intc_group *groups, 335 int nr_groups) 336 { 337 unsigned int i, k; 338 struct intc_source *s; 339 340 for (i = 0; i < nr_vectors; i++) { 341 struct intc_vect *vect = vectors + i; 342 343 sh_intc_register_source(desc, vect->enum_id, groups, nr_groups); 344 s = sh_intc_source(desc, vect->enum_id); 345 if (s) { 346 s->vect = vect->vect; 347 trace_sh_intc_register("source", vect->enum_id, s->vect, 348 s->enable_count, s->enable_max); 349 } 350 } 351 352 if (groups) { 353 for (i = 0; i < nr_groups; i++) { 354 struct intc_group *gr = groups + i; 355 356 s = sh_intc_source(desc, gr->enum_id); 357 s->next_enum_id = gr->enum_ids[0]; 358 359 for (k = 1; k < ARRAY_SIZE(gr->enum_ids); k++) { 360 if (!gr->enum_ids[k]) { 361 continue; 362 } 363 s = sh_intc_source(desc, gr->enum_ids[k - 1]); 364 s->next_enum_id = gr->enum_ids[k]; 365 } 366 trace_sh_intc_register("group", gr->enum_id, 0xffff, 367 s->enable_count, s->enable_max); 368 } 369 } 370 } 371 372 static unsigned int sh_intc_register(MemoryRegion *sysmem, 373 struct intc_desc *desc, 374 const unsigned long address, 375 const char *type, 376 const char *action, 377 const unsigned int index) 378 { 379 char name[60]; 380 MemoryRegion *iomem, *iomem_p4, *iomem_a7; 381 382 if (!address) { 383 return 0; 384 } 385 386 iomem = &desc->iomem; 387 iomem_p4 = desc->iomem_aliases + index; 388 iomem_a7 = iomem_p4 + 1; 389 390 snprintf(name, sizeof(name), "intc-%s-%s-%s", type, action, "p4"); 391 memory_region_init_alias(iomem_p4, NULL, name, iomem, A7ADDR(address), 4); 392 memory_region_add_subregion(sysmem, P4ADDR(address), iomem_p4); 393 394 snprintf(name, sizeof(name), "intc-%s-%s-%s", type, action, "a7"); 395 memory_region_init_alias(iomem_a7, NULL, name, iomem, A7ADDR(address), 4); 396 memory_region_add_subregion(sysmem, A7ADDR(address), iomem_a7); 397 398 /* used to increment aliases index */ 399 return 2; 400 } 401 402 int sh_intc_init(MemoryRegion *sysmem, 403 struct intc_desc *desc, 404 int nr_sources, 405 struct intc_mask_reg *mask_regs, 406 int nr_mask_regs, 407 struct intc_prio_reg *prio_regs, 408 int nr_prio_regs) 409 { 410 unsigned int i, j; 411 412 desc->pending = 0; 413 desc->nr_sources = nr_sources; 414 desc->mask_regs = mask_regs; 415 desc->nr_mask_regs = nr_mask_regs; 416 desc->prio_regs = prio_regs; 417 desc->nr_prio_regs = nr_prio_regs; 418 /* Allocate 4 MemoryRegions per register (2 actions * 2 aliases) */ 419 desc->iomem_aliases = g_new0(MemoryRegion, 420 (nr_mask_regs + nr_prio_regs) * 4); 421 422 j = 0; 423 i = sizeof(struct intc_source) * nr_sources; 424 desc->sources = g_malloc0(i); 425 426 for (i = 0; i < desc->nr_sources; i++) { 427 struct intc_source *source = desc->sources + i; 428 429 source->parent = desc; 430 } 431 432 desc->irqs = qemu_allocate_irqs(sh_intc_set_irq, desc, nr_sources); 433 memory_region_init_io(&desc->iomem, NULL, &sh_intc_ops, desc, "intc", 434 0x100000000ULL); 435 436 if (desc->mask_regs) { 437 for (i = 0; i < desc->nr_mask_regs; i++) { 438 struct intc_mask_reg *mr = desc->mask_regs + i; 439 440 j += sh_intc_register(sysmem, desc, mr->set_reg, "mask", "set", j); 441 j += sh_intc_register(sysmem, desc, mr->clr_reg, "mask", "clr", j); 442 } 443 } 444 445 if (desc->prio_regs) { 446 for (i = 0; i < desc->nr_prio_regs; i++) { 447 struct intc_prio_reg *pr = desc->prio_regs + i; 448 449 j += sh_intc_register(sysmem, desc, pr->set_reg, "prio", "set", j); 450 j += sh_intc_register(sysmem, desc, pr->clr_reg, "prio", "clr", j); 451 } 452 } 453 454 return 0; 455 } 456 457 /* 458 * Assert level <n> IRL interrupt. 459 * 0:deassert. 1:lowest priority,... 15:highest priority 460 */ 461 void sh_intc_set_irl(void *opaque, int n, int level) 462 { 463 struct intc_source *s = opaque; 464 int i, irl = level ^ 15; 465 for (i = 0; (s = sh_intc_source(s->parent, s->next_enum_id)); i++) { 466 if (i == irl) { 467 sh_intc_toggle_source(s, s->enable_count ? 0 : 1, 468 s->asserted ? 0 : 1); 469 } else if (s->asserted) { 470 sh_intc_toggle_source(s, 0, -1); 471 } 472 } 473 } 474