← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-sh4/cpu.h

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-sh4/cpu.h
15
15
 *
16
16
 * You should have received a copy of the GNU Lesser General Public
17
17
 * License along with this library; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
19
19
 */
20
20
#ifndef _CPU_SH4_H
21
21
#define _CPU_SH4_H
27
27
 
28
28
#define ELF_MACHINE     EM_SH
29
29
 
 
30
/* CPU Subtypes */
 
31
#define SH_CPU_SH7750  (1 << 0)
 
32
#define SH_CPU_SH7750S (1 << 1)
 
33
#define SH_CPU_SH7750R (1 << 2)
 
34
#define SH_CPU_SH7751  (1 << 3)
 
35
#define SH_CPU_SH7751R (1 << 4)
 
36
#define SH_CPU_SH7785  (1 << 5)
 
37
#define SH_CPU_SH7750_ALL (SH_CPU_SH7750 | SH_CPU_SH7750S | SH_CPU_SH7750R)
 
38
#define SH_CPU_SH7751_ALL (SH_CPU_SH7751 | SH_CPU_SH7751R)
 
39
 
30
40
#include "cpu-defs.h"
31
41
 
32
42
#include "softfloat.h"
39
49
#define SR_FD (1 << 15)
40
50
#define SR_M  (1 << 9)
41
51
#define SR_Q  (1 << 8)
 
52
#define SR_I3 (1 << 7)
 
53
#define SR_I2 (1 << 6)
 
54
#define SR_I1 (1 << 5)
 
55
#define SR_I0 (1 << 4)
42
56
#define SR_S  (1 << 1)
43
57
#define SR_T  (1 << 0)
44
58
 
79
93
 
80
94
#define NB_MMU_MODES 2
81
95
 
 
96
enum sh_features {
 
97
    SH_FEATURE_SH4A = 1,
 
98
    SH_FEATURE_BCR3_AND_BCR4 = 2,
 
99
};
 
100
 
82
101
typedef struct CPUSH4State {
 
102
    int id;                     /* CPU model */
 
103
 
83
104
    uint32_t flags;             /* general execution flags */
84
105
    uint32_t gregs[24];         /* general registers */
85
106
    float32 fregs[32];          /* floating point registers */
98
119
    uint32_t fpscr;             /* floating point status/control register */
99
120
    uint32_t fpul;              /* floating point communication register */
100
121
 
101
 
    /* temporary float registers */
102
 
    float32 ft0, ft1;
103
 
    float64 dt0, dt1;
 
122
    /* float point status register */
104
123
    float_status fp_status;
105
124
 
 
125
    /* The features that we should emulate. See sh_features above.  */
 
126
    uint32_t features;
 
127
 
106
128
    /* Those belong to the specific unit (SH7750) but are handled here */
107
129
    uint32_t mmucr;             /* MMU control register */
108
130
    uint32_t pteh;              /* page table entry high register */
114
136
    uint32_t expevt;            /* exception event register */
115
137
    uint32_t intevt;            /* interrupt event register */
116
138
 
117
 
    jmp_buf jmp_env;
118
 
    int user_mode_only;
119
 
    int interrupt_request;
120
 
    int halted;
121
 
    int exception_index;
 
139
    uint32_t pvr;               /* Processor Version Register */
 
140
    uint32_t prr;               /* Processor Revision Register */
 
141
    uint32_t cvr;               /* Cache Version Register */
 
142
 
 
143
    uint32_t ldst;
 
144
 
122
145
     CPU_COMMON tlb_t utlb[UTLB_SIZE];  /* unified translation table */
123
146
    tlb_t itlb[ITLB_SIZE];      /* instruction translation table */
124
147
    void *intc_handle;
 
148
    int intr_at_halt;           /* SR_BL ignored during sleep */
125
149
} CPUSH4State;
126
150
 
127
151
CPUSH4State *cpu_sh4_init(const char *cpu_model);
128
152
int cpu_sh4_exec(CPUSH4State * s);
129
153
int cpu_sh4_signal_handler(int host_signum, void *pinfo,
130
154
                           void *puc);
 
