static int msm_bus_rpm_req(int ctx, uint32_t rsc_type, uint32_t key,
struct msm_bus_node_hw_info *hw_info, bool valid)
{
struct msm_rpm_request *rpm_req;
int ret = 0, msg_id;
if (ctx == ACTIVE_CTX)
ctx = MSM_RPM_CTX_ACTIVE_SET;
else if (ctx == DUAL_CTX)
ctx = MSM_RPM_CTX_SLEEP_SET;
rpm_req = msm_rpm_create_request(ctx, rsc_type, hw_info->hw_id, 1);
if (rpm_req == NULL) {
MSM_BUS_WARN("RPM: Couldn't create RPM Request\n");
return -ENXIO;
}
if (valid) {
ret = msm_rpm_add_kvp_data(rpm_req, key, (const uint8_t *)
&hw_info->bw, (int)(sizeof(uint64_t)));
if (ret) {
MSM_BUS_WARN("RPM: Add KVP failed for RPM Req:%u\n",
rsc_type);
goto free_rpm_request;
}
MSM_BUS_DBG("Added Key: %d, Val: %llu, size: %zu\n", key,
hw_info->bw, sizeof(uint64_t));
} else {
/* Invalidate RPM requests */
ret = msm_rpm_add_kvp_data(rpm_req, 0, NULL, 0);
if (ret) {
MSM_BUS_WARN("RPM: Add KVP failed for RPM Req:%u\n",
rsc_type);
goto free_rpm_request;
}
}
msg_id = msm_rpm_send_request(rpm_req);
if (!msg_id) {
MSM_BUS_WARN("RPM: No message ID for req\n");
ret = -ENXIO;
goto free_rpm_request;
}
ret = msm_rpm_wait_for_ack(msg_id);
if (ret) {
MSM_BUS_WARN("RPM: Ack failed\n");
goto free_rpm_request;
}
free_rpm_request:
msm_rpm_free_request(rpm_req);
return ret;
}
static int rpm_write(unsigned long val, unsigned id)
{
int i = 0;
int ret = 0;
struct ocmem_hw_region *region;
region = ®ion_ctrl[id];
for (i = 0; i < region->num_macros; i++) {
unsigned macro_state;
unsigned rpm_state;
macro_state = read_macro_state(id, i);
rpm_state = rpm_macro_state(macro_state);
if (val == REGION_DEFAULT_ON) {
pr_debug("macro (%d) region (%d) -> active\n",
i, id);
rpm_state = rpm_macro_on;
}
if (val == REGION_DEFAULT_OFF) {
pr_debug("macro (%d) region (%d) -> off\n",
i, id);
rpm_state = rpm_macro_off;
}
ret = msm_rpm_add_kvp_data(region->rpm_req, i,
(u8 *) &rpm_state, 4);
if (ret < 0) {
pr_err("ocmem: Error adding key %d val %d on rsc %d\n",
i, rpm_state, id);
return -EINVAL;
}
}
ret = msm_rpm_send_request(region->rpm_req);
if (ret < 0) {
pr_err("ocmem: Error sending RPM request\n");
return -EINVAL;
}
pr_debug("Transmit request to rpm for region %d\n", id);
return 0;
}
static int msm_bus_rpm_req(u32 rsc_type, u32 key, u32 hwid,
int ctx, u32 val)
{
struct msm_rpm_request *rpm_req;
int ret, msg_id;
rpm_req = msm_rpm_create_request(ctx, rsc_type, SPDM_RES_ID, 1);
if (rpm_req == NULL) {
pr_err("RPM: Couldn't create RPM Request\n");
return -ENXIO;
}
ret = msm_rpm_add_kvp_data(rpm_req, key, (const uint8_t *)&val,
(int)(sizeof(uint32_t)));
if (ret) {
pr_err("RPM: Add KVP failed for RPM Req:%u\n",
rsc_type);
goto err;
}
pr_debug("Added Key: %d, Val: %u, size: %zu\n", key,
(uint32_t)val, sizeof(uint32_t));
msg_id = msm_rpm_send_request(rpm_req);
if (!msg_id) {
pr_err("RPM: No message ID for req\n");
ret = -ENXIO;
goto err;
}
ret = msm_rpm_wait_for_ack(msg_id);
if (ret) {
pr_err("RPM: Ack failed\n");
goto err;
}
err:
msm_rpm_free_request(rpm_req);
return ret;
}
static ssize_t rsc_ops_write(struct file *fp, const char __user *user_buffer,
size_t count, loff_t *position)
{
char buf[MAX_MSG_BUFFER], rsc_type_str[6] = {}, rpm_set[8] = {},
key_str[6] = {};
int i, pos, set = -1, nelems;
char *cmp;
uint32_t rsc_type, rsc_id, key, data;
struct msm_rpm_request *req;
count = min(count, sizeof(buf) - 1);
if (copy_from_user(&buf, user_buffer, count))
return -EFAULT;
buf[count] = '\0';
cmp = strstrip(buf);
sscanf(cmp, "%7s %5s %u %d %n", rpm_set, rsc_type_str, &rsc_id,
&nelems, &pos);
if (strlen(rpm_set) > 6 || strlen(rsc_type_str) > 4) {
pr_err("Invalid value of set or resource type\n");
goto err;
}
if (!strcmp(rpm_set, "active"))
set = 0;
else if (!strcmp(rpm_set, "sleep"))
set = 1;
rsc_type = string_to_uint(rsc_type_str);
if (set < 0 || nelems < 0) {
pr_err("Invalid value of set or nelems\n");
goto err;
}
if (nelems > MAX_KEY_VALUE_PAIRS) {
pr_err("Exceeded max no of key-value entries\n");
goto err;
}
req = msm_rpm_create_request(set, rsc_type, rsc_id, nelems);
if (!req)
return -ENOMEM;
for (i = 0; i < nelems; i++) {
cmp += pos;
sscanf(cmp, "%5s %n", key_str, &pos);
if (strlen(key_str) > 4) {
pr_err("Key value cannot be more than 4 charecters");
goto err;
}
key = string_to_uint(key_str);
if (!key) {
pr_err("Key values entered incorrectly\n");
goto err;
}
cmp += pos;
sscanf(cmp, "%u %n", &data, &pos);
if (msm_rpm_add_kvp_data(req, key,
(void *)&data, sizeof(data)))
goto err_request;
}
if (msm_rpm_wait_for_ack(msm_rpm_send_request(req)))
pr_err("Sending the RPM message failed\n");
else
pr_info("RPM message sent succesfully\n");
err_request:
msm_rpm_free_request(req);
err:
return count;
}
static int msm_bus_rpm_req(int ctx, uint32_t rsc_type, uint32_t key,
struct msm_bus_node_hw_info *hw_info, bool valid)
{
struct qcom_msm_bus_req req = {
.key = key,
};
int ret = 0;
if (ctx == ACTIVE_CTX)
ctx = QCOM_SMD_RPM_ACTIVE_STATE;
else if (ctx == DUAL_CTX)
ctx = QCOM_SMD_RPM_SLEEP_STATE;
#if 0
rpm_req = msm_rpm_create_request(ctx, rsc_type, hw_info->hw_id, 1);
if (rpm_req == NULL) {
MSM_BUS_WARN("RPM: Couldn't create RPM Request\n");
return -ENXIO;
}
#endif
if (valid) {
req.value = hw_info->bw;
req.nbytes = sizeof(uint64_t);
#if 0
ret = msm_rpm_add_kvp_data(rpm_req, key, (const uint8_t *)
&hw_info->bw, (int)(sizeof(uint64_t)));
if (ret) {
MSM_BUS_WARN("RPM: Add KVP failed for RPM Req:%u\n",
rsc_type);
goto free_rpm_request;
}
MSM_BUS_DBG("Added Key: %d, Val: %llu, size: %zu\n", key,
hw_info->bw, sizeof(uint64_t));
#endif
} else {
req.value = 0;
req.nbytes = 0;
#if 0
/* Invalidate RPM requests */
ret = msm_rpm_add_kvp_data(rpm_req, 0, NULL, 0);
if (ret) {
MSM_BUS_WARN("RPM: Add KVP failed for RPM Req:%u\n",
rsc_type);
goto free_rpm_request;
}
#endif
}
#if 0
msg_id = msm_rpm_send_request(rpm_req);
if (!msg_id) {
MSM_BUS_WARN("RPM: No message ID for req\n");
ret = -ENXIO;
goto free_rpm_request;
}
ret = msm_rpm_wait_for_ack(msg_id);
if (ret) {
MSM_BUS_WARN("RPM: Ack failed\n");
goto free_rpm_request;
}
free_rpm_request:
msm_rpm_free_request(rpm_req);
#endif
ret = qcom_rpm_bus_send_message(ctx, rsc_type, hw_info->hw_id, &req);
return ret;
}