/[gxemul]/trunk/src/devices/dev_openpic.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/devices/dev_openpic.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/src/devices/dev_gc.c revision 44 by dpavlin, Mon Oct 8 16:22:56 2007 UTC trunk/src/devices/dev_openpic.c revision 69 by dpavlin, Sun Oct 14 16:06:44 2007 UTC
# Line 24  Line 24 
24   *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25   *  SUCH DAMAGE.   *  SUCH DAMAGE.
26   *     *  
27   *  $Id: dev_gc.c,v 1.14 2007/09/11 21:42:52 debug Exp $   *  $Id: dev_openpic.c,v 1.14 2007/09/11 21:42:52 debug Exp $
28   *     *  
29   *  COMMENT: Grand Central Interrupt controller (used by MacPPC)   *  COMMENT: OpenPIC Interrupt controller (used by sandpoint ppc)
30     *  based on dev_gc.c
31   */   */
32    
33  #include <stdio.h>  #include <stdio.h>
# Line 40  Line 41 
41  #include "misc.h"  #include "misc.h"
42    
43    
44  #define DEV_GC_LENGTH           0x100  #define DEV_OPENPIC_LENGTH              0x40000
45    
46  struct gc_data {  struct openpic_data {
47          struct interrupt cpu_irq;          struct interrupt cpu_irq;
48    
49          uint32_t        status_hi;          uint32_t        status_hi;
# Line 52  struct gc_data { Line 53  struct gc_data {
53  };  };
54    
55    
56  void gc_hi_interrupt_assert(struct interrupt *interrupt)  void openpic_hi_interrupt_assert(struct interrupt *interrupt)
57  {  {
58          struct gc_data *d = interrupt->extra;          struct openpic_data *d = interrupt->extra;
59          d->status_hi |= interrupt->line;          d->status_hi |= interrupt->line;
60          if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)          if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)
61                  INTERRUPT_ASSERT(d->cpu_irq);                  INTERRUPT_ASSERT(d->cpu_irq);
62  }  }
63  void gc_hi_interrupt_deassert(struct interrupt *interrupt)  void openpic_hi_interrupt_deassert(struct interrupt *interrupt)
64  {  {
65          struct gc_data *d = interrupt->extra;          struct openpic_data *d = interrupt->extra;
66          d->status_hi &= ~interrupt->line;          d->status_hi &= ~interrupt->line;
67          if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))          if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))
68                  INTERRUPT_DEASSERT(d->cpu_irq);                  INTERRUPT_DEASSERT(d->cpu_irq);
69  }  }
70  void gc_lo_interrupt_assert(struct interrupt *interrupt)  void openpic_lo_interrupt_assert(struct interrupt *interrupt)
71  {  {
72          struct gc_data *d = interrupt->extra;          struct openpic_data *d = interrupt->extra;
73          d->status_lo |= interrupt->line;          d->status_lo |= interrupt->line;
74          if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)          if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)
75                  INTERRUPT_ASSERT(d->cpu_irq);                  INTERRUPT_ASSERT(d->cpu_irq);
76  }  }
77  void gc_lo_interrupt_deassert(struct interrupt *interrupt)  void openpic_lo_interrupt_deassert(struct interrupt *interrupt)
78  {  {
79          struct gc_data *d = interrupt->extra;          struct openpic_data *d = interrupt->extra;
80          d->status_lo &= ~interrupt->line;          d->status_lo &= ~interrupt->line;
81          if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))          if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))
82                  INTERRUPT_DEASSERT(d->cpu_irq);                  INTERRUPT_DEASSERT(d->cpu_irq);
83  }  }
84    
85    /*
86     * FIXME acitvity is never sat
87     */
88    
89    #define OPENPIC_MASK                            0x80000000
90    #define OPENPIC_ACTIVITY                        0x40000000      /* Read Only */
91    #define OPENPIC_PRIORITY_MASK                   0x000f0000
92    #define OPENPIC_PRIORITY_SHIFT                  16
93    #define OPENPIC_VECTOR_MASK                     0x000000ff
94    
95    #define OPENPIC_VEC_TIMER       64      /* and up */
96    #define OPENPIC_VEC_IPI         72      /* and up */
97    #define OPENPIC_VEC_SPURIOUS    127
98    
99    #define OPENPIC_NUM_TIMERS      4
100    #define OPENPIC_NUM_IPI         4
101    #define OPENPIC_NUM_PRI         16
102    #define OPENPIC_NUM_VECTORS     256
103    
104  DEVICE_ACCESS(gc)  DEVICE_ACCESS(openpic)
105  {  {
106          struct gc_data *d = extra;  //      struct openpic_data *d = extra;
107          uint64_t idata = 0, odata = 0;          uint64_t idata = 0, odata = 0;
108    
109          if (writeflag == MEM_WRITE)          if (writeflag == MEM_WRITE) {
110                  idata = memory_readmax64(cpu, data, len);                  idata = memory_readmax64(cpu, data, len);
111                    // shuffle byte order
112                    idata =
113                            ( idata & 0x000000ff ) << 24 |
114                            ( idata & 0x0000ff00 ) << 8  |
115                            ( idata & 0x00ff0000 ) >> 8  |
116                            ( idata & 0xff000000 ) >> 24 ;
117    
118                    uint64_t priority,vector, active;
119                    priority = ( idata & OPENPIC_PRIORITY_MASK ) >> OPENPIC_PRIORITY_SHIFT;
120                    vector   = ( idata & OPENPIC_VECTOR_MASK );
121                    active   = ( idata & OPENPIC_ACTIVITY );
122    
123                    debug("[ openpic: WRITE %05x | %08x | priority: %x vector: 0x%02x %d active: %x ]\n",
124                            (int)relative_addr, (int)idata, (int)priority, (int)vector, (int)vector, (int)active );
125            }
126    
127          switch (relative_addr) {          switch (relative_addr) {
128    
129            // version
130            case 0x00:
131                    if (writeflag == MEM_READ) {
132                            // version 1.x, so 2 -> 1.2
133                            odata = 2;
134                            fatal("[ openpic: read version "
135                                "offset 0x%x = 1.%d]\n", (int)
136                                relative_addr, (int)odata);
137                    }
138                    fatal("[ openpic: unimplemented write to "
139                        "offset 0x%x: data=0x%x (OpenPIC version) ]\n", (int)
140                        relative_addr, (int)idata);
141                    break;
142    
143            // global timer frequency
144            case 0xf0:
145                    if (writeflag == MEM_READ) {
146                            odata = 170 * 1000000;  // MHz
147                            fatal("[ openpic: read global timer frequency "
148                                "offset 0x%x = %x]\n", (int)
149                                relative_addr, (int)odata);
150                    }
151                    fatal("[ openpic: unimplemented write to "
152                        "offset 0x%x: data=0x%x ]\n", (int)
153                        relative_addr, (int)idata);
154                    break;
155    
156  #if 0  #if 0
157  #define INT_STATE_REG_H  (interrupt_reg + 0x00)  #define INT_STATE_REG_H  (interrupt_reg + 0x00)
158  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)
# Line 101  DEVICE_ACCESS(gc) Line 162  DEVICE_ACCESS(gc)
162  #define INT_ENABLE_REG_L (interrupt_reg + 0x14)  #define INT_ENABLE_REG_L (interrupt_reg + 0x14)
163  #define INT_CLEAR_REG_L  (interrupt_reg + 0x18)  #define INT_CLEAR_REG_L  (interrupt_reg + 0x18)
164  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)
 #endif  
165    
166          case 0x10:          case 0x10:
167                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
# Line 189  DEVICE_ACCESS(gc) Line 249  DEVICE_ACCESS(gc)
249          case 0x2c:          case 0x2c:
250                  /*  Avoid a debug message.  */                  /*  Avoid a debug message.  */
251                  break;                  break;
252    #endif
253          default:if (writeflag == MEM_WRITE) {          default:
254                          fatal("[ gc: unimplemented write to "                  if (writeflag == MEM_WRITE) {
255                              "offset 0x%x: data=0x%x ]\n", (int)                          fatal("[ openpic: unimplemented write to "
256                              relative_addr, (int)idata);                                  "offset 0x%x idata = %x ]\n",
257                                    (int)relative_addr, (int)idata
258                            );
259                  } else {                  } else {
260                          fatal("[ gc: unimplemented read from "                          fatal("[ openpic: unimplemented read from "
261                              "offset 0x%x ]\n", (int)relative_addr);                                  "offset 0x%x odata = %x ]\n",
262                                    (int)relative_addr, (int)odata
263                            );
264                  }                  }
265          }          }
266    
267          if (writeflag == MEM_READ)          if (writeflag == MEM_READ) {
268                    // shuffle byte order
269                    odata =
270                            ( odata & 0x000000ff ) << 24 |
271                            ( odata & 0x0000ff00 ) << 8  |
272                            ( odata & 0x00ff0000 ) >> 8  |
273                            ( odata & 0xff000000 ) >> 24 ;
274                  memory_writemax64(cpu, data, len, odata);                  memory_writemax64(cpu, data, len, odata);
275                    debug("[ openpic: READ %05x | %08x ]\n",
276                            (int)relative_addr, (int)odata
277                    );
278            }
279    
280          return 1;          return 1;
281  }  }
282    
283    
284  DEVINIT(gc)  DEVINIT(openpic)
285  {  {
286          struct gc_data *d;          struct openpic_data *d;
287          int i;          int i;
288    
289          CHECK_ALLOCATION(d = malloc(sizeof(struct gc_data)));          CHECK_ALLOCATION(d = malloc(sizeof(struct openpic_data)));
290          memset(d, 0, sizeof(struct gc_data));          memset(d, 0, sizeof(struct openpic_data));
291    
292          /*  Connect to the CPU interrupt pin:  */          /*  Connect to the CPU interrupt pin:  */
293          INTERRUPT_CONNECT(devinit->interrupt_path, d->cpu_irq);          INTERRUPT_CONNECT(devinit->interrupt_path, d->cpu_irq);
294    
295          /*          /*
296           *  Register the 64 Grand Central interrupts (32 lo, 32 hi):           *  Register the 126 OpenPIC interrupts
297           */           */
298          for (i=0; i<32; i++) {          for (i=0; i<126; i++) {
299                  struct interrupt template;                  struct interrupt template;
300                  char n[300];                  char n[300];
301                  snprintf(n, sizeof(n), "%s.gc.lo.%i",                  snprintf(n, sizeof(n), "%s.openpic.%i",
                     devinit->interrupt_path, i);  
                 memset(&template, 0, sizeof(template));  
                 template.line = 1 << i;  
                 template.name = n;  
                 template.extra = d;  
                 template.interrupt_assert = gc_lo_interrupt_assert;  
                 template.interrupt_deassert = gc_lo_interrupt_deassert;  
                 interrupt_handler_register(&template);  
   
                 snprintf(n, sizeof(n), "%s.gc.hi.%i",  
302                      devinit->interrupt_path, i);                      devinit->interrupt_path, i);
303                  memset(&template, 0, sizeof(template));                  memset(&template, 0, sizeof(template));
304                  template.line = 1 << i;                  template.line = 1 << i;
305                  template.name = n;                  template.name = n;
306                  template.extra = d;                  template.extra = d;
307                  template.interrupt_assert = gc_hi_interrupt_assert;                  template.interrupt_assert = openpic_lo_interrupt_assert;
308                  template.interrupt_deassert = gc_hi_interrupt_deassert;                  template.interrupt_deassert = openpic_lo_interrupt_deassert;
309                  interrupt_handler_register(&template);                  interrupt_handler_register(&template);
310                    debug("[ openpic: added interrupt %s ]\n", n);
311          }          }
312    
313          memory_device_register(devinit->machine->memory, "gc",          memory_device_register(devinit->machine->memory, "openpic",
314              devinit->addr, DEV_GC_LENGTH, dev_gc_access, d, DM_DEFAULT, NULL);              devinit->addr, DEV_OPENPIC_LENGTH, dev_openpic_access, d, DM_DEFAULT, NULL);
315    
316          return 1;          return 1;
317  }  }

Legend:
Removed from v.44  
changed lines
  Added in v.69

  ViewVC Help
Powered by ViewVC 1.1.26