path: root/driver/gator_events_mali_400.c

/**
 * Copyright (C) ARM Limited 2010-2012. All rights reserved.
 *
 * This program 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.
 */

#include "gator.h"

#include <linux/module.h>
#include <linux/time.h>
#include <linux/math64.h>

#include "linux/mali_linux_trace.h"

#include "gator_events_mali_common.h"
#include "gator_events_mali_400.h"

/*
 * There are (currently) three different variants of the comms between gator and Mali:
 * 1 (deprecated): No software counter support
 * 2 (deprecated): Tracepoint called for each separate s/w counter value as it appears
 * 3 (default): Single tracepoint for all s/w counters in a bundle.
 * Interface style 3 is the default if no other is specified.  1 and 2 will be eliminated when
 * existing Mali DDKs are upgraded.
 */

#if !defined(GATOR_MALI_INTERFACE_STYLE)
#define GATOR_MALI_INTERFACE_STYLE (3)
#endif

/*
 * List of possible actions allowing DDK to be controlled by Streamline.
 * The following numbers are used by DDK to control the frame buffer dumping.
 */
#define FBDUMP_CONTROL_ENABLE (1)
#define FBDUMP_CONTROL_RATE (2)
#define SW_EVENTS_ENABLE      (3)
#define FBDUMP_CONTROL_RESIZE_FACTOR (4)

/*
 * Check that the MALI_SUPPORT define is set to one of the allowable device codes.
 */
#if (MALI_SUPPORT != MALI_400)
#error MALI_SUPPORT set to an invalid device code: expecting MALI_400
#endif

/*
 * The number of fragment processors.  Update to suit your hardware implementation.
 */
#define NUM_FP_UNITS            (4)

enum counters {
    /* Timeline activity */
    ACTIVITY_VP = 0,
    ACTIVITY_FP0,
    ACTIVITY_FP1,
    ACTIVITY_FP2,
    ACTIVITY_FP3,
    
    /* L2 cache counters */
    COUNTER_L2_C0,
    COUNTER_L2_C1,

    /* Vertex processor counters */
    COUNTER_VP_C0,
    COUNTER_VP_C1, 

    /* Fragment processor counters */
    COUNTER_FP0_C0,    
    COUNTER_FP0_C1,     
    COUNTER_FP1_C0,
    COUNTER_FP1_C1,
    COUNTER_FP2_C0,
    COUNTER_FP2_C1,
    COUNTER_FP3_C0,
    COUNTER_FP3_C1,

    /* EGL Software Counters */
    COUNTER_EGL_BLIT_TIME,

    /* GLES Software Counters */
    COUNTER_GLES_DRAW_ELEMENTS_CALLS,
    COUNTER_GLES_DRAW_ELEMENTS_NUM_INDICES,
    COUNTER_GLES_DRAW_ELEMENTS_NUM_TRANSFORMED,
    COUNTER_GLES_DRAW_ARRAYS_CALLS,
    COUNTER_GLES_DRAW_ARRAYS_NUM_TRANSFORMED,
    COUNTER_GLES_DRAW_POINTS,
    COUNTER_GLES_DRAW_LINES,
    COUNTER_GLES_DRAW_LINE_LOOP,
    COUNTER_GLES_DRAW_LINE_STRIP,
    COUNTER_GLES_DRAW_TRIANGLES,
    COUNTER_GLES_DRAW_TRIANGLE_STRIP,
    COUNTER_GLES_DRAW_TRIANGLE_FAN,
    COUNTER_GLES_NON_VBO_DATA_COPY_TIME,
    COUNTER_GLES_UNIFORM_BYTES_COPIED_TO_MALI,
    COUNTER_GLES_UPLOAD_TEXTURE_TIME,
    COUNTER_GLES_UPLOAD_VBO_TIME,
    COUNTER_GLES_NUM_FLUSHES,
    COUNTER_GLES_NUM_VSHADERS_GENERATED,
    COUNTER_GLES_NUM_FSHADERS_GENERATED,
    COUNTER_GLES_VSHADER_GEN_TIME,
    COUNTER_GLES_FSHADER_GEN_TIME,
    COUNTER_GLES_INPUT_TRIANGLES,
    COUNTER_GLES_VXCACHE_HIT,
    COUNTER_GLES_VXCACHE_MISS,
    COUNTER_GLES_VXCACHE_COLLISION,
    COUNTER_GLES_CULLED_TRIANGLES,
    COUNTER_GLES_CULLED_LINES,
    COUNTER_GLES_BACKFACE_TRIANGLES,
    COUNTER_GLES_GBCLIP_TRIANGLES,
    COUNTER_GLES_GBCLIP_LINES,
    COUNTER_GLES_TRIANGLES_DRAWN,
    COUNTER_GLES_DRAWCALL_TIME,
    COUNTER_GLES_TRIANGLES_COUNT,
    COUNTER_GLES_INDEPENDENT_TRIANGLES_COUNT,
    COUNTER_GLES_STRIP_TRIANGLES_COUNT,
    COUNTER_GLES_FAN_TRIANGLES_COUNT,
    COUNTER_GLES_LINES_COUNT,
    COUNTER_GLES_INDEPENDENT_LINES_COUNT,
    COUNTER_GLES_STRIP_LINES_COUNT,
    COUNTER_GLES_LOOP_LINES_COUNT,

