static int send_rpm_msg(struct device *device)
{
int ret = 0;
int ctx;
int rsc_type;
struct msm_bus_node_device_type *ndev =
device->platform_data;
struct msm_rpm_kvp rpm_kvp;
if (!ndev) {
MSM_BUS_ERR("%s: Error getting node info.", __func__);
ret = -ENODEV;
goto exit_send_rpm_msg;
}
rpm_kvp.length = sizeof(uint64_t);
rpm_kvp.key = RPM_MASTER_FIELD_BW;
for (ctx = MSM_RPM_CTX_ACTIVE_SET; ctx <= MSM_RPM_CTX_SLEEP_SET;
ctx++) {
if (ctx == MSM_RPM_CTX_ACTIVE_SET)
rpm_kvp.data =
(uint8_t *)&ndev->node_ab.ab[MSM_RPM_CTX_ACTIVE_SET];
else {
rpm_kvp.data =
(uint8_t *) &ndev->node_ab.ab[MSM_RPM_CTX_SLEEP_SET];
}
if (ndev->node_info->mas_rpm_id != -1) {
rsc_type = RPM_BUS_MASTER_REQ;
ret = msm_rpm_send_message(ctx, rsc_type,
ndev->node_info->mas_rpm_id, &rpm_kvp, 1);
if (ret) {
MSM_BUS_ERR("%s: Failed to send RPM message:",
__func__);
MSM_BUS_ERR("%s:Node Id %d RPM id %d",
__func__, ndev->node_info->id,
ndev->node_info->mas_rpm_id);
goto exit_send_rpm_msg;
}
}
if (ndev->node_info->slv_rpm_id != -1) {
rsc_type = RPM_BUS_SLAVE_REQ;
ret = msm_rpm_send_message(ctx, rsc_type,
ndev->node_info->slv_rpm_id, &rpm_kvp, 1);
if (ret) {
MSM_BUS_ERR("%s: Failed to send RPM message:",
__func__);
MSM_BUS_ERR("%s: Node Id %d RPM id %d",
__func__, ndev->node_info->id,
ndev->node_info->slv_rpm_id);
goto exit_send_rpm_msg;
}
}
}
exit_send_rpm_msg:
return ret;
}
static int clk_rpmrs_set_rate_smd(struct rpm_clk *r, uint32_t value,
uint32_t context)
{
struct msm_rpm_kvp kvp = {
.key = r->rpm_key,
.data = (void *)&value,
.length = sizeof(value),
};
return msm_rpm_send_message(context, r->rpm_res_type, r->rpm_clk_id,
&kvp, 1);
}
static int clk_rpmrs_handoff_smd(struct rpm_clk *r)
{
if (!r->branch)
r->c.rate = INT_MAX;
return 0;
}
static int clk_rpmrs_is_enabled_smd(struct rpm_clk *r)
{
return !!r->c.prepare_count;
}
struct clk_rpmrs_data {
int (*set_rate_fn)(struct rpm_clk *r, uint32_t value, uint32_t context);
int (*get_rate_fn)(struct rpm_clk *r);
int (*handoff_fn)(struct rpm_clk *r);
int (*is_enabled)(struct rpm_clk *r);
int ctx_active_id;
int ctx_sleep_id;
};
struct clk_rpmrs_data clk_rpmrs_data_smd = {
.set_rate_fn = clk_rpmrs_set_rate_smd,
.handoff_fn = clk_rpmrs_handoff_smd,
.is_enabled = clk_rpmrs_is_enabled_smd,
.ctx_active_id = MSM_RPM_CTX_ACTIVE_SET,
.ctx_sleep_id = MSM_RPM_CTX_SLEEP_SET,
};
static DEFINE_MUTEX(rpm_clock_lock);
static void to_active_sleep_khz(struct rpm_clk *r, unsigned long rate,
unsigned long *active_khz, unsigned long *sleep_khz)
{
/* Convert the rate (hz) to khz */
*active_khz = DIV_ROUND_UP(rate, 1000);
/*
* Active-only clocks don't care what the rate is during sleep. So,
* they vote for zero.
*/
if (r->active_only)
*sleep_khz = 0;
else
*sleep_khz = *active_khz;
}
static int clk_rpmrs_set_rate(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq)
{
struct msm_rpm_iv_pair iv = {
.id = r->rpm_clk_id,
.value = value,
};
if (noirq)
return msm_rpmrs_set_noirq(context, &iv, 1);
else
return msm_rpmrs_set(context, &iv, 1);
}
static int clk_rpmrs_get_rate(struct rpm_clk *r)
{
int rc;
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
rc = msm_rpm_get_status(&iv, 1);
return (rc < 0) ? rc : iv.value * r->factor;
}
static int clk_rpmrs_set_rate_smd(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq)
{
struct msm_rpm_kvp kvp = {
.key = r->rpm_key,
.data = (void *)&value,
.length = sizeof(value),
};
if (noirq)
return msm_rpm_send_message_noirq(context,
r->rpm_res_type, r->rpm_clk_id, &kvp, 1);
else
return msm_rpm_send_message(context, r->rpm_res_type,
r->rpm_clk_id, &kvp, 1);
}
struct clk_rpmrs_data {
int (*set_rate_fn)(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq);
int (*get_rate_fn)(struct rpm_clk *r);
int ctx_active_id;
int ctx_sleep_id;
};
struct clk_rpmrs_data clk_rpmrs_data = {
.set_rate_fn = clk_rpmrs_set_rate,
.get_rate_fn = clk_rpmrs_get_rate,
.ctx_active_id = MSM_RPM_CTX_SET_0,
.ctx_sleep_id = MSM_RPM_CTX_SET_SLEEP,
};
struct clk_rpmrs_data clk_rpmrs_data_smd = {
.set_rate_fn = clk_rpmrs_set_rate_smd,
.ctx_active_id = MSM_RPM_CTX_ACTIVE_SET,
.ctx_sleep_id = MSM_RPM_CTX_SLEEP_SET,
};
static DEFINE_SPINLOCK(rpm_clock_lock);
static int rpm_clk_enable(struct clk *clk)
{
unsigned long flags;
struct rpm_clk *r = to_rpm_clk(clk);
uint32_t value;
int rc = 0;
unsigned long this_khz, this_sleep_khz;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
struct rpm_clk *peer = r->peer;
spin_lock_irqsave(&rpm_clock_lock, flags);
this_khz = r->last_set_khz;
/* Don't send requests to the RPM if the rate has not been set. */
if (this_khz == 0)
goto out;
this_sleep_khz = r->last_set_sleep_khz;
/* Take peer clock's rate into account only if it's enabled. */
if (peer->enabled) {
peer_khz = peer->last_set_khz;
peer_sleep_khz = peer->last_set_sleep_khz;
}
value = max(this_khz, peer_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_active_noirq(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_sleep_noirq(r, value);
if (rc) {
/* Undo the active set vote and restore it to peer_khz */
value = peer_khz;
rc = clk_rpmrs_set_rate_active_noirq(r, value);
}
out:
if (!rc)
r->enabled = true;
spin_unlock_irqrestore(&rpm_clock_lock, flags);
return rc;
}
static void rpm_clk_disable(struct clk *clk)
{
unsigned long flags;
struct rpm_clk *r = to_rpm_clk(clk);
spin_lock_irqsave(&rpm_clock_lock, flags);
if (r->last_set_khz) {
uint32_t value;
struct rpm_clk *peer = r->peer;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
int rc;
/* Take peer clock's rate into account only if it's enabled. */
if (peer->enabled) {
peer_khz = peer->last_set_khz;
peer_sleep_khz = peer->last_set_sleep_khz;
}
value = r->branch ? !!peer_khz : peer_khz;
rc = clk_rpmrs_set_rate_active_noirq(r, value);
if (rc)
goto out;
value = r->branch ? !!peer_sleep_khz : peer_sleep_khz;
rc = clk_rpmrs_set_rate_sleep_noirq(r, value);
}
r->enabled = false;
out:
spin_unlock_irqrestore(&rpm_clock_lock, flags);
return;
}
static int clk_rpmrs_set_rate(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq)
{
struct msm_rpm_iv_pair iv = {
.id = r->rpm_clk_id,
.value = value,
};
if (noirq)
return msm_rpmrs_set_noirq(context, &iv, 1);
else
return msm_rpmrs_set(context, &iv, 1);
}
static int clk_rpmrs_get_rate(struct rpm_clk *r)
{
int rc;
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
rc = msm_rpm_get_status(&iv, 1);
return (rc < 0) ? rc : iv.value * r->factor;
}
#define RPM_SMD_KEY_RATE 0x007A484B
#define RPM_SMD_KEY_ENABLE 0x62616E45
static int clk_rpmrs_set_rate_smd(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq)
{
u32 rpm_key = r->branch ? RPM_SMD_KEY_ENABLE : RPM_SMD_KEY_RATE;
struct msm_rpm_kvp kvp = {
.key = rpm_key,
.data = (void *)&value,
.length = sizeof(value),
};
if (noirq)
return msm_rpm_send_message_noirq(context,
r->rpm_res_type, r->rpm_clk_id, &kvp, 1);
else
return msm_rpm_send_message(context, r->rpm_res_type,
r->rpm_clk_id, &kvp, 1);
}
struct clk_rpmrs_data {
int (*set_rate_fn)(struct rpm_clk *r, uint32_t value,
uint32_t context, int noirq);
int (*get_rate_fn)(struct rpm_clk *r);
int ctx_active_id;
int ctx_sleep_id;
};
struct clk_rpmrs_data clk_rpmrs_data = {
.set_rate_fn = clk_rpmrs_set_rate,
.get_rate_fn = clk_rpmrs_get_rate,
.ctx_active_id = MSM_RPM_CTX_SET_0,
.ctx_sleep_id = MSM_RPM_CTX_SET_SLEEP,
};
struct clk_rpmrs_data clk_rpmrs_data_smd = {
.set_rate_fn = clk_rpmrs_set_rate_smd,
.ctx_active_id = MSM_RPM_CTX_ACTIVE_SET,
.ctx_sleep_id = MSM_RPM_CTX_SLEEP_SET,
};
static DEFINE_SPINLOCK(rpm_clock_lock);
static int rpm_clk_enable(struct clk *clk)
{
unsigned long flags;
struct rpm_clk *r = to_rpm_clk(clk);
uint32_t value;
int rc = 0;
unsigned long this_khz, this_sleep_khz;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
struct rpm_clk *peer = r->peer;
spin_lock_irqsave(&rpm_clock_lock, flags);
this_khz = r->last_set_khz;
if (this_khz == 0)
goto out;
this_sleep_khz = r->last_set_sleep_khz;
if (peer->enabled) {
peer_khz = peer->last_set_khz;
peer_sleep_khz = peer->last_set_sleep_khz;
}
value = max(this_khz, peer_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_active_noirq(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_sleep_noirq(r, value);
if (rc) {
value = peer_khz;
rc = clk_rpmrs_set_rate_active_noirq(r, value);
}
out:
if (!rc)
r->enabled = true;
spin_unlock_irqrestore(&rpm_clock_lock, flags);
return rc;
}
static int clk_rpmrs_set_rate(struct rpm_clk *r, uint32_t value,
uint32_t context)
{
struct msm_rpm_iv_pair iv = {
.id = r->rpm_clk_id,
.value = value,
};
return msm_rpmrs_set(context, &iv, 1);
}
static int clk_rpmrs_get_rate(struct rpm_clk *r)
{
int rc;
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
rc = msm_rpm_get_status(&iv, 1);
return (rc < 0) ? rc : iv.value * 1000;
}
static int clk_rpmrs_handoff(struct rpm_clk *r)
{
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
int rc = msm_rpm_get_status(&iv, 1);
if (rc < 0)
return rc;
if (!r->branch)
r->c.rate = iv.value * 1000;
return 0;
}
static int clk_rpmrs_set_rate_smd(struct rpm_clk *r, uint32_t value,
uint32_t context)
{
struct msm_rpm_kvp kvp = {
.key = r->rpm_key,
.data = (void *)&value,
.length = sizeof(value),
};
return msm_rpm_send_message(context, r->rpm_res_type, r->rpm_clk_id,
&kvp, 1);
}
static int clk_rpmrs_handoff_smd(struct rpm_clk *r)
{
if (!r->branch)
r->c.rate = INT_MAX;
return 0;
}
struct clk_rpmrs_data {
int (*set_rate_fn)(struct rpm_clk *r, uint32_t value, uint32_t context);
int (*get_rate_fn)(struct rpm_clk *r);
int (*handoff_fn)(struct rpm_clk *r);
int ctx_active_id;
int ctx_sleep_id;
};
struct clk_rpmrs_data clk_rpmrs_data = {
.set_rate_fn = clk_rpmrs_set_rate,
.get_rate_fn = clk_rpmrs_get_rate,
.handoff_fn = clk_rpmrs_handoff,
.ctx_active_id = MSM_RPM_CTX_SET_0,
.ctx_sleep_id = MSM_RPM_CTX_SET_SLEEP,
};
struct clk_rpmrs_data clk_rpmrs_data_smd = {
.set_rate_fn = clk_rpmrs_set_rate_smd,
.handoff_fn = clk_rpmrs_handoff_smd,
.ctx_active_id = MSM_RPM_CTX_ACTIVE_SET,
.ctx_sleep_id = MSM_RPM_CTX_SLEEP_SET,
};
static DEFINE_MUTEX(rpm_clock_lock);
static void to_active_sleep_khz(struct rpm_clk *r, unsigned long rate,
unsigned long *active_khz, unsigned long *sleep_khz)
{
/* Convert the rate (hz) to khz */
*active_khz = DIV_ROUND_UP(rate, 1000);
/*
* Active-only clocks don't care what the rate is during sleep. So,
* they vote for zero.
*/
if (r->active_only)
*sleep_khz = 0;
else
*sleep_khz = *active_khz;
}
static int rpm_clk_prepare(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
uint32_t value;
int rc = 0;
unsigned long this_khz, this_sleep_khz;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
struct rpm_clk *peer = r->peer;
mutex_lock(&rpm_clock_lock);
to_active_sleep_khz(r, r->c.rate, &this_khz, &this_sleep_khz);
/* Don't send requests to the RPM if the rate has not been set. */
if (this_khz == 0)
goto out;
/* Take peer clock's rate into account only if it's enabled. */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = max(this_khz, peer_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_sleep(r, value);
if (rc) {
/* Undo the active set vote and restore it to peer_khz */
value = peer_khz;
rc = clk_rpmrs_set_rate_active(r, value);
}
out:
if (!rc)
r->enabled = true;
mutex_unlock(&rpm_clock_lock);
return rc;
}
static void rpm_clk_unprepare(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
mutex_lock(&rpm_clock_lock);
if (r->c.rate) {
uint32_t value;
struct rpm_clk *peer = r->peer;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
int rc;
/* Take peer clock's rate into account only if it's enabled. */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = r->branch ? !!peer_khz : peer_khz;
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = r->branch ? !!peer_sleep_khz : peer_sleep_khz;
rc = clk_rpmrs_set_rate_sleep(r, value);
}
r->enabled = false;
out:
mutex_unlock(&rpm_clock_lock);
return;
}
static int rpm_clk_set_rate(struct clk *clk, unsigned long rate)
{
struct rpm_clk *r = to_rpm_clk(clk);
unsigned long this_khz, this_sleep_khz;
int rc = 0;
mutex_lock(&rpm_clock_lock);
if (r->enabled) {
uint32_t value;
struct rpm_clk *peer = r->peer;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
to_active_sleep_khz(r, rate, &this_khz, &this_sleep_khz);
/* Take peer clock's rate into account only if it's enabled. */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = max(this_khz, peer_khz);
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
rc = clk_rpmrs_set_rate_sleep(r, value);
}
out:
mutex_unlock(&rpm_clock_lock);
return rc;
}
static int rpm_branch_clk_set_rate(struct clk *clk, unsigned long rate)
{
if (rate == clk->rate)
return 0;
return -EPERM;
}
static unsigned long rpm_clk_get_rate(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
if (r->rpmrs_data->get_rate_fn)
return r->rpmrs_data->get_rate_fn(r);
else
return clk->rate;
}
static int rpm_clk_is_enabled(struct clk *clk)
{
return !!(rpm_clk_get_rate(clk));
}
static long rpm_clk_round_rate(struct clk *clk, unsigned long rate)
{
/* Not supported. */
return rate;
}
static bool rpm_clk_is_local(struct clk *clk)
{
return false;
}
static enum handoff rpm_clk_handoff(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
int rc;
/*
* Querying an RPM clock's status will return 0 unless the clock's
* rate has previously been set through the RPM. When handing off,
* assume these clocks are enabled (unless the RPM call fails) so
* child clocks of these RPM clocks can still be handed off.
*/
rc = r->rpmrs_data->handoff_fn(r);
if (rc < 0)
return HANDOFF_DISABLED_CLK;
/*
* Since RPM handoff code may update the software rate of the clock by
* querying the RPM, we need to make sure our request to RPM now
* matches the software rate of the clock. When we send the request
* to RPM, we also need to update any other state info we would
* normally update. So, call the appropriate clock function instead
* of directly using the RPM driver APIs.
*/
rc = rpm_clk_prepare(clk);
if (rc < 0)
return HANDOFF_DISABLED_CLK;
return HANDOFF_ENABLED_CLK;
}
struct clk_ops clk_ops_rpm = {
.prepare = rpm_clk_prepare,
.unprepare = rpm_clk_unprepare,
.set_rate = rpm_clk_set_rate,
.get_rate = rpm_clk_get_rate,
.is_enabled = rpm_clk_is_enabled,
.round_rate = rpm_clk_round_rate,
.is_local = rpm_clk_is_local,
.handoff = rpm_clk_handoff,
};
struct clk_ops clk_ops_rpm_branch = {
.prepare = rpm_clk_prepare,
.unprepare = rpm_clk_unprepare,
.set_rate = rpm_branch_clk_set_rate,
.is_local = rpm_clk_is_local,
.handoff = rpm_clk_handoff,
};
static int clk_rpmrs_set_rate(struct rpm_clk *r, uint32_t value,
uint32_t context)
{
struct msm_rpm_iv_pair iv = {
.id = r->rpm_clk_id,
.value = value,
};
return msm_rpmrs_set(context, &iv, 1);
}
static int clk_rpmrs_get_rate(struct rpm_clk *r)
{
int rc;
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
rc = msm_rpm_get_status(&iv, 1);
return (rc < 0) ? rc : iv.value * 1000;
}
static int clk_rpmrs_handoff(struct rpm_clk *r)
{
struct msm_rpm_iv_pair iv = { .id = r->rpm_status_id, };
int rc = msm_rpm_get_status(&iv, 1);
if (rc < 0)
return rc;
if (!r->branch)
r->c.rate = iv.value * 1000;
return 0;
}
static int clk_rpmrs_is_enabled(struct rpm_clk *r)
{
return !!clk_rpmrs_get_rate(r);
}
static int clk_rpmrs_set_rate_smd(struct rpm_clk *r, uint32_t value,
uint32_t context)
{
struct msm_rpm_kvp kvp = {
.key = r->rpm_key,
.data = (void *)&value,
.length = sizeof(value),
};
return msm_rpm_send_message(context, r->rpm_res_type, r->rpm_clk_id,
&kvp, 1);
}
static int clk_rpmrs_handoff_smd(struct rpm_clk *r)
{
if (!r->branch)
r->c.rate = INT_MAX;
return 0;
}
static int clk_rpmrs_is_enabled_smd(struct rpm_clk *r)
{
return !!r->c.prepare_count;
}
struct clk_rpmrs_data {
int (*set_rate_fn)(struct rpm_clk *r, uint32_t value, uint32_t context);
int (*get_rate_fn)(struct rpm_clk *r);
int (*handoff_fn)(struct rpm_clk *r);
int (*is_enabled)(struct rpm_clk *r);
int ctx_active_id;
int ctx_sleep_id;
};
struct clk_rpmrs_data clk_rpmrs_data = {
.set_rate_fn = clk_rpmrs_set_rate,
.get_rate_fn = clk_rpmrs_get_rate,
.handoff_fn = clk_rpmrs_handoff,
.is_enabled = clk_rpmrs_is_enabled,
.ctx_active_id = MSM_RPM_CTX_SET_0,
.ctx_sleep_id = MSM_RPM_CTX_SET_SLEEP,
};
struct clk_rpmrs_data clk_rpmrs_data_smd = {
.set_rate_fn = clk_rpmrs_set_rate_smd,
.handoff_fn = clk_rpmrs_handoff_smd,
.is_enabled = clk_rpmrs_is_enabled_smd,
.ctx_active_id = MSM_RPM_CTX_ACTIVE_SET,
.ctx_sleep_id = MSM_RPM_CTX_SLEEP_SET,
};
static DEFINE_MUTEX(rpm_clock_lock);
static void to_active_sleep_khz(struct rpm_clk *r, unsigned long rate,
unsigned long *active_khz, unsigned long *sleep_khz)
{
/* */
*active_khz = DIV_ROUND_UP(rate, 1000);
/*
*/
if (r->active_only)
*sleep_khz = 0;
else
*sleep_khz = *active_khz;
}
static int rpm_clk_prepare(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
uint32_t value;
int rc = 0;
unsigned long this_khz, this_sleep_khz;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
struct rpm_clk *peer = r->peer;
mutex_lock(&rpm_clock_lock);
to_active_sleep_khz(r, r->c.rate, &this_khz, &this_sleep_khz);
/* */
if (this_khz == 0)
goto out;
/* */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = max(this_khz, peer_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
if (r->branch)
value = !!value;
rc = clk_rpmrs_set_rate_sleep(r, value);
if (rc) {
/* */
value = peer_khz;
rc = clk_rpmrs_set_rate_active(r, value);
}
out:
if (!rc)
r->enabled = true;
mutex_unlock(&rpm_clock_lock);
return rc;
}
static void rpm_clk_unprepare(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
mutex_lock(&rpm_clock_lock);
if (r->c.rate) {
uint32_t value;
struct rpm_clk *peer = r->peer;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
int rc;
/* */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = r->branch ? !!peer_khz : peer_khz;
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = r->branch ? !!peer_sleep_khz : peer_sleep_khz;
rc = clk_rpmrs_set_rate_sleep(r, value);
}
r->enabled = false;
out:
mutex_unlock(&rpm_clock_lock);
return;
}
static int rpm_clk_set_rate(struct clk *clk, unsigned long rate)
{
struct rpm_clk *r = to_rpm_clk(clk);
unsigned long this_khz, this_sleep_khz;
int rc = 0;
mutex_lock(&rpm_clock_lock);
if (r->enabled) {
uint32_t value;
struct rpm_clk *peer = r->peer;
unsigned long peer_khz = 0, peer_sleep_khz = 0;
to_active_sleep_khz(r, rate, &this_khz, &this_sleep_khz);
/* */
if (peer->enabled)
to_active_sleep_khz(peer, peer->c.rate,
&peer_khz, &peer_sleep_khz);
value = max(this_khz, peer_khz);
rc = clk_rpmrs_set_rate_active(r, value);
if (rc)
goto out;
value = max(this_sleep_khz, peer_sleep_khz);
rc = clk_rpmrs_set_rate_sleep(r, value);
}
out:
mutex_unlock(&rpm_clock_lock);
return rc;
}
static int rpm_branch_clk_set_rate(struct clk *clk, unsigned long rate)
{
if (rate == clk->rate)
return 0;
return -EPERM;
}
static unsigned long rpm_clk_get_rate(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
if (r->rpmrs_data->get_rate_fn)
return r->rpmrs_data->get_rate_fn(r);
else
return clk->rate;
}
static int rpm_clk_is_enabled(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
return r->rpmrs_data->is_enabled(r);
}
static long rpm_clk_round_rate(struct clk *clk, unsigned long rate)
{
/* */
return rate;
}
static bool rpm_clk_is_local(struct clk *clk)
{
return false;
}
static enum handoff rpm_clk_handoff(struct clk *clk)
{
struct rpm_clk *r = to_rpm_clk(clk);
int rc;
/*
*/
rc = r->rpmrs_data->handoff_fn(r);
if (rc < 0)
return HANDOFF_DISABLED_CLK;
/*
*/
rc = rpm_clk_prepare(clk);
if (rc < 0)
return HANDOFF_DISABLED_CLK;
return HANDOFF_ENABLED_CLK;
}
#define RPM_MISC_CLK_TYPE 0x306b6c63
#define RPM_SCALING_ENABLE_ID 0x2
void enable_rpm_scaling(void)
{
int rc, value = 0x1;
struct msm_rpm_kvp kvp = {
.key = RPM_SMD_KEY_ENABLE,
.data = (void *)&value,
.length = sizeof(value),
};
rc = msm_rpm_send_message_noirq(MSM_RPM_CTX_SLEEP_SET,
RPM_MISC_CLK_TYPE, RPM_SCALING_ENABLE_ID, &kvp, 1);
WARN(rc < 0, "RPM clock scaling (sleep set) did not enable!\n");
rc = msm_rpm_send_message_noirq(MSM_RPM_CTX_ACTIVE_SET,
RPM_MISC_CLK_TYPE, RPM_SCALING_ENABLE_ID, &kvp, 1);
WARN(rc < 0, "RPM clock scaling (active set) did not enable!\n");
}
struct clk_ops clk_ops_rpm = {
.prepare = rpm_clk_prepare,
.unprepare = rpm_clk_unprepare,
.set_rate = rpm_clk_set_rate,
.get_rate = rpm_clk_get_rate,
.is_enabled = rpm_clk_is_enabled,
.round_rate = rpm_clk_round_rate,
.is_local = rpm_clk_is_local,
.handoff = rpm_clk_handoff,
};
struct clk_ops clk_ops_rpm_branch = {
.prepare = rpm_clk_prepare,
.unprepare = rpm_clk_unprepare,
.set_rate = rpm_branch_clk_set_rate,
.is_local = rpm_clk_is_local,
.handoff = rpm_clk_handoff,
};
.length = sizeof(gpio_num),
},
{
.key = RPM_GPIO_STAT_KEY,
.data = (void *)&gpio_status_active,
.length = sizeof(gpio_status_active),
},
{
.key = RPM_GPIO_SETT_KEY,
.data = (void *)&settling_time,
.length = sizeof(settling_time),
},
};
rc = msm_rpm_send_message(MSM_RPM_CTX_ACTIVE_SET,
RPM_REQUEST_TYPE_GPIO, RPM_GPIO_RESOURCE_ID, kvp_active,
ARRAY_SIZE(kvp_active));
WARN(rc < 0, "RPM GPIO toggling (active set) did not enable!\n");
rc = msm_rpm_send_message(MSM_RPM_CTX_SLEEP_SET,
RPM_REQUEST_TYPE_GPIO, RPM_GPIO_RESOURCE_ID, kvp_sleep,
ARRAY_SIZE(kvp_sleep));
WARN(rc < 0, "RPM GPIO toggling (sleep set) did not enable!\n");
return rc;
}
static int msm_ext_buck_probe(struct platform_device *pdev)
{
char *key = NULL;
int gpio_num;
static int ddr_health_set(const char *val, struct kernel_param *kp)
{
int ret;
void *virt;
uint64_t old_addr = 0;
uint32_t old_size = 0;
mutex_lock(&lock);
ret = param_set_uint(val, kp);
if (ret) {
pr_err("ddr-health: error setting value %d\n", ret);
mutex_unlock(&lock);
return ret;
}
if (rpm_kvp.data) {
ddr_health = (struct ddr_health *)rpm_kvp.data;
old_addr = ddr_health->addr;
old_size = ddr_health->size;
}
rpm_kvp.key = RPM_MISC_REQ_DDR_HEALTH;
if (mem_size) {
virt = kzalloc(mem_size, GFP_KERNEL);
if (!virt) {
pr_err("ddr-health: failed to alloc mem request %x\n",
mem_size);
mutex_unlock(&lock);
return -ENOMEM;
}
ddr_health->addr = (uint64_t)virt_to_phys(virt);
ddr_health->size = mem_size;
rpm_kvp.length = sizeof(struct ddr_health);
rpm_kvp.data = (void *)ddr_health;
ret = msm_rpm_send_message(MSM_RPM_CTX_ACTIVE_SET,
RPM_MISC_REQ_TYPE, 0, &rpm_kvp, 1);
if (ret) {
pr_err("ddr-health: send buf to RPM failed %d, %x\n",
ret, mem_size);
kfree(virt);
goto err;
}
} else {
ddr_health->addr = 0;
ddr_health->size = 0;
rpm_kvp.length = sizeof(struct ddr_health);
rpm_kvp.data = (void *)ddr_health;
ret = msm_rpm_send_message(MSM_RPM_CTX_ACTIVE_SET,
RPM_MISC_REQ_TYPE, 0, &rpm_kvp, 1);
if (ret) {
pr_err("ddr-health: send nobuf to RPM failed %d, %x\n",
ret, mem_size);
goto err;
}
}
if (old_addr)
kfree(phys_to_virt((phys_addr_t)old_addr));
mutex_unlock(&lock);
return 0;
err:
ddr_health->addr = old_addr;
ddr_health->size = old_size;
mutex_unlock(&lock);
return ret;
}
