M7350/kernel/arch/arm/mach-msm/msm_bus/msm_bus_of.c

564 lines
14 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/* Copyright (c) 2012-2013, The Linux Foundation. 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 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) "AXI: %s(): " fmt, __func__
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <mach/msm_bus.h>
#include <mach/msm_bus_board.h>
#include "msm_bus_core.h"
#define KBTOB(a) (a * 1000ULL)
static const char * const hw_sel_name[] = {"RPM", "NoC", "BIMC", NULL};
static const char * const mode_sel_name[] = {"Fixed", "Limiter", "Bypass",
"Regulator", NULL};
static int get_num(const char *const str[], const char *name)
{
int i = 0;
do {
if (!strcmp(name, str[i]))
return i;
i++;
} while (str[i] != NULL);
pr_err("Error: string %s not found\n", name);
return -EINVAL;
}
static struct msm_bus_scale_pdata *get_pdata(struct platform_device *pdev,
struct device_node *of_node)
{
struct msm_bus_scale_pdata *pdata = NULL;
struct msm_bus_paths *usecase = NULL;
int i = 0, j, ret, num_usecases = 0, num_paths, len;
const uint32_t *vec_arr = NULL;
bool mem_err = false;
if (!pdev) {
pr_err("Error: Null Platform device\n");
return NULL;
}
pdata = devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_scale_pdata),
GFP_KERNEL);
if (!pdata) {
pr_err("Error: Memory allocation for pdata failed\n");
mem_err = true;
goto err;
}
ret = of_property_read_string(of_node, "qcom,msm-bus,name",
&pdata->name);
if (ret) {
pr_err("Error: Client name not found\n");
goto err;
}
ret = of_property_read_u32(of_node, "qcom,msm-bus,num-cases",
&num_usecases);
if (ret) {
pr_err("Error: num-usecases not found\n");
goto err;
}
pdata->num_usecases = num_usecases;
if (of_property_read_bool(of_node, "qcom,msm-bus,active-only"))
pdata->active_only = 1;
else {
pr_debug("active_only flag absent.\n");
pr_debug("Using dual context by default\n");
}
usecase = devm_kzalloc(&pdev->dev, (sizeof(struct msm_bus_paths) *
pdata->num_usecases), GFP_KERNEL);
if (!usecase) {
pr_err("Error: Memory allocation for paths failed\n");
mem_err = true;
goto err;
}
ret = of_property_read_u32(of_node, "qcom,msm-bus,num-paths",
&num_paths);
if (ret) {
pr_err("Error: num_paths not found\n");
goto err;
}
vec_arr = of_get_property(of_node, "qcom,msm-bus,vectors-KBps", &len);
if (vec_arr == NULL) {
pr_err("Error: Vector array not found\n");
goto err;
}
if (len != num_usecases * num_paths * sizeof(uint32_t) * 4) {
pr_err("Error: Length-error on getting vectors\n");
goto err;
}
for (i = 0; i < num_usecases; i++) {
usecase[i].num_paths = num_paths;
usecase[i].vectors = devm_kzalloc(&pdev->dev, num_paths *
sizeof(struct msm_bus_vectors), GFP_KERNEL);
if (!usecase[i].vectors) {
mem_err = true;
pr_err("Error: Mem alloc failure in vectors\n");
goto err;
}
for (j = 0; j < num_paths; j++) {
int index = ((i * num_paths) + j) * 4;
usecase[i].vectors[j].src = be32_to_cpu(vec_arr[index]);
usecase[i].vectors[j].dst =
be32_to_cpu(vec_arr[index + 1]);
usecase[i].vectors[j].ab = (uint64_t)
KBTOB(be32_to_cpu(vec_arr[index + 2]));
usecase[i].vectors[j].ib = (uint64_t)
KBTOB(be32_to_cpu(vec_arr[index + 3]));
}
}
pdata->usecase = usecase;
return pdata;
err:
if (mem_err) {
for (; i > 0; i--)
kfree(usecase[i-1].vectors);
kfree(usecase);
kfree(pdata);
}
return NULL;
}
/**
* msm_bus_cl_get_pdata() - Generate bus client data from device tree
* provided by clients.
*
* of_node: Device tree node to extract information from
*
* The function returns a valid pointer to the allocated bus-scale-pdata
* if the vectors were correctly read from the client's device node.
* Any error in reading or parsing the device node will return NULL
* to the caller.
*/
struct msm_bus_scale_pdata *msm_bus_cl_get_pdata(struct platform_device *pdev)
{
struct device_node *of_node;
struct msm_bus_scale_pdata *pdata = NULL;
if (!pdev) {
pr_err("Error: Null Platform device\n");
return NULL;
}
of_node = pdev->dev.of_node;
pdata = get_pdata(pdev, of_node);
if (!pdata) {
pr_err("Error getting bus pdata!\n");
return NULL;
}
return pdata;
}
EXPORT_SYMBOL(msm_bus_cl_get_pdata);
/**
* msm_bus_cl_pdata_from_node() - Generate bus client data from device tree
* node provided by clients. This function should be used when a client
* driver needs to register multiple bus-clients from a single device-tree
* node associated with the platform-device.
*
* of_node: The subnode containing information about the bus scaling
* data
*
* pdev: Platform device associated with the device-tree node
*
* The function returns a valid pointer to the allocated bus-scale-pdata
* if the vectors were correctly read from the client's device node.
* Any error in reading or parsing the device node will return NULL
* to the caller.
*/
struct msm_bus_scale_pdata *msm_bus_pdata_from_node(
struct platform_device *pdev, struct device_node *of_node)
{
struct msm_bus_scale_pdata *pdata = NULL;
if (!pdev) {
pr_err("Error: Null Platform device\n");
return NULL;
}
if (!of_node) {
pr_err("Error: Null of_node passed to bus driver\n");
return NULL;
}
pdata = get_pdata(pdev, of_node);
if (!pdata) {
pr_err("Error getting bus pdata!\n");
return NULL;
}
return pdata;
}
EXPORT_SYMBOL(msm_bus_pdata_from_node);
/**
* msm_bus_cl_clear_pdata() - Clear pdata allocated from device-tree
* of_node: Device tree node to extract information from
*/
void msm_bus_cl_clear_pdata(struct msm_bus_scale_pdata *pdata)
{
int i;
for (i = 0; i < pdata->num_usecases; i++)
kfree(pdata->usecase[i].vectors);
kfree(pdata->usecase);
kfree(pdata);
}
EXPORT_SYMBOL(msm_bus_cl_clear_pdata);
static int *get_arr(struct platform_device *pdev,
const struct device_node *node, const char *prop,
int *nports)
{
int size = 0, ret;
int *arr = NULL;
if (of_get_property(node, prop, &size)) {
*nports = size / sizeof(int);
} else {
pr_debug("Property %s not available\n", prop);
*nports = 0;
return NULL;
}
arr = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
if ((size > 0) && ZERO_OR_NULL_PTR(arr)) {
pr_err("Error: Failed to alloc mem for %s\n", prop);
return NULL;
}
ret = of_property_read_u32_array(node, prop, (u32 *)arr, *nports);
if (ret) {
pr_err("Error in reading property: %s\n", prop);
goto err;
}
return arr;
err:
devm_kfree(&pdev->dev, arr);
return NULL;
}
static struct msm_bus_node_info *get_nodes(struct device_node *of_node,
struct platform_device *pdev,
struct msm_bus_fabric_registration *pdata)
{
struct msm_bus_node_info *info;
struct device_node *child_node = NULL;
int i = 0, ret;
u32 temp;
for_each_child_of_node(of_node, child_node) {
i++;
}
pdata->len = i;
info = (struct msm_bus_node_info *)
devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_node_info) *
pdata->len, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(info)) {
pr_err("Failed to alloc memory for nodes: %d\n", pdata->len);
goto err;
}
i = 0;
child_node = NULL;
for_each_child_of_node(of_node, child_node) {
const char *sel_str;
ret = of_property_read_string(child_node, "label",
&info[i].name);
if (ret)
pr_err("Error reading node label\n");
ret = of_property_read_u32(child_node, "cell-id", &info[i].id);
if (ret) {
pr_err("Error reading node id\n");
goto err;
}
if (of_property_read_bool(child_node, "qcom,gateway"))
info[i].gateway = 1;
of_property_read_u32(child_node, "qcom,mas-hw-id",
&info[i].mas_hw_id);
of_property_read_u32(child_node, "qcom,slv-hw-id",
&info[i].slv_hw_id);
info[i].masterp = get_arr(pdev, child_node,
"qcom,masterp", &info[i].num_mports);
/* No need to store number of qports */
info[i].qport = get_arr(pdev, child_node,
"qcom,qport", &ret);
pdata->nmasters += info[i].num_mports;
info[i].slavep = get_arr(pdev, child_node,
"qcom,slavep", &info[i].num_sports);
pdata->nslaves += info[i].num_sports;
info[i].tier = get_arr(pdev, child_node,
"qcom,tier", &info[i].num_tiers);
if (of_property_read_bool(child_node, "qcom,ahb"))
info[i].ahb = 1;
ret = of_property_read_string(child_node, "qcom,hw-sel",
&sel_str);
if (ret)
info[i].hw_sel = 0;
else {
ret = get_num(hw_sel_name, sel_str);
if (ret < 0) {
pr_err("Invalid hw-sel\n");
goto err;
}
info[i].hw_sel = ret;
}
of_property_read_u32(child_node, "qcom,buswidth",
&info[i].buswidth);
of_property_read_u32(child_node, "qcom,ws", &info[i].ws);
ret = of_property_read_u32(child_node, "qcom,thresh",
&temp);
if (!ret)
info[i].th = (uint64_t)KBTOB(temp);
ret = of_property_read_u32(child_node, "qcom,bimc,bw",
&temp);
if (!ret)
info[i].bimc_bw = (uint64_t)KBTOB(temp);
of_property_read_u32(child_node, "qcom,bimc,gp",
&info[i].bimc_gp);
of_property_read_u32(child_node, "qcom,bimc,thmp",
&info[i].bimc_thmp);
ret = of_property_read_string(child_node, "qcom,mode",
&sel_str);
if (ret)
info[i].mode = 0;
else {
ret = get_num(mode_sel_name, sel_str);
if (ret < 0) {
pr_err("Unknown mode :%s\n", sel_str);
goto err;
}
info[i].mode = ret;
}
info[i].dual_conf =
of_property_read_bool(child_node, "qcom,dual-conf");
ret = of_property_read_string(child_node, "qcom,mode-thresh",
&sel_str);
if (ret)
info[i].mode_thresh = 0;
else {
ret = get_num(mode_sel_name, sel_str);
if (ret < 0) {
pr_err("Unknown mode :%s\n", sel_str);
goto err;
}
info[i].mode_thresh = ret;
MSM_BUS_DBG("AXI: THreshold mode set: %d\n",
info[i].mode_thresh);
}
ret = of_property_read_string(child_node, "qcom,perm-mode",
&sel_str);
if (ret)
info[i].perm_mode = 0;
else {
ret = get_num(mode_sel_name, sel_str);
if (ret < 0)
goto err;
info[i].perm_mode = 1 << ret;
}
of_property_read_u32(child_node, "qcom,prio-lvl",
&info[i].prio_lvl);
of_property_read_u32(child_node, "qcom,prio-rd",
&info[i].prio_rd);
of_property_read_u32(child_node, "qcom,prio-wr",
&info[i].prio_wr);
of_property_read_u32(child_node, "qcom,prio0", &info[i].prio0);
of_property_read_u32(child_node, "qcom,prio1", &info[i].prio1);
ret = of_property_read_string(child_node, "qcom,slaveclk-dual",
&info[i].slaveclk[DUAL_CTX]);
if (!ret)
pr_debug("Got slaveclk_dual: %s\n",
info[i].slaveclk[DUAL_CTX]);
else
info[i].slaveclk[DUAL_CTX] = NULL;
ret = of_property_read_string(child_node,
"qcom,slaveclk-active", &info[i].slaveclk[ACTIVE_CTX]);
if (!ret)
pr_debug("Got slaveclk_active\n");
else
info[i].slaveclk[ACTIVE_CTX] = NULL;
ret = of_property_read_string(child_node, "qcom,memclk-dual",
&info[i].memclk[DUAL_CTX]);
if (!ret)
pr_debug("Got memclk_dual\n");
else
info[i].memclk[DUAL_CTX] = NULL;
ret = of_property_read_string(child_node, "qcom,memclk-active",
&info[i].memclk[ACTIVE_CTX]);
if (!ret)
pr_debug("Got memclk_active\n");
else
info[i].memclk[ACTIVE_CTX] = NULL;
ret = of_property_read_string(child_node, "qcom,iface-clk-node",
&info[i].iface_clk_node);
if (!ret)
pr_debug("Got iface_clk_node\n");
else
info[i].iface_clk_node = NULL;
pr_debug("Node name: %s\n", info[i].name);
of_node_put(child_node);
i++;
}
pr_debug("Bus %d added: %d masters\n", pdata->id, pdata->nmasters);
pr_debug("Bus %d added: %d slaves\n", pdata->id, pdata->nslaves);
return info;
err:
return NULL;
}
struct msm_bus_fabric_registration
*msm_bus_of_get_fab_data(struct platform_device *pdev)
{
struct device_node *of_node;
struct msm_bus_fabric_registration *pdata;
bool mem_err = false;
int ret = 0;
const char *sel_str;
if (!pdev) {
pr_err("Error: Null platform device\n");
return NULL;
}
of_node = pdev->dev.of_node;
pdata = devm_kzalloc(&pdev->dev,
sizeof(struct msm_bus_fabric_registration), GFP_KERNEL);
if (!pdata) {
pr_err("Error: Memory allocation for pdata failed\n");
mem_err = true;
goto err;
}
ret = of_property_read_string(of_node, "label", &pdata->name);
if (ret) {
pr_err("Error: label not found\n");
goto err;
}
pr_debug("Fab_of: Read name: %s\n", pdata->name);
ret = of_property_read_u32(of_node, "cell-id",
&pdata->id);
if (ret) {
pr_err("Error: num-usecases not found\n");
goto err;
}
pr_debug("Fab_of: Read id: %u\n", pdata->id);
if (of_property_read_bool(of_node, "qcom,ahb"))
pdata->ahb = 1;
ret = of_property_read_string(of_node, "qcom,fabclk-dual",
&pdata->fabclk[DUAL_CTX]);
if (ret) {
pr_debug("fabclk_dual not available\n");
pdata->fabclk[DUAL_CTX] = NULL;
} else
pr_debug("Fab_of: Read clk dual ctx: %s\n",
pdata->fabclk[DUAL_CTX]);
ret = of_property_read_string(of_node, "qcom,fabclk-active",
&pdata->fabclk[ACTIVE_CTX]);
if (ret) {
pr_debug("Error: fabclk_active not available\n");
pdata->fabclk[ACTIVE_CTX] = NULL;
} else
pr_debug("Fab_of: Read clk act ctx: %s\n",
pdata->fabclk[ACTIVE_CTX]);
ret = of_property_read_u32(of_node, "qcom,ntieredslaves",
&pdata->ntieredslaves);
if (ret) {
pr_err("Error: ntieredslaves not found\n");
goto err;
}
ret = of_property_read_u32(of_node, "qcom,qos-freq", &pdata->qos_freq);
if (ret)
pr_debug("qos_freq not available\n");
ret = of_property_read_string(of_node, "qcom,hw-sel", &sel_str);
if (ret) {
pr_err("Error: hw_sel not found\n");
goto err;
} else {
ret = get_num(hw_sel_name, sel_str);
if (ret < 0)
goto err;
pdata->hw_sel = ret;
}
if (of_property_read_bool(of_node, "qcom,virt"))
pdata->virt = true;
if (of_property_read_bool(of_node, "qcom,rpm-en"))
pdata->rpm_enabled = 1;
pdata->info = get_nodes(of_node, pdev, pdata);
return pdata;
err:
return NULL;
}
EXPORT_SYMBOL(msm_bus_of_get_fab_data);