const struct slca_entry *slca_get_entry(uint16_t slca_index)
{
struct HDIF_common_hdr *slca_hdr;
int count;
slca_hdr = get_hdif(&spira.ntuples.slca, SLCA_HDIF_SIG);
if (!slca_hdr) {
prerror("SLCA Invalid\n");
return NULL;
}
count = HDIF_get_iarray_size(slca_hdr, SLCA_IDATA_ARRAY);
if (count < 0) {
prerror("SLCA: Can't find SLCA array size!\n");
return NULL;
}
if (slca_index < count) {
const struct slca_entry *s_entry;
unsigned int entry_sz;
s_entry = HDIF_get_iarray_item(slca_hdr, SLCA_IDATA_ARRAY,
slca_index, &entry_sz);
if (s_entry && entry_sz >= sizeof(*s_entry))
return s_entry;
} else
prlog(PR_NOTICE,
"SLCA: Can't find slca_entry for index %d\n", slca_index);
return NULL;
}
static bool __memory_parse(struct dt_node *root)
{
struct HDIF_common_hdr *ms_vpd;
const struct msvpd_ms_addr_config *msac;
const struct msvpd_total_config_ms *tcms;
unsigned int size;
ms_vpd = get_hdif(&spira.ntuples.ms_vpd, MSVPD_HDIF_SIG);
if (!ms_vpd) {
prerror("MS VPD: invalid\n");
op_display(OP_FATAL, OP_MOD_MEM, 0x0000);
return false;
}
if (be32_to_cpu(spira.ntuples.ms_vpd.act_len) < sizeof(*ms_vpd)) {
prerror("MS VPD: invalid size %u\n",
be32_to_cpu(spira.ntuples.ms_vpd.act_len));
op_display(OP_FATAL, OP_MOD_MEM, 0x0001);
return false;
}
prlog(PR_DEBUG, "MS VPD: is at %p\n", ms_vpd);
msac = HDIF_get_idata(ms_vpd, MSVPD_IDATA_MS_ADDR_CONFIG, &size);
if (!CHECK_SPPTR(msac) || size < sizeof(*msac)) {
prerror("MS VPD: bad msac size %u @ %p\n", size, msac);
op_display(OP_FATAL, OP_MOD_MEM, 0x0002);
return false;
}
prlog(PR_DEBUG, "MS VPD: MSAC is at %p\n", msac);
dt_add_property_u64(dt_root, DT_PRIVATE "maxmem",
be64_to_cpu(msac->max_configured_ms_address));
tcms = HDIF_get_idata(ms_vpd, MSVPD_IDATA_TOTAL_CONFIG_MS, &size);
if (!CHECK_SPPTR(tcms) || size < sizeof(*tcms)) {
prerror("MS VPD: Bad tcms size %u @ %p\n", size, tcms);
op_display(OP_FATAL, OP_MOD_MEM, 0x0003);
return false;
}
prlog(PR_DEBUG, "MS VPD: TCMS is at %p\n", tcms);
prlog(PR_DEBUG, "MS VPD: Maximum configured address: 0x%llx\n",
(long long)be64_to_cpu(msac->max_configured_ms_address));
prlog(PR_DEBUG, "MS VPD: Maximum possible address: 0x%llx\n",
(long long)be64_to_cpu(msac->max_possible_ms_address));
get_msareas(root, ms_vpd);
prlog(PR_INFO, "MS VPD: Total MB of RAM: 0x%llx\n",
(long long)be64_to_cpu(tcms->total_in_mb));
return true;
}
/*
* Get System Attention Indicator SLCA entry
*/
static const struct slca_entry *slca_get_sai_entry(void)
{
int count;
unsigned int i;
struct HDIF_common_hdr *slca_hdr;
slca_hdr = get_hdif(&spira.ntuples.slca, SLCA_HDIF_SIG);
if (!slca_hdr) {
prerror("SLCA Invalid\n");
return NULL;
}
count = HDIF_get_iarray_size(slca_hdr, SLCA_IDATA_ARRAY);
if (count < 0) {
prerror("SLCA: Can't find SLCA array size!\n");
return NULL;
}
for (i = 0; i < count; i++) {
const struct slca_entry *s_entry;
unsigned int entry_sz;
s_entry = HDIF_get_iarray_item(slca_hdr, SLCA_IDATA_ARRAY,
i, &entry_sz);
if (s_entry &&
VPD_ID(s_entry->fru_id[0],
s_entry->fru_id[1]) == SLCA_SAI_INDICATOR_ID) {
prlog(PR_TRACE, "SLCA: SAI index: 0x%x\n",
s_entry->my_index);
prlog(PR_TRACE, "SLCA: SAI location code: %s\n",
s_entry->loc_code);
return s_entry;
}
}
return NULL;
}
static unsigned int paca_index(const struct HDIF_common_hdr *paca)
{
void *start = get_hdif(&spira.ntuples.paca, PACA_HDIF_SIG);
return ((void *)paca - start)
/ be32_to_cpu(spira.ntuples.paca.alloc_len);
}
