clocks.c

/*******************************************************************************
 * Copyright (C) 2010, Linaro
 * Copyright (C) 2010, IBM Corporation
 *
 * This file is part of PowerDebug.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Amit Arora <amit.arora@linaro.org> (IBM Corporation)
 *       - initial API and implementation
 *******************************************************************************/

#include "powerdebug.h"
#include "clocks.h"
#include <errno.h>
#include <sys/stat.h>

static int  clk_tree_level = 1;
static char clk_dir_path[PATH_MAX];
static char highlighted_path[PATH_MAX];
static char clk_name[NAME_MAX];
static int  gadder = 0;


void init_clock_details(void)
{
        char *path = debugfs_locate_mpoint();
        struct stat buf;


        if (path)
                strcpy(clk_dir_path, path);
        else {
                fprintf(stderr, "powerdebug: Unable to locate debugfs mount"
                        " point. Mount debugfs and try again..\n");
                exit(1);
        }
        sprintf(clk_dir_path, "%s/clock", clk_dir_path);
        //strcpy(clk_dir_path, "/debug/clock"); // Hardcoded for testing..
        if (stat(clk_dir_path, &buf)) {
                fprintf(stderr, "powerdebug: Unable to find clock tree"
                        " information at %s. Exiting..\n", clk_dir_path);
                exit(1);
        }
        strcpy(clk_name, "");
        strcpy(highlighted_path, "");
}

int get_int_from(char *file)
{
        FILE *filep;
        char result[NAME_MAX];
        int ret;

        filep = fopen(file, "r");

        if (!filep)
                return -1;  //TBD : What should we return on failure, here ?

        ret = fscanf(filep, "%s", result);
        fclose(filep);

        return atoi(result);
}

int read_and_print_clock_info(int verbose, int hrow, int selected)
{
        if (selected) {
        //        if (!(strcmp(clk_dir_path, "/debug/clock") &&
         //               strcmp(highlighted_path, ".."))) {
                strcpy(clk_dir_path, highlighted_path);
                hrow = 0;
                clk_tree_level += gadder;
                if (clk_tree_level <=0)
                        clk_tree_level = 1;
        }

        hrow = read_and_print_clock_one_level(verbose, hrow, selected);

        return hrow;
}

void set_hl_dir_path_to_parent(void)
{
        char *ptr;

        strcpy(highlighted_path, clk_dir_path);
        if (strcmp(clk_dir_path, "/clock/debug")) {
                ptr = strrchr(highlighted_path, '/');
                if (ptr)
                        ptr[0]='\0';
        }
}

int read_and_print_clock_one_level(int verbose, int hrow, int selected)
{
        int line = 0, usecount = 0, flags = 0, rate = 0;
//      int parent_dir_row = 1000;
        DIR *dir, *subdir;
        char filename[PATH_MAX], devpath[PATH_MAX], clockname[NAME_MAX];
        struct dirent *item, *subitem;

        (void)verbose;

        print_clock_header(clk_tree_level);

        sprintf(filename, "%s", clk_dir_path);

        dir = opendir(filename);
        if (!dir)
                return 0;

        while ((item = readdir(dir))) {
                /* skip hidden dirs except ".." */
                if (item->d_name[0] == '.' && strcmp(item->d_name, ".."))
                        continue;

                if (selected && hrow == line && !strcmp(item->d_name, "..")) {
                        sprintf(devpath, "%s", clk_dir_path);
                        strcpy(clockname, "..");
                } else {
                        sprintf(devpath, "%s/%s", clk_dir_path, item->d_name);
                        strcpy(clockname, item->d_name);
                }

                subdir = opendir(devpath);

                if (!subdir)
                        continue;

                while ((subitem = readdir(subdir))) {
                        if (subitem->d_name[0] == '.') /* skip hidden files */
                                continue;

                        sprintf(filename, "%s/%s", devpath, subitem->d_name);

                        if (!strcmp(subitem->d_name, "flags"))
                                flags = get_int_from(filename);

                        if (!strcmp(subitem->d_name, "rate"))
                                rate = get_int_from(filename);
        
                        if (!strcmp(subitem->d_name, "usecount"))
                                usecount = get_int_from(filename);
                }

                if (hrow == line) {
                        if (!strcmp(clockname, "..")) {
                                if (clk_tree_level != 1) {
                                        set_hl_dir_path_to_parent();
                                        gadder = -1;
                                } 
                        } else {
                                strcpy(highlighted_path, devpath);
                                gadder = 1;
                        }
                }

//                sprintf(clockname, "%s:dp-%s:n-%s:hp-%s",
//                        clockname, clk_dir_path, clk_name, highlighted_path);

/*                if (strcmp(clockname, "..")) {
                        int row = line + 1;

                        if (line > parent_dir_row)
                                row--;
                        print_clock_info_line(row, clockname, flags, rate, usecount,
                                              (hrow == line) ? 1 : 0);
                } else {
                        print_clock_info_line(0, clockname, flags, rate, usecount,
                                              (hrow == line) ? 1 : 0);
                        parent_dir_row = line;
                }
*/

                print_clock_info_line(line, clockname, flags, rate, usecount,
                                      (hrow == line) ? 1 : 0);
                line++;

                closedir(subdir);
        }

        closedir(dir);

        if (hrow >= (line - 1))
                hrow = -1;
        return hrow;
}

void dump_clock_info(int verbose)
{
        (void)verbose;
        printf("Clock Tree :\n");
        printf("**********\n");
        read_clock_info(clk_dir_path);
        print_clock_info(clocks_info, 1, 1);
}

