irq.c

   1 /*
   2         ppcskel - a Free Software replacement for the Nintendo/BroadOn IOS.
   3         IRQ support
   4
   5 Copyright (C) 2009              Bernhard Urban <lewurm@gmx.net>
   6 Copyright (C) 2009              Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
   7
   8 # This code is licensed to you under the terms of the GNU GPL, version 2;
   9 # see file COPYING or http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
  10 */
  11
  12 #include "irq.h"
  13 #include "hollywood.h"
  14 #include "ipc.h"
  15 #include "bootmii_ppc.h"
  16 #include "usb/host/host.h"
  17 #include "mini_ipc.h"
  18
  19 void show_frame_no(void);
  20
  21 void irq_initialize(void)
  22 {
  23         // clear flipper-pic (processor interface)
  24         write32(BW_PI_IRQMASK, 0);
  25         write32(BW_PI_IRQFLAG, 0xffffffff);
  26
  27         // clear hollywood-pic
  28         write32(HW_PPCIRQMASK, 0);
  29         write32(HW_PPCIRQFLAG, 0xffffffff);
  30
  31         /* ??? -- needed?!
  32          * in mini they do
  33          *
  34          * write32(HW_ARMIRQMASK+0x04, 0);
  35          * write32(HW_ARMIRQMASK+0x20, 0);
  36          *
  37          *
  38          * may it's here following; on the other
  39          * hand it's already done by mini...
  40          *
  41          * write32(HW_PPCIRQMASK+0x04+0x08, 0);
  42          * write32(HW_PPCIRQMASK+0x20+0x08, 0);
  43          */
  44
  45         _CPU_ISR_Enable()
  46 }
  47
  48 void irq_shutdown(void)
  49 {
  50         write32(HW_PPCIRQMASK, 0);
  51         write32(HW_PPCIRQFLAG, 0xffffffff);
  52         (void) irq_kill();
  53 }
  54
  55 void irq_handler(void)
  56 {
  57         u32 enabled = read32(BW_PI_IRQMASK);
  58         u32 flags = read32(BW_PI_IRQFLAG);
  59
  60         flags = flags & enabled;
  61
  62         if (flags & (1<<BW_PI_IRQ_RESET)) {
  63                 write32(BW_PI_IRQFLAG, 1<<BW_PI_IRQ_RESET);
  64                 boot2_run(1,2); //sysmenu
  65         }
  66
  67         if (flags & (1<<BW_PI_IRQ_HW)) { //HW-PIC IRQ
  68                 u32 hw_enabled = read32(HW_PPCIRQMASK);
  69                 u32 hw_flags = read32(HW_PPCIRQFLAG);
  70
  71                 //printf("In IRQ handler: 0x%08x 0x%08x 0x%08x\n", hw_enabled, hw_flags, hw_flags & hw_enabled);
  72
  73                 hw_flags = hw_flags & hw_enabled;
  74
  75                 if(hw_flags & IRQF_TIMER) {
  76                         write32(HW_PPCIRQFLAG, IRQF_TIMER);
  77                 }
  78                 if(hw_flags & IRQF_NAND) {
  79                         //              printf("IRQ: NAND\n");
  80                         // hmmm... should be done by mini?
  81                         write32(NAND_CMD, 0x7fffffff); // shut it up
  82                         write32(HW_PPCIRQFLAG, IRQF_NAND);
  83                         //nand_irq();
  84                 }
  85                 if(hw_flags & IRQF_GPIO1B) {
  86                         //              printf("IRQ: GPIO1B\n");
  87                         // hmmm... should be done by mini?
  88                         write32(HW_GPIO1BINTFLAG, 0xFFFFFF); // shut it up
  89                         write32(HW_PPCIRQFLAG, IRQF_GPIO1B);
  90                 }
  91                 if(hw_flags & IRQF_GPIO1) {
  92                         //              printf("IRQ: GPIO1\n");
  93                         // hmmm... should be done by mini?
  94                         write32(HW_GPIO1INTFLAG, 0xFFFFFF); // shut it up
  95                         write32(HW_PPCIRQFLAG, IRQF_GPIO1);
  96                 }
  97                 if(hw_flags & IRQF_RESET) {
  98                         //              printf("IRQ: RESET\n");
  99                         write32(HW_PPCIRQFLAG, IRQF_RESET);
 100                 }
 101                 if(hw_flags & IRQF_IPC) {
 102                         //printf("IRQ: IPC\n");
 103                         //not necessary here?
 104                         //ipc_irq();
 105                         write32(HW_PPCIRQFLAG, IRQF_IPC);
 106                 }
 107                 if(hw_flags & IRQF_AES) {
 108                         //              printf("IRQ: AES\n");
 109                         write32(HW_PPCIRQFLAG, IRQF_AES);
 110                 }
 111                 if (hw_flags & IRQF_SDHC) {
 112                         //              printf("IRQ: SDHC\n");
 113                         write32(HW_PPCIRQFLAG, IRQF_SDHC);
 114                         //sdhc_irq();
 115                 }
 116                 if (hw_flags & IRQF_OHCI0) {
 117                         hcdi_irq(OHCI0_REG_BASE);
 118                         write32(HW_PPCIRQFLAG, IRQF_OHCI0);
 119                 }
 120                 if (hw_flags & IRQF_OHCI1) {
 121                         hcdi_irq(OHCI1_REG_BASE);
 122                         write32(HW_PPCIRQFLAG, IRQF_OHCI1);
 123                 }
 124
 125                 hw_flags &= ~IRQF_ALL;
 126                 if(hw_flags) {
 127                         printf("IRQ: unknown 0x%08x\n", hw_flags);
 128                         write32(HW_PPCIRQFLAG, hw_flags);
 129                 }
 130
 131                 // not necessary here, but "cleaner"?
 132                 write32(BW_PI_IRQFLAG, 1<<BW_PI_IRQ_HW);
 133         }
 134 }
 135
 136 void irq_bw_enable(u32 irq)
 137 {
 138         set32(BW_PI_IRQMASK, 1<<irq);
 139 }
 140
 141 void irq_bw_disable(u32 irq) {
 142         clear32(BW_PI_IRQMASK, 1<<irq);
 143 }
 144
 145 void irq_hw_enable(u32 irq)
 146 {
 147         set32(HW_PPCIRQMASK, 1<<irq);
 148 }
 149
 150 void irq_hw_disable(u32 irq)
 151 {
 152         clear32(HW_PPCIRQMASK, 1<<irq);
 153 }
 154
 155 u32 irq_kill() {
 156         u32 cookie;
 157         _CPU_ISR_Disable(cookie);
 158         return cookie;
 159 }
 160
 161 void irq_restore(u32 cookie) {
 162         _CPU_ISR_Restore(cookie);
 163         _CPU_ISR_Enable(); //wtf :/
 164 }
 165