    COUNTER_FILMSTRIP,
    COUNTER_FREQUENCY,
    COUNTER_VOLTAGE,

    NUMBER_OF_EVENTS
};

#define FIRST_ACTIVITY_EVENT    ACTIVITY_VP
#define LAST_ACTIVITY_EVENT     ACTIVITY_FP3

#define FIRST_HW_COUNTER        COUNTER_L2_C0
#define LAST_HW_COUNTER         COUNTER_FP3_C1

#define FIRST_SW_COUNTER        COUNTER_EGL_BLIT_TIME
#define LAST_SW_COUNTER         COUNTER_GLES_LOOP_LINES_COUNT

#define FIRST_SPECIAL_COUNTER   COUNTER_FILMSTRIP
#define LAST_SPECIAL_COUNTER    COUNTER_VOLTAGE

/* gatorfs variables for counter enable state,
 * the event the counter should count and the
 * 'key' (a unique id set by gatord and returned
 * by gator.ko)
 */
static unsigned long counter_enabled[NUMBER_OF_EVENTS];
static unsigned long counter_event[NUMBER_OF_EVENTS];
static unsigned long counter_key[NUMBER_OF_EVENTS];

/* The data we have recorded */
static u32 counter_data[NUMBER_OF_EVENTS];
/* The address to sample (or 0 if samples are sent to us) */
static u32* counter_address[NUMBER_OF_EVENTS];

/* An array used to return the data we recorded
 * as key,value pairs hence the *2
 */
static unsigned long counter_dump[NUMBER_OF_EVENTS * 2];
static unsigned long counter_prev[NUMBER_OF_EVENTS];

/* Note whether tracepoints have been registered */
static int trace_registered;

/**
 * Calculate the difference and handle the overflow.
 */
static u32 get_difference(u32 start, u32 end)
{
    if (start - end >= 0)
    {
        return start - end;
    }

    // Mali counters are unsigned 32 bit values that wrap.
    return (4294967295u - end) + start;
}

/**
 * Returns non-zero if the given counter ID is an activity counter.
 */
static inline int is_activity_counter(unsigned int event_id)
{
    return (event_id >= FIRST_ACTIVITY_EVENT && 
        event_id <= LAST_ACTIVITY_EVENT);
}

/**
 * Returns non-zero if the given counter ID is a hardware counter.
 */
static inline int is_hw_counter(unsigned int event_id)
{
    return (event_id >= FIRST_HW_COUNTER && event_id <= LAST_HW_COUNTER);
}

#if GATOR_MALI_INTERFACE_STYLE == 2
/**
 * Returns non-zero if the given counter ID is a software counter.
 */
static inline int is_sw_counter(unsigned int event_id)
{
    return (event_id >= FIRST_SW_COUNTER && event_id <= LAST_SW_COUNTER);
}
#endif

#if GATOR_MALI_INTERFACE_STYLE == 2
/*
 * The Mali DDK uses s64 types to contain software counter values, but gator
 * can only use a maximum of 32 bits. This function scales a software counter
 * to an appopriate range.
 */
