aboutsummaryrefslogtreecommitdiffstats
path: root/lib/lufa/Projects/LEDNotifier/LEDMixerApp/LEDMixer.Designer.cs
blob: 595083a4a888093c68b2fd4b398f0f94b04fba5b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
namespace LEDMixer
{
    partial class LEDMixer
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.tbRed = new System.Windows.Forms.TrackBar();
            this.tbGreen = new System.Windows.Forms.TrackBar();
            this.tbBlue = new System.Windows.Forms.TrackBar();
            this.serSerialPort = new System.IO.Ports.SerialPort(this.components);
            this.cbPort = new System.Windows.Forms.ComboBox();
            this.lblRed = new System.Windows.Forms.Label();
            this.lblBlue = new System.Windows.Forms.Label();
            this.lblGreen = new System.Windows.Forms.Label();
            ((System.ComponentModel.ISupportInitialize)(this.tbRed)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.tbGreen)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.tbBlue)).BeginInit();
            this.SuspendLayout();
            // 
            // tbRed
            // 
            this.tbRed.Location = new System.Drawing.Point(54, 64);
            this.tbRed.Maximum = 512;
            this.tbRed.Name = "tbRed";
            this.tbRed.Size = new System.Drawing.Size(230, 45);
            this.tbRed.TabIndex = 0;
            this.tbRed.Scroll += new System.EventHandler(this.tbRed_Scroll);
            // 
            // tbGreen
            // 
            this.tbGreen.Location = new System.Drawing.Point(54, 115);
            this.tbGreen.Maximum = 512;
            this.tbGreen.Name = "tbGreen";
            this.tbGreen.Size = new System.Drawing.Size(230, 45);
            this.tbGreen.TabIndex = 1;
            this.tbGreen.Scroll += new System.EventHandler(this.tbGreen_Scroll);
            // 
            // tbBlue
            // 
            this.tbBlue.Location = new System.Drawing.Point(54, 163);
            this.tbBlue.Maximum = 512;
            this.tbBlue.Name = "tbBlue";
            this.tbBlue.Size = new System.Drawing.Size(230, 45);
            this.tbBlue.TabIndex = 2;
            this.tbBlue.Scroll += new System.EventHandler(this.tbBlue_Scroll);
            // 
            // cbPort
            // 
            this.cbPort.FormattingEnabled = true;
            this.cbPort.Location = new System.Drawing.Point(97, 12);
            this.cbPort.Name = "cbPort";
            this.cbPort.Size = new System.Drawing.Size(99, 21);
            this.cbPort.TabIndex = 3;
            this.cbPort.SelectedIndexChanged += new System.EventHandler(this.cbPort_SelectedIndexChanged);
            // 
            // lblRed
            // 
            this.lblRed.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblRed.Location = new System.Drawing.Point(3, 64);
            this.lblRed.Name = "lblRed";
            this.lblRed.Size = new System.Drawing.Size(48, 29);
            this.lblRed.TabIndex = 4;
            this.lblRed.Text = "Red";
            this.lblRed.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
            // 
            // lblBlue
            // 
            this.lblBlue.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblBlue.Location = new System.Drawing.Point(3, 115);
            this.lblBlue.Name = "lblGreen";
            this.lblBlue.Size = new System.Drawing.Size(50, 27);
            this.lblBlue.TabIndex = 5;
            this.lblBlue.Text = "Green";
            this.lblBlue.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
            // 
            // lblGreen
            // 
            this.lblGreen.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblGreen.Location = new System.Drawing.Point(3, 163);
            this.lblGreen.Name = "lblBlue";
            this.lblGreen.Size = new System.Drawing.Size(50, 25);
            this.lblGreen.TabIndex = 6;
            this.lblGreen.Text = "Blue";
            this.lblGreen.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
            // 
            // LEDMixer
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(284, 207);
            this.Controls.Add(this.lblGreen);
            this.Controls.Add(this.lblBlue);
            this.Controls.Add(this.lblRed);
            this.Controls.Add(this.cbPort);
            this.Controls.Add(this.tbBlue);
            this.Controls.Add(this.tbGreen);
            this.Controls.Add(this.tbRed);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "LEDMixer";
            this.Text = "LED Mixer";
            this.Load += new System.EventHandler(this.LEDMixer_Load);
            ((System.ComponentModel.ISupportInitialize)(this.tbRed)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.tbGreen)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.tbBlue)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.TrackBar tbRed;
        private System.Windows.Forms.TrackBar tbGreen;
        private System.Windows.Forms.TrackBar tbBlue;
        private System.IO.Ports.SerialPort serSerialPort;
        private System.Windows.Forms.ComboBox cbPort;
        private System.Windows.Forms.Label lblRed;
        private System.Windows.Forms.Label lblBlue;
        private System.Windows.Forms.Label lblGreen;
    }
}
AULT priv_ptr_i(VCPU *vcpu, INST64 inst) { UINT64 vadr = vcpu_get_gr(vcpu,inst.M45.r3); UINT64 log_range; log_range = (vcpu_get_gr(vcpu,inst.M45.r2) & 0xfc) >> 2; return vcpu_ptr_i(vcpu,vadr,log_range); } static IA64FAULT priv_tpa(VCPU *vcpu, INST64 inst) { UINT64 padr; UINT fault; UINT src = inst.M46.r3; // NOTE: tpa with source gr > 63 is emulated as a ttag rx=r(y-64) if (privify_en && src > 63) fault = vcpu_ttag(vcpu,vcpu_get_gr(vcpu,src-64),&padr); else fault = vcpu_tpa(vcpu,vcpu_get_gr(vcpu,src),&padr); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M46.r1, padr, 0); else return fault; } static IA64FAULT priv_tak(VCPU *vcpu, INST64 inst) { UINT64 key; UINT fault; UINT src = inst.M46.r3; // NOTE: tak with source gr > 63 is emulated as a thash rx=r(y-64) if (privify_en && src > 63) fault = vcpu_thash(vcpu,vcpu_get_gr(vcpu,src-64),&key); else fault = vcpu_tak(vcpu,vcpu_get_gr(vcpu,src),&key); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M46.r1, key,0); else return fault; } /************************************ * Insert translation register/cache ************************************/ static IA64FAULT priv_itr_d(VCPU *vcpu, INST64 inst) { UINT64 fault, itir, ifa, pte, slot; //if (!vcpu_get_psr_ic(vcpu)) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_itir(vcpu,&itir)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_ifa(vcpu,&ifa)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); pte = vcpu_get_gr(vcpu,inst.M42.r2); slot = vcpu_get_gr(vcpu,inst.M42.r3); return (vcpu_itr_d(vcpu,slot,pte,itir,ifa)); } static IA64FAULT priv_itr_i(VCPU *vcpu, INST64 inst) { UINT64 fault, itir, ifa, pte, slot; //if (!vcpu_get_psr_ic(vcpu)) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_itir(vcpu,&itir)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_ifa(vcpu,&ifa)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); pte = vcpu_get_gr(vcpu,inst.M42.r2); slot = vcpu_get_gr(vcpu,inst.M42.r3); return (vcpu_itr_i(vcpu,slot,pte,itir,ifa)); } static IA64FAULT priv_itc_d(VCPU *vcpu, INST64 inst) { UINT64 fault, itir, ifa, pte; //if (!vcpu_get_psr_ic(vcpu)) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_itir(vcpu,&itir)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_ifa(vcpu,&ifa)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); pte = vcpu_get_gr(vcpu,inst.M41.r2); return (vcpu_itc_d(vcpu,pte,itir,ifa)); } static IA64FAULT priv_itc_i(VCPU *vcpu, INST64 inst) { UINT64 fault, itir, ifa, pte; //if (!vcpu_get_psr_ic(vcpu)) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_itir(vcpu,&itir)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); if ((fault = vcpu_get_ifa(vcpu,&ifa)) != IA64_NO_FAULT) return(IA64_ILLOP_FAULT); pte = vcpu_get_gr(vcpu,inst.M41.r2); return (vcpu_itc_i(vcpu,pte,itir,ifa)); } /************************************* * Moves to semi-privileged registers *************************************/ static IA64FAULT priv_mov_to_ar_imm(VCPU *vcpu, INST64 inst) { // I27 and M30 are identical for these fields UINT64 ar3 = inst.M30.ar3; UINT64 imm = vcpu_get_gr(vcpu,inst.M30.imm); return (vcpu_set_ar(vcpu,ar3,imm)); } static IA64FAULT priv_mov_to_ar_reg(VCPU *vcpu, INST64 inst) { // I26 and M29 are identical for these fields UINT64 ar3 = inst.M29.ar3; if (privify_en && inst.M29.r2 > 63 && inst.M29.ar3 < 8) { // privified mov from kr UINT64 val; if (vcpu_get_ar(vcpu,ar3,&val) != IA64_ILLOP_FAULT) return vcpu_set_gr(vcpu, inst.M29.r2-64, val,0); else return IA64_ILLOP_FAULT; } else { UINT64 r2 = vcpu_get_gr(vcpu,inst.M29.r2); return (vcpu_set_ar(vcpu,ar3,r2)); } } /******************************** * Moves to privileged registers ********************************/ static IA64FAULT priv_mov_to_pkr(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_pkr(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_rr(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_rr(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_dbr(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_dbr(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_ibr(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_ibr(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_pmc(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_pmc(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_pmd(VCPU *vcpu, INST64 inst) { UINT64 r3 = vcpu_get_gr(vcpu,inst.M42.r3); UINT64 r2 = vcpu_get_gr(vcpu,inst.M42.r2); return (vcpu_set_pmd(vcpu,r3,r2)); } static IA64FAULT priv_mov_to_cr(VCPU *vcpu, INST64 inst) { UINT64 val = vcpu_get_gr(vcpu, inst.M32.r2); privcnt.to_cr_cnt[inst.M32.cr3]++; switch (inst.M32.cr3) { case 0: return vcpu_set_dcr(vcpu,val); case 1: return vcpu_set_itm(vcpu,val); case 2: return vcpu_set_iva(vcpu,val); case 8: return vcpu_set_pta(vcpu,val); case 16:return vcpu_set_ipsr(vcpu,val); case 17:return vcpu_set_isr(vcpu,val); case 19:return vcpu_set_iip(vcpu,val); case 20:return vcpu_set_ifa(vcpu,val); case 21:return vcpu_set_itir(vcpu,val); case 22:return vcpu_set_iipa(vcpu,val); case 23:return vcpu_set_ifs(vcpu,val); case 24:return vcpu_set_iim(vcpu,val); case 25:return vcpu_set_iha(vcpu,val); case 64:return vcpu_set_lid(vcpu,val); case 65:return IA64_ILLOP_FAULT; case 66:return vcpu_set_tpr(vcpu,val); case 67:return vcpu_set_eoi(vcpu,val); case 68:return IA64_ILLOP_FAULT; case 69:return IA64_ILLOP_FAULT; case 70:return IA64_ILLOP_FAULT; case 71:return IA64_ILLOP_FAULT; case 72:return vcpu_set_itv(vcpu,val); case 73:return vcpu_set_pmv(vcpu,val); case 74:return vcpu_set_cmcv(vcpu,val); case 80:return vcpu_set_lrr0(vcpu,val); case 81:return vcpu_set_lrr1(vcpu,val); default: return IA64_ILLOP_FAULT; } } static IA64FAULT priv_rsm(VCPU *vcpu, INST64 inst) { UINT64 imm24 = (inst.M44.i<<23)|(inst.M44.i2<<21)|inst.M44.imm; return vcpu_reset_psr_sm(vcpu,imm24); } static IA64FAULT priv_ssm(VCPU *vcpu, INST64 inst) { UINT64 imm24 = (inst.M44.i<<23)|(inst.M44.i2<<21)|inst.M44.imm; return vcpu_set_psr_sm(vcpu,imm24); } /** * @todo Check for reserved bits and return IA64_RSVDREG_FAULT. */ static IA64FAULT priv_mov_to_psr(VCPU *vcpu, INST64 inst) { UINT64 val = vcpu_get_gr(vcpu, inst.M35.r2); return vcpu_set_psr_l(vcpu,val); } /********************************** * Moves from privileged registers **********************************/ static IA64FAULT priv_mov_from_rr(VCPU *vcpu, INST64 inst) { UINT64 val; IA64FAULT fault; UINT64 reg; reg = vcpu_get_gr(vcpu,inst.M43.r3); if (privify_en && inst.M43.r1 > 63) { // privified mov from cpuid fault = vcpu_get_cpuid(vcpu,reg,&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1-64, val, 0); } else { fault = vcpu_get_rr(vcpu,reg,&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1, val, 0); } return fault; } static IA64FAULT priv_mov_from_pkr(VCPU *vcpu, INST64 inst) { UINT64 val; IA64FAULT fault; fault = vcpu_get_pkr(vcpu,vcpu_get_gr(vcpu,inst.M43.r3),&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1, val, 0); else return fault; } static IA64FAULT priv_mov_from_dbr(VCPU *vcpu, INST64 inst) { UINT64 val; IA64FAULT fault; fault = vcpu_get_dbr(vcpu,vcpu_get_gr(vcpu,inst.M43.r3),&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1, val, 0); else return fault; } static IA64FAULT priv_mov_from_ibr(VCPU *vcpu, INST64 inst) { UINT64 val; IA64FAULT fault; fault = vcpu_get_ibr(vcpu,vcpu_get_gr(vcpu,inst.M43.r3),&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1, val, 0); else return fault; } static IA64FAULT priv_mov_from_pmc(VCPU *vcpu, INST64 inst) { UINT64 val; IA64FAULT fault; UINT64 reg; reg = vcpu_get_gr(vcpu,inst.M43.r3); if (privify_en && inst.M43.r1 > 63) { // privified mov from pmd fault = vcpu_get_pmd(vcpu,reg,&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1-64, val, 0); } else { fault = vcpu_get_pmc(vcpu,reg,&val); if (fault == IA64_NO_FAULT) return vcpu_set_gr(vcpu, inst.M43.r1, val, 0); } return fault; } #define cr_get(cr) \ ((fault = vcpu_get_##cr(vcpu,&val)) == IA64_NO_FAULT) ? \ vcpu_set_gr(vcpu, tgt, val, 0) : fault; static IA64FAULT priv_mov_from_cr(VCPU *vcpu, INST64 inst) { UINT64 tgt = inst.M33.r1; UINT64 val; IA64FAULT fault; privcnt.from_cr_cnt[inst.M33.cr3]++; switch (inst.M33.cr3) { case 0: return cr_get(dcr); case 1: return cr_get(itm); case 2: return cr_get(iva); case 8: return cr_get(pta); case 16:return cr_get(ipsr); case 17:return cr_get(isr); case 19:return cr_get(iip); case 20:return cr_get(ifa); case 21:return cr_get(itir); case 22:return cr_get(iipa); case 23:return cr_get(ifs); case 24:return cr_get(iim); case 25:return cr_get(iha); case 64:return cr_get(lid); case 65:return cr_get(ivr); case 66:return cr_get(tpr); case 67:return vcpu_set_gr(vcpu,tgt,0L,0); case 68:return cr_get(irr0); case 69:return cr_get(irr1); case 70:return cr_get(irr2); case 71:return cr_get(irr3); case 72:return cr_get(itv); case 73:return cr_get(pmv); case 74:return cr_get(cmcv); case 80:return cr_get(lrr0); case 81:return cr_get(lrr1); default: return IA64_ILLOP_FAULT; } return IA64_ILLOP_FAULT; } static IA64FAULT priv_mov_from_psr(VCPU *vcpu, INST64 inst) { UINT64 tgt = inst.M33.r1; UINT64 val; IA64FAULT fault; if ((fault = vcpu_get_psr(vcpu,&val)) == IA64_NO_FAULT) return vcpu_set_gr(vcpu, tgt, val, 0); else return fault; } /************************************************************************** Privileged operation decode and dispatch routines **************************************************************************/ static const IA64_SLOT_TYPE slot_types[0x20][3] = { {M, I, I}, {M, I, I}, {M, I, I}, {M, I, I}, {M, I, ILLEGAL}, {M, I, ILLEGAL}, {ILLEGAL, ILLEGAL, ILLEGAL}, {ILLEGAL, ILLEGAL, ILLEGAL}, {M, M, I}, {M, M, I}, {M, M, I}, {M, M, I}, {M, F, I}, {M, F, I}, {M, M, F}, {M, M, F}, {M, I, B}, {M, I, B}, {M, B, B}, {M, B, B}, {ILLEGAL, ILLEGAL, ILLEGAL}, {ILLEGAL, ILLEGAL, ILLEGAL}, {B, B, B}, {B, B, B}, {M, M, B}, {M, M, B}, {ILLEGAL, ILLEGAL, ILLEGAL}, {ILLEGAL, ILLEGAL, ILLEGAL}, {M, F, B}, {M, F, B}, {ILLEGAL, ILLEGAL, ILLEGAL}, {ILLEGAL, ILLEGAL, ILLEGAL} }; // pointer to privileged emulation function typedef IA64FAULT (*PPEFCN)(VCPU *vcpu, INST64 inst); static const PPEFCN Mpriv_funcs[64] = { priv_mov_to_rr, priv_mov_to_dbr, priv_mov_to_ibr, priv_mov_to_pkr, priv_mov_to_pmc, priv_mov_to_pmd, 0, 0, 0, priv_ptc_l, priv_ptc_g, priv_ptc_ga, priv_ptr_d, priv_ptr_i, priv_itr_d, priv_itr_i, priv_mov_from_rr, priv_mov_from_dbr, priv_mov_from_ibr, priv_mov_from_pkr, priv_mov_from_pmc, 0, 0, 0, 0, 0, 0, 0, 0, 0, priv_tpa, priv_tak, 0, 0, 0, 0, priv_mov_from_cr, priv_mov_from_psr, 0, 0, 0, 0, 0, 0, priv_mov_to_cr, priv_mov_to_psr, priv_itc_d, priv_itc_i, 0, 0, 0, 0, priv_ptc_e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; static IA64FAULT priv_handle_op(VCPU *vcpu, REGS *regs, int privlvl) { IA64_BUNDLE bundle; IA64_BUNDLE __get_domain_bundle(UINT64); int slot; IA64_SLOT_TYPE slot_type; INST64 inst; PPEFCN pfunc; unsigned long ipsr = regs->cr_ipsr; UINT64 iip = regs->cr_iip; int x6; // make a local copy of the bundle containing the privop if (!vcpu_get_domain_bundle(vcpu, regs, iip, &bundle)) { //return vcpu_force_data_miss(vcpu, regs->cr_iip); return vcpu_force_inst_miss(vcpu, regs->cr_iip); } #if 0 if (iip==0xa000000100001820) { static int firstpagefault = 1; if (firstpagefault) { printf("*** First time to domain page fault!\n"); firstpagefault=0; } } #endif if (privop_trace) { static long i = 400; //if (i > 0) printf("priv_handle_op: at 0x%lx\n",iip); if (i > 0) printf("priv_handle_op: privop trace at 0x%lx, itc=%lx, itm=%lx\n", iip,ia64_get_itc(),ia64_get_itm()); i--; } slot = ((struct ia64_psr *)&ipsr)->ri; if (!slot) inst.inst = (bundle.i64[0]>>5) & MASK_41; else if (slot == 1) inst.inst = ((bundle.i64[0]>>46) | bundle.i64[1]<<18) & MASK_41; else if (slot == 2) inst.inst = (bundle.i64[1]>>23) & MASK_41; else printf("priv_handle_op: illegal slot: %d\n", slot); slot_type = slot_types[bundle.template][slot]; if (priv_verbose) { printf("priv_handle_op: checking bundle at 0x%lx (op=0x%016lx) slot %d (type=%d)\n", iip, (UINT64)inst.inst, slot, slot_type); } if (slot_type == B && inst.generic.major == 0 && inst.B8.x6 == 0x0) { // break instr for privified cover } else if (privlvl != 2) return (IA64_ILLOP_FAULT); switch (slot_type) { case M: if (inst.generic.major == 0) { #if 0 if (inst.M29.x6 == 0 && inst.M29.x3 == 0) { privcnt.cover++; return priv_cover(vcpu,inst); } #endif if (inst.M29.x3 != 0) break; if (inst.M30.x4 == 8 && inst.M30.x2 == 2) { privcnt.mov_to_ar_imm++; return priv_mov_to_ar_imm(vcpu,inst); } if (inst.M44.x4 == 6) { privcnt.ssm++; return priv_ssm(vcpu,inst); } if (inst.M44.x4 == 7) { privcnt.rsm++; return priv_rsm(vcpu,inst); } break; } else if (inst.generic.major != 1) break; x6 = inst.M29.x6; if (x6 == 0x2a) { if (privify_en && inst.M29.r2 > 63 && inst.M29.ar3 < 8) privcnt.mov_from_ar++; // privified mov from kr else privcnt.mov_to_ar_reg++; return priv_mov_to_ar_reg(vcpu,inst); } if (inst.M29.x3 != 0) break; if (!(pfunc = Mpriv_funcs[x6])) break; if (x6 == 0x1e || x6 == 0x1f) { // tpa or tak are "special" if (privify_en && inst.M46.r3 > 63) { if (x6 == 0x1e) x6 = 0x1b; else x6 = 0x1a; } } if (privify_en && x6 == 52 && inst.M28.r3 > 63) privcnt.fc++; else if (privify_en && x6 == 16 && inst.M43.r3 > 63) privcnt.cpuid++; else privcnt.Mpriv_cnt[x6]++; return (*pfunc)(vcpu,inst); break; case B: if (inst.generic.major != 0) break; if (inst.B8.x6 == 0x08) { IA64FAULT fault; privcnt.rfi++; fault = priv_rfi(vcpu,inst); if (fault == IA64_NO_FAULT) fault = IA64_RFI_IN_PROGRESS; return fault; } if (inst.B8.x6 == 0x0c) { privcnt.bsw0++; return priv_bsw0(vcpu,inst); } if (inst.B8.x6 == 0x0d) { privcnt.bsw1++; return priv_bsw1(vcpu,inst); } if (inst.B8.x6 == 0x0) { // break instr for privified cover privcnt.cover++; return priv_cover(vcpu,inst); } break; case I: if (inst.generic.major != 0) break; #if 0 if (inst.I26.x6 == 0 && inst.I26.x3 == 0) { privcnt.cover++; return priv_cover(vcpu,inst); } #endif if (inst.I26.x3 != 0) break; // I26.x3 == I27.x3 if (inst.I26.x6 == 0x2a) { if (privify_en && inst.I26.r2 > 63 && inst.I26.ar3 < 8) privcnt.mov_from_ar++; // privified mov from kr else privcnt.mov_to_ar_reg++; return priv_mov_to_ar_reg(vcpu,inst); } if (inst.I27.x6 == 0x0a) { privcnt.mov_to_ar_imm++; return priv_mov_to_ar_imm(vcpu,inst); } break; default: break; } //printf("We who are about do die salute you\n"); printf("priv_handle_op: can't handle privop at 0x%lx (op=0x%016lx) slot %d (type=%d), ipsr=0x%lx\n", iip, (UINT64)inst.inst, slot, slot_type, ipsr); //printf("vtop(0x%lx)==0x%lx\n", iip, tr_vtop(iip)); //thread_mozambique("privop fault\n"); return (IA64_ILLOP_FAULT); } /** Emulate a privileged operation. * * This should probably return 0 on success and the "trap number" * (e.g. illegal operation for bad register, priv op for an * instruction that isn't allowed, etc.) on "failure" * * @param vcpu virtual cpu * @param isrcode interrupt service routine code * @return fault */ IA64FAULT priv_emulate(VCPU *vcpu, REGS *regs, UINT64 isr) { IA64FAULT fault; UINT64 ipsr = regs->cr_ipsr; UINT64 isrcode = (isr >> 4) & 0xf; int privlvl; // handle privops masked as illops? and breaks (6) if (isrcode != 1 && isrcode != 2 && isrcode != 0 && isrcode != 6) { printf("priv_emulate: isrcode != 0 or 1 or 2\n"); printf("priv_emulate: returning ILLOP, not implemented!\n"); while (1); return IA64_ILLOP_FAULT; } //if (isrcode != 1 && isrcode != 2) return 0; privlvl = (ipsr & IA64_PSR_CPL) >> IA64_PSR_CPL0_BIT; // its OK for a privified-cover to be executed in user-land fault = priv_handle_op(vcpu,regs,privlvl); if ((fault == IA64_NO_FAULT) || (fault == IA64_EXTINT_VECTOR)) { // success!! // update iip/ipsr to point to the next instruction (void)vcpu_increment_iip(vcpu); } if (fault == IA64_ILLOP_FAULT) printf("priv_emulate: priv_handle_op fails, isr=0x%lx\n",isr); return fault; } /* hyperprivops are generally executed in assembly (with physical psr.ic off) * so this code is primarily used for debugging them */ int ia64_hyperprivop(unsigned long iim, REGS *regs) { struct vcpu *v = current; UINT64 val; UINT64 itir, ifa; // FIXME: Handle faults appropriately for these if (!iim || iim > HYPERPRIVOP_MAX) { panic_domain(regs, "bad hyperprivop ignored; iim=%lx, " "iip=0x%lx\n", iim, regs->cr_iip); return 1; } slow_hyperpriv_cnt[iim]++; switch(iim) { case HYPERPRIVOP_RFI: (void)vcpu_rfi(v); return 0; // don't update iip case HYPERPRIVOP_RSM_DT: (void)vcpu_reset_psr_dt(v); return 1; case HYPERPRIVOP_SSM_DT: (void)vcpu_set_psr_dt(v); return 1; case HYPERPRIVOP_COVER: (void)vcpu_cover(v); return 1; case HYPERPRIVOP_ITC_D: (void)vcpu_get_itir(v,&itir); (void)vcpu_get_ifa(v,&ifa); (void)vcpu_itc_d(v,regs->r8,itir,ifa); return 1; case HYPERPRIVOP_ITC_I: (void)vcpu_get_itir(v,&itir); (void)vcpu_get_ifa(v,&ifa); (void)vcpu_itc_i(v,regs->r8,itir,ifa); return 1; case HYPERPRIVOP_SSM_I: (void)vcpu_set_psr_i(v); return 1; case HYPERPRIVOP_GET_IVR: (void)vcpu_get_ivr(v,&val); regs->r8 = val; return 1; case HYPERPRIVOP_GET_TPR: (void)vcpu_get_tpr(v,&val); regs->r8 = val; return 1; case HYPERPRIVOP_SET_TPR: (void)vcpu_set_tpr(v,regs->r8); return 1; case HYPERPRIVOP_EOI: (void)vcpu_set_eoi(v,0L); return 1; case HYPERPRIVOP_SET_ITM: (void)vcpu_set_itm(v,regs->r8); return 1; case HYPERPRIVOP_THASH: (void)vcpu_thash(v,regs->r8,&val); regs->r8 = val; return 1; case HYPERPRIVOP_PTC_GA: (void)vcpu_ptc_ga(v,regs->r8,(1L << ((regs->r9 & 0xfc) >> 2))); return 1; case HYPERPRIVOP_ITR_D: (void)vcpu_get_itir(v,&itir); (void)vcpu_get_ifa(v,&ifa); (void)vcpu_itr_d(v,regs->r8,regs->r9,itir,ifa); return 1; case HYPERPRIVOP_GET_RR: (void)vcpu_get_rr(v,regs->r8,&val); regs->r8 = val; return 1; case HYPERPRIVOP_SET_RR: (void)vcpu_set_rr(v,regs->r8,regs->r9); return 1; case HYPERPRIVOP_SET_KR: (void)vcpu_set_ar(v,regs->r8,regs->r9); return 1; case HYPERPRIVOP_FC: (void)vcpu_fc(v,regs->r8); return 1; case HYPERPRIVOP_GET_CPUID: (void)vcpu_get_cpuid(v,regs->r8,&val); regs->r8 = val; return 1; case HYPERPRIVOP_GET_PMD: (void)vcpu_get_pmd(v,regs->r8,&val); regs->r8 = val; return 1; case HYPERPRIVOP_GET_EFLAG: (void)vcpu_get_ar(v,24,&val); regs->r8 = val; return 1; case HYPERPRIVOP_SET_EFLAG: (void)vcpu_set_ar(v,24,regs->r8); return 1; } return 0; }