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.49 2007/07/20 09:03:33 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;

        int                     irq_asserted;

        /*  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)
};


/*  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	dpavlin	12	#ifndef CPU_ALPHA_H
2			#define CPU_ALPHA_H
3
4			/*
5	dpavlin	34	* Copyright (C) 2005-2007 Anders Gavare. All rights reserved.
6	dpavlin	12	*
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	dpavlin	44	* $Id: cpu_alpha.h,v 1.49 2007/07/20 09:03:33 debug Exp $
32	dpavlin	12	*/
33
34			#include "misc.h"
35
36	dpavlin	32	#include "alpha_cpu.h"
37	dpavlin	12
38	dpavlin	32
39	dpavlin	24	/* ALPHA CPU types: */
40			struct alpha_cpu_type_def {
41			char *name;
42	dpavlin	32	uint64_t pcs_type; /* See alpha_rpb.h */
43	dpavlin	24	int features;
44	dpavlin	32	int implver;
45	dpavlin	24	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	dpavlin	32	{ "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	dpavlin	24
69
70	dpavlin	12	struct cpu_family;
71
72	dpavlin	32	/* ALPHA_KENTRY_INT .. ALPHA_KENTRY_SYS */
73			#define N_ALPHA_KENTRY 6
74
75	dpavlin	12	#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	dpavlin	32	/* Dyntrans definitions: */
96
97	dpavlin	12	#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	dpavlin	24	#define ALPHA_MAX_VPH_TLB_ENTRIES 128
107	dpavlin	12
108	dpavlin	24	#define ALPHA_L2N 17
109			#define ALPHA_L3N 17
110	dpavlin	12
111	dpavlin	24	DYNTRANS_MISC_DECLARATIONS(alpha,ALPHA,uint64_t)
112			DYNTRANS_MISC64_DECLARATIONS(alpha,ALPHA,uint8_t)
113	dpavlin	12
114
115	dpavlin	32	#define ALPHA_PAGESHIFT 13
116
117
118	dpavlin	12	struct alpha_cpu {
119	dpavlin	32	struct alpha_cpu_type_def cpu_type;
120
121
122	dpavlin	12	/*
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	dpavlin	24	uint64_t fpcr; /* FP Control Reg. */
130	dpavlin	12
131			/* Misc.: */
132			uint64_t pcc; /* Cycle Counter */
133			uint64_t ipl;
134			uint64_t load_linked_addr;
135			int ll_flag;
136
137	dpavlin	42	int irq_asserted;
138
139	dpavlin	32	/* OSF1 PALcode specific: */
140			uint64_t vptptr; /* Virtual Page Table Ptr */
141	dpavlin	24	uint64_t sysvalue;
142	dpavlin	32	uint64_t kgp; /* Kernel GP */
143			uint64_t kentry[N_ALPHA_KENTRY];
144			uint64_t ctx; /* Ptr to current PCB (?) */
145			struct alpha_pcb pcb; /* Process Control Block */
146	dpavlin	12
147	dpavlin	24
148	dpavlin	12	/*
149	dpavlin	24	* Instruction translation cache and Virtual->Physical->Host
150			* address translation:
151	dpavlin	12	*/
152	dpavlin	22	DYNTRANS_ITC(alpha)
153			VPH_TLBS(alpha,ALPHA)
154	dpavlin	42	VPH64(alpha,ALPHA)
155	dpavlin	12	};
156
157
158			/* cpu_alpha.c: */
159			void alpha_update_translation_table(struct cpu *cpu, uint64_t vaddr_page,
160			unsigned char *host_page, int writeflag, uint64_t paddr_page);
161	dpavlin	18	void alpha_invalidate_translation_caches(struct cpu *cpu, uint64_t, int);
162	dpavlin	14	void alpha_invalidate_code_translation(struct cpu *cpu, uint64_t, int);
163	dpavlin	24	void alpha_init_64bit_dummy_tables(struct cpu *cpu);
164	dpavlin	28	int alpha_run_instr(struct cpu *cpu);
165	dpavlin	12	int alpha_memory_rw(struct cpu cpu, struct memory mem, uint64_t vaddr,
166			unsigned char *data, size_t len, int writeflag, int cache_flags);
167			int alpha_userland_memory_rw(struct cpu cpu, struct memory mem,
168			uint64_t vaddr, unsigned char *data, size_t len, int writeflag,
169			int cache_flags);
170			int alpha_cpu_family_init(struct cpu_family *);
171
172			/* cpu_alpha_palcode.c: */
173			void alpha_palcode_name(uint32_t palcode, char *buf, size_t buflen);
174			void alpha_palcode(struct cpu *cpu, uint32_t palcode);
175
176	dpavlin	24	/* memory_alpha.c: */
177	dpavlin	26	int alpha_translate_v2p(struct cpu *cpu, uint64_t vaddr,
178	dpavlin	24	uint64_t *return_addr, int flags);
179	dpavlin	12
180	dpavlin	28
181	dpavlin	12	#endif /* CPU_ALPHA_H */