| /* |
| * dbll.c |
| * |
| * DSP-BIOS Bridge driver support functions for TI OMAP processors. |
| * |
| * Copyright (C) 2005-2006 Texas Instruments, Inc. |
| * |
| * This package is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
| * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
| */ |
| #include <linux/types.h> |
| |
| /* ----------------------------------- Host OS */ |
| #include <dspbridge/host_os.h> |
| |
| /* ----------------------------------- DSP/BIOS Bridge */ |
| #include <dspbridge/dbdefs.h> |
| |
| /* ----------------------------------- Trace & Debug */ |
| #include <dspbridge/dbc.h> |
| #include <dspbridge/gh.h> |
| |
| /* ----------------------------------- OS Adaptation Layer */ |
| |
| /* Dynamic loader library interface */ |
| #include <dspbridge/dynamic_loader.h> |
| #include <dspbridge/getsection.h> |
| |
| /* ----------------------------------- This */ |
| #include <dspbridge/dbll.h> |
| #include <dspbridge/rmm.h> |
| |
| /* Number of buckets for symbol hash table */ |
| #define MAXBUCKETS 211 |
| |
| /* Max buffer length */ |
| #define MAXEXPR 128 |
| |
| #define DOFF_ALIGN(x) (((x) + 3) & ~3UL) |
| |
| /* |
| * ======== struct dbll_tar_obj* ======== |
| * A target may have one or more libraries of symbols/code/data loaded |
| * onto it, where a library is simply the symbols/code/data contained |
| * in a DOFF file. |
| */ |
| /* |
| * ======== dbll_tar_obj ======== |
| */ |
| struct dbll_tar_obj { |
| struct dbll_attrs attrs; |
| struct dbll_library_obj *head; /* List of all opened libraries */ |
| }; |
| |
| /* |
| * The following 4 typedefs are "super classes" of the dynamic loader |
| * library types used in dynamic loader functions (dynamic_loader.h). |
| */ |
| /* |
| * ======== dbll_stream ======== |
| * Contains dynamic_loader_stream |
| */ |
| struct dbll_stream { |
| struct dynamic_loader_stream dl_stream; |
| struct dbll_library_obj *lib; |
| }; |
| |
| /* |
| * ======== ldr_symbol ======== |
| */ |
| struct ldr_symbol { |
| struct dynamic_loader_sym dl_symbol; |
| struct dbll_library_obj *lib; |
| }; |
| |
| /* |
| * ======== dbll_alloc ======== |
| */ |
| struct dbll_alloc { |
| struct dynamic_loader_allocate dl_alloc; |
| struct dbll_library_obj *lib; |
| }; |
| |
| /* |
| * ======== dbll_init_obj ======== |
| */ |
| struct dbll_init_obj { |
| struct dynamic_loader_initialize dl_init; |
| struct dbll_library_obj *lib; |
| }; |
| |
| /* |
| * ======== DBLL_Library ======== |
| * A library handle is returned by DBLL_Open() and is passed to dbll_load() |
| * to load symbols/code/data, and to dbll_unload(), to remove the |
| * symbols/code/data loaded by dbll_load(). |
| */ |
| |
| /* |
| * ======== dbll_library_obj ======== |
| */ |
| struct dbll_library_obj { |
| struct dbll_library_obj *next; /* Next library in target's list */ |
| struct dbll_library_obj *prev; /* Previous in the list */ |
| struct dbll_tar_obj *target_obj; /* target for this library */ |
| |
| /* Objects needed by dynamic loader */ |
| struct dbll_stream stream; |
| struct ldr_symbol symbol; |
| struct dbll_alloc allocate; |
| struct dbll_init_obj init; |
| void *dload_mod_obj; |
| |
| char *file_name; /* COFF file name */ |
| void *fp; /* Opaque file handle */ |
| u32 entry; /* Entry point */ |
| void *desc; /* desc of DOFF file loaded */ |
| u32 open_ref; /* Number of times opened */ |
| u32 load_ref; /* Number of times loaded */ |
| struct gh_t_hash_tab *sym_tab; /* Hash table of symbols */ |
| u32 pos; |
| }; |
| |
| /* |
| * ======== dbll_symbol ======== |
| */ |
| struct dbll_symbol { |
| struct dbll_sym_val value; |
| char *name; |
| }; |
| |
| static void dof_close(struct dbll_library_obj *zl_lib); |
| static int dof_open(struct dbll_library_obj *zl_lib); |
| static s32 no_op(struct dynamic_loader_initialize *thisptr, void *bufr, |
| ldr_addr locn, struct ldr_section_info *info, |
| unsigned bytsize); |
| |
| /* |
| * Functions called by dynamic loader |
| * |
| */ |
| /* dynamic_loader_stream */ |
| static int dbll_read_buffer(struct dynamic_loader_stream *this, void *buffer, |
| unsigned bufsize); |
| static int dbll_set_file_posn(struct dynamic_loader_stream *this, |
| unsigned int pos); |
| /* dynamic_loader_sym */ |
| static struct dynload_symbol *dbll_find_symbol(struct dynamic_loader_sym *this, |
| const char *name); |
| static struct dynload_symbol *dbll_add_to_symbol_table(struct dynamic_loader_sym |
| *this, const char *name, |
| unsigned module_id); |
| static struct dynload_symbol *find_in_symbol_table(struct dynamic_loader_sym |
| *this, const char *name, |
| unsigned moduleid); |
| static void dbll_purge_symbol_table(struct dynamic_loader_sym *this, |
| unsigned module_id); |
| static void *allocate(struct dynamic_loader_sym *this, unsigned memsize); |
| static void deallocate(struct dynamic_loader_sym *this, void *mem_ptr); |
| static void dbll_err_report(struct dynamic_loader_sym *this, const char *errstr, |
| va_list args); |
| /* dynamic_loader_allocate */ |
| static int dbll_rmm_alloc(struct dynamic_loader_allocate *this, |
| struct ldr_section_info *info, unsigned align); |
| static void rmm_dealloc(struct dynamic_loader_allocate *this, |
| struct ldr_section_info *info); |
| |
| /* dynamic_loader_initialize */ |
| static int connect(struct dynamic_loader_initialize *this); |
| static int read_mem(struct dynamic_loader_initialize *this, void *buf, |
| ldr_addr addr, struct ldr_section_info *info, |
| unsigned bytes); |
| static int write_mem(struct dynamic_loader_initialize *this, void *buf, |
| ldr_addr addr, struct ldr_section_info *info, |
| unsigned nbytes); |
| static int fill_mem(struct dynamic_loader_initialize *this, ldr_addr addr, |
| struct ldr_section_info *info, unsigned bytes, |
| unsigned val); |
| static int execute(struct dynamic_loader_initialize *this, ldr_addr start); |
| static void release(struct dynamic_loader_initialize *this); |
| |
| /* symbol table hash functions */ |
| static u16 name_hash(void *key, u16 max_bucket); |
| static bool name_match(void *key, void *sp); |
| static void sym_delete(void *value); |
| |
| static u32 refs; /* module reference count */ |
| |
| /* Symbol Redefinition */ |
| static int redefined_symbol; |
| static int gbl_search = 1; |
| |
| /* |
| * ======== dbll_close ======== |
| */ |
| void dbll_close(struct dbll_library_obj *zl_lib) |
| { |
| struct dbll_tar_obj *zl_target; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(zl_lib->open_ref > 0); |
| zl_target = zl_lib->target_obj; |
| zl_lib->open_ref--; |
| if (zl_lib->open_ref == 0) { |
| /* Remove library from list */ |
| if (zl_target->head == zl_lib) |
| zl_target->head = zl_lib->next; |
| |
| if (zl_lib->prev) |
| (zl_lib->prev)->next = zl_lib->next; |
| |
| if (zl_lib->next) |
| (zl_lib->next)->prev = zl_lib->prev; |
| |
| /* Free DOF resources */ |
| dof_close(zl_lib); |
| kfree(zl_lib->file_name); |
| |
| /* remove symbols from symbol table */ |
| if (zl_lib->sym_tab) |
| gh_delete(zl_lib->sym_tab); |
| |
| /* remove the library object itself */ |
| kfree(zl_lib); |
| zl_lib = NULL; |
| } |
| } |
| |
| /* |
| * ======== dbll_create ======== |
| */ |
| int dbll_create(struct dbll_tar_obj **target_obj, |
| struct dbll_attrs *pattrs) |
| { |
| struct dbll_tar_obj *pzl_target; |
| int status = 0; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(pattrs != NULL); |
| DBC_REQUIRE(target_obj != NULL); |
| |
| /* Allocate DBL target object */ |
| pzl_target = kzalloc(sizeof(struct dbll_tar_obj), GFP_KERNEL); |
| if (target_obj != NULL) { |
| if (pzl_target == NULL) { |
| *target_obj = NULL; |
| status = -ENOMEM; |
| } else { |
| pzl_target->attrs = *pattrs; |
| *target_obj = (struct dbll_tar_obj *)pzl_target; |
| } |
| DBC_ENSURE((!status && *target_obj) || |
| (status && *target_obj == NULL)); |
| } |
| |
| return status; |
| } |
| |
| /* |
| * ======== dbll_delete ======== |
| */ |
| void dbll_delete(struct dbll_tar_obj *target) |
| { |
| struct dbll_tar_obj *zl_target = (struct dbll_tar_obj *)target; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_target); |
| |
| kfree(zl_target); |
| |
| } |
| |
| /* |
| * ======== dbll_exit ======== |
| * Discontinue usage of DBL module. |
| */ |
| void dbll_exit(void) |
| { |
| DBC_REQUIRE(refs > 0); |
| |
| refs--; |
| |
| if (refs == 0) |
| gh_exit(); |
| |
| DBC_ENSURE(refs >= 0); |
| } |
| |
| /* |
| * ======== dbll_get_addr ======== |
| * Get address of name in the specified library. |
| */ |
| bool dbll_get_addr(struct dbll_library_obj *zl_lib, char *name, |
| struct dbll_sym_val **sym_val) |
| { |
| struct dbll_symbol *sym; |
| bool status = false; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(name != NULL); |
| DBC_REQUIRE(sym_val != NULL); |
| DBC_REQUIRE(zl_lib->sym_tab != NULL); |
| |
| sym = (struct dbll_symbol *)gh_find(zl_lib->sym_tab, name); |
| if (sym != NULL) { |
| *sym_val = &sym->value; |
| status = true; |
| } |
| |
| dev_dbg(bridge, "%s: lib: %p name: %s paddr: %p, status 0x%x\n", |
| __func__, zl_lib, name, sym_val, status); |
| return status; |
| } |
| |
| /* |
| * ======== dbll_get_attrs ======== |
| * Retrieve the attributes of the target. |
| */ |
| void dbll_get_attrs(struct dbll_tar_obj *target, struct dbll_attrs *pattrs) |
| { |
| struct dbll_tar_obj *zl_target = (struct dbll_tar_obj *)target; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_target); |
| DBC_REQUIRE(pattrs != NULL); |
| |
| if ((pattrs != NULL) && (zl_target != NULL)) |
| *pattrs = zl_target->attrs; |
| |
| } |
| |
| /* |
| * ======== dbll_get_c_addr ======== |
| * Get address of a "C" name in the specified library. |
| */ |
| bool dbll_get_c_addr(struct dbll_library_obj *zl_lib, char *name, |
| struct dbll_sym_val **sym_val) |
| { |
| struct dbll_symbol *sym; |
| char cname[MAXEXPR + 1]; |
| bool status = false; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(sym_val != NULL); |
| DBC_REQUIRE(zl_lib->sym_tab != NULL); |
| DBC_REQUIRE(name != NULL); |
| |
| cname[0] = '_'; |
| |
| strncpy(cname + 1, name, sizeof(cname) - 2); |
| cname[MAXEXPR] = '\0'; /* insure '\0' string termination */ |
| |
| /* Check for C name, if not found */ |
| sym = (struct dbll_symbol *)gh_find(zl_lib->sym_tab, cname); |
| |
| if (sym != NULL) { |
| *sym_val = &sym->value; |
| status = true; |
| } |
| |
| return status; |
| } |
| |
| /* |
| * ======== dbll_get_sect ======== |
| * Get the base address and size (in bytes) of a COFF section. |
| */ |
| int dbll_get_sect(struct dbll_library_obj *lib, char *name, u32 *paddr, |
| u32 *psize) |
| { |
| u32 byte_size; |
| bool opened_doff = false; |
| const struct ldr_section_info *sect = NULL; |
| struct dbll_library_obj *zl_lib = (struct dbll_library_obj *)lib; |
| int status = 0; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(name != NULL); |
| DBC_REQUIRE(paddr != NULL); |
| DBC_REQUIRE(psize != NULL); |
| DBC_REQUIRE(zl_lib); |
| |
| /* If DOFF file is not open, we open it. */ |
| if (zl_lib != NULL) { |
| if (zl_lib->fp == NULL) { |
| status = dof_open(zl_lib); |
| if (!status) |
| opened_doff = true; |
| |
| } else { |
| (*(zl_lib->target_obj->attrs.fseek)) (zl_lib->fp, |
| zl_lib->pos, |
| SEEK_SET); |
| } |
| } else { |
| status = -EFAULT; |
| } |
| if (!status) { |
| byte_size = 1; |
| if (dload_get_section_info(zl_lib->desc, name, §)) { |
| *paddr = sect->load_addr; |
| *psize = sect->size * byte_size; |
| /* Make sure size is even for good swap */ |
| if (*psize % 2) |
| (*psize)++; |
| |
| /* Align size */ |
| *psize = DOFF_ALIGN(*psize); |
| } else { |
| status = -ENXIO; |
| } |
| } |
| if (opened_doff) { |
| dof_close(zl_lib); |
| opened_doff = false; |
| } |
| |
| dev_dbg(bridge, "%s: lib: %p name: %s paddr: %p psize: %p, " |
| "status 0x%x\n", __func__, lib, name, paddr, psize, status); |
| |
| return status; |
| } |
| |
| /* |
| * ======== dbll_init ======== |
| */ |
| bool dbll_init(void) |
| { |
| DBC_REQUIRE(refs >= 0); |
| |
| if (refs == 0) |
| gh_init(); |
| |
| refs++; |
| |
| return true; |
| } |
| |
| /* |
| * ======== dbll_load ======== |
| */ |
| int dbll_load(struct dbll_library_obj *lib, dbll_flags flags, |
| struct dbll_attrs *attrs, u32 *entry) |
| { |
| struct dbll_library_obj *zl_lib = (struct dbll_library_obj *)lib; |
| struct dbll_tar_obj *dbzl; |
| bool got_symbols = true; |
| s32 err; |
| int status = 0; |
| bool opened_doff = false; |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(entry != NULL); |
| DBC_REQUIRE(attrs != NULL); |
| |
| /* |
| * Load if not already loaded. |
| */ |
| if (zl_lib->load_ref == 0 || !(flags & DBLL_DYNAMIC)) { |
| dbzl = zl_lib->target_obj; |
| dbzl->attrs = *attrs; |
| /* Create a hash table for symbols if not already created */ |
| if (zl_lib->sym_tab == NULL) { |
| got_symbols = false; |
| zl_lib->sym_tab = gh_create(MAXBUCKETS, |
| sizeof(struct dbll_symbol), |
| name_hash, |
| name_match, sym_delete); |
| if (zl_lib->sym_tab == NULL) |
| status = -ENOMEM; |
| |
| } |
| /* |
| * Set up objects needed by the dynamic loader |
| */ |
| /* Stream */ |
| zl_lib->stream.dl_stream.read_buffer = dbll_read_buffer; |
| zl_lib->stream.dl_stream.set_file_posn = dbll_set_file_posn; |
| zl_lib->stream.lib = zl_lib; |
| /* Symbol */ |
| zl_lib->symbol.dl_symbol.find_matching_symbol = |
| dbll_find_symbol; |
| if (got_symbols) { |
| zl_lib->symbol.dl_symbol.add_to_symbol_table = |
| find_in_symbol_table; |
| } else { |
| zl_lib->symbol.dl_symbol.add_to_symbol_table = |
| dbll_add_to_symbol_table; |
| } |
| zl_lib->symbol.dl_symbol.purge_symbol_table = |
| dbll_purge_symbol_table; |
| zl_lib->symbol.dl_symbol.dload_allocate = allocate; |
| zl_lib->symbol.dl_symbol.dload_deallocate = deallocate; |
| zl_lib->symbol.dl_symbol.error_report = dbll_err_report; |
| zl_lib->symbol.lib = zl_lib; |
| /* Allocate */ |
| zl_lib->allocate.dl_alloc.dload_allocate = dbll_rmm_alloc; |
| zl_lib->allocate.dl_alloc.dload_deallocate = rmm_dealloc; |
| zl_lib->allocate.lib = zl_lib; |
| /* Init */ |
| zl_lib->init.dl_init.connect = connect; |
| zl_lib->init.dl_init.readmem = read_mem; |
| zl_lib->init.dl_init.writemem = write_mem; |
| zl_lib->init.dl_init.fillmem = fill_mem; |
| zl_lib->init.dl_init.execute = execute; |
| zl_lib->init.dl_init.release = release; |
| zl_lib->init.lib = zl_lib; |
| /* If COFF file is not open, we open it. */ |
| if (zl_lib->fp == NULL) { |
| status = dof_open(zl_lib); |
| if (!status) |
| opened_doff = true; |
| |
| } |
| if (!status) { |
| zl_lib->pos = (*(zl_lib->target_obj->attrs.ftell)) |
| (zl_lib->fp); |
| /* Reset file cursor */ |
| (*(zl_lib->target_obj->attrs.fseek)) (zl_lib->fp, |
| (long)0, |
| SEEK_SET); |
| symbols_reloaded = true; |
| /* The 5th argument, DLOAD_INITBSS, tells the DLL |
| * module to zero-init all BSS sections. In general, |
| * this is not necessary and also increases load time. |
| * We may want to make this configurable by the user */ |
| err = dynamic_load_module(&zl_lib->stream.dl_stream, |
| &zl_lib->symbol.dl_symbol, |
| &zl_lib->allocate.dl_alloc, |
| &zl_lib->init.dl_init, |
| DLOAD_INITBSS, |
| &zl_lib->dload_mod_obj); |
| |
| if (err != 0) { |
| status = -EILSEQ; |
| } else if (redefined_symbol) { |
| zl_lib->load_ref++; |
| dbll_unload(zl_lib, (struct dbll_attrs *)attrs); |
| redefined_symbol = false; |
| status = -EILSEQ; |
| } else { |
| *entry = zl_lib->entry; |
| } |
| } |
| } |
| if (!status) |
| zl_lib->load_ref++; |
| |
| /* Clean up DOFF resources */ |
| if (opened_doff) |
| dof_close(zl_lib); |
| |
| DBC_ENSURE(status || zl_lib->load_ref > 0); |
| |
| dev_dbg(bridge, "%s: lib: %p flags: 0x%x entry: %p, status 0x%x\n", |
| __func__, lib, flags, entry, status); |
| |
| return status; |
| } |
| |
| /* |
| * ======== dbll_open ======== |
| */ |
| int dbll_open(struct dbll_tar_obj *target, char *file, dbll_flags flags, |
| struct dbll_library_obj **lib_obj) |
| { |
| struct dbll_tar_obj *zl_target = (struct dbll_tar_obj *)target; |
| struct dbll_library_obj *zl_lib = NULL; |
| s32 err; |
| int status = 0; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_target); |
| DBC_REQUIRE(zl_target->attrs.fopen != NULL); |
| DBC_REQUIRE(file != NULL); |
| DBC_REQUIRE(lib_obj != NULL); |
| |
| zl_lib = zl_target->head; |
| while (zl_lib != NULL) { |
| if (strcmp(zl_lib->file_name, file) == 0) { |
| /* Library is already opened */ |
| zl_lib->open_ref++; |
| break; |
| } |
| zl_lib = zl_lib->next; |
| } |
| if (zl_lib == NULL) { |
| /* Allocate DBL library object */ |
| zl_lib = kzalloc(sizeof(struct dbll_library_obj), GFP_KERNEL); |
| if (zl_lib == NULL) { |
| status = -ENOMEM; |
| } else { |
| zl_lib->pos = 0; |
| /* Increment ref count to allow close on failure |
| * later on */ |
| zl_lib->open_ref++; |
| zl_lib->target_obj = zl_target; |
| /* Keep a copy of the file name */ |
| zl_lib->file_name = kzalloc(strlen(file) + 1, |
| GFP_KERNEL); |
| if (zl_lib->file_name == NULL) { |
| status = -ENOMEM; |
| } else { |
| strncpy(zl_lib->file_name, file, |
| strlen(file) + 1); |
| } |
| zl_lib->sym_tab = NULL; |
| } |
| } |
| /* |
| * Set up objects needed by the dynamic loader |
| */ |
| if (status) |
| goto func_cont; |
| |
| /* Stream */ |
| zl_lib->stream.dl_stream.read_buffer = dbll_read_buffer; |
| zl_lib->stream.dl_stream.set_file_posn = dbll_set_file_posn; |
| zl_lib->stream.lib = zl_lib; |
| /* Symbol */ |
| zl_lib->symbol.dl_symbol.add_to_symbol_table = dbll_add_to_symbol_table; |
| zl_lib->symbol.dl_symbol.find_matching_symbol = dbll_find_symbol; |
| zl_lib->symbol.dl_symbol.purge_symbol_table = dbll_purge_symbol_table; |
| zl_lib->symbol.dl_symbol.dload_allocate = allocate; |
| zl_lib->symbol.dl_symbol.dload_deallocate = deallocate; |
| zl_lib->symbol.dl_symbol.error_report = dbll_err_report; |
| zl_lib->symbol.lib = zl_lib; |
| /* Allocate */ |
| zl_lib->allocate.dl_alloc.dload_allocate = dbll_rmm_alloc; |
| zl_lib->allocate.dl_alloc.dload_deallocate = rmm_dealloc; |
| zl_lib->allocate.lib = zl_lib; |
| /* Init */ |
| zl_lib->init.dl_init.connect = connect; |
| zl_lib->init.dl_init.readmem = read_mem; |
| zl_lib->init.dl_init.writemem = write_mem; |
| zl_lib->init.dl_init.fillmem = fill_mem; |
| zl_lib->init.dl_init.execute = execute; |
| zl_lib->init.dl_init.release = release; |
| zl_lib->init.lib = zl_lib; |
| if (!status && zl_lib->fp == NULL) |
| status = dof_open(zl_lib); |
| |
| zl_lib->pos = (*(zl_lib->target_obj->attrs.ftell)) (zl_lib->fp); |
| (*(zl_lib->target_obj->attrs.fseek)) (zl_lib->fp, (long)0, SEEK_SET); |
| /* Create a hash table for symbols if flag is set */ |
| if (zl_lib->sym_tab != NULL || !(flags & DBLL_SYMB)) |
| goto func_cont; |
| |
| zl_lib->sym_tab = |
| gh_create(MAXBUCKETS, sizeof(struct dbll_symbol), name_hash, |
| name_match, sym_delete); |
| if (zl_lib->sym_tab == NULL) { |
| status = -ENOMEM; |
| } else { |
| /* Do a fake load to get symbols - set write func to no_op */ |
| zl_lib->init.dl_init.writemem = no_op; |
| err = dynamic_open_module(&zl_lib->stream.dl_stream, |
| &zl_lib->symbol.dl_symbol, |
| &zl_lib->allocate.dl_alloc, |
| &zl_lib->init.dl_init, 0, |
| &zl_lib->dload_mod_obj); |
| if (err != 0) { |
| status = -EILSEQ; |
| } else { |
| /* Now that we have the symbol table, we can unload */ |
| err = dynamic_unload_module(zl_lib->dload_mod_obj, |
| &zl_lib->symbol.dl_symbol, |
| &zl_lib->allocate.dl_alloc, |
| &zl_lib->init.dl_init); |
| if (err != 0) |
| status = -EILSEQ; |
| |
| zl_lib->dload_mod_obj = NULL; |
| } |
| } |
| func_cont: |
| if (!status) { |
| if (zl_lib->open_ref == 1) { |
| /* First time opened - insert in list */ |
| if (zl_target->head) |
| (zl_target->head)->prev = zl_lib; |
| |
| zl_lib->prev = NULL; |
| zl_lib->next = zl_target->head; |
| zl_target->head = zl_lib; |
| } |
| *lib_obj = (struct dbll_library_obj *)zl_lib; |
| } else { |
| *lib_obj = NULL; |
| if (zl_lib != NULL) |
| dbll_close((struct dbll_library_obj *)zl_lib); |
| |
| } |
| DBC_ENSURE((!status && (zl_lib->open_ref > 0) && *lib_obj) |
| || (status && *lib_obj == NULL)); |
| |
| dev_dbg(bridge, "%s: target: %p file: %s lib_obj: %p, status 0x%x\n", |
| __func__, target, file, lib_obj, status); |
| |
| return status; |
| } |
| |
| /* |
| * ======== dbll_read_sect ======== |
| * Get the content of a COFF section. |
| */ |
| int dbll_read_sect(struct dbll_library_obj *lib, char *name, |
| char *buf, u32 size) |
| { |
| struct dbll_library_obj *zl_lib = (struct dbll_library_obj *)lib; |
| bool opened_doff = false; |
| u32 byte_size; /* size of bytes */ |
| u32 ul_sect_size; /* size of section */ |
| const struct ldr_section_info *sect = NULL; |
| int status = 0; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(name != NULL); |
| DBC_REQUIRE(buf != NULL); |
| DBC_REQUIRE(size != 0); |
| |
| /* If DOFF file is not open, we open it. */ |
| if (zl_lib != NULL) { |
| if (zl_lib->fp == NULL) { |
| status = dof_open(zl_lib); |
| if (!status) |
| opened_doff = true; |
| |
| } else { |
| (*(zl_lib->target_obj->attrs.fseek)) (zl_lib->fp, |
| zl_lib->pos, |
| SEEK_SET); |
| } |
| } else { |
| status = -EFAULT; |
| } |
| if (status) |
| goto func_cont; |
| |
| byte_size = 1; |
| if (!dload_get_section_info(zl_lib->desc, name, §)) { |
| status = -ENXIO; |
| goto func_cont; |
| } |
| /* |
| * Ensure the supplied buffer size is sufficient to store |
| * the section buf to be read. |
| */ |
| ul_sect_size = sect->size * byte_size; |
| /* Make sure size is even for good swap */ |
| if (ul_sect_size % 2) |
| ul_sect_size++; |
| |
| /* Align size */ |
| ul_sect_size = DOFF_ALIGN(ul_sect_size); |
| if (ul_sect_size > size) { |
| status = -EPERM; |
| } else { |
| if (!dload_get_section(zl_lib->desc, sect, buf)) |
| status = -EBADF; |
| |
| } |
| func_cont: |
| if (opened_doff) { |
| dof_close(zl_lib); |
| opened_doff = false; |
| } |
| |
| dev_dbg(bridge, "%s: lib: %p name: %s buf: %p size: 0x%x, " |
| "status 0x%x\n", __func__, lib, name, buf, size, status); |
| return status; |
| } |
| |
| /* |
| * ======== dbll_unload ======== |
| */ |
| void dbll_unload(struct dbll_library_obj *lib, struct dbll_attrs *attrs) |
| { |
| struct dbll_library_obj *zl_lib = (struct dbll_library_obj *)lib; |
| s32 err = 0; |
| |
| DBC_REQUIRE(refs > 0); |
| DBC_REQUIRE(zl_lib); |
| DBC_REQUIRE(zl_lib->load_ref > 0); |
| dev_dbg(bridge, "%s: lib: %p\n", __func__, lib); |
| zl_lib->load_ref--; |
| /* Unload only if reference count is 0 */ |
| if (zl_lib->load_ref != 0) |
| goto func_end; |
| |
| zl_lib->target_obj->attrs = *attrs; |
| if (zl_lib->dload_mod_obj) { |
| err = dynamic_unload_module(zl_lib->dload_mod_obj, |
| &zl_lib->symbol.dl_symbol, |
| &zl_lib->allocate.dl_alloc, |
| &zl_lib->init.dl_init); |
| if (err != 0) |
| dev_dbg(bridge, "%s: failed: 0x%x\n", __func__, err); |
| } |
| /* remove symbols from symbol table */ |
| if (zl_lib->sym_tab != NULL) { |
| gh_delete(zl_lib->sym_tab); |
| zl_lib->sym_tab = NULL; |
| } |
| /* delete DOFF desc since it holds *lots* of host OS |
| * resources */ |
| dof_close(zl_lib); |
| func_end: |
| DBC_ENSURE(zl_lib->load_ref >= 0); |
| } |
| |
| /* |
| * ======== dof_close ======== |
| */ |
| static void dof_close(struct dbll_library_obj *zl_lib) |
| { |
| if (zl_lib->desc) { |
| dload_module_close(zl_lib->desc); |
| zl_lib->desc = NULL; |
| } |
| /* close file */ |
| if (zl_lib->fp) { |
| (zl_lib->target_obj->attrs.fclose) (zl_lib->fp); |
| zl_lib->fp = NULL; |
| } |
| } |
| |
| /* |
| * ======== dof_open ======== |
| */ |
| static int dof_open(struct dbll_library_obj *zl_lib) |
| { |
| void *open = *(zl_lib->target_obj->attrs.fopen); |
| int status = 0; |
| |
| /* First open the file for the dynamic loader, then open COF */ |
| zl_lib->fp = |
| (void *)((dbll_f_open_fxn) (open)) (zl_lib->file_name, "rb"); |
| |
| /* Open DOFF module */ |
| if (zl_lib->fp && zl_lib->desc == NULL) { |
| (*(zl_lib->target_obj->attrs.fseek)) (zl_lib->fp, (long)0, |
| SEEK_SET); |
| zl_lib->desc = |
| dload_module_open(&zl_lib->stream.dl_stream, |
| &zl_lib->symbol.dl_symbol); |
| if (zl_lib->desc == NULL) { |
| (zl_lib->target_obj->attrs.fclose) (zl_lib->fp); |
| zl_lib->fp = NULL; |
| status = -EBADF; |
| } |
| } else { |
| status = -EBADF; |
| } |
| |
| return status; |
| } |
| |
| /* |
| * ======== name_hash ======== |
| */ |
| static u16 name_hash(void *key, u16 max_bucket) |
| { |
| u16 ret; |
| u16 hash; |
| char *name = (char *)key; |
| |
| DBC_REQUIRE(name != NULL); |
| |
| hash = 0; |
| |
| while (*name) { |
| hash <<= 1; |
| hash ^= *name++; |
| } |
| |
| ret = hash % max_bucket; |
| |
| return ret; |
| } |
| |
| /* |
| * ======== name_match ======== |
| */ |
| static bool name_match(void *key, void *sp) |
| { |
| DBC_REQUIRE(key != NULL); |
| DBC_REQUIRE(sp != NULL); |
| |
| if ((key != NULL) && (sp != NULL)) { |
| if (strcmp((char *)key, ((struct dbll_symbol *)sp)->name) == |
| 0) |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * ======== no_op ======== |
| */ |
| static int no_op(struct dynamic_loader_initialize *thisptr, void *bufr, |
| ldr_addr locn, struct ldr_section_info *info, unsigned bytsize) |
| { |
| return 1; |
| } |
| |
| /* |
| * ======== sym_delete ======== |
| */ |
| static void sym_delete(void *value) |
| { |
| struct dbll_symbol *sp = (struct dbll_symbol *)value; |
| |
| kfree(sp->name); |
| } |
| |
| /* |
| * Dynamic Loader Functions |
| */ |
| |
| /* dynamic_loader_stream */ |
| /* |
| * ======== dbll_read_buffer ======== |
| */ |
| static int dbll_read_buffer(struct dynamic_loader_stream *this, void *buffer, |
| unsigned bufsize) |
| { |
| struct dbll_stream *pstream = (struct dbll_stream *)this; |
| struct dbll_library_obj *lib; |
| int bytes_read = 0; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = pstream->lib; |
| DBC_REQUIRE(lib); |
| |
| if (lib != NULL) { |
| bytes_read = |
| (*(lib->target_obj->attrs.fread)) (buffer, 1, bufsize, |
| lib->fp); |
| } |
| return bytes_read; |
| } |
| |
| /* |
| * ======== dbll_set_file_posn ======== |
| */ |
| static int dbll_set_file_posn(struct dynamic_loader_stream *this, |
| unsigned int pos) |
| { |
| struct dbll_stream *pstream = (struct dbll_stream *)this; |
| struct dbll_library_obj *lib; |
| int status = 0; /* Success */ |
| |
| DBC_REQUIRE(this != NULL); |
| lib = pstream->lib; |
| DBC_REQUIRE(lib); |
| |
| if (lib != NULL) { |
| status = (*(lib->target_obj->attrs.fseek)) (lib->fp, (long)pos, |
| SEEK_SET); |
| } |
| |
| return status; |
| } |
| |
| /* dynamic_loader_sym */ |
| |
| /* |
| * ======== dbll_find_symbol ======== |
| */ |
| static struct dynload_symbol *dbll_find_symbol(struct dynamic_loader_sym *this, |
| const char *name) |
| { |
| struct dynload_symbol *ret_sym; |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| struct dbll_sym_val *dbll_sym = NULL; |
| bool status = false; /* Symbol not found yet */ |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| |
| if (lib != NULL) { |
| if (lib->target_obj->attrs.sym_lookup) { |
| /* Check current lib + base lib + dep lib + |
| * persistent lib */ |
| status = (*(lib->target_obj->attrs.sym_lookup)) |
| (lib->target_obj->attrs.sym_handle, |
| lib->target_obj->attrs.sym_arg, |
| lib->target_obj->attrs.rmm_handle, name, |
| &dbll_sym); |
| } else { |
| /* Just check current lib for symbol */ |
| status = dbll_get_addr((struct dbll_library_obj *)lib, |
| (char *)name, &dbll_sym); |
| if (!status) { |
| status = |
| dbll_get_c_addr((struct dbll_library_obj *) |
| lib, (char *)name, |
| &dbll_sym); |
| } |
| } |
| } |
| |
| if (!status && gbl_search) |
| dev_dbg(bridge, "%s: Symbol not found: %s\n", __func__, name); |
| |
| DBC_ASSERT((status && (dbll_sym != NULL)) |
| || (!status && (dbll_sym == NULL))); |
| |
| ret_sym = (struct dynload_symbol *)dbll_sym; |
| return ret_sym; |
| } |
| |
| /* |
| * ======== find_in_symbol_table ======== |
| */ |
| static struct dynload_symbol *find_in_symbol_table(struct dynamic_loader_sym |
| *this, const char *name, |
| unsigned moduleid) |
| { |
| struct dynload_symbol *ret_sym; |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| struct dbll_symbol *sym; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| DBC_REQUIRE(lib->sym_tab != NULL); |
| |
| sym = (struct dbll_symbol *)gh_find(lib->sym_tab, (char *)name); |
| |
| ret_sym = (struct dynload_symbol *)&sym->value; |
| return ret_sym; |
| } |
| |
| /* |
| * ======== dbll_add_to_symbol_table ======== |
| */ |
| static struct dynload_symbol *dbll_add_to_symbol_table(struct dynamic_loader_sym |
| *this, const char *name, |
| unsigned module_id) |
| { |
| struct dbll_symbol *sym_ptr = NULL; |
| struct dbll_symbol symbol; |
| struct dynload_symbol *dbll_sym = NULL; |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| struct dynload_symbol *ret; |
| |
| DBC_REQUIRE(this != NULL); |
| DBC_REQUIRE(name); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| |
| /* Check to see if symbol is already defined in symbol table */ |
| if (!(lib->target_obj->attrs.base_image)) { |
| gbl_search = false; |
| dbll_sym = dbll_find_symbol(this, name); |
| gbl_search = true; |
| if (dbll_sym) { |
| redefined_symbol = true; |
| dev_dbg(bridge, "%s already defined in symbol table\n", |
| name); |
| return NULL; |
| } |
| } |
| /* Allocate string to copy symbol name */ |
| symbol.name = kzalloc(strlen((char *const)name) + 1, GFP_KERNEL); |
| if (symbol.name == NULL) |
| return NULL; |
| |
| if (symbol.name != NULL) { |
| /* Just copy name (value will be filled in by dynamic loader) */ |
| strncpy(symbol.name, (char *const)name, |
| strlen((char *const)name) + 1); |
| |
| /* Add symbol to symbol table */ |
| sym_ptr = |
| (struct dbll_symbol *)gh_insert(lib->sym_tab, (void *)name, |
| (void *)&symbol); |
| if (sym_ptr == NULL) |
| kfree(symbol.name); |
| |
| } |
| if (sym_ptr != NULL) |
| ret = (struct dynload_symbol *)&sym_ptr->value; |
| else |
| ret = NULL; |
| |
| return ret; |
| } |
| |
| /* |
| * ======== dbll_purge_symbol_table ======== |
| */ |
| static void dbll_purge_symbol_table(struct dynamic_loader_sym *this, |
| unsigned module_id) |
| { |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| |
| /* May not need to do anything */ |
| } |
| |
| /* |
| * ======== allocate ======== |
| */ |
| static void *allocate(struct dynamic_loader_sym *this, unsigned memsize) |
| { |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| void *buf; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| |
| buf = kzalloc(memsize, GFP_KERNEL); |
| |
| return buf; |
| } |
| |
| /* |
| * ======== deallocate ======== |
| */ |
| static void deallocate(struct dynamic_loader_sym *this, void *mem_ptr) |
| { |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| |
| kfree(mem_ptr); |
| } |
| |
| /* |
| * ======== dbll_err_report ======== |
| */ |
| static void dbll_err_report(struct dynamic_loader_sym *this, const char *errstr, |
| va_list args) |
| { |
| struct ldr_symbol *ldr_sym = (struct ldr_symbol *)this; |
| struct dbll_library_obj *lib; |
| char temp_buf[MAXEXPR]; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = ldr_sym->lib; |
| DBC_REQUIRE(lib); |
| vsnprintf((char *)temp_buf, MAXEXPR, (char *)errstr, args); |
| dev_dbg(bridge, "%s\n", temp_buf); |
| } |
| |
| /* dynamic_loader_allocate */ |
| |
| /* |
| * ======== dbll_rmm_alloc ======== |
| */ |
| static int dbll_rmm_alloc(struct dynamic_loader_allocate *this, |
| struct ldr_section_info *info, unsigned align) |
| { |
| struct dbll_alloc *dbll_alloc_obj = (struct dbll_alloc *)this; |
| struct dbll_library_obj *lib; |
| int status = 0; |
| u32 mem_sect_type; |
| struct rmm_addr rmm_addr_obj; |
| s32 ret = true; |
| unsigned stype = DLOAD_SECTION_TYPE(info->type); |
| char *token = NULL; |
| char *sz_sec_last_token = NULL; |
| char *sz_last_token = NULL; |
| char *sz_sect_name = NULL; |
| char *psz_cur; |
| s32 token_len = 0; |
| s32 seg_id = -1; |
| s32 req = -1; |
| s32 count = 0; |
| u32 alloc_size = 0; |
| u32 run_addr_flag = 0; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = dbll_alloc_obj->lib; |
| DBC_REQUIRE(lib); |
| |
| mem_sect_type = |
| (stype == DLOAD_TEXT) ? DBLL_CODE : (stype == |
| DLOAD_BSS) ? DBLL_BSS : |
| DBLL_DATA; |
| |
| /* Attempt to extract the segment ID and requirement information from |
| the name of the section */ |
| DBC_REQUIRE(info->name); |
| token_len = strlen((char *)(info->name)) + 1; |
| |
| sz_sect_name = kzalloc(token_len, GFP_KERNEL); |
| sz_last_token = kzalloc(token_len, GFP_KERNEL); |
| sz_sec_last_token = kzalloc(token_len, GFP_KERNEL); |
| |
| if (sz_sect_name == NULL || sz_sec_last_token == NULL || |
| sz_last_token == NULL) { |
| status = -ENOMEM; |
| goto func_cont; |
| } |
| strncpy(sz_sect_name, (char *)(info->name), token_len); |
| psz_cur = sz_sect_name; |
| while ((token = strsep(&psz_cur, ":")) && *token != '\0') { |
| strncpy(sz_sec_last_token, sz_last_token, |
| strlen(sz_last_token) + 1); |
| strncpy(sz_last_token, token, strlen(token) + 1); |
| token = strsep(&psz_cur, ":"); |
| count++; /* optimizes processing */ |
| } |
| /* If token is 0 or 1, and sz_sec_last_token is DYN_DARAM or DYN_SARAM, |
| or DYN_EXTERNAL, then mem granularity information is present |
| within the section name - only process if there are at least three |
| tokens within the section name (just a minor optimization) */ |
| if (count >= 3) |
| strict_strtol(sz_last_token, 10, (long *)&req); |
| |
| if ((req == 0) || (req == 1)) { |
| if (strcmp(sz_sec_last_token, "DYN_DARAM") == 0) { |
| seg_id = 0; |
| } else { |
| if (strcmp(sz_sec_last_token, "DYN_SARAM") == 0) { |
| seg_id = 1; |
| } else { |
| if (strcmp(sz_sec_last_token, |
| "DYN_EXTERNAL") == 0) |
| seg_id = 2; |
| } |
| } |
| } |
| func_cont: |
| kfree(sz_sect_name); |
| sz_sect_name = NULL; |
| kfree(sz_last_token); |
| sz_last_token = NULL; |
| kfree(sz_sec_last_token); |
| sz_sec_last_token = NULL; |
| |
| if (mem_sect_type == DBLL_CODE) |
| alloc_size = info->size + GEM_L1P_PREFETCH_SIZE; |
| else |
| alloc_size = info->size; |
| |
| if (info->load_addr != info->run_addr) |
| run_addr_flag = 1; |
| /* TODO - ideally, we can pass the alignment requirement also |
| * from here */ |
| if (lib != NULL) { |
| status = |
| (lib->target_obj->attrs.alloc) (lib->target_obj->attrs. |
| rmm_handle, mem_sect_type, |
| alloc_size, align, |
| (u32 *) &rmm_addr_obj, |
| seg_id, req, false); |
| } |
| if (status) { |
| ret = false; |
| } else { |
| /* RMM gives word address. Need to convert to byte address */ |
| info->load_addr = rmm_addr_obj.addr * DSPWORDSIZE; |
| if (!run_addr_flag) |
| info->run_addr = info->load_addr; |
| info->context = (u32) rmm_addr_obj.segid; |
| dev_dbg(bridge, "%s: %s base = 0x%x len = 0x%x, " |
| "info->run_addr 0x%x, info->load_addr 0x%x\n", |
| __func__, info->name, info->load_addr / DSPWORDSIZE, |
| info->size / DSPWORDSIZE, info->run_addr, |
| info->load_addr); |
| } |
| return ret; |
| } |
| |
| /* |
| * ======== rmm_dealloc ======== |
| */ |
| static void rmm_dealloc(struct dynamic_loader_allocate *this, |
| struct ldr_section_info *info) |
| { |
| struct dbll_alloc *dbll_alloc_obj = (struct dbll_alloc *)this; |
| struct dbll_library_obj *lib; |
| u32 segid; |
| int status = 0; |
| unsigned stype = DLOAD_SECTION_TYPE(info->type); |
| u32 mem_sect_type; |
| u32 free_size = 0; |
| |
| mem_sect_type = |
| (stype == DLOAD_TEXT) ? DBLL_CODE : (stype == |
| DLOAD_BSS) ? DBLL_BSS : |
| DBLL_DATA; |
| DBC_REQUIRE(this != NULL); |
| lib = dbll_alloc_obj->lib; |
| DBC_REQUIRE(lib); |
| /* segid was set by alloc function */ |
| segid = (u32) info->context; |
| if (mem_sect_type == DBLL_CODE) |
| free_size = info->size + GEM_L1P_PREFETCH_SIZE; |
| else |
| free_size = info->size; |
| if (lib != NULL) { |
| status = |
| (lib->target_obj->attrs.free) (lib->target_obj->attrs. |
| sym_handle, segid, |
| info->load_addr / |
| DSPWORDSIZE, free_size, |
| false); |
| } |
| } |
| |
| /* dynamic_loader_initialize */ |
| /* |
| * ======== connect ======== |
| */ |
| static int connect(struct dynamic_loader_initialize *this) |
| { |
| return true; |
| } |
| |
| /* |
| * ======== read_mem ======== |
| * This function does not need to be implemented. |
| */ |
| static int read_mem(struct dynamic_loader_initialize *this, void *buf, |
| ldr_addr addr, struct ldr_section_info *info, |
| unsigned nbytes) |
| { |
| struct dbll_init_obj *init_obj = (struct dbll_init_obj *)this; |
| struct dbll_library_obj *lib; |
| int bytes_read = 0; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = init_obj->lib; |
| DBC_REQUIRE(lib); |
| /* Need bridge_brd_read function */ |
| return bytes_read; |
| } |
| |
| /* |
| * ======== write_mem ======== |
| */ |
| static int write_mem(struct dynamic_loader_initialize *this, void *buf, |
| ldr_addr addr, struct ldr_section_info *info, |
| unsigned bytes) |
| { |
| struct dbll_init_obj *init_obj = (struct dbll_init_obj *)this; |
| struct dbll_library_obj *lib; |
| struct dbll_tar_obj *target_obj; |
| struct dbll_sect_info sect_info; |
| u32 mem_sect_type; |
| bool ret = true; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = init_obj->lib; |
| if (!lib) |
| return false; |
| |
| target_obj = lib->target_obj; |
| |
| mem_sect_type = |
| (DLOAD_SECTION_TYPE(info->type) == |
| DLOAD_TEXT) ? DBLL_CODE : DBLL_DATA; |
| if (target_obj && target_obj->attrs.write) { |
| ret = |
| (*target_obj->attrs.write) (target_obj->attrs.input_params, |
| addr, buf, bytes, |
| mem_sect_type); |
| |
| if (target_obj->attrs.log_write) { |
| sect_info.name = info->name; |
| sect_info.sect_run_addr = info->run_addr; |
| sect_info.sect_load_addr = info->load_addr; |
| sect_info.size = info->size; |
| sect_info.type = mem_sect_type; |
| /* Pass the information about what we've written to |
| * another module */ |
| (*target_obj->attrs.log_write) (target_obj->attrs. |
| log_write_handle, |
| §_info, addr, |
| bytes); |
| } |
| } |
| return ret; |
| } |
| |
| /* |
| * ======== fill_mem ======== |
| * Fill bytes of memory at a given address with a given value by |
| * writing from a buffer containing the given value. Write in |
| * sets of MAXEXPR (128) bytes to avoid large stack buffer issues. |
| */ |
| static int fill_mem(struct dynamic_loader_initialize *this, ldr_addr addr, |
| struct ldr_section_info *info, unsigned bytes, unsigned val) |
| { |
| bool ret = true; |
| char *pbuf; |
| struct dbll_library_obj *lib; |
| struct dbll_init_obj *init_obj = (struct dbll_init_obj *)this; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = init_obj->lib; |
| pbuf = NULL; |
| /* Pass the NULL pointer to write_mem to get the start address of Shared |
| memory. This is a trick to just get the start address, there is no |
| writing taking place with this Writemem |
| */ |
| if ((lib->target_obj->attrs.write) != (dbll_write_fxn) no_op) |
| write_mem(this, &pbuf, addr, info, 0); |
| if (pbuf) |
| memset(pbuf, val, bytes); |
| |
| return ret; |
| } |
| |
| /* |
| * ======== execute ======== |
| */ |
| static int execute(struct dynamic_loader_initialize *this, ldr_addr start) |
| { |
| struct dbll_init_obj *init_obj = (struct dbll_init_obj *)this; |
| struct dbll_library_obj *lib; |
| bool ret = true; |
| |
| DBC_REQUIRE(this != NULL); |
| lib = init_obj->lib; |
| DBC_REQUIRE(lib); |
| /* Save entry point */ |
| if (lib != NULL) |
| lib->entry = (u32) start; |
| |
| return ret; |
| } |
| |
| /* |
| * ======== release ======== |
| */ |
| static void release(struct dynamic_loader_initialize *this) |
| { |
| } |
| |
| #ifdef CONFIG_TIDSPBRIDGE_BACKTRACE |
| /** |
| * find_symbol_context - Basic symbol context structure |
| * @address: Symbol Address |
| * @offset_range: Offset range where the search for the DSP symbol |
| * started. |
| * @cur_best_offset: Best offset to start looking for the DSP symbol |
| * @sym_addr: Address of the DSP symbol |
| * @name: Symbol name |
| * |
| */ |
| struct find_symbol_context { |
| /* input */ |
| u32 address; |
| u32 offset_range; |
| /* state */ |
| u32 cur_best_offset; |
| /* output */ |
| u32 sym_addr; |
| char name[120]; |
| }; |
| |
| /** |
| * find_symbol_callback() - Validates symbol address and copies the symbol name |
| * to the user data. |
| * @elem: dsp library context |
| * @user_data: Find symbol context |
| * |
| */ |
| void find_symbol_callback(void *elem, void *user_data) |
| { |
| struct dbll_symbol *symbol = elem; |
| struct find_symbol_context *context = user_data; |
| u32 symbol_addr = symbol->value.value; |
| u32 offset = context->address - symbol_addr; |
| |
| /* |
| * Address given should be greater than symbol address, |
| * symbol address should be within specified range |
| * and the offset should be better than previous one |
| */ |
| if (context->address >= symbol_addr && symbol_addr < (u32)-1 && |
| offset < context->cur_best_offset) { |
| context->cur_best_offset = offset; |
| context->sym_addr = symbol_addr; |
| strncpy(context->name, symbol->name, sizeof(context->name)); |
| } |
| |
| return; |
| } |
| |
| /** |
| * dbll_find_dsp_symbol() - This function retrieves the dsp symbol from the dsp binary. |
| * @zl_lib: DSP binary obj library pointer |
| * @address: Given address to find the dsp symbol |
| * @offset_range: offset range to look for dsp symbol |
| * @sym_addr_output: Symbol Output address |
| * @name_output: String with the dsp symbol |
| * |
| * This function retrieves the dsp symbol from the dsp binary. |
| */ |
| bool dbll_find_dsp_symbol(struct dbll_library_obj *zl_lib, u32 address, |
| u32 offset_range, u32 *sym_addr_output, |
| char *name_output) |
| { |
| bool status = false; |
| struct find_symbol_context context; |
| |
| context.address = address; |
| context.offset_range = offset_range; |
| context.cur_best_offset = offset_range; |
| context.sym_addr = 0; |
| context.name[0] = '\0'; |
| |
| gh_iterate(zl_lib->sym_tab, find_symbol_callback, &context); |
| |
| if (context.name[0]) { |
| status = true; |
| strcpy(name_output, context.name); |
| *sym_addr_output = context.sym_addr; |
| } |
| |
| return status; |
| } |
| #endif |