/alps/pcitool

#define _GNU_SOURCE

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <stdlib.h>

#include <views/register.h>

#include "pci.h"

#include "bank.h"

#include "view.h"

#include "register.h"

#include "property.h"

#include "tools.h"

#include "error.h"

int pcilib_add_registers_from_properties(pcilib_t *ctx, size_t n, pcilib_view_context_t* const *view_ctx, pcilib_view_description_t* const *v) {

    int err;

    pcilib_view_t i;

    pcilib_register_t pos = 0;

    pcilib_register_description_t regs[n];

    int access;

    pcilib_register_bank_t bank;

    bank = pcilib_find_register_bank_by_addr(ctx, pcilib_property_register_bank.addr);

    if (bank == PCILIB_REGISTER_BANK_INVALID) {

        err = pcilib_add_register_banks(ctx, 0, 1, &pcilib_property_register_bank, &bank);

        if (err) {

            pcilib_error("Error (%i) adding register bank (%s)", err, pcilib_property_register_bank.name);

            return err;

        }

    }

    access = ctx->banks[bank].access / 8;

    for (i = 0; i < n; i++) {

        if ((v[i]->flags&PCILIB_VIEW_FLAG_REGISTER) == 0) continue;

        regs[pos++] = (pcilib_register_description_t){

            .addr = view_ctx[i]->view * access,

            .bits = 8 * sizeof(pcilib_register_value_t),

            .mode = v[i]->mode,

            .type = PCILIB_REGISTER_PROPERTY,

            .bank = PCILIB_REGISTER_BANK_PROPERTY,

            .name = (v[i]->regname?v[i]->regname:v[i]->name),

            .description = v[i]->description

        };

    }

    if (pos)

        return pcilib_add_registers(ctx, 0, pos, regs, NULL);

    return 0;

}

int pcilib_add_properties_from_registers(pcilib_t *ctx, size_t n, const pcilib_register_bank_t *banks, const pcilib_register_description_t *registers) {

    int err;

    pcilib_register_t i;

    pcilib_view_t cur_view = ctx->num_views;

    if (!n) 

        return PCILIB_ERROR_INVALID_ARGUMENT;

    for (i = 0; i < n; i++) {

        char *view_name;

        pcilib_access_mode_t mode = 0;

        pcilib_register_view_description_t v = {{0}};

        pcilib_register_bank_description_t *b = &ctx->banks[banks[i]];

        if (registers[i].type == PCILIB_REGISTER_PROPERTY) continue;

        view_name = malloc(strlen(registers[i].name) + strlen(b->name) + 13);

        if (!view_name) {

            pcilib_clean_views(ctx, cur_view);

            return PCILIB_ERROR_MEMORY;

        }

        sprintf(view_name, "/registers/%s/%s", b->name, registers[i].name);

        if ((registers[i].views)&&(registers[i].views[0].view)) {

            pcilib_view_t view = pcilib_find_view_by_name(ctx, registers[i].views[0].view);

            if (view == PCILIB_VIEW_INVALID) return PCILIB_ERROR_NOTFOUND;

            memcpy(&v, ctx->views[view], sizeof(pcilib_view_description_t));

            v.view = registers[i].views[0].name;

            if (ctx->views[view]->api->read_from_reg) mode |= PCILIB_ACCESS_R;

            if (ctx->views[view]->api->write_to_reg) mode |= PCILIB_ACCESS_W;

            mode &= ctx->views[view]->mode;

        } else {

            v.base.type = PCILIB_TYPE_LONG;

            mode = PCILIB_ACCESS_RW;

        }

        v.base.api = &pcilib_register_view_api;

        v.base.name = view_name;

        v.base.description = registers[i].description;

        v.base.mode = registers[i].mode&mode;

        v.base.flags |= PCILIB_VIEW_FLAG_PROPERTY;

        v.reg = registers[i].name;

        v.bank = b->name;

        err = pcilib_add_views(ctx, 1, (pcilib_view_description_t*)&v);

        if (err) {

            free(view_name);

            pcilib_clean_views(ctx, cur_view);

            return err;

        }

/*

        pcilib_view_context_t *view_ctx = pcilib_find_view_context_by_name(ctx, v.base.name);

        view_ctx->flags |= PCILIB_VIEW_FLAG_PROPERTY;

*/

    }

    return 0;

}

