int reset_pnodes(int curr, int pnode)
{
struct msm_bus_inode_info *info;
struct msm_bus_fabric_device *fabdev;
int index, next_pnode;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found for: %d\n",
(GET_FABID(curr)));
return -ENXIO;
}
index = GET_INDEX(pnode);
info = fabdev->algo->find_node(fabdev, curr);
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
MSM_BUS_DBG("Starting the loop--remove\n");
do {
struct msm_bus_inode_info *hop;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found\n");
return -ENXIO;
}
next_pnode = info->pnode[index].next;
info->pnode[index].next = -2;
curr = GET_NODE(next_pnode);
index = GET_INDEX(next_pnode);
if (IS_NODE(curr))
hop = fabdev->algo->find_node(fabdev, curr);
else
hop = fabdev->algo->find_gw_node(fabdev, curr);
if (!hop) {
MSM_BUS_ERR("Null Info found for hop\n");
return -ENXIO;
}
MSM_BUS_DBG("%d[%d] = %d\n", info->node_info->priv_id, index,
info->pnode[index].next);
MSM_BUS_DBG("num_pnodes: %d: %d\n", info->node_info->priv_id,
info->num_pnodes);
info = hop;
} while (GET_NODE(info->pnode[index].next) != info->node_info->priv_id);
info->pnode[index].next = -2;
MSM_BUS_DBG("%d[%d] = %d\n", info->node_info->priv_id, index,
info->pnode[index].next);
MSM_BUS_DBG("num_pnodes: %d: %d\n", info->node_info->priv_id,
info->num_pnodes);
return 0;
}
static void setup_nr_limits(int curr, int pnode)
{
struct msm_bus_fabric_device *fabdev =
msm_bus_get_fabric_device(GET_FABID(curr));
struct msm_bus_inode_info *info;
if (!fabdev) {
MSM_BUS_WARN("Fabric Not yet registered. Try again\n");
goto exit_setup_nr_limits;
}
/* This logic is currently applicable to BIMC masters only */
if (fabdev->id != MSM_BUS_FAB_DEFAULT) {
MSM_BUS_ERR("Static limiting of NR masters only for BIMC\n");
goto exit_setup_nr_limits;
}
info = fabdev->algo->find_node(fabdev, curr);
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
goto exit_setup_nr_limits;
}
compute_nr_limits(fabdev, pnode);
exit_setup_nr_limits:
return;
}
static uint64_t get_vfe_bw(void)
{
int vfe_id = MSM_BUS_MASTER_VFE;
int iid = msm_bus_board_get_iid(vfe_id);
int fabid;
struct msm_bus_fabric_device *fabdev;
struct msm_bus_inode_info *info;
uint64_t vfe_bw = 0;
fabid = GET_FABID(iid);
fabdev = msm_bus_get_fabric_device(fabid);
if (!fabdev) {
MSM_BUS_ERR("Fabric not found for: %d\n", fabid);
goto exit_get_vfe_bw;
}
info = fabdev->algo->find_node(fabdev, iid);
if (!info) {
MSM_BUS_ERR("%s: Can't find node %d", __func__,
vfe_id);
goto exit_get_vfe_bw;
}
vfe_bw = get_node_sumab(info);
MSM_BUS_DBG("vfe_ab %llu", vfe_bw);
exit_get_vfe_bw:
return vfe_bw;
}
int msm_bus_board_get_iid(int id)
{
struct msm_bus_fabric_device *deffab;
deffab = msm_bus_get_fabric_device(MSM_BUS_FAB_DEFAULT);
if (!deffab) {
MSM_BUS_ERR("Error finding default fabric\n");
return -ENXIO;
}
return deffab->board_algo->get_iid(id);
}
static uint64_t get_mdp_bw(void)
{
int ids[] = {MSM_BUS_MASTER_MDP_PORT0, MSM_BUS_MASTER_MDP_PORT1};
int i;
uint64_t mdp_ab = 0;
uint32_t ff = 0;
for (i = 0; i < ARRAY_SIZE(ids); i++) {
int iid = msm_bus_board_get_iid(ids[i]);
int fabid;
struct msm_bus_fabric_device *fabdev;
struct msm_bus_inode_info *info;
fabid = GET_FABID(iid);
fabdev = msm_bus_get_fabric_device(fabid);
if (!fabdev) {
MSM_BUS_ERR("Fabric not found for: %d\n", fabid);
continue;
}
info = fabdev->algo->find_node(fabdev, iid);
if (!info) {
MSM_BUS_ERR("%s: Can't find node %d", __func__,
ids[i]);
continue;
}
mdp_ab += get_node_sumab(info);
MSM_BUS_DBG("mdp_ab %llu", mdp_ab);
ff = info->node_info->ff;
}
if (ff) {
mdp_ab = msm_bus_div64(2 * ff, 100 * mdp_ab);
} else {
MSM_BUS_ERR("MDP FF is 0");
mdp_ab = 0;
}
MSM_BUS_DBG("MDP BW %llu\n", mdp_ab);
return mdp_ab;
}
int msm_bus_axi_portunhalt(int master_port)
{
int ret = 0;
int priv_id;
struct msm_bus_fabric_device *fabdev;
priv_id = msm_bus_board_get_iid(master_port);
MSM_BUS_DBG("master_port: %d iid: %d fabid: %d\n",
master_port, priv_id, GET_FABID(priv_id));
fabdev = msm_bus_get_fabric_device(GET_FABID(priv_id));
if (IS_ERR_OR_NULL(fabdev)) {
MSM_BUS_ERR("Fabric device not found for mport: %d\n",
master_port);
return -ENODEV;
}
mutex_lock(&msm_bus_config_lock);
ret = fabdev->algo->port_unhalt(fabdev, priv_id);
mutex_unlock(&msm_bus_config_lock);
return ret;
}
static bool is_nr_lim(int id)
{
struct msm_bus_fabric_device *fabdev = msm_bus_get_fabric_device
(GET_FABID(id));
struct msm_bus_inode_info *info;
bool ret = false;
if (!fabdev) {
MSM_BUS_ERR("Bus device for bus ID: %d not found!\n",
GET_FABID(id));
goto exit_is_nr_lim;
}
info = fabdev->algo->find_node(fabdev, id);
if (!info)
MSM_BUS_ERR("Cannot find node info %d!\n", id);
else if ((info->node_info->nr_lim || info->node_info->rt_mas))
ret = true;
exit_is_nr_lim:
return ret;
}
/**
* msm_bus_scale_register_client() - Register the clients with the msm bus
* driver
* @pdata: Platform data of the client, containing src, dest, ab, ib
*
* Client data contains the vectors specifying arbitrated bandwidth (ab)
* and instantaneous bandwidth (ib) requested between a particular
* src and dest.
*/
uint32_t msm_bus_scale_register_client(struct msm_bus_scale_pdata *pdata)
{
struct msm_bus_client *client = NULL;
int i;
int src, dest, nfab;
struct msm_bus_fabric_device *deffab;
deffab = msm_bus_get_fabric_device(MSM_BUS_FAB_DEFAULT);
if (!deffab) {
MSM_BUS_ERR("Error finding default fabric\n");
return -ENXIO;
}
nfab = msm_bus_get_num_fab();
if (nfab < deffab->board_algo->board_nfab) {
MSM_BUS_ERR("Can't register client!\n"
"Num of fabrics up: %d\n",
nfab);
return 0;
}
if ((!pdata) || (pdata->usecase->num_paths == 0) || IS_ERR(pdata)) {
MSM_BUS_ERR("Cannot register client with null data\n");
return 0;
}
client = kzalloc(sizeof(struct msm_bus_client), GFP_KERNEL);
if (!client) {
MSM_BUS_ERR("Error allocating client\n");
return 0;
}
mutex_lock(&msm_bus_lock);
client->pdata = pdata;
client->curr = -1;
for (i = 0; i < pdata->usecase->num_paths; i++) {
int *pnode;
struct msm_bus_fabric_device *srcfab;
pnode = krealloc(client->src_pnode, ((i + 1) * sizeof(int)),
GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pnode)) {
MSM_BUS_ERR("Invalid Pnode ptr!\n");
continue;
} else
client->src_pnode = pnode;
if (!IS_MASTER_VALID(pdata->usecase->vectors[i].src)) {
MSM_BUS_ERR("Invalid Master ID %d in request!\n",
pdata->usecase->vectors[i].src);
goto err;
}
if (!IS_SLAVE_VALID(pdata->usecase->vectors[i].dst)) {
MSM_BUS_ERR("Invalid Slave ID %d in request!\n",
pdata->usecase->vectors[i].dst);
goto err;
}
src = msm_bus_board_get_iid(pdata->usecase->vectors[i].src);
if (src == -ENXIO) {
MSM_BUS_ERR("Master %d not supported. Client cannot be"
" registered\n",
pdata->usecase->vectors[i].src);
goto err;
}
dest = msm_bus_board_get_iid(pdata->usecase->vectors[i].dst);
if (dest == -ENXIO) {
MSM_BUS_ERR("Slave %d not supported. Client cannot be"
" registered\n",
pdata->usecase->vectors[i].dst);
goto err;
}
srcfab = msm_bus_get_fabric_device(GET_FABID(src));
srcfab->visited = true;
pnode[i] = getpath(src, dest);
bus_for_each_dev(&msm_bus_type, NULL, NULL, clearvisitedflag);
if (pnode[i] == -ENXIO) {
MSM_BUS_ERR("Cannot register client now! Try again!\n");
goto err;
}
}
msm_bus_dbg_client_data(client->pdata, MSM_BUS_DBG_REGISTER,
(uint32_t)client);
mutex_unlock(&msm_bus_lock);
MSM_BUS_DBG("ret: %u num_paths: %d\n", (uint32_t)client,
pdata->usecase->num_paths);
return (uint32_t)(client);
err:
kfree(client->src_pnode);
kfree(client);
mutex_unlock(&msm_bus_lock);
return 0;
}
/**
* update_path() - Update the path with the bandwidth and clock values, as
* requested by the client.
*
* @curr: Current source node, as specified in the client vector (master)
* @pnode: The first-hop node on the path, stored in the internal client struct
* @req_clk: Requested clock value from the vector
* @req_bw: Requested bandwidth value from the vector
* @curr_clk: Current clock frequency
* @curr_bw: Currently allocated bandwidth
*
* This function updates the nodes on the path calculated using getpath(), with
* clock and bandwidth values. The sum of bandwidths, and the max of clock
* frequencies is calculated at each node on the path. Commit data to be sent
* to RPM for each master and slave is also calculated here.
*/
static int update_path(int curr, int pnode, unsigned long req_clk, unsigned
long req_bw, unsigned long curr_clk, unsigned long curr_bw,
unsigned int ctx, unsigned int cl_active_flag)
{
int index, ret = 0;
struct msm_bus_inode_info *info;
int next_pnode;
long int add_bw = req_bw - curr_bw;
unsigned bwsum = 0;
unsigned req_clk_hz, curr_clk_hz, bwsum_hz;
int *master_tiers;
struct msm_bus_fabric_device *fabdev = msm_bus_get_fabric_device
(GET_FABID(curr));
MSM_BUS_DBG("args: %d %d %d %lu %lu %lu %lu %u\n",
curr, GET_NODE(pnode), GET_INDEX(pnode), req_clk, req_bw,
curr_clk, curr_bw, ctx);
index = GET_INDEX(pnode);
MSM_BUS_DBG("Client passed index :%d\n", index);
info = fabdev->algo->find_node(fabdev, curr);
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
info->link_info.sel_bw = &info->link_info.bw[ctx];
info->link_info.sel_clk = &info->link_info.clk[ctx];
*info->link_info.sel_bw += add_bw;
info->pnode[index].sel_bw = &info->pnode[index].bw[ctx];
/**
* To select the right clock, AND the context with
* client active flag.
*/
info->pnode[index].sel_clk = &info->pnode[index].clk[ctx &
cl_active_flag];
*info->pnode[index].sel_bw += add_bw;
info->link_info.num_tiers = info->node_info->num_tiers;
info->link_info.tier = info->node_info->tier;
master_tiers = info->node_info->tier;
do {
struct msm_bus_inode_info *hop;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found\n");
return -ENXIO;
}
MSM_BUS_DBG("id: %d\n", info->node_info->priv_id);
/* find next node and index */
next_pnode = info->pnode[index].next;
curr = GET_NODE(next_pnode);
index = GET_INDEX(next_pnode);
MSM_BUS_DBG("id:%d, next: %d\n", info->
node_info->priv_id, curr);
/* Get hop */
/* check if we are here as gateway, or does the hop belong to
* this fabric */
if (IS_NODE(curr))
hop = fabdev->algo->find_node(fabdev, curr);
else
hop = fabdev->algo->find_gw_node(fabdev, curr);
if (!hop) {
MSM_BUS_ERR("Null Info found for hop\n");
return -ENXIO;
}
hop->link_info.sel_bw = &hop->link_info.bw[ctx];
hop->link_info.sel_clk = &hop->link_info.clk[ctx];
*hop->link_info.sel_bw += add_bw;
hop->pnode[index].sel_bw = &hop->pnode[index].bw[ctx];
hop->pnode[index].sel_clk = &hop->pnode[index].clk[ctx &
cl_active_flag];
if (!hop->node_info->buswidth) {
MSM_BUS_WARN("No bus width found. Using default\n");
hop->node_info->buswidth = 8;
}
*hop->pnode[index].sel_clk = BW_TO_CLK_FREQ_HZ(hop->node_info->
buswidth, req_clk);
*hop->pnode[index].sel_bw += add_bw;
MSM_BUS_DBG("fabric: %d slave: %d, slave-width: %d info: %d\n",
fabdev->id, hop->node_info->priv_id, hop->node_info->
buswidth, info->node_info->priv_id);
/* Update Bandwidth */
fabdev->algo->update_bw(fabdev, hop, info, add_bw,
master_tiers, ctx);
bwsum = (uint16_t)*hop->link_info.sel_bw;
/* Update Fabric clocks */
curr_clk_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
curr_clk);
req_clk_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
req_clk);
bwsum_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
bwsum);
MSM_BUS_DBG("Calling update-clks: curr_hz: %lu, req_hz: %lu,"
" bw_hz %u\n", curr_clk, req_clk, bwsum_hz);
ret = fabdev->algo->update_clks(fabdev, hop, index,
curr_clk_hz, req_clk_hz, bwsum_hz, SEL_FAB_CLK,
ctx, cl_active_flag);
if (ret)
MSM_BUS_WARN("Failed to update clk\n");
info = hop;
} while (GET_NODE(info->pnode[index].next) != info->node_info->priv_id);
/* Update BW, clk after exiting the loop for the last one */
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
/* Update slave clocks */
ret = fabdev->algo->update_clks(fabdev, info, index, curr_clk_hz,
req_clk_hz, bwsum_hz, SEL_SLAVE_CLK, ctx, cl_active_flag);
if (ret)
MSM_BUS_ERR("Failed to update clk\n");
return ret;
}
/**
* getpath() - Finds the path from the topology between src and dest
* @src: Source. This is the master from which the request originates
* @dest: Destination. This is the slave to which we're trying to reach
*
* Function returns: next_pnode_id. The higher 16 bits of the next_pnode_id
* represent the src id of the next node on path. The lower 16 bits of the
* next_pnode_id represent the "index", which is the next entry in the array
* of pnodes for that node to fill in clk and bw values. This is created using
* CREATE_PNODE_ID. The return value is stored in ret_pnode, and this is added
* to the list of path nodes.
*
* This function recursively finds the path by updating the src to the
* closest possible node to dest.
*/
static int getpath(int src, int dest)
{
int pnode_num = -1, i;
struct msm_bus_fabnodeinfo *fabnodeinfo;
struct msm_bus_fabric_device *fabdev;
int next_pnode_id = -1;
struct msm_bus_inode_info *info = NULL;
int _src = src/FABRIC_ID_KEY;
int _dst = dest/FABRIC_ID_KEY;
int ret_pnode = -1;
int fabid = GET_FABID(src);
/* Find the location of fabric for the src */
MSM_BUS_DBG("%d --> %d\n", src, dest);
fabdev = msm_bus_get_fabric_device(fabid);
if (!fabdev) {
MSM_BUS_WARN("Fabric Not yet registered. Try again\n");
return -ENXIO;
}
/* Are we there yet? */
if (src == dest) {
info = fabdev->algo->find_node(fabdev, src);
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Node %d not found\n", dest);
return -ENXIO;
}
for (i = 0; i <= info->num_pnodes; i++) {
if (info->pnode[i].next == -2) {
MSM_BUS_DBG("src = dst Reusing pnode for"
" info: %d at index: %d\n",
info->node_info->priv_id, i);
next_pnode_id = CREATE_PNODE_ID(src, i);
info->pnode[i].clk[DUAL_CTX] = 0;
info->pnode[i].bw[DUAL_CTX] = 0;
info->pnode[i].next = next_pnode_id;
MSM_BUS_DBG("returning: %d, %d\n", GET_NODE
(next_pnode_id), GET_INDEX(next_pnode_id));
return next_pnode_id;
}
}
next_pnode_id = CREATE_PNODE_ID(src, (info->num_pnodes + 1));
pnode_num = add_path_node(info, next_pnode_id);
if (pnode_num < 0) {
MSM_BUS_ERR("Error adding path node\n");
return -ENXIO;
}
MSM_BUS_DBG("returning: %d, %d\n", GET_NODE(next_pnode_id),
GET_INDEX(next_pnode_id));
return next_pnode_id;
} else if (_src == _dst) {
/*
* src and dest belong to same fabric, find the destination
* from the radix tree
*/
info = fabdev->algo->find_node(fabdev, dest);
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Node %d not found\n", dest);
return -ENXIO;
}
ret_pnode = getpath(info->node_info->priv_id, dest);
next_pnode_id = ret_pnode;
} else {
/* find the dest fabric */
int trynextgw = true;
struct list_head *gateways = fabdev->algo->get_gw_list(fabdev);
list_for_each_entry(fabnodeinfo, gateways, list) {
/* see if the destination is at a connected fabric */
if (_dst == (fabnodeinfo->info->node_info->priv_id /
FABRIC_ID_KEY)) {
/* Found the fab on which the device exists */
info = fabnodeinfo->info;
trynextgw = false;
ret_pnode = getpath(info->node_info->priv_id,
dest);
pnode_num = add_path_node(info, ret_pnode);
if (pnode_num < 0) {
MSM_BUS_ERR("Error adding path node\n");
return -ENXIO;
}
next_pnode_id = CREATE_PNODE_ID(
info->node_info->priv_id, pnode_num);
break;
}
}
/* find the gateway */
if (trynextgw) {
gateways = fabdev->algo->get_gw_list(fabdev);
list_for_each_entry(fabnodeinfo, gateways, list) {
struct msm_bus_fabric_device *gwfab =
msm_bus_get_fabric_device(fabnodeinfo->
info->node_info->priv_id);
if (!gwfab->visited) {
MSM_BUS_DBG("VISITED ID: %d\n",
gwfab->id);
gwfab->visited = true;
info = fabnodeinfo->info;
ret_pnode = getpath(info->
node_info->priv_id, dest);
pnode_num = add_path_node(info,
ret_pnode);
if (pnode_num < 0) {
MSM_BUS_ERR("Malloc failure in"
" adding path node\n");
return -ENXIO;
}
next_pnode_id = CREATE_PNODE_ID(
info->node_info->priv_id, pnode_num);
break;
}
}
if (next_pnode_id < 0)
return -ENXIO;
}
}
if (!IS_NODE(src)) {
MSM_BUS_DBG("Returning next_pnode_id:%d[%d]\n", GET_NODE(
next_pnode_id), GET_INDEX(next_pnode_id));
return next_pnode_id;
}
info = fabdev->algo->find_node(fabdev, src);
if (!info) {
MSM_BUS_ERR("Node info not found.\n");
return -ENXIO;
}
pnode_num = add_path_node(info, next_pnode_id);
MSM_BUS_DBG(" Last: %d[%d] = (%d, %d)\n",
src, info->num_pnodes, GET_NODE(next_pnode_id),
GET_INDEX(next_pnode_id));
MSM_BUS_DBG("returning: %d, %d\n", src, pnode_num);
return CREATE_PNODE_ID(src, pnode_num);
}
/**
* msm_bus_scale_client_update_request() - Update the request for bandwidth
* from a particular client
*
* cl: Handle to the client
* index: Index into the vector, to which the bw and clock values need to be
* updated
*/
int msm_bus_scale_client_update_request(uint32_t cl, unsigned index)
{
int i, ret = 0;
struct msm_bus_scale_pdata *pdata;
int pnode, src, curr, ctx;
uint64_t req_clk, req_bw, curr_clk, curr_bw;
struct msm_bus_client *client = (struct msm_bus_client *)cl;
#ifdef DEBUG_MSM_BUS_ARB_REQ
static int log_cnt = 0;
#endif
if (IS_ERR_OR_NULL(client)) {
MSM_BUS_ERR("msm_bus_scale_client update req error %d\n",
(uint32_t)client);
return -ENXIO;
}
#ifdef SEC_FEATURE_USE_RT_MUTEX
rt_mutex_lock(&msm_bus_lock);
#else
mutex_lock(&msm_bus_lock);
#endif
if (client->curr == index)
goto err;
curr = client->curr;
pdata = client->pdata;
if (!pdata) {
MSM_BUS_ERR("Null pdata passed to update-request\n");
return -ENXIO;
}
if (index >= pdata->num_usecases) {
MSM_BUS_ERR("Client %u passed invalid index: %d\n",
(uint32_t)client, index);
ret = -ENXIO;
goto err;
}
MSM_BUS_DBG("cl: %u index: %d curr: %d num_paths: %d\n",
cl, index, client->curr, client->pdata->usecase->num_paths);
for (i = 0; i < pdata->usecase->num_paths; i++) {
src = msm_bus_board_get_iid(client->pdata->usecase[index].
vectors[i].src);
if (src == -ENXIO) {
MSM_BUS_ERR("Master %d not supported. Request cannot"
" be updated\n", client->pdata->usecase->
vectors[i].src);
goto err;
}
if (msm_bus_board_get_iid(client->pdata->usecase[index].
vectors[i].dst) == -ENXIO) {
MSM_BUS_ERR("Slave %d not supported. Request cannot"
" be updated\n", client->pdata->usecase->
vectors[i].dst);
}
pnode = client->src_pnode[i];
req_clk = client->pdata->usecase[index].vectors[i].ib;
req_bw = client->pdata->usecase[index].vectors[i].ab;
#ifdef DEBUG_MSM_BUS_ARB_REQ
//Debug code to collect client info
{
struct msm_bus_fabric_device *fabdev_d = msm_bus_get_fabric_device(GET_FABID(src));
if (MSM_BUS_FAB_APPSS == fabdev_d->id)
{
if (log_cnt >= 1000)
log_cnt = 0;
log_req[log_cnt].ab = client->pdata->usecase[index].vectors[i].ab;
log_req[log_cnt].ib = client->pdata->usecase[index].vectors[i].ib;
log_req[log_cnt].src = client->pdata->usecase[index].vectors[i].src;
log_req[log_cnt].dst = client->pdata->usecase[index].vectors[i].dst;
log_req[log_cnt].cnt = arch_counter_get_cntpct();
strncpy(log_req[log_cnt].name, client->pdata->name, 19);
log_cnt++;
//printk("*** cl: %s ab: %llu ib: %llu\n", client->pdata->name, req_bw, req_clk);
}
}
#endif
if (curr < 0) {
curr_clk = 0;
curr_bw = 0;
} else {
curr_clk = client->pdata->usecase[curr].vectors[i].ib;
curr_bw = client->pdata->usecase[curr].vectors[i].ab;
MSM_BUS_DBG("ab: %llu ib: %llu\n", curr_bw, curr_clk);
}
if (!pdata->active_only) {
ret = update_path(src, pnode, req_clk, req_bw,
curr_clk, curr_bw, 0, pdata->active_only);
if (ret) {
MSM_BUS_ERR("Update path failed! %d\n", ret);
goto err;
}
}
ret = update_path(src, pnode, req_clk, req_bw, curr_clk,
curr_bw, ACTIVE_CTX, pdata->active_only);
if (ret) {
MSM_BUS_ERR("Update Path failed! %d\n", ret);
goto err;
}
}
client->curr = index;
ctx = ACTIVE_CTX;
msm_bus_dbg_client_data(client->pdata, index, cl);
bus_for_each_dev(&msm_bus_type, NULL, NULL, msm_bus_commit_fn);
err:
#ifdef SEC_FEATURE_USE_RT_MUTEX
rt_mutex_unlock(&msm_bus_lock);
#else
mutex_unlock(&msm_bus_lock);
#endif
return ret;
}
/**
* update_path() - Update the path with the bandwidth and clock values, as
* requested by the client.
*
* @curr: Current source node, as specified in the client vector (master)
* @pnode: The first-hop node on the path, stored in the internal client struct
* @req_clk: Requested clock value from the vector
* @req_bw: Requested bandwidth value from the vector
* @curr_clk: Current clock frequency
* @curr_bw: Currently allocated bandwidth
*
* This function updates the nodes on the path calculated using getpath(), with
* clock and bandwidth values. The sum of bandwidths, and the max of clock
* frequencies is calculated at each node on the path. Commit data to be sent
* to RPM for each master and slave is also calculated here.
*/
static int update_path(int curr, int pnode, uint64_t req_clk, uint64_t req_bw,
uint64_t curr_clk, uint64_t curr_bw, unsigned int ctx, unsigned int
cl_active_flag)
{
int index, ret = 0;
struct msm_bus_inode_info *info;
int next_pnode;
int64_t add_bw = req_bw - curr_bw;
uint64_t bwsum = 0;
uint64_t req_clk_hz, curr_clk_hz, bwsum_hz;
int *master_tiers;
struct msm_bus_fabric_device *fabdev = msm_bus_get_fabric_device
(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Bus device for bus ID: %d not found!\n",
GET_FABID(curr));
return -ENXIO;
}
MSM_BUS_DBG("args: %d %d %d %llu %llu %llu %llu %u\n",
curr, GET_NODE(pnode), GET_INDEX(pnode), req_clk, req_bw,
curr_clk, curr_bw, ctx);
index = GET_INDEX(pnode);
MSM_BUS_DBG("Client passed index :%d\n", index);
info = fabdev->algo->find_node(fabdev, curr);
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
#ifndef CONFIG_BW_LIMITER_FIX
/**
* If master supports dual configuration, check if
* the configuration needs to be changed based on
* incoming requests
*/
if (info->node_info->dual_conf)
fabdev->algo->config_master(fabdev, info,
req_clk, req_bw);
#endif
info->link_info.sel_bw = &info->link_info.bw[ctx];
info->link_info.sel_clk = &info->link_info.clk[ctx];
*info->link_info.sel_bw += add_bw;
info->pnode[index].sel_bw = &info->pnode[index].bw[ctx];
/**
* To select the right clock, AND the context with
* client active flag.
*/
info->pnode[index].sel_clk = &info->pnode[index].clk[ctx &
cl_active_flag];
*info->pnode[index].sel_bw += add_bw;
#ifdef CONFIG_BW_LIMITER_FIX
*info->pnode[index].sel_clk = req_clk;
/**
* If master supports dual configuration, check if
* the configuration needs to be changed based on
* incoming requests
*/
if (info->node_info->dual_conf) {
uint64_t node_maxib = 0;
node_maxib = get_node_maxib(info);
fabdev->algo->config_master(fabdev, info,
node_maxib, req_bw);
}
#endif
info->link_info.num_tiers = info->node_info->num_tiers;
info->link_info.tier = info->node_info->tier;
master_tiers = info->node_info->tier;
do {
struct msm_bus_inode_info *hop;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found\n");
return -ENXIO;
}
MSM_BUS_DBG("id: %d\n", info->node_info->priv_id);
/* find next node and index */
next_pnode = info->pnode[index].next;
curr = GET_NODE(next_pnode);
index = GET_INDEX(next_pnode);
MSM_BUS_DBG("id:%d, next: %d\n", info->
node_info->priv_id, curr);
/* Get hop */
/* check if we are here as gateway, or does the hop belong to
* this fabric */
if (IS_NODE(curr))
hop = fabdev->algo->find_node(fabdev, curr);
else
hop = fabdev->algo->find_gw_node(fabdev, curr);
if (!hop) {
MSM_BUS_ERR("Null Info found for hop\n");
return -ENXIO;
}
hop->link_info.sel_bw = &hop->link_info.bw[ctx];
hop->link_info.sel_clk = &hop->link_info.clk[ctx];
*hop->link_info.sel_bw += add_bw;
hop->pnode[index].sel_bw = &hop->pnode[index].bw[ctx];
hop->pnode[index].sel_clk = &hop->pnode[index].clk[ctx &
cl_active_flag];
if (!hop->node_info->buswidth) {
MSM_BUS_WARN("No bus width found. Using default\n");
hop->node_info->buswidth = 8;
}
*hop->pnode[index].sel_clk = BW_TO_CLK_FREQ_HZ(hop->node_info->
buswidth, req_clk);
*hop->pnode[index].sel_bw += add_bw;
MSM_BUS_DBG("fabric: %d slave: %d, slave-width: %d info: %d\n",
fabdev->id, hop->node_info->priv_id, hop->node_info->
buswidth, info->node_info->priv_id);
/* Update Bandwidth */
fabdev->algo->update_bw(fabdev, hop, info, add_bw,
master_tiers, ctx);
bwsum = *hop->link_info.sel_bw;
/* Update Fabric clocks */
curr_clk_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
curr_clk);
req_clk_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
req_clk);
bwsum_hz = BW_TO_CLK_FREQ_HZ(hop->node_info->buswidth,
bwsum);
/* Account for multiple channels if any */
if (hop->node_info->num_sports > 1)
bwsum_hz = msm_bus_div64(hop->node_info->num_sports,
bwsum_hz);
MSM_BUS_DBG("AXI: Hop: %d, ports: %d, bwsum_hz: %llu\n",
hop->node_info->id, hop->node_info->num_sports,
bwsum_hz);
MSM_BUS_DBG("up-clk: curr_hz: %llu, req_hz: %llu, bw_hz %llu\n",
curr_clk, req_clk, bwsum_hz);
ret = fabdev->algo->update_clks(fabdev, hop, index,
curr_clk_hz, req_clk_hz, bwsum_hz, SEL_FAB_CLK,
ctx, cl_active_flag);
if (ret)
MSM_BUS_WARN("Failed to update clk\n");
info = hop;
} while (GET_NODE(info->pnode[index].next) != info->node_info->priv_id);
/* Update BW, clk after exiting the loop for the last one */
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
/* Update slave clocks */
ret = fabdev->algo->update_clks(fabdev, info, index, curr_clk_hz,
req_clk_hz, bwsum_hz, SEL_SLAVE_CLK, ctx, cl_active_flag);
if (ret)
MSM_BUS_ERR("Failed to update clk\n");
return ret;
}