void read_clock_info(char *clkpath)
{
        DIR *dir;
        struct dirent *item;
        char filename[NAME_MAX], clockname[NAME_MAX];
        struct clock_info *child;
        struct clock_info *cur;

        dir = opendir(clkpath);
        if (!dir)
                return;

        clocks_info = (struct clock_info *)malloc(sizeof(struct clock_info));
        memset(clocks_info, 0, sizeof(clocks_info));
        strcpy(clocks_info->name, "/");

        while ((item = readdir(dir))) {
                /* skip hidden dirs except ".." */
                if (item->d_name[0] == '.')
                        continue;

                strcpy(clockname, item->d_name);
                sprintf(filename, "%s/%s", clkpath, item->d_name);
                cur = (struct clock_info *)malloc(sizeof(struct clock_info));
                memset(cur, 0, sizeof(cur));
                strcpy(cur->name, clockname);
                cur->parent = clocks_info;
                insert_children(&clocks_info, cur);
                child = read_clock_info_recur(filename, 2, cur);
        }
        closedir(dir);
}

struct clock_info *read_clock_info_recur(char *clkpath, int level,
                        struct clock_info *parent)
{
        int ret = 0;
        DIR *dir;
        char filename[PATH_MAX];
        struct dirent *item;
        struct clock_info *cur = NULL;
        struct stat buf;

        dir = opendir(clkpath);
        if (!dir)
                return NULL;

        while ((item = readdir(dir))) {
                struct clock_info *child;
                /* skip hidden dirs except ".." */
                if (item->d_name[0] == '.' )
                        continue;

                sprintf(filename, "%s/%s", clkpath, item->d_name);

                ret = stat(filename, &buf);

                if (ret < 0) {
                        printf("Error doing a stat on %s\n", filename);
                        exit(1);
                }

                if (S_ISREG(buf.st_mode))
                {
                        if (!strcmp(item->d_name, "flags"))
                                parent->flags = get_int_from(filename);
                        if (!strcmp(item->d_name, "rate"))
                                parent->rate = get_int_from(filename);
                        if (!strcmp(item->d_name, "usecount"))
                                parent->usecount = get_int_from(filename);
                        continue;
                }

                if (!S_ISDIR(buf.st_mode))
                        continue;

                cur = (struct clock_info *)malloc(sizeof(struct clock_info));
                memset(cur, 0, sizeof(cur));
                strcpy(cur->name, item->d_name);
                cur->children = NULL;
                cur->parent = NULL;
                cur->num_children = 0;
                child = read_clock_info_recur(filename, level + 1, cur);

                insert_children(&parent, cur);
                cur->parent = parent;
        }
        closedir(dir);

        return cur;
}

void insert_children(struct clock_info **parent, struct clock_info *clk)
{
        if (!(*parent)->children) {
                (*parent)->children = (struct clock_info **)
                                      malloc(sizeof(struct clock_info *)*2);
                (*parent)->num_children = 0;
        } else
                (*parent)->children = (struct clock_info **)
                                      realloc((*parent)->children,
                                      sizeof(struct clock_info *) *
                                      ((*parent)->num_children + 2));
        if ((*parent)->num_children > 0)
                (*parent)->children[(*parent)->num_children - 1]->last_child = 0;
        clk->last_child = 1;
        (*parent)->children[(*parent)->num_children] = clk;
        (*parent)->children[(*parent)->num_children + 1] = NULL;
        (*parent)->num_children++;
}


void print_clock_info(struct clock_info *clk, int level, int bmp)
{
        int i, j;

        if (!clk)
                return;

        for (i = 1, j = 0; i < level; i++, j = (i - 1)) {
                if (i == (level - 1)) {
                        if (clk->last_child)
                                printf("`-- ");
                        else
                                printf("|-- ");
                } else {
                        if ((1<<j) & bmp)
                                printf("|   ");
                        else
                                printf("    ");
                }
        }
        if (clk == clocks_info)
                printf("%s\n", clk->name);
        else {
                char *unit = "Hz";
                double drate = (double)clk->rate;
                
                if (drate > 1000 && drate < 1000000) {
                        unit = "KHz";
                        drate /= 1000;
                }
                if (drate > 1000000) {
                        unit = "MHz";
                        drate /= 1000000;
                }
                printf("%s (flags:%d,usecount:%d,rate:%5.2f %s)\n",
                        clk->name, clk->flags, clk->usecount, drate, unit);
                //printf("%s (flags:%d,usecount:%d,rate:%5.2f %s, bmp=0x%x)\n",
                //        clk->name, clk->flags, clk->usecount, drate, unit, bmp);
        }
        if (clk->children) {
                int tbmp = bmp;
                int xbmp = -1;

                if (clk->last_child) {
                        xbmp ^= 1 << (level - 2 );
        
                        xbmp = tbmp & xbmp;
                } else
                        xbmp = bmp;
                for (i = 0; i<clk->num_children; i++) {
                        //if (clk->children[i]->last_child)
                        tbmp = xbmp | (1<<level);
                        print_clock_info(clk->children[i], level + 1, tbmp);
                }
        } 
}

char *debugfs_locate_mpoint(void)
{
	int ret;
	FILE *filep;
	char **path;
	char fsname[64];
	struct statfs sfs;

	path = likely_mpoints;
	while (*path) {
                ret = statfs(*path, &sfs);
                if (ret >= 0 && sfs.f_type == (long)DEBUGFS_MAGIC)
			return *path;
		path++;
	}

	filep = fopen("/proc/mounts", "r");
	if (filep == NULL) {
		fprintf(stderr, "powerdebug: Error opening /proc/mounts.");
                exit(1);
        }

	while (fscanf(filep, "%*s %s %s %*s %*d %*d\n",
		      debugfs_mntpoint, fsname) == 2)
		if (!strcmp(fsname, "debugfs"))
			break;
	fclose(filep);

	if (strcmp(fsname, "debugfs"))
		return NULL;

	return debugfs_mntpoint;
}