pcilib_property_info_t *pcilib_get_property_list(pcilib_t *ctx, const char *branch, pcilib_list_flags_t flags) {

    int err = 0;

    size_t pos = 0;

    size_t name_offset = 0;

    pcilib_view_context_t *view_ctx, *view_tmp;

    pcilib_property_info_t *info = (pcilib_property_info_t*)malloc((ctx->num_views + 1) * sizeof(pcilib_property_info_t));

    struct dir_hash_s {

        char *name;

        UT_hash_handle hh;

    } *dir_hash = NULL, *dir, *dir_tmp;

    if (branch) {

        name_offset = strlen(branch);

        if (branch[name_offset - 1] != '/') name_offset++;

    }

        // Find all folders

    HASH_ITER(hh, ctx->view_hash, view_ctx, view_tmp) {

        const pcilib_view_description_t *v = ctx->views[view_ctx->view];

        const char *subname = v->name + name_offset;

        const char *suffix;

        if (!(v->flags&PCILIB_VIEW_FLAG_PROPERTY)) continue;

        if ((branch)&&(strncasecmp(branch, v->name, strlen(branch)))) continue;

        suffix = strchr(subname, '/');

        if (suffix) {

            char *name = strndup(v->name, suffix - v->name);

            if (!name) {

                err = PCILIB_ERROR_MEMORY;

                break;

            }

            HASH_FIND_STR(dir_hash, name + name_offset, dir);

            if (dir) {

                free(name);

                continue;

            }

            dir = (struct dir_hash_s*)malloc(sizeof(struct dir_hash_s));

            if (!dir) {

                err = PCILIB_ERROR_MEMORY;

                break;

            }

            dir->name = name;

            HASH_ADD_KEYPTR(hh, dir_hash, dir->name + name_offset, strlen(dir->name + name_offset), dir);

        }

    }

    HASH_ITER(hh, ctx->view_hash, view_ctx, view_tmp) {

        const pcilib_view_description_t *v = ctx->views[view_ctx->view];

        const char *subname = v->name + name_offset;

        if (!(v->flags&PCILIB_VIEW_FLAG_PROPERTY)) continue;

        if ((branch)&&(strncasecmp(branch, v->name, strlen(branch)))) continue;

        if (!strchr(subname, '/')) {

            pcilib_view_context_t *found_view;

            char *path = strdup(v->name);

            if (!path) {

                err = PCILIB_ERROR_MEMORY;

                break;

            }

            char *name = strrchr(v->name, '/');

            if (name) name++;

            else name = path;

            HASH_FIND_STR(dir_hash, name, found_view);

            info[pos++] = (pcilib_property_info_t) {

                .name = name,

                .path = path,

                .description = v->description,

                .type = v->type,

                .mode = v->mode,

                .unit = v->unit,

                .flags = (found_view?PCILIB_LIST_FLAG_CHILDS:0)

            };

            if (found_view) HASH_DEL(dir_hash, found_view);

        }

    }

    HASH_ITER(hh, dir_hash, dir, dir_tmp) {

        char *name = strrchr(dir->name, '/');

        if (name) name++;

        else name = dir->name;

        info[pos++] = (pcilib_property_info_t) {

            .name = name,

            .path = dir->name,

            .type = PCILIB_TYPE_INVALID,

            .flags = PCILIB_LIST_FLAG_CHILDS

        };

    }

    HASH_ITER(hh, dir_hash, dir, dir_tmp) {

	HASH_DEL(dir_hash, dir);

	free(dir);

    }

    HASH_CLEAR(hh, dir_hash);

    memset(&info[pos], 0, sizeof(pcilib_property_info_t));

    if (err) {

        pcilib_free_property_info(ctx, info);

        return NULL;

    }

    return info;

}

void pcilib_free_property_info(pcilib_t *ctx, pcilib_property_info_t *info) {

    int i;

    for (i = 0; info[i].path; i++)

        free((char*)info[i].path);

    free(info);

}

int pcilib_get_property(pcilib_t *ctx, const char *prop, pcilib_value_t *val) {

    return pcilib_read_register_view(ctx, NULL, NULL, prop, val);

}

int pcilib_set_property(pcilib_t *ctx, const char *prop, const pcilib_value_t *val) {

    return pcilib_write_register_view(ctx, NULL, NULL, prop, val);

}

int pcilib_get_property_attr(pcilib_t *ctx, const char *prop, const char *attr, pcilib_value_t *val) {

    pcilib_view_context_t *view_ctx;

    view_ctx = pcilib_find_view_context_by_name(ctx, prop);

    if (!view_ctx) {

        pcilib_error("The specified property (%s) is not found", prop);

        return PCILIB_ERROR_NOTFOUND;

    }

    if (!view_ctx->xml) return PCILIB_ERROR_NOTFOUND;

    return pcilib_get_xml_attr(ctx, view_ctx->xml, attr, val);

}