182 lines
4.7 KiB
C
182 lines
4.7 KiB
C
/*
|
|
* Copyright (c) 2019-2020, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* NVIDIA CORPORATION and its licensors retain all intellectual property
|
|
* and proprietary rights in and to this software, related documentation
|
|
* and any modifications thereto. Any use, reproduction, disclosure or
|
|
* distribution of this software and related documentation without an express
|
|
* license agreement from NVIDIA CORPORATION is strictly prohibited.
|
|
*/
|
|
|
|
#ifndef __TEGRA_HV_ERRINFO_H__
|
|
#define __TEGRA_HV_ERRINFO_H__
|
|
|
|
/* Supported synchronous and asynchronous errors */
|
|
enum err_reason {
|
|
REASON_UNDEFINED = 0UL,
|
|
REASON_ASYNC_SMMU_CB,
|
|
REASON_ASYNC_SMMU_GLOBAL,
|
|
REASON_ASYNC_BRIDGE,
|
|
REASON_ASYNC_MC,
|
|
REASON_ASYNC_MC_T19X,
|
|
REASON_ASYNC_CBB,
|
|
REASON_SYNC,
|
|
REASON_ENUM_SIZE
|
|
};
|
|
|
|
enum err_type {
|
|
SYNC = 0UL,
|
|
ASYNC
|
|
};
|
|
|
|
struct __attribute__((__packed__)) async_metadata_t {
|
|
uint64_t rd_idx;
|
|
uint64_t wr_idx;
|
|
};
|
|
|
|
#define NAME_SIZE 64
|
|
|
|
struct __attribute__((__packed__)) async_bridge_err_t {
|
|
char br_name[NAME_SIZE];
|
|
unsigned int err_addr;
|
|
unsigned int err_status1;
|
|
unsigned int err_status2;
|
|
unsigned int rw;
|
|
unsigned int err_type;
|
|
unsigned int length;
|
|
unsigned int br_id;
|
|
unsigned int src_id;
|
|
unsigned int axi_id;
|
|
unsigned int count;
|
|
unsigned int protection;
|
|
unsigned int burst;
|
|
unsigned int cache;
|
|
};
|
|
|
|
struct __attribute__((__packed__)) async_cbb_err_t {
|
|
char cbb_name[NAME_SIZE];
|
|
unsigned int error_logger;
|
|
unsigned int errlog0;
|
|
char transaction_type[NAME_SIZE];
|
|
char error_code[NAME_SIZE];
|
|
char error_source[NAME_SIZE];
|
|
char error_description[NAME_SIZE];
|
|
bool header_format;
|
|
unsigned int packet_header_lock;
|
|
unsigned int packet_header_len1;
|
|
unsigned int errlog1;
|
|
unsigned int errlog2;
|
|
uint64_t route_id;
|
|
char initflow[NAME_SIZE];
|
|
char targflow[NAME_SIZE];
|
|
unsigned int targ_subrange;
|
|
unsigned int seqid;
|
|
unsigned int errlog3;
|
|
unsigned int errlog4;
|
|
uint64_t address;
|
|
unsigned int errlog5;
|
|
char master_id[NAME_SIZE];
|
|
unsigned int non_mod;
|
|
unsigned int axi_id;
|
|
unsigned int security_group;
|
|
uint32_t cache;
|
|
uint32_t protection;
|
|
unsigned int falconsec;
|
|
unsigned int virtual_q_channel;
|
|
};
|
|
|
|
struct __attribute__((__packed__)) async_smmu_err_t {
|
|
unsigned int stream_id;
|
|
unsigned int cb_id;
|
|
unsigned int fsynr0;
|
|
unsigned int fsynr1;
|
|
uint64_t far;
|
|
unsigned int fsr;
|
|
};
|
|
|
|
struct __attribute__((__packed__)) async_mc_err_t {
|
|
uint64_t ch_base;
|
|
unsigned int int_status;
|
|
unsigned int err_status;
|
|
uint64_t fault_addr;
|
|
unsigned int vcpuid; /* 0xffffU IDLE_vCPU_ID */
|
|
unsigned int client_id;
|
|
int32_t peripheral_id;
|
|
};
|
|
|
|
struct __attribute__((__packed__)) async_mc_err_t19x_t {
|
|
bool vpr_violation;
|
|
unsigned int vpr_base[2];
|
|
unsigned int vpr_size;
|
|
unsigned int vpr_ctrl;
|
|
unsigned int vpr_override[4];
|
|
bool no_status;
|
|
bool two_status;
|
|
int client_swgid;
|
|
char client_name[NAME_SIZE];
|
|
char fault_msg[NAME_SIZE];
|
|
unsigned int status;
|
|
uint64_t address;
|
|
unsigned int secure;
|
|
unsigned int write;
|
|
};
|
|
|
|
struct __attribute__((__packed__)) sync_t {
|
|
bool is_filled; /* metadata field per vcpu */
|
|
unsigned int offending_vcpu_id;
|
|
uint32_t esr_el2;
|
|
uint64_t elr_el2;
|
|
uint64_t far_el2;
|
|
uint64_t hpfar_el2;
|
|
uint64_t par_hpfar_el2;
|
|
uint64_t spsr_el2;
|
|
uint64_t elr_el1;
|
|
uint64_t far_el1;
|
|
uint64_t spsr_el1;
|
|
uint32_t esr_el1;
|
|
uint32_t fault_instr;
|
|
uint64_t gpr_array[31];
|
|
};
|
|
|
|
struct __attribute__((__packed__)) err_data_t {
|
|
unsigned int offending_guest_id;
|
|
unsigned int err_type;
|
|
unsigned int err_reason;
|
|
union {
|
|
/* Asynchronous */
|
|
struct async_bridge_err_t async_bridge_err;
|
|
struct async_smmu_err_t async_smmu_err;
|
|
struct async_mc_err_t async_mc_err;
|
|
struct async_cbb_err_t async_cbb_err;
|
|
struct async_mc_err_t19x_t async_mc_err_t19x;
|
|
/* Synchronous */
|
|
struct sync_t sync;
|
|
};
|
|
};
|
|
|
|
/* VM shared memory for error information is allocated contiguously to store
|
|
* Asynchronous(async) error information followed by the Synchronous(sync)
|
|
* error information. HV has write access and the VM has read access to this
|
|
* shared memory. The shared memory layout looks like:
|
|
*
|
|
* |--async-err-metadata--|--async-errors-array-|--sync-errors-array-|
|
|
*
|
|
* Size of async errors array = Max errors + 1(to avoid same empty and full
|
|
* conditions of the buffer)
|
|
* Size of sync errors array = 1 error per VCPU * number of VCPUs on a VM
|
|
*
|
|
* So for a give VM, shared memory has:
|
|
*
|
|
* |--------ASyncErrInfo--------------|---------SyncErrInfo-------------------|
|
|
* |--------1bufferPerVM--------------|---VCpu0-buffer----|---VCpuN-buffer----|
|
|
* |---metadata---|---err_data--------|-metadata+err_data-|-metadata+err_data-|
|
|
* |rd_idx|wr_idx|-Err1-|-Err2-|-ErrN-|-is_filled-|-Err1--|-is_filled-|--Err1-|
|
|
*/
|
|
|
|
struct __attribute__((__packed__)) err_info_t {
|
|
struct async_metadata_t async_metadata;
|
|
struct err_data_t err_data[];
|
|
};
|
|
|
|
#endif
|