155
int cpu_sh4_handle_mmu_fault(CPUSH4State * env, target_ulong address, int rw,
 
156
                             int mmu_idx, int is_softmmu);
 
157
void do_interrupt(CPUSH4State * env);
 
158
 
 
159
void sh4_cpu_list(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...));
 
160
void cpu_sh4_write_mmaped_utlb_addr(CPUSH4State *s, target_phys_addr_t addr,
 
161
                                    uint32_t mem_value);
 
162
 
 
163
static inline void cpu_set_tls(CPUSH4State *env, target_ulong newtls)
 
164
{
 
165
  env->gbr = newtls;
 
166
}
 
167
 
 
168
void cpu_load_tlb(CPUSH4State * env);
131
169
 
132
170
#include "softfloat.h"
133
171
 
136
174
#define cpu_exec cpu_sh4_exec
137
175
#define cpu_gen_code cpu_sh4_gen_code
138
176
#define cpu_signal_handler cpu_sh4_signal_handler
 
177
#define cpu_list sh4_cpu_list
139
178
 
140
179
/* MMU modes definitions */
141
180
#define MMU_MODE0_SUFFIX _kernel
146
185
    return (env->sr & SR_MD) == 0 ? 1 : 0;
147
186
}
148
187
 
 
188
#if defined(CONFIG_USER_ONLY)
 
189
static inline void cpu_clone_regs(CPUState *env, target_ulong newsp)
 
190
{
 
191
    if (newsp)
 
192
        env->gregs[15] = newsp;
 
193
    env->gregs[0] = 0;
 
194
}
 
195
#endif
 
196
 
149
197
#include "cpu-all.h"
 
198
#include "exec-all.h"
150
199
 
