src/include/cpu_alpha.h

#ifndef CPU_ALPHA_H
#define CPU_ALPHA_H

/*
 *  Copyright (C) 2005-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: cpu_alpha.h,v 1.45 2006/12/30 13:31:00 debug Exp $
 */

#include "misc.h"

#include "alpha_cpu.h"


/*  ALPHA CPU types:  */
struct alpha_cpu_type_def { 
        char            *name;
        uint64_t        pcs_type;       /*  See alpha_rpb.h  */
        int             features;
        int             implver;
        int             icache_shift;
        int             ilinesize;
        int             iway;
        int             dcache_shift;
        int             dlinesize;
        int             dway;
        int             l2cache_shift;
        int             l2linesize;
        int             l2way;
};

/*  TODO: More features  */
#define ALPHA_FEATURE_BWX               1

#define ALPHA_CPU_TYPE_DEFS     {                                       \
        { "21064",      0x000000002ULL, 0, 0, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21066",      0x200000004ULL, 0, 0, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21164",      0x000000005ULL, 0, 1, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21164A-2",   0x000000007ULL, 0, 1, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21164PC",    0x000000009ULL, 0, 1, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21264",      0x00000000dULL, 0, 2, 16,5,2, 16,5,2,  0,0,0 }, \
        { "21364",      0x000000000ULL, 0, 3, 16,5,2, 16,5,2,  0,0,0 }, \
        { NULL,         0x000000000ULL, 0, 0,  0,0,0,  0,0,0,  0,0,0 }  }


struct cpu_family;

/*  ALPHA_KENTRY_INT .. ALPHA_KENTRY_SYS  */
#define N_ALPHA_KENTRY          6

#define ALPHA_V0                0
#define ALPHA_A0                16
#define ALPHA_A1                17
#define ALPHA_A2                18
#define ALPHA_A3                19
#define ALPHA_A4                20
#define ALPHA_A5                21
#define ALPHA_RA                26
#define ALPHA_T12               27
#define ALPHA_SP                30
#define ALPHA_ZERO              31
#define N_ALPHA_REGS            32

#define ALPHA_REG_NAMES         {                               \
        "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",         \
        "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",         \
        "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",         \
        "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero"     }


/*  Dyntrans definitions:  */

#define ALPHA_N_IC_ARGS                 3
#define ALPHA_INSTR_ALIGNMENT_SHIFT     2
#define ALPHA_IC_ENTRIES_SHIFT          11
#define ALPHA_IC_ENTRIES_PER_PAGE       (1 << ALPHA_IC_ENTRIES_SHIFT)
#define ALPHA_PC_TO_IC_ENTRY(a)         (((a)>>ALPHA_INSTR_ALIGNMENT_SHIFT) \
                                        & (ALPHA_IC_ENTRIES_PER_PAGE-1))
#define ALPHA_ADDR_TO_PAGENR(a)         ((a) >> (ALPHA_IC_ENTRIES_SHIFT \
                                        + ALPHA_INSTR_ALIGNMENT_SHIFT))

#define ALPHA_MAX_VPH_TLB_ENTRIES       128

#define ALPHA_L2N               17
#define ALPHA_L3N               17

DYNTRANS_MISC_DECLARATIONS(alpha,ALPHA,uint64_t)
DYNTRANS_MISC64_DECLARATIONS(alpha,ALPHA,uint8_t)


#define ALPHA_PAGESHIFT         13


struct alpha_cpu {
        struct alpha_cpu_type_def       cpu_type;


        /*
         *  General Purpose Registers:
         */

        uint64_t                r[N_ALPHA_REGS];        /*  Integer  */
        uint64_t                f[N_ALPHA_REGS];        /*  Floating Point  */

        uint64_t                fpcr;                   /*  FP Control Reg.  */

        /*  Misc.:  */
        uint64_t                pcc;                    /*  Cycle Counter  */
        uint64_t                ipl;
        uint64_t                load_linked_addr;
        int                     ll_flag;

        /*  OSF1 PALcode specific:  */
        uint64_t                vptptr;         /*  Virtual Page Table Ptr  */
        uint64_t                sysvalue;
        uint64_t                kgp;            /*  Kernel GP  */
        uint64_t                kentry[N_ALPHA_KENTRY];
        uint64_t                ctx;            /*  Ptr to current PCB (?)  */
        struct alpha_pcb        pcb;            /*  Process Control Block  */


