IA32/x64 architecture specific defintions needed by debug transfer protocol.It is only\r
intended to be used by Debug related module implementation.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
//\r
// IA-32/x64 processor register index table\r
//\r
-#define SOFT_DEBUGGER_REGISTER_DR0 0\r
-#define SOFT_DEBUGGER_REGISTER_DR1 1\r
-#define SOFT_DEBUGGER_REGISTER_DR2 2\r
-#define SOFT_DEBUGGER_REGISTER_DR3 3\r
-#define SOFT_DEBUGGER_REGISTER_DR6 4\r
-#define SOFT_DEBUGGER_REGISTER_DR7 5\r
-#define SOFT_DEBUGGER_REGISTER_EFLAGS 6\r
-#define SOFT_DEBUGGER_REGISTER_LDTR 7\r
-#define SOFT_DEBUGGER_REGISTER_TR 8\r
-#define SOFT_DEBUGGER_REGISTER_GDTR0 9 // the low 32bit of GDTR\r
-#define SOFT_DEBUGGER_REGISTER_GDTR1 10 // the high 32bit of GDTR\r
-#define SOFT_DEBUGGER_REGISTER_IDTR0 11 // the low 32bit of IDTR\r
-#define SOFT_DEBUGGER_REGISTER_IDTR1 12 // the high 32bot of IDTR\r
-#define SOFT_DEBUGGER_REGISTER_EIP 13\r
-#define SOFT_DEBUGGER_REGISTER_GS 14\r
-#define SOFT_DEBUGGER_REGISTER_FS 15\r
-#define SOFT_DEBUGGER_REGISTER_ES 16\r
-#define SOFT_DEBUGGER_REGISTER_DS 17\r
-#define SOFT_DEBUGGER_REGISTER_CS 18\r
-#define SOFT_DEBUGGER_REGISTER_SS 19\r
-#define SOFT_DEBUGGER_REGISTER_CR0 20\r
-#define SOFT_DEBUGGER_REGISTER_CR1 21\r
-#define SOFT_DEBUGGER_REGISTER_CR2 22\r
-#define SOFT_DEBUGGER_REGISTER_CR3 23\r
-#define SOFT_DEBUGGER_REGISTER_CR4 24\r
-\r
-#define SOFT_DEBUGGER_REGISTER_DI 25\r
-#define SOFT_DEBUGGER_REGISTER_SI 26\r
-#define SOFT_DEBUGGER_REGISTER_BP 27\r
-#define SOFT_DEBUGGER_REGISTER_SP 28\r
-#define SOFT_DEBUGGER_REGISTER_DX 29\r
-#define SOFT_DEBUGGER_REGISTER_CX 30\r
-#define SOFT_DEBUGGER_REGISTER_BX 31\r
-#define SOFT_DEBUGGER_REGISTER_AX 32\r
+#define SOFT_DEBUGGER_REGISTER_DR0 0x00\r
+#define SOFT_DEBUGGER_REGISTER_DR1 0x01\r
+#define SOFT_DEBUGGER_REGISTER_DR2 0x02\r
+#define SOFT_DEBUGGER_REGISTER_DR3 0x03\r
+#define SOFT_DEBUGGER_REGISTER_DR6 0x04\r
+#define SOFT_DEBUGGER_REGISTER_DR7 0x05\r
+#define SOFT_DEBUGGER_REGISTER_EFLAGS 0x06\r
+#define SOFT_DEBUGGER_REGISTER_LDTR 0x07\r
+#define SOFT_DEBUGGER_REGISTER_TR 0x08\r
+#define SOFT_DEBUGGER_REGISTER_GDTR0 0x09 // the low 32bit of GDTR\r
+#define SOFT_DEBUGGER_REGISTER_GDTR1 0x0A // the high 32bit of GDTR\r
+#define SOFT_DEBUGGER_REGISTER_IDTR0 0x0B // the low 32bit of IDTR\r
+#define SOFT_DEBUGGER_REGISTER_IDTR1 0x0C // the high 32bot of IDTR\r
+#define SOFT_DEBUGGER_REGISTER_EIP 0x0D\r
+#define SOFT_DEBUGGER_REGISTER_GS 0x0E\r
+#define SOFT_DEBUGGER_REGISTER_FS 0x0F\r
+#define SOFT_DEBUGGER_REGISTER_ES 0x10\r
+#define SOFT_DEBUGGER_REGISTER_DS 0x11\r
+#define SOFT_DEBUGGER_REGISTER_CS 0x12\r
+#define SOFT_DEBUGGER_REGISTER_SS 0x13\r
+#define SOFT_DEBUGGER_REGISTER_CR0 0x14\r
+#define SOFT_DEBUGGER_REGISTER_CR1 0x15\r
+#define SOFT_DEBUGGER_REGISTER_CR2 0x16\r
+#define SOFT_DEBUGGER_REGISTER_CR3 0x17\r
+#define SOFT_DEBUGGER_REGISTER_CR4 0x18\r
+\r
+#define SOFT_DEBUGGER_REGISTER_DI 0x19\r
+#define SOFT_DEBUGGER_REGISTER_SI 0x1A\r
+#define SOFT_DEBUGGER_REGISTER_BP 0x1B\r
+#define SOFT_DEBUGGER_REGISTER_SP 0x1C\r
+#define SOFT_DEBUGGER_REGISTER_DX 0x1D\r
+#define SOFT_DEBUGGER_REGISTER_CX 0x1E\r
+#define SOFT_DEBUGGER_REGISTER_BX 0x1F\r
+#define SOFT_DEBUGGER_REGISTER_AX 0x20\r
\r
//\r
// This below registers are only available for x64 (not valid for Ia32 mode)\r
//\r
-#define SOFT_DEBUGGER_REGISTER_CR8 33\r
-#define SOFT_DEBUGGER_REGISTER_R8 34\r
-#define SOFT_DEBUGGER_REGISTER_R9 35\r
-#define SOFT_DEBUGGER_REGISTER_R10 36\r
-#define SOFT_DEBUGGER_REGISTER_R11 37\r
-#define SOFT_DEBUGGER_REGISTER_R12 38\r
-#define SOFT_DEBUGGER_REGISTER_R13 39\r
-#define SOFT_DEBUGGER_REGISTER_R14 40\r
-#define SOFT_DEBUGGER_REGISTER_R15 41\r
-\r
-#define SOFT_DEBUGGER_REGISTER_MAX_COUNT_IA32 33\r
-#define SOFT_DEBUGGER_REGISTER_MAX_COUNT_X64 42\r
+#define SOFT_DEBUGGER_REGISTER_CR8 0x21\r
+#define SOFT_DEBUGGER_REGISTER_R8 0x22\r
+#define SOFT_DEBUGGER_REGISTER_R9 0x23\r
+#define SOFT_DEBUGGER_REGISTER_R10 0x24\r
+#define SOFT_DEBUGGER_REGISTER_R11 0x25\r
+#define SOFT_DEBUGGER_REGISTER_R12 0x26\r
+#define SOFT_DEBUGGER_REGISTER_R13 0x27\r
+#define SOFT_DEBUGGER_REGISTER_R14 0x28\r
+#define SOFT_DEBUGGER_REGISTER_R15 0x29\r
\r
//\r
// This below registers are FP / MMX / XMM registers\r
//\r
-#define SOFT_DEBUGGER_REGISTER_FP_BASE 50\r
-\r
-#define SOFT_DEBUGGER_REGISTER_FP_FCW (SOFT_DEBUGGER_REGISTER_FP_BASE + 0)\r
-#define SOFT_DEBUGGER_REGISTER_FP_FSW (SOFT_DEBUGGER_REGISTER_FP_BASE + 1)\r
-#define SOFT_DEBUGGER_REGISTER_FP_FTW (SOFT_DEBUGGER_REGISTER_FP_BASE + 2)\r
-#define SOFT_DEBUGGER_REGISTER_FP_OPCODE (SOFT_DEBUGGER_REGISTER_FP_BASE + 3)\r
-#define SOFT_DEBUGGER_REGISTER_FP_EIP (SOFT_DEBUGGER_REGISTER_FP_BASE + 4)\r
-#define SOFT_DEBUGGER_REGISTER_FP_CS (SOFT_DEBUGGER_REGISTER_FP_BASE + 5)\r
-#define SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET (SOFT_DEBUGGER_REGISTER_FP_BASE + 6)\r
-#define SOFT_DEBUGGER_REGISTER_FP_DS (SOFT_DEBUGGER_REGISTER_FP_BASE + 7)\r
-#define SOFT_DEBUGGER_REGISTER_FP_MXCSR (SOFT_DEBUGGER_REGISTER_FP_BASE + 8)\r
-#define SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK (SOFT_DEBUGGER_REGISTER_FP_BASE + 9)\r
-#define SOFT_DEBUGGER_REGISTER_ST0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 10)\r
-#define SOFT_DEBUGGER_REGISTER_ST1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 11)\r
-#define SOFT_DEBUGGER_REGISTER_ST2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 12)\r
-#define SOFT_DEBUGGER_REGISTER_ST3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 13)\r
-#define SOFT_DEBUGGER_REGISTER_ST4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 14)\r
-#define SOFT_DEBUGGER_REGISTER_ST5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 15)\r
-#define SOFT_DEBUGGER_REGISTER_ST6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 16)\r
-#define SOFT_DEBUGGER_REGISTER_ST7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 17)\r
-#define SOFT_DEBUGGER_REGISTER_XMM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 18)\r
-#define SOFT_DEBUGGER_REGISTER_XMM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 19)\r
-#define SOFT_DEBUGGER_REGISTER_XMM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 20)\r
-#define SOFT_DEBUGGER_REGISTER_XMM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 21)\r
-#define SOFT_DEBUGGER_REGISTER_XMM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 22)\r
-#define SOFT_DEBUGGER_REGISTER_XMM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 23)\r
-#define SOFT_DEBUGGER_REGISTER_XMM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 24)\r
-#define SOFT_DEBUGGER_REGISTER_XMM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 25)\r
-#define SOFT_DEBUGGER_REGISTER_XMM8 (SOFT_DEBUGGER_REGISTER_FP_BASE + 26)\r
-#define SOFT_DEBUGGER_REGISTER_XMM9 (SOFT_DEBUGGER_REGISTER_FP_BASE + 27)\r
-#define SOFT_DEBUGGER_REGISTER_XMM10 (SOFT_DEBUGGER_REGISTER_FP_BASE + 28)\r
-#define SOFT_DEBUGGER_REGISTER_XMM11 (SOFT_DEBUGGER_REGISTER_FP_BASE + 29)\r
-#define SOFT_DEBUGGER_REGISTER_XMM12 (SOFT_DEBUGGER_REGISTER_FP_BASE + 30)\r
-#define SOFT_DEBUGGER_REGISTER_XMM13 (SOFT_DEBUGGER_REGISTER_FP_BASE + 31)\r
-#define SOFT_DEBUGGER_REGISTER_XMM14 (SOFT_DEBUGGER_REGISTER_FP_BASE + 32)\r
-#define SOFT_DEBUGGER_REGISTER_XMM15 (SOFT_DEBUGGER_REGISTER_FP_BASE + 33)\r
-#define SOFT_DEBUGGER_REGISTER_MM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 34)\r
-#define SOFT_DEBUGGER_REGISTER_MM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 35)\r
-#define SOFT_DEBUGGER_REGISTER_MM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 36)\r
-#define SOFT_DEBUGGER_REGISTER_MM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 37)\r
-#define SOFT_DEBUGGER_REGISTER_MM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 38)\r
-#define SOFT_DEBUGGER_REGISTER_MM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 39)\r
-#define SOFT_DEBUGGER_REGISTER_MM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 40)\r
-#define SOFT_DEBUGGER_REGISTER_MM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 41)\r
+#define SOFT_DEBUGGER_REGISTER_FP_BASE 0x30\r
\r
-//\r
-// This below registers are for GDT, LDT, TSS\r
-//\r
-#define SOFT_DEBUGGER_REGISTER_OTHERS_BASE 100\r
-\r
-#define SOFT_DEBUGGER_REGISTER_CS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 0)\r
-#define SOFT_DEBUGGER_REGISTER_SS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 1)\r
-#define SOFT_DEBUGGER_REGISTER_GS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 2)\r
-#define SOFT_DEBUGGER_REGISTER_FS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 3)\r
-#define SOFT_DEBUGGER_REGISTER_ES_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 4)\r
-#define SOFT_DEBUGGER_REGISTER_DS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 5)\r
-#define SOFT_DEBUGGER_REGISTER_LDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 6)\r
-#define SOFT_DEBUGGER_REGISTER_TSS_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 7)\r
-\r
-#define SOFT_DEBUGGER_REGISTER_CS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 8)\r
-#define SOFT_DEBUGGER_REGISTER_SS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 9)\r
-#define SOFT_DEBUGGER_REGISTER_GS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 10)\r
-#define SOFT_DEBUGGER_REGISTER_FS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 11)\r
-#define SOFT_DEBUGGER_REGISTER_ES_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 12)\r
-#define SOFT_DEBUGGER_REGISTER_DS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 13)\r
-#define SOFT_DEBUGGER_REGISTER_LDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 14)\r
-#define SOFT_DEBUGGER_REGISTER_TSS_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 15)\r
-\r
-#define SOFT_DEBUGGER_REGISTER_CSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 16)\r
-#define SOFT_DEBUGGER_REGISTER_SSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 17)\r
-#define SOFT_DEBUGGER_REGISTER_GSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 18)\r
-#define SOFT_DEBUGGER_REGISTER_FSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 19)\r
-#define SOFT_DEBUGGER_REGISTER_ESAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 20)\r
-#define SOFT_DEBUGGER_REGISTER_DSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 21)\r
-#define SOFT_DEBUGGER_REGISTER_LDTAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 22)\r
-#define SOFT_DEBUGGER_REGISTER_TSSAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 23)\r
-\r
-#define SOFT_DEBUGGER_REGISTER_IDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 24)\r
-#define SOFT_DEBUGGER_REGISTER_GDT_LIM (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 25)\r
-#define SOFT_DEBUGGER_REGISTER_IDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 26)\r
-#define SOFT_DEBUGGER_REGISTER_GDT_BAS (SOFT_DEBUGGER_REGISTER_OTHERS_BASE + 27)\r
-\r
-\r
-#define SOFT_DEBUGGER_MSR_EFER (0xC0000080)\r
+#define SOFT_DEBUGGER_REGISTER_FP_FCW (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x00)\r
+#define SOFT_DEBUGGER_REGISTER_FP_FSW (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x01)\r
+#define SOFT_DEBUGGER_REGISTER_FP_FTW (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x02)\r
+#define SOFT_DEBUGGER_REGISTER_FP_OPCODE (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x03)\r
+#define SOFT_DEBUGGER_REGISTER_FP_EIP (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x04)\r
+#define SOFT_DEBUGGER_REGISTER_FP_CS (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x05)\r
+#define SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x06)\r
+#define SOFT_DEBUGGER_REGISTER_FP_DS (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x07)\r
+#define SOFT_DEBUGGER_REGISTER_FP_MXCSR (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x08)\r
+#define SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x09)\r
+#define SOFT_DEBUGGER_REGISTER_ST0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0A)\r
+#define SOFT_DEBUGGER_REGISTER_ST1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0B)\r
+#define SOFT_DEBUGGER_REGISTER_ST2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0C)\r
+#define SOFT_DEBUGGER_REGISTER_ST3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0D)\r
+#define SOFT_DEBUGGER_REGISTER_ST4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0E)\r
+#define SOFT_DEBUGGER_REGISTER_ST5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x0F)\r
+#define SOFT_DEBUGGER_REGISTER_ST6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x10)\r
+#define SOFT_DEBUGGER_REGISTER_ST7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x11)\r
+#define SOFT_DEBUGGER_REGISTER_XMM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x12)\r
+#define SOFT_DEBUGGER_REGISTER_XMM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x13)\r
+#define SOFT_DEBUGGER_REGISTER_XMM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x14)\r
+#define SOFT_DEBUGGER_REGISTER_XMM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x15)\r
+#define SOFT_DEBUGGER_REGISTER_XMM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x16)\r
+#define SOFT_DEBUGGER_REGISTER_XMM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x17)\r
+#define SOFT_DEBUGGER_REGISTER_XMM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x18)\r
+#define SOFT_DEBUGGER_REGISTER_XMM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x19)\r
+#define SOFT_DEBUGGER_REGISTER_XMM8 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1A)\r
+#define SOFT_DEBUGGER_REGISTER_XMM9 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1B)\r
+#define SOFT_DEBUGGER_REGISTER_XMM10 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1C)\r
+#define SOFT_DEBUGGER_REGISTER_XMM11 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1D)\r
+#define SOFT_DEBUGGER_REGISTER_XMM12 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1E)\r
+#define SOFT_DEBUGGER_REGISTER_XMM13 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x1F)\r
+#define SOFT_DEBUGGER_REGISTER_XMM14 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x20)\r
+#define SOFT_DEBUGGER_REGISTER_XMM15 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x21)\r
+#define SOFT_DEBUGGER_REGISTER_MM0 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x22)\r
+#define SOFT_DEBUGGER_REGISTER_MM1 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x23)\r
+#define SOFT_DEBUGGER_REGISTER_MM2 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x24)\r
+#define SOFT_DEBUGGER_REGISTER_MM3 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x25)\r
+#define SOFT_DEBUGGER_REGISTER_MM4 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x26)\r
+#define SOFT_DEBUGGER_REGISTER_MM5 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x27)\r
+#define SOFT_DEBUGGER_REGISTER_MM6 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x28)\r
+#define SOFT_DEBUGGER_REGISTER_MM7 (SOFT_DEBUGGER_REGISTER_FP_BASE + 0x29)\r
\r
-//\r
-// Definition for the Index field for DEBUG_DATA_READ_REGISTER_GROUP\r
-//\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_GPDRS32 1 //for cs,ds,es,fs,gs,ss,eflags,ebp,eip,esp,eax,ebx,ecx,edx,esi,edi,dr0,dr1,dr2,dr3,dr6,dr7\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_LIMITS32 2 //for cslim,sslim,gslim,fslim,eslim,dslim,ldtlim,tsslim\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES32 3 //for csbas,ssbas,gsbas,fsbas,esbas,dsbas,ldtbas,tssbas\r
-\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT64 4 //for cs,ds,es,fs,gs,ss\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_GP2_64 5 //for eflags,rbp,rip,rsp\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_GP64 6 //for rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12,r13,r14,r15\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_DR64 7 //for dr0,dr1,dr2,dr3,dr6,dr7\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BAS_LIM64 8 //for ldtbas,ldtlim,gdtbas,gdtlim,cslim,sslim,gslim,fslim,eslim,dslim,ldtlim,tsslim,csbas,ssbas,gsbas,fsbas,esbas,dsbas,ldtbas,tssbas\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES64 9 //for idtr,tr,csas,ssas,gsas,fsas,esas,dsas,idtas,tssas\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_CR64 10 //for cr0,cr2,cr3,cr4,cr8\r
-#define SOFT_DEBUGGER_REGISTER_GROUP_XMM64 11 //for xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6,xmm7,xmm8,xmm9,xmm10,xmm11,xmm12,xmm13,xmm14,xmm15\r
+#define SOFT_DEBUGGER_REGISTER_MAX SOFT_DEBUGGER_REGISTER_MM7\r
+\r
+#define SOFT_DEBUGGER_MSR_EFER (0xC0000080)\r
+\r
+#pragma pack(1)\r
+\r
+///\r
+/// FXSAVE_STATE\r
+/// FP / MMX / XMM registers (see fxrstor instruction definition)\r
+///\r
+typedef struct {\r
+ UINT16 Fcw;\r
+ UINT16 Fsw;\r
+ UINT16 Ftw;\r
+ UINT16 Opcode;\r
+ UINT32 Eip;\r
+ UINT16 Cs;\r
+ UINT16 Reserved1;\r
+ UINT32 DataOffset;\r
+ UINT16 Ds;\r
+ UINT8 Reserved2[2];\r
+ UINT32 Mxcsr;\r
+ UINT32 Mxcsr_Mask;\r
+ UINT8 St0Mm0[10];\r
+ UINT8 Reserved3[6];\r
+ UINT8 St1Mm1[10];\r
+ UINT8 Reserved4[6];\r
+ UINT8 St2Mm2[10];\r
+ UINT8 Reserved5[6];\r
+ UINT8 St3Mm3[10];\r
+ UINT8 Reserved6[6];\r
+ UINT8 St4Mm4[10];\r
+ UINT8 Reserved7[6];\r
+ UINT8 St5Mm5[10];\r
+ UINT8 Reserved8[6];\r
+ UINT8 St6Mm6[10];\r
+ UINT8 Reserved9[6];\r
+ UINT8 St7Mm7[10];\r
+ UINT8 Reserved10[6];\r
+ UINT8 Xmm0[16];\r
+ UINT8 Xmm1[16];\r
+ UINT8 Xmm2[16];\r
+ UINT8 Xmm3[16];\r
+ UINT8 Xmm4[16];\r
+ UINT8 Xmm5[16];\r
+ UINT8 Xmm6[16];\r
+ UINT8 Xmm7[16];\r
+ UINT8 Reserved11[14 * 16];\r
+} DEBUG_DATA_IA32_FX_SAVE_STATE;\r
+\r
+///\r
+/// IA-32 processor context definition\r
+///\r
+typedef struct {\r
+ UINT32 ExceptionData;\r
+ DEBUG_DATA_IA32_FX_SAVE_STATE FxSaveState;\r
+ UINT32 Dr0;\r
+ UINT32 Dr1;\r
+ UINT32 Dr2;\r
+ UINT32 Dr3;\r
+ UINT32 Dr6;\r
+ UINT32 Dr7;\r
+ UINT32 Eflags;\r
+ UINT32 Ldtr;\r
+ UINT32 Tr;\r
+ UINT32 Gdtr[2];\r
+ UINT32 Idtr[2];\r
+ UINT32 Eip;\r
+ UINT32 Gs;\r
+ UINT32 Fs;\r
+ UINT32 Es;\r
+ UINT32 Ds;\r
+ UINT32 Cs;\r
+ UINT32 Ss;\r
+ UINT32 Cr0;\r
+ UINT32 Cr1; ///< Reserved\r
+ UINT32 Cr2;\r
+ UINT32 Cr3;\r
+ UINT32 Cr4;\r
+ UINT32 Edi;\r
+ UINT32 Esi;\r
+ UINT32 Ebp;\r
+ UINT32 Esp;\r
+ UINT32 Edx;\r
+ UINT32 Ecx;\r
+ UINT32 Ebx;\r
+ UINT32 Eax;\r
+} DEBUG_DATA_IA32_SYSTEM_CONTEXT;\r
+\r
+///\r
+/// FXSAVE_STATE\r
+/// FP / MMX / XMM registers (see fxrstor instruction definition)\r
+///\r
+typedef struct {\r
+ UINT16 Fcw;\r
+ UINT16 Fsw;\r
+ UINT16 Ftw;\r
+ UINT16 Opcode;\r
+ UINT32 Eip;\r
+ UINT16 Cs;\r
+ UINT16 Reserved1;\r
+ UINT32 DataOffset;\r
+ UINT16 Ds;\r
+ UINT8 Reserved2[2];\r
+ UINT32 Mxcsr;\r
+ UINT32 Mxcsr_Mask;\r
+ UINT8 St0Mm0[10];\r
+ UINT8 Reserved3[6];\r
+ UINT8 St1Mm1[10];\r
+ UINT8 Reserved4[6];\r
+ UINT8 St2Mm2[10];\r
+ UINT8 Reserved5[6];\r
+ UINT8 St3Mm3[10];\r
+ UINT8 Reserved6[6];\r
+ UINT8 St4Mm4[10];\r
+ UINT8 Reserved7[6];\r
+ UINT8 St5Mm5[10];\r
+ UINT8 Reserved8[6];\r
+ UINT8 St6Mm6[10];\r
+ UINT8 Reserved9[6];\r
+ UINT8 St7Mm7[10];\r
+ UINT8 Reserved10[6];\r
+ UINT8 Xmm0[16];\r
+ UINT8 Xmm1[16];\r
+ UINT8 Xmm2[16];\r
+ UINT8 Xmm3[16];\r
+ UINT8 Xmm4[16];\r
+ UINT8 Xmm5[16];\r
+ UINT8 Xmm6[16];\r
+ UINT8 Xmm7[16];\r
+ UINT8 Xmm8[16];\r
+ UINT8 Xmm9[16];\r
+ UINT8 Xmm10[16];\r
+ UINT8 Xmm11[16];\r
+ UINT8 Xmm12[16];\r
+ UINT8 Xmm13[16];\r
+ UINT8 Xmm14[16];\r
+ UINT8 Xmm15[16];\r
+ UINT8 Reserved11[6 * 16];\r
+} DEBUG_DATA_X64_FX_SAVE_STATE;\r
+\r
+///\r
+/// x64 processor context definition\r
+///\r
+typedef struct {\r
+ UINT64 ExceptionData;\r
+ DEBUG_DATA_X64_FX_SAVE_STATE FxSaveState;\r
+ UINT64 Dr0;\r
+ UINT64 Dr1;\r
+ UINT64 Dr2;\r
+ UINT64 Dr3;\r
+ UINT64 Dr6;\r
+ UINT64 Dr7;\r
+ UINT64 Eflags;\r
+ UINT64 Ldtr;\r
+ UINT64 Tr;\r
+ UINT64 Gdtr[2];\r
+ UINT64 Idtr[2];\r
+ UINT64 Eip;\r
+ UINT64 Gs;\r
+ UINT64 Fs;\r
+ UINT64 Es;\r
+ UINT64 Ds;\r
+ UINT64 Cs;\r
+ UINT64 Ss;\r
+ UINT64 Cr0;\r
+ UINT64 Cr1; ///< Reserved\r
+ UINT64 Cr2;\r
+ UINT64 Cr3;\r
+ UINT64 Cr4;\r
+ UINT64 Rdi;\r
+ UINT64 Rsi;\r
+ UINT64 Rbp;\r
+ UINT64 Rsp;\r
+ UINT64 Rdx;\r
+ UINT64 Rcx;\r
+ UINT64 Rbx;\r
+ UINT64 Rax;\r
+ UINT64 Cr8;\r
+ UINT64 R8;\r
+ UINT64 R9;\r
+ UINT64 R10;\r
+ UINT64 R11;\r
+ UINT64 R12;\r
+ UINT64 R13;\r
+ UINT64 R14;\r
+ UINT64 R15;\r
+} DEBUG_DATA_X64_SYSTEM_CONTEXT;\r
\r
+#pragma pack()\r
\r
#endif\r
\r
+++ /dev/null
-/** @file\r
- Soft Debugger defintions. The definitions will also be used as part\r
- of debug transfer protocol. It is only intended to be used by Debug\r
- related module implementation.\r
-\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef __SOFT_DEBUGGER_DEFINITIONS_H__\r
-#define __SOFT_DEBUGGER_DEFINITIONS_H__\r
-\r
-//\r
-// Definition for processor mode (IA16, IA32, X64, ...)\r
-//\r
-#define SOFT_DEBUGGER_PROCESSOR_IA16 0\r
-#define SOFT_DEBUGGER_PROCESSOR_IA32 1\r
-#define SOFT_DEBUGGER_PROCESSOR_X64 2\r
-\r
-//\r
-// Break cause defintions\r
-//\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_UNKNOWN 0\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_HW_BREAKPOINT 1\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_STEPPING 2\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_SW_BREAKPOINT 3\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_USER_HALT 4\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_IMAGE_LOAD 5\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_IMAGE_UNLOAD 6\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_SYSTEM_RESET 7\r
-#define SOFT_DEBUGGER_BREAK_CAUSE_EXCEPTION 8\r
-\r
-#define SOFT_DEBUGGER_SETTING_SMM_ENTRY_BREAK 1\r
-\r
-#endif\r
#define __TRANSFER_PROTOCOL_H__\r
\r
#include "ProcessorContext.h"\r
-#include "SoftDebuggerDefinitions.h"\r
+\r
+//\r
+// Current revision of transfer protocol\r
+//\r
+#define DEBUG_AGENT_REVISION ((0 << 16) | 02)\r
+#define DEBUG_AGENT_CAPABILITIES 0\r
\r
//\r
// Definitions for break command.\r
//\r
-#define DEBUG_STARTING_SYMBOL_BREAK (0x21) // '!'\r
-#define DEBUG_STARTING_SYMBOL_BREAK_STRING ("!")\r
+#define DEBUG_STARTING_SYMBOL_BREAK (0xFC)\r
+\r
+//\r
+// Definitions for attach command\r
+//\r
+#define DEBUG_STARTING_SYMBOL_ATTACH (0xFA)\r
\r
//\r
-// Definition for starting symbol of a normal debug packet. Choose a non-ASCII to avoid conflict with other serial output.\r
+// Definition for starting symbol of a normal debug packet. Choose a non-ASCII to avoid conflict with other serial output.\r
//\r
#define DEBUG_STARTING_SYMBOL_NORMAL (0xFE)\r
\r
#pragma pack(1)\r
\r
//\r
-// Definition for common header for normal debug packets (not including break command)\r
+// Definition for debug packet header for normal debug packets (not including break/attach command)\r
//\r
typedef struct {\r
UINT8 StartSymbol;\r
UINT8 Command;\r
- UINT8 DataLength;\r
-} DEBUG_COMMAND_HEADER;\r
-\r
-//\r
-// Structure to facilitate debug packet header parsing or construction\r
-//\r
-typedef struct {\r
- UINT8 Command;\r
- UINT8 DataLength;\r
-} DEBUG_COMMAND_HEADER_NO_START_SYMBOL;\r
-\r
+ UINT8 Length; // Length of Debug Packet including header and payload in byte\r
+ UINT8 CheckSum;\r
+} DEBUG_PACKET_HEADER;\r
\r
//\r
// Definition for Command field for debug packets\r
#define DEBUG_COMMAND_REQUEST (0 << 7)\r
#define DEBUG_COMMAND_RESPONSE (1 << 7)\r
\r
-\r
-\r
-#define DEBUG_COMMAND_RESET (DEBUG_COMMAND_REQUEST | 0) // 0\r
-\r
-#define DEBUG_COMMAND_GO (DEBUG_COMMAND_REQUEST | 1) // 1\r
-\r
-#define DEBUG_COMMAND_BREAK_CAUSE (DEBUG_COMMAND_REQUEST | 2) // 2\r
-\r
-#define DEBUG_COMMAND_SET_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 3) // 3\r
-#define DEBUG_COMMAND_CLEAR_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 4) // 4\r
-\r
-#define DEBUG_COMMAND_SINGLE_STEPPING (DEBUG_COMMAND_REQUEST | 5) // 5\r
-\r
-#define DEBUG_COMMAND_SET_SW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 6) // 6\r
-#define DEBUG_COMMAND_CLEAR_SW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 7) // 7\r
-\r
-#define DEBUG_COMMAND_READ_MEMORY_8 (DEBUG_COMMAND_REQUEST | 8) // 8\r
-#define DEBUG_COMMAND_READ_MEMORY_16 (DEBUG_COMMAND_REQUEST | 9) // 9\r
-#define DEBUG_COMMAND_READ_MEMORY_32 (DEBUG_COMMAND_REQUEST | 10) // 10\r
-#define DEBUG_COMMAND_READ_MEMORY_64 (DEBUG_COMMAND_REQUEST | 11) // 11\r
-\r
-#define DEBUG_COMMAND_WRITE_MEMORY_8 (DEBUG_COMMAND_REQUEST | 12) // 12\r
-#define DEBUG_COMMAND_WRITE_MEMORY_16 (DEBUG_COMMAND_REQUEST | 13) // 13\r
-#define DEBUG_COMMAND_WRITE_MEMORY_32 (DEBUG_COMMAND_REQUEST | 14) // 14\r
-#define DEBUG_COMMAND_WRITE_MEMORY_64 (DEBUG_COMMAND_REQUEST | 15) // 15\r
-\r
-#define DEBUG_COMMAND_READ_IO (DEBUG_COMMAND_REQUEST | 16) // 16\r
-#define DEBUG_COMMAND_WRITE_IO (DEBUG_COMMAND_REQUEST | 20) // 20\r
-\r
-#define DEBUG_COMMAND_READ_REGISTER (DEBUG_COMMAND_REQUEST | 24) // 24\r
-#define DEBUG_COMMAND_WRITE_REGISTER (DEBUG_COMMAND_REQUEST | 26) // 26\r
-\r
-#define DEBUG_COMMAND_STEP_OVER (DEBUG_COMMAND_REQUEST | 28) // 28\r
-#define DEBUG_COMMAND_STEP_OUT (DEBUG_COMMAND_REQUEST | 29) // 29\r
-#define DEBUG_COMMAND_STEP_BRANCH (DEBUG_COMMAND_REQUEST | 30) // 30\r
-\r
-#define DEBUG_COMMAND_ARCH_MODE (DEBUG_COMMAND_REQUEST | 34) // 34\r
-\r
-#define DEBUG_COMMAND_READ_MSR (DEBUG_COMMAND_REQUEST | 35) // 35\r
-#define DEBUG_COMMAND_WRITE_MSR (DEBUG_COMMAND_REQUEST | 36) // 36\r
-\r
-#define DEBUG_COMMAND_READ_REGISTER_GROUP (DEBUG_COMMAND_REQUEST | 37) // 37\r
-\r
-#define DEBUG_COMMAND_SET_DEBUG_FLAG (DEBUG_COMMAND_REQUEST | 38) // 38\r
-\r
-#define DEBUG_COMMAND_GET_REVISION (DEBUG_COMMAND_REQUEST | 39) // 39\r
-\r
-#define DEBUG_COMMAND_GET_EXCEPTION (DEBUG_COMMAND_REQUEST | 40) // 40\r
-\r
-#define DEBUG_COMMAND_SET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 41) // 41\r
-\r
-#define DEBUG_COMMAND_GET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 42) // 42\r
-\r
-//\r
-// The below are target side initiated commands.\r
//\r
-#define DEBUG_COMMAND_INIT_BREAK (DEBUG_COMMAND_REQUEST | 63) // 63\r
-#define DEBUG_COMMAND_BREAK_POINT (DEBUG_COMMAND_REQUEST | 62) // 62\r
-#define DEBUG_COMMAND_MEMORY_READY (DEBUG_COMMAND_REQUEST | 61) // 61\r
-\r
-#define DEBUG_COMMAND_OK (DEBUG_COMMAND_RESPONSE | 0)\r
-#define DEBUG_COMMAND_RESEND (DEBUG_COMMAND_RESPONSE | 1)\r
-#define DEBUG_COMMAND_ABORT (DEBUG_COMMAND_RESPONSE | 2)\r
-\r
-//\r
-// The below 2 commands are used when transferring big data (like > ~250 bytes). The sequence is:\r
-// Host Macine Target Macine\r
-// Request =>\r
-// <= IN_PROGRESS with part of the data\r
-// CONTINUE =>\r
-// (could have multiple IN_PROGRESS and CONTINUE interactions)\r
-// <= OK with the last part of data\r
-// OK (no data as ACK) =>\r
-//\r
-#define DEBUG_COMMAND_IN_PROGRESS (DEBUG_COMMAND_RESPONSE | 3) // Used when trying to\r
-#define DEBUG_COMMAND_CONTINUE (DEBUG_COMMAND_RESPONSE | 4) // Used when trying to transfer big data (like > ~250 bytes)\r
-\r
-//\r
-// The below 2 commands are used to support deferred halt. HALT_DEFERRED will be returned when a halt request received while target is already in inter-active mode.\r
-// HALT_PROCESSED will be return as a possible return value for GO command, if target has a pending halt request.\r
-//\r
-#define DEBUG_COMMAND_HALT_DEFERRED (DEBUG_COMMAND_RESPONSE | 5)\r
-#define DEBUG_COMMAND_HALT_PROCESSED (DEBUG_COMMAND_RESPONSE | 6)\r
-\r
-#define DEBUG_COMMAND_TIMEOUT (DEBUG_COMMAND_RESPONSE | 7)\r
-#define DEBUG_COMMAND_NOT_SUPPORTED (DEBUG_COMMAND_RESPONSE | 15)\r
+// HOST initiated commands\r
+//\r
+#define DEBUG_COMMAND_RESET (DEBUG_COMMAND_REQUEST | 0x00)\r
+#define DEBUG_COMMAND_GO (DEBUG_COMMAND_REQUEST | 0x01)\r
+#define DEBUG_COMMAND_BREAK_CAUSE (DEBUG_COMMAND_REQUEST | 0x02)\r
+#define DEBUG_COMMAND_SET_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 0x03)\r
+#define DEBUG_COMMAND_CLEAR_HW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 0x04)\r
+#define DEBUG_COMMAND_SINGLE_STEPPING (DEBUG_COMMAND_REQUEST | 0x05)\r
+#define DEBUG_COMMAND_SET_SW_BREAKPOINT (DEBUG_COMMAND_REQUEST | 0x06)\r
+#define DEBUG_COMMAND_READ_MEMORY (DEBUG_COMMAND_REQUEST | 0x07)\r
+#define DEBUG_COMMAND_WRITE_MEMORY (DEBUG_COMMAND_REQUEST | 0x08)\r
+#define DEBUG_COMMAND_READ_IO (DEBUG_COMMAND_REQUEST | 0x09)\r
+#define DEBUG_COMMAND_WRITE_IO (DEBUG_COMMAND_REQUEST | 0x0A)\r
+#define DEBUG_COMMAND_READ_REGISTER (DEBUG_COMMAND_REQUEST | 0x0B)\r
+#define DEBUG_COMMAND_WRITE_REGISTER (DEBUG_COMMAND_REQUEST | 0x0C)\r
+#define DEBUG_COMMAND_READ_ALL_REGISTERS (DEBUG_COMMAND_REQUEST | 0x0D)\r
+#define DEBUG_COMMAND_ARCH_MODE (DEBUG_COMMAND_REQUEST | 0x0E)\r
+#define DEBUG_COMMAND_READ_MSR (DEBUG_COMMAND_REQUEST | 0x0F)\r
+#define DEBUG_COMMAND_WRITE_MSR (DEBUG_COMMAND_REQUEST | 0x10)\r
+#define DEBUG_COMMAND_SET_DEBUG_SETTING (DEBUG_COMMAND_REQUEST | 0x11)\r
+#define DEBUG_COMMAND_GET_REVISION (DEBUG_COMMAND_REQUEST | 0x12)\r
+#define DEBUG_COMMAND_GET_EXCEPTION (DEBUG_COMMAND_REQUEST | 0x13)\r
+#define DEBUG_COMMAND_SET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 0x14)\r
+#define DEBUG_COMMAND_GET_VIEWPOINT (DEBUG_COMMAND_REQUEST | 0x15)\r
+#define DEBUG_COMMAND_DETACH (DEBUG_COMMAND_REQUEST | 0x16)\r
+#define DEBUG_COMMAND_CPUID (DEBUG_COMMAND_REQUEST | 0x17)\r
+#define DEBUG_COMMAND_SEARCH_SIGNATURE (DEBUG_COMMAND_REQUEST | 0x18)\r
+\r
+//\r
+// TARGET initiated commands\r
+//\r
+#define DEBUG_COMMAND_INIT_BREAK (DEBUG_COMMAND_REQUEST | 0x3F)\r
+#define DEBUG_COMMAND_BREAK_POINT (DEBUG_COMMAND_REQUEST | 0x3E)\r
+#define DEBUG_COMMAND_MEMORY_READY (DEBUG_COMMAND_REQUEST | 0x3D)\r
+#define DEBUG_COMMAND_PRINT_MESSAGE (DEBUG_COMMAND_REQUEST | 0x3C)\r
+\r
+//\r
+// Response commands\r
+//\r
+#define DEBUG_COMMAND_OK (DEBUG_COMMAND_RESPONSE | 0x00)\r
+#define DEBUG_COMMAND_RESEND (DEBUG_COMMAND_RESPONSE | 0x01)\r
+#define DEBUG_COMMAND_ABORT (DEBUG_COMMAND_RESPONSE | 0x02)\r
+//\r
+// The below 2 commands are used when transferring big data (like > ~250 bytes).\r
+// The sequence is:\r
+// HOST TARGET\r
+// Request =>\r
+// <= IN_PROGRESS with partial data\r
+// CONTINUE =>\r
+// (could have multiple IN_PROGRESS and CONTINUE interactions)\r
+// <= OK with the last part of data\r
+// OK (no data as ACK) =>\r
+//\r
+#define DEBUG_COMMAND_IN_PROGRESS (DEBUG_COMMAND_RESPONSE | 0x03)\r
+#define DEBUG_COMMAND_CONTINUE (DEBUG_COMMAND_RESPONSE | 0x04)\r
+//\r
+// The below 2 commands are used to support deferred halt:\r
+// TARGET returns HALT_DEFERRED when it receives a HALT request in inter-active mode.\r
+// TARGET returns HALT_PROCESSED when it receives a GO request and has a pending HALT request.\r
+//\r
+#define DEBUG_COMMAND_HALT_DEFERRED (DEBUG_COMMAND_RESPONSE | 0x05)\r
+#define DEBUG_COMMAND_HALT_PROCESSED (DEBUG_COMMAND_RESPONSE | 0x06)\r
+\r
+#define DEBUG_COMMAND_TIMEOUT (DEBUG_COMMAND_RESPONSE | 0x07)\r
+#define DEBUG_COMMAND_NOT_SUPPORTED (DEBUG_COMMAND_RESPONSE | 0x0F)\r
\r
//\r
// Definition for data field for debug packets\r
//\r
-#define DEBUG_DATA_MAXIMUM_LENGTH_FOR_SMALL_COMMANDS 20\r
-\r
-#define DEBUG_DATA_UPPER_LIMIT 0xff // This is the upper limit for the data size, by the limit of the packet header definition.\r
-\r
-#define DEBUG_DATA_MAXIMUM_REAL_DATA 0xf8\r
+#define DEBUG_DATA_UPPER_LIMIT 0xff // Upper limit for the data size, by the limit of the packet header definition.\r
\r
-#define DEBUG_DEFINITION_MAX_IO_LENGTH 4\r
+#define DEBUG_DATA_MAXIMUM_REAL_DATA (DEBUG_DATA_UPPER_LIMIT - sizeof (DEBUG_PACKET_HEADER))\r
\r
//\r
// Response data for DEBUG_COMMAND_BREAK_CAUSE\r
UINT8 Cause;\r
UINT64 StopAddress;\r
} DEBUG_DATA_RESPONSE_BREAK_CAUSE;\r
-\r
//\r
// Break type defintions for DEBUG_DATA_BREAK_CAUSE\r
//\r
typedef struct {\r
UINT8 CpuMode;\r
} DEBUG_DATA_RESPONSE_ARCH_MODE;\r
-\r
//\r
// Cpu architecture defintions for DEBUG_DATA_RESPONSE_ARCH_MODE\r
//\r
#define DEBUG_DATA_BREAK_CPU_ARCH_IA32 1\r
#define DEBUG_DATA_BREAK_CPU_ARCH_X64 2\r
\r
-//\r
-// Command and response data for DEBUG_COMMAND_XX_YY_BREAKPOINT\r
-//\r
typedef struct {\r
UINT8 Length:2; // Refer to below DEBUG_DATA_BREAKPOINT_LENGTH_XX macros\r
UINT8 Access:2; // Refer to below DEBUG_DATA_BREAKPOINT_ACCESS_XX macros\r
UINT8 Index:2; // Index of debug register\r
UINT8 Reserved:2;\r
} DEBUG_DATA_BREAKPOINT_TYPE;\r
-\r
-#define DEBUG_DATA_BREAKPOINT_MEMORY_ACCESS (0x11)\r
-#define DEBUG_DATA_BREAKPOINT_IO_ACCESS (0x10)\r
-#define DEBUG_DATA_BREAKPOINT_MEMORY_WRITE (0x01)\r
-#define DEBUG_DATA_BREAKPOINT_MEMORY_EXECUTE (0x00)\r
-\r
-#define DEBUG_DATA_BREAKPOINT_LENGTH_64 (0x11)\r
-#define DEBUG_DATA_BREAKPOINT_LENGTH_32 (0x10)\r
-#define DEBUG_DATA_BREAKPOINT_LENGTH_16 (0x01)\r
-#define DEBUG_DATA_BREAKPOINT_LENGTH_8 (0x00)\r
+#define DEBUG_DATA_BREAKPOINT_MEMORY_ACCESS (0x3)\r
+#define DEBUG_DATA_BREAKPOINT_IO_ACCESS (0x2)\r
+#define DEBUG_DATA_BREAKPOINT_MEMORY_WRITE (0x1)\r
+#define DEBUG_DATA_BREAKPOINT_MEMORY_EXECUTE (0x0)\r
+#define DEBUG_DATA_BREAKPOINT_LENGTH_32 (0x3)\r
+#define DEBUG_DATA_BREAKPOINT_LENGTH_64 (0x2)\r
+#define DEBUG_DATA_BREAKPOINT_LENGTH_16 (0x1)\r
+#define DEBUG_DATA_BREAKPOINT_LENGTH_8 (0x0)\r
\r
//\r
-// Command data for DEBUG_COMMAND_SET_HW_BREAKPOINT\r
+// Request data for DEBUG_COMMAND_SET_HW_BREAKPOINT\r
//\r
typedef struct {\r
DEBUG_DATA_BREAKPOINT_TYPE Type;\r
} DEBUG_DATA_SET_HW_BREAKPOINT;\r
\r
//\r
-// Command data for DEBUG_COMMAND_CLEAR_HW_BREAKPOINT\r
+// Request data for DEBUG_COMMAND_CLEAR_HW_BREAKPOINT\r
//\r
typedef struct {\r
UINT8 IndexMask; // 0x0f will clear all hw breakpoints\r
} DEBUG_DATA_CLEAR_HW_BREAKPOINT;\r
\r
//\r
-// Command data for DEBUG_COMMAND_SET_SW_BREAKPOINT\r
+// Request and response data for DEBUG_COMMAND_SET_SW_BREAKPOINT\r
//\r
typedef struct {\r
UINT64 Address;\r
} DEBUG_DATA_SET_SW_BREAKPOINT;\r
\r
-//\r
-// Response data for DEBUG_COMMAND_SET_SW_BREAKPOINT\r
-//\r
typedef struct {\r
UINT8 OriginalData;\r
} DEBUG_DATA_RESPONSE_SET_SW_BREAKPOINT;\r
\r
//\r
-// Command data for DEBUG_COMMAND_CLEAR_SW_BREAKPOINT\r
-//\r
-typedef DEBUG_DATA_SET_SW_BREAKPOINT DEBUG_DATA_CLEAR_SW_BREAKPOINT;\r
-\r
-//\r
-// Command data for DEBUG_COMMAND_READ_MEMORY_XX\r
+// Request data for DEBUG_COMMAND_READ_MEMORY\r
//\r
typedef struct {\r
UINT64 Address;\r
+ UINT8 Width;\r
UINT16 Count;\r
-} DEBUG_DATA_READ_MEMORY_8;\r
-\r
-typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_16;\r
-\r
-typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_32;\r
-\r
-typedef DEBUG_DATA_READ_MEMORY_8 DEBUG_DATA_READ_MEMORY_64;\r
+} DEBUG_DATA_READ_MEMORY;\r
\r
//\r
-// Command data for DEBUG_COMMAND_WRITE_MEMORY_XX\r
+// Request data for DEBUG_COMMAND_WRITE_MEMORY\r
//\r
typedef struct {\r
UINT64 Address;\r
+ UINT8 Width;\r
UINT16 Count;\r
- UINT8 Data; // The actual length for this field is decided by Width x Count\r
-} DEBUG_DATA_WRITE_MEMORY_8;\r
-\r
-typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_16;\r
-\r
-typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_32;\r
-\r
-typedef DEBUG_DATA_WRITE_MEMORY_8 DEBUG_DATA_WRITE_MEMORY_64;\r
+ UINT8 Data[1]; // The actual length is (Width * Count)\r
+} DEBUG_DATA_WRITE_MEMORY;\r
\r
//\r
-// Command data for DEBUG_COMMAND_READ_IO\r
+// Request and response data for DEBUG_COMMAND_READ_IO\r
//\r
typedef struct {\r
- UINT16 Port;\r
+ UINT64 Port;\r
UINT8 Width;\r
} DEBUG_DATA_READ_IO;\r
\r
-//\r
-// Response data for DEBUG_COMMAND_READ_IO\r
-//\r
typedef struct {\r
- UINT8 Data; // The actual length of this structure will be adjusted according to the Width field\r
+ UINT8 Data[1]; // The actual length depends on the packet header\r
} DEBUG_DATA_RESPONSE_READ_IO;\r
\r
//\r
-// Command data for DEBUG_COMMAND_WRITE_IO\r
+// Request data for DEBUG_COMMAND_WRITE_IO\r
//\r
typedef struct {\r
- UINT16 Port;\r
+ UINT64 Port;\r
UINT8 Width;\r
- UINT8 Data; // The actual length of this structure will be adjusted according to the Width field\r
+ UINT8 Data[1]; // The actual length is Width\r
} DEBUG_DATA_WRITE_IO;\r
\r
//\r
-// Command data for DEBUG_COMMAND_READ_REGISTER\r
+// Request data for DEBUG_COMMAND_READ_REGISTER\r
//\r
typedef struct {\r
- UINT8 Index; // defined as DEBUG_DEFINITION_REGISTER_XX\r
- UINT8 Offset:4;\r
- UINT8 Length:4;\r
+ UINT8 Index; // defined as SOFT_DEBUGGER_REGISTER_XX\r
} DEBUG_DATA_READ_REGISTER;\r
\r
//\r
-// Command data for DEBUG_COMMAND_WRITE_REGISTER\r
+// Request data for DEBUG_COMMAND_WRITE_REGISTER\r
//\r
typedef struct {\r
- UINT8 Index; // defined as DEBUG_DEFINITION_REGISTER_XX\r
- UINT8 Offset:4;\r
- UINT8 Length:4;\r
- UINT64 Value;\r
+ UINT8 Index; // defined as SOFT_DEBUGGER_REGISTER_XX\r
+ UINT8 Length;\r
+ UINT8 Data[1]; // The actual length is Length\r
} DEBUG_DATA_WRITE_REGISTER;\r
\r
//\r
-// Command data for DEBUG_COMMAND_READ_MSR\r
+// Request and response data for DEBUG_COMMAND_READ_MSR\r
//\r
typedef struct {\r
UINT32 Index;\r
} DEBUG_DATA_READ_MSR;\r
\r
-//\r
-// Response data for DEBUG_COMMAND_READ_MSR\r
-//\r
typedef struct {\r
UINT64 Value;\r
} DEBUG_DATA_RESPONSE_READ_MSR;\r
\r
//\r
-// Command data for DEBUG_COMMAND_WRITE_MSR\r
+// Request data for DEBUG_COMMAND_WRITE_MSR\r
//\r
typedef struct {\r
UINT32 Index;\r
UINT64 Value;\r
} DEBUG_DATA_WRITE_MSR;\r
\r
-//\r
-// Command data for DEBUG_COMMAND_READ_REGISTER_GROUP\r
-//\r
-typedef struct {\r
- // For possible values, refer to the definition for DEBUG_DEFINITION_REGISTER_GROUP_XXX (in another .h file as it is architecture specific)\r
- UINT8 Index;\r
-} DEBUG_DATA_READ_REGISTER_GROUP;\r
-\r
//\r
// Response data for DEBUG_COMMAND_GET_REVISION\r
//\r
//\r
typedef struct {\r
UINT8 ExceptionNum;\r
- UINT64 ExceptionData;\r
+ UINT32 ExceptionData;\r
} DEBUG_DATA_RESPONSE_GET_EXCEPTION;\r
\r
-typedef struct {\r
- UINT8 DRn; // The index of DR register which to be used as temporary breakpoint\r
-} DEBUG_DATA_STEP_OVER;\r
-\r
//\r
-// Command data for DEBUG_COMMAND_SET_DEBUG_FLAG\r
+// Request data for DEBUG_DATA_SET_DEBUG_SETTING\r
//\r
typedef struct {\r
- UINT32 DebugFlag; // The index of DR register which to be used as temporary breakpoint\r
-} DEBUG_DATA_SET_DEBUG_FLAG;\r
+ UINT8 Key;\r
+ UINT8 Value;\r
+} DEBUG_DATA_SET_DEBUG_SETTING;\r
+//\r
+// Supported keys\r
+//\r
+#define DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK 1\r
+#define DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL 2\r
+//\r
+// Bitmask of print error level for debug message\r
+//\r
+#define DEBUG_AGENT_ERROR BIT0\r
+#define DEBUG_AGENT_WARNING BIT1\r
+#define DEBUG_AGENT_INFO BIT2\r
+#define DEBUG_AGENT_VERBOSE BIT3\r
\r
//\r
-// Command data for DEBUG_COMMAND_SET_VIEWPOINT\r
-// If viewpoint is changed successfully, DEBUG_COMMAND_OK will be returned.\r
-// If viewpoint is not availabe, DEBUG_COMMAND_NOT_SUPPORTED will be returned.\r
+// Request data for DEBUG_COMMAND_SET_VIEWPOINT\r
//\r
typedef struct {\r
UINT32 ViewPoint; // The index of viewpoint will be set\r
UINT32 ViewPoint; // The index of viewpoint will be returned\r
} DEBUG_DATA_RESPONSE_GET_VIEWPOINT;\r
\r
-#pragma pack()\r
+//\r
+// Request and response data for DEBUG_COMMAND_CPUID\r
+//\r
+typedef struct {\r
+ UINT32 Eax; // The value of EAX prior to invoking the CPUID instruction\r
+ UINT32 Ecx; // The value of ECX prior to invoking the CPUID instruction\r
+} DEBUG_DATA_CPUID;\r
+\r
+typedef struct {\r
+ UINT32 Eax; // The value of EAX returned by the CPUID instruction\r
+ UINT32 Ebx; // The value of EBX returned by the CPUID instruction\r
+ UINT32 Ecx; // The value of ECX returned by the CPUID instruction\r
+ UINT32 Edx; // The value of EDX returned by the CPUID instruction\r
+} DEBUG_DATA_RESPONSE_CPUID;\r
\r
-#define DEBUG_PACKET_CONSTRUCTOR_WITH_NO_DATA(DebugPacket,ShortCommandType) \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL; \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->Command = DEBUG_COMMAND_##ShortCommandType; \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->DataLength = 0;\r
-\r
-#define DEBUG_PACKET_CONSTRUCTOR_WITH_DATA(DebugPacket,ShortCommandType, DebugPacketDataPointer, PacketLength) \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL; \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->Command = DEBUG_COMMAND_##ShortCommandType; \\r
- ((DEBUG_COMMAND_HEADER *)DebugPacket)->DataLength = sizeof (DEBUG_DATA_##ShortCommandType); \\r
- *DebugPacketDataPointer = (DEBUG_DATA_##ShortCommandType *)((DEBUG_COMMAND_HEADER *)DebugPacket+1); \\r
- *PacketLength = sizeof (DEBUG_COMMAND_HEADER) + sizeof (DEBUG_DATA_##ShortCommandType);\r
+//\r
+// Request and response data for DEBUG_COMMAND_SEARCH_SIGNATURE\r
+//\r
+typedef struct {\r
+ UINT64 Start;\r
+ UINT32 Count;\r
+ UINT32 Alignment;\r
+ BOOLEAN Positive; // TRUE to search in higher address memory\r
+ UINT8 DataLength;\r
+ UINT8 Data[1];\r
+} DEBUG_DATA_SEARCH_SIGNATURE;\r
+\r
+typedef struct {\r
+ UINT64 Address; // -1 indicates not found\r
+} DEBUG_DATA_RESPONSE_SEARCH_SIGNATURE;\r
+\r
+#pragma pack()\r
\r
#endif\r
\r
#include "DebugAgent.h"\r
#include "Ia32/DebugException.h"\r
\r
+#define INIT_BREAK_ACK_TIMEOUT (200 * 1000)\r
+\r
+CHAR8 mErrorMsgVersionAlert[] = "\rThe SourceLevelDebugPkg you are using requires a newer version of the Intel(R) UDK Debugger Tool.\r\n";\r
+CHAR8 mErrorMsgSendInitPacket[] = "\rSend INIT break packet to HOST ...\r\n";\r
+CHAR8 mErrorMsgConnectOK[] = "HOST connection is successful!\r\n";\r
+CHAR8 mErrorMsgConnectFail[] = "HOST connection is failed!\r\n";\r
+\r
/**\r
- Check if HOST is connected based on Mailbox.\r
+ Send a debug message packet to the debug port.\r
\r
- @retval TRUE HOST is connected.\r
- @retval FALSE HOST is not connected.\r
+ @param[in] Buffer The debug message.\r
+ @param[in] Length The length of debug message.\r
\r
**/\r
-BOOLEAN\r
-IsHostConnected (\r
- VOID\r
+VOID\r
+SendDebugMsgPacket (\r
+ IN CHAR8 *Buffer,\r
+ IN UINTN Length \r
)\r
{\r
- DEBUG_AGENT_MAILBOX *Mailbox;\r
+ DEBUG_PACKET_HEADER DebugHeader;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ \r
+ Handle = GetDebugPortHandle();\r
\r
- Mailbox = GetMailboxPointer ();\r
+ DebugHeader.StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;\r
+ DebugHeader.Command = DEBUG_COMMAND_PRINT_MESSAGE;\r
+ DebugHeader.Length = sizeof (DEBUG_PACKET_HEADER) + (UINT8) Length;\r
+ DebugHeader.CheckSum = 0;\r
+ DebugHeader.CheckSum = CalculateCheckSum8 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));\r
\r
- if (Mailbox->DebugFlag.Bits.HostPresent == 1) {\r
- return TRUE;\r
- } else {\r
- return FALSE;\r
+ DebugPortWriteBuffer (Handle, (UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));\r
+ DebugPortWriteBuffer (Handle, (UINT8 *)Buffer, Length);\r
+}\r
+\r
+/**\r
+ Prints a debug message to the debug port if the specified error level is enabled.\r
+\r
+ If any bit in ErrorLevel is also set in Mainbox, then print the message specified\r
+ by Format and the associated variable argument list to the debug port.\r
+\r
+ @param[in] ErrorLevel The error level of the debug message.\r
+ @param[in] Format Format string for the debug message to print.\r
+ @param[in] ... Variable argument list whose contents are accessed \r
+ based on the format string specified by Format.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+DebugAgentMsgPrint (\r
+ IN UINT8 ErrorLevel,\r
+ IN CHAR8 *Format,\r
+ ...\r
+ )\r
+{\r
+ DEBUG_AGENT_MAILBOX *Mailbox;\r
+ CHAR8 Buffer[DEBUG_DATA_MAXIMUM_REAL_DATA];\r
+ VA_LIST Marker;\r
+\r
+ Mailbox = GetMailboxPointer ();\r
+ //\r
+ // Check driver debug mask value and global mask\r
+ //\r
+ if ((ErrorLevel & Mailbox->DebugFlag.PrintErrorLevel) == 0) {\r
+ return;\r
}\r
+\r
+ //\r
+ // Convert the DEBUG() message to an ASCII String\r
+ //\r
+ VA_START (Marker, Format);\r
+ AsciiVSPrint (Buffer, sizeof (Buffer), Format, Marker);\r
+ VA_END (Marker);\r
+\r
+ SendDebugMsgPacket (Buffer, AsciiStrLen (Buffer));\r
}\r
\r
/**\r
- Set HOST connect flag in Mailbox.\r
+ Prints a debug message to the debug output device if the specified error level is enabled.\r
+\r
+ If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function \r
+ GetDebugPrintErrorLevel (), then print the message specified by Format and the \r
+ associated variable argument list to the debug output device.\r
+\r
+ If Format is NULL, then ASSERT().\r
+\r
+ @param[in] ErrorLevel The error level of the debug message.\r
+ @param[in] IsSend Flag of debug message to declare that the data is being sent or being received.\r
+ @param[in] Data Variable argument list whose contents are accessed \r
+ @param[in] Length based on the format string specified by Format.\r
\r
**/\r
VOID\r
-SetHostConnectedFlag (\r
- VOID\r
+EFIAPI\r
+DebugAgentDataMsgPrint (\r
+ IN UINT8 ErrorLevel,\r
+ IN BOOLEAN IsSend,\r
+ IN UINT8 *Data,\r
+ IN UINT8 Length \r
)\r
{\r
- DEBUG_AGENT_MAILBOX *Mailbox;\r
+ DEBUG_AGENT_MAILBOX *Mailbox;\r
+ CHAR8 Buffer[DEBUG_DATA_MAXIMUM_REAL_DATA];\r
+ CHAR8 *DestBuffer;\r
+ UINTN Index;\r
\r
Mailbox = GetMailboxPointer ();\r
+ //\r
+ // Check driver debug mask value and global mask\r
+ //\r
+ if ((ErrorLevel & Mailbox->DebugFlag.PrintErrorLevel) == 0) {\r
+ return;\r
+ }\r
+\r
+ DestBuffer = Buffer;\r
+ if (IsSend) {\r
+ DestBuffer += AsciiSPrint (DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA, "Sent data [ ");\r
+ } else {\r
+ DestBuffer += AsciiSPrint (DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA, "Received data [ ");\r
+ }\r
\r
- Mailbox->DebugFlag.Bits.HostPresent = 1;\r
+ Index = 0;\r
+ while (TRUE) {\r
+ if (DestBuffer - Buffer > DEBUG_DATA_MAXIMUM_REAL_DATA - 6) {\r
+ //\r
+ // If there was no enough space in buffer, send out the debug message, \r
+ // reserving 6 bytes is for the last data and end characters "]\n".\r
+ //\r
+ SendDebugMsgPacket (Buffer, DestBuffer - Buffer);\r
+ DestBuffer = Buffer;\r
+ }\r
+ DestBuffer += AsciiSPrint (DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA - (DestBuffer - Buffer), "%02x ", Data[Index]);\r
+ Index ++;\r
+ if (Index >= Length) {\r
+ //s\r
+ // The last character of debug message has been foramtted in buffer\r
+ //\r
+ DestBuffer += AsciiSPrint(DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA - (DestBuffer - Buffer), "]\n");\r
+ SendDebugMsgPacket (Buffer, DestBuffer - Buffer);\r
+ break;\r
+ }\r
+ }\r
}\r
\r
+\r
/**\r
- Set debug flag of Debug Agent in Mailbox.\r
+ Check if HOST is attached based on Mailbox.\r
\r
- @param DebugFlag Debug Flag defined by transfer protocol.\r
+ @retval TRUE HOST is attached.\r
+ @retval FALSE HOST is not attached.\r
\r
+**/\r
+BOOLEAN\r
+IsHostAttached (\r
+ VOID\r
+ )\r
+{\r
+ return (BOOLEAN) (GetMailboxPointer ()->DebugFlag.HostAttached == 1);\r
+}\r
+\r
+/**\r
+ Set HOST connect flag in Mailbox.\r
+\r
+ @param[in] Attached Attach status.\r
+ \r
**/\r
VOID\r
-SetDebugFlag (\r
- IN UINT32 DebugFlag\r
+SetHostAttached (\r
+ IN BOOLEAN Attached\r
)\r
{\r
+ DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Attach status is %d\n", Attached);\r
+ GetMailboxPointer ()->DebugFlag.HostAttached = Attached;\r
+}\r
+\r
+/**\r
+ Set debug setting of Debug Agent in Mailbox.\r
+\r
+ @param DebugSetting Pointer to Debug Setting defined by transfer protocol.\r
+ \r
+ @retval RETURN_SUCCESS The setting is set successfully.\r
+ @retval RETURN_UNSUPPORTED The Key value is not supported.\r
+\r
+**/\r
+RETURN_STATUS\r
+SetDebugSetting (\r
+ IN DEBUG_DATA_SET_DEBUG_SETTING *DebugSetting \r
+ )\r
+{\r
+ RETURN_STATUS Status;\r
DEBUG_AGENT_MAILBOX *Mailbox;\r
\r
Mailbox = GetMailboxPointer ();\r
\r
- if ((DebugFlag & SOFT_DEBUGGER_SETTING_SMM_ENTRY_BREAK) != 0) {\r
- Mailbox->DebugFlag.Bits.BreakOnNextSmi = 1;\r
- } else {\r
- Mailbox->DebugFlag.Bits.BreakOnNextSmi = 0;\r
+ Status = RETURN_SUCCESS;\r
+ switch (DebugSetting->Key) {\r
+ case DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK:\r
+ Mailbox->DebugFlag.BreakOnNextSmi = DebugSetting->Value;\r
+ break;\r
+ case DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL:\r
+ Mailbox->DebugFlag.PrintErrorLevel = DebugSetting->Value;\r
+ break;\r
+ default:\r
+ Status = RETURN_UNSUPPORTED;\r
}\r
+ return Status;\r
}\r
\r
/**\r
//\r
// Set RWx and Lenx\r
//\r
- Dr7Value &= ~(0xf0000 << (RegisterIndex * 4));\r
- Dr7Value |= (SetHwBreakpoint->Type.Length | SetHwBreakpoint->Type.Access) << (RegisterIndex * 4);\r
+ Dr7Value &= ~(0xf << (16 + RegisterIndex * 4));\r
+ Dr7Value |= (UINTN) ((SetHwBreakpoint->Type.Length << 2) | SetHwBreakpoint->Type.Access) << (16 + RegisterIndex * 4);\r
//\r
// Enable GE, LE\r
//\r
}\r
}\r
\r
+\r
/**\r
- Send acknowledge packet to HOST.\r
+ Return the offset of FP / MMX / XMM registers in the FPU saved state by register index.\r
\r
- @param[in] AckCommand Type of Acknowledge packet.\r
+ @param[in] Index Register index.\r
+ @param[out] Width Register width returned.\r
+\r
+ @return Offset in the FPU Save State.\r
+\r
+**/\r
+UINT16\r
+ArchReadFxStatOffset (\r
+ IN UINT8 Index,\r
+ OUT UINT8 *Width\r
+ )\r
+{\r
+ if (Index < SOFT_DEBUGGER_REGISTER_ST0) {\r
+ switch (Index) {\r
+ case SOFT_DEBUGGER_REGISTER_FP_FCW:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Fcw);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_FSW:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Fsw);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_FTW:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Ftw);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_OPCODE:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Opcode);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_EIP:\r
+ *Width = (UINT8) sizeof (UINT32);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Eip);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_CS:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Cs);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET:\r
+ *Width = (UINT8) sizeof (UINT32);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, DataOffset);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_DS:\r
+ *Width = (UINT8) sizeof (UINT16);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Ds);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_MXCSR:\r
+ *Width = (UINT8) sizeof (UINT32);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Mxcsr);\r
+\r
+ case SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK:\r
+ *Width = (UINT8) sizeof (UINT32);\r
+ return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE, Mxcsr_Mask);\r
+ }\r
+ }\r
+\r
+ if (Index <= SOFT_DEBUGGER_REGISTER_ST7) {\r
+ *Width = 10;\r
+ } else if (Index <= SOFT_DEBUGGER_REGISTER_XMM15) {\r
+ *Width = 16;\r
+ } else {\r
+ //\r
+ // MMX register\r
+ //\r
+ *Width = 8;\r
+ Index -= SOFT_DEBUGGER_REGISTER_MM0 - SOFT_DEBUGGER_REGISTER_ST0;\r
+ }\r
+\r
+ return OFFSET_OF (DEBUG_DATA_FX_SAVE_STATE, St0Mm0) + (Index - SOFT_DEBUGGER_REGISTER_ST0) * 16;\r
+}\r
+\r
+/**\r
+ Return the pointer of the register value in the CPU saved context.\r
+\r
+ @param[in] CpuContext Pointer to saved CPU context.\r
+ @param[in] Index Register index value.\r
+ @param[out] Width Data width to read.\r
+\r
+ @return The pointer in the CPU saved context.\r
+\r
+**/\r
+UINT8 *\r
+ArchReadRegisterBuffer (\r
+ IN DEBUG_CPU_CONTEXT *CpuContext,\r
+ IN UINT8 Index,\r
+ OUT UINT8 *Width\r
+ )\r
+{\r
+ UINT8 *Buffer;\r
+\r
+ if (Index < SOFT_DEBUGGER_REGISTER_FP_BASE) {\r
+ Buffer = (UINT8 *) CpuContext + OFFSET_OF (DEBUG_CPU_CONTEXT, Dr0) + Index * sizeof (UINTN);\r
+ *Width = (UINT8) sizeof (UINTN);\r
+ } else {\r
+ //\r
+ // FPU/MMX/XMM registers\r
+ //\r
+ Buffer = (UINT8 *) CpuContext + OFFSET_OF (DEBUG_CPU_CONTEXT, FxSaveState) + ArchReadFxStatOffset (Index, Width);\r
+ }\r
+\r
+ return Buffer;\r
+}\r
+\r
+/**\r
+ Send the packet without data to HOST.\r
+\r
+ @param[in] CommandType Type of Command.\r
\r
**/\r
VOID\r
-SendAckPacket (\r
- IN UINT8 AckCommand\r
+SendPacketWithoutData (\r
+ IN UINT8 CommandType\r
)\r
{\r
- DEBUG_COMMAND_HEADER DebugCommonHeader;\r
+ DEBUG_PACKET_HEADER DebugHeader;\r
DEBUG_PORT_HANDLE Handle;\r
\r
Handle = GetDebugPortHandle();\r
\r
- DebugCommonHeader.StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;\r
- DebugCommonHeader.Command = AckCommand;\r
- DebugCommonHeader.DataLength = 0;\r
+ DebugHeader.StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;\r
+ DebugHeader.Command = CommandType;\r
+ DebugHeader.Length = sizeof (DEBUG_PACKET_HEADER);\r
+ DebugHeader.CheckSum = 0;\r
+ DebugHeader.CheckSum = CalculateCheckSum8 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));\r
\r
- DebugPortWriteBuffer (Handle, (UINT8 *) &DebugCommonHeader, sizeof (DEBUG_COMMAND_HEADER));\r
+ DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, TRUE, (UINT8 *) &DebugHeader, DebugHeader.Length);\r
+ DebugPortWriteBuffer (Handle, (UINT8 *) &DebugHeader, DebugHeader.Length);\r
+}\r
+\r
+/**\r
+ Send acknowledge packet to HOST.\r
+\r
+ @param[in] AckCommand Type of Acknowledge packet.\r
+\r
+**/\r
+VOID\r
+SendAckPacket (\r
+ IN UINT8 AckCommand\r
+ )\r
+{\r
+ if (AckCommand != DEBUG_COMMAND_OK) {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Send ACK(%d)\n", AckCommand);\r
+ }\r
+ SendPacketWithoutData (AckCommand);\r
}\r
\r
/**\r
Receive acknowledge packet from HOST in specified time.\r
\r
- @param[out] Ack Returned acknowlege type from HOST.\r
- @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
- The unit is microsecond.\r
- @param[out] BreakReceived If BreakReceived is not NULL,\r
- TRUE is retured if break-in symbol received.\r
- FALSE is retured if break-in symbol not received.\r
+ @param[out] Ack Returned acknowlege type from HOST.\r
+ @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
+ The unit is microsecond.\r
+ @param[out] BreakReceived If BreakReceived is not NULL,\r
+ TRUE is retured if break-in symbol received.\r
+ FALSE is retured if break-in symbol not received.\r
+ @param[out] CheckSumStatus If CheckSumStatus is not NULL,\r
+ RETURN_SUCCESS CheckSum is OK.\r
+ RETURN_NOT_FOUND Not find the CheckSum field.\r
\r
@retval RETRUEN_SUCCESS Succeed to receive acknowlege packet from HOST,\r
the type of acknowlege packet saved in Ack.\r
ReceiveAckPacket (\r
OUT UINT8 *Ack,\r
IN UINTN Timeout,\r
- OUT BOOLEAN *BreakReceived OPTIONAL\r
+ OUT BOOLEAN *BreakReceived, OPTIONAL\r
+ OUT RETURN_STATUS *CheckSumStatus OPTIONAL\r
)\r
{\r
- DEBUG_COMMAND_HEADER DebugCommonHeader;\r
+ DEBUG_PACKET_HEADER DebugHeader;\r
DEBUG_PORT_HANDLE Handle;\r
\r
Handle = GetDebugPortHandle();\r
\r
while (TRUE) {\r
- if (DebugPortReadBuffer (Handle, (UINT8 *) &DebugCommonHeader.StartSymbol, 1, Timeout) == 0) {\r
+ if (DebugPortReadBuffer (Handle, (UINT8 *) &DebugHeader.StartSymbol, sizeof (DebugHeader.StartSymbol), Timeout) == 0) {\r
return RETURN_TIMEOUT;\r
}\r
- if (DebugCommonHeader.StartSymbol == DEBUG_STARTING_SYMBOL_BREAK) {\r
+ if (DebugHeader.StartSymbol == DEBUG_STARTING_SYMBOL_BREAK) {\r
if (BreakReceived != NULL) {\r
SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);\r
*BreakReceived = TRUE;\r
}\r
}\r
- if (DebugCommonHeader.StartSymbol == DEBUG_STARTING_SYMBOL_NORMAL) {\r
+ if (DebugHeader.StartSymbol == DEBUG_STARTING_SYMBOL_NORMAL) {\r
break;\r
}\r
+ DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Invalid start symbol received [%02x]\n", DebugHeader.StartSymbol);\r
}\r
- if (DebugPortReadBuffer (Handle, (UINT8 *)&DebugCommonHeader.Command, sizeof (DEBUG_COMMAND_HEADER) - 1, Timeout) == 0) {\r
+ //\r
+ // Read ACK packet header till field Length (not including StartSymbol and CheckSum)\r
+ //\r
+ DebugHeader.Length = 0;\r
+ if (DebugPortReadBuffer (\r
+ Handle,\r
+ (UINT8 *)&DebugHeader.Command,\r
+ OFFSET_OF (DEBUG_PACKET_HEADER, Length) + sizeof (DebugHeader.Length) - sizeof (DebugHeader.StartSymbol),\r
+ Timeout\r
+ ) == 0) {\r
return RETURN_TIMEOUT;\r
}\r
\r
- *Ack = DebugCommonHeader.Command;\r
+ if (DebugHeader.Length == 0) {\r
+ //\r
+ // The CheckSum field does not exist\r
+ //\r
+ if (CheckSumStatus != NULL) {\r
+ *CheckSumStatus = RETURN_NOT_FOUND;\r
+ }\r
+ } else {\r
+ if (CheckSumStatus != NULL) {\r
+ *CheckSumStatus = RETURN_SUCCESS;\r
+ }\r
+ if (DebugPortReadBuffer (Handle, &DebugHeader.CheckSum, sizeof (DebugHeader.CheckSum), Timeout) == 0) {\r
+ return RETURN_TIMEOUT;\r
+ }\r
+ }\r
+\r
+ DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *)&DebugHeader, DebugHeader.Length);\r
+ *Ack = DebugHeader.Command;\r
return RETURN_SUCCESS;\r
}\r
\r
/**\r
Receive acknowledge packet OK from HOST in specified time.\r
\r
- @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
- The unit is microsecond.\r
- @param[out] BreakReceived If BreakReceived is not NULL,\r
- TRUE is retured if break-in symbol received.\r
- FALSE is retured if break-in symbol not received.\r
+ @param[in] Command The command type issued by TARGET.\r
+ @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
+ The unit is microsecond.\r
+ @param[out] BreakReceived If BreakReceived is not NULL,\r
+ TRUE is retured if break-in symbol received.\r
+ FALSE is retured if break-in symbol not received.\r
+ @param[out] CheckSumStatus If CheckSumStatus is not NULL,\r
+ RETURN_SUCCESS CheckSum is OK.\r
+ RETURN_NOT_FOUND Not find the CheckSum field.\r
\r
@retval RETRUEN_SUCCESS Succeed to receive acknowlege packet from HOST,\r
the type of acknowlege packet saved in Ack.\r
\r
**/\r
RETURN_STATUS\r
-WaitForAckPacketOK (\r
- IN UINTN Timeout,\r
- OUT BOOLEAN *BreakReceived OPTIONAL\r
+SendCommandAndWaitForAckOK (\r
+ IN UINT8 Command,\r
+ IN UINTN Timeout,\r
+ OUT BOOLEAN *BreakReceived, OPTIONAL\r
+ OUT RETURN_STATUS *CheckSumStatus OPTIONAL\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT8 Ack;\r
-\r
+ RETURN_STATUS Status;\r
+ UINT8 Ack;\r
+ \r
while (TRUE) {\r
- Status = ReceiveAckPacket (&Ack, Timeout, BreakReceived);\r
- if ((Status == RETURN_SUCCESS && Ack == DEBUG_COMMAND_OK) ||\r
- Status == RETURN_TIMEOUT) {\r
- break;\r
+ SendPacketWithoutData (Command);\r
+ while (TRUE) {\r
+ Status = ReceiveAckPacket (&Ack, Timeout, BreakReceived, CheckSumStatus);\r
+ if (Status == RETURN_SUCCESS && Ack == DEBUG_COMMAND_RESEND) {\r
+ //\r
+ // Resend the last command\r
+ //\r
+ break;\r
+ } \r
+ if ((Status == RETURN_SUCCESS && Ack == DEBUG_COMMAND_OK) ||\r
+ Status == RETURN_TIMEOUT) {\r
+ //\r
+ // Received Ack OK or timeout\r
+ //\r
+ return Status;\r
+ } \r
}\r
}\r
-\r
- return Status;\r
}\r
\r
/**\r
FALSE means break-in symbol not received.\r
\r
@retval RETURN_SUCCESS A valid package was reveived in InputPacket.\r
- @retval RETURN_NOT_READY No valid start symbol received.\r
@retval RETURN_TIMEOUT Timeout occurs.\r
\r
**/\r
OUT BOOLEAN *BreakReceived\r
)\r
{\r
- DEBUG_COMMAND_HEADER *DebugHeader;\r
+ DEBUG_PACKET_HEADER *DebugHeader;\r
UINTN Received;\r
DEBUG_PORT_HANDLE Handle;\r
+ UINT8 CheckSum;\r
\r
Handle = GetDebugPortHandle();\r
- //\r
- // Find the valid start symbol\r
- //\r
- DebugPortReadBuffer (Handle, InputPacket, 1, 0);\r
-\r
- if (*InputPacket == DEBUG_STARTING_SYMBOL_BREAK) {\r
- *BreakReceived = TRUE;\r
- SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);\r
- }\r
+ \r
+ DebugHeader = (DEBUG_PACKET_HEADER *) InputPacket;\r
+ while (TRUE) {\r
+ //\r
+ // Find the valid start symbol\r
+ //\r
+ DebugPortReadBuffer (Handle, &DebugHeader->StartSymbol, sizeof (DebugHeader->StartSymbol), 0);\r
\r
- if (*InputPacket != DEBUG_STARTING_SYMBOL_NORMAL) {\r
- return RETURN_NOT_READY;\r
- }\r
+ if (DebugHeader->StartSymbol == DEBUG_STARTING_SYMBOL_BREAK) {\r
+ *BreakReceived = TRUE;\r
+ SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);\r
+ }\r
\r
- //\r
- // Read Package header\r
- //\r
- Received = DebugPortReadBuffer (Handle, InputPacket + 1, sizeof(DEBUG_COMMAND_HEADER_NO_START_SYMBOL), 0);\r
- if (Received == 0) {\r
- return RETURN_TIMEOUT;\r
- }\r
+ if (DebugHeader->StartSymbol != DEBUG_STARTING_SYMBOL_NORMAL) {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Invalid start symbol received [%02x]\n", DebugHeader->StartSymbol);\r
+ continue;\r
+ }\r
\r
- DebugHeader = (DEBUG_COMMAND_HEADER *) InputPacket;\r
- //\r
- // Read the payload if has\r
- //\r
- if (DebugHeader->DataLength > 0 && DebugHeader->DataLength < (DEBUG_DATA_MAXIMUM_REAL_DATA - sizeof(DEBUG_COMMAND_HEADER))) {\r
- InputPacket = InputPacket + 1 + Received;\r
- Received = DebugPortReadBuffer (Handle, InputPacket, DebugHeader->DataLength, 0);\r
+ //\r
+ // Read Package header except for checksum\r
+ //\r
+ Received = DebugPortReadBuffer (\r
+ Handle,\r
+ &DebugHeader->Command,\r
+ OFFSET_OF (DEBUG_PACKET_HEADER, Length) + sizeof (DebugHeader->Length) - sizeof (DebugHeader->StartSymbol),\r
+ 0\r
+ );\r
+ if (Received == 0) {\r
+ return RETURN_TIMEOUT;\r
+ }\r
\r
+ //\r
+ // Read the payload data include the checksum\r
+ //\r
+ Received = DebugPortReadBuffer (Handle, &DebugHeader->CheckSum, DebugHeader->Length - OFFSET_OF (DEBUG_PACKET_HEADER, CheckSum), 0);\r
if (Received == 0) {\r
return RETURN_TIMEOUT;\r
}\r
+ //\r
+ // Calculate the checksum of Debug Packet\r
+ //\r
+ CheckSum = CalculateCheckSum8 ((UINT8 *) DebugHeader, DebugHeader->Length);\r
+ if (CheckSum == 0) {\r
+ break;\r
+ }\r
+ DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "CheckSum Error (Caculated checksum is %x, received checksum is %x\n", CheckSum, DebugHeader->CheckSum);\r
+ DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Send DEBUG_COMMAND_RESEND command.\n");\r
+ SendAckPacket (DEBUG_COMMAND_RESEND);\r
}\r
\r
+ DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *) DebugHeader, DebugHeader->Length);\r
+\r
return RETURN_SUCCESS;\r
}\r
\r
\r
default:\r
if (Vector < 20) {\r
- Cause = DEBUG_DATA_BREAK_CAUSE_EXCEPTION;\r
+ if (GetMailboxPointer()->DebugFlag.SteppingFlag == 1) {\r
+ //\r
+ // If stepping command is executing\r
+ //\r
+ Cause = DEBUG_DATA_BREAK_CAUSE_STEPPING;\r
+ } else {\r
+ Cause = DEBUG_DATA_BREAK_CAUSE_EXCEPTION;\r
+ }\r
}\r
break;\r
}\r
}\r
\r
/**\r
- Send packet with response data to HOST.\r
+ Send command packet with data to HOST.\r
\r
- @param[in] CpuContext Pointer to saved CPU context.\r
+ @param[in] Command Command type.\r
@param[in] Data Pointer to response data buffer.\r
@param[in] DataSize Size of response data in byte.\r
\r
\r
**/\r
RETURN_STATUS\r
-SendDataResponsePacket (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
+SendCommandWithDataPacket (\r
+ IN UINT8 Command,\r
IN UINT8 *Data,\r
IN UINT16 DataSize\r
)\r
{\r
- UINT8 PacketHeader[DEBUG_DATA_MAXIMUM_LENGTH_FOR_SMALL_COMMANDS];\r
+ DEBUG_PACKET_HEADER *DebugHeader;\r
BOOLEAN LastPacket;\r
UINT8 Ack;\r
- UINT8 PacketData[DEBUG_DATA_MAXIMUM_REAL_DATA];\r
+ UINT8 DebugPacket[DEBUG_DATA_UPPER_LIMIT];\r
DEBUG_PORT_HANDLE Handle;\r
\r
Handle = GetDebugPortHandle();\r
\r
- ((DEBUG_COMMAND_HEADER *)PacketHeader)->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;\r
+ DebugHeader = (DEBUG_PACKET_HEADER *) &DebugPacket;\r
+ DebugHeader->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;\r
\r
while (TRUE) {\r
if (DataSize <= DEBUG_DATA_MAXIMUM_REAL_DATA) {\r
LastPacket = TRUE;\r
- ((DEBUG_COMMAND_HEADER *)PacketHeader)->Command = DEBUG_COMMAND_OK;\r
- ((DEBUG_COMMAND_HEADER *)PacketHeader)->DataLength = (UINT8) DataSize;\r
- CopyMem (PacketData, Data, DataSize);\r
+ DebugHeader->Command = Command;\r
+ DebugHeader->Length = (UINT8) (DataSize + sizeof (DEBUG_PACKET_HEADER));\r
+ DebugHeader->CheckSum = 0;\r
+ CopyMem (DebugHeader + 1, Data, DataSize);\r
\r
} else {\r
LastPacket = FALSE;\r
- ((DEBUG_COMMAND_HEADER *)PacketHeader)->Command = DEBUG_COMMAND_IN_PROGRESS;\r
- ((DEBUG_COMMAND_HEADER *)PacketHeader)->DataLength = DEBUG_DATA_MAXIMUM_REAL_DATA;\r
- CopyMem (PacketData, Data, DEBUG_DATA_MAXIMUM_REAL_DATA);\r
+ DebugHeader->Command = DEBUG_COMMAND_IN_PROGRESS;\r
+ DebugHeader->Length = DEBUG_DATA_MAXIMUM_REAL_DATA + sizeof (DEBUG_PACKET_HEADER);\r
+ DebugHeader->CheckSum = 0;\r
+ CopyMem (DebugHeader + 1, Data, DEBUG_DATA_MAXIMUM_REAL_DATA);\r
}\r
\r
- DebugPortWriteBuffer (Handle, PacketHeader, sizeof (DEBUG_COMMAND_HEADER));\r
- DebugPortWriteBuffer (Handle, PacketData, ((DEBUG_COMMAND_HEADER *)PacketHeader)->DataLength);\r
+ //\r
+ // Calculate and fill the checksum\r
+ //\r
+ DebugHeader->CheckSum = CalculateCheckSum8 ((UINT8 *) DebugHeader, DebugHeader->Length);\r
+\r
+ DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, TRUE, (UINT8 *) DebugHeader, DebugHeader->Length);\r
+ \r
+ DebugPortWriteBuffer (Handle, (UINT8 *) DebugHeader, DebugHeader->Length);\r
\r
- ReceiveAckPacket(&Ack, 0, NULL);\r
+ ReceiveAckPacket(&Ack, 0, NULL, NULL);\r
switch (Ack) {\r
case DEBUG_COMMAND_RESEND:\r
//\r
// Send the packet again\r
//\r
+ DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Received DEBUG_COMMAND_RESEND.\n");\r
break;\r
\r
case DEBUG_COMMAND_CONTINUE:\r
}\r
}\r
\r
+/**\r
+ Send packet with response data to HOST.\r
+\r
+ @param[in] Data Pointer to response data buffer.\r
+ @param[in] DataSize Size of response data in byte.\r
+\r
+ @retval RETURN_SUCCESS Response data was sent successfully.\r
+ @retval RETURN_DEVICE_ERROR Cannot receive DEBUG_COMMAND_OK from HOST.\r
+\r
+**/\r
+RETURN_STATUS\r
+SendDataResponsePacket (\r
+ IN UINT8 *Data,\r
+ IN UINT16 DataSize\r
+ )\r
+{\r
+ return SendCommandWithDataPacket (DEBUG_COMMAND_OK, Data, DataSize);\r
+}\r
+\r
/**\r
Send break cause packet to HOST.\r
\r
DebugDataBreakCause.StopAddress = CpuContext->Eip;\r
DebugDataBreakCause.Cause = GetBreakCause (Vector, CpuContext);\r
\r
- return SendDataResponsePacket (CpuContext, (UINT8 *) &DebugDataBreakCause, (UINT16) sizeof (DEBUG_DATA_RESPONSE_BREAK_CAUSE));\r
+ return SendDataResponsePacket ((UINT8 *) &DebugDataBreakCause, (UINT16) sizeof (DEBUG_DATA_RESPONSE_BREAK_CAUSE));\r
}\r
\r
+/**\r
+ Try to attach the HOST.\r
+ \r
+ Send init break packet to HOST:\r
+ If no acknowlege received in specified Timeout, return RETURN_TIMEOUT. \r
+ If received acknowlege, check the revision of HOST. \r
+ Set Attach Flag if attach successfully. \r
+ \r
+ @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
+ The unit is microsecond.\r
+ @param[out] BreakReceived If BreakReceived is not NULL,\r
+ TRUE is retured if break-in symbol received.\r
+ FALSE is retured if break-in symbol not received.\r
+**/\r
+RETURN_STATUS\r
+AttachHost (\r
+ IN UINTN Timeout,\r
+ OUT BOOLEAN *BreakReceived\r
+ )\r
+{\r
+ RETURN_STATUS Status;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ RETURN_STATUS CheckSumStatus;\r
+\r
+ Handle = GetDebugPortHandle();\r
+ \r
+ //\r
+ // Send init break and wait ack in Timeout\r
+ //\r
+ DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgSendInitPacket, AsciiStrLen (mErrorMsgSendInitPacket));\r
+ Status = SendCommandAndWaitForAckOK (DEBUG_COMMAND_INIT_BREAK, Timeout, BreakReceived, &CheckSumStatus);\r
+ if (RETURN_ERROR (Status)) {\r
+ DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectFail, AsciiStrLen (mErrorMsgConnectFail));\r
+ return Status;\r
+ }\r
+ \r
+ if (CheckSumStatus == RETURN_NOT_FOUND) {\r
+ //\r
+ // If the CheckSum field does not exist in Debug Packet,\r
+ // the HOST should be running with 0.1 transfer protocol.\r
+ // It could be UDK Debugger for Windows v1.1 or for Linux v0.8.\r
+ //\r
+ DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgVersionAlert, AsciiStrLen (mErrorMsgVersionAlert));\r
+ CpuDeadLoop ();\r
+ }\r
+\r
+ DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectOK, AsciiStrLen (mErrorMsgConnectOK));\r
+ //\r
+ // Set Attach flag\r
+ //\r
+ SetHostAttached (TRUE);\r
+\r
+ return Status;\r
+}\r
+\r
+/**\r
+ Send Break point packet to HOST. \r
+ \r
+ Only the first breaking processor could sent BREAK_POINT packet.\r
+ \r
+ @param[in] ProcessorIndex Processor index value.\r
+ @param[out] BreakReceived If BreakReceived is not NULL,\r
+ TRUE is retured if break-in symbol received.\r
+ FALSE is retured if break-in symbol not received.\r
+ \r
+**/\r
+VOID\r
+SendBreakPacketToHost (\r
+ IN UINT32 ProcessorIndex,\r
+ OUT BOOLEAN *BreakReceived\r
+ )\r
+{\r
+ UINT8 InputCharacter;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ \r
+ Handle = GetDebugPortHandle();\r
+ \r
+ if (IsHostAttached ()) {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Send Break Packet to HOST.\n", ProcessorIndex);\r
+ SendCommandAndWaitForAckOK (DEBUG_COMMAND_BREAK_POINT, 0, BreakReceived, NULL);\r
+ } else {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Try to attach HOST.\n", ProcessorIndex);\r
+ //\r
+ // If HOST is not attached, try to attach it firstly.\r
+ //\r
+ //\r
+ // Poll Attach symbols from HOST and ack OK\r
+ // \r
+ do {\r
+ DebugPortReadBuffer (Handle, &InputCharacter, 1, 0);\r
+ } while (InputCharacter != DEBUG_STARTING_SYMBOL_ATTACH);\r
+ SendAckPacket (DEBUG_COMMAND_OK);\r
+ \r
+ //\r
+ // Try to attach HOST\r
+ //\r
+ while (AttachHost (0, NULL) != RETURN_SUCCESS);\r
+ \r
+ }\r
+}\r
\r
/**\r
The main function to process communication with HOST.\r
IN BOOLEAN BreakReceived\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT8 InputPacketBuffer[DEBUG_DATA_MAXIMUM_LENGTH_FOR_SMALL_COMMANDS];\r
- DEBUG_COMMAND_HEADER *DebugHeader;\r
- UINT8 Data8;\r
- UINT32 Data32;\r
- UINT64 Data64;\r
- UINTN DataN;\r
- DEBUG_DATA_READ_MEMORY_8 *MemoryRead;\r
- DEBUG_DATA_WRITE_MEMORY_8 *MemoryWrite;\r
- DEBUG_DATA_READ_IO *IoRead;\r
- DEBUG_DATA_WRITE_IO *IoWrite;\r
- DEBUG_DATA_READ_REGISTER *RegisterRead;\r
- DEBUG_DATA_WRITE_REGISTER *RegisterWrite;\r
- UINT8 *RegisterBuffer;\r
- DEBUG_DATA_READ_MSR *MsrRegisterRead;\r
- DEBUG_DATA_WRITE_MSR *MsrRegisterWrite;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM RegisterGroupSegLim;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE RegisterGroupSegBase;\r
- DEBUG_DATA_RESPONSE_GET_REVISION DebugAgentRevision;\r
- BOOLEAN HaltDeferred;\r
- DEBUG_DATA_RESPONSE_GET_EXCEPTION Exception;\r
- UINT32 ProcessorIndex;\r
- DEBUG_PORT_HANDLE Handle;\r
-\r
- Handle = GetDebugPortHandle();\r
+ RETURN_STATUS Status;\r
+ UINT8 InputPacketBuffer[DEBUG_DATA_UPPER_LIMIT];\r
+ DEBUG_PACKET_HEADER *DebugHeader;\r
+ UINT8 Width;\r
+ UINT8 Data8;\r
+ UINT32 Data32;\r
+ UINT64 Data64;\r
+ DEBUG_DATA_READ_MEMORY *MemoryRead;\r
+ DEBUG_DATA_WRITE_MEMORY *MemoryWrite;\r
+ DEBUG_DATA_READ_IO *IoRead;\r
+ DEBUG_DATA_WRITE_IO *IoWrite;\r
+ DEBUG_DATA_READ_REGISTER *RegisterRead;\r
+ DEBUG_DATA_WRITE_REGISTER *RegisterWrite;\r
+ UINT8 *RegisterBuffer;\r
+ DEBUG_DATA_READ_MSR *MsrRegisterRead;\r
+ DEBUG_DATA_WRITE_MSR *MsrRegisterWrite;\r
+ DEBUG_DATA_CPUID *Cpuid;\r
+ DEBUG_DATA_RESPONSE_CPUID CpuidResponse;\r
+ DEBUG_DATA_SEARCH_SIGNATURE *SearchSignature;\r
+ DEBUG_DATA_RESPONSE_GET_EXCEPTION Exception;\r
+ DEBUG_DATA_RESPONSE_GET_REVISION DebugAgentRevision;\r
+ DEBUG_DATA_SET_VIEWPOINT *SetViewPoint;\r
+ BOOLEAN HaltDeferred;\r
+ UINT32 ProcessorIndex;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ DEBUG_AGENT_EXCEPTION_BUFFER AgentExceptionBuffer;\r
+ UINT32 IssuedViewPoint;\r
\r
ProcessorIndex = 0;\r
- HaltDeferred = BreakReceived;\r
+ IssuedViewPoint = 0;\r
+ HaltDeferred = BreakReceived;\r
\r
if (MultiProcessorDebugSupport) {\r
ProcessorIndex = GetProcessorIndex ();\r
SetCpuStopFlagByIndex (ProcessorIndex, TRUE);\r
+ if (mDebugMpContext.ViewPointIndex == ProcessorIndex) {\r
+ //\r
+ // Only the current view processor could set AgentInProgress Flag. \r
+ //\r
+ IssuedViewPoint = ProcessorIndex;\r
+ }\r
}\r
\r
+ if (IssuedViewPoint == ProcessorIndex) {\r
+ //\r
+ // Set AgentInProgress Flag.\r
+ //\r
+ GetMailboxPointer()->DebugFlag.AgentInProgress = 1;\r
+ } \r
+\r
+ Handle = GetDebugPortHandle();\r
+\r
while (TRUE) {\r
\r
if (MultiProcessorDebugSupport) {\r
+ //\r
+ // Check if the current processor is HOST view point\r
+ //\r
if (mDebugMpContext.ViewPointIndex != ProcessorIndex) {\r
if (mDebugMpContext.RunCommandSet) {\r
+ //\r
+ // If HOST view point sets RUN flag, run GO command to leave\r
+ //\r
SetCpuStopFlagByIndex (ProcessorIndex, FALSE);\r
CommandGo (CpuContext);\r
break;\r
} else {\r
+ //\r
+ // Run into loop again\r
+ //\r
+ CpuPause ();\r
continue;\r
}\r
}\r
\r
Data8 = 1;\r
\r
- DebugHeader =(DEBUG_COMMAND_HEADER *) InputPacketBuffer;\r
+ DebugHeader =(DEBUG_PACKET_HEADER *) InputPacketBuffer;\r
+\r
+ GetMailboxPointer()->ExceptionBufferPointer = (UINT64)(UINTN) &AgentExceptionBuffer.JumpBuffer;\r
+ //\r
+ // Save CPU content before executing HOST commond\r
+ //\r
+ if (SetJump (&AgentExceptionBuffer.JumpBuffer) != 0) {\r
+ //\r
+ // If HOST command failed, continue to wait for HOST's next command\r
+ // If needed, agent could send exception info to HOST.\r
+ //\r
+ SendAckPacket (DEBUG_COMMAND_ABORT);\r
+ ReleaseDebugPortControl ();\r
+ continue;\r
+ }\r
+\r
+ DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Processor[%x]:Received one command(%x)\n", mDebugMpContext.ViewPointIndex, DebugHeader->Command);\r
+ \r
switch (DebugHeader->Command) {\r
\r
case DEBUG_COMMAND_RESET:\r
\r
case DEBUG_COMMAND_GO:\r
CommandGo (CpuContext);\r
+ //\r
+ // Clear Dr0 to avoid to be recognized as IMAGE_LOAD/_UNLOAD again when hitting a breakpoint after GO\r
+ // If HOST changed Dr0 before GO, we will not change Dr0 here\r
+ //\r
+ Data8 = GetBreakCause (Vector, CpuContext);\r
+ if (Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD || Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD) {\r
+ CpuContext->Dr0 = 0;\r
+ }\r
+ //\r
+ // Clear Stepping Flag\r
+ //\r
+ GetMailboxPointer()->DebugFlag.SteppingFlag = 0;\r
+ \r
if (!HaltDeferred) {\r
//\r
// If no HALT command received when being in-active mode\r
//\r
if (MultiProcessorDebugSupport) {\r
- Data32 = FindCpuNotRunning ();\r
+ Data32 = FindNextPendingBreakCpu ();\r
if (Data32 != -1) {\r
//\r
// If there are still others processors being in break state, \r
mDebugMpContext.BreakAtCpuIndex = mDebugMpContext.ViewPointIndex;\r
SetCpuBreakFlagByIndex (mDebugMpContext.ViewPointIndex, FALSE);\r
//\r
- // Send break packet to HOST and exit to wait for command packet from HOST.\r
+ // Send break packet to HOST to let HOST break again\r
+ //\r
+ SendBreakPacketToHost (0, &BreakReceived);\r
+ //\r
+ // Continue to run into loop to read command packet from HOST\r
//\r
- SendAckPacket (DEBUG_COMMAND_BREAK_POINT);\r
- WaitForAckPacketOK (0, &BreakReceived);\r
ReleaseDebugPortControl (); \r
break;\r
}\r
//\r
SendAckPacket (DEBUG_COMMAND_HALT_PROCESSED);\r
HaltDeferred = FALSE;\r
- Data8 = GetBreakCause (Vector, CpuContext);\r
- if (Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD || Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD) {\r
- CpuContext->Dr0 = 0;\r
- CpuContext->Dr3 = 0;\r
- }\r
\r
Vector = DEBUG_TIMER_VECTOR;\r
}\r
\r
case DEBUG_COMMAND_SINGLE_STEPPING:\r
CommandStepping (CpuContext);\r
+ //\r
+ // Clear Dr0 to avoid to be recognized as IMAGE_LOAD/_UNLOAD again when hitting a breakpoint after GO\r
+ // If HOST changed Dr0 before GO, we will not change Dr0 here\r
+ //\r
+ Data8 = GetBreakCause (Vector, CpuContext);\r
+ if (Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD || Data8 == DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD) {\r
+ CpuContext->Dr0 = 0;\r
+ }\r
\r
mDebugMpContext.BreakAtCpuIndex = (UINT32) (-1);\r
-\r
+ //\r
+ // Set Stepping Flag\r
+ //\r
+ GetMailboxPointer()->DebugFlag.SteppingFlag = 1;\r
ReleaseDebugPortControl ();\r
//\r
- // Executing stepping command directly without sending ACK packet.\r
+ // Executing stepping command directly without sending ACK packet,\r
+ // ACK packet will be sent after stepping done.\r
//\r
return;\r
\r
Data64 = (UINTN) (((DEBUG_DATA_SET_SW_BREAKPOINT *) (DebugHeader + 1))->Address);\r
Data8 = *(UINT8 *) (UINTN) Data64;\r
*(UINT8 *) (UINTN) Data64 = DEBUG_SW_BREAKPOINT_SYMBOL;\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Data8, (UINT16) sizeof (UINT8));\r
+ Status = SendDataResponsePacket ((UINT8 *) &Data8, (UINT16) sizeof (UINT8));\r
break;\r
\r
- case DEBUG_COMMAND_READ_MEMORY_64:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_READ_MEMORY_32:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_READ_MEMORY_16:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_READ_MEMORY_8:\r
- MemoryRead = (DEBUG_DATA_READ_MEMORY_8 *) (DebugHeader + 1);\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) (UINTN) MemoryRead->Address, (UINT16) (MemoryRead->Count * Data8));\r
+ case DEBUG_COMMAND_READ_MEMORY:\r
+ MemoryRead = (DEBUG_DATA_READ_MEMORY *) (DebugHeader + 1);\r
+ Status = SendDataResponsePacket ((UINT8 *) (UINTN) MemoryRead->Address, (UINT16) (MemoryRead->Count * MemoryRead->Width));\r
break;\r
\r
- case DEBUG_COMMAND_WRITE_MEMORY_64:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_WRITE_MEMORY_32:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_WRITE_MEMORY_16:\r
- Data8 *= 2;\r
- case DEBUG_COMMAND_WRITE_MEMORY_8:\r
- MemoryWrite = (DEBUG_DATA_WRITE_MEMORY_8 *) (DebugHeader + 1);\r
- CopyMem ((VOID *) (UINTN) MemoryWrite->Address, &MemoryWrite->Data, MemoryWrite->Count * Data8);\r
+ case DEBUG_COMMAND_WRITE_MEMORY:\r
+ MemoryWrite = (DEBUG_DATA_WRITE_MEMORY *) (DebugHeader + 1);\r
+ CopyMem ((VOID *) (UINTN) MemoryWrite->Address, &MemoryWrite->Data, MemoryWrite->Count * MemoryWrite->Width);\r
SendAckPacket (DEBUG_COMMAND_OK);\r
break;\r
\r
IoRead = (DEBUG_DATA_READ_IO *) (DebugHeader + 1);\r
switch (IoRead->Width) {\r
case 1:\r
- Data64 = IoRead8 (IoRead->Port);\r
+ Data64 = IoRead8 ((UINTN) IoRead->Port);\r
break;\r
case 2:\r
- Data64 = IoRead16 (IoRead->Port);\r
+ Data64 = IoRead16 ((UINTN) IoRead->Port);\r
break;\r
case 4:\r
- Data64 = IoRead32 (IoRead->Port);\r
+ Data64 = IoRead32 ((UINTN) IoRead->Port);\r
break;\r
case 8:\r
- Data64 = IoRead64 (IoRead->Port);\r
+ Data64 = IoRead64 ((UINTN) IoRead->Port);\r
break;\r
default:\r
Data64 = (UINT64) -1;\r
}\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Data64, IoRead->Width);\r
+ Status = SendDataResponsePacket ((UINT8 *) &Data64, IoRead->Width);\r
break;\r
\r
case DEBUG_COMMAND_WRITE_IO:\r
IoWrite = (DEBUG_DATA_WRITE_IO *) (DebugHeader + 1);\r
switch (IoWrite->Width) {\r
case 1:\r
- Data64 = IoWrite8 (IoWrite->Port, *(UINT8 *) &IoWrite->Data);\r
+ Data64 = IoWrite8 ((UINTN) IoWrite->Port, *(UINT8 *) &IoWrite->Data);\r
break;\r
case 2:\r
- Data64 = IoWrite16 (IoWrite->Port, *(UINT16 *) &IoWrite->Data);\r
+ Data64 = IoWrite16 ((UINTN) IoWrite->Port, *(UINT16 *) &IoWrite->Data);\r
break;\r
case 4:\r
- Data64 = IoWrite32 (IoWrite->Port, *(UINT32 *) &IoWrite->Data);\r
+ Data64 = IoWrite32 ((UINTN) IoWrite->Port, *(UINT32 *) &IoWrite->Data);\r
break;\r
case 8:\r
- Data64 = IoWrite64 (IoWrite->Port, *(UINT64 *) &IoWrite->Data);\r
+ Data64 = IoWrite64 ((UINTN) IoWrite->Port, *(UINT64 *) &IoWrite->Data);\r
break;\r
default:\r
Data64 = (UINT64) -1;\r
SendAckPacket (DEBUG_COMMAND_OK);\r
break;\r
\r
+ case DEBUG_COMMAND_READ_ALL_REGISTERS:\r
+ Status = SendDataResponsePacket ((UINT8 *) CpuContext, sizeof (*CpuContext));\r
+ break;\r
+\r
case DEBUG_COMMAND_READ_REGISTER:\r
RegisterRead = (DEBUG_DATA_READ_REGISTER *) (DebugHeader + 1);\r
\r
- if (RegisterRead->Index < SOFT_DEBUGGER_REGISTER_OTHERS_BASE) {\r
- Data8 = RegisterRead->Length;\r
- RegisterBuffer = ArchReadRegisterBuffer (CpuContext, RegisterRead->Index, RegisterRead->Offset, &Data8);\r
- Status = SendDataResponsePacket (CpuContext, RegisterBuffer, Data8);\r
- break;\r
- }\r
-\r
- if (RegisterRead->Index <= SOFT_DEBUGGER_REGISTER_TSS_LIM) {\r
- ReadRegisterGroupSegLim (CpuContext, &RegisterGroupSegLim);\r
- DataN = * ((UINTN *) &RegisterGroupSegLim + (RegisterRead->Index - SOFT_DEBUGGER_REGISTER_CS_LIM));\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- } else if (RegisterRead->Index <= SOFT_DEBUGGER_REGISTER_TSS_BAS) {\r
- ReadRegisterGroupSegBase (CpuContext, &RegisterGroupSegBase);\r
- DataN = * ((UINTN *) &RegisterGroupSegBase + (RegisterRead->Index - SOFT_DEBUGGER_REGISTER_CS_BAS));\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- } else if (RegisterRead->Index < SOFT_DEBUGGER_REGISTER_IDT_LIM) {\r
- Data64 = ReadRegisterSelectorByIndex (CpuContext, RegisterRead->Index);\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Data64, (UINT16) sizeof (UINT64));\r
+ if (RegisterRead->Index <= SOFT_DEBUGGER_REGISTER_MAX) {\r
+ RegisterBuffer = ArchReadRegisterBuffer (CpuContext, RegisterRead->Index, &Width);\r
+ Status = SendDataResponsePacket (RegisterBuffer, Width);\r
} else {\r
- switch (RegisterRead->Index) {\r
- case SOFT_DEBUGGER_REGISTER_IDT_LIM:\r
- DataN = (UINTN) (CpuContext->Idtr[0] & 0xffff);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_GDT_LIM:\r
- DataN = (UINTN) (CpuContext->Gdtr[0] & 0xffff);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_IDT_BAS:\r
- DataN = (UINTN) RShiftU64 (CpuContext->Idtr[0], 16);\r
- DataN |= (UINTN) LShiftU64 (CpuContext->Idtr[1], (UINT16) (sizeof (UINTN) * 8 - 16));\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_GDT_BAS:\r
- DataN = (UINTN) RShiftU64 (CpuContext->Gdtr[0], 16);\r
- DataN |= (UINTN) LShiftU64 (CpuContext->Gdtr[1], (UINT16) (sizeof (UINTN) * 8 - 16));\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &DataN, (UINT16) sizeof (UINTN));\r
- break;\r
- }\r
+ Status = RETURN_UNSUPPORTED;\r
}\r
break;\r
\r
case DEBUG_COMMAND_WRITE_REGISTER:\r
RegisterWrite = (DEBUG_DATA_WRITE_REGISTER *) (DebugHeader + 1);\r
- ArchWriteRegisterBuffer (CpuContext, RegisterWrite->Index, RegisterWrite->Offset, RegisterWrite->Length, (UINT8 *)&RegisterWrite->Value);\r
- SendAckPacket (DEBUG_COMMAND_OK);\r
+ if (RegisterWrite->Index <= SOFT_DEBUGGER_REGISTER_MAX) {\r
+ RegisterBuffer = ArchReadRegisterBuffer (CpuContext, RegisterWrite->Index, &Width);\r
+ ASSERT (Width == RegisterWrite->Length);\r
+ CopyMem (RegisterBuffer, RegisterWrite->Data, Width);\r
+ SendAckPacket (DEBUG_COMMAND_OK);\r
+ } else {\r
+ Status = RETURN_UNSUPPORTED;\r
+ }\r
break;\r
\r
case DEBUG_COMMAND_ARCH_MODE:\r
Data8 = DEBUG_ARCH_SYMBOL;\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Data8, (UINT16) sizeof (UINT8));\r
+ Status = SendDataResponsePacket ((UINT8 *) &Data8, (UINT16) sizeof (UINT8));\r
break;\r
\r
case DEBUG_COMMAND_READ_MSR:\r
MsrRegisterRead = (DEBUG_DATA_READ_MSR *) (DebugHeader + 1);\r
Data64 = AsmReadMsr64 (MsrRegisterRead->Index);\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Data64, (UINT16) sizeof (UINT64));\r
+ Status = SendDataResponsePacket ((UINT8 *) &Data64, (UINT16) sizeof (UINT64));\r
break;\r
\r
case DEBUG_COMMAND_WRITE_MSR:\r
SendAckPacket (DEBUG_COMMAND_OK);\r
break;\r
\r
- case DEBUG_COMMAND_READ_REGISTER_GROUP:\r
- Data8 = *(UINT8 *) (DebugHeader + 1);\r
- Status = ArchReadRegisterGroup (CpuContext, Data8);\r
- break;\r
-\r
- case DEBUG_COMMAND_SET_DEBUG_FLAG:\r
- Data32 = *(UINT32 *) (DebugHeader + 1);\r
- SetDebugFlag (Data32);\r
- SendAckPacket (DEBUG_COMMAND_OK);\r
+ case DEBUG_COMMAND_SET_DEBUG_SETTING:\r
+ Status = SetDebugSetting ((DEBUG_DATA_SET_DEBUG_SETTING *)(DebugHeader + 1));\r
+ if (Status == RETURN_SUCCESS) {\r
+ SendAckPacket (DEBUG_COMMAND_OK);\r
+ }\r
break;\r
\r
case DEBUG_COMMAND_GET_REVISION:\r
DebugAgentRevision.Revision = DEBUG_AGENT_REVISION;\r
DebugAgentRevision.Capabilities = DEBUG_AGENT_CAPABILITIES;\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &DebugAgentRevision, (UINT16) sizeof (DEBUG_DATA_RESPONSE_GET_REVISION));\r
+ Status = SendDataResponsePacket ((UINT8 *) &DebugAgentRevision, (UINT16) sizeof (DEBUG_DATA_RESPONSE_GET_REVISION));\r
break;\r
\r
case DEBUG_COMMAND_GET_EXCEPTION:\r
Exception.ExceptionNum = (UINT8) Vector;\r
- Exception.ExceptionData = 0;\r
- Status = SendDataResponsePacket (CpuContext, (UINT8 *) &Exception, (UINT16) sizeof (DEBUG_DATA_RESPONSE_GET_EXCEPTION));\r
+ Exception.ExceptionData = (UINT32) CpuContext->ExceptionData;\r
+ Status = SendDataResponsePacket ((UINT8 *) &Exception, (UINT16) sizeof (DEBUG_DATA_RESPONSE_GET_EXCEPTION));\r
break;\r
\r
case DEBUG_COMMAND_SET_VIEWPOINT:\r
- Data32 = *(UINT32 *) (DebugHeader + 1);\r
-\r
+ SetViewPoint = (DEBUG_DATA_SET_VIEWPOINT *) (DebugHeader + 1);\r
if (MultiProcessorDebugSupport) {\r
- if (IsCpuStopped (Data32)) {\r
- SetDebugViewPoint (Data32);\r
+ if (IsCpuStopped (SetViewPoint->ViewPoint)) {\r
+ SetDebugViewPoint (SetViewPoint->ViewPoint);\r
SendAckPacket (DEBUG_COMMAND_OK);\r
} else {\r
//\r
//\r
SendAckPacket (DEBUG_COMMAND_NOT_SUPPORTED);\r
}\r
- } else if (Data32 == 0) {\r
+ } else if (SetViewPoint->ViewPoint == 0) {\r
SendAckPacket (DEBUG_COMMAND_OK);\r
\r
} else {\r
\r
case DEBUG_COMMAND_GET_VIEWPOINT:\r
Data32 = mDebugMpContext.ViewPointIndex;\r
- SendDataResponsePacket(CpuContext, (UINT8 *) &Data32, (UINT16) sizeof (UINT32));\r
+ SendDataResponsePacket((UINT8 *) &Data32, (UINT16) sizeof (UINT32));\r
+ break;\r
+\r
+ case DEBUG_COMMAND_MEMORY_READY:\r
+ Data8 = (UINT8) GetMailboxPointer ()->DebugFlag.MemoryReady;\r
+ SendDataResponsePacket (&Data8, (UINT16) sizeof (UINT8));\r
+ break;\r
+\r
+ case DEBUG_COMMAND_DETACH:\r
+ SetHostAttached (FALSE);\r
+ SendAckPacket (DEBUG_COMMAND_OK);\r
+ break;\r
+\r
+ case DEBUG_COMMAND_CPUID:\r
+ Cpuid = (DEBUG_DATA_CPUID *) (DebugHeader + 1);\r
+ AsmCpuidEx (\r
+ Cpuid->Eax, Cpuid->Ecx, \r
+ &CpuidResponse.Eax, &CpuidResponse.Ebx,\r
+ &CpuidResponse.Ecx, &CpuidResponse.Edx\r
+ );\r
+ SendDataResponsePacket ((UINT8 *) &CpuidResponse, (UINT16) sizeof (CpuidResponse));\r
+ break;\r
+\r
+ case DEBUG_COMMAND_SEARCH_SIGNATURE:\r
+ SearchSignature = (DEBUG_DATA_SEARCH_SIGNATURE *) (DebugHeader + 1);\r
+ if ((SearchSignature->Alignment != 0) && \r
+ (SearchSignature->Alignment == GetPowerOfTwo32 (SearchSignature->Alignment))\r
+ ) {\r
+ if (SearchSignature->Positive) {\r
+ for (\r
+ Data64 = ALIGN_VALUE ((UINTN) SearchSignature->Start, SearchSignature->Alignment);\r
+ Data64 <= SearchSignature->Start + SearchSignature->Count - SearchSignature->DataLength;\r
+ Data64 += SearchSignature->Alignment\r
+ ) {\r
+ if (CompareMem ((VOID *) (UINTN) Data64, &SearchSignature->Data, SearchSignature->DataLength) == 0) {\r
+ break;\r
+ }\r
+ }\r
+ if (Data64 > SearchSignature->Start + SearchSignature->Count - SearchSignature->DataLength) {\r
+ Data64 = (UINT64) -1;\r
+ }\r
+ } else {\r
+ for (\r
+ Data64 = ALIGN_VALUE ((UINTN) SearchSignature->Start - SearchSignature->Alignment, SearchSignature->Alignment);\r
+ Data64 >= SearchSignature->Start - SearchSignature->Count;\r
+ Data64 -= SearchSignature->Alignment\r
+ ) {\r
+ if (CompareMem ((VOID *) (UINTN) Data64, &SearchSignature->Data, SearchSignature->DataLength) == 0) {\r
+ break;\r
+ }\r
+ }\r
+ if (Data64 < SearchSignature->Start - SearchSignature->Count) {\r
+ Data64 = (UINT64) -1;\r
+ }\r
+ }\r
+ SendDataResponsePacket ((UINT8 *) &Data64, (UINT16) sizeof (Data64));\r
+ } else {\r
+ Status = RETURN_UNSUPPORTED;\r
+ }\r
break;\r
\r
default:\r
IN DEBUG_CPU_CONTEXT *CpuContext\r
)\r
{\r
- UINT8 InputCharacter;\r
- UINT8 BreakCause;\r
- UINTN SavedEip;\r
- BOOLEAN BreakReceived;\r
- UINT32 ProcessorIndex;\r
- UINT32 CurrentDebugTimerInitCount;\r
- DEBUG_PORT_HANDLE Handle;\r
- UINT8 Data8;\r
-\r
- Handle = GetDebugPortHandle();\r
+ UINT8 InputCharacter;\r
+ UINT8 BreakCause;\r
+ UINTN SavedEip;\r
+ BOOLEAN BreakReceived;\r
+ UINT32 ProcessorIndex;\r
+ UINT32 CurrentDebugTimerInitCount;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ UINT8 Data8;\r
+ UINT8 *Al;\r
+ UINT32 IssuedViewPoint;\r
+ DEBUG_AGENT_EXCEPTION_BUFFER *ExceptionBuffer;\r
\r
- ProcessorIndex = 0;\r
- BreakReceived = FALSE;\r
+ ProcessorIndex = 0;\r
+ IssuedViewPoint = 0;\r
+ BreakReceived = FALSE;\r
\r
if (MultiProcessorDebugSupport) {\r
ProcessorIndex = GetProcessorIndex ();\r
- while (mDebugMpContext.RunCommandSet);\r
+ //\r
+ // If this processor has alreay halted before, need to check it later\r
+ //\r
+ if (IsCpuStopped (ProcessorIndex)) {\r
+ IssuedViewPoint = ProcessorIndex;\r
+ }\r
}\r
\r
+ if (IssuedViewPoint == ProcessorIndex) {\r
+ //\r
+ // Check if this exception is issued by Debug Agent itself\r
+ // If yes, fill the debug agent exception buffer and LongJump() back to\r
+ // the saved CPU content in CommandCommunication()\r
+ //\r
+ if (GetMailboxPointer()->DebugFlag.AgentInProgress == 1) {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Debug agent meet one Exception, ExceptionNum is %d.\n", Vector);\r
+ ExceptionBuffer = (DEBUG_AGENT_EXCEPTION_BUFFER *) (UINTN) GetMailboxPointer()->ExceptionBufferPointer;\r
+ ExceptionBuffer->ExceptionContent.ExceptionNum = (UINT8) Vector;\r
+ ExceptionBuffer->ExceptionContent.ExceptionData = (UINT32) CpuContext->ExceptionData;\r
+ LongJump ((BASE_LIBRARY_JUMP_BUFFER *)(UINTN)(GetMailboxPointer()->ExceptionBufferPointer), 1);\r
+ }\r
+ }\r
+\r
+ if (MultiProcessorDebugSupport) {\r
+ //\r
+ // If RUN commmand is executing, wait for it done. \r
+ //\r
+ while (mDebugMpContext.RunCommandSet) {\r
+ CpuPause ();\r
+ }\r
+ }\r
+\r
+ Handle = GetDebugPortHandle();\r
+\r
switch (Vector) {\r
case DEBUG_INT1_VECTOR:\r
case DEBUG_INT3_VECTOR:\r
-\r
BreakCause = GetBreakCause (Vector, CpuContext);\r
\r
- if (BreakCause == DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET) {\r
-\r
- //\r
- // Init break, if no ack received after 200ms, return\r
- //\r
- SendAckPacket (DEBUG_COMMAND_INIT_BREAK);\r
- if (WaitForAckPacketOK (200 * 1000, &BreakReceived) != RETURN_SUCCESS) {\r
+ switch (BreakCause) {\r
+ case DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET:\r
+ if (AttachHost (INIT_BREAK_ACK_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {\r
+ //\r
+ // Try to connect HOST, return if fails\r
+ //\r
break;\r
}\r
-\r
- SetHostConnectedFlag ();\r
CommandCommunication (Vector, CpuContext, BreakReceived);\r
+ break;\r
\r
- } else if (BreakCause == DEBUG_DATA_BREAK_CAUSE_STEPPING) {\r
-\r
+ case DEBUG_DATA_BREAK_CAUSE_STEPPING:\r
//\r
// Stepping is finished, send Ack package.\r
//\r
}\r
SendAckPacket (DEBUG_COMMAND_OK);\r
CommandCommunication (Vector, CpuContext, BreakReceived);\r
+ break;\r
\r
- } else if (BreakCause == DEBUG_DATA_BREAK_CAUSE_MEMORY_READY) {\r
-\r
+ case DEBUG_DATA_BREAK_CAUSE_MEMORY_READY:\r
//\r
// Memory is ready\r
//\r
- SendAckPacket (DEBUG_COMMAND_MEMORY_READY);\r
- WaitForAckPacketOK (0, &BreakReceived);\r
+ SendCommandAndWaitForAckOK (DEBUG_COMMAND_MEMORY_READY, 0, &BreakReceived, NULL);\r
CommandCommunication (Vector, CpuContext, BreakReceived);\r
+ break;\r
\r
- } else {\r
+ case DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD:\r
+ case DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD:\r
+ //\r
+ // Set AL to DEBUG_AGENT_IMAGE_CONTINUE\r
+ //\r
+ Al = ArchReadRegisterBuffer (CpuContext, SOFT_DEBUGGER_REGISTER_AX, &Data8);\r
+ *Al = DEBUG_AGENT_IMAGE_CONTINUE;\r
\r
- if (BreakCause == DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD || BreakCause == DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD) {\r
- \r
+ if (!IsHostAttached ()) {\r
//\r
- // Set AL to DEBUG_AGENT_IMAGE_CONTINUE\r
+ // If HOST is not connected for image load/unload, return\r
//\r
- Data8 = DEBUG_AGENT_IMAGE_CONTINUE;\r
- ArchWriteRegisterBuffer (CpuContext, SOFT_DEBUGGER_REGISTER_AX, 0, 1, &Data8);\r
-\r
- if (!IsHostConnected ()) {\r
- //\r
- // If HOST is not connected, return\r
- //\r
- break;\r
- }\r
+ break;\r
}\r
-\r
+ //\r
+ // Continue to run the following common code\r
+ //\r
+ \r
+ case DEBUG_DATA_BREAK_CAUSE_HW_BREAKPOINT:\r
+ case DEBUG_DATA_BREAK_CAUSE_SW_BREAKPOINT:\r
+ default:\r
+ //\r
+ // Send Break packet to HOST\r
+ //\r
AcquireDebugPortControl ();\r
-\r
- if (MultiProcessorDebugSupport) {\r
- if(!IsAllCpuRunning ()) {\r
- //\r
- // If other processors have been stopped\r
- //\r
- SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);\r
- } else {\r
- //\r
- // If no any processor was stopped, try to halt other processors\r
- //\r
- HaltOtherProcessors (ProcessorIndex);\r
- SendAckPacket (DEBUG_COMMAND_BREAK_POINT);\r
- WaitForAckPacketOK (0, &BreakReceived);\r
- }\r
- } else {\r
- SendAckPacket (DEBUG_COMMAND_BREAK_POINT);\r
- WaitForAckPacketOK (0, &BreakReceived);\r
+ //\r
+ // Only the first breaking processor could send BREAK_POINT to HOST\r
+ // \r
+ if (IsFirstBreakProcessor (ProcessorIndex)) {\r
+ SendBreakPacketToHost (ProcessorIndex, &BreakReceived);\r
}\r
-\r
ReleaseDebugPortControl ();\r
-\r
+ \r
if (Vector == DEBUG_INT3_VECTOR) {\r
//\r
// go back address located "0xCC"\r
} else {\r
CommandCommunication (Vector, CpuContext, BreakReceived);\r
}\r
+ break;\r
}\r
\r
break;\r
\r
case DEBUG_TIMER_VECTOR:\r
\r
+ AcquireDebugPortControl ();\r
+\r
if (MultiProcessorDebugSupport) {\r
if (IsBsp (ProcessorIndex)) {\r
//\r
}\r
\r
if (!IsBsp (ProcessorIndex) || mDebugMpContext.IpiSentByAp) {\r
+ ReleaseDebugPortControl ();\r
//\r
// If current processor is not BSP or this is one IPI sent by AP\r
//\r
//\r
// Only BSP could run here\r
//\r
-\r
- AcquireDebugPortControl ();\r
- \r
- while (DebugPortPollBuffer (Handle)) {\r
+ while (TRUE) {\r
//\r
- // If there is data in debug port, will check whether it is break-in symbol,\r
+ // If there is data in debug port, will check whether it is break(attach/break-in) symbol,\r
// If yes, go into communication mode with HOST.\r
// If no, exit interrupt process.\r
//\r
- DebugPortReadBuffer (Handle, &InputCharacter, 1, 0);\r
- if (InputCharacter == DEBUG_STARTING_SYMBOL_BREAK) {\r
+ if (DebugReadBreakSymbol (Handle, &InputCharacter) == EFI_NOT_FOUND) {\r
+ break;\r
+ }\r
+ if ((!IsHostAttached () && (InputCharacter == DEBUG_STARTING_SYMBOL_ATTACH)) ||\r
+ (IsHostAttached () && (InputCharacter == DEBUG_STARTING_SYMBOL_BREAK))\r
+ ) {\r
+ DebugAgentMsgPrint (DEBUG_AGENT_VERBOSE, "Received data [%02x]\n", InputCharacter);\r
+ //\r
+ // Ack OK for break-in symbol\r
+ //\r
SendAckPacket (DEBUG_COMMAND_OK);\r
+\r
+ if (!IsHostAttached ()) {\r
+ //\r
+ // Try to attach HOST, if no ack received after 200ms, return\r
+ //\r
+ if (AttachHost (INIT_BREAK_ACK_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {\r
+ break;\r
+ }\r
+ }\r
+\r
if (MultiProcessorDebugSupport) {\r
- if(FindCpuNotRunning () != -1) {\r
+ if(FindNextPendingBreakCpu () != -1) {\r
SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);\r
} else {\r
HaltOtherProcessors (ProcessorIndex);\r
default:\r
\r
if (Vector <= DEBUG_EXCEPT_SIMD) {\r
-\r
- AcquireDebugPortControl ();\r
-\r
- if (MultiProcessorDebugSupport) {\r
- if(FindCpuNotRunning () != -1) {\r
- SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);\r
- } else {\r
- HaltOtherProcessors (ProcessorIndex);\r
+ BreakCause = GetBreakCause (Vector, CpuContext);\r
+ if (BreakCause == DEBUG_DATA_BREAK_CAUSE_STEPPING) {\r
+ //\r
+ // Stepping is finished, send Ack package.\r
+ //\r
+ if (MultiProcessorDebugSupport) {\r
+ mDebugMpContext.BreakAtCpuIndex = ProcessorIndex;\r
}\r
+ SendAckPacket (DEBUG_COMMAND_OK);\r
+ } else {\r
+ //\r
+ // Exception occurs, send Break packet to HOST\r
+ //\r
+ AcquireDebugPortControl ();\r
+ //\r
+ // Only the first breaking processor could send BREAK_POINT to HOST\r
+ // \r
+ if (IsFirstBreakProcessor (ProcessorIndex)) {\r
+ SendBreakPacketToHost (ProcessorIndex, &BreakReceived);\r
+ }\r
+ ReleaseDebugPortControl ();\r
}\r
- SendAckPacket (DEBUG_COMMAND_BREAK_POINT);\r
- WaitForAckPacketOK (0, &BreakReceived);\r
- ReleaseDebugPortControl ();\r
+ \r
CommandCommunication (Vector, CpuContext, BreakReceived);\r
}\r
break;\r
// Clear flag and wait for all processors run here\r
//\r
SetIpiSentByApFlag (FALSE);\r
- while (mDebugMpContext.RunCommandSet);\r
+ while (mDebugMpContext.RunCommandSet) {\r
+ CpuPause ();\r
+ }\r
+\r
+ //\r
+ // Only current (view) processor could clean up AgentInProgress flag.\r
+ //\r
+ if (mDebugMpContext.ViewPointIndex == ProcessorIndex) {\r
+ IssuedViewPoint = mDebugMpContext.ViewPointIndex;\r
+ }\r
+ }\r
+\r
+ if (IssuedViewPoint == ProcessorIndex) {\r
+ //\r
+ // Clean up AgentInProgress flag\r
+ //\r
+ GetMailboxPointer()->DebugFlag.AgentInProgress = 0;\r
}\r
\r
return;\r
#include <Library/LocalApicLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/TimerLib.h>\r
+#include <Library/PrintLib.h>\r
\r
#include <TransferProtocol.h>\r
#include <ImageDebugSupport.h>\r
#include "DebugTimer.h"\r
#include "ArchDebugSupport.h"\r
\r
-#define DEBUG_AGENT_REVISION ((0 << 16) | 01)\r
-#define DEBUG_AGENT_CAPABILITIES 0\r
-\r
#define DEBUG_INT1_VECTOR 1\r
#define DEBUG_INT3_VECTOR 3\r
#define DEBUG_TIMER_VECTOR 32\r
extern UINTN TimerInterruptHandle;\r
extern UINT16 ExceptionStubHeaderSize;\r
\r
-typedef union {\r
- struct {\r
- UINT32 HostPresent : 1;\r
- UINT32 BreakOnNextSmi : 1;\r
- UINT32 Reserved : 30;\r
- } Bits;\r
- UINT32 Uint32;\r
-} DEBUG_AGENT_FLAG;\r
+//\r
+// CPU exception information issued by debug agent\r
+//\r
+typedef struct {\r
+ //\r
+ // This field is used to save CPU content before executing HOST command\r
+ //\r
+ BASE_LIBRARY_JUMP_BUFFER JumpBuffer;\r
+ //\r
+ // This filed returens the exception information issued by HOST command\r
+ //\r
+ DEBUG_DATA_RESPONSE_GET_EXCEPTION ExceptionContent;\r
+} DEBUG_AGENT_EXCEPTION_BUFFER;\r
\r
#pragma pack(1)\r
+typedef struct {\r
+ //\r
+ // Lower 32 bits to store the status of DebugAgent\r
+ //\r
+ UINT32 HostAttached : 1; // 1: HOST is attached\r
+ UINT32 AgentInProgress : 1; // 1: Debug Agent is communicating with HOST\r
+ UINT32 MemoryReady : 1; // 1: Memory is ready\r
+ UINT32 SteppingFlag : 1; // 1: Agent is running stepping command\r
+ UINT32 Reserved1 : 28;\r
+\r
+ //\r
+ // Higher 32bits to control the behavior of DebugAgent\r
+ //\r
+ UINT32 BreakOnNextSmi : 1; // 1: Break on next SMI\r
+ UINT32 PrintErrorLevel : 8; // Bitmask of print error level for debug message\r
+ UINT32 Reserved2 : 23;\r
+} DEBUG_AGENT_FLAG;\r
+\r
typedef struct {\r
DEBUG_AGENT_FLAG DebugFlag;\r
UINT64 DebugPortHandle;\r
+ //\r
+ // Pointer to DEBUG_AGENT_EXCEPTION_BUFFER\r
+ //\r
+ UINT64 ExceptionBufferPointer;\r
} DEBUG_AGENT_MAILBOX;\r
#pragma pack()\r
\r
VOID\r
);\r
\r
-/**\r
- Write specified register into save CPU context.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range\r
- @param[in] Width Data width to read.\r
- @param[in] RegisterBuffer Pointer to input buffer with data.\r
-\r
-**/\r
-VOID\r
-ArchWriteRegisterBuffer (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 Index,\r
- IN UINT8 Offset,\r
- IN UINT8 Width,\r
- IN UINT8 *RegisterBuffer\r
- );\r
-\r
/**\r
Read register value from saved CPU context.\r
\r
@param[in] CpuContext Pointer to saved CPU context.\r
@param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range\r
@param[in] Width Data width to read.\r
\r
@return The address of register value.\r
ArchReadRegisterBuffer (\r
IN DEBUG_CPU_CONTEXT *CpuContext,\r
IN UINT8 Index,\r
- IN UINT8 Offset,\r
IN UINT8 *Width\r
);\r
\r
/**\r
Send packet with response data to HOST.\r
\r
- @param[in] CpuContext Pointer to saved CPU context.\r
@param[in] Data Pointer to response data buffer.\r
@param[in] DataSize Size of response data in byte.\r
\r
**/\r
RETURN_STATUS\r
SendDataResponsePacket (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
IN UINT8 *Data,\r
IN UINT16 DataSize\r
);\r
\r
/**\r
- Read segment selector by register index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterIndex Register Index.\r
+ Check if HOST is attached based on Mailbox.\r
\r
- @return Value of segment selector.\r
+ @retval TRUE HOST is attached.\r
+ @retval FALSE HOST is not attached.\r
\r
**/\r
-UINT64\r
-ReadRegisterSelectorByIndex (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 RegisterIndex\r
- );\r
-\r
-/**\r
- Read group register of common registers.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroup Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP *RegisterGroup\r
- );\r
-\r
-/**\r
- Read group register of Segment Base.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegBase Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegBase (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE *RegisterGroupSegBase\r
- );\r
-\r
-/**\r
- Read gourp register of Segment Limit.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegLim Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegLim (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM *RegisterGroupSegLim\r
+BOOLEAN\r
+IsHostAttached (\r
+ VOID\r
);\r
\r
/**\r
- Read group register by group index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] GroupIndex Group Index.\r
+ Get Debug Agent Mailbox pointer.\r
\r
- @retval RETURN_SUCCESS Read successfully.\r
- @retval RETURN_NOT_SUPPORTED Group index cannot be supported.\r
+ @return Mailbox pointer.\r
\r
**/\r
-RETURN_STATUS\r
-ArchReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 GroupIndex\r
+DEBUG_AGENT_MAILBOX *\r
+GetMailboxPointer (\r
+ VOID\r
);\r
\r
/**\r
- Send acknowledge packet to HOST.\r
+ Get debug port handle.\r
\r
- @param AckCommand Type of Acknowledge packet.\r
+ @return Debug port handle.\r
\r
**/\r
-VOID\r
-SendAckPacket (\r
- IN UINT8 AckCommand\r
+DEBUG_PORT_HANDLE\r
+GetDebugPortHandle (\r
+ VOID\r
);\r
\r
/**\r
- Receive acknowledge packet OK from HOST in specified time.\r
-\r
- @param[in] Timeout Time out value to wait for acknowlege from HOST.\r
- The unit is microsecond.\r
- @param[out] BreakReceived If BreakReceived is not NULL,\r
- TRUE is retured if break-in symbol received.\r
- FALSE is retured if break-in symbol not received.\r
-\r
- @retval RETRUEN_SUCCESS Succeed to receive acknowlege packet from HOST,\r
- the type of acknowlege packet saved in Ack.\r
- @retval RETURN_TIMEOUT Specified timeout value was up.\r
-\r
-**/\r
-RETURN_STATUS\r
-WaitForAckPacketOK (\r
- IN UINTN Timeout,\r
- OUT BOOLEAN *BreakReceived OPTIONAL\r
- );\r
+ Read the Attach/Break-in symbols from the debug port.\r
\r
-/**\r
- Check if HOST is connected based on Mailbox.\r
+ @param[in] Handle Pointer to Debug Port handle.\r
+ @param[out] BreakSymbol Returned break symbol.\r
\r
- @retval TRUE HOST is connected.\r
- @retval FALSE HOST is not connected.\r
+ @retval EFI_SUCCESS Read the symbol in BreakSymbol.\r
+ @retval EFI_NOT_FOUND No read the break symbol.\r
\r
**/\r
-BOOLEAN\r
-IsHostConnected (\r
- VOID\r
+EFI_STATUS\r
+DebugReadBreakSymbol (\r
+ IN DEBUG_PORT_HANDLE Handle,\r
+ OUT UINT8 *BreakSymbol\r
);\r
\r
/**\r
- Get Debug Agent Mailbox pointer.\r
+ Prints a debug message to the debug port if the specified error level is enabled.\r
\r
- @return Mailbox pointer.\r
+ If any bit in ErrorLevel is also set in Mainbox, then print the message specified\r
+ by Format and the associated variable argument list to the debug port.\r
\r
-**/\r
-DEBUG_AGENT_MAILBOX *\r
-GetMailboxPointer (\r
- VOID\r
- );\r
-\r
-/**\r
- Get debug port handle.\r
-\r
- @return Debug port handle.\r
+ @param[in] ErrorLevel The error level of the debug message.\r
+ @param[in] Format Format string for the debug message to print.\r
+ @param[in] ... Variable argument list whose contents are accessed \r
+ based on the format string specified by Format.\r
\r
**/\r
-DEBUG_PORT_HANDLE\r
-GetDebugPortHandle (\r
- VOID\r
+VOID\r
+EFIAPI\r
+DebugAgentMsgPrint (\r
+ IN UINT8 ErrorLevel,\r
+ IN CHAR8 *Format,\r
+ ...\r
);\r
-\r
#endif\r
\r
/** @file\r
Multi-Processor support functions implementation.\r
\r
- Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
IN UINT32 CurrentProcessorIndex\r
)\r
{\r
-\r
+ DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Try to halt other processors.\n", CurrentProcessorIndex);\r
if (!IsBsp (CurrentProcessorIndex)) {\r
SetIpiSentByApFlag (TRUE);;\r
}\r
}\r
\r
/**\r
- Initialize debug timer.\r
+ Set the IPI send by BPS/AP flag.\r
\r
@param[in] IpiSentByApFlag TRUE means this IPI is sent by AP.\r
FALSE means this IPI is sent by BSP.\r
}\r
\r
/**\r
- Check if any processor breaks.\r
+ Check the next pending breaking CPU.\r
\r
@retval others There is at least one processor broken, the minimum\r
index number of Processor returned.\r
\r
**/\r
UINT32\r
-FindCpuNotRunning (\r
+FindNextPendingBreakCpu (\r
VOID\r
)\r
{\r
return TRUE;\r
}\r
\r
+/**\r
+ Check if the current processor is the first breaking processor.\r
+\r
+ If yes, halt other processors. \r
+ \r
+ @param[in] ProcessorIndex Processor index value.\r
+ \r
+ @return TRUE This processor is the first breaking processor.\r
+ @return FALSE This processor is not the first breaking processor.\r
+ \r
+**/\r
+BOOLEAN\r
+IsFirstBreakProcessor (\r
+ IN UINT32 ProcessorIndex\r
+ )\r
+{\r
+ if (MultiProcessorDebugSupport) {\r
+ if (mDebugMpContext.BreakAtCpuIndex != (UINT32) -1) {\r
+ //\r
+ // The current processor is not the first breaking one.\r
+ //\r
+ SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);\r
+ return FALSE;\r
+ } else {\r
+ //\r
+ // If no any processor breaks, try to halt other processors\r
+ //\r
+ HaltOtherProcessors (ProcessorIndex);\r
+ return TRUE;\r
+ }\r
+ }\r
+ return TRUE;\r
+} \r
+\r
/** @file\r
Header file for Multi-Processor support.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
UINT32 BreakAtCpuIndex; ///< Processor index value of the current breaking CPU\r
UINT32 DebugTimerInitCount; ///< Record BSP's init timer count\r
BOOLEAN IpiSentByAp; ///< TRUR: IPI is sent by AP. TALSE: IPI is sent by BSP\r
- BOOLEAN RunCommandSet; ///< TRUE: RUN commmand is not executed. FALSE : RUN command is executed.\r
+ BOOLEAN RunCommandSet; ///< TRUE: RUN commmand is executing. FALSE : RUN command has been executed.\r
} DEBUG_MP_CONTEXT;\r
\r
extern CONST BOOLEAN MultiProcessorDebugSupport;\r
);\r
\r
/**\r
- Initialize debug timer.\r
+ Set the IPI send by BPS/AP flag.\r
\r
@param[in] IpiSentByApFlag TRUE means this IPI is sent by AP.\r
FALSE means this IPI is sent by BSP.\r
);\r
\r
/**\r
- Check if any processor breaks.\r
+ Check the next pending breaking CPU.\r
\r
@retval others There is at least one processor broken, the minimum\r
index number of Processor returned.\r
\r
**/\r
UINT32\r
-FindCpuNotRunning (\r
+FindNextPendingBreakCpu (\r
VOID\r
);\r
\r
VOID\r
);\r
\r
+/**\r
+ Check if the current processor is the first breaking processor.\r
+\r
+ If yes, halt other processors. \r
+ \r
+ @param[in] ProcessorIndex Processor index value.\r
+ \r
+ @return TRUE This processor is the first breaking processor.\r
+ @return FALSE This processor is not the first breaking processor.\r
+ \r
+**/\r
+BOOLEAN\r
+IsFirstBreakProcessor (\r
+ IN UINT32 ProcessorIndex\r
+ );\r
+ \r
#endif\r
\r
/** @file\r
- Public include file for Debug Port Library.\r
+ Supporting functions for IA32 architecture.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
\r
#include "DebugAgent.h"\r
\r
-/**\r
- Read the offset of FP / MMX / XMM registers by register index.\r
-\r
- @param[in] Index Register index.\r
- @param[out] Width Register width returned.\r
-\r
- @return Offset in register address range.\r
-\r
-**/\r
-UINT16\r
-ArchReadFxStatOffset (\r
- IN UINT8 Index,\r
- OUT UINT8 *Width\r
- )\r
-{\r
- if (Index < SOFT_DEBUGGER_REGISTER_ST0) {\r
- switch (Index) {\r
- case SOFT_DEBUGGER_REGISTER_FP_FCW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Fcw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_FSW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Fsw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_FTW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Ftw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_OPCODE:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Opcode);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_EIP:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Eip);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_CS:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Cs);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, DataOffset);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_DS:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Ds);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_MXCSR:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Mxcsr);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return (UINT16)OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, Mxcsr_Mask);\r
- }\r
- }\r
-\r
- if (Index < SOFT_DEBUGGER_REGISTER_XMM0) {\r
- *Width = 10;\r
- } else if (Index < SOFT_DEBUGGER_REGISTER_MM0 ) {\r
- *Width = 16;\r
- } else {\r
- *Width = 8;\r
- Index -= SOFT_DEBUGGER_REGISTER_MM0 - SOFT_DEBUGGER_REGISTER_ST0;\r
- }\r
-\r
- return (UINT16)(OFFSET_OF(DEBUG_DATA_IA32_FX_SAVE_STATE, St0Mm0) + (Index - SOFT_DEBUGGER_REGISTER_ST0) * 16);\r
-}\r
-\r
-/**\r
- Write specified register into save CPU context.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range.\r
- @param[in] Width Data width to read.\r
- @param[in] RegisterBuffer Pointer to input buffer with data.\r
-\r
-**/\r
-VOID\r
-ArchWriteRegisterBuffer (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 Index,\r
- IN UINT8 Offset,\r
- IN UINT8 Width,\r
- IN UINT8 *RegisterBuffer\r
- )\r
-{\r
- UINT8 *Buffer;\r
- if (Index < SOFT_DEBUGGER_REGISTER_FP_BASE) {\r
- Buffer = (UINT8 *) CpuContext + sizeof (DEBUG_DATA_IA32_FX_SAVE_STATE) + Index * 4;\r
- } else {\r
- //\r
- // If it is MMX register, adjust its index position\r
- //\r
- if (Index >= SOFT_DEBUGGER_REGISTER_MM0) {\r
- Index -= SOFT_DEBUGGER_REGISTER_MM0 - SOFT_DEBUGGER_REGISTER_ST0;\r
- }\r
- //\r
- // FPU/MMX/XMM registers\r
- //\r
- Buffer = (UINT8 *) CpuContext + ArchReadFxStatOffset (Index, &Width);\r
- }\r
-\r
- CopyMem (Buffer + Offset, RegisterBuffer, Width);\r
-}\r
-\r
-/**\r
- Read register value from saved CPU context.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range\r
- @param[in] Width Data width to read.\r
-\r
- @return The address of register value.\r
-\r
-**/\r
-UINT8 *\r
-ArchReadRegisterBuffer (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 Index,\r
- IN UINT8 Offset,\r
- IN UINT8 *Width\r
- )\r
-{\r
- UINT8 *Buffer;\r
-\r
- if (Index < SOFT_DEBUGGER_REGISTER_FP_BASE) {\r
- Buffer = (UINT8 *) CpuContext + sizeof (DEBUG_DATA_IA32_FX_SAVE_STATE) + Index * 4;\r
- if (*Width == 0) {\r
- *Width = (UINT8) sizeof (UINTN);\r
- }\r
- } else {\r
- //\r
- // FPU/MMX/XMM registers\r
- //\r
- Buffer = (UINT8 *) CpuContext + ArchReadFxStatOffset (Index, Width);\r
- }\r
-\r
- return Buffer;\r
-}\r
-\r
-/**\r
- Read group register of common registers.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroup Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP *RegisterGroup\r
- )\r
-{\r
- RegisterGroup->Cs = (UINT16) CpuContext->Cs;\r
- RegisterGroup->Ds = (UINT16) CpuContext->Ds;\r
- RegisterGroup->Es = (UINT16) CpuContext->Es;\r
- RegisterGroup->Fs = (UINT16) CpuContext->Fs;\r
- RegisterGroup->Gs = (UINT16) CpuContext->Gs;\r
- RegisterGroup->Ss = (UINT16) CpuContext->Ss;\r
- RegisterGroup->Eflags = CpuContext->Eflags;\r
- RegisterGroup->Ebp = CpuContext->Ebp;\r
- RegisterGroup->Eip = CpuContext->Eip;\r
- RegisterGroup->Esp = CpuContext->Esp;\r
- RegisterGroup->Eax = CpuContext->Eax;\r
- RegisterGroup->Ebx = CpuContext->Ebx;\r
- RegisterGroup->Ecx = CpuContext->Ecx;\r
- RegisterGroup->Edx = CpuContext->Edx;\r
- RegisterGroup->Esi = CpuContext->Esi;\r
- RegisterGroup->Edi = CpuContext->Edi;\r
- RegisterGroup->Dr0 = CpuContext->Dr0;\r
- RegisterGroup->Dr1 = CpuContext->Dr1;\r
- RegisterGroup->Dr2 = CpuContext->Dr2;\r
- RegisterGroup->Dr3 = CpuContext->Dr3;\r
- RegisterGroup->Dr6 = CpuContext->Dr6;\r
- RegisterGroup->Dr7 = CpuContext->Dr7;\r
-}\r
-\r
/**\r
Initialize IDT entries to support source level debug.\r
\r
InterruptHandler = (UINTN) &TimerInterruptHandle;\r
IdtEntry[DEBUG_TIMER_VECTOR].Bits.OffsetLow = (UINT16)(UINTN)InterruptHandler;\r
IdtEntry[DEBUG_TIMER_VECTOR].Bits.OffsetHigh = (UINT16)((UINTN)InterruptHandler >> 16);\r
- IdtEntry[Index].Bits.Selector = CodeSegment;\r
- IdtEntry[Index].Bits.GateType = IA32_IDT_GATE_TYPE_INTERRUPT_32;\r
+ IdtEntry[DEBUG_TIMER_VECTOR].Bits.Selector = CodeSegment;\r
+ IdtEntry[DEBUG_TIMER_VECTOR].Bits.GateType = IA32_IDT_GATE_TYPE_INTERRUPT_32;\r
+ \r
+ //\r
+ // Set DE flag in CR4 to enable IO breakpoint\r
+ //\r
+ AsmWriteCr4 (AsmReadCr4 () | BIT3);\r
}\r
/** @file\r
IA32 specific defintions for debug agent library instance.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
#ifndef _ARCH_DEBUG_SUPPORT_H_\r
#define _ARCH_DEBUG_SUPPORT_H_\r
\r
-#include "ArchRegisters.h"\r
+#include "ProcessorContext.h"\r
#include "TransferProtocol.h"\r
\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_IA32 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP;\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM_IA32 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM;\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE_IA32 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE;\r
-\r
#define DEBUG_SW_BREAKPOINT_SYMBOL 0xcc\r
-\r
#define DEBUG_ARCH_SYMBOL DEBUG_DATA_BREAK_CPU_ARCH_IA32\r
\r
+typedef DEBUG_DATA_IA32_FX_SAVE_STATE DEBUG_DATA_FX_SAVE_STATE;\r
typedef DEBUG_DATA_IA32_SYSTEM_CONTEXT DEBUG_CPU_CONTEXT;\r
\r
#endif\r
+++ /dev/null
-/** @file\r
- IA32 Group registers read support functions.\r
-\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include "DebugAgent.h"\r
-\r
-/**\r
- Read group register of Segment Base.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegBase Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegBase (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE *RegisterGroupSegBase\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINTN Index;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Index = CpuContext->Cs / 8;\r
- RegisterGroupSegBase->CsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Ss / 8;\r
- RegisterGroupSegBase->SsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Gs / 8;\r
- RegisterGroupSegBase->GsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Fs / 8;\r
- RegisterGroupSegBase->FsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Es / 8;\r
- RegisterGroupSegBase->EsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Ds / 8;\r
- RegisterGroupSegBase->DsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
-\r
- RegisterGroupSegBase->LdtBas = 0;\r
- RegisterGroupSegBase->TssBas = 0;\r
-}\r
-\r
-/**\r
- Read gourp register of Segment Limit.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegLim Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegLim (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM *RegisterGroupSegLim\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINTN Index;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Index = CpuContext->Cs / 8;\r
- RegisterGroupSegLim->CsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->CsLim = (RegisterGroupSegLim->CsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Ss / 8;\r
- RegisterGroupSegLim->SsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->SsLim = (RegisterGroupSegLim->SsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Gs / 8;\r
- RegisterGroupSegLim->GsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->GsLim = (RegisterGroupSegLim->GsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Fs / 8;\r
- RegisterGroupSegLim->FsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->FsLim = (RegisterGroupSegLim->FsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Es / 8;\r
- RegisterGroupSegLim->EsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->EsLim = (RegisterGroupSegLim->EsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Ds / 8;\r
- RegisterGroupSegLim->DsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->DsLim = (RegisterGroupSegLim->DsLim << 12) | 0xfff;\r
- }\r
-\r
- RegisterGroupSegLim->LdtLim = 0xffff;\r
- RegisterGroupSegLim->TssLim = 0xffff;\r
-}\r
-\r
-/**\r
- Read group register by group index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] GroupIndex Group Index.\r
-\r
- @retval RETURN_SUCCESS Read successfully.\r
- @retval RETURN_NOT_SUPPORTED Group index cannot be supported.\r
-\r
-**/\r
-RETURN_STATUS\r
-ArchReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 GroupIndex\r
- )\r
-{\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP RegisterGroup;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM RegisterGroupSegLim;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE RegisterGroupSegBase;\r
-\r
- switch (GroupIndex) {\r
- case SOFT_DEBUGGER_REGISTER_GROUP_GPDRS32:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_LIMITS32:\r
- ReadRegisterGroupSegLim (CpuContext, &RegisterGroupSegLim);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroupSegLim, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES32:\r
- ReadRegisterGroupSegBase (CpuContext, &RegisterGroupSegBase);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroupSegBase, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE));\r
- break;\r
-\r
- default:\r
- return RETURN_UNSUPPORTED;\r
- }\r
-\r
- return RETURN_SUCCESS;\r
-}\r
-\r
-/**\r
- Read segment selector by register index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterIndex Register Index.\r
-\r
- @return Value of segment selector.\r
-\r
-**/\r
-UINT64\r
-ReadRegisterSelectorByIndex (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 RegisterIndex\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINT16 Selector;\r
- UINT32 Data32;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Selector = 0;\r
-\r
- switch (RegisterIndex) {\r
- case SOFT_DEBUGGER_REGISTER_CSAS:\r
- Selector = (UINT16) CpuContext->Cs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_SSAS:\r
- Selector = (UINT16) CpuContext->Ss;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_GSAS:\r
- Selector = (UINT16) CpuContext->Gs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_FSAS:\r
- Selector = (UINT16) CpuContext->Fs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_ESAS:\r
- Selector = (UINT16) CpuContext->Es;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_DSAS:\r
- Selector = (UINT16) CpuContext->Ds;\r
- case SOFT_DEBUGGER_REGISTER_LDTAS:\r
- case SOFT_DEBUGGER_REGISTER_TSSAS:\r
- return 0x00820000;\r
- break;\r
- }\r
-\r
- Data32 = (UINT32) RShiftU64 (Ia32Gdt[Selector / 8].Uint64, 24);\r
- return (Data32 & (UINT32)(~0xff)) | Selector;\r
-\r
-}\r
-\r
+++ /dev/null
-/** @file\r
- IA32 register defintions needed by debug transfer protocol.\r
-\r
- Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef _ARCH_REGISTERS_H_\r
-#define _ARCH_REGISTERS_H_\r
-\r
-#pragma pack(1)\r
-\r
-///\r
-/// FXSAVE_STATE\r
-/// FP / MMX / XMM registers (see fxrstor instruction definition)\r
-///\r
-typedef struct {\r
- UINT16 Fcw;\r
- UINT16 Fsw;\r
- UINT16 Ftw;\r
- UINT16 Opcode;\r
- UINT32 Eip;\r
- UINT16 Cs;\r
- UINT16 Reserved1;\r
- UINT32 DataOffset;\r
- UINT16 Ds;\r
- UINT8 Reserved2[2];\r
- UINT32 Mxcsr;\r
- UINT32 Mxcsr_Mask;\r
- UINT8 St0Mm0[10];\r
- UINT8 Reserved3[6];\r
- UINT8 St1Mm1[10];\r
- UINT8 Reserved4[6];\r
- UINT8 St2Mm2[10];\r
- UINT8 Reserved5[6];\r
- UINT8 St3Mm3[10];\r
- UINT8 Reserved6[6];\r
- UINT8 St4Mm4[10];\r
- UINT8 Reserved7[6];\r
- UINT8 St5Mm5[10];\r
- UINT8 Reserved8[6];\r
- UINT8 St6Mm6[10];\r
- UINT8 Reserved9[6];\r
- UINT8 St7Mm7[10];\r
- UINT8 Reserved10[6];\r
- UINT8 Xmm0[16];\r
- UINT8 Xmm1[16];\r
- UINT8 Xmm2[16];\r
- UINT8 Xmm3[16];\r
- UINT8 Xmm4[16];\r
- UINT8 Xmm5[16];\r
- UINT8 Xmm6[16];\r
- UINT8 Xmm7[16];\r
- UINT8 Reserved11[14 * 16];\r
-} DEBUG_DATA_IA32_FX_SAVE_STATE;\r
-\r
-///\r
-/// IA-32 processor context definition\r
-///\r
-typedef struct {\r
- DEBUG_DATA_IA32_FX_SAVE_STATE FxSaveState;\r
- UINT32 Dr0;\r
- UINT32 Dr1;\r
- UINT32 Dr2;\r
- UINT32 Dr3;\r
- UINT32 Dr6;\r
- UINT32 Dr7;\r
- UINT32 Eflags;\r
- UINT32 Ldtr;\r
- UINT32 Tr;\r
- UINT32 Gdtr[2];\r
- UINT32 Idtr[2];\r
- UINT32 Eip;\r
- UINT32 Gs;\r
- UINT32 Fs;\r
- UINT32 Es;\r
- UINT32 Ds;\r
- UINT32 Cs;\r
- UINT32 Ss;\r
- UINT32 Cr0;\r
- UINT32 Cr1; ///< Reserved\r
- UINT32 Cr2;\r
- UINT32 Cr3;\r
- UINT32 Cr4;\r
- UINT32 Edi;\r
- UINT32 Esi;\r
- UINT32 Ebp;\r
- UINT32 Esp;\r
- UINT32 Edx;\r
- UINT32 Ecx;\r
- UINT32 Ebx;\r
- UINT32 Eax;\r
-} DEBUG_DATA_IA32_SYSTEM_CONTEXT;\r
-\r
-///\r
-/// IA32 GROUP register\r
-///\r
-typedef struct {\r
- UINT16 Cs;\r
- UINT16 Ds;\r
- UINT16 Es;\r
- UINT16 Fs;\r
- UINT16 Gs;\r
- UINT16 Ss;\r
- UINT32 Eflags;\r
- UINT32 Ebp;\r
- UINT32 Eip;\r
- UINT32 Esp;\r
- UINT32 Eax;\r
- UINT32 Ebx;\r
- UINT32 Ecx;\r
- UINT32 Edx;\r
- UINT32 Esi;\r
- UINT32 Edi;\r
- UINT32 Dr0;\r
- UINT32 Dr1;\r
- UINT32 Dr2;\r
- UINT32 Dr3;\r
- UINT32 Dr6;\r
- UINT32 Dr7;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_IA32;\r
-\r
-///\r
-/// IA32 Segment Limit GROUP register\r
-///\r
-typedef struct {\r
- UINT32 CsLim;\r
- UINT32 SsLim;\r
- UINT32 GsLim;\r
- UINT32 FsLim;\r
- UINT32 EsLim;\r
- UINT32 DsLim;\r
- UINT32 LdtLim;\r
- UINT32 TssLim;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM_IA32;\r
-\r
-///\r
-/// IA32 Segment Base GROUP register\r
-///\r
-typedef struct {\r
- UINT32 CsBas;\r
- UINT32 SsBas;\r
- UINT32 GsBas;\r
- UINT32 FsBas;\r
- UINT32 EsBas;\r
- UINT32 DsBas;\r
- UINT32 LdtBas;\r
- UINT32 TssBas;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE_IA32;\r
-\r
-#pragma pack()\r
-\r
-#endif\r
#------------------------------------------------------------------------------\r
#\r
-# Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution. The full text of the license may be found at\r
movl %esp,%edi\r
.byte 0x0f, 0xae, 0x07 # fxsave [edi]\r
\r
+## save the exception data\r
+ pushl 8(%esp)\r
+\r
## Clear Direction Flag\r
cld\r
\r
call ASM_PFX(InterruptProcess)\r
addl $8,%esp\r
\r
+## skip the exception data\r
+ addl $4,%esp\r
+\r
## FX_SAVE_STATE_IA32 FxSaveState;\r
movl %esp,%esi\r
.byte 0x0f, 0xae, 0x0e # fxrstor [esi]\r
;------------------------------------------------------------------------------\r
;\r
-; Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+; Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
; This program and the accompanying materials\r
; are licensed and made available under the terms and conditions of the BSD License\r
; which accompanies this distribution. The full text of the license may be found at\r
mov edi, esp\r
db 0fh, 0aeh, 00000111y ;fxsave [edi]\r
\r
+ ;; save the exception data \r
+ push dword ptr [ebp + 8]\r
+\r
;; Clear Direction Flag\r
cld\r
\r
call InterruptProcess\r
add esp, 8\r
\r
+ ; skip the exception data\r
+ add esp, 4\r
+\r
;; FX_SAVE_STATE_IA32 FxSaveState;\r
mov esi, esp\r
db 0fh, 0aeh, 00001110y ; fxrstor [esi]\r
/** @file\r
- Supporting functions for x64 architecture.\r
+ Supporting functions for X64 architecture.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
\r
#include "DebugAgent.h"\r
\r
-/**\r
- Read the offset of FP / MMX / XMM registers by register index.\r
-\r
- @param[in] Index Register index.\r
- @param[out] Width Register width returned.\r
-\r
- @return Offset in register address range.\r
-\r
-**/\r
-UINT16\r
-ArchReadFxStatOffset (\r
- IN UINT8 Index,\r
- OUT UINT8 *Width\r
- )\r
-{\r
- if (Index < SOFT_DEBUGGER_REGISTER_ST0) {\r
- switch (Index) {\r
- case SOFT_DEBUGGER_REGISTER_FP_FCW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Fcw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_FSW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Fsw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_FTW:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Ftw);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_OPCODE:\r
- *Width = (UINT8) sizeof (UINT16);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Opcode);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_EIP:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Rip);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET:\r
- *Width = (UINT8) sizeof (UINTN);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, DataOffset);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_MXCSR:\r
- *Width = (UINT8) sizeof (UINT32);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Mxcsr);\r
-\r
- case SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK:\r
- *Width = (UINT8) sizeof (UINT32);\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, Mxcsr_Mask);\r
-\r
- default:\r
- return (UINT16) (-1);\r
- }\r
- }\r
-\r
- if (Index < SOFT_DEBUGGER_REGISTER_XMM0) {\r
- *Width = 10;\r
- } else if (Index < SOFT_DEBUGGER_REGISTER_MM0 ) {\r
- *Width = 16;\r
- } else {\r
- *Width = 8;\r
- Index -= SOFT_DEBUGGER_REGISTER_MM0 - SOFT_DEBUGGER_REGISTER_ST0;\r
- }\r
-\r
- return OFFSET_OF(DEBUG_DATA_X64_FX_SAVE_STATE, St0Mm0) + (Index - SOFT_DEBUGGER_REGISTER_ST0) * 16;\r
-}\r
-\r
-/**\r
- Write specified register into save CPU context.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range\r
- @param[in] Width Data width to read.\r
- @param[in] RegisterBuffer Pointer to input buffer with data.\r
-\r
-**/\r
-VOID\r
-ArchWriteRegisterBuffer (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 Index,\r
- IN UINT8 Offset,\r
- IN UINT8 Width,\r
- IN UINT8 *RegisterBuffer\r
- )\r
-{\r
- UINT8 *Buffer;\r
- if (Index < SOFT_DEBUGGER_REGISTER_FP_BASE) {\r
- Buffer = (UINT8 *) CpuContext + sizeof (DEBUG_DATA_X64_FX_SAVE_STATE) + Index * 8;\r
- } else {\r
- //\r
- // If it is MMX register, adjust its index position\r
- //\r
- if (Index >= SOFT_DEBUGGER_REGISTER_MM0) {\r
- Index -= SOFT_DEBUGGER_REGISTER_MM0 - SOFT_DEBUGGER_REGISTER_ST0;\r
- }\r
-\r
- //\r
- // FPU/MMX/XMM registers\r
- //\r
- Buffer = (UINT8 *) CpuContext + ArchReadFxStatOffset (Index, &Width);\r
- }\r
-\r
- CopyMem (Buffer + Offset, RegisterBuffer, Width);\r
-}\r
-\r
-/**\r
- Read register value from saved CPU context.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] Index Register index value.\r
- @param[in] Offset Offset in register address range\r
- @param[in] Width Data width to read.\r
-\r
- @return The address of register value.\r
-\r
-**/\r
-UINT8 *\r
-ArchReadRegisterBuffer (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 Index,\r
- IN UINT8 Offset,\r
- IN UINT8 *Width\r
- )\r
-{\r
- UINT8 *Buffer;\r
-\r
- if (Index < SOFT_DEBUGGER_REGISTER_FP_BASE) {\r
- Buffer = (UINT8 *) CpuContext + sizeof (DEBUG_DATA_X64_FX_SAVE_STATE) + Index * 8;\r
- if (*Width == 0) {\r
- *Width = (UINT8) sizeof (UINTN);\r
- }\r
- } else {\r
- //\r
- // FPU/MMX/XMM registers\r
- //\r
- Buffer = (UINT8 *) CpuContext + ArchReadFxStatOffset (Index, Width);\r
- }\r
-\r
- return Buffer;\r
-}\r
-\r
-/**\r
- Read group register of common registers.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroup Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP *RegisterGroup\r
- )\r
-{\r
- RegisterGroup->Cs = (UINT16) CpuContext->Cs;\r
- RegisterGroup->Ds = (UINT16) CpuContext->Ds;\r
- RegisterGroup->Es = (UINT16) CpuContext->Es;\r
- RegisterGroup->Fs = (UINT16) CpuContext->Fs;\r
- RegisterGroup->Gs = (UINT16) CpuContext->Gs;\r
- RegisterGroup->Ss = (UINT16) CpuContext->Ss;\r
- RegisterGroup->Eflags = (UINT32) CpuContext->Eflags;\r
- RegisterGroup->Rbp = CpuContext->Rbp;\r
- RegisterGroup->Eip = CpuContext->Eip;\r
- RegisterGroup->Rsp = CpuContext->Rsp;\r
- RegisterGroup->Eax = CpuContext->Rax;\r
- RegisterGroup->Rbx = CpuContext->Rbx;\r
- RegisterGroup->Rcx = CpuContext->Rcx;\r
- RegisterGroup->Rdx = CpuContext->Rdx;\r
- RegisterGroup->Rsi = CpuContext->Rsi;\r
- RegisterGroup->Rdi = CpuContext->Rdi;\r
- RegisterGroup->R8 = CpuContext->R8;\r
- RegisterGroup->R9 = CpuContext->R9;\r
- RegisterGroup->R10 = CpuContext->R10;\r
- RegisterGroup->R11 = CpuContext->R11;\r
- RegisterGroup->R12 = CpuContext->R12;\r
- RegisterGroup->R13 = CpuContext->R13;\r
- RegisterGroup->R14 = CpuContext->R14;\r
- RegisterGroup->R15 = CpuContext->R15;\r
- RegisterGroup->Dr0 = CpuContext->Dr0;\r
- RegisterGroup->Dr1 = CpuContext->Dr1;\r
- RegisterGroup->Dr2 = CpuContext->Dr2;\r
- RegisterGroup->Dr3 = CpuContext->Dr3;\r
- RegisterGroup->Dr6 = CpuContext->Dr6;\r
- RegisterGroup->Dr7 = CpuContext->Dr7;\r
- RegisterGroup->Cr0 = CpuContext->Cr0;\r
- RegisterGroup->Cr2 = CpuContext->Cr2;\r
- RegisterGroup->Cr3 = CpuContext->Cr3;\r
- RegisterGroup->Cr4 = CpuContext->Cr4;\r
- RegisterGroup->Cr8 = CpuContext->Cr8;\r
-\r
- CopyMem ((UINT8 *) &RegisterGroup->Xmm0[0], (UINT8 *) &CpuContext->FxSaveState.Xmm0[0], 16 * 10);\r
-}\r
-\r
/**\r
Initialize IDT entries to support source level debug.\r
\r
IdtEntry[DEBUG_TIMER_VECTOR].Bits.OffsetUpper = (UINT32)((UINTN)InterruptHandler >> 32);\r
IdtEntry[DEBUG_TIMER_VECTOR].Bits.Selector = CodeSegment;\r
IdtEntry[DEBUG_TIMER_VECTOR].Bits.GateType = IA32_IDT_GATE_TYPE_INTERRUPT_32;\r
+\r
+ //\r
+ // Set DE flag in CR4 to enable IO breakpoint\r
+ //\r
+ AsmWriteCr4 (AsmReadCr4 () | BIT3);\r
}\r
/** @file\r
X64 specific defintions for debug agent library instance.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
#ifndef _ARCH_DEBUG_SUPPORT_H_\r
#define _ARCH_DEBUG_SUPPORT_H_\r
\r
-#include "ArchRegisters.h"\r
+#include "ProcessorContext.h"\r
#include "TransferProtocol.h"\r
\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_X64 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP;\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM_X64 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM;\r
-typedef DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE_X64 DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE;\r
-\r
#define DEBUG_SW_BREAKPOINT_SYMBOL 0xcc\r
-\r
#define DEBUG_ARCH_SYMBOL DEBUG_DATA_BREAK_CPU_ARCH_X64\r
\r
+typedef DEBUG_DATA_X64_FX_SAVE_STATE DEBUG_DATA_FX_SAVE_STATE;\r
typedef DEBUG_DATA_X64_SYSTEM_CONTEXT DEBUG_CPU_CONTEXT;\r
\r
#endif\r
+++ /dev/null
-/** @file\r
- x64 Group registers read support functions.\r
-\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include "DebugAgent.h"\r
-\r
-/**\r
- Read segment selector by register index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterIndex Register Index.\r
-\r
- @return Value of segment selector.\r
-\r
-**/\r
-UINT64\r
-ReadRegisterSelectorByIndex (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 RegisterIndex\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINT16 Selector;\r
- UINT32 Data32;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Selector = 0;\r
-\r
- switch (RegisterIndex) {\r
- case SOFT_DEBUGGER_REGISTER_CSAS:\r
- Selector = (UINT16) CpuContext->Cs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_SSAS:\r
- Selector = (UINT16) CpuContext->Ss;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_GSAS:\r
- Selector = (UINT16) CpuContext->Gs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_FSAS:\r
- Selector = (UINT16) CpuContext->Fs;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_ESAS:\r
- Selector = (UINT16) CpuContext->Es;\r
- break;\r
- case SOFT_DEBUGGER_REGISTER_DSAS:\r
- Selector = (UINT16) CpuContext->Ds;\r
- case SOFT_DEBUGGER_REGISTER_LDTAS:\r
- case SOFT_DEBUGGER_REGISTER_TSSAS:\r
- return 0x00820000;\r
- break;\r
- }\r
-\r
- Data32 = (UINT32) RShiftU64 (Ia32Gdt[Selector / 8].Uint64, 24);\r
- return (Data32 & (UINT32)(~0xff)) | Selector;\r
-\r
-}\r
-\r
-/**\r
- Read group register of Segment Base.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegBase Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegBase (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE *RegisterGroupSegBase\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINTN Index;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Index = CpuContext->Cs / 8;\r
- RegisterGroupSegBase->CsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Ss / 8;\r
- RegisterGroupSegBase->SsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Gs / 8;\r
- RegisterGroupSegBase->GsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Fs / 8;\r
- RegisterGroupSegBase->FsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Es / 8;\r
- RegisterGroupSegBase->EsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
- Index = CpuContext->Ds / 8;\r
- RegisterGroupSegBase->DsBas = (Ia32Gdt[Index].Bits.BaseLow) + (Ia32Gdt[Index].Bits.BaseMid << 16) + (Ia32Gdt[Index].Bits.BaseMid << 24);\r
-\r
- RegisterGroupSegBase->LdtBas = 0;\r
- RegisterGroupSegBase->TssBas = 0;\r
-}\r
-\r
-/**\r
- Read group register of Segment Limit.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] RegisterGroupSegLim Pointer to Group registers.\r
-\r
-**/\r
-VOID\r
-ReadRegisterGroupSegLim (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM *RegisterGroupSegLim\r
- )\r
-{\r
- IA32_DESCRIPTOR *Ia32Descriptor;\r
- IA32_GDT *Ia32Gdt;\r
- UINTN Index;\r
-\r
- Ia32Descriptor = (IA32_DESCRIPTOR *) CpuContext->Gdtr;\r
- Ia32Gdt = (IA32_GDT *) (Ia32Descriptor->Base);\r
-\r
- Index = CpuContext->Cs / 8;\r
- RegisterGroupSegLim->CsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->CsLim = (RegisterGroupSegLim->CsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Ss / 8;\r
- RegisterGroupSegLim->SsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->SsLim = (RegisterGroupSegLim->SsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Gs / 8;\r
- RegisterGroupSegLim->GsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->GsLim = (RegisterGroupSegLim->GsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Fs / 8;\r
- RegisterGroupSegLim->FsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->FsLim = (RegisterGroupSegLim->FsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Es / 8;\r
- RegisterGroupSegLim->EsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->EsLim = (RegisterGroupSegLim->EsLim << 12) | 0xfff;\r
- }\r
-\r
- Index = CpuContext->Ds / 8;\r
- RegisterGroupSegLim->DsLim = Ia32Gdt[Index].Bits.LimitLow + (Ia32Gdt[Index].Bits.LimitHigh << 16);\r
- if (Ia32Gdt[Index].Bits.Granularity == 1) {\r
- RegisterGroupSegLim->DsLim = (RegisterGroupSegLim->DsLim << 12) | 0xfff;\r
- }\r
-\r
- RegisterGroupSegLim->LdtLim = 0xffff;\r
- RegisterGroupSegLim->TssLim = 0xffff;\r
-}\r
-\r
-/**\r
- Read group register by group index.\r
-\r
- @param[in] CpuContext Pointer to saved CPU context.\r
- @param[in] GroupIndex Group Index.\r
-\r
- @retval RETURN_SUCCESS Read successfully.\r
- @retval RETURN_NOT_SUPPORTED Group index cannot be supported.\r
-\r
-**/\r
-RETURN_STATUS\r
-ArchReadRegisterGroup (\r
- IN DEBUG_CPU_CONTEXT *CpuContext,\r
- IN UINT8 GroupIndex\r
- )\r
-{\r
- UINTN DataN;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP RegisterGroup;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BAS_LIM RegisterGroupBasLim;\r
- DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BASES_X64 RegisterGroupBases64;\r
-\r
- switch (GroupIndex) {\r
- case SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BAS_LIM64:\r
- DataN = (UINTN) (CpuContext->Idtr[0] & 0xffff);\r
- RegisterGroupBasLim.IdtLim = DataN;\r
- DataN = (UINTN) (CpuContext->Gdtr[0] & 0xffff);\r
- RegisterGroupBasLim.GdtLim = DataN;\r
- DataN = (UINTN) RShiftU64 (CpuContext->Idtr[0], 16);\r
- DataN |= (UINTN) LShiftU64 (CpuContext->Idtr[1], sizeof (UINTN) * 8 - 16);\r
- RegisterGroupBasLim.IdtBas = DataN;\r
- DataN = (UINTN) RShiftU64 (CpuContext->Gdtr[0], 16);\r
- DataN |= (UINTN) LShiftU64 (CpuContext->Gdtr[1], sizeof (UINTN) * 8 - 16);\r
- RegisterGroupBasLim.GdtBas = DataN;\r
-\r
- ReadRegisterGroupSegLim (CpuContext, (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM *) &RegisterGroupBasLim.CsLim);\r
- ReadRegisterGroupSegBase (CpuContext, (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE *) &RegisterGroupBasLim.CsBas);\r
-\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroupBasLim, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BAS_LIM));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_GP2_64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup.Eflags, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_GP2));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_GP64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup.Eax, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_GP));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_DR64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup.Dr0, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_DR));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_SEGMENT_BASES64:\r
- RegisterGroupBases64.Ldtr = (UINT16) CpuContext->Ldtr;\r
- RegisterGroupBases64.Tr = (UINT16) CpuContext->Tr;\r
-\r
- RegisterGroupBases64.Csas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_CSAS);\r
- RegisterGroupBases64.Ssas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_SSAS);\r
- RegisterGroupBases64.Gsas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_GSAS);\r
- RegisterGroupBases64.Fsas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_FSAS);\r
- RegisterGroupBases64.Esas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_ESAS);\r
- RegisterGroupBases64.Dsas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_DSAS);\r
- RegisterGroupBases64.Ldtas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_LDTAS);\r
- RegisterGroupBases64.Tssas = ReadRegisterSelectorByIndex (CpuContext, SOFT_DEBUGGER_REGISTER_TSSAS);\r
-\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroupBases64, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BASES_X64));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_CR64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup.Dr7 + 8, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_CR));\r
- break;\r
-\r
- case SOFT_DEBUGGER_REGISTER_GROUP_XMM64:\r
- ReadRegisterGroup (CpuContext, &RegisterGroup);\r
- SendDataResponsePacket (CpuContext, (UINT8 *) &RegisterGroup.Dr7 + 8 * 6, (UINT16) sizeof (DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_XMM));\r
- break;\r
-\r
- default:\r
- return RETURN_UNSUPPORTED;\r
- }\r
-\r
- return RETURN_SUCCESS;\r
-}\r
+++ /dev/null
-/** @file\r
- X64 register defintions needed by debug transfer protocol.\r
-\r
- Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef _ARCH_REGISTERS_H_\r
-#define _ARCH_REGISTERS_H_\r
-\r
-#pragma pack(1)\r
-\r
-///\r
-/// FXSAVE_STATE (promoted operation)\r
-/// FP / MMX / XMM registers (see fxrstor instruction definition)\r
-///\r
-typedef struct {\r
- UINT16 Fcw;\r
- UINT16 Fsw;\r
- UINT16 Ftw;\r
- UINT16 Opcode;\r
- UINT64 Rip;\r
- UINT64 DataOffset;\r
- UINT32 Mxcsr;\r
- UINT32 Mxcsr_Mask;\r
- UINT8 St0Mm0[10];\r
- UINT8 Reserved2[6];\r
- UINT8 St1Mm1[10];\r
- UINT8 Reserved3[6];\r
- UINT8 St2Mm2[10];\r
- UINT8 Reserved4[6];\r
- UINT8 St3Mm3[10];\r
- UINT8 Reserved5[6];\r
- UINT8 St4Mm4[10];\r
- UINT8 Reserved6[6];\r
- UINT8 St5Mm5[10];\r
- UINT8 Reserved7[6];\r
- UINT8 St6Mm6[10];\r
- UINT8 Reserved8[6];\r
- UINT8 St7Mm7[10];\r
- UINT8 Reserved9[6];\r
- UINT8 Xmm0[16];\r
- UINT8 Xmm1[16];\r
- UINT8 Xmm2[16];\r
- UINT8 Xmm3[16];\r
- UINT8 Xmm4[16];\r
- UINT8 Xmm5[16];\r
- UINT8 Xmm6[16];\r
- UINT8 Xmm7[16];\r
- UINT8 Xmm8[16];\r
- UINT8 Xmm9[16];\r
- UINT8 Xmm10[16];\r
- UINT8 Xmm11[16];\r
- UINT8 Xmm12[16];\r
- UINT8 Xmm13[16];\r
- UINT8 Xmm14[16];\r
- UINT8 Xmm15[16];\r
- UINT8 Reserved11[6 * 16];\r
-} DEBUG_DATA_X64_FX_SAVE_STATE;\r
-\r
-///\r
-/// x64 processor context definition\r
-///\r
-typedef struct {\r
- DEBUG_DATA_X64_FX_SAVE_STATE FxSaveState;\r
- UINT64 Dr0;\r
- UINT64 Dr1;\r
- UINT64 Dr2;\r
- UINT64 Dr3;\r
- UINT64 Dr6;\r
- UINT64 Dr7;\r
- UINT64 Eflags;\r
- UINT64 Ldtr;\r
- UINT64 Tr;\r
- UINT64 Gdtr[2];\r
- UINT64 Idtr[2];\r
- UINT64 Eip;\r
- UINT64 Gs;\r
- UINT64 Fs;\r
- UINT64 Es;\r
- UINT64 Ds;\r
- UINT64 Cs;\r
- UINT64 Ss;\r
- UINT64 Cr0;\r
- UINT64 Cr1; /* Reserved */\r
- UINT64 Cr2;\r
- UINT64 Cr3;\r
- UINT64 Cr4;\r
- UINT64 Rdi;\r
- UINT64 Rsi;\r
- UINT64 Rbp;\r
- UINT64 Rsp;\r
- UINT64 Rdx;\r
- UINT64 Rcx;\r
- UINT64 Rbx;\r
- UINT64 Rax;\r
- UINT64 Cr8;\r
- UINT64 R8;\r
- UINT64 R9;\r
- UINT64 R10;\r
- UINT64 R11;\r
- UINT64 R12;\r
- UINT64 R13;\r
- UINT64 R14;\r
- UINT64 R15;\r
-} DEBUG_DATA_X64_SYSTEM_CONTEXT;\r
-\r
-\r
-///\r
-/// x64 GROUP register\r
-///\r
-typedef struct {\r
- UINT16 Cs;\r
- UINT16 Ds;\r
- UINT16 Es;\r
- UINT16 Fs;\r
- UINT16 Gs;\r
- UINT16 Ss;\r
- UINT32 Eflags;\r
- UINT64 Rbp;\r
- UINT64 Eip;\r
- UINT64 Rsp;\r
- UINT64 Eax;\r
- UINT64 Rbx;\r
- UINT64 Rcx;\r
- UINT64 Rdx;\r
- UINT64 Rsi;\r
- UINT64 Rdi;\r
- UINT64 R8;\r
- UINT64 R9;\r
- UINT64 R10;\r
- UINT64 R11;\r
- UINT64 R12;\r
- UINT64 R13;\r
- UINT64 R14;\r
- UINT64 R15;\r
- UINT64 Dr0;\r
- UINT64 Dr1;\r
- UINT64 Dr2;\r
- UINT64 Dr3;\r
- UINT64 Dr6;\r
- UINT64 Dr7;\r
- UINT64 Cr0;\r
- UINT64 Cr2;\r
- UINT64 Cr3;\r
- UINT64 Cr4;\r
- UINT64 Cr8;\r
- UINT8 Xmm0[16];\r
- UINT8 Xmm1[16];\r
- UINT8 Xmm2[16];\r
- UINT8 Xmm3[16];\r
- UINT8 Xmm4[16];\r
- UINT8 Xmm5[16];\r
- UINT8 Xmm6[16];\r
- UINT8 Xmm7[16];\r
- UINT8 Xmm8[16];\r
- UINT8 Xmm9[16];\r
- UINT8 Xmm10[16];\r
- UINT8 Xmm11[16];\r
- UINT8 Xmm12[16];\r
- UINT8 Xmm13[16];\r
- UINT8 Xmm14[16];\r
- UINT8 Xmm15[16];\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_X64;\r
-\r
-///\r
-/// x64 Segment Limit GROUP register\r
-///\r
-typedef struct {\r
- UINT64 CsLim;\r
- UINT64 SsLim;\r
- UINT64 GsLim;\r
- UINT64 FsLim;\r
- UINT64 EsLim;\r
- UINT64 DsLim;\r
- UINT64 LdtLim;\r
- UINT64 TssLim;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGLIM_X64;\r
-\r
-///\r
-/// x64 Segment Base GROUP register\r
-///\r
-typedef struct {\r
- UINT64 CsBas;\r
- UINT64 SsBas;\r
- UINT64 GsBas;\r
- UINT64 FsBas;\r
- UINT64 EsBas;\r
- UINT64 DsBas;\r
- UINT64 LdtBas;\r
- UINT64 TssBas;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGBASE_X64;\r
-\r
-///\r
-/// x64 Segment Base/Limit GROUP register\r
-///\r
-typedef struct {\r
- UINT64 IdtBas;\r
- UINT64 IdtLim;\r
- UINT64 GdtBas;\r
- UINT64 GdtLim;\r
- UINT64 CsLim;\r
- UINT64 SsLim;\r
- UINT64 GsLim;\r
- UINT64 FsLim;\r
- UINT64 EsLim;\r
- UINT64 DsLim;\r
- UINT64 LdtLim;\r
- UINT64 TssLim;\r
- UINT64 CsBas;\r
- UINT64 SsBas;\r
- UINT64 GsBas;\r
- UINT64 FsBas;\r
- UINT64 EsBas;\r
- UINT64 DsBas;\r
- UINT64 LdtBas;\r
- UINT64 TssBas;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BAS_LIM;\r
-\r
-///\r
-/// x64 register GROUP register\r
-///\r
-typedef struct {\r
- UINT32 Eflags;\r
- UINT64 Rbp;\r
- UINT64 Eip;\r
- UINT64 Rsp;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_GP2;\r
-\r
-///\r
-/// x64 general register GROUP register\r
-///\r
-typedef struct {\r
- UINT64 Eax;\r
- UINT64 Rbx;\r
- UINT64 Rcx;\r
- UINT64 Rdx;\r
- UINT64 Rsi;\r
- UINT64 Rdi;\r
- UINT64 R8;\r
- UINT64 R9;\r
- UINT64 R10;\r
- UINT64 R11;\r
- UINT64 R12;\r
- UINT64 R13;\r
- UINT64 R14;\r
- UINT64 R15;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_GP;\r
-\r
-///\r
-/// x64 Segment GROUP register\r
-///\r
-typedef struct {\r
- UINT16 Cs;\r
- UINT16 Ds;\r
- UINT16 Es;\r
- UINT16 Fs;\r
- UINT16 Gs;\r
- UINT16 Ss;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT;\r
-\r
-///\r
-/// x64 Debug Register GROUP register\r
-///\r
-typedef struct {\r
- UINT64 Dr0;\r
- UINT64 Dr1;\r
- UINT64 Dr2;\r
- UINT64 Dr3;\r
- UINT64 Dr6;\r
- UINT64 Dr7;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_DR;\r
-\r
-///\r
-/// x64 Control Register GROUP register\r
-///\r
-typedef struct {\r
- UINT64 Cr0;\r
- UINT64 Cr2;\r
- UINT64 Cr3;\r
- UINT64 Cr4;\r
- UINT64 Cr8;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_CR;\r
-\r
-///\r
-/// x64 XMM Register GROUP register\r
-///\r
-typedef struct {\r
- UINT8 Xmm0[16];\r
- UINT8 Xmm1[16];\r
- UINT8 Xmm2[16];\r
- UINT8 Xmm3[16];\r
- UINT8 Xmm4[16];\r
- UINT8 Xmm5[16];\r
- UINT8 Xmm6[16];\r
- UINT8 Xmm7[16];\r
- UINT8 Xmm8[16];\r
- UINT8 Xmm9[16];\r
- UINT8 Xmm10[16];\r
- UINT8 Xmm11[16];\r
- UINT8 Xmm12[16];\r
- UINT8 Xmm13[16];\r
- UINT8 Xmm14[16];\r
- UINT8 Xmm15[16];\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_XMM;\r
-\r
-///\r
-/// x64 Segment Base GROUP register\r
-///\r
-typedef struct {\r
- UINT16 Ldtr;\r
- UINT16 Tr;\r
- UINT64 Csas;\r
- UINT64 Ssas;\r
- UINT64 Gsas;\r
- UINT64 Fsas;\r
- UINT64 Esas;\r
- UINT64 Dsas;\r
- UINT64 Ldtas;\r
- UINT64 Tssas;\r
-} DEBUG_DATA_REPONSE_READ_REGISTER_GROUP_SEGMENT_BASES_X64;\r
-\r
-#pragma pack()\r
-\r
-#endif\r
#------------------------------------------------------------------------------\r
#\r
-# Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution. The full text of the license may be found at\r
movq %rsp, %rdi\r
.byte 0x0f, 0xae, 0b00000111\r
\r
+## save the exception data;\r
+ pushq 16(%rbp)\r
+\r
## Clear Direction Flag\r
cld\r
\r
# Per X64 calling convention, allocate maximum parameter stack space\r
# and make sure RSP is 16-byte aligned\r
#\r
- subq $(4 * 8), %rsp\r
+ subq $(32 + 8), %rsp\r
call ASM_PFX(InterruptProcess)\r
- addq $(4 * 8), %rsp\r
+ addq $(32 + 8), %rsp\r
+\r
+## skip the exception data;\r
+ addq $8, %rsp\r
\r
## FX_SAVE_STATE_X64 FxSaveState;\r
\r
;------------------------------------------------------------------------------\r
;\r
-; Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+; Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
; This program and the accompanying materials\r
; are licensed and made available under the terms and conditions of the BSD License\r
; which accompanies this distribution. The full text of the license may be found at\r
push rax\r
\r
sub rsp, 512\r
- mov rdi, rsp\r
+ mov rdi, rsp\r
db 0fh, 0aeh, 00000111y ;fxsave [rdi]\r
\r
+ ;; save the exception data\r
+ push qword ptr [rbp + 16]\r
+\r
;; Clear Direction Flag\r
cld\r
\r
mov rdx, rsp ; Structure\r
mov r15, rcx ; save vector in r15\r
\r
- sub rsp, 32\r
+ ;\r
+ ; Per X64 calling convention, allocate maximum parameter stack space\r
+ ; and make sure RSP is 16-byte aligned\r
+ ;\r
+ sub rsp, 32 + 8\r
call InterruptProcess\r
- add rsp, 32\r
+ add rsp, 32 + 8\r
+\r
+ ;; skip the exception data\r
+ add rsp, 8\r
\r
mov rsi, rsp\r
db 0fh, 0aeh, 00001110y ; fxrstor [rsi]\r
/** @file\r
Debug Agent library implementition for Dxe Core and Dxr modules.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
#include "DxeDebugAgentLib.h"\r
\r
DEBUG_AGENT_MAILBOX mMailbox;\r
-\r
DEBUG_AGENT_MAILBOX *mMailboxPointer;\r
-\r
IA32_IDT_GATE_DESCRIPTOR mIdtEntryTable[33];\r
-\r
-BOOLEAN mConfigurationTableNeeded = FALSE;\r
-\r
+BOOLEAN mDxeCoreFlag = FALSE;\r
CONST BOOLEAN MultiProcessorDebugSupport = TRUE;\r
\r
/**\r
@param[in] ImageHandle The firmware allocated handle for the EFI image.\r
@param[in] SystemTable A pointer to the EFI System Table.\r
\r
- @retval RETURN_SUCCESS Allocate the global memory space to store guid and function tables.\r
- @retval RETURN_OUT_OF_RESOURCES No enough memory to allocated.\r
+ @retval RETURN_SUCCESS Allocate the global memory space to store guid and function tables.\r
\r
**/\r
RETURN_STATUS\r
{\r
EFI_STATUS Status;\r
EFI_PHYSICAL_ADDRESS Address;\r
+ EFI_EVENT Event;\r
+ VOID *EventRegistration;\r
\r
- if (!mConfigurationTableNeeded) {\r
+ if (!mDxeCoreFlag) {\r
return RETURN_SUCCESS;\r
}\r
\r
+ Status = gBS->CreateEvent (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_CALLBACK,\r
+ InstallSerialIoNotification,\r
+ NULL,\r
+ &Event\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ //\r
+ // Register for protocol notifications on this event\r
+ //\r
+\r
+ Status = gBS->RegisterProtocolNotify (\r
+ &gEfiPcdProtocolGuid,\r
+ Event,\r
+ &EventRegistration\r
+ );\r
+\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
Address = 0;\r
Status = gBS->AllocatePages (\r
AllocateAnyPages,\r
EFI_SIZE_TO_PAGES (sizeof (DEBUG_AGENT_MAILBOX)),\r
&Address\r
);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
+ ASSERT_EFI_ERROR (Status);\r
\r
CopyMem (\r
(UINT8 *) (UINTN) Address,\r
\r
mMailboxPointer = (DEBUG_AGENT_MAILBOX *) (UINTN) Address;\r
\r
- return gBS->InstallConfigurationTable (&gEfiDebugAgentGuid, (VOID *) mMailboxPointer);\r
+ Status = gBS->InstallConfigurationTable (&gEfiDebugAgentGuid, (VOID *) mMailboxPointer);\r
+ ASSERT_EFI_ERROR (Status);\r
+ \r
+ return Status;\r
}\r
\r
/**\r
//\r
// Try to get Mailbox from GUIDed HOB.\r
//\r
- mConfigurationTableNeeded = TRUE;\r
+ mDxeCoreFlag = TRUE;\r
Mailbox = GetMailboxFromHob (Context);\r
+ \r
+ //\r
+ // Clear Break CPU index value\r
+ //\r
+ mDebugMpContext.BreakAtCpuIndex = (UINT32) -1;\r
\r
} else if (InitFlag == DEBUG_AGENT_INIT_DXE_AP) {\r
\r
// If Mailbox exists, copy it into one global variable.\r
//\r
CopyMem (&mMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX));\r
- mMailbox.DebugPortHandle = 0;\r
} else {\r
//\r
// If Mailbox not exists, used the local Mailbox.\r
if (IdtEntryCount < 33) {\r
Idtr.Limit = (UINT16) (sizeof (IA32_IDT_GATE_DESCRIPTOR) * 33 - 1);\r
Idtr.Base = (UINTN) &mIdtEntryTable;\r
+ ZeroMem (&mIdtEntryTable, Idtr.Limit + 1);\r
AsmWriteIdtr ((IA32_DESCRIPTOR *) &Idtr);\r
}\r
\r
//\r
// Initialize debug communication port\r
//\r
- mMailboxPointer->DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize (NULL, NULL);\r
+ mMailboxPointer->DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)mMailbox.DebugPortHandle, NULL);\r
\r
InitializeSpinLock (&mDebugMpContext.MpContextSpinLock);\r
InitializeSpinLock (&mDebugMpContext.DebugPortSpinLock);\r
/** @file\r
Header file for Dxe Core Debug Agent Library instance.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
\r
#include <PiDxe.h>\r
\r
+#include <Protocol/SerialIo.h>\r
+#include <Protocol/DevicePath.h>\r
+#include <Protocol/PiPcd.h>\r
+\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
+#include <Library/DevicePathLib.h>\r
\r
#include "DebugAgent.h"\r
\r
+/**\r
+ Notification function on EFI PCD protocol to install EFI Serial IO protocol based\r
+ on Debug Communication Library. \r
+\r
+ @param[in] Event The event of notify protocol.\r
+ @param[in] Context Notify event context.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+InstallSerialIoNotification (\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
+ );\r
+ \r
#endif\r
--- /dev/null
+/** @file\r
+ Install Serial IO Protocol that layers on top of a Debug Communication Library instance.\r
+\r
+ Copyright (c) 2012, Intel Corporation. All rights reserved.<BR>\r
+ This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php.\r
+\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#include "DxeDebugAgentLib.h"\r
+\r
+//\r
+// Serial I/O Protocol Interface defintions.\r
+//\r
+\r
+/**\r
+ Reset serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+\r
+ @retval EFI_SUCCESS Reset successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialReset (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This\r
+ );\r
+ \r
+/**\r
+ Set new attributes to a serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in] BaudRate The baudrate of the serial device.\r
+ @param[in] ReceiveFifoDepth The depth of receive FIFO buffer.\r
+ @param[in] Timeout The request timeout for a single char.\r
+ @param[in] Parity The type of parity used in serial device.\r
+ @param[in] DataBits Number of databits used in serial device.\r
+ @param[in] StopBits Number of stopbits used in serial device.\r
+\r
+ @retval EFI_SUCCESS The new attributes were set.\r
+ @retval EFI_INVALID_PARAMETER One or more attributes have an unsupported value.\r
+ @retval EFI_DEVICE_ERROR The serial device is not functioning correctly (no return).\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialSetAttributes (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN UINT64 BaudRate,\r
+ IN UINT32 ReceiveFifoDepth,\r
+ IN UINT32 Timeout,\r
+ IN EFI_PARITY_TYPE Parity,\r
+ IN UINT8 DataBits,\r
+ IN EFI_STOP_BITS_TYPE StopBits\r
+ );\r
+\r
+/**\r
+ Set Control Bits.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in] Control Control bits that can be settable.\r
+\r
+ @retval EFI_SUCCESS New Control bits were set successfully.\r
+ @retval EFI_UNSUPPORTED The Control bits wanted to set are not supported.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialSetControl (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN UINT32 Control\r
+ );\r
+\r
+/**\r
+ Get ControlBits.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[out] Control Control signals of the serial device.\r
+\r
+ @retval EFI_SUCCESS Get Control signals successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialGetControl (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ OUT UINT32 *Control\r
+ );\r
+\r
+/**\r
+ Write the specified number of bytes to serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in, out] BufferSize On input the size of Buffer, on output the amount of\r
+ data actually written.\r
+ @param[in] Buffer The buffer of data to write.\r
+\r
+ @retval EFI_SUCCESS The data were written successfully.\r
+ @retval EFI_DEVICE_ERROR The device reported an error.\r
+ @retval EFI_TIMEOUT The write operation was stopped due to timeout.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialWrite (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN OUT UINTN *BufferSize,\r
+ IN VOID *Buffer\r
+ );\r
+\r
+/**\r
+ Read the specified number of bytes from serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in, out] BufferSize On input the size of Buffer, on output the amount of\r
+ data returned in buffer.\r
+ @param[out] Buffer The buffer to return the data into.\r
+\r
+ @retval EFI_SUCCESS The data were read successfully.\r
+ @retval EFI_DEVICE_ERROR The device reported an error.\r
+ @retval EFI_TIMEOUT The read operation was stopped due to timeout.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialRead (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
+ );\r
+\r
+//\r
+// Serial Driver Defaults\r
+//\r
+#define SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH 1\r
+#define SERIAL_PORT_DEFAULT_TIMEOUT 1000000\r
+#define SERIAL_PORT_DEFAULT_CONTROL_MASK 0\r
+#define SERIAL_PORT_LOOPBACK_BUFFER_FULL BIT8\r
+\r
+//\r
+// EFI_SERIAL_IO_MODE instance\r
+//\r
+EFI_SERIAL_IO_MODE mSerialIoMode = {\r
+ SERIAL_PORT_DEFAULT_CONTROL_MASK,\r
+ SERIAL_PORT_DEFAULT_TIMEOUT,\r
+ 0, // BaudRate\r
+ SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH,\r
+ 0, // DataBits\r
+ 0, // Parity\r
+ 0 // StopBits\r
+};\r
+\r
+//\r
+// EFI_SERIAL_IO_PROTOCOL instance\r
+//\r
+EFI_SERIAL_IO_PROTOCOL mSerialIo = {\r
+ SERIAL_IO_INTERFACE_REVISION,\r
+ SerialReset,\r
+ SerialSetAttributes,\r
+ SerialSetControl,\r
+ SerialGetControl,\r
+ SerialWrite,\r
+ SerialRead,\r
+ &mSerialIoMode\r
+};\r
+\r
+//\r
+// Serial IO Device Path definition\r
+//\r
+typedef struct {\r
+ VENDOR_DEVICE_PATH VendorDevicePath;\r
+ UART_DEVICE_PATH UartDevicePath;\r
+ EFI_DEVICE_PATH_PROTOCOL EndDevicePath;\r
+} SERIAL_IO_DEVICE_PATH;\r
+\r
+//\r
+// Serial IO Device Patch instance\r
+//\r
+SERIAL_IO_DEVICE_PATH mSerialIoDevicePath = {\r
+ {\r
+ {\r
+ HARDWARE_DEVICE_PATH,\r
+ HW_VENDOR_DP,\r
+ (UINT8) (sizeof (VENDOR_DEVICE_PATH)),\r
+ (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)\r
+ },\r
+ EFI_DEBUG_AGENT_GUID,\r
+ },\r
+ {\r
+ {\r
+ MESSAGING_DEVICE_PATH,\r
+ MSG_UART_DP,\r
+ (UINT8) (sizeof (UART_DEVICE_PATH)),\r
+ (UINT8) ((sizeof (UART_DEVICE_PATH)) >> 8)\r
+ },\r
+ 0,\r
+ 0, // BaudRate\r
+ 0, // DataBits\r
+ 0, // Parity\r
+ 0, // StopBits\r
+ },\r
+ {\r
+ END_DEVICE_PATH_TYPE,\r
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
+ {\r
+ END_DEVICE_PATH_LENGTH,\r
+ 0\r
+ }\r
+ }\r
+};\r
+\r
+#define DEBGU_SERIAL_IO_FIFO_DEPTH 10\r
+//\r
+// Data buffer for Terminal input character and Debug Symbols.\r
+// The depth is DEBGU_SERIAL_IO_FIFO_DEPTH.\r
+// Fields:\r
+// First UINT8: The index of the first data in array Data[].\r
+// Last UINT8: The index, which you can put a new data into array Data[].\r
+// Surplus UINT8: Identify how many data you can put into array Data[].\r
+// Data[] UINT8: An array, which used to store data.\r
+//\r
+typedef struct {\r
+ UINT8 First;\r
+ UINT8 Last;\r
+ UINT8 Surplus;\r
+ UINT8 Data[DEBGU_SERIAL_IO_FIFO_DEPTH];\r
+} DEBUG_SERIAL_FIFO;\r
+\r
+//\r
+// Global Varibles\r
+//\r
+EFI_HANDLE mSerialIoHandle = NULL;\r
+UINTN mLoopbackBuffer = 0;\r
+DEBUG_SERIAL_FIFO mSerialFifoForTerminal = {0, 0, DEBGU_SERIAL_IO_FIFO_DEPTH, { 0 }};\r
+DEBUG_SERIAL_FIFO mSerialFifoForDebug = {0, 0, DEBGU_SERIAL_IO_FIFO_DEPTH, { 0 }};\r
+\r
+/**\r
+ Detect whether specific FIFO is empty or not.\r
+ \r
+ @param[in] Fifo A pointer to the Data Structure DEBUG_SERIAL_FIFO.\r
+\r
+ @return whether specific FIFO is empty or not.\r
+\r
+**/\r
+BOOLEAN\r
+IsDebugTermianlFifoEmpty (\r
+ IN DEBUG_SERIAL_FIFO *Fifo\r
+ )\r
+{\r
+ if (Fifo->Surplus == DEBGU_SERIAL_IO_FIFO_DEPTH) {\r
+ return TRUE;\r
+ }\r
+\r
+ return FALSE;\r
+}\r
+\r
+/**\r
+ Detect whether specific FIFO is full or not.\r
+\r
+ @param[in] Fifo A pointer to the Data Structure DEBUG_SERIAL_FIFO.\r
+\r
+ @return whether specific FIFO is full or not.\r
+\r
+**/\r
+BOOLEAN\r
+IsDebugTerminalFifoFull (\r
+ IN DEBUG_SERIAL_FIFO *Fifo\r
+ )\r
+\r
+{\r
+ if (Fifo->Surplus == 0) {\r
+ return TRUE;\r
+ }\r
+\r
+ return FALSE;\r
+}\r
+\r
+/**\r
+ Add data to specific FIFO.\r
+\r
+ @param[in] Fifo A pointer to the Data Structure DEBUG_SERIAL_FIFO.\r
+ @param[in] Data The data added to FIFO.\r
+\r
+ @retval EFI_SUCCESS Add data to specific FIFO successfully.\r
+ @retval EFI_OUT_OF_RESOURCE Failed to add data because FIFO is already full.\r
+\r
+**/\r
+EFI_STATUS\r
+DebugTerminalFifoAdd (\r
+ IN DEBUG_SERIAL_FIFO *Fifo,\r
+ IN UINT8 Data\r
+ )\r
+\r
+{\r
+ //\r
+ // if FIFO full can not add data\r
+ //\r
+ if (IsDebugTerminalFifoFull (Fifo)) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+ //\r
+ // FIFO is not full can add data\r
+ //\r
+ Fifo->Data[Fifo->Last] = Data;\r
+ Fifo->Surplus--;\r
+ Fifo->Last++;\r
+ if (Fifo->Last == DEBGU_SERIAL_IO_FIFO_DEPTH) {\r
+ Fifo->Last = 0;\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Remove data from specific FIFO.\r
+\r
+ @param[in] Fifo A pointer to the Data Structure DEBUG_SERIAL_FIFO.\r
+ @param[out] Data The data removed from FIFO.\r
+\r
+ @retval EFI_SUCCESS Remove data from specific FIFO successfully.\r
+ @retval EFI_OUT_OF_RESOURCE Failed to remove data because FIFO is empty.\r
+\r
+**/\r
+EFI_STATUS\r
+DebugTerminalFifoRemove (\r
+ IN DEBUG_SERIAL_FIFO *Fifo,\r
+ OUT UINT8 *Data\r
+ )\r
+{\r
+ //\r
+ // if FIFO is empty, no data can remove\r
+ //\r
+ if (IsDebugTermianlFifoEmpty (Fifo)) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+ //\r
+ // FIFO is not empty, can remove data\r
+ //\r
+ *Data = Fifo->Data[Fifo->First];\r
+ Fifo->Surplus++;\r
+ Fifo->First++;\r
+ if (Fifo->First == DEBGU_SERIAL_IO_FIFO_DEPTH) {\r
+ Fifo->First = 0;\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Notification function on EFI PCD protocol to install EFI Serial IO protocol based\r
+ on Debug Communication Library. \r
+\r
+ @param[in] Event The event of notify protocol.\r
+ @param[in] Context Notify event context.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+InstallSerialIoNotification (\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+\r
+ //\r
+ // Get Debug Port parameters from PCDs\r
+ //\r
+ mSerialIoDevicePath.UartDevicePath.BaudRate = PcdGet64 (PcdUartDefaultBaudRate);\r
+ mSerialIoDevicePath.UartDevicePath.DataBits = PcdGet8 (PcdUartDefaultDataBits);\r
+ mSerialIoDevicePath.UartDevicePath.Parity = PcdGet8 (PcdUartDefaultParity);\r
+ mSerialIoDevicePath.UartDevicePath.StopBits = PcdGet8 (PcdUartDefaultStopBits);\r
+\r
+ mSerialIoMode.BaudRate = mSerialIoDevicePath.UartDevicePath.BaudRate;\r
+ mSerialIoMode.DataBits = mSerialIoDevicePath.UartDevicePath.DataBits;\r
+ mSerialIoMode.Parity = mSerialIoDevicePath.UartDevicePath.Parity;\r
+ mSerialIoMode.StopBits = mSerialIoDevicePath.UartDevicePath.StopBits;\r
+\r
+ Status = gBS->InstallMultipleProtocolInterfaces (\r
+ &mSerialIoHandle,\r
+ &gEfiDevicePathProtocolGuid, &mSerialIoDevicePath,\r
+ &gEfiSerialIoProtocolGuid, &mSerialIo,\r
+ NULL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((EFI_D_ERROR, "Debug Agent: Failed to install EFI Serial IO Protocol on Debug Port!\n"));\r
+ }\r
+}\r
+\r
+/**\r
+ Reset serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+\r
+ @retval EFI_SUCCESS Reset successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialReset (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This\r
+ )\r
+{\r
+ mSerialIoMode.ControlMask = SERIAL_PORT_DEFAULT_CONTROL_MASK;\r
+ mLoopbackBuffer = 0;\r
+ //\r
+ // Not reset serial devcie hardware indeed.\r
+ //\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Set new attributes to a serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in] BaudRate The baudrate of the serial device.\r
+ @param[in] ReceiveFifoDepth The depth of receive FIFO buffer.\r
+ @param[in] Timeout The request timeout for a single char.\r
+ @param[in] Parity The type of parity used in serial device.\r
+ @param[in] DataBits Number of databits used in serial device.\r
+ @param[in] StopBits Number of stopbits used in serial device.\r
+\r
+ @retval EFI_SUCCESS The new attributes were set.\r
+ @retval EFI_INVALID_PARAMETER One or more attributes have an unsupported value.\r
+ @retval EFI_DEVICE_ERROR The serial device is not functioning correctly (no return).\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialSetAttributes (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN UINT64 BaudRate,\r
+ IN UINT32 ReceiveFifoDepth,\r
+ IN UINT32 Timeout,\r
+ IN EFI_PARITY_TYPE Parity,\r
+ IN UINT8 DataBits,\r
+ IN EFI_STOP_BITS_TYPE StopBits\r
+ )\r
+{\r
+ //\r
+ // The Debug Communication Library does not support changing communications parameters, so unless\r
+ // the request is to use the default value or the value the Debug Communication Library is already\r
+ // using, then return EFI_INVALID_PARAMETER.\r
+ //\r
+ if (BaudRate != 0 && BaudRate != PcdGet64 (PcdUartDefaultBaudRate)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ if (Parity != DefaultParity && Parity != PcdGet8 (PcdUartDefaultParity)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ if (DataBits != 0 && DataBits != PcdGet8 (PcdUartDefaultDataBits)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ if (StopBits != DefaultStopBits && StopBits != PcdGet8 (PcdUartDefaultStopBits)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ \r
+ //\r
+ // Update the Timeout value in the mode structure based on the request.\r
+ // The Debug Communication Library can not support a timeout on writes, but the timeout on \r
+ // reads can be provided by this module.\r
+ //\r
+ if (Timeout == 0) {\r
+ mSerialIoMode.Timeout = SERIAL_PORT_DEFAULT_TIMEOUT;\r
+ } else {\r
+ mSerialIoMode.Timeout = Timeout;\r
+ }\r
+ \r
+ //\r
+ // Update the ReceiveFifoDepth value in the mode structure based on the request.\r
+ // This module assumes that the Debug Communication Library uses a FIFO depth of \r
+ // SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH. The Debug Communication Library may actually be \r
+ // using a larger FIFO, but there is no way to tell.\r
+ //\r
+ if (ReceiveFifoDepth == 0 || ReceiveFifoDepth >= SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH) {\r
+ mSerialIoMode.ReceiveFifoDepth = SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH;\r
+ } else {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Set Control Bits.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in] Control Control bits that can be settable.\r
+\r
+ @retval EFI_SUCCESS New Control bits were set successfully.\r
+ @retval EFI_UNSUPPORTED The Control bits wanted to set are not supported.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialSetControl (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN UINT32 Control\r
+ )\r
+{\r
+ //\r
+ // The only control bit supported by this module is software loopback.\r
+ // If any other bit is set, then return an error\r
+ //\r
+ if ((Control & (~EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE)) != 0) {\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ mSerialIoMode.ControlMask = Control;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Get ControlBits.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[out] Control Control signals of the serial device.\r
+\r
+ @retval EFI_SUCCESS Get Control signals successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialGetControl (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ OUT UINT32 *Control\r
+ )\r
+{\r
+ DEBUG_PORT_HANDLE Handle;\r
+\r
+ Handle = GetDebugPortHandle ();\r
+ \r
+ //\r
+ // Always assume the output buffer is empty and the Debug Communication Library can process\r
+ // more write requests.\r
+ //\r
+ *Control = mSerialIoMode.ControlMask | EFI_SERIAL_OUTPUT_BUFFER_EMPTY;\r
+ \r
+ //\r
+ // Check to see if the Terminal FIFO is empty and \r
+ // check to see if the input buffer in the Debug Communication Library is empty\r
+ //\r
+ if (!IsDebugTermianlFifoEmpty (&mSerialFifoForTerminal) || DebugPortPollBuffer (Handle)) {\r
+ *Control &= ~EFI_SERIAL_INPUT_BUFFER_EMPTY;\r
+ }\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Write the specified number of bytes to serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in, out] BufferSize On input the size of Buffer, on output the amount of\r
+ data actually written.\r
+ @param[in] Buffer The buffer of data to write.\r
+\r
+ @retval EFI_SUCCESS The data were written successfully.\r
+ @retval EFI_DEVICE_ERROR The device reported an error.\r
+ @retval EFI_TIMEOUT The write operation was stopped due to timeout.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialWrite (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN OUT UINTN *BufferSize,\r
+ IN VOID *Buffer\r
+ )\r
+{\r
+ DEBUG_PORT_HANDLE Handle;\r
+\r
+ Handle = GetDebugPortHandle ();\r
+ \r
+ if ((mSerialIoMode.ControlMask & EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE) != 0) {\r
+ if (*BufferSize == 0) {\r
+ return EFI_SUCCESS;\r
+ }\r
+ if ((mLoopbackBuffer & SERIAL_PORT_LOOPBACK_BUFFER_FULL) != 0) {\r
+ *BufferSize = 0;\r
+ return EFI_TIMEOUT;\r
+ }\r
+ mLoopbackBuffer = SERIAL_PORT_LOOPBACK_BUFFER_FULL | *(UINT8 *)Buffer;\r
+ *BufferSize = 1;\r
+ } else {\r
+ *BufferSize = DebugPortWriteBuffer (Handle, Buffer, *BufferSize);\r
+ }\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Read the specified number of bytes from serial device.\r
+\r
+ @param[in] This Pointer to EFI_SERIAL_IO_PROTOCOL.\r
+ @param[in, out] BufferSize On input the size of Buffer, on output the amount of\r
+ data returned in buffer.\r
+ @param[out] Buffer The buffer to return the data into.\r
+\r
+ @retval EFI_SUCCESS The data were read successfully.\r
+ @retval EFI_DEVICE_ERROR The device reported an error.\r
+ @retval EFI_TIMEOUT The read operation was stopped due to timeout.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+SerialRead (\r
+ IN EFI_SERIAL_IO_PROTOCOL *This,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ UINT8 *Uint8Buffer;\r
+ BOOLEAN OldInterruptState;\r
+ DEBUG_PORT_HANDLE Handle;\r
+ UINT8 Data;\r
+\r
+ Handle = GetDebugPortHandle ();\r
+\r
+ //\r
+ // Save and disable Debug Timer interrupt to avoid it to access Debug Port\r
+ //\r
+ OldInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);\r
+ \r
+ Uint8Buffer = (UINT8 *)Buffer;\r
+ if ((mSerialIoMode.ControlMask & EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE) != 0) {\r
+ if ((mLoopbackBuffer & SERIAL_PORT_LOOPBACK_BUFFER_FULL) == 0) {\r
+ return EFI_TIMEOUT;\r
+ }\r
+ *Uint8Buffer = (UINT8)(mLoopbackBuffer & 0xff);\r
+ mLoopbackBuffer = 0;\r
+ *BufferSize = 1;\r
+ } else {\r
+ for (Index = 0; Index < *BufferSize; Index++) {\r
+ //\r
+ // Read input character from terminal FIFO firstly\r
+ //\r
+ Status = DebugTerminalFifoRemove (&mSerialFifoForTerminal, &Data);\r
+ if (Status == EFI_SUCCESS) {\r
+ *Uint8Buffer = Data;\r
+ Uint8Buffer ++;\r
+ continue;\r
+ }\r
+ //\r
+ // Read the input character from Debug Port \r
+ //\r
+ if (!DebugPortPollBuffer (Handle)) {\r
+ break;\r
+ }\r
+ DebugPortReadBuffer (Handle, &Data, 1, 0);\r
+\r
+ if (Data== DEBUG_STARTING_SYMBOL_ATTACH ||\r
+ Data == DEBUG_STARTING_SYMBOL_BREAK) {\r
+ //\r
+ // Add the debug symbol into Debug FIFO\r
+ //\r
+ DebugTerminalFifoAdd (&mSerialFifoForDebug, Data);\r
+ } else {\r
+ *Uint8Buffer = Data;\r
+ Uint8Buffer ++;\r
+ }\r
+ }\r
+ *BufferSize = (UINTN)Uint8Buffer - (UINTN)Buffer;\r
+ }\r
+\r
+ //\r
+ // Restore Debug Timer interrupt\r
+ // \r
+ SaveAndSetDebugTimerInterrupt (OldInterruptState);\r
+ \r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Read the Attach/Break-in symbols from the debug port.\r
+\r
+ @param[in] Handle Pointer to Debug Port handle.\r
+ @param[out] BreakSymbol Returned break symbol.\r
+\r
+ @retval EFI_SUCCESS Read the symbol in BreakSymbol.\r
+ @retval EFI_NOT_FOUND No read the break symbol.\r
+\r
+**/\r
+EFI_STATUS\r
+DebugReadBreakSymbol (\r
+ IN DEBUG_PORT_HANDLE Handle,\r
+ OUT UINT8 *BreakSymbol\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINT8 Data;\r
+\r
+ Status = DebugTerminalFifoRemove (&mSerialFifoForDebug, &Data);\r
+ if (Status != EFI_SUCCESS) {\r
+ if (!DebugPortPollBuffer (Handle)) {\r
+ //\r
+ // No data in Debug Port buffer.\r
+ //\r
+ return EFI_NOT_FOUND;\r
+ } else {\r
+ //\r
+ // Read one character from Debug Port.\r
+ //\r
+ DebugPortReadBuffer (Handle, &Data, 1, 0);\r
+ if ((Data != DEBUG_STARTING_SYMBOL_ATTACH) && (Data != DEBUG_STARTING_SYMBOL_BREAK)) {\r
+ //\r
+ // If the data is not Break symbol, add it into Terminal FIFO\r
+ //\r
+ DebugTerminalFifoAdd (&mSerialFifoForTerminal, Data);\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ }\r
+ }\r
+ \r
+ *BreakSymbol = Data;\r
+ return EFI_SUCCESS;\r
+}\r
[Sources.common]\r
DxeDebugAgent/DxeDebugAgentLib.c\r
DxeDebugAgent/DxeDebugAgentLib.h\r
+ DxeDebugAgent/SerialIo.c\r
DebugAgentCommon/DebugAgent.c\r
DebugAgentCommon/DebugAgent.h\r
DebugAgentCommon/DebugTimer.c\r
DebugAgentCommon/Ia32/AsmFuncs.asm | MSFT\r
DebugAgentCommon/Ia32/ArchDebugSupport.h\r
DebugAgentCommon/Ia32/ArchDebugSupport.c\r
- DebugAgentCommon/Ia32/ArchReadGroupRegister.c\r
- DebugAgentCommon/Ia32/ArchRegisters.h\r
DebugAgentCommon/Ia32/DebugException.h\r
\r
[Sources.X64]\r
DebugAgentCommon/X64/AsmFuncs.asm | MSFT\r
DebugAgentCommon/X64/ArchDebugSupport.h\r
DebugAgentCommon/X64/ArchDebugSupport.c\r
- DebugAgentCommon/X64/ArchReadGroupRegister.c\r
- DebugAgentCommon/X64/ArchRegisters.h\r
DebugAgentCommon/X64/DebugException.h\r
\r
[Packages]\r
MemoryAllocationLib\r
LocalApicLib\r
TimerLib\r
+ PrintLib\r
\r
[Guids]\r
gEfiDebugAgentGuid ## PRODUCES ## Configuration Table\r
gEfiDebugAgentGuid ## CONSUMES ## HOB\r
\r
+[Protocols]\r
+ gEfiSerialIoProtocolGuid ## PRODUCES\r
+ gEfiDevicePathProtocolGuid ## PRODUCES \r
+ gEfiPcdProtocolGuid ## NOTIFY\r
+\r
[Pcd]\r
gEfiMdePkgTokenSpaceGuid.PcdFSBClock ## CONSUMES\r
+ gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate ## CONSUMES\r
+ gEfiMdePkgTokenSpaceGuid.PcdUartDefaultDataBits ## CONSUMES\r
+ gEfiMdePkgTokenSpaceGuid.PcdUartDefaultParity ## CONSUMES\r
+ gEfiMdePkgTokenSpaceGuid.PcdUartDefaultStopBits ## CONSUMES\r
gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdExceptionsIgnoredByDebugger ## CONSUMES\r
\r
/** @file\r
SEC Core Debug Agent Library instance implementition.\r
\r
- Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
\r
CONST BOOLEAN MultiProcessorDebugSupport = FALSE;\r
\r
+/**\r
+ Read the Attach/Break-in symbols from the debug port.\r
+\r
+ @param[in] Handle Pointer to Debug Port handle.\r
+ @param[out] BreakSymbol Returned break symbol.\r
+\r
+ @retval EFI_SUCCESS Read the symbol in BreakSymbol.\r
+ @retval EFI_NOT_FOUND No read the break symbol.\r
+\r
+**/\r
+EFI_STATUS\r
+DebugReadBreakSymbol (\r
+ IN DEBUG_PORT_HANDLE Handle,\r
+ OUT UINT8 *BreakSymbol\r
+ )\r
+{\r
+ *BreakSymbol = 0;\r
+ //\r
+ // If Debug Port buffer has data, read it till it was break symbol or Debug Port buffer emty.\r
+ //\r
+ while (DebugPortPollBuffer (Handle)) {\r
+ DebugPortReadBuffer (Handle, BreakSymbol, 1, 0);\r
+ if (*BreakSymbol == DEBUG_STARTING_SYMBOL_ATTACH || *BreakSymbol == DEBUG_STARTING_SYMBOL_BREAK) {\r
+ return EFI_SUCCESS;\r
+ }\r
+ }\r
+ \r
+ return EFI_NOT_FOUND;\r
+}\r
+\r
/**\r
Get pointer to Mailbox from IDT entry before memory is ready.\r
\r
//\r
// Memory has been ready\r
//\r
- if (IsHostConnected()) {\r
+ if (IsHostAttached()) {\r
//\r
// Trigger one software interrupt to inform HOST\r
//\r
DebugAgentContext = (DEBUG_AGENT_CONTEXT_POSTMEM_SEC *) Context;\r
\r
Mailbox = (DEBUG_AGENT_MAILBOX *) GetMailboxPointerInIdtEntry ();\r
- Mailbox->DebugPortHandle = Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset;\r
+ Mailbox->DebugPortHandle = (UINT64)(UINT32)(Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset);\r
+ Mailbox->DebugFlag.MemoryReady = 1;\r
\r
Mailbox = BuildMailboxHob ();\r
Mailbox = (DEBUG_AGENT_MAILBOX *) ((UINTN) Mailbox + DebugAgentContext->HeapMigrateOffset);\r
//\r
Phase2Context = (DEBUG_AGENT_PHASE2_CONTEXT *) Context;\r
SecCoreData = (EFI_SEC_PEI_HAND_OFF *)Phase2Context->Context;\r
- if ((UINTN)SecCoreData->TemporaryRamBase < BASE_128MB && IsHostConnected ()) {\r
+ if ((UINTN)SecCoreData->TemporaryRamBase < BASE_128MB && IsHostAttached ()) {\r
TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);\r
}\r
\r
DebugAgentCommon/Ia32/AsmFuncs.asm | MSFT\r
DebugAgentCommon/Ia32/ArchDebugSupport.h\r
DebugAgentCommon/Ia32/ArchDebugSupport.c\r
- DebugAgentCommon/Ia32/ArchReadGroupRegister.c\r
- DebugAgentCommon/Ia32/ArchRegisters.h\r
DebugAgentCommon/Ia32/DebugException.h\r
\r
[Sources.X64]\r
DebugAgentCommon/X64/AsmFuncs.asm | MSFT\r
DebugAgentCommon/X64/ArchDebugSupport.h\r
DebugAgentCommon/X64/ArchDebugSupport.c\r
- DebugAgentCommon/X64/ArchReadGroupRegister.c\r
- DebugAgentCommon/X64/ArchRegisters.h\r
DebugAgentCommon/X64/DebugException.h\r
\r
[Packages]\r
LocalApicLib\r
DebugLib\r
TimerLib\r
+ PrintLib\r
\r
[Guids]\r
gEfiDebugAgentGuid ## PRODUCES ## HOB\r
/** @file\r
Debug Agent library implementition.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
UINTN mSavedDebugRegisters[6];\r
CONST BOOLEAN MultiProcessorDebugSupport = FALSE;\r
\r
+/**\r
+ Read the Attach/Break-in symbols from the debug port.\r
+\r
+ @param[in] Handle Pointer to Debug Port handle.\r
+ @param[out] BreakSymbol Returned break symbol.\r
+\r
+ @retval EFI_SUCCESS Read the symbol in BreakSymbol.\r
+ @retval EFI_NOT_FOUND No read the break symbol.\r
+\r
+**/\r
+EFI_STATUS\r
+DebugReadBreakSymbol (\r
+ IN DEBUG_PORT_HANDLE Handle,\r
+ OUT UINT8 *BreakSymbol\r
+ )\r
+{\r
+ //\r
+ // Smm instance has no debug timer to poll break symbol.\r
+ //\r
+ return EFI_NOT_FOUND;\r
+}\r
\r
/**\r
Get Debug Agent Mailbox pointer.\r
DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((DEBUG_PORT_HANDLE) (UINTN)mMailboxPointer->DebugPortHandle, NULL);\r
mMailboxPointer->DebugPortHandle = DebugPortHandle;\r
\r
- if (mMailboxPointer->DebugFlag.Bits.BreakOnNextSmi == 1) {\r
+ if (mMailboxPointer->DebugFlag.BreakOnNextSmi == 1) {\r
//\r
// If SMM entry break is set, SMM code will be break at here.\r
//\r
DebugAgentCommon/Ia32/AsmFuncs.asm | MSFT\r
DebugAgentCommon/Ia32/ArchDebugSupport.h\r
DebugAgentCommon/Ia32/ArchDebugSupport.c\r
- DebugAgentCommon/Ia32/ArchReadGroupRegister.c\r
- DebugAgentCommon/Ia32/ArchRegisters.h\r
DebugAgentCommon/Ia32/DebugException.h\r
\r
[Sources.X64]\r
DebugAgentCommon/X64/AsmFuncs.asm | MSFT\r
DebugAgentCommon/X64/ArchDebugSupport.h\r
DebugAgentCommon/X64/ArchDebugSupport.c\r
- DebugAgentCommon/X64/ArchReadGroupRegister.c\r
- DebugAgentCommon/X64/ArchRegisters.h\r
DebugAgentCommon/X64/DebugException.h\r
\r
[Packages]\r
SynchronizationLib\r
LocalApicLib\r
TimerLib\r
+ PrintLib\r
\r
[Guids]\r
gEfiDebugAgentGuid ## CONSUMES ## Configuration Table\r
UINT8 Reserved3;\r
}USB_DEBUG_PORT_REGISTER;\r
\r
+//\r
+// The state machine of usb debug port\r
+//\r
+#define USBDBG_NO_DEV 0 // No device present at debug port\r
+#define USBDBG_NO_DBG_CAB 1 // The device attached is not usb debug cable\r
+#define USBDBG_DBG_CAB 2 // The device attached is usb debug cable\r
+#define USBDBG_INIT_DONE 4 // The usb debug cable device is initialized\r
+#define USBDBG_RESET 8 // The system is reset\r
+\r
#pragma pack(1)\r
//\r
// The internal data structure of DEBUG_PORT_HANDLE, which stores some\r
// The usb debug port memory BAR number in EHCI configuration space.\r
//\r
UINT8 DebugPortBarNumber;\r
- BOOLEAN Initialized;\r
+ UINT8 Initialized;\r
//\r
// The offset of usb debug port registers in EHCI memory range.\r
//\r
//\r
// The usb debug port memory BAR address.\r
//\r
- UINTN UsbDebugPortMemoryBase;\r
+ UINT32 UsbDebugPortMemoryBase;\r
//\r
// The EHCI memory BAR address.\r
//\r
- UINTN EhciMemoryBase;\r
+ UINT32 EhciMemoryBase;\r
//\r
// The Bulk In endpoint toggle bit.\r
//\r
//\r
// Wait for completing the request\r
//\r
- while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0);\r
+ while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0) {\r
+ if ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE))\r
+ != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE)) {\r
+ return RETURN_DEVICE_ERROR;\r
+ }\r
+ }\r
+ \r
+ //\r
+ // Clearing DONE bit by writing 1\r
+ //\r
+ MmioOr32((UINTN)&DebugPortRegister->ControlStatus, BIT16);\r
\r
//\r
// Check if the request is executed successfully or not.\r
//\r
// Wait for completing the request\r
//\r
- while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & BIT16) == 0);\r
+ while ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & BIT16) == 0) {\r
+ if ((MmioRead32((UINTN)&DebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE))\r
+ != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE)) {\r
+ return RETURN_DEVICE_ERROR;\r
+ }\r
+ }\r
+ \r
+ //\r
+ // Clearing DONE bit by writing 1\r
+ //\r
+ MmioOr32((UINTN)&DebugPortRegister->ControlStatus, BIT16);\r
\r
//\r
// Check if the request is executed successfully or not.\r
)\r
{\r
UINT16 PciCmd;\r
- UINTN UsbDebugPortMemoryBase;\r
- UINTN EhciMemoryBase;\r
+ UINT32 UsbDebugPortMemoryBase;\r
+ UINT32 EhciMemoryBase;\r
BOOLEAN Status;\r
USB_DEBUG_PORT_REGISTER *UsbDebugPortRegister;\r
\r
//\r
PciCmd = PciRead16 (PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET);\r
if (((PciCmd & EFI_PCI_COMMAND_MEMORY_SPACE) == 0) || ((PciCmd & EFI_PCI_COMMAND_BUS_MASTER) == 0)) {\r
+ PciCmd |= EFI_PCI_COMMAND_MEMORY_SPACE | EFI_PCI_COMMAND_BUS_MASTER;\r
+ PciWrite16(PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET, PciCmd);\r
Status = TRUE;\r
}\r
\r
//\r
- // Check if the debug port is enabled and owned by myself.\r
+ // If the owner and in_use bit is not set, it means system is doing cold/warm boot or EHCI host controller is reset by system software.\r
//\r
- UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);\r
- if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) &\r
- (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE)) == 0) {\r
+ UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UINTN)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);\r
+ if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE))\r
+ != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE)) {\r
+ Status = TRUE;\r
+ }\r
+\r
+ if (Handle->Initialized == USBDBG_RESET) {\r
+ Status = TRUE;\r
+ } else if (Handle->Initialized != USBDBG_INIT_DONE) {\r
Status = TRUE;\r
}\r
return Status;\r
UINT8 DebugPortNumber;\r
UINT8 Length;\r
\r
- UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);\r
+ UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UINTN)(Handle->UsbDebugPortMemoryBase + Handle->DebugPortOffset);\r
PciCmd = PciRead16 (PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET);\r
- UsbHCSParam = (UINT32 *)(Handle->EhciMemoryBase + 0x04);\r
- UsbCmd = (UINT32 *)(Handle->EhciMemoryBase + 0x20);\r
- UsbStatus = (UINT32 *)(Handle->EhciMemoryBase + 0x24);\r
+ UsbHCSParam = (UINT32 *)(UINTN)(Handle->EhciMemoryBase + 0x04);\r
+ UsbCmd = (UINT32 *)(UINTN)(Handle->EhciMemoryBase + 0x20);\r
+ UsbStatus = (UINT32 *)(UINTN)(Handle->EhciMemoryBase + 0x24);\r
\r
//\r
- // initialize the data toggle used by bulk in/out endpoint.\r
+ // Check if the debug port is enabled and owned by myself.\r
//\r
- Handle->BulkInToggle = 0;\r
- Handle->BulkOutToggle = 0;\r
+ if (((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE))\r
+ != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE)) || (Handle->Initialized == USBDBG_RESET)) {\r
+ //\r
+ // If the host controller is not halted, then halt it.\r
+ //\r
+ if ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0) {\r
+ MmioAnd32((UINTN)UsbCmd, (UINT32)~BIT0);\r
+ while ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0);\r
+ }\r
+ //\r
+ // reset the host controller.\r
+ //\r
+ MmioOr32((UINTN)UsbCmd, BIT1);\r
+ //\r
+ // ensure that the host controller is reset.\r
+ //\r
+ while (MmioRead32((UINTN)UsbCmd) & BIT1);\r
\r
- //\r
- // Enable Ehci Memory Space Access\r
- //\r
- if (((PciCmd & EFI_PCI_COMMAND_MEMORY_SPACE) == 0) || ((PciCmd & EFI_PCI_COMMAND_BUS_MASTER) == 0)) {\r
- PciCmd |= EFI_PCI_COMMAND_MEMORY_SPACE | EFI_PCI_COMMAND_BUS_MASTER;\r
- PciWrite16(PcdGet32(PcdUsbEhciPciAddress) + PCI_COMMAND_OFFSET, PciCmd);\r
- }\r
+ //\r
+ // Start the host controller if it's not running\r
+ //\r
+ if (MmioRead32((UINTN)UsbStatus) & BIT12) {\r
+ MmioOr32((UINTN)UsbCmd, BIT0);\r
+ // ensure that the host controller is started (HALTED bit must be cleared)\r
+ while (MmioRead32((UINTN)UsbStatus) & BIT12);\r
+ }\r
\r
- //\r
- // If the host controller is not halted, then halt it.\r
- //\r
- if ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0) {\r
- MmioAnd32((UINTN)UsbCmd, (UINT32)~BIT0);\r
- while ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0);\r
- }\r
- //\r
- // reset the host controller.\r
- //\r
- MmioOr32((UINTN)UsbCmd, BIT1);\r
- //\r
- // ensure that the host controller is reset.\r
- //\r
- while (MmioRead32((UINTN)UsbCmd) & BIT1);\r
+ //\r
+ // First get the ownership of port 0.\r
+ //\r
+ MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE);\r
\r
- //\r
- // Start the host controller if it's not running\r
- //\r
- if (MmioRead32((UINTN)UsbStatus) & BIT12) {\r
- MmioOr32((UINTN)UsbCmd, BIT0);\r
- // ensure that the host controller is started (HALTED bit must be cleared)\r
- while (MmioRead32((UINTN)UsbStatus) & BIT12);\r
+ MicroSecondDelay (200000);\r
}\r
-\r
- //\r
- // First get the ownership of port 0.\r
- //\r
- MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_OWNER);\r
-\r
- MicroSecondDelay (200000);\r
-\r
//\r
// Find out which port is used as debug port.\r
//\r
DebugPortNumber = (UINT8)((MmioRead32((UINTN)UsbHCSParam) & 0x00F00000) >> 20);\r
//\r
- // Should find a non low-speed device is connected\r
+ // Should find a device is connected at debug port\r
//\r
- PortStatus = (UINT32 *)(Handle->EhciMemoryBase + 0x64 + (DebugPortNumber - 1) * 4);\r
- if (!(MmioRead32((UINTN)PortStatus) & BIT0) || ((MmioRead32((UINTN)PortStatus) & USB_PORT_LINE_STATUS_MASK) == USB_PORT_LINE_STATUS_LS)) {\r
+ PortStatus = (UINT32 *)(UINTN)(Handle->EhciMemoryBase + 0x64 + (DebugPortNumber - 1) * 4);\r
+ if (!(MmioRead32((UINTN)PortStatus) & BIT0)) {\r
+ Handle->Initialized = USBDBG_NO_DEV;\r
return RETURN_NOT_FOUND;\r
}\r
\r
- //\r
- // Reset the debug port\r
- //\r
- MmioOr32((UINTN)PortStatus, BIT8);\r
- MicroSecondDelay (200000);\r
- MmioAnd32((UINTN)PortStatus, (UINT32)~BIT8);\r
- while (MmioRead32((UINTN)PortStatus) & BIT8);\r
+ if (Handle->Initialized != USBDBG_INIT_DONE) {\r
+ //\r
+ // Reset the debug port\r
+ //\r
+ MmioOr32((UINTN)PortStatus, BIT8);\r
+ MicroSecondDelay (500000);\r
+ MmioAnd32((UINTN)PortStatus, (UINT32)~BIT8);\r
+ while (MmioRead32((UINTN)PortStatus) & BIT8);\r
\r
- //\r
- // The port enabled bit should be set by HW.\r
- //\r
- if ((MmioRead32((UINTN)PortStatus) & BIT2) == 0) {\r
- return RETURN_DEVICE_ERROR;\r
- }\r
+ //\r
+ // The port enabled bit should be set by HW.\r
+ //\r
+ if ((MmioRead32((UINTN)PortStatus) & BIT2) == 0) {\r
+ Handle->Initialized = USBDBG_NO_DBG_CAB;\r
+ return RETURN_DEVICE_ERROR;\r
+ }\r
\r
- //\r
- // Enable Usb Debug Port Capability\r
- //\r
- MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_ENABLE | USB_DEBUG_PORT_IN_USE);\r
+ //\r
+ // Enable Usb Debug Port Capability\r
+ //\r
+ MmioOr32((UINTN)&UsbDebugPortRegister->ControlStatus, USB_DEBUG_PORT_ENABLE);\r
\r
- //\r
- // Start to communicate with Usb Debug Device to see if the attached device is usb debug device or not.\r
- //\r
- Length = (UINT8)sizeof (USB_DEBUG_PORT_DESCRIPTOR);\r
+ //\r
+ // initialize the data toggle used by bulk in/out endpoint.\r
+ //\r
+ Handle->BulkInToggle = 0;\r
+ Handle->BulkOutToggle = 0;\r
\r
- //\r
- // It's not a dedicated usb debug device, should use address 0 to get debug descriptor.\r
- //\r
- Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mGetDebugDescriptor, 0x0, 0x0, (UINT8*)&UsbDebugPortDescriptor, &Length);\r
- if (RETURN_ERROR(Status)) {\r
//\r
- // The device is not a usb debug device.\r
+ // set usb debug device address as 0x7F.\r
//\r
- return Status;\r
- }\r
+ Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugAddress, 0x0, 0x0, NULL, NULL);\r
+ if (RETURN_ERROR(Status)) {\r
+ //\r
+ // The device can not work well.\r
+ //\r
+ Handle->Initialized = USBDBG_NO_DBG_CAB;\r
+ return Status;\r
+ }\r
\r
- if (Length != sizeof(USB_DEBUG_PORT_DESCRIPTOR)) {\r
- return RETURN_DEVICE_ERROR;\r
- }\r
+ //\r
+ // Start to communicate with Usb Debug Device to see if the attached device is usb debug device or not.\r
+ //\r
+ Length = (UINT8)sizeof (USB_DEBUG_PORT_DESCRIPTOR);\r
\r
- //\r
- // set usb debug device address as 0x7F.\r
- //\r
- Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugAddress, 0x0, 0x0, NULL, NULL);\r
- if (RETURN_ERROR(Status)) {\r
//\r
- // The device can not work well.\r
+ // Get debug descriptor.\r
//\r
- return Status;\r
+ Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mGetDebugDescriptor, 0x7F, 0x0, (UINT8*)&UsbDebugPortDescriptor, &Length);\r
+ if (RETURN_ERROR(Status)) {\r
+ //\r
+ // The device is not a usb debug device.\r
+ //\r
+ Handle->Initialized = USBDBG_NO_DBG_CAB;\r
+ return Status;\r
+ }\r
+\r
+ if (Length != sizeof(USB_DEBUG_PORT_DESCRIPTOR)) {\r
+ Handle->Initialized = USBDBG_NO_DBG_CAB;\r
+ return RETURN_DEVICE_ERROR;\r
+ }\r
+\r
+ //\r
+ // enable the usb debug feature.\r
+ //\r
+ Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugFeature, 0x7F, 0x0, NULL, NULL);\r
+ if (RETURN_ERROR(Status)) {\r
+ //\r
+ // The device can not work well.\r
+ //\r
+ Handle->Initialized = USBDBG_NO_DBG_CAB;\r
+ return Status;\r
+ }\r
+ \r
+ Handle->Initialized = USBDBG_DBG_CAB;\r
}\r
\r
//\r
- // enable the usb debug feature.\r
+ // Set initialized flag\r
//\r
- Status = UsbDebugPortControlTransfer (UsbDebugPortRegister, &mSetDebugFeature, 0x7F, 0x0, NULL, NULL);\r
+ Handle->Initialized = USBDBG_INIT_DONE;\r
\r
- return Status;\r
+ return RETURN_SUCCESS;\r
}\r
\r
/**\r
UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;\r
}\r
\r
- //\r
- // Check if debug port is ready\r
- //\r
- if (!UsbDebugPortHandle->Initialized) {\r
- return 0;\r
- }\r
-\r
if (NeedReinitializeHardware(UsbDebugPortHandle)) {\r
Status = InitializeUsbDebugHardware (UsbDebugPortHandle);\r
if (RETURN_ERROR(Status)) {\r
}\r
}\r
\r
- UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
+ UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UINTN)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
\r
//\r
// First read data from buffer, then read debug port hw to get received data.\r
UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;\r
}\r
\r
- //\r
- // Check if debug port is ready\r
- //\r
- if (!UsbDebugPortHandle->Initialized) {\r
- return 0;\r
- }\r
-\r
if (NeedReinitializeHardware(UsbDebugPortHandle)) {\r
Status = InitializeUsbDebugHardware (UsbDebugPortHandle);\r
if (RETURN_ERROR(Status)) {\r
}\r
}\r
\r
- UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
+ UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UINTN)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
\r
while ((Total < NumberOfBytes)) {\r
if (NumberOfBytes - Total > USB_DEBUG_PORT_MAX_PACKET_SIZE) {\r
UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Handle;\r
}\r
\r
- //\r
- // Check if debug port is ready\r
- //\r
- if (!UsbDebugPortHandle->Initialized) {\r
- return 0;\r
- }\r
-\r
if (NeedReinitializeHardware(UsbDebugPortHandle)) {\r
Status = InitializeUsbDebugHardware(UsbDebugPortHandle);\r
if (RETURN_ERROR(Status)) {\r
return TRUE;\r
}\r
\r
- UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
+ UsbDebugPortRegister = (USB_DEBUG_PORT_REGISTER *)(UINTN)(UsbDebugPortHandle->UsbDebugPortMemoryBase + UsbDebugPortHandle->DebugPortOffset);\r
\r
UsbDebugPortRegister->TokenPid = INPUT_PID;\r
if (UsbDebugPortHandle->BulkInToggle == 0) {\r
//\r
// Wait for completing the request\r
//\r
- while ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0);\r
+ while ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (UINT32)BIT16) == 0) {\r
+ if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE))\r
+ != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_ENABLE)) {\r
+ return FALSE;\r
+ }\r
+ }\r
\r
if ((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus)) & BIT6) {\r
return FALSE;\r
{\r
RETURN_STATUS Status;\r
USB_DEBUG_PORT_HANDLE Handle;\r
-\r
- if (Function == NULL && Context != NULL) {\r
+\r if (Function == NULL && Context != NULL) {\r
return (DEBUG_PORT_HANDLE *) Context;\r
}\r
\r
\r
Status = CalculateUsbDebugPortBar(&Handle.DebugPortOffset, &Handle.DebugPortBarNumber);\r
if (RETURN_ERROR (Status)) {\r
- DEBUG ((EFI_D_ERROR, "USB Debug Port: the pci device pointed by PcdUsbEhciPciAddress is not EHCI host controller or does not support debug port capability!\n"));\r
+ DEBUG ((EFI_D_ERROR, "UsbDbg: the pci device pointed by PcdUsbEhciPciAddress is not EHCI host controller or does not support debug port capability!\n"));\r
goto Exit;\r
}\r
\r
Handle.UsbDebugPortMemoryBase = 0xFFFFFC00 & PciRead32(PcdGet32(PcdUsbEhciPciAddress) + PCI_BASE_ADDRESSREG_OFFSET + Handle.DebugPortBarNumber * 4);\r
}\r
\r
- Status = InitializeUsbDebugHardware (&Handle);\r
- if (RETURN_ERROR(Status)) {\r
- DEBUG ((EFI_D_ERROR, "USB Debug Port: Initialization failed, please check if USB debug cable is plugged into EHCI debug port correctly!\n"));\r
- goto Exit;\r
- }\r
+ Handle.Initialized = USBDBG_RESET;\r
\r
- //\r
- // Set debug port initialized successfully flag\r
- //\r
- Handle.Initialized = TRUE;\r
+ if (NeedReinitializeHardware(&Handle)) {\r
+ DEBUG ((EFI_D_ERROR, "UsbDbg: Start EHCI debug port initialization!\n"));\r
+ Status = InitializeUsbDebugHardware (&Handle);\r
+ if (RETURN_ERROR(Status)) {\r
+ DEBUG ((EFI_D_ERROR, "UsbDbg: Initialization failed, please check if USB debug cable is plugged into EHCI debug port correctly!\n"));\r
+ goto Exit;\r
+ }\r
+ }\r
\r
Exit:\r
\r
/** @file\r
PE/Coff Extra Action library instances.\r
\r
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
}\r
\r
/**\r
- Performs additional actions after a PE/COFF image has been loaded and relocated.\r
+ Common routine to report the PE/COFF image loading/relocating or unloading event.\r
\r
If ImageContext is NULL, then ASSERT().\r
-\r
+ \r
@param ImageContext Pointer to the image context structure that describes the\r
- PE/COFF image that has already been loaded and relocated.\r
+ PE/COFF image.\r
+ @param Signature IMAGE_LOAD_SIGNATURE or IMAGE_UNLOAD_SIGNATURE.\r
\r
**/\r
VOID\r
-EFIAPI\r
-PeCoffLoaderRelocateImageExtraAction (\r
- IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext\r
+PeCoffLoaderExtraActionCommon (\r
+ IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,\r
+ IN UINTN Signature\r
)\r
{\r
BOOLEAN InterruptState;\r
Cr4 = AsmReadCr4 ();\r
\r
//\r
- // DR0 = IMAGE_LOAD_SIGNATURE\r
+ // DR0 = Signature\r
// DR1 = The address of the Null-terminated ASCII string for the PE/COFF image's PDB file name\r
// DR2 = The pointer to the ImageContext structure\r
// DR3 = IO_PORT_BREAKPOINT_ADDRESS\r
// CR4 = Make sure DE(BIT3) is set\r
//\r
AsmWriteDr7 (0);\r
- AsmWriteDr0 (IMAGE_LOAD_SIGNATURE);\r
- AsmWriteDr1 ((UINTN)ImageContext->PdbPointer);\r
- AsmWriteDr2 ((UINTN)ImageContext);\r
+ AsmWriteDr0 (Signature);\r
+ AsmWriteDr1 ((UINTN) ImageContext->PdbPointer);\r
+ AsmWriteDr2 ((UINTN) ImageContext);\r
AsmWriteDr3 (IO_PORT_BREAKPOINT_ADDRESS);\r
\r
LoadImageMethod = PcdGet8 (PcdDebugLoadImageMethod);\r
// in the above exception handler\r
//\r
NewDr7 = AsmReadDr7 ();\r
- if (!IsDrxEnabled (0, NewDr7)) {\r
+ if (!IsDrxEnabled (0, NewDr7) && (AsmReadDr0 () == 0 || AsmReadDr0 () == Signature)) {\r
+ //\r
+ // If user changed Dr3 (by setting HW bp in the above exception handler,\r
+ // we will not set Dr0 to 0 in GO/STEP handler because the break cause is not IMAGE_LOAD/_UNLOAD.\r
+ //\r
AsmWriteDr0 (Dr0);\r
}\r
- if (!IsDrxEnabled (1, NewDr7)) {\r
+ if (!IsDrxEnabled (1, NewDr7) && (AsmReadDr1 () == (UINTN) ImageContext->PdbPointer)) {\r
AsmWriteDr1 (Dr1);\r
}\r
- if (!IsDrxEnabled (2, NewDr7)) {\r
+ if (!IsDrxEnabled (2, NewDr7) && (AsmReadDr2 () == (UINTN) ImageContext)) {\r
AsmWriteDr2 (Dr2);\r
}\r
- if (!IsDrxEnabled (3, NewDr7)) {\r
+ if (!IsDrxEnabled (3, NewDr7) && (AsmReadDr3 () == IO_PORT_BREAKPOINT_ADDRESS)) {\r
AsmWriteDr3 (Dr3);\r
}\r
if (AsmReadCr4 () == (Cr4 | BIT3)) {\r
SetInterruptState (InterruptState);\r
}\r
\r
+/**\r
+ Performs additional actions after a PE/COFF image has been loaded and relocated.\r
+\r
+ @param ImageContext Pointer to the image context structure that describes the\r
+ PE/COFF image that has already been loaded and relocated.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+PeCoffLoaderRelocateImageExtraAction (\r
+ IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext\r
+ )\r
+{\r
+ PeCoffLoaderExtraActionCommon (ImageContext, IMAGE_LOAD_SIGNATURE);\r
+}\r
+\r
/**\r
Performs additional actions just before a PE/COFF image is unloaded. Any resources\r
that were allocated by PeCoffLoaderRelocateImageExtraAction() must be freed.\r
\r
- If ImageContext is NULL, then ASSERT().\r
-\r
@param ImageContext Pointer to the image context structure that describes the\r
PE/COFF image that is being unloaded.\r
\r
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext\r
)\r
{\r
- BOOLEAN InterruptState;\r
- UINTN Dr0;\r
- UINTN Dr1;\r
- UINTN Dr2;\r
- UINTN Dr3;\r
- UINTN Dr7;\r
- UINTN Cr4;\r
- UINTN NewDr7;\r
- UINT8 LoadImageMethod;\r
- UINT8 DebugAgentStatus;\r
-\r
- ASSERT (ImageContext != NULL);\r
-\r
- if (ImageContext->PdbPointer != NULL) {\r
- DEBUG((EFI_D_ERROR, " PDB = %a\n", ImageContext->PdbPointer));\r
- }\r
-\r
- //\r
- // Disable interrupts and save the current interrupt state\r
- //\r
- InterruptState = SaveAndDisableInterrupts ();\r
-\r
- //\r
- // Save Debug Register State\r
- //\r
- Dr0 = AsmReadDr0 ();\r
- Dr1 = AsmReadDr1 ();\r
- Dr2 = AsmReadDr2 ();\r
- Dr3 = AsmReadDr3 ();\r
- Dr7 = AsmReadDr7 ();\r
- Cr4 = AsmReadCr4 ();\r
-\r
- //\r
- // DR0 = IMAGE_UNLOAD_SIGNATURE\r
- // DR1 = The address of the Null-terminated ASCII string for the PE/COFF image's PDB file name\r
- // DR2 = The pointer to the ImageContext structure\r
- // DR3 = IO_PORT_BREAKPOINT_ADDRESS\r
- // DR7 = Disables all HW breakpoints except for DR3 I/O port access of length 1 byte\r
- // CR4 = Make sure DE(BIT3) is set\r
- //\r
- AsmWriteDr7 (0);\r
- AsmWriteDr0 (IMAGE_UNLOAD_SIGNATURE);\r
- AsmWriteDr1 ((UINTN)ImageContext->PdbPointer);\r
- AsmWriteDr2 ((UINTN)ImageContext);\r
- AsmWriteDr3 (IO_PORT_BREAKPOINT_ADDRESS);\r
-\r
- LoadImageMethod = PcdGet8 (PcdDebugLoadImageMethod);\r
- if (LoadImageMethod == DEBUG_LOAD_IMAGE_METHOD_IO_HW_BREAKPOINT) {\r
- AsmWriteDr7 (0x20000480);\r
- AsmWriteCr4 (Cr4 | BIT3);\r
- //\r
- // Do an IN from IO_PORT_BREAKPOINT_ADDRESS to generate a HW breakpoint until the port\r
- // returns a read value other than DEBUG_AGENT_IMAGE_WAIT\r
- //\r
- do {\r
- DebugAgentStatus = IoRead8 (IO_PORT_BREAKPOINT_ADDRESS);\r
- } while (DebugAgentStatus == DEBUG_AGENT_IMAGE_WAIT);\r
-\r
- } else if (LoadImageMethod == DEBUG_LOAD_IMAGE_METHOD_SOFT_INT3) {\r
- //\r
- // Generate a software break point.\r
- //\r
- CpuBreakpoint ();\r
- }\r
-\r
- //\r
- // Restore Debug Register State only when Host didn't change it inside exception handler.\r
- // E.g.: User halts the target and sets the HW breakpoint while target is \r
- // in the above exception handler\r
- //\r
- NewDr7 = AsmReadDr7 ();\r
- if (!IsDrxEnabled (0, NewDr7)) {\r
- AsmWriteDr0 (Dr0);\r
- }\r
- if (!IsDrxEnabled (1, NewDr7)) {\r
- AsmWriteDr1 (Dr1);\r
- }\r
- if (!IsDrxEnabled (2, NewDr7)) {\r
- AsmWriteDr2 (Dr2);\r
- }\r
- if (!IsDrxEnabled (3, NewDr7)) {\r
- AsmWriteDr3 (Dr3);\r
- }\r
- if (AsmReadCr4 () == (Cr4 | BIT3)) {\r
- AsmWriteCr4 (Cr4);\r
- }\r
- if (NewDr7 == 0x20000480) {\r
- AsmWriteDr7 (Dr7);\r
- }\r
-\r
- //\r
- // Restore the interrupt state\r
- //\r
- SetInterruptState (InterruptState);\r
+ PeCoffLoaderExtraActionCommon (ImageContext, IMAGE_UNLOAD_SIGNATURE);\r
}\r
\r
The Intel(R) UDK Debugger Tool and its detailed user manual can be obtained\r
from: http://www.intel.com/technology/efi.\r
-\r
-NOTE: In addition to the known issues listed in the user manual, the following\r
-anomalies have been observed:\r
-\r
-1) When using a USB debug cable, after the TARGET completes a reset during\r
- memory initialization, the connection between the HOST and the TARGET may be\r
- lost. A work around for this issue is to unplug the USB debug cable and then\r
- plug the cable back in. A new debug session can then be started.\r
DEC_SPECIFICATION = 0x00010005\r
PACKAGE_NAME = SourceLevelDebugPkg\r
PACKAGE_GUID = DBF00C27-D8D7-443d-918B-4E85CDA1373B\r
- PACKAGE_VERSION = 0.71\r
+ PACKAGE_VERSION = 0.80\r
\r
[Includes]\r
Include\r
[Defines]\r
PLATFORM_NAME = SourceLevelDebugPkg\r
PLATFORM_GUID = 38C85805-883F-4ee8-A854-95B966ED73AA\r
- PLATFORM_VERSION = 0.71\r
+ PLATFORM_VERSION = 0.80\r
DSC_SPECIFICATION = 0x00010005\r
OUTPUT_DIRECTORY = Build/SourceLevelDebugPkg\r
SUPPORTED_ARCHITECTURES = IA32|X64\r
projects / mirror_edk2.git / commitdiff