static u32 scale_sw_counter_value(unsigned int event_id, signed long long value)
{
    u32 scaled_value;

    switch (event_id) {
        case COUNTER_GLES_UPLOAD_TEXTURE_TIME:
        case COUNTER_GLES_UPLOAD_VBO_TIME:
            scaled_value = (u32)div_s64(value, 1000000);
            break;
        default:
            scaled_value = (u32)value;
            break;
    }

    return scaled_value;
}
#endif

/* Probe for continuously sampled counter */
#if 0 //WE_DONT_CURRENTLY_USE_THIS_SO_SUPPRESS_WARNING
GATOR_DEFINE_PROBE(mali_sample_address, TP_PROTO(unsigned int event_id, u32* addr))
{
    /* Turning on too many pr_debug statements in frequently called functions
     * can cause stability and/or performance problems
     */
    //pr_debug("gator: mali_sample_address %d %d\n", event_id, addr);
    if (event_id >= ACTIVITY_VP && event_id <= COUNTER_FP3_C1) {
        counter_address[event_id] = addr;
    }
}
#endif

/* Probe for hardware counter events */
GATOR_DEFINE_PROBE(mali_hw_counter, TP_PROTO(unsigned int event_id, unsigned int value))
{
    /* Turning on too many pr_debug statements in frequently called functions
     * can cause stability and/or performance problems
     */
    //pr_debug("gator: mali_hw_counter %d %d\n", event_id, value);
    if (is_hw_counter(event_id)) {
        counter_data[event_id] = value;
    }
}

#if GATOR_MALI_INTERFACE_STYLE == 2
GATOR_DEFINE_PROBE(mali_sw_counter, TP_PROTO(unsigned int event_id, signed long long value))
{
    if (is_sw_counter(event_id)) {
        counter_data[event_id] = scale_sw_counter_value(event_id, value);
    }
}
#endif /* GATOR_MALI_INTERFACE_STYLE == 2 */


#if GATOR_MALI_INTERFACE_STYLE == 3
GATOR_DEFINE_PROBE(mali_sw_counters, TP_PROTO(pid_t pid, pid_t tid, void * surface_id, unsigned int * counters))
{
    u32 i;

    /* Copy over the values for those counters which are enabled. */
    for(i=FIRST_SW_COUNTER; i <= LAST_SW_COUNTER; i++)
    {
        if(counter_enabled[i])
        {
            counter_data[i] = (u32)(counters[i - FIRST_SW_COUNTER]);
        }
    }
}
#endif /* GATOR_MALI_INTERFACE_STYLE == 3 */