        /*
         *  Instruction translation cache and Virtual->Physical->Host
         *  address translation:
         */
        DYNTRANS_ITC(alpha)
        VPH_TLBS(alpha,ALPHA)
        VPH64(alpha,ALPHA,uint8_t)
};


/*  cpu_alpha.c:  */
void alpha_update_translation_table(struct cpu *cpu, uint64_t vaddr_page,
        unsigned char *host_page, int writeflag, uint64_t paddr_page);
void alpha_invalidate_translation_caches(struct cpu *cpu, uint64_t, int);
void alpha_invalidate_code_translation(struct cpu *cpu, uint64_t, int);
void alpha_init_64bit_dummy_tables(struct cpu *cpu);
int alpha_run_instr(struct cpu *cpu);
int alpha_memory_rw(struct cpu *cpu, struct memory *mem, uint64_t vaddr,
        unsigned char *data, size_t len, int writeflag, int cache_flags);
int alpha_userland_memory_rw(struct cpu *cpu, struct memory *mem,
        uint64_t vaddr, unsigned char *data, size_t len, int writeflag,
        int cache_flags);
int alpha_cpu_family_init(struct cpu_family *);

/*  cpu_alpha_palcode.c:  */
void alpha_palcode_name(uint32_t palcode, char *buf, size_t buflen);
void alpha_palcode(struct cpu *cpu, uint32_t palcode);

/*  memory_alpha.c:  */
int alpha_translate_v2p(struct cpu *cpu, uint64_t vaddr,
        uint64_t *return_addr, int flags);


