/[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 22 by dpavlin, Mon Oct 8 16:19:37 2007 UTC trunk/src/devices/dev_openpic.c revision 66 by dpavlin, Sun Oct 14 12:03:25 2007 UTC
# Line 1  Line 1 
1  /*  /*
2   *  Copyright (C) 2005-2006  Anders Gavare.  All rights reserved.   *  Copyright (C) 2005-2007  Anders Gavare.  All rights reserved.
3   *   *
4   *  Redistribution and use in source and binary forms, with or without   *  Redistribution and use in source and binary forms, with or without
5   *  modification, are permitted provided that the following conditions are met:   *  modification, are permitted provided that the following conditions are met:
# 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.6 2006/01/01 13:17:16 debug Exp $   *  $Id: dev_openpic.c,v 1.14 2007/09/11 21:42:52 debug Exp $
28   *     *  
29   *  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 35  Line 36 
36    
37  #include "cpu.h"  #include "cpu.h"
38  #include "device.h"  #include "device.h"
 #include "devices.h"  
39  #include "machine.h"  #include "machine.h"
40  #include "memory.h"  #include "memory.h"
41  #include "misc.h"  #include "misc.h"
42    
43    
44  /*  #define DEV_OPENPIC_LENGTH              0x40000
45   *  dev_gc_access():  
46   */  struct openpic_data {
47  DEVICE_ACCESS(gc)          struct interrupt cpu_irq;
48    
49            uint32_t        status_hi;
50            uint32_t        status_lo;
51            uint32_t        enable_hi;
52            uint32_t        enable_lo;
53    };
54    
55    
56    void openpic_hi_interrupt_assert(struct interrupt *interrupt)
57    {
58            struct openpic_data *d = interrupt->extra;
59            d->status_hi |= interrupt->line;
60            if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)
61                    INTERRUPT_ASSERT(d->cpu_irq);
62    }
63    void openpic_hi_interrupt_deassert(struct interrupt *interrupt)
64    {
65            struct openpic_data *d = interrupt->extra;
66            d->status_hi &= ~interrupt->line;
67            if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))
68                    INTERRUPT_DEASSERT(d->cpu_irq);
69    }
70    void openpic_lo_interrupt_assert(struct interrupt *interrupt)
71  {  {
72          struct gc_data *d = extra;          struct openpic_data *d = interrupt->extra;
73            d->status_lo |= interrupt->line;
74            if (d->status_lo & d->enable_lo || d->status_hi & d->enable_hi)
75                    INTERRUPT_ASSERT(d->cpu_irq);
76    }
77    void openpic_lo_interrupt_deassert(struct interrupt *interrupt)
78    {
79            struct openpic_data *d = interrupt->extra;
80            d->status_lo &= ~interrupt->line;
81            if (!(d->status_lo & d->enable_lo || d->status_hi & d->enable_hi))
82                    INTERRUPT_DEASSERT(d->cpu_irq);
83    }
84    
85    #define OPENPIC_MASK                            0x80000000
86    #define OPENPIC_ACTIVITY                        0x40000000      /* Read Only */
87    #define OPENPIC_PRIORITY_MASK                   0x000f0000
88    #define OPENPIC_PRIORITY_SHIFT                  16
89    #define OPENPIC_VECTOR_MASK                     0x000000ff
90    
91    #define OPENPIC_VEC_TIMER       64      /* and up */
92    #define OPENPIC_VEC_IPI         72      /* and up */
93    #define OPENPIC_VEC_SPURIOUS    127
94    
95    DEVICE_ACCESS(openpic)
96    {
97    //      struct openpic_data *d = extra;
98          uint64_t idata = 0, odata = 0;          uint64_t idata = 0, odata = 0;
99    
100          if (writeflag == MEM_WRITE)          if (writeflag == MEM_WRITE)
101                  idata = memory_readmax64(cpu, data, len);                  idata = memory_readmax64(cpu, data, len);
102    
103            uint64_t priority,vector, active;
104            priority = ( relative_addr & 0xf000 );
105            vector   = ( relative_addr & 0x00ff );
106            active   = ( relative_addr & 0x4000 );
107    
108            debug("[ openpic: access at %04x -> priority: %x vector: 0x%02x %d active: %x ]\n",
109                    (int)relative_addr, (int)priority, (int)vector, (int)vector, (int)active );
110    
111          switch (relative_addr) {          switch (relative_addr) {
112    
113            case 0x00:
114                    if (writeflag == MEM_READ) {
115                            // version 1.2
116                            odata = 0x02000000;
117                            fatal("[ openpic: read from "
118                                "offset 0x%x (OpenPIC version) = %x]\n", (int)
119                                relative_addr, (int)odata);
120                    }
121                    fatal("[ openpic: unimplemented write to "
122                        "offset 0x%x: data=0x%x (OpenPIC version) ]\n", (int)
123                        relative_addr, (int)idata);
124                    break;
125    
126  #if 0  #if 0
127  #define INT_STATE_REG_H  (interrupt_reg + 0x00)  #define INT_STATE_REG_H  (interrupt_reg + 0x00)
128  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)
# Line 65  DEVICE_ACCESS(gc) Line 134  DEVICE_ACCESS(gc)
134  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)
135  #endif  #endif
136    
137    #if 0
138          case 0x10:          case 0x10:
139                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
140                          odata = d->status_hi                          odata = d->status_hi & d->enable_hi;
 & d->enable_hi  
 ;  
141                  break;                  break;
142    
143          case 0x14:          case 0x14:
144                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
145                          odata = d->enable_hi;                          odata = d->enable_hi;
146                  else {                  else {
147                          uint32_t old_enable_hi = d->enable_hi;                          int old_assert = (d->status_lo & d->enable_lo
148                                || d->status_hi & d->enable_hi);
149                            int new_assert;
150                          d->enable_hi = idata;                          d->enable_hi = idata;
151                          if (d->enable_hi != old_enable_hi)  
152                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
153                                d->status_hi & d->enable_hi);
154    
155                            if (old_assert && !new_assert)
156                                    INTERRUPT_DEASSERT(d->cpu_irq);
157                            else if (!old_assert && new_assert)
158                                    INTERRUPT_ASSERT(d->cpu_irq);
159                  }                  }
160                  break;                  break;
161    
162          case 0x18:          case 0x18:
163                  if (writeflag == MEM_WRITE) {                  if (writeflag == MEM_WRITE) {
164                          uint32_t old_status_hi = d->status_hi;                          int old_assert = (d->status_lo & d->enable_lo
165                                || d->status_hi & d->enable_hi);
166                            int new_assert;
167                          d->status_hi &= ~idata;                          d->status_hi &= ~idata;
168                          if (d->status_hi != old_status_hi)  
169                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
170                                d->status_hi & d->enable_hi);
171    
172                            if (old_assert && !new_assert)
173                                    INTERRUPT_DEASSERT(d->cpu_irq);
174                            else if (!old_assert && new_assert)
175                                    INTERRUPT_ASSERT(d->cpu_irq);
176                  }                  }
177                  break;                  break;
178    
179          case 0x20:          case 0x20:
180                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
181                          odata = d->status_lo                          odata = d->status_lo & d->enable_lo;
 & d->enable_lo  
 ;  
