Node* makeData(enum NodeType type, const char* string)
{
switch(type)
{
case Node_STRING:
{
const char* start, *end;
start = string+1;
end = string+strlen(string)-1;
Node* ret = (Node*)alloc_resource(sizeof(Node) + (end-start)+1);
ret->type = type;
strncpy(ret->payload, start, end-start);
ret->payload[end-start] = 0;
return ret;
}
case Node_INTEGER:
case Node_TOKEN:
case Node_IDENTIFIER:
{
const char* start, *end;
start = string;
end = string+strlen(string);
Node* ret = (Node*)alloc_resource(sizeof(Node) + (end-start)+1);
ret->type = type;
strncpy(ret->payload, start, end-start);
ret->payload[end-start] = 0;
return ret;
}
default:
printf("Node fail: %d\n", type);
return 0;
}
}
void init_map(Map* map)
{
map->key_list = alloc_resource(sizeof(List));
map->val_list = alloc_resource(sizeof(List));
init_list(map->key_list);
init_list(map->val_list);
}
int create_graph(FILE* input)
{
yylex_destroy();
__click_modules = alloc_resource(sizeof(List));
__click_symbol_table = alloc_resource(sizeof(Map));
__click_edges = alloc_resource(sizeof(List));
init_list(__click_modules);
init_map(__click_symbol_table);
init_list(__click_edges);
yyset_in(input);
int ret = yyparse();
yylex_destroy();
int k;
for(k=0; k<__click_modules->len; k++)
{
Node* node = (Node*)__click_modules->list[k];
assert(node->type == Node_MODULE);
Module* module = (Module*)node->payload;
printf("%s::\t", module->name->payload);
ArgList* arglist = (ArgList*)module->args->payload;
int j;
for(j=0; j<arglist->len; j++)
{
Node* eacharg = (Node*)arglist->list[j];
if(eacharg == NULL)
{
printf("NULL ");
}
else if(eacharg->type == Node_VALUE_LIST)
{
ValueList* valuelist = (ValueList*)eacharg->payload;
int i;
for(i=0; i<valuelist->len; i++)
{
Node* eachval = (Node*)valuelist->list[i];
printf("%s ", eachval->payload);
}
printf(", ");
}
else
{
assert(0);
}
}
printf("\n");
}
clear_resource();
__click_modules = 0;
__click_symbol_table = 0;
__click_edges = 0;
return ret;
}
bool DictList::load_list(FILE *fp) {
if (NULL == fp)
return false;
initialized_ = false;
if (fread(&scis_num_, sizeof(uint32), 1, fp) != 1)
return false;
if (fread(start_pos_, sizeof(uint32), kMaxLemmaSize + 1, fp) !=
kMaxLemmaSize + 1)
return false;
if (fread(start_id_, sizeof(uint32), kMaxLemmaSize + 1, fp) !=
kMaxLemmaSize + 1)
return false;
free_resource();
if (!alloc_resource(start_pos_[kMaxLemmaSize], scis_num_))
return false;
if (fread(scis_hz_, sizeof(char16), scis_num_, fp) != scis_num_)
return false;
if (fread(scis_splid_, sizeof(SpellingId), scis_num_, fp) != scis_num_)
return false;
if (fread(buf_, sizeof(char16), start_pos_[kMaxLemmaSize], fp) !=
start_pos_[kMaxLemmaSize])
return false;
initialized_ = true;
return true;
}
static void amdgpu_cs_vce_destroy(void)
{
int len, r;
num_resources = 0;
alloc_resource(&enc.fb[0], 4096, AMDGPU_GEM_DOMAIN_GTT);
resources[num_resources++] = enc.fb[0].handle;
resources[num_resources++] = ib_handle;
len = 0;
memcpy(ib_cpu, vce_session, sizeof(vce_session));
len += sizeof(vce_session) / 4;
memcpy((ib_cpu + len), vce_taskinfo, sizeof(vce_taskinfo));
ib_cpu[len + 3] = 1;
len += sizeof(vce_taskinfo) / 4;
memcpy((ib_cpu + len), vce_feedback, sizeof(vce_feedback));
ib_cpu[len + 2] = enc.fb[0].addr >> 32;
ib_cpu[len + 3] = enc.fb[0].addr;
len += sizeof(vce_feedback) / 4;
memcpy((ib_cpu + len), vce_destroy, sizeof(vce_destroy));
len += sizeof(vce_destroy) / 4;
r = submit(len, AMDGPU_HW_IP_VCE);
CU_ASSERT_EQUAL(r, 0);
free_resource(&enc.fb[0]);
}
bool DictList::init_list(const SingleCharItem *scis, size_t scis_num,
const LemmaEntry *lemma_arr, size_t lemma_num) {
if (NULL == scis || 0 == scis_num || NULL == lemma_arr || 0 == lemma_num)
return false;
initialized_ = false;
if (NULL != buf_)
free(buf_);
// calculate the size
size_t buf_size = calculate_size(lemma_arr, lemma_num);
if (0 == buf_size)
return false;
if (!alloc_resource(buf_size, scis_num))
return false;
fill_scis(scis, scis_num);
// Copy the related content from the array to inner buffer
fill_list(lemma_arr, lemma_num);
initialized_ = true;
return true;
}
static void __init
mcpcia_new_hose(int h)
{
struct pci_controller *hose;
struct resource *io, *mem, *hae_mem;
int mid = MCPCIA_HOSE2MID(h);
hose = alloc_pci_controller();
if (h == 0)
pci_isa_hose = hose;
io = alloc_resource();
mem = alloc_resource();
hae_mem = alloc_resource();
hose->io_space = io;
hose->mem_space = hae_mem;
hose->sparse_mem_base = MCPCIA_SPARSE(mid) - IDENT_ADDR;
hose->dense_mem_base = MCPCIA_DENSE(mid) - IDENT_ADDR;
hose->sparse_io_base = MCPCIA_IO(mid) - IDENT_ADDR;
hose->dense_io_base = 0;
hose->config_space_base = MCPCIA_CONF(mid);
hose->index = h;
io->start = MCPCIA_IO(mid) - MCPCIA_IO_BIAS;
io->end = io->start + 0xffff;
io->name = pci_io_names[h];
io->flags = IORESOURCE_IO;
mem->start = MCPCIA_DENSE(mid) - MCPCIA_MEM_BIAS;
mem->end = mem->start + 0xffffffff;
mem->name = pci_mem_names[h];
mem->flags = IORESOURCE_MEM;
hae_mem->start = mem->start;
hae_mem->end = mem->start + MCPCIA_MEM_MASK;
hae_mem->name = pci_hae0_name;
hae_mem->flags = IORESOURCE_MEM;
if (request_resource(&ioport_resource, io) < 0)
printk(KERN_ERR "Failed to request IO on hose %d\n", h);
if (request_resource(&iomem_resource, mem) < 0)
printk(KERN_ERR "Failed to request MEM on hose %d\n", h);
if (request_resource(mem, hae_mem) < 0)
printk(KERN_ERR "Failed to request HAE_MEM on hose %d\n", h);
}
void add_map(Map* map, const void* key, int keylen, void* item)
{
assert(0 == find_map(map, key, keylen));
Key* new_key = alloc_resource(sizeof(Key) + keylen);
memcpy(new_key->data, key, keylen);
new_key->keylen = keylen;
add_list(map->key_list, new_key);
add_list(map->val_list, item);
}
void add_list(List* list, void* item)
{
list->list[list->len++] = item;
if(list->len == list->capacity)
{
list->capacity = list->capacity*2;
void** new_list = (void**)alloc_resource(sizeof(void*) * list->capacity);
memcpy(new_list, list->list, sizeof(void*)*list->len);
//free(list->list);
list->list = new_list;
}
}
static acpi_status
add_window (struct acpi_resource *res, void *data)
{
struct pci_root_info *info = (struct pci_root_info *) data;
struct pci_window *window;
struct acpi_resource_address64 addr;
acpi_status status;
unsigned long flags, offset = 0;
struct resource *root;
status = acpi_resource_to_address64(res, &addr);
if (ACPI_SUCCESS(status)) {
if (!addr.address_length)
return AE_OK;
if (addr.resource_type == ACPI_MEMORY_RANGE) {
flags = IORESOURCE_MEM;
root = &iomem_resource;
offset = addr.address_translation_offset;
} else if (addr.resource_type == ACPI_IO_RANGE) {
flags = IORESOURCE_IO;
root = &ioport_resource;
offset = add_io_space(&addr);
if (offset == ~0)
return AE_OK;
} else
return AE_OK;
window = &info->controller->window[info->controller->windows++];
window->resource.flags |= flags;
window->resource.start = addr.min_address_range;
window->resource.end = addr.max_address_range;
window->offset = offset;
if (alloc_resource(info->name, root, addr.min_address_range + offset,
addr.max_address_range + offset, flags))
printk(KERN_ERR "alloc 0x%lx-0x%lx from %s for %s failed\n",
addr.min_address_range + offset, addr.max_address_range + offset,
root->name, info->name);
}
return AE_OK;
}
static int
gusc_attach(device_t dev)
{
sc_p scp;
void *ih;
scp = device_get_softc(dev);
bzero(scp, sizeof(*scp));
scp->dev = dev;
if (alloc_resource(scp)) {
release_resource(scp);
return (ENXIO);
}
if (scp->irq != NULL)
snd_setup_intr(dev, scp->irq, 0, gusc_intr, scp, &ih);
bus_generic_attach(dev);
return (0);
}
static char* vlist_to_string(ValueList* vlist)
{
int i;
int total_len = 0;
for(i=0; i<vlist->len; i++)
{
Node* eachval = (Node*)vlist->list[i];
total_len += strlen(eachval->payload) + 1;
}
char* ret = (char*)alloc_resource(total_len);
*ret = 0;
for(i=0; i<vlist->len; i++)
{
Node* eachval = (Node*)vlist->list[i];
strcat(ret, eachval->payload);
if((i+1) != vlist->len)
strcat(ret, " ");
}
return ret;
}
void __init pcibios_allocate_resources(void)
{
struct pci_dev *dev;
int idx, disabled;
u16 command;
struct resource *r;
pci_for_each_dev(dev)
{
pci_read_config_word(dev, PCI_COMMAND, &command);
for(idx = 0; idx < 6; idx++)
{
r = &dev->resource[idx];
if(r->parent)
continue;
if(!r->start)
continue;
alloc_resource(dev, idx);
}
}
}
static int
gusc_attach(device_t dev)
{
sc_p scp;
int unit;
void *ih;
scp = device_get_softc(dev);
unit = device_get_unit(dev);
bzero(scp, sizeof(*scp));
scp->dev = dev;
if (alloc_resource(scp)) {
release_resource(scp);
return (ENXIO);
}
if (scp->irq != NULL)
bus_setup_intr(dev, scp->irq, INTR_TYPE_AV, gusc_intr, scp, &ih, NULL);
bus_generic_attach(dev);
return (0);
}
void init_list(List* list)
{
list->list = alloc_resource(sizeof(void*));
list->capacity = 1;
list->len = 0;
}
static int
sbc_attach(device_t dev)
{
char *err = NULL;
struct sbc_softc *scp;
struct sndcard_func *func;
u_int32_t logical_id = isa_get_logicalid(dev);
int flags = device_get_flags(dev);
int f, dh, dl, x, irq, i;
if (!logical_id && (flags & DV_F_DUAL_DMA)) {
bus_set_resource(dev, SYS_RES_DRQ, 1,
flags & DV_F_DRQ_MASK, 1);
}
scp = device_get_softc(dev);
bzero(scp, sizeof(*scp));
scp->dev = dev;
sbc_lockinit(scp);
err = "alloc_resource";
if (alloc_resource(scp)) goto bad;
err = "sb_reset_dsp";
if (sb_reset_dsp(scp->io[0])) goto bad;
err = "sb_identify_board";
scp->bd_ver = sb_identify_board(scp->io[0]) & 0x00000fff;
if (scp->bd_ver == 0) goto bad;
f = 0;
if (logical_id == 0x01200000 && scp->bd_ver < 0x0400) scp->bd_ver = 0x0499;
switch ((scp->bd_ver & 0x0f00) >> 8) {
case 1: /* old sound blaster has nothing... */
break;
case 2:
f |= BD_F_DUP_MIDI;
if (scp->bd_ver > 0x200) f |= BD_F_MIX_CT1335;
break;
case 5:
f |= BD_F_ESS;
scp->bd_ver = 0x0301;
case 3:
f |= BD_F_DUP_MIDI | BD_F_MIX_CT1345;
break;
case 4:
f |= BD_F_SB16 | BD_F_MIX_CT1745;
if (scp->drq[0]) dl = rman_get_start(scp->drq[0]); else dl = -1;
if (scp->drq[1]) dh = rman_get_start(scp->drq[1]); else dh = dl;
if (!logical_id && (dh < dl)) {
struct resource *r;
r = scp->drq[0];
scp->drq[0] = scp->drq[1];
scp->drq[1] = r;
dl = rman_get_start(scp->drq[0]);
dh = rman_get_start(scp->drq[1]);
}
/* soft irq/dma configuration */
x = -1;
irq = rman_get_start(scp->irq[0]);
#ifdef PC98
/* SB16 in PC98 use different IRQ table */
if (irq == 3) x = 1;
else if (irq == 5) x = 8;
else if (irq == 10) x = 2;
else if (irq == 12) x = 4;
if (x == -1) {
err = "bad irq (3/5/10/12 valid)";
goto bad;
}
else sb_setmixer(scp->io[0], IRQ_NR, x);
/* SB16 in PC98 use different dma setting */
sb_setmixer(scp->io[0], DMA_NR, dh == 0 ? 1 : 2);
#else
if (irq == 5) x = 2;
else if (irq == 7) x = 4;
else if (irq == 9) x = 1;
else if (irq == 10) x = 8;
if (x == -1) {
err = "bad irq (5/7/9/10 valid)";
goto bad;
}
else sb_setmixer(scp->io[0], IRQ_NR, x);
sb_setmixer(scp->io[0], DMA_NR, (1 << dh) | (1 << dl));
#endif
if (bootverbose) {
device_printf(dev, "setting card to irq %d, drq %d", irq, dl);
if (dl != dh) printf(", %d", dh);
printf("\n");
}
break;
}
switch (logical_id) {
case 0x43008c0e: /* CTL0043 */
case 0x01200000:
case 0x01000000:
f |= BD_F_SB16X;
break;
}
scp->bd_ver |= f << 16;
err = "setup_intr";
for (i = 0; i < IRQ_MAX; i++) {
scp->ihl[i].parent = scp;
if (snd_setup_intr(dev, scp->irq[i], 0, sbc_intr, &scp->ihl[i], &scp->ih[i]))
goto bad;
}
/* PCM Audio */
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
if (func == NULL) goto bad;
func->func = SCF_PCM;
scp->child_pcm = device_add_child(dev, "pcm", -1);
device_set_ivars(scp->child_pcm, func);
/* Midi Interface */
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
if (func == NULL) goto bad;
func->func = SCF_MIDI;
scp->child_midi1 = device_add_child(dev, "midi", -1);
device_set_ivars(scp->child_midi1, func);
/* OPL FM Synthesizer */
func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
if (func == NULL) goto bad;
func->func = SCF_SYNTH;
scp->child_midi2 = device_add_child(dev, "midi", -1);
device_set_ivars(scp->child_midi2, func);
/* probe/attach kids */
bus_generic_attach(dev);
return (0);
bad: if (err) device_printf(dev, "%s\n", err);
release_resource(scp);
return (ENXIO);
}
ParseInfo* click_parse_configuration(FILE* input, ClickAllocator alloc, ClickLinker link, void* obj)
{
ParseInfo* ret = 0;
yylex_destroy();
__click_modules = alloc_resource(sizeof(List));
__click_symbol_table = alloc_resource(sizeof(Map));
__click_edges = alloc_resource(sizeof(List));
init_list(__click_modules);
init_map(__click_symbol_table);
init_list(__click_edges);
yyset_in(input);
int parse_result = yyparse();
yylex_destroy();
if(parse_result == 0)
{
int no_modules = __click_modules->len;
ret = malloc(sizeof(ParseInfo));
ret->all_modules = malloc(sizeof(void*)*no_modules);
ret->root_modules = malloc(sizeof(void*)*no_modules);
ret->leaf_modules = malloc(sizeof(void*)*no_modules);
ret->no_modules = no_modules;
ret->no_root = 0;
ret->no_leaf = 0;
int k;
for(k=0; k<no_modules; k++)
{
Node* node = (Node*)__click_modules->list[k];
assert(node->type == Node_MODULE);
Module* module = (Module*)node->payload;
char* module_name = module->name->payload;
assert(module->args->type == Node_ARG_LIST);
ArgList* arglist = (ArgList*)module->args->payload;
char** argv = alloc_resource(sizeof(char*) * (arglist->len + 1));
argv[arglist->len] = 0;
int argc = arglist->len;
int j;
for(j=0; j<arglist->len; j++)
{
Node* eacharg = (Node*)arglist->list[j];
char* value_str = 0;
if(eacharg == NULL)
{
}
else if(eacharg->type == Node_VALUE_LIST)
{
ValueList* valuelist = (ValueList*)eacharg->payload;
value_str = vlist_to_string(valuelist);
}
else
{
assert(0);
}
argv[j] = value_str;
}
void* user_module = 0;
if(alloc)
user_module = alloc(k, module_name, argc, argv, obj);
ret->all_modules[k] = user_module;
}
int* inward = alloc_resource(sizeof(int)*no_modules);
int* outward = alloc_resource(sizeof(int)*no_modules);
for(k=0; k<no_modules; k++)
{
inward[k] = 0;
outward[k] = 0;
}
for(k=0; k<__click_edges->len; k++)
{
Chain* edge = (Chain*)__click_edges->list[k];
assert(edge->head->type == Node_MODULE);
assert(edge->tail->type == Node_MODULE);
Module* head = (Module*)edge->head->payload;
Module* tail = (Module*)edge->tail->payload;
if(link)
link(ret->all_modules[head->index], edge->head_outport, ret->all_modules[tail->index], edge->tail_inport, obj);
inward[tail->index]++;
outward[head->index]++;
}
for(k=0; k<no_modules; k++)
{
if(inward[k] == 0)
{
ret->root_modules[ret->no_root++] = ret->all_modules[k];
}
if(outward[k] == 0)
{
ret->leaf_modules[ret->no_leaf++] = ret->all_modules[k];
}
}
}
clear_resource();
__click_modules = 0;
__click_symbol_table = 0;
__click_edges = 0;
return ret;
}
static void amdgpu_cs_vce_encode(void)
{
uint32_t vbuf_size, bs_size = 0x154000, cpb_size;
int r;
vbuf_size = enc.width * enc.height * 1.5;
cpb_size = vbuf_size * 10;
num_resources = 0;
alloc_resource(&enc.fb[0], 4096, AMDGPU_GEM_DOMAIN_GTT);
resources[num_resources++] = enc.fb[0].handle;
alloc_resource(&enc.fb[1], 4096, AMDGPU_GEM_DOMAIN_GTT);
resources[num_resources++] = enc.fb[1].handle;
alloc_resource(&enc.bs[0], bs_size, AMDGPU_GEM_DOMAIN_GTT);
resources[num_resources++] = enc.bs[0].handle;
alloc_resource(&enc.bs[1], bs_size, AMDGPU_GEM_DOMAIN_GTT);
resources[num_resources++] = enc.bs[1].handle;
alloc_resource(&enc.vbuf, vbuf_size, AMDGPU_GEM_DOMAIN_VRAM);
resources[num_resources++] = enc.vbuf.handle;
alloc_resource(&enc.cpb, cpb_size, AMDGPU_GEM_DOMAIN_VRAM);
resources[num_resources++] = enc.cpb.handle;
resources[num_resources++] = ib_handle;
r = amdgpu_bo_cpu_map(enc.vbuf.handle, (void **)&enc.vbuf.ptr);
CU_ASSERT_EQUAL(r, 0);
memcpy(enc.vbuf.ptr, frame, sizeof(frame));
r = amdgpu_bo_cpu_unmap(enc.vbuf.handle);
CU_ASSERT_EQUAL(r, 0);
amdgpu_cs_vce_config();
if (family_id >= AMDGPU_FAMILY_VI) {
vce_taskinfo[3] = 3;
amdgpu_cs_vce_encode_idr(&enc);
amdgpu_cs_vce_encode_p(&enc);
check_result(&enc);
/* two pipes */
vce_encode[16] = 0;
amdgpu_cs_vce_encode_idr(&enc);
amdgpu_cs_vce_encode_p(&enc);
check_result(&enc);
/* two instances */
enc.two_instance = true;
vce_taskinfo[2] = 0x83;
vce_taskinfo[4] = 1;
amdgpu_cs_vce_encode_idr(&enc);
vce_taskinfo[2] = 0xffffffff;
vce_taskinfo[4] = 2;
amdgpu_cs_vce_encode_p(&enc);
check_result(&enc);
} else {
vce_taskinfo[3] = 3;
vce_encode[16] = 0;
amdgpu_cs_vce_encode_idr(&enc);
amdgpu_cs_vce_encode_p(&enc);
check_result(&enc);
}
free_resource(&enc.fb[0]);
free_resource(&enc.fb[1]);
free_resource(&enc.bs[0]);
free_resource(&enc.bs[1]);
free_resource(&enc.vbuf);
free_resource(&enc.cpb);
}
