int fdt_node_check_compatible(const void *fdt, int nodeoffset,
const char *compatible)
{
const void *prop;
int len;
prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
if (!prop)
return len;
return !fdt_stringlist_contains(prop, len, compatible);
}
static int check_type_include(void *priv, int type, const char *data, int size)
{
struct display_info *disp = priv;
struct value_node *val;
int match, none_match = FDT_IS_ANY;
/* If none of our conditions mention this type, we know nothing */
debug("type=%x, data=%s\n", type, data ? data : "(null)");
if (!((disp->types_inc | disp->types_exc) & type)) {
debug(" - not in any condition\n");
return -1;
}
/*
* Go through the list of conditions. For inclusive conditions, we
* return 1 at the first match. For exclusive conditions, we must
* check that there are no matches.
*/
for (val = disp->value_head; val; val = val->next) {
if (!(type & val->type))
continue;
match = fdt_stringlist_contains(data, size, val->string);
debug(" - val->type=%x, str='%s', match=%d\n",
val->type, val->string, match);
if (match && val->include) {
debug(" - match inc %s\n", val->string);
return 1;
}
if (match)
none_match &= ~val->type;
}
/*
* If this is an exclusive condition, and nothing matches, then we
* should return 1.
*/
if ((type & disp->types_exc) && (none_match & type)) {
debug(" - match exc\n");
/*
* Allow FDT_IS_COMPAT to make the final decision in the
* case where there is no specific type
*/
if (type == FDT_IS_NODE && disp->types_exc == FDT_ANY_GLOBAL) {
debug(" - supressed exc node\n");
return -1;
}
return 1;
}
/*
* Allow FDT_IS_COMPAT to make the final decision in the
* case where there is no specific type (inclusive)
*/
if (type == FDT_IS_NODE && disp->types_inc == FDT_ANY_GLOBAL)
return -1;
debug(" - no match, types_inc=%x, types_exc=%x, none_match=%x\n",
disp->types_inc, disp->types_exc, none_match);
return 0;
}
static int unifykey_item_dt_parse(const void* dt_addr,int nodeoffset,int id,char *item_path)
{
struct key_item_t *temp_item=NULL;
char *propdata;
struct fdt_property *prop;
int count;
temp_item = unifykey_item + id;
propdata = (char*)fdt_getprop(dt_addr, nodeoffset, "key-encrypt", NULL);
if (propdata) {
count = strlen(propdata);
if ( count > KEY_UNIFY_TYPE_LEN_MAX ) {
KM_ERR("key-encrypt [%s] too long\n", propdata);
return __LINE__;
}
memcpy(temp_item->encType, propdata, count);
}
propdata = (char*)fdt_getprop(dt_addr, nodeoffset, "key-name",NULL);
if (!propdata) {
printf("%s get key-name fail,%s:%d\n",item_path,__func__,__LINE__);
return __LINE__;
}
count = strlen(propdata);
if (count >= KEY_UNIFY_NAME_LEN) {
KM_ERR("key-name strlen (%d) > max(%d) at key_%d\n", count, KEY_UNIFY_NAME_LEN - 1, id);
return __LINE__;
}
memcpy(temp_item->name, propdata, count);
temp_item->name[count] = 0;
propdata = (char*)fdt_getprop(dt_addr, nodeoffset, "key-device",NULL);
if (!propdata) {
KM_ERR("%s get key-device fail at key_%d\n",item_path, id);
return __LINE__;
}
if (strcmp(propdata,UNIFYKEY_DEVICE_EFUSEKEY) == 0) {
temp_item->dev = KEY_M_EFUSE_NORMAL;
}
else if(strcmp(propdata,UNIFYKEY_DEVICE_SECURESKEY) == 0){
temp_item->dev = KEY_M_SECURE_KEY;
}
else if(strcmp(propdata,UNIFYKEY_DEVICE_NORMAL) == 0){
temp_item->dev = KEY_M_NORAML_KEY;
}
else{
KM_ERR("key-device %s is unknown at key_%d\n", propdata, id);
return __LINE__;
}
propdata = (char*)fdt_getprop((const void *)dt_addr, nodeoffset, "key-type",NULL);
if (!propdata) //prop 'key-type' not configured, default to raw except special names
{
strcpy(temp_item->keyType, "raw");
}
else
{
const int keyTypeLen = strlen(propdata);
if (keyTypeLen > KEY_UNIFY_TYPE_LEN_MAX) {
KM_ERR("key[%s]cfg key-type[%s] sz %d > max %d\n", temp_item->name, propdata, keyTypeLen, KEY_UNIFY_TYPE_LEN_MAX);
return __LINE__;
}
strcpy(temp_item->keyType, propdata);
}
#if 0
propdata = (char*)fdt_getprop((const void *)dt_addr, nodeoffset, "key-dataformat",NULL);
if (!propdata) {
KM_ERR("%s get key-dataformat fail at key_%d\n",item_path, id);
return __LINE__;
}
#endif
prop = (struct fdt_property*)fdt_get_property((const void *)dt_addr,nodeoffset,"key-permit",NULL) ;
if (!prop) {
KM_ERR("%s get key-permit fail at key_%d\n",item_path, id);
return __LINE__;
}
temp_item->permit = 0;
const int propLen = prop->len > 512 ? strnlen(prop->data, 512) : prop->len;
if (fdt_stringlist_contains(prop->data, propLen, UNIFYKEY_PERMIT_READ)) {
temp_item->permit |= KEY_M_PERMIT_READ;
}
if (fdt_stringlist_contains(prop->data, propLen, UNIFYKEY_PERMIT_WRITE)) {
temp_item->permit |= KEY_M_PERMIT_WRITE;
}
if (fdt_stringlist_contains(prop->data, propLen, UNIFYKEY_PERMIT_DEL)) {
temp_item->permit |= KEY_M_PERMIT_DEL;
}
temp_item->id = id;
KM_DBG("key[%02d] keyname %s, %d\n", id, temp_item->name, temp_item->dev);
return 0;
}
