/[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 73 by dpavlin, Sun Oct 14 18:35:57 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    
46    struct openpic_data {
47            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 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  /*  /*
86   *  dev_gc_access():   * FIXME acitvity is never sat
87   */   */
88  DEVICE_ACCESS(gc)  
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(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                            debug("[ openpic: read version "
135                                    "offset 0x%x = 1.%d]\n", (int)
136                                    relative_addr, (int)odata);
137                            odata |= 0x00190000; // FIXME ?
138    
139                    }
140                    fatal("[ openpic: unimplemented write to "
141                        "offset 0x%x: data=0x%x (OpenPIC version) ]\n", (int)
142                        relative_addr, (int)idata);
143                    break;
144    
145            // global timer frequency
146            case 0xf0:
147                    if (writeflag == MEM_READ) {
148                            // this would be correct, but real DSM-G600 isn't
149                            // returning it!
150                            //odata = 170 * 1000000;        // MHz
151                            odata = 0;
152                            debug("[ openpic: read global timer frequency "
153                                "offset 0x%x = %x]\n", (int)
154                                relative_addr, (int)odata);
155                    }
156                    fatal("[ openpic: unimplemented write to "
157                        "offset 0x%x: data=0x%x ]\n", (int)
158                        relative_addr, (int)idata);
159                    break;
160    
161  #if 0  #if 0
162  #define INT_STATE_REG_H  (interrupt_reg + 0x00)  #define INT_STATE_REG_H  (interrupt_reg + 0x00)
163  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)  #define INT_ENABLE_REG_H (interrupt_reg + 0x04)
# Line 63  DEVICE_ACCESS(gc) Line 167  DEVICE_ACCESS(gc)
167  #define INT_ENABLE_REG_L (interrupt_reg + 0x14)  #define INT_ENABLE_REG_L (interrupt_reg + 0x14)
168  #define INT_CLEAR_REG_L  (interrupt_reg + 0x18)  #define INT_CLEAR_REG_L  (interrupt_reg + 0x18)
169  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)  #define INT_LEVEL_REG_L  (interrupt_reg + 0x1c)
 #endif  
170    
171          case 0x10:          case 0x10:
172                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
173                          odata = d->status_hi                          odata = d->status_hi & d->enable_hi;
 & d->enable_hi  
 ;  
174                  break;                  break;
175    
176          case 0x14:          case 0x14:
177                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
178                          odata = d->enable_hi;                          odata = d->enable_hi;
179                  else {                  else {
180                          uint32_t old_enable_hi = d->enable_hi;                          int old_assert = (d->status_lo & d->enable_lo
181                                || d->status_hi & d->enable_hi);
182                            int new_assert;
183                          d->enable_hi = idata;                          d->enable_hi = idata;
184                          if (d->enable_hi != old_enable_hi)  
185                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
186                                d->status_hi & d->enable_hi);
187    
188                            if (old_assert && !new_assert)
189                                    INTERRUPT_DEASSERT(d->cpu_irq);
190                            else if (!old_assert && new_assert)
191                                    INTERRUPT_ASSERT(d->cpu_irq);
192                  }                  }
193                  break;                  break;
194    
195          case 0x18:          case 0x18:
196                  if (writeflag == MEM_WRITE) {                  if (writeflag == MEM_WRITE) {
197                          uint32_t old_status_hi = d->status_hi;                          int old_assert = (d->status_lo & d->enable_lo
198                                || d->status_hi & d->enable_hi);
199                            int new_assert;
200                          d->status_hi &= ~idata;                          d->status_hi &= ~idata;
201                          if (d->status_hi != old_status_hi)  
202                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
203                                d->status_hi & d->enable_hi);
204    
205                            if (old_assert && !new_assert)
206                                    INTERRUPT_DEASSERT(d->cpu_irq);
207                            else if (!old_assert && new_assert)
208                                    INTERRUPT_ASSERT(d->cpu_irq);
209                  }                  }
210                  break;                  break;
211    
212          case 0x20:          case 0x20:
213                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
214                          odata = d->status_lo                          odata = d->status_lo & d->enable_lo;
 & d->enable_lo  
 ;  
