path: root/arch/arm/mach-omap2/ldo.c

/*
 * OMAP3/4 LDO users core
 *
 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
 * Mike Turquette <mturquette@ti.com>
 * Nishanth Menon
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>

#include <plat/cpu.h>
#include "voltage.h"
#include "ldo.h"

/**
 * _is_abb_enabled() - check if abb is enabled
 * @voltdm:	voltage domain to check for
 * @abb:	abb instance pointer
 *
 * Returns true if enabled, else returns false
 */
static inline bool _is_abb_enabled(struct voltagedomain *voltdm,
				   struct omap_ldo_abb_instance *abb)
{
	return (voltdm->read(abb->setup_reg) & abb->setup_bits->enable_mask) ?
	    true : false;
}

/**
 * _abb_set_availability() - sets the availability of the ABB LDO
 * @voltdm:	voltage domain for which we would like to set
 * @abb:	abb instance pointer
 * @available:	should I enable/disable the LDO?
 *
 * Depending on the request, it enables/disables the LDO if it was not
 * in that state already.
 */
static inline void _abb_set_availability(struct voltagedomain *voltdm,
					 struct omap_ldo_abb_instance *abb,
					 bool available)
{
	if (_is_abb_enabled(voltdm, abb) == available)
		return;

	voltdm->rmw(abb->setup_bits->enable_mask,
		    (available) ? abb->setup_bits->enable_mask : 0,
		    abb->setup_reg);
}

/**
 * _abb_wait_tranx() - wait for abb tranxdone event
 * @voltdm:	voltage domain we are operating on
 * @abb:	pointer to the abb instance
 *
 * Returns -ETIMEDOUT if the event is not set on time.
 */
static int _abb_wait_tranx(struct voltagedomain *voltdm,
			    struct omap_ldo_abb_instance *abb)
{
	int timeout;
	int ret;

	timeout = 0;
	while (timeout++ < abb->tranx_timeout) {
		ret = abb->ops->check_txdone(abb->prm_irq_id);
		if (ret)
			break;

		udelay(1);
	}

	if (timeout >= abb->tranx_timeout) {
		pr_warning("%s:%s: ABB TRANXDONE waittimeout(timeout=%d)\n",
			   __func__, voltdm->name, timeout);
		return -ETIMEDOUT;
	}
	return 0;
}

/**
 * _abb_clear_tranx() - clear abb tranxdone event
 * @voltdm:	voltage domain we are operating on
 * @abb:	pointer to the abb instance
 *
 * Returns -ETIMEDOUT if the event is not cleared on time.
 */
static int _abb_clear_tranx(struct voltagedomain *voltdm,
			    struct omap_ldo_abb_instance *abb)
{
	int timeout;
	int ret;

	/* clear interrupt status */
	timeout = 0;
	while (timeout++ < abb->tranx_timeout) {
		abb->ops->clear_txdone(abb->prm_irq_id);

		ret = abb->ops->check_txdone(abb->prm_irq_id);
		if (!ret)
			break;

		udelay(1);
	}

	if (timeout >= abb->tranx_timeout) {
		pr_warning("%s:%s: ABB TRANXDONE timeout(timeout=%d)\n",
			   __func__, voltdm->name, timeout);
		return -ETIMEDOUT;
	}
	return 0;
}

/**
 * _abb_set_abb() - helper to actually set ABB (NOMINAL/FAST)
 * @voltdm:	voltage domain we are operating on
 * @abb_type:	ABB type we want to set
 */
