arch/sparc/kernel/leon_kernel.c

   1 /*
   2  * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
   3  * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/errno.h>
   8 #include <linux/mutex.h>
   9 #include <linux/of.h>
  10 #include <linux/of_platform.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/of_device.h>
  13 #include <linux/clocksource.h>
  14 #include <linux/clockchips.h>
  15
  16 #include <asm/oplib.h>
  17 #include <asm/timer.h>
  18 #include <asm/prom.h>
  19 #include <asm/leon.h>
  20 #include <asm/leon_amba.h>
  21 #include <asm/traps.h>
  22 #include <asm/cacheflush.h>
  23 #include <asm/smp.h>
  24 #include <asm/setup.h>
  25
  26 #include "prom.h"
  27 #include "irq.h"
  28
  29 struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address */
  30 struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address */
  31
  32 int leondebug_irq_disable;
  33 int leon_debug_irqout;
  34 static int dummy_master_l10_counter;
  35 unsigned long amba_system_id;
  36 static DEFINE_SPINLOCK(leon_irq_lock);
  37
  38 unsigned long leon3_gptimer_irq; /* interrupt controller irq number */
  39 unsigned long leon3_gptimer_idx; /* Timer Index (0..6) within Timer Core */
  40 int leon3_ticker_irq; /* Timer ticker IRQ */
  41 unsigned int sparc_leon_eirq;
  42 #define LEON_IMASK(cpu) (&leon3_irqctrl_regs->mask[cpu])
  43 #define LEON_IACK (&leon3_irqctrl_regs->iclear)
  44 #define LEON_DO_ACK_HW 1
  45
  46 /* Return the last ACKed IRQ by the Extended IRQ controller. It has already
  47  * been (automatically) ACKed when the CPU takes the trap.
  48  */
  49 static inline unsigned int leon_eirq_get(int cpu)
  50 {
  51         return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f;
  52 }
  53
  54 /* Handle one or multiple IRQs from the extended interrupt controller */
  55 static void leon_handle_ext_irq(unsigned int irq, struct irq_desc *desc)
  56 {
  57         unsigned int eirq;
  58         int cpu = sparc_leon3_cpuid();
  59
  60         eirq = leon_eirq_get(cpu);
  61         if ((eirq & 0x10) && irq_map[eirq]->irq) /* bit4 tells if IRQ happened */
  62                 generic_handle_irq(irq_map[eirq]->irq);
  63 }
  64
  65 /* The extended IRQ controller has been found, this function registers it */
  66 void leon_eirq_setup(unsigned int eirq)
  67 {
  68         unsigned long mask, oldmask;
  69         unsigned int veirq;
  70
  71         if (eirq < 1 || eirq > 0xf) {
  72                 printk(KERN_ERR "LEON EXT IRQ NUMBER BAD: %d\n", eirq);
  73                 return;
  74         }
  75
  76         veirq = leon_build_device_irq(eirq, leon_handle_ext_irq, "extirq", 0);
  77
  78         /*
  79          * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ
  80          * controller have a mask-bit of their own, so this is safe.
  81          */
  82         irq_link(veirq);
  83         mask = 1 << eirq;
  84         oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(boot_cpu_id));
  85         LEON3_BYPASS_STORE_PA(LEON_IMASK(boot_cpu_id), (oldmask | mask));
  86         sparc_leon_eirq = eirq;
  87 }
  88
  89 static inline unsigned long get_irqmask(unsigned int irq)
  90 {
  91         unsigned long mask;
  92
  93         if (!irq || ((irq > 0xf) && !sparc_leon_eirq)
  94             || ((irq > 0x1f) && sparc_leon_eirq)) {
  95                 printk(KERN_ERR
  96                        "leon_get_irqmask: false irq number: %d\n", irq);
  97                 mask = 0;
  98         } else {
  99                 mask = LEON_HARD_INT(irq);
 100         }
 101         return mask;
 102 }
 103
 104 #ifdef CONFIG_SMP
 105 static int irq_choose_cpu(const struct cpumask *affinity)
 106 {
 107         cpumask_t mask;
 108
 109         cpumask_and(&mask, cpu_online_mask, affinity);
 110         if (cpumask_equal(&mask, cpu_online_mask) || cpumask_empty(&mask))
 111                 return boot_cpu_id;
 112         else
 113                 return cpumask_first(&mask);
 114 }
 115 #else
 116 #define irq_choose_cpu(affinity) boot_cpu_id
 117 #endif
 118
 119 static int leon_set_affinity(struct irq_data *data, const struct cpumask *dest,
 120                              bool force)
 121 {
 122         unsigned long mask, oldmask, flags;
 123         int oldcpu, newcpu;
 124
 125         mask = (unsigned long)data->chip_data;
 126         oldcpu = irq_choose_cpu(data->affinity);
 127         newcpu = irq_choose_cpu(dest);
 128
 129         if (oldcpu == newcpu)
 130                 goto out;
 131
 132         /* unmask on old CPU first before enabling on the selected CPU */
 133         spin_lock_irqsave(&leon_irq_lock, flags);
 134         oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(oldcpu));
 135         LEON3_BYPASS_STORE_PA(LEON_IMASK(oldcpu), (oldmask & ~mask));
 136         oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(newcpu));
 137         LEON3_BYPASS_STORE_PA(LEON_IMASK(newcpu), (oldmask | mask));
 138         spin_unlock_irqrestore(&leon_irq_lock, flags);
 139 out:
 140         return IRQ_SET_MASK_OK;
 141 }
 142
 143 static void leon_unmask_irq(struct irq_data *data)
 144 {
 145         unsigned long mask, oldmask, flags;
 146         int cpu;
 147
 148         mask = (unsigned long)data->chip_data;
 149         cpu = irq_choose_cpu(data->affinity);
 150         spin_lock_irqsave(&leon_irq_lock, flags);
 151         oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
 152         LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask | mask));
 153         spin_unlock_irqrestore(&leon_irq_lock, flags);
 154 }
 155
 156 static void leon_mask_irq(struct irq_data *data)
 157 {
 158         unsigned long mask, oldmask, flags;
 159         int cpu;
 160
 161         mask = (unsigned long)data->chip_data;
 162         cpu = irq_choose_cpu(data->affinity);
 163         spin_lock_irqsave(&leon_irq_lock, flags);
 164         oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
 165         LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask & ~mask));
 166         spin_unlock_irqrestore(&leon_irq_lock, flags);
 167 }
 168
 169 static unsigned int leon_startup_irq(struct irq_data *data)
 170 {
 171         irq_link(data->irq);
 172         leon_unmask_irq(data);
 173         return 0;
 174 }
 175
 176 static void leon_shutdown_irq(struct irq_data *data)
 177 {
 178         leon_mask_irq(data);
 179         irq_unlink(data->irq);
 180 }
 181
 182 /* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */
 183 static void leon_eoi_irq(struct irq_data *data)
 184 {
 185         unsigned long mask = (unsigned long)data->chip_data;
 186
 187         if (mask & LEON_DO_ACK_HW)
 188                 LEON3_BYPASS_STORE_PA(LEON_IACK, mask & ~LEON_DO_ACK_HW);
 189 }
 190
 191 static struct irq_chip leon_irq = {
 192         .name                   = "leon",
 193         .irq_startup            = leon_startup_irq,
 194         .irq_shutdown           = leon_shutdown_irq,
 195         .irq_mask               = leon_mask_irq,
 196         .irq_unmask             = leon_unmask_irq,
 197         .irq_eoi                = leon_eoi_irq,
 198         .irq_set_affinity       = leon_set_affinity,
 199 };
 200
 201 /*
 202  * Build a LEON IRQ for the edge triggered LEON IRQ controller:
 203  *  Edge (normal) IRQ           - handle_simple_irq, ack=DONT-CARE, never ack
 204  *  Level IRQ (PCI|Level-GPIO)  - handle_fasteoi_irq, ack=1, ack after ISR
 205  *  Per-CPU Edge                - handle_percpu_irq, ack=0
 206  */
 207 unsigned int leon_build_device_irq(unsigned int real_irq,
 208                                     irq_flow_handler_t flow_handler,
 209                                     const char *name, int do_ack)
 210 {
 211         unsigned int irq;
 212         unsigned long mask;
 213
 214         irq = 0;
 215         mask = get_irqmask(real_irq);
 216         if (mask == 0)
 217                 goto out;
 218
 219         irq = irq_alloc(real_irq, real_irq);
 220         if (irq == 0)
 221                 goto out;
 222
 223         if (do_ack)
 224                 mask |= LEON_DO_ACK_HW;
 225
 226         irq_set_chip_and_handler_name(irq, &leon_irq,
 227                                       flow_handler, name);
 228         irq_set_chip_data(irq, (void *)mask);
 229
 230 out:
 231         return irq;
 232 }
 233
 234 static unsigned int _leon_build_device_irq(struct platform_device *op,
 235                                            unsigned int real_irq)
 236 {
 237         return leon_build_device_irq(real_irq, handle_simple_irq, "edge", 0);
 238 }
 239
 240 void leon_update_virq_handling(unsigned int virq,
 241                               irq_flow_handler_t flow_handler,
 242                               const char *name, int do_ack)
 243 {
 244         unsigned long mask = (unsigned long)irq_get_chip_data(virq);
 245
 246         mask &= ~LEON_DO_ACK_HW;
 247         if (do_ack)
 248                 mask |= LEON_DO_ACK_HW;
 249
 250         irq_set_chip_and_handler_name(virq, &leon_irq,
 251                                       flow_handler, name);
 252         irq_set_chip_data(virq, (void *)mask);
 253 }
 254
 255 static u32 leon_cycles_offset(void)
 256 {
 257         u32 rld, val, off;
 258         rld = LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld);
 259         val = LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val);
 260         off = rld - val;
 261         return rld - val;
 262 }
 263
 264 #ifdef CONFIG_SMP
 265
 266 /* smp clockevent irq */
 267 irqreturn_t leon_percpu_timer_ce_interrupt(int irq, void *unused)
 268 {
 269         struct clock_event_device *ce;
 270         int cpu = smp_processor_id();
 271
 272         leon_clear_profile_irq(cpu);
 273
 274         ce = &per_cpu(sparc32_clockevent, cpu);
 275
 276         irq_enter();
 277         if (ce->event_handler)
 278                 ce->event_handler(ce);
 279         irq_exit();
 280
 281         return IRQ_HANDLED;
 282 }
 283
 284 #endif /* CONFIG_SMP */
 285
 286 void __init leon_init_timers(void)
 287 {
 288         int irq, eirq;
 289         struct device_node *rootnp, *np, *nnp;
 290         struct property *pp;
 291         int len;
 292         int icsel;
 293         int ampopts;
 294         int err;
 295
 296         sparc_config.get_cycles_offset = leon_cycles_offset;
 297         sparc_config.cs_period = 1000000 / HZ;
 298         sparc_config.features |= FEAT_L10_CLOCKSOURCE;
 299
 300 #ifndef CONFIG_SMP
 301         sparc_config.features |= FEAT_L10_CLOCKEVENT;
 302 #endif
 303
 304         leondebug_irq_disable = 0;
 305         leon_debug_irqout = 0;
 306         master_l10_counter = (unsigned int *)&dummy_master_l10_counter;
 307         dummy_master_l10_counter = 0;
 308
 309         rootnp = of_find_node_by_path("/ambapp0");
 310         if (!rootnp)
 311                 goto bad;
 312
 313         /* Find System ID: GRLIB build ID and optional CHIP ID */
 314         pp = of_find_property(rootnp, "systemid", &len);
 315         if (pp)
 316                 amba_system_id = *(unsigned long *)pp->value;
 317
 318         /* Find IRQMP IRQ Controller Registers base adr otherwise bail out */
 319         np = of_find_node_by_name(rootnp, "GAISLER_IRQMP");
 320         if (!np) {
 321                 np = of_find_node_by_name(rootnp, "01_00d");
 322                 if (!np)
 323                         goto bad;
 324         }
 325         pp = of_find_property(np, "reg", &len);
 326         if (!pp)
 327                 goto bad;
 328         leon3_irqctrl_regs = *(struct leon3_irqctrl_regs_map **)pp->value;
 329
 330         /* Find GPTIMER Timer Registers base address otherwise bail out. */
 331         nnp = rootnp;
 332         do {
 333                 np = of_find_node_by_name(nnp, "GAISLER_GPTIMER");
 334                 if (!np) {
 335                         np = of_find_node_by_name(nnp, "01_011");
 336                         if (!np)
 337                                 goto bad;
 338                 }
 339
 340                 ampopts = 0;
 341                 pp = of_find_property(np, "ampopts", &len);
 342                 if (pp) {
 343                         ampopts = *(int *)pp->value;
 344                         if (ampopts == 0) {
 345                                 /* Skip this instance, resource already
 346                                  * allocated by other OS */
 347                                 nnp = np;
 348                                 continue;
 349                         }
 350                 }
 351
 352                 /* Select Timer-Instance on Timer Core. Default is zero */
 353                 leon3_gptimer_idx = ampopts & 0x7;
 354
 355                 pp = of_find_property(np, "reg", &len);
 356                 if (pp)
 357                         leon3_gptimer_regs = *(struct leon3_gptimer_regs_map **)
 358                                                 pp->value;
 359                 pp = of_find_property(np, "interrupts", &len);
 360                 if (pp)
 361                         leon3_gptimer_irq = *(unsigned int *)pp->value;
 362         } while (0);
 363
 364         if (!(leon3_gptimer_regs && leon3_irqctrl_regs && leon3_gptimer_irq))
 365                 goto bad;
 366
 367         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val, 0);
 368         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld,
 369                                 (((1000000 / HZ) - 1)));
 370         LEON3_BYPASS_STORE_PA(
 371                         &leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 0);
 372
 373 #ifdef CONFIG_SMP
 374         leon3_ticker_irq = leon3_gptimer_irq + 1 + leon3_gptimer_idx;
 375
 376         if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
 377               (1<<LEON3_GPTIMER_SEPIRQ))) {
 378                 printk(KERN_ERR "timer not configured with separate irqs\n");
 379                 BUG();
 380         }
 381
 382         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].val,
 383                                 0);
 384         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].rld,
 385                                 (((1000000/HZ) - 1)));
 386         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
 387                                 0);
 388 #endif
 389
 390         /*
 391          * The IRQ controller may (if implemented) consist of multiple
 392          * IRQ controllers, each mapped on a 4Kb boundary.
 393          * Each CPU may be routed to different IRQCTRLs, however
 394          * we assume that all CPUs (in SMP system) is routed to the
 395          * same IRQ Controller, and for non-SMP only one IRQCTRL is
 396          * accessed anyway.
 397          * In AMP systems, Linux must run on CPU0 for the time being.
 398          */
 399         icsel = LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->icsel[boot_cpu_id/8]);
 400         icsel = (icsel >> ((7 - (boot_cpu_id&0x7)) * 4)) & 0xf;
 401         leon3_irqctrl_regs += icsel;
 402
 403         /* Mask all IRQs on boot-cpu IRQ controller */
 404         LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->mask[boot_cpu_id], 0);
 405
 406         /* Probe extended IRQ controller */
 407         eirq = (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->mpstatus)
 408                 >> 16) & 0xf;
 409         if (eirq != 0)
 410                 leon_eirq_setup(eirq);
 411
 412         irq = _leon_build_device_irq(NULL, leon3_gptimer_irq+leon3_gptimer_idx);
 413         err = request_irq(irq, timer_interrupt, IRQF_TIMER, "timer", NULL);
 414         if (err) {
 415                 printk(KERN_ERR "unable to attach timer IRQ%d\n", irq);
 416                 prom_halt();
 417         }
 418
 419 #ifdef CONFIG_SMP
 420         {
 421                 unsigned long flags;
 422
 423                 /*
 424                  * In SMP, sun4m adds a IPI handler to IRQ trap handler that
 425                  * LEON never must take, sun4d and LEON overwrites the branch
 426                  * with a NOP.
 427                  */
 428                 local_irq_save(flags);
 429                 patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
 430                 local_flush_cache_all();
 431                 local_irq_restore(flags);
 432         }
 433 #endif
 434
 435         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl,
 436                               LEON3_GPTIMER_EN |
 437                               LEON3_GPTIMER_RL |
 438                               LEON3_GPTIMER_LD |
 439                               LEON3_GPTIMER_IRQEN);
 440
 441 #ifdef CONFIG_SMP
 442         /* Install per-cpu IRQ handler for broadcasted ticker */
 443         irq = leon_build_device_irq(leon3_ticker_irq, handle_percpu_irq,
 444                                     "per-cpu", 0);
 445         err = request_irq(irq, leon_percpu_timer_ce_interrupt,
 446                           IRQF_PERCPU | IRQF_TIMER, "ticker",
 447                           NULL);
 448         if (err) {
 449                 printk(KERN_ERR "unable to attach ticker IRQ%d\n", irq);
 450                 prom_halt();
 451         }
 452
 453         LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
 454                               LEON3_GPTIMER_EN |
 455                               LEON3_GPTIMER_RL |
 456                               LEON3_GPTIMER_LD |
 457                               LEON3_GPTIMER_IRQEN);
 458 #endif
 459         return;
 460 bad:
 461         printk(KERN_ERR "No Timer/irqctrl found\n");
 462         BUG();
 463         return;
 464 }
 465
 466 void leon_clear_clock_irq(void)
 467 {
 468 }
 469
 470 void leon_load_profile_irq(int cpu, unsigned int limit)
 471 {
 472 }
 473
 474 void __init leon_trans_init(struct device_node *dp)
 475 {
 476         if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) {
 477                 struct property *p;
 478                 p = of_find_property(dp, "mid", (void *)0);
 479                 if (p) {
 480                         int mid;
 481                         dp->name = prom_early_alloc(5 + 1);
 482                         memcpy(&mid, p->value, p->length);
 483                         sprintf((char *)dp->name, "cpu%.2d", mid);
 484                 }
 485         }
 486 }
 487
 488 void __initdata (*prom_amba_init)(struct device_node *dp, struct device_node ***nextp) = 0;
 489
 490 void __init leon_node_init(struct device_node *dp, struct device_node ***nextp)
 491 {
 492         if (prom_amba_init &&
 493             strcmp(dp->type, "ambapp") == 0 &&
 494             strcmp(dp->name, "ambapp0") == 0) {
 495                 prom_amba_init(dp, nextp);
 496         }
 497 }
 498
 499 #ifdef CONFIG_SMP
 500
 501 void leon_set_cpu_int(int cpu, int level)
 502 {
 503         unsigned long mask;
 504         mask = get_irqmask(level);
 505         LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask);
 506 }
 507
 508 static void leon_clear_ipi(int cpu, int level)
 509 {
 510         unsigned long mask;
 511         mask = get_irqmask(level);
 512         LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask<<16);
 513 }
 514
 515 static void leon_set_udt(int cpu)
 516 {
 517 }
 518
 519 void leon_clear_profile_irq(int cpu)
 520 {
 521 }
 522
 523 void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu)
 524 {
 525         unsigned long mask, flags, *addr;
 526         mask = get_irqmask(irq_nr);
 527         spin_lock_irqsave(&leon_irq_lock, flags);
 528         addr = (unsigned long *)LEON_IMASK(cpu);
 529         LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | mask));
 530         spin_unlock_irqrestore(&leon_irq_lock, flags);
 531 }
 532
 533 #endif
 534
 535 void __init leon_init_IRQ(void)
 536 {
 537         sparc_config.init_timers      = leon_init_timers;
 538         sparc_config.build_device_irq = _leon_build_device_irq;
 539         sparc_config.clock_rate = 1000000;
 540
 541         BTFIXUPSET_CALL(clear_clock_irq, leon_clear_clock_irq,
 542                         BTFIXUPCALL_NORM);
 543         BTFIXUPSET_CALL(load_profile_irq, leon_load_profile_irq,
 544                         BTFIXUPCALL_NOP);
 545
 546 #ifdef CONFIG_SMP
 547         BTFIXUPSET_CALL(set_cpu_int, leon_set_cpu_int, BTFIXUPCALL_NORM);
 548         BTFIXUPSET_CALL(clear_cpu_int, leon_clear_ipi, BTFIXUPCALL_NORM);
 549         BTFIXUPSET_CALL(set_irq_udt, leon_set_udt, BTFIXUPCALL_NORM);
 550 #endif
 551
 552 }
 553
 554 void __init leon_init(void)
 555 {
 556         of_pdt_build_more = &leon_node_init;
 557 }