static int create_files(struct super_block *sb, struct dentry *root) {
    struct dentry *dir;
    int event;
    int n_fp = NUM_FP_UNITS;

    const char* mali_name = gator_mali_get_mali_name();

    /*
     * Create the filesystem entries for vertex processor, fragement processor
     * and L2 cache timeline and hardware counters. Software counters get 
     * special handling after this block.
     */
    for (event = FIRST_ACTIVITY_EVENT; event <= LAST_HW_COUNTER; event++)
    {
        char buf[40];

        /* 
         * We can skip this event if it's for a non-existent fragment
         * processor.
         */
        if (((event - ACTIVITY_FP0 >= n_fp) && (event < COUNTER_L2_C0)) ||
            (((event - COUNTER_FP0_C0)/2 >= n_fp)))
        {
            continue;
        }

        /* Otherwise, set up the filesystem entry for this event. */
        switch (event) {
            case ACTIVITY_VP:
                snprintf(buf, sizeof buf, "ARM_%s_VP_active", mali_name);
                break;
            case ACTIVITY_FP0:
            case ACTIVITY_FP1:
            case ACTIVITY_FP2:
            case ACTIVITY_FP3:
                snprintf(buf, sizeof buf, "ARM_%s_FP%d_active", 
                    mali_name, event - ACTIVITY_FP0);
                break;
            case COUNTER_L2_C0:
            case COUNTER_L2_C1:
                snprintf(buf, sizeof buf, "ARM_%s_L2_cnt%d", 
                    mali_name, event - COUNTER_L2_C0);
                break;
            case COUNTER_VP_C0:
            case COUNTER_VP_C1:
                snprintf(buf, sizeof buf, "ARM_%s_VP_cnt%d", 
                    mali_name, event - COUNTER_VP_C0);
                break;
            case COUNTER_FP0_C0:
            case COUNTER_FP0_C1:
            case COUNTER_FP1_C0:
            case COUNTER_FP1_C1:
            case COUNTER_FP2_C0:
            case COUNTER_FP2_C1:
            case COUNTER_FP3_C0:
            case COUNTER_FP3_C1:
                snprintf(buf, sizeof buf, "ARM_%s_FP%d_cnt%d", mali_name, 
                    (event - COUNTER_FP0_C0) / 2, (event - COUNTER_FP0_C0) % 2);
                break;
            default:
                printk("gator: trying to create file for non-existent counter (%d)\n", event);
                continue;
        }

        dir = gatorfs_mkdir(sb, root, buf);
        
        if (!dir) {
            return -1;
        }
        
        gatorfs_create_ulong(sb, dir, "enabled", &counter_enabled[event]);
        
        /* Only create an event node for counters that can change what they count */
        if (event >= COUNTER_L2_C0) {
            gatorfs_create_ulong(sb, dir, "event", &counter_event[event]);
        }
        
        gatorfs_create_ro_ulong(sb, dir, "key", &counter_key[event]);
    }

    /* Now set up the software counter entries */
    for (event = FIRST_SW_COUNTER; event <= LAST_SW_COUNTER; event++)
    {
        char buf[40];

        snprintf(buf, sizeof(buf), "ARM_%s_SW_%d", mali_name, event);

        dir = gatorfs_mkdir(sb, root, buf);

        if (!dir) {
            return -1;
        }

        gatorfs_create_ulong(sb, dir, "enabled", &counter_enabled[event]);
        gatorfs_create_ro_ulong(sb, dir, "key", &counter_key[event]);
    }

    /* Now set up the special counter entries */
    for (event = FIRST_SPECIAL_COUNTER; event <= LAST_SPECIAL_COUNTER; event++)
    {
        char buf[40];

        switch(event) {
        case COUNTER_FILMSTRIP:
            snprintf(buf, sizeof(buf), "ARM_%s_Filmstrip", mali_name);
        	break;

        case COUNTER_FREQUENCY:
            snprintf(buf, sizeof(buf), "ARM_%s_Frequency", mali_name);
        	break;

        case COUNTER_VOLTAGE:
            snprintf(buf, sizeof(buf), "ARM_%s_Voltage", mali_name);
        	break;

        default:
        	break;
        }

        dir = gatorfs_mkdir(sb, root, buf);

        if (!dir) {
            return -1;
        }

        gatorfs_create_ulong(sb, dir, "event", &counter_event[event]);
        gatorfs_create_ulong(sb, dir, "enabled", &counter_enabled[event]);
        gatorfs_create_ro_ulong(sb, dir, "key", &counter_key[event]);
    }

    return 0;
}

/*
 * Local store for the get_counters entry point into the DDK.
 * This is stored here since it is used very regularly.
 */
static mali_profiling_get_counters_type *mali_get_counters = NULL;

/*
 * Examine list of software counters and determine if any one is enabled.
 * Returns 1 if any counter is enabled, 0 if none is.
 */
