2005-09-08 00:20:26 +08:00
|
|
|
/*
|
|
|
|
* linux/arch/arm/plat-omap/dmtimer.c
|
|
|
|
*
|
|
|
|
* OMAP Dual-Mode Timers
|
|
|
|
*
|
2011-09-20 19:30:17 +08:00
|
|
|
* Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
|
|
|
|
* Tarun Kanti DebBarma <tarun.kanti@ti.com>
|
|
|
|
* Thara Gopinath <thara@ti.com>
|
|
|
|
*
|
|
|
|
* dmtimer adaptation to platform_driver.
|
|
|
|
*
|
2005-09-08 00:20:26 +08:00
|
|
|
* Copyright (C) 2005 Nokia Corporation
|
2006-06-27 07:16:12 +08:00
|
|
|
* OMAP2 support by Juha Yrjola
|
|
|
|
* API improvements and OMAP2 clock framework support by Timo Teras
|
2005-09-08 00:20:26 +08:00
|
|
|
*
|
2009-05-29 05:16:04 +08:00
|
|
|
* Copyright (C) 2009 Texas Instruments
|
|
|
|
* Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
|
|
|
|
*
|
2005-09-08 00:20:26 +08:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
* option) any later version.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
|
|
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
2012-09-29 00:43:30 +08:00
|
|
|
#include <linux/clk.h>
|
2015-10-06 07:28:21 +08:00
|
|
|
#include <linux/clk-provider.h>
|
2011-11-02 09:49:46 +08:00
|
|
|
#include <linux/module.h>
|
2008-09-06 19:10:45 +08:00
|
|
|
#include <linux/io.h>
|
2012-04-20 20:39:20 +08:00
|
|
|
#include <linux/device.h>
|
2011-09-20 19:30:20 +08:00
|
|
|
#include <linux/err.h>
|
2011-09-20 19:30:21 +08:00
|
|
|
#include <linux/pm_runtime.h>
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2012-09-29 00:34:49 +08:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/platform_data/dmtimer-omap.h>
|
2009-05-29 05:16:04 +08:00
|
|
|
|
2018-02-15 14:01:44 +08:00
|
|
|
#include <clocksource/timer-ti-dm.h>
|
2012-02-25 02:34:35 +08:00
|
|
|
|
2012-06-06 01:34:51 +08:00
|
|
|
static u32 omap_reserved_systimers;
|
2011-09-20 19:30:19 +08:00
|
|
|
static LIST_HEAD(omap_timer_list);
|
2011-09-20 19:30:20 +08:00
|
|
|
static DEFINE_SPINLOCK(dm_timer_lock);
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
enum {
|
|
|
|
REQUEST_ANY = 0,
|
|
|
|
REQUEST_BY_ID,
|
|
|
|
REQUEST_BY_CAP,
|
|
|
|
REQUEST_BY_NODE,
|
|
|
|
};
|
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_read_reg - read timer registers in posted and non-posted mode
|
|
|
|
* @timer: timer pointer over which read operation to perform
|
|
|
|
* @reg: lowest byte holds the register offset
|
|
|
|
*
|
|
|
|
* The posted mode bit is encoded in reg. Note that in posted mode write
|
|
|
|
* pending bit must be checked. Otherwise a read of a non completed write
|
|
|
|
* will produce an error.
|
2008-07-03 17:24:30 +08:00
|
|
|
*/
|
|
|
|
static inline u32 omap_dm_timer_read_reg(struct omap_dm_timer *timer, u32 reg)
|
2006-06-27 07:16:12 +08:00
|
|
|
{
|
2011-09-17 06:44:20 +08:00
|
|
|
WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
|
|
|
|
return __omap_dm_timer_read(timer, reg, timer->posted);
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_write_reg - write timer registers in posted and non-posted mode
|
|
|
|
* @timer: timer pointer over which write operation is to perform
|
|
|
|
* @reg: lowest byte holds the register offset
|
|
|
|
* @value: data to write into the register
|
|
|
|
*
|
|
|
|
* The posted mode bit is encoded in reg. Note that in posted mode the write
|
|
|
|
* pending bit must be checked. Otherwise a write on a register which has a
|
|
|
|
* pending write will be lost.
|
2008-07-03 17:24:30 +08:00
|
|
|
*/
|
|
|
|
static void omap_dm_timer_write_reg(struct omap_dm_timer *timer, u32 reg,
|
|
|
|
u32 value)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-17 06:44:20 +08:00
|
|
|
WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
|
|
|
|
__omap_dm_timer_write(timer, reg, value, timer->posted);
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
static void omap_timer_restore_context(struct omap_dm_timer *timer)
|
|
|
|
{
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_WAKEUP_EN_REG,
|
|
|
|
timer->context.twer);
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_COUNTER_REG,
|
|
|
|
timer->context.tcrr);
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG,
|
|
|
|
timer->context.tldr);
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_MATCH_REG,
|
|
|
|
timer->context.tmar);
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_IF_CTRL_REG,
|
|
|
|
timer->context.tsicr);
|
2014-04-16 01:37:47 +08:00
|
|
|
writel_relaxed(timer->context.tier, timer->irq_ena);
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG,
|
|
|
|
timer->context.tclr);
|
|
|
|
}
|
|
|
|
|
2012-07-12 02:47:38 +08:00
|
|
|
static int omap_dm_timer_reset(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2012-07-12 02:47:38 +08:00
|
|
|
u32 l, timeout = 100000;
|
2006-06-27 07:16:12 +08:00
|
|
|
|
2012-07-12 02:47:38 +08:00
|
|
|
if (timer->revision != 1)
|
|
|
|
return -EINVAL;
|
2011-09-17 06:44:20 +08:00
|
|
|
|
2012-07-12 02:47:38 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_IF_CTRL_REG, 0x06);
|
|
|
|
|
|
|
|
do {
|
|
|
|
l = __omap_dm_timer_read(timer,
|
|
|
|
OMAP_TIMER_V1_SYS_STAT_OFFSET, 0);
|
|
|
|
} while (!l && timeout--);
|
|
|
|
|
|
|
|
if (!timeout) {
|
|
|
|
dev_err(&timer->pdev->dev, "Timer failed to reset\n");
|
|
|
|
return -ETIMEDOUT;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2012-07-12 02:47:38 +08:00
|
|
|
/* Configure timer for smart-idle mode */
|
|
|
|
l = __omap_dm_timer_read(timer, OMAP_TIMER_OCP_CFG_OFFSET, 0);
|
|
|
|
l |= 0x2 << 0x3;
|
|
|
|
__omap_dm_timer_write(timer, OMAP_TIMER_OCP_CFG_OFFSET, l, 0);
|
|
|
|
|
|
|
|
timer->posted = 0;
|
|
|
|
|
|
|
|
return 0;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
|
|
|
|
2015-11-02 19:14:14 +08:00
|
|
|
static int omap_dm_timer_of_set_source(struct omap_dm_timer *timer)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct clk *parent;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: OMAP1 devices do not use the clock framework for dmtimers so
|
|
|
|
* do not call clk_get() for these devices.
|
|
|
|
*/
|
|
|
|
if (!timer->fclk)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
parent = clk_get(&timer->pdev->dev, NULL);
|
|
|
|
if (IS_ERR(parent))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
ret = clk_set_parent(timer->fclk, parent);
|
|
|
|
if (ret < 0)
|
|
|
|
pr_err("%s: failed to set parent\n", __func__);
|
|
|
|
|
|
|
|
clk_put(parent);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-29 01:21:09 +08:00
|
|
|
static int omap_dm_timer_prepare(struct omap_dm_timer *timer)
|
2006-06-27 07:16:12 +08:00
|
|
|
{
|
2012-07-12 02:47:38 +08:00
|
|
|
int rc;
|
|
|
|
|
2012-06-06 01:34:58 +08:00
|
|
|
/*
|
|
|
|
* FIXME: OMAP1 devices do not use the clock framework for dmtimers so
|
|
|
|
* do not call clk_get() for these devices.
|
|
|
|
*/
|
|
|
|
if (!(timer->capability & OMAP_TIMER_NEEDS_RESET)) {
|
|
|
|
timer->fclk = clk_get(&timer->pdev->dev, "fck");
|
2013-02-24 18:46:59 +08:00
|
|
|
if (WARN_ON_ONCE(IS_ERR(timer->fclk))) {
|
2012-06-06 01:34:58 +08:00
|
|
|
dev_err(&timer->pdev->dev, ": No fclk handle.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2011-09-20 19:30:20 +08:00
|
|
|
}
|
|
|
|
|
2012-07-07 05:45:04 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
|
|
|
|
2012-07-12 02:47:38 +08:00
|
|
|
if (timer->capability & OMAP_TIMER_NEEDS_RESET) {
|
|
|
|
rc = omap_dm_timer_reset(timer);
|
|
|
|
if (rc) {
|
|
|
|
omap_dm_timer_disable(timer);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
2011-09-20 19:30:20 +08:00
|
|
|
|
2012-07-07 05:45:04 +08:00
|
|
|
__omap_dm_timer_enable_posted(timer);
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:20 +08:00
|
|
|
|
2015-11-02 19:14:14 +08:00
|
|
|
rc = omap_dm_timer_of_set_source(timer);
|
|
|
|
if (rc == -ENODEV)
|
|
|
|
return omap_dm_timer_set_source(timer, OMAP_TIMER_SRC_32_KHZ);
|
|
|
|
|
|
|
|
return rc;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
|
|
|
|
2012-06-06 01:34:51 +08:00
|
|
|
static inline u32 omap_dm_timer_reserved_systimer(int id)
|
|
|
|
{
|
|
|
|
return (omap_reserved_systimers & (1 << (id - 1))) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int omap_dm_timer_reserve_systimer(int id)
|
|
|
|
{
|
|
|
|
if (omap_dm_timer_reserved_systimer(id))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
omap_reserved_systimers |= (1 << (id - 1));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
static struct omap_dm_timer *_omap_dm_timer_request(int req_type, void *data)
|
2006-06-27 07:16:12 +08:00
|
|
|
{
|
2011-09-20 19:30:20 +08:00
|
|
|
struct omap_dm_timer *timer = NULL, *t;
|
2013-03-20 01:38:17 +08:00
|
|
|
struct device_node *np = NULL;
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned long flags;
|
2013-03-20 01:38:17 +08:00
|
|
|
u32 cap = 0;
|
|
|
|
int id = 0;
|
|
|
|
|
|
|
|
switch (req_type) {
|
|
|
|
case REQUEST_BY_ID:
|
|
|
|
id = *(int *)data;
|
|
|
|
break;
|
|
|
|
case REQUEST_BY_CAP:
|
|
|
|
cap = *(u32 *)data;
|
|
|
|
break;
|
|
|
|
case REQUEST_BY_NODE:
|
|
|
|
np = (struct device_node *)data;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* REQUEST_ANY */
|
|
|
|
break;
|
|
|
|
}
|
2006-06-27 07:16:12 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dm_timer_lock, flags);
|
2011-09-20 19:30:20 +08:00
|
|
|
list_for_each_entry(t, &omap_timer_list, node) {
|
|
|
|
if (t->reserved)
|
2006-06-27 07:16:12 +08:00
|
|
|
continue;
|
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
switch (req_type) {
|
|
|
|
case REQUEST_BY_ID:
|
|
|
|
if (id == t->pdev->id) {
|
|
|
|
timer = t;
|
|
|
|
timer->reserved = 1;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case REQUEST_BY_CAP:
|
|
|
|
if (cap == (t->capability & cap)) {
|
|
|
|
/*
|
|
|
|
* If timer is not NULL, we have already found
|
2017-10-04 03:24:00 +08:00
|
|
|
* one timer. But it was not an exact match
|
|
|
|
* because it had more capabilities than what
|
2013-03-20 01:38:17 +08:00
|
|
|
* was required. Therefore, unreserve the last
|
|
|
|
* timer found and see if this one is a better
|
|
|
|
* match.
|
|
|
|
*/
|
|
|
|
if (timer)
|
|
|
|
timer->reserved = 0;
|
|
|
|
timer = t;
|
|
|
|
timer->reserved = 1;
|
|
|
|
|
|
|
|
/* Exit loop early if we find an exact match */
|
|
|
|
if (t->capability == cap)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case REQUEST_BY_NODE:
|
|
|
|
if (np == t->pdev->dev.of_node) {
|
|
|
|
timer = t;
|
|
|
|
timer->reserved = 1;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* REQUEST_ANY */
|
|
|
|
timer = t;
|
|
|
|
timer->reserved = 1;
|
|
|
|
goto found;
|
|
|
|
}
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2013-03-20 01:38:17 +08:00
|
|
|
found:
|
2012-08-12 18:45:34 +08:00
|
|
|
spin_unlock_irqrestore(&dm_timer_lock, flags);
|
2011-09-20 19:30:20 +08:00
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
if (timer && omap_dm_timer_prepare(timer)) {
|
|
|
|
timer->reserved = 0;
|
|
|
|
timer = NULL;
|
2011-09-20 19:30:20 +08:00
|
|
|
}
|
2006-06-27 07:16:12 +08:00
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
if (!timer)
|
|
|
|
pr_debug("%s: timer request failed!\n", __func__);
|
2006-06-27 07:16:23 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
return timer;
|
|
|
|
}
|
2013-03-20 01:38:17 +08:00
|
|
|
|
|
|
|
struct omap_dm_timer *omap_dm_timer_request(void)
|
|
|
|
{
|
|
|
|
return _omap_dm_timer_request(REQUEST_ANY, NULL);
|
|
|
|
}
|
2006-06-27 07:16:12 +08:00
|
|
|
|
|
|
|
struct omap_dm_timer *omap_dm_timer_request_specific(int id)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
/* Requesting timer by ID is not supported when device tree is used */
|
|
|
|
if (of_have_populated_dt()) {
|
2013-03-20 01:38:17 +08:00
|
|
|
pr_warn("%s: Please use omap_dm_timer_request_by_cap/node()\n",
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
__func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
return _omap_dm_timer_request(REQUEST_BY_ID, &id);
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2012-09-07 04:28:00 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_request_by_cap - Request a timer by capability
|
|
|
|
* @cap: Bit mask of capabilities to match
|
|
|
|
*
|
|
|
|
* Find a timer based upon capabilities bit mask. Callers of this function
|
|
|
|
* should use the definitions found in the plat/dmtimer.h file under the
|
|
|
|
* comment "timer capabilities used in hwmod database". Returns pointer to
|
|
|
|
* timer handle on success and a NULL pointer on failure.
|
|
|
|
*/
|
|
|
|
struct omap_dm_timer *omap_dm_timer_request_by_cap(u32 cap)
|
|
|
|
{
|
2013-03-20 01:38:17 +08:00
|
|
|
return _omap_dm_timer_request(REQUEST_BY_CAP, &cap);
|
|
|
|
}
|
2012-09-07 04:28:00 +08:00
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_request_by_node - Request a timer by device-tree node
|
|
|
|
* @np: Pointer to device-tree timer node
|
|
|
|
*
|
|
|
|
* Request a timer based upon a device node pointer. Returns pointer to
|
|
|
|
* timer handle on success and a NULL pointer on failure.
|
|
|
|
*/
|
|
|
|
struct omap_dm_timer *omap_dm_timer_request_by_node(struct device_node *np)
|
|
|
|
{
|
|
|
|
if (!np)
|
2012-09-07 04:28:00 +08:00
|
|
|
return NULL;
|
|
|
|
|
2013-03-20 01:38:17 +08:00
|
|
|
return _omap_dm_timer_request(REQUEST_BY_NODE, np);
|
2012-09-07 04:28:00 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_free(struct omap_dm_timer *timer)
|
2006-06-27 07:16:12 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
clk_put(timer->fclk);
|
2006-09-25 17:41:35 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
WARN_ON(!timer->reserved);
|
|
|
|
timer->reserved = 0;
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
|
|
|
|
2006-09-25 17:41:42 +08:00
|
|
|
void omap_dm_timer_enable(struct omap_dm_timer *timer)
|
|
|
|
{
|
2013-03-20 01:38:15 +08:00
|
|
|
int c;
|
|
|
|
|
2011-09-20 19:30:21 +08:00
|
|
|
pm_runtime_get_sync(&timer->pdev->dev);
|
2013-03-20 01:38:15 +08:00
|
|
|
|
|
|
|
if (!(timer->capability & OMAP_TIMER_ALWON)) {
|
|
|
|
if (timer->get_context_loss_count) {
|
|
|
|
c = timer->get_context_loss_count(&timer->pdev->dev);
|
|
|
|
if (c != timer->ctx_loss_count) {
|
|
|
|
omap_timer_restore_context(timer);
|
|
|
|
timer->ctx_loss_count = c;
|
|
|
|
}
|
2013-03-20 01:38:16 +08:00
|
|
|
} else {
|
|
|
|
omap_timer_restore_context(timer);
|
2013-03-20 01:38:15 +08:00
|
|
|
}
|
|
|
|
}
|
2006-09-25 17:41:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void omap_dm_timer_disable(struct omap_dm_timer *timer)
|
|
|
|
{
|
2012-07-14 04:12:03 +08:00
|
|
|
pm_runtime_put_sync(&timer->pdev->dev);
|
2006-09-25 17:41:42 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
int omap_dm_timer_get_irq(struct omap_dm_timer *timer)
|
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (timer)
|
|
|
|
return timer->irq;
|
|
|
|
return -EINVAL;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_ARCH_OMAP1)
|
2012-11-01 03:38:43 +08:00
|
|
|
#include <mach/hardware.h>
|
2006-04-03 00:46:21 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_modify_idlect_mask - Check if any running timers use ARMXOR
|
|
|
|
* @inputmask: current value of idlect mask
|
|
|
|
*/
|
|
|
|
__u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
|
|
|
|
{
|
2011-09-20 19:30:20 +08:00
|
|
|
int i = 0;
|
|
|
|
struct omap_dm_timer *timer = NULL;
|
|
|
|
unsigned long flags;
|
2006-04-03 00:46:21 +08:00
|
|
|
|
|
|
|
/* If ARMXOR cannot be idled this function call is unnecessary */
|
|
|
|
if (!(inputmask & (1 << 1)))
|
|
|
|
return inputmask;
|
|
|
|
|
|
|
|
/* If any active timer is using ARMXOR return modified mask */
|
2011-09-20 19:30:20 +08:00
|
|
|
spin_lock_irqsave(&dm_timer_lock, flags);
|
|
|
|
list_for_each_entry(timer, &omap_timer_list, node) {
|
2006-06-27 07:16:12 +08:00
|
|
|
u32 l;
|
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2006-06-27 07:16:12 +08:00
|
|
|
if (l & OMAP_TIMER_CTRL_ST) {
|
|
|
|
if (((omap_readl(MOD_CONF_CTRL_1) >> (i * 2)) & 0x03) == 0)
|
2006-04-03 00:46:21 +08:00
|
|
|
inputmask &= ~(1 << 1);
|
|
|
|
else
|
|
|
|
inputmask &= ~(1 << 2);
|
|
|
|
}
|
2011-09-20 19:30:20 +08:00
|
|
|
i++;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2011-09-20 19:30:20 +08:00
|
|
|
spin_unlock_irqrestore(&dm_timer_lock, flags);
|
2006-04-03 00:46:21 +08:00
|
|
|
|
|
|
|
return inputmask;
|
|
|
|
}
|
|
|
|
|
2010-02-13 04:26:48 +08:00
|
|
|
#else
|
2006-04-03 00:46:21 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2013-02-24 18:46:59 +08:00
|
|
|
if (timer && !IS_ERR(timer->fclk))
|
2011-09-20 19:30:26 +08:00
|
|
|
return timer->fclk;
|
|
|
|
return NULL;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
__u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
|
|
|
|
{
|
|
|
|
BUG();
|
2006-12-07 09:14:00 +08:00
|
|
|
|
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
#endif
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_trigger(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
|
|
|
|
pr_err("%s: timer not available or enabled.\n", __func__);
|
|
|
|
return -EINVAL;
|
2011-09-20 19:30:24 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_start(struct omap_dm_timer *timer)
|
2006-06-27 07:16:12 +08:00
|
|
|
{
|
|
|
|
u32 l;
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
|
|
|
if (!(l & OMAP_TIMER_CTRL_ST)) {
|
|
|
|
l |= OMAP_TIMER_CTRL_ST;
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
|
|
|
|
}
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_stop(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-03-30 06:54:48 +08:00
|
|
|
unsigned long rate = 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-06-06 01:34:57 +08:00
|
|
|
if (!(timer->capability & OMAP_TIMER_NEEDS_RESET))
|
2011-09-20 19:30:20 +08:00
|
|
|
rate = clk_get_rate(timer->fclk);
|
2011-03-30 06:54:48 +08:00
|
|
|
|
2011-09-17 06:44:20 +08:00
|
|
|
__omap_dm_timer_stop(timer, timer->posted, rate);
|
2011-09-20 19:30:26 +08:00
|
|
|
|
2012-03-06 08:11:00 +08:00
|
|
|
/*
|
|
|
|
* Since the register values are computed and written within
|
|
|
|
* __omap_dm_timer_stop, we need to use read to retrieve the
|
|
|
|
* context.
|
|
|
|
*/
|
|
|
|
timer->context.tclr =
|
|
|
|
omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
OMAP2/3 GPTIMER: allow system tick GPTIMER to be changed in board-*.c files
Add a function omap2_gp_clockevent_set_gptimer() for board-*.c files
to use in .init_irq functions to configure the system tick GPTIMER.
Practical choices at this point are GPTIMER1 or GPTIMER12. Both of
these timers are in the WKUP powerdomain, and so are unaffected by
chip power management. GPTIMER1 can use sys_clk as a source, for
applications where a high-resolution timer is more important than
power management. GPTIMER12 has the special property that it has the
secure 32kHz oscillator as its source clock, which may be less prone
to glitches than the off-chip 32kHz oscillator. But on HS devices, it
may not be available for Linux use.
It appears that most boards are fine with GPTIMER1, but BeagleBoard
should use GPTIMER12 when using a 32KiHz timer source, due to hardware bugs
in revisions B4 and below. Modify board-omap3beagle.c to use GPTIMER12.
This patch originally used a Kbuild config option to select the GPTIMER,
but was changed to allow this to be specified in board-*.c files, per
Tony's request.
Kalle Vallo <kalle.valo@nokia.com> found a bug in an earlier version of
this patch - thanks Kalle.
Tested on Beagle rev B4 ES2.1, with and without CONFIG_OMAP_32K_TIMER, and
3430SDP.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
Cc: Kalle Valo <kalle.valo@nokia.com>
2009-04-24 11:11:10 +08:00
|
|
|
int omap_dm_timer_set_source(struct omap_dm_timer *timer, int source)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:20 +08:00
|
|
|
int ret;
|
2012-06-06 01:34:59 +08:00
|
|
|
char *parent_name = NULL;
|
2012-07-19 09:10:12 +08:00
|
|
|
struct clk *parent;
|
2011-09-20 19:30:26 +08:00
|
|
|
struct dmtimer_platform_data *pdata;
|
|
|
|
|
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pdata = timer->pdev->dev.platform_data;
|
2011-09-20 19:30:20 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
if (source < 0 || source >= 3)
|
OMAP2/3 GPTIMER: allow system tick GPTIMER to be changed in board-*.c files
Add a function omap2_gp_clockevent_set_gptimer() for board-*.c files
to use in .init_irq functions to configure the system tick GPTIMER.
Practical choices at this point are GPTIMER1 or GPTIMER12. Both of
these timers are in the WKUP powerdomain, and so are unaffected by
chip power management. GPTIMER1 can use sys_clk as a source, for
applications where a high-resolution timer is more important than
power management. GPTIMER12 has the special property that it has the
secure 32kHz oscillator as its source clock, which may be less prone
to glitches than the off-chip 32kHz oscillator. But on HS devices, it
may not be available for Linux use.
It appears that most boards are fine with GPTIMER1, but BeagleBoard
should use GPTIMER12 when using a 32KiHz timer source, due to hardware bugs
in revisions B4 and below. Modify board-omap3beagle.c to use GPTIMER12.
This patch originally used a Kbuild config option to select the GPTIMER,
but was changed to allow this to be specified in board-*.c files, per
Tony's request.
Kalle Vallo <kalle.valo@nokia.com> found a bug in an earlier version of
this patch - thanks Kalle.
Tested on Beagle rev B4 ES2.1, with and without CONFIG_OMAP_32K_TIMER, and
3430SDP.
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
Cc: Kalle Valo <kalle.valo@nokia.com>
2009-04-24 11:11:10 +08:00
|
|
|
return -EINVAL;
|
2006-06-27 07:16:12 +08:00
|
|
|
|
2012-06-06 01:34:59 +08:00
|
|
|
/*
|
|
|
|
* FIXME: Used for OMAP1 devices only because they do not currently
|
|
|
|
* use the clock framework to set the parent clock. To be removed
|
|
|
|
* once OMAP1 migrated to using clock framework for dmtimers
|
|
|
|
*/
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
if (pdata && pdata->set_timer_src)
|
2012-06-06 01:34:59 +08:00
|
|
|
return pdata->set_timer_src(timer->pdev, source);
|
|
|
|
|
2013-02-24 18:46:59 +08:00
|
|
|
if (IS_ERR(timer->fclk))
|
2012-06-06 01:34:59 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2015-10-06 07:28:21 +08:00
|
|
|
#if defined(CONFIG_COMMON_CLK)
|
|
|
|
/* Check if the clock has configurable parents */
|
|
|
|
if (clk_hw_get_num_parents(__clk_get_hw(timer->fclk)) < 2)
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
|
2012-06-06 01:34:59 +08:00
|
|
|
switch (source) {
|
|
|
|
case OMAP_TIMER_SRC_SYS_CLK:
|
2012-06-06 01:35:00 +08:00
|
|
|
parent_name = "timer_sys_ck";
|
2012-06-06 01:34:59 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OMAP_TIMER_SRC_32_KHZ:
|
2012-06-06 01:35:00 +08:00
|
|
|
parent_name = "timer_32k_ck";
|
2012-06-06 01:34:59 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OMAP_TIMER_SRC_EXT_CLK:
|
2012-06-06 01:35:00 +08:00
|
|
|
parent_name = "timer_ext_ck";
|
2012-06-06 01:34:59 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
parent = clk_get(&timer->pdev->dev, parent_name);
|
2013-02-24 18:46:59 +08:00
|
|
|
if (IS_ERR(parent)) {
|
2012-06-06 01:34:59 +08:00
|
|
|
pr_err("%s: %s not found\n", __func__, parent_name);
|
2012-07-19 09:10:12 +08:00
|
|
|
return -EINVAL;
|
2012-06-06 01:34:59 +08:00
|
|
|
}
|
|
|
|
|
2012-07-19 09:10:12 +08:00
|
|
|
ret = clk_set_parent(timer->fclk, parent);
|
ARM: OMAP: use consistent error checking
Consistently check errors using the usual method used in the kernel
for much of its history. For instance:
int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t)
{
int div;
div = gpmc_calc_divider(t->sync_clk);
if (div < 0)
return div;
static int gpmc_set_async_mode(int cs, struct gpmc_timings *t)
{
...
return gpmc_cs_set_timings(cs, t);
.....
ret = gpmc_set_async_mode(gpmc_onenand_data->cs, &t);
if (IS_ERR_VALUE(ret))
return ret;
So, gpmc_cs_set_timings() thinks any negative return value is an error,
but where we check that in higher levels, only a limited range are
errors...
There is only _one_ use of IS_ERR_VALUE() in arch/arm which is really
appropriate, and that is in arch/arm/include/asm/syscall.h:
static inline long syscall_get_error(struct task_struct *task,
struct pt_regs *regs)
{
unsigned long error = regs->ARM_r0;
return IS_ERR_VALUE(error) ? error : 0;
}
because this function really does have to differentiate between error
return values and addresses which look like negative numbers (eg, from
mmap()).
So, here's a patch to remove them from OMAP, except for the above.
Acked-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2013-03-14 04:44:21 +08:00
|
|
|
if (ret < 0)
|
2012-06-06 01:34:59 +08:00
|
|
|
pr_err("%s: failed to set %s as parent\n", __func__,
|
|
|
|
parent_name);
|
|
|
|
|
|
|
|
clk_put(parent);
|
2011-09-20 19:30:20 +08:00
|
|
|
|
|
|
|
return ret;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_load(struct omap_dm_timer *timer, int autoreload,
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned int load)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
|
|
|
u32 l;
|
2006-06-27 07:16:12 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
2005-09-08 00:20:26 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2006-06-27 07:16:12 +08:00
|
|
|
if (autoreload)
|
|
|
|
l |= OMAP_TIMER_CTRL_AR;
|
|
|
|
else
|
|
|
|
l &= ~OMAP_TIMER_CTRL_AR;
|
2005-09-08 00:20:26 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
|
2006-06-27 07:16:12 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
|
2008-07-03 17:24:30 +08:00
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
|
2011-09-20 19:30:24 +08:00
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
|
|
|
timer->context.tldr = load;
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2008-07-03 17:24:30 +08:00
|
|
|
/* Optimized set_load which removes costly spin wait in timer_start */
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_load_start(struct omap_dm_timer *timer, int autoreload,
|
2008-07-03 17:24:30 +08:00
|
|
|
unsigned int load)
|
|
|
|
{
|
|
|
|
u32 l;
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
|
|
|
|
2008-07-03 17:24:30 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2008-12-11 09:36:34 +08:00
|
|
|
if (autoreload) {
|
2008-07-03 17:24:30 +08:00
|
|
|
l |= OMAP_TIMER_CTRL_AR;
|
2008-12-11 09:36:34 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
|
|
|
|
} else {
|
2008-07-03 17:24:30 +08:00
|
|
|
l &= ~OMAP_TIMER_CTRL_AR;
|
2008-12-11 09:36:34 +08:00
|
|
|
}
|
2008-07-03 17:24:30 +08:00
|
|
|
l |= OMAP_TIMER_CTRL_ST;
|
|
|
|
|
2011-09-17 06:44:20 +08:00
|
|
|
__omap_dm_timer_load_start(timer, l, load, timer->posted);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
|
|
|
timer->context.tldr = load;
|
|
|
|
timer->context.tcrr = load;
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2008-07-03 17:24:30 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned int match)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
|
|
|
u32 l;
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
2005-09-08 00:20:26 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2006-06-27 07:16:23 +08:00
|
|
|
if (enable)
|
2006-06-27 07:16:12 +08:00
|
|
|
l |= OMAP_TIMER_CTRL_CE;
|
|
|
|
else
|
|
|
|
l &= ~OMAP_TIMER_CTRL_CE;
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_MATCH_REG, match);
|
2012-10-05 07:17:42 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
|
|
|
timer->context.tmar = match;
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_pwm(struct omap_dm_timer *timer, int def_on,
|
2006-06-27 07:16:12 +08:00
|
|
|
int toggle, int trigger)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
|
|
|
u32 l;
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
2005-09-08 00:20:26 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2006-06-27 07:16:12 +08:00
|
|
|
l &= ~(OMAP_TIMER_CTRL_GPOCFG | OMAP_TIMER_CTRL_SCPWM |
|
|
|
|
OMAP_TIMER_CTRL_PT | (0x03 << 10));
|
|
|
|
if (def_on)
|
|
|
|
l |= OMAP_TIMER_CTRL_SCPWM;
|
|
|
|
if (toggle)
|
|
|
|
l |= OMAP_TIMER_CTRL_PT;
|
|
|
|
l |= trigger << 10;
|
2005-09-08 00:20:26 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_prescaler(struct omap_dm_timer *timer, int prescaler)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
|
|
|
u32 l;
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
2005-09-08 00:20:26 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
|
2006-06-27 07:16:12 +08:00
|
|
|
l &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2));
|
|
|
|
if (prescaler >= 0x00 && prescaler <= 0x07) {
|
|
|
|
l |= OMAP_TIMER_CTRL_PRE;
|
|
|
|
l |= prescaler << 2;
|
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tclr = l;
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_set_int_enable(struct omap_dm_timer *timer,
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned int value)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-20 19:30:24 +08:00
|
|
|
omap_dm_timer_enable(timer);
|
2011-09-17 06:44:20 +08:00
|
|
|
__omap_dm_timer_int_enable(timer, value);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tier = value;
|
|
|
|
timer->context.twer = value;
|
|
|
|
omap_dm_timer_disable(timer);
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2012-07-14 03:03:18 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_set_int_disable - disable timer interrupts
|
|
|
|
* @timer: pointer to timer handle
|
|
|
|
* @mask: bit mask of interrupts to be disabled
|
|
|
|
*
|
|
|
|
* Disables the specified timer interrupts for a timer.
|
|
|
|
*/
|
|
|
|
int omap_dm_timer_set_int_disable(struct omap_dm_timer *timer, u32 mask)
|
|
|
|
{
|
|
|
|
u32 l = mask;
|
|
|
|
|
|
|
|
if (unlikely(!timer))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
omap_dm_timer_enable(timer);
|
|
|
|
|
|
|
|
if (timer->revision == 1)
|
2014-04-16 01:37:47 +08:00
|
|
|
l = readl_relaxed(timer->irq_ena) & ~mask;
|
2012-07-14 03:03:18 +08:00
|
|
|
|
2014-04-16 01:37:47 +08:00
|
|
|
writel_relaxed(l, timer->irq_dis);
|
2012-07-14 03:03:18 +08:00
|
|
|
l = omap_dm_timer_read_reg(timer, OMAP_TIMER_WAKEUP_EN_REG) & ~mask;
|
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_WAKEUP_EN_REG, l);
|
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tier &= ~mask;
|
|
|
|
timer->context.twer &= ~mask;
|
|
|
|
omap_dm_timer_disable(timer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned int omap_dm_timer_read_status(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2006-09-25 17:41:35 +08:00
|
|
|
unsigned int l;
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
|
|
|
|
pr_err("%s: timer not available or enabled.\n", __func__);
|
2011-09-20 19:30:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-16 01:37:47 +08:00
|
|
|
l = readl_relaxed(timer->irq_stat);
|
2006-09-25 17:41:35 +08:00
|
|
|
|
|
|
|
return l;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_write_status(struct omap_dm_timer *timer, unsigned int value)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-09-17 06:44:20 +08:00
|
|
|
__omap_dm_timer_write_status(timer, value);
|
2012-10-05 06:01:14 +08:00
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
unsigned int omap_dm_timer_read_counter(struct omap_dm_timer *timer)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
|
|
|
|
pr_err("%s: timer not iavailable or enabled.\n", __func__);
|
2011-09-20 19:30:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-17 06:44:20 +08:00
|
|
|
return __omap_dm_timer_read_counter(timer, timer->posted);
|
2005-09-08 00:20:26 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:26 +08:00
|
|
|
int omap_dm_timer_write_counter(struct omap_dm_timer *timer, unsigned int value)
|
2006-06-27 07:16:23 +08:00
|
|
|
{
|
2011-09-20 19:30:26 +08:00
|
|
|
if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
|
|
|
|
pr_err("%s: timer not available or enabled.\n", __func__);
|
|
|
|
return -EINVAL;
|
2011-09-20 19:30:24 +08:00
|
|
|
}
|
|
|
|
|
2006-09-25 17:41:35 +08:00
|
|
|
omap_dm_timer_write_reg(timer, OMAP_TIMER_COUNTER_REG, value);
|
2011-09-20 19:30:24 +08:00
|
|
|
|
|
|
|
/* Save the context */
|
|
|
|
timer->context.tcrr = value;
|
2011-09-20 19:30:26 +08:00
|
|
|
return 0;
|
2006-06-27 07:16:23 +08:00
|
|
|
}
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
int omap_dm_timers_active(void)
|
2005-09-08 00:20:26 +08:00
|
|
|
{
|
2011-09-20 19:30:20 +08:00
|
|
|
struct omap_dm_timer *timer;
|
2006-09-25 17:41:42 +08:00
|
|
|
|
2011-09-20 19:30:20 +08:00
|
|
|
list_for_each_entry(timer, &omap_timer_list, node) {
|
2011-09-20 19:30:21 +08:00
|
|
|
if (!timer->reserved)
|
2006-09-25 17:41:42 +08:00
|
|
|
continue;
|
|
|
|
|
2006-06-27 07:16:12 +08:00
|
|
|
if (omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG) &
|
2006-09-25 17:41:35 +08:00
|
|
|
OMAP_TIMER_CTRL_ST) {
|
2006-06-27 07:16:12 +08:00
|
|
|
return 1;
|
2006-09-25 17:41:35 +08:00
|
|
|
}
|
2006-06-27 07:16:12 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2005-09-08 00:20:26 +08:00
|
|
|
|
2013-03-20 01:38:19 +08:00
|
|
|
static const struct of_device_id omap_timer_match[];
|
|
|
|
|
2011-09-20 19:30:19 +08:00
|
|
|
/**
|
|
|
|
* omap_dm_timer_probe - probe function called for every registered device
|
|
|
|
* @pdev: pointer to current timer platform device
|
|
|
|
*
|
|
|
|
* Called by driver framework at the end of device registration for all
|
|
|
|
* timer devices.
|
|
|
|
*/
|
2012-12-22 06:02:24 +08:00
|
|
|
static int omap_dm_timer_probe(struct platform_device *pdev)
|
2011-09-20 19:30:19 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct omap_dm_timer *timer;
|
2012-04-20 20:39:20 +08:00
|
|
|
struct resource *mem, *irq;
|
|
|
|
struct device *dev = &pdev->dev;
|
2013-03-20 01:38:19 +08:00
|
|
|
const struct of_device_id *match;
|
|
|
|
const struct dmtimer_platform_data *pdata;
|
2015-03-17 09:14:02 +08:00
|
|
|
int ret;
|
2013-03-20 01:38:19 +08:00
|
|
|
|
|
|
|
match = of_match_device(of_match_ptr(omap_timer_match), dev);
|
|
|
|
pdata = match ? match->data : dev->platform_data;
|
2011-09-20 19:30:19 +08:00
|
|
|
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
if (!pdata && !dev->of_node) {
|
2012-04-20 20:39:20 +08:00
|
|
|
dev_err(dev, "%s: no platform data.\n", __func__);
|
2011-09-20 19:30:19 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
|
|
|
|
if (unlikely(!irq)) {
|
2012-04-20 20:39:20 +08:00
|
|
|
dev_err(dev, "%s: no IRQ resource.\n", __func__);
|
2011-09-20 19:30:19 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (unlikely(!mem)) {
|
2012-04-20 20:39:20 +08:00
|
|
|
dev_err(dev, "%s: no memory resource.\n", __func__);
|
2011-09-20 19:30:19 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2017-10-04 02:46:48 +08:00
|
|
|
timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
|
2017-10-03 19:10:26 +08:00
|
|
|
if (!timer)
|
2012-04-20 20:39:20 +08:00
|
|
|
return -ENOMEM;
|
2011-09-20 19:30:19 +08:00
|
|
|
|
2013-02-24 18:46:59 +08:00
|
|
|
timer->fclk = ERR_PTR(-ENODEV);
|
2013-01-21 18:08:55 +08:00
|
|
|
timer->io_base = devm_ioremap_resource(dev, mem);
|
|
|
|
if (IS_ERR(timer->io_base))
|
|
|
|
return PTR_ERR(timer->io_base);
|
2011-09-20 19:30:19 +08:00
|
|
|
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
if (dev->of_node) {
|
|
|
|
if (of_find_property(dev->of_node, "ti,timer-alwon", NULL))
|
|
|
|
timer->capability |= OMAP_TIMER_ALWON;
|
|
|
|
if (of_find_property(dev->of_node, "ti,timer-dsp", NULL))
|
|
|
|
timer->capability |= OMAP_TIMER_HAS_DSP_IRQ;
|
|
|
|
if (of_find_property(dev->of_node, "ti,timer-pwm", NULL))
|
|
|
|
timer->capability |= OMAP_TIMER_HAS_PWM;
|
|
|
|
if (of_find_property(dev->of_node, "ti,timer-secure", NULL))
|
|
|
|
timer->capability |= OMAP_TIMER_SECURE;
|
|
|
|
} else {
|
|
|
|
timer->id = pdev->id;
|
|
|
|
timer->capability = pdata->timer_capability;
|
|
|
|
timer->reserved = omap_dm_timer_reserved_systimer(timer->id);
|
2012-11-10 06:54:17 +08:00
|
|
|
timer->get_context_loss_count = pdata->get_context_loss_count;
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
}
|
|
|
|
|
2013-03-20 01:38:19 +08:00
|
|
|
if (pdata)
|
|
|
|
timer->errata = pdata->timer_errata;
|
|
|
|
|
2011-09-20 19:30:19 +08:00
|
|
|
timer->irq = irq->start;
|
|
|
|
timer->pdev = pdev;
|
|
|
|
|
2018-02-23 02:02:49 +08:00
|
|
|
pm_runtime_enable(dev);
|
|
|
|
pm_runtime_irq_safe(dev);
|
2011-09-20 19:30:21 +08:00
|
|
|
|
2011-09-22 07:38:51 +08:00
|
|
|
if (!timer->reserved) {
|
2015-03-17 09:14:02 +08:00
|
|
|
ret = pm_runtime_get_sync(dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "%s: pm_runtime_get_sync failed!\n",
|
|
|
|
__func__);
|
|
|
|
goto err_get_sync;
|
|
|
|
}
|
2011-09-22 07:38:51 +08:00
|
|
|
__omap_dm_timer_init_regs(timer);
|
2012-04-20 20:39:20 +08:00
|
|
|
pm_runtime_put(dev);
|
2011-09-22 07:38:51 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 19:30:19 +08:00
|
|
|
/* add the timer element to the list */
|
|
|
|
spin_lock_irqsave(&dm_timer_lock, flags);
|
|
|
|
list_add_tail(&timer->node, &omap_timer_list);
|
|
|
|
spin_unlock_irqrestore(&dm_timer_lock, flags);
|
|
|
|
|
2012-04-20 20:39:20 +08:00
|
|
|
dev_dbg(dev, "Device Probed.\n");
|
2011-09-20 19:30:19 +08:00
|
|
|
|
|
|
|
return 0;
|
2015-03-17 09:14:02 +08:00
|
|
|
|
|
|
|
err_get_sync:
|
|
|
|
pm_runtime_put_noidle(dev);
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
return ret;
|
2011-09-20 19:30:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* omap_dm_timer_remove - cleanup a registered timer device
|
|
|
|
* @pdev: pointer to current timer platform device
|
|
|
|
*
|
|
|
|
* Called by driver framework whenever a timer device is unregistered.
|
|
|
|
* In addition to freeing platform resources it also deletes the timer
|
|
|
|
* entry from the local list.
|
|
|
|
*/
|
2012-12-22 06:02:24 +08:00
|
|
|
static int omap_dm_timer_remove(struct platform_device *pdev)
|
2011-09-20 19:30:19 +08:00
|
|
|
{
|
|
|
|
struct omap_dm_timer *timer;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dm_timer_lock, flags);
|
|
|
|
list_for_each_entry(timer, &omap_timer_list, node)
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
if (!strcmp(dev_name(&timer->pdev->dev),
|
|
|
|
dev_name(&pdev->dev))) {
|
2011-09-20 19:30:19 +08:00
|
|
|
list_del(&timer->node);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&dm_timer_lock, flags);
|
|
|
|
|
2015-03-17 09:14:03 +08:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
|
2011-09-20 19:30:19 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-02-15 14:01:48 +08:00
|
|
|
const static struct omap_dm_timer_ops dmtimer_ops = {
|
|
|
|
.request_by_node = omap_dm_timer_request_by_node,
|
|
|
|
.request_specific = omap_dm_timer_request_specific,
|
|
|
|
.request = omap_dm_timer_request,
|
|
|
|
.set_source = omap_dm_timer_set_source,
|
|
|
|
.get_irq = omap_dm_timer_get_irq,
|
|
|
|
.set_int_enable = omap_dm_timer_set_int_enable,
|
|
|
|
.set_int_disable = omap_dm_timer_set_int_disable,
|
|
|
|
.free = omap_dm_timer_free,
|
|
|
|
.enable = omap_dm_timer_enable,
|
|
|
|
.disable = omap_dm_timer_disable,
|
|
|
|
.get_fclk = omap_dm_timer_get_fclk,
|
|
|
|
.start = omap_dm_timer_start,
|
|
|
|
.stop = omap_dm_timer_stop,
|
|
|
|
.set_load = omap_dm_timer_set_load,
|
|
|
|
.set_match = omap_dm_timer_set_match,
|
|
|
|
.set_pwm = omap_dm_timer_set_pwm,
|
|
|
|
.set_prescaler = omap_dm_timer_set_prescaler,
|
|
|
|
.read_counter = omap_dm_timer_read_counter,
|
|
|
|
.write_counter = omap_dm_timer_write_counter,
|
|
|
|
.read_status = omap_dm_timer_read_status,
|
|
|
|
.write_status = omap_dm_timer_write_status,
|
|
|
|
};
|
|
|
|
|
2013-03-20 01:38:19 +08:00
|
|
|
static const struct dmtimer_platform_data omap3plus_pdata = {
|
|
|
|
.timer_errata = OMAP_TIMER_ERRATA_I103_I767,
|
2018-02-15 14:01:48 +08:00
|
|
|
.timer_ops = &dmtimer_ops,
|
2013-03-20 01:38:19 +08:00
|
|
|
};
|
|
|
|
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
static const struct of_device_id omap_timer_match[] = {
|
2013-03-20 01:38:19 +08:00
|
|
|
{
|
|
|
|
.compatible = "ti,omap2420-timer",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap3430-timer",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap4430-timer",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap5430-timer",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,am335x-timer",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,am335x-timer-1ms",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
2015-10-22 17:18:53 +08:00
|
|
|
{
|
|
|
|
.compatible = "ti,dm816-timer",
|
|
|
|
.data = &omap3plus_pdata,
|
|
|
|
},
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, omap_timer_match);
|
|
|
|
|
2011-09-20 19:30:19 +08:00
|
|
|
static struct platform_driver omap_dm_timer_driver = {
|
|
|
|
.probe = omap_dm_timer_probe,
|
2012-12-22 06:02:24 +08:00
|
|
|
.remove = omap_dm_timer_remove,
|
2011-09-20 19:30:19 +08:00
|
|
|
.driver = {
|
|
|
|
.name = "omap_timer",
|
ARM: OMAP: Add DT support for timer driver
In order to add device-tree support to the timer driver the following changes
were made ...
1. Allocate system timers (used for clock-events and clock-source) based upon
timer properties rather than using an hard-coded timer instance ID. To allow
this a new helper function called omap_dmtimer_find_by_property() has been
added for finding a timer with the particular properties in the device-tree
blob. Please note that this is an internal helper function for system timers
only to find a timer in the device-tree blob. This cannot be used by device
drivers, another API has been added for that (see below). Timers that are
allocated for system timers are dynamically disabled at boot time by adding
a status property with the value "disabled" to the timer's device-tree node.
Please note that when allocating system timers we now pass a timer ID and
timer property. The timer ID is only be used for allocating a timer when
booting without device-tree. Once device-tree migration is complete, all
the timer ID references will be removed.
2. System timer resources (memory and interrupts) are directly obtained from
the device-tree timer node when booting with device-tree, so that system
timers are no longer reliant upon the OMAP HWMOD framework to provide these
resources.
3. If DT blob is present, then let device-tree create the timer devices
dynamically.
4. When device-tree is present the "id" field in the platform_device structure
(pdev->id) is initialised to -1 and hence cannot be used to identify a timer
instance. Due to this the following changes were made ...
a). The API omap_dm_timer_request_specific() is not supported when using
device-tree, because it uses the device ID to request a specific timer.
This function will return an error if called when device-tree is present.
Users of this API should use omap_dm_timer_request_by_cap() instead.
b). When removing the DMTIMER driver, the timer "id" was used to identify the
timer instance. The remove function has been modified to use the device
name instead of the "id".
5. When device-tree is present the platform_data structure will be NULL and so
check for this.
6. The OMAP timer device tree binding has the following optional parameters ...
a). ti,timer-alwon --> Timer is in an always-on power domain
b). ti,timer-dsp --> Timer can generate an interrupt to the on-chip DSP
c). ti,timer-pwm --> Timer can generate a PWM output
d). ti,timer-secure --> Timer is reserved on a secure OMAP device
Search for the above parameters and set the appropriate timer attribute
flags.
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
2012-05-14 23:41:37 +08:00
|
|
|
.of_match_table = of_match_ptr(omap_timer_match),
|
2011-09-20 19:30:19 +08:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
early_platform_init("earlytimer", &omap_dm_timer_driver);
|
2012-12-17 03:30:02 +08:00
|
|
|
module_platform_driver(omap_dm_timer_driver);
|
2011-09-20 19:30:19 +08:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("OMAP Dual-Mode Timer Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS("platform:" DRIVER_NAME);
|
|
|
|
MODULE_AUTHOR("Texas Instruments Inc");
|