← Back to branch summary

~ubuntu-branches/ubuntu/breezy/tiemu/breezy

« back to all changes in this revision

Viewing changes to src/core/ti_hw/mem92p.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien BLACHE
  • Date: 2005-06-02 16:50:15 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050602165015-59ab24414tl2wzol
Tags: 1.99+svn1460-1
* New snapshot.
* debian/control:
  + Updated build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/ti_hw/mem92p.c
 
1
/* Hey EMACS -*- linux-c -*- */
 
2
/* $Id: mem92p.c 1455 2005-05-31 18:38:03Z roms $ */
 
3
 
 
4
/*  TiEmu - an TI emulator
 
5
 *
 
6
 *  Copyright (c) 2000-2001, Thomas Corvazier, Romain Lievin
 
7
 *  Copyright (c) 2001-2003, Romain Lievin
 
8
 *  Copyright (c) 2003, Julien Blache
 
9
 *  Copyright (c) 2004, Romain Li�vin
 
10
 *  Copyright (c) 2005, Romain Li�vin
 
11
 *
 
12
 *  This program is free software; you can redistribute it and/or modify
 
13
 *  it under the terms of the GNU General Public License as published by
 
14
 *  the Free Software Foundation; either version 2 of the License, or
 
15
 *  (at your option) any later version.
 
16
 *
 
17
 *  This program is distributed in the hope that it will be useful,
 
18
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 *  GNU General Public License for more details.
 
21
 *
 
22
 *  You should have received a copy of the GNU General Public License
 
23
 *  along with this program; if not, write to the Free Software
 
24
 *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 
25
 */
 
26
 
 
27
/*
 
28
    Memory management: TI92+ FLASH without Hardware Protection
 
29
        Some values may be hard-coded for performance reasons !
 
30
*/
 
31
 
 
32
#include <stdlib.h>
 
33
#include <string.h>
 
34
#include <stdio.h>
 
35
 
 
36
#include "libuae.h"
 
37
#include "ports.h"
 
38
#include "hw.h"
 
39
#include "mem.h"
 
40
#include "mem92p.h"
 
41
#include "images.h"
 
42
#include "bkpts.h"
 
43
#include "m68k.h"
 
44
#include "ti68k_def.h"
 
45
#include "ti68k_int.h"
 
46
#include "flash.h"
 
47
 
 
48
// 000000-0fffff : RAM (256 KB)
 
49
// 100000-1fffff : ghost of RAM
 
50
// 200000-2fffff : ghost of FLASH (HW2)
 
51
// 300000-3fffff : unused
 
52
// 400000-4fffff : external FLASH
 
53
// 500000-5fffff : idem
 
54
// 600000-6fffff : memory mapped I/O (all HW)
 
55
// 700000-7fffff : memory mapped I/O (HW2)
 
56
// 800000-8fffff : unused
 
57
// 900000-9fffff :       ... 
 
58
// a00000-afffff : 
 
59
// b00000-bfffff : 
 
60
// c00000-cfffff : 
 
61
// d00000-dfffff :
 
62
// e00000-efffff :   ...
 
63
// d00000-ffffff : unused
 
64
 
 
65
int ti92p_mem_init(void)
 
66
{
 
67
        // set mappers
 
68
        mem_get_byte_ptr = ti92p_get_byte;
 
69
        mem_get_word_ptr = ti92p_get_word;
 
70
        mem_get_long_ptr = ti92p_get_long;
 
71
        mem_put_byte_ptr = ti92p_put_byte;
 
72
        mem_put_word_ptr = ti92p_put_word;
 
73
        mem_put_long_ptr = ti92p_put_long;
 
74
 
 
75
        mem_get_real_addr_ptr = ti92p_get_real_addr;
 
76
  
 
77
    return 0;
 
78
}
 
79
 
 
80
uint8_t* ti92p_get_real_addr(uint32_t adr)
 
81
{
 
82
        // RAM access
 
83
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
84
        {
 
85
                return getp(tihw.ram, adr, RAM_SIZE_TI92P - 1);
 
86
        }
 
87
 
 
88
    // FLASH access
 
89
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
90
        {
 
91
                return getp(tihw.rom, adr, ROM_SIZE_TI92P - 1);
 
92
        }
 
93
        
 
94
        // memory-mapped I/O
 
95
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
96
        {
 
97
                return getp(tihw.io, adr, IO1_SIZE_TI92P - 1);
 
98
        }
 
99
 
 
100
        // memory-mapped I/O (hw2)
 
101
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
102
        {
 
103
                return getp(tihw.io2, adr, IO2_SIZE_TI92P - 1);
 
104
        }
 
105
 
 
106
        return tihw.unused;
 
107
}
 
108
 
 
109
uint32_t ti92p_get_long(uint32_t adr) 
 