215                  break;                  break;
216    
217          case 0x24:          case 0x24:
218                  if (writeflag == MEM_READ)                  if (writeflag == MEM_READ)
219                          odata = d->enable_lo;                          odata = d->enable_lo;
220                  else {                  else {
221                          uint32_t old_enable_lo = d->enable_lo;                          int old_assert = (d->status_lo & d->enable_lo
222                                || d->status_hi & d->enable_hi);
223                            int new_assert;
224                          d->enable_lo = idata;                          d->enable_lo = idata;
225                          if (d->enable_lo != old_enable_lo)  
226                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
227                                d->status_hi & d->enable_hi);
228    
229                            if (old_assert && !new_assert)
230                                    INTERRUPT_DEASSERT(d->cpu_irq);
231                            else if (!old_assert && new_assert)
232                                    INTERRUPT_ASSERT(d->cpu_irq);
233                  }                  }
234                  break;                  break;
235    
236          case 0x28:          case 0x28:
237                  if (writeflag == MEM_WRITE) {                  if (writeflag == MEM_WRITE) {
238                          uint32_t old_status_lo = d->status_lo;                          int old_assert = (d->status_lo & d->enable_lo
239                                || d->status_hi & d->enable_hi);
240                            int new_assert;
241                          d->status_lo &= ~idata;                          d->status_lo &= ~idata;
242                          if (d->status_lo != old_status_lo)  
243                                  cpu_interrupt(cpu, d->reassert_irq);                          new_assert = (d->status_lo & d->enable_lo ||
244                                d->status_hi & d->enable_hi);
245    
246                            if (old_assert && !new_assert)
247                                    INTERRUPT_DEASSERT(d->cpu_irq);
248                            else if (!old_assert && new_assert)
249                                    INTERRUPT_ASSERT(d->cpu_irq);
250                  }                  }
251                  break;                  break;
252    
253          default:if (writeflag == MEM_WRITE) {          case 0x1c:
254                          fatal("[ gc: unimplemented write to "          case 0x2c:
255                              "offset 0x%x: data=0x%x ]\n", (int)                  /*  Avoid a debug message.  */
256                              relative_addr, (int)idata);                  break;
257    #endif
258            default:
259                    if (writeflag == MEM_WRITE) {
260                            fatal("[ openpic: unimplemented write to "
261                                    "offset 0x%x idata = %x ]\n",
262                                    (int)relative_addr, (int)idata
263                            );
264                  } else {                  } else {
265                          fatal("[ gc: unimplemented read from "                          // decoded from real device
266                              "offset 0x%x ]\n", (int)relative_addr);                          odata |= OPENPIC_MASK;
267                            
268                            int vec =
269                            (
270                                    (
271                                            (
272                                                    (
273                                                            ( relative_addr - 0x120 ) & 0xfff
274                                                    ) / 0x40
275                                            )
276                                    ) & 0xff
277                            ) + 0x40;
278    
279                            odata |= vec;
280    
281                            debug("[ openpic: unimplemented read from "
282                                    "offset 0x%x decoded vec = 0x%02x %d odata = %x ]\n",
283                                    (int)relative_addr, vec, vec, (int)odata
284                            );
285                  }                  }
286          }          }
287    
288          if (writeflag == MEM_READ)          if (writeflag == MEM_READ) {
289    
290                    debug("[ openpic: READ %05x | %08x ]\n",
291                            (int)relative_addr, (int)odata
292                    );
293    
294                    // shuffle byte order
295                    odata =
296                            ( odata & 0x000000ff ) << 24 |
297                            ( odata & 0x0000ff00 ) << 8  |
298                            ( odata & 0x00ff0000 ) >> 8  |
299                            ( odata & 0xff000000 ) >> 24 ;
300                  memory_writemax64(cpu, data, len, odata);                  memory_writemax64(cpu, data, len, odata);
301            }
302    
303          return 1;          return 1;
304  }  }
305    
306    
307  /*  DEVINIT(openpic)
  *  dev_gc_init():  
  */  
 struct gc_data *dev_gc_init(struct machine *machine, struct memory *mem,  
         uint64_t addr, int reassert_irq)  
308  {  {
309          struct gc_data *d;          struct openpic_data *d;
310            int i;
311    
312            CHECK_ALLOCATION(d = malloc(sizeof(struct openpic_data)));
313            memset(d, 0, sizeof(struct openpic_data));
314    
315          d = malloc(sizeof(struct gc_data));          /*  Connect to the CPU interrupt pin:  */
316          if (d == NULL) {          INTERRUPT_CONNECT(devinit->interrupt_path, d->cpu_irq);
317                  fprintf(stderr, "out of memory\n");  
318                  exit(1);          /*
319             *  Register the 126 OpenPIC interrupts
320             */
321            for (i=0; i<126; i++) {
322                    struct interrupt template;
323                    char n[300];
324                    snprintf(n, sizeof(n), "%s.openpic.%i",
325                        devinit->interrupt_path, i);
326                    memset(&template, 0, sizeof(template));
327                    template.line = 1 << i;
328                    template.name = n;
329                    template.extra = d;
330                    template.interrupt_assert = openpic_lo_interrupt_assert;
331                    template.interrupt_deassert = openpic_lo_interrupt_deassert;
332                    interrupt_handler_register(&template);
333    //              debug("[ openpic: added interrupt %s ]\n", n);
334          }          }
         memset(d, 0, sizeof(struct gc_data));  
         d->reassert_irq = reassert_irq;  
335    
336          memory_device_register(mem, "gc", addr, 0x100,          memory_device_register(devinit->machine->memory, "openpic",
337              dev_gc_access, d, DM_DEFAULT, NULL);              devinit->addr, DEV_OPENPIC_LENGTH, dev_openpic_access, d, DM_DEFAULT, NULL);
338    
339          return d;          return 1;
340  }  }
341    
Legend:
Removed from v.22  
changed lines
  Added in v.73
  ViewVC Help
Powered by ViewVC 1.1.26