static int is_any_sw_counter_enabled(void)
{
    unsigned int i;

    for (i = FIRST_SW_COUNTER; i <= LAST_SW_COUNTER; i++)
    {
        if (counter_enabled[i])
        {
            return 1;    /* At least one counter is enabled */
        }
    }

    return 0;    /* No s/w counters enabled */
}

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
     */
    mali_profiling_set_event_type *mali_set_hw_event;
    mali_osk_fb_control_set_type *mali_set_fb_event;
    mali_profiling_control_type *mali_control;

    mali_set_hw_event = symbol_get(_mali_profiling_set_event);

    if (mali_set_hw_event) {
        int i;

        pr_debug("gator: mali online _mali_profiling_set_event symbol @ %p\n",mali_set_hw_event);

        for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) {
            if (counter_enabled[i]) {
                mali_set_hw_event(i, counter_event[i]);
            } else {
                mali_set_hw_event(i, 0xFFFFFFFF);
            }
        }

        symbol_put(_mali_profiling_set_event);
    } else {
        printk("gator: mali online _mali_profiling_set_event symbol not found\n");
    }

    mali_set_fb_event = symbol_get(_mali_osk_fb_control_set);

    if (mali_set_fb_event) {
        pr_debug("gator: mali online _mali_osk_fb_control_set symbol @ %p\n", mali_set_fb_event);

        mali_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");
    }

    /* 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 rate = counter_event[COUNTER_FILMSTRIP] & 0xff;
        unsigned int resize_factor = (counter_event[COUNTER_FILMSTRIP] >> 8) & 0xff;

        pr_debug("gator: mali online _mali_profiling_control symbol @ %p\n", mali_control);

        mali_control(SW_EVENTS_ENABLE, (is_any_sw_counter_enabled()?1:0));
        mali_control(FBDUMP_CONTROL_ENABLE, (counter_enabled[COUNTER_FILMSTRIP]?1:0));
        mali_control(FBDUMP_CONTROL_RATE, rate);
        mali_control(FBDUMP_CONTROL_RESIZE_FACTOR, resize_factor);

        pr_debug("gator: sent mali_control enabled=%d, rate=%d\n", (counter_enabled[COUNTER_FILMSTRIP]?1:0), rate);

        symbol_put(_mali_profiling_control);
    } else {
        printk("gator: mali online _mali_profiling_control symbol not found\n");
    }

    mali_get_counters = symbol_get(_mali_profiling_get_counters);
    if (mali_get_counters){
        pr_debug("gator: mali online _mali_profiling_get_counters symbol @ %p\n", mali_get_counters);
        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");
    }
}

static void mali_counter_deinitialize(void) 
{
    mali_profiling_set_event_type *mali_set_hw_event;
    mali_osk_fb_control_set_type *mali_set_fb_event;
    mali_profiling_control_type *mali_control;

    mali_set_hw_event = symbol_get(_mali_profiling_set_event);

    if (mali_set_hw_event) {
        int i;
        
        pr_debug("gator: mali offline _mali_profiling_set_event symbol @ %p\n",mali_set_hw_event);
        for (i = FIRST_HW_COUNTER; i <= LAST_HW_COUNTER; i++) {
            mali_set_hw_event(i, 0xFFFFFFFF);
        }
        
        symbol_put(_mali_profiling_set_event);
    } else {
        printk("gator: mali offline _mali_profiling_set_event symbol not found\n");
    }

    mali_set_fb_event = symbol_get(_mali_osk_fb_control_set);

    if (mali_set_fb_event) {
        pr_debug("gator: mali offline _mali_osk_fb_control_set symbol @ %p\n", mali_set_fb_event);

        mali_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");
    }

    /* Generic control interface for Mali DDK. */
    mali_control = symbol_get(_mali_profiling_control);

    if (mali_control) {
        pr_debug("gator: mali offline _mali_profiling_control symbol @ %p\n", mali_set_fb_event);

        /* Reset the DDK state - disable counter collection */
        mali_control(SW_EVENTS_ENABLE, 0);

        mali_control(FBDUMP_CONTROL_ENABLE, 0);

        symbol_put(_mali_profiling_control);
    } else {
        printk("gator: mali offline _mali_profiling_control symbol not found\n");
    }

    if (mali_get_counters){
        symbol_put(_mali_profiling_get_counters);
    }

}

static int start(void) {
    // register tracepoints
    if (GATOR_REGISTER_TRACE(mali_hw_counter)) {
        printk("gator: mali_hw_counter tracepoint failed to activate\n");
        return -1;
    }

#if GATOR_MALI_INTERFACE_STYLE == 1
        /* None. */
#elif GATOR_MALI_INTERFACE_STYLE == 2
        /* For patched Mali driver. */
    if (GATOR_REGISTER_TRACE(mali_sw_counter)) {
        printk("gator: mali_sw_counter tracepoint failed to activate\n");
        return -1;
    }
#elif GATOR_MALI_INTERFACE_STYLE == 3
/* For Mali drivers with built-in support. */
    if (GATOR_REGISTER_TRACE(mali_sw_counters)) {
        printk("gator: mali_sw_counters tracepoint failed to activate\n");
        return -1;
    }
#else
#error Unknown GATOR_MALI_INTERFACE_STYLE option.
#endif

    trace_registered = 1;

    mali_counter_initialize();
    return 0;
}

