int
Csp1ConfigDevice(void)
{
void * n1_ssl_config_device(void);
void * (*func)(void);
func = symbol_get(n1_ssl_config_device);
if (!func) {
printk(KERN_CRIT "n1_ssl_config_device: symbol_get failed\n");
return -1;
}
n1_list = (struct N1_Dev *)(*func)();
if (n1_list == NULL) {
printk(KERN_CRIT "No Cavium devices detected in the system\n");
symbol_put(n1_ssl_config_device);
return -1;
}
module_count++;
if (module_count == 1) {
if (p_alloc_context == NULL) {
p_alloc_context = symbol_get(n1_ssl_alloc_context);
}
if (p_dealloc_context == NULL) {
p_dealloc_context = symbol_get(n1_ssl_dealloc_context);
}
if (p_KernAes == NULL) {
p_KernAes = symbol_get(n1_KernAes);
}
}
symbol_put(n1_ssl_config_device);
return 0;
}
/**
* intel_gvt_init_host - Load MPT modules and detect if we're running in host
* @gvt: intel gvt device
*
* This function is called at the driver loading stage. If failed to find a
* loadable MPT module or detect currently we're running in a VM, then GVT-g
* will be disabled
*
* Returns:
* Zero on success, negative error code if failed.
*
*/
int intel_gvt_init_host(void)
{
if (intel_gvt_host.initialized)
return 0;
/* Xen DOM U */
if (xen_domain() && !xen_initial_domain())
return -ENODEV;
/* Try to load MPT modules for hypervisors */
if (xen_initial_domain()) {
/* In Xen dom0 */
intel_gvt_host.mpt = try_then_request_module(
symbol_get(xengt_mpt), "xengt");
intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_XEN;
} else {
#if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
/* not in Xen. Try KVMGT */
intel_gvt_host.mpt = try_then_request_module(
symbol_get(kvmgt_mpt), "kvmgt");
intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_KVM;
#endif
}
/* Fail to load MPT modules - bail out */
if (!intel_gvt_host.mpt)
return -EINVAL;
gvt_dbg_core("Running with hypervisor %s in host mode\n",
supported_hypervisors[intel_gvt_host.hypervisor_type]);
intel_gvt_host.initialized = true;
return 0;
}
static void mali_counter_initialize(void)
{
/* If a Mali driver is present and exporting the appropriate symbol
* then we can request the HW counters (of which there are only 2)
* be configured to count the desired events
*/
void (*set_hw_event)(unsigned int, unsigned int);
void (*set_fb_event)(unsigned int, unsigned int);
set_hw_event = symbol_get(_mali_profiling_set_event);
if (set_hw_event) {
int i;
pr_debug("gator: mali online _mali_profiling_set_event symbol @ %p\n",set_hw_event);
for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) {
if (counter_enabled[i]) {
set_hw_event(i, counter_event[i]);
} else {
set_hw_event(i, 0xFFFFFFFF);
}
}
symbol_put(_mali_profiling_set_event);
} else {
printk("gator: mali online _mali_profiling_set_event symbol not found\n");
}
set_fb_event = symbol_get(_mali_osk_fb_control_set);
if (set_fb_event) {
pr_debug("gator: mali online _mali_osk_fb_control_set symbol @ %p\n", set_fb_event);
set_fb_event(0,(counter_enabled[COUNTER_FILMSTRIP]?1:0));
symbol_put(_mali_osk_fb_control_set);
} else {
printk("gator: mali online _mali_osk_fb_control_set symbol not found\n");
}
_mali_profiling_get_counters_function_pointer = symbol_get(_mali_profiling_get_counters);
if (_mali_profiling_get_counters_function_pointer){
pr_debug("gator: mali online _mali_profiling_get_counters symbol @ %p\n", _mali_profiling_get_counters_function_pointer);
counter_prev[COUNTER_L2_C0] = 0;
counter_prev[COUNTER_L2_C1] = 0;
}
else{
pr_debug("gator WARNING: mali _mali_profiling_get_counters symbol not defined");
}
}
/*
* test if two lower dentries have overlapping branches.
*/
int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_adding)
{
struct super_block *h_sb;
struct file *backing_file;
if (unlikely(!backing_file_func)) {
/* don't load "loop" module here */
backing_file_func = symbol_get(loop_backing_file);
if (unlikely(!backing_file_func))
/* "loop" module is not loaded */
return 0;
}
h_sb = h_adding->d_sb;
backing_file = backing_file_func(h_sb);
if (!backing_file)
return 0;
h_adding = backing_file->f_path.dentry;
/*
* h_adding can be local NFS.
* in this case aufs cannot detect the loop.
*/
if (unlikely(h_adding->d_sb == sb))
return 1;
return !!au_test_subdir(h_adding, sb->s_root);
}
void symbol_get_2(Symbol *sym, float *v0, float *v1)
{
float val[2];
symbol_get(sym, val, 2);
*v0 = val[0];
*v1 = val[1];
}
symbol_t* symbol_get(symbol_table_t* symbol_table, char* name) {
if (!symbol_table) return NULL;
symbol_t* symbol = symbol_get_in_scope(symbol_table, name);
if (symbol)
return symbol;
return symbol_get(symbol_table->parent, name);
}
static int corgibl_send_intensity(struct backlight_device *bd)
{
void (*corgi_kick_batt)(void);
int intensity = bd->props.brightness;
if (bd->props.power != FB_BLANK_UNBLANK)
intensity = 0;
if (bd->props.fb_blank != FB_BLANK_UNBLANK)
intensity = 0;
if (corgibl_flags & CORGIBL_SUSPENDED)
intensity = 0;
if (corgibl_flags & CORGIBL_BATTLOW)
intensity &= bl_machinfo->limit_mask;
bl_machinfo->set_bl_intensity(intensity);
corgibl_intensity = intensity;
corgi_kick_batt = symbol_get(sharpsl_battery_kick);
if (corgi_kick_batt) {
corgi_kick_batt();
symbol_put(sharpsl_battery_kick);
}
return 0;
}
void symbol_get_3(Symbol *sym, float *v0, float *v1, float *v2)
{
float val[3];
symbol_get(sym, val, 3);
*v0 = val[0];
*v1 = val[1];
*v2 = val[2];
}
static Pointer makeToken(const char* start, int length)
{
Pointer ptr = symbol_alloc(length);
char* dest = (char*) symbol_get(ptr);
memcpy(dest, start, length);
dest[length] = 0;
return ptr;
}
void symbol_get_4(Symbol *sym, float *v0, float *v1, float *v2, float *v3)
{
float val[4];
symbol_get(sym, val, 4);
*v0 = val[0];
*v1 = val[1];
*v2 = val[2];
*v3 = val[3];
}
static void corgi_bl_kick_battery(void)
{
void (*kick_batt)(void);
kick_batt = symbol_get(sharpsl_battery_kick);
if (kick_batt) {
kick_batt();
symbol_put(sharpsl_battery_kick);
}
}
static irqreturn_t db1100_mmc_cd(int irq, void *ptr)
{
void (*mmc_cd)(struct mmc_host *, unsigned long);
/* link against CONFIG_MMC=m */
mmc_cd = symbol_get(mmc_detect_change);
mmc_cd(ptr, msecs_to_jiffies(500));
symbol_put(mmc_detect_change);
return IRQ_HANDLED;
}
void symbol_get_5(Symbol *sym, float *v0, float *v1, float *v2, float *v3,
float *v4)
{
float val[5];
symbol_get(sym, val, 5);
*v0 = val[0];
*v1 = val[1];
*v2 = val[2];
*v3 = val[3];
*v4 = val[4];
}
void bind_names ( node_t *root ) {
if (root == NULL)
return;
switch (root->type.index) {
case FUNCTION_LIST: {
add_functions_to_symtab ( root );
traverse_children ( root );
break;
}
case FUNCTION: {
scope_add ();
add_parameters_to_scope ( root );
if ( root->children[2]->type.index == BLOCK) {
bind_names ( root->children[2]->children[0] );
bind_names ( root->children[2]->children[1] );
} else
fprintf(stderr,
"Expected BLOCK-statement after FUNCTION \"%s\"\n", (char *) root->data);
scope_remove ();
break;
}
case BLOCK: {
scope_add ();
traverse_children ( root );
scope_remove ();
break;
}
case DECLARATION_LIST: {
int stack_offset = -VSL_PTR_SIZE;
for ( int i = 0; i < root->n_children; i++ ) {
node_t *declaration_n = root->children[i];
stack_offset = add_variables_to_scope ( declaration_n, stack_offset );
}
break;
}
case VARIABLE: {
symbol_t *var = symbol_get ( (char *) root->data );
if ( var != NULL )
root->entry = var;
else
fprintf(stderr, "The variable \"%s\" is not declared.\n", (char *) root->data);
traverse_children ( root );
break;
}
case TEXT: {
add_text ( root );
traverse_children ( root );
break;
}
default:
traverse_children ( root );
}
}
static u8 *savage_do_probe_i2c_edid(struct savagefb_i2c_chan *chan)
{
u8 start = 0x0;
int (*transfer)(struct i2c_adapter *, struct i2c_msg *, int) =
symbol_get(i2c_transfer);
struct i2c_msg msgs[] = {
{
.addr = SAVAGE_DDC,
.len = 1,
.buf = &start,
}, {
.addr = SAVAGE_DDC,
void symbol_get_6(Symbol *sym, float *v0, float *v1, float *v2, float *v3,
float *v4, float *v5)
{
float val[6];
symbol_get(sym, val, 6);
*v0 = val[0];
*v1 = val[1];
*v2 = val[2];
*v3 = val[3];
*v4 = val[4];
*v5 = val[5];
}
void savagefb_delete_i2c_busses(struct fb_info *info)
{
struct savagefb_par *par = (struct savagefb_par *)info->par;
int (*del_bus)(struct i2c_adapter *) =
symbol_get(i2c_bit_del_bus);
if (del_bus && par->chan.par) {
del_bus(&par->chan.adapter);
symbol_put(i2c_bit_del_bus);
}
par->chan.par = NULL;
}
static void mali_counter_deinitialize(void)
{
void (*set_hw_event)(unsigned int, unsigned int);
void (*set_fb_event)(unsigned int, unsigned int);
set_hw_event = symbol_get(_mali_profiling_set_event);
if (set_hw_event) {
int i;
pr_debug("gator: mali offline _mali_profiling_set_event symbol @ %p\n",set_hw_event);
for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) {
set_hw_event(i, 0xFFFFFFFF);
}
symbol_put(_mali_profiling_set_event);
} else {
printk("gator: mali offline _mali_profiling_set_event symbol not found\n");
}
set_fb_event = symbol_get(_mali_osk_fb_control_set);
if (set_fb_event) {
pr_debug("gator: mali offline _mali_osk_fb_control_set symbol @ %p\n", set_fb_event);
set_fb_event(0,0);
symbol_put(_mali_osk_fb_control_set);
} else {
printk("gator: mali offline _mali_osk_fb_control_set symbol not found\n");
}
if (_mali_profiling_get_counters_function_pointer){
symbol_put(_mali_profiling_get_counters);
}
}
static int start(void)
{
unsigned int cnt;
mali_profiling_control_type *mali_control;
previous_shader_bitmask = 0;
previous_tiler_bitmask = 0;
previous_l2_bitmask = 0;
/* Clean all data for the next capture */
for (cnt = 0; cnt < NUMBER_OF_TIMELINE_EVENTS; cnt++) {
timeline_event_starttime[cnt].tv_sec = timeline_event_starttime[cnt].tv_nsec = 0;
timeline_data[cnt] = 0;
}
for (cnt = 0; cnt < NUMBER_OF_SOFTWARE_COUNTERS; cnt++)
sw_counter_data[cnt] = 0;
for (cnt = 0; cnt < NUMBER_OF_ACCUMULATORS; cnt++)
accumulators_data[cnt] = 0;
/* Register tracepoints */
if (register_tracepoints() == 0)
return -1;
/* Generic control interface for Mali DDK. */
mali_control = symbol_get(_mali_profiling_control);
if (mali_control) {
/* The event attribute in the XML file keeps the actual frame rate. */
unsigned int enabled = counters[FILMSTRIP].enabled ? 1 : 0;
unsigned int rate = filmstrip_event & 0xff;
unsigned int resize_factor = (filmstrip_event >> 8) & 0xff;
pr_debug("gator: mali online _mali_profiling_control symbol @ %p\n", mali_control);
#define FBDUMP_CONTROL_ENABLE (1)
#define FBDUMP_CONTROL_RATE (2)
#define FBDUMP_CONTROL_RESIZE_FACTOR (4)
mali_control(FBDUMP_CONTROL_ENABLE, enabled);
mali_control(FBDUMP_CONTROL_RATE, rate);
mali_control(FBDUMP_CONTROL_RESIZE_FACTOR, resize_factor);
pr_debug("gator: sent mali_control enabled=%d, rate=%d, resize_factor=%d\n", enabled, rate, resize_factor);
symbol_put(_mali_profiling_control);
} else {
u64 Csp1AllocContext(void)
{
if (!p_alloc_context)
{
if (n1_list == NULL)
{
printk(KERN_CRIT " Cavium device is not initialized1\n");
return (u64)0;
}
p_alloc_context = symbol_get(n1_ssl_alloc_context);
if (!p_alloc_context) {
printk(KERN_CRIT "kernel_shim: Csp1AllocContext: symbol_get(Csp1AllocContext) failed\n");
return (u64)0;
}
}
return (*p_alloc_context)(n1_list->data);
}
void
recurse_tree(node_t* root){
if(root == NULL) return;
if(root->type.index == DECLARATION){
declare_tree(root);
}else if(root->type.index == BLOCK){
next_stack_offset = -4;
scope_add();
}else if(root->type.index == FUNCTION){
next_stack_offset = -4;
scope_add();
//function is defined already, but not the parameters.
define_parameters(root);
}else if(root->type.index == EXPRESSION
|| root->type.index == ASSIGNMENT_STATEMENT){
for(int i = 0; i< root->n_children;i++){
node_t* child = root->children[i];
if(child == NULL) continue;
if(child->type.index == VARIABLE){
symbol_t* symbol = symbol_get((char*)child->data);
root->entry = symbol;
}
}
}else if(root->type.index == TEXT){
char* text = (char*) root->data;
//For future ease of use, I will not store
//the index directly in the pointer.
int32_t* intpoint = malloc(sizeof(int32_t));
*intpoint = strings_add(text);
//Store the string index instead of the string
root->data = intpoint;
}
for(int i = 0; i < root->n_children; i++){
node_t* child = root->children[i];
recurse_tree(child);
}
if(root->type.index == BLOCK
|| root->type.index == FUNCTION){
scope_remove();
}
}
static irqreturn_t db1300_mmc_cd(int irq, void *ptr)
{
void(*mmc_cd)(struct mmc_host *, unsigned long);
if (irq == DB1300_SD1_INSERT_INT) {
disable_irq_nosync(DB1300_SD1_INSERT_INT);
enable_irq(DB1300_SD1_EJECT_INT);
} else {
disable_irq_nosync(DB1300_SD1_EJECT_INT);
enable_irq(DB1300_SD1_INSERT_INT);
}
mmc_cd = symbol_get(mmc_detect_change);
mmc_cd(ptr, msecs_to_jiffies(500));
symbol_put(mmc_detect_change);
return IRQ_HANDLED;
}
int EXP_get_symbol(void)
{
char *s = (char *) calloc(1,EXP_MAX);
int i = 0;
if (s == NULL) {
fprintf(stderr,"FATAL ERROR - EX0101\n");
return(-1);
}
*s = 0;
memset(EXP_string_value,0,EXP_MAX);
while(isalnum((int)EXP_str[EXP_pos]) || EXP_str[EXP_pos] == '_' || EXP_str[EXP_pos] == '$') {
s[i++] = EXP_str[EXP_pos++];
}
symbol_get(s,EXP_string_value);
EXP_number_value = atol(EXP_string_value);
free(s);
return(0);
}
void
Csp1FreeContext(void)
{
if (!p_dealloc_context)
{
if (n1_list == NULL)
{
printk(KERN_CRIT " Cavium device is not initialized\n");
return;
}
p_dealloc_context = symbol_get(n1_ssl_dealloc_context);
if (!p_dealloc_context) {
printk(KERN_CRIT "kernel_shim: Csp1FreeContext: symbol_get(Csp1FreeContext) failed\n");
return;
}
}
(*p_dealloc_context)(n1_list->data, ctx);
}
/* our own functions */
static int __init mod_init(void)
{
PR_INFO("start");
PR_INFO("name is %s", KBUILD_MODNAME);
PR_INFO("name is %s", THIS_MODULE->name);
PR_INFO("srcversion is %s", THIS_MODULE->srcversion);
PR_INFO("version is %s", THIS_MODULE->version);
/*
PR_INFO("init_size is %d", THIS_MODULE->init_size);
PR_INFO("core_size is %d", THIS_MODULE->core_size);
PR_INFO("init_text_size is %d", THIS_MODULE->init_text_size);
PR_INFO("core_text_size is %d", THIS_MODULE->core_text_size);
*/
PR_INFO("printk is %p", printk);
/* using this symbol_get function you can also get kernel symbols,
other modules symbols or your own exported symbols. */
PR_INFO("printk (via get) is %p", symbol_get("printk"));
return 0;
}
static Pointer readForm(Tokeniser* t)
{
if (tokeniser_eof(t)) {
return nil_make();
}
Pointer ret = tokeniser_token(t);
// If ret is a string, it's ready to return
if (ret.type == Type_symbol) {
const char* token = symbol_get(ret);
int intValue;
if (util_streq(token, "(")) {
tokeniser_next(t); // consume the '(', read the list and
return readList(t); // return immediately to avoid hitting the
// tokeniser_next() below
}
else if (util_streq(token, "nil")) {
ret = nil_make();
}
else if (util_streq(token, "true")) {
ret = boolean_make(1);
}
else if (util_streq(token, "false")) {
ret = boolean_make(0);
}
else if (readInteger(token, &intValue)) {
ret = integer_make(intValue);
}
else {
// Insert the symbol into the symbol table. We may or may not get
// the same symbol back.
ret = symtab_insert(ret);
}
}
PUSH(ret);
tokeniser_next(t);
return POP();
}
static int create_files(struct super_block *sb, struct dentry *root)
{
int event;
/*
* Create the filesystem for all events
*/
int counter_index = 0;
const char *mali_name = gator_mali_get_mali_name();
mali_profiling_control_type *mali_control;
for (event = FIRST_TIMELINE_EVENT; event < FIRST_TIMELINE_EVENT + NUMBER_OF_TIMELINE_EVENTS; event++) {
if (gator_mali_create_file_system(mali_name, timeline_event_names[counter_index], sb, root, &counters[event], NULL) != 0) {
return -1;
}
counter_index++;
}
counter_index = 0;
for (event = FIRST_SOFTWARE_COUNTER; event < FIRST_SOFTWARE_COUNTER + NUMBER_OF_SOFTWARE_COUNTERS; event++) {
if (gator_mali_create_file_system(mali_name, software_counter_names[counter_index], sb, root, &counters[event], NULL) != 0) {
return -1;
}
counter_index++;
}
counter_index = 0;
for (event = FIRST_ACCUMULATOR; event < FIRST_ACCUMULATOR + NUMBER_OF_ACCUMULATORS; event++) {
if (gator_mali_create_file_system(mali_name, accumulators_names[counter_index], sb, root, &counters[event], NULL) != 0) {
return -1;
}
counter_index++;
}
mali_control = symbol_get(_mali_profiling_control);
if (mali_control) {
if (gator_mali_create_file_system(mali_name, "Filmstrip_cnt0", sb, root, &counters[FILMSTRIP], &filmstrip_event) != 0) {
return -1;
}
symbol_put(_mali_profiling_control);
}
return 0;
}
static Pointer readList(Tokeniser* t)
{
if (tokeniser_eof(t)) {
THROW("Expected ), got EOF");
}
Pointer token = tokeniser_token(t);
if ((token.type == Type_symbol) && util_streq(symbol_get(token), ")")) {
tokeniser_next(t);
return nil_make();
}
StackIndex carIndex = PUSH(readForm(t));
StackIndex cdrIndex = PUSH(readList(t));
Pointer ret = pair_make(carIndex, cdrIndex);
DROP(2);
return ret;
}
/* SD carddetects: they're supposed to be edge-triggered, but ack
* doesn't seem to work (CPLD Rev 2). Instead, the screaming one
* is disabled and its counterpart enabled. The 500ms timeout is
* because the carddetect isn't debounced in hardware.
*/
static irqreturn_t db1200_mmc_cd(int irq, void *ptr)
{
void(*mmc_cd)(struct mmc_host *, unsigned long);
if (irq == DB1200_SD0_INSERT_INT) {
disable_irq_nosync(DB1200_SD0_INSERT_INT);
enable_irq(DB1200_SD0_EJECT_INT);
} else {
disable_irq_nosync(DB1200_SD0_EJECT_INT);
enable_irq(DB1200_SD0_INSERT_INT);
}
/* link against CONFIG_MMC=m */
mmc_cd = symbol_get(mmc_detect_change);
if (mmc_cd) {
mmc_cd(ptr, msecs_to_jiffies(500));
symbol_put(mmc_detect_change);
}
return IRQ_HANDLED;
}
static irqreturn_t db1300_mmc_cd(int irq, void *ptr)
{
void(*mmc_cd)(struct mmc_host *, unsigned long);
/* disable the one currently screaming. No other way to shut it up */
if (irq == DB1300_SD1_INSERT_INT) {
disable_irq_nosync(DB1300_SD1_INSERT_INT);
enable_irq(DB1300_SD1_EJECT_INT);
} else {
disable_irq_nosync(DB1300_SD1_EJECT_INT);
enable_irq(DB1300_SD1_INSERT_INT);
}
/* link against CONFIG_MMC=m. We can only be called once MMC core has
* initialized the controller, so symbol_get() should always succeed.
*/
mmc_cd = symbol_get(mmc_detect_change);
mmc_cd(ptr, msecs_to_jiffies(500));
symbol_put(mmc_detect_change);
return IRQ_HANDLED;
}