110
{
 
111
        // RAM access
 
112
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
113
        {
 
114
                return getl(tihw.ram, adr, RAM_SIZE_TI92P - 1);
 
115
        }
 
116
 
 
117
    // FLASH access
 
118
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
119
        {
 
120
                return getl(tihw.rom, adr, ROM_SIZE_TI92P - 1) | wsm.ret_or;
 
121
        }
 
122
        
 
123
        // memory-mapped I/O
 
124
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
125
        {
 
126
       return io_get_long(adr);
 
127
        }
 
128
 
 
129
        // memory-mapped I/O (hw2)
 
130
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
131
        {
 
132
                return io2_get_long(adr);
 
133
        }
 
134
 
 
135
    return 0x14141414;
 
136
}
 
137
 
 
138
uint16_t ti92p_get_word(uint32_t adr) 
 
139
{
 
140
    // RAM access
 
141
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
142
        {
 
143
                return getw(tihw.ram, adr, RAM_SIZE_TI92P - 1);
 
144
        }
 
145
 
 
146
    // FLASH access
 
147
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
148
        {
 
149
                return getw(tihw.rom, adr, ROM_SIZE_TI92P - 1) | wsm.ret_or;
 
150
        }
 
151
        
 
152
        // memory-mapped I/O
 
153
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
154
        {
 
155
       return io_get_word(adr);
 
156
        }
 
157
 
 
158
        // memory-mapped I/O (hw2)
 
159
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
160
        {
 
161
                return io2_get_word(adr);
 
162
        }
 
163
 
 
164
    return 0x1414;
 
165
}
 
166
 
 
167
uint8_t ti92p_get_byte(uint32_t adr) 
 
168
{    
 
169
    // RAM access
 
170
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
171
        {
 
172
                return getb(tihw.ram, adr, RAM_SIZE_TI92P - 1);
 
173
        }
 
174
 
 
175
    // FLASH access
 
176
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
177
        {
 
178
                return getb(tihw.rom, adr, ROM_SIZE_TI92P - 1) | wsm.ret_or;
 
179
        }
 
180
        
 
181
        // memory-mapped I/O
 
182
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
183
        {
 
184
       return io_get_byte(adr);
 
185
        }
 
186
 
 
187
        // memory-mapped I/O (hw2)
 
188
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
189
        {
 
190
                return io2_get_byte(adr);
 
191
        }
 
192
 
 
193
    return 0x14;
 
194
}
 
195
 
 
196
void ti92p_put_long(uint32_t adr, uint32_t arg) 
 
197
{
 
198
        // RAM access
 
199
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
200
        {
 
201
                putl(tihw.ram, adr, RAM_SIZE_TI92P - 1, arg);
 
202
        }
 
203
 
 
204
    // FLASH access
 
205
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
206
        {
 
207
                FlashWriteLong(adr, arg);
 
208
        }
 
209
 
 
210
        // memory-mapped I/O
 
211
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
212
        {
 
213
                io_put_long(adr, arg);
 
214
        }
 
215
 
 
216
        // memory-mapped I/O (hw2)
 
217
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
218
        {
 
219
                io2_put_long(adr, arg);
 
220
        }
 
221
 
 
222
    return;
 
223
}
 
224
 
 
225
void ti92p_put_word(uint32_t adr, uint16_t arg) 
 
226
{
 
227
    // RAM access
 
228
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
229
        {
 
230
                putw(tihw.ram, adr, RAM_SIZE_TI92P - 1, arg);
 
231
        }
 
232
 
 
233
    // FLASH access
 
234
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
235
        {
 
236
                FlashWriteWord(adr, arg);
 
237
        }
 
238
 
 
239
        // memory-mapped I/O
 
240
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
241
        {
 
242
                io_put_word(adr, arg);
 
243
        }
 
244
 
 
245
        // memory-mapped I/O (hw2)
 
246
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
247
        {
 
248
                io2_put_word(adr, arg);
 
249
        }
 
250
 
 
251
    return;
 
252
}
 
253
 
 
254
void ti92p_put_byte(uint32_t adr, uint8_t arg) 
 
255
{
 
256
    // RAM access
 
257
        if(IN_BOUNDS(0x000000, adr, 0x1fffff))
 
258
        {
 
259
                putb(tihw.ram, adr, RAM_SIZE_TI92P - 1, arg);
 
260
        }
 
261
 
 
262
    // FLASH access
 
263
        else if(IN_BOUNDS(0x200000, adr, 0x5fffff))
 
264
        {
 
265
                FlashWriteByte(adr, arg);
 
266
        }
 
267
 
 
268
        // memory-mapped I/O
 
269
    else if(IN_BOUNDS(0x600000, adr, 0x6fffff))
 
270
        {
 
271
                io_put_byte(adr, arg);
 
272
        }
 
273
 
 
274
        // memory-mapped I/O (hw2)
 
275
        else if(IN_RANGE(adr, 0x700000, IO2_SIZE_TI92P))
 
276
        {
 
277
                io2_put_byte(adr, arg);
 
278
        }
 
279
 
 
280
    return;
 
281
}
 
282