static void stop(void) {
    unsigned int cnt;

    pr_debug("gator: mali stop\n");

    if (trace_registered) {
        GATOR_UNREGISTER_TRACE(mali_hw_counter);

#if GATOR_MALI_INTERFACE_STYLE == 1
    /* None. */
#elif GATOR_MALI_INTERFACE_STYLE == 2
    /* For patched Mali driver. */
    GATOR_UNREGISTER_TRACE(mali_sw_counter);
#elif GATOR_MALI_INTERFACE_STYLE == 3
    /* For Mali drivers with built-in support. */
    GATOR_UNREGISTER_TRACE(mali_sw_counters);
#else
#error Unknown GATOR_MALI_INTERFACE_STYLE option.
#endif

        pr_debug("gator: mali timeline tracepoint deactivated\n");
        
        trace_registered = 0;
    }

    for (cnt = FIRST_ACTIVITY_EVENT; cnt < NUMBER_OF_EVENTS; cnt++) {
        counter_enabled[cnt] = 0;
        counter_event[cnt] = 0;
        counter_address[cnt] = NULL;
    }

    mali_counter_deinitialize();
}

static int read(int **buffer) {
    int cnt, len = 0;

    if (smp_processor_id()) return 0;

    // Read the L2 C0 and C1 here.
    if (counter_enabled[COUNTER_L2_C0] || counter_enabled[COUNTER_L2_C1] ) {
        u32 src0 = 0;
        u32 val0 = 0;
        u32 src1 = 0;
        u32 val1 = 0;

        // Poke the driver to get the counter values
        if (mali_get_counters){
            mali_get_counters(&src0, &val0, &src1, &val1);
        }

        if (counter_enabled[COUNTER_L2_C0])
        {
            // Calculate and save src0's counter val0
            counter_dump[len++] = counter_key[COUNTER_L2_C0];
            counter_dump[len++] = get_difference(val0, counter_prev[COUNTER_L2_C0]);
        }

        if (counter_enabled[COUNTER_L2_C1])
        {
            // Calculate and save src1's counter val1
            counter_dump[len++] = counter_key[COUNTER_L2_C1];
            counter_dump[len++] = get_difference(val1, counter_prev[COUNTER_L2_C1]);
        }

        // Save the previous values for the counters.
        counter_prev[COUNTER_L2_C0] = val0;
        counter_prev[COUNTER_L2_C1] = val1;
    }

    // Process other (non-timeline) counters.
    for (cnt = COUNTER_VP_C0; cnt <= LAST_SW_COUNTER; cnt++) {
        if (counter_enabled[cnt]) {
            counter_dump[len++] = counter_key[cnt];
            counter_dump[len++] = counter_data[cnt];

            counter_data[cnt] = 0;
        }
    }

    /*
     * Add in the voltage and frequency counters if enabled.  Note that, since these are
     * actually passed as events, the counter value should not be cleared.
     */
    cnt = COUNTER_FREQUENCY;
    if (counter_enabled[cnt]) {
        counter_dump[len++] = counter_key[cnt];
        counter_dump[len++] = counter_data[cnt];
    }

    cnt = COUNTER_VOLTAGE;
    if (counter_enabled[cnt]) {
        counter_dump[len++] = counter_key[cnt];
        counter_dump[len++] = counter_data[cnt];
    }


    if (buffer) {
        *buffer = (int*) counter_dump;
    }

    return len;
}

static struct gator_interface gator_events_mali_interface = {
    .create_files = create_files,
    .start = start,
    .stop = stop,
    .read = read,
};

extern void gator_events_mali_log_dvfs_event(unsigned int frequency_mhz, unsigned int voltage_mv) {
	counter_data[COUNTER_FREQUENCY] = frequency_mhz;
	counter_data[COUNTER_VOLTAGE] = voltage_mv;
}

int gator_events_mali_init(void)
{
    unsigned int cnt;

    pr_debug("gator: mali init\n");

    for (cnt = FIRST_ACTIVITY_EVENT; cnt < NUMBER_OF_EVENTS; cnt++) {
        counter_enabled[cnt] = 0;
        counter_event[cnt] = 0;
        counter_key[cnt] = gator_events_get_key();
        counter_address[cnt] = NULL;
        counter_data[cnt] = 0;
    }

    trace_registered = 0;

    return gator_events_install(&gator_events_mali_interface);
}

gator_events_init(gator_events_mali_init);