/*
* Callback with config info. Assume that only one TLV comes in, carrying
* the response to earlier conf read request. Copy in all the data to
* current table being read. You might also get an error TLV as response
* in a NAK.
*/
static void conf_rsp_cb(void *buf, size_t rlen)
{
struct ayla_cmd *cmd;
struct ayla_tlv *tlv;
size_t tlen;
cmd = buf;
rlen -= sizeof(*cmd);
tlv = (struct ayla_tlv *)(cmd + 1);
while (rlen > sizeof(*tlv)) {
tlen = sizeof(*tlv) + tlv->len;
if (tlen > rlen) {
copy_val(NULL, tlv->type, -1);
break;
}
if (tlv->type != ATLV_CONF) {
copy_val(tlv + 1, tlv->type, tlv->len);
cur_idx++;
conf_read_next_tbl();
return;
}
rlen -= tlen;
tlv = (struct ayla_tlv *)((char *)tlv + tlen);
}
copy_val(NULL, ATLV_ERR, 0);
cur_idx++;
conf_read_next_tbl();
}
/* reg must be MAX_ADDR_CELLS */
static int find_range(u32 *reg, u32 *ranges, int nregaddr,
int naddr, int nsize, int buflen)
{
int nrange = nregaddr + naddr + nsize;
int i;
for (i = 0; i + nrange <= buflen; i += nrange) {
u32 range_addr[MAX_ADDR_CELLS];
u32 range_size[MAX_ADDR_CELLS];
copy_val(range_addr, ranges + i, naddr);
copy_val(range_size, ranges + i + nregaddr + naddr, nsize);
if (compare_reg(reg, range_addr, range_size))
return i;
}
return -1;
}
int main(void)
{
int ar[NUM];
copy_val(ar,NUM,RANGE);
show_ar(ar,NUM);
putchar('\n');
putchar('\n');
sort_ar(ar,NUM);
show_ar(ar,NUM);
putchar('\n');
putchar('\n');
printf("%d", ar[100]);
return 0;
}
static int dt_xlate(void *node, int res, int reglen, unsigned long *addr,
unsigned long *size)
{
u32 last_addr[MAX_ADDR_CELLS];
u32 this_addr[MAX_ADDR_CELLS];
void *parent;
u64 ret_addr, ret_size;
u32 naddr, nsize, prev_naddr, prev_nsize;
int buflen, offset;
parent = get_parent(node);
if (!parent)
return 0;
dt_get_reg_format(parent, &naddr, &nsize);
if (nsize > 2)
return 0;
offset = (naddr + nsize) * res;
if (reglen < offset + naddr + nsize ||
MAX_PROP_LEN < (offset + naddr + nsize) * 4)
return 0;
copy_val(last_addr, prop_buf + offset, naddr);
ret_size = prop_buf[offset + naddr];
if (nsize == 2) {
ret_size <<= 32;
ret_size |= prop_buf[offset + naddr + 1];
}
for (;;) {
prev_naddr = naddr;
prev_nsize = nsize;
node = parent;
parent = get_parent(node);
if (!parent)
break;
dt_get_reg_format(parent, &naddr, &nsize);
buflen = getprop(node, "ranges", prop_buf,
sizeof(prop_buf));
if (buflen == 0)
continue;
if (buflen < 0 || buflen > sizeof(prop_buf))
return 0;
offset = find_range(last_addr, prop_buf, prev_naddr,
naddr, prev_nsize, buflen / 4);
if (offset < 0)
return 0;
copy_val(this_addr, prop_buf + offset, prev_naddr);
if (!sub_reg(last_addr, this_addr))
return 0;
copy_val(this_addr, prop_buf + offset + prev_naddr, naddr);
if (!add_reg(last_addr, this_addr, naddr))
return 0;
}
if (naddr > 2)
return 0;
ret_addr = ((u64)last_addr[2] << 32) | last_addr[3];
if (sizeof(void *) == 4 &&
(ret_addr >= 0x100000000ULL || ret_size > 0x100000000ULL ||
ret_addr + ret_size > 0x100000000ULL))
return 0;
*addr = ret_addr;
if (size)
*size = ret_size;
return 1;
}
int main()
{
int att_array[3];
int i = 0;
TransactionManager transact_val1;
dct_tree *tree_val = NULL;
dct_tree *tree_val2 = NULL;
dct_tree *tree_val3 = NULL;
dct_node *temp = NULL;
tree_val = build_dcttree(3);
tree_val3 = build_dcttree(3);
att_array[0] = 1;
att_array[1] = 2;
att_array[2] = 3;
try
{
insert_val(att_array, tree_val, transact_val1);
insert_val(att_array, tree_val3, transact_val1);
//throw -1;
transact_val1.commit_transaction();
tree_val2 = copy_val((tree_val->getdummy()), (tree_val->getnumber_of_nodes()));
}catch (int e)
{
cout<<"exception caught"<<" "<<e<<endl;
return 1;
}
//att_array[2] = 3;
if (search_val(att_array, tree_val))
{
cout<<"All values found"<<endl;
}
else
{
cout<<"All values not found"<<endl;
}
temp = search_val(att_array, tree_val2);
if (temp != NULL)
{
cout<<" All values found copy tree"<<endl;
}
else
{
cout<<"All values not found copy tree"<<endl;
}
if (search_val(att_array, tree_val3))
{
cout<<"All values found3"<<endl;
}
else
{
cout<<"All values not found3"<<endl;
}
delete tree_val;
delete tree_val2;
delete tree_val3;
delete temp;
}