151
200
/* Memory access type */
152
201
enum {
163
212
#define MMUCR    0x1F000010
164
213
#define MMUCR_AT (1<<0)
165
214
#define MMUCR_SV (1<<8)
 
215
#define MMUCR_URC_BITS (6)
 
216
#define MMUCR_URC_OFFSET (10)
 
217
#define MMUCR_URC_SIZE (1 << MMUCR_URC_BITS)
 
218
#define MMUCR_URC_MASK (((MMUCR_URC_SIZE) - 1) << MMUCR_URC_OFFSET)
 
219
static inline int cpu_mmucr_urc (uint32_t mmucr)
 
220
{
 
221
    return ((mmucr & MMUCR_URC_MASK) >> MMUCR_URC_OFFSET);
 
222
}
 
223
 
 
224
/* PTEH : Page Translation Entry High register */
 
225
#define PTEH_ASID_BITS (8)
 
226
#define PTEH_ASID_SIZE (1 << PTEH_ASID_BITS)
 
227
#define PTEH_ASID_MASK (PTEH_ASID_SIZE - 1)
 
228
#define cpu_pteh_asid(pteh) ((pteh) & PTEH_ASID_MASK)
 
229
#define PTEH_VPN_BITS (22)
 
230
#define PTEH_VPN_OFFSET (10)
 
231
#define PTEH_VPN_SIZE (1 << PTEH_VPN_BITS)
 
232
#define PTEH_VPN_MASK (((PTEH_VPN_SIZE) - 1) << PTEH_VPN_OFFSET)
 
233
static inline int cpu_pteh_vpn (uint32_t pteh)
 
234
{
 
235
    return ((pteh & PTEH_VPN_MASK) >> PTEH_VPN_OFFSET);
 
236
}
 
237
 
 
238
/* PTEL : Page Translation Entry Low register */
 
239
#define PTEL_V        (1 << 8)
 
240
#define cpu_ptel_v(ptel) (((ptel) & PTEL_V) >> 8)
 
241
#define PTEL_C        (1 << 3)
 
242
#define cpu_ptel_c(ptel) (((ptel) & PTEL_C) >> 3)
 
243
#define PTEL_D        (1 << 2)
 
244
#define cpu_ptel_d(ptel) (((ptel) & PTEL_D) >> 2)
 
245
#define PTEL_SH       (1 << 1)
 
246
#define cpu_ptel_sh(ptel)(((ptel) & PTEL_SH) >> 1)
 
247
#define PTEL_WT       (1 << 0)
 
248
#define cpu_ptel_wt(ptel) ((ptel) & PTEL_WT)
 
249
 
 
250
#define PTEL_SZ_HIGH_OFFSET  (7)
 
251
#define PTEL_SZ_HIGH  (1 << PTEL_SZ_HIGH_OFFSET)
 
252
#define PTEL_SZ_LOW_OFFSET   (4)
 
253
#define PTEL_SZ_LOW   (1 << PTEL_SZ_LOW_OFFSET)
 
254
static inline int cpu_ptel_sz (uint32_t ptel)
 
255
{
 
256
    int sz;
 
257
    sz = (ptel & PTEL_SZ_HIGH) >> PTEL_SZ_HIGH_OFFSET;
 
258
    sz <<= 1;
 
259
    sz |= (ptel & PTEL_SZ_LOW) >> PTEL_SZ_LOW_OFFSET;
 
260
    return sz;
 
261
}
 
262
 
 
263
#define PTEL_PPN_BITS (19)
 
264
#define PTEL_PPN_OFFSET (10)
 
265
#define PTEL_PPN_SIZE (1 << PTEL_PPN_BITS)
 
266
#define PTEL_PPN_MASK (((PTEL_PPN_SIZE) - 1) << PTEL_PPN_OFFSET)
 
267
static inline int cpu_ptel_ppn (uint32_t ptel)
 
268
{
 
269
    return ((ptel & PTEL_PPN_MASK) >> PTEL_PPN_OFFSET);
 
270
}
 
271
 
 
272
#define PTEL_PR_BITS   (2)
 
273
#define PTEL_PR_OFFSET (5)
 
274
#define PTEL_PR_SIZE (1 << PTEL_PR_BITS)
 
275
#define PTEL_PR_MASK (((PTEL_PR_SIZE) - 1) << PTEL_PR_OFFSET)
 
276
static inline int cpu_ptel_pr (uint32_t ptel)
 
277
{
 
278
    return ((ptel & PTEL_PR_MASK) >> PTEL_PR_OFFSET);
 
279
}
 
280
 
 
281
/* PTEA : Page Translation Entry Assistance register */
 
282
#define PTEA_SA_BITS (3)
 
283
#define PTEA_SA_SIZE (1 << PTEA_SA_BITS)
 
284
#define PTEA_SA_MASK (PTEA_SA_SIZE - 1)
 
285
#define cpu_ptea_sa(ptea) ((ptea) & PTEA_SA_MASK)
 
286
#define PTEA_TC        (1 << 3)
 
287
#define cpu_ptea_tc(ptea) (((ptea) & PTEA_TC) >> 3)
 
288
 
 
289
static inline void cpu_pc_from_tb(CPUState *env, TranslationBlock *tb)
 
290
{
 
291
    env->pc = tb->pc;
 
292
    env->flags = tb->flags;
 
293
}
 
294
 
 
295
static inline void cpu_get_tb_cpu_state(CPUState *env, target_ulong *pc,
 
296
                                        target_ulong *cs_base, int *flags)
 
297
{
 
298
    *pc = env->pc;
 
299
    *cs_base = 0;
 
300
    *flags = (env->flags & (DELAY_SLOT | DELAY_SLOT_CONDITIONAL
 
301
                    | DELAY_SLOT_TRUE | DELAY_SLOT_CLEARME))   /* Bits  0- 3 */
 
302
            | (env->fpscr & (FPSCR_FR | FPSCR_SZ | FPSCR_PR))  /* Bits 19-21 */
 
303
            | (env->sr & (SR_MD | SR_RB))                      /* Bits 29-30 */
 
304
            | (env->sr & SR_FD);                               /* Bit 15 */
 
305
}
166
306
 
167
307
#endif                          /* _CPU_SH4_H */