182                  break;                  break;
183    
184          case 0x24:          case 0x24:
185                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
186                          odata = d->enable_lo;                          odata = d->enable_lo;
187                  else {                  else {
188                          uint32_t old_enable_lo = d->enable_lo;                          int old_assert = (d->status_lo & d->enable_lo
189                                || d->status_hi & d->enable_hi);
190                            int new_assert;
191                          d->enable_lo = idata;                          d->enable_lo = idata;
192                          if (d->enable_lo != old_enable_lo)  
193                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
194                                d->status_hi & d->enable_hi);
195    
196                            if (old_assert && !new_assert)
197                                    INTERRUPT_DEASSERT(d->cpu_irq);
198                            else if (!old_assert && new_assert)
199                                    INTERRUPT_ASSERT(d->cpu_irq);
200                  }                  }
201                  break;                  break;
202    
203          case 0x28:          case 0x28:
204                  if (writeflag == MEM_WRITE) {                  if (writeflag == MEM_WRITE) {
205                          uint32_t old_status_lo = d->status_lo;                          int old_assert = (d->status_lo & d->enable_lo
206                                || d->status_hi & d->enable_hi);
207                            int new_assert;
208                          d->status_lo &= ~idata;                          d->status_lo &= ~idata;
209                          if (d->status_lo != old_status_lo)  
210                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
211                                d->status_hi & d->enable_hi);
212    
213                            if (old_assert && !new_assert)
214                                    INTERRUPT_DEASSERT(d->cpu_irq);
215                            else if (!old_assert && new_assert)
216                                    INTERRUPT_ASSERT(d->cpu_irq);
217                  }                  }
218                  break;                  break;
219    
220            case 0x1c:
221            case 0x2c:
222                    /*  Avoid a debug message.  */
223                    break;
224    #endif
225          default:if (writeflag == MEM_WRITE) {          default:if (writeflag == MEM_WRITE) {
226                          fatal("[ gc: unimplemented write to "                          fatal("[ openpic: unimplemented write to "
227                              "offset 0x%x: data=0x%x ]\n", (int)                              "offset 0x%x: data=0x%x ]\n", (int)
228                              relative_addr, (int)idata);                              relative_addr, (int)idata);
229                  } else {                  } else {
230                          fatal("[ gc: unimplemented read from "                          fatal("[ openpic: unimplemented read from "
231                              "offset 0x%x ]\n", (int)relative_addr);                              "offset 0x%x ]\n", (int)relative_addr);
232                  }                  }
233          }          }
# Line 136  DEVICE_ACCESS(gc) Line 239  DEVICE_ACCESS(gc)
239  }  }
240    
241    
242  /*  DEVINIT(openpic)
  *  dev_gc_init():  
  */  
 struct gc_data *dev_gc_init(struct machine *machine, struct memory *mem,  
         uint64_t addr, int reassert_irq)  