#endif  /*  CPU_ALPHA_H  */
1	#ifndef CPU_ALPHA_H
2	#define CPU_ALPHA_H
3
4	/*
5	* Copyright (C) 2005-2007 Anders Gavare. All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions are met:
9	*
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.
15	* 3. The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.
17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28	* SUCH DAMAGE.
29	*
30	*
31	* $Id: cpu_alpha.h,v 1.45 2006/12/30 13:31:00 debug Exp $
32	*/
33
34	#include "misc.h"
35
36	#include "alpha_cpu.h"
37
38
39	/* ALPHA CPU types: */
40	struct alpha_cpu_type_def {
41	char *name;
42	uint64_t pcs_type; /* See alpha_rpb.h */
43	int features;
44	int implver;
45	int icache_shift;
46	int ilinesize;
47	int iway;
48	int dcache_shift;
49	int dlinesize;
50	int dway;
51	int l2cache_shift;
52	int l2linesize;
53	int l2way;
54	};
55
56	/* TODO: More features */
57	#define ALPHA_FEATURE_BWX 1
58
59	#define ALPHA_CPU_TYPE_DEFS { \
60	{ "21064", 0x000000002ULL, 0, 0, 16,5,2, 16,5,2, 0,0,0 }, \
61	{ "21066", 0x200000004ULL, 0, 0, 16,5,2, 16,5,2, 0,0,0 }, \
62	{ "21164", 0x000000005ULL, 0, 1, 16,5,2, 16,5,2, 0,0,0 }, \
63	{ "21164A-2", 0x000000007ULL, 0, 1, 16,5,2, 16,5,2, 0,0,0 }, \
64	{ "21164PC", 0x000000009ULL, 0, 1, 16,5,2, 16,5,2, 0,0,0 }, \
65	{ "21264", 0x00000000dULL, 0, 2, 16,5,2, 16,5,2, 0,0,0 }, \
66	{ "21364", 0x000000000ULL, 0, 3, 16,5,2, 16,5,2, 0,0,0 }, \
67	{ NULL, 0x000000000ULL, 0, 0, 0,0,0, 0,0,0, 0,0,0 } }
68
69
70	struct cpu_family;
71
72	/* ALPHA_KENTRY_INT .. ALPHA_KENTRY_SYS */
73	#define N_ALPHA_KENTRY 6
74
75	#define ALPHA_V0 0
76	#define ALPHA_A0 16
77	#define ALPHA_A1 17
78	#define ALPHA_A2 18
79	#define ALPHA_A3 19
80	#define ALPHA_A4 20
81	#define ALPHA_A5 21
82	#define ALPHA_RA 26
83	#define ALPHA_T12 27
84	#define ALPHA_SP 30
85	#define ALPHA_ZERO 31
86	#define N_ALPHA_REGS 32
87
88	#define ALPHA_REG_NAMES { \
89	"v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6", \
90	"t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp", \
91	"a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9", \
92	"t10", "t11", "ra", "t12", "at", "gp", "sp", "zero" }
93
94
95	/* Dyntrans definitions: */
96
97	#define ALPHA_N_IC_ARGS 3
98	#define ALPHA_INSTR_ALIGNMENT_SHIFT 2
99	#define ALPHA_IC_ENTRIES_SHIFT 11
100	#define ALPHA_IC_ENTRIES_PER_PAGE (1 << ALPHA_IC_ENTRIES_SHIFT)
101	#define ALPHA_PC_TO_IC_ENTRY(a) (((a)>>ALPHA_INSTR_ALIGNMENT_SHIFT) \
102	& (ALPHA_IC_ENTRIES_PER_PAGE-1))
103	#define ALPHA_ADDR_TO_PAGENR(a) ((a) >> (ALPHA_IC_ENTRIES_SHIFT \
104	+ ALPHA_INSTR_ALIGNMENT_SHIFT))
105
106	#define ALPHA_MAX_VPH_TLB_ENTRIES 128
107
108	#define ALPHA_L2N 17
109	#define ALPHA_L3N 17
110
111	DYNTRANS_MISC_DECLARATIONS(alpha,ALPHA,uint64_t)
112	DYNTRANS_MISC64_DECLARATIONS(alpha,ALPHA,uint8_t)
113
114
115	#define ALPHA_PAGESHIFT 13
116
117
118	struct alpha_cpu {
119	struct alpha_cpu_type_def cpu_type;
120
121
122	/*
123	* General Purpose Registers:
124	*/
125
126	uint64_t r[N_ALPHA_REGS]; /* Integer */
127	uint64_t f[N_ALPHA_REGS]; /* Floating Point */
128
129	uint64_t fpcr; /* FP Control Reg. */
130
131	/* Misc.: */
132	uint64_t pcc; /* Cycle Counter */
133	uint64_t ipl;
134	uint64_t load_linked_addr;
135	int ll_flag;
136
137	/* OSF1 PALcode specific: */
138	uint64_t vptptr; /* Virtual Page Table Ptr */
139	uint64_t sysvalue;
140	uint64_t kgp; /* Kernel GP */
141	uint64_t kentry[N_ALPHA_KENTRY];
142	uint64_t ctx; /* Ptr to current PCB (?) */
143	struct alpha_pcb pcb; /* Process Control Block */
144
145
146	/*
147	* Instruction translation cache and Virtual->Physical->Host
148	* address translation:
149	*/
150	DYNTRANS_ITC(alpha)
151	VPH_TLBS(alpha,ALPHA)
152	VPH64(alpha,ALPHA,uint8_t)
153	};
154
155
156	/* cpu_alpha.c: */
157	void alpha_update_translation_table(struct cpu *cpu, uint64_t vaddr_page,
158	unsigned char *host_page, int writeflag, uint64_t paddr_page);
159	void alpha_invalidate_translation_caches(struct cpu *cpu, uint64_t, int);
160	void alpha_invalidate_code_translation(struct cpu *cpu, uint64_t, int);
161	void alpha_init_64bit_dummy_tables(struct cpu *cpu);
162	int alpha_run_instr(struct cpu *cpu);
163	int alpha_memory_rw(struct cpu cpu, struct memory mem, uint64_t vaddr,
164	unsigned char *data, size_t len, int writeflag, int cache_flags);
165	int alpha_userland_memory_rw(struct cpu cpu, struct memory mem,
166	uint64_t vaddr, unsigned char *data, size_t len, int writeflag,
167	int cache_flags);
168	int alpha_cpu_family_init(struct cpu_family *);
169
170	/* cpu_alpha_palcode.c: */
171	void alpha_palcode_name(uint32_t palcode, char *buf, size_t buflen);
172	void alpha_palcode(struct cpu *cpu, uint32_t palcode);
173
174	/* memory_alpha.c: */
175	int alpha_translate_v2p(struct cpu *cpu, uint64_t vaddr,
176	uint64_t *return_addr, int flags);
177
178
179	#endif /* CPU_ALPHA_H */