1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/sbefw/sbecmdtracearray.C $ */
/* */
/* OpenPOWER sbe Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2017 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
/*
* @file: ppe/sbe/sbefw/sbecmdtracearray.C
*
* @brief This file contains the SBE Control Tracearray chipOp
*
*/
#include "sbecmdtracearray.H"
#include "sbefifo.H"
#include "sbe_sp_intf.H"
#include "sbetrace.H"
#include "sbeFifoMsgUtils.H"
#include "sbeutil.H"
#include "sbefapiutil.H"
#include "fapi2.H"
#include "p9_sbe_tracearray.H"
using namespace fapi2;
constexpr uint32_t SBE_TRACE_GRANULE_NUM_ROWS = 1;
constexpr uint32_t SBE_TRACEARRAY_BYTES_PER_ROW =
(P9_TRACEARRAY_BITS_PER_ROW / 8);
constexpr uint32_t SBE_TRACE_GRANULE_NUM_WORDS =
(SBE_TRACE_GRANULE_NUM_ROWS * SBE_TRACEARRAY_BYTES_PER_ROW) /
sizeof(uint32_t);
#ifdef SEEPROM_IMAGE
p9_sbe_tracearray_FP_t p9_sbe_tracearray_hwp = &p9_sbe_tracearray;
#endif
uint32_t sbeControlTraceArray(uint8_t *i_pArg)
{
#define SBE_FUNC " sbeControlTraceArray"
SBE_ENTER(SBE_FUNC);
uint32_t l_rc = SBE_SEC_OPERATION_SUCCESSFUL;
sbeControlTraceArrayCMD_t l_req = {};
sbeRespGenHdr_t respHdr;
respHdr.init();
sbeResponseFfdc_t l_ffdc;
ReturnCode l_fapiRc;
uint32_t l_NumWordsRead = 0;
uint32_t l_len = 0;
do
{
l_len = sizeof(sbeControlTraceArrayCMD_t)/sizeof(uint32_t);
l_rc = sbeUpFifoDeq_mult (l_len, (uint32_t *)&l_req); //EOT fetch
// If FIFO access failure
CHECK_SBE_RC_AND_BREAK_IF_NOT_SUCCESS(l_rc);
SBE_INFO(SBE_FUNC" targetType [0x%04X] chipletId [0x%02X]"
" traceArrayId [0x%04X] operation [0x%04X]",
l_req.targetType,
l_req.chipletId,
l_req.traceArrayId,
l_req.operation);
// Construct a Target from Chiplet ID and Target Type
fapi2::plat_target_handle_t l_tgtHndl;
if(!sbeGetFapiTargetHandle(l_req.targetType, l_req.chipletId,
l_tgtHndl))
{
SBE_ERROR(SBE_FUNC "Invalid target type [0x%04x]",
(uint16_t)l_req.targetType);
respHdr.setStatus(SBE_PRI_INVALID_DATA,
SBE_SEC_INVALID_TARGET_TYPE_PASSED);
break;
}
proc_gettracearray_args l_args = {};
// Fill trace array Id
l_args.trace_bus = (p9_tracearray_bus_id)l_req.traceArrayId;
// Fill control arguments
l_args.reset_post_dump = (l_req.operation & SBE_TA_RESET);
l_args.restart_post_dump = (l_req.operation & SBE_TA_RESTART);
l_args.stop_pre_dump = (l_req.operation & SBE_TA_STOP);
l_args.collect_dump = (l_req.operation & SBE_TA_COLLECT_DUMP);
l_args.ignore_mux_setting = (l_req.operation &
SBE_TA_IGNORE_MUX_SETTING);
uint64_t l_buffer[SBE_TRACE_GRANULE_NUM_WORDS/2] = {};
for(uint32_t l_cur_row = 0; l_cur_row < P9_TRACEARRAY_NUM_ROWS;
l_cur_row++)
{
SBE_EXEC_HWP(l_fapiRc, p9_sbe_tracearray_hwp,
l_tgtHndl,
l_args,
l_buffer,
l_cur_row,
SBE_TRACE_GRANULE_NUM_ROWS);
if(l_fapiRc != FAPI2_RC_SUCCESS)
{
SBE_ERROR("p9_sbe_tracearray failed");
// Respond with HWP FFDC
respHdr.setStatus( SBE_PRI_GENERIC_EXECUTION_FAILURE,
SBE_SEC_GENERIC_FAILURE_IN_EXECUTION );
l_ffdc.setRc(l_fapiRc);
break;
}
// If dump is not requested, break from the loop
if(!l_args.collect_dump)
break;
// Put the buffer onto Fifo
SBE_DEBUG(SBE_FUNC " sending row [%d]", l_cur_row);
l_len = SBE_TRACE_GRANULE_NUM_WORDS;
l_rc = sbeDownFifoEnq_mult (l_len,
reinterpret_cast<uint32_t *>(l_buffer));
CHECK_SBE_RC_AND_BREAK_IF_NOT_SUCCESS(l_rc);
l_NumWordsRead += SBE_TRACE_GRANULE_NUM_WORDS;
}
} while(false);
// Now build and enqueue response into downstream FIFO
// If there was a FIFO error, will skip sending the response,
// instead give the control back to the command processor thread
if ( SBE_SEC_OPERATION_SUCCESSFUL == l_rc )
{
SBE_INFO(SBE_FUNC " l_NumWordsRead [%d]", l_NumWordsRead);
l_len = sizeof(l_NumWordsRead)/sizeof(uint32_t);
l_rc = sbeDownFifoEnq_mult (l_len, &l_NumWordsRead);
if(SBE_SEC_OPERATION_SUCCESSFUL == l_rc)
{
l_rc = sbeDsSendRespHdr( respHdr, &l_ffdc);
}
}
SBE_EXIT(SBE_FUNC);
return l_rc;
#undef SBE_FUNC
}
|
