arch/arm/mach-msm/clock-rpm.c - fp2-dev/kernel/msm - Gitiles

 /* Copyright (c) 2010-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.
  *
  */

 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <mach/clk-provider.h>

 #include "rpm_resources.h"
 #include "clock-rpm.h"

 #define __clk_rpmrs_set_rate(r, value, ctx) \
 	((r)->rpmrs_data->set_rate_fn((r), (value), (ctx)))

 #define clk_rpmrs_set_rate_sleep(r, value) \
 	    __clk_rpmrs_set_rate((r), (value), (r)->rpmrs_data->ctx_sleep_id)

 #define clk_rpmrs_set_rate_active(r, value) \
 	   __clk_rpmrs_set_rate((r), (value), (r)->rpmrs_data->ctx_active_id)

 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 * r->factor;
 }

 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 * r->factor;

 	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, r->factor);

 	/*
 	 * 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;
 }

 #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,
 };
	/* Copyright (c) 2010-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.
	*
	*/

	#include <linux/err.h>
	#include <linux/mutex.h>
	#include <mach/clk-provider.h>

	#include "rpm_resources.h"
	#include "clock-rpm.h"

	#define __clk_rpmrs_set_rate(r, value, ctx) \
	((r)->rpmrs_data->set_rate_fn((r), (value), (ctx)))

	#define clk_rpmrs_set_rate_sleep(r, value) \
	__clk_rpmrs_set_rate((r), (value), (r)->rpmrs_data->ctx_sleep_id)

	#define clk_rpmrs_set_rate_active(r, value) \
	__clk_rpmrs_set_rate((r), (value), (r)->rpmrs_data->ctx_active_id)

	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 * r->factor;
	}

	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 * r->factor;

	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, r->factor);

	/*
	* 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;
	}

	#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,
	};