243  {  {
244          struct gc_data *d;          struct openpic_data *d;
245            int i;
246    
247            CHECK_ALLOCATION(d = malloc(sizeof(struct openpic_data)));
248            memset(d, 0, sizeof(struct openpic_data));
249    
250          d = malloc(sizeof(struct gc_data));          /*  Connect to the CPU interrupt pin:  */
251          if (d == NULL) {          INTERRUPT_CONNECT(devinit->interrupt_path, d->cpu_irq);
252                  fprintf(stderr, "out of memory\n");  
253                  exit(1);          /*
254             *  Register the 126 OpenPIC interrupts
255             */
256            for (i=0; i<126; i++) {
257                    struct interrupt template;
258                    char n[300];
259                    snprintf(n, sizeof(n), "%s.openpic.%i",
260                        devinit->interrupt_path, i);
261                    memset(&template, 0, sizeof(template));
262                    template.line = 1 << i;
263                    template.name = n;
264                    template.extra = d;
265                    template.interrupt_assert = openpic_lo_interrupt_assert;
266                    template.interrupt_deassert = openpic_lo_interrupt_deassert;
267                    interrupt_handler_register(&template);
268          }          }
         memset(d, 0, sizeof(struct gc_data));  
         d->reassert_irq = reassert_irq;  
269    
270          memory_device_register(mem, "gc", addr, 0x100,          memory_device_register(devinit->machine->memory, "openpic",
271              dev_gc_access, d, DM_DEFAULT, NULL);              devinit->addr, DEV_OPENPIC_LENGTH, dev_openpic_access, d, DM_DEFAULT, NULL);
272    
273          return d;          return 1;
274  }  }
275    
Legend:
Removed from v.22  
changed lines
  Added in v.66
  ViewVC Help
Powered by ViewVC 1.1.26