static int _abb_set_abb(struct voltagedomain *voltdm, int abb_type)
{
	struct omap_ldo_abb_instance *abb = voltdm->abb;
	int ret;

	ret = _abb_clear_tranx(voltdm, abb);
	if (ret)
		return ret;

	/* program next state of ABB ldo */
	voltdm->rmw(abb->ctrl_bits->opp_sel_mask,
		    abb_type << __ffs(abb->ctrl_bits->opp_sel_mask),
		    abb->ctrl_reg);

	/* initiate ABB ldo change */
	voltdm->rmw(abb->ctrl_bits->opp_change_mask,
		    abb->ctrl_bits->opp_change_mask, abb->ctrl_reg);

	/* Wait for conversion completion */
	ret = _abb_wait_tranx(voltdm, abb);
	WARN_ONCE(ret, "%s: voltdm %s ABB TRANXDONE was not set on time:%d\n",
			__func__, voltdm->name, ret);
	/* clear interrupt status */
	ret |= _abb_clear_tranx(voltdm, abb);

	return ret;
}

/**
 * _abb_scale() - wrapper which does the necessary things for pre and post scale
 * @voltdm:		voltage domain to operate on
 * @target_volt:	voltage we are going to
 * @is_prescale:	are we doing a prescale operation?
 *
 * NOTE: We expect caller ensures that a specific voltdm is modified
 * sequentially. All locking is expected to be implemented by users
 * of LDO functions
 */
static int _abb_scale(struct voltagedomain *voltdm,
		      struct omap_volt_data *target_vdata, bool is_prescale)
{
	int ret = 0;
	int curr_abb, target_abb;
	struct omap_ldo_abb_instance *abb;

	if (IS_ERR_OR_NULL(target_vdata)) {
		pr_err("%s:%s: Invalid volt data tv=%p!\n", __func__,
		       voltdm->name, target_vdata);
		return -EINVAL;
	}

	abb = voltdm->abb;
	if (IS_ERR_OR_NULL(abb)) {
		WARN(1, "%s:%s: no abb structure!\n", __func__, voltdm->name);
		return -EINVAL;
	}

	curr_abb = abb->__cur_abb_type;
	target_abb = target_vdata->abb_type;

	pr_debug("%s: %s: Enter: t_v=%ld scale=%d c_abb=%d t_abb=%d ret=%d\n",
		 __func__, voltdm->name, omap_get_nominal_voltage(target_vdata),
		 is_prescale, curr_abb, target_abb, ret);

	/* If we were'nt booting and there is no change, we get out */
	if (target_abb == curr_abb && voltdm->curr_volt)
		goto out;

	/* Do we have an invalid ABB entry? scream for a fix! */
	if (curr_abb == OMAP_ABB_NONE || target_abb == OMAP_ABB_NONE) {
		WARN(1, "%s:%s: INVALID abb entries? curr=%d target=%d\n",
		     __func__, voltdm->name, curr_abb, target_abb);
		return -EINVAL;
	}

	/*
	 * We set up ABB as follows:
	 * if we are scaling *to* a voltage which needs ABB, do it in post
	 * if we are scaling *from* a voltage which needs ABB, do it in pre
	 * So, if the conditions are in reverse, we just return happy
	 */
	if (is_prescale && (target_abb > curr_abb))
		goto out;

	if (!is_prescale && (target_abb < curr_abb))
		goto out;

	/* Time to set ABB now */
	ret = _abb_set_abb(voltdm, target_abb);
	if (!ret) {
		abb->__cur_abb_type = target_abb;
		pr_debug("%s: %s:  scaled - t_abb=%d!\n", __func__,
			 voltdm->name, target_abb);
	} else {
		pr_warning("%s: %s:  failed scale: t_abb=%d (%d)!\n", __func__,
			   voltdm->name, target_abb, ret);
	}

out:
	pr_debug("%s: %s:Exit: t_v=%ld scale=%d c_abb=%d t_abb=%d ret=%d\n",
		 __func__, voltdm->name, omap_get_nominal_voltage(target_vdata),
		 is_prescale, curr_abb, target_abb, ret);
	return ret;

}

/**
 * omap_ldo_abb_pre_scale() - Enable required ABB strategy before voltage scale
 * @voltdm:		voltage domain to operate on
 * @target_volt:	target voltage data we moved to.
 */
int omap_ldo_abb_pre_scale(struct voltagedomain *voltdm,
			   struct omap_volt_data *target_vdata)
{
	return _abb_scale(voltdm, target_vdata, true);
}

/**
 * omap_ldo_abb_pre_scale() - Enable required ABB strategy after voltage scale
 * @voltdm:		voltage domain operated on
 * @target_volt:	target voltage we are going to
 */
int omap_ldo_abb_post_scale(struct voltagedomain *voltdm,
			    struct omap_volt_data *target_vdata)
{
	return _abb_scale(voltdm, target_vdata, false);
}

/**
 * omap_ldo_abb_init() - initialize the ABB LDO for associated for this domain
 * @voltdm:	voltdm for which we need to initialize the ABB LDO
 *
 * Programs up the the configurations that dont change in the domain
 *
 * Return 0 if all goes fine, else returns appropriate error value
 */
void __init omap_ldo_abb_init(struct voltagedomain *voltdm)
{
	u32 sys_clk_rate;
	u32 cycle_rate;
	u32 settling_time;
	u32 wait_count_val;
	struct omap_ldo_abb_instance *abb;

	if (IS_ERR_OR_NULL(voltdm)) {
		pr_err("%s: No voltdm?\n", __func__);
		return;
	}
	if (!voltdm->read || !voltdm->write || !voltdm->rmw) {
		pr_err("%s: No read/write/rmw API for accessing vdd_%s regs\n",
		       __func__, voltdm->name);
		return;
	}

	abb = voltdm->abb;
	if (IS_ERR_OR_NULL(abb))
		return;
	if (IS_ERR_OR_NULL(abb->ctrl_bits) || IS_ERR_OR_NULL(abb->setup_bits)) {
		pr_err("%s: Corrupted ABB configuration on vdd_%s regs\n",
		       __func__, voltdm->name);
		return;
	}

	/*
	 * SR2_WTCNT_VALUE must be programmed with the expected settling time
	 * for ABB ldo transition.  This value depends on the cycle rate for
	 * the ABB IP (varies per OMAP family), and the system clock frequency
	 * (varies per board).  The formula is:
	 *
	 * SR2_WTCNT_VALUE = SettlingTime / (CycleRate / SystemClkRate))
	 * where SettlingTime is in micro-seconds and SystemClkRate is in MHz.
	 *
	 * To avoid dividing by zero multiply both CycleRate and SettlingTime
	 * by 10 such that the final result is the one we want.
	 */

	/* Convert SYS_CLK rate to MHz & prevent divide by zero */
	sys_clk_rate = DIV_ROUND_CLOSEST(voltdm->sys_clk.rate, 1000000);
	cycle_rate = abb->cycle_rate * 10;
	settling_time = abb->settling_time * 10;

	/* Calculate cycle rate */
	cycle_rate = DIV_ROUND_CLOSEST(cycle_rate, sys_clk_rate);

	/* Calulate SR2_WTCNT_VALUE */
	wait_count_val = DIV_ROUND_CLOSEST(settling_time, cycle_rate);

	voltdm->rmw(abb->setup_bits->wait_count_mask,
		    wait_count_val << __ffs(abb->setup_bits->wait_count_mask),
		    abb->setup_reg);

	/* Allow Forward Body-Bias */
	voltdm->rmw(abb->setup_bits->active_fbb_mask,
		    abb->setup_bits->active_fbb_mask, abb->setup_reg);

	/* Enable ABB */
	_abb_set_availability(voltdm, abb, true);

	/*
	 * Beware of the bootloader!
	 * Initialize current abb type based on what we read off the reg.
	 * we cant trust the initial state based off boot voltage's volt_data
	 * even. Not all bootloaders are nice :(
	 */
	abb->__cur_abb_type = (voltdm->read(abb->ctrl_reg) &
			       abb->ctrl_bits->opp_sel_mask) >>
				    __ffs(abb->ctrl_bits->opp_sel